Merge branch '2.0' into refact/slguan

src/client/inc/tscUtil.h

@@ -85,7 +85,7 @@ int32_t tscGetDataBlockFromList(void* pHashList, SDataBlockList* pDataBlockList,
                                 STableDataBlocks** dataBlocks);
 
 SVnodeSidList*    tscGetVnodeSidList(SSuperTableMeta* pMetricmeta, int32_t vnodeIdx);
-STableSidExtInfo* tscGetMeterSidInfo(SVnodeSidList* pSidList, int32_t idx);
+STableIdInfo* tscGetMeterSidInfo(SVnodeSidList* pSidList, int32_t idx);
 
 /**
  *

src/client/inc/tsclient.h

@@ -62,7 +62,7 @@ typedef struct STableMeta {
   int8_t     numOfVpeers;
   int16_t    sversion;
   SVnodeDesc vpeerDesc[TSDB_VNODES_SUPPORT];
-  int32_t    vgid;     // virtual group id, which current table belongs to
+  int32_t    vgId;     // virtual group id, which current table belongs to
   int32_t    sid;      // the index of one table in a virtual node
   uint64_t   uid;      // unique id of a table
   SSchema    schema[]; // if the table is TSDB_CHILD_TABLE, schema is acquired by super table meta info
@@ -182,7 +182,7 @@ typedef struct STableDataBlocks {
   char    tableId[TSDB_TABLE_ID_LEN];
   int8_t  tsSource;     // where does the UNIX timestamp come from, server or client
   bool    ordered;      // if current rows are ordered or not
-  int64_t vgid;         // virtual group id
+  int64_t vgId;         // virtual group id
   int64_t prevTS;       // previous timestamp, recorded to decide if the records array is ts ascending
   int32_t numOfTables;  // number of tables in current submit block
 

src/client/src/tscLocal.c

@@ -318,15 +318,16 @@ static int tscBuildMetricTagProjectionResult(SSqlObj *pSql) {
     SVnodeSidList *pSidList = (SVnodeSidList *)((char *)pMetricMeta + pMetricMeta->list[i]);
 
     for (int32_t j = 0; j < pSidList->numOfSids; ++j) {
-      STableSidExtInfo *pSidExt = tscGetMeterSidInfo(pSidList, j);
+      STableIdInfo *pSidExt = tscGetMeterSidInfo(pSidList, j);
       
       for (int32_t k = 0; k < pQueryInfo->fieldsInfo.numOfOutputCols; ++k) {
         SColIndexEx *pColIndex = &tscSqlExprGet(pQueryInfo, k)->colInfo;
         int16_t      offsetId = pColIndex->colIdx;
 
         assert((pColIndex->flag & TSDB_COL_TAG) != 0);
+        assert(0);
         
-        char *      val = pSidExt->tags + vOffset[offsetId];
+        char *      val = NULL;//pSidExt->tags + vOffset[offsetId];
         TAOS_FIELD *pField = tscFieldInfoGetField(pQueryInfo, k);
 
         memcpy(pRes->data + tscFieldInfoGetOffset(pQueryInfo, k) * totalNumOfResults + pField->bytes * rowIdx, val,

src/client/src/tscParseInsert.c

@@ -18,9 +18,10 @@
 
 #define _XOPEN_SOURCE
 
-#include "hash.h"
 #include "os.h"
-#include "tscSecondaryMerge.h"
+
+#include "hash.h"
+//#include "tscSecondaryMerge.h"
 #include "tscUtil.h"
 #include "tschemautil.h"
 #include "tsclient.h"
@@ -32,6 +33,8 @@
 #include "tstoken.h"
 #include "ttime.h"
 
+#include "dataformat.h"
+
 enum {
   TSDB_USE_SERVER_TS = 0,
   TSDB_USE_CLI_TS = 1,
@@ -393,7 +396,6 @@ static int32_t tsCheckTimestamp(STableDataBlocks *pDataBlocks, const char *start
 int tsParseOneRowData(char **str, STableDataBlocks *pDataBlocks, SSchema schema[], SParsedDataColInfo *spd, char *error,
                       int16_t timePrec, int32_t *code, char *tmpTokenBuf) {
   int32_t index = 0;
-  // bool      isPrevOptr; //fang, never used
   SSQLToken sToken = {0};
   char *    payload = pDataBlocks->pData + pDataBlocks->size;
 
@@ -604,8 +606,8 @@ int32_t tscAllocateMemIfNeed(STableDataBlocks *pDataBlock, int32_t rowSize, int3
   return TSDB_CODE_SUCCESS;
 }
 
-static void tsSetBlockInfo(SShellSubmitBlock *pBlocks, const STableMeta *pTableMeta, int32_t numOfRows) {
-  pBlocks->sid = pTableMeta->sid;
+static void tsSetBlockInfo(SSubmitBlk *pBlocks, const STableMeta *pTableMeta, int32_t numOfRows) {
+  pBlocks->tid = pTableMeta->sid;
   pBlocks->uid = pTableMeta->uid;
   pBlocks->sversion = pTableMeta->sversion;
   pBlocks->numOfRows += numOfRows;
@@ -613,10 +615,10 @@ static void tsSetBlockInfo(SShellSubmitBlock *pBlocks, const STableMeta *pTableM
 
 // data block is disordered, sort it in ascending order
 void sortRemoveDuplicates(STableDataBlocks *dataBuf) {
-  SShellSubmitBlock *pBlocks = (SShellSubmitBlock *)dataBuf->pData;
+  SSubmitBlk *pBlocks = (SSubmitBlk *)dataBuf->pData;
 
   // size is less than the total size, since duplicated rows may be removed yet.
-  assert(pBlocks->numOfRows * dataBuf->rowSize + sizeof(SShellSubmitBlock) == dataBuf->size);
+  assert(pBlocks->numOfRows * dataBuf->rowSize + sizeof(SSubmitBlk) == dataBuf->size);
 
   // if use server time, this block must be ordered
   if (dataBuf->tsSource == TSDB_USE_SERVER_TS) {
@@ -624,7 +626,7 @@ void sortRemoveDuplicates(STableDataBlocks *dataBuf) {
   }
 
   if (!dataBuf->ordered) {
-    char *pBlockData = pBlocks->payLoad;
+    char *pBlockData = pBlocks->data;
     qsort(pBlockData, pBlocks->numOfRows, dataBuf->rowSize, rowDataCompar);
 
     int32_t i = 0;
@@ -650,7 +652,7 @@ void sortRemoveDuplicates(STableDataBlocks *dataBuf) {
     dataBuf->ordered = true;
 
     pBlocks->numOfRows = i + 1;
-    dataBuf->size = sizeof(SShellSubmitBlock) + dataBuf->rowSize * pBlocks->numOfRows;
+    dataBuf->size = sizeof(SSubmitBlk) + dataBuf->rowSize * pBlocks->numOfRows;
   }
 }
 
@@ -663,7 +665,7 @@ static int32_t doParseInsertStatement(SSqlObj *pSql, void *pTableHashList, char
   
   STableDataBlocks *dataBuf = NULL;
   int32_t ret = tscGetDataBlockFromList(pTableHashList, pCmd->pDataBlocks, pTableMeta->uid, TSDB_DEFAULT_PAYLOAD_SIZE,
-                                        sizeof(SShellSubmitBlock), tinfo.rowSize, pTableMetaInfo->name,
+                                        sizeof(SSubmitBlk), tinfo.rowSize, pTableMetaInfo->name,
                                         pTableMeta, &dataBuf);
   if (ret != TSDB_CODE_SUCCESS) {
     return ret;
@@ -691,14 +693,14 @@ static int32_t doParseInsertStatement(SSqlObj *pSql, void *pTableHashList, char
     SParamInfo *param = dataBuf->params + i;
     if (param->idx == -1) {
       param->idx = pCmd->numOfParams++;
-      param->offset -= sizeof(SShellSubmitBlock);
+      param->offset -= sizeof(SSubmitBlk);
     }
   }
 
-  SShellSubmitBlock *pBlocks = (SShellSubmitBlock *)(dataBuf->pData);
+  SSubmitBlk *pBlocks = (SSubmitBlk *)(dataBuf->pData);
   tsSetBlockInfo(pBlocks, pTableMeta, numOfRows);
 
-  dataBuf->vgid = pTableMeta->vgid;
+  dataBuf->vgId = pTableMeta->vgId;
   dataBuf->numOfTables = 1;
 
   /*
@@ -1058,7 +1060,6 @@ int doParseInsertSql(SSqlObj *pSql, char *str) {
       goto _error_clean;
     }
 
-    void *fp = pSql->fp;
     ptrdiff_t pos = pSql->asyncTblPos - pSql->sqlstr;
     
     if ((code = tscCheckIfCreateTable(&str, pSql)) != TSDB_CODE_SUCCESS) {
@@ -1068,7 +1069,6 @@ int doParseInsertSql(SSqlObj *pSql, char *str) {
        * And during the getMeterMetaCallback function, the sql string will be parsed from the
        * interrupted position.
        */
-      if (fp != NULL) {
       if (TSDB_CODE_ACTION_IN_PROGRESS == code) {
         tscTrace("async insert and waiting to get meter meta, then continue parse sql from offset: %" PRId64, pos);
         return code;
@@ -1077,7 +1077,6 @@ int doParseInsertSql(SSqlObj *pSql, char *str) {
       // todo add to return
       tscError("async insert parse error, code:%d, %s", code, tstrerror(code));
       pSql->asyncTblPos = NULL;
-      }
       
       goto _error_clean;       // TODO: should _clean or _error_clean to async flow ????
     }
@@ -1096,15 +1095,13 @@ int doParseInsertSql(SSqlObj *pSql, char *str) {
       goto _error_clean;
     }
     
-    int32_t numOfCols = tscGetNumOfTags(pTableMetaInfo->pTableMeta);
     STableComInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
     
     if (sToken.type == TK_VALUES) {
-      SParsedDataColInfo spd = {.numOfCols = numOfCols};
+      SParsedDataColInfo spd = {.numOfCols = tinfo.numOfColumns};
       
       SSchema *pSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
-
-      tscSetAssignedColumnInfo(&spd, pSchema, numOfCols);
+      tscSetAssignedColumnInfo(&spd, pSchema, tinfo.numOfColumns);
 
       if (validateDataSource(pCmd, DATA_FROM_SQL_STRING, sToken.z) != TSDB_CODE_SUCCESS) {
         goto _error_clean;
@@ -1146,7 +1143,7 @@ int doParseInsertSql(SSqlObj *pSql, char *str) {
       STableDataBlocks *pDataBlock = NULL;
       STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
       
-      int32_t ret = tscCreateDataBlock(PATH_MAX, tinfo.rowSize, sizeof(SShellSubmitBlock), pTableMetaInfo->name,
+      int32_t ret = tscCreateDataBlock(PATH_MAX, tinfo.rowSize, sizeof(SSubmitBlk), pTableMetaInfo->name,
                                        pTableMeta, &pDataBlock);
       if (ret != TSDB_CODE_SUCCESS) {
         goto _error_clean;
@@ -1243,7 +1240,7 @@ int doParseInsertSql(SSqlObj *pSql, char *str) {
 
   // submit to more than one vnode
   if (pCmd->pDataBlocks->nSize > 0) {
-    // merge according to vgid
+    // merge according to vgId
     if ((code = tscMergeTableDataBlocks(pSql, pCmd->pDataBlocks)) != TSDB_CODE_SUCCESS) {
       goto _error_clean;
     }
@@ -1358,7 +1355,7 @@ static int doPackSendDataBlock(SSqlObj *pSql, int32_t numOfRows, STableDataBlock
   assert(pCmd->numOfClause == 1);
   STableMeta *pTableMeta = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0)->pTableMeta;
 
-  SShellSubmitBlock *pBlocks = (SShellSubmitBlock *)(pTableDataBlocks->pData);
+  SSubmitBlk *pBlocks = (SSubmitBlk *)(pTableDataBlocks->pData);
   tsSetBlockInfo(pBlocks, pTableMeta, numOfRows);
 
   if ((code = tscMergeTableDataBlocks(pSql, pCmd->pDataBlocks)) != TSDB_CODE_SUCCESS) {
@@ -1399,7 +1396,7 @@ static int tscInsertDataFromFile(SSqlObj *pSql, FILE *fp, char *tmpTokenBuf) {
 
   pCmd->pDataBlocks = tscCreateBlockArrayList();
   STableDataBlocks *pTableDataBlock = NULL;
-  int32_t           ret = tscCreateDataBlock(TSDB_PAYLOAD_SIZE, rowSize, sizeof(SShellSubmitBlock),
+  int32_t           ret = tscCreateDataBlock(TSDB_PAYLOAD_SIZE, rowSize, sizeof(SSubmitBlk),
                                    pTableMetaInfo->name, pTableMeta, &pTableDataBlock);
   if (ret != TSDB_CODE_SUCCESS) {
     return -1;
@@ -1440,7 +1437,7 @@ static int tscInsertDataFromFile(SSqlObj *pSql, FILE *fp, char *tmpTokenBuf) {
       }
 
       pTableDataBlock = pCmd->pDataBlocks->pData[0];
-      pTableDataBlock->size = sizeof(SShellSubmitBlock);
+      pTableDataBlock->size = sizeof(SSubmitBlk);
       pTableDataBlock->rowSize = tinfo.rowSize;
 
       numOfRows += pSql->res.numOfRows;

src/client/src/tscPrepare.c

@@ -325,12 +325,12 @@ static int insertStmtBindParam(STscStmt* stmt, TAOS_BIND* bind) {
 
   for (int32_t i = 0; i < pCmd->pDataBlocks->nSize; ++i) {
     STableDataBlocks* pBlock = pCmd->pDataBlocks->pData[i];
-    uint32_t          totalDataSize = pBlock->size - sizeof(SShellSubmitBlock);
+    uint32_t          totalDataSize = pBlock->size - sizeof(SSubmitBlk);
     uint32_t          dataSize = totalDataSize / alloced;
     assert(dataSize * alloced == totalDataSize);
 
     if (alloced == binded) {
-      totalDataSize += dataSize + sizeof(SShellSubmitBlock);
+      totalDataSize += dataSize + sizeof(SSubmitBlk);
       if (totalDataSize > pBlock->nAllocSize) {
         const double factor = 1.5;
         void* tmp = realloc(pBlock->pData, (uint32_t)(totalDataSize * factor));
@@ -342,7 +342,7 @@ static int insertStmtBindParam(STscStmt* stmt, TAOS_BIND* bind) {
       }
     }
 
-    char* data = pBlock->pData + sizeof(SShellSubmitBlock) + dataSize * binded;
+    char* data = pBlock->pData + sizeof(SSubmitBlk) + dataSize * binded;
     for (uint32_t j = 0; j < pBlock->numOfParams; ++j) {
       SParamInfo* param = pBlock->params + j;
       int code = doBindParam(data, param, bind + param->idx);
@@ -365,10 +365,10 @@ static int insertStmtBindParam(STscStmt* stmt, TAOS_BIND* bind) {
   for (int32_t i = 0; i < pCmd->pDataBlocks->nSize; ++i) {
     STableDataBlocks* pBlock = pCmd->pDataBlocks->pData[i];
 
-    uint32_t totalDataSize = pBlock->size - sizeof(SShellSubmitBlock);
+    uint32_t totalDataSize = pBlock->size - sizeof(SSubmitBlk);
     pBlock->size += totalDataSize / alloced;
 
-    SShellSubmitBlock* pSubmit = (SShellSubmitBlock*)pBlock->pData;
+    SSubmitBlk* pSubmit = (SSubmitBlk*)pBlock->pData;
     pSubmit->numOfRows += pSubmit->numOfRows / alloced;
   }
 
@@ -398,10 +398,10 @@ static int insertStmtReset(STscStmt* pStmt) {
     for (int32_t i = 0; i < pCmd->pDataBlocks->nSize; ++i) {
       STableDataBlocks* pBlock = pCmd->pDataBlocks->pData[i];
 
-      uint32_t totalDataSize = pBlock->size - sizeof(SShellSubmitBlock);
-      pBlock->size = sizeof(SShellSubmitBlock) + totalDataSize / alloced;
+      uint32_t totalDataSize = pBlock->size - sizeof(SSubmitBlk);
+      pBlock->size = sizeof(SSubmitBlk) + totalDataSize / alloced;
 
-      SShellSubmitBlock* pSubmit = (SShellSubmitBlock*)pBlock->pData;
+      SSubmitBlk* pSubmit = (SSubmitBlk*)pBlock->pData;
       pSubmit->numOfRows = pSubmit->numOfRows / alloced;
     }
   }

src/client/src/tscSchemaUtil.c

@@ -58,7 +58,7 @@ SSchema *tscGetTableSchema(const STableMeta *pTableMeta) {
     return pSTableMeta->schema;
   }
   
-  return pTableMeta->schema;
+  return (SSchema*) pTableMeta->schema;
 }
 
 SSchema* tscGetTableTagSchema(const STableMeta* pTableMeta) {
@@ -165,7 +165,7 @@ STableMeta* tscCreateTableMetaFromMsg(STableMetaMsg* pTableMetaMsg, size_t* size
   
   pTableMeta->sid = pTableMetaMsg->sid;
   pTableMeta->uid = pTableMetaMsg->uid;
-  pTableMeta->vgid = pTableMetaMsg->vgid;
+  pTableMeta->vgId = pTableMetaMsg->vgId;
   
   pTableMeta->numOfVpeers = pTableMetaMsg->numOfVpeers;
   memcpy(pTableMeta->vpeerDesc, pTableMetaMsg->vpeerDesc, sizeof(SVnodeDesc) * pTableMeta->numOfVpeers);

src/client/src/tscServer.c

@@ -341,11 +341,7 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg) {
      * the tscShouldFreeAsyncSqlObj will success and tscFreeSqlObj free it immediately.
      */
     bool shouldFree = tscShouldFreeAsyncSqlObj(pSql);
-    if (command == TSDB_SQL_INSERT) {  // handle multi-vnode insertion situation
-      (*pSql->fp)(pSql, taosres, rpcMsg->code);
-    } else {
     (*pSql->fp)(pSql->param, taosres, rpcMsg->code);
-    }
 
     if (shouldFree) {
       // If it is failed, all objects allocated during execution taos_connect_a should be released
@@ -512,14 +508,17 @@ int tscBuildRetrieveMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   pRetrieveMsg->free = htons(pQueryInfo->type);
   pMsg += sizeof(pQueryInfo->type);
 
-  pSql->cmd.payloadLen = pMsg - pStart;
-  pSql->cmd.msgType = TSDB_MSG_TYPE_RETRIEVE;
+  pRetrieveMsg->header.vgId = htonl(1);
+  pMsg += sizeof(SRetrieveTableMsg);
+  
+  pRetrieveMsg->header.contLen = htonl(pSql->cmd.payloadLen);
   
+  pSql->cmd.msgType = TSDB_MSG_TYPE_RETRIEVE;
   return TSDB_CODE_SUCCESS;
 }
 
 void tscUpdateVnodeInSubmitMsg(SSqlObj *pSql, char *buf) {
-  //SShellSubmitMsg *pShellMsg;
+  //SSubmitMsg *pShellMsg;
   //char *           pMsg;
   //STableMetaInfo * pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, pSql->cmd.clauseIndex, 0);
 
@@ -528,34 +527,38 @@ void tscUpdateVnodeInSubmitMsg(SSqlObj *pSql, char *buf) {
   //pMsg = buf + tsRpcHeadSize;
 
   //TODO set iplist
-  //pShellMsg = (SShellSubmitMsg *)pMsg;
+  //pShellMsg = (SSubmitMsg *)pMsg;
   //pShellMsg->vnode = htons(pTableMeta->vpeerDesc[pSql->index].vnode);
   //tscTrace("%p update submit msg vnode:%s:%d", pSql, taosIpStr(pTableMeta->vpeerDesc[pSql->index].ip),
   //         htons(pShellMsg->vnode));
 }
 
 int tscBuildSubmitMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
-  SShellSubmitMsg *pShellMsg;
+  SSubmitMsg *pShellMsg;
   char *           pMsg, *pStart;
 
   SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  STableMeta* pTableMeta = tscGetMetaInfo(pQueryInfo, 0)->pTableMeta;
   
   pStart = pSql->cmd.payload + tsRpcHeadSize;
   pMsg = pStart;
   
-  pShellMsg = (SShellSubmitMsg *)pMsg;
+  SMsgDesc* pMsgDesc = (SMsgDesc*) pMsg;
+  pMsgDesc->numOfVnodes = htonl(1);       //set the number of vnodes
+  pMsg += sizeof(SMsgDesc);
+  
+  pShellMsg = (SSubmitMsg *)pMsg;
+  pShellMsg->header.vgId = htonl(pTableMeta->vgId);
+  pShellMsg->header.contLen = htonl(pSql->cmd.payloadLen);
+  pShellMsg->length = pShellMsg->header.contLen;
   
-  pShellMsg->import = htons(TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_INSERT) ? 0 : 1);
-  pShellMsg->vnode = 0; //htons(pTableMeta->vpeerDesc[pTableMeta->index].vnode);
-  pShellMsg->numOfSid = htonl(pSql->cmd.numOfTablesInSubmit);  // number of meters to be inserted
+  pShellMsg->numOfBlocks = htonl(pSql->cmd.numOfTablesInSubmit);  // number of meters to be inserted
 
   // pSql->cmd.payloadLen is set during parse sql routine, so we do not use it here
   pSql->cmd.msgType = TSDB_MSG_TYPE_SUBMIT;
+  
 //  tscTrace("%p update submit msg vnode:%s:%d", pSql, taosIpStr(pTableMeta->vpeerDesc[pTableMeta->index].ip),
 //           htons(pShellMsg->vnode));
-
-  pSql->cmd.payloadLen = sizeof(SShellSubmitMsg);
-
   return TSDB_CODE_SUCCESS;
 }
 
@@ -598,7 +601,7 @@ static int32_t tscEstimateQueryMsgSize(SSqlCmd *pCmd, int32_t clauseIndex) {
   SSuperTableMeta *pMetricMeta = pTableMetaInfo->pMetricMeta;
   SVnodeSidList *pVnodeSidList = tscGetVnodeSidList(pMetricMeta, pTableMetaInfo->vnodeIndex);
 
-  int32_t meterInfoSize = (pMetricMeta->tagLen + sizeof(STableSidExtInfo)) * pVnodeSidList->numOfSids;
+  int32_t meterInfoSize = (pMetricMeta->tagLen + sizeof(STableIdInfo)) * pVnodeSidList->numOfSids;
   int32_t outputColumnSize = pQueryInfo->exprsInfo.numOfExprs * sizeof(SSqlFuncExprMsg);
 
   int32_t size = meterInfoSize + outputColumnSize + srcColListSize + exprSize + MIN_QUERY_MSG_PKT_SIZE;
@@ -609,37 +612,34 @@ static int32_t tscEstimateQueryMsgSize(SSqlCmd *pCmd, int32_t clauseIndex) {
   return size;
 }
 
-static char *doSerializeTableInfo(SSqlObj *pSql, int32_t numOfTables, int32_t vnodeId, char *pMsg) {
+static char *doSerializeTableInfo(SSqlObj *pSql, int32_t numOfTables, int32_t vgId, char *pMsg) {
   STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, pSql->cmd.clauseIndex, 0);
 
   STableMeta * pTableMeta = pTableMetaInfo->pTableMeta;
   SSuperTableMeta *pMetricMeta = pTableMetaInfo->pMetricMeta;
 
-  tscTrace("%p vid:%d, query on %d meters", pSql, vnodeId, numOfTables);
+  tscTrace("%p vgId:%d, query on %d tables", pSql, vgId, numOfTables);
   if (UTIL_TABLE_IS_NOMRAL_TABLE(pTableMetaInfo)) {
 #ifdef _DEBUG_VIEW
     tscTrace("%p sid:%d, uid:%" PRIu64, pSql, pTableMetaInfo->pTableMeta->sid, pTableMetaInfo->pTableMeta->uid);
 #endif
-    STableSidExtInfo *pTableMetaInfo = (STableSidExtInfo *)pMsg;
-    pTableMetaInfo->sid = htonl(pTableMeta->sid);
-    pTableMetaInfo->uid = htobe64(pTableMeta->uid);
-    pTableMetaInfo->key = htobe64(tscGetSubscriptionProgress(pSql->pSubscription, pTableMeta->uid));
-    pMsg += sizeof(STableSidExtInfo);
+    STableIdInfo *pTableIdInfo = (STableIdInfo *)pMsg;
+    pTableIdInfo->sid = htonl(pTableMeta->sid);
+    pTableIdInfo->uid = htobe64(pTableMeta->uid);
+    pTableIdInfo->key = htobe64(tscGetSubscriptionProgress(pSql->pSubscription, pTableMeta->uid));
+    pMsg += sizeof(STableIdInfo);
   } else {
     SVnodeSidList *pVnodeSidList = tscGetVnodeSidList(pMetricMeta, pTableMetaInfo->vnodeIndex);
 
     for (int32_t i = 0; i < numOfTables; ++i) {
-      STableSidExtInfo *pTableMetaInfo = (STableSidExtInfo *)pMsg;
-      STableSidExtInfo *pQueryMeterInfo = tscGetMeterSidInfo(pVnodeSidList, i);
-
-      pTableMetaInfo->sid = htonl(pQueryMeterInfo->sid);
-      pTableMetaInfo->uid = htobe64(pQueryMeterInfo->uid);
-      pTableMetaInfo->key = htobe64(tscGetSubscriptionProgress(pSql->pSubscription, pQueryMeterInfo->uid));
+      STableIdInfo *pTableIdInfo = (STableIdInfo *)pMsg;
+      STableIdInfo *pQueryMeterInfo = tscGetMeterSidInfo(pVnodeSidList, i);
 
-      pMsg += sizeof(STableSidExtInfo);
+      pTableIdInfo->sid = htonl(pQueryMeterInfo->sid);
+      pTableIdInfo->uid = htobe64(pQueryMeterInfo->uid);
+      pTableIdInfo->key = htobe64(tscGetSubscriptionProgress(pSql->pSubscription, pQueryMeterInfo->uid));
       
-      memcpy(pMsg, pQueryMeterInfo->tags, pMetricMeta->tagLen);
-      pMsg += pMetricMeta->tagLen;
+      pMsg += sizeof(STableIdInfo);
 
 #ifdef _DEBUG_VIEW
       tscTrace("%p sid:%d, uid:%" PRId64, pSql, pQueryMeterInfo->sid, pQueryMeterInfo->uid);
@@ -679,6 +679,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
     pQueryMsg->uid = pTableMeta->uid;
     pQueryMsg->numOfTagsCols = 0;
     
+    pQueryMsg->vgId = htonl(pTableMeta->vgId);
     tscTrace("%p queried tables:%d, table id: %s", pSql, 1, pTableMetaInfo->name);
   } else {  // query on super table
     if (pTableMetaInfo->vnodeIndex < 0) {
@@ -696,7 +697,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
     }
 
     tscTrace("%p query on vid:%d, number of tables:%d", pSql, vnodeId, numOfTables);
-    pQueryMsg->vnode = htons(vnodeId);
+    pQueryMsg->vgId = htons(vnodeId);
   }
 
   pQueryMsg->numOfTables = htonl(numOfTables);
@@ -764,14 +765,14 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
     SColumnBase *pCol = tscColumnBaseInfoGet(&pQueryInfo->colList, i);
     SSchema *    pColSchema = &pSchema[pCol->colIndex.columnIndex];
 
-    if (pCol->colIndex.columnIndex >= tscGetNumOfColumns(pTableMeta) || pColSchema->type < TSDB_DATA_TYPE_BOOL ||
-        pColSchema->type > TSDB_DATA_TYPE_NCHAR) {
-      tscError("%p vid:%d sid:%d id:%s, column index out of range, numOfColumns:%d, index:%d, column name:%s", pSql,
-               htons(pQueryMsg->vnode), pTableMeta->sid, pTableMetaInfo->name, tscGetNumOfColumns(pTableMeta), pCol->colIndex,
-               pColSchema->name);
-
-      return -1;  // 0 means build msg failed
-    }
+//    if (pCol->colIndex.columnIndex >= tscGetNumOfColumns(pTableMeta) || pColSchema->type < TSDB_DATA_TYPE_BOOL ||
+//        pColSchema->type > TSDB_DATA_TYPE_NCHAR) {
+//      tscError("%p vid:%d sid:%d id:%s, column index out of range, numOfColumns:%d, index:%d, column name:%s", pSql,
+//               htons(pQueryMsg->vnode), pTableMeta->sid, pTableMetaInfo->name, tscGetNumOfColumns(pTableMeta), pCol->colIndex,
+//               pColSchema->name);
+//
+//      return -1;  // 0 means build msg failed
+//    }
 
     pQueryMsg->colList[i].colId = htons(pColSchema->colId);
     pQueryMsg->colList[i].bytes = htons(pColSchema->bytes);
@@ -865,7 +866,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   pQueryMsg->colNameLen = htonl(len);
 
   // serialize the table info (sid, uid, tags)
-  pMsg = doSerializeTableInfo(pSql, numOfTables, htons(pQueryMsg->vnode), pMsg);
+  pMsg = doSerializeTableInfo(pSql, numOfTables, htons(pQueryMsg->vgId), pMsg);
 
   // only include the required tag column schema. If a tag is not required, it won't be sent to vnode
   if (pTableMetaInfo->numOfTags > 0) {
@@ -947,6 +948,8 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   pCmd->payloadLen = msgLen;
   pSql->cmd.msgType = TSDB_MSG_TYPE_QUERY;
   
+  pQueryMsg->contLen = htonl(msgLen);
+  
   assert(msgLen + minMsgSize() <= size);
 
   return TSDB_CODE_SUCCESS;
@@ -1849,12 +1852,12 @@ int tscProcessTableMetaRsp(SSqlObj *pSql) {
 
   pMetaMsg->sid = htonl(pMetaMsg->sid);
   pMetaMsg->sversion = htons(pMetaMsg->sversion);
-  pMetaMsg->vgid = htonl(pMetaMsg->vgid);
+  pMetaMsg->vgId = htonl(pMetaMsg->vgId);
   pMetaMsg->uid = htobe64(pMetaMsg->uid);
   pMetaMsg->contLen = htons(pMetaMsg->contLen);
 
-  if (pMetaMsg->sid < 0 || pMetaMsg->vgid < 0) {
-    tscError("invalid meter vgid:%d, sid%d", pMetaMsg->vgid, pMetaMsg->sid);
+  if (pMetaMsg->sid < 0 || pMetaMsg->vgId < 0) {
+    tscError("invalid meter vgId:%d, sid%d", pMetaMsg->vgId, pMetaMsg->sid);
     return TSDB_CODE_INVALID_VALUE;
   }
 
@@ -1948,11 +1951,11 @@ int tscProcessMultiMeterMetaRsp(SSqlObj *pSql) {
 
     pMeta->sid = htonl(pMeta->sid);
     pMeta->sversion = htons(pMeta->sversion);
-    pMeta->vgid = htonl(pMeta->vgid);
+    pMeta->vgId = htonl(pMeta->vgId);
     pMeta->uid = htobe64(pMeta->uid);
 
-    if (pMeta->sid <= 0 || pMeta->vgid < 0) {
-      tscError("invalid meter vgid:%d, sid%d", pMeta->vgid, pMeta->sid);
+    if (pMeta->sid <= 0 || pMeta->vgId < 0) {
+      tscError("invalid meter vgId:%d, sid%d", pMeta->vgId, pMeta->sid);
       pSql->res.code = TSDB_CODE_INVALID_VALUE;
       pSql->res.numOfTotal = i;
       return TSDB_CODE_OTHERS;
@@ -2067,7 +2070,7 @@ int tscProcessMetricMetaRsp(SSqlObj *pSql) {
     pMeta->numOfVnodes = htonl(pMeta->numOfVnodes);
     pMeta->tagLen = htons(pMeta->tagLen);
 
-    size += pMeta->numOfVnodes * sizeof(SVnodeSidList *) + pMeta->numOfTables * sizeof(STableSidExtInfo *);
+    size += pMeta->numOfVnodes * sizeof(SVnodeSidList *) + pMeta->numOfTables * sizeof(STableIdInfo *);
 
     char *pBuf = calloc(1, size);
     if (pBuf == NULL) {
@@ -2093,16 +2096,16 @@ int tscProcessMetricMetaRsp(SSqlObj *pSql) {
 
       tscTrace("%p metricmeta:vid:%d,numOfTables:%d", pSql, i, pLists->numOfSids);
 
-      pBuf += sizeof(SVnodeSidList) + sizeof(STableSidExtInfo *) * pSidLists->numOfSids;
+      pBuf += sizeof(SVnodeSidList) + sizeof(STableIdInfo *) * pSidLists->numOfSids;
       rsp += sizeof(SVnodeSidList);
 
-      size_t elemSize = sizeof(STableSidExtInfo) + pNewMetricMeta->tagLen;
+      size_t elemSize = sizeof(STableIdInfo) + pNewMetricMeta->tagLen;
       for (int32_t j = 0; j < pSidLists->numOfSids; ++j) {
         pLists->pSidExtInfoList[j] = pBuf - (char *)pLists;
         memcpy(pBuf, rsp, elemSize);
 
-        ((STableSidExtInfo *)pBuf)->uid = htobe64(((STableSidExtInfo *)pBuf)->uid);
-        ((STableSidExtInfo *)pBuf)->sid = htonl(((STableSidExtInfo *)pBuf)->sid);
+        ((STableIdInfo *)pBuf)->uid = htobe64(((STableIdInfo *)pBuf)->uid);
+        ((STableIdInfo *)pBuf)->sid = htonl(((STableIdInfo *)pBuf)->sid);
 
         rsp += elemSize;
         pBuf += elemSize;

src/client/src/tscSql.c

@@ -130,7 +130,7 @@ STscObj *taosConnectImpl(const char *ip, const char *user, const char *pass, con
   pSql->pTscObj = pObj;
   pSql->signature = pSql;
   tsem_init(&pSql->rspSem, 0, 0);
-//  tsem_init(&pSql->emptyRspSem, 0, 1);
+  
   pObj->pSql = pSql;
   pSql->fp = fp;
   pSql->param = param;
@@ -146,6 +146,8 @@ STscObj *taosConnectImpl(const char *ip, const char *user, const char *pass, con
     return NULL;
   }
 
+  // tsRpcHeaderSize will be updated during RPC initialization, so only after it initialization, this value is valid
+  tsInsertHeadSize = tsRpcHeadSize + sizeof(SMsgDesc) + sizeof(SSubmitMsg);
   return pObj;
 }
 

src/client/src/tscSub.c

@@ -202,7 +202,7 @@ int tscUpdateSubscription(STscObj* pObj, SSub* pSub) {
     for (int32_t i = 0; i < pMetricMeta->numOfVnodes; i++) {
       SVnodeSidList *pVnodeSidList = tscGetVnodeSidList(pMetricMeta, i);
       for (int32_t j = 0; j < pVnodeSidList->numOfSids; j++) {
-        STableSidExtInfo *pTableMetaInfo = tscGetMeterSidInfo(pVnodeSidList, j);
+        STableIdInfo *pTableMetaInfo = tscGetMeterSidInfo(pVnodeSidList, j);
         int64_t uid = pTableMetaInfo->uid;
         progress[numOfTables].uid = uid;
         progress[numOfTables++].key = tscGetSubscriptionProgress(pSub, uid);

src/client/src/tscSystem.c

@@ -34,7 +34,6 @@ void *  pTscMgmtConn;
 void *  pSlaveConn;
 void *  tscCacheHandle;
 int32_t globalCode = 0;
-int     initialized = 0;
 int     slaveIndex;
 void *  tscTmr;
 void *  tscQhandle;
@@ -187,9 +186,7 @@ void taos_init_imp() {
 
   if (tscCacheHandle == NULL) tscCacheHandle = taosCacheInit(tscTmr, refreshTime);
 
-  initialized = 1;
   tscTrace("client is initialized successfully");
-  tsInsertHeadSize = tsRpcHeadSize + sizeof(SShellSubmitMsg);
 }
 
 void taos_init() { pthread_once(&tscinit, taos_init_imp); }

src/client/src/tscUtil.c

@@ -191,7 +191,7 @@ SVnodeSidList* tscGetVnodeSidList(SSuperTableMeta* pMetricmeta, int32_t vnodeIdx
   return (SVnodeSidList*)(pMetricmeta->list[vnodeIdx] + (char*)pMetricmeta);
 }
 
-STableSidExtInfo* tscGetMeterSidInfo(SVnodeSidList* pSidList, int32_t idx) {
+STableIdInfo* tscGetMeterSidInfo(SVnodeSidList* pSidList, int32_t idx) {
   if (pSidList == NULL) {
     tscError("illegal sidlist");
     return 0;
@@ -206,7 +206,7 @@ STableSidExtInfo* tscGetMeterSidInfo(SVnodeSidList* pSidList, int32_t idx) {
   
   assert(pSidList->pSidExtInfoList[idx] >= 0);
   
-  return (STableSidExtInfo*)(pSidList->pSidExtInfoList[idx] + (char*)pSidList);
+  return (STableIdInfo*)(pSidList->pSidExtInfoList[idx] + (char*)pSidList);
 }
 
 bool tscIsTwoStageSTableQuery(SQueryInfo* pQueryInfo, int32_t tableIndex) {
@@ -614,7 +614,7 @@ int32_t tscCopyDataBlockToPayload(SSqlObj* pSql, STableDataBlocks* pDataBlock) {
    */
   pCmd->payloadLen = pDataBlock->nAllocSize - tsRpcHeadSize;
 
-  assert(pCmd->allocSize >= pCmd->payloadLen + tsRpcHeadSize + 100);
+  assert(pCmd->allocSize >= pCmd->payloadLen + tsRpcHeadSize + 100 && pCmd->payloadLen > 0);
   return TSDB_CODE_SUCCESS;
 }
 
@@ -695,6 +695,49 @@ int32_t tscGetDataBlockFromList(void* pHashList, SDataBlockList* pDataBlockList,
   return TSDB_CODE_SUCCESS;
 }
 
+static void trimDataBlock(void* pDataBlock, STableDataBlocks* pTableDataBlock) {
+  int32_t firstPartLen = 0;
+  
+  STableMeta* pTableMeta = pTableDataBlock->pTableMeta;
+  STableComInfo tinfo = tscGetTableInfo(pTableMeta);
+  SSchema* pSchema = tscGetTableSchema(pTableMeta);
+  
+  memcpy(pDataBlock, pTableDataBlock->pData, sizeof(SSubmitBlk));
+  pDataBlock += sizeof(SSubmitBlk);
+  
+  int32_t total = sizeof(int32_t)*2;
+  for(int32_t i = 0; i < tinfo.numOfColumns; ++i) {
+    switch (pSchema[i].type) {
+      case TSDB_DATA_TYPE_NCHAR:
+      case TSDB_DATA_TYPE_BINARY: {
+        assert(0);  // not support binary yet
+        firstPartLen += sizeof(int32_t);break;
+      }
+      default:
+        firstPartLen += tDataTypeDesc[pSchema[i].type].nSize;
+        total += tDataTypeDesc[pSchema[i].type].nSize;
+    }
+  }
+  
+  char* p = pTableDataBlock->pData + sizeof(SSubmitBlk);
+  
+  SSubmitBlk* pBlock = pTableDataBlock->pData;
+  int32_t rows = htons(pBlock->numOfRows);
+  
+  for(int32_t i = 0; i < rows; ++i) {
+    *(int32_t*) pDataBlock = total;
+    pDataBlock += sizeof(int32_t);
+    
+    *(int32_t*) pDataBlock = firstPartLen;
+    pDataBlock += sizeof(int32_t);
+    
+    memcpy(pDataBlock, p, pTableDataBlock->rowSize);
+    
+    p += pTableDataBlock->rowSize;
+    pDataBlock += pTableDataBlock->rowSize;
+  }
+}
+
 int32_t tscMergeTableDataBlocks(SSqlObj* pSql, SDataBlockList* pTableDataBlockList) {
   SSqlCmd* pCmd = &pSql->cmd;
 
@@ -705,8 +748,9 @@ int32_t tscMergeTableDataBlocks(SSqlObj* pSql, SDataBlockList* pTableDataBlockLi
     STableDataBlocks* pOneTableBlock = pTableDataBlockList->pData[i];
 
     STableDataBlocks* dataBuf = NULL;
+    
     int32_t ret =
-        tscGetDataBlockFromList(pVnodeDataBlockHashList, pVnodeDataBlockList, pOneTableBlock->vgid, TSDB_PAYLOAD_SIZE,
+        tscGetDataBlockFromList(pVnodeDataBlockHashList, pVnodeDataBlockList, pOneTableBlock->vgId, TSDB_PAYLOAD_SIZE,
                                 tsInsertHeadSize, 0, pOneTableBlock->tableId, pOneTableBlock->pTableMeta, &dataBuf);
     if (ret != TSDB_CODE_SUCCESS) {
       tscError("%p failed to prepare the data block buffer for merging table data, code:%d", pSql, ret);
@@ -715,7 +759,7 @@ int32_t tscMergeTableDataBlocks(SSqlObj* pSql, SDataBlockList* pTableDataBlockLi
       return ret;
     }
 
-    int64_t destSize = dataBuf->size + pOneTableBlock->size;
+    int64_t destSize = dataBuf->size + pOneTableBlock->size + pOneTableBlock->size*sizeof(int32_t)*2;
     if (dataBuf->nAllocSize < destSize) {
       while (dataBuf->nAllocSize < destSize) {
         dataBuf->nAllocSize = dataBuf->nAllocSize * 1.5;
@@ -729,29 +773,33 @@ int32_t tscMergeTableDataBlocks(SSqlObj* pSql, SDataBlockList* pTableDataBlockLi
         tscError("%p failed to allocate memory for merging submit block, size:%d", pSql, dataBuf->nAllocSize);
 
         taosHashCleanup(pVnodeDataBlockHashList);
-        tfree(dataBuf->pData);
         tscDestroyBlockArrayList(pVnodeDataBlockList);
+        tfree(dataBuf->pData);
 
         return TSDB_CODE_CLI_OUT_OF_MEMORY;
       }
     }
 
-    SShellSubmitBlock* pBlocks = (SShellSubmitBlock*)pOneTableBlock->pData;
+    SSubmitBlk* pBlocks = (SSubmitBlk*) pOneTableBlock->pData;
     sortRemoveDuplicates(pOneTableBlock);
 
-    char* e = (char*)pBlocks->payLoad + pOneTableBlock->rowSize*(pBlocks->numOfRows-1);
+    char* e = (char*)pBlocks->data + pOneTableBlock->rowSize*(pBlocks->numOfRows-1);
+    
+    tscTrace("%p tableId:%s, sid:%d rows:%d sversion:%d skey:%" PRId64 ", ekey:%" PRId64, pSql, pOneTableBlock->tableId,
+        pBlocks->tid, pBlocks->numOfRows, pBlocks->sversion, GET_INT64_VAL(pBlocks->data), GET_INT64_VAL(e));
 
-    tscTrace("%p tableId:%s, sid:%d rows:%d sversion:%d skey:%" PRId64 ", ekey:%" PRId64, pSql, pOneTableBlock->tableId, pBlocks->sid,
-             pBlocks->numOfRows, pBlocks->sversion, GET_INT64_VAL(pBlocks->payLoad), GET_INT64_VAL(e));
+    int32_t len = pBlocks->numOfRows * (pOneTableBlock->rowSize + sizeof(int32_t) * 2);
     
-    pBlocks->sid = htonl(pBlocks->sid);
+    pBlocks->tid = htonl(pBlocks->tid);
     pBlocks->uid = htobe64(pBlocks->uid);
     pBlocks->sversion = htonl(pBlocks->sversion);
     pBlocks->numOfRows = htons(pBlocks->numOfRows);
     
-    memcpy(dataBuf->pData + dataBuf->size, pOneTableBlock->pData, pOneTableBlock->size);
+    pBlocks->len = htonl(len);
     
-    dataBuf->size += pOneTableBlock->size;
+    // erase the empty space reserved for binary data
+    trimDataBlock(dataBuf->pData + dataBuf->size, pOneTableBlock);
+    dataBuf->size += (len + sizeof(SSubmitBlk));
     dataBuf->numOfTables += 1;
   }
 

src/common/inc/dataformat.h

@@ -81,11 +81,13 @@ STSchema *tdDecodeSchema(void **psrc);
  */
 typedef void *SDataRow;
 
+
 #define TD_DATA_ROW_HEAD_SIZE (2 * sizeof(int32_t))
 
 #define dataRowLen(r) (*(int32_t *)(r))
 #define dataRowFLen(r) (*(int32_t *)((char *)(r) + sizeof(int32_t)))
 #define dataRowTuple(r) ((char *)(r) + TD_DATA_ROW_HEAD_SIZE)
+#define dataRowKey(r) (*(TSKEY *)(dataRowTuple(r)))
 #define dataRowSetLen(r, l) (dataRowLen(r) = (l))
 #define dataRowSetFLen(r, l) (dataRowFLen(r) = (l))
 #define dataRowIdx(r, i) ((char *)(r) + i)
@@ -101,23 +103,13 @@ int      tdAppendColVal(SDataRow row, void *value, STColumn *pCol);
 void     tdDataRowReset(SDataRow row, STSchema *pSchema);
 SDataRow tdDataRowDup(SDataRow row);
 
-/* Data column definition
- * +---------+---------+-----------------------+
- * | int32_t | int32_t |                       |
- * +---------+---------+-----------------------+
- * |   len   | npoints |          data         |
- * +---------+---------+-----------------------+
- */
-typedef char *SDataCol;
-
-/* Data columns definition
- * +---------+---------+-----------------------+--------+-----------------------+
- * | int32_t | int32_t |                       |        |                       |
- * +---------+---------+-----------------------+--------+-----------------------+
- * |   len   | npoints |        SDataCol       |  ....  |        SDataCol       |
- * +---------+---------+-----------------------+--------+-----------------------+
- */
-typedef char *SDataCols;
+// ----------------- Data column structure
+typedef struct SDataCol {
+  int64_t len;
+  char    data[];
+} SDataCol;
+
+void tdConvertDataRowToCol(SDataCol *cols, STSchema *pSchema, int *iter);
 
 #ifdef __cplusplus
 }

src/common/src/dataformat.c

@@ -150,7 +150,7 @@ void tdFreeSchema(STSchema *pSchema) {
  */
 void tdUpdateSchema(STSchema *pSchema) {
   STColumn *pCol = NULL;
-  int32_t offset = 0;
+  int32_t offset = TD_DATA_ROW_HEAD_SIZE;
   for (int i = 0; i < schemaNCols(pSchema); i++) {
     pCol = schemaColAt(pSchema, i);
     colSetOffset(pCol, offset);
@@ -294,6 +294,16 @@ SDataRow tdDataRowDup(SDataRow row) {
   return trow;
 }
 
+void tdConvertDataRowToCol(SDataCol *cols, STSchema *pSchema, int *iter) {
+  int row = *iter;
+
+  for (int i = 0; i < schemaNCols(pSchema); i++) {
+    // TODO
+  }
+
+  *iter = row + 1;
+}
+
 /**
  * Return the first part length of a data row for a schema
  */

src/dnode/src/dnodeRead.c

@@ -15,13 +15,16 @@
 
 #define _DEFAULT_SOURCE
 #include "os.h"
+
 #include "taoserror.h"
 #include "taosmsg.h"
 #include "tlog.h"
 #include "tqueue.h"
 #include "trpc.h"
-#include "dnodeRead.h"
+
 #include "dnodeMgmt.h"
+#include "dnodeRead.h"
+#include "queryExecutor.h"
 
 typedef struct {
   int32_t  code;
@@ -75,6 +78,8 @@ void dnodeRead(SRpcMsg *pMsg) {
   char        *pCont       = (char *) pMsg->pCont;
   SRpcContext *pRpcContext = NULL;
   
+  dTrace("dnode read msg disposal");
+  
 //  SMsgDesc *pDesc = pCont;
 //  pDesc->numOfVnodes = htonl(pDesc->numOfVnodes);
 //  pCont += sizeof(SMsgDesc);
@@ -88,7 +93,7 @@ void dnodeRead(SRpcMsg *pMsg) {
 
   while (leftLen > 0) {
     SMsgHead *pHead = (SMsgHead *) pCont;
-    pHead->vgId    = 1; //htonl(pHead->vgId);
+    pHead->vgId    = 1;//htonl(pHead->vgId);
     pHead->contLen = pMsg->contLen; //htonl(pHead->contLen);
 
     void *pVnode = dnodeGetVnode(pHead->vgId);
@@ -223,43 +228,81 @@ static void dnodeProcessReadResult(SReadMsg *pRead) {
 }
 
 static void dnodeProcessQueryMsg(SReadMsg *pMsg) {
-  void *pQInfo = (void*)100;
-  dTrace("query msg is disposed, qInfo:%p", pQInfo);
+  SQueryTableMsg* pQueryTableMsg = (SQueryTableMsg*) pMsg->pCont;
+  
+  SQInfo* pQInfo = NULL;
+  void* tsdb = dnodeGetVnodeTsdb(pMsg->pVnode);
+  int32_t code = qCreateQueryInfo(tsdb, pQueryTableMsg, &pQInfo);
   
   SQueryTableRsp *pRsp = (SQueryTableRsp *) rpcMallocCont(sizeof(SQueryTableRsp));
-  pRsp->code    = 0;
+  pRsp->code    = code;
   pRsp->qhandle = htobe64((uint64_t) (pQInfo));
 
   SRpcMsg rpcRsp = {
       .handle = pMsg->rpcMsg.handle,
       .pCont = pRsp,
       .contLen = sizeof(SQueryTableRsp),
-      .code = 0,
+      .code = code,
       .msgType = 0
   };
+  
   rpcSendResponse(&rpcRsp);
+  
+  // do execute query
+  qTableQuery(pQInfo);
 }
 
 static void dnodeProcessRetrieveMsg(SReadMsg *pMsg) {
   SRetrieveTableMsg *pRetrieve = pMsg->pCont;
   void *pQInfo = htobe64(pRetrieve->qhandle);
 
-  dTrace("retrieve msg is disposed, qInfo:%p", pQInfo);
+  dTrace("QInfo:%p vgId:%d, retrieve msg is received", pQInfo, pRetrieve->header.vgId);
+  
+  int32_t rowSize = 0;
+  int32_t numOfRows = 0;
+  int32_t contLen = 0;
   
-  assert(pQInfo != NULL);
-  int32_t contLen = 100;
-  SRetrieveTableRsp *pRsp = (SRetrieveTableRsp *) rpcMallocCont(contLen);
+  SRpcMsg rpcRsp = {0};
+  
+  int32_t code = qRetrieveQueryResultInfo(pQInfo, &numOfRows, &rowSize);
+  if (code != TSDB_CODE_SUCCESS) {
+    contLen = sizeof(SRetrieveTableRsp);
+    
+    SRetrieveTableRsp *pRsp = (SRetrieveTableRsp *)rpcMallocCont(contLen);
     pRsp->numOfRows = 0;
     pRsp->precision = 0;
     pRsp->offset = 0;
     pRsp->useconds = 0;
   
-  SRpcMsg rpcRsp = {
+    rpcRsp = (SRpcMsg) {
         .handle = pMsg->rpcMsg.handle,
         .pCont = pRsp,
         .contLen = contLen,
-      .code = 0,
+        .code = code,
         .msgType = 0
     };
+    
+    //todo free qinfo
+  } else {
+    contLen = 100;
+    
+    SRetrieveTableRsp *pRsp = (SRetrieveTableRsp *)rpcMallocCont(contLen);
+    pRsp->numOfRows = htonl(1);
+    pRsp->precision = htons(0);
+    pRsp->offset = htobe64(0);
+    pRsp->useconds = htobe64(0);
+  
+    // todo set the data
+    *(int64_t*) pRsp->data = 1000;
+    
+    rpcRsp = (SRpcMsg) {
+        .handle = pMsg->rpcMsg.handle,
+        .pCont = pRsp,
+        .contLen = contLen,
+        .code = code,
+        .msgType = 0
+    };
+  }
+  
   rpcSendResponse(&rpcRsp);
 }

src/dnode/src/dnodeWrite.c

@@ -276,6 +276,11 @@ static void dnodeProcessSubmitMsg(SWriteMsg *pMsg) {
   pRsp->affectedRows      = htonl(1);
   pRsp->numOfFailedBlocks = 0;
   
+  void* tsdb = dnodeGetVnodeTsdb(pMsg->pVnode);
+  assert(tsdb != NULL);
+  
+  tsdbInsertData(tsdb, pMsg->pCont);
+  
   SRpcMsg rpcRsp = {
     .handle = pMsg->rpcMsg.handle,
     .pCont = pRsp,
@@ -283,6 +288,7 @@ static void dnodeProcessSubmitMsg(SWriteMsg *pMsg) {
     .code = 0,
     .msgType = 0
   };
+  
   rpcSendResponse(&rpcRsp);
 }
 

src/inc/taosmsg.h

@@ -188,21 +188,51 @@ extern char *taosMsg[];
 
 #pragma pack(push, 1)
 
-typedef struct {
-  int32_t  vnode;
-  int32_t  sid;
-  int32_t  sversion;
-  uint64_t uid;
-  int16_t  numOfRows;
-  char     payLoad[];
-} SShellSubmitBlock;
+//typedef struct {
+//  int32_t  vnode;
+//  int32_t  sid;
+//  int32_t  sversion;
+//  uint64_t uid;
+//  int16_t  numOfRows;
+//  char     payLoad[];
+//} SShellSubmitBlock;
 
 typedef struct {
-  int16_t import;
-  int16_t vnode;
-  int32_t numOfSid; /* total number of sid */
-  char    blks[];   /* numOfSid blocks, each blocks for one table */
-} SShellSubmitMsg;
+  int32_t numOfVnodes;
+} SMsgDesc;
+
+typedef struct SMsgHead {
+  int32_t contLen;
+  int32_t vgId;
+} SMsgHead;
+
+//typedef struct {
+//  SMsgDesc desc;
+//  SMsgHead header;
+//  int16_t import;
+//  int32_t numOfTables; // total number of sid
+//  char    blks[];      // number of data blocks, each table has at least one data block
+//} SShellSubmitMsg;
+
+// Submit message for one table
+typedef struct SSubmitBlk {
+  int64_t  uid;        // table unique id
+  int32_t  tid;        // table id
+  int32_t  padding;    // TODO just for padding here
+  int32_t  sversion;   // data schema version
+  int32_t  len;        // data part length, not including the SSubmitBlk head
+  int16_t  numOfRows;  // total number of rows in current submit block
+  char     data[];
+} SSubmitBlk;
+
+// Submit message for this TSDB
+typedef struct SSubmitMsg {
+  SMsgHead   header;
+  int32_t    length;
+  int32_t    compressed:2;
+  int32_t    numOfBlocks:30;
+  SSubmitBlk blocks[];
+} SSubmitMsg;
 
 typedef struct {
   int32_t index; // index of failed block in submit blocks
@@ -232,15 +262,6 @@ typedef struct {
   uint32_t ip;
 } SVnodeDesc;
 
-typedef struct {
-  int32_t numOfVnodes;
-} SMsgDesc;
-
-typedef struct {
-  int32_t contLen;
-  int32_t vgId;
-} SMsgHead;
-
 typedef struct {
   int32_t    contLen;
   int32_t    vgId;
@@ -434,15 +455,11 @@ typedef struct SColumnInfo {
   SColumnFilterInfo *filters;
 } SColumnInfo;
 
-/*
- * enable vnode to understand how to group several tables with different tag;
- */
-typedef struct STableSidExtInfo {
+typedef struct STableIdInfo {
   int32_t sid;
   int64_t uid;
-  TSKEY   key;   // key for subscription
-  char    tags[];
-} STableSidExtInfo;
+  TSKEY   key;   // last accessed ts, for subscription
+} STableIdInfo;
 
 typedef struct STimeWindow {
   TSKEY skey;
@@ -455,10 +472,10 @@ typedef struct STimeWindow {
  * the outputCols will be 3 while the numOfCols is 1.
  */
 typedef struct {
-  int16_t  vnode;
-  int32_t  numOfTables;
-  uint64_t pSidExtInfo;  // table id & tag info ptr, in windows pointer may
+  int32_t contLen;   // msg header
+  int16_t vgId;
   
+  int32_t  numOfTables;
   uint64_t uid;
   STimeWindow window;
 
@@ -504,17 +521,19 @@ typedef struct {
 } SQueryTableMsg;
 
 typedef struct {
-  char     code;
+  int32_t  code;
   uint64_t qhandle;
 } SQueryTableRsp;
 
 typedef struct {
+  SMsgHead header;
   uint64_t qhandle;
   uint16_t free;
 } SRetrieveTableMsg;
 
-typedef struct {
+typedef struct SRetrieveTableRsp {
   int32_t numOfRows;
+  int8_t  completed; // all results are returned to client
   int16_t precision;
   int64_t offset;    // updated offset value for multi-vnode projection query
   int64_t useconds;
@@ -670,7 +689,7 @@ typedef struct {
   SVnodeDesc vpeerDesc[TSDB_VNODES_SUPPORT];
   int16_t    index;  // used locally
   int32_t    numOfSids;
-  int32_t    pSidExtInfoList[];  // offset value of STableSidExtInfo
+  int32_t    pSidExtInfoList[];  // offset value of STableIdInfo
 } SVnodeSidList;
 
 typedef struct {
@@ -692,7 +711,7 @@ typedef struct STableMetaMsg {
   int8_t  numOfVpeers;
   SVnodeDesc vpeerDesc[TSDB_VNODES_SUPPORT];
   int32_t  sid;
-  int32_t  vgid;
+  int32_t  vgId;
   uint64_t uid;
   SSchema  schema[];
 } STableMetaMsg;

src/mnode/src/mgmtChildTable.c

@@ -413,7 +413,7 @@ int32_t mgmtModifyChildTableTagValueByName(SChildTableObj *pTable, char *tagName
 int32_t mgmtGetChildTableMeta(SDbObj *pDb, SChildTableObj *pTable, STableMetaMsg *pMeta, bool usePublicIp) {
   pMeta->uid          = htobe64(pTable->uid);
   pMeta->sid          = htonl(pTable->sid);
-  pMeta->vgid         = htonl(pTable->vgId);
+  pMeta->vgId         = htonl(pTable->vgId);
   pMeta->sversion     = htons(pTable->superTable->sversion);
   pMeta->precision    = pDb->cfg.precision;
   pMeta->numOfTags    = pTable->superTable->numOfTags;

src/mnode/src/mgmtDnode.c

@@ -553,11 +553,14 @@ void mgmtProcessDnodeStatusMsg(SRpcMsg *rpcMsg) {
   pDnode->privateIp        = htonl(pStatus->privateIp);
   pDnode->publicIp         = htonl(pStatus->publicIp);
   pDnode->lastReboot       = htonl(pStatus->lastReboot);
-  pDnode->numOfTotalVnodes = htons(pStatus->numOfTotalVnodes);
   pDnode->numOfCores       = htons(pStatus->numOfCores);
   pDnode->diskAvailable    = pStatus->diskAvailable;
   pDnode->alternativeRole  = pStatus->alternativeRole;
 
+  if (pDnode->numOfTotalVnodes == 0) {
+    pDnode->numOfTotalVnodes = htons(pStatus->numOfTotalVnodes); 
+  }
+  
   if (pStatus->dnodeId == 0) {
     mTrace("dnode:%d, first access, privateIp:%s, name:%s, ", pDnode->dnodeId, taosIpStr(pDnode->privateIp), pDnode->dnodeName);
     mgmtSetDnodeMaxVnodes(pDnode);

src/mnode/src/mgmtNormalTable.c

@@ -493,7 +493,7 @@ static int32_t mgmtSetSchemaFromNormalTable(SSchema *pSchema, SNormalTableObj *p
 int32_t mgmtGetNormalTableMeta(SDbObj *pDb, SNormalTableObj *pTable, STableMetaMsg *pMeta, bool usePublicIp) {
   pMeta->uid          = htobe64(pTable->uid);
   pMeta->sid          = htonl(pTable->sid);
-  pMeta->vgid         = htonl(pTable->vgId);
+  pMeta->vgId         = htonl(pTable->vgId);
   pMeta->sversion     = htons(pTable->sversion);
   pMeta->precision    = pDb->cfg.precision;
   pMeta->numOfTags    = 0;

src/mnode/src/mgmtSuperTable.c

@@ -622,7 +622,7 @@ int32_t mgmtSetSchemaFromSuperTable(SSchema *pSchema, SSuperTableObj *pTable) {
 int32_t mgmtGetSuperTableMeta(SDbObj *pDb, SSuperTableObj *pTable, STableMetaMsg *pMeta, bool usePublicIp) {
   pMeta->uid          = htobe64(pTable->uid);
   pMeta->sid          = htonl(pTable->sid);
-  pMeta->vgid         = htonl(pTable->vgId);
+  pMeta->vgId         = htonl(pTable->vgId);
   pMeta->sversion     = htons(pTable->sversion);
   pMeta->precision    = pDb->cfg.precision;
   pMeta->numOfTags    = pTable->numOfTags;

src/query/CMakeLists.txt

@@ -11,5 +11,5 @@ INCLUDE_DIRECTORIES(inc)
 IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
   AUX_SOURCE_DIRECTORY(src SRC)
   ADD_LIBRARY(query ${SRC})
-  TARGET_LINK_LIBRARIES(query tutil m rt)
+  TARGET_LINK_LIBRARIES(query tsdb tutil m rt)
 ENDIF ()
\ No newline at end of file

src/query/inc/qextbuffer.h

@@ -124,9 +124,8 @@ typedef struct tTagSchema {
 typedef struct tSidSet {
   int32_t            numOfSids;
   int32_t            numOfSubSet;
-  STableSidExtInfo **pSids;
+  STableIdInfo     **pTableIdList;
   int32_t *          starterPos;  // position of each subgroup, generated according to
-
   SColumnModel      *pColumnModel;
   SColumnOrderInfo   orderIdx;
 } tSidSet;

src/query/inc/queryExecutor.h

@@ -25,6 +25,7 @@
 #include "taosdef.h"
 #include "tref.h"
 #include "tsqlfunction.h"
+#include "tarray.h"
 
 typedef struct SData {
   int32_t num;
@@ -39,7 +40,7 @@ enum {
 
 struct SColumnFilterElem;
 typedef bool (*__filter_func_t)(struct SColumnFilterElem* pFilter, char* val1, char* val2);
-typedef int (*__block_search_fn_t)(char* data, int num, int64_t key, int order);
+typedef int32_t (*__block_search_fn_t)(char* data, int32_t num, int64_t key, int32_t order);
 
 typedef struct SSqlGroupbyExpr {
   int16_t     tableIndex;
@@ -142,7 +143,7 @@ typedef struct SQuery {
   int32_t           pos;
   int64_t           pointsOffset;  // the number of points offset to save read data
   SData**           sdata;
-
+  int32_t capacity;
   SSingleColumnFilterInfo* pFilterInfo;
 } SQuery;
 
@@ -152,7 +153,6 @@ typedef struct SQueryCostSummary {
 typedef struct SQueryRuntimeEnv {
   SResultInfo*       resultInfo;  // todo refactor to merge with SWindowResInfo
   SQuery*            pQuery;
-  void*              pTabObj;
   SData**            pInterpoBuf;
   SQLFunctionCtx*    pCtx;
   int16_t            numOfRowsPerPage;
@@ -171,18 +171,20 @@ typedef struct SQueryRuntimeEnv {
 
 typedef struct SQInfo {
   uint64_t         signature;
+  void* pVnode;
   TSKEY            startTime;
   int64_t          elapsedTime;
   SResultRec       rec;
-  int              pointsReturned;
-  int              pointsInterpo;
-  int              code;  // error code to returned to client
+  int32_t          pointsReturned;
+  int32_t          pointsInterpo;
+  int32_t          code;   // error code to returned to client
+  int32_t          killed; // denotes if current query is killed
   sem_t            dataReady;
-  SHashObj*        pTableList;  // table list
+  SArray*          pTableIdList;  // table list
   SQueryRuntimeEnv runtimeEnv;
   int32_t          subgroupIdx;
   int32_t          offset; /* offset in group result set of subgroup */
-  tSidSet*         pSidSet;
+//  tSidSet*         pSidSet;
   
   T_REF_DECLARE()
   /*
@@ -204,13 +206,13 @@ typedef struct SQInfo {
  * @param pQInfo
  * @return
  */
-int32_t qCreateQueryInfo(void* pReadMsg, SQInfo** pQInfo);
+int32_t qCreateQueryInfo(void* pVnode, SQueryTableMsg* pQueryTableMsg, SQInfo** pQInfo);
 
 /**
  * query on single table
  * @param pReadMsg
  */
-void qTableQuery(void* pReadMsg);
+void qTableQuery(SQInfo* pQInfo);
 
 /**
  * query on super table
@@ -218,4 +220,13 @@ void qTableQuery(void* pReadMsg);
  */
 void qSuperTableQuery(void* pReadMsg);
 
+/**
+ * wait for the query completed, and retrieve final results to client
+ * @param pQInfo
+ */
+int32_t qRetrieveQueryResultInfo(SQInfo* pQInfo, int32_t *numOfRows, int32_t* rowsize);
+
+
+//int32_t qBuildQueryResult(SQInfo* pQInfo, void* pBuf);
+
 #endif  // TDENGINE_QUERYEXECUTOR_H

src/query/src/queryExecutor.c

@@ -17,16 +17,18 @@
 #include "hash.h"
 #include "hashfunc.h"
 #include "taosmsg.h"
+#include "tlog.h"
 #include "tlosertree.h"
-#include "tstatus.h"
 #include "tscompression.h"
+#include "tstatus.h"
 #include "ttime.h"
-#include "tlog.h"
 
+#include "qast.h"
+
+#include "qresultBuf.h"
 #include "queryExecutor.h"
 #include "queryUtil.h"
 #include "tsdb.h"
-#include "qresultBuf.h"
 
 #define DEFAULT_INTERN_BUF_SIZE 16384L
 
@@ -36,7 +38,6 @@
  */
 #define PRIMARY_TSCOL_LOADED(query) ((query)->colList[0].data.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX)
 
-
 #define Q_STATUS_EQUAL(p, s) (((p) & (s)) != 0)
 #define TSDB_COL_IS_TAG(f) (((f)&TSDB_COL_TAG) != 0)
 #define QUERY_IS_ASC_QUERY(q) (GET_FORWARD_DIRECTION_FACTOR((q)->order.order) == QUERY_ASC_FORWARD_STEP)
@@ -46,16 +47,15 @@
 #define SET_SUPPLEMENT_SCAN_FLAG(runtime) ((runtime)->scanFlag = SUPPLEMENTARY_SCAN)
 #define SET_MASTER_SCAN_FLAG(runtime) ((runtime)->scanFlag = MASTER_SCAN)
 
-#define GET_QINFO_ADDR(x) ((char*)(x)-offsetof(SQInfo, runtimeEnv))
+#define GET_QINFO_ADDR(x) ((char *)(x)-offsetof(SQInfo, runtimeEnv))
 
-#define GET_COL_DATA_POS(query, index, step) ((query)->pos + (index)*(step))
+#define GET_COL_DATA_POS(query, index, step) ((query)->pos + (index) * (step))
 
 /* get the qinfo struct address from the query struct address */
 #define GET_COLUMN_BYTES(query, colidx) \
-  ((query)->colList[(query)->pSelectExpr[colidx].pBase.colInfo.colIdxInBuf].data.bytes)
+  ((query)->colList[(query)->pSelectExpr[colidx].pBase.colInfo.colIdxInBuf].info.bytes)
 #define GET_COLUMN_TYPE(query, colidx) \
-  ((query)->colList[(query)->pSelectExpr[colidx].pBase.colInfo.colIdxInBuf].data.type)
-
+  ((query)->colList[(query)->pSelectExpr[colidx].pBase.colInfo.colIdxInBuf].info.type)
 
 typedef struct SPointInterpoSupporter {
   int32_t numOfCols;
@@ -98,13 +98,10 @@ typedef enum {
   QUERY_NO_DATA_TO_CHECK = 0x8u,
 } vnodeQueryStatus;
 
-
 static void setQueryStatus(SQuery *pQuery, int8_t status);
 bool        isIntervalQuery(SQuery *pQuery) { return pQuery->intervalTime > 0; }
 
-int32_t setQueryCtxForTableQuery(void* pReadMsg, SQInfo** pQInfo) {
-
-}
+int32_t setQueryCtxForTableQuery(void *pReadMsg, SQInfo **pQInfo) {}
 
 enum {
   TS_JOIN_TS_EQUAL = 0,
@@ -112,7 +109,8 @@ enum {
   TS_JOIN_TAG_NOT_EQUALS = 2,
 };
 
-static int32_t doMergeMetersResultsToGroupRes(SQInfo *pQInfo, STableDataInfo *pTableDataInfo, int32_t start, int32_t end);
+static int32_t doMergeMetersResultsToGroupRes(SQInfo *pQInfo, STableDataInfo *pTableDataInfo, int32_t start,
+                                              int32_t end);
 
 static void setWindowResOutputBuf(SQueryRuntimeEnv *pRuntimeEnv, SWindowResult *pResult);
 
@@ -234,19 +232,19 @@ bool getNeighborPoints(SQInfo *pQInfo, void *pMeterObj, SPointInterpoSupporter *
   return true;
 }
 
-bool vnodeDoFilterData(SQuery* pQuery, int32_t elemPos) {
+bool vnodeDoFilterData(SQuery *pQuery, int32_t elemPos) {
   for (int32_t k = 0; k < pQuery->numOfFilterCols; ++k) {
     SSingleColumnFilterInfo *pFilterInfo = &pQuery->pFilterInfo[k];
-    char* pElem = pFilterInfo->pData + pFilterInfo->info.info.bytes * elemPos;
+    char *                   pElem = pFilterInfo->pData + pFilterInfo->info.info.bytes * elemPos;
 
-    if(isNull(pElem, pFilterInfo->info.info.type)) {
+    if (isNull(pElem, pFilterInfo->info.info.type)) {
       return false;
     }
 
     int32_t num = pFilterInfo->numOfFilters;
     bool    qualified = false;
-    for(int32_t j = 0; j < num; ++j) {
-      SColumnFilterElem* pFilterElem = &pFilterInfo->pFilters[j];
+    for (int32_t j = 0; j < num; ++j) {
+      SColumnFilterElem *pFilterElem = &pFilterInfo->pFilters[j];
       if (pFilterElem->fp(pFilterElem, pElem, pElem)) {
         qualified = true;
         break;
@@ -261,7 +259,7 @@ bool vnodeDoFilterData(SQuery* pQuery, int32_t elemPos) {
   return true;
 }
 
-bool vnodeFilterData(SQuery* pQuery, int32_t* numOfActualRead, int32_t index) {
+bool vnodeFilterData(SQuery *pQuery, int32_t *numOfActualRead, int32_t index) {
   (*numOfActualRead)++;
   if (!vnodeDoFilterData(pQuery, index)) {
     return false;
@@ -401,9 +399,9 @@ bool doRevisedResultsByLimit(SQInfo *pQInfo) {
 static bool queryPaused(SQuery *pQuery, SDataBlockInfo *pDataBlockInfo, int32_t forwardStep) {
   // output buffer is full, pause current query
   if (Q_STATUS_EQUAL(pQuery->status, QUERY_RESBUF_FULL)) {
-//    assert((QUERY_IS_ASC_QUERY(pQuery) && forwardStep + pQuery->pos <= pDataBlockInfo->size) ||
-//        (!QUERY_IS_ASC_QUERY(pQuery) && pQuery->pos - forwardStep + 1 >= 0));
-//    
+    //    assert((QUERY_IS_ASC_QUERY(pQuery) && forwardStep + pQuery->pos <= pDataBlockInfo->size) ||
+    //        (!QUERY_IS_ASC_QUERY(pQuery) && pQuery->pos - forwardStep + 1 >= 0));
+    //
     return true;
   }
 
@@ -429,7 +427,8 @@ static bool isTopBottomQuery(SQuery *pQuery) {
   return false;
 }
 
-static SDataStatis *getStatisInfo(SQuery *pQuery, SDataStatis *pStatis, SDataBlockInfo *pDataBlockInfo, int32_t columnIndex) {
+static SDataStatis *getStatisInfo(SQuery *pQuery, SDataStatis *pStatis, SDataBlockInfo *pDataBlockInfo,
+                                  int32_t columnIndex) {
   // no SField info exist, or column index larger than the output column, no result.
   if (pStatis == NULL) {
     return NULL;
@@ -696,7 +695,8 @@ static void doCheckQueryCompleted(SQueryRuntimeEnv *pRuntimeEnv, TSKEY lastKey,
 }
 
 static int32_t getNumOfRowsInTimeWindow(SQuery *pQuery, SDataBlockInfo *pDataBlockInfo, TSKEY *pPrimaryColumn,
-                                        int32_t startPos, TSKEY ekey, __block_search_fn_t searchFn, bool updateLastKey) {
+                                        int32_t startPos, TSKEY ekey, __block_search_fn_t searchFn,
+                                        bool updateLastKey) {
   assert(startPos >= 0 && startPos < pDataBlockInfo->size);
 
   int32_t num = -1;
@@ -743,7 +743,7 @@ static int32_t getNumOfRowsInTimeWindow(SQuery *pQuery, SDataBlockInfo *pDataBlo
 }
 
 static void doBlockwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SWindowStatus *pStatus, STimeWindow *pWin,
-                                      int32_t startPos, int32_t forwardStep, TSKEY* tsBuf) {
+                                      int32_t startPos, int32_t forwardStep, TSKEY *tsBuf) {
   SQuery *        pQuery = pRuntimeEnv->pQuery;
   SQLFunctionCtx *pCtx = pRuntimeEnv->pCtx;
 
@@ -869,10 +869,10 @@ char *getDataBlocks(SQueryRuntimeEnv *pRuntimeEnv, SArithmeticSupport *sas, int3
     for (int32_t i = 0; i < pQuery->numOfCols; ++i) {
       SColumnInfo *pColMsg = &pQuery->colList[i].info;
       assert(0);
-//      char *       pData = doGetDataBlocks(pQuery, pRuntimeEnv->colDataBuffer, pQuery->colList[i].colIdxInBuf);
+      //      char *       pData = doGetDataBlocks(pQuery, pRuntimeEnv->colDataBuffer, pQuery->colList[i].colIdxInBuf);
 
       sas->elemSize[i] = pColMsg->bytes;
-//      sas->data[i] = pData + pCtx->startOffset * sas->elemSize[i];  // start from the offset
+      //      sas->data[i] = pData + pCtx->startOffset * sas->elemSize[i];  // start from the offset
     }
 
     sas->numOfCols = pQuery->numOfCols;
@@ -930,7 +930,7 @@ static int32_t blockwiseApplyAllFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataSt
     primaryKeyCol = (TSKEY *)(pColInfo->pData);
   }
 
-  pQuery->pos = QUERY_IS_ASC_QUERY(pQuery)? 0:pDataBlockInfo->size - 1;
+  pQuery->pos = QUERY_IS_ASC_QUERY(pQuery) ? 0 : pDataBlockInfo->size - 1;
   int64_t prevNumOfRes = getNumOfResult(pRuntimeEnv);
 
   SArithmeticSupport *sasArray = calloc((size_t)pQuery->numOfOutputCols, sizeof(SArithmeticSupport));
@@ -953,9 +953,10 @@ static int32_t blockwiseApplyAllFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataSt
 
     STimeWindow win = getActiveTimeWindow(pWindowResInfo, ts, pQuery);
     assert(0);
-//    if (setWindowOutputBufByKey(pRuntimeEnv, pWindowResInfo, pRuntimeEnv->pTabObj->sid, &win) != TSDB_CODE_SUCCESS) {
-//      return 0;
-//    }
+    //    if (setWindowOutputBufByKey(pRuntimeEnv, pWindowResInfo, pRuntimeEnv->pTabObj->sid, &win) !=
+    //    TSDB_CODE_SUCCESS) {
+    //      return 0;
+    //    }
 
     TSKEY   ekey = reviseWindowEkey(pQuery, &win);
     int32_t forwardStep =
@@ -975,7 +976,7 @@ static int32_t blockwiseApplyAllFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataSt
       }
 
       // null data, failed to allocate more memory buffer
-//      int32_t sid = pRuntimeEnv->pTabObj->sid;
+      //      int32_t sid = pRuntimeEnv->pTabObj->sid;
       int32_t sid = 0;
       assert(0);
       if (setWindowOutputBufByKey(pRuntimeEnv, pWindowResInfo, sid, &nextWin) != TSDB_CODE_SUCCESS) {
@@ -1070,7 +1071,7 @@ static char *getGroupbyColumnData(SQuery *pQuery, SData **data, int16_t *type, i
     *type = pQuery->colList[colIndex].info.type;
     *bytes = pQuery->colList[colIndex].info.bytes;
 
-//    groupbyColumnData = doGetDataBlocks(pQuery, data, pQuery->colList[colIndex].inf);
+    //    groupbyColumnData = doGetDataBlocks(pQuery, data, pQuery->colList[colIndex].inf);
     break;
   }
 
@@ -1131,13 +1132,14 @@ static bool functionNeedToExecute(SQueryRuntimeEnv *pRuntimeEnv, SQLFunctionCtx
   return true;
 }
 
-static int32_t rowwiseApplyAllFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis* pStatis,
-                                        SDataBlockInfo *pDataBlockInfo, SWindowResInfo *pWindowResInfo, SArray* pDataBlock) {
+static int32_t rowwiseApplyAllFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *pStatis,
+                                        SDataBlockInfo *pDataBlockInfo, SWindowResInfo *pWindowResInfo,
+                                        SArray *pDataBlock) {
   SQLFunctionCtx *pCtx = pRuntimeEnv->pCtx;
   SQuery *        pQuery = pRuntimeEnv->pQuery;
   TSKEY *         primaryKeyCol = (TSKEY *)taosArrayGet(pDataBlock, 0);
 
-//  SData **data = pRuntimeEnv->colDataBuffer;
+  //  SData **data = pRuntimeEnv->colDataBuffer;
 
   int64_t prevNumOfRes = 0;
   bool    groupbyStateValue = isGroupbyNormalCol(pQuery->pGroupbyExpr);
@@ -1154,19 +1156,19 @@ static int32_t rowwiseApplyAllFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStat
   char *groupbyColumnData = NULL;
   if (groupbyStateValue) {
     assert(0);
-//    groupbyColumnData = getGroupbyColumnData(pQuery, data, &type, &bytes);
+    //    groupbyColumnData = getGroupbyColumnData(pQuery, data, &type, &bytes);
   }
 
   for (int32_t k = 0; k < pQuery->numOfOutputCols; ++k) {
     int32_t functionId = pQuery->pSelectExpr[k].pBase.functionId;
 
-    SDataStatis* pColStatis = NULL;
+    SDataStatis *pColStatis = NULL;
 
     bool  hasNull = hasNullValue(pQuery, k, pDataBlockInfo, pStatis, &pColStatis);
     char *dataBlock = getDataBlocks(pRuntimeEnv, &sasArray[k], k, pDataBlockInfo->size, pDataBlock);
 
-    setExecParams(pQuery, &pCtx[k], dataBlock, (char *)primaryKeyCol, pDataBlockInfo->size, functionId, pColStatis, hasNull,
-                  &sasArray[k], pRuntimeEnv->scanFlag);
+    setExecParams(pQuery, &pCtx[k], dataBlock, (char *)primaryKeyCol, pDataBlockInfo->size, functionId, pColStatis,
+                  hasNull, &sasArray[k], pRuntimeEnv->scanFlag);
   }
 
   // set the input column data
@@ -1177,7 +1179,7 @@ static int32_t rowwiseApplyAllFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStat
      * NOTE: here the tbname/tags column cannot reach here, since it will never be a filter column,
      * so we do NOT check if is a tag or not
      */
-//    pFilterInfo->pData = doGetDataBlocks(pQuery, data, pFilterInfo->info.colIdxInBuf);
+    //    pFilterInfo->pData = doGetDataBlocks(pQuery, data, pFilterInfo->info.colIdxInBuf);
   }
 
   int32_t numOfRes = 0;
@@ -1220,7 +1222,7 @@ static int32_t rowwiseApplyAllFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStat
 
       assert(0);
       int32_t ret = 0;
-//      int32_t ret = setWindowOutputBufByKey(pRuntimeEnv, pWindowResInfo, pRuntimeEnv->pTabObj->sid, &win);
+      //      int32_t ret = setWindowOutputBufByKey(pRuntimeEnv, pWindowResInfo, pRuntimeEnv->pTabObj->sid, &win);
       if (ret != TSDB_CODE_SUCCESS) {  // null data, too many state code
         continue;
       }
@@ -1235,11 +1237,12 @@ static int32_t rowwiseApplyAllFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStat
       STimeWindow nextWin = win;
       int32_t     index = pWindowResInfo->curIndex;
       assert(0);
-      int32_t     sid = 0;//pRuntimeEnv->pTabObj->sid;
+      int32_t sid = 0;  // pRuntimeEnv->pTabObj->sid;
 
       while (1) {
         getNextTimeWindow(pQuery, &nextWin);
-        if (pWindowResInfo->startTime > nextWin.skey || (nextWin.skey > pQuery->window.ekey && QUERY_IS_ASC_QUERY(pQuery)) ||
+        if (pWindowResInfo->startTime > nextWin.skey ||
+            (nextWin.skey > pQuery->window.ekey && QUERY_IS_ASC_QUERY(pQuery)) ||
             (nextWin.skey > pQuery->window.skey && !QUERY_IS_ASC_QUERY(pQuery))) {
           break;
         }
@@ -1298,7 +1301,7 @@ static int32_t rowwiseApplyAllFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStat
     if ((pQuery->checkBufferInLoop == 1) && (++numOfRes) >= pQuery->pointsOffset) {
       pQuery->lastKey = lastKey + step;
       assert(0);
-//      *forwardStep = j + 1;
+      //      *forwardStep = j + 1;
       break;
     }
   }
@@ -1479,12 +1482,10 @@ static void setWindowResultInfo(SResultInfo *pResultInfo, SQuery *pQuery, bool i
   }
 }
 
-static int32_t setupQueryRuntimeEnv(void *pMeterObj, SQuery *pQuery, SQueryRuntimeEnv *pRuntimeEnv,
-                                    SColumnModel *pTagsSchema, int16_t order, bool isSTableQuery) {
-  dTrace("QInfo:%p setup runtime env", GET_QINFO_ADDR(pQuery));
-  
-  pRuntimeEnv->pTabObj = pMeterObj;
-  pRuntimeEnv->pQuery = pQuery;
+static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, SColumnModel *pTagsSchema, int16_t order,
+                                    bool isSTableQuery) {
+  dTrace("QInfo:%p setup runtime env", GET_QINFO_ADDR(pRuntimeEnv));
+  SQuery *pQuery = pRuntimeEnv->pQuery;
 
   pRuntimeEnv->resultInfo = calloc(pQuery->numOfOutputCols, sizeof(SResultInfo));
   pRuntimeEnv->pCtx = (SQLFunctionCtx *)calloc(pQuery->numOfOutputCols, sizeof(SQLFunctionCtx));
@@ -1506,9 +1507,8 @@ static int32_t setupQueryRuntimeEnv(void *pMeterObj, SQuery *pQuery, SQueryRunti
       pCtx->inputType = pSchema->type;
       pCtx->inputBytes = pSchema->bytes;
     } else {
-      assert(0);
-//      pCtx->inputType = GET_COLUMN_TYPE(pQuery, i);
-//      pCtx->inputBytes = GET_COLUMN_BYTES(pQuery, i);
+      pCtx->inputType = GET_COLUMN_TYPE(pQuery, i);
+      pCtx->inputBytes = GET_COLUMN_BYTES(pQuery, i);
     }
 
     pCtx->ptsOutputBuf = NULL;
@@ -1559,12 +1559,9 @@ static int32_t setupQueryRuntimeEnv(void *pMeterObj, SQuery *pQuery, SQueryRunti
   }
 
   setCtxTagColumnInfo(pQuery, pRuntimeEnv->pCtx);
-  
-  // for loading block data in memory
-//  assert(vnodeList[pMeterObj->vnode].cfg.rowsInFileBlock == pMeterObj->pointsPerFileBlock);
   return TSDB_CODE_SUCCESS;
 
-  _error_clean:
+_error_clean:
   tfree(pRuntimeEnv->resultInfo);
   tfree(pRuntimeEnv->pCtx);
 
@@ -1725,7 +1722,7 @@ bool needSupplementaryScan(SQuery *pQuery) {
 /////////////////////////////////////////////////////////////////////////////////////////////
 
 void doGetAlignedIntervalQueryRangeImpl(SQuery *pQuery, int64_t key, int64_t keyFirst, int64_t keyLast,
-                                        int64_t *realSkey, int64_t *realEkey, STimeWindow* win) {
+                                        int64_t *realSkey, int64_t *realEkey, STimeWindow *win) {
   assert(key >= keyFirst && key <= keyLast && pQuery->slidingTime <= pQuery->intervalTime);
 
   win->skey = taosGetIntervalStartTimestamp(key, pQuery->slidingTime, pQuery->slidingTimeUnit, pQuery->precision);
@@ -1782,8 +1779,8 @@ static bool doGetQueryPos(TSKEY key, SQInfo *pQInfo, SPointInterpoSupporter *pPo
 #endif
 }
 
-static bool doSetDataInfo(SQInfo *pQInfo, SPointInterpoSupporter *pPointInterpSupporter,
-                          void *pMeterObj, TSKEY nextKey) {
+static bool doSetDataInfo(SQInfo *pQInfo, SPointInterpoSupporter *pPointInterpSupporter, void *pMeterObj,
+                          TSKEY nextKey) {
   SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
   SQuery *          pQuery = pRuntimeEnv->pQuery;
 
@@ -1793,8 +1790,8 @@ static bool doSetDataInfo(SQInfo *pQInfo, SPointInterpoSupporter *pPointInterpSu
      * the query range is existed, so set them both the value of nextKey
      */
     if (pQuery->window.skey != pQuery->window.ekey) {
-      assert(pQuery->window.skey >= pQuery->window.ekey && !QUERY_IS_ASC_QUERY(pQuery) && nextKey >= pQuery->window.ekey &&
-          nextKey <= pQuery->window.skey);
+      assert(pQuery->window.skey >= pQuery->window.ekey && !QUERY_IS_ASC_QUERY(pQuery) &&
+             nextKey >= pQuery->window.ekey && nextKey <= pQuery->window.skey);
 
       pQuery->window.skey = nextKey;
       pQuery->window.ekey = nextKey;
@@ -1895,8 +1892,7 @@ static void setScanLimitationByResultBuffer(SQuery *pQuery) {
     pQuery->checkBufferInLoop = hasMultioutput ? 1 : 0;
   }
 
-  assert(0);
-//  pQuery->pointsOffset = pQuery->pointsToRead;
+  //  pQuery->pointsOffset = pQuery->pointsToRead;
 }
 
 /*
@@ -1960,8 +1956,8 @@ static void changeExecuteScanOrder(SQuery *pQuery, bool metricQuery) {
 
   if (isPointInterpoQuery(pQuery) && pQuery->intervalTime == 0) {
     if (!QUERY_IS_ASC_QUERY(pQuery)) {
-      dTrace(msg, GET_QINFO_ADDR(pQuery), "interp", pQuery->order.order, TSQL_SO_ASC, pQuery->window.skey, pQuery->window.ekey,
-             pQuery->window.ekey, pQuery->window.skey);
+      dTrace(msg, GET_QINFO_ADDR(pQuery), "interp", pQuery->order.order, TSQL_SO_ASC, pQuery->window.skey,
+             pQuery->window.ekey, pQuery->window.ekey, pQuery->window.skey);
       SWAP(pQuery->window.skey, pQuery->window.ekey, TSKEY);
     }
 
@@ -1972,8 +1968,8 @@ static void changeExecuteScanOrder(SQuery *pQuery, bool metricQuery) {
   if (pQuery->intervalTime == 0) {
     if (onlyFirstQuery(pQuery)) {
       if (!QUERY_IS_ASC_QUERY(pQuery)) {
-        dTrace(msg, GET_QINFO_ADDR(pQuery), "only-first", pQuery->order.order, TSQL_SO_ASC, pQuery->window.skey, pQuery->window.ekey,
-               pQuery->window.ekey, pQuery->window.skey);
+        dTrace(msg, GET_QINFO_ADDR(pQuery), "only-first", pQuery->order.order, TSQL_SO_ASC, pQuery->window.skey,
+               pQuery->window.ekey, pQuery->window.ekey, pQuery->window.skey);
 
         SWAP(pQuery->window.skey, pQuery->window.ekey, TSKEY);
       }
@@ -1981,8 +1977,8 @@ static void changeExecuteScanOrder(SQuery *pQuery, bool metricQuery) {
       pQuery->order.order = TSQL_SO_ASC;
     } else if (onlyLastQuery(pQuery)) {
       if (QUERY_IS_ASC_QUERY(pQuery)) {
-        dTrace(msg, GET_QINFO_ADDR(pQuery), "only-last", pQuery->order.order, TSQL_SO_DESC, pQuery->window.skey, pQuery->window.ekey,
-               pQuery->window.ekey, pQuery->window.skey);
+        dTrace(msg, GET_QINFO_ADDR(pQuery), "only-last", pQuery->order.order, TSQL_SO_DESC, pQuery->window.skey,
+               pQuery->window.ekey, pQuery->window.ekey, pQuery->window.skey);
 
         SWAP(pQuery->window.skey, pQuery->window.ekey, TSKEY);
       }
@@ -1994,8 +1990,8 @@ static void changeExecuteScanOrder(SQuery *pQuery, bool metricQuery) {
     if (metricQuery) {
       if (onlyFirstQuery(pQuery)) {
         if (!QUERY_IS_ASC_QUERY(pQuery)) {
-          dTrace(msg, GET_QINFO_ADDR(pQuery), "only-first stable", pQuery->order.order, TSQL_SO_ASC, pQuery->window.skey,
-                 pQuery->window.ekey, pQuery->window.ekey, pQuery->window.skey);
+          dTrace(msg, GET_QINFO_ADDR(pQuery), "only-first stable", pQuery->order.order, TSQL_SO_ASC,
+                 pQuery->window.skey, pQuery->window.ekey, pQuery->window.ekey, pQuery->window.skey);
 
           SWAP(pQuery->window.skey, pQuery->window.ekey, TSKEY);
         }
@@ -2003,8 +1999,8 @@ static void changeExecuteScanOrder(SQuery *pQuery, bool metricQuery) {
         pQuery->order.order = TSQL_SO_ASC;
       } else if (onlyLastQuery(pQuery)) {
         if (QUERY_IS_ASC_QUERY(pQuery)) {
-          dTrace(msg, GET_QINFO_ADDR(pQuery), "only-last stable", pQuery->order.order, TSQL_SO_DESC, pQuery->window.skey,
-                 pQuery->window.ekey, pQuery->window.ekey, pQuery->window.skey);
+          dTrace(msg, GET_QINFO_ADDR(pQuery), "only-last stable", pQuery->order.order, TSQL_SO_DESC,
+                 pQuery->window.skey, pQuery->window.ekey, pQuery->window.ekey, pQuery->window.skey);
 
           SWAP(pQuery->window.skey, pQuery->window.ekey, TSKEY);
         }
@@ -2081,7 +2077,7 @@ static void doSetInterpVal(SQLFunctionCtx *pCtx, TSKEY ts, int16_t type, int32_t
  */
 void pointInterpSupporterSetData(SQInfo *pQInfo, SPointInterpoSupporter *pPointInterpSupport) {
   SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
-  SQuery *pQuery = pRuntimeEnv->pQuery;
+  SQuery *          pQuery = pRuntimeEnv->pQuery;
 
   // not point interpolation query, abort
   if (!isPointInterpoQuery(pQuery)) {
@@ -2154,7 +2150,7 @@ void pointInterpSupporterSetData(SQInfo *pQInfo, SPointInterpoSupporter *pPointI
         pInterpInfo->pInterpDetail = calloc(1, sizeof(SInterpInfoDetail));
         SInterpInfoDetail *pInterpDetail = pInterpInfo->pInterpDetail;
 
-//        int32_t type = GET_COLUMN_TYPE(pQuery, i);
+        //        int32_t type = GET_COLUMN_TYPE(pQuery, i);
         int32_t type = 0;
         assert(0);
 
@@ -2188,7 +2184,7 @@ void pointInterpSupporterInit(SQuery *pQuery, SPointInterpoSupporter *pInterpoSu
       len += pQuery->colList[i].info.bytes;
     }
 
-//    assert(PRIMARY_TSCOL_LOADED(pQuery));
+    //    assert(PRIMARY_TSCOL_LOADED(pQuery));
 
     void *prev = calloc(1, len);
     void *next = calloc(1, len);
@@ -2244,10 +2240,10 @@ static int32_t getInitialPageNum(SQInfo *pQInfo) {
   if (isGroupbyNormalCol(pQuery->pGroupbyExpr)) {
     num = 128;
   } else if (isIntervalQuery(pQuery)) {  // time window query, allocate one page for each table
-    size_t s = taosHashGetSize(pQInfo->pTableList);
+    size_t s = taosArrayGetSize(pQInfo->pTableIdList);
     num = MAX(s, INITIAL_RESULT_ROWS_VALUE);
   } else {  // for super table query, one page for each subset
-    num = pQInfo->pSidSet->numOfSubSet;
+            //    num = pQInfo->pSidSet->numOfSubSet;
   }
 
   assert(num > 0);
@@ -2291,16 +2287,11 @@ void vnodeQueryFreeQInfoEx(SQInfo *pQInfo) {
 
   teardownQueryRuntimeEnv(&pQInfo->runtimeEnv);
 
-  if (pQInfo->pTableList != NULL) {
-    taosHashCleanup(pQInfo->pTableList);
-    pQInfo->pTableList = NULL;
-  }
-  
-//  tSidSetDestroy(&pQInfo->pSidSet);
+  //  tSidSetDestroy(&pQInfo->pSidSet);
 
   if (pQInfo->pTableDataInfo != NULL) {
-    size_t num = taosHashGetSize(pQInfo->pTableList);
-    for (int32_t j = 0; j < num; ++j) {
+    //    size_t num = taosHashGetSize(pQInfo->pTableIdList);
+    for (int32_t j = 0; j < 0; ++j) {
       destroyMeterQueryInfo(pQInfo->pTableDataInfo[j].pTableQInfo, pQuery->numOfOutputCols);
     }
   }
@@ -2311,19 +2302,19 @@ void vnodeQueryFreeQInfoEx(SQInfo *pQInfo) {
 int32_t vnodeSTableQueryPrepare(SQInfo *pQInfo, SQuery *pQuery, void *param) {
   if ((QUERY_IS_ASC_QUERY(pQuery) && (pQuery->window.skey > pQuery->window.ekey)) ||
       (!QUERY_IS_ASC_QUERY(pQuery) && (pQuery->window.ekey > pQuery->window.skey))) {
-    dTrace("QInfo:%p no result in time range %" PRId64 "-%" PRId64 ", order %d", pQInfo, pQuery->window.skey, pQuery->window.ekey,
-           pQuery->order.order);
+    dTrace("QInfo:%p no result in time range %" PRId64 "-%" PRId64 ", order %d", pQInfo, pQuery->window.skey,
+           pQuery->window.ekey, pQuery->order.order);
 
     sem_post(&pQInfo->dataReady);
-//    pQInfo->over = 1;
+    //    pQInfo->over = 1;
 
     return TSDB_CODE_SUCCESS;
   }
 
   pQuery->status = 0;
 
-  pQInfo->rec = (SResultRec) {0};
-  pQuery->rec = (SResultRec) {0};
+  pQInfo->rec = (SResultRec){0};
+  pQuery->rec = (SResultRec){0};
 
   changeExecuteScanOrder(pQuery, true);
   SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
@@ -2338,11 +2329,11 @@ int32_t vnodeSTableQueryPrepare(SQInfo *pQInfo, SQuery *pQuery, void *param) {
   pQuery->lastKey = pQuery->window.skey;
 
   // create runtime environment
-  SColumnModel *pTagSchemaInfo = pQInfo->pSidSet->pColumnModel;
+  //  SColumnModel *pTagSchemaInfo = pQInfo->pSidSet->pColumnModel;
 
   // get one queried meter
   assert(0);
-//  SMeterObj *pMeter = getMeterObj(pQInfo->pTableList, pQInfo->pSidSet->pSids[0]->sid);
+  //  SMeterObj *pMeter = getMeterObj(pQInfo->pTableIdList, pQInfo->pSidSet->pTableIdList[0]->sid);
 
   pRuntimeEnv->pTSBuf = param;
   pRuntimeEnv->cur.vnodeIndex = -1;
@@ -2354,12 +2345,12 @@ int32_t vnodeSTableQueryPrepare(SQInfo *pQInfo, SQuery *pQuery, void *param) {
   }
 
   assert(0);
-//  int32_t ret = setupQueryRuntimeEnv(pMeter, pQuery, &pQInfo->runtimeEnv, pTagSchemaInfo, TSQL_SO_ASC, true);
-//  if (ret != TSDB_CODE_SUCCESS) {
-//    return ret;
-//  }
+  //  int32_t ret = setupQueryRuntimeEnv(pMeter, pQuery, &pQInfo->runtimeEnv, pTagSchemaInfo, TSQL_SO_ASC, true);
+  //  if (ret != TSDB_CODE_SUCCESS) {
+  //    return ret;
+  //  }
 
-//  tSidSetSort(pQInfo->pSidSet);
+  //  tSidSetSort(pQInfo->pSidSet);
 
   int32_t size = getInitialPageNum(pQInfo);
   int32_t ret = createDiskbasedResultBuffer(&pRuntimeEnv->pResultBuf, size, pQuery->rowSize);
@@ -2388,25 +2379,25 @@ int32_t vnodeSTableQueryPrepare(SQInfo *pQInfo, SQuery *pQuery, void *param) {
   cond.colList = *pQuery->colList;
   SArray *sa = taosArrayInit(1, POINTER_BYTES);
 
-  for(int32_t i = 0; i < pQInfo->pSidSet->numOfSids; ++i) {
-//    SMeterObj *p1 = getMeterObj(pQInfo->pTableList, pQInfo->pSidSet->pSids[i]->sid);
-//    taosArrayPush(sa, &p1);
-  }
+  //  for(int32_t i = 0; i < pQInfo->pSidSet->numOfTables; ++i) {
+  //    SMeterObj *p1 = getMeterObj(pQInfo->pTableIdList, pQInfo->pSidSet->pTableIdList[i]->sid);
+  //    taosArrayPush(sa, &p1);
+  //  }
 
   SArray *cols = taosArrayInit(pQuery->numOfCols, sizeof(pQuery->colList[0]));
   for (int32_t i = 0; i < pQuery->numOfCols; ++i) {
     taosArrayPush(cols, &pQuery->colList[i]);
   }
 
-  pRuntimeEnv->pQueryHandle = tsdbQueryByTableId(&cond, sa, cols);
+  pRuntimeEnv->pQueryHandle = tsdbQueryByTableId(NULL, &cond, sa, cols);
 
   // metric query do not invoke interpolation, it will be done at the second-stage merge
   if (!isPointInterpoQuery(pQuery)) {
     pQuery->interpoType = TSDB_INTERPO_NONE;
   }
 
-  TSKEY revisedStime = taosGetIntervalStartTimestamp(pQuery->window.skey, pQuery->intervalTime,
-                                                     pQuery->slidingTimeUnit, pQuery->precision);
+  TSKEY revisedStime = taosGetIntervalStartTimestamp(pQuery->window.skey, pQuery->intervalTime, pQuery->slidingTimeUnit,
+                                                     pQuery->precision);
   taosInitInterpoInfo(&pRuntimeEnv->interpoInfo, pQuery->order.order, revisedStime, 0, 0);
   pRuntimeEnv->stableQuery = true;
 
@@ -2419,7 +2410,7 @@ int32_t vnodeSTableQueryPrepare(SQInfo *pQInfo, SQuery *pQuery, void *param) {
  */
 void vnodeDecMeterRefcnt(SQInfo *pQInfo) {
   if (pQInfo != NULL) {
-    assert(taosHashGetSize(pQInfo->pTableList) >= 1);
+    //    assert(taosHashGetSize(pQInfo->pTableIdList) >= 1);
   }
 
 #if 0
@@ -2430,7 +2421,7 @@ void vnodeDecMeterRefcnt(SQInfo *pQInfo) {
   } else {
     int32_t num = 0;
     for (int32_t i = 0; i < pQInfo->numOfMeters; ++i) {
-      SMeterObj *pMeter = getMeterObj(pQInfo->pTableList, pQInfo->pSidSet->pSids[i]->sid);
+      SMeterObj *pMeter = getMeterObj(pQInfo->pTableIdList, pQInfo->pSidSet->pTableIdList[i]->sid);
       atomic_fetch_sub_32(&(pMeter->numOfQueries), 1);
       
       if (pMeter->numOfQueries > 0) {
@@ -2532,14 +2523,14 @@ static void getNextTimeWindow(SQuery *pQuery, STimeWindow *pTimeWindow) {
   pTimeWindow->ekey = pTimeWindow->skey + (pQuery->intervalTime - 1);
 }
 
-SArray* loadDataBlockOnDemand(SQueryRuntimeEnv* pRuntimeEnv, SDataBlockInfo* pBlockInfo, SDataStatis** pStatis) {
-  SQuery* pQuery = pRuntimeEnv->pQuery;
+SArray *loadDataBlockOnDemand(SQueryRuntimeEnv *pRuntimeEnv, SDataBlockInfo *pBlockInfo, SDataStatis **pStatis) {
+  SQuery *            pQuery = pRuntimeEnv->pQuery;
   tsdb_query_handle_t pQueryHandle = pRuntimeEnv->pQueryHandle;
 
   uint32_t r = 0;
   SArray * pDataBlock = NULL;
 
-//  STimeWindow *w = &pQueryHandle->window;
+  //  STimeWindow *w = &pQueryHandle->window;
 
   if (pQuery->numOfFilterCols > 0) {
     r = BLK_DATA_ALL_NEEDED;
@@ -2548,7 +2539,7 @@ SArray* loadDataBlockOnDemand(SQueryRuntimeEnv* pRuntimeEnv, SDataBlockInfo* pBl
       int32_t functionId = pQuery->pSelectExpr[i].pBase.functionId;
       int32_t colId = pQuery->pSelectExpr[i].pBase.colInfo.colId;
 
-//      r |= aAggs[functionId].dataReqFunc(&pRuntimeEnv->pCtx[i], w->skey, w->ekey, colId);
+      //      r |= aAggs[functionId].dataReqFunc(&pRuntimeEnv->pCtx[i], w->skey, w->ekey, colId);
     }
 
     if (pRuntimeEnv->pTSBuf > 0 || isIntervalQuery(pQuery)) {
@@ -2593,15 +2584,72 @@ SArray* loadDataBlockOnDemand(SQueryRuntimeEnv* pRuntimeEnv, SDataBlockInfo* pBl
   return pDataBlock;
 }
 
+int32_t binarySearchForKey(char *pValue, int num, TSKEY key, int order) {
+  int    firstPos, lastPos, midPos = -1;
+  int    numOfPoints;
+  TSKEY *keyList;
+
+  if (num <= 0) return -1;
+
+  keyList = (TSKEY *)pValue;
+  firstPos = 0;
+  lastPos = num - 1;
+
+  if (order == 0) {
+    // find the first position which is smaller than the key
+    while (1) {
+      if (key >= keyList[lastPos]) return lastPos;
+      if (key == keyList[firstPos]) return firstPos;
+      if (key < keyList[firstPos]) return firstPos - 1;
+
+      numOfPoints = lastPos - firstPos + 1;
+      midPos = (numOfPoints >> 1) + firstPos;
+
+      if (key < keyList[midPos]) {
+        lastPos = midPos - 1;
+      } else if (key > keyList[midPos]) {
+        firstPos = midPos + 1;
+      } else {
+        break;
+      }
+    }
+
+  } else {
+    // find the first position which is bigger than the key
+    while (1) {
+      if (key <= keyList[firstPos]) return firstPos;
+      if (key == keyList[lastPos]) return lastPos;
+
+      if (key > keyList[lastPos]) {
+        lastPos = lastPos + 1;
+        if (lastPos >= num)
+          return -1;
+        else
+          return lastPos;
+      }
+
+      numOfPoints = lastPos - firstPos + 1;
+      midPos = (numOfPoints >> 1) + firstPos;
+
+      if (key < keyList[midPos]) {
+        lastPos = midPos - 1;
+      } else if (key > keyList[midPos]) {
+        firstPos = midPos + 1;
+      } else {
+        break;
+      }
+    }
+  }
+
+  return midPos;
+}
+
 static int64_t doScanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
-#if 0
   SQuery *pQuery = pRuntimeEnv->pQuery;
-  assert(0);
-//  __block_search_fn_t searchFn = vnodeSearchKeyFunc[pRuntimeEnv->pTabObj->searchAlgorithm];
 
   int64_t cnt = 0;
-  dTrace("QInfo:%p query start, qrange:%" PRId64 "-%" PRId64 ", lastkey:%" PRId64 ", order:%d", GET_QINFO_ADDR(pQuery),
-         pQuery->window.skey, pQuery->window.ekey, pQuery->lastKey, pQuery->order.order);
+  dTrace("QInfo:%p query start, qrange:%" PRId64 "-%" PRId64 ", lastkey:%" PRId64 ", order:%d",
+         GET_QINFO_ADDR(pRuntimeEnv), pQuery->window.skey, pQuery->window.ekey, pQuery->lastKey, pQuery->order.order);
 
   tsdb_query_handle_t pQueryHandle = pRuntimeEnv->pQueryHandle;
 
@@ -2617,20 +2665,20 @@ static int64_t doScanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
     if (isIntervalQuery(pQuery) && pRuntimeEnv->windowResInfo.prevSKey == 0) {
       TSKEY           skey1, ekey1;
       STimeWindow     w = {0};
-      SWindowResInfo* pWindowResInfo = &pRuntimeEnv->windowResInfo;
+      SWindowResInfo *pWindowResInfo = &pRuntimeEnv->windowResInfo;
 
       if (QUERY_IS_ASC_QUERY(pQuery)) {
-//        doGetAlignedIntervalQueryRangeImpl(pQuery, blockInfo.window.skey, blockInfo.window.skey,
-//                                           pQueryHandle->window.ekey, &skey1, &ekey1, &w);
+        doGetAlignedIntervalQueryRangeImpl(pQuery, blockInfo.window.skey, blockInfo.window.skey, pQuery->window.ekey,
+                                           &skey1, &ekey1, &w);
         pWindowResInfo->startTime = w.skey;
         pWindowResInfo->prevSKey = w.skey;
       } else {
         // the start position of the first time window in the endpoint that spreads beyond the queried last timestamp
         TSKEY winStart = blockInfo.window.ekey - pQuery->intervalTime;
-//        doGetAlignedIntervalQueryRangeImpl(pQuery, winStart, pQueryHandle->window.ekey,
-//                                           blockInfo.window.ekey, &skey1, &ekey1, &w);
+        doGetAlignedIntervalQueryRangeImpl(pQuery, winStart, pQuery->window.ekey, blockInfo.window.ekey, &skey1, &ekey1,
+                                           &w);
 
-//        pWindowResInfo->startTime = pQueryHandle->window.skey;
+        pWindowResInfo->startTime = pQuery->window.skey;
         pWindowResInfo->prevSKey = w.skey;
       }
     }
@@ -2638,21 +2686,19 @@ static int64_t doScanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
     int32_t numOfRes = 0;
 
     SDataStatis *pStatis = NULL;
-    SArray *pDataBlock = loadDataBlockOnDemand(pRuntimeEnv, &blockInfo, &pStatis);
-//    int32_t forwardStep = tableApplyFunctionsOnBlock(pRuntimeEnv, &blockInfo, pStatis, searchFn, &numOfRes,
-//                                                     &pRuntimeEnv->windowResInfo, pDataBlock);
+    SArray *     pDataBlock = loadDataBlockOnDemand(pRuntimeEnv, &blockInfo, &pStatis);
+    int32_t forwardStep = tableApplyFunctionsOnBlock(pRuntimeEnv, &blockInfo, pStatis, binarySearchForKey, &numOfRes,
+                                                     &pRuntimeEnv->windowResInfo, pDataBlock);
 
-//    dTrace("QInfo:%p check data block, brange:%" PRId64 "-%" PRId64 ", fileId:%d, slot:%d, pos:%d, rows:%d, checked:%d",
-//           GET_QINFO_ADDR(pQuery), blockInfo.window.skey, blockInfo.window.ekey, pQueryHandle->cur.fileId, pQueryHandle->cur.slot,
-//           pQuery->pos, blockInfo.size, forwardStep);
+    //    dTrace("QInfo:%p check data block, brange:%" PRId64 "-%" PRId64 ", fileId:%d, slot:%d, pos:%d, rows:%d,
+    //    checked:%d",
+    //           GET_QINFO_ADDR(pQuery), blockInfo.window.skey, blockInfo.window.ekey, pQueryHandle->cur.fileId,
+    //           pQueryHandle->cur.slot, pQuery->pos, blockInfo.size, forwardStep);
 
     // save last access position
-//    cnt += forwardStep;
-    
-//    if (queryPaused(pQuery, &blockInfo, forwardStep)) {
-//      if (Q_STATUS_EQUAL(pQuery->status, QUERY_RESBUF_FULL)) {
-//        break;
-//      }
+    cnt += forwardStep;
+    if (Q_STATUS_EQUAL(pQuery->status, QUERY_RESBUF_FULL)) {
+      break;
     }
   }
 
@@ -2663,7 +2709,7 @@ static int64_t doScanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
 
   if (isIntervalQuery(pQuery) && IS_MASTER_SCAN(pRuntimeEnv)) {
     if (Q_STATUS_EQUAL(pQuery->status, QUERY_COMPLETED | QUERY_NO_DATA_TO_CHECK)) {
-      int32_t step = QUERY_IS_ASC_QUERY(pQuery)? QUERY_ASC_FORWARD_STEP:QUERY_DESC_FORWARD_STEP;
+      int32_t step = QUERY_IS_ASC_QUERY(pQuery) ? QUERY_ASC_FORWARD_STEP : QUERY_DESC_FORWARD_STEP;
 
       closeAllTimeWindow(&pRuntimeEnv->windowResInfo);
       removeRedundantWindow(&pRuntimeEnv->windowResInfo, pQuery->lastKey - step, step);
@@ -2674,8 +2720,6 @@ static int64_t doScanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
   }
 
   return cnt;
-#endif
-  return 0;
 }
 
 static void updatelastkey(SQuery *pQuery, STableQueryInfo *pTableQInfo) { pTableQInfo->lastKey = pQuery->lastKey; }
@@ -2684,8 +2728,7 @@ static void updatelastkey(SQuery *pQuery, STableQueryInfo *pTableQInfo) { pTable
  * set tag value in SQLFunctionCtx
  * e.g.,tag information into input buffer
  */
-static void doSetTagValueInParam(SColumnModel *pTagSchema, int32_t tagColIdx, void *pMeterSidInfo,
-                                 tVariant *param) {
+static void doSetTagValueInParam(SColumnModel *pTagSchema, int32_t tagColIdx, void *pMeterSidInfo, tVariant *param) {
   assert(tagColIdx >= 0);
 #if 0
   int16_t offset = getColumnModelOffset(pTagSchema, tagColIdx);
@@ -2886,9 +2929,9 @@ void UNUSED_FUNC displayInterResult(SData **pdata, SQuery *pQuery, int32_t numOf
 }
 
 typedef struct SCompSupporter {
-  STableDataInfo **      pTableDataInfo;
+  STableDataInfo **pTableDataInfo;
   int32_t *        position;
-  SQInfo *pQInfo;
+  SQInfo *         pQInfo;
 } SCompSupporter;
 
 int32_t tableResultComparFn(const void *pLeft, const void *pRight, void *param) {
@@ -2937,29 +2980,30 @@ int32_t mergeMetersResultToOneGroups(SQInfo *pQInfo) {
   int64_t st = taosGetTimestampMs();
   int32_t ret = TSDB_CODE_SUCCESS;
 
-  while (pQInfo->subgroupIdx < pQInfo->pSidSet->numOfSubSet) {
-    int32_t start = pQInfo->pSidSet->starterPos[pQInfo->subgroupIdx];
-    int32_t end = pQInfo->pSidSet->starterPos[pQInfo->subgroupIdx + 1];
-    
-    assert(0);
-//    ret = doMergeMetersResultsToGroupRes(pQInfo, pQuery, pRuntimeEnv, pQInfo->pTableDataInfo, start, end);
-    if (ret < 0) {  // not enough disk space to save the data into disk
-      return -1;
-    }
-    
-    pQInfo->subgroupIdx += 1;
-    
-    // this group generates at least one result, return results
-    if (ret > 0) {
-      break;
-    }
-    
-    assert(pQInfo->numOfGroupResultPages == 0);
-    dTrace("QInfo:%p no result in group %d, continue", GET_QINFO_ADDR(pQuery), pQInfo->subgroupIdx - 1);
-  }
-  
-  dTrace("QInfo:%p merge res data into group, index:%d, total group:%d, elapsed time:%lldms", GET_QINFO_ADDR(pQuery),
-         pQInfo->subgroupIdx - 1, pQInfo->pSidSet->numOfSubSet, taosGetTimestampMs() - st);
+  //  while (pQInfo->subgroupIdx < pQInfo->pSidSet->numOfSubSet) {
+  //    int32_t start = pQInfo->pSidSet->starterPos[pQInfo->subgroupIdx];
+  //    int32_t end = pQInfo->pSidSet->starterPos[pQInfo->subgroupIdx + 1];
+  //
+  //    assert(0);
+  //    //    ret = doMergeMetersResultsToGroupRes(pQInfo, pQuery, pRuntimeEnv, pQInfo->pTableDataInfo, start, end);
+  //    if (ret < 0) {  // not enough disk space to save the data into disk
+  //      return -1;
+  //    }
+  //
+  //    pQInfo->subgroupIdx += 1;
+  //
+  //    // this group generates at least one result, return results
+  //    if (ret > 0) {
+  //      break;
+  //    }
+  //
+  //    assert(pQInfo->numOfGroupResultPages == 0);
+  //    dTrace("QInfo:%p no result in group %d, continue", GET_QINFO_ADDR(pQuery), pQInfo->subgroupIdx - 1);
+  //  }
+  //
+  //  dTrace("QInfo:%p merge res data into group, index:%d, total group:%d, elapsed time:%lldms",
+  //  GET_QINFO_ADDR(pQuery),
+  //         pQInfo->subgroupIdx - 1, pQInfo->pSidSet->numOfSubSet, taosGetTimestampMs() - st);
 
   return TSDB_CODE_SUCCESS;
 }
@@ -2974,10 +3018,10 @@ void copyResToQueryResultBuf(SQInfo *pQInfo, SQuery *pQuery) {
     }
 
     // set current query completed
-    if (pQInfo->numOfGroupResultPages == 0 && pQInfo->subgroupIdx == pQInfo->pSidSet->numOfSubSet) {
-      pQInfo->tableIndex = pQInfo->pSidSet->numOfSids;
-      return;
-    }
+    //    if (pQInfo->numOfGroupResultPages == 0 && pQInfo->subgroupIdx == pQInfo->pSidSet->numOfSubSet) {
+    //      pQInfo->tableIndex = pQInfo->pSidSet->numOfTables;
+    //      return;
+    //    }
   }
 
   SQueryRuntimeEnv *   pRuntimeEnv = &pQInfo->runtimeEnv;
@@ -3040,8 +3084,8 @@ int64_t getNumOfResultWindowRes(SQueryRuntimeEnv *pRuntimeEnv, SWindowResult *pW
 }
 
 int32_t doMergeMetersResultsToGroupRes(SQInfo *pQInfo, STableDataInfo *pTableDataInfo, int32_t start, int32_t end) {
-  SQueryRuntimeEnv* pRuntimeEnv = &pQInfo->runtimeEnv;
-  SQuery* pQuery = pQInfo->runtimeEnv.pQuery;
+  SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
+  SQuery *          pQuery = pQInfo->runtimeEnv.pQuery;
 
   tFilePage **     buffer = (tFilePage **)pQuery->sdata;
   int32_t *        posList = calloc((end - start), sizeof(int32_t));
@@ -3107,13 +3151,13 @@ int32_t doMergeMetersResultsToGroupRes(SQInfo *pQInfo, STableDataInfo *pTableDat
         doMerge(pRuntimeEnv, ts, pWindowRes, true);
       } else {  // copy data to disk buffer
         assert(0);
-//        if (buffer[0]->numOfElems == pQuery->pointsToRead) {
-//          if (flushFromResultBuf(pQInfo) != TSDB_CODE_SUCCESS) {
-//            return -1;
-//          }
+        //        if (buffer[0]->numOfElems == pQuery->pointsToRead) {
+        //          if (flushFromResultBuf(pQInfo) != TSDB_CODE_SUCCESS) {
+        //            return -1;
+        //          }
 
-//          resetMergeResultBuf(pQuery, pRuntimeEnv->pCtx, pResultInfo);
-//        }
+        //          resetMergeResultBuf(pQuery, pRuntimeEnv->pCtx, pResultInfo);
+        //        }
 
         doMerge(pRuntimeEnv, ts, pWindowRes, false);
         buffer[0]->numOfElems += 1;
@@ -3169,8 +3213,8 @@ int32_t doMergeMetersResultsToGroupRes(SQInfo *pQInfo, STableDataInfo *pTableDat
 }
 
 int32_t flushFromResultBuf(SQInfo *pQInfo) {
-  SQueryRuntimeEnv* pRuntimeEnv = &pQInfo->runtimeEnv;
-  SQuery* pQuery = pRuntimeEnv->pQuery;
+  SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
+  SQuery *          pQuery = pRuntimeEnv->pQuery;
 
   SDiskbasedResultBuf *pResultBuf = pRuntimeEnv->pResultBuf;
   int32_t              capacity = (DEFAULT_INTERN_BUF_SIZE - sizeof(tFilePage)) / pQuery->rowSize;
@@ -3284,7 +3328,7 @@ void disableFunctForSuppleScan(SQInfo *pQInfo, int32_t order) {
   }
 
   if (isIntervalQuery(pQuery)) {
-    size_t numOfTables = taosHashGetSize(pQInfo->pTableList);
+    size_t numOfTables = taosArrayGetSize(pQInfo->pTableIdList);
 
     for (int32_t i = 0; i < numOfTables; ++i) {
       STableQueryInfo *pTableQueryInfo = pQInfo->pTableDataInfo[i].pTableQInfo;
@@ -3322,7 +3366,6 @@ void createQueryResultInfo(SQuery *pQuery, SWindowResult *pResultRow, bool isSTa
 
 void resetCtxOutputBuf(SQueryRuntimeEnv *pRuntimeEnv) {
   SQuery *pQuery = pRuntimeEnv->pQuery;
-//  int32_t rows = pRuntimeEnv->pTabObj->pointsPerFileBlock;
 
   for (int32_t i = 0; i < pQuery->numOfOutputCols; ++i) {
     SQLFunctionCtx *pCtx = &pRuntimeEnv->pCtx[i];
@@ -3341,8 +3384,7 @@ void resetCtxOutputBuf(SQueryRuntimeEnv *pRuntimeEnv) {
       pCtx->ptsOutputBuf = pRuntimeEnv->pCtx[0].aOutputBuf;
     }
 
-    assert(0);
-//    memset(pQuery->sdata[i]->data, 0, (size_t)pQuery->pSelectExpr[i].resBytes * rows);
+    memset(pQuery->sdata[i]->data, 0, (size_t)pQuery->pSelectExpr[i].resBytes * pQuery->capacity);
   }
 
   initCtxOutputBuf(pRuntimeEnv);
@@ -3397,7 +3439,7 @@ void doSkipResults(SQueryRuntimeEnv *pRuntimeEnv) {
     pQuery->limit.offset -= pQuery->rec.pointsRead;
 
     pQuery->rec.pointsRead = 0;
-//    pQuery->pointsOffset = pQuery->rec.pointsToRead;  // clear all data in result buffer
+    //    pQuery->pointsOffset = pQuery->rec.pointsToRead;  // clear all data in result buffer
 
     resetCtxOutputBuf(pRuntimeEnv);
 
@@ -3411,7 +3453,7 @@ void doSkipResults(SQueryRuntimeEnv *pRuntimeEnv) {
       int32_t functionId = pQuery->pSelectExpr[i].pBase.functionId;
       int32_t bytes = pRuntimeEnv->pCtx[i].outputBytes;
       assert(0);
-//      memmove(pQuery->sdata[i]->data, pQuery->sdata[i]->data + bytes * numOfSkip, pQuery->pointsRead * bytes);
+      //      memmove(pQuery->sdata[i]->data, pQuery->sdata[i]->data + bytes * numOfSkip, pQuery->pointsRead * bytes);
       pRuntimeEnv->pCtx[i].aOutputBuf += bytes * numOfSkip;
 
       if (functionId == TSDB_FUNC_DIFF || functionId == TSDB_FUNC_TOP || functionId == TSDB_FUNC_BOTTOM) {
@@ -3597,7 +3639,8 @@ void vnodeScanAllData(SQueryRuntimeEnv *pRuntimeEnv) {
 
   doSingleMeterSupplementScan(pRuntimeEnv);
 
-  // update the pQuery->window.skey and pQuery->window.ekey to limit the scan scope of sliding query during supplementary scan
+  // update the pQuery->window.skey and pQuery->window.ekey to limit the scan scope of sliding query during
+  // supplementary scan
   pQuery->lastKey = lkey;
   pQuery->window.ekey = ekey;
 
@@ -3659,7 +3702,10 @@ STableQueryInfo *createMeterQueryInfo(SQInfo *pQInfo, int32_t sid, TSKEY skey, T
 
   STableQueryInfo *pTableQueryInfo = calloc(1, sizeof(STableQueryInfo));
 
-  pTableQueryInfo->win = (STimeWindow) {.skey = skey, .ekey = ekey,};
+  pTableQueryInfo->win = (STimeWindow){
+      .skey = skey,
+      .ekey = ekey,
+  };
   pTableQueryInfo->lastKey = skey;
 
   pTableQueryInfo->sid = sid;
@@ -3716,8 +3762,8 @@ void restoreIntervalQueryRange(SQueryRuntimeEnv *pRuntimeEnv, STableQueryInfo *p
  * @param pRuntimeEnv
  * @param pDataBlockInfoEx
  */
-void setExecutionContext(SQInfo *pQInfo, STableQueryInfo *pTableQueryInfo, int32_t meterIdx,
-                         int32_t groupIdx, TSKEY nextKey) {
+void setExecutionContext(SQInfo *pQInfo, STableQueryInfo *pTableQueryInfo, int32_t meterIdx, int32_t groupIdx,
+                         TSKEY nextKey) {
   SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
   SWindowResInfo *  pWindowResInfo = &pRuntimeEnv->windowResInfo;
   int32_t           GROUPRESULTID = 1;
@@ -3774,7 +3820,7 @@ int32_t setAdditionalInfo(SQInfo *pQInfo, int32_t meterIdx, STableQueryInfo *pTa
   SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
   assert(pTableQueryInfo->lastKey > 0);
 
-//  vnodeSetTagValueInParam(pQInfo->pSidSet, pRuntimeEnv, pQInfo->pMeterSidExtInfo[meterIdx]);
+  //  vnodeSetTagValueInParam(pQInfo->pSidSet, pRuntimeEnv, pQInfo->pMeterSidExtInfo[meterIdx]);
 
   // both the master and supplement scan needs to set the correct ts comp start position
   if (pRuntimeEnv->pTSBuf != NULL) {
@@ -3882,7 +3928,7 @@ static int32_t getNumOfSubset(SQInfo *pQInfo) {
   if (isGroupbyNormalCol(pQuery->pGroupbyExpr) || (isIntervalQuery(pQuery))) {
     totalSubset = numOfClosedTimeWindow(&pQInfo->runtimeEnv.windowResInfo);
   } else {
-    totalSubset = pQInfo->pSidSet->numOfSubSet;
+    //    totalSubset = pQInfo->pSidSet->numOfSubSet;
   }
 
   return totalSubset;
@@ -3924,13 +3970,13 @@ static int32_t doCopyToSData(SQInfo *pQInfo, SWindowResult *result, int32_t orde
      * current output space is not enough to keep all the result data of this group, only copy partial results
      * to SQuery object's result buffer
      */
-//    if (numOfRowsToCopy > pQuery->pointsToRead - numOfResult) {
-//      numOfRowsToCopy = pQuery->pointsToRead - numOfResult;
-//      pQInfo->offset += numOfRowsToCopy;
-//    } else {
-//      pQInfo->offset = 0;
-//      pQInfo->subgroupIdx += 1;
-//    }
+    //    if (numOfRowsToCopy > pQuery->pointsToRead - numOfResult) {
+    //      numOfRowsToCopy = pQuery->pointsToRead - numOfResult;
+    //      pQInfo->offset += numOfRowsToCopy;
+    //    } else {
+    //      pQInfo->offset = 0;
+    //      pQInfo->subgroupIdx += 1;
+    //    }
 
     for (int32_t j = 0; j < pQuery->numOfOutputCols; ++j) {
       int32_t size = pRuntimeEnv->pCtx[j].outputBytes;
@@ -3942,9 +3988,9 @@ static int32_t doCopyToSData(SQInfo *pQInfo, SWindowResult *result, int32_t orde
 
     numOfResult += numOfRowsToCopy;
     assert(0);
-//    if (numOfResult == pQuery->rec.pointsToRead) {
-//      break;
-//    }
+    //    if (numOfResult == pQuery->rec.pointsToRead) {
+    //      break;
+    //    }
   }
 
   dTrace("QInfo:%p copy data to SQuery buf completed", GET_QINFO_ADDR(pQuery));
@@ -3971,7 +4017,7 @@ void copyFromWindowResToSData(SQInfo *pQInfo, SWindowResult *result) {
   int32_t numOfResult = doCopyToSData(pQInfo, result, orderType);
 
   pQuery->rec.pointsRead += numOfResult;
-//  assert(pQuery->rec.pointsRead <= pQuery->pointsToRead);
+  //  assert(pQuery->rec.pointsRead <= pQuery->pointsToRead);
 }
 
 static void updateWindowResNumOfRes(SQueryRuntimeEnv *pRuntimeEnv, STableDataInfo *pTableDataInfo) {
@@ -3989,9 +4035,8 @@ static void updateWindowResNumOfRes(SQueryRuntimeEnv *pRuntimeEnv, STableDataInf
   }
 }
 
-void stableApplyFunctionsOnBlock_(SQInfo *pQInfo, STableDataInfo *pTableDataInfo,
-                                  SDataBlockInfo *pDataBlockInfo, SDataStatis *pStatis, SArray* pDataBlock,
-                                  __block_search_fn_t searchFn) {
+void stableApplyFunctionsOnBlock_(SQInfo *pQInfo, STableDataInfo *pTableDataInfo, SDataBlockInfo *pDataBlockInfo,
+                                  SDataStatis *pStatis, SArray *pDataBlock, __block_search_fn_t searchFn) {
   SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
   SQuery *          pQuery = pRuntimeEnv->pQuery;
   STableQueryInfo * pTableQueryInfo = pTableDataInfo->pTableQInfo;
@@ -3999,7 +4044,7 @@ void stableApplyFunctionsOnBlock_(SQInfo *pQInfo, STableDataInfo *pTableDataInfo
 
   int32_t numOfRes = 0;
   if (pQuery->numOfFilterCols > 0 || pRuntimeEnv->pTSBuf != NULL) {
-//    numOfRes = rowwiseApplyAllFunctions(pRuntimeEnv, &forwardStep, pFields, pDataBlockInfo, pWindowResInfo);
+    //    numOfRes = rowwiseApplyAllFunctions(pRuntimeEnv, &forwardStep, pFields, pDataBlockInfo, pWindowResInfo);
   } else {
     numOfRes = blockwiseApplyAllFunctions(pRuntimeEnv, pStatis, pDataBlockInfo, pWindowResInfo, searchFn, pDataBlock);
   }
@@ -4067,9 +4112,11 @@ bool vnodeHasRemainResults(void *handle) {
     if (Q_STATUS_EQUAL(pQuery->status, QUERY_COMPLETED | QUERY_NO_DATA_TO_CHECK)) {
       TSKEY ekey = taosGetRevisedEndKey(pQuery->window.ekey, pQuery->order.order, pQuery->intervalTime,
                                         pQuery->slidingTimeUnit, pQuery->precision);
-//      int32_t numOfTotal = taosGetNumOfResultWithInterpo(pInterpoInfo, (TSKEY *)pRuntimeEnv->pInterpoBuf[0]->data,
-//                                                         remain, pQuery->intervalTime, ekey, pQuery->pointsToRead);
-//      return numOfTotal > 0;
+      //      int32_t numOfTotal = taosGetNumOfResultWithInterpo(pInterpoInfo, (TSKEY
+      //      *)pRuntimeEnv->pInterpoBuf[0]->data,
+      //                                                         remain, pQuery->intervalTime, ekey,
+      //                                                         pQuery->pointsToRead);
+      //      return numOfTotal > 0;
       assert(0);
       return false;
     }
@@ -4214,7 +4261,6 @@ int32_t vnodeQueryResultInterpolate(SQInfo *pQInfo, tFilePage **pDst, tFilePage
     }
   }
 #endif
-
 }
 
 void vnodePrintQueryStatistics(SQInfo *pQInfo) {
@@ -4262,49 +4308,45 @@ void vnodePrintQueryStatistics(SQInfo *pQInfo) {
 #endif
 }
 
-int32_t vnodeQueryTablePrepare(SQInfo *pQInfo, void *pMeterObj, void *param) {
+int32_t vnodeQueryTablePrepare(SQInfo *pQInfo, void *param, void* tsdb) {
   SQuery *pQuery = pQInfo->runtimeEnv.pQuery;
   int32_t code = TSDB_CODE_SUCCESS;
 
-  //only the successful complete requries the sem_post/over = 1 operations.
+  // only the successful complete requries the sem_post/over = 1 operations.
   if ((QUERY_IS_ASC_QUERY(pQuery) && (pQuery->window.skey > pQuery->window.ekey)) ||
       (!QUERY_IS_ASC_QUERY(pQuery) && (pQuery->window.ekey > pQuery->window.skey))) {
-    dTrace("QInfo:%p no result in time range %" PRId64 "-%" PRId64 ", order %d", pQInfo, pQuery->window.skey, pQuery->window.ekey,
-           pQuery->order.order);
+    dTrace("QInfo:%p no result in time range %" PRId64 "-%" PRId64 ", order %d", pQInfo, pQuery->window.skey,
+           pQuery->window.ekey, pQuery->order.order);
 
     sem_post(&pQInfo->dataReady);
-//    pQInfo->over = 1;
+    pQInfo->killed = 1;
     return TSDB_CODE_SUCCESS;
   }
 
   setScanLimitationByResultBuffer(pQuery);
   changeExecuteScanOrder(pQuery, false);
 
-//  pQInfo->over = 0;
-  pQInfo->rec = (SResultRec) {0};
-//  pQuery->pointsRead = 0;
+  pQInfo->rec = (SResultRec){0};
 
   // dataInCache requires lastKey value
   pQuery->lastKey = pQuery->window.skey;
 
   STsdbQueryCond cond = {0};
+
   cond.twindow = (STimeWindow){.skey = pQuery->window.skey, .ekey = pQuery->window.ekey};
   cond.order = pQuery->order.order;
-  
   cond.colList = *pQuery->colList;
-  SArray *sa = taosArrayInit(1, POINTER_BYTES);
-  taosArrayPush(sa, &pMeterObj);
 
   SArray *cols = taosArrayInit(pQuery->numOfCols, sizeof(pQuery->colList[0]));
   for (int32_t i = 0; i < pQuery->numOfCols; ++i) {
     taosArrayPush(cols, &pQuery->colList[i]);
   }
 
-  pQInfo->runtimeEnv.pQueryHandle = tsdbQueryByTableId(&cond, sa, cols);
+  
+  pQInfo->runtimeEnv.pQueryHandle = tsdbQueryByTableId(tsdb, &cond, pQInfo->pTableIdList, cols);
 
   SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
   pRuntimeEnv->pQuery = pQuery;
-  pRuntimeEnv->pTabObj = pMeterObj;
 
   pRuntimeEnv->pTSBuf = param;
   pRuntimeEnv->cur.vnodeIndex = -1;
@@ -4314,7 +4356,7 @@ int32_t vnodeQueryTablePrepare(SQInfo *pQInfo, void *pMeterObj, void *param) {
   }
 
   // create runtime environment
-  code = setupQueryRuntimeEnv(pMeterObj, pQuery, &pQInfo->runtimeEnv, NULL, pQuery->order.order, false);
+  code = setupQueryRuntimeEnv(&pQInfo->runtimeEnv, NULL, pQuery->order.order, false);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
@@ -4338,7 +4380,6 @@ int32_t vnodeQueryTablePrepare(SQInfo *pQInfo, void *pMeterObj, void *param) {
     initWindowResInfo(&pRuntimeEnv->windowResInfo, pRuntimeEnv, rows, 4096, type);
   }
 
-  /* query on single table */
   setQueryStatus(pQuery, QUERY_NOT_COMPLETED);
 
   SPointInterpoSupporter interpInfo = {0};
@@ -4371,7 +4412,7 @@ int32_t vnodeQueryTablePrepare(SQInfo *pQInfo, void *pMeterObj, void *param) {
   int64_t rs = taosGetIntervalStartTimestamp(pQuery->window.skey, pQuery->intervalTime, pQuery->slidingTimeUnit,
                                              pQuery->precision);
   taosInitInterpoInfo(&pRuntimeEnv->interpoInfo, pQuery->order.order, rs, 0, 0);
-//  allocMemForInterpo(pQInfo, pQuery, pMeterObj);
+  //  allocMemForInterpo(pQInfo, pQuery, pMeterObj);
 
   if (!isPointInterpoQuery(pQuery)) {
     //    assert(pQuery->pos >= 0 && pQuery->slot >= 0);
@@ -4384,7 +4425,6 @@ int32_t vnodeQueryTablePrepare(SQInfo *pQInfo, void *pMeterObj, void *param) {
   return TSDB_CODE_SUCCESS;
 }
 
-
 static bool isGroupbyEachTable(SSqlGroupbyExpr *pGroupbyExpr, tSidSet *pSidset) {
   if (pGroupbyExpr == NULL || pGroupbyExpr->numOfGroupCols == 0) {
     return false;
@@ -4393,7 +4433,7 @@ static bool isGroupbyEachTable(SSqlGroupbyExpr *pGroupbyExpr, tSidSet *pSidset)
   for (int32_t i = 0; i < pGroupbyExpr->numOfGroupCols; ++i) {
     SColIndexEx *pColIndex = &pGroupbyExpr->columnInfo[i];
     if (pColIndex->flag == TSDB_COL_TAG) {
-      assert(pSidset->numOfSids == pSidset->numOfSubSet);
+      //      assert(pSidset->numOfTables == pSidset->numOfSubSet);
       return true;
     }
   }
@@ -4410,8 +4450,6 @@ static bool doCheckWithPrevQueryRange(SQuery *pQuery, TSKEY nextKey) {
   return true;
 }
 
-
-
 static void enableExecutionForNextTable(SQueryRuntimeEnv *pRuntimeEnv) {
   SQuery *pQuery = pRuntimeEnv->pQuery;
 
@@ -4424,13 +4462,13 @@ static void enableExecutionForNextTable(SQueryRuntimeEnv *pRuntimeEnv) {
 }
 
 static void queryOnDataBlocks(SQInfo *pQInfo, STableDataInfo *pMeterDataInfo) {
-  SQueryRuntimeEnv *     pRuntimeEnv = &pQInfo->runtimeEnv;
+  SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
   SQuery *          pQuery = pRuntimeEnv->pQuery;
 
-//  SMeterObj *         pTempMeter = getMeterObj(pSupporter->pMetersHashTable, pSupporter->pMeterSidExtInfo[0]->sid);
-//  __block_search_fn_t searchFn = vnodeSearchKeyFunc[pTempMeter->searchAlgorithm];
+  //  SMeterObj *         pTempMeter = getMeterObj(pSupporter->pMetersHashTable, pSupporter->pMeterSidExtInfo[0]->sid);
+  //  __block_search_fn_t searchFn = vnodeSearchKeyFunc[pTempMeter->searchAlgorithm];
 
-//  dTrace("QInfo:%p start to check data blocks in %d files", pQInfo, pVnodeFileInfo->numOfFiles);
+  //  dTrace("QInfo:%p start to check data blocks in %d files", pQInfo, pVnodeFileInfo->numOfFiles);
 
   tsdb_query_handle_t *pQueryHandle = pRuntimeEnv->pQueryHandle;
   while (tsdbNextDataBlock(pQueryHandle)) {
@@ -4441,52 +4479,51 @@ static void queryOnDataBlocks(SQInfo *pQInfo, STableDataInfo *pMeterDataInfo) {
     // prepare the STableDataInfo struct for each table
 
     SDataBlockInfo blockInfo = tsdbRetrieveDataBlockInfo(pQueryHandle);
-//    SMeterObj *    pMeterObj = getMeterObj(pSupporter->pMetersHashTable, blockInfo.sid);
+    //    SMeterObj *    pMeterObj = getMeterObj(pSupporter->pMetersHashTable, blockInfo.sid);
 
-//    pQInfo->pObj = pMeterObj;
-//    pRuntimeEnv->pMeterObj = pMeterObj;
+    //    pQInfo->pObj = pMeterObj;
+    //    pRuntimeEnv->pMeterObj = pMeterObj;
 
     STableDataInfo *pTableDataInfo = NULL;
-//    for (int32_t i = 0; i < pSupporter->pSidSet->numOfSids; ++i) {
-//      if (pMeterDataInfo[i].pMeterObj == pMeterObj) {
-//        pTableDataInfo = &pMeterDataInfo[i];
-//        break;
-//      }
-//    }
+    //    for (int32_t i = 0; i < pSupporter->pSidSet->numOfTables; ++i) {
+    //      if (pMeterDataInfo[i].pMeterObj == pMeterObj) {
+    //        pTableDataInfo = &pMeterDataInfo[i];
+    //        break;
+    //      }
+    //    }
 
     assert(pTableDataInfo != NULL);
     STableQueryInfo *pTableQueryInfo = pTableDataInfo->pTableQInfo;
 
     if (pTableDataInfo->pTableQInfo == NULL) {
-//      pTableDataInfo->pTableQInfo = createMeterQueryInfo(pQInfo, pMeterObj->sid, pQuery->skey, pQuery->ekey);
+      //      pTableDataInfo->pTableQInfo = createMeterQueryInfo(pQInfo, pMeterObj->sid, pQuery->skey, pQuery->ekey);
     }
 
     restoreIntervalQueryRange(pRuntimeEnv, pTableQueryInfo);
 
     SDataStatis *pStatis = NULL;
-    SArray *pDataBlock = loadDataBlockOnDemand(pRuntimeEnv, &blockInfo, &pStatis);
+    SArray *     pDataBlock = loadDataBlockOnDemand(pRuntimeEnv, &blockInfo, &pStatis);
 
     TSKEY nextKey = blockInfo.window.ekey;
     if (pQuery->intervalTime == 0) {
-      setExecutionContext(pQInfo, pTableQueryInfo, pTableDataInfo->tableIndex, pTableDataInfo->groupIdx,
-                          nextKey);
+      setExecutionContext(pQInfo, pTableQueryInfo, pTableDataInfo->tableIndex, pTableDataInfo->groupIdx, nextKey);
     } else {  // interval query
       setIntervalQueryRange(pTableQueryInfo, pQInfo, nextKey);
       int32_t ret = setAdditionalInfo(pQInfo, pTableDataInfo->tableIndex, pTableQueryInfo);
       if (ret != TSDB_CODE_SUCCESS) {
-//        pQInfo->killed = 1;
+        //        pQInfo->killed = 1;
         return;
       }
     }
 
-//    stableApplyFunctionsOnBlock_(pSupporter, pTableDataInfo, &blockInfo, pStatis, pDataBlock, searchFn);
+    //    stableApplyFunctionsOnBlock_(pSupporter, pTableDataInfo, &blockInfo, pStatis, pDataBlock, searchFn);
   }
 }
 
 static bool multimeterMultioutputHelper(SQInfo *pQInfo, bool *dataInDisk, bool *dataInCache, int32_t index,
                                         int32_t start) {
-//  SMeterSidExtInfo **pMeterSidExtInfo = pQInfo->pMeterSidExtInfo;
-  SQueryRuntimeEnv * pRuntimeEnv = &pQInfo->runtimeEnv;
+  //  STableIdInfo **pMeterSidExtInfo = pQInfo->pMeterSidExtInfo;
+  SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
   SQuery *          pQuery = &pRuntimeEnv->pQuery;
 #if 0
   setQueryStatus(pQuery, QUERY_NOT_COMPLETED);
@@ -4540,7 +4577,7 @@ static bool multimeterMultioutputHelper(SQInfo *pQInfo, bool *dataInDisk, bool *
 
 static int64_t doCheckMetersInGroup(SQInfo *pQInfo, int32_t index, int32_t start) {
   SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
-  SQuery* pQuery = pRuntimeEnv->pQuery;
+  SQuery *          pQuery = pRuntimeEnv->pQuery;
 
   bool dataInDisk = true;
   bool dataInCache = true;
@@ -4548,15 +4585,14 @@ static int64_t doCheckMetersInGroup(SQInfo *pQInfo, int32_t index, int32_t start
     return 0;
   }
 
-  
   SPointInterpoSupporter pointInterpSupporter = {0};
   pointInterpSupporterInit(pQuery, &pointInterpSupporter);
   assert(0);
 
-//  if (!normalizedFirstQueryRange(dataInDisk, dataInCache, pSupporter, &pointInterpSupporter, NULL)) {
-//    pointInterpSupporterDestroy(&pointInterpSupporter);
-//    return 0;
-//  }
+  //  if (!normalizedFirstQueryRange(dataInDisk, dataInCache, pSupporter, &pointInterpSupporter, NULL)) {
+  //    pointInterpSupporterDestroy(&pointInterpSupporter);
+  //    return 0;
+  //  }
 
   /*
    * here we set the value for before and after the specified time into the
@@ -4590,11 +4626,11 @@ static int64_t doCheckMetersInGroup(SQInfo *pQInfo, int32_t index, int32_t start
  * @param pQInfo
  */
 static void vnodeSTableSeqProcessor(SQInfo *pQInfo) {
-  SQueryRuntimeEnv * pRuntimeEnv = &pQInfo->runtimeEnv;
+  SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
 
 #if 0
   SQuery* pQuery = pRuntimeEnv->pQuery;
-//  tSidSet *pSids = pSupporter->pSidSet;
+//  tSidSet *pTableIdList = pSupporter->pSidSet;
   
   int32_t vid = getMeterObj(pSupporter->pMetersHashTable, pMeterSidExtInfo[0]->sid)->vnode;
   
@@ -4603,12 +4639,12 @@ static void vnodeSTableSeqProcessor(SQInfo *pQInfo) {
     
     assert(pQuery->limit.offset == 0 && pQuery->limit.limit != 0);
     
-    while (pSupporter->subgroupIdx < pSids->numOfSubSet) {
-      int32_t start = pSids->starterPos[pSupporter->subgroupIdx];
-      int32_t end = pSids->starterPos[pSupporter->subgroupIdx + 1] - 1;
+    while (pSupporter->subgroupIdx < pTableIdList->numOfSubSet) {
+      int32_t start = pTableIdList->starterPos[pSupporter->subgroupIdx];
+      int32_t end = pTableIdList->starterPos[pSupporter->subgroupIdx + 1] - 1;
       
       if (isFirstLastRowQuery(pQuery)) {
-        dTrace("QInfo:%p last_row query on vid:%d, numOfGroups:%d, current group:%d", pQInfo, vid, pSids->numOfSubSet,
+        dTrace("QInfo:%p last_row query on vid:%d, numOfGroups:%d, current group:%d", pQInfo, vid, pTableIdList->numOfSubSet,
                pSupporter->subgroupIdx);
         
         TSKEY   key = -1;
@@ -4641,7 +4677,7 @@ static void vnodeSTableSeqProcessor(SQInfo *pQInfo) {
         int64_t num = doCheckMetersInGroup(pQInfo, index, start);
         assert(num >= 0);
       } else {
-        dTrace("QInfo:%p interp query on vid:%d, numOfGroups:%d, current group:%d", pQInfo, vid, pSids->numOfSubSet,
+        dTrace("QInfo:%p interp query on vid:%d, numOfGroups:%d, current group:%d", pQInfo, vid, pTableIdList->numOfSubSet,
                pSupporter->subgroupIdx);
         
         for (int32_t k = start; k <= end; ++k) {
@@ -4686,7 +4722,7 @@ static void vnodeSTableSeqProcessor(SQInfo *pQInfo) {
       }
     }
     
-    if (pSupporter->meterIdx >= pSids->numOfSids) {
+    if (pSupporter->meterIdx >= pTableIdList->numOfTables) {
       return;
     }
     
@@ -4752,7 +4788,7 @@ static void vnodeSTableSeqProcessor(SQInfo *pQInfo) {
       
       // the limitation of output result is reached, set the query completed
       if (doRevisedResultsByLimit(pQInfo)) {
-        pSupporter->meterIdx = pSupporter->pSidSet->numOfSids;
+        pSupporter->meterIdx = pSupporter->pSidSet->numOfTables;
         break;
       }
       
@@ -4839,7 +4875,7 @@ static void vnodeSTableSeqProcessor(SQInfo *pQInfo) {
   dTrace(
       "QInfo %p vid:%d, numOfMeters:%d, index:%d, numOfGroups:%d, %d points returned, totalRead:%d totalReturn:%d,"
       "next skey:%" PRId64 ", offset:%" PRId64,
-      pQInfo, vid, pSids->numOfSids, pSupporter->meterIdx, pSids->numOfSubSet, pQuery->pointsRead, pQInfo->pointsRead,
+      pQInfo, vid, pTableIdList->numOfTables, pSupporter->meterIdx, pTableIdList->numOfSubSet, pQuery->pointsRead, pQInfo->pointsRead,
       pQInfo->pointsReturned, pQuery->skey, pQuery->limit.offset);
 #endif
 }
@@ -4848,15 +4884,15 @@ static void doOrderedScan(SQInfo *pQInfo) {
   SQuery *pQuery = &pQInfo->runtimeEnv.pQuery;
 #if 0
 //  if (pQInfo->runtimeEnv. == NULL) {
-//    pSupporter->pMeterDataInfo = calloc(pSupporter->pSidSet->numOfSids, sizeof(STableDataInfo));
+//    pSupporter->pMeterDataInfo = calloc(pSupporter->pSidSet->numOfTables, sizeof(STableDataInfo));
 //  }
   
-  SMeterSidExtInfo **pMeterSidExtInfo = pSupporter->pMeterSidExtInfo;
+  STableIdInfo **pMeterSidExtInfo = pSupporter->pMeterSidExtInfo;
   
   tSidSet* pSidset = pSupporter->pSidSet;
   int32_t groupId = 0;
   
-  for (int32_t i = 0; i < pSidset->numOfSids; ++i) {  // load all meter meta info
+  for (int32_t i = 0; i < pSidset->numOfTables; ++i) {  // load all meter meta info
     SMeterObj *pMeterObj = getMeterObj(pSupporter->pMetersHashTable, pMeterSidExtInfo[i]->sid);
     if (pMeterObj == NULL) {
       dError("QInfo:%p failed to find required sid:%d", pQInfo, pMeterSidExtInfo[i]->sid);
@@ -4884,16 +4920,16 @@ static void doOrderedScan(SQInfo *pQInfo) {
 static void setupMeterQueryInfoForSupplementQuery(SQInfo *pQInfo) {
   SQuery *pQuery = pQInfo->runtimeEnv.pQuery;
 
-  int32_t num = taosHashGetSize(pQInfo->pTableList);
+  int32_t num = taosHashGetSize(pQInfo->pTableIdList);
   for (int32_t i = 0; i < num; ++i) {
-//    STableQueryInfo *pTableQueryInfo = pSupporter->pMeterDataInfo[i].pTableQInfo;
-//    changeMeterQueryInfoForSuppleQuery(pQuery, pTableQueryInfo, pSupporter->rawSKey, pSupporter->rawEKey);
+    //    STableQueryInfo *pTableQueryInfo = pSupporter->pMeterDataInfo[i].pTableQInfo;
+    //    changeMeterQueryInfoForSuppleQuery(pQuery, pTableQueryInfo, pSupporter->rawSKey, pSupporter->rawEKey);
   }
 }
 
 static void doMultiMeterSupplementaryScan(SQInfo *pQInfo) {
   SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
-  SQuery *pQuery = pRuntimeEnv->pQuery;
+  SQuery *          pQuery = pRuntimeEnv->pQuery;
 
   if (!needSupplementaryScan(pQuery)) {
     dTrace("QInfo:%p no need to do supplementary scan, query completed", pQInfo);
@@ -4901,7 +4937,7 @@ static void doMultiMeterSupplementaryScan(SQInfo *pQInfo) {
   }
 
   SET_SUPPLEMENT_SCAN_FLAG(pRuntimeEnv);
-//  disableFunctForSuppleScan(pSupporter, pQuery->order.order);
+  //  disableFunctForSuppleScan(pSupporter, pQuery->order.order);
 
   if (pRuntimeEnv->pTSBuf != NULL) {
     pRuntimeEnv->pTSBuf->cur.order = pRuntimeEnv->pTSBuf->cur.order ^ 1u;
@@ -4933,7 +4969,7 @@ static void doMultiMeterSupplementaryScan(SQInfo *pQInfo) {
 }
 
 static void vnodeMultiMeterQueryProcessor(SQInfo *pQInfo) {
-  SQueryRuntimeEnv *     pRuntimeEnv = &pQInfo->runtimeEnv;
+  SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
   SQuery *          pQuery = pRuntimeEnv->pQuery;
 
   if (pQInfo->subgroupIdx > 0) {
@@ -4954,7 +4990,7 @@ static void vnodeMultiMeterQueryProcessor(SQInfo *pQInfo) {
     pQInfo->rec.pointsRead += pQuery->rec.pointsRead;
 
     if (pQuery->rec.pointsRead == 0) {
-//      vnodePrintQueryStatistics(pSupporter);
+      //      vnodePrintQueryStatistics(pSupporter);
     }
 
     dTrace("QInfo:%p points returned:%d, totalRead:%d totalReturn:%d", pQInfo, pQuery->rec.pointsRead,
@@ -5023,7 +5059,7 @@ static void vnodeMultiMeterQueryProcessor(SQInfo *pQInfo) {
  * select count(*)/top(field,k)/avg(field name) from table_name [where ts>now-1a];
  * select count(*) from table_name group by status_column;
  */
-static void vnodeSingleTableFixedOutputProcessor(SQInfo *pQInfo) {
+static void tableFixedOutputProcessor(SQInfo *pQInfo) {
   SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
   SQuery *          pQuery = pRuntimeEnv->pQuery;
 
@@ -5050,7 +5086,7 @@ static void vnodeSingleTableFixedOutputProcessor(SQInfo *pQInfo) {
   pQInfo->rec.pointsRead = pQuery->rec.pointsRead;
 }
 
-static void vnodeSingleTableMultiOutputProcessor(SQInfo *pQInfo) {
+static void tableMultiOutputProcessor(SQInfo *pQInfo) {
 #if 0
   SQuery *   pQuery = &pQInfo->query;
   SMeterObj *pMeterObj = pQInfo->pObj;
@@ -5146,7 +5182,7 @@ static void vnodeSingleMeterIntervalMainLooper(SQueryRuntimeEnv *pRuntimeEnv) {
     }
 
     // load the data block for the next retrieve
-//    loadRequiredBlockIntoMem(pRuntimeEnv, &pRuntimeEnv->nextPos);
+    //    loadRequiredBlockIntoMem(pRuntimeEnv, &pRuntimeEnv->nextPos);
     if (Q_STATUS_EQUAL(pQuery->status, QUERY_RESBUF_FULL)) {
       break;
     }
@@ -5154,11 +5190,11 @@ static void vnodeSingleMeterIntervalMainLooper(SQueryRuntimeEnv *pRuntimeEnv) {
 }
 
 /* handle time interval query on single table */
-static void vnodeSingleTableIntervalProcessor(SQInfo *pQInfo) {
-//  STable *pMeterObj = pQInfo->pObj;
+static void tableIntervalProcessor(SQInfo *pQInfo) {
+  //  STable *pMeterObj = pQInfo->pObj;
 
-  SQueryRuntimeEnv *     pRuntimeEnv = &(pQInfo->runtimeEnv);
-  SQuery* pQuery = pRuntimeEnv->pQuery;
+  SQueryRuntimeEnv *pRuntimeEnv = &(pQInfo->runtimeEnv);
+  SQuery *          pQuery = pRuntimeEnv->pQuery;
 
   int32_t numOfInterpo = 0;
 
@@ -5187,8 +5223,8 @@ static void vnodeSingleTableIntervalProcessor(SQInfo *pQInfo) {
       }
 
       numOfInterpo = 0;
-      pQuery->rec.pointsRead = vnodeQueryResultInterpolate(pQInfo, (tFilePage **)pQuery->sdata, (tFilePage **)pInterpoBuf,
-                                                       pQuery->rec.pointsRead, &numOfInterpo);
+      pQuery->rec.pointsRead = vnodeQueryResultInterpolate(
+          pQInfo, (tFilePage **)pQuery->sdata, (tFilePage **)pInterpoBuf, pQuery->rec.pointsRead, &numOfInterpo);
 
       dTrace("QInfo: %p interpo completed, final:%d", pQInfo, pQuery->rec.pointsRead);
       if (pQuery->rec.pointsRead > 0 || Q_STATUS_EQUAL(pQuery->status, QUERY_COMPLETED | QUERY_NO_DATA_TO_CHECK)) {
@@ -5212,36 +5248,24 @@ static void vnodeSingleTableIntervalProcessor(SQInfo *pQInfo) {
   pQInfo->rec.pointsRead += pQuery->rec.pointsRead;
   pQInfo->pointsInterpo += numOfInterpo;
 
-//  dTrace("%p vid:%d sid:%d id:%s, %d points returned %d points interpo, totalRead:%d totalInterpo:%d totalReturn:%d",
-//         pQInfo, pMeterObj->vnode, pMeterObj->sid, pMeterObj->meterId, pQuery->pointsRead, numOfInterpo,
-//         pQInfo->pointsRead - pQInfo->pointsInterpo, pQInfo->pointsInterpo, pQInfo->pointsReturned);
+  //  dTrace("%p vid:%d sid:%d id:%s, %d points returned %d points interpo, totalRead:%d totalInterpo:%d
+  //  totalReturn:%d",
+  //         pQInfo, pMeterObj->vnode, pMeterObj->sid, pMeterObj->meterId, pQuery->pointsRead, numOfInterpo,
+  //         pQInfo->pointsRead - pQInfo->pointsInterpo, pQInfo->pointsInterpo, pQInfo->pointsReturned);
 }
 
-void qTableQuery(void* pReadMsg) {
-//  SQInfo *pQInfo = (SQInfo *)pReadMsg->ahandle;
+void qTableQuery(SQInfo *pQInfo) {
+  assert(pQInfo != NULL);
 
-#if 0
-  if (pQInfo == NULL) {
-    dTrace("%p freed abort query", pQInfo);
+  if (pQInfo->killed) {
+    dTrace("QInfo:%p it is already killed, abort", pQInfo);
     return;
   }
 
-//  if (pQInfo->killed) {
-//    dTrace("QInfo:%p it is already killed, abort", pQInfo);
-//    vnodeDecRefCount(pQInfo);
-//
-//    return;
-//  }
-  
-//  assert(pQInfo->refCount >= 1);
-  
   SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
-  SQuery *          pQuery = &pRuntimeEnv->pQuery;
-  
-//  assert(pRuntimeEnv->pMeterObj == pMeterObj);
+  SQuery *          pQuery = pRuntimeEnv->pQuery;
 
-//  dTrace("vid:%d sid:%d id:%s, query thread is created, numOfQueries:%d, QInfo:%p", pMeterObj->vnode, pMeterObj->sid,
-//         pMeterObj->meterId, pMeterObj->numOfQueries, pQInfo);
+  //  dTrace("vid:%d sid:%d id:%s, query thread is created, numOfQueries:%d, QInfo:%p", pQInfo);
 
   if (vnodeHasRemainResults(pQInfo)) {
     /*
@@ -5259,15 +5283,10 @@ void qTableQuery(void* pReadMsg) {
     pQInfo->pointsInterpo += numOfInterpo;
     pQInfo->rec.pointsRead += pQuery->rec.pointsRead;
 
-//    dTrace(
-//        "QInfo:%p vid:%d sid:%d id:%s, %d points returned %d points interpo, totalRead:%d totalInterpo:%d "
-//        "totalReturn:%d",
-//        pQInfo, pMeterObj->vnode, pMeterObj->sid, pMeterObj->meterId, pQuery->pointsRead, numOfInterpo,
-//        pQInfo->pointsRead, pQInfo->pointsInterpo, pQInfo->pointsReturned);
-    
+    //    dTrace("QInfo:%p %d points returned %d points interpo, totalRead:%d totalInterpo:%d totalReturn:%d",
+    //        pQInfo, pQuery->pointsRead, numOfInterpo, pQInfo->pointsRead, pQInfo->pointsInterpo,
+    //        pQInfo->pointsReturned);
     sem_post(&pQInfo->dataReady);
-//    vnodeDecRefCount(pQInfo);
-    
     return;
   }
 
@@ -5287,46 +5306,43 @@ void qTableQuery(void* pReadMsg) {
         clearFirstNTimeWindow(pRuntimeEnv, pQInfo->subgroupIdx);
 
         if (pQuery->rec.pointsRead > 0) {
-//          dTrace("QInfo:%p vid:%d sid:%d id:%s, %d points returned %d from group results, totalRead:%d totalReturn:%d",
-//                 pQInfo, pMeterObj->vnode, pMeterObj->sid, pMeterObj->meterId, pQuery->pointsRead, pQInfo->pointsRead,
-//                 pQInfo->pointsInterpo, pQInfo->pointsReturned);
+          //          dTrace("QInfo:%p vid:%d sid:%d id:%s, %d points returned %d from group results, totalRead:%d
+          //          totalReturn:%d",
+          //                 pQInfo, pMeterObj->vnode, pMeterObj->sid, pMeterObj->meterId, pQuery->pointsRead,
+          //                 pQInfo->pointsRead, pQInfo->pointsInterpo, pQInfo->pointsReturned);
 
           sem_post(&pQInfo->dataReady);
-//          vnodeDecRefCount(pQInfo);
-          
           return;
         }
       }
     }
 
-    assert(0);
-//    pQInfo->over = 1;
-//    dTrace("QInfo:%p vid:%d sid:%d id:%s, query over, %d points are returned", pQInfo, pMeterObj->vnode, pMeterObj->sid,
-//           pMeterObj->meterId, pQInfo->pointsRead);
+    //    dTrace("QInfo:%p vid:%d sid:%d id:%s, query over, %d points are returned", pQInfo, pMeterObj->vnode,
+    //    pMeterObj->sid,
+    //           pMeterObj->meterId, pQInfo->pointsRead);
 
-//    vnodePrintQueryStatistics(pSupporter);
+    //    vnodePrintQueryStatistics(pSupporter);
     sem_post(&pQInfo->dataReady);
-    
-//    vnodeDecRefCount(pQInfo);
     return;
   }
 
-  /* number of points returned during this query  */
+  // number of points returned during this query
   pQuery->rec.pointsRead = 0;
 
   int64_t st = taosGetTimestampUs();
 
   // group by normal column, sliding window query, interval query are handled by interval query processor
   if (pQuery->intervalTime != 0 || isGroupbyNormalCol(pQuery->pGroupbyExpr)) {  // interval (down sampling operation)
-//    assert(pQuery->checkBufferInLoop == 0 && pQuery->pointsOffset == pQuery->pointsToRead);
-    vnodeSingleTableIntervalProcessor(pQInfo);
+    //    assert(pQuery->checkBufferInLoop == 0 && pQuery->pointsOffset == pQuery->pointsToRead);
+    tableIntervalProcessor(pQInfo);
   } else {
     if (isFixedOutputQuery(pQuery)) {
       assert(pQuery->checkBufferInLoop == 0);
-      vnodeSingleTableFixedOutputProcessor(pQInfo);
+
+      tableFixedOutputProcessor(pQInfo);
     } else {  // diff/add/multiply/subtract/division
       assert(pQuery->checkBufferInLoop == 1);
-      vnodeSingleTableMultiOutputProcessor(pQInfo);
+      tableMultiOutputProcessor(pQInfo);
     }
   }
 
@@ -5336,15 +5352,14 @@ void qTableQuery(void* pReadMsg) {
   /* check if query is killed or not */
   if (isQueryKilled(pQuery)) {
     dTrace("QInfo:%p query is killed", pQInfo);
-//    pQInfo->over = 1;
+    //    pQInfo->over = 1;
   } else {
-//    dTrace("QInfo:%p vid:%d sid:%d id:%s, meter query thread completed, %d points are returned", pQInfo,
-//           pMeterObj->vnode, pMeterObj->sid, pMeterObj->meterId, pQuery->pointsRead);
+    //    dTrace("QInfo:%p vid:%d sid:%d id:%s, meter query thread completed, %d points are returned", pQInfo,
+    //           pMeterObj->vnode, pMeterObj->sid, pMeterObj->meterId, pQuery->pointsRead);
   }
 
   sem_post(&pQInfo->dataReady);
-//  vnodeDecRefCount(pQInfo);
-#endif
+  //  vnodeDecRefCount(pQInfo);
 }
 
 void qSuperTableQuery(void *pReadMsg) {
@@ -5395,3 +5410,860 @@ void qSuperTableQuery(void *pReadMsg) {
 //  vnodeDecRefCount(pQInfo);
 #endif
 }
+
+static int32_t getColumnIndexInSource(SQueryTableMsg *pQueryTableMsg, SSqlFuncExprMsg *pExprMsg) {
+  int32_t j = 0;
+
+  while (j < pQueryTableMsg->numOfCols) {
+    if (pExprMsg->colInfo.colId == pQueryTableMsg->colList[j].colId) {
+      break;
+    }
+
+    j += 1;
+  }
+
+  return j;
+}
+
+bool vnodeValidateExprColumnInfo(SQueryTableMsg *pQueryTableMsg, SSqlFuncExprMsg *pExprMsg) {
+  int32_t j = getColumnIndexInSource(pQueryTableMsg, pExprMsg);
+  return j < pQueryTableMsg->numOfCols;
+}
+
+static int32_t validateQueryMeterMsg(SQueryTableMsg *pQueryTableMsg) {
+  if (pQueryTableMsg->intervalTime < 0) {
+    dError("qmsg:%p illegal value of aggTimeInterval %" PRId64 "", pQueryTableMsg, pQueryTableMsg->intervalTime);
+    return -1;
+  }
+
+  if (pQueryTableMsg->numOfTagsCols < 0 || pQueryTableMsg->numOfTagsCols > TSDB_MAX_TAGS + 1) {
+    dError("qmsg:%p illegal value of numOfTagsCols %d", pQueryTableMsg, pQueryTableMsg->numOfTagsCols);
+    return -1;
+  }
+
+  if (pQueryTableMsg->numOfCols <= 0 || pQueryTableMsg->numOfCols > TSDB_MAX_COLUMNS) {
+    dError("qmsg:%p illegal value of numOfCols %d", pQueryTableMsg, pQueryTableMsg->numOfCols);
+    return -1;
+  }
+
+  if (pQueryTableMsg->numOfTables <= 0) {
+    dError("qmsg:%p illegal value of numOfTables %d", pQueryTableMsg, pQueryTableMsg->numOfTables);
+    return -1;
+  }
+
+  if (pQueryTableMsg->numOfGroupCols < 0) {
+    dError("qmsg:%p illegal value of numOfGroupbyCols %d", pQueryTableMsg, pQueryTableMsg->numOfGroupCols);
+    return -1;
+  }
+
+  if (pQueryTableMsg->numOfOutputCols > TSDB_MAX_COLUMNS || pQueryTableMsg->numOfOutputCols <= 0) {
+    dError("qmsg:%p illegal value of output columns %d", pQueryTableMsg, pQueryTableMsg->numOfOutputCols);
+    return -1;
+  }
+
+  if (pQueryTableMsg->tagLength < 0) {
+    dError("qmsg:%p illegal value of tag length %d", pQueryTableMsg, pQueryTableMsg->tagLength);
+    return -1;
+  }
+
+  return 0;
+}
+
+static int32_t convertQueryTableMsg(SQueryTableMsg *pQueryTableMsg, SArray **pTableIdList) {
+  pQueryTableMsg->vgId = htons(pQueryTableMsg->vgId);
+  pQueryTableMsg->numOfTables = htonl(pQueryTableMsg->numOfTables);
+
+  pQueryTableMsg->window.skey = htobe64(pQueryTableMsg->window.skey);
+  pQueryTableMsg->window.ekey = htobe64(pQueryTableMsg->window.ekey);
+
+  pQueryTableMsg->order = htons(pQueryTableMsg->order);
+  pQueryTableMsg->orderColId = htons(pQueryTableMsg->orderColId);
+
+  pQueryTableMsg->queryType = htons(pQueryTableMsg->queryType);
+
+  pQueryTableMsg->intervalTime = htobe64(pQueryTableMsg->intervalTime);
+  pQueryTableMsg->slidingTime = htobe64(pQueryTableMsg->slidingTime);
+
+  pQueryTableMsg->numOfTagsCols = htons(pQueryTableMsg->numOfTagsCols);
+  pQueryTableMsg->numOfCols = htons(pQueryTableMsg->numOfCols);
+  pQueryTableMsg->numOfOutputCols = htons(pQueryTableMsg->numOfOutputCols);
+  pQueryTableMsg->numOfGroupCols = htons(pQueryTableMsg->numOfGroupCols);
+  pQueryTableMsg->tagLength = htons(pQueryTableMsg->tagLength);
+
+  pQueryTableMsg->limit = htobe64(pQueryTableMsg->limit);
+  pQueryTableMsg->offset = htobe64(pQueryTableMsg->offset);
+
+  pQueryTableMsg->tsOffset = htonl(pQueryTableMsg->tsOffset);
+  pQueryTableMsg->tsLen = htonl(pQueryTableMsg->tsLen);
+  pQueryTableMsg->tsNumOfBlocks = htonl(pQueryTableMsg->tsNumOfBlocks);
+  pQueryTableMsg->tsOrder = htonl(pQueryTableMsg->tsOrder);
+
+  // query msg safety check
+  if (validateQueryMeterMsg(pQueryTableMsg) != 0) {
+    return TSDB_CODE_INVALID_QUERY_MSG;
+  }
+
+  char *pMsg = (char *)(pQueryTableMsg->colList) + sizeof(SColumnInfo) * pQueryTableMsg->numOfCols;
+
+  for (int32_t col = 0; col < pQueryTableMsg->numOfCols; ++col) {
+    pQueryTableMsg->colList[col].colId = htons(pQueryTableMsg->colList[col].colId);
+    pQueryTableMsg->colList[col].type = htons(pQueryTableMsg->colList[col].type);
+    pQueryTableMsg->colList[col].bytes = htons(pQueryTableMsg->colList[col].bytes);
+    pQueryTableMsg->colList[col].numOfFilters = htons(pQueryTableMsg->colList[col].numOfFilters);
+
+    assert(pQueryTableMsg->colList[col].type >= TSDB_DATA_TYPE_BOOL &&
+           pQueryTableMsg->colList[col].type <= TSDB_DATA_TYPE_NCHAR);
+
+    int32_t numOfFilters = pQueryTableMsg->colList[col].numOfFilters;
+
+    if (numOfFilters > 0) {
+      pQueryTableMsg->colList[col].filters = calloc(numOfFilters, sizeof(SColumnFilterInfo));
+    }
+
+    for (int32_t f = 0; f < numOfFilters; ++f) {
+      SColumnFilterInfo *pFilterInfo = (SColumnFilterInfo *)pMsg;
+      SColumnFilterInfo *pDestFilterInfo = &pQueryTableMsg->colList[col].filters[f];
+
+      pDestFilterInfo->filterOnBinary = htons(pFilterInfo->filterOnBinary);
+
+      pMsg += sizeof(SColumnFilterInfo);
+
+      if (pDestFilterInfo->filterOnBinary) {
+        pDestFilterInfo->len = htobe64(pFilterInfo->len);
+
+        pDestFilterInfo->pz = (int64_t)calloc(1, pDestFilterInfo->len + 1);
+        memcpy((void *)pDestFilterInfo->pz, pMsg, pDestFilterInfo->len + 1);
+        pMsg += (pDestFilterInfo->len + 1);
+      } else {
+        pDestFilterInfo->lowerBndi = htobe64(pFilterInfo->lowerBndi);
+        pDestFilterInfo->upperBndi = htobe64(pFilterInfo->upperBndi);
+      }
+
+      pDestFilterInfo->lowerRelOptr = htons(pFilterInfo->lowerRelOptr);
+      pDestFilterInfo->upperRelOptr = htons(pFilterInfo->upperRelOptr);
+    }
+  }
+
+  bool hasArithmeticFunction = false;
+
+  /*
+   * 1. simple projection query on meters, we only record the pSqlFuncExprs[i].colIdx value
+   * 2. for complex queries, whole SqlExprs object is required.
+   */
+  pQueryTableMsg->pSqlFuncExprs = (int64_t)malloc(POINTER_BYTES * pQueryTableMsg->numOfOutputCols);
+  SSqlFuncExprMsg *pExprMsg = (SSqlFuncExprMsg *)pMsg;
+
+  for (int32_t i = 0; i < pQueryTableMsg->numOfOutputCols; ++i) {
+    ((SSqlFuncExprMsg **)pQueryTableMsg->pSqlFuncExprs)[i] = pExprMsg;
+
+    pExprMsg->colInfo.colIdx = htons(pExprMsg->colInfo.colIdx);
+    pExprMsg->colInfo.colId = htons(pExprMsg->colInfo.colId);
+    pExprMsg->colInfo.flag = htons(pExprMsg->colInfo.flag);
+
+    pExprMsg->functionId = htons(pExprMsg->functionId);
+    pExprMsg->numOfParams = htons(pExprMsg->numOfParams);
+
+    pMsg += sizeof(SSqlFuncExprMsg);
+
+    for (int32_t j = 0; j < pExprMsg->numOfParams; ++j) {
+      pExprMsg->arg[j].argType = htons(pExprMsg->arg[j].argType);
+      pExprMsg->arg[j].argBytes = htons(pExprMsg->arg[j].argBytes);
+
+      if (pExprMsg->arg[j].argType == TSDB_DATA_TYPE_BINARY) {
+        pExprMsg->arg[j].argValue.pz = pMsg;
+        pMsg += pExprMsg->arg[j].argBytes + 1;  // one more for the string terminated char.
+      } else {
+        pExprMsg->arg[j].argValue.i64 = htobe64(pExprMsg->arg[j].argValue.i64);
+      }
+    }
+
+    if (pExprMsg->functionId == TSDB_FUNC_ARITHM) {
+      hasArithmeticFunction = true;
+    } else if (pExprMsg->functionId == TSDB_FUNC_TAG || pExprMsg->functionId == TSDB_FUNC_TAGPRJ ||
+               pExprMsg->functionId == TSDB_FUNC_TAG_DUMMY) {
+      if (pExprMsg->colInfo.flag != TSDB_COL_TAG) {  // ignore the column  index check for arithmetic expression.
+        return TSDB_CODE_INVALID_QUERY_MSG;
+      }
+    } else {
+      if (!vnodeValidateExprColumnInfo(pQueryTableMsg, pExprMsg)) {
+        return TSDB_CODE_INVALID_QUERY_MSG;
+      }
+    }
+
+    pExprMsg = (SSqlFuncExprMsg *)pMsg;
+  }
+
+  pQueryTableMsg->colNameLen = htonl(pQueryTableMsg->colNameLen);
+  if (hasArithmeticFunction) {  // column name array
+    assert(pQueryTableMsg->colNameLen > 0);
+    pQueryTableMsg->colNameList = (int64_t)pMsg;
+    pMsg += pQueryTableMsg->colNameLen;
+  }
+
+  *pTableIdList = taosArrayInit(pQueryTableMsg->numOfTables, sizeof(STableIdInfo));
+
+  STableIdInfo *pTableIdInfo = (STableIdInfo *)pMsg;
+  pTableIdInfo->sid = htonl(pTableIdInfo->sid);
+  pTableIdInfo->uid = htobe64(pTableIdInfo->uid);
+  pTableIdInfo->key = htobe64(pTableIdInfo->key);
+
+  taosArrayPush(*pTableIdList, pTableIdInfo);
+  pMsg += sizeof(STableIdInfo);
+
+  for (int32_t j = 1; j < pQueryTableMsg->numOfTables; ++j) {
+    pTableIdInfo = (STableIdInfo *)pMsg;
+
+    pTableIdInfo->sid = htonl(pTableIdInfo->sid);
+    pTableIdInfo->uid = htobe64(pTableIdInfo->uid);
+    pTableIdInfo->key = htobe64(pTableIdInfo->key);
+
+    taosArrayPush(*pTableIdList, pTableIdInfo);
+    pMsg += sizeof(STableIdInfo);
+  }
+
+  if (pQueryTableMsg->numOfGroupCols > 0 || pQueryTableMsg->numOfTagsCols > 0) {  // group by tag columns
+    pQueryTableMsg->pTagSchema = (uint64_t)pMsg;
+    SSchema *pTagSchema = (SSchema *)pQueryTableMsg->pTagSchema;
+    pMsg += sizeof(SSchema) * pQueryTableMsg->numOfTagsCols;
+
+    if (pQueryTableMsg->numOfGroupCols > 0) {
+      pQueryTableMsg->groupbyTagIds = (uint64_t) & (pTagSchema[pQueryTableMsg->numOfTagsCols]);
+    } else {
+      pQueryTableMsg->groupbyTagIds = 0;
+    }
+    pQueryTableMsg->orderByIdx = htons(pQueryTableMsg->orderByIdx);
+    pQueryTableMsg->orderType = htons(pQueryTableMsg->orderType);
+
+    pMsg += sizeof(SColIndexEx) * pQueryTableMsg->numOfGroupCols;
+  } else {
+    pQueryTableMsg->pTagSchema = 0;
+    pQueryTableMsg->groupbyTagIds = 0;
+  }
+
+  pQueryTableMsg->interpoType = htons(pQueryTableMsg->interpoType);
+  if (pQueryTableMsg->interpoType != TSDB_INTERPO_NONE) {
+    pQueryTableMsg->defaultVal = (uint64_t)(pMsg);
+
+    int64_t *v = (int64_t *)pMsg;
+    for (int32_t i = 0; i < pQueryTableMsg->numOfOutputCols; ++i) {
+      v[i] = htobe64(v[i]);
+    }
+  }
+
+  dTrace("qmsg:%p query on %d meter(s), qrange:%" PRId64 "-%" PRId64
+         ", numOfGroupbyTagCols:%d, numOfTagCols:%d, timestamp order:%d, "
+         "tags order:%d, tags order col:%d, numOfOutputCols:%d, numOfCols:%d, interval:%" PRId64
+         ", fillType:%d, comptslen:%d, limit:%" PRId64
+         ", "
+         "offset:%" PRId64,
+         pQueryTableMsg, pQueryTableMsg->numOfTables, pQueryTableMsg->window.skey, pQueryTableMsg->window.ekey,
+         pQueryTableMsg->numOfGroupCols, pQueryTableMsg->numOfTagsCols, pQueryTableMsg->order,
+         pQueryTableMsg->orderType, pQueryTableMsg->orderByIdx, pQueryTableMsg->numOfOutputCols,
+         pQueryTableMsg->numOfCols, pQueryTableMsg->intervalTime, pQueryTableMsg->interpoType, pQueryTableMsg->tsLen,
+         pQueryTableMsg->limit, pQueryTableMsg->offset);
+
+  return 0;
+}
+
+static int32_t buildAirthmeticExprFromMsg(SSqlFunctionExpr *pExpr, SQueryTableMsg *pQueryMsg) {
+  SSqlBinaryExprInfo *pBinaryExprInfo = &pExpr->binExprInfo;
+  SColumnInfo *       pColMsg = pQueryMsg->colList;
+#if 0
+  tSQLBinaryExpr* pBinExpr = NULL;
+  SSchema*        pSchema = toSchema(pQueryMsg, pColMsg, pQueryMsg->numOfCols);
+  
+  dTrace("qmsg:%p create binary expr from string:%s", pQueryMsg, pExpr->pBase.arg[0].argValue.pz);
+  tSQLBinaryExprFromString(&pBinExpr, pSchema, pQueryMsg->numOfCols, pExpr->pBase.arg[0].argValue.pz,
+                           pExpr->pBase.arg[0].argBytes);
+  
+  if (pBinExpr == NULL) {
+    dError("qmsg:%p failed to create arithmetic expression string from:%s", pQueryMsg, pExpr->pBase.arg[0].argValue.pz);
+    return TSDB_CODE_APP_ERROR;
+  }
+  
+  pBinaryExprInfo->pBinExpr = pBinExpr;
+  
+  int32_t num = 0;
+  int16_t ids[TSDB_MAX_COLUMNS] = {0};
+  
+  tSQLBinaryExprTrv(pBinExpr, &num, ids);
+  qsort(ids, num, sizeof(int16_t), id_compar);
+  
+  int32_t i = 0, j = 0;
+  
+  while (i < num && j < num) {
+    if (ids[i] == ids[j]) {
+      j++;
+    } else {
+      ids[++i] = ids[j++];
+    }
+  }
+  assert(i <= num);
+  
+  // there may be duplicated referenced columns.
+  num = i + 1;
+  pBinaryExprInfo->pReqColumns = malloc(sizeof(SColIndexEx) * num);
+  
+  for (int32_t k = 0; k < num; ++k) {
+    SColIndexEx* pColIndex = &pBinaryExprInfo->pReqColumns[k];
+    pColIndex->colId = ids[k];
+  }
+  
+  pBinaryExprInfo->numOfCols = num;
+  free(pSchema);
+#endif
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t createSqlFunctionExprFromMsg(SQueryTableMsg *pQueryMsg, SSqlFunctionExpr **pSqlFuncExpr) {
+  *pSqlFuncExpr = NULL;
+  int32_t code = TSDB_CODE_SUCCESS;
+
+  SSqlFunctionExpr *pExprs = (SSqlFunctionExpr *)calloc(1, sizeof(SSqlFunctionExpr) * pQueryMsg->numOfOutputCols);
+  if (pExprs == NULL) {
+    tfree(pQueryMsg->pSqlFuncExprs);
+    return TSDB_CODE_SERV_OUT_OF_MEMORY;
+  }
+
+  bool    isSuperTable = QUERY_IS_STABLE_QUERY(pQueryMsg->queryType);
+  int16_t tagLen = 0;
+
+  SSchema *pTagSchema = (SSchema *)pQueryMsg->pTagSchema;
+  for (int32_t i = 0; i < pQueryMsg->numOfOutputCols; ++i) {
+    pExprs[i].pBase = *((SSqlFuncExprMsg **)pQueryMsg->pSqlFuncExprs)[i];
+    pExprs[i].resBytes = 0;
+
+    int16_t type = 0;
+    int16_t bytes = 0;
+
+    SColIndexEx *pColumnIndexExInfo = &pExprs[i].pBase.colInfo;
+
+    // tag column schema is kept in pQueryMsg->pColumnModel
+    if (TSDB_COL_IS_TAG(pColumnIndexExInfo->flag)) {
+      if (pColumnIndexExInfo->colIdx >= pQueryMsg->numOfTagsCols) {
+        tfree(pExprs);
+
+        return TSDB_CODE_INVALID_QUERY_MSG;
+      }
+
+      type = pTagSchema[pColumnIndexExInfo->colIdx].type;
+      bytes = pTagSchema[pColumnIndexExInfo->colIdx].bytes;
+
+    } else {  // parse the arithmetic expression
+      if (pExprs[i].pBase.functionId == TSDB_FUNC_ARITHM) {
+        code = buildAirthmeticExprFromMsg(&pExprs[i], pQueryMsg);
+
+        if (code != TSDB_CODE_SUCCESS) {
+          tfree(pExprs);
+          return code;
+        }
+
+        type = TSDB_DATA_TYPE_DOUBLE;
+        bytes = tDataTypeDesc[type].nSize;
+      } else {  // parse the normal column
+        int32_t j = getColumnIndexInSource(pQueryMsg, &pExprs[i].pBase);
+        assert(j < pQueryMsg->numOfCols);
+
+        SColumnInfo *pCol = &pQueryMsg->colList[j];
+        type = pCol->type;
+        bytes = pCol->bytes;
+      }
+    }
+
+    int32_t param = pExprs[i].pBase.arg[0].argValue.i64;
+    if (getResultDataInfo(type, bytes, pExprs[i].pBase.functionId, param, &pExprs[i].resType, &pExprs[i].resBytes,
+                          &pExprs[i].interResBytes, 0, isSuperTable) != TSDB_CODE_SUCCESS) {
+      tfree(pExprs);
+      return TSDB_CODE_INVALID_QUERY_MSG;
+    }
+
+    if (pExprs[i].pBase.functionId == TSDB_FUNC_TAG_DUMMY || pExprs[i].pBase.functionId == TSDB_FUNC_TS_DUMMY) {
+      tagLen += pExprs[i].resBytes;
+    }
+    assert(isValidDataType(pExprs[i].resType, pExprs[i].resBytes));
+  }
+
+  // get the correct result size for top/bottom query, according to the number of tags columns in selection clause
+
+  // TODO refactor
+  for (int32_t i = 0; i < pQueryMsg->numOfOutputCols; ++i) {
+    pExprs[i].pBase = *((SSqlFuncExprMsg **)pQueryMsg->pSqlFuncExprs)[i];
+    int16_t functId = pExprs[i].pBase.functionId;
+    if (functId == TSDB_FUNC_TOP || functId == TSDB_FUNC_BOTTOM) {
+      int32_t j = getColumnIndexInSource(pQueryMsg, &pExprs[i].pBase);
+      assert(j < pQueryMsg->numOfCols);
+
+      SColumnInfo *pCol = &pQueryMsg->colList[j];
+      int16_t      type = pCol->type;
+      int16_t      bytes = pCol->bytes;
+
+      int32_t ret =
+          getResultDataInfo(type, bytes, pExprs[i].pBase.functionId, pExprs[i].pBase.arg[0].argValue.i64,
+                            &pExprs[i].resType, &pExprs[i].resBytes, &pExprs[i].interResBytes, tagLen, isSuperTable);
+      assert(ret == TSDB_CODE_SUCCESS);
+    }
+  }
+
+  tfree(pQueryMsg->pSqlFuncExprs);
+  *pSqlFuncExpr = pExprs;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static SSqlGroupbyExpr *createGroupbyExprFromMsg(SQueryTableMsg *pQueryMsg, int32_t *code) {
+  if (pQueryMsg->numOfGroupCols == 0) {
+    return NULL;
+  }
+
+  // using group by tag columns
+  SSqlGroupbyExpr *pGroupbyExpr =
+      (SSqlGroupbyExpr *)malloc(sizeof(SSqlGroupbyExpr) + pQueryMsg->numOfGroupCols * sizeof(SColIndexEx));
+  if (pGroupbyExpr == NULL) {
+    *code = TSDB_CODE_SERV_OUT_OF_MEMORY;
+    return NULL;
+  }
+
+  SColIndexEx *pGroupbyColInfo = (SColIndexEx *)pQueryMsg->groupbyTagIds;
+
+  pGroupbyExpr->numOfGroupCols = pQueryMsg->numOfGroupCols;
+  pGroupbyExpr->orderType = pQueryMsg->orderType;
+  pGroupbyExpr->orderIndex = pQueryMsg->orderByIdx;
+
+  memcpy(pGroupbyExpr->columnInfo, pGroupbyColInfo, sizeof(SColIndexEx) * pGroupbyExpr->numOfGroupCols);
+  return pGroupbyExpr;
+}
+
+static int32_t vnodeCreateFilterInfo(void *pQInfo, SQuery *pQuery) {
+  for (int32_t i = 0; i < pQuery->numOfCols; ++i) {
+    if (pQuery->colList[i].info.numOfFilters > 0) {
+      pQuery->numOfFilterCols++;
+    }
+  }
+
+  if (pQuery->numOfFilterCols == 0) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  pQuery->pFilterInfo = calloc(1, sizeof(SSingleColumnFilterInfo) * pQuery->numOfFilterCols);
+
+  for (int32_t i = 0, j = 0; i < pQuery->numOfCols; ++i) {
+    if (pQuery->colList[i].info.numOfFilters > 0) {
+      SSingleColumnFilterInfo *pFilterInfo = &pQuery->pFilterInfo[j];
+
+      memcpy(&pFilterInfo->info, &pQuery->colList[i], sizeof(SColumnInfoEx));
+      pFilterInfo->info.info.filters = NULL;
+
+      pFilterInfo->numOfFilters = pQuery->colList[i].info.numOfFilters;
+      pFilterInfo->pFilters = calloc(pFilterInfo->numOfFilters, sizeof(SColumnFilterElem));
+
+      for (int32_t f = 0; f < pFilterInfo->numOfFilters; ++f) {
+        SColumnFilterElem *pSingleColFilter = &pFilterInfo->pFilters[f];
+        pSingleColFilter->filterInfo = pQuery->colList[i].info.filters[f];
+
+        int32_t lower = pSingleColFilter->filterInfo.lowerRelOptr;
+        int32_t upper = pSingleColFilter->filterInfo.upperRelOptr;
+
+        if (lower == TSDB_RELATION_INVALID && upper == TSDB_RELATION_INVALID) {
+          dError("QInfo:%p invalid filter info", pQInfo);
+          return TSDB_CODE_INVALID_QUERY_MSG;
+        }
+
+        int16_t type = pQuery->colList[i].info.type;
+        int16_t bytes = pQuery->colList[i].info.bytes;
+
+        __filter_func_t *rangeFilterArray = NULL;  // vnodeGetRangeFilterFuncArray(type);
+        __filter_func_t *filterArray = NULL;       // vnodeGetValueFilterFuncArray(type);
+
+        if (rangeFilterArray == NULL && filterArray == NULL) {
+          dError("QInfo:%p failed to get filter function, invalid data type:%d", pQInfo, type);
+          return TSDB_CODE_INVALID_QUERY_MSG;
+        }
+
+        if ((lower == TSDB_RELATION_LARGE_EQUAL || lower == TSDB_RELATION_LARGE) &&
+            (upper == TSDB_RELATION_LESS_EQUAL || upper == TSDB_RELATION_LESS)) {
+          if (lower == TSDB_RELATION_LARGE_EQUAL) {
+            if (upper == TSDB_RELATION_LESS_EQUAL) {
+              pSingleColFilter->fp = rangeFilterArray[4];
+            } else {
+              pSingleColFilter->fp = rangeFilterArray[2];
+            }
+          } else {
+            if (upper == TSDB_RELATION_LESS_EQUAL) {
+              pSingleColFilter->fp = rangeFilterArray[3];
+            } else {
+              pSingleColFilter->fp = rangeFilterArray[1];
+            }
+          }
+        } else {  // set callback filter function
+          if (lower != TSDB_RELATION_INVALID) {
+            pSingleColFilter->fp = filterArray[lower];
+
+            if (upper != TSDB_RELATION_INVALID) {
+              dError("pQInfo:%p failed to get filter function, invalid filter condition", pQInfo, type);
+              return TSDB_CODE_INVALID_QUERY_MSG;
+            }
+          } else {
+            pSingleColFilter->fp = filterArray[upper];
+          }
+        }
+        assert(pSingleColFilter->fp != NULL);
+        pSingleColFilter->bytes = bytes;
+      }
+
+      j++;
+    }
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static SQInfo *createQInfoImpl(SQueryTableMsg *pQueryMsg, SSqlGroupbyExpr *pGroupbyExpr, SSqlFunctionExpr *pExprs,
+                               SArray *pTableIdList) {
+  SQInfo *pQInfo = (SQInfo *)calloc(1, sizeof(SQInfo));
+  if (pQInfo == NULL) {
+    goto _clean_memory;
+  }
+
+  SQuery *pQuery = calloc(1, sizeof(SQuery));
+  pQInfo->runtimeEnv.pQuery = pQuery;
+
+  int16_t numOfCols = pQueryMsg->numOfCols;
+  int16_t numOfOutputCols = pQueryMsg->numOfOutputCols;
+
+  pQuery->numOfCols = numOfCols;
+  pQuery->numOfOutputCols = numOfOutputCols;
+
+  pQuery->limit.limit = pQueryMsg->limit;
+  pQuery->limit.offset = pQueryMsg->offset;
+
+  pQuery->order.order = pQueryMsg->order;
+  pQuery->order.orderColId = pQueryMsg->orderColId;
+
+  pQuery->pSelectExpr = pExprs;
+  pQuery->pGroupbyExpr = pGroupbyExpr;
+
+  pQuery->intervalTime = pQueryMsg->intervalTime;
+
+  pQuery->slidingTime = pQueryMsg->slidingTime;
+  pQuery->slidingTimeUnit = pQueryMsg->slidingTimeUnit;
+
+  pQuery->interpoType = pQueryMsg->interpoType;
+
+  pQuery->colList = calloc(1, sizeof(SSingleColumnFilterInfo) * numOfCols);
+  if (pQuery->colList == NULL) {
+    goto _clean_memory;
+  }
+
+  for (int16_t i = 0; i < numOfCols; ++i) {
+    pQuery->colList[i].info = pQueryMsg->colList[i];
+    //    SColumnInfo *pColInfo = &pQuery->colList[i].data;
+    //    pColInfo->filters = NULL;
+    //    if (colList[i].numOfFilters > 0) {
+    //      pColInfo->filters = calloc(1, colList[i].numOfFilters * sizeof(SColumnFilterInfo));
+    //
+    //      for (int32_t j = 0; j < colList[i].numOfFilters; ++j) {
+    //        tscColumnFilterInfoCopy(&pColInfo->filters[j], &colList[i].filters[j]);
+    //      }
+    //    } else {
+    //      pQuery->colList[i].data.filters = NULL;
+    //    }
+  }
+
+  // calculate the result row size
+  for (int16_t col = 0; col < numOfOutputCols; ++col) {
+    assert(pExprs[col].resBytes > 0);
+    pQuery->rowSize += pExprs[col].resBytes;
+  }
+
+  int32_t ret = vnodeCreateFilterInfo(pQInfo, pQuery);
+  if (ret != TSDB_CODE_SUCCESS) {
+    goto _clean_memory;
+  }
+
+  // prepare the result buffer
+  pQuery->sdata = (SData **)calloc(pQuery->numOfOutputCols, sizeof(SData *));
+  if (pQuery->sdata == NULL) {
+    goto _clean_memory;
+  }
+
+  // set the output buffer capacity
+  pQuery->capacity = 4096;
+  for (int32_t col = 0; col < pQuery->numOfOutputCols; ++col) {
+    assert(pExprs[col].interResBytes >= pExprs[col].resBytes);
+
+    // allocate additional memory for interResults that are usually larger then final results
+    size_t size = (pQuery->capacity + 1) * pExprs[col].resBytes + pExprs[col].interResBytes + sizeof(SData);
+    pQuery->sdata[col] = (SData *)calloc(1, size);
+    if (pQuery->sdata[col] == NULL) {
+      goto _clean_memory;
+    }
+  }
+
+  if (pQuery->interpoType != TSDB_INTERPO_NONE) {
+    pQuery->defaultVal = malloc(sizeof(int64_t) * pQuery->numOfOutputCols);
+    if (pQuery->defaultVal == NULL) {
+      goto _clean_memory;
+    }
+
+    // the first column is the timestamp
+    memcpy(pQuery->defaultVal, (char *)pQueryMsg->defaultVal, pQuery->numOfOutputCols * sizeof(int64_t));
+  }
+
+  // to make sure third party won't overwrite this structure
+  pQInfo->signature = (uint64_t)pQInfo;
+  pQInfo->pTableIdList = pTableIdList;
+
+  pQuery->pos = -1;
+  //  dTrace("vid:%d sid:%d meterId:%s, QInfo is allocated:%p", pMeterObj->vnode, pMeterObj->sid, pMeterObj->meterId,
+  //  pQInfo);
+
+  return pQInfo;
+
+_clean_memory:
+  tfree(pQuery->defaultVal);
+
+  if (pQuery->sdata != NULL) {
+    for (int16_t col = 0; col < pQuery->numOfOutputCols; ++col) {
+      tfree(pQuery->sdata[col]);
+    }
+  }
+
+  tfree(pQuery->sdata);
+  tfree(pQuery->pFilterInfo);
+  tfree(pQuery->colList);
+
+  tfree(pExprs);
+  tfree(pGroupbyExpr);
+
+  tfree(pQInfo);
+
+  return NULL;
+}
+
+bool isQInfoValid(void *param) {
+  SQInfo *pQInfo = (SQInfo *)param;
+  if (pQInfo == NULL) {
+    return false;
+  }
+
+  /*
+   * pQInfo->signature may be changed by another thread, so we assign value of signature
+   * into local variable, then compare by using local variable
+   */
+  uint64_t sig = pQInfo->signature;
+  return (sig == (uint64_t)pQInfo);
+}
+
+void vnodeFreeQInfo(SQInfo *pQInfo, bool decQueryRef) {
+  if (!isQInfoValid(pQInfo)) {
+    return;
+  }
+
+  pQInfo->killed = 1;
+  dTrace("QInfo:%p start to free SQInfo", pQInfo);
+
+  if (decQueryRef) {
+    vnodeDecMeterRefcnt(pQInfo);
+  }
+
+  SQuery *pQuery = pQInfo->runtimeEnv.pQuery;
+
+  for (int col = 0; col < pQuery->numOfOutputCols; ++col) {
+    tfree(pQuery->sdata[col]);
+  }
+
+  //  for (int col = 0; col < pQuery->numOfCols; ++col) {
+  //    vnodeFreeColumnInfo(&pQuery->colList[col].data);
+  //  }
+  //
+  //  if (pQuery->colList[0].colIdx != PRIMARYKEY_TIMESTAMP_COL_INDEX) {
+  //    tfree(pQuery->tsData);
+  //  }
+
+  sem_destroy(&(pQInfo->dataReady));
+  vnodeQueryFreeQInfoEx(pQInfo);
+
+  for (int32_t i = 0; i < pQuery->numOfFilterCols; ++i) {
+    SSingleColumnFilterInfo *pColFilter = &pQuery->pFilterInfo[i];
+    if (pColFilter->numOfFilters > 0) {
+      tfree(pColFilter->pFilters);
+    }
+  }
+
+  tfree(pQuery->pFilterInfo);
+  tfree(pQuery->colList);
+  tfree(pQuery->sdata);
+
+  if (pQuery->pSelectExpr != NULL) {
+    for (int32_t i = 0; i < pQuery->numOfOutputCols; ++i) {
+      SSqlBinaryExprInfo *pBinExprInfo = &pQuery->pSelectExpr[i].binExprInfo;
+
+      if (pBinExprInfo->numOfCols > 0) {
+        tfree(pBinExprInfo->pReqColumns);
+        tSQLBinaryExprDestroy(&pBinExprInfo->pBinExpr, NULL);
+      }
+    }
+
+    tfree(pQuery->pSelectExpr);
+  }
+
+  if (pQuery->defaultVal != NULL) {
+    tfree(pQuery->defaultVal);
+  }
+
+  tfree(pQuery->pGroupbyExpr);
+  tfree(pQuery);
+
+  //  dTrace("QInfo:%p vid:%d sid:%d meterId:%s, QInfo is freed", pQInfo, pObj->vnode, pObj->sid, pObj->meterId);
+
+  // destroy signature, in order to avoid the query process pass the object safety check
+  memset(pQInfo, 0, sizeof(SQInfo));
+  tfree(pQInfo);
+}
+
+static int32_t createQInfo(SQueryTableMsg *pQueryMsg, SSqlGroupbyExpr *pGroupbyExpr, SSqlFunctionExpr *pSqlExprs,
+                           SArray *pTableIdList, void* tsdb, SQInfo **pQInfo) {
+  int32_t code = TSDB_CODE_SUCCESS;
+
+  (*pQInfo) = createQInfoImpl(pQueryMsg, pGroupbyExpr, pSqlExprs, pTableIdList);
+  if (pQInfo == NULL) {
+    code = TSDB_CODE_SERV_OUT_OF_MEMORY;
+    goto _error;
+  }
+
+  SQuery *pQuery = (*pQInfo)->runtimeEnv.pQuery;
+  dTrace("qmsg:%p create QInfo:%p, QInfo created", pQueryMsg, pQInfo);
+
+  pQuery->window.skey = pQueryMsg->window.skey;
+  pQuery->window.ekey = pQueryMsg->window.ekey;
+
+  pQuery->lastKey = pQuery->window.skey;
+
+  if (sem_init(&(*pQInfo)->dataReady, 0, 0) != 0) {
+    //    dError("QInfo:%p vid:%d sid:%d meterId:%s, init dataReady sem failed, reason:%s", pQInfo, pMeterObj->vnode,
+    //           pMeterObj->sid, pMeterObj->meterId, strerror(errno));
+    code = TSDB_CODE_APP_ERROR;
+    goto _error;
+  }
+
+  vnodeParametersSafetyCheck(pQuery);
+
+  STSBuf *pTSBuf = NULL;
+  if (pQueryMsg->tsLen > 0) {  // open new file to save the result
+    char *tsBlock = (char *)pQueryMsg + pQueryMsg->tsOffset;
+    pTSBuf = tsBufCreateFromCompBlocks(tsBlock, pQueryMsg->tsNumOfBlocks, pQueryMsg->tsLen, pQueryMsg->tsOrder);
+
+    tsBufResetPos(pTSBuf);
+    tsBufNextPos(pTSBuf);
+  }
+
+  if ((code = vnodeQueryTablePrepare(*pQInfo, pTSBuf, tsdb)) != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
+  //  if (pQInfo->over == 1) {
+  //    vnodeAddRefCount(pQInfo);  // for retrieve procedure
+  //    return pQInfo;
+  //  }
+
+  // dTrace("QInfo:%p set query flag and prepare runtime environment completed, ref:%d, wait for schedule", pQInfo,
+  //       pQInfo->refCount);
+  return code;
+
+_error:
+  // table query ref will be decrease during error handling
+  vnodeFreeQInfo(*pQInfo, false);
+  return code;
+}
+
+int32_t qCreateQueryInfo(void* tsdb, SQueryTableMsg *pQueryTableMsg, SQInfo **pQInfo) {
+  assert(pQueryTableMsg != NULL);
+
+  int32_t code = TSDB_CODE_SUCCESS;
+  SArray *pTableIdList = NULL;
+  if ((code = convertQueryTableMsg(pQueryTableMsg, &pTableIdList)) != TSDB_CODE_SUCCESS) {
+    return code;
+  }
+
+  if (pQueryTableMsg->numOfTables <= 0) {
+    dError("Invalid number of tables to query, numOfTables:%d", pQueryTableMsg->numOfTables);
+    code = TSDB_CODE_INVALID_QUERY_MSG;
+    goto _query_over;
+  }
+
+  // todo check vnode status
+  if (pTableIdList == NULL || taosArrayGetSize(pTableIdList) == 0) {
+    dError("qmsg:%p, SQueryTableMsg wrong format", pQueryTableMsg);
+    code = TSDB_CODE_INVALID_QUERY_MSG;
+    goto _query_over;
+  }
+
+  SSqlFunctionExpr *pExprs = NULL;
+  if ((code = createSqlFunctionExprFromMsg(pQueryTableMsg, &pExprs)) != TSDB_CODE_SUCCESS) {
+    goto _query_over;
+  }
+
+  SSqlGroupbyExpr *pGroupbyExpr = createGroupbyExprFromMsg(pQueryTableMsg, &code);
+  if ((pGroupbyExpr == NULL && pQueryTableMsg->numOfGroupCols != 0) || code != TSDB_CODE_SUCCESS) {
+    goto _query_over;
+  }
+
+  if (QUERY_IS_STABLE_QUERY(pQueryTableMsg->queryType)) {
+    //    pObj->qhandle = vnodeQueryOnMultiMeters(pMeterObjList, pGroupbyExpr, pExprs, pQueryTableMsg, &code);
+  } else {
+    code = createQInfo(pQueryTableMsg, pGroupbyExpr, pExprs, pTableIdList, tsdb, pQInfo);
+  }
+
+_query_over:
+  if (code != TSDB_CODE_SUCCESS) {
+    taosArrayDestroy(pTableIdList);
+  }
+
+  // if failed to add ref for all meters in this query, abort current query
+  //  if (code != TSDB_CODE_SUCCESS) {
+  //    vnodeDecQueryRefCount(pQueryTableMsg, pMeterObjList, incNumber);
+  //  }
+  //
+  //  tfree(pQueryTableMsg->pSqlFuncExprs);
+  //  tfree(pMeterObjList);
+  //  ret = vnodeSendQueryRspMsg(pObj, code, pObj->qhandle);
+  //
+  //  tfree(pQueryTableMsg->pSidExtInfo);
+  //  for(int32_t i = 0; i < pQueryTableMsg->numOfCols; ++i) {
+  //    vnodeFreeColumnInfo(&pQueryTableMsg->colList[i]);
+  //  }
+  //
+  //  atomic_fetch_add_32(&vnodeSelectReqNum, 1);
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t qRetrieveQueryResultInfo(SQInfo *pQInfo, int32_t *numOfRows, int32_t *rowsize) {
+  if (pQInfo == NULL || !isQInfoValid(pQInfo)) {
+    return TSDB_CODE_INVALID_QHANDLE;
+  }
+
+  if (pQInfo->killed) {
+    dTrace("QInfo:%p query is killed, code:%d", pQInfo, pQInfo->code);
+    if (pQInfo->code == TSDB_CODE_SUCCESS) {
+      return TSDB_CODE_QUERY_CANCELLED;
+    } else {  // in case of not TSDB_CODE_SUCCESS, return the code to client
+      return abs(pQInfo->code);
+    }
+  }
+
+  sem_wait(&pQInfo->dataReady);
+
+  SQuery *pQuery = pQInfo->runtimeEnv.pQuery;
+
+  //  *numOfRows = pQInfo->rec.pointsRead;
+  //  *rowsize = pQuery->rowSize;
+  *numOfRows = 1;
+
+  //  dTrace("QInfo:%p, retrieve data info completed, precision:%d, rowsize:%d, rows:%d, code:%d", pQInfo, *timePrec,
+  //         *rowsize, *numOfRows, pQInfo->code);
+
+  if (pQInfo->code < 0) {  // less than 0 means there are error existed.
+    return -pQInfo->code;
+  }
+}

src/rpc/src/rpcMain.c

@@ -287,7 +287,7 @@ void rpcClose(void *param) {
   (*taosCleanUpConn[pRpc->connType])(pRpc->udphandle);
 
   for (int i = 0; i < pRpc->sessions; ++i) {
-    if (pRpc->connList[i].user[0]) {
+    if (pRpc->connList && pRpc->connList[i].user[0]) {
       rpcCloseConn((void *)(pRpc->connList + i));
     }
   }
@@ -495,9 +495,10 @@ static void rpcCloseConn(void *thandle) {
   SRpcConn *pConn = (SRpcConn *)thandle;
   SRpcInfo *pRpc = pConn->pRpc;
 
+  if (pConn->user[0] == 0) return;
+
   rpcLockConn(pConn);
 
-  if (pConn->user[0]) {
   pConn->user[0] = 0;
   if (taosCloseConn[pConn->connType]) (*taosCloseConn[pConn->connType])(pConn->chandle);
 
@@ -522,7 +523,6 @@ static void rpcCloseConn(void *thandle) {
   pConn->pContext = NULL;
 
   tTrace("%s %p, rpc connection is closed", pRpc->label, pConn);
-  }
 
   rpcUnlockConn(pConn);
 }

src/util/inc/tlist.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef _TD_LIST_
+#define _TD_LIST_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum { TD_LIST_FORWARD, TD_LIST_BACKWARD } TD_LIST_DIRECTION_T;
+
+typedef struct _list_node {
+  struct _list_node *next;
+  struct _list_node *prev;
+  char               data[];
+} SListNode;
+
+typedef struct {
+  struct _list_node *head;
+  struct _list_node *tail;
+  int                numOfEles;
+  int                eleSize;
+} SList;
+
+typedef struct {
+  SListNode *         next;
+  TD_LIST_DIRECTION_T direction;
+} SListIter;
+
+#define listHead(l) (l)->head
+#define listTail(l) (l)->tail
+#define listNEles(l) (l)->numOfEles
+#define listEleSize(l) (l)->eleSize
+#define isListEmpty(l) ((l)->numOfEles == 0)
+#define listNodeFree(n) free(n);
+
+SList *    tdListNew(int eleSize);
+void       tdListFree(SList *list);
+void       tdListEmpty(SList *list);
+void       tdListPrependNode(SList *list, SListNode *node);
+void       tdListAppendNode(SList *list, SListNode *node);
+int        tdListPrepend(SList *list, void *data);
+int        tdListAppend(SList *list, void *data);
+SListNode *tdListPopHead(SList *list);
+SListNode *tdListPopTail(SList *list);
+SListNode *tdListPopNode(SList *list, SListNode *node);
+void       tdListMove(SList *src, SList *dst);
+
+void       tdListNodeGetData(SList *list, SListNode *node, void *target);
+void       tdListInitIter(SList *list, SListIter *pIter, TD_LIST_DIRECTION_T direction);
+SListNode *tdListNext(SListIter *pIter);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
\ No newline at end of file

src/util/src/tlist.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+#include <stdlib.h>
+#include <string.h>
+
+#include "tlist.h"
+
+SList *tdListNew(int eleSize) {
+  SList *list = (SList *)malloc(sizeof(SList));
+  if (list == NULL) return NULL;
+
+  list->eleSize = eleSize;
+  list->numOfEles = 0;
+  list->head = list->tail = NULL;
+  return list;
+}
+
+void tdListEmpty(SList *list) {
+  SListNode *node = list->head;
+  while (node) {
+    list->head = node->next;
+    free(node);
+    node = list->head;
+  }
+  list->head = list->tail = 0;
+  list->numOfEles = 0;
+}
+
+void tdListFree(SList *list) {
+  tdListEmpty(list);
+  free(list);
+}
+
+void tdListPrependNode(SList *list, SListNode *node) {
+  if (list->head == NULL) {
+    list->head = node;
+    list->tail = node;
+  } else {
+    node->next = list->head;
+    node->prev = NULL;
+    list->head->prev = node;
+    list->head = node;
+  }
+  list->numOfEles++;
+}
+
+void tdListAppendNode(SList *list, SListNode *node) {
+  if (list->head == NULL) {
+    list->head = node;
+    list->tail = node;
+  } else {
+    node->prev = list->tail;
+    node->next = NULL;
+    list->tail->next = node;
+    list->tail = node;
+  }
+
+  list->numOfEles++;
+}
+
+int tdListPrepend(SList *list, void *data) {
+  SListNode *node = (SListNode *)malloc(sizeof(SListNode) + list->eleSize);
+  if (node == NULL) return -1;
+
+  memcpy((void *)(node->data), data, list->eleSize);
+  tdListPrependNode(list, node);
+
+  return 0;
+}
+
+int tdListAppend(SList *list, void *data) {
+  SListNode *node = (SListNode *)malloc(sizeof(SListNode) + list->eleSize);
+  if (node == NULL) return -1;
+
+  memcpy((void *)(node->data), data, list->eleSize);
+  tdListAppendNode(list, node);
+
+  return 0;
+}
+
+SListNode *tdListPopHead(SList *list) {
+  if (list->head == NULL) return NULL;
+  SListNode *node = list->head;
+  if (node->next == NULL) {
+    list->head = NULL;
+    list->tail = NULL;
+  } else {
+    list->head = node->next;
+  }
+  list->numOfEles--;
+  return node;
+}
+
+SListNode *tdListPopTail(SList *list) {
+  if (list->tail == NULL) return NULL;
+  SListNode *node = list->tail;
+  if (node->prev == NULL) {
+    list->head = NULL;
+    list->tail = NULL;
+  } else {
+    list->tail = node->prev;
+  }
+  list->numOfEles--;
+  return node;
+}
+
+SListNode *tdListPopNode(SList *list, SListNode *node) {
+  if (list->head == node) {
+    list->head = node->next;
+  }
+  if (list->tail == node) {
+    list->tail = node->prev;
+  }
+
+  if (node->prev != NULL) {
+    node->prev->next = node->next;
+  }
+  if (node->next != NULL) {
+    node->next->prev = node->prev;
+  }
+  list->numOfEles--;
+
+  return node;
+}
+
+// Move all node elements from src to dst, the dst is assumed as an empty list
+void tdListMove(SList *src, SList *dst) {
+  // assert(dst->eleSize == src->eleSize);
+  dst->numOfEles = src->numOfEles;
+  dst->head = src->head;
+  dst->tail = src->tail;
+  src->numOfEles = 0;
+  src->head = src->tail = NULL;
+}
+
+void tdListNodeGetData(SList *list, SListNode *node, void *target) { memcpy(target, node->data, list->eleSize); }
+
+void tdListInitIter(SList *list, SListIter *pIter, TD_LIST_DIRECTION_T direction) {
+  pIter->direction = direction;
+  if (direction == TD_LIST_FORWARD) {
+    pIter->next = list->head;
+  } else {
+    pIter->next = list->tail;
+  }
+}
+
+SListNode *tdListNext(SListIter *pIter) {
+  SListNode *node = pIter->next;
+  if (node == NULL) return NULL;
+  if (pIter->direction == TD_LIST_FORWARD) {
+    pIter->next = node->next;
+  } else {
+    pIter->next = node->prev;
+  }
+
+  return node;
+}
\ No newline at end of file

src/util/src/tskiplist.c

@@ -15,7 +15,6 @@
 #include "os.h"
 
 #include "tlog.h"
-// #include "tsdb.h"
 #include "tskiplist.h"
 #include "tutil.h"
 
@@ -395,6 +394,7 @@ SSkipListNode *tSkipListPut(SSkipList *pSkipList, SSkipListNode *pNode) {
   SSkipListNode *px = pSkipList->pHead;
   SSkipListNode *forward[MAX_SKIP_LIST_LEVEL] = {0};
 
+  bool identical = false;
   for (int32_t i = pSkipList->level - 1; i >= 0; --i) {
     SSkipListNode *p = SL_GET_FORWARD_POINTER(px, i);
     while (p != NULL) {
@@ -402,11 +402,16 @@ SSkipListNode *tSkipListPut(SSkipList *pSkipList, SSkipListNode *pNode) {
       char *newDatakey = SL_GET_NODE_KEY(pSkipList, pNode);
 
       // if the forward element is less than the specified key, forward one step
-      if (pSkipList->comparFn(key, newDatakey) < 0) {
+      int32_t ret = pSkipList->comparFn(key, newDatakey);
+      if (ret < 0) {
         px = p;
 
         p = SL_GET_FORWARD_POINTER(px, i);
       } else {
+        if (identical == false) {
+          identical = (ret == 0);
+        }
+        
         break;
       }
     }
@@ -418,18 +423,13 @@ SSkipListNode *tSkipListPut(SSkipList *pSkipList, SSkipListNode *pNode) {
   }
 
   // if the skip list does not allowed identical key inserted, the new data will be discarded.
-  if (pSkipList->keyInfo.dupKey == 0 && forward[0] != pSkipList->pHead) {
-    char *key = SL_GET_NODE_KEY(pSkipList, forward[0]);
-    char *pNewDataKey = SL_GET_NODE_KEY(pSkipList, pNode);
-
-    if (pSkipList->comparFn(key, pNewDataKey) == 0) {
+  if (pSkipList->keyInfo.dupKey == 0 && identical) {
     if (pSkipList->lock) {
       pthread_rwlock_unlock(pSkipList->lock);
     }
 
     return forward[0];
   }
-  }
 
 #if SKIP_LIST_RECORD_PERFORMANCE
   recordNodeEachLevel(pSkipList, level);

src/vnode/tsdb/inc/tsdb.h

@@ -58,6 +58,9 @@ int32_t        tsdbDropRepo(tsdb_repo_t *repo);
 tsdb_repo_t *  tsdbOpenRepo(char *tsdbDir);
 int32_t        tsdbCloseRepo(tsdb_repo_t *repo);
 int32_t        tsdbConfigRepo(tsdb_repo_t *repo, STsdbCfg *pCfg);
+int32_t        tsdbTriggerCommit(tsdb_repo_t *repo);
+int32_t        tsdbLockRepo(tsdb_repo_t *repo);
+int32_t        tsdbUnLockRepo(tsdb_repo_t *repo);
 
 // --------- TSDB TABLE DEFINITION
 typedef struct {
@@ -87,15 +90,6 @@ int tsdbCreateTable(tsdb_repo_t *repo, STableCfg *pCfg);
 int tsdbDropTable(tsdb_repo_t *pRepo, STableId tableId);
 int tsdbAlterTable(tsdb_repo_t *repo, STableCfg *pCfg);
 
-// Submit message for one table
-typedef struct {
-  STableId tableId;
-  int32_t  padding;    // TODO just for padding here
-  int32_t  sversion;   // data schema version
-  int32_t  len;        // data part length, not including the SSubmitBlk head
-  char     data[];
-} SSubmitBlk;
-
 typedef struct {
   int32_t  totalLen;
   int32_t  len;
@@ -105,15 +99,10 @@ typedef struct {
 int      tsdbInitSubmitBlkIter(SSubmitBlk *pBlock, SSubmitBlkIter *pIter);
 SDataRow tsdbGetSubmitBlkNext(SSubmitBlkIter *pIter);
 
-// Submit message for this TSDB
-typedef struct {
-  int32_t    length;
-  int32_t    compressed;
-  SSubmitBlk blocks[];
-} SSubmitMsg;
-
 #define TSDB_SUBMIT_MSG_HEAD_SIZE sizeof(SSubmitMsg)
 
+struct STsdbRepo;
+
 // SSubmitMsg Iterator
 typedef struct {
   int32_t totalLen;
@@ -242,7 +231,7 @@ typedef void *tsdbpos_t;
  * @param pTableList    table sid list
  * @return
  */
-tsdb_query_handle_t *tsdbQueryByTableId(STsdbQueryCond *pCond, SArray *idList, SArray *pColumnInfo);
+tsdb_query_handle_t *tsdbQueryByTableId(tsdb_repo_t* tsdb, STsdbQueryCond *pCond, SArray *idList, SArray *pColumnInfo);
 
 /**
  * move to next block

src/vnode/tsdb/inc/tsdbCache.h

@@ -17,45 +17,50 @@
 
 #include <stdint.h>
 
-// #include "cache.h"
+#include "taosdef.h"
+#include "tlist.h"
+#include "tsdb.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#define TSDB_DEFAULT_CACHE_BLOCK_SIZE 16*1024*1024 /* 16M */
+#define TSDB_DEFAULT_CACHE_BLOCK_SIZE 16 * 1024 * 1024 /* 16M */
 
 typedef struct {
-  int64_t skey;     // start key
-  int64_t ekey;     // end key
-  int32_t numOfRows; // numOfRows
-} STableCacheInfo;
+  int  blockId;
+  int  offset;
+  int  remain;
+  int  padding;
+  char data[];
+} STsdbCacheBlock;
 
-typedef struct _tsdb_cache_block {
-  char *                    pData;
-  STableCacheInfo *         pTableInfo;
-  struct _tsdb_cache_block *prev;
-  struct _tsdb_cache_block *next;
-} STSDBCacheBlock;
+typedef struct {
+  int64_t index;
+  SList * memPool;
+} STsdbCachePool;
 
-// Use a doublely linked list to implement this
-typedef struct STSDBCache {
-  // Number of blocks the cache is allocated
-  int32_t          numOfBlocks;
-  STSDBCacheBlock *cacheList;
-  void *           current;
-} STsdbCache;
+typedef struct {
+  TSKEY   keyFirst;
+  TSKEY   keyLast;
+  int64_t numOfPoints;
+  SList * list;
+} SCacheMem;
 
-// ---- Operation on STSDBCacheBlock
-#define TSDB_CACHE_BLOCK_DATA(pBlock) ((pBlock)->pData)
-#define TSDB_CACHE_AVAIL_SPACE(pBlock) ((char *)((pBlock)->pTableInfo) - ((pBlock)->pData))
-#define TSDB_TABLE_INFO_OF_CACHE(pBlock, tableId) ((pBlock)->pTableInfo)[tableId]
-#define TSDB_NEXT_CACHE_BLOCK(pBlock) ((pBlock)->next)
-#define TSDB_PREV_CACHE_BLOCK(pBlock) ((pBlock)->prev)
+typedef struct {
+  int              maxBytes;
+  int              cacheBlockSize;
+  int              totalCacheBlocks;
+  STsdbCachePool   pool;
+  STsdbCacheBlock *curBlock;
+  SCacheMem *      mem;
+  SCacheMem *      imem;
+  tsdb_repo_t *    pRepo;
+} STsdbCache;
 
-STsdbCache *tsdbInitCache(int64_t maxSize);
-int32_t     tsdbFreeCache(STsdbCache *pCache);
-void *      tsdbAllocFromCache(STsdbCache *pCache, int64_t bytes);
+STsdbCache *tsdbInitCache(int maxBytes, int cacheBlockSize, tsdb_repo_t *pRepo);
+void        tsdbFreeCache(STsdbCache *pCache);
+void *      tsdbAllocFromCache(STsdbCache *pCache, int bytes, TSKEY key);
 
 #ifdef __cplusplus
 }

src/vnode/tsdb/inc/tsdbFile.h

@@ -18,16 +18,20 @@
 #include <stdint.h>
 
 #include "taosdef.h"
+#include "tglobalcfg.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+#define tsdbGetKeyFileId(key, daysPerFile, precision) ((key) / tsMsPerDay[(precision)] / (daysPerFile))
+#define tsdbGetMaxNumOfFiles(keep, daysPerFile) ((keep) / (daysPerFile) + 3)
+
 typedef enum {
-  TSDB_FILE_TYPE_HEAD,  // .head file type
+  TSDB_FILE_TYPE_HEAD = 0,  // .head file type
   TSDB_FILE_TYPE_DATA,      // .data file type
   TSDB_FILE_TYPE_LAST,      // .last file type
-  TSDB_FILE_TYPE_META   // .meta file type
+  TSDB_FILE_TYPE_MAX
 } TSDB_FILE_TYPE;
 
 extern const char *tsdbFileSuffix[];
@@ -38,16 +42,15 @@ typedef struct {
 } SFileInfo;
 
 typedef struct {
-  int     fd;
+  int8_t  type;
+  char    fname[128];
   int64_t size;      // total size of the file
   int64_t tombSize;  // unused file size
 } SFile;
 
 typedef struct {
   int32_t fileId;
-  SFile   fhead;
-  SFile   fdata;
-  SFile   flast;
+  SFile   files[TSDB_FILE_TYPE_MAX];
 } SFileGroup;
 
 // TSDB file handle
@@ -56,17 +59,38 @@ typedef struct {
   int32_t    keep;
   int32_t    minRowPerFBlock;
   int32_t    maxRowsPerFBlock;
+  int32_t    maxTables;
   SFileGroup fGroup[];
 } STsdbFileH;
 
-#define IS_VALID_TSDB_FILE_TYPE(type) ((type) >= TSDB_FILE_TYPE_HEAD && (type) <= TSDB_FILE_TYPE_META)
+/**
+ * if numOfSubBlocks == -1, then the SCompBlock is a sub-block
+ * if numOfSubBlocks == 1, then the SCompBlock refers to the data block, and offset/len refer to
+ *                         the data block offset and length
+ * if numOfSubBlocks > 1, then the offset/len refer to the offset of the first sub-block in the
+ * binary
+ */
+typedef struct {
+  int64_t last : 1;          // If the block in data file or last file
+  int64_t offset : 63;       // Offset of data block or sub-block index depending on numOfSubBlocks
+  int32_t algorithm : 8;     // Compression algorithm
+  int32_t numOfPoints : 24;  // Number of total points
+  int32_t sversion;          // Schema version
+  int32_t len;               // Data block length or nothing
+  int16_t numOfSubBlocks;    // Number of sub-blocks;
+  int16_t numOfCols;
+  TSKEY   keyFirst;
+  TSKEY   keyLast;
+} SCompBlock;
 
-STsdbFileH *tsdbInitFile(char *dataDir, int32_t daysPerFile, int32_t keep, int32_t minRowsPerFBlock,
-                         int32_t maxRowsPerFBlock);
-void        tsdbCloseFile(STsdbFileH *pFileH);
+#define IS_VALID_TSDB_FILE_TYPE(type) ((type) >= TSDB_FILE_TYPE_HEAD && (type) < TSDB_FILE_TYPE_MAX)
 
-char *tsdbGetFileName(char *dirName, char *fname, TSDB_FILE_TYPE type);
+STsdbFileH *tsdbInitFile(char *dataDir, int32_t daysPerFile, int32_t keep, int32_t minRowsPerFBlock,
+                         int32_t maxRowsPerFBlock, int32_t maxTables);
 
+void  tsdbCloseFile(STsdbFileH *pFileH);
+int   tsdbCreateFileGroup(char *dataDir, int fileId, SFileGroup *pFGroup, int maxTables);
+void  tsdbGetKeyRangeOfFileId(int32_t daysPerFile, int8_t precision, int32_t fileId, TSKEY *minKey, TSKEY *maxKey);
 #ifdef __cplusplus
 }
 #endif

src/vnode/tsdb/inc/tsdbMeta.h

@@ -33,19 +33,25 @@ extern "C" {
 
 #define IS_CREATE_STABLE(pCfg) ((pCfg)->tagValues != NULL)
 
+typedef struct {
+  TSKEY   keyFirst;
+  TSKEY   keyLast;
+  int32_t numOfPoints;
+  void *  pData;
+} SMemTable;
+
 // ---------- TSDB TABLE DEFINITION
 typedef struct STable {
   int8_t         type;
   STableId       tableId;
-  int32_t         superUid;  // Super table UID
+  int64_t        superUid;  // Super table UID
   int32_t        sversion;
   STSchema *     schema;
   STSchema *     tagSchema;
   SDataRow       tagVal;
-  union {
-    void *pData;   // For TSDB_NORMAL_TABLE and TSDB_CHILD_TABLE, it is the skiplist for cache data
-    void *pIndex;  // For TSDB_SUPER_TABLE, it is the skiplist index
-  } content;
+  SMemTable *    mem;
+  SMemTable *    imem;
+  void *         pIndex;         // For TSDB_SUPER_TABLE, it is the skiplist index
   void *         eventHandler;   // TODO
   void *         streamHandler;  // TODO
   struct STable *next;           // TODO: remove the next
@@ -68,6 +74,8 @@ typedef struct {
   void *map; // table map of (uid ===> table)
 
   SMetaFile *mfh; // meta file handle
+  int        maxRowBytes;
+  int        maxCols;
 } STsdbMeta;
 
 STsdbMeta *tsdbInitMeta(const char *rootDir, int32_t maxTables);
@@ -90,11 +98,14 @@ int32_t    tsdbFreeMeta(STsdbMeta *pMeta);
 #define TSDB_TABLE_OF_ID(pHandle, id) ((pHandle)->pTables)[id]
 #define TSDB_GET_TABLE_OF_NAME(pHandle, name) /* TODO */
 
+STsdbMeta* tsdbGetMeta(tsdb_repo_t* pRepo);
+
 int32_t tsdbCreateTableImpl(STsdbMeta *pMeta, STableCfg *pCfg);
 int32_t tsdbDropTableImpl(STsdbMeta *pMeta, STableId tableId);
 STable *tsdbIsValidTableToInsert(STsdbMeta *pMeta, STableId tableId);
-int32_t tsdbInsertRowToTableImpl(SSkipListNode *pNode, STable *pTable);
+// int32_t tsdbInsertRowToTableImpl(SSkipListNode *pNode, STable *pTable);
 STable *tsdbGetTableByUid(STsdbMeta *pMeta, int64_t uid);
+char *getTupleKey(const void * data);
 
 #ifdef __cplusplus
 }

src/vnode/tsdb/src/tsdbCache.c

@@ -14,24 +14,126 @@
  */
 #include <stdlib.h>
 
+#include "tsdb.h"
 #include "tsdbCache.h"
 
-STsdbCache *tsdbInitCache(int64_t maxSize) {
-  STsdbCache *pCacheHandle = (STsdbCache *)malloc(sizeof(STsdbCache));
-  if (pCacheHandle == NULL) {
-    // TODO : deal with the error
-    return NULL;
+static int tsdbAllocBlockFromPool(STsdbCache *pCache);
+static void tsdbFreeBlockList(SCacheMem *mem);
+
+STsdbCache *tsdbInitCache(int maxBytes, int cacheBlockSize, tsdb_repo_t *pRepo) {
+  STsdbCache *pCache = (STsdbCache *)calloc(1, sizeof(STsdbCache));
+  if (pCache == NULL) return NULL;
+
+  if (cacheBlockSize < 0) cacheBlockSize = TSDB_DEFAULT_CACHE_BLOCK_SIZE;
+
+  pCache->maxBytes = maxBytes;
+  pCache->cacheBlockSize = cacheBlockSize;
+  pCache->pRepo = pRepo;
+
+  int nBlocks = maxBytes / cacheBlockSize + 1;
+  if (nBlocks <= 1) nBlocks = 2;
+  pCache->totalCacheBlocks = nBlocks;
+
+  STsdbCachePool *pPool = &(pCache->pool);
+  pPool->index = 0;
+  pPool->memPool = tdListNew(sizeof(STsdbCacheBlock *));
+  if (pPool->memPool == NULL) goto _err;
+
+  for (int i = 0; i < nBlocks; i++) {
+    STsdbCacheBlock *pBlock = (STsdbCacheBlock *)malloc(sizeof(STsdbCacheBlock) + cacheBlockSize);
+    if (pBlock == NULL) {
+      goto _err;
+    }
+    pBlock->offset = 0;
+    pBlock->remain = cacheBlockSize;
+    tdListAppend(pPool->memPool, (void *)(&pBlock));
   }
 
-  return pCacheHandle;
+  pCache->mem = NULL;
+  pCache->imem = NULL;
+
+  return pCache;
+
+_err:
+  tsdbFreeCache(pCache);
+  return NULL;
+}
+
+void tsdbFreeCache(STsdbCache *pCache) {
+  tsdbFreeBlockList(pCache->imem);
+  tsdbFreeBlockList(pCache->mem);
+  tsdbFreeBlockList(pCache->pool.memPool);
+  free(pCache);
 }
 
-int32_t tsdbFreeCache(STsdbCache *pHandle) { return 0; }
+void *tsdbAllocFromCache(STsdbCache *pCache, int bytes, TSKEY key) {
+  if (pCache == NULL) return NULL;
+  if (bytes > pCache->cacheBlockSize) return NULL;
 
-void *tsdbAllocFromCache(STsdbCache *pCache, int64_t bytes) {
-  // TODO: implement here
-  void *ptr = malloc(bytes);
-  if (ptr == NULL) return NULL;
+  if (pCache->curBlock == NULL || pCache->curBlock->remain < bytes) {
+    if (pCache->curBlock !=NULL && (pCache->mem->list) >= pCache->totalCacheBlocks/2) {
+      tsdbTriggerCommit(pCache->pRepo);
+    }
+    if (tsdbAllocBlockFromPool(pCache) < 0) {
+      // TODO: deal with the error
+    }
+  } 
+
+  void *ptr = (void *)(pCache->curBlock->data + pCache->curBlock->offset);
+  pCache->curBlock->offset += bytes;
+  pCache->curBlock->remain -= bytes;
+  memset(ptr, 0, bytes);
+  if (key < pCache->mem->keyFirst) pCache->mem->keyFirst = key;
+  if (key > pCache->mem->keyLast) pCache->mem->keyLast = key;
+  pCache->mem->numOfPoints++;
 
   return ptr;
 }
+
+static void tsdbFreeBlockList(SCacheMem *mem) {
+  if (mem == NULL) return;
+  SList *          list = mem->list;
+  SListNode *      node = NULL;
+  STsdbCacheBlock *pBlock = NULL;
+  while ((node = tdListPopHead(list)) != NULL) {
+    tdListNodeGetData(list, node, (void *)(&pBlock));
+    free(pBlock);
+    listNodeFree(node);
+  }
+  tdListFree(list);
+  free(mem);
+}
+
+static int tsdbAllocBlockFromPool(STsdbCache *pCache) {
+  STsdbCachePool *pPool = &(pCache->pool);
+  
+  tsdbLockRepo(pCache->pRepo);
+  if (listNEles(pPool->memPool) == 0) {
+    tsdbUnLockRepo(pCache->pRepo);
+    return -1;
+  }
+
+  SListNode *node = tdListPopHead(pPool->memPool);
+  
+  STsdbCacheBlock *pBlock = NULL;
+  tdListNodeGetData(pPool->memPool, node, (void *)(&pBlock));
+  pBlock->blockId = pPool->index++;
+  pBlock->offset = 0;
+  pBlock->remain = pCache->cacheBlockSize;
+
+  if (pCache->mem == NULL) { // Create a new one
+    pCache->mem = (SCacheMem *)malloc(sizeof(SCacheMem));
+    if (pCache->mem == NULL) return NULL;
+    pCache->mem->keyFirst = INT64_MAX;
+    pCache->mem->keyLast = 0;
+    pCache->mem->numOfPoints = 0;
+    pCache->mem->list = tdListNew(sizeof(STsdbCacheBlock *));
+  }
+
+  tdListAppendNode(pCache->mem->list, node);
+  pCache->curBlock = pBlock;
+
+  tsdbUnLockRepo(pCache->pRepo);
+
+  return 0;
+}
\ No newline at end of file

src/vnode/tsdb/src/tsdbFile.c

@@ -12,82 +12,159 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
+#include <dirent.h>
+#include <fcntl.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <stdint.h>
 #include <string.h>
-#include <dirent.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
 
 #include "tsdbFile.h"
-#include "tglobalcfg.h"
-
-// int64_t tsMsPerDay[] = {
-//     86400000L,       // TSDB_PRECISION_MILLI
-//     86400000000L,    // TSDB_PRECISION_MICRO
-//     86400000000000L  // TSDB_PRECISION_NANO
-// };
 
-#define tsdbGetKeyFileId(key, daysPerFile, precision) ((key) / tsMsPerDay[(precision)] / (daysPerFile))
-#define tsdbGetMaxNumOfFiles(keep, daysPerFile) ((keep) / (daysPerFile) + 3)
+#define TSDB_FILE_HEAD_SIZE 512
+#define TSDB_FILE_DELIMITER 0xF00AFA0F
 
 typedef struct {
+  int32_t len;
+  int32_t padding;  // For padding purpose
   int64_t offset;
-} SCompHeader;
+} SCompIdx;
 
 typedef struct {
+  int32_t    delimiter;  // For recovery usage
+  int32_t    checksum;   // TODO: decide if checksum logic in this file or make it one API
   int64_t    uid;
-  int64_t last : 1;
-  int64_t numOfBlocks : 63;
-  int32_t delimiter;
+  int32_t    padding;      // For padding purpose
+  int32_t    numOfBlocks;  // TODO: make the struct padding
+  SCompBlock blocks[];
 } SCompInfo;
 
+// TODO: take pre-calculation into account
 typedef struct {
-  TSKEY   keyFirst;
-  TSKEY   keyLast;
-  int32_t numOfBlocks;
-  int32_t offset;
-} SCompIdx;
+  int16_t colId;  // Column ID
+  int16_t len;    // Column length
+  int32_t type : 8;
+  int32_t offset : 24;
+} SCompCol;
 
+// TODO: Take recover into account
 typedef struct {
-  TSKEY   keyFirst;
-  TSKEY   keyLast;
-  int64_t offset;
-  int32_t len;
-  int32_t sversion;
-} SCompBlock;
-
-typedef struct {
-  int64_t uid;
-} SBlock;
-
-typedef struct {
-  int16_t colId;
-  int16_t bytes;
-  int32_t nNullPoints;
-  int32_t type:8;
-  int32_t offset:24;
-  int32_t len;
-  // fields for pre-aggregate
-  // TODO: pre-aggregation should be seperated
-  int64_t sum;
-  int64_t max;
-  int64_t min;
-  int16_t maxIdx;
-  int16_t minIdx;
-} SField;
+  int32_t  delimiter;  // For recovery usage
+  int32_t  numOfCols;  // For recovery usage
+  int64_t  uid;        // For recovery usage
+  SCompCol cols[];
+} SCompData;
 
 const char *tsdbFileSuffix[] = {
     ".head",  // TSDB_FILE_TYPE_HEAD
     ".data",  // TSDB_FILE_TYPE_DATA
-    ".last",  // TSDB_FILE_TYPE_LAST
-    ".meta"   // TSDB_FILE_TYPE_META
+    ".last"   // TSDB_FILE_TYPE_LAST
 };
 
+static int tsdbWriteFileHead(int fd, SFile *pFile) {
+  char head[TSDB_FILE_HEAD_SIZE] = "\0";
+
+  pFile->size += TSDB_FILE_HEAD_SIZE;
+
+  // TODO: write version and File statistic to the head
+  lseek(fd, 0, SEEK_SET);
+  if (write(fd, head, TSDB_FILE_HEAD_SIZE) < 0) return -1;
+
+  return 0;
+}
+
+static int tsdbWriteHeadFileIdx(int fd, int maxTables, SFile *pFile) {
+  int   size = sizeof(SCompIdx) * maxTables;
+  void *buf = calloc(1, size);
+  if (buf == NULL) return -1;
+
+  if (lseek(fd, TSDB_FILE_HEAD_SIZE, SEEK_SET) < 0) {
+    free(buf);
+    return -1;
+  }
+
+  if (write(fd, buf, size) < 0) {
+    free(buf);
+    return -1;
+  }
+
+  pFile->size += size;
+
+  return 0;
+}
+
+static int tsdbGetFileName(char *dataDir, int fileId, int8_t type, char *fname) {
+  if (dataDir == NULL || fname == NULL || !IS_VALID_TSDB_FILE_TYPE(type)) return -1;
+
+  sprintf(fname, "%s/f%d%s", dataDir, fileId, tsdbFileSuffix[type]);
+
+  return 0;
+}
+
+/**
+ * Create a file and set the SFile object
+ */
+static int tsdbCreateFile(char *dataDir, int fileId, int8_t type, int maxTables, SFile *pFile) {
+  memset((void *)pFile, 0, sizeof(SFile));
+  pFile->type = type;
+
+  tsdbGetFileName(dataDir, fileId, type, pFile->fname);
+  if (access(pFile->fname, F_OK) == 0) {
+    // File already exists
+    return -1;
+  }
+
+  int fd = open(pFile->fname, O_WRONLY | O_CREAT, 0755);
+  if (fd < 0) return -1;
+
+  if (type == TSDB_FILE_TYPE_HEAD) {
+    if (tsdbWriteHeadFileIdx(fd, maxTables, pFile) < 0) {
+      close(fd);
+      return -1;
+    }
+  }
+
+  if (tsdbWriteFileHead(fd, pFile) < 0) {
+    close(fd);
+    return -1;
+  }
+
+  close(fd);
+
+  return 0;
+}
+
+static int tsdbRemoveFile(SFile *pFile) {
+  if (pFile == NULL) return -1;
+  return remove(pFile->fname);
+}
+
+// Create a file group with fileId and return a SFileGroup object
+int tsdbCreateFileGroup(char *dataDir, int fileId, SFileGroup *pFGroup, int maxTables) {
+  if (dataDir == NULL || pFGroup == NULL) return -1;
+
+  memset((void *)pFGroup, 0, sizeof(SFileGroup));
+
+  for (int type = TSDB_FILE_TYPE_HEAD; type < TSDB_FILE_TYPE_MAX; type++) {
+    if (tsdbCreateFile(dataDir, fileId, type, maxTables, &(pFGroup->files[type])) < 0) {
+      // TODO: deal with the error here, remove the created files
+      return -1;
+    }
+  }
+
+  pFGroup->fileId = fileId;
+
+  return 0;
+}
+
 /**
  * Initialize the TSDB file handle
  */
 STsdbFileH *tsdbInitFile(char *dataDir, int32_t daysPerFile, int32_t keep, int32_t minRowsPerFBlock,
-                         int32_t maxRowsPerFBlock) {
+                         int32_t maxRowsPerFBlock, int32_t maxTables) {
   STsdbFileH *pTsdbFileH =
       (STsdbFileH *)calloc(1, sizeof(STsdbFileH) + sizeof(SFileGroup) * tsdbGetMaxNumOfFiles(keep, daysPerFile));
   if (pTsdbFileH == NULL) return NULL;
@@ -96,6 +173,7 @@ STsdbFileH *tsdbInitFile(char *dataDir, int32_t daysPerFile, int32_t keep, int32
   pTsdbFileH->keep = keep;
   pTsdbFileH->minRowPerFBlock = minRowsPerFBlock;
   pTsdbFileH->maxRowsPerFBlock = maxRowsPerFBlock;
+  pTsdbFileH->maxTables = maxTables;
 
   // Open the directory to read information of each file
   DIR *dir = opendir(dataDir);
@@ -104,8 +182,9 @@ STsdbFileH *tsdbInitFile(char *dataDir, int32_t daysPerFile, int32_t keep, int32
     return NULL;
   }
 
-  struct dirent *dp;
   char fname[256];
+
+  struct dirent *dp;
   while ((dp = readdir(dir)) != NULL) {
     if (strncmp(dp->d_name, ".", 1) == 0 || strncmp(dp->d_name, "..", 2) == 0) continue;
     if (true /* check if the file is the .head file */) {
@@ -125,24 +204,7 @@ STsdbFileH *tsdbInitFile(char *dataDir, int32_t daysPerFile, int32_t keep, int32
   return pTsdbFileH;
 }
 
-/**
- * Closet the file handle
- */
-void tsdbCloseFile(STsdbFileH *pFileH) {
-  // TODO
-}
-
-char *tsdbGetFileName(char *dirName, char *fname, TSDB_FILE_TYPE type) {
-  if (!IS_VALID_TSDB_FILE_TYPE(type)) return NULL;
-
-  char *fileName = (char *)malloc(strlen(dirName) + strlen(fname) + strlen(tsdbFileSuffix[type]) + 5);
-  if (fileName == NULL) return NULL;
-
-  sprintf(fileName, "%s/%s%s", dirName, fname, tsdbFileSuffix[type]);
-  return fileName;
-}
-
-static void tsdbGetKeyRangeOfFileId(int32_t daysPerFile, int8_t precision, int32_t fileId, TSKEY *minKey,
+void tsdbGetKeyRangeOfFileId(int32_t daysPerFile, int8_t precision, int32_t fileId, TSKEY *minKey,
                                     TSKEY *maxKey) {
   *minKey = fileId * daysPerFile * tsMsPerDay[precision];
   *maxKey = *minKey + daysPerFile * tsMsPerDay[precision] - 1;

src/vnode/tsdb/src/tsdbMain.c

@@ -44,6 +44,7 @@
 
 #define TSDB_CFG_FILE_NAME "CONFIG"
 #define TSDB_DATA_DIR_NAME "data"
+#define TSDB_DEFAULT_FILE_BLOCK_ROW_OPTION 0.7
 
 enum { TSDB_REPO_STATE_ACTIVE, TSDB_REPO_STATE_CLOSED, TSDB_REPO_STATE_CONFIGURING };
 
@@ -58,13 +59,16 @@ typedef struct _tsdb_repo {
   // The cache Handle
   STsdbCache *tsdbCache;
 
+  // The TSDB file handle
+  STsdbFileH *tsdbFileH;
+
   // Disk tier handle for multi-tier storage
   void *diskTier;
 
-  // File Store
-  void *tsdbFiles;
+  pthread_mutex_t mutex;
 
-  pthread_mutex_t tsdbMutex;
+  int commit;
+  pthread_t commitThread;
 
   // A limiter to monitor the resources used by tsdb
   void *limiter;
@@ -79,6 +83,8 @@ static int32_t tsdbDestroyRepoEnv(STsdbRepo *pRepo);
 static int     tsdbOpenMetaFile(char *tsdbDir);
 static int32_t tsdbInsertDataToTable(tsdb_repo_t *repo, SSubmitBlk *pBlock);
 static int32_t tsdbRestoreCfg(STsdbRepo *pRepo, STsdbCfg *pCfg);
+static int32_t tsdbGetDataDirName(STsdbRepo *pRepo, char *fname);
+static void *  tsdbCommitToFile(void *arg);
 
 #define TSDB_GET_TABLE_BY_ID(pRepo, sid) (((STSDBRepo *)pRepo)->pTableList)[sid]
 #define TSDB_GET_TABLE_BY_NAME(pRepo, name)
@@ -144,6 +150,7 @@ tsdb_repo_t *tsdbCreateRepo(char *rootDir, STsdbCfg *pCfg, void *limiter /* TODO
   pRepo->rootDir = strdup(rootDir);
   pRepo->config = *pCfg;
   pRepo->limiter = limiter;
+  pthread_mutex_init(&pRepo->mutex, NULL);
 
   // Create the environment files and directories
   if (tsdbSetRepoEnv(pRepo) < 0) {
@@ -162,7 +169,7 @@ tsdb_repo_t *tsdbCreateRepo(char *rootDir, STsdbCfg *pCfg, void *limiter /* TODO
   pRepo->tsdbMeta = pMeta;
 
   // Initialize cache
-  STsdbCache *pCache = tsdbInitCache(pCfg->maxCacheSize);
+  STsdbCache *pCache = tsdbInitCache(pCfg->maxCacheSize, -1, (tsdb_repo_t *)pRepo);
   if (pCache == NULL) {
     free(pRepo->rootDir);
     tsdbFreeMeta(pRepo->tsdbMeta);
@@ -171,6 +178,19 @@ tsdb_repo_t *tsdbCreateRepo(char *rootDir, STsdbCfg *pCfg, void *limiter /* TODO
   }
   pRepo->tsdbCache = pCache;
 
+  // Initialize file handle
+  char dataDir[128] = "\0";
+  tsdbGetDataDirName(pRepo, dataDir);
+  pRepo->tsdbFileH =
+      tsdbInitFile(dataDir, pCfg->daysPerFile, pCfg->keep, pCfg->minRowsPerFileBlock, pCfg->maxRowsPerFileBlock, pCfg->maxTables);
+  if (pRepo->tsdbFileH == NULL) {
+    free(pRepo->rootDir);
+    tsdbFreeCache(pRepo->tsdbCache);
+    tsdbFreeMeta(pRepo->tsdbMeta);
+    free(pRepo);
+    return NULL;
+  }
+
   pRepo->state = TSDB_REPO_STATE_ACTIVE;
 
   return (tsdb_repo_t *)pRepo;
@@ -230,7 +250,7 @@ tsdb_repo_t *tsdbOpenRepo(char *tsdbDir) {
     return NULL;
   }
 
-  pRepo->tsdbCache = tsdbInitCache(pRepo->config.maxCacheSize);
+  pRepo->tsdbCache = tsdbInitCache(pRepo->config.maxCacheSize, -1, (tsdb_repo_t *)pRepo);
   if (pRepo->tsdbCache == NULL) {
     tsdbFreeMeta(pRepo->tsdbMeta);
     free(pRepo->rootDir);
@@ -284,6 +304,45 @@ int32_t tsdbConfigRepo(tsdb_repo_t *repo, STsdbCfg *pCfg) {
   return 0;
 }
 
+int32_t tsdbTriggerCommit(tsdb_repo_t *repo) {
+  STsdbRepo *pRepo = (STsdbRepo *)repo;
+  
+  tsdbLockRepo(repo);
+  if (pRepo->commit) {
+    tsdbUnLockRepo(repo);
+    return -1;
+  }
+  pRepo->commit = 1;
+  // Loop to move pData to iData
+  for (int i = 0; i < pRepo->config.maxTables; i++) {
+    STable *pTable = pRepo->tsdbMeta->tables[i];
+    if (pTable != NULL && pTable->mem != NULL) {
+      pTable->imem = pTable->mem;
+      pTable->mem = NULL;
+    }
+  }
+  // TODO: Loop to move mem to imem
+  pRepo->tsdbCache->imem = pRepo->tsdbCache->mem;
+  pRepo->tsdbCache->mem = NULL;
+  pRepo->tsdbCache->curBlock = NULL;
+
+  // TODO: here should set as detached or use join for memory leak
+  pthread_create(&(pRepo->commitThread), NULL, tsdbCommitToFile, (void *)repo);
+  tsdbUnLockRepo(repo);
+
+  return 0;
+}
+
+int32_t tsdbLockRepo(tsdb_repo_t *repo) {
+  STsdbRepo *pRepo = (STsdbRepo *)repo;
+  return pthread_mutex_lock(repo);
+}
+
+int32_t tsdbUnLockRepo(tsdb_repo_t *repo) {
+  STsdbRepo *pRepo = (STsdbRepo *)repo;
+  return pthread_mutex_unlock(repo);
+}
+
 /**
  * Get the TSDB repository information, including some statistics
  * @param pRepo the TSDB repository handle
@@ -440,6 +499,10 @@ SDataRow tsdbGetSubmitBlkNext(SSubmitBlkIter *pIter) {
 int tsdbInitSubmitMsgIter(SSubmitMsg *pMsg, SSubmitMsgIter *pIter) {
   if (pMsg == NULL || pIter == NULL) return -1;
 
+  pMsg->length = htonl(pMsg->length);
+  pMsg->numOfBlocks = htonl(pMsg->numOfBlocks);
+  pMsg->compressed = htonl(pMsg->compressed);
+  
   pIter->totalLen = pMsg->length;
   pIter->len = TSDB_SUBMIT_MSG_HEAD_SIZE;
   if (pMsg->length <= TSDB_SUBMIT_MSG_HEAD_SIZE) {
@@ -455,6 +518,14 @@ SSubmitBlk *tsdbGetSubmitMsgNext(SSubmitMsgIter *pIter) {
   SSubmitBlk *pBlock = pIter->pBlock;
   if (pBlock == NULL) return NULL;
   
+  pBlock->len = htonl(pBlock->len);
+  pBlock->numOfRows = htons(pBlock->numOfRows);
+  pBlock->uid = htobe64(pBlock->uid);
+  pBlock->tid = htonl(pBlock->tid);
+  
+  pBlock->sversion = htonl(pBlock->sversion);
+  pBlock->padding = htonl(pBlock->padding);
+  
   pIter->len = pIter->len + sizeof(SSubmitBlk) + pBlock->len;
   if (pIter->len >= pIter->totalLen) {
     pIter->pBlock = NULL;
@@ -465,6 +536,11 @@ SSubmitBlk *tsdbGetSubmitMsgNext(SSubmitMsgIter *pIter) {
   return pBlock;
 }
 
+STsdbMeta* tsdbGetMeta(tsdb_repo_t* pRepo) {
+  STsdbRepo *tsdb = (STsdbRepo *)pRepo;
+  return tsdb->tsdbMeta;
+}
+
 // Check the configuration and set default options
 static int32_t tsdbCheckAndSetDefaultCfg(STsdbCfg *pCfg) {
   // Check precision
@@ -612,9 +688,6 @@ static int32_t tsdbDestroyRepoEnv(STsdbRepo *pRepo) {
 
   rmdir(dirName);
 
-  char *metaFname = tsdbGetFileName(pRepo->rootDir, "tsdb", TSDB_FILE_TYPE_META);
-  remove(metaFname);
-
   return 0;
 }
 
@@ -628,10 +701,21 @@ static int32_t tdInsertRowToTable(STsdbRepo *pRepo, SDataRow row, STable *pTable
   int32_t level = 0;
   int32_t headSize = 0;
 
-  tSkipListRandNodeInfo(pTable->content.pData, &level, &headSize);
+  if (pTable->mem == NULL) {
+    pTable->mem = (SMemTable *)calloc(1, sizeof(SMemTable));
+    if (pTable->mem == NULL) return -1;
+    pTable->mem->pData = tSkipListCreate(5, TSDB_DATA_TYPE_TIMESTAMP, TYPE_BYTES[TSDB_DATA_TYPE_TIMESTAMP], 0, 0, getTupleKey);
+    pTable->mem->keyFirst = INT64_MAX;
+    pTable->mem->keyLast = 0;
+  }
+
+  tSkipListRandNodeInfo(pTable->mem->pData, &level, &headSize);
+
+  TSKEY key = dataRowKey(row);
+  printf("insert:%lld, size:%d\n", key, pTable->mem->numOfPoints);
   
   // Copy row into the memory
-  SSkipListNode *pNode = tsdbAllocFromCache(pRepo->tsdbCache, headSize + dataRowLen(row));
+  SSkipListNode *pNode = tsdbAllocFromCache(pRepo->tsdbCache, headSize + dataRowLen(row), key);
   if (pNode == NULL) {
     // TODO: deal with allocate failure
   }
@@ -640,7 +724,19 @@ static int32_t tdInsertRowToTable(STsdbRepo *pRepo, SDataRow row, STable *pTable
   dataRowCpy(SL_GET_NODE_DATA(pNode), row);
 
   // Insert the skiplist node into the data
-  tsdbInsertRowToTableImpl(pNode, pTable);
+  if (pTable->mem == NULL) {
+    pTable->mem = (SMemTable *)calloc(1, sizeof(SMemTable));
+    if (pTable->mem == NULL) return -1;
+    pTable->mem->pData = tSkipListCreate(5, TSDB_DATA_TYPE_TIMESTAMP, TYPE_BYTES[TSDB_DATA_TYPE_TIMESTAMP], 0, 0, getTupleKey);
+    pTable->mem->keyFirst = INT64_MAX;
+    pTable->mem->keyLast = 0;
+  }
+  tSkipListPut(pTable->mem->pData, pNode);
+  if (key > pTable->mem->keyLast) pTable->mem->keyLast = key;
+  if (key < pTable->mem->keyFirst) pTable->mem->keyFirst = key;
+  
+  pTable->mem->numOfPoints = tSkipListGetSize(pTable->mem->pData);
+//  pTable->mem->numOfPoints++;
 
   return 0;
 }
@@ -648,7 +744,8 @@ static int32_t tdInsertRowToTable(STsdbRepo *pRepo, SDataRow row, STable *pTable
 static int32_t tsdbInsertDataToTable(tsdb_repo_t *repo, SSubmitBlk *pBlock) {
   STsdbRepo *pRepo = (STsdbRepo *)repo;
 
-  STable *pTable = tsdbIsValidTableToInsert(pRepo->tsdbMeta, pBlock->tableId);
+  STableId tableId = {.uid = pBlock->uid, .tid = pBlock->tid};
+  STable *pTable = tsdbIsValidTableToInsert(pRepo->tsdbMeta, tableId);
   if (pTable == NULL) return -1;
 
   SSubmitBlkIter blkIter;
@@ -663,3 +760,105 @@ static int32_t tsdbInsertDataToTable(tsdb_repo_t *repo, SSubmitBlk *pBlock) {
 
   return 0;
 }
+
+static int tsdbReadRowsFromCache(SSkipListIterator *pIter, TSKEY maxKey, int maxRowsToRead, SDataCol **cols, STSchema *pSchema) {
+  int numOfRows = 0;
+  do {
+    SSkipListNode *node = tSkipListIterGet(pIter);
+    if (node == NULL) break;
+
+    SDataRow row = SL_GET_NODE_DATA(node);
+    if (dataRowKey(row) > maxKey) break;
+    // Convert row data to column data
+    // for (int i = 0; i < schemaNCols(pSchema); i++) {
+    //   STColumn *pCol = schemaColAt(pSchema, i);
+    //   memcpy(cols[i]->data + TYPE_BYTES[colType(pCol)] * numOfRows, dataRowAt(row, pCol->offset),
+    //          TYPE_BYTES[colType(pCol)]);
+    // }
+
+    numOfRows++;
+    if (numOfRows > maxRowsToRead) break;
+  } while (tSkipListIterNext(pIter));
+  return numOfRows;
+}
+
+// Commit to file
+static void *tsdbCommitToFile(void *arg) {
+  // TODO
+  STsdbRepo * pRepo = (STsdbRepo *)arg;
+  STsdbMeta * pMeta = pRepo->tsdbMeta;
+  STsdbCache *pCache = pRepo->tsdbCache;
+  STsdbCfg * pCfg = &(pRepo->config);
+  if (pCache->imem == NULL) return;
+
+  int sfid = tsdbGetKeyFileId(pCache->imem->keyFirst, pCfg->daysPerFile, pCfg->precision);
+  int efid = tsdbGetKeyFileId(pCache->imem->keyLast, pCfg->daysPerFile, pCfg->precision);
+
+  SSkipListIterator **iters = (SSkipListIterator **)calloc(pCfg->maxTables, sizeof(SSkipListIterator *));
+  if (iters == NULL) {
+    // TODO: deal with the error
+    return NULL;
+  }
+
+  int maxCols = pMeta->maxCols;
+  int maxBytes = pMeta->maxRowBytes;
+  SDataCol **cols = (SDataCol **)malloc(sizeof(SDataCol *) * maxCols);
+  void *buf = malloc((maxBytes + sizeof(SDataCol)) * pCfg->maxRowsPerFileBlock);
+
+  for (int fid = sfid; fid <= efid; fid++) {
+    TSKEY minKey = 0, maxKey = 0;
+    tsdbGetKeyRangeOfFileId(pCfg->daysPerFile, pCfg->precision, fid, &minKey, &maxKey);
+
+    for (int tid = 0; tid < pCfg->maxTables; tid++) {
+      STable *pTable = pMeta->tables[tid];
+      if (pTable == NULL || pTable->imem == NULL) continue;
+      if (iters[tid] == NULL) {  // create table iterator
+        iters[tid] = tSkipListCreateIter(pTable->imem->pData);
+        // TODO: deal with the error
+        if (iters[tid] == NULL) break;
+        if (!tSkipListIterNext(iters[tid])) {
+          // assert(0);
+        }
+      }
+
+      // Init row data part
+      cols[0] = (SDataCol *)buf;
+      for (int col = 1; col < schemaNCols(pTable->schema); col++) {
+        cols[col] = (SDataCol *)((char *)(cols[col - 1]) + sizeof(SDataCol) + colBytes(schemaColAt(pTable->schema, col-1)) * pCfg->maxRowsPerFileBlock);
+      }
+
+      // Loop the iterator
+      int rowsRead = 0;
+      while ((rowsRead = tsdbReadRowsFromCache(iters[tid], maxKey, pCfg->maxRowsPerFileBlock, cols, pTable->schema)) >
+             0) {
+        // printf("rowsRead:%d-----------\n", rowsRead);
+        int k = 0;
+      }
+    }
+  }
+
+  // Free the iterator
+  for (int tid = 0; tid < pCfg->maxTables; tid++) {
+    if (iters[tid] != NULL) tSkipListDestroyIter(iters[tid]);
+  }
+
+  free(buf);
+  free(cols);
+  free(iters);
+
+  tsdbLockRepo(arg);
+  tdListMove(pCache->imem->list, pCache->pool.memPool);
+  free(pCache->imem);
+  pCache->imem = NULL;
+  pRepo->commit = 0;
+  // TODO: free the skiplist
+  for (int i = 0; i < pCfg->maxTables; i++) {
+    STable *pTable = pMeta->tables[i];
+    if (pTable && pTable->imem) { // Here has memory leak
+      pTable->imem = NULL;
+    }
+  }
+  tsdbUnLockRepo(arg);
+
+  return NULL;
+}
\ No newline at end of file

src/vnode/tsdb/src/tsdbMeta.c

@@ -18,7 +18,6 @@ static int     tsdbAddTableIntoMap(STsdbMeta *pMeta, STable *pTable);
 static int     tsdbAddTableIntoIndex(STsdbMeta *pMeta, STable *pTable);
 static int     tsdbRemoveTableFromIndex(STsdbMeta *pMeta, STable *pTable);
 static int     tsdbEstimateTableEncodeSize(STable *pTable);
-static char *  getTupleKey(const void *data);
 
 /**
  * Encode a TSDB table object as a binary content
@@ -102,11 +101,8 @@ int tsdbRestoreTable(void *pHandle, void *cont, int contLen) {
   if (pTable == NULL) return -1;
   
   if (pTable->type == TSDB_SUPER_TABLE) {
-    pTable->content.pIndex =
+    pTable->pIndex =
         tSkipListCreate(TSDB_SUPER_TABLE_SL_LEVEL, TSDB_DATA_TYPE_TIMESTAMP, sizeof(int64_t), 1, 0, getTupleKey);
-  } else {
-    pTable->content.pData = tSkipListCreate(TSDB_SUPER_TABLE_SL_LEVEL, TSDB_DATA_TYPE_TIMESTAMP,
-                                            TYPE_BYTES[TSDB_DATA_TYPE_TIMESTAMP], 0, 0, getTupleKey);
   } 
 
   tsdbAddTableToMeta(pMeta, pTable, false);
@@ -137,6 +133,8 @@ STsdbMeta *tsdbInitMeta(const char *rootDir, int32_t maxTables) {
   pMeta->nTables = 0;
   pMeta->superList = NULL;
   pMeta->tables = (STable **)calloc(maxTables, sizeof(STable *));
+  pMeta->maxRowBytes = 0;
+  pMeta->maxCols = 0;
   if (pMeta->tables == NULL) {
     free(pMeta);
     return NULL;
@@ -208,10 +206,10 @@ int32_t tsdbCreateTableImpl(STsdbMeta *pMeta, STableCfg *pCfg) {
       super->schema = tdDupSchema(pCfg->schema);
       super->tagSchema = tdDupSchema(pCfg->tagSchema);
       super->tagVal = tdDataRowDup(pCfg->tagValues);
-      super->content.pIndex = tSkipListCreate(TSDB_SUPER_TABLE_SL_LEVEL, TSDB_DATA_TYPE_TIMESTAMP, sizeof(int64_t), 1,
+      super->pIndex = tSkipListCreate(TSDB_SUPER_TABLE_SL_LEVEL, TSDB_DATA_TYPE_TIMESTAMP, sizeof(int64_t), 1,
                                                 0, getTupleKey);  // Allow duplicate key, no lock
 
-      if (super->content.pIndex == NULL) {
+      if (super->pIndex == NULL) {
         tdFreeSchema(super->schema);
         tdFreeSchema(super->tagSchema);
         tdFreeDataRow(super->tagVal);
@@ -223,7 +221,7 @@ int32_t tsdbCreateTableImpl(STsdbMeta *pMeta, STableCfg *pCfg) {
     }
   }
 
-  STable *table = (STable *)malloc(sizeof(STable));
+  STable *table = (STable *)calloc(1, sizeof(STable));
   if (table == NULL) {
     if (newSuper) tsdbFreeTable(super);
     return -1;
@@ -238,8 +236,11 @@ int32_t tsdbCreateTableImpl(STsdbMeta *pMeta, STableCfg *pCfg) {
     table->type = TSDB_NORMAL_TABLE;
     table->superUid = -1;
     table->schema = tdDupSchema(pCfg->schema);
+    if (schemaNCols(table->schema) > pMeta->maxCols) pMeta->maxCols = schemaNCols(table->schema);
+    tdUpdateSchema(table->schema);
+    int bytes = tdMaxRowBytesFromSchema(table->schema);
+    if (bytes > pMeta->maxRowBytes) pMeta->maxRowBytes = bytes;
   }
-  table->content.pData = tSkipListCreate(TSDB_SUPER_TABLE_SL_LEVEL, TSDB_DATA_TYPE_TIMESTAMP, TYPE_BYTES[TSDB_DATA_TYPE_TIMESTAMP], 0, 0, getTupleKey);
 
   // Register to meta
   if (newSuper) tsdbAddTableToMeta(pMeta, super, true);
@@ -299,10 +300,10 @@ int32_t tsdbDropTableImpl(STsdbMeta *pMeta, STableId tableId) {
   return 0;
 }
 
-int32_t tsdbInsertRowToTableImpl(SSkipListNode *pNode, STable *pTable) {
-  tSkipListPut(pTable->content.pData, pNode);
-  return 0;
-}
+// int32_t tsdbInsertRowToTableImpl(SSkipListNode *pNode, STable *pTable) {
+//   tSkipListPut(pTable->mem->pData, pNode);
+//   return 0;
+// }
 
 static int tsdbFreeTable(STable *pTable) {
   // TODO: finish this function
@@ -314,9 +315,7 @@ static int tsdbFreeTable(STable *pTable) {
 
   // Free content
   if (TSDB_TABLE_IS_SUPER_TABLE(pTable)) {
-    tSkipListDestroy(pTable->content.pIndex);
-  } else {
-    tSkipListDestroy(pTable->content.pData);
+    tSkipListDestroy(pTable->pIndex);
   } 
 
   free(pTable);
@@ -404,7 +403,7 @@ static int tsdbEstimateTableEncodeSize(STable *pTable) {
   return size;
 }
 
-static char *getTupleKey(const void * data) {
+char *getTupleKey(const void * data) {
   SDataRow row = (SDataRow)data;
 
   return dataRowAt(row, TD_DATA_ROW_HEAD_SIZE);

src/vnode/tsdb/src/tsdbRead.c

@@ -14,5 +14,378 @@
  */
 
 #include "os.h"
+#include "tutil.h"
+
 #include "tsdb.h"
+#include "tsdbFile.h"
+#include "tsdbMeta.h"
+
+#define EXTRA_BYTES 2
+#define PRIMARY_TSCOL_REQUIRED(c) (((SColumnInfoEx *)taosArrayGet(c, 0))->info.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX)
+#define QUERY_IS_ASC_QUERY(o) (o == TSQL_SO_ASC)
+#define QH_GET_NUM_OF_COLS(handle) (taosArrayGetSize((handle)->pColumns))
+
+typedef struct SField {
+  // todo need the definition
+} SField;
+
+typedef struct SHeaderFileInfo {
+  int32_t fileId;
+} SHeaderFileInfo;
+
+typedef struct SQueryHandlePos {
+  int32_t fileId;
+  int32_t slot;
+  int32_t pos;
+  int32_t fileIndex;
+} SQueryHandlePos;
+
+typedef struct SDataBlockLoadInfo {
+  int32_t fileListIndex;
+  int32_t fileId;
+  int32_t slotIdx;
+  int32_t sid;
+  SArray *pLoadedCols;
+} SDataBlockLoadInfo;
+
+typedef struct SLoadCompBlockInfo {
+  int32_t sid; /* meter sid */
+  int32_t fileId;
+  int32_t fileListIndex;
+} SLoadCompBlockInfo;
+
+typedef struct SQueryFilesInfo {
+  SArray *pFileInfo;
+  int32_t current;  // the memory mapped header file, NOTE: only one header file can be mmap.
+  int32_t vnodeId;
+
+  int32_t headerFd;  // header file fd
+  int64_t headerFileSize;
+  int32_t dataFd;
+  int32_t lastFd;
+
+  char headerFilePath[PATH_MAX];  // current opened header file name
+  char dataFilePath[PATH_MAX];    // current opened data file name
+  char lastFilePath[PATH_MAX];    // current opened last file path
+  char dbFilePathPrefix[PATH_MAX];
+} SQueryFilesInfo;
+
+typedef struct STableQueryRec {
+  TSKEY       lastKey;
+  STable *    pTableObj;
+  int64_t     offsetInHeaderFile;
+  int32_t     numOfBlocks;
+  int32_t     start;
+  SCompBlock *pBlock;
+} STableQueryRec;
+
+typedef struct {
+  SCompBlock *compBlock;
+  SField *    fields;
+} SCompBlockFields;
+
+typedef struct STableDataBlockInfoEx {
+  SCompBlockFields pBlock;
+  STableQueryRec * pMeterDataInfo;
+  int32_t          blockIndex;
+  int32_t          groupIdx; /* number of group is less than the total number of meters */
+} STableDataBlockInfoEx;
+
+typedef struct STsdbQueryHandle {
+  struct STsdbRepo* pTsdb;
+  
+  SQueryHandlePos cur;    // current position
+  SQueryHandlePos start;  // the start position, used for secondary/third iteration
+  int32_t         unzipBufSize;
+  char *unzipBuffer;
+  char *secondaryUnzipBuffer;
+
+  SDataBlockLoadInfo dataBlockLoadInfo; /* record current block load information */
+  SLoadCompBlockInfo compBlockLoadInfo; /* record current compblock information in SQuery */
+
+  SQueryFilesInfo vnodeFileInfo;
+
+  int16_t     numOfRowsPerPage;
+  uint16_t    flag;  // denotes reversed scan of data or not
+  int16_t     order;
+  STimeWindow window;  // the primary query time window that applies to all queries
+  TSKEY       lastKey;
+  int32_t     blockBufferSize;
+  SCompBlock *pBlock;
+  int32_t     numOfBlocks;
+  SField **   pFields;
+  SArray *    pColumns;         // column list, SColumnInfoEx array list
+  SArray *    pTableIdList;     // table id object list
+  bool        locateStart;
+  int32_t     realNumOfRows;
+  bool        loadDataAfterSeek;  // load data after seek.
+
+  STableDataBlockInfoEx *pDataBlockInfoEx;
+  STableQueryRec *       pTableQueryInfo;
+  int32_t                tableIndex;
+  bool                   isFirstSlot;
+  void *                 qinfo;  // query info handle, for debug purpose
+} STsdbQueryHandle;
+
+int32_t doAllocateBuf(STsdbQueryHandle *pQueryHandle, int32_t rowsPerFileBlock) {
+  // record the maximum column width among columns of this meter/metric
+  SColumnInfoEx *pColumn = taosArrayGet(pQueryHandle->pColumns, 0);
+
+  int32_t maxColWidth = pColumn->info.bytes;
+  for (int32_t i = 1; i < QH_GET_NUM_OF_COLS(pQueryHandle); ++i) {
+    int32_t bytes = pColumn[i].info.bytes;
+    if (bytes > maxColWidth) {
+      maxColWidth = bytes;
+    }
+  }
+
+  // only one unzip buffer required, since we can unzip each column one by one
+  pQueryHandle->unzipBufSize = (size_t)(maxColWidth * rowsPerFileBlock + EXTRA_BYTES);  // plus extra_bytes
+  pQueryHandle->unzipBuffer = (char *)calloc(1, pQueryHandle->unzipBufSize);
+
+  pQueryHandle->secondaryUnzipBuffer = (char *)calloc(1, pQueryHandle->unzipBufSize);
+
+  if (pQueryHandle->unzipBuffer == NULL || pQueryHandle->secondaryUnzipBuffer == NULL) {
+    goto _error_clean;
+  }
+
+  return TSDB_CODE_SUCCESS;
+
+_error_clean:
+  tfree(pQueryHandle->unzipBuffer);
+  tfree(pQueryHandle->secondaryUnzipBuffer);
+
+  return TSDB_CODE_SERV_OUT_OF_MEMORY;
+}
+
+static void initQueryFileInfoFD(SQueryFilesInfo *pVnodeFilesInfo) {
+  pVnodeFilesInfo->current = -1;
+  pVnodeFilesInfo->headerFileSize = -1;
+  
+  pVnodeFilesInfo->headerFd = FD_INITIALIZER;  // set the initial value
+  pVnodeFilesInfo->dataFd = FD_INITIALIZER;
+  pVnodeFilesInfo->lastFd = FD_INITIALIZER;
+}
+
+static void vnodeInitDataBlockLoadInfo(SDataBlockLoadInfo *pBlockLoadInfo) {
+  pBlockLoadInfo->slotIdx = -1;
+  pBlockLoadInfo->fileId = -1;
+  pBlockLoadInfo->sid = -1;
+  pBlockLoadInfo->fileListIndex = -1;
+}
+
+static void vnodeInitCompBlockLoadInfo(SLoadCompBlockInfo *pCompBlockLoadInfo) {
+  pCompBlockLoadInfo->sid = -1;
+  pCompBlockLoadInfo->fileId = -1;
+  pCompBlockLoadInfo->fileListIndex = -1;
+}
+
+static int fileOrderComparFn(const void *p1, const void *p2) {
+  SHeaderFileInfo *pInfo1 = (SHeaderFileInfo *)p1;
+  SHeaderFileInfo *pInfo2 = (SHeaderFileInfo *)p2;
+  
+  if (pInfo1->fileId == pInfo2->fileId) {
+    return 0;
+  }
+  
+  return (pInfo1->fileId > pInfo2->fileId) ? 1 : -1;
+}
+
+void vnodeRecordAllFiles(int32_t vnodeId, SQueryFilesInfo *pVnodeFilesInfo) {
+  char suffix[] = ".head";
+  pVnodeFilesInfo->pFileInfo = taosArrayInit(4, sizeof(int32_t));
+  
+  struct dirent *pEntry = NULL;
+  pVnodeFilesInfo->vnodeId = vnodeId;
+  char* tsDirectory = "";
+  
+  sprintf(pVnodeFilesInfo->dbFilePathPrefix, "%s/vnode%d/db/", tsDirectory, vnodeId);
+  DIR *pDir = opendir(pVnodeFilesInfo->dbFilePathPrefix);
+  if (pDir == NULL) {
+    //    dError("QInfo:%p failed to open directory:%s, %s", pQInfo, pVnodeFilesInfo->dbFilePathPrefix,
+    //    strerror(errno));
+    return;
+  }
+  
+  while ((pEntry = readdir(pDir)) != NULL) {
+    if ((pEntry->d_name[0] == '.' && pEntry->d_name[1] == '\0') || (strcmp(pEntry->d_name, "..") == 0)) {
+      continue;
+    }
+    
+    if (pEntry->d_type & DT_DIR) {
+      continue;
+    }
+    
+    size_t len = strlen(pEntry->d_name);
+    if (strcasecmp(&pEntry->d_name[len - 5], suffix) != 0) {
+      continue;
+    }
+    
+    int32_t vid = 0;
+    int32_t fid = 0;
+    sscanf(pEntry->d_name, "v%df%d", &vid, &fid);
+    if (vid != vnodeId) { /* ignore error files */
+      //      dError("QInfo:%p error data file:%s in vid:%d, ignore", pQInfo, pEntry->d_name, vnodeId);
+      continue;
+    }
+    
+//    int32_t firstFid = pVnode->fileId - pVnode->numOfFiles + 1;
+//    if (fid > pVnode->fileId || fid < firstFid) {
+//           dError("QInfo:%p error data file:%s in vid:%d, fid:%d, fid range:%d-%d", pQInfo, pEntry->d_name, vnodeId,
+//           fid, firstFid, pVnode->fileId);
+//      continue;
+//    }
+    
+    assert(fid >= 0 && vid >= 0);
+    taosArrayPush(pVnodeFilesInfo->pFileInfo, &fid);
+  }
+  
+  closedir(pDir);
+  
+  //  dTrace("QInfo:%p find %d data files in %s to be checked", pQInfo, pVnodeFilesInfo->numOfFiles,
+  //         pVnodeFilesInfo->dbFilePathPrefix);
+  
+  // order the files information according their names */
+  size_t numOfFiles = taosArrayGetSize(pVnodeFilesInfo->pFileInfo);
+  qsort(pVnodeFilesInfo->pFileInfo->pData, numOfFiles, sizeof(SHeaderFileInfo), fileOrderComparFn);
+}
+
+tsdb_query_handle_t *tsdbQueryByTableId(tsdb_repo_t* tsdb, STsdbQueryCond *pCond, SArray *idList, SArray *pColumnInfo) {
+  // todo 1. filter not exist table
+
+  // todo 2. add the reference count for each table that is involved in query
+
+  STsdbQueryHandle *pQueryHandle = calloc(1, sizeof(STsdbQueryHandle));
+  pQueryHandle->order = pCond->order;
+  pQueryHandle->window = pCond->twindow;
+  pQueryHandle->pTsdb = tsdb;
+
+  pQueryHandle->pTableIdList = idList;
+  pQueryHandle->pColumns = pColumnInfo;
+  pQueryHandle->loadDataAfterSeek = false;
+  pQueryHandle->isFirstSlot = true;
+
+  pQueryHandle->lastKey = pQueryHandle->window.skey;  // ascending query
+  
+  // malloc buffer in order to load data from file
+  int32_t numOfCols = taosArrayGetSize(pColumnInfo);
+  size_t  bufferCapacity = 4096;
+  
+  pQueryHandle->pColumns = taosArrayInit(numOfCols, sizeof(SColumnInfoEx));
+  for (int32_t i = 0; i < numOfCols; ++i) {
+    SColumnInfoEx *pCol = taosArrayGet(pColumnInfo, i);
+    SColumnInfoEx  pDest = {{0}, 0};
+
+    pDest.pData = calloc(1, EXTRA_BYTES + bufferCapacity * pCol->info.bytes);
+    pDest.info = pCol->info;
+    taosArrayPush(pQueryHandle->pColumns, &pDest);
+  }
+
+  if (doAllocateBuf(pQueryHandle, bufferCapacity) != TSDB_CODE_SUCCESS) {
+    return NULL;
+  }
+
+  initQueryFileInfoFD(&pQueryHandle->vnodeFileInfo);
+  vnodeInitDataBlockLoadInfo(&pQueryHandle->dataBlockLoadInfo);
+  vnodeInitCompBlockLoadInfo(&pQueryHandle->compBlockLoadInfo);
+
+  int32_t vnodeId = 1;
+  vnodeRecordAllFiles(vnodeId, &pQueryHandle->vnodeFileInfo);
+
+  return (tsdb_query_handle_t)pQueryHandle;
+}
+
+static int32_t next = 1;
+bool tsdbNextDataBlock(tsdb_query_handle_t *pQueryHandle) {
+  if (next == 0) {
+    return false;
+  } else {
+    next = 0;
+    return true;
+  }
+}
+
+static int tsdbReadRowsFromCache(SSkipListIterator *pIter, TSKEY maxKey, int maxRowsToRead,
+    TSKEY* skey, TSKEY* ekey, STsdbQueryHandle* pHandle) {
+  int numOfRows = 0;
+  int32_t numOfCols = taosArrayGetSize(pHandle->pColumns);
+  *skey = INT64_MIN;
+  
+  while(tSkipListIterNext(pIter)) {
+    SSkipListNode *node = tSkipListIterGet(pIter);
+    if (node == NULL) break;
+    
+    SDataRow row = SL_GET_NODE_DATA(node);
+    if (dataRowKey(row) > maxKey) break;
+    // Convert row data to column data
+    
+    if (*skey == INT64_MIN) {
+      *skey = dataRowKey(row);
+    }
+    
+    *ekey = dataRowKey(row);
+    
+    int32_t offset = 0;
+    for(int32_t i = 0; i < numOfCols; ++i) {
+      SColumnInfoEx* pColInfo = taosArrayGet(pHandle->pColumns, 0);
+      memcpy(pColInfo->pData + numOfRows*pColInfo->info.bytes, dataRowTuple(row) + offset, pColInfo->info.bytes);
+      offset += pColInfo->info.bytes;
+    }
+    
+    numOfRows++;
+    if (numOfRows > maxRowsToRead) break;
+  };
+  
+  return numOfRows;
+}
+
+// copy data from cache into data block
+SDataBlockInfo tsdbRetrieveDataBlockInfo(tsdb_query_handle_t *pQueryHandle) {
+  STsdbQueryHandle* pHandle = (STsdbQueryHandle*) pQueryHandle;
+  STableIdInfo* idInfo = taosArrayGet(pHandle->pTableIdList, 0);
+  
+  STableId tableId = {.uid = idInfo->uid, .tid = idInfo->sid};
+  STable *pTable = tsdbIsValidTableToInsert(tsdbGetMeta(pHandle->pTsdb), tableId);
+  assert(pTable != NULL);
+  
+  TSKEY skey = 0, ekey = 0;
+  int32_t rows = 0;
+  
+  if (pTable->mem != NULL) {
+    SSkipListIterator* iter = tSkipListCreateIter(pTable->mem->pData);
+    rows = tsdbReadRowsFromCache(iter, INT64_MAX, 4000, &skey, &ekey, pHandle);
+  }
+  
+  SDataBlockInfo blockInfo = {
+      .uid = tableId.uid,
+      .sid = tableId.tid,
+      .size = rows,
+      .window = {.skey = skey, .ekey = ekey}
+  };
+  
+  return blockInfo;
+}
+
+// return null for data block in cache
+int32_t tsdbRetrieveDataBlockStatisInfo(tsdb_query_handle_t *pQueryHandle, SDataStatis **pBlockStatis) {
+  *pBlockStatis = NULL;
+  return TSDB_CODE_SUCCESS;
+}
+
+SArray *tsdbRetrieveDataBlock(tsdb_query_handle_t *pQueryHandle, SArray *pIdList) {
+
+}
+
+int32_t tsdbResetQuery(tsdb_query_handle_t *pQueryHandle, STimeWindow *window, tsdbpos_t position, int16_t order) {}
+
+int32_t tsdbDataBlockSeek(tsdb_query_handle_t *pQueryHandle, tsdbpos_t pos) {}
+
+tsdbpos_t tsdbDataBlockTell(tsdb_query_handle_t *pQueryHandle) { return NULL; }
+
+SArray *tsdbRetrieveDataRow(tsdb_query_handle_t *pQueryHandle, SArray *pIdList, SQueryRowCond *pCond) {}
+
+tsdb_query_handle_t *tsdbQueryFromTagConds(STsdbQueryCond *pCond, int16_t stableId, const char *pTagFilterStr) {}
+
+STableIDList *tsdbGetTableList(tsdb_query_handle_t *pQueryHandle) {}
 
+STableIDList *tsdbQueryTableList(int16_t stableId, const char *pTagCond) {}

src/vnode/tsdb/tests/tsdbTests.cpp

 #include <gtest/gtest.h>
 #include <stdlib.h>
+#include <sys/time.h>
 
 #include "tsdb.h"
 #include "dataformat.h"
+#include "tsdbFile.h"
 #include "tsdbMeta.h"
 
-TEST(TsdbTest, tableEncodeDecode) {
+double getCurTime() {
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  return tv.tv_sec + tv.tv_usec * 1E-6;
+}
+
+TEST(TsdbTest, DISABLED_tableEncodeDecode) {
   STable *pTable = (STable *)malloc(sizeof(STable));
 
   pTable->type = TSDB_NORMAL_TABLE;
@@ -39,7 +47,6 @@ TEST(TsdbTest, tableEncodeDecode) {
   ASSERT_EQ(pTable->superUid, tTable->superUid);
   ASSERT_EQ(pTable->sversion, tTable->sversion);
   ASSERT_EQ(memcmp(pTable->schema, tTable->schema, sizeof(STSchema) + sizeof(STColumn) * nCols), 0);
-  ASSERT_EQ(tTable->content.pData, nullptr);
 }
 
 TEST(TsdbTest, createRepo) {
@@ -71,39 +78,59 @@ TEST(TsdbTest, createRepo) {
   tsdbCreateTable(pRepo, &tCfg);
 
   // // 3. Loop to write some simple data
-  int nRows = 10;
-  SSubmitMsg *pMsg = (SSubmitMsg *)malloc(sizeof(SSubmitMsg) + sizeof(SSubmitBlk) + tdMaxRowBytesFromSchema(schema) * nRows);
+  int nRows = 10000000;
+  int rowsPerSubmit = 100;
+  int64_t start_time = 1584081000000;
+
+  SSubmitMsg *pMsg = (SSubmitMsg *)malloc(sizeof(SSubmitMsg) + sizeof(SSubmitBlk) + tdMaxRowBytesFromSchema(schema) * rowsPerSubmit);
+
+  double stime = getCurTime();
 
+  for (int k = 0; k < nRows/rowsPerSubmit; k++) {
     SSubmitBlk *pBlock = pMsg->blocks;
     pBlock->tableId = {.uid = 987607499877672L, .tid = 0};
     pBlock->sversion = 0;
     pBlock->len = 0;
-  int64_t start_time = 1584081000000;
-  for (int i = 0; i < nRows; i++) {
-    int64_t ttime = start_time + 1000 * i;
+    for (int i = 0; i < rowsPerSubmit; i++) {
+      // start_time += 1000;
+      start_time -= 1000;
       SDataRow row = (SDataRow)(pBlock->data + pBlock->len);
       tdInitDataRow(row, schema);
 
       for (int j = 0; j < schemaNCols(schema); j++) {
         if (j == 0) {  // Just for timestamp
-        tdAppendColVal(row, (void *)(&ttime), schemaColAt(schema, j));
+          tdAppendColVal(row, (void *)(&start_time), schemaColAt(schema, j));
         } else {  // For int
           int val = 10;
           tdAppendColVal(row, (void *)(&val), schemaColAt(schema, j));
         }
-
       }
       pBlock->len += dataRowLen(row);
-
     }
     pMsg->length = pMsg->length + sizeof(SSubmitBlk) + pBlock->len;
 
     tsdbInsertData(pRepo, pMsg);
+  }
+
+  double etime = getCurTime();
+
+  printf("Spent %f seconds to write %d records\n", etime - stime, nRows);
+
+
+
+  // tsdbTriggerCommit(pRepo);
 
-  int k = 0;
 }
 
-TEST(TsdbTest, openRepo) {
+TEST(TsdbTest, DISABLED_openRepo) {
   tsdb_repo_t *pRepo = tsdbOpenRepo("/home/ubuntu/work/ttest/vnode0");
   ASSERT_NE(pRepo, nullptr);
 }
+
+TEST(TsdbTest, DISABLED_createFileGroup) {
+  SFileGroup fGroup;
+
+  ASSERT_EQ(tsdbCreateFileGroup("/home/ubuntu/work/ttest/vnode0/data", 1820, &fGroup, 1000), 0);
+
+  int k = 0;
+}
\ No newline at end of file