Merge branch '3.0' of https://github.com/taosdata/TDengine into feature/vnode

include/common/tmsg.h

@@ -1520,20 +1520,19 @@ typedef struct SMqSetCVgReq {
   int32_t vgId;
   int64_t consumerId;
   char    topicName[TSDB_TOPIC_FNAME_LEN];
-  char    cGroup[TSDB_CONSUMER_GROUP_LEN];
+  char    cgroup[TSDB_CONSUMER_GROUP_LEN];
   char*   sql;
   char*   logicalPlan;
   char*   physicalPlan;
   SArray* tasks;  // SArray<SSubQueryMsg>
 } SMqSetCVgReq;
 
-
 static FORCE_INLINE int32_t tEncodeSMqSetCVgReq(void** buf, const SMqSetCVgReq* pReq) {
   int32_t tlen = 0;
   tlen += taosEncodeFixedI32(buf, pReq->vgId);
   tlen += taosEncodeFixedI64(buf, pReq->consumerId);
   tlen += taosEncodeString(buf, pReq->topicName);
-  tlen += taosEncodeString(buf, pReq->cGroup);
+  tlen += taosEncodeString(buf, pReq->cgroup);
   tlen += taosEncodeString(buf, pReq->sql);
   tlen += taosEncodeString(buf, pReq->logicalPlan);
   tlen += taosEncodeString(buf, pReq->physicalPlan);
@@ -1544,7 +1543,7 @@ static FORCE_INLINE void* tDecodeSMqSetCVgReq(void* buf, SMqSetCVgReq* pReq) {
   buf = taosDecodeFixedI32(buf, &pReq->vgId);
   buf = taosDecodeFixedI64(buf, &pReq->consumerId);
   buf = taosDecodeStringTo(buf, pReq->topicName);
-  buf = taosDecodeStringTo(buf, pReq->cGroup);
+  buf = taosDecodeStringTo(buf, pReq->cgroup);
   buf = taosDecodeString(buf, &pReq->sql);
   buf = taosDecodeString(buf, &pReq->logicalPlan);
   buf = taosDecodeString(buf, &pReq->physicalPlan);
@@ -1552,14 +1551,28 @@ static FORCE_INLINE void* tDecodeSMqSetCVgReq(void* buf, SMqSetCVgReq* pReq) {
   return buf;
 }
 
+typedef struct SMqSetCVgRsp {
+  int32_t vgId;
+  int64_t consumerId;
+  char    topicName[TSDB_TOPIC_FNAME_LEN];
+  char    cGroup[TSDB_CONSUMER_GROUP_LEN];
+} SMqSetCVgRsp;
+
 typedef struct SMqCVConsumeReq {
   int64_t reqId;
   int64_t offset;
-  int64_t clientId;
+  int64_t consumerId;
+  int64_t blockingTime;
   char    topicName[TSDB_TOPIC_FNAME_LEN];
   char    cgroup[TSDB_CONSUMER_GROUP_LEN];
 } SMqCVConsumeReq;
 
+typedef struct SMqConsumeRspBlock {
+  int32_t bodyLen;
+  char topicName[TSDB_TOPIC_FNAME_LEN];
+  char body[];
+} SMqConsumeRspBlock;
+
 typedef struct SMqCVConsumeRsp {
   int64_t reqId;
   int64_t clientId;
@@ -1569,7 +1582,7 @@ typedef struct SMqCVConsumeRsp {
   int32_t skipLogNum;
   int32_t bodyLen;
   char    topicName[TSDB_TOPIC_FNAME_LEN];
-  char    body[];
+  SMqConsumeRspBlock blocks[];
 } SMqCvConsumeRsp;
 
 #ifdef __cplusplus

include/common/tmsgdef.h

@@ -160,7 +160,7 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_VND_MQ_QUERY, "vnode-mq-query", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_MQ_CONNECT, "vnode-mq-connect", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_MQ_DISCONNECT, "vnode-mq-disconnect", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_VND_MQ_SET_CONN, "vnode-mq-set-conn", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_MQ_SET_CONN, "vnode-mq-set-conn", SMqSetCVgReq, SMqSetCVgRsp)
   TD_DEF_MSG_TYPE(TDMT_VND_MQ_SET_CUR, "vnode-mq-set-cur", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_RES_READY, "vnode-res-ready", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_TASKS_STATUS, "vnode-tasks-status", NULL, NULL)

include/libs/function/function.h

@@ -80,6 +80,13 @@ extern "C" {
 
 #define FUNCTION_COV          38
 
+typedef struct SResultRowEntryInfo {
+  int8_t   hasResult;       // result generated, not NULL value
+  bool     initialized;     // output buffer has been initialized
+  bool     complete;        // query has completed
+  uint32_t numOfRes;        // num of output result in current buffer
+} SResultRowEntryInfo;
+
 // determine the real data need to calculated the result
 enum {
   BLK_DATA_NO_NEEDED     = 0x0,
@@ -127,6 +134,8 @@ typedef struct SFunctionFpSet {
   void (*combine)(struct SQLFunctionCtx *pCtx);
 } SFunctionFpSet;
 
+extern SFunctionFpSet fpSet[1];
+
 // sql function runtime context
 typedef struct SQLFunctionCtx {
   int32_t      size;      // number of rows
@@ -156,6 +165,7 @@ typedef struct SQLFunctionCtx {
   SPoint1      start;
   SPoint1      end;
 
+  int32_t      columnIndex;
   SFunctionFpSet* fpSet;
 } SQLFunctionCtx;
 

include/libs/parser/parser.h

@@ -91,6 +91,7 @@ SSchema *getOneColumnSchema(const STableMeta* pTableMeta, int32_t colIndex);
 
 int32_t getNewResColId();
 void addIntoSourceParam(SSourceParam* pSourceParam, tExprNode* pNode, SColumn* pColumn);
+SExprInfo* createBinaryExprInfo(struct tExprNode* pNode, SSchema* pResSchema);
 
 #ifdef __cplusplus
 }

include/libs/planner/planner.h

@@ -114,10 +114,16 @@ typedef struct SProjectPhyNode {
   SPhyNode node;
 } SProjectPhyNode;
 
+typedef struct SDownstreamSource {
+  SQueryNodeAddr addr;
+  uint64_t       taskId;
+  uint64_t       schedId;
+} SDownstreamSource;
+
 typedef struct SExchangePhyNode {
   SPhyNode    node;
   uint64_t    srcTemplateId;  // template id of datasource suplans
-  SArray     *pSrcEndPoints;  // SEpAddr, scheduler fill by calling qSetSuplanExecutionNode
+  SArray     *pSrcEndPoints;  // SArray<SDownstreamSource>, scheduler fill by calling qSetSuplanExecutionNode
 } SExchangePhyNode;
 
 typedef enum EAggAlgo {
@@ -178,7 +184,7 @@ int32_t qCreateQueryDag(const struct SQueryNode* pQueryInfo, struct SQueryDag**
 // @subplan subplan to be schedule
 // @templateId templateId of a group of datasource subplans of this @subplan
 // @ep one execution location of this group of datasource subplans 
-void qSetSubplanExecutionNode(SSubplan* subplan, uint64_t templateId, SQueryNodeAddr* ep);
+void qSetSubplanExecutionNode(SSubplan* subplan, uint64_t templateId, SDownstreamSource* pSource);
 
 int32_t qExplainQuery(const struct SQueryNode* pQueryInfo, struct SEpSet* pQnode, char** str);
 

include/libs/wal/wal.h

@@ -80,8 +80,8 @@ typedef enum { TAOS_WAL_NOLOG = 0, TAOS_WAL_WRITE = 1, TAOS_WAL_FSYNC = 2 } EWal
 
 typedef struct SWalReadHead {
   int8_t  headVer;
-  uint8_t msgType;
-  int8_t  reserved[2];
+  int16_t msgType;
+  int8_t  reserved;
   int32_t len;
   int64_t ingestTs;  // not implemented
   int64_t version;

source/client/inc/clientInt.h

@@ -179,7 +179,7 @@ extern int32_t  clientConnRefPool;
 
 extern int (*handleRequestRspFp[TDMT_MAX])(void*, const SDataBuf* pMsg, int32_t code);
 int genericRspCallback(void* param, const SDataBuf* pMsg, int32_t code);
-SMsgSendInfo* buildMsgInfoImpl(SRequestObj*);
+SMsgSendInfo* buildMsgInfoImpl(SRequestObj* pReqObj);
 
 int   taos_init();
 

source/client/src/clientImpl.c

@@ -195,8 +195,7 @@ int32_t execDdlQuery(SRequestObj* pRequest, SQueryNode* pQuery) {
     }
     asyncSendMsgToServer(pTscObj->pAppInfo->pTransporter, &pDcl->epSet, &transporterId, pSendMsg);
   } else {
-    SEpSet* pEpSet = &pTscObj->pAppInfo->mgmtEp.epSet;
-    asyncSendMsgToServer(pTscObj->pAppInfo->pTransporter, pEpSet, &transporterId, pSendMsg);
+    asyncSendMsgToServer(pTscObj->pAppInfo->pTransporter, &pDcl->epSet, &transporterId, pSendMsg);
   }
 
   tsem_wait(&pRequest->body.rspSem);
@@ -259,9 +258,9 @@ int32_t scheduleQuery(SRequestObj* pRequest, SQueryDag* pDag) {
 
   SArray *execNode = taosArrayInit(4, sizeof(SQueryNodeAddr));
 
-  SQueryNodeAddr addr = {.numOfEps = 1, .inUse = 0, .nodeId = 0};
-  addr.epAddr[0].port = 6030;
-  strcpy(addr.epAddr[0].fqdn, "ubuntu");
+  SQueryNodeAddr addr = {.numOfEps = 1, .inUse = 0, .nodeId = 2};
+  addr.epAddr[0].port = 7100;
+  strcpy(addr.epAddr[0].fqdn, "localhost");
 
   taosArrayPush(execNode, &addr);
   return scheduleAsyncExecJob(pRequest->pTscObj->pAppInfo->pTransporter, execNode, pDag, &pRequest->body.pQueryJob);
@@ -706,6 +705,8 @@ void* doFetchRow(SRequestObj* pRequest) {
   assert(pRequest != NULL);
   SReqResultInfo* pResultInfo = &pRequest->body.resInfo;
 
+  SEpSet epSet = {0};
+
   if (pResultInfo->pData == NULL || pResultInfo->current >= pResultInfo->numOfRows) {
     if (pRequest->type == TDMT_VND_QUERY) {
       // All data has returned to App already, no need to try again
@@ -727,8 +728,20 @@ void* doFetchRow(SRequestObj* pRequest) {
       goto _return;
     } else if (pRequest->type == TDMT_MND_SHOW) {
       pRequest->type = TDMT_MND_SHOW_RETRIEVE;
+      epSet = getEpSet_s(&pRequest->pTscObj->pAppInfo->mgmtEp);
     } else if (pRequest->type == TDMT_VND_SHOW_TABLES) {
       pRequest->type = TDMT_VND_SHOW_TABLES_FETCH;
+      SShowReqInfo* pShowReqInfo = &pRequest->body.showInfo;
+      SVgroupInfo* pVgroupInfo = taosArrayGet(pShowReqInfo->pArray, pShowReqInfo->currentIndex);
+
+      epSet.numOfEps = pVgroupInfo->numOfEps;
+      epSet.inUse = pVgroupInfo->inUse;
+
+      for (int32_t i = 0; i < epSet.numOfEps; ++i) {
+        strncpy(epSet.fqdn[i], pVgroupInfo->epAddr[i].fqdn, tListLen(epSet.fqdn[i]));
+        epSet.port[i] = pVgroupInfo->epAddr[i].port;
+      }
+
     } else if (pRequest->type == TDMT_VND_SHOW_TABLES_FETCH) {
       pRequest->type = TDMT_VND_SHOW_TABLES;
       SShowReqInfo* pShowReqInfo = &pRequest->body.showInfo;
@@ -746,19 +759,29 @@ void* doFetchRow(SRequestObj* pRequest) {
 
       SMsgSendInfo* body = buildMsgInfoImpl(pRequest);
 
+      epSet.numOfEps = pVgroupInfo->numOfEps;
+      epSet.inUse = pVgroupInfo->inUse;
+
+      for (int32_t i = 0; i < epSet.numOfEps; ++i) {
+        strncpy(epSet.fqdn[i], pVgroupInfo->epAddr[i].fqdn, tListLen(epSet.fqdn[i]));
+        epSet.port[i] = pVgroupInfo->epAddr[i].port;
+      }
+
       int64_t  transporterId = 0;
       STscObj *pTscObj = pRequest->pTscObj;
-      asyncSendMsgToServer(pTscObj->pAppInfo->pTransporter, &pTscObj->pAppInfo->mgmtEp.epSet, &transporterId, body);
+      asyncSendMsgToServer(pTscObj->pAppInfo->pTransporter, &epSet, &transporterId, body);
       tsem_wait(&pRequest->body.rspSem);
 
       pRequest->type = TDMT_VND_SHOW_TABLES_FETCH;
+    } else if (pRequest->type == TDMT_MND_SHOW_RETRIEVE && pResultInfo->pData != NULL) {
+      return NULL;
     }
 
     SMsgSendInfo* body = buildMsgInfoImpl(pRequest);
 
     int64_t  transporterId = 0;
     STscObj *pTscObj = pRequest->pTscObj;
-    asyncSendMsgToServer(pTscObj->pAppInfo->pTransporter, &pTscObj->pAppInfo->mgmtEp.epSet, &transporterId, body);
+    asyncSendMsgToServer(pTscObj->pAppInfo->pTransporter, &epSet, &transporterId, body);
 
     tsem_wait(&pRequest->body.rspSem);
 

source/client/test/clientTests.cpp

@@ -15,6 +15,7 @@
 
 #include <gtest/gtest.h>
 #include <taoserror.h>
+#include <tglobal.h>
 #include <iostream>
 #pragma GCC diagnostic ignored "-Wwrite-strings"
 
@@ -46,17 +47,19 @@ int main(int argc, char** argv) {
   return RUN_ALL_TESTS();
 }
 
-TEST(testCase, driverInit_Test) { taos_init(); }
-
-TEST(testCase, connect_Test) {
-  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  if (pConn == NULL) {
-    printf("failed to connect to server, reason:%s\n", taos_errstr(NULL));
-  }
-  sleep(3);
-  taos_close(pConn);
+TEST(testCase, driverInit_Test) {
+  taosInitGlobalCfg();
+//  taos_init();
 }
 
+//TEST(testCase, connect_Test) {
+//  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+//  if (pConn == NULL) {
+//    printf("failed to connect to server, reason:%s\n", taos_errstr(NULL));
+//  }
+//  taos_close(pConn);
+//}
+//
 //TEST(testCase, create_user_Test) {
 //  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
 //  assert(pConn != NULL);
@@ -148,30 +151,30 @@ TEST(testCase, connect_Test) {
 //  taos_close(pConn);
 //}
 //
-TEST(testCase, create_db_Test) {
-  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  assert(pConn != NULL);
-
-  TAOS_RES* pRes = taos_query(pConn, "create database abc1 vgroups 2");
-  if (taos_errno(pRes) != 0) {
-    printf("error in create db, reason:%s\n", taos_errstr(pRes));
-  }
-
-  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
-  ASSERT_TRUE(pFields == NULL);
-
-  int32_t numOfFields = taos_num_fields(pRes);
-  ASSERT_EQ(numOfFields, 0);
-
-  taos_free_result(pRes);
-
-  pRes = taos_query(pConn, "create database abc1 vgroups 4");
-  if (taos_errno(pRes) != 0) {
-    printf("error in create db, reason:%s\n", taos_errstr(pRes));
-  }
-  taos_close(pConn);
-}
-
+//TEST(testCase, create_db_Test) {
+//  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+//  assert(pConn != NULL);
+//
+//  TAOS_RES* pRes = taos_query(pConn, "create database abc1 vgroups 2");
+//  if (taos_errno(pRes) != 0) {
+//    printf("error in create db, reason:%s\n", taos_errstr(pRes));
+//  }
+//
+//  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
+//  ASSERT_TRUE(pFields == NULL);
+//
+//  int32_t numOfFields = taos_num_fields(pRes);
+//  ASSERT_EQ(numOfFields, 0);
+//
+//  taos_free_result(pRes);
+//
+//  pRes = taos_query(pConn, "create database abc1 vgroups 4");
+//  if (taos_errno(pRes) != 0) {
+//    printf("error in create db, reason:%s\n", taos_errstr(pRes));
+//  }
+//  taos_close(pConn);
+//}
+//
 //TEST(testCase, create_dnode_Test) {
 //  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
 //  assert(pConn != NULL);
@@ -254,7 +257,7 @@ TEST(testCase, create_db_Test) {
 //  taos_free_result(pRes);
 //  taos_close(pConn);
 //}
-
+//
 //TEST(testCase, create_stable_Test) {
 //  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
 //  assert(pConn != NULL);
@@ -275,17 +278,14 @@ TEST(testCase, create_db_Test) {
 //
 //  int32_t numOfFields = taos_num_fields(pRes);
 //  ASSERT_EQ(numOfFields, 0);
-//
 //  taos_free_result(pRes);
-//  taos_close(pConn);
-//}
 //
 //  pRes = taos_query(pConn, "create stable if not exists abc1.`123_$^)` (ts timestamp, `abc` int) tags(a int)");
 //  if (taos_errno(pRes) != 0) {
 //    printf("failed to create super table 123_$^), reason:%s\n", taos_errstr(pRes));
 //  }
 //
-//  TAOS_RES* pRes = taos_query(pConn, "use abc1");
+//  pRes = taos_query(pConn, "use abc1");
 //  taos_free_result(pRes);
 //  pRes = taos_query(pConn, "drop stable `123_$^)`");
 //  if (taos_errno(pRes) != 0) {
@@ -294,7 +294,7 @@ TEST(testCase, create_db_Test) {
 //
 //  taos_close(pConn);
 //}
-
+//
 //TEST(testCase, create_table_Test) {
 //  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
 //  assert(pConn != NULL);
@@ -313,7 +313,7 @@ TEST(testCase, create_db_Test) {
 //  taos_free_result(pRes);
 //  taos_close(pConn);
 //}
-
+//
 //TEST(testCase, create_ctable_Test) {
 //  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
 //  assert(pConn != NULL);
@@ -324,6 +324,12 @@ TEST(testCase, create_db_Test) {
 //  }
 //  taos_free_result(pRes);
 //
+//  pRes = taos_query(pConn, "create stable if not exists st1 (ts timestamp, k int ) tags(a int)");
+//  if (taos_errno(pRes) != 0) {
+//    printf("failed to create stable, reason:%s\n", taos_errstr(pRes));
+//  }
+//  taos_free_result(pRes);
+//
 //  pRes = taos_query(pConn, "create table tm0 using st1 tags(1)");
 //  if (taos_errno(pRes) != 0) {
 //    printf("failed to create child table tm0, reason:%s\n", taos_errstr(pRes));
@@ -332,17 +338,11 @@ TEST(testCase, create_db_Test) {
 //  taos_free_result(pRes);
 //  taos_close(pConn);
 //}
-
+//
 //TEST(testCase, show_stable_Test) {
 //  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
 //  assert(pConn != nullptr);
 //
-////  TAOS_RES* pRes = taos_query(pConn, "use abc1");
-////  if (taos_errno(pRes) != 0) {
-////    printf("failed to use db, reason:%s\n", taos_errstr(pRes));
-////  }
-////  taos_free_result(pRes);
-//
 //  TAOS_RES* pRes = taos_query(pConn, "show abc1.stables");
 //  if (taos_errno(pRes) != 0) {
 //    printf("failed to show stables, reason:%s\n", taos_errstr(pRes));
@@ -456,24 +456,28 @@ TEST(testCase, create_db_Test) {
 //  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
 //  assert(pConn != NULL);
 //
-//  TAOS_RES* pRes = taos_query(pConn, "use abc1");
+//  TAOS_RES* pRes = taos_query(pConn, "show tables");
+//  if (taos_errno(pRes) != 0) {
+//    printf("failed to show tables, reason:%s\n", taos_errstr(pRes));
 //    taos_free_result(pRes);
+//  }
 //
-//  pRes = taos_query(pConn, "show tables");
+//  pRes = taos_query(pConn, "show abc1.tables");
 //  if (taos_errno(pRes) != 0) {
-//    printf("failed to show vgroups, reason:%s\n", taos_errstr(pRes));
+//    printf("failed to show tables, reason:%s\n", taos_errstr(pRes));
 //    taos_free_result(pRes);
-//    ASSERT_TRUE(false);
 //  }
 //
 //  TAOS_ROW    pRow = NULL;
 //  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
 //  int32_t     numOfFields = taos_num_fields(pRes);
 //
+//  int32_t count = 0;
 //  char str[512] = {0};
+//
 //  while ((pRow = taos_fetch_row(pRes)) != NULL) {
 //    int32_t code = taos_print_row(str, pRow, pFields, numOfFields);
-//    printf("%s\n", str);
+//    printf("%d: %s\n", ++count, str);
 //  }
 //
 //  taos_free_result(pRes);
@@ -544,7 +548,7 @@ TEST(testCase, create_db_Test) {
 //  taos_free_result(pRes);
 //  taos_close(pConn);
 //}
-
+//
 //TEST(testCase, insert_test) {
 //  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
 //  ASSERT_NE(pConn, nullptr);
@@ -562,7 +566,7 @@ TEST(testCase, create_db_Test) {
 //  taos_free_result(pRes);
 //  taos_close(pConn);
 //}
-
+//
 //TEST(testCase, projection_query_tables) {
 //  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
 //  ASSERT_NE(pConn, nullptr);
@@ -613,15 +617,43 @@ TEST(testCase, create_db_Test) {
 //  taos_free_result(pRes);
 //  taos_close(pConn);
 //}
+//
+//TEST(testCase, projection_query_stables) {
+//  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+//  ASSERT_NE(pConn, nullptr);
+//
+//  TAOS_RES* pRes = taos_query(pConn, "use abc1");
+//  taos_free_result(pRes);
+//
+//  pRes = taos_query(pConn, "select ts from m1");
+//  if (taos_errno(pRes) != 0) {
+//    printf("failed to select from table, reason:%s\n", taos_errstr(pRes));
+//    taos_free_result(pRes);
+//    ASSERT_TRUE(false);
+//  }
+//
+//  TAOS_ROW    pRow = NULL;
+//  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
+//  int32_t     numOfFields = taos_num_fields(pRes);
+//
+//  char str[512] = {0};
+//  while ((pRow = taos_fetch_row(pRes)) != NULL) {
+//    int32_t code = taos_print_row(str, pRow, pFields, numOfFields);
+//    printf("%s\n", str);
+//  }
+//
+//  taos_free_result(pRes);
+//  taos_close(pConn);
+//}
 
-TEST(testCase, projection_query_stables) {
+TEST(testCase, agg_query_tables) {
   TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
   ASSERT_NE(pConn, nullptr);
 
   TAOS_RES* pRes = taos_query(pConn, "use abc1");
   taos_free_result(pRes);
 
-  pRes = taos_query(pConn, "select ts from m1");
+  pRes = taos_query(pConn, "select count(*) from tu");
   if (taos_errno(pRes) != 0) {
     printf("failed to select from table, reason:%s\n", taos_errstr(pRes));
     taos_free_result(pRes);

source/dnode/mnode/impl/inc/mndDef.h

@@ -230,7 +230,7 @@ typedef struct {
   char    acct[TSDB_USER_LEN];
   int64_t createdTime;
   int64_t updateTime;
-  int64_t uid;
+  uint64_t uid;
   int32_t cfgVersion;
   int32_t vgVersion;
   int8_t  hashMethod;  // default is 1

source/dnode/mnode/impl/src/mndStb.c

@@ -839,14 +839,12 @@ static int32_t mndRetrieveStb(SMnodeMsg *pReq, SShowObj *pShow, char *data, int3
   SStbObj *pStb = NULL;
   int32_t  cols = 0;
   char    *pWrite;
-  char     prefix[64] = {0};
+  char     prefix[TSDB_DB_FNAME_LEN] = {0};
 
   SDbObj *pDb = mndAcquireDb(pMnode, pShow->db);
-  if (pDb == NULL) {
-    return TSDB_CODE_MND_INVALID_DB;
-  }
+  if (pDb == NULL) return 0;
 
-  tstrncpy(prefix, pShow->db, 64);
+  tstrncpy(prefix, pShow->db, TSDB_DB_FNAME_LEN);
   strcat(prefix, TS_PATH_DELIMITER);
   int32_t prefixLen = (int32_t)strlen(prefix);
 
@@ -855,6 +853,10 @@ static int32_t mndRetrieveStb(SMnodeMsg *pReq, SShowObj *pShow, char *data, int3
     if (pShow->pIter == NULL) break;
 
     if (pStb->dbUid != pDb->uid) {
+      if (strncmp(pStb->db, pDb->name, tListLen(pStb->db)) == 0) {
+        mError("Inconsistent table data, name:%s, db:%s, dbUid:%"PRIu64, pStb->name, pDb->name, pDb->uid);
+      }
+
       sdbRelease(pSdb, pStb);
       continue;
     }

source/dnode/mnode/impl/src/mndSubscribe.c

@@ -55,8 +55,6 @@ int32_t mndInitSubscribe(SMnode *pMnode) {
                      .deleteFp = (SdbDeleteFp)mndSubActionDelete};
 
   mndSetMsgHandle(pMnode, TDMT_MND_SUBSCRIBE, mndProcessSubscribeReq);
-  /*mndSetMsgHandle(pMnode, TDMT_MND_SUBSCRIBE_RSP, mndProcessSubscribeRsp);*/
-  /*mndSetMsgHandle(pMnode, TDMT_VND_SUBSCRIBE, mndProcessSubscribeInternalReq);*/
   mndSetMsgHandle(pMnode, TDMT_VND_SUBSCRIBE_RSP, mndProcessSubscribeInternalRsp);
   mndSetMsgHandle(pMnode, TDMT_MND_MQ_TIMER, mndProcessMqTimerMsg);
   return sdbSetTable(pMnode->pSdb, table);
@@ -95,14 +93,14 @@ static int32_t mndProcessMqTimerMsg(SMnodeMsg *pMsg) {
         SMqConsumerEp *pCEp = taosArrayPop(pSub->unassignedVg);
         pCEp->consumerId = consumerId;
         taosArrayPush(pSub->assigned, pCEp);
-        pSub->nextConsumerIdx++;
+        pSub->nextConsumerIdx = (pSub->nextConsumerIdx + 1) % taosArrayGetSize(pSub->availConsumer);
 
         // build msg
         SMqSetCVgReq req = {
             .vgId = pCEp->vgId,
             .consumerId = consumerId,
         };
-        strcpy(req.cGroup, cgroup);
+        strcpy(req.cgroup, cgroup);
         strcpy(req.topicName, topic);
         strcpy(req.sql, pTopic->sql);
         strcpy(req.logicalPlan, pTopic->logicalPlan);
@@ -170,7 +168,7 @@ static int mndBuildMqSetConsumerVgReq(SMnode *pMnode, STrans *pTrans, SMqConsume
         .vgId = vgId,
         .consumerId = pConsumer->consumerId,
     };
-    strcpy(req.cGroup, pConsumer->cgroup);
+    strcpy(req.cgroup, pConsumer->cgroup);
     strcpy(req.topicName, pTopic->name);
     strcpy(req.sql, pTopic->sql);
     strcpy(req.logicalPlan, pTopic->logicalPlan);

source/dnode/mnode/impl/src/mndSync.c

@@ -92,6 +92,10 @@ static int32_t mndRestoreWal(SMnode *pMnode) {
       goto WAL_RESTORE_OVER;
     }
 
+    if (walCommit(pWal, sdbVer) != 0) {
+      goto WAL_RESTORE_OVER;
+    }
+
     if (walBeginSnapshot(pWal, sdbVer) < 0) {
       goto WAL_RESTORE_OVER;
     }
@@ -99,7 +103,6 @@ static int32_t mndRestoreWal(SMnode *pMnode) {
     if (walEndSnapshot(pWal) < 0) {
       goto WAL_RESTORE_OVER;
     }
-
   }
 
   code = 0;

source/dnode/mnode/impl/src/mndVgroup.c

@@ -540,10 +540,14 @@ static int32_t mndRetrieveVgroups(SMnodeMsg *pReq, SShowObj *pShow, char *data,
   int32_t cols = 0;
   char   *pWrite;
 
+  SDbObj *pDb = mndAcquireDb(pMnode, pShow->db);
+  if (pDb == NULL) return 0;
+
   while (numOfRows < rows) {
     pShow->pIter = sdbFetch(pSdb, SDB_VGROUP, pShow->pIter, (void **)&pVgroup);
     if (pShow->pIter == NULL) break;
 
+    if (pVgroup->dbUid == pDb->uid) {
       cols = 0;
 
       pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
@@ -564,11 +568,13 @@ static int32_t mndRetrieveVgroups(SMnodeMsg *pReq, SShowObj *pShow, char *data,
         STR_WITH_MAXSIZE_TO_VARSTR(pWrite, role, pShow->bytes[cols]);
         cols++;
       }
+      numOfRows++;
+    }
 
     sdbRelease(pSdb, pVgroup);
-    numOfRows++;
   }
 
+  mndReleaseDb(pMnode, pDb);
   mndVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
   pShow->numOfReads += numOfRows;
   return numOfRows;

source/dnode/vnode/inc/tq.h

@@ -27,6 +27,7 @@
 #include "trpc.h"
 #include "ttimer.h"
 #include "tutil.h"
+#include "wal.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -161,7 +162,8 @@ typedef struct STqGroup {
 } STqGroup;
 
 typedef struct STqTaskItem {
-  int32_t       status;
+  int8_t        status;
+  int64_t       offset;
   void*         dst;
   SSubQueryMsg* pMsg;
 } STqTaskItem;
@@ -173,34 +175,29 @@ typedef struct STqBuffer {
   STqTaskItem output[TQ_BUFFER_SIZE];
 } STqBuffer;
 
-typedef struct STqClientHandle {
-  int64_t   clientId;
+typedef struct STqTopicHandle {
   char            topicName[TSDB_TOPIC_FNAME_LEN];
-  char      cGroup[TSDB_TOPIC_FNAME_LEN];
+  char            cgroup[TSDB_TOPIC_FNAME_LEN];
   char*           sql;
   char*           logicalPlan;
   char*           physicalPlan;
   int64_t         committedOffset;
   int64_t         currentOffset;
   STqBuffer       buffer;
-} STqClientHandle;
+  SWalReadHandle* pReadhandle;
+} STqTopicHandle;
+
+typedef struct STqConsumerHandle {
+  int64_t consumerId;
+  int64_t epoch;
+  SArray* topics;  // SArray<STqClientTopic>
+} STqConsumerHandle;
 
 typedef struct STqQueryMsg {
   STqMsgItem*         item;
   struct STqQueryMsg* next;
 } STqQueryMsg;
 
-typedef struct STqLogHandle {
-  void* logHandle;
-  void* (*openLogReader)(void* logHandle);
-  void (*closeLogReader)(void* logReader);
-  int32_t (*logRead)(void* logReader, void** data, int64_t ver);
-
-  int64_t (*logGetFirstVer)(void* logHandle);
-  int64_t (*logGetSnapshotVer)(void* logHandle);
-  int64_t (*logGetLastVer)(void* logHandle);
-} STqLogHandle;
-
 typedef struct STqCfg {
   // TODO
 } STqCfg;
@@ -298,9 +295,9 @@ typedef struct STQ {
   // the handle of meta kvstore
   char*         path;
   STqCfg*       tqConfig;
-  STqLogHandle* tqLogHandle;
   STqMemRef     tqMemRef;
   STqMetaStore* tqMeta;
+  SWal*         pWal;
 } STQ;
 
 typedef struct STqMgmt {
@@ -315,31 +312,27 @@ int  tqInit();
 void tqCleanUp();
 
 // open in each vnode
-STQ* tqOpen(const char* path, STqCfg* tqConfig, STqLogHandle* tqLogHandle, SMemAllocatorFactory* allocFac);
+STQ* tqOpen(const char* path, SWal* pWal, STqCfg* tqConfig, SMemAllocatorFactory* allocFac);
 void tqClose(STQ*);
 
 // void* will be replace by a msg type
 int tqPushMsg(STQ*, void* msg, int64_t version);
 int tqCommit(STQ*);
-int tqConsume(STQ*, SRpcMsg* pReq, SRpcMsg** pRsp);
 
+#if 0
+int tqConsume(STQ*, SRpcMsg* pReq, SRpcMsg** pRsp);
 int tqSetCursor(STQ*, STqSetCurReq* pMsg);
 int tqBufferSetOffset(STqTopic*, int64_t offset);
-
 STqTopic* tqFindTopic(STqGroup*, int64_t topicId);
-
 STqGroup* tqGetGroup(STQ*, int64_t clientId);
-
 STqGroup* tqOpenGroup(STQ*, int64_t topicId, int64_t cgId, int64_t cId);
 int       tqCloseGroup(STQ*, int64_t topicId, int64_t cgId, int64_t cId);
 int       tqRegisterContext(STqGroup*, void* ahandle);
 int       tqSendLaunchQuery(STqMsgItem*, int64_t offset);
+#endif
 
-int tqSerializeGroup(const STqGroup*, STqSerializedHead**);
-
-const void* tqDeserializeGroup(const STqSerializedHead*, STqGroup**);
-
-static int tqQueryExecuting(int32_t status) { return status; }
+int32_t tqProcessConsumeReq(STQ* pTq, SRpcMsg* pMsg, SRpcMsg** ppRsp);
+int32_t tqProcessSetConnReq(STQ* pTq, SMqSetCVgReq* pReq);
 
 typedef struct STqReadHandle {
   int64_t        ver;
@@ -348,16 +341,15 @@ typedef struct STqReadHandle {
   SSubmitMsgIter msgIter;
   SSubmitBlkIter blkIter;
   SMeta*         pMeta;
+  SArray*        pColumnIdList;
 } STqReadHandle;
 
-typedef struct SSubmitBlkScanInfo {
-} SSubmitBlkScanInfo;
-
-STqReadHandle* tqInitSubmitMsgScanner(SMeta* pMeta, SSubmitMsg* pMsg);
+STqReadHandle* tqInitSubmitMsgScanner(SMeta* pMeta, SArray* pColumnIdList);
+void           tqReadHandleSetMsg(STqReadHandle* pHandle, SSubmitMsg* pMsg, int64_t ver);
 bool           tqNextDataBlock(STqReadHandle* pHandle);
 int            tqRetrieveDataBlockInfo(STqReadHandle* pHandle, SDataBlockInfo* pBlockInfo);
 // return SArray<SColumnInfoData>
-SArray* tqRetrieveDataBlock(STqReadHandle* pHandle, SArray* pColumnIdList);
+SArray* tqRetrieveDataBlock(STqReadHandle* pHandle);
 
 #ifdef __cplusplus
 }

source/dnode/vnode/src/inc/tqInt.h

@@ -43,6 +43,9 @@ extern int32_t tqDebugFlag;
 // delete persistent storage for meta info
 // int tqDropTCGroup(STQ*, const char* topic, int cgId);
 
+int tqSerializeGroup(const STqGroup*, STqSerializedHead**);
+const void* tqDeserializeGroup(const STqSerializedHead* pHead, STqGroup** ppGroup);
+static int FORCE_INLINE tqQueryExecuting(int32_t status) { return status; }
 #ifdef __cplusplus
 }
 #endif

source/dnode/vnode/src/tq/tq.c

@@ -37,7 +37,7 @@ const void* tqDeserializeItem(const void* pBytes, STqMsgItem* pItem);
 
 int tqInit() {
   int8_t old = atomic_val_compare_exchange_8(&tqMgmt.inited, 0, 1);
-  if(old == 1) return 0;
+  if (old == 1) return 0;
 
   tqMgmt.timer = taosTmrInit(0, 0, 0, "TQ");
   return 0;
@@ -45,12 +45,12 @@ int tqInit() {
 
 void tqCleanUp() {
   int8_t old = atomic_val_compare_exchange_8(&tqMgmt.inited, 1, 0);
-  if(old == 0) return;
+  if (old == 0) return;
   taosTmrStop(tqMgmt.timer);
   taosTmrCleanUp(tqMgmt.timer);
 }
 
-STQ* tqOpen(const char* path, STqCfg* tqConfig, STqLogHandle* tqLogHandle, SMemAllocatorFactory* allocFac) {
+STQ* tqOpen(const char* path, SWal* pWal, STqCfg* tqConfig, SMemAllocatorFactory* allocFac) {
   STQ* pTq = malloc(sizeof(STQ));
   if (pTq == NULL) {
     terrno = TSDB_CODE_TQ_OUT_OF_MEMORY;
@@ -58,7 +58,6 @@ STQ* tqOpen(const char* path, STqCfg* tqConfig, STqLogHandle* tqLogHandle, SMemA
   }
   pTq->path = strdup(path);
   pTq->tqConfig = tqConfig;
-  pTq->tqLogHandle = tqLogHandle;
 #if 0
   pTq->tqMemRef.pAllocatorFactory = allocFac;
   pTq->tqMemRef.pAllocator = allocFac->create(allocFac);
@@ -150,7 +149,7 @@ int tqCreateGroup(STQ* pTq, int64_t topicId, int64_t cgId, int64_t cId, STqGroup
   memset(pGroup, 0, sizeof(STqGroup));
 
   pGroup->topicList = tdListNew(sizeof(STqTopic));
-  if(pGroup->topicList == NULL) {
+  if (pGroup->topicList == NULL) {
     free(pGroup);
     return -1;
   }
@@ -329,7 +328,7 @@ int tqProcessCMsg(STQ* pTq, STqConsumeReq* pMsg, STqRspHandle* pRsp) {
 }
 
 int tqConsume(STQ* pTq, SRpcMsg* pReq, SRpcMsg** pRsp) {
-  STqConsumeReq *pMsg = pReq->pCont;
+  STqConsumeReq* pMsg = pReq->pCont;
   int64_t        clientId = pMsg->head.clientId;
   STqGroup*      pGroup = tqGetGroup(pTq, clientId);
   if (pGroup == NULL) {
@@ -343,8 +342,7 @@ int tqConsume(STQ* pTq, SRpcMsg* pReq, SRpcMsg** pRsp) {
   int numOfMsgs = 0;
   int sizeLimit = 4096;
 
-
-  STqConsumeRsp *pCsmRsp = (*pRsp)->pCont;
+  STqConsumeRsp* pCsmRsp = (*pRsp)->pCont;
   void*          ptr = realloc((*pRsp)->pCont, sizeof(STqConsumeRsp) + sizeLimit);
   if (ptr == NULL) {
     terrno = TSDB_CODE_TQ_OUT_OF_MEMORY;
@@ -358,14 +356,14 @@ int tqConsume(STQ* pTq, SRpcMsg* pReq, SRpcMsg** pRsp) {
   STqMsgContent* buffer = NULL;
   SArray*        pArray = taosArrayInit(0, sizeof(void*));
 
-  SListNode *pn;
-  while((pn = tdListNext(&iter)) != NULL) {
+  SListNode* pn;
+  while ((pn = tdListNext(&iter)) != NULL) {
     STqTopic*   pTopic = *(STqTopic**)pn->data;
     int         idx = pTopic->floatingCursor % TQ_BUFFER_SIZE;
     STqMsgItem* pItem = &pTopic->buffer[idx];
     if (pItem->content != NULL && pItem->offset == pTopic->floatingCursor) {
-      if(pItem->status == TQ_ITEM_READY) {
-        //if has data
+      if (pItem->status == TQ_ITEM_READY) {
+        // if has data
         totSize += pTopic->buffer[idx].size;
         if (totSize > sizeLimit) {
           void* ptr = realloc((*pRsp)->pCont, sizeof(STqConsumeRsp) + totSize);
@@ -388,13 +386,13 @@ int tqConsume(STQ* pTq, SRpcMsg* pReq, SRpcMsg** pRsp) {
         if (totSize > sizeLimit) {
           break;
         }
-      } else if(pItem->status == TQ_ITEM_PROCESS) {
-        //if not have data but in process
+      } else if (pItem->status == TQ_ITEM_PROCESS) {
+        // if not have data but in process
 
-      } else if(pItem->status == TQ_ITEM_EMPTY){
-        //if not have data and not in process
+      } else if (pItem->status == TQ_ITEM_EMPTY) {
+        // if not have data and not in process
         int32_t old = atomic_val_compare_exchange_32(&pItem->status, TQ_ITEM_EMPTY, TQ_ITEM_PROCESS);
-        if(old != TQ_ITEM_EMPTY) {
+        if (old != TQ_ITEM_EMPTY) {
           continue;
         }
         pItem->offset = pTopic->floatingCursor;
@@ -416,22 +414,22 @@ int tqConsume(STQ* pTq, SRpcMsg* pReq, SRpcMsg** pRsp) {
   }
 
   // fetched a num of msgs, rpc response
-  for(int i = 0; i < pArray->size; i++) {
+  for (int i = 0; i < pArray->size; i++) {
     STqMsgItem* pItem = taosArrayGet(pArray, i);
 
-    //read from wal
+    // read from wal
     void* raw = NULL;
     /*int code = pTq->tqLogReader->logRead(, &raw, pItem->offset);*/
-    int code = pTq->tqLogHandle->logRead(pItem->pTopic->logReader, &raw, pItem->offset);
-    if(code < 0) {
-      //TODO: error
-    }
-    //get msgType
-    //if submitblk
+    /*int code = pTq->tqLogHandle->logRead(pItem->pTopic->logReader, &raw, pItem->offset);*/
+    /*if (code < 0) {*/
+      // TODO: error
+    /*}*/
+    // get msgType
+    // if submitblk
     pItem->executor->assign(pItem->executor->runtimeEnv, raw);
     SSDataBlock* content = pItem->executor->exec(pItem->executor->runtimeEnv);
     pItem->content = content;
-    //if other type, send just put into buffer
+    // if other type, send just put into buffer
     /*pItem->content = raw;*/
 
     int32_t old = atomic_val_compare_exchange_32(&pItem->status, TQ_ITEM_PROCESS, TQ_ITEM_READY);
@@ -608,20 +606,118 @@ int tqItemSSize() {
   return 0;
 }
 
-STqReadHandle* tqInitSubmitMsgScanner(SMeta* pMeta, SSubmitMsg *pMsg) {
+int32_t tqProcessConsumeReq(STQ* pTq, SRpcMsg* pMsg, SRpcMsg** ppRsp) {
+  SMqCVConsumeReq* pReq = pMsg->pCont;
+  int64_t          reqId = pReq->reqId;
+  int64_t          consumerId = pReq->consumerId;
+  int64_t          offset = pReq->offset;
+  int64_t          blockingTime = pReq->blockingTime;
+
+  STqConsumerHandle* pConsumer = tqHandleGet(pTq->tqMeta, consumerId);
+  int sz = taosArrayGetSize(pConsumer->topics);
+
+  for (int i = 0 ; i < sz; i++) {
+    STqTopicHandle *pHandle = taosArrayGet(pConsumer->topics, i);
+
+    int8_t           pos = offset % TQ_BUFFER_SIZE;
+    int8_t           old = atomic_val_compare_exchange_8(&pHandle->buffer.output[pos].status, 0, 1);
+    if (old == 1) {
+      // do nothing
+      continue;
+    }
+    if (walReadWithHandle(pHandle->pReadhandle, offset) < 0) {
+      // TODO
+    }
+    SWalHead* pHead = pHandle->pReadhandle->pHead;
+    while (pHead->head.msgType != TDMT_VND_SUBMIT) {
+      // read until find TDMT_VND_SUBMIT
+    }
+    SSubmitMsg* pCont = (SSubmitMsg*)&pHead->head.body;
+
+    SSubQueryMsg* pQueryMsg = pHandle->buffer.output[pos].pMsg;
+
+    // TODO: launch query and get output data
+    void* outputData;
+    pHandle->buffer.output[pos].dst = outputData;
+    if (pHandle->buffer.firstOffset == -1
+        || pReq->offset < pHandle->buffer.firstOffset) {
+      pHandle->buffer.firstOffset = pReq->offset;
+    }
+    if (pHandle->buffer.lastOffset == -1
+        || pReq->offset > pHandle->buffer.lastOffset) {
+      pHandle->buffer.lastOffset = pReq->offset;
+    }
+    atomic_store_8(&pHandle->buffer.output[pos].status, 1);
+
+    // put output into rsp
+  }
+
+  // launch query
+  // get result
+  SMqCvConsumeRsp* pRsp;
+  return 0;
+}
+
+int32_t tqProcessSetConnReq(STQ* pTq, SMqSetCVgReq* pReq) {
+  STqConsumerHandle* pConsumer = calloc(sizeof(STqConsumerHandle), 1);
+  if (pConsumer == NULL) {
+    return -1;
+  }
+  
+  STqTopicHandle* pTopic = calloc(sizeof(STqTopicHandle), 1);
+  if (pTopic == NULL) {
+    free(pConsumer);
+    return -1;
+  }
+  strcpy(pTopic->topicName, pReq->topicName); 
+  strcpy(pTopic->cgroup, pReq->cgroup); 
+  strcpy(pTopic->sql, pReq->sql);
+  strcpy(pTopic->logicalPlan, pReq->logicalPlan);
+  strcpy(pTopic->physicalPlan, pReq->physicalPlan);
+  SArray *pArray;
+  //TODO: deserialize to SQueryDag
+  SQueryDag *pDag;
+  // convert to task
+  if (schedulerConvertDagToTaskList(pDag, &pArray) < 0) {
+    // TODO: handle error
+  }
+  ASSERT(taosArrayGetSize(pArray) == 0);
+  STaskInfo *pInfo = taosArrayGet(pArray, 0);
+  SArray* pTasks;
+  schedulerCopyTask(pInfo, &pTasks, TQ_BUFFER_SIZE);
+  pTopic->buffer.firstOffset = -1;
+  pTopic->buffer.lastOffset = -1;
+  for (int i = 0; i < TQ_BUFFER_SIZE; i++) {
+    SSubQueryMsg* pMsg = taosArrayGet(pTasks, i);
+    pTopic->buffer.output[i].pMsg = pMsg;
+    pTopic->buffer.output[i].status = 0;
+  }
+  pTopic->pReadhandle = walOpenReadHandle(pTq->pWal);
+  // write mq meta
+  return 0;
+}
+
+STqReadHandle* tqInitSubmitMsgScanner(SMeta* pMeta, SArray* pColumnIdList) {
   STqReadHandle* pReadHandle = malloc(sizeof(STqReadHandle));
   if (pReadHandle == NULL) {
     return NULL;
   }
   pReadHandle->pMeta = pMeta;
-  pReadHandle->pMsg = pMsg;
-  tInitSubmitMsgIter(pMsg, &pReadHandle->msgIter);
+  pReadHandle->pMsg = NULL;
   pReadHandle->ver = -1;
+  pReadHandle->pColumnIdList = pColumnIdList;
   return NULL;
 }
 
+void tqReadHandleSetMsg(STqReadHandle* pReadHandle, SSubmitMsg* pMsg, int64_t ver) {
+  pReadHandle->pMsg = pMsg;
+  tInitSubmitMsgIter(pMsg, &pReadHandle->msgIter);
+  pReadHandle->ver = ver;
+  memset(&pReadHandle->blkIter, 0, sizeof(SSubmitBlkIter));
+}
+
 bool tqNextDataBlock(STqReadHandle* pHandle) {
-  if(tGetSubmitMsgNext(&pHandle->msgIter, &pHandle->pBlock) < 0) {
+  if (tGetSubmitMsgNext(&pHandle->msgIter, &pHandle->pBlock) < 0) {
     return false;
   }
   return true;
@@ -634,14 +730,14 @@ int tqRetrieveDataBlockInfo(STqReadHandle* pHandle, SDataBlockInfo* pBlockInfo)
   pBlockInfo->numOfCols = pSchema->nCols;
   pBlockInfo->rows = pHandle->pBlock->numOfRows;
   pBlockInfo->uid = pHandle->pBlock->uid;
-  //TODO: filter out unused column
+  // TODO: filter out unused column
   return 0;
 }
-SArray *tqRetrieveDataBlock(STqReadHandle* pHandle, SArray* pColumnIdList) {
+SArray* tqRetrieveDataBlock(STqReadHandle* pHandle) {
   int32_t         sversion = pHandle->pBlock->sversion;
   SSchemaWrapper* pSchemaWrapper = metaGetTableSchema(pHandle->pMeta, pHandle->pBlock->uid, sversion, true);
   STSchema*       pTschema = metaGetTbTSchema(pHandle->pMeta, pHandle->pBlock->uid, sversion);
-  SArray *pArray = taosArrayInit(pSchemaWrapper->nCols, sizeof(SColumnInfoData));
+  SArray*         pArray = taosArrayInit(pSchemaWrapper->nCols, sizeof(SColumnInfoData));
   if (pArray == NULL) {
     return NULL;
   }
@@ -652,25 +748,21 @@ SArray *tqRetrieveDataBlock(STqReadHandle* pHandle, SArray* pColumnIdList) {
     return NULL;
   }
 
-  for (int i = 0; i < pTschema->numOfCols; i++) {
-    //TODO: filter out unused column
-    taosArrayPush(pColumnIdList, &(schemaColAt(pTschema, i)->colId));
-  }
-
   SMemRow row;
   int32_t kvIdx;
   while ((row = tGetSubmitBlkNext(&pHandle->blkIter)) != NULL) {
     for (int i = 0; i < pTschema->numOfCols && kvIdx < pTschema->numOfCols; i++) {
-    //TODO: filter out unused column
-      STColumn *pCol = schemaColAt(pTschema, i);
+      // TODO: filter out unused column
+      STColumn* pCol = schemaColAt(pTschema, i);
       void* val = tdGetMemRowDataOfColEx(row, pCol->colId, pCol->type, TD_DATA_ROW_HEAD_SIZE + pCol->offset, &kvIdx);
-      //TODO: handle varlen
+      // TODO: handle varlen
       memcpy(POINTER_SHIFT(colInfo.pData, pCol->offset), val, pCol->bytes);
     }
   }
   taosArrayPush(pArray, &colInfo);
   return pArray;
 }
-/*int tqLoadDataBlock(SExecTaskInfo* pTaskInfo, SSubmitBlkScanInfo* pSubmitBlkScanInfo, SSDataBlock* pBlock, uint32_t status) {*/
-  /*return 0;*/
+/*int tqLoadDataBlock(SExecTaskInfo* pTaskInfo, SSubmitBlkScanInfo* pSubmitBlkScanInfo, SSDataBlock* pBlock, uint32_t
+ * status) {*/
+/*return 0;*/
 /*}*/

source/dnode/vnode/src/vnd/vnodeMain.c

@@ -117,14 +117,6 @@ static int vnodeOpenImpl(SVnode *pVnode) {
     return -1;
   }
 
-  // TODO: Open TQ
-  sprintf(dir, "%s/tq", pVnode->path);
-  pVnode->pTq = tqOpen(dir, &(pVnode->config.tqCfg), NULL, vBufPoolGetMAF(pVnode));
-  if (pVnode->pTq == NULL) {
-    // TODO: handle error
-    return -1;
-  }
-
   // Open WAL
   sprintf(dir, "%s/wal", pVnode->path);
   pVnode->pWal = walOpen(dir, &(pVnode->config.walCfg));
@@ -133,6 +125,14 @@ static int vnodeOpenImpl(SVnode *pVnode) {
     return -1;
   }
 
+  // Open TQ
+  sprintf(dir, "%s/tq", pVnode->path);
+  pVnode->pTq = tqOpen(dir, pVnode->pWal, &(pVnode->config.tqCfg), vBufPoolGetMAF(pVnode));
+  if (pVnode->pTq == NULL) {
+    // TODO: handle error
+    return -1;
+  }
+
   // Open Query
   if (vnodeQueryOpen(pVnode)) {
     return -1;

source/dnode/vnode/src/vnd/vnodeQuery.c

@@ -58,7 +58,7 @@ int vnodeProcessFetchReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
     case TDMT_VND_TABLE_META:
       return vnodeGetTableMeta(pVnode, pMsg, pRsp);
     case TDMT_VND_CONSUME:
-      return 0;
+      return tqProcessConsumeReq(pVnode->pTq, pMsg, pRsp);
     default:
       vError("unknown msg type:%d in fetch queue", pMsg->msgType);
       return TSDB_CODE_VND_APP_ERROR;
@@ -166,16 +166,26 @@ static int32_t vnodeGetTableList(SVnode *pVnode, SRpcMsg *pMsg) {
 
   char *  name = NULL;
   int32_t totalLen = 0;
+  int32_t numOfTables = 0;
   while ((name = metaTbCursorNext(pCur)) != NULL) {
+    if (numOfTables < 1000) {  // TODO: temp get tables of vnode, and should del when show tables commad ok.
       taosArrayPush(pArray, &name);
       totalLen += strlen(name);
     }
+    numOfTables++;
+  }
+
+  // TODO: temp debug, and should del when show tables command ok
+  vError("====vgId:%d, numOfTables: %d", pVnode->vgId, numOfTables);
+  if (numOfTables > 1000) {
+     numOfTables = 1000;
+  }
 
   metaCloseTbCursor(pCur);
 
   int32_t rowLen =
       (TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE) + 8 + 2 + (TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE) + 8 + 4;
-  int32_t numOfTables = (int32_t)taosArrayGetSize(pArray);
+  //int32_t numOfTables = (int32_t)taosArrayGetSize(pArray);
 
   int32_t payloadLen = rowLen * numOfTables;
   //  SVShowTablesFetchReq *pFetchReq = pMsg->pCont;
@@ -203,5 +213,6 @@ static int32_t vnodeGetTableList(SVnode *pVnode, SRpcMsg *pMsg) {
   };
 
   rpcSendResponse(&rpcMsg);
+  taosArrayDestroy(pArray);
   return 0;
 }

source/dnode/vnode/src/vnd/vnodeWrite.c

@@ -13,8 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "vnd.h"
 #include "tq.h"
+#include "vnd.h"
 
 int vnodeProcessNoWalWMsgs(SVnode *pVnode, SRpcMsg *pMsg) {
   switch (pMsg->msgType) {
@@ -34,7 +34,7 @@ int vnodeProcessWMsgs(SVnode *pVnode, SArray *pMsgs) {
     pMsg = *(SRpcMsg **)taosArrayGet(pMsgs, i);
 
     // ser request version
-    void *  pBuf = POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead));
+    void   *pBuf = POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead));
     int64_t ver = pVnode->state.processed++;
     taosEncodeFixedU64(&pBuf, ver);
 
@@ -53,7 +53,7 @@ int vnodeProcessWMsgs(SVnode *pVnode, SArray *pMsgs) {
 int vnodeApplyWMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
   SVCreateTbReq      vCreateTbReq;
   SVCreateTbBatchReq vCreateTbBatchReq;
-  void *             ptr = vnodeMalloc(pVnode, pMsg->contLen);
+  void              *ptr = vnodeMalloc(pVnode, pMsg->contLen);
   if (ptr == NULL) {
     // TODO: handle error
   }
@@ -110,39 +110,11 @@ int vnodeApplyWMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
       }
       break;
     case TDMT_VND_MQ_SET_CONN: {
-      char* reqStr = ptr;
       SMqSetCVgReq req;
-      tDecodeSMqSetCVgReq(reqStr, &req);
-      STqClientHandle* pHandle = calloc(sizeof(STqClientHandle), 1);
-      if (pHandle == NULL) {
-        // TODO: handle error
-      }
-      strcpy(pHandle->topicName, req.topicName); 
-      strcpy(pHandle->cGroup, req.cGroup); 
-      strcpy(pHandle->sql, req.sql);
-      strcpy(pHandle->logicalPlan, req.logicalPlan);
-      strcpy(pHandle->physicalPlan, req.physicalPlan);
-      SArray *pArray;
-      //TODO: deserialize to SQueryDag
-      SQueryDag *pDag;
-      // convert to task
-      if (schedulerConvertDagToTaskList(pDag, &pArray) < 0) {
-        // TODO: handle error
-      }
-      ASSERT(taosArrayGetSize(pArray) == 0);
-      STaskInfo *pInfo = taosArrayGet(pArray, 0);
-      SArray* pTasks;
-      schedulerCopyTask(pInfo, &pTasks, TQ_BUFFER_SIZE);
-      pHandle->buffer.firstOffset = -1;
-      pHandle->buffer.lastOffset = -1;
-      for (int i = 0; i < TQ_BUFFER_SIZE; i++) {
-        SSubQueryMsg* pMsg = taosArrayGet(pTasks, i);
-        pHandle->buffer.output[i].pMsg = pMsg;
-        pHandle->buffer.output[i].status = 0;
+      tDecodeSMqSetCVgReq(ptr, &req);
+      if (tqProcessSetConnReq(pVnode->pTq, &req) < 0) {
       }
-      // write mq meta
-    }
-      break;
+    } break;
     default:
       ASSERT(0);
       break;

source/libs/executor/inc/executil.h

@@ -94,7 +94,7 @@ struct SUdfInfo;
 
 int32_t getOutputInterResultBufSize(struct STaskAttr* pQueryAttr);
 
-size_t  getResultRowSize(struct STaskRuntimeEnv* pRuntimeEnv);
+size_t  getResultRowSize(SArray* pExprInfo);
 int32_t initResultRowInfo(SResultRowInfo* pResultRowInfo, int32_t size, int16_t type);
 void    cleanupResultRowInfo(SResultRowInfo* pResultRowInfo);
 

source/libs/executor/inc/executorimpl.h

@@ -375,9 +375,12 @@ typedef struct STaskParam {
 } STaskParam;
 
 typedef struct SExchangeInfo {
-  int32_t numOfSources;
-  SEpSet *pEpset;
+  SArray            *pSources;
   int32_t            bytes;   // total load bytes from remote
+  tsem_t             ready;
+  void              *pTransporter;
+  SRetrieveTableRsp *pRsp;
+  SSDataBlock       *pResult;
 } SExchangeInfo;
 
 typedef struct STableScanInfo {
@@ -411,11 +414,16 @@ typedef struct STagScanInfo {
   int32_t      curPos;
 } STagScanInfo;
 
+typedef struct SStreamBlockScanInfo {
+
+} SStreamBlockScanInfo;
+
 typedef struct SOptrBasicInfo {
   SResultRowInfo    resultRowInfo;
   int32_t          *rowCellInfoOffset;  // offset value for each row result cell info
   SQLFunctionCtx   *pCtx;
   SSDataBlock      *pRes;
+  void             *keyBuf;
 } SOptrBasicInfo;
 
 typedef struct SOptrBasicInfo STableIntervalOperatorInfo;
@@ -423,6 +431,13 @@ typedef struct SOptrBasicInfo STableIntervalOperatorInfo;
 typedef struct SAggOperatorInfo {
   SOptrBasicInfo        binfo;
   uint32_t              seed;
+  SDiskbasedResultBuf  *pResultBuf;       // query result buffer based on blocked-wised disk file
+  SHashObj*             pResultRowHashTable; // quick locate the window object for each result
+  SHashObj*             pResultRowListSet;   // used to check if current ResultRowInfo has ResultRow object or not
+  SArray*               pResultRowArrayList; // The array list that contains the Result rows
+  char*                 keyBuf;           // window key buffer
+  SResultRowPool*       pool;             // The window result objects pool, all the resultRow Objects are allocated and managed by this object.
+  STableQueryInfo      *current;
 } SAggOperatorInfo;
 
 typedef struct SProjectOperatorInfo {
@@ -543,15 +558,14 @@ typedef struct SOrderOperatorInfo {
   SSDataBlock *pDataBlock;
 } SOrderOperatorInfo;
 
-void appendUpstream(SOperatorInfo* p, SOperatorInfo* pUpstream);
-
-SOperatorInfo* createExchangeOperatorInfo(const SVgroupInfo* pVgroups, int32_t numOfSources, int32_t numOfOutput, SExecTaskInfo* pTaskInfo);
+SOperatorInfo* createExchangeOperatorInfo(const SArray* pSources, const SArray* pSchema, SExecTaskInfo* pTaskInfo);
 
 SOperatorInfo* createDataBlocksOptScanInfo(void* pTsdbReadHandle, int32_t order, int32_t numOfOutput, int32_t repeatTime, int32_t reverseTime, SExecTaskInfo* pTaskInfo);
 SOperatorInfo* createTableScanOperatorInfo(void* pTsdbReadHandle, int32_t order, int32_t numOfOutput, int32_t repeatTime, SExecTaskInfo* pTaskInfo);
 SOperatorInfo* createTableSeqScanOperator(void* pTsdbReadHandle, STaskRuntimeEnv* pRuntimeEnv);
+SOperatorInfo* createSubmitBlockScanOperatorInfo(void *pSubmitBlockReadHandle, int32_t numOfOutput, SExecTaskInfo* pTaskInfo);
 
-SOperatorInfo* createAggregateOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExpr, int32_t numOfOutput);
+SOperatorInfo* createAggregateOperatorInfo(SOperatorInfo* downstream, SArray* pExprInfo, SExecTaskInfo* pTaskInfo);
 SOperatorInfo* createProjectOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SOperatorInfo* downstream, SExprInfo* pExpr, int32_t numOfOutput);
 SOperatorInfo* createLimitOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SOperatorInfo* downstream);
 SOperatorInfo* createTimeIntervalOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SOperatorInfo* downstream, SExprInfo* pExpr, int32_t numOfOutput);
@@ -649,6 +663,6 @@ int32_t getMaximumIdleDurationSec();
 
 void doInvokeUdf(struct SUdfInfo* pUdfInfo, SQLFunctionCtx *pCtx, int32_t idx, int32_t type);
 void setTaskStatus(SExecTaskInfo *pTaskInfo, int8_t status);
-int32_t doCreateExecTaskInfo(SSubplan* pPlan, SExecTaskInfo** pTaskInfo, STableGroupInfo* pGroupInfo, void* readerHandle);
+int32_t doCreateExecTaskInfo(SSubplan* pPlan, SExecTaskInfo** pTaskInfo, void* readerHandle);
 
 #endif  // TDENGINE_EXECUTORIMPL_H

source/libs/executor/src/executil.c

@@ -168,16 +168,14 @@ void clearResultRow(STaskRuntimeEnv *pRuntimeEnv, SResultRow *pResultRow, int16_
 }
 
 // TODO refactor: use macro
-struct SResultRowEntryInfo* getResultCell(const SResultRow* pRow, int32_t index, int32_t* offset) {
+SResultRowEntryInfo* getResultCell(const SResultRow* pRow, int32_t index, int32_t* offset) {
   assert(index >= 0 && offset != NULL);
-//  return (SResultRowEntryInfo*)((char*) pRow->pCellInfo + offset[index]);
-return NULL;
+  return (SResultRowEntryInfo*)((char*) pRow->pEntryInfo + offset[index]);
 }
 
-size_t getResultRowSize(STaskRuntimeEnv* pRuntimeEnv) {
-  STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr;
-  return 0;
-//  return (pQueryAttr->numOfOutput * sizeof(SResultRowEntryInfo)) + pQueryAttr->interBufSize + sizeof(SResultRow);
+size_t getResultRowSize(SArray* pExprInfo) {
+  size_t numOfOutput = taosArrayGetSize(pExprInfo);
+  return (numOfOutput * sizeof(SResultRowEntryInfo)) + /*pQueryAttr->interBufSize +*/ sizeof(SResultRow);
 }
 
 SResultRowPool* initResultRowPool(size_t size) {

source/libs/executor/src/executorMain.c

@@ -73,45 +73,7 @@ int32_t qCreateExecTask(void* tsdb, int32_t vgId, SSubplan* pSubplan, qTaskInfo_
   assert(tsdb != NULL && pSubplan != NULL);
   SExecTaskInfo** pTask = (SExecTaskInfo**)pTaskInfo;
 
-  int32_t         code = 0;
-  uint64_t        uid = 0;
-  STimeWindow     window = TSWINDOW_INITIALIZER;
-  int32_t         tableType = 0;
-
-  SPhyNode   *pPhyNode = pSubplan->pNode;
-  if (pPhyNode->info.type == OP_TableScan || pPhyNode->info.type == OP_DataBlocksOptScan) {
-    STableScanPhyNode* pTableScanNode = (STableScanPhyNode*)pPhyNode;
-    uid       = pTableScanNode->scan.uid;
-    window    = pTableScanNode->window;
-    tableType = pTableScanNode->scan.tableType;
-  } else {
-    assert(0);
-  }
-
-  STableGroupInfo groupInfo = {0};
-  if (tableType == TSDB_SUPER_TABLE) {
-    code = tsdbQuerySTableByTagCond(tsdb, uid, window.skey, NULL, 0, 0, NULL, &groupInfo, NULL, 0, pSubplan->id.queryId);
-    if (code != TSDB_CODE_SUCCESS) {
-      goto _error;
-    }
-  } else { // Create one table group.
-    groupInfo.numOfTables = 1;
-    groupInfo.pGroupList = taosArrayInit(1, POINTER_BYTES);
-
-    SArray* pa = taosArrayInit(1, sizeof(STableKeyInfo));
-
-    STableKeyInfo info = {.pTable = NULL, .lastKey = 0, .uid = uid};
-    taosArrayPush(pa, &info);
-    taosArrayPush(groupInfo.pGroupList, &pa);
-  }
-
-  if (groupInfo.numOfTables == 0) {
-    code = 0;
-//    qDebug("no table qualified for query, reqId:0x%"PRIx64, (*pTask)->id.queryId);
-    goto _error;
-  }
-
-  code = doCreateExecTaskInfo(pSubplan, pTask, &groupInfo, tsdb);
+  int32_t code = doCreateExecTaskInfo(pSubplan, pTask, tsdb);
   if (code != TSDB_CODE_SUCCESS) {
     goto _error;
   }
@@ -126,7 +88,7 @@ int32_t qCreateExecTask(void* tsdb, int32_t vgId, SSubplan* pSubplan, qTaskInfo_
 
   *handle = (*pTask)->dsHandle;
 
-  _error:
+_error:
   // if failed to add ref for all tables in this query, abort current query
   return code;
 }
@@ -182,7 +144,7 @@ int32_t qExecTask(qTaskInfo_t tinfo, SSDataBlock** pRes, uint64_t *useconds) {
 
   // todo: remove it.
   if (tinfo == NULL) {
-    return NULL;
+    return TSDB_CODE_SUCCESS;
   }
 
   *pRes = NULL;

source/libs/executor/src/executorimpl.c

@@ -12,11 +12,12 @@
  * 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 <parser.h>
+#include "exception.h"
 #include "os.h"
-#include "tmsg.h"
 #include "tglobal.h"
+#include "tmsg.h"
 #include "ttime.h"
-#include "exception.h"
 
 #include "executorimpl.h"
 #include "function.h"
@@ -176,7 +177,7 @@ static void setResultOutputBuf(STaskRuntimeEnv* pRuntimeEnv, SResultRow* pResult
 void setResultRowOutputBufInitCtx(STaskRuntimeEnv *pRuntimeEnv, SResultRow *pResult, SQLFunctionCtx* pCtx, int32_t numOfOutput, int32_t* rowCellInfoOffset);
 static bool functionNeedToExecute(STaskRuntimeEnv *pRuntimeEnv, SQLFunctionCtx *pCtx);
 
-static void setBlockStatisInfo(SQLFunctionCtx *pCtx, SSDataBlock* pSDataBlock, SColIndex* pColIndex);
+static void setBlockStatisInfo(SQLFunctionCtx *pCtx, SSDataBlock* pSDataBlock, SColumn* pColumn);
 
 static void destroyTableQueryInfoImpl(STableQueryInfo *pTableQueryInfo);
 static bool hasMainOutput(STaskAttr *pQueryAttr);
@@ -309,6 +310,31 @@ SSDataBlock* createOutputBuf(SExprInfo* pExpr, int32_t numOfOutput, int32_t numO
   return res;
 }
 
+SSDataBlock* createOutputBuf_rv(SArray* pExprInfo, int32_t numOfRows) {
+  const static int32_t minSize = 8;
+
+  size_t numOfOutput = taosArrayGetSize(pExprInfo);
+
+  SSDataBlock *res = calloc(1, sizeof(SSDataBlock));
+  res->info.numOfCols = numOfOutput;
+  res->pDataBlock = taosArrayInit(numOfOutput, sizeof(SColumnInfoData));
+
+  for (int32_t i = 0; i < numOfOutput; ++i) {
+    SColumnInfoData idata = {{0}};
+    SExprInfo* pExpr = taosArrayGetP(pExprInfo, i);
+
+    idata.info.type  = pExpr->base.resSchema.type;
+    idata.info.bytes = pExpr->base.resSchema.bytes;
+    idata.info.colId = pExpr->base.resSchema.colId;
+
+    int32_t size = MAX(idata.info.bytes * numOfRows, minSize);
+    idata.pData = calloc(1, size);  // at least to hold a pointer on x64 platform
+    taosArrayPush(res->pDataBlock, &idata);
+  }
+
+  return res;
+}
+
 void* destroyOutputBuf(SSDataBlock* pBlock) {
   if (pBlock == NULL) {
     return NULL;
@@ -357,8 +383,8 @@ static bool isProjQuery(STaskAttr *pQueryAttr) {
   return true;
 }
 
-static bool hasNull(SColIndex* pColIndex, SColumnDataAgg *pStatis) {
-  if (TSDB_COL_IS_TAG(pColIndex->flag) || TSDB_COL_IS_UD_COL(pColIndex->flag) || pColIndex->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
+static bool hasNull(SColumn* pColumn, SColumnDataAgg *pStatis) {
+  if (TSDB_COL_IS_TAG(pColumn->flag) || TSDB_COL_IS_UD_COL(pColumn->flag) || pColumn->info.colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
     return false;
   }
 
@@ -369,7 +395,7 @@ static bool hasNull(SColIndex* pColIndex, SColumnDataAgg *pStatis) {
   return true;
 }
 
-static void prepareResultListBuffer(SResultRowInfo* pResultRowInfo, STaskRuntimeEnv* pRuntimeEnv) {
+static void prepareResultListBuffer(SResultRowInfo* pResultRowInfo, jmp_buf env) {
   // more than the capacity, reallocate the resources
   if (pResultRowInfo->size < pResultRowInfo->capacity) {
     return;
@@ -384,7 +410,7 @@ static void prepareResultListBuffer(SResultRowInfo* pResultRowInfo, STaskRuntime
 
   char *t = realloc(pResultRowInfo->pResult, (size_t)(newCapacity * POINTER_BYTES));
   if (t == NULL) {
-    longjmp(pRuntimeEnv->env, TSDB_CODE_QRY_OUT_OF_MEMORY);
+    longjmp(env, TSDB_CODE_QRY_OUT_OF_MEMORY);
   }
 
   pResultRowInfo->pResult = (SResultRow **)t;
@@ -473,7 +499,7 @@ static SResultRow* doSetResultOutBufByKey(STaskRuntimeEnv* pRuntimeEnv, SResultR
   }
 
   if (!existed) {
-    prepareResultListBuffer(pResultRowInfo, pRuntimeEnv);
+//    prepareResultListBuffer(pResultRowInfo, pRuntimeEnv);
 
     SResultRow *pResult = NULL;
     if (p1 == NULL) {
@@ -507,6 +533,80 @@ static SResultRow* doSetResultOutBufByKey(STaskRuntimeEnv* pRuntimeEnv, SResultR
   return pResultRowInfo->pResult[pResultRowInfo->curPos];
 }
 
+static SResultRow* doSetResultOutBufByKey_rv(SResultRowInfo* pResultRowInfo, int64_t tid, char* pData, int16_t bytes,
+    bool masterscan, uint64_t tableGroupId, SExecTaskInfo* pTaskInfo, bool isIntervalQuery, SAggOperatorInfo* pAggInfo) {
+  bool existed = false;
+  SET_RES_WINDOW_KEY(pAggInfo->keyBuf, pData, bytes, tableGroupId);
+
+  SResultRow **p1 =
+      (SResultRow **)taosHashGet(pAggInfo->pResultRowHashTable, pAggInfo->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes));
+
+  // in case of repeat scan/reverse scan, no new time window added.
+  if (isIntervalQuery) {
+    if (!masterscan) {  // the *p1 may be NULL in case of sliding+offset exists.
+      return (p1 != NULL)? *p1:NULL;
+    }
+
+    if (p1 != NULL) {
+      if (pResultRowInfo->size == 0) {
+        existed = false;
+        assert(pResultRowInfo->curPos == -1);
+      } else if (pResultRowInfo->size == 1) {
+        existed = (pResultRowInfo->pResult[0] == (*p1));
+        pResultRowInfo->curPos = 0;
+      } else {  // check if current pResultRowInfo contains the existed pResultRow
+        SET_RES_EXT_WINDOW_KEY(pAggInfo->keyBuf, pData, bytes, tid, pResultRowInfo);
+        int64_t* index = taosHashGet(pAggInfo->pResultRowListSet, pAggInfo->keyBuf, GET_RES_EXT_WINDOW_KEY_LEN(bytes));
+        if (index != NULL) {
+          pResultRowInfo->curPos = (int32_t) *index;
+          existed = true;
+        } else {
+          existed = false;
+        }
+      }
+    }
+  } else {
+    // In case of group by column query, the required SResultRow object must be existed in the pResultRowInfo object.
+    if (p1 != NULL) {
+      return *p1;
+    }
+  }
+
+  if (!existed) {
+    prepareResultListBuffer(pResultRowInfo, pTaskInfo->env);
+
+    SResultRow *pResult = NULL;
+    if (p1 == NULL) {
+      pResult = getNewResultRow(pAggInfo->pool);
+      int32_t ret = initResultRow(pResult);
+      if (ret != TSDB_CODE_SUCCESS) {
+        longjmp(pTaskInfo->env, TSDB_CODE_QRY_OUT_OF_MEMORY);
+      }
+
+      // add a new result set for a new group
+      taosHashPut(pAggInfo->pResultRowHashTable, pAggInfo->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes), &pResult, POINTER_BYTES);
+      SResultRowCell cell = {.groupId = tableGroupId, .pRow = pResult};
+      taosArrayPush(pAggInfo->pResultRowArrayList, &cell);
+    } else {
+      pResult = *p1;
+    }
+
+    pResultRowInfo->curPos = pResultRowInfo->size;
+    pResultRowInfo->pResult[pResultRowInfo->size++] = pResult;
+
+    int64_t index = pResultRowInfo->curPos;
+    SET_RES_EXT_WINDOW_KEY(pAggInfo->keyBuf, pData, bytes, tid, pResultRowInfo);
+    taosHashPut(pAggInfo->pResultRowListSet, pAggInfo->keyBuf, GET_RES_EXT_WINDOW_KEY_LEN(bytes), &index, POINTER_BYTES);
+  }
+
+  // too many time window in query
+  if (pResultRowInfo->size > MAX_INTERVAL_TIME_WINDOW) {
+    longjmp(pTaskInfo->env, TSDB_CODE_QRY_TOO_MANY_TIMEWINDOW);
+  }
+
+  return pResultRowInfo->pResult[pResultRowInfo->curPos];
+}
+
 static void getInitialStartTimeWindow(STaskAttr* pQueryAttr, TSKEY ts, STimeWindow* w) {
   if (QUERY_IS_ASC_QUERY(pQueryAttr)) {
     getAlignQueryTimeWindow(pQueryAttr, ts, ts, pQueryAttr->window.ekey, w);
@@ -1023,43 +1123,52 @@ static void doSetInputDataBlockInfo(SOperatorInfo* pOperator, SQLFunctionCtx* pC
 }
 
 void setInputDataBlock(SOperatorInfo* pOperator, SQLFunctionCtx* pCtx, SSDataBlock* pBlock, int32_t order) {
-  if (pCtx[0].functionId == FUNCTION_ARITHM) {
+//  if (pCtx[0].functionId == FUNCTION_ARITHM) {
 //    SScalar* pSupport = (SScalarFunctionSupport*) pCtx[0].param[1].pz;
 //    if (pSupport->colList == NULL) {
 //      doSetInputDataBlock(pOperator, pCtx, pBlock, order);
 //    } else {
 //      doSetInputDataBlockInfo(pOperator, pCtx, pBlock, order);
 //    }
-  } else {
+//  } else {
     if (pBlock->pDataBlock != NULL) {
       doSetInputDataBlock(pOperator, pCtx, pBlock, order);
     } else {
       doSetInputDataBlockInfo(pOperator, pCtx, pBlock, order);
     }
-  }
+//  }
 }
 
 static void doSetInputDataBlock(SOperatorInfo* pOperator, SQLFunctionCtx* pCtx, SSDataBlock* pBlock, int32_t order) {
-#if 0
   for (int32_t i = 0; i < pOperator->numOfOutput; ++i) {
     pCtx[i].order = order;
     pCtx[i].size  = pBlock->info.rows;
-    pCtx[i].currentStage = (uint8_t)pOperator->pRuntimeEnv->scanFlag;
+    pCtx[i].currentStage = MAIN_SCAN/*(uint8_t)pOperator->pRuntimeEnv->scanFlag*/;
 
-    setBlockStatisInfo(&pCtx[i], pBlock, &pOperator->pExpr[i].base.colInfo);
+    setBlockStatisInfo(&pCtx[i], pBlock, pOperator->pExpr[i].base.pColumns);
 
     if (pCtx[i].functionId == FUNCTION_ARITHM) {
 //      setArithParams((SScalarFunctionSupport*)pCtx[i].param[1].pz, &pOperator->pExpr[i], pBlock);
     } else {
-      SColIndex* pCol = &pOperator->pExpr[i].base.pColumns->info.;
-      if (TSDB_COL_IS_NORMAL_COL(pCol->flag) || (pCtx[i].functionId == FUNCTION_BLKINFO) ||
-          (TSDB_COL_IS_TAG(pCol->flag) && pOperator->pRuntimeEnv->scanFlag == MERGE_STAGE)) {
-        SColIndex*       pColIndex = &pOperator->pExpr[i].base.colInfo;
-        SColumnInfoData* p = taosArrayGet(pBlock->pDataBlock, pColIndex->colIndex);
+      uint32_t flag = pOperator->pExpr[i].base.pColumns->flag;
+      if (TSDB_COL_IS_NORMAL_COL(flag) /*|| (pCtx[i].functionId == FUNCTION_BLKINFO) ||
+          (TSDB_COL_IS_TAG(flag) && pOperator->pRuntimeEnv->scanFlag == MERGE_STAGE)*/) {
 
+        SColumn* pCol = pOperator->pExpr[i].base.pColumns;
+        if (pCtx[i].columnIndex == -1) {
+          for(int32_t j = 0; j < pBlock->info.numOfCols; ++j) {
+            SColumnInfoData* pColData = taosArrayGet(pBlock->pDataBlock, j);
+            if (pColData->info.colId == pCol->info.colId) {
+              pCtx[i].columnIndex = j;
+              break;
+            }
+          }
+        }
+
+        SColumnInfoData* p = taosArrayGet(pBlock->pDataBlock, pCtx[i].columnIndex);
         // in case of the block distribution query, the inputBytes is not a constant value.
         pCtx[i].pInput = p->pData;
-        assert(p->info.colId == pColIndex->info.colId && pCtx[i].inputType == p->info.type);
+        assert(p->info.colId == pCol->info.colId);
 
         if (pCtx[i].functionId < 0) {
           SColumnInfoData* tsInfo = taosArrayGet(pBlock->pDataBlock, 0);
@@ -1070,37 +1179,33 @@ static void doSetInputDataBlock(SOperatorInfo* pOperator, SQLFunctionCtx* pCtx,
 
 //        uint32_t status = aAggs[pCtx[i].functionId].status;
 //        if ((status & (FUNCSTATE_SELECTIVITY | FUNCSTATE_NEED_TS)) != 0) {
-//          SColumnInfoData* tsInfo = taosArrayGet(pBlock->pDataBlock, 0);
-//          // In case of the top/bottom query again the nest query result, which has no timestamp column
-//          // don't set the ptsList attribute.
-//          if (tsInfo->info.type == TSDB_DATA_TYPE_TIMESTAMP) {
-//            pCtx[i].ptsList = (int64_t*) tsInfo->pData;
-//          } else {
-//            pCtx[i].ptsList = NULL;
+          SColumnInfoData* tsInfo = taosArrayGet(pBlock->pDataBlock, 0);
+          // In case of the top/bottom query again the nest query result, which has no timestamp column
+          // don't set the ptsList attribute.
+          if (tsInfo->info.type == TSDB_DATA_TYPE_TIMESTAMP) {
+            pCtx[i].ptsList = (int64_t*) tsInfo->pData;
+          } else {
+            pCtx[i].ptsList = NULL;
+          }
 //        }
+//      } else if (TSDB_COL_IS_UD_COL(pCol->flag) && (pOperator->pRuntimeEnv->scanFlag == MERGE_STAGE)) {
+//        SColIndex*       pColIndex = &pOperator->pExpr[i].base.colInfo;
+//        SColumnInfoData* p = taosArrayGet(pBlock->pDataBlock, pColIndex->colIndex);
+//
+//        pCtx[i].pInput = p->pData;
+//        assert(p->info.colId == pColIndex->info.colId && pCtx[i].inputType == p->info.type);
+//        for(int32_t j = 0; j < pBlock->info.rows; ++j) {
+//          char* dst = p->pData + j * p->info.bytes;
+//          taosVariantDump(&pOperator->pExpr[i].base.param[1], dst, p->info.type, true);
 //        }
-      } else if (TSDB_COL_IS_UD_COL(pCol->flag) && (pOperator->pRuntimeEnv->scanFlag == MERGE_STAGE)) {
-        SColIndex*       pColIndex = &pOperator->pExpr[i].base.colInfo;
-        SColumnInfoData* p = taosArrayGet(pBlock->pDataBlock, pColIndex->colIndex);
-
-        pCtx[i].pInput = p->pData;
-        assert(p->info.colId == pColIndex->info.colId && pCtx[i].inputType == p->info.type);
-        for(int32_t j = 0; j < pBlock->info.rows; ++j) {
-          char* dst = p->pData + j * p->info.bytes;
-          taosVariantDump(&pOperator->pExpr[i].base.param[1], dst, p->info.type, true);
-        }
       }
     }
   }
-#endif
-
 }
 
 static void doAggregateImpl(SOperatorInfo* pOperator, TSKEY startTs, SQLFunctionCtx* pCtx, SSDataBlock* pSDataBlock) {
-  STaskRuntimeEnv* pRuntimeEnv = pOperator->pRuntimeEnv;
-
   for (int32_t k = 0; k < pOperator->numOfOutput; ++k) {
-    if (functionNeedToExecute(pRuntimeEnv, &pCtx[k])) {
+    if (functionNeedToExecute(NULL, &pCtx[k])) {
       pCtx[k].startTs = startTs;// this can be set during create the struct
       pCtx[k].fpSet->addInput(&pCtx[k]);
     }
@@ -1719,7 +1824,6 @@ static int32_t getGroupbyColumnIndex(SGroupbyExpr *pGroupbyExpr, SSDataBlock* pD
 
 static bool functionNeedToExecute(STaskRuntimeEnv *pRuntimeEnv, SQLFunctionCtx *pCtx) {
   struct SResultRowEntryInfo *pResInfo = GET_RES_INFO(pCtx);
-  STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr;
 
   // in case of timestamp column, always generated results.
   int32_t functionId = pCtx->functionId;
@@ -1732,28 +1836,28 @@ static bool functionNeedToExecute(STaskRuntimeEnv *pRuntimeEnv, SQLFunctionCtx *
   }
 
   if (functionId == FUNCTION_FIRST_DST || functionId == FUNCTION_FIRST) {
-    return QUERY_IS_ASC_QUERY(pQueryAttr);
+//    return QUERY_IS_ASC_QUERY(pQueryAttr);
   }
 
   // denote the order type
   if ((functionId == FUNCTION_LAST_DST || functionId == FUNCTION_LAST)) {
-    return pCtx->param[0].i == pQueryAttr->order.order;
+//    return pCtx->param[0].i == pQueryAttr->order.order;
   }
 
   // in the reverse table scan, only the following functions need to be executed
-  if (IS_REVERSE_SCAN(pRuntimeEnv) ||
-      (pRuntimeEnv->scanFlag == REPEAT_SCAN && functionId != FUNCTION_STDDEV && functionId != FUNCTION_PERCT)) {
-    return false;
-  }
+//  if (IS_REVERSE_SCAN(pRuntimeEnv) ||
+//      (pRuntimeEnv->scanFlag == REPEAT_SCAN && functionId != FUNCTION_STDDEV && functionId != FUNCTION_PERCT)) {
+//    return false;
+//  }
 
   return true;
 }
 
-void setBlockStatisInfo(SQLFunctionCtx *pCtx, SSDataBlock* pSDataBlock, SColIndex* pColIndex) {
+void setBlockStatisInfo(SQLFunctionCtx *pCtx, SSDataBlock* pSDataBlock, SColumn* pColumn) {
   SColumnDataAgg *pAgg = NULL;
 
-  if (pSDataBlock->pBlockAgg != NULL && TSDB_COL_IS_NORMAL_COL(pColIndex->flag)) {
-    pAgg = &pSDataBlock->pBlockAgg[pColIndex->colIndex];
+  if (pSDataBlock->pBlockAgg != NULL && TSDB_COL_IS_NORMAL_COL(pColumn->flag)) {
+    pAgg = &pSDataBlock->pBlockAgg[pCtx->columnIndex];
 
     pCtx->agg = *pAgg;
     pCtx->isAggSet  = true;
@@ -1762,10 +1866,10 @@ void setBlockStatisInfo(SQLFunctionCtx *pCtx, SSDataBlock* pSDataBlock, SColInde
     pCtx->isAggSet = false;
   }
 
-  pCtx->hasNull = hasNull(pColIndex, pAgg);
+  pCtx->hasNull = hasNull(pColumn, pAgg);
 
   // set the statistics data for primary time stamp column
-  if (pCtx->functionId == FUNCTION_SPREAD && pColIndex->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
+  if (pCtx->functionId == FUNCTION_SPREAD && pColumn->info.colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
     pCtx->isAggSet  = true;
     pCtx->agg.min = pSDataBlock->info.window.skey;
     pCtx->agg.max = pSDataBlock->info.window.ekey;
@@ -1918,7 +2022,9 @@ static SQLFunctionCtx* createSqlFunctionCtx(STaskRuntimeEnv* pRuntimeEnv, SExprI
   return pFuncCtx;
 }
 
-static SQLFunctionCtx* createSqlFunctionCtx_rv(SExprInfo* pExpr, int32_t numOfOutput, int32_t** rowCellInfoOffset) {
+static SQLFunctionCtx* createSqlFunctionCtx_rv(SArray* pExprInfo, int32_t** rowCellInfoOffset) {
+  size_t numOfOutput = taosArrayGetSize(pExprInfo);
+
   SQLFunctionCtx * pFuncCtx = (SQLFunctionCtx *)calloc(numOfOutput, sizeof(SQLFunctionCtx));
   if (pFuncCtx == NULL) {
     return NULL;
@@ -1931,8 +2037,11 @@ static SQLFunctionCtx* createSqlFunctionCtx_rv(SExprInfo* pExpr, int32_t numOfOu
   }
 
   for (int32_t i = 0; i < numOfOutput; ++i) {
-    SSqlExpr *pSqlExpr = &pExpr[i].base;
+    SExprInfo* pExpr = taosArrayGetP(pExprInfo, i);
+
+    SSqlExpr *pSqlExpr = &pExpr->base;
     SQLFunctionCtx* pCtx = &pFuncCtx[i];
+
 #if 0
     SColIndex *pIndex = &pSqlExpr->colInfo;
 
@@ -1943,15 +2052,16 @@ static SQLFunctionCtx* createSqlFunctionCtx_rv(SExprInfo* pExpr, int32_t numOfOu
       pCtx->requireNull = false;
     }
 #endif
-//    pCtx->inputBytes = pSqlExpr->colBytes;
+//    pCtx->inputBytes = pSqlExpr->;
 //    pCtx->inputType  = pSqlExpr->colType;
 
     pCtx->ptsOutputBuf = NULL;
-
+    pCtx->fpSet = fpSet;
+    pCtx->columnIndex = -1;
     pCtx->resDataInfo.bytes  = pSqlExpr->resSchema.bytes;
     pCtx->resDataInfo.type   = pSqlExpr->resSchema.type;
 
-//    pCtx->order        = pQueryAttr->order.order;
+    pCtx->order        = TSDB_ORDER_ASC;
 //    pCtx->functionId   = pSqlExpr->functionId;
 //    pCtx->stableQuery  = pQueryAttr->stableQuery;
     pCtx->resDataInfo.intermediateBytes = pSqlExpr->interBytes;
@@ -2007,12 +2117,12 @@ static SQLFunctionCtx* createSqlFunctionCtx_rv(SExprInfo* pExpr, int32_t numOfOu
     }
   }
 
-//  for(int32_t i = 1; i < numOfOutput; ++i) {
-//    (*rowCellInfoOffset)[i] = (int32_t)((*rowCellInfoOffset)[i - 1] + sizeof(SResultRowEntryInfo) + pExpr[i - 1].base.interBytes);
-//  }
+  for(int32_t i = 1; i < numOfOutput; ++i) {
+    SExprInfo* pExpr = taosArrayGetP(pExprInfo, i - 1);
+    (*rowCellInfoOffset)[i] = (int32_t)((*rowCellInfoOffset)[i - 1] + sizeof(SResultRowEntryInfo) + pExpr->base.interBytes);
+  }
 
   setCtxTagColumnInfo(pFuncCtx, numOfOutput);
-
   return pFuncCtx;
 }
 
@@ -2044,7 +2154,7 @@ static int32_t setupQueryRuntimeEnv(STaskRuntimeEnv *pRuntimeEnv, int32_t numOfT
   pRuntimeEnv->pResultRowHashTable = taosHashInit(numOfTables, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
   pRuntimeEnv->pResultRowListSet = taosHashInit(numOfTables * 10, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
   pRuntimeEnv->keyBuf  = malloc(pQueryAttr->maxTableColumnWidth + sizeof(int64_t) + POINTER_BYTES);
-  pRuntimeEnv->pool    = initResultRowPool(getResultRowSize(pRuntimeEnv));
+//  pRuntimeEnv->pool    = initResultRowPool(getResultRowSize(pRuntimeEnv));
   pRuntimeEnv->pResultRowArrayList = taosArrayInit(numOfTables, sizeof(SResultRowCell));
 
   pRuntimeEnv->prevRow = malloc(POINTER_BYTES * pQueryAttr->numOfCols + pQueryAttr->srcRowSize);
@@ -3457,6 +3567,43 @@ void setDefaultOutputBuf(STaskRuntimeEnv *pRuntimeEnv, SOptrBasicInfo *pInfo, in
   initCtxOutputBuffer(pCtx, pDataBlock->info.numOfCols);
 }
 
+void setDefaultOutputBuf_rv(SAggOperatorInfo* pAggInfo, int64_t uid, int32_t stage, SExecTaskInfo* pTaskInfo) {
+  SOptrBasicInfo *pInfo = &pAggInfo->binfo;
+
+  SQLFunctionCtx* pCtx           = pInfo->pCtx;
+  SSDataBlock* pDataBlock        = pInfo->pRes;
+  int32_t* rowCellInfoOffset     = pInfo->rowCellInfoOffset;
+  SResultRowInfo* pResultRowInfo = &pInfo->resultRowInfo;
+
+  int64_t tid = 0;
+  pInfo->keyBuf = realloc(pInfo->keyBuf, sizeof(tid) + sizeof(int64_t) + POINTER_BYTES);
+  SResultRow* pRow = doSetResultOutBufByKey_rv(pResultRowInfo, tid, (char *)&tid, sizeof(tid), true, uid, pTaskInfo, false, pAggInfo);
+
+  for (int32_t i = 0; i < pDataBlock->info.numOfCols; ++i) {
+    SColumnInfoData* pData = taosArrayGet(pDataBlock->pDataBlock, i);
+
+    /*
+     * set the output buffer information and intermediate buffer
+     * not all queries require the interResultBuf, such as COUNT/TAGPRJ/PRJ/TAG etc.
+     */
+    struct SResultRowEntryInfo* pEntry = getResultCell(pRow, i, rowCellInfoOffset);
+    cleanupResultRowEntry(pEntry);
+
+    pCtx[i].resultInfo   = pEntry;
+    pCtx[i].pOutput      = pData->pData;
+    pCtx[i].currentStage = stage;
+    assert(pCtx[i].pOutput != NULL);
+
+    // set the timestamp output buffer for top/bottom/diff query
+    int32_t fid = pCtx[i].functionId;
+    if (fid == FUNCTION_TOP || fid == FUNCTION_BOTTOM || fid == FUNCTION_DIFF || fid == FUNCTION_DERIVATIVE) {
+      if (i > 0) pCtx[i].ptsOutputBuf = pCtx[i-1].pOutput;
+    }
+  }
+
+  initCtxOutputBuffer(pCtx, pDataBlock->info.numOfCols);
+}
+
 void updateOutputBuf(SOptrBasicInfo* pBInfo, int32_t *bufCapacity, int32_t numOfInputRows) {
   SSDataBlock* pDataBlock = pBInfo->pRes;
 
@@ -3579,49 +3726,49 @@ static void setupEnvForReverseScan(STableScanInfo *pTableScanInfo, SQLFunctionCt
 
 void finalizeQueryResult(SOperatorInfo* pOperator, SQLFunctionCtx* pCtx, SResultRowInfo* pResultRowInfo, int32_t* rowCellInfoOffset) {
   STaskRuntimeEnv *pRuntimeEnv = pOperator->pRuntimeEnv;
-  STaskAttr *pQueryAttr = pRuntimeEnv->pQueryAttr;
+//  STaskAttr *pQueryAttr = pRuntimeEnv->pQueryAttr;
 
   int32_t numOfOutput = pOperator->numOfOutput;
-  if (pQueryAttr->groupbyColumn || QUERY_IS_INTERVAL_QUERY(pQueryAttr) || pQueryAttr->sw.gap > 0 || pQueryAttr->stateWindow) {
-    // for each group result, call the finalize function for each column
-    if (pQueryAttr->groupbyColumn) {
-      closeAllResultRows(pResultRowInfo);
-    }
-
-    for (int32_t i = 0; i < pResultRowInfo->size; ++i) {
-      SResultRow *buf = pResultRowInfo->pResult[i];
-      if (!isResultRowClosed(pResultRowInfo, i)) {
-        continue;
-      }
-
-      setResultOutputBuf(pRuntimeEnv, buf, pCtx, numOfOutput, rowCellInfoOffset);
-
-      for (int32_t j = 0; j < numOfOutput; ++j) {
-//        pCtx[j].startTs  = buf->win.skey;
-//        if (pCtx[j].functionId < 0) {
-//          doInvokeUdf(pRuntimeEnv->pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_FINALIZE);
-//        } else {
-//          aAggs[pCtx[j].functionId].xFinalize(&pCtx[j]);
+//  if (pQueryAttr->groupbyColumn || QUERY_IS_INTERVAL_QUERY(pQueryAttr) || pQueryAttr->sw.gap > 0 || pQueryAttr->stateWindow) {
+//    // for each group result, call the finalize function for each column
+//    if (pQueryAttr->groupbyColumn) {
+//      closeAllResultRows(pResultRowInfo);
 //    }
-      }
-
-
-      /*
-       * set the number of output results for group by normal columns, the number of output rows usually is 1 except
-       * the top and bottom query
-       */
-      buf->numOfRows = (uint16_t)getNumOfResult(pCtx, numOfOutput);
-    }
-
-  } else {
+//
+//    for (int32_t i = 0; i < pResultRowInfo->size; ++i) {
+//      SResultRow *buf = pResultRowInfo->pResult[i];
+//      if (!isResultRowClosed(pResultRowInfo, i)) {
+//        continue;
+//      }
+//
+//      setResultOutputBuf(pRuntimeEnv, buf, pCtx, numOfOutput, rowCellInfoOffset);
+//
+//      for (int32_t j = 0; j < numOfOutput; ++j) {
+////        pCtx[j].startTs  = buf->win.skey;
+////        if (pCtx[j].functionId < 0) {
+////          doInvokeUdf(pRuntimeEnv->pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_FINALIZE);
+////        } else {
+////          aAggs[pCtx[j].functionId].xFinalize(&pCtx[j]);
+////        }
+//      }
+//
+//
+//      /*
+//       * set the number of output results for group by normal columns, the number of output rows usually is 1 except
+//       * the top and bottom query
+//       */
+//      buf->numOfRows = (uint16_t)getNumOfResult(pCtx, numOfOutput);
+//    }
+//
+//  } else {
     for (int32_t j = 0; j < numOfOutput; ++j) {
 //      if (pCtx[j].functionId < 0) {
 //        doInvokeUdf(pRuntimeEnv->pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_FINALIZE);
 //      } else {
-//        aAggs[pCtx[j].functionId].xFinalize(&pCtx[j]);
+        pCtx[j].fpSet->finalize(&pCtx[j]);
 //      }
     }
-  }
+//  }
 }
 
 static bool hasMainOutput(STaskAttr *pQueryAttr) {
@@ -4558,6 +4705,7 @@ void appendDownstream(SOperatorInfo* p, SOperatorInfo* pUpstream) {
 
 static void doDestroyTableQueryInfo(STableGroupInfo* pTableqinfoGroupInfo);
 
+void createResultBlock(const SArray* pExprInfo, SExchangeInfo* pInfo, const SOperatorInfo* pOperator, size_t size);
 static int32_t setupQueryHandle(void* tsdb, STaskRuntimeEnv* pRuntimeEnv, int64_t qId, bool isSTableQuery) {
   STaskAttr *pQueryAttr = pRuntimeEnv->pQueryAttr;
 #if 0
@@ -4914,57 +5062,127 @@ static SSDataBlock* doBlockInfoScan(void* param, bool* newgroup) {
 }
 
 int32_t loadRemoteDataCallback(void* param, const SDataBuf* pMsg, int32_t code) {
+  SExchangeInfo* pEx = (SExchangeInfo*) param;
+  pEx->pRsp = pMsg->pData;
 
+  pEx->pRsp->numOfRows = htonl(pEx->pRsp->numOfRows);
+  pEx->pRsp->useconds = htobe64(pEx->pRsp->useconds);
+  pEx->pRsp->compLen = htonl(pEx->pRsp->compLen);
+
+  tsem_post(&pEx->ready);
+}
+
+static void destroySendMsgInfo(SMsgSendInfo* pMsgBody) {
+  assert(pMsgBody != NULL);
+  tfree(pMsgBody->msgInfo.pData);
+  tfree(pMsgBody);
+}
+
+void processRspMsg(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) {
+  SMsgSendInfo *pSendInfo = (SMsgSendInfo *) pMsg->ahandle;
+  assert(pMsg->ahandle != NULL);
+
+  SDataBuf buf = {.len = pMsg->contLen, .pData = NULL};
+
+  if (pMsg->contLen > 0) {
+    buf.pData = calloc(1, pMsg->contLen);
+    if (buf.pData == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      pMsg->code = TSDB_CODE_OUT_OF_MEMORY;
+    } else {
+      memcpy(buf.pData, pMsg->pCont, pMsg->contLen);
+    }
+  }
+
+  pSendInfo->fp(pSendInfo->param, &buf, pMsg->code);
+  rpcFreeCont(pMsg->pCont);
+  destroySendMsgInfo(pSendInfo);
 }
 
 static SSDataBlock* doLoadRemoteData(void* param, bool* newgroup) {
-  SOperatorInfo* pOperator = (SOperatorInfo*) param;
+  SOperatorInfo *pOperator = (SOperatorInfo*) param;
 
   SExchangeInfo *pExchangeInfo = pOperator->info;
   SExecTaskInfo *pTaskInfo = pOperator->pTaskInfo;
 
   *newgroup = false;
+  if (pExchangeInfo->pRsp != NULL && pExchangeInfo->pRsp->completed == 1) {
+    return NULL;
+  }
 
   SResFetchReq *pMsg = calloc(1, sizeof(SResFetchReq));
   if (NULL == pMsg) {  // todo handle malloc error
-
+    pTaskInfo->code = TSDB_CODE_QRY_OUT_OF_MEMORY;
+    goto _error;
   }
 
-  SEpSet epSet;
+  SDownstreamSource* pSource = taosArrayGet(pExchangeInfo->pSources, 0);
+  SEpSet epSet = {0};
 
-  int64_t sId = -1, queryId = 0, taskId = 1, vgId = 1;
-  pMsg->header.vgId = htonl(vgId);
+  epSet.numOfEps = pSource->addr.numOfEps;
+  epSet.port[0] = pSource->addr.epAddr[0].port;
+  tstrncpy(epSet.fqdn[0], pSource->addr.epAddr[0].fqdn, tListLen(epSet.fqdn[0]));
 
-  pMsg->sId     = htobe64(sId);
-  pMsg->taskId  = htobe64(taskId);
-  pMsg->queryId = htobe64(queryId);
+  pMsg->header.vgId = htonl(pSource->addr.nodeId);
+  pMsg->sId         = htobe64(pSource->schedId);
+  pMsg->taskId      = htobe64(pSource->taskId);
+  pMsg->queryId     = htobe64(pTaskInfo->id.queryId);
 
   // send the fetch remote task result reques
   SMsgSendInfo* pMsgSendInfo = calloc(1, sizeof(SMsgSendInfo));
   if (NULL == pMsgSendInfo) {
-    qError("QID:%"PRIx64 ",TID:%"PRIx64 " calloc %d failed", queryId, taskId, (int32_t)sizeof(SMsgSendInfo));
+    qError("QID:%"PRIx64" calloc %d failed", GET_TASKID(pTaskInfo), (int32_t)sizeof(SMsgSendInfo));
+    pTaskInfo->code = TSDB_CODE_QRY_OUT_OF_MEMORY;
+    goto _error;
   }
 
-  pMsgSendInfo->param = NULL;
+  pMsgSendInfo->param = pExchangeInfo;
   pMsgSendInfo->msgInfo.pData = pMsg;
   pMsgSendInfo->msgInfo.len = sizeof(SResFetchReq);
   pMsgSendInfo->msgType = TDMT_VND_FETCH;
   pMsgSendInfo->fp = loadRemoteDataCallback;
 
   int64_t  transporterId = 0;
-  void* pTransporter = NULL;
-  int32_t code = asyncSendMsgToServer(pTransporter, &epSet, &transporterId, pMsgSendInfo);
+  int32_t code = asyncSendMsgToServer(pExchangeInfo->pTransporter, &epSet, &transporterId, pMsgSendInfo);
+  tsem_wait(&pExchangeInfo->ready);
+
+  if (pExchangeInfo->pRsp->numOfRows == 0) {
+    return NULL;
+  }
 
-  printf("abc\n");
-  getchar();
+  SSDataBlock* pRes = pExchangeInfo->pResult;
+  char* pData = pExchangeInfo->pRsp->data;
 
-  // add it into the sink node
+  for(int32_t i = 0; i < pOperator->numOfOutput; ++i) {
+    SColumnInfoData* pColInfoData = taosArrayGet(pRes->pDataBlock, i);
+    char* tmp = realloc(pColInfoData->pData, pColInfoData->info.bytes * pExchangeInfo->pRsp->numOfRows);
+    if (tmp == NULL) {
+      goto _error;
+    }
 
+    size_t len = pExchangeInfo->pRsp->numOfRows * pColInfoData->info.bytes;
+    memcpy(tmp, pData, len);
+
+    pColInfoData->pData = tmp;
+    pData += len;
+  }
+
+  pRes->info.numOfCols = pOperator->numOfOutput;
+  pRes->info.rows = pExchangeInfo->pRsp->numOfRows;
+
+  return pExchangeInfo->pResult;
+
+  _error:
+  tfree(pMsg);
+  tfree(pMsgSendInfo);
+
+  terrno = pTaskInfo->code;
+  return NULL;
 }
 
-SOperatorInfo* createExchangeOperatorInfo(const SVgroupInfo* pVgroups, int32_t numOfSources, int32_t numOfOutput, SExecTaskInfo* pTaskInfo) {
-  assert(numOfSources > 0);
+static SSDataBlock* createResultDataBlock(const SArray* pExprInfo);
 
+SOperatorInfo* createExchangeOperatorInfo(const SArray* pSources, const SArray* pExprInfo, SExecTaskInfo* pTaskInfo) {
   SExchangeInfo* pInfo    = calloc(1, sizeof(SExchangeInfo));
   SOperatorInfo* pOperator = calloc(1, sizeof(SOperatorInfo));
 
@@ -4975,21 +5193,71 @@ SOperatorInfo* createExchangeOperatorInfo(const SVgroupInfo* pVgroups, int32_t n
     return NULL;
   }
 
-  pInfo->numOfSources = numOfSources;
+  pInfo->pSources = taosArrayDup(pSources);
+  assert(taosArrayGetSize(pInfo->pSources) > 0);
+
+  size_t size = taosArrayGetSize(pExprInfo);
+  pInfo->pResult = createResultDataBlock(pExprInfo);
 
   pOperator->name         = "ExchangeOperator";
   pOperator->operatorType = OP_Exchange;
   pOperator->blockingOptr = false;
   pOperator->status       = OP_IN_EXECUTING;
   pOperator->info         = pInfo;
-  pOperator->numOfOutput  = numOfOutput;
+  pOperator->numOfOutput  = size;
   pOperator->pRuntimeEnv  = NULL;
   pOperator->exec         = doLoadRemoteData;
   pOperator->pTaskInfo    = pTaskInfo;
 
+  { // todo refactor
+    SRpcInit rpcInit;
+    memset(&rpcInit, 0, sizeof(rpcInit));
+    rpcInit.localPort = 0;
+    rpcInit.label = "TSC";
+    rpcInit.numOfThreads = 1;
+    rpcInit.cfp = processRspMsg;
+    rpcInit.sessions = tsMaxConnections;
+    rpcInit.connType = TAOS_CONN_CLIENT;
+    rpcInit.user = (char *)"root";
+    rpcInit.idleTime = tsShellActivityTimer * 1000;
+    rpcInit.ckey = "key";
+//  rpcInit.spi = 1;
+    rpcInit.secret = (char *)"dcc5bed04851fec854c035b2e40263b6";
+
+    pInfo->pTransporter = rpcOpen(&rpcInit);
+    if (pInfo->pTransporter == NULL) {
+      return NULL; // todo
+    }
+  }
+
   return pOperator;
 }
 
+SSDataBlock* createResultDataBlock(const SArray* pExprInfo) {
+  SSDataBlock* pResBlock = calloc(1, sizeof(SSDataBlock));
+  if (pResBlock == NULL) {
+    return NULL;
+  }
+
+  size_t numOfCols = taosArrayGetSize(pExprInfo);
+  pResBlock->pDataBlock = taosArrayInit(numOfCols, sizeof(SColumnInfoData));
+
+  SArray* pResult = pResBlock->pDataBlock;
+  for(int32_t i = 0; i < numOfCols; ++i) {
+    SColumnInfoData colInfoData = {0};
+    SExprInfo* p = taosArrayGetP(pExprInfo, i);
+
+    SSchema* pSchema = &p->base.resSchema;
+    colInfoData.info.type  = pSchema->type;
+    colInfoData.info.colId = pSchema->colId;
+    colInfoData.info.bytes = pSchema->bytes;
+
+    taosArrayPush(pResult, &colInfoData);
+  }
+
+  return pResBlock;
+}
+
 SOperatorInfo* createTableScanOperatorInfo(void* pTsdbReadHandle, int32_t order, int32_t numOfOutput, int32_t repeatTime, SExecTaskInfo* pTaskInfo) {
   assert(repeatTime > 0 && numOfOutput > 0);
 
@@ -5016,7 +5284,6 @@ SOperatorInfo* createTableScanOperatorInfo(void* pTsdbReadHandle, int32_t order,
   pOperator->status       = OP_IN_EXECUTING;
   pOperator->info         = pInfo;
   pOperator->numOfOutput  = numOfOutput;
-  pOperator->pRuntimeEnv  = NULL;
   pOperator->exec         = doTableScan;
   pOperator->pTaskInfo    = pTaskInfo;
 
@@ -5049,7 +5316,6 @@ SOperatorInfo* createDataBlocksOptScanInfo(void* pTsdbReadHandle, int32_t order,
   pOperator->status        = OP_IN_EXECUTING;
   pOperator->info          = pInfo;
   pOperator->numOfOutput   = numOfOutput;
-  pOperator->pRuntimeEnv   = NULL;
   pOperator->exec          = doTableScan;
   pOperator->pTaskInfo     = pTaskInfo;
 
@@ -5105,6 +5371,11 @@ SOperatorInfo* createTableBlockInfoScanOperator(void* pTsdbReadHandle, STaskRunt
   return pOperator;
 }
 
+SOperatorInfo* createSubmitBlockScanOperatorInfo(void *pSubmitBlockReadHandle, int32_t numOfOutput, SExecTaskInfo* pTaskInfo) {
+
+}
+
+
 void setTableScanFilterOperatorInfo(STableScanInfo* pTableScanInfo, SOperatorInfo* pDownstream) {
   assert(pTableScanInfo != NULL && pDownstream != NULL);
 
@@ -5483,11 +5754,7 @@ static SSDataBlock* doAggregate(void* param, bool* newgroup) {
   SAggOperatorInfo* pAggInfo = pOperator->info;
   SOptrBasicInfo* pInfo = &pAggInfo->binfo;
 
-  STaskRuntimeEnv* pRuntimeEnv = pOperator->pRuntimeEnv;
-
-  STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr;
-  int32_t order = pQueryAttr->order.order;
-
+  int32_t order = TSDB_ORDER_ASC;
   SOperatorInfo* downstream = pOperator->pDownstream[0];
 
   while(1) {
@@ -5499,18 +5766,13 @@ static SSDataBlock* doAggregate(void* param, bool* newgroup) {
       break;
     }
 
-    if (pRuntimeEnv->current != NULL) {
-      setTagValue(pOperator, pRuntimeEnv->current->pTable, pInfo->pCtx, pOperator->numOfOutput);
-    }
-
-//    if (downstream->operatorType == OP_DataBlocksOptScan) {
-//      STableScanInfo* pScanInfo = downstream->info;
-//      order = getTableScanOrder(pScanInfo);
+//    if (pAggInfo->current != NULL) {
+//      setTagValue(pOperator, pAggInfo->current->pTable, pInfo->pCtx, pOperator->numOfOutput);
 //    }
 
     // the pDataBlock are always the same one, no need to call this again
     setInputDataBlock(pOperator, pInfo->pCtx, pBlock, order);
-    doAggregateImpl(pOperator, pQueryAttr->window.skey, pInfo->pCtx, pBlock);
+    doAggregateImpl(pOperator, 0, pInfo->pCtx, pBlock);
   }
 
   doSetOperatorCompleted(pOperator);
@@ -6397,19 +6659,31 @@ static void destroyOperatorInfo(SOperatorInfo* pOperator) {
   tfree(pOperator);
 }
 
-SOperatorInfo* createAggregateOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExpr, int32_t numOfOutput) {
+SOperatorInfo* createAggregateOperatorInfo(SOperatorInfo* downstream, SArray* pExprInfo, SExecTaskInfo* pTaskInfo) {
   SAggOperatorInfo* pInfo = calloc(1, sizeof(SAggOperatorInfo));
 
-//  STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr;
   int32_t numOfRows = 1;//(int32_t)(getRowNumForMultioutput(pQueryAttr, pQueryAttr->topBotQuery, pQueryAttr->stableQuery));
 
-  pInfo->binfo.pRes = createOutputBuf(pExpr, numOfOutput, numOfRows);
-  pInfo->binfo.pCtx = createSqlFunctionCtx_rv(pExpr, numOfOutput, &pInfo->binfo.rowCellInfoOffset);
+  size_t numOfOutput = taosArrayGetSize(pExprInfo);
+  pInfo->binfo.pRes = createOutputBuf_rv(pExprInfo, numOfRows);
+  pInfo->binfo.pCtx = createSqlFunctionCtx_rv(pExprInfo, &pInfo->binfo.rowCellInfoOffset);
+
+  pInfo->pResultRowHashTable = taosHashInit(10, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
+  pInfo->pResultRowListSet = taosHashInit(100, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
+  pInfo->keyBuf  = malloc(1024 + sizeof(int64_t) + POINTER_BYTES); // TODO:
+  pInfo->pool    = initResultRowPool(getResultRowSize(pExprInfo));
+  pInfo->pResultRowArrayList = taosArrayInit(10, sizeof(SResultRowCell));
 
   initResultRowInfo(&pInfo->binfo.resultRowInfo, 8, TSDB_DATA_TYPE_INT);
 
   pInfo->seed = rand();
-//  setDefaultOutputBuf(pRuntimeEnv, &pInfo->binfo, pInfo->seed, MAIN_SCAN);
+  setDefaultOutputBuf_rv(pInfo, pInfo->seed, MAIN_SCAN, pTaskInfo);
+
+  SExprInfo* p = calloc(numOfOutput, sizeof(SExprInfo));
+  for(int32_t i = 0; i < taosArrayGetSize(pExprInfo); ++i) {
+    SExprInfo* pExpr = taosArrayGetP(pExprInfo, i);
+    assignExprInfo(&p[i], pExpr);
+  }
 
   SOperatorInfo* pOperator = calloc(1, sizeof(SOperatorInfo));
   pOperator->name         = "TableAggregate";
@@ -6417,10 +6691,11 @@ SOperatorInfo* createAggregateOperatorInfo(SOperatorInfo* downstream, SExprInfo*
   pOperator->blockingOptr = true;
   pOperator->status       = OP_IN_EXECUTING;
   pOperator->info         = pInfo;
-  pOperator->pExpr        = pExpr;
+  pOperator->pExpr        = p;
   pOperator->numOfOutput  = numOfOutput;
   pOperator->pRuntimeEnv  = NULL;
 
+  pOperator->pTaskInfo    = pTaskInfo;
   pOperator->exec         = doAggregate;
   pOperator->cleanup      = destroyAggOperatorInfo;
   appendDownstream(pOperator, downstream);
@@ -7353,36 +7628,53 @@ static SExecTaskInfo* createExecTaskInfo(uint64_t queryId) {
   return pTaskInfo;
 }
 
-SOperatorInfo* doCreateOperatorTreeNode(SPhyNode* pPhyNode, SExecTaskInfo* pTaskInfo, void* param) {
+static tsdbReadHandleT doCreateDataReadHandle(STableScanPhyNode* pTableScanNode, void* readerHandle, uint64_t queryId);
+
+SOperatorInfo* doCreateOperatorTreeNode(SPhyNode* pPhyNode, SExecTaskInfo* pTaskInfo, void* readerHandle, uint64_t queryId) {
   if (pPhyNode->pChildren == NULL || taosArrayGetSize(pPhyNode->pChildren) == 0) {
     if (pPhyNode->info.type == OP_TableScan) {
+
       SScanPhyNode*  pScanPhyNode = (SScanPhyNode*)pPhyNode;
       size_t         numOfCols = taosArrayGetSize(pPhyNode->pTargets);
-      return createTableScanOperatorInfo(param, pScanPhyNode->order, numOfCols, pScanPhyNode->count, pTaskInfo);
+
+      tsdbReadHandleT tReaderHandle = doCreateDataReadHandle((STableScanPhyNode*) pPhyNode, readerHandle, (uint64_t) queryId);
+
+      return createTableScanOperatorInfo(tReaderHandle, pScanPhyNode->order, numOfCols, pScanPhyNode->count, pTaskInfo);
     } else if (pPhyNode->info.type == OP_DataBlocksOptScan) {
       SScanPhyNode*  pScanPhyNode = (SScanPhyNode*)pPhyNode;
       size_t         numOfCols = taosArrayGetSize(pPhyNode->pTargets);
-      return createDataBlocksOptScanInfo(param, pScanPhyNode->order, numOfCols, pScanPhyNode->count, pScanPhyNode->reverse, pTaskInfo);
-    } else {
-      assert(0);
+
+      tsdbReadHandleT tReaderHandle = doCreateDataReadHandle((STableScanPhyNode*) pPhyNode, readerHandle, (uint64_t) queryId);
+
+      return createDataBlocksOptScanInfo(tReaderHandle, pScanPhyNode->order, numOfCols, pScanPhyNode->count, pScanPhyNode->reverse, pTaskInfo);
+    } else if (pPhyNode->info.type == OP_Exchange) {
+      SExchangePhyNode* pEx = (SExchangePhyNode*) pPhyNode;
+      return createExchangeOperatorInfo(pEx->pSrcEndPoints, pEx->node.pTargets, pTaskInfo);
+    }
+  }
+
+  if (pPhyNode->info.type == OP_Aggregate) {
+    size_t size = taosArrayGetSize(pPhyNode->pChildren);
+    assert(size == 1);
+
+    for (int32_t i = 0; i < size; ++i) {
+      SPhyNode*      pChildNode = taosArrayGetP(pPhyNode->pChildren, i);
+      SOperatorInfo* op = doCreateOperatorTreeNode(pChildNode, pTaskInfo, readerHandle, queryId);
+      return createAggregateOperatorInfo(op, pPhyNode->pTargets, pTaskInfo);
     }
   }
 }
 
-int32_t doCreateExecTaskInfo(SSubplan* pPlan, SExecTaskInfo** pTaskInfo, STableGroupInfo* pGroupInfo, void* readerHandle) {
+static tsdbReadHandleT createDataReadHandle(STableScanPhyNode* pTableScanNode, STableGroupInfo* pGroupInfo, void* readerHandle, uint64_t queryId) {
   STsdbQueryCond cond = {.loadExternalRows = false};
 
-  SPhyNode* pPhyNode = pPlan->pNode;
-  if (pPhyNode->info.type == OP_TableScan || pPhyNode->info.type == OP_DataBlocksOptScan) {
-
-    STableScanPhyNode* pTableScanNode = (STableScanPhyNode*) pPhyNode;
   cond.order = pTableScanNode->scan.order;
   cond.numOfCols = taosArrayGetSize(pTableScanNode->scan.node.pTargets);
   cond.colList = calloc(cond.numOfCols, sizeof(SColumnInfo));
   cond.twindow = pTableScanNode->window;
   cond.type = BLOCK_LOAD_OFFSET_SEQ_ORDER;
 
-    for(int32_t i = 0; i < cond.numOfCols; ++i) {
+  for (int32_t i = 0; i < cond.numOfCols; ++i) {
     SExprInfo* pExprInfo = taosArrayGetP(pTableScanNode->scan.node.pTargets, i);
     assert(pExprInfo->pExpr->nodeType == TEXPR_COL_NODE);
 
@@ -7391,14 +7683,58 @@ int32_t doCreateExecTaskInfo(SSubplan* pPlan, SExecTaskInfo** pTaskInfo, STableG
     cond.colList[i].bytes = pSchema->bytes;
     cond.colList[i].colId = pSchema->colId;
   }
-  } else {
-    assert(0);
+
+  return tsdbQueryTables(readerHandle, &cond, pGroupInfo, queryId, NULL);
+}
+
+static tsdbReadHandleT doCreateDataReadHandle(STableScanPhyNode* pTableScanNode, void* readerHandle, uint64_t queryId) {
+  int32_t         code = 0;
+  STableGroupInfo groupInfo = {0};
+
+  uint64_t uid = pTableScanNode->scan.uid;
+  STimeWindow window = pTableScanNode->window;
+  int32_t tableType = pTableScanNode->scan.tableType;
+
+  if (tableType == TSDB_SUPER_TABLE) {
+    code =
+        tsdbQuerySTableByTagCond(readerHandle, uid, window.skey, NULL, 0, 0, NULL, &groupInfo, NULL, 0, queryId);
+    if (code != TSDB_CODE_SUCCESS) {
+      goto _error;
     }
+  } else {  // Create one table group.
+    groupInfo.numOfTables = 1;
+    groupInfo.pGroupList = taosArrayInit(1, POINTER_BYTES);
+
+    SArray* pa = taosArrayInit(1, sizeof(STableKeyInfo));
+
+    STableKeyInfo info = {.pTable = NULL, .lastKey = 0, .uid = uid};
+    taosArrayPush(pa, &info);
+    taosArrayPush(groupInfo.pGroupList, &pa);
+  }
+
+  if (groupInfo.numOfTables == 0) {
+    code = 0;
+    //    qDebug("no table qualified for query, reqId:0x%"PRIx64, (*pTask)->id.queryId);
+    goto _error;
+  }
+
+  return createDataReadHandle(pTableScanNode, &groupInfo, readerHandle, queryId);
+  _error:
+  terrno = code;
+  return NULL;
+}
+
+int32_t doCreateExecTaskInfo(SSubplan* pPlan, SExecTaskInfo** pTaskInfo, void* readerHandle) {
+  tsdbReadHandleT tReaderHandle = NULL;
+
+  int32_t code = 0;
+  uint64_t queryId = pPlan->id.queryId;
+
+  SPhyNode* pPhyNode = pPlan->pNode;
 
-  *pTaskInfo = createExecTaskInfo((uint64_t)pPlan->id.queryId);
-  tsdbReadHandleT tsdbReadHandle = tsdbQueryTables(readerHandle, &cond, pGroupInfo, (*pTaskInfo)->id.queryId, NULL);
+  *pTaskInfo = createExecTaskInfo(queryId);
 
-  (*pTaskInfo)->pRoot = doCreateOperatorTreeNode(pPlan->pNode, *pTaskInfo, tsdbReadHandle);
+  (*pTaskInfo)->pRoot = doCreateOperatorTreeNode(pPlan->pNode, *pTaskInfo, readerHandle, queryId);
   if ((*pTaskInfo)->pRoot == NULL) {
     return terrno;
   }

source/libs/function/inc/taggfunction.h

@@ -28,14 +28,8 @@ extern "C" {
 #include "function.h"
 #include "tudf.h"
 
-extern SAggFunctionInfo aggFunc[35];
 
-typedef struct SResultRowEntryInfo {
-  int8_t   hasResult;       // result generated, not NULL value
-  bool     initialized;     // output buffer has been initialized
-  bool     complete;        // query has completed
-  uint32_t numOfRes;        // num of output result in current buffer
-} SResultRowEntryInfo;
+extern SAggFunctionInfo aggFunc[35];
 
 #define FUNCSTATE_SO           0x0u
 #define FUNCSTATE_MO           0x1u    // dynamic number of output, not multinumber of output e.g., TOP/BOTTOM

source/libs/function/src/taggfunction.c

@@ -4379,6 +4379,24 @@ int32_t functionCompatList[] = {
     6,          8,        7,
 };
 
+//typedef struct SFunctionFpSet {
+//  bool (*init)(struct SQLFunctionCtx *pCtx, struct SResultRowEntryInfo* pResultCellInfo);  // setup the execute environment
+//  void (*addInput)(struct SQLFunctionCtx *pCtx);
+//
+//  // finalizer must be called after all exec has been executed to generated final result.
+//  void (*finalize)(struct SQLFunctionCtx *pCtx);
+//  void (*combine)(struct SQLFunctionCtx *pCtx);
+//} SFunctionFpSet;
+
+SFunctionFpSet fpSet[1] = {
+    {
+      .init = function_setup,
+      .addInput = count_function,
+      .finalize = doFinalizer,
+      .combine = count_func_merge,
+    }
+};
+
 SAggFunctionInfo aggFunc[35] = {{
                               // 0, count function does not invoke the finalize function
                               "count",

source/libs/parser/inc/queryInfoUtil.h

@@ -30,7 +30,6 @@ SSchema *getTableTagSchema(const STableMeta* pTableMeta);
 
 SArray  *getCurrentExprList(SQueryStmtInfo* pQueryInfo);
 size_t   getNumOfExprs(SQueryStmtInfo* pQueryInfo);
-SExprInfo* createBinaryExprInfo(struct tExprNode* pNode, SSchema* pResSchema);
 
 void       addExprInfo(SArray* pExprList, int32_t index, SExprInfo* pExprInfo, int32_t level);
 void       updateExprInfo(SExprInfo* pExprInfo, int16_t functionId, int32_t colId, int16_t srcColumnIndex, int16_t resType, int16_t resSize);

source/libs/parser/src/astValidate.c

@@ -2080,7 +2080,7 @@ static int32_t setColumnIndex(SQueryStmtInfo* pQueryInfo, SArray* pParamList, SC
   STableMeta* pTableMeta = getMetaInfo(pQueryInfo, 0)->pTableMeta;
   if (pParamList == NULL) {
     // count(*) is equalled to count(primary_timestamp_key)
-    *index = (SColumnIndex) {0, PRIMARYKEY_TIMESTAMP_COL_ID, false};
+    *index = (SColumnIndex) {0, 0, false};
     *columnSchema = *(SSchema*) getOneColumnSchema(pTableMeta, index->columnIndex);
   } else {
     tSqlExprItem* pParamElem = taosArrayGet(pParamList, 0);
@@ -3955,6 +3955,7 @@ int32_t qParserValidateSqlNode(SParseContext *pCtx, SSqlInfo* pInfo, SQueryStmtI
   pQueryInfo->pTableMetaInfo[0]->name = *name;
   pQueryInfo->numOfTables = 1;
   pQueryInfo->pTableMetaInfo[0]->tagColList = taosArrayInit(4, POINTER_BYTES);
+  strcpy(pQueryInfo->pTableMetaInfo[0]->aliasName, name->tname);
   
   code = setTableVgroupList(pCtx, name, &pQueryInfo->pTableMetaInfo[0]->vgroupList);
   if (code != TSDB_CODE_SUCCESS) {

source/libs/parser/src/dCDAstProcess.c

@@ -26,18 +26,26 @@ static int32_t setShowInfo(SShowInfo* pShowInfo, SParseContext* pCtx, void** out
   const char* msg4 = "pattern is invalid";
   const char* msg5 = "database name is empty";
   const char* msg6 = "pattern string is empty";
-
+  const char* msg7 = "db is not specified";
   /*
    * database prefix in pInfo->pMiscInfo->a[0]
    * wildcard in like clause in pInfo->pMiscInfo->a[1]
    */
   int16_t showType = pShowInfo->showType;
   if (showType == TSDB_MGMT_TABLE_TABLE) {
-    SVShowTablesReq* pShowReq = calloc(1, sizeof(SVShowTablesReq));
-
     SArray* array = NULL;
     SName   name = {0};
+
+    if (pCtx->db == NULL && pShowInfo->prefix.n == 0) {
+      return buildInvalidOperationMsg(pMsgBuf, msg7);
+    }
+
+    SVShowTablesReq* pShowReq = calloc(1, sizeof(SVShowTablesReq));
+    if (pShowInfo->prefix.n > 0) {
+      tNameSetDbName(&name, pCtx->acctId, pShowInfo->prefix.z, pShowInfo->prefix.n);
+    } else {
       tNameSetDbName(&name, pCtx->acctId, pCtx->db, strlen(pCtx->db));
+    }
 
     char dbFname[TSDB_DB_FNAME_LEN] = {0};
     tNameGetFullDbName(&name, dbFname);
@@ -715,6 +723,8 @@ SDclStmtInfo* qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseContext* pCtx, ch
   SMsgBuf  m = {.buf = msgBuf, .len = msgBufLen};
   SMsgBuf* pMsgBuf = &m;
 
+  pDcl->epSet = pCtx->mgmtEpSet;
+
   switch (pInfo->type) {
     case TSDB_SQL_CREATE_USER:
     case TSDB_SQL_ALTER_USER: {

source/libs/parser/src/parserUtil.c

@@ -1947,6 +1947,7 @@ int32_t KvRowAppend(const void *value, int32_t len, void *param) {
 int32_t createSName(SName* pName, SToken* pTableName, SParseContext* pParseCtx, SMsgBuf* pMsgBuf) {
   const char* msg1 = "name too long";
   const char* msg2 = "invalid database name";
+  const char* msg3 = "db is not specified";
 
   int32_t  code = TSDB_CODE_SUCCESS;
   char* p  = strnchr(pTableName->z, TS_PATH_DELIMITER[0], pTableName->n, true);
@@ -1984,6 +1985,10 @@ int32_t createSName(SName* pName, SToken* pTableName, SParseContext* pParseCtx,
     strncpy(name, pTableName->z, pTableName->n);
     strdequote(name);
 
+    if (pParseCtx->db == NULL) {
+      return buildInvalidOperationMsg(pMsgBuf, msg3);
+    }
+
     code = tNameSetDbName(pName, pParseCtx->acctId, pParseCtx->db, strlen(pParseCtx->db));
     if (code != TSDB_CODE_SUCCESS) {
       code = buildInvalidOperationMsg(pMsgBuf, msg2);

source/libs/planner/inc/plannerInt.h

@@ -106,7 +106,7 @@ int32_t queryPlanToString(struct SQueryPlanNode* pQueryNode, char** str);
 int32_t queryPlanToSql(struct SQueryPlanNode* pQueryNode, char** sql);
 
 int32_t createDag(SQueryPlanNode* pQueryNode, struct SCatalog* pCatalog, SQueryDag** pDag, uint64_t requestId);
-void setSubplanExecutionNode(SSubplan* subplan, uint64_t templateId, SQueryNodeAddr* ep);
+void setSubplanExecutionNode(SSubplan* subplan, uint64_t templateId, SDownstreamSource* pSource);
 int32_t subPlanToString(const SSubplan *pPhyNode, char** str, int32_t* len);
 int32_t stringToSubplan(const char* str, SSubplan** subplan);
 

source/libs/planner/src/logicPlan.c

@@ -13,6 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <function.h>
 #include "function.h"
 #include "os.h"
 #include "parser.h"
@@ -197,23 +198,23 @@ static SQueryPlanNode* doAddTableColumnNode(const SQueryStmtInfo* pQueryInfo, SQ
   SQueryPlanNode*  pNode = createQueryNode(QNODE_TABLESCAN, "TableScan", NULL, 0, NULL, 0, info);
 
   if (!pQueryInfo->info.projectionQuery) {
-    STableMetaInfo* pTableMetaInfo1 = getMetaInfo(pQueryInfo, 0);
+    SArray* p = pQueryInfo->exprList[0];
 
     // table source column projection, generate the projection expr
     int32_t numOfCols = (int32_t) taosArrayGetSize(tableCols);
-    SExprInfo** pExpr = calloc(numOfCols, POINTER_BYTES);
-    for (int32_t i = 0; i < numOfCols; ++i) {
-      SColumn* pCol = taosArrayGetP(tableCols, i);
 
-      SSourceParam param = {0};
-      addIntoSourceParam(&param, NULL, pCol);
-      SSchema s = createSchema(pCol->info.type, pCol->info.bytes, pCol->info.colId, pCol->name);
-      SExprInfo* p = createExprInfo(pTableMetaInfo1, "project", &param, &s, 0);
-      pExpr[i] = p;
-    }
+    pNode->numOfExpr = numOfCols;
+    pNode->pExpr = taosArrayInit(numOfCols, POINTER_BYTES);
+    for(int32_t i = 0; i < numOfCols; ++i) {
+      SExprInfo* pExprInfo = taosArrayGetP(p, i);
+      SColumn* pCol = pExprInfo->base.pColumns;
+
+      SSchema schema = createSchema(pCol->info.type, pCol->info.bytes, pCol->info.colId, pCol->name);
 
-    // pNode = createQueryNode(QNODE_PROJECT, "Projection", &pNode, 1, pExpr, numOfCols, NULL);
-    tfree(pExpr);
+      tExprNode* pExprNode = pExprInfo->pExpr->_function.pChild[0];
+      SExprInfo* px = createBinaryExprInfo(pExprNode, &schema);
+      taosArrayPush(pNode->pExpr, &px);
+    }
   }
 
   return pNode;

source/libs/planner/src/physicalPlan.c

@@ -278,7 +278,7 @@ static uint64_t splitSubplanByTable(SPlanContext* pCxt, SQueryPlanNode* pPlanNod
 static SPhyNode* createExchangeNode(SPlanContext* pCxt, SQueryPlanNode* pPlanNode, uint64_t srcTemplateId) {
   SExchangePhyNode* node = (SExchangePhyNode*)initPhyNode(pPlanNode, OP_Exchange, sizeof(SExchangePhyNode));
   node->srcTemplateId = srcTemplateId;
-  node->pSrcEndPoints = validPointer(taosArrayInit(TARRAY_MIN_SIZE, sizeof(SQueryNodeAddr)));
+  node->pSrcEndPoints = validPointer(taosArrayInit(TARRAY_MIN_SIZE, sizeof(SDownstreamSource)));
   return (SPhyNode*)node;
 }
 
@@ -409,24 +409,25 @@ int32_t createDag(SQueryPlanNode* pQueryNode, struct SCatalog* pCatalog, SQueryD
   return TSDB_CODE_SUCCESS;
 }
 
-void setExchangSourceNode(uint64_t templateId, SQueryNodeAddr* pEp, SPhyNode* pNode) {
+void setExchangSourceNode(uint64_t templateId, SDownstreamSource *pSource, SPhyNode* pNode) {
   if (NULL == pNode) {
     return;
   }
   if (OP_Exchange == pNode->info.type) {
     SExchangePhyNode* pExchange = (SExchangePhyNode*)pNode;
     if (templateId == pExchange->srcTemplateId) {
-      taosArrayPush(pExchange->pSrcEndPoints, pEp);
+      taosArrayPush(pExchange->pSrcEndPoints, pSource);
     }
   }
+
   if (pNode->pChildren != NULL) {
     size_t size = taosArrayGetSize(pNode->pChildren);
     for(int32_t i = 0; i < size; ++i) {
-      setExchangSourceNode(templateId, pEp, taosArrayGetP(pNode->pChildren, i));
+      setExchangSourceNode(templateId, pSource, taosArrayGetP(pNode->pChildren, i));
     }
   }
 }
 
-void setSubplanExecutionNode(SSubplan* subplan, uint64_t templateId, SQueryNodeAddr* pEp) {
-  setExchangSourceNode(templateId, pEp, subplan->pNode);
+void setSubplanExecutionNode(SSubplan* subplan, uint64_t templateId, SDownstreamSource* pSource) {
+  setExchangSourceNode(templateId, pSource, subplan->pNode);
 }

source/libs/planner/src/physicalPlanJson.c

@@ -29,6 +29,14 @@ static void copyString(const cJSON* json, const char* name, char* dst) {
   strcpy(dst, cJSON_GetStringValue(cJSON_GetObjectItem(json, name)));
 }
 
+static uint64_t getBigintFromString(const cJSON* json, const char* name) {
+  char* val = getString(json, name);
+  uint64_t intVal = strtoul(val, NULL, 10);
+  tfree(val);
+
+  return intVal;
+}
+
 static int64_t getNumber(const cJSON* json, const char* name) {
   double d = cJSON_GetNumberValue(cJSON_GetObjectItem(json, name));
   return (int64_t) d;
@@ -400,7 +408,7 @@ static bool functionToJson(const void* obj, cJSON* jFunc) {
   const tExprNode* exprInfo = (const tExprNode*)obj;
   bool res = cJSON_AddStringToObject(jFunc, jkFunctionName, exprInfo->_function.functionName);
   if (res && NULL != exprInfo->_function.pChild) {
-      res = addRawArray(jFunc, jkFunctionChild, exprNodeToJson, *(exprInfo->_function.pChild), sizeof(tExprNode*), exprInfo->_function.num);
+      res = addRawArray(jFunc, jkFunctionChild, exprNodeToJson, exprInfo->_function.pChild, sizeof(tExprNode*), exprInfo->_function.num);
   }
   return res;
 }
@@ -459,7 +467,7 @@ static const char* jkExprNodeColumn = "Column";
 static const char* jkExprNodeValue = "Value";
 
 static bool exprNodeToJson(const void* obj, cJSON* jExprInfo) {
-  const tExprNode* exprInfo = (const tExprNode*)obj;
+  const tExprNode* exprInfo = *(const tExprNode**)obj;
   bool res = cJSON_AddNumberToObject(jExprInfo, jkExprNodeType, exprInfo->nodeType);
   if (res) {
     switch (exprInfo->nodeType) {
@@ -547,7 +555,7 @@ static bool exprInfoToJson(const void* obj, cJSON* jExprInfo) {
   const SExprInfo* exprInfo = (const SExprInfo*)obj;
   bool res = addObject(jExprInfo, jkExprInfoBase, sqlExprToJson, &exprInfo->base);
   if (res) {
-    res = addObject(jExprInfo, jkExprInfoExpr, exprNodeToJson, exprInfo->pExpr);
+    res = addObject(jExprInfo, jkExprInfoExpr, exprNodeToJson, &exprInfo->pExpr);
   }
   return res;
 }
@@ -567,13 +575,13 @@ static const char* jkTimeWindowEndKey = "EndKey";
 static bool timeWindowToJson(const void* obj, cJSON* json) {
   const STimeWindow* win = (const STimeWindow*)obj;
 
-  char tmp[32] = {0};
-  sprintf(tmp, "%"PRId64, win->skey);
+  char tmp[40] = {0};
+  snprintf(tmp, tListLen(tmp),"%"PRId64, win->skey);
 
   bool res = cJSON_AddStringToObject(json, jkTimeWindowStartKey, tmp);
   if (res) {
     memset(tmp, 0, tListLen(tmp));
-    sprintf(tmp, "%"PRId64, win->ekey);
+    snprintf(tmp, tListLen(tmp),"%"PRId64, win->ekey);
     res = cJSON_AddStringToObject(json, jkTimeWindowEndKey, tmp);
   }
   return res;
@@ -581,16 +589,8 @@ static bool timeWindowToJson(const void* obj, cJSON* json) {
 
 static bool timeWindowFromJson(const cJSON* json, void* obj) {
   STimeWindow* win = (STimeWindow*)obj;
-
-  char* pStartKey = getString(json, jkTimeWindowStartKey);
-  win->skey = strtoll(pStartKey, NULL, 10);
-
-  char* pEndKey = getString(json, jkTimeWindowEndKey);
-  win->ekey = strtoll(pEndKey, NULL, 10);
-
-  tfree(pStartKey);
-  tfree(pEndKey);
-
+  win->skey = getBigintFromString(json, jkTimeWindowStartKey);
+  win->ekey = getBigintFromString(json, jkTimeWindowEndKey);
   return true;
 }
 
@@ -629,10 +629,7 @@ static bool scanNodeToJson(const void* obj, cJSON* json) {
 static bool scanNodeFromJson(const cJSON* json, void* obj) {
   SScanPhyNode* pNode = (SScanPhyNode*)obj;
 
-  char* val        = getString(json, jkScanNodeTableId);
-  pNode->uid       = strtoull(val, NULL, 10);
-  tfree(val);
-
+  pNode->uid       = getBigintFromString(json, jkScanNodeTableId);
   pNode->tableType = getNumber(json, jkScanNodeTableType);
   pNode->count     = getNumber(json, jkScanNodeTableCount);
   pNode->order     = getNumber(json, jkScanNodeTableOrder);
@@ -755,38 +752,70 @@ static bool epAddrFromJson(const cJSON* json, void* obj) {
 
 static const char* jkNodeAddrId      = "NodeId";
 static const char* jkNodeAddrInUse   = "InUse";
-static const char* jkNodeAddrEpAddrs = "EpAddrs";
+static const char* jkNodeAddrEpAddrs = "Ep";
+static const char* jkNodeAddr        = "NodeAddr";
+static const char* jkNodeTaskId      = "TaskId";
+static const char* jkNodeTaskSchedId = "SchedId";
+
+static bool queryNodeAddrToJson(const void* obj, cJSON* json) {
+  const SQueryNodeAddr* pAddr = (const SQueryNodeAddr*) obj;
+  bool res = cJSON_AddNumberToObject(json, jkNodeAddrId, pAddr->nodeId);
+
+  if (res) {
+    res = cJSON_AddNumberToObject(json, jkNodeAddrInUse, pAddr->inUse);
+  }
+
+  if (res) {
+    res = addRawArray(json, jkNodeAddrEpAddrs, epAddrToJson, pAddr->epAddr, sizeof(SEpAddr), pAddr->numOfEps);
+  }
+  return res;
+}
+
+static bool queryNodeAddrFromJson(const cJSON* json, void* obj) {
+  SQueryNodeAddr* pAddr = (SQueryNodeAddr*) obj;
+
+  pAddr->nodeId = getNumber(json, jkNodeAddrId);
+  pAddr->inUse = getNumber(json, jkNodeAddrInUse);
+
+  int32_t numOfEps = 0;
+  bool res = fromRawArray(json, jkNodeAddrEpAddrs, epAddrFromJson, pAddr->epAddr, sizeof(SEpAddr), &numOfEps);
+  pAddr->numOfEps = numOfEps;
+  return res;
+}
 
 static bool nodeAddrToJson(const void* obj, cJSON* json) {
-  const SQueryNodeAddr* ep = (const SQueryNodeAddr*)obj;
-  bool res = cJSON_AddNumberToObject(json, jkNodeAddrId, ep->nodeId);
+  const SDownstreamSource* pSource = (const SDownstreamSource*) obj;
+  bool res = cJSON_AddNumberToObject(json, jkNodeTaskId, pSource->taskId);
+
   if (res) {
-    res = cJSON_AddNumberToObject(json, jkNodeAddrInUse, ep->inUse);
+    char t[30] = {0};
+    snprintf(t, tListLen(t), "%"PRIu64, pSource->schedId);
+    res = cJSON_AddStringToObject(json, jkNodeTaskSchedId, t);
   }
+
   if (res) {
-    res = addRawArray(json, jkNodeAddrEpAddrs, epAddrToJson, ep->epAddr, sizeof(SEpAddr), ep->numOfEps);
+    res = addObject(json, jkNodeAddr, queryNodeAddrToJson, &pSource->addr);
   }
   return res;
 }
 
 static bool nodeAddrFromJson(const cJSON* json, void* obj) {
-  SQueryNodeAddr* ep = (SQueryNodeAddr*)obj;
-  ep->nodeId = getNumber(json, jkNodeAddrId);
-  ep->inUse = getNumber(json, jkNodeAddrInUse);
-  int32_t numOfEps = 0;
-  bool res = fromRawArray(json, jkNodeAddrEpAddrs, nodeAddrFromJson, &ep->epAddr, sizeof(SEpAddr), &numOfEps);
-  ep->numOfEps = numOfEps;
+  SDownstreamSource* pSource = (SDownstreamSource*)obj;
+  pSource->taskId = getNumber(json, jkNodeTaskId);
+
+  pSource->schedId = getBigintFromString(json, jkNodeTaskSchedId);
+  bool res = fromObject(json, jkNodeAddr, queryNodeAddrFromJson, &pSource->addr, true);
   return res;
 }
 
 static const char* jkExchangeNodeSrcTemplateId = "SrcTemplateId";
-static const char* jkExchangeNodeSrcEndPoints = "SrcEndPoints";
+static const char* jkExchangeNodeSrcEndPoints = "SrcAddrs";
 
 static bool exchangeNodeToJson(const void* obj, cJSON* json) {
   const SExchangePhyNode* exchange = (const SExchangePhyNode*)obj;
   bool res = cJSON_AddNumberToObject(json, jkExchangeNodeSrcTemplateId, exchange->srcTemplateId);
   if (res) {
-    res = addInlineArray(json, jkExchangeNodeSrcEndPoints, nodeAddrToJson, exchange->pSrcEndPoints);
+    res = addRawArray(json, jkExchangeNodeSrcEndPoints, nodeAddrToJson, exchange->pSrcEndPoints->pData, sizeof(SDownstreamSource), taosArrayGetSize(exchange->pSrcEndPoints));
   }
   return res;
 }
@@ -794,7 +823,7 @@ static bool exchangeNodeToJson(const void* obj, cJSON* json) {
 static bool exchangeNodeFromJson(const cJSON* json, void* obj) {
   SExchangePhyNode* exchange = (SExchangePhyNode*)obj;
   exchange->srcTemplateId = getNumber(json, jkExchangeNodeSrcTemplateId);
-  return fromInlineArray(json, jkExchangeNodeSrcEndPoints, nodeAddrFromJson, &exchange->pSrcEndPoints, sizeof(SQueryNodeAddr));
+  return fromInlineArray(json, jkExchangeNodeSrcEndPoints, nodeAddrFromJson, &exchange->pSrcEndPoints, sizeof(SDownstreamSource));
 }
 
 static bool specificPhyNodeToJson(const void* obj, cJSON* json) {
@@ -1003,7 +1032,11 @@ static const char* jkIdSubplanId = "SubplanId";
 
 static bool subplanIdToJson(const void* obj, cJSON* jId) {
   const SSubplanId* id = (const SSubplanId*)obj;
-  bool res = cJSON_AddNumberToObject(jId, jkIdQueryId, id->queryId);
+
+  char ids[40] = {0};
+  snprintf(ids, tListLen(ids), "%"PRIu64, id->queryId);
+
+  bool res = cJSON_AddStringToObject(jId, jkIdQueryId, ids);
   if (res) {
     res = cJSON_AddNumberToObject(jId, jkIdTemplateId, id->templateId);
   }
@@ -1015,7 +1048,8 @@ static bool subplanIdToJson(const void* obj, cJSON* jId) {
 
 static bool subplanIdFromJson(const cJSON* json, void* obj) {
   SSubplanId* id = (SSubplanId*)obj;
-  id->queryId = getNumber(json, jkIdQueryId);
+
+  id->queryId    = getBigintFromString(json, jkIdQueryId);
   id->templateId = getNumber(json, jkIdTemplateId);
   id->subplanId  = getNumber(json, jkIdSubplanId);
   return true;

source/libs/planner/src/planner.c

@@ -65,9 +65,9 @@ int32_t qCreateQueryDag(const struct SQueryNode* pNode, struct SQueryDag** pDag,
   }
 
   if (pLogicPlan->info.type != QNODE_MODIFY) {
-   char* str = NULL;
-   queryPlanToString(pLogicPlan, &str);
-   printf("%s\n", str);
+//   char* str = NULL;
+//   queryPlanToString(pLogicPlan, &str);
+//   printf("%s\n", str);
   }
 
   code = optimizeQueryPlan(pLogicPlan);
@@ -87,8 +87,8 @@ int32_t qCreateQueryDag(const struct SQueryNode* pNode, struct SQueryDag** pDag,
   return TSDB_CODE_SUCCESS;
 }
 
-void qSetSubplanExecutionNode(SSubplan* subplan, uint64_t templateId, SQueryNodeAddr* ep) {
-  setSubplanExecutionNode(subplan, templateId, ep);
+void qSetSubplanExecutionNode(SSubplan* subplan, uint64_t templateId, SDownstreamSource* pSource) {
+  setSubplanExecutionNode(subplan, templateId, pSource);
 }
 
 int32_t qSubPlanToString(const SSubplan *subplan, char** str, int32_t* len) {

source/libs/qworker/src/qworker.c

@@ -258,6 +258,8 @@ int32_t qwAddTaskCtxImpl(SQWorkerMgmt *mgmt, uint64_t sId, uint64_t qId, uint64_
   char id[sizeof(qId) + sizeof(tId)] = {0};
   QW_SET_QTID(id, qId, tId);
 
+  printf("%"PRIx64", tid:%"PRIx64"\n", qId, tId);
+
   SQWTaskCtx nctx = {0};
 
   QW_LOCK(QW_WRITE, &mgmt->ctxLock);

source/libs/scheduler/src/scheduler.c

@@ -765,7 +765,8 @@ int32_t schProcessOnTaskSuccess(SSchJob *pJob, SSchTask *pTask) {
     atomic_add_fetch_32(&par->childReady, 1);
 
     SCH_LOCK(SCH_WRITE, &par->lock);
-    qSetSubplanExecutionNode(par->plan, pTask->plan->id.templateId, &pTask->succeedAddr);
+    SDownstreamSource source = {.taskId = pTask->taskId, .schedId = schMgmt.sId, .addr = pTask->succeedAddr};
+    qSetSubplanExecutionNode(par->plan, pTask->plan->id.templateId, &source);
     SCH_UNLOCK(SCH_WRITE, &par->lock);
 
     if (SCH_TASK_READY_TO_LUNCH(par)) {
@@ -1197,7 +1198,7 @@ int32_t schLaunchTask(SSchJob *pJob, SSchTask *pTask) {
       SCH_ERR_JRET(code);
     }
 
-    printf("physical plan:%s\n", pTask->msg);
+//    printf("physical plan:%s\n", pTask->msg);
   }
 
   SCH_ERR_JRET(schSetTaskCandidateAddrs(pJob, pTask));
@@ -1463,7 +1464,7 @@ int32_t schedulerConvertDagToTaskList(SQueryDag *pDag, SArray **pTasks) {
       SCH_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY);
     }
     
-    SSubQueryMsg *pMsg = msg;
+    SSubQueryMsg *pMsg = (SSubQueryMsg*) msg;
     
     pMsg->header.vgId = htonl(tInfo.addr.nodeId);
 

source/libs/tfs/CMakeLists.txt

@@ -7,3 +7,7 @@ target_include_directories(
 )
 
 target_link_libraries(tfs os util common)
+
+if(${BUILD_TEST})
+    add_subdirectory(test)
+endif(${BUILD_TEST})
\ No newline at end of file

source/libs/tfs/inc/tfsInt.h

@@ -22,7 +22,6 @@
 #include "taoserror.h"
 #include "tcoding.h"
 #include "tfs.h"
-#include "tglobal.h"
 #include "thash.h"
 #include "tlog.h"
 

source/libs/tfs/src/tfs.c

@@ -141,6 +141,7 @@ const char *tfsGetDiskPath(STfs *pTfs, SDiskID diskId) { return TFS_DISK_AT(pTfs
 
 void tfsInitFile(STfs *pTfs, STfsFile *pFile, SDiskID diskId, const char *rname) {
   STfsDisk *pDisk = TFS_DISK_AT(pTfs, diskId);
+  if (pDisk == NULL) return;
 
   pFile->did = diskId;
   tstrncpy(pFile->rname, rname, TSDB_FILENAME_LEN);
@@ -197,9 +198,7 @@ void tfsDirname(const STfsFile *pFile, char *dest) {
   tstrncpy(dest, dirname(tname), TSDB_FILENAME_LEN);
 }
 
-int32_t tfsRemoveFile(const STfsFile *pFile) {
-  return remove(pFile->aname);
-}
+int32_t tfsRemoveFile(const STfsFile *pFile) { return remove(pFile->aname); }
 
 int32_t tfsCopyFile(const STfsFile *pFile1, const STfsFile *pFile2) {
   return taosCopyFile(pFile1->aname, pFile2->aname);
@@ -291,6 +290,8 @@ int32_t tfsRename(STfs *pTfs, char *orname, char *nrname) {
       snprintf(oaname, TMPNAME_LEN, "%s%s%s", pDisk->path, TD_DIRSEP, orname);
       snprintf(naname, TMPNAME_LEN, "%s%s%s", pDisk->path, TD_DIRSEP, nrname);
       if (taosRenameFile(oaname, naname) != 0) {
+        terrno = TAOS_SYSTEM_ERROR(errno);
+        fError("failed to rename %s to %s since %s", oaname, naname, terrstr());
         return -1;
       }
     }
@@ -330,7 +331,12 @@ const STfsFile *tfsReaddir(STfsDir *pDir) {
       // Skip . and ..
       if (strcmp(dp->d_name, ".") == 0 || strcmp(dp->d_name, "..") == 0) continue;
 
+      if (pDir->dirname == NULL || pDir->dirname[0] == 0) {
+        snprintf(bname, TMPNAME_LEN * 2, "%s", dp->d_name);
+      } else {
         snprintf(bname, TMPNAME_LEN * 2, "%s%s%s", pDir->dirname, TD_DIRSEP, dp->d_name);
+      }
+
       tfsInitFile(pDir->pTfs, &pDir->tfile, pDir->did, bname);
       return &pDir->tfile;
     }
@@ -402,8 +408,7 @@ static int32_t tfsCheckAndFormatCfg(STfs *pTfs, SDiskCfg *pCfg) {
   }
 
   if (tfsFormatDir(pCfg->dir, dirName) < 0) {
-    fError("failed to mount %s to FS since invalid dir format", pCfg->dir);
-    terrno = TSDB_CODE_FS_INVLD_CFG;
+    fError("failed to mount %s to FS since %s", pCfg->dir, terrstr());
     return -1;
   }
 
@@ -501,7 +506,11 @@ static int32_t tfsOpendirImpl(STfs *pTfs, STfsDir *pDir) {
     pDir->did.level = pDisk->level;
     pDir->did.id = pDisk->id;
 
+    if (pDisk->path == NULL || pDisk->path[0] == 0) {
+      snprintf(adir, TMPNAME_LEN * 2, "%s", pDir->dirname);
+    } else {
       snprintf(adir, TMPNAME_LEN * 2, "%s%s%s", pDisk->path, TD_DIRSEP, pDir->dirname);
+    }
     pDir->dir = opendir(adir);
     if (pDir->dir != NULL) break;
   }

source/libs/tfs/test/CMakeLists.txt

+enable_testing()
+
+aux_source_directory(. TFS_TEST_SRC)
+add_executable(tfs_test ${TFS_TEST_SRC})
+target_link_libraries(
+  tfs_test
+  PUBLIC tfs
+  PUBLIC gtest_main
+)
+
+add_test(
+    NAME tfs_test
+    COMMAND tfs_test
+)

source/libs/tfs/test/tfsTest.cpp

+/**
+ * @file tfsTest.cpp
+ * @author slguan (slguan@taosdata.com)
+ * @brief TFS module tests
+ * @version 1.0
+ * @date 2022-01-20
+ *
+ * @copyright Copyright (c) 2022
+ *
+ */
+
+#include <gtest/gtest.h>
+#include "os.h"
+
+#include "tfs.h"
+
+class TfsTest : public ::testing::Test {
+ protected:
+  static void SetUpTestSuite() { root = "/tmp/tfsTest"; }
+  static void TearDownTestSuite() {}
+
+ public:
+  void SetUp() override {}
+  void TearDown() override {}
+
+  static const char *root;
+};
+
+const char *TfsTest::root;
+
+TEST_F(TfsTest, 01_Open_Close) {
+  SDiskCfg dCfg = {0};
+  tstrncpy(dCfg.dir, root, TSDB_FILENAME_LEN);
+  dCfg.level = 0;
+  dCfg.primary = 1;
+
+  taosRemoveDir(root);
+  STfs *pTfs = tfsOpen(&dCfg, 1);
+  ASSERT_EQ(pTfs, nullptr);
+
+  taosMkDir(root);
+  pTfs = tfsOpen(&dCfg, 1);
+  ASSERT_NE(pTfs, nullptr);
+
+  tfsUpdateSize(pTfs);
+  SDiskSize size = tfsGetSize(pTfs);
+
+  EXPECT_GT(size.avail, 0);
+  EXPECT_GT(size.used, 0);
+  EXPECT_GT(size.total, size.avail);
+  EXPECT_GT(size.total, size.used);
+
+  tfsClose(pTfs);
+}
+
+TEST_F(TfsTest, 02_AllocDisk) {
+  int32_t  code = 0;
+  SDiskCfg dCfg = {0};
+  tstrncpy(dCfg.dir, root, TSDB_FILENAME_LEN);
+  dCfg.level = 0;
+  dCfg.primary = 1;
+
+  taosRemoveDir(root);
+  taosMkDir(root);
+  STfs *pTfs = tfsOpen(&dCfg, 1);
+  ASSERT_NE(pTfs, nullptr);
+
+  SDiskID did;
+  did.id = 0;
+  did.level = 0;
+
+  code = tfsAllocDisk(pTfs, 0, &did);
+  EXPECT_EQ(code, 0);
+  EXPECT_EQ(did.id, 0);
+  EXPECT_EQ(did.level, 0);
+
+  did.id = 1;
+  did.level = 1;
+  code = tfsAllocDisk(pTfs, 0, &did);
+  EXPECT_EQ(code, 0);
+  EXPECT_EQ(did.id, 0);
+  EXPECT_EQ(did.level, 0);
+
+  did.id = 1;
+  did.level = 2;
+  code = tfsAllocDisk(pTfs, 0, &did);
+  EXPECT_EQ(code, 0);
+  EXPECT_EQ(did.id, 0);
+  EXPECT_EQ(did.level, 0);
+
+  did.id = 1;
+  did.level = 3;
+  code = tfsAllocDisk(pTfs, 0, &did);
+  EXPECT_EQ(code, 0);
+  EXPECT_EQ(did.id, 0);
+  EXPECT_EQ(did.level, 0);
+
+  const char *primary = tfsGetPrimaryPath(pTfs);
+  EXPECT_STREQ(primary, root);
+
+  const char *path = tfsGetDiskPath(pTfs, did);
+  EXPECT_STREQ(path, root);
+
+  tfsClose(pTfs);
+}
+
+TEST_F(TfsTest, 03_Dir) {
+  int32_t  code = 0;
+  SDiskCfg dCfg = {0};
+  tstrncpy(dCfg.dir, root, TSDB_FILENAME_LEN);
+  dCfg.level = 0;
+  dCfg.primary = 1;
+
+  taosRemoveDir(root);
+  taosMkDir(root);
+  STfs *pTfs = tfsOpen(&dCfg, 1);
+  ASSERT_NE(pTfs, nullptr);
+
+  char p1[] = "p1";
+  char ap1[128] = {0};
+  snprintf(ap1, 128, "%s%s%s", root, TD_DIRSEP, p1);
+  EXPECT_NE(taosDirExist(ap1), 0);
+  EXPECT_EQ(tfsMkdir(pTfs, p1), 0);
+  EXPECT_EQ(taosDirExist(ap1), 0);
+
+  char p2[] = "p2";
+  char ap2[128] = {0};
+  snprintf(ap2, 128, "%s%s%s", root, TD_DIRSEP, p2);
+  SDiskID did = {0};
+  EXPECT_NE(taosDirExist(ap2), 0);
+  EXPECT_EQ(tfsMkdirAt(pTfs, p2, did), 0);
+  EXPECT_EQ(taosDirExist(ap2), 0);
+
+  char p3[] = "p3/p2/p1/p0";
+  char ap3[128] = {0};
+  snprintf(ap3, 128, "%s%s%s", root, TD_DIRSEP, p3);
+  EXPECT_NE(taosDirExist(ap3), 0);
+  EXPECT_NE(tfsMkdir(pTfs, p3), 0);
+  EXPECT_NE(tfsMkdirAt(pTfs, p3, did), 0);
+  EXPECT_EQ(tfsMkdirRecurAt(pTfs, p3, did), 0);
+  EXPECT_EQ(taosDirExist(ap3), 0);
+
+  EXPECT_EQ(tfsRmdir(pTfs, p3), 0);
+  EXPECT_NE(taosDirExist(ap3), 0);
+
+  char p45[] = "p5";
+  char p44[] = "p4";
+  char p4[] = "p4/p2/p1/p0";
+  char ap4[128] = {0};
+  snprintf(ap4, 128, "%s%s%s", root, TD_DIRSEP, p4);
+
+  EXPECT_NE(taosDirExist(ap4), 0);
+  EXPECT_EQ(tfsMkdirRecurAt(pTfs, p4, did), 0);
+  EXPECT_EQ(taosDirExist(ap4), 0);
+  EXPECT_EQ(tfsRename(pTfs, p44, p45), 0);
+  EXPECT_EQ(tfsRmdir(pTfs, p4), 0);
+  EXPECT_NE(taosDirExist(ap4), 0);
+
+  tfsClose(pTfs);
+}
+
+TEST_F(TfsTest, 04_File) {
+  int32_t  code = 0;
+  SDiskCfg dCfg = {0};
+  tstrncpy(dCfg.dir, root, TSDB_FILENAME_LEN);
+  dCfg.level = 0;
+  dCfg.primary = 1;
+
+  taosRemoveDir(root);
+  taosMkDir(root);
+  STfs *pTfs = tfsOpen(&dCfg, 1);
+  ASSERT_NE(pTfs, nullptr);
+
+  STfsFile file0;
+  STfsFile file1;
+  STfsFile file2;
+  STfsFile file3;
+  STfsFile file4;
+  SDiskID  did0 = {0};
+  SDiskID  did1 = {0};
+  SDiskID  did2 = {0};
+  SDiskID  did3 = {0};
+  SDiskID  did4 = {0};
+  did3.id = 1;
+  did4.level = 1;
+  tfsInitFile(pTfs, &file0, did0, "fname");
+  tfsInitFile(pTfs, &file1, did1, "fname");
+  tfsInitFile(pTfs, &file2, did2, "fnamex");
+  tfsInitFile(pTfs, &file3, did3, "fname");
+  tfsInitFile(pTfs, &file4, did4, "fname");
+
+  EXPECT_TRUE(tfsIsSameFile(&file0, &file1));
+  EXPECT_FALSE(tfsIsSameFile(&file0, &file2));
+  EXPECT_FALSE(tfsIsSameFile(&file0, &file3));
+  EXPECT_FALSE(tfsIsSameFile(&file0, &file4));
+
+  {
+    int32_t size = 1024;
+    void   *ret = malloc(size + sizeof(size_t));
+    *(size_t *)ret = size;
+    void *buf = (void *)((char *)ret + sizeof(size_t));
+
+    file0.did.id = 0;
+    file0.did.level = 0;
+    int32_t len = tfsEncodeFile((void **)&buf, &file0);
+    EXPECT_EQ(len, 8);
+
+    STfsFile outfile = {0};
+    char    *outbuf = (char *)tfsDecodeFile(pTfs, (void *)((char *)buf - len), &outfile);
+    int32_t  decodeLen = (outbuf - (char *)buf);
+
+    EXPECT_EQ(outfile.did.id, 0);
+    EXPECT_EQ(outfile.did.level, 0);
+    EXPECT_STREQ(outfile.aname, file0.aname);
+    EXPECT_STREQ(outfile.rname, "fname");
+    EXPECT_EQ(outfile.pTfs, pTfs);
+  }
+
+  {
+    char     n1[] = "t3/t1.json";
+    char     n2[] = "t3/t2.json";
+    STfsFile f1 = {0};
+    STfsFile f2 = {0};
+    SDiskID  did;
+    did.id = 0;
+    did.level = 0;
+
+    tfsInitFile(pTfs, &f1, did, n1);
+    tfsInitFile(pTfs, &f2, did, n2);
+
+    EXPECT_EQ(tfsMkdir(pTfs, "t3"), 0);
+
+    FILE *fp = fopen(f1.aname, "w");
+    ASSERT_NE(fp, nullptr);
+    fwrite("12345678", 1, 5, fp);
+    fclose(fp);
+
+    char base[128] = {0};
+    tfsBasename(&f1, base);
+    char dir[128] = {0};
+    tfsDirname(&f1, dir);
+
+    EXPECT_STREQ(base, "t1.json");
+
+    char fulldir[128];
+    snprintf(fulldir, 128, "%s%s%s", root, TD_DIRSEP, "t3");
+    EXPECT_STREQ(dir, fulldir);
+
+    EXPECT_NE(tfsCopyFile(&f1, &f2), 0);
+
+    char af2[128] = {0};
+    snprintf(af2, 128, "%s%s%s", root, TD_DIRSEP, n2);
+    EXPECT_EQ(taosDirExist(af2), 0);
+    tfsRemoveFile(&f2);
+    EXPECT_NE(taosDirExist(af2), 0);
+    EXPECT_NE(tfsCopyFile(&f1, &f2), 0);
+
+    {
+      STfsDir *pDir = tfsOpendir(pTfs, "");
+
+      const STfsFile *pf1 = tfsReaddir(pDir);
+      EXPECT_STREQ(pf1->rname, "t3");
+      EXPECT_EQ(pf1->did.id, 0);
+      EXPECT_EQ(pf1->did.level, 0);
+      EXPECT_EQ(pf1->pTfs, pTfs);
+
+      const STfsFile *pf2 = tfsReaddir(pDir);
+      EXPECT_EQ(pf2, nullptr);
+
+      tfsClosedir(pDir);
+    }
+
+    {
+      STfsDir *pDir = tfsOpendir(pTfs, "t3");
+
+      const STfsFile *pf1 = tfsReaddir(pDir);
+      EXPECT_NE(pf1, nullptr);
+      EXPECT_EQ(pf1->did.id, 0);
+      EXPECT_EQ(pf1->did.level, 0);
+      EXPECT_EQ(pf1->pTfs, pTfs);
+
+      const STfsFile *pf2 = tfsReaddir(pDir);
+      EXPECT_NE(pf2, nullptr);
+
+      const STfsFile *pf3 = tfsReaddir(pDir);
+      EXPECT_EQ(pf3, nullptr);
+
+      tfsClosedir(pDir);
+    }
+  }
+
+  tfsClose(pTfs);
+}
\ No newline at end of file

source/util/src/tconfig.c

@@ -16,8 +16,8 @@
 #define _DEFAULT_SOURCE
 #include "os.h"
 #include "tconfig.h"
-#include "ulog.h"
 #include "tutil.h"
+#include "ulog.h"
 
 SGlobalCfg tsGlobalConfig[TSDB_CFG_MAX_NUM] = {{0}};
 int32_t    tsGlobalConfigNum = 0;

src/CMakeLists.txt

-# Base components
-add_subdirectory(os)
-add_subdirectory(util)
-add_subdirectory(common)
-
-# Library components
-
-# Service components
-# add_subdirectory(mnode)
-# add_subdirectory(vnode)
-# add_subdirectory(qnode)
-add_subdirectory(dnode)
-

go @ b8f76da4

-Subproject commit b8f76da4a708d158ec3cc4b844571dc4414e36b4

grafanaplugin @ 4a4d7909

-Subproject commit 4a4d79099b076b8ff12d5b4fdbcba54049a6866d

hivemq-tdengine-extension @ ce520101

-Subproject commit ce5201014136503d34fecbd56494b67b4961056c

src/cq/CMakeLists.txt

-CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
-PROJECT(TDengine)
-
-INCLUDE_DIRECTORIES(inc)
-INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/client/inc)
-INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc)
-AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/src SRC)
-
-ADD_LIBRARY(tcq ${SRC})
-IF (TD_SOMODE_STATIC)
-  TARGET_LINK_LIBRARIES(tcq tutil common taos_static)
-ELSE ()
-  TARGET_LINK_LIBRARIES(tcq tutil common taos)
-ENDIF ()
-ADD_SUBDIRECTORY(test)

src/cq/src/cqMain.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/>.
- */
-
-#define _DEFAULT_SOURCE
-
-#include <errno.h>
-#include <pthread.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "../../../include/client/taos.h"
-#include "taosdef.h"
-#include "tmsg.h"
-#include "tcq.h"
-#include "tdataformat.h"
-#include "tglobal.h"
-#include "tlog.h"
-#include "tsclient.h"
-#include "ttimer.h"
-#include "twal.h"
-
-#define cFatal(...) { if (cqDebugFlag & DEBUG_FATAL) { taosPrintLog("CQ  FATAL ", 255, __VA_ARGS__); }}
-#define cError(...) { if (cqDebugFlag & DEBUG_ERROR) { taosPrintLog("CQ  ERROR ", 255, __VA_ARGS__); }}
-#define cWarn(...)  { if (cqDebugFlag & DEBUG_WARN)  { taosPrintLog("CQ  WARN ", 255, __VA_ARGS__); }}
-#define cInfo(...)  { if (cqDebugFlag & DEBUG_INFO)  { taosPrintLog("CQ  ", 255, __VA_ARGS__); }}
-#define cDebug(...) { if (cqDebugFlag & DEBUG_DEBUG) { taosPrintLog("CQ  ", cqDebugFlag, __VA_ARGS__); }}
-#define cTrace(...) { if (cqDebugFlag & DEBUG_TRACE) { taosPrintLog("CQ  ", cqDebugFlag, __VA_ARGS__); }}
-
-
-typedef struct SCqObj {
-  tmr_h          tmrId;
-  int64_t        rid;
-  uint64_t       uid;
-  int32_t        tid;      // table ID
-  int32_t        rowSize;  // bytes of a row
-  char *         dstTable;
-  char *         sqlStr;   // SQL string
-  STSchema *     pSchema;  // pointer to schema array
-  void *         pStream;
-  struct SCqObj *prev;
-  struct SCqObj *next;
-  SCqContext *   pContext;
-} SCqObj;
-
-static void cqProcessStreamRes(void *param, TAOS_RES *tres, TAOS_ROW row); 
-static void cqCreateStream(SCqContext *pContext, SCqObj *pObj);
-
-int32_t    cqObjRef = -1;
-int32_t    cqVnodeNum = 0;
-
-void cqRmFromList(SCqObj *pObj) {
-  //LOCK in caller
-
-  SCqContext *pContext = pObj->pContext;
-
-  if (pObj->prev) {
-    pObj->prev->next = pObj->next;
-  } else {
-    pContext->pHead = pObj->next;
-  }
-
-  if (pObj->next) {
-    pObj->next->prev = pObj->prev;
-  }
-
-}
-
-static void freeSCqContext(void *handle) {
-  if (handle == NULL) {
-    return;
-  }
-  SCqContext *pContext = handle;
-  pthread_mutex_destroy(&pContext->mutex);
-
-  taosTmrCleanUp(pContext->tmrCtrl);
-  pContext->tmrCtrl = NULL;
-  cDebug("vgId:%d, CQ is closed", pContext->vgId);
-  free(pContext);
-}
-
-
-void cqFree(void *handle) {
-  if (tsEnableStream == 0) {
-    return;
-  }
-  SCqObj *pObj = handle;
-  SCqContext *pContext = pObj->pContext;
-  int32_t delete = 0;
-
-  pthread_mutex_lock(&pContext->mutex);
-  
-  // free the resources associated
-  if (pObj->pStream) {
-    taos_close_stream(pObj->pStream);
-    pObj->pStream = NULL;
-  } else {
-    taosTmrStop(pObj->tmrId);
-    pObj->tmrId = 0;
-  }
-
-  cInfo("vgId:%d, id:%d CQ:%s is dropped", pContext->vgId, pObj->tid, pObj->sqlStr); 
-  tdFreeSchema(pObj->pSchema);
-  free(pObj->dstTable);
-  free(pObj->sqlStr);
-  free(pObj);
-
-  pContext->cqObjNum--;
-
-  if (pContext->cqObjNum <= 0 && pContext->delete) {
-    delete = 1;
-  }
-
-  pthread_mutex_unlock(&pContext->mutex);
-
-  if (delete) {
-    freeSCqContext(pContext);
-  }
-}
-
-
-void cqCreateRef() {
-  int32_t ref = atomic_load_32(&cqObjRef);
-  if (ref == -1) {
-    ref = taosOpenRef(4096, cqFree);
-
-    if (atomic_val_compare_exchange_32(&cqObjRef, -1, ref) != -1) {
-      taosCloseRef(ref);
-    }  
-  }
-}
-
-
-void *cqOpen(void *ahandle, const SCqCfg *pCfg) {
-  if (tsEnableStream == 0) {
-    return NULL;
-  }
-  SCqContext *pContext = calloc(sizeof(SCqContext), 1);
-  if (pContext == NULL) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    return NULL;
-  }
-
-  atomic_add_fetch_32(&cqVnodeNum, 1);
-  
-  cqCreateRef();
-
-  pContext->tmrCtrl = taosTmrInit(0, 0, 0, "CQ");
-
-  tstrncpy(pContext->user, pCfg->user, sizeof(pContext->user));
-  tstrncpy(pContext->pass, pCfg->pass, sizeof(pContext->pass));
-  const char* db = pCfg->db;
-  for (const char* p = db; *p != 0; p++) {
-    if (*p == '.') {
-      db = p + 1;
-      break;
-    }
-  }
-  tstrncpy(pContext->db, db, sizeof(pContext->db));
-  pContext->vgId = pCfg->vgId;
-  pContext->cqWrite = pCfg->cqWrite;
-  tscEmbedded = 1;
-
-  pthread_mutex_init(&pContext->mutex, NULL);
-
-
-  cDebug("vgId:%d, CQ is opened", pContext->vgId);
-
-  return pContext;
-}
-
-
-void cqClose(void *handle) {
-  if (tsEnableStream == 0) {
-    return;
-  }
-  SCqContext *pContext = handle;
-  if (handle == NULL) return;
-
-  pContext->delete = 1;
-  int32_t hasCq = 0;
-  int32_t existLoop = 0;
-
-  // stop all CQs
-  cqStop(pContext);
-
-  int64_t rid = 0;
-
-  while (1) {
-    pthread_mutex_lock(&pContext->mutex);
-
-    SCqObj *pObj = pContext->pHead;
-    if (pObj) {
-      cqRmFromList(pObj);
-
-      rid = pObj->rid;
-
-      hasCq = 1;
-
-      if (pContext->pHead == NULL) {
-        existLoop = 1;
-      }
-    } else {
-      pthread_mutex_unlock(&pContext->mutex);
-      break;
-    }
-    
-    pthread_mutex_unlock(&pContext->mutex);
-    
-    taosRemoveRef(cqObjRef, rid);
-
-    if (existLoop) {
-      break;
-    }
-  }
-
-  if (hasCq == 0) {
-    freeSCqContext(pContext);
-  }
-
-  int32_t remainn = atomic_sub_fetch_32(&cqVnodeNum, 1);
-  if (remainn <= 0) {
-    int32_t ref = cqObjRef;
-    cqObjRef = -1;    
-    taosCloseRef(ref);
-  }
-}
-
-void cqStart(void *handle) {
-  if (tsEnableStream == 0) {
-    return;
-  }
-  SCqContext *pContext = handle;
-  if (pContext->dbConn || pContext->master) return;
-
-  cDebug("vgId:%d, start all CQs", pContext->vgId);
-  pthread_mutex_lock(&pContext->mutex);
-
-  pContext->master = 1;
-
-  SCqObj *pObj = pContext->pHead;
-  while (pObj) {
-    cqCreateStream(pContext, pObj);
-    pObj = pObj->next;
-  }
-
-  pthread_mutex_unlock(&pContext->mutex);
-}
-
-void cqStop(void *handle) {
-  if (tsEnableStream == 0) {
-    return;
-  }
-
-  SCqContext *pContext = handle;
-  cDebug("vgId:%d, stop all CQs", pContext->vgId);
-  if (pContext->dbConn == NULL || pContext->master == 0) return;
-
-  pthread_mutex_lock(&pContext->mutex);
-
-  pContext->master = 0;
-  SCqObj *pObj = pContext->pHead;
-  while (pObj) {
-    if (pObj->pStream) {
-      taos_close_stream(pObj->pStream);
-      pObj->pStream = NULL;
-      cInfo("vgId:%d, id:%d CQ:%s is closed", pContext->vgId, pObj->tid, pObj->sqlStr);
-    } else {
-      taosTmrStop(pObj->tmrId);
-      pObj->tmrId = 0;
-    }
-    pObj = pObj->next;
-  }
-
-  if (pContext->dbConn) taos_close(pContext->dbConn);
-  pContext->dbConn = NULL;
-
-  pthread_mutex_unlock(&pContext->mutex);
-}
-
-void *cqCreate(void *handle, uint64_t uid, int32_t sid, const char* dstTable, char *sqlStr, STSchema *pSchema, int start) {
-  if (tsEnableStream == 0) {
-    return NULL;
-  }
-  SCqContext *pContext = handle;
-  int64_t rid = 0;
-
-  pthread_mutex_lock(&pContext->mutex);
-
-  SCqObj *pObj = pContext->pHead;
-  while (pObj) {
-    if (pObj->uid == uid) {
-      rid = pObj->rid;
-      pthread_mutex_unlock(&pContext->mutex);
-      return (void *)rid;
-    }
-    
-    pObj = pObj->next;
-  }
-  
-  pthread_mutex_unlock(&pContext->mutex);
-  
-  pObj = calloc(sizeof(SCqObj), 1);
-  if (pObj == NULL) return NULL;
-
-  pObj->uid = uid;
-  pObj->tid = sid;
-  if (dstTable != NULL) {
-    pObj->dstTable = strdup(dstTable);
-  }
-  pObj->sqlStr = strdup(sqlStr);
-
-  pObj->pSchema = tdDupSchema(pSchema);
-  pObj->rowSize = schemaTLen(pSchema);
-
-  cInfo("vgId:%d, id:%d CQ:%s is created", pContext->vgId, pObj->tid, pObj->sqlStr);
-
-  pthread_mutex_lock(&pContext->mutex);
-
-  pObj->next = pContext->pHead;
-  if (pContext->pHead) pContext->pHead->prev = pObj;
-  pContext->pHead = pObj;
-
-  pContext->cqObjNum++;
-
-  pObj->rid = taosAddRef(cqObjRef, pObj);
-
-  if(start && pContext->master) {
-    cqCreateStream(pContext, pObj);
-  } else {
-    pObj->pContext = pContext;
-  }
-
-  rid = pObj->rid;
-
-  pthread_mutex_unlock(&pContext->mutex);
-
-
-  return (void *)rid;
-}
-
-void cqDrop(void *handle) {
-  if (tsEnableStream == 0) {
-    return;
-  }
-
-  SCqObj* pObj = (SCqObj*)taosAcquireRef(cqObjRef, (int64_t)handle);
-  if (pObj == NULL) {
-    return;
-  }
-  
-  SCqContext *pContext = pObj->pContext;
-  
-  pthread_mutex_lock(&pContext->mutex);
-
-  cqRmFromList(pObj);
-  
-  // free the resources associated
-  if (pObj->pStream) {
-    taos_close_stream(pObj->pStream);
-    pObj->pStream = NULL;
-  } else {
-    taosTmrStop(pObj->tmrId);
-    pObj->tmrId = 0;
-  }
-
-  pthread_mutex_unlock(&pContext->mutex);
-
-  taosRemoveRef(cqObjRef, (int64_t)handle);
-  taosReleaseRef(cqObjRef, (int64_t)handle);
-}
-
-static void doCreateStream(void *param, TAOS_RES *result, int32_t code) {
-  SCqObj* pObj = (SCqObj*)taosAcquireRef(cqObjRef, (int64_t)param);
-  if (pObj == NULL) {
-    return;
-  }
-
-  SCqContext* pContext = pObj->pContext;
-  SSqlObj* pSql = (SSqlObj*)result;  
-  if (code == TSDB_CODE_SUCCESS) {
-    if (atomic_val_compare_exchange_ptr(&(pContext->dbConn), NULL, pSql->pTscObj) != NULL) {
-      taos_close(pSql->pTscObj);
-    }
-  }
-  
-  pthread_mutex_lock(&pContext->mutex);
-  cqCreateStream(pContext, pObj);
-  pthread_mutex_unlock(&pContext->mutex);
-
-  taosReleaseRef(cqObjRef, (int64_t)param);
-}
-
-static void cqProcessCreateTimer(void *param, void *tmrId) {
-  SCqObj* pObj = (SCqObj*)taosAcquireRef(cqObjRef, (int64_t)param);
-  if (pObj == NULL) {
-    return;
-  }
-  
-  SCqContext* pContext = pObj->pContext;
-
-  if (pContext->dbConn == NULL) {
-    cDebug("vgId:%d, try connect to TDengine", pContext->vgId);
-    taos_connect_a(NULL, pContext->user, pContext->pass, pContext->db, 0, doCreateStream, param, NULL);
-  } else {
-    pthread_mutex_lock(&pContext->mutex);
-    cqCreateStream(pContext, pObj);
-    pthread_mutex_unlock(&pContext->mutex);
-  }
-
-  taosReleaseRef(cqObjRef, (int64_t)param);
-}
-
-// inner implement in tscStream.c
-TAOS_STREAM *taos_open_stream_withname(TAOS *taos, const char* desName, const char *sqlstr, void (*fp)(void *param, TAOS_RES *, TAOS_ROW row),
-                              int64_t stime, void *param, void (*callback)(void *), void* cqhandle);
-
-static void cqCreateStream(SCqContext *pContext, SCqObj *pObj) {
-  pObj->pContext = pContext;
-
-  if (pContext->dbConn == NULL) {
-    cDebug("vgId:%d, create dbConn after 1000 ms", pContext->vgId);
-    pObj->tmrId = taosTmrStart(cqProcessCreateTimer, 1000, (void *)pObj->rid, pContext->tmrCtrl);
-    return;
-  }
-
-  pObj->tmrId = 0;
-
-  if (pObj->pStream == NULL) {
-    pObj->pStream = taos_open_stream_withname(pContext->dbConn, pObj->dstTable, pObj->sqlStr, cqProcessStreamRes, \
-                                               INT64_MIN, (void *)pObj->rid, NULL, pContext);
-
-    // TODO the pObj->pStream may be released if error happens
-    if (pObj->pStream) {
-      pContext->num++;
-      cDebug("vgId:%d, id:%d CQ:%s is opened", pContext->vgId, pObj->tid, pObj->sqlStr);
-    } else {
-      cError("vgId:%d, id:%d CQ:%s, failed to open", pContext->vgId, pObj->tid, pObj->sqlStr);
-    }
-  }
-}
-
-static void cqProcessStreamRes(void *param, TAOS_RES *tres, TAOS_ROW row) {
-  SCqObj* pObj = (SCqObj*)taosAcquireRef(cqObjRef, (int64_t)param);
-  if (pObj == NULL) {
-    return;
-  }
-  
-  if (tres == NULL && row == NULL) {
-    taos_close_stream(pObj->pStream);
-
-    pObj->pStream = NULL;
-
-    taosReleaseRef(cqObjRef, (int64_t)param);
-
-    return;
-  }
-
-  SCqContext *pContext = pObj->pContext;
-  STSchema   *pSchema = pObj->pSchema;
-  if (pObj->pStream == NULL) {    
-    taosReleaseRef(cqObjRef, (int64_t)param);
-    return;
-  }
-  
-  cDebug("vgId:%d, id:%d CQ:%s stream result is ready", pContext->vgId, pObj->tid, pObj->sqlStr);
-
-  int32_t size = sizeof(SWalHead) + sizeof(SSubmitMsg) + sizeof(SSubmitBlk) + TD_MEM_ROW_DATA_HEAD_SIZE + pObj->rowSize;
-  char *buffer = calloc(size, 1);
-
-  SWalHead   *pHead = (SWalHead *)buffer;
-  SSubmitMsg *pMsg = (SSubmitMsg *) (buffer + sizeof(SWalHead));
-  SSubmitBlk *pBlk = (SSubmitBlk *) (buffer + sizeof(SWalHead) + sizeof(SSubmitMsg));
-
-  SMemRow trow = (SMemRow)pBlk->data;
-  SDataRow dataRow = (SDataRow)memRowDataBody(trow);
-  memRowSetType(trow, SMEM_ROW_DATA);
-  tdInitDataRow(dataRow, pSchema);
-
-  for (int32_t i = 0; i < pSchema->numOfCols; i++) {
-    STColumn *c = pSchema->columns + i;
-    void *val = row[i];
-    if (val == NULL) {
-      val = (void *)getNullValue(c->type);
-    } else if (c->type == TSDB_DATA_TYPE_BINARY) {
-      val = ((char*)val) - sizeof(VarDataLenT);
-    } else if (c->type == TSDB_DATA_TYPE_NCHAR) {
-      char buf[TSDB_MAX_NCHAR_LEN];
-      int32_t len = taos_fetch_lengths(tres)[i];
-      taosMbsToUcs4(val, len, buf, sizeof(buf), &len);
-      memcpy((char *)val + sizeof(VarDataLenT), buf, len);
-      varDataLen(val) = len;
-    }
-    tdAppendColVal(dataRow, val, c->type, c->offset);
-  }
-  pBlk->dataLen = htonl(memRowDataTLen(trow));
-  pBlk->schemaLen = 0;
-
-  pBlk->uid = htobe64(pObj->uid);
-  pBlk->tid = htonl(pObj->tid);
-  pBlk->numOfRows = htons(1);
-  pBlk->sversion = htonl(pSchema->version);
-  pBlk->padding = 0;
-
-  pHead->len = sizeof(SSubmitMsg) + sizeof(SSubmitBlk) + memRowDataTLen(trow);
-
-  pMsg->header.vgId = htonl(pContext->vgId);
-  pMsg->header.contLen = htonl(pHead->len);
-  pMsg->length = pMsg->header.contLen;
-  pMsg->numOfBlocks = htonl(1);
-
-  pHead->msgType = TDMT_VND_SUBMIT;
-  pHead->version = 0;
-
-  // write into vnode write queue
-  pContext->cqWrite(pContext->vgId, pHead, TAOS_QTYPE_CQ, NULL);
-  free(buffer);
-  
-  taosReleaseRef(cqObjRef, (int64_t)param);
-}
-

src/cq/test/CMakeLists.txt

-CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
-PROJECT(TDengine)
-
-LIST(APPEND CQTEST_SRC ./cqtest.c)
-ADD_EXECUTABLE(cqtest ${CQTEST_SRC})
-TARGET_LINK_LIBRARIES(cqtest tcq taos_static)

src/cq/test/cqtest.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/>.
- */
-
-//#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taosdef.h"
-#include "tmsg.h"
-#include "tglobal.h"
-#include "tlog.h"
-#include "tcq.h"
-
-int64_t  ver = 0;
-void    *pCq = NULL;
-
-int writeToQueue(int32_t vgId, void *data, int type, void *pMsg) { 
-  return 0;
-}
-
-int main(int argc, char *argv[]) {
-  int num = 3;
-
-  for (int i=1; i<argc; ++i) {
-    if (strcmp(argv[i], "-d")==0 && i < argc-1) {
-      dDebugFlag = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-n") == 0 && i <argc-1) {
-      num = atoi(argv[++i]);
-    } else {
-      printf("\nusage: %s [options] \n", argv[0]);
-      printf("  [-n num]: number of streams, default:%d\n", num);
-      printf("  [-d debugFlag]: debug flag, default:%d\n", dDebugFlag);
-      printf("  [-h help]: print out this help\n\n");
-      exit(0);
-    }
-  } 
-
-  taosInitLog("cq.log", 100000, 10);
-
-  SCqCfg cqCfg;
-  strcpy(cqCfg.user, TSDB_DEFAULT_USER);
-  strcpy(cqCfg.pass, TSDB_DEFAULT_PASS);
-  cqCfg.vgId = 2;
-  cqCfg.cqWrite = writeToQueue;
-
-  pCq = cqOpen(NULL, &cqCfg);
-  if (pCq == NULL) {
-    printf("failed to open CQ\n");
-    exit(-1);
-  }
-
-  STSchemaBuilder schemaBuilder = {0};
-
-  tdInitTSchemaBuilder(&schemaBuilder, 0);
-  tdAddColToSchema(&schemaBuilder, TSDB_DATA_TYPE_TIMESTAMP, 0, 8);
-  tdAddColToSchema(&schemaBuilder, TSDB_DATA_TYPE_INT, 1, 4);
-
-  STSchema *pSchema = tdGetSchemaFromBuilder(&schemaBuilder);
-
-  tdDestroyTSchemaBuilder(&schemaBuilder);
-
-  for (int sid =1; sid<10; ++sid) {
-    cqCreate(pCq, sid, sid, NULL, "select avg(speed) from demo.t1 sliding(1s) interval(5s)", pSchema, 1);
-  }
-
-  tdFreeSchema(pSchema);
-
-  while (1) {
-    char c = (char)getchar();
-    
-    switch(c) {
-      case 's':
-        cqStart(pCq);
-        break;
-      case 't':
-        cqStop(pCq);
-        break;
-      case 'c':
-        // create a CQ 
-        break;
-      case 'd':
-        // drop a CQ
-        break;
-      case 'q':
-        break;
-      default:
-        printf("invalid command:%c", c);
-    }
-
-    if (c=='q') break;
-  }
-
-  cqClose(pCq);
-
-  taosCloseLog();
-
-  return 0;
-}

src/inc/query.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 TDENGINE_QUERY_H
-#define TDENGINE_QUERY_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef void* qinfo_t;
-
-/**
- * create the qinfo object according to QueryTableMsg
- * @param tsdb
- * @param pQueryTableMsg
- * @param qinfo
- * @return
- */
-int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryTableMsg, qinfo_t* qinfo, uint64_t qId);
-
-
-/**
- * the main query execution function, including query on both table and multitables,
- * which are decided according to the tag or table name query conditions
- *
- * @param qinfo
- * @return
- */
-bool qTableQuery(qinfo_t qinfo, uint64_t *qId);
-
-/**
- * Retrieve the produced results information, if current query is not paused or completed,
- * this function will be blocked to wait for the query execution completed or paused,
- * in which case enough results have been produced already.
- *
- * @param qinfo
- * @return
- */
-int32_t qRetrieveQueryResultInfo(qinfo_t qinfo, bool* buildRes, void* pRspContext);
-
-/**
- *
- * Retrieve the actual results to fill the response message payload.
- * Note that this function must be executed after qRetrieveQueryResultInfo is invoked.
- *
- * @param qinfo  qinfo object
- * @param pRsp    response message
- * @param contLen payload length
- * @return
- */
-int32_t qDumpRetrieveResult(qinfo_t qinfo, SRetrieveTableRsp** pRsp, int32_t* contLen, bool* continueExec);
-
-/**
- *
- * @param qinfo
- * @return
- */
-void* qGetResultRetrieveMsg(qinfo_t qinfo);
-
-/**
- * kill current ongoing query and free query handle automatically
- * @param qinfo  qhandle
- * @return
- */
-int32_t qKillQuery(qinfo_t qinfo);
-
-//kill by qid 
-int32_t qKillQueryByQId(void* pMgmt, int64_t qId, int32_t waitMs, int32_t waitCount);
-
-bool qSolveCommitNoBlock(void* pRepo, void* pMgmt);
-
-int32_t qQueryCompleted(qinfo_t qinfo);
-
-/**
- * destroy query info structure
- * @param qHandle
- */
-void qDestroyQueryInfo(qinfo_t qHandle);
-
-void* qOpenQueryMgmt(int32_t vgId);
-void  qQueryMgmtNotifyClosed(void* pExecutor);
-void  qQueryMgmtReOpen(void *pExecutor);
-void  qCleanupQueryMgmt(void* pExecutor);
-void** qRegisterQInfo(void* pMgmt, uint64_t qId, void *qInfo);
-void** qAcquireQInfo(void* pMgmt, uint64_t key);
-void** qReleaseQInfo(void* pMgmt, void* pQInfo, bool freeHandle);
-bool checkQIdEqual(void *qHandle, uint64_t qId);
-int64_t genQueryId(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // TDENGINE_QUERY_H

src/inc/tcq.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_CQ_H_
-#define _TD_CQ_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "tdataformat.h"
-
-typedef int32_t (*FCqWrite)(int32_t vgId, void *pHead, int32_t qtype, void *pMsg);
-
-typedef struct {
-  int32_t  vgId;
-  char     user[TSDB_USER_LEN];
-  char     pass[TSDB_PASSWORD_LEN];
-  char     db[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN]; // size must same with SVnodeObj.db[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN]
-  FCqWrite cqWrite;
-} SCqCfg;
-
-// SCqContext
-typedef struct {
-  int32_t  vgId;
-  int32_t  master;
-  int32_t  num;      // number of continuous streams
-  char     user[TSDB_USER_LEN];
-  char     pass[TSDB_PASSWORD_LEN];
-  char     db[TSDB_DB_NAME_LEN];
-  FCqWrite cqWrite;
-  struct SCqObj *pHead;
-  void    *dbConn;
-  void    *tmrCtrl;
-  pthread_mutex_t mutex;
-  int32_t delete;
-  int32_t cqObjNum;
-} SCqContext;
-
-// the following API shall be called by vnode
-void *cqOpen(void *ahandle, const SCqCfg *pCfg);
-void  cqClose(void *handle);
-
-// if vnode is master, vnode call this API to start CQ
-void  cqStart(void *handle);
-
-// if vnode is slave/unsynced, vnode shall call this API to stop CQ
-void  cqStop(void *handle);
-
-// cqCreate is called by TSDB to start an instance of CQ 
-void *cqCreate(void *handle, uint64_t uid, int32_t sid, const char* dstTable, char *sqlStr, STSchema *pSchema, int start);
-
-// cqDrop is called by TSDB to stop an instance of CQ, handle is the return value of cqCreate
-void  cqDrop(void *handle);
-
-extern int32_t cqDebugFlag;
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // _TD_CQ_H_

src/inc/tsdb.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_TSDB_H_
-#define _TD_TSDB_H_
-
-#include <pthread.h>
-#include <stdbool.h>
-#include <stdint.h>
-
-#include "taosdef.h"
-#include "tmsg.h"
-#include "tarray.h"
-#include "tdataformat.h"
-#include "tname.h"
-#include "hash.h"
-#include "tlockfree.h"
-#include "tlist.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define TSDB_VERSION_MAJOR 1
-#define TSDB_VERSION_MINOR 0
-
-#define TSDB_INVALID_SUPER_TABLE_ID -1
-
-#define TSDB_STATUS_COMMIT_START 1
-#define TSDB_STATUS_COMMIT_OVER 2
-#define TSDB_STATUS_COMMIT_NOBLOCK 3 //commit no block, need to be solved 
-
-// TSDB STATE DEFINITION
-#define TSDB_STATE_OK 0x0
-#define TSDB_STATE_BAD_META 0x1
-#define TSDB_STATE_BAD_DATA 0x2
-
-// --------- TSDB APPLICATION HANDLE DEFINITION
-typedef struct {
-  void *appH;
-  void *cqH;
-  int (*notifyStatus)(void *, int status, int eno);
-  int (*eventCallBack)(void *);
-  void *(*cqCreateFunc)(void *handle, uint64_t uid, int32_t sid, const char *dstTable, char *sqlStr, STSchema *pSchema, int start);
-  void (*cqDropFunc)(void *handle);
-} STsdbAppH;
-
-// --------- TSDB REPOSITORY CONFIGURATION DEFINITION
-typedef struct {
-  int32_t tsdbId;
-  int32_t cacheBlockSize;
-  int32_t totalBlocks;
-  int32_t daysPerFile;  // day per file sharding policy
-  int32_t keep;         // day of data to keep
-  int32_t keep1;
-  int32_t keep2;
-  int32_t minRowsPerFileBlock;  // minimum rows per file block
-  int32_t maxRowsPerFileBlock;  // maximum rows per file block
-  int8_t  precision;
-  int8_t  compression;
-  int8_t  update;
-  int8_t  cacheLastRow;    // 0:no cache, 1: cache last row, 2: cache last NULL column 3: 1&2
-} STsdbCfg;
-
-#define CACHE_NO_LAST(c)          ((c)->cacheLastRow == 0)
-#define CACHE_LAST_ROW(c)         (((c)->cacheLastRow & 1) > 0)
-#define CACHE_LAST_NULL_COLUMN(c) (((c)->cacheLastRow & 2) > 0)
-
-// --------- TSDB REPOSITORY USAGE STATISTICS
-typedef struct {
-  int64_t totalStorage;  // total bytes occupie
-  int64_t compStorage;
-  int64_t pointsWritten;  // total data points written
-} STsdbStat;
-
-typedef struct STsdbRepo STsdbRepo;
-
-STsdbCfg *tsdbGetCfg(const STsdbRepo *repo);
-
-// --------- TSDB REPOSITORY DEFINITION
-int32_t    tsdbCreateRepo(int repoid);
-int32_t    tsdbDropRepo(int repoid);
-STsdbRepo *tsdbOpenRepo(STsdbCfg *pCfg, STsdbAppH *pAppH);
-int        tsdbCloseRepo(STsdbRepo *repo, int toCommit);
-int32_t    tsdbConfigRepo(STsdbRepo *repo, STsdbCfg *pCfg);
-int        tsdbGetState(STsdbRepo *repo);
-int8_t     tsdbGetCompactState(STsdbRepo *repo);
-// --------- TSDB TABLE DEFINITION
-typedef struct {
-  uint64_t uid;  // the unique table ID
-  int32_t  tid;  // the table ID in the repository.
-} STableId;
-
-// --------- TSDB TABLE configuration
-typedef struct {
-  ETableType type;
-  char *     name;
-  STableId   tableId;
-  int32_t    sversion;
-  char *     sname;  // super table name
-  uint64_t   superUid;
-  STSchema * schema;
-  STSchema * tagSchema;
-  SKVRow     tagValues;
-  char *     sql;
-} STableCfg;
-
-void tsdbClearTableCfg(STableCfg *config);
-
-void *tsdbGetTableTagVal(const void *pTable, int32_t colId, int16_t type, int16_t bytes);
-char *tsdbGetTableName(void *pTable);
-
-#define TSDB_TABLEID(_table) ((STableId*) (_table))
-#define TSDB_PREV_ROW  0x1
-#define TSDB_NEXT_ROW  0x2
-
-STableCfg *tsdbCreateTableCfgFromMsg(SMDCreateTableMsg *pMsg);
-
-int tsdbCreateTable(STsdbRepo *repo, STableCfg *pCfg);
-int tsdbDropTable(STsdbRepo *pRepo, STableId tableId);
-int tsdbUpdateTableTagValue(STsdbRepo *repo, SUpdateTableTagValMsg *pMsg);
-
-uint32_t tsdbGetFileInfo(STsdbRepo *repo, char *name, uint32_t *index, uint32_t eindex, int64_t *size);
-
-// the TSDB repository info
-typedef struct STsdbRepoInfo {
-  STsdbCfg tsdbCfg;
-  uint64_t version;            // version of the repository
-  int64_t  tsdbTotalDataSize;  // the original inserted data size
-  int64_t  tsdbTotalDiskSize;  // the total disk size taken by this TSDB repository
-  // TODO: Other informations to add
-} STsdbRepoInfo;
-STsdbRepoInfo *tsdbGetStatus(STsdbRepo *pRepo);
-
-// the meter information report structure
-typedef struct {
-  STableCfg tableCfg;
-  uint64_t  version;
-  int64_t   tableTotalDataSize;  // In bytes
-  int64_t   tableTotalDiskSize;  // In bytes
-} STableInfo;
-
-// -- FOR INSERT DATA
-/**
- * Insert data to a table in a repository
- * @param pRepo the TSDB repository handle
- * @param pData the data to insert (will give a more specific description)
- *
- * @return the number of points inserted, -1 for failure and the error number is set
- */
-int32_t tsdbInsertData(STsdbRepo *repo, SSubmitMsg *pMsg, SShellSubmitRspMsg *pRsp);
-
-// -- FOR QUERY TIME SERIES DATA
-
-typedef void *TsdbQueryHandleT;  // Use void to hide implementation details
-
-#define BLOCK_LOAD_OFFSET_SEQ_ORDER   1
-#define BLOCK_LOAD_TABLE_SEQ_ORDER    2
-#define BLOCK_LOAD_TABLE_RR_ORDER     3
-
-// query condition to build multi-table data block iterator
-typedef struct STsdbQueryCond {
-  STimeWindow  twindow;
-  int32_t      order;             // desc|asc order to iterate the data block
-  int32_t      numOfCols;
-  SColumnInfo *colList;
-  bool         loadExternalRows;  // load external rows or not
-  int32_t      type;              // data block load type:
-} STsdbQueryCond;
-
-typedef struct STableData STableData;
-typedef struct {
-  T_REF_DECLARE()
-  SRWLatch     latch;
-  TSKEY        keyFirst;
-  TSKEY        keyLast;
-  int64_t      numOfRows;
-  int32_t      maxTables;
-  STableData **tData;
-  SList *      actList;
-  SList *      extraBuffList;
-  SList *      bufBlockList;
-  int64_t      pointsAdd;   // TODO
-  int64_t      storageAdd;  // TODO
-} SMemTable;
-
-typedef struct {
-  SMemTable* mem;
-  SMemTable* imem;
-  SMemTable  mtable;
-  SMemTable* omem;
-} SMemSnapshot;
-
-typedef struct SMemRef {
-  int32_t      ref;
-  SMemSnapshot snapshot;
-} SMemRef;
-
-typedef struct SDataBlockInfo {
-  STimeWindow window;
-  int32_t     rows;
-  int32_t     numOfCols;
-  int64_t     uid;
-  int32_t     tid;
-} SDataBlockInfo;
-
-typedef struct SFileBlockInfo {
-  int32_t numBlocksOfStep;
-} SFileBlockInfo;
-
-typedef struct {
-  void *pTable;
-  TSKEY lastKey;
-} STableKeyInfo;
-
-typedef struct {
-  uint32_t  numOfTables;
-  SArray   *pGroupList;
-  SHashObj *map;  // speedup acquire the tableQueryInfo by table uid
-} STableGroupInfo;
-
-#define TSDB_BLOCK_DIST_STEP_ROWS 16
-typedef struct {
-  uint16_t  rowSize;
-  uint16_t  numOfFiles;
-  uint32_t  numOfTables;
-  uint64_t  totalSize;
-  uint64_t  totalRows;
-  int32_t   maxRows;
-  int32_t   minRows;
-  int32_t   firstSeekTimeUs;
-  uint32_t  numOfRowsInMemTable;
-  uint32_t  numOfSmallBlocks;
-  SArray   *dataBlockInfos;
-} STableBlockDist;
-
-/**
- * Get the data block iterator, starting from position according to the query condition
- *
- * @param tsdb       tsdb handle
- * @param pCond      query condition, including time window, result set order, and basic required columns for each block
- * @param tableInfoGroup  table object list in the form of set, grouped into different sets according to the
- *                        group by condition
- * @param qinfo      query info handle from query processor
- * @return
- */
-TsdbQueryHandleT *tsdbQueryTables(STsdbRepo *tsdb, STsdbQueryCond *pCond, STableGroupInfo *tableInfoGroup, uint64_t qId,
-                                  SMemRef *pRef);
-
-/**
- * Get the last row of the given query time window for all the tables in STableGroupInfo object.
- * Note that only one data block with only row will be returned while invoking retrieve data block function for
- * all tables in this group.
- *
- * @param tsdb   tsdb handle
- * @param pCond  query condition, including time window, result set order, and basic required columns for each block
- * @param tableInfo  table list.
- * @return
- */
-TsdbQueryHandleT tsdbQueryLastRow(STsdbRepo *tsdb, STsdbQueryCond *pCond, STableGroupInfo *tableInfo, uint64_t qId,
-                                  SMemRef *pRef);
-
-
-TsdbQueryHandleT tsdbQueryCacheLast(STsdbRepo *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList, uint64_t qId, SMemRef* pMemRef);
-
-bool isTsdbCacheLastRow(TsdbQueryHandleT* pTsdbReadHandle);
-
-
-/**
- * get the queried table object list
- * @param pHandle
- * @return
- */
-SArray *tsdbGetQueriedTableList(TsdbQueryHandleT *pHandle);
-
-/**
- * get the group list according to table id from client
- * @param tsdb
- * @param pCond
- * @param groupList
- * @param qinfo
- * @return
- */
-TsdbQueryHandleT tsdbQueryRowsInExternalWindow(STsdbRepo *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList,
-                                               uint64_t qId, SMemRef *pRef);
-
-
-/**
- * get num of rows in mem table 
- *
- * @param pHandle
- * @return row size
- */
-
-int64_t tsdbGetNumOfRowsInMemTable(TsdbQueryHandleT* pHandle);
-
-/**
- * move to next block if exists 
- *
- * @param pTsdbReadHandle
- * @return
- */
-bool tsdbNextDataBlock(TsdbQueryHandleT pTsdbReadHandle);
-
-/**
- * Get current data block information
- *
- * @param pTsdbReadHandle
- * @param pBlockInfo
- * @return
- */
-void tsdbRetrieveDataBlockInfo(TsdbQueryHandleT *pTsdbReadHandle, SDataBlockInfo *pBlockInfo);
-
-/**
- *
- * Get the pre-calculated information w.r.t. current data block.
- *
- * In case of data block in cache, the pBlockStatis will always be NULL.
- * If a block is not completed loaded from disk, the pBlockStatis will be NULL.
-
- * @pBlockStatis the pre-calculated value for current data blocks. if the block is a cache block, always return 0
- * @return
- */
-int32_t tsdbRetrieveDataBlockStatisInfo(TsdbQueryHandleT *pTsdbReadHandle, SDataStatis **pBlockStatis);
-
-/**
- *
- * The query condition with primary timestamp is passed to iterator during its constructor function,
- * the returned data block must be satisfied with the time window condition in any cases,
- * which means the SData data block is not actually the completed disk data blocks.
- *
- * @param pTsdbReadHandle      query handle
- * @param pColumnIdList     required data columns id list
- * @return
- */
-SArray *tsdbRetrieveDataBlock(TsdbQueryHandleT *pTsdbReadHandle, SArray *pColumnIdList);
-
-/**
- * Get the qualified table id for a super table according to the tag query expression.
- * @param stableid. super table sid
- * @param pTagCond. tag query condition
- */
-int32_t tsdbQuerySTableByTagCond(STsdbRepo *tsdb, uint64_t uid, TSKEY key, const char *pTagCond, size_t len,
-                                 int16_t tagNameRelType, const char *tbnameCond, STableGroupInfo *pGroupList,
-                                 SColIndex *pColIndex, int32_t numOfCols);
-
-/**
- * destroy the created table group list, which is generated by tag query
- * @param pGroupList
- */
-void tsdbDestroyTableGroup(STableGroupInfo *pGroupList);
-
-/**
- * create the table group result including only one table, used to handle the normal table query
- *
- * @param tsdb        tsdbHandle
- * @param uid         table uid
- * @param pGroupInfo  the generated result
- * @return
- */
-int32_t tsdbGetOneTableGroup(STsdbRepo *tsdb, uint64_t uid, TSKEY startKey, STableGroupInfo *pGroupInfo);
-
-/**
- *
- * @param tsdb
- * @param pTableIdList
- * @param pGroupInfo
- * @return
- */
-int32_t tsdbGetTableGroupFromIdList(STsdbRepo *tsdb, SArray *pTableIdList, STableGroupInfo *pGroupInfo);
-
-/**
- * clean up the query handle
- * @param queryHandle
- */
-void tsdbCleanupQueryHandle(TsdbQueryHandleT queryHandle);
-
-void tsdbResetQueryHandle(TsdbQueryHandleT queryHandle, STsdbQueryCond *pCond);
-
-void tsdbResetQueryHandleForNewTable(TsdbQueryHandleT queryHandle, STsdbQueryCond *pCond, STableGroupInfo* groupList);
-
-int32_t tsdbGetFileBlocksDistInfo(TsdbQueryHandleT* queryHandle, STableBlockDist* pTableBlockInfo);
-
-/**
- * get the statistics of repo usage
- * @param repo. point to the tsdbrepo
- * @param totalPoints. total data point written
- * @param totalStorage. total bytes took by the tsdb
- * @param compStorage. total bytes took by the tsdb after compressed
- */
-void tsdbReportStat(void *repo, int64_t *totalPoints, int64_t *totalStorage, int64_t *compStorage);
-
-int  tsdbInitCommitQueue();
-void tsdbDestroyCommitQueue();
-int  tsdbSyncCommit(STsdbRepo *repo);
-void tsdbIncCommitRef(int vgId);
-void tsdbDecCommitRef(int vgId);
-
-// For TSDB file sync
-int tsdbSyncSend(void *pRepo, SOCKET socketFd);
-int tsdbSyncRecv(void *pRepo, SOCKET socketFd);
-
-// For TSDB Compact
-int tsdbCompact(STsdbRepo *pRepo);
-
-// For TSDB Health Monitor
-
-// no problem return true
-bool tsdbNoProblem(STsdbRepo* pRepo);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // _TD_TSDB_H_

tests/script/sh/massiveTable/deployCluster.sh

@@ -53,22 +53,22 @@ curr_dir=$(readlink -f "$(dirname "$0")")
 echo $curr_dir
 
 ${curr_dir}/cleanCluster.sh -r "/data"
-${curr_dir}/cleanCluster.sh -r "/data2"
+#${curr_dir}/cleanCluster.sh -r "/data2"
 
 if [[ "${updateSrc}" == "yes" ]]; then
   ${curr_dir}/compileVersion.sh -r ${curr_dir}/../../../../ -v "3.0"
 fi
 
 ${curr_dir}/setupDnodes.sh -r "/data"  -n ${dnodeNumber} -f ${firstEp} -p 7000
-${curr_dir}/setupDnodes.sh -r "/data2" -n ${dnodeNumber} -f ${firstEp} -p 8000
+#${curr_dir}/setupDnodes.sh -r "/data2" -n ${dnodeNumber} -f ${firstEp} -p 8000
 
 if [[ "${masterDnode}" == "master" ]]; then
   # create all dnode into cluster
-  taos -s "create dnode trd02 port 8000;"
+  #taos -s "create dnode trd02 port 8000;"
   taos -s "create dnode trd03 port 7000;"
-  taos -s "create dnode trd03 port 8000;"
+  #taos -s "create dnode trd03 port 8000;"
   taos -s "create dnode trd04 port 7000;"
-  taos -s "create dnode trd04 port 8000;"
+  #taos -s "create dnode trd04 port 8000;"
 fi
 
 

tests/script/sim/db/basic1.sim

@@ -4,7 +4,7 @@ system sh/exec.sh -n dnode1 -s start
 sql connect
 
 print =============== create database
-sql create database d1
+sql create database d1 vgroups 2
 sql show databases
 if $rows != 1 then 
   return -1
@@ -22,6 +22,21 @@ if $data03 != 0 then
   return -1
 endi
 
+print =============== show vgroups1
+sql use d1
+sql show vgroups
+if $rows != 2 then 
+  return -1
+endi
+
+if $data00 != 2 then 
+  return -1
+endi
+
+if $data10 != 3 then 
+  return -1
+endi
+
 print =============== drop database
 sql drop database d1
 sql show databases
@@ -30,14 +45,68 @@ if $rows != 0 then
 endi
 
 print =============== more databases
-sql create database d2
-sql create database d3
-sql create database d4
+sql create database d2 vgroups 2
+sql create database d3 vgroups 3
+sql create database d4 vgroups 4
 sql show databases
 if $rows != 3 then 
   return -1
 endi
 
+print =============== show vgroups2
+sql show d2.vgroups
+if $rows != 2 then
+  return -1
+endi
+
+if $data00 != 4 then 
+  return -1
+endi
+
+if $data10 != 5 then 
+  return -1
+endi
+
+print =============== show vgroups3
+sql show d3.vgroups
+if $rows != 3 then
+  return -1
+endi
+
+if $data00 != 6 then 
+  return -1
+endi
+
+if $data10 != 7 then 
+  return -1
+endi
+
+if $data20 != 8 then 
+  return -1
+endi
+
+print =============== show vgroups4
+sql show d4.vgroups
+if $rows != 4 then
+  return -1
+endi
+
+if $data00 != 9 then 
+  return -1
+endi
+
+if $data10 != 10 then 
+  return -1
+endi
+
+if $data20 != 11 then 
+  return -1
+endi
+
+if $data30 != 12 then 
+  return -1
+endi
+
 print =============== drop database
 sql drop database d2
 sql drop database d3
@@ -50,7 +119,7 @@ if $data00 != d4 then
   return -1
 endi
 
-if $data02 != 2 then 
+if $data02 != 4 then 
   return -1
 endi
 
@@ -58,19 +127,12 @@ if $data03 != 0 then
   return -1
 endi
 
-print =============== show vgroups
-sql show databases
-
-if $rows != 1 then 
-  return -1
-endi
-
+print =============== show vgroups4 again
 sql_error use d1
 
 sql use d4
 sql show vgroups
-
-if $rows != 2 then
+if $rows != 4 then
   return -1
 endi
 
@@ -81,15 +143,17 @@ if $data00 != 1 then
   return -1
 endi
 
-if $data02 != 2 then
+if $data02 != 4 then
   return -1
 endi
 
+print =============== restart
+
 system sh/exec.sh -n dnode1 -s stop -x SIGKILL
 system sh/exec.sh -n dnode1 -s start
 
+print =============== show databases
 sql show databases
-
 if $rows != 1 then 
   return -1
 endi
@@ -99,7 +163,27 @@ sql_error use d1
 sql use d4
 sql show vgroups
 
-if $rows != 2 then
+if $rows != 4 then
+  return -1
+endi
+
+print =============== create databases
+sql create database d5 vgroups 5;
+
+print =============== show vgroups
+sql use d5
+sql show vgroups
+if $rows != 5 then
+  return -1
+endi
+
+sql show d4.vgroups
+if $rows != 4 then
+  return -1
+endi
+
+sql show d5.vgroups
+if $rows != 5 then
   return -1
 endi
 

tests/script/sim/db/basic6.sim

@@ -7,8 +7,10 @@ print ============================ dnode1 start
 
 $i = 0
 $dbPrefix = db
+$stPrefix = st
 $tbPrefix = tb
 $db = $dbPrefix . $i
+$st = $stPrefix . $i
 $tb = $tbPrefix . $i
 
 print =============== step1
@@ -68,12 +70,47 @@ if $data06 != 15 then
   return -1
 endi
 
+return
+
 print =============== step6
 $i = $i + 1
 while $i < 5
   $db = $dbPrefix . $i
+  $st = $stPrefix . $i
+  $tb = $tbPrefix . $i
+
+  print create database $db
   sql create database $db
+
+  print use $db
   sql use $db
+
+  print create table $st (ts timestamp, i int) tags (j int)
+  sql create table $st (ts timestamp, i int) tags (j int)
+
+  print create table $tb using $st tags(1)
+  sql create table $tb using $st tags(1)
+
+  sql show stables
+  if $rows != 1 then 
+    return -1
+  endi
+
+  print $data00 $data01 $data02 $data03
+  if $data00 != $st then 
+    return -1
+  endi
+
+  sql show tables
+  if $rows != 1 then 
+    return -1
+  endi
+
+  print $data00 $data01 $data02 $data03
+  if $data00 != $tb then 
+    return -1
+  endi
+
   $i = $i + 1
 endw
 
@@ -86,93 +123,179 @@ while $i < 5
 endw
 
 print =============== step8
-$i = 0
+$i = 1
 $db = $dbPrefix . $i
+$st = $stPrefix . $i
 $tb = $tbPrefix . $i
 sql create database $db
 sql use $db
-sql create table st (ts timestamp, i int) tags (j int)
-sql create table $tb using st tags(1)
+sql create table $st (ts timestamp, i int) tags (j int)
+sql create table $tb using $st tags(1)
 
-return 
-system sh/exec.sh -n dnode1 -s stop -x SIGINT
+sql show stables
+if $rows != 1 then 
+  return -1
+endi
+
+if $data00 != $st then 
+  return -1
+endi
 
 sql show tables
 if $rows != 1 then 
   return -1
 endi
 
+if $data00 != $tb then 
+  return -1
+endi
+
 print =============== step9
 sql drop database $db
 
 print =============== step10
 sql create database $db
 sql use $db
+
+sql show stables
+if $rows != 0 then 
+  return -1
+endi
+
 sql show tables
 if $rows != 0 then 
   return -1
 endi
 
 print =============== step11
-sql create table st (ts timestamp, i int) tags (j int)
-sql create table $tb using st tags(1)
+sql create table $st (ts timestamp, i int) tags (j int)
+sql create table $tb using $st tags(1)
+
+sql show stables
+if $rows != 1 then 
+  return -1
+endi
+
+if $data00 != $st then 
+  return -1
+endi
+
 sql show tables
 if $rows != 1 then 
   return -1
 endi
 
+if $data00 != $tb then 
+  return -1
+endi
+
 print =============== step12
 sql drop database $db
 
 print =============== step13
 sql create database $db
 sql use $db
+
+sql show stables
+if $rows != 0 then 
+  return -1
+endi
+
 sql show tables
 if $rows != 0 then 
   return -1
 endi
 
-sql create table st (ts timestamp, i int) tags (j int)
-sql create table $tb using st tags(1)
+print ============== step14
+sql create table $st (ts timestamp, i int) tags (j int)
+sql create table $tb using $st tags(1)
+
+sql show stables
+if $rows != 1 then 
+  return -1
+endi
+
+if $data00 != $st then 
+  return -1
+endi
+
 sql show tables
 if $rows != 1 then 
   return -1
 endi
 
+if $data00 != $tb then 
+  return -1
+endi
+
 sql insert into $tb values (now+1a, 0)
 sql insert into $tb values (now+2a, 1)
 sql insert into $tb values (now+3a, 2)
 sql insert into $tb values (now+4a, 3)
 sql insert into $tb values (now+5a, 4)
 
-
-return 
-
 sql select * from $tb
 if $rows != 5 then 
   return -1
 endi
 
+sql select * from $stb
+if $rows != 5 then 
+  return -1
+endi
+
 print =============== step14
 sql drop database $db
 
 print =============== step15
 sql create database $db
 sql use $db
+
+sql show stables
+if $rows != 0 then 
+  return -1
+endi
+
 sql show tables
 if $rows != 0 then 
   return -1
 endi
 
 print =============== step16
-sql create table st (ts timestamp, i int) tags (j int)
-sql create table $tb using st tags(1)
+sql create table $st (ts timestamp, i int) tags (j int)
+sql create table $tb using $st tags(1)
+
+sql show stables
+if $rows != 1 then 
+  return -1
+endi
+
+if $data00 != $st then 
+  return -1
+endi
+
 sql show tables
 if $rows != 1 then 
   return -1
 endi
+
+if $data00 != $tb then 
+  return -1
+endi
+
+sql insert into $tb values (now+1a, 0)
+sql insert into $tb values (now+2a, 1)
+sql insert into $tb values (now+3a, 2)
+sql insert into $tb values (now+4a, 3)
+sql insert into $tb values (now+5a, 4)
+
 sql select * from $tb
-if $rows != 0 then 
+if $rows != 5 then 
+  return -1
+endi
+
+sql select * from $stb
+if $rows != 5 then 
   return -1
 endi
 

tests/script/sim/dnode/basic1.sim

@@ -78,8 +78,8 @@ if $data02 != master then
   return -1
 endi
 
-print =============== create table
-sql create database d1;
+print =============== create database
+sql create database d1 vgroups 4;
 sql create database d2;
 
 sql show databases
@@ -90,10 +90,98 @@ endi
 sql use d1
 sql show vgroups;
 
-if $rows != 2 then 
+if $rows != 4 then 
+  return -1
+endi
+
+print =============== create table
+sql use d1
+
+sql create table st (ts timestamp, i int) tags (j int)
+sql show stables
+if $rows != 1 then 
+  return -1
+endi
+
+print $data00 $data01 $data02
+
+sql create table c1 using st tags(1)
+sql create table c2 using st tags(2) 
+sql create table c3 using st tags(2) 
+sql create table c4 using st tags(2) 
+sql create table c5 using st tags(2) 
+
+sql show tables
+print $data00 $data01 $data02
+
+if $rows != 5 then 
+  return -1
+endi
+
+print =============== insert data
+sql insert into c1 values(now+1s, 1)
+sql insert into c1 values(now+2s, 2)
+sql insert into c1 values(now+3s, 3)
+sql insert into c2 values(now+1s, 1)
+sql insert into c2 values(now+2s, 2)
+sql insert into c2 values(now+3s, 3)
+sql insert into c3 values(now+1s, 1)
+sql insert into c3 values(now+2s, 2)
+sql insert into c3 values(now+3s, 3)
+sql insert into c4 values(now+1s, 1)
+sql insert into c4 values(now+2s, 2)
+sql insert into c4 values(now+3s, 3)
+sql insert into c5 values(now+1s, 1)
+sql insert into c5 values(now+2s, 2)
+sql insert into c5 values(now+3s, 3)
+
+print =============== query data
+sql select * from c1
+if $rows != 3 then 
+  return -1
+endi
+
+print $data00 $data01
+print $data10 $data11
+print $data20 $data11
+
+if $data01 != 1 then 
+  return -1
+endi
+
+if $data11 != 2 then 
+  return -1
+endi
+
+if $data21 != 3 then 
+  return -1
+endi
+
+sql select * from c2
+if $rows != 3 then 
   return -1
 endi
 
+sql select * from c3
+if $rows != 3 then 
+  return -1
+endi
+
+sql select * from c4
+if $rows != 3 then 
+  return -1
+endi
+
+sql select * from c5
+if $rows != 3 then 
+  return -1
+endi
+
+sql select * from st
+#if $rows != 15 then 
+#  return -1
+#endi
+
 print =============== drop dnode
 sql drop dnode 2;
 sql show dnodes;

tests/script/sim/table/basic1.sim

@@ -66,6 +66,24 @@ print =============== insert data
 sql insert into c1 values(now+1s, 1)
 sql insert into c1 values(now+2s, 2)
 sql insert into c1 values(now+3s, 3)
+sql insert into c2 values(now+1s, 1)
+sql insert into c2 values(now+2s, 2)
+sql insert into c2 values(now+3s, 3)
+sql insert into c3 values(now+1s, 1)
+sql insert into c3 values(now+2s, 2)
+sql insert into c3 values(now+3s, 3)
+sql insert into c4 values(now+1s, 1)
+sql insert into c4 values(now+2s, 2)
+sql insert into c4 values(now+3s, 3)
+sql insert into c5 values(now+1s, 1)
+sql insert into c5 values(now+2s, 2)
+sql insert into c5 values(now+3s, 3)
+sql insert into c6 values(now+1s, 1)
+sql insert into c6 values(now+2s, 2)
+sql insert into c6 values(now+3s, 3)
+sql insert into c7 values(now+1s, 1)
+sql insert into c7 values(now+2s, 2)
+sql insert into c7 values(now+3s, 3)
 
 print =============== query data
 sql select * from c1
@@ -89,6 +107,42 @@ if $data21 != 3 then
   return -1
 endi
 
+sql select * from c2
+if $rows != 3 then 
+  return -1
+endi
+
+sql select * from c3
+if $rows != 3 then 
+  return -1
+endi
+
+sql select * from c4
+if $rows != 3 then 
+  return -1
+endi
+
+sql select * from c5
+if $rows != 3 then 
+  return -1
+endi
+
+sql select * from c6
+if $rows != 3 then 
+  return -1
+endi
+
+sql select * from c7
+if $rows != 3 then 
+  return -1
+endi
+
+print =============== query data frpm st
+sql select * from st
+#if $rows != 21 then 
+#  return -1
+#endi
+
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
 system sh/exec.sh -n dnode1 -s start
 
@@ -114,4 +168,40 @@ if $data21 != 3 then
   return -1
 endi
 
+sql select * from c2
+if $rows != 3 then 
+  return -1
+endi
+
+sql select * from c3
+if $rows != 3 then 
+  return -1
+endi
+
+sql select * from c4
+if $rows != 3 then 
+  return -1
+endi
+
+sql select * from c5
+if $rows != 3 then 
+  return -1
+endi
+
+sql select * from c6
+if $rows != 3 then 
+  return -1
+endi
+
+sql select * from c7
+if $rows != 3 then 
+  return -1
+endi
+
+print =============== query data frpm st
+sql select * from st
+#if $rows != 21 then 
+#  return -1
+#endi
+
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
\ No newline at end of file