[td-98] fix bugs in super table group by query

src/client/inc/tsclient.h

@@ -71,6 +71,7 @@ typedef struct STableMeta {
 typedef struct STableMetaInfo {
   STableMeta * pTableMeta;       // table meta, cached in client side and acquried by name
   SVgroupsInfo* vgroupList;
+  
   /*
    * 1. keep the vnode index during the multi-vnode super table projection query
    * 2. keep the vnode index for multi-vnode insertion

src/client/src/tscServer.c

@@ -651,19 +651,22 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
     pQueryMsg->head.vgId = htonl(pTableMeta->vgroupInfo.vgId);
     tscTrace("%p queried tables:%d, table id: %s", pSql, 1, pTableMetaInfo->name);
   } else {  // query super table
+    int32_t index = pTableMetaInfo->vgroupIndex;
     
-    if (pTableMetaInfo->vgroupIndex < 0) {
-      tscError("%p error vnodeIdx:%d", pSql, pTableMetaInfo->vgroupIndex);
+    if (index < 0) {
+      tscError("%p error vgroupIndex:%d", pSql, index);
       return -1;
     }
     
-    pSql->ipList.numOfIps = 1; // todo fix me
+    SCMVgroupInfo* pVgroupInfo = &pTableMetaInfo->vgroupList->vgroups[index];
+    
+    pSql->ipList.numOfIps = pVgroupInfo->numOfIps; // todo fix me
     pSql->ipList.port     = tsDnodeShellPort;
     pSql->ipList.inUse    = 0;
   
-    // todo extract method
-    SCMVgroupInfo* pVgroupInfo = &pTableMetaInfo->vgroupList->vgroups[pTableMetaInfo->vgroupIndex];
-    pSql->ipList.ip[0] = pVgroupInfo->ipAddr[0].ip;
+    for(int32_t i = 0; i < pVgroupInfo->numOfIps; ++i) {
+      pSql->ipList.ip[i] = pVgroupInfo->ipAddr[i].ip;
+    }
     
 #if 0
     SVnodeSidList *pVnodeSidList = tscGetVnodeSidList(pMetricMeta, pTableMetaInfo->vgroupIndex);
@@ -676,8 +679,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
     }
 #endif
     
-    tscTrace("%p query on super table, numOfVgroup:%d, vgroupIndex:%d", pSql, pTableMetaInfo->vgroupList->numOfVgroups,
-        pTableMetaInfo->vgroupIndex);
+    tscTrace("%p query on super table, numOfVgroup:%d, vgroupIndex:%d", pSql, pTableMetaInfo->vgroupList->numOfVgroups, index);
     
     pQueryMsg->head.vgId = htonl(pVgroupInfo->vgId);
     numOfTables = 1;
@@ -2133,10 +2135,11 @@ _error_clean:
   
   for(int32_t i = 0; i < pInfo->vgroupList->numOfVgroups; ++i) {
     SCMVgroupInfo* pVgroups = &pInfo->vgroupList->vgroups[i];
-    pVgroups->numOfIps = htonl(pVgroups->numOfIps);
+    
     pVgroups->vgId = htonl(pVgroups->vgId);
+    assert(pVgroups->numOfIps >= 1);
     
-    for(int32_t j = 0; j < tListLen(pVgroups->ipAddr); ++j) {
+    for(int32_t j = 0; j < pVgroups->numOfIps; ++j) {
       pVgroups->ipAddr[j].ip = htonl(pVgroups->ipAddr[j].ip);
       pVgroups->ipAddr[j].port = htons(pVgroups->ipAddr[j].port);
     }

src/client/src/tscUtil.c

@@ -2128,27 +2128,23 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, void (*fp)(), void
 
   if (pPrevSql == NULL) {
     STableMeta* pTableMeta = taosCacheAcquireByName(tscCacheHandle, name);
-    
-//    SSuperTableMeta* pMetricMeta = NULL;
-//    if (cmd == TSDB_SQL_SELECT) {
-//      pMetricMeta = taosCacheAcquireByName(tscCacheHandle, key);
-//    }
 
     pFinalInfo = tscAddTableMetaInfo(pNewQueryInfo, name, pTableMeta, pTableMetaInfo->vgroupList, pTableMetaInfo->numOfTags,
                                      pTableMetaInfo->tagColumnIndex);
-  } else {  // transfer the ownership of pTableMeta/pMetricMeta to the newly create sql object.
-//    STableMetaInfo* pPrevInfo = tscGetTableMetaInfoFromCmd(&pPrevSql->cmd, pPrevSql->cmd.clauseIndex, 0);
-
-//    STableMeta*  pPrevMeterMeta = taosCacheTransfer(tscCacheHandle, (void**)&pPrevInfo->pTableMeta);
-//    SSuperTableMeta* pPrevMetricMeta = taosCacheTransfer(tscCacheHandle, (void**)&pPrevInfo->pMetricMeta);
+  } else {  // transfer the ownership of pTableMeta to the newly create sql object.
+    STableMetaInfo* pPrevInfo = tscGetTableMetaInfoFromCmd(&pPrevSql->cmd, pPrevSql->cmd.clauseIndex, 0);
 
-//    pFinalInfo = tscAddTableMetaInfo(pNewQueryInfo, name, pPrevMeterMeta, pPrevMetricMeta, pTableMetaInfo->numOfTags,
-//                                     pTableMetaInfo->tagColumnIndex);
+    STableMeta*  pPrevTableMeta = taosCacheTransfer(tscCacheHandle, (void**)&pPrevInfo->pTableMeta);
+    SVgroupsInfo* pVgroupsInfo = pPrevInfo->vgroupList;
+    pPrevInfo->vgroupList = NULL;
+    
+    pFinalInfo = tscAddTableMetaInfo(pNewQueryInfo, name, pPrevTableMeta, pVgroupsInfo, pTableMetaInfo->numOfTags,
+                                     pTableMetaInfo->tagColumnIndex);
   }
 
   assert(pFinalInfo->pTableMeta != NULL && pNewQueryInfo->numOfTables == 1);
   if (UTIL_TABLE_IS_SUPERTABLE(pTableMetaInfo)) {
-//    assert(pFinalInfo->pMetricMeta != NULL);
+    assert(pFinalInfo->vgroupList != NULL);
   }
   
   if (cmd == TSDB_SQL_SELECT) {

src/query/inc/queryExecutor.h

@@ -18,6 +18,7 @@
 #include "os.h"
 
 #include "hash.h"
+#include "tsdb.h"
 #include "qinterpolation.h"
 #include "qresultBuf.h"
 #include "qsqlparser.h"
@@ -89,7 +90,7 @@ typedef struct SColumnFilterElem {
 } SColumnFilterElem;
 
 typedef struct SSingleColumnFilterInfo {
-  SColumnInfoData      info;
+  SColumnInfoData    info;
   int32_t            numOfFilters;
   SColumnFilterElem* pFilters;
   void*              pData;
@@ -108,8 +109,8 @@ typedef struct STableQueryInfo {
 } STableQueryInfo;
 
 typedef struct STableDataInfo {
-  int32_t          numOfBlocks;
-  int32_t          start;     // start block index
+//  int32_t          numOfBlocks;
+//  int32_t          start;     // start block index
   int32_t          tableIndex;
   int32_t          groupIdx;  // group id in table list
   STableQueryInfo* pTableQInfo;
@@ -171,7 +172,7 @@ typedef struct SQInfo {
   int32_t          pointsInterpo;
   int32_t          code;          // error code to returned to client
   sem_t            dataReady;
-  SArray*          pTableList;    // table id list
+  STableGroupInfo  groupInfo;     // table id list
   void*            tsdb;
   
   SQueryRuntimeEnv runtimeEnv;
@@ -187,7 +188,7 @@ typedef struct SQInfo {
    */
   int32_t         tableIndex;
   int32_t         numOfGroupResultPages;
-  STableDataInfo* pTableDataInfo;
+//  STableDataInfo* pTableDataInfo;
   TSKEY*          tsList;
 } SQInfo;
 

src/tsdb/inc/tsdb.h

@@ -95,6 +95,8 @@ int  tsdbTableSetTagSchema(STableCfg *config, STSchema *pSchema, bool dup);
 int  tsdbTableSetTagValue(STableCfg *config, SDataRow row, bool dup);
 void tsdbClearTableCfg(STableCfg *config);
 
+int32_t tsdbGetTableTagVal(tsdb_repo_t *repo, STableId id, int32_t col, int16_t* type, int16_t* bytes, char** val);
+
 int tsdbCreateTable(tsdb_repo_t *repo, STableCfg *pCfg);
 int tsdbDropTable(tsdb_repo_t *pRepo, STableId tableId);
 int tsdbAlterTable(tsdb_repo_t *repo, STableCfg *pCfg);
@@ -181,11 +183,6 @@ int32_t tsdbInsertData(tsdb_repo_t *pRepo, SSubmitMsg *pMsg);
 
 typedef void* tsdb_query_handle_t;  // Use void to hide implementation details
 
-typedef struct STableGroupList {    // qualified table object list in group
-  SArray*  pGroupList;
-  int32_t  numOfTables;
-} STableGroupList;
-
 // query condition to build vnode iterator
 typedef struct STsdbQueryCond {
   STimeWindow       twindow;
@@ -216,11 +213,16 @@ typedef struct SDataBlockInfo {
   int32_t     sid;
 } SDataBlockInfo;
 
+typedef struct {
+  size_t  numOfTables;
+  SArray* pGroupList;
+} STableGroupInfo;
+
 typedef struct {
 } SFields;
 
 #define TSDB_TS_GREATER_EQUAL 1
-#define TSDB_TS_LESS_EQUAL 2
+#define TSDB_TS_LESS_EQUAL    2
 
 typedef struct SQueryRowCond {
   int32_t rel;
@@ -235,7 +237,7 @@ typedef void *tsdbpos_t;
  * @param pTableList    table sid list
  * @return
  */
-tsdb_query_handle_t *tsdbQueryTables(tsdb_repo_t* tsdb, STsdbQueryCond *pCond, SArray *idList, SArray *pColumnInfo);
+tsdb_query_handle_t *tsdbQueryTables(tsdb_repo_t* tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupInfo, SArray *pColumnInfo);
 
 /**
  * move to next block
@@ -337,10 +339,10 @@ SArray *tsdbGetTableList(tsdb_query_handle_t *pQueryHandle);
  * @param pTagCond. tag query condition
  *
  */
-int32_t tsdbQueryTags(tsdb_repo_t* tsdb, int64_t uid, const char* pTagCond, size_t len, SArray** pGroupList,
+int32_t tsdbQueryTags(tsdb_repo_t* tsdb, int64_t uid, const char* pTagCond, size_t len, STableGroupInfo* pGroupList,
                       SColIndex* pColIndex, int32_t numOfCols);
 
-int32_t tsdbGetOneTableGroup(tsdb_repo_t* tsdb, int64_t uid, SArray** pGroupList);
+int32_t tsdbGetOneTableGroup(tsdb_repo_t* tsdb, int64_t uid, STableGroupInfo* pGroupInfo);
 
 /**
  * clean up the query handle

src/tsdb/src/tsdbMeta.c

@@ -214,6 +214,23 @@ STSchema * tsdbGetTableTagSchema(STsdbMeta *pMeta, STable *pTable) {
   }
 }
 
+int32_t tsdbGetTableTagVal(tsdb_repo_t* repo, STableId id, int32_t col, int16_t* type, int16_t* bytes, char** val) {
+  STsdbMeta* pMeta = tsdbGetMeta(repo);
+  STable* pTable = tsdbGetTableByUid(pMeta, id.uid);
+  
+  STSchema* pSchema = tsdbGetTableTagSchema(pMeta, pTable);
+  STColumn* pCol = schemaColAt(pSchema, col);
+  
+  SDataRow row = (SDataRow)pTable->tagVal;
+  char* d = dataRowAt(row, TD_DATA_ROW_HEAD_SIZE);
+  
+  *val = d;
+  *type = pCol->type;
+  *bytes = pCol->bytes;
+  
+  return 0;
+}
+
 int32_t tsdbCreateTableImpl(STsdbMeta *pMeta, STableCfg *pCfg) {
   if (tsdbCheckTableCfg(pCfg) < 0) return -1;
 

src/tsdb/src/tsdbRead.c

@@ -143,7 +143,7 @@ static void tsdbInitCompBlockLoadInfo(SLoadCompBlockInfo* pCompBlockLoadInfo) {
   pCompBlockLoadInfo->fileListIndex = -1;
 }
 
-tsdb_query_handle_t* tsdbQueryTables(tsdb_repo_t* tsdb, STsdbQueryCond* pCond, SArray* groupList, SArray* pColumnInfo) {
+tsdb_query_handle_t* tsdbQueryTables(tsdb_repo_t* tsdb, STsdbQueryCond* pCond, STableGroupInfo* groupList, SArray* pColumnInfo) {
   // todo 1. filter not exist table
   // todo 2. add the reference count for each table that is involved in query
 
@@ -157,22 +157,25 @@ tsdb_query_handle_t* tsdbQueryTables(tsdb_repo_t* tsdb, STsdbQueryCond* pCond, S
   pQueryHandle->isFirstSlot = true;
   pQueryHandle->cur.fid = -1;
 
-  size_t size = taosArrayGetSize(groupList);
-  assert(size >= 1);
+  size_t sizeOfGroup = taosArrayGetSize(groupList->pGroupList);
+  assert(sizeOfGroup >= 1);
 
-  pQueryHandle->pTableCheckInfo = taosArrayInit(size, sizeof(STableCheckInfo));
-  for (int32_t i = 0; i < size; ++i) {
-    SArray* group = *(SArray**)taosArrayGet(groupList, i);
+  pQueryHandle->pTableCheckInfo = taosArrayInit(groupList->numOfTables, sizeof(STableCheckInfo));
+  
+  for (int32_t i = 0; i < sizeOfGroup; ++i) {
+    SArray* group = *(SArray**) taosArrayGet(groupList->pGroupList, i);
 
     size_t gsize = taosArrayGetSize(group);
+    assert(gsize > 0);
+    
     for (int32_t j = 0; j < gsize; ++j) {
-      STable* pTable = *(STable**)taosArrayGet(group, j);
-      assert(pTable != NULL);
+      SPair* d = (SPair*) taosArrayGet(group, j);
+      assert(d->first !=  NULL);
       
       STableCheckInfo info = {
           .lastKey = pQueryHandle->window.skey,
-          .tableId = pTable->tableId,
-          .pTableObj = pTable,
+          .tableId = ((STable*) d->first)->tableId,
+          .pTableObj = d->first,
       };
 
       taosArrayPush(pQueryHandle->pTableCheckInfo, &info);
@@ -1143,7 +1146,7 @@ static int32_t getAllTableIdList(STsdbRepo* tsdb, int64_t uid, SArray* list) {
     SSkipListNode* pNode = tSkipListIterGet(iter);
     
     STable* t = *(STable**)SL_GET_NODE_DATA(pNode);
-    taosArrayPush(list, t);
+    taosArrayPush(list, &t);
   }
   
   return TSDB_CODE_SUCCESS;
@@ -1306,26 +1309,31 @@ int32_t tableGroupComparFn(const void *p1, const void *p2, const void *param) {
 }
 
 void createTableGroupImpl(SArray* pGroups, STable** pTables, size_t numOfTables, STableGroupSupporter* pSupp, __ext_compar_fn_t compareFn) {
-  SArray* g = taosArrayInit(16, POINTER_BYTES);
-  taosArrayPush(g, &pTables[0]);
+  SArray* g = taosArrayInit(16, sizeof(SPair));
+  
+  SPair p = {.first = pTables[0]};
+  taosArrayPush(g, &p);
   
   for (int32_t i = 1; i < numOfTables; ++i) {
     int32_t ret = compareFn(&pTables[i - 1], &pTables[i], pSupp);
     assert(ret == 0 || ret == -1);
     
     if (ret == 0) {
-      taosArrayPush(g, &pTables[i]);
+      SPair p1 = {.first = pTables[i]};
+      taosArrayPush(g, &p1);
     } else {
       taosArrayPush(pGroups, &g);  // current group is ended, start a new group
-      
       g = taosArrayInit(16, POINTER_BYTES);
-      taosArrayPush(g, &pTables[i]);
+  
+      SPair p1 = {.first = pTables[i]};
+      taosArrayPush(g, &p1);
     }
   }
 }
 
 SArray* createTableGroup(SArray* pTableList, STSchema* pTagSchema, SColIndex* pCols, int32_t numOfOrderCols) {
-  assert(pTableList != NULL && taosArrayGetSize(pTableList) > 0);
+  assert(pTableList != NULL);
+  
   SArray* pTableGroup = taosArrayInit(1, POINTER_BYTES);
   
   size_t size = taosArrayGetSize(pTableList);
@@ -1335,7 +1343,17 @@ SArray* createTableGroup(SArray* pTableList, STSchema* pTagSchema, SColIndex* pC
   }
   
   if (numOfOrderCols == 0 || size == 1) { // no group by tags clause or only one table
-    taosArrayPush(pTableGroup, pTableList);
+    size_t num = taosArrayGetSize(pTableList);
+    
+    SArray* sa = taosArrayInit(num, sizeof(SPair));
+    for(int32_t i = 0; i < num; ++i) {
+      STable* pTable = taosArrayGetP(pTableList, i);
+      
+      SPair p = {.first = pTable};
+      taosArrayPush(sa, &p);
+    }
+    
+    taosArrayPush(pTableGroup, &sa);
     pTrace("all %d tables belong to one group", size);
     
 #ifdef _DEBUG_VIEW
@@ -1430,7 +1448,7 @@ static int32_t doQueryTableList(STable* pSTable, SArray* pRes, tExprNode* pExpr)
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t tsdbQueryTags(tsdb_repo_t* tsdb, int64_t uid, const char* pTagCond, size_t len, SArray** pGroupList,
+int32_t tsdbQueryTags(tsdb_repo_t* tsdb, int64_t uid, const char* pTagCond, size_t len, STableGroupInfo* pGroupInfo,
     SColIndex* pColIndex, int32_t numOfCols) {
   
   STable* pSTable = tsdbGetTableByUid(tsdbGetMeta(tsdb), uid);
@@ -1448,9 +1466,9 @@ int32_t tsdbQueryTags(tsdb_repo_t* tsdb, int64_t uid, const char* pTagCond, size
       taosArrayDestroy(res);
       return ret;
     }
-    
-    *pGroupList = createTableGroup(res, pTagSchema, pColIndex, numOfCols);
-    taosArrayDestroy(res);
+  
+    pGroupInfo->numOfTables = taosArrayGetSize(res);
+    pGroupInfo->pGroupList  = createTableGroup(res, pTagSchema, pColIndex, numOfCols);
     return ret;
   }
 
@@ -1465,25 +1483,27 @@ int32_t tsdbQueryTags(tsdb_repo_t* tsdb, int64_t uid, const char* pTagCond, size
   }
 
   doQueryTableList(pSTable, res, pExprNode);
-  *pGroupList = createTableGroup(res, pTagSchema, pColIndex, numOfCols);
+  
+  pGroupInfo->numOfTables = taosArrayGetSize(res);
+  pGroupInfo->pGroupList  = createTableGroup(res, pTagSchema, pColIndex, numOfCols);
 
-  taosArrayDestroy(res);
   return ret;
 }
 
-int32_t tsdbGetOneTableGroup(tsdb_repo_t* tsdb, int64_t uid, SArray** pGroupList) {
+int32_t tsdbGetOneTableGroup(tsdb_repo_t* tsdb, int64_t uid, STableGroupInfo* pGroupInfo) {
   STable* pTable = tsdbGetTableByUid(tsdbGetMeta(tsdb), uid);
   if (pTable == NULL) {
     return TSDB_CODE_INVALID_TABLE_ID;
   }
   
   //todo assert table type, add the table ref count
+  pGroupInfo->numOfTables = 1;
+  pGroupInfo->pGroupList = taosArrayInit(1, POINTER_BYTES);
   
-  *pGroupList = taosArrayInit(1, POINTER_BYTES);
   SArray* group = taosArrayInit(1, POINTER_BYTES);
   
   taosArrayPush(group, &pTable);
-  taosArrayPush(*pGroupList, &group);
+  taosArrayPush(pGroupInfo->pGroupList, &group);
   
   return TSDB_CODE_SUCCESS;
 }

src/util/inc/tutil.h

@@ -107,6 +107,11 @@ extern "C" {
 
 #define POW2(x) ((x) * (x))
 
+typedef struct SPair {
+  void* first;
+  void* sec;
+} SPair;
+
 int32_t strdequote(char *src);
 
 void strtrim(char *src);