Merge pull request #10685 from taosdata/3.0_query_integrate

3.0 query integrate

.gitignore

@@ -87,7 +87,7 @@ tests/comparisonTest/opentsdb/opentsdbtest/.settings/
 tests/examples/JDBC/JDBCDemo/.classpath
 tests/examples/JDBC/JDBCDemo/.project
 tests/examples/JDBC/JDBCDemo/.settings/
-source/libs/parser/inc/new_sql.*
+source/libs/parser/inc/sql.*
 
 # Emacs
 # -*- mode: gitignore; -*-

include/client/taos.h

@@ -51,6 +51,7 @@ typedef void **TAOS_ROW;
 #define TSDB_DATA_TYPE_JSON      17  // json
 #define TSDB_DATA_TYPE_DECIMAL   18  // decimal
 #define TSDB_DATA_TYPE_BLOB      19  // binary
+#define TSDB_DATA_TYPE_MEDIUMBLOB 20
 
 typedef enum {
   TSDB_OPTION_LOCALE,

include/common/tcommon.h

@@ -56,8 +56,9 @@ typedef struct SColumnDataAgg {
 typedef struct SDataBlockInfo {
   STimeWindow window;
   int32_t     rows;
+  int32_t     rowSize;
   int32_t     numOfCols;
-  int64_t     uid;
+  union {int64_t uid; int64_t blockId;};
 } SDataBlockInfo;
 
 typedef struct SConstantItem {
@@ -69,9 +70,9 @@ typedef struct SConstantItem {
 
 // info.numOfCols = taosArrayGetSize(pDataBlock) + taosArrayGetSize(pConstantList);
 typedef struct SSDataBlock {
-  SColumnDataAgg* pBlockAgg;
-  SArray*         pDataBlock;  // SArray<SColumnInfoData>
-  SArray* pConstantList;       // SArray<SConstantItem>, it is a constant/tags value of the corresponding result value.
+  SColumnDataAgg *pBlockAgg;
+  SArray         *pDataBlock;    // SArray<SColumnInfoData>
+  SArray         *pConstantList; // SArray<SConstantItem>, it is a constant/tags value of the corresponding result value.
   SDataBlockInfo  info;
 } SSDataBlock;
 
@@ -108,7 +109,7 @@ static FORCE_INLINE int32_t tEncodeDataBlock(void** buf, const SSDataBlock* pBlo
     SColumnInfoData* pColData = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, i);
     tlen += taosEncodeFixedI16(buf, pColData->info.colId);
     tlen += taosEncodeFixedI16(buf, pColData->info.type);
-    tlen += taosEncodeFixedI16(buf, pColData->info.bytes);
+    tlen += taosEncodeFixedI32(buf, pColData->info.bytes);
     int32_t colSz = rows * pColData->info.bytes;
     tlen += taosEncodeBinary(buf, pColData->pData, colSz);
   }
@@ -127,7 +128,7 @@ static FORCE_INLINE void* tDecodeDataBlock(const void* buf, SSDataBlock* pBlock)
     SColumnInfoData data = {0};
     buf = taosDecodeFixedI16(buf, &data.info.colId);
     buf = taosDecodeFixedI16(buf, &data.info.type);
-    buf = taosDecodeFixedI16(buf, &data.info.bytes);
+    buf = taosDecodeFixedI32(buf, &data.info.bytes);
     int32_t colSz = pBlock->info.rows * data.info.bytes;
     buf = taosDecodeBinary(buf, (void**)&data.pData, colSz);
     taosArrayPush(pBlock->pDataBlock, &data);
@@ -212,10 +213,22 @@ static FORCE_INLINE void tDeleteSMqConsumeRsp(SMqPollRsp* pRsp) {
 //======================================================================================================================
 // the following structure shared by parser and executor
 typedef struct SColumn {
+  union {
     uint64_t uid;
+    int64_t  dataBlockId;
+  };
+
+  union {
+    int16_t colId;
+    int16_t slotId;
+  };
+
   char    name[TSDB_COL_NAME_LEN];
   int8_t  flag;  // column type: normal column, tag, or user-input column (integer/float/string)
-  SColumnInfo info;
+  int16_t type;
+  int32_t bytes;
+  uint8_t precision;
+  uint8_t scale;
 } SColumn;
 
 typedef struct SLimit {
@@ -233,21 +246,32 @@ typedef struct SGroupbyExpr {
   bool    groupbyTag;  // group by tag or column
 } SGroupbyExpr;
 
+typedef struct SFunctParam {
+  int32_t  type;
+  SColumn *pCol;
+  SVariant param;
+} SFunctParam;
+
 // the structure for sql function in select clause
-typedef struct SSqlExpr {
-  char    token[TSDB_COL_NAME_LEN];  // original token
-  SSchema resSchema;
+typedef struct SResSchame {
+  int8_t  type;
+  int32_t colId;
+  int32_t bytes;
+  int32_t precision;
+  int32_t scale;
+  char    name[TSDB_COL_NAME_LEN];
+} SResSchema;
 
-  int32_t  numOfCols;
-  SColumn* pColumns;     // data columns that are required by query
-  int32_t  interBytes;   // inter result buffer size
+// TODO move away to executor.h
+typedef struct SExprBasicInfo {
+  SResSchema   resSchema;
   int16_t      numOfParams;  // argument value of each function
-  SVariant param[3];     // parameters are not more than 3
-} SSqlExpr;
+  SFunctParam *pParam;
+} SExprBasicInfo;
 
 typedef struct SExprInfo {
-  struct SSqlExpr   base;
-  struct tExprNode* pExpr;
+  struct SExprBasicInfo  base;
+  struct tExprNode      *pExpr;
 } SExprInfo;
 
 typedef struct SStateWindow {

include/common/tdatablock.h

@@ -94,8 +94,8 @@ int32_t blockDataUpdateTsWindow(SSDataBlock* pDataBlock);
 int32_t colDataGetLength(const SColumnInfoData* pColumnInfoData, int32_t numOfRows);
 void    colDataTrim(SColumnInfoData* pColumnInfoData);
 
-size_t colDataGetNumOfCols(const SSDataBlock* pBlock);
-size_t colDataGetNumOfRows(const SSDataBlock* pBlock);
+size_t blockDataGetNumOfCols(const SSDataBlock* pBlock);
+size_t blockDataGetNumOfRows(const SSDataBlock* pBlock);
 
 int32_t      blockDataMerge(SSDataBlock* pDest, const SSDataBlock* pSrc);
 int32_t      blockDataSplitRows(SSDataBlock* pBlock, bool hasVarCol, int32_t startIndex, int32_t* stopIndex,

include/common/tmsg.h

@@ -140,6 +140,8 @@ typedef enum _mgmt_table {
 
 #define TSDB_KILL_MSG_LEN 30
 
+#define TSDB_TABLE_NUM_UNIT 100000
+
 #define TSDB_VN_READ_ACCCESS  ((char)0x1)
 #define TSDB_VN_WRITE_ACCCESS ((char)0x2)
 #define TSDB_VN_ALL_ACCCESS   (TSDB_VN_READ_ACCCESS | TSDB_VN_WRITE_ACCCESS)
@@ -169,6 +171,7 @@ typedef struct {
   char    db[TSDB_DB_FNAME_LEN];
   int64_t dbId;
   int32_t vgVersion;
+  int32_t numOfTable;      // unit is TSDB_TABLE_NUM_UNIT
 } SBuildUseDBInput;
 
 typedef struct SField {
@@ -416,10 +419,15 @@ typedef struct {
  * But for data in vnode side, we need all the following information.
  */
 typedef struct {
+  union {
     int16_t colId;
+    int16_t slotId;
+  };
+
   int16_t   type;
-  int16_t           bytes;
-  SColumnFilterList flist;
+  int32_t   bytes;
+  uint8_t   precision;
+  uint8_t   scale;
 } SColumnInfo;
 
 typedef struct {
@@ -449,57 +457,6 @@ typedef struct {
   int64_t offset;
 } SInterval;
 
-typedef struct {
-  SMsgHead head;
-  char     version[TSDB_VERSION_LEN];
-
-  bool stableQuery;        // super table query or not
-  bool topBotQuery;        // TODO used bitwise flag
-  bool interpQuery;        // interp query or not
-  bool groupbyColumn;      // denote if this is a groupby normal column query
-  bool hasTagResults;      // if there are tag values in final result or not
-  bool timeWindowInterpo;  // if the time window start/end required interpolation
-  bool queryBlockDist;     // if query data block distribution
-  bool stabledev;          // super table stddev query
-  bool tsCompQuery;        // is tscomp query
-  bool simpleAgg;
-  bool pointInterpQuery;  // point interpolation query
-  bool needReverseScan;   // need reverse scan
-  bool stateWindow;       // state window flag
-
-  STimeWindow window;
-  int32_t     numOfTables;
-  int16_t     order;
-  int16_t     orderColId;
-  int16_t     numOfCols;  // the number of columns will be load from vnode
-  SInterval   interval;
-  //  SSessionWindow sw;            // session window
-  int16_t tagCondLen;      // tag length in current query
-  int16_t colCondLen;      // column length in current query
-  int16_t numOfGroupCols;  // num of group by columns
-  int16_t orderByIdx;
-  int16_t orderType;    // used in group by xx order by xxx
-  int64_t vgroupLimit;  // limit the number of rows for each table, used in order by + limit in stable projection query.
-  int16_t prjOrder;     // global order in super table projection query.
-  int64_t limit;
-  int64_t offset;
-  int32_t queryType;    // denote another query process
-  int16_t numOfOutput;  // final output columns numbers
-  int16_t fillType;     // interpolate type
-  int64_t fillVal;      // default value array list
-  int32_t secondStageOutput;
-  STsBufInfo  tsBuf;          // tsBuf info
-  int32_t     numOfTags;      // number of tags columns involved
-  int32_t     sqlstrLen;      // sql query string
-  int32_t     prevResultLen;  // previous result length
-  int32_t     numOfOperator;
-  int32_t     tableScanOperator;  // table scan operator. -1 means no scan operator
-  int32_t     udfNum;             // number of udf function
-  int32_t     udfContentOffset;
-  int32_t     udfContentLen;
-  SColumnInfo tableCols[];
-} SQueryTableReq;
-
 typedef struct {
   int32_t code;
 } SQueryTableRsp;
@@ -566,6 +523,7 @@ typedef struct {
   char    db[TSDB_DB_FNAME_LEN];
   int64_t dbId;
   int32_t vgVersion;
+  int32_t numOfTable;    // unit is TSDB_TABLE_NUM_UNIT
 } SUseDbReq;
 
 int32_t tSerializeSUseDbReq(void* buf, int32_t bufLen, SUseDbReq* pReq);
@@ -584,6 +542,23 @@ int32_t tSerializeSUseDbRsp(void* buf, int32_t bufLen, SUseDbRsp* pRsp);
 int32_t tDeserializeSUseDbRsp(void* buf, int32_t bufLen, SUseDbRsp* pRsp);
 void    tFreeSUsedbRsp(SUseDbRsp* pRsp);
 
+typedef struct {
+  int32_t rowNum;
+} SQnodeListReq;
+
+int32_t tSerializeSQnodeListReq(void* buf, int32_t bufLen, SQnodeListReq* pReq);
+int32_t tDeserializeSQnodeListReq(void* buf, int32_t bufLen, SQnodeListReq* pReq);
+
+typedef struct {
+  SArray *epSetList; // SArray<SEpSet>
+} SQnodeListRsp;
+
+int32_t tSerializeSQnodeListRsp(void* buf, int32_t bufLen, SQnodeListRsp* pRsp);
+int32_t tDeserializeSQnodeListRsp(void* buf, int32_t bufLen, SQnodeListRsp* pRsp);
+void    tFreeSQnodeListRsp(SQnodeListRsp* pRsp);
+
+
+
 typedef struct {
   SArray* pArray;  // Array of SUseDbRsp
 } SUseDbBatchRsp;
@@ -796,8 +771,10 @@ typedef struct SVgroupInfo {
   uint32_t hashBegin;
   uint32_t hashEnd;
   SEpSet   epSet;
+  int32_t  numOfTable;  // unit is TSDB_TABLE_NUM_UNIT
 } SVgroupInfo;
 
+
 typedef struct {
   int32_t     numOfVgroups;
   SVgroupInfo vgroups[];
@@ -876,6 +853,8 @@ int32_t tDeserializeSShowRsp(void* buf, int32_t bufLen, SShowRsp* pRsp);
 void    tFreeSShowRsp(SShowRsp* pRsp);
 
 typedef struct {
+  int32_t type;
+  char    db[TSDB_DB_FNAME_LEN];
   int64_t showId;
   int8_t  free;
 } SRetrieveTableReq;
@@ -903,6 +882,8 @@ int32_t tDeserializeSCreateDnodeReq(void* buf, int32_t bufLen, SCreateDnodeReq*
 
 typedef struct {
   int32_t dnodeId;
+  char    fqdn[TSDB_FQDN_LEN];
+  int32_t port;
 } SDropDnodeReq;
 
 int32_t tSerializeSDropDnodeReq(void* buf, int32_t bufLen, SDropDnodeReq* pReq);
@@ -1026,6 +1007,7 @@ typedef struct SSubQueryMsg {
   uint64_t sId;
   uint64_t queryId;
   uint64_t taskId;
+  int64_t  refId;
   int8_t   taskType;
   uint32_t sqlLen;  // the query sql,
   uint32_t phyLen;
@@ -1072,19 +1054,57 @@ typedef struct {
 typedef struct {
   uint64_t queryId;
   uint64_t taskId;
+  int64_t  refId;
   int8_t   status;
 } STaskStatus;
 
 typedef struct {
-  uint32_t    num;
-  STaskStatus status[];
+  int64_t  refId;
+  SArray  *taskStatus;  //SArray<STaskStatus>
 } SSchedulerStatusRsp;
 
+typedef struct {
+  uint64_t queryId;
+  uint64_t taskId;
+  int8_t   action;
+} STaskAction;
+
+
+typedef struct SQueryNodeEpId {
+  int32_t nodeId;  // vgId or qnodeId
+  SEp     ep;
+} SQueryNodeEpId;
+
+
+typedef struct {
+  SMsgHead       header;
+  uint64_t       sId;
+  SQueryNodeEpId epId;
+  SArray        *taskAction;  //SArray<STaskAction>
+} SSchedulerHbReq;
+
+int32_t tSerializeSSchedulerHbReq(void *buf, int32_t bufLen, SSchedulerHbReq *pReq);
+int32_t tDeserializeSSchedulerHbReq(void *buf, int32_t bufLen, SSchedulerHbReq *pReq);
+void tFreeSSchedulerHbReq(SSchedulerHbReq *pReq);
+
+
+typedef struct {
+  uint64_t       seqId;
+  SQueryNodeEpId epId;
+  SArray        *taskStatus;  //SArray<STaskStatus>
+} SSchedulerHbRsp;
+
+int32_t tSerializeSSchedulerHbRsp(void *buf, int32_t bufLen, SSchedulerHbRsp *pRsp);
+int32_t tDeserializeSSchedulerHbRsp(void *buf, int32_t bufLen, SSchedulerHbRsp *pRsp);
+void tFreeSSchedulerHbRsp(SSchedulerHbRsp *pRsp);
+
+
 typedef struct {
   SMsgHead header;
   uint64_t sId;
   uint64_t queryId;
   uint64_t taskId;
+  int64_t  refId;
 } STaskCancelReq;
 
 typedef struct {
@@ -1096,6 +1116,7 @@ typedef struct {
   uint64_t sId;
   uint64_t queryId;
   uint64_t taskId;
+  int64_t  refId;
 } STaskDropReq;
 
 typedef struct {

include/common/tmsgdef.h

@@ -129,11 +129,13 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_MND_DROP_STB, "mnode-drop-stb", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_TABLE_META, "mnode-table-meta", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_VGROUP_LIST, "mnode-vgroup-list", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_QNODE_LIST, "mnode-qnode-list", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_KILL_QUERY, "mnode-kill-query", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_KILL_CONN, "mnode-kill-conn", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_HEARTBEAT, "mnode-heartbeat", SClientHbBatchReq, SClientHbBatchRsp)
   TD_DEF_MSG_TYPE(TDMT_MND_SHOW, "mnode-show", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_SHOW_RETRIEVE, "mnode-retrieve", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_SYSTABLE_RETRIEVE, "mnode-systable-retrieve", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_STATUS, "mnode-status", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_TRANS_TIMER, "mnode-trans-tmr", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_KILL_TRANS, "mnode-kill-trans", NULL, NULL)
@@ -183,6 +185,7 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_VND_SHOW_TABLES, "vnode-show-tables", SVShowTablesReq, SVShowTablesRsp)
   TD_DEF_MSG_TYPE(TDMT_VND_SHOW_TABLES_FETCH, "vnode-show-tables-fetch", SVShowTablesFetchReq, SVShowTablesFetchRsp)
   TD_DEF_MSG_TYPE(TDMT_VND_QUERY_CONTINUE, "vnode-query-continue", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_QUERY_HEARTBEAT, "vnode-query-heartbeat", NULL, NULL)
 
   TD_DEF_MSG_TYPE(TDMT_VND_SUBSCRIBE, "vnode-subscribe", SMVSubscribeReq, SMVSubscribeRsp)
   TD_DEF_MSG_TYPE(TDMT_VND_CONSUME, "vnode-consume", SMqCVConsumeReq, SMqCVConsumeRsp)

include/common/ttokendef.h

@@ -16,279 +16,159 @@
 #ifndef _TD_COMMON_TOKEN_H_
 #define _TD_COMMON_TOKEN_H_
 
-#define TK_ID           1
-#define TK_BOOL         2
-#define TK_INTEGER      3
-#define TK_FLOAT        4
-#define TK_STRING       5
-#define TK_TIMESTAMP    6
-#define TK_OR           7
-#define TK_AND          8
-#define TK_NOT          9
-#define TK_EQ           10
-#define TK_NE           11
-#define TK_ISNULL       12
-#define TK_NOTNULL      13
-#define TK_IS           14
-#define TK_LIKE         15
-#define TK_MATCH        16
-#define TK_NMATCH       17
-#define TK_GLOB         18
-#define TK_BETWEEN      19
-#define TK_IN           20
-#define TK_GT           21
-#define TK_GE           22
-#define TK_LT           23
-#define TK_LE           24
-#define TK_BITAND       25
-#define TK_BITOR        26
-#define TK_LSHIFT       27
-#define TK_RSHIFT       28
-#define TK_PLUS         29
-#define TK_MINUS        30
-#define TK_DIVIDE       31
-#define TK_TIMES        32
-#define TK_STAR         33
-#define TK_SLASH        34
-#define TK_REM          35
-#define TK_CONCAT       36
-#define TK_UMINUS       37
-#define TK_UPLUS        38
-#define TK_BITNOT       39
-#define TK_SHOW         40
-#define TK_DATABASES    41
-#define TK_TOPICS       42
-#define TK_FUNCTIONS    43
-#define TK_MNODES       44
-#define TK_DNODES       45
-#define TK_ACCOUNTS     46
-#define TK_USERS        47
-#define TK_MODULES      48
-#define TK_QUERIES      49
-#define TK_CONNECTIONS  50
-#define TK_STREAMS      51
-#define TK_VARIABLES    52
-#define TK_SCORES       53
-#define TK_GRANTS       54
-#define TK_VNODES       55
-#define TK_DOT          56
-#define TK_CREATE       57
-#define TK_TABLE        58
+#define TK_OR                               1
+#define TK_AND                              2
+#define TK_UNION                            3
+#define TK_ALL                              4
+#define TK_MINUS                            5
+#define TK_EXCEPT                           6
+#define TK_INTERSECT                        7
+#define TK_NK_BITAND                        8
+#define TK_NK_BITOR                         9
+#define TK_NK_LSHIFT                       10
+#define TK_NK_RSHIFT                       11
+#define TK_NK_PLUS                         12
+#define TK_NK_MINUS                        13
+#define TK_NK_STAR                         14
+#define TK_NK_SLASH                        15
+#define TK_NK_REM                          16
+#define TK_NK_CONCAT                       17
+#define TK_CREATE                          18
+#define TK_USER                            19
+#define TK_PASS                            20
+#define TK_NK_STRING                       21
+#define TK_ALTER                           22
+#define TK_PRIVILEGE                       23
+#define TK_DROP                            24
+#define TK_SHOW                            25
+#define TK_USERS                           26
+#define TK_DNODE                           27
+#define TK_PORT                            28
+#define TK_NK_INTEGER                      29
+#define TK_DNODES                          30
+#define TK_NK_ID                           31
+#define TK_NK_IPTOKEN                      32
+#define TK_DATABASE                        33
+#define TK_DATABASES                       34
+#define TK_USE                             35
+#define TK_IF                              36
+#define TK_NOT                             37
+#define TK_EXISTS                          38
+#define TK_BLOCKS                          39
+#define TK_CACHE                           40
+#define TK_CACHELAST                       41
+#define TK_COMP                            42
+#define TK_DAYS                            43
+#define TK_FSYNC                           44
+#define TK_MAXROWS                         45
+#define TK_MINROWS                         46
+#define TK_KEEP                            47
+#define TK_PRECISION                       48
+#define TK_QUORUM                          49
+#define TK_REPLICA                         50
+#define TK_TTL                             51
+#define TK_WAL                             52
+#define TK_VGROUPS                         53
+#define TK_SINGLE_STABLE                   54
+#define TK_STREAM_MODE                     55
+#define TK_TABLE                           56
+#define TK_NK_LP                           57
+#define TK_NK_RP                           58
 #define TK_STABLE                          59
-#define TK_DATABASE     60
-#define TK_TABLES       61
-#define TK_STABLES      62
-#define TK_VGROUPS      63
-#define TK_DROP         64
-#define TK_TOPIC        65
-#define TK_FUNCTION     66
-#define TK_DNODE        67
-#define TK_USER         68
-#define TK_ACCOUNT      69
-#define TK_USE          70
-#define TK_DESCRIBE     71
-#define TK_DESC         72
-#define TK_ALTER        73
-#define TK_PASS         74
-#define TK_PRIVILEGE    75
-#define TK_LOCAL        76
-#define TK_COMPACT      77
-#define TK_LP           78
-#define TK_RP           79
-#define TK_IF           80
-#define TK_EXISTS       81
-#define TK_PORT         82
-#define TK_IPTOKEN      83
-#define TK_AS           84
-#define TK_OUTPUTTYPE   85
-#define TK_AGGREGATE    86
-#define TK_BUFSIZE      87
-#define TK_PPS          88
-#define TK_TSERIES      89
-#define TK_DBS          90
-#define TK_STORAGE      91
-#define TK_QTIME        92
-#define TK_CONNS        93
-#define TK_STATE        94
-#define TK_COMMA        95
-#define TK_KEEP         96
-#define TK_CACHE        97
-#define TK_REPLICA      98
-#define TK_QUORUM       99
-#define TK_DAYS         100
-#define TK_MINROWS      101
-#define TK_MAXROWS      102
-#define TK_BLOCKS       103
-#define TK_CTIME        104
-#define TK_WAL          105
-#define TK_FSYNC        106
-#define TK_COMP         107
-#define TK_PRECISION    108
-#define TK_UPDATE       109
-#define TK_CACHELAST    110
-#define TK_STREAM       111
-#define TK_MODE         112
-#define TK_UNSIGNED     113
-#define TK_TAGS         114
-#define TK_USING        115
-#define TK_NULL         116
-#define TK_NOW          117
-#define TK_SELECT       118
-#define TK_UNION        119
-#define TK_ALL          120
-#define TK_DISTINCT     121
-#define TK_FROM         122
-#define TK_VARIABLE     123
-#define TK_INTERVAL     124
-#define TK_EVERY        125
-#define TK_SESSION      126
-#define TK_STATE_WINDOW 127
-#define TK_FILL         128
-#define TK_SLIDING      129
-#define TK_ORDER        130
-#define TK_BY           131
-#define TK_ASC          132
-#define TK_GROUP        133
-#define TK_HAVING       134
-#define TK_LIMIT        135
-#define TK_OFFSET       136
-#define TK_SLIMIT       137
-#define TK_SOFFSET      138
-#define TK_WHERE        139
-#define TK_RESET        140
-#define TK_QUERY        141
-#define TK_SYNCDB       142
-#define TK_ADD          143
-#define TK_COLUMN       144
-#define TK_MODIFY       145
-#define TK_TAG          146
-#define TK_CHANGE       147
-#define TK_SET          148
-#define TK_KILL         149
-#define TK_CONNECTION   150
-#define TK_COLON        151
-#define TK_ABORT        152
-#define TK_AFTER        153
-#define TK_ATTACH       154
-#define TK_BEFORE       155
-#define TK_BEGIN        156
-#define TK_CASCADE      157
-#define TK_CLUSTER      158
-#define TK_CONFLICT     159
-#define TK_COPY         160
-#define TK_DEFERRED     161
-#define TK_DELIMITERS   162
-#define TK_DETACH       163
-#define TK_EACH         164
-#define TK_END          165
-#define TK_EXPLAIN      166
-#define TK_FAIL         167
-#define TK_FOR          168
-#define TK_IGNORE       169
-#define TK_IMMEDIATE    170
-#define TK_INITIALLY    171
-#define TK_INSTEAD      172
-#define TK_KEY          173
-#define TK_OF           174
-#define TK_RAISE        175
-#define TK_REPLACE      176
-#define TK_RESTRICT     177
-#define TK_ROW          178
-#define TK_STATEMENT    179
-#define TK_TRIGGER      180
-#define TK_VIEW         181
-#define TK_SEMI         182
-#define TK_NONE         183
-#define TK_PREV         184
-#define TK_LINEAR       185
-#define TK_IMPORT       186
-#define TK_TBNAME       187
-#define TK_JOIN         188
-#define TK_INSERT       189
-#define TK_INTO         190
-#define TK_VALUES       191
+#define TK_TABLES                          60
+#define TK_STABLES                         61
+#define TK_USING                           62
+#define TK_TAGS                            63
+#define TK_NK_DOT                          64
+#define TK_NK_COMMA                        65
+#define TK_COMMENT                         66
+#define TK_BOOL                            67
+#define TK_TINYINT                         68
+#define TK_SMALLINT                        69
+#define TK_INT                             70
+#define TK_INTEGER                         71
+#define TK_BIGINT                          72
+#define TK_FLOAT                           73
+#define TK_DOUBLE                          74
+#define TK_BINARY                          75
+#define TK_TIMESTAMP                       76
+#define TK_NCHAR                           77
+#define TK_UNSIGNED                        78
+#define TK_JSON                            79
+#define TK_VARCHAR                         80
+#define TK_MEDIUMBLOB                      81
+#define TK_BLOB                            82
+#define TK_VARBINARY                       83
+#define TK_DECIMAL                         84
+#define TK_SMA                             85
+#define TK_MNODES                          86
+#define TK_NK_FLOAT                        87
+#define TK_NK_BOOL                         88
+#define TK_NK_VARIABLE                     89
+#define TK_BETWEEN                         90
+#define TK_IS                              91
+#define TK_NULL                            92
+#define TK_NK_LT                           93
+#define TK_NK_GT                           94
+#define TK_NK_LE                           95
+#define TK_NK_GE                           96
+#define TK_NK_NE                           97
+#define TK_NK_EQ                           98
+#define TK_LIKE                            99
+#define TK_MATCH                          100
+#define TK_NMATCH                         101
+#define TK_IN                             102
+#define TK_FROM                           103
+#define TK_AS                             104
+#define TK_JOIN                           105
+#define TK_ON                             106
+#define TK_INNER                          107
+#define TK_SELECT                         108
+#define TK_DISTINCT                       109
+#define TK_WHERE                          110
+#define TK_PARTITION                      111
+#define TK_BY                             112
+#define TK_SESSION                        113
+#define TK_STATE_WINDOW                   114
+#define TK_INTERVAL                       115
+#define TK_SLIDING                        116
+#define TK_FILL                           117
+#define TK_VALUE                          118
+#define TK_NONE                           119
+#define TK_PREV                           120
+#define TK_LINEAR                         121
+#define TK_NEXT                           122
+#define TK_GROUP                          123
+#define TK_HAVING                         124
+#define TK_ORDER                          125
+#define TK_SLIMIT                         126
+#define TK_SOFFSET                        127
+#define TK_LIMIT                          128
+#define TK_OFFSET                         129
+#define TK_ASC                            130
+#define TK_DESC                           131
+#define TK_NULLS                          132
+#define TK_FIRST                          133
+#define TK_LAST                           134
 
-#define NEW_TK_OR           1
-#define NEW_TK_AND          2
-#define NEW_TK_UNION        3
-#define NEW_TK_ALL          4
-#define NEW_TK_MINUS        5
-#define NEW_TK_EXCEPT       6
-#define NEW_TK_INTERSECT    7
-#define NEW_TK_NK_PLUS      8
-#define NEW_TK_NK_MINUS     9
-#define NEW_TK_NK_STAR      10
-#define NEW_TK_NK_SLASH     11
-#define NEW_TK_NK_REM       12
-#define NEW_TK_SHOW         13
-#define NEW_TK_DATABASES    14
-#define NEW_TK_NK_INTEGER   15
-#define NEW_TK_NK_FLOAT     16
-#define NEW_TK_NK_STRING    17
-#define NEW_TK_NK_BOOL      18
-#define NEW_TK_TIMESTAMP    19
-#define NEW_TK_NK_VARIABLE  20
-#define NEW_TK_NK_COMMA     21
-#define NEW_TK_NK_ID        22
-#define NEW_TK_NK_LP        23
-#define NEW_TK_NK_RP        24
-#define NEW_TK_NK_DOT       25
-#define NEW_TK_BETWEEN      26
-#define NEW_TK_NOT          27
-#define NEW_TK_IS           28
-#define NEW_TK_NULL         29
-#define NEW_TK_NK_LT        30
-#define NEW_TK_NK_GT        31
-#define NEW_TK_NK_LE        32
-#define NEW_TK_NK_GE        33
-#define NEW_TK_NK_NE        34
-#define NEW_TK_NK_EQ        35
-#define NEW_TK_LIKE         36
-#define NEW_TK_MATCH        37
-#define NEW_TK_NMATCH       38
-#define NEW_TK_IN           39
-#define NEW_TK_FROM         40
-#define NEW_TK_AS           41
-#define NEW_TK_JOIN         42
-#define NEW_TK_ON           43
-#define NEW_TK_INNER        44
-#define NEW_TK_SELECT       45
-#define NEW_TK_DISTINCT     46
-#define NEW_TK_WHERE        47
-#define NEW_TK_PARTITION    48
-#define NEW_TK_BY           49
-#define NEW_TK_SESSION      50
-#define NEW_TK_STATE_WINDOW 51
-#define NEW_TK_INTERVAL     52
-#define NEW_TK_SLIDING      53
-#define NEW_TK_FILL         54
-#define NEW_TK_VALUE        55
-#define NEW_TK_NONE         56
-#define NEW_TK_PREV         57
-#define NEW_TK_LINEAR       58
-#define NEW_TK_NEXT         59
-#define NEW_TK_GROUP        60
-#define NEW_TK_HAVING       61
-#define NEW_TK_ORDER        62
-#define NEW_TK_SLIMIT       63
-#define NEW_TK_SOFFSET      64
-#define NEW_TK_LIMIT        65
-#define NEW_TK_OFFSET       66
-#define NEW_TK_ASC          67
-#define NEW_TK_DESC         68
-#define NEW_TK_NULLS        69
-#define NEW_TK_FIRST        70
-#define NEW_TK_LAST         71
+#define TK_NK_SPACE                       300
+#define TK_NK_COMMENT                     301
+#define TK_NK_ILLEGAL                     302
+#define TK_NK_HEX                         303   // hex number  0x123
+#define TK_NK_OCT                         304   // oct number
+#define TK_NK_BIN                         305   // bin format data 0b111
+#define TK_NK_FILE                        306
+#define TK_NK_QUESTION                    307   // denoting the placeholder of "?",when invoking statement bind query
 
-#define TK_SPACE    300
-#define TK_COMMENT  301
-#define TK_ILLEGAL  302
-#define TK_HEX      303  // hex number  0x123
-#define TK_OCT      304  // oct number
-#define TK_BIN      305  // bin format data 0b111
-#define TK_FILE     306
-#define TK_QUESTION 307  // denoting the placeholder of "?",when invoking statement bind query
+#define TK_NK_COLON                       500
+#define TK_NK_BITNOT                      501
+#define TK_INSERT                         502
+#define TK_INTO                           503
+#define TK_NOW                            504
+#define TK_VALUES                         507
+#define TK_IMPORT                         507
+#define TK_NK_SEMI                        508
 
-#define TK_NIL 65535
+#define TK_NK_NIL                         65535
 
 #endif /*_TD_COMMON_TOKEN_H_*/

include/libs/catalog/catalog.h

@@ -51,7 +51,7 @@ typedef struct SMetaData {
   SArray    *pTableMeta;  // STableMeta array
   SArray    *pVgroupInfo; // SVgroupInfo list
   SArray    *pUdfList;    // udf info list
-  SEpSet    *pEpSet;      // qnode epset list
+  SArray    *pEpSetList;  // qnode epset list, SArray<SEpSet>
 } SMetaData;
 
 typedef struct SCatalogCfg {
@@ -74,9 +74,9 @@ typedef struct SDbVgVersion {
   char    dbFName[TSDB_DB_FNAME_LEN];
   int64_t dbId;
   int32_t vgVersion;
+  int32_t numOfTable; // unit is TSDB_TABLE_NUM_UNIT
 } SDbVgVersion;
 
-
 int32_t catalogInit(SCatalogCfg *cfg);
 
 /**
@@ -95,7 +95,7 @@ int32_t catalogGetHandle(uint64_t clusterId, SCatalog** catalogHandle);
  */
 void catalogFreeHandle(SCatalog* pCatalog);
 
-int32_t catalogGetDBVgVersion(SCatalog* pCtg, const char* dbFName, int32_t* version, int64_t* dbId);
+int32_t catalogGetDBVgVersion(SCatalog* pCtg, const char* dbFName, int32_t* version, int64_t* dbId, int32_t *tableNum);
 
 /**
  * Get a DB's all vgroup info.

include/libs/executor/dataSinkMgt.h

@@ -23,6 +23,7 @@ extern "C" {
 #include "os.h"
 #include "thash.h"
 #include "executor.h"
+#include "plannodes.h"
 
 #define DS_BUF_LOW   1
 #define DS_BUF_FULL  2
@@ -59,7 +60,7 @@ typedef struct SOutputData {
  * @param pHandle output
  * @return error code
  */
-int32_t dsCreateDataSinker(const struct SDataSink *pDataSink, DataSinkHandle* pHandle);
+int32_t dsCreateDataSinker(const SDataSinkNode* pDataSink, DataSinkHandle* pHandle);
 
 /**
  * Put the result set returned by the executor into datasinker.

include/libs/function/function.h

@@ -20,9 +20,30 @@
 extern "C" {
 #endif
 
+#include "tbuffer.h"
 #include "tcommon.h"
 #include "tvariant.h"
-#include "tbuffer.h"
+
+struct SqlFunctionCtx;
+struct SResultRowEntryInfo;
+
+typedef struct SFunctionNode SFunctionNode;
+
+typedef struct SFuncExecEnv {
+  int32_t calcMemSize;
+} SFuncExecEnv;
+
+typedef bool (*FExecGetEnv)(SFunctionNode* pFunc, SFuncExecEnv* pEnv);
+typedef bool (*FExecInit)(struct SqlFunctionCtx *pCtx, struct SResultRowEntryInfo* pResultCellInfo);
+typedef void (*FExecProcess)(struct SqlFunctionCtx *pCtx);
+typedef void (*FExecFinalize)(struct SqlFunctionCtx *pCtx);
+
+typedef struct SFuncExecFuncs {
+  FExecGetEnv getEnv;
+  FExecInit init;
+  FExecProcess process;
+  FExecFinalize finalize;
+} SFuncExecFuncs;
 
 #define MAX_INTERVAL_TIME_WINDOW 1000000  // maximum allowed time windows in final results
 
@@ -111,64 +132,65 @@ struct SqlFunctionCtx;
 struct SResultRowEntryInfo;
 
 //for selectivity query, the corresponding tag value is assigned if the data is qualified
-typedef struct SExtTagsInfo {
-  int16_t                 tagsLen;      // keep the tags data for top/bottom query result
-  int16_t                 numOfTagCols;
-  struct SqlFunctionCtx **pTagCtxList;
-} SExtTagsInfo;
+typedef struct SSubsidiaryResInfo {
+  int16_t                 bufLen;      // keep the tags data for top/bottom query result
+  int16_t                 numOfCols;
+  struct SqlFunctionCtx **pCtx;
+} SSubsidiaryResInfo;
 
 typedef struct SResultDataInfo {
+  int16_t precision;
+  int16_t scale;
   int16_t type;
   int16_t bytes;
-  int32_t intermediateBytes;
+  int32_t interBufSize;
 } SResultDataInfo;
 
 #define GET_RES_INFO(ctx) ((ctx)->resultInfo)
 
-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;
-
-extern SFunctionFpSet fpSet[1];
+typedef struct SInputColumnInfoData {
+  int32_t           totalRows;      // total rows in current columnar data
+  int32_t           startRowIndex;  // handle started row index
+  int32_t           numOfRows;      // the number of rows needs to be handled
+  int32_t           numOfInputCols; // PTS is not included
+  bool              colDataAggIsSet;// if agg is set or not
+  SColumnInfoData  *pPTS;           // primary timestamp column
+  SColumnInfoData **pData;
+  SColumnDataAgg  **pColumnDataAgg;
+} SInputColumnInfoData;
 
 // sql function runtime context
 typedef struct SqlFunctionCtx {
-  int32_t      startRow;
-  int32_t      size;      // number of rows
-  SColumnInfoData* pInput;
-
-  uint32_t     order;     // asc|desc
-  int16_t      inputType;
-  int16_t      inputBytes;
-
+  SInputColumnInfoData input;
   SResultDataInfo      resDataInfo;
-  bool         hasNull;       // null value exist in current block
-  bool         requireNull;   // require null in some function
+  uint32_t             order;  // asc|desc
+  ////////////////////////////////////////////////////////////////
+  int32_t          startRow;   // start row index
+  int32_t          size;       // handled processed row number
+  SColumnInfoData* pInput;
+  SColumnDataAgg   agg;
+  int16_t          inputType;    // TODO remove it
+  int16_t          inputBytes;   // TODO remove it
+  bool             hasNull;      // null value exist in current block, TODO remove it
+  bool             requireNull;  // require null in some function, TODO remove it
+  int32_t          columnIndex;  // TODO remove it
+  uint8_t          currentStage;  // record current running step, default: 0
+  bool             isAggSet;
+  /////////////////////////////////////////////////////////////////
   bool             stableQuery;
   int16_t          functionId;    // function id
   char *           pOutput;       // final result output buffer, point to sdata->data
-  uint8_t      currentStage;  // record current running step, default: 0
   int64_t          startTs;       // timestamp range of current query when function is executed on a specific data block
   int32_t          numOfParams;
   SVariant         param[4];      // input parameter, e.g., top(k, 20), the number of results for top query is kept in param
   int64_t         *ptsList;       // corresponding timestamp array list
   void            *ptsOutputBuf;  // corresponding output buffer for timestamp of each result, e.g., top/bottom*/
   SVariant         tag;
-
-  bool        isAggSet;
-  SColumnDataAgg agg;
   struct  SResultRowEntryInfo *resultInfo;
-  SExtTagsInfo tagInfo;
+  SSubsidiaryResInfo     subsidiaryRes;
   SPoint1          start;
   SPoint1          end;
-
-  int32_t      columnIndex;
-  SFunctionFpSet* fpSet;
+  SFuncExecFuncs   fpSet;
 } SqlFunctionCtx;
 
 enum {
@@ -194,9 +216,10 @@ typedef struct tExprNode {
     struct SVariant    *pVal;   // value node
 
     struct {// function node
-      char              functionName[FUNCTIONS_NAME_MAX_LENGTH];
+      char              functionName[FUNCTIONS_NAME_MAX_LENGTH];  // todo refactor
+      int32_t           functionId;
       int32_t           num;
-
+      SFunctionNode    *pFunctNode;
       // Note that the attribute of pChild is not the parameter of function, it is the columns that involved in the
       // calculation instead.
       // E.g., Cov(col1, col2), the column information, w.r.t. the col1 and col2, is kept in pChild nodes.
@@ -207,7 +230,6 @@ typedef struct tExprNode {
   };
 } tExprNode;
 
-//TODO create?
 void exprTreeToBinary(SBufferWriter* bw, tExprNode* pExprTree);
 void tExprTreeDestroy(tExprNode *pNode, void (*fp)(void *));
 
@@ -294,7 +316,7 @@ tExprNode* exprdup(tExprNode* pTree);
 
 void resetResultRowEntryResult(SqlFunctionCtx* pCtx, int32_t num);
 void cleanupResultRowEntry(struct SResultRowEntryInfo* pCell);
-int32_t getNumOfResult(SqlFunctionCtx* pCtx, int32_t num);
+int32_t getNumOfResult(SqlFunctionCtx* pCtx, int32_t num, SSDataBlock* pResBlock);
 bool isRowEntryCompleted(struct SResultRowEntryInfo* pEntry);
 bool isRowEntryInitialized(struct SResultRowEntryInfo* pEntry);
 

include/libs/function/functionMgt.h

@@ -102,22 +102,6 @@ struct SqlFunctionCtx;
 struct SResultRowEntryInfo;
 struct STimeWindow;
 
-typedef struct SFuncExecEnv {
-  int32_t calcMemSize;
-} SFuncExecEnv;
-
-typedef bool (*FExecGetEnv)(SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-typedef bool (*FExecInit)(struct SqlFunctionCtx *pCtx, struct SResultRowEntryInfo* pResultCellInfo);
-typedef void (*FExecProcess)(struct SqlFunctionCtx *pCtx);
-typedef void (*FExecFinalize)(struct SqlFunctionCtx *pCtx);
-
-typedef struct SFuncExecFuncs {
-  FExecGetEnv getEnv;
-  FExecInit init;
-  FExecProcess process;
-  FExecFinalize finalize;
-} SFuncExecFuncs;
-
 typedef int32_t (*FScalarExecProcess)(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 
 typedef struct SScalarFuncExecFuncs {
@@ -127,6 +111,8 @@ typedef struct SScalarFuncExecFuncs {
 
 int32_t fmFuncMgtInit();
 
+void fmFuncMgtDestroy();
+
 int32_t fmGetFuncInfo(const char* pFuncName, int32_t* pFuncId, int32_t* pFuncType);
 
 int32_t fmGetFuncResultType(SFunctionNode* pFunc);

include/libs/nodes/cmdnodes.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_CMD_NODES_H_
+#define _TD_CMD_NODES_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "querynodes.h"
+
+typedef struct SDatabaseOptions {
+  int32_t numOfBlocks;
+  int32_t cacheBlockSize;
+  int8_t cachelast;
+  int32_t compressionLevel;
+  int32_t daysPerFile;
+  int32_t fsyncPeriod;
+  int32_t maxRowsPerBlock;
+  int32_t minRowsPerBlock;
+  int32_t keep;
+  int32_t precision;
+  int32_t quorum;
+  int32_t replica;
+  int32_t ttl;
+  int32_t walLevel;
+  int32_t numOfVgroups;
+  int8_t singleStable;
+  int8_t streamMode;
+} SDatabaseOptions;
+
+typedef struct SCreateDatabaseStmt {
+  ENodeType type;
+  char dbName[TSDB_DB_NAME_LEN];
+  bool ignoreExists;
+  SDatabaseOptions options;
+} SCreateDatabaseStmt;
+
+typedef struct SUseDatabaseStmt {
+  ENodeType type;
+  char dbName[TSDB_DB_NAME_LEN];
+} SUseDatabaseStmt;
+
+typedef struct SDropDatabaseStmt {
+  ENodeType type;
+  char dbName[TSDB_DB_NAME_LEN];
+  bool ignoreNotExists;
+} SDropDatabaseStmt;
+
+typedef struct STableOptions {
+  int32_t keep;
+  int32_t ttl;
+  char comments[TSDB_STB_COMMENT_LEN];
+  SNodeList* pSma;
+} STableOptions;
+
+typedef struct SColumnDefNode {
+  ENodeType type;
+  char colName[TSDB_COL_NAME_LEN];
+  SDataType dataType;
+  char comments[TSDB_STB_COMMENT_LEN];
+} SColumnDefNode;
+
+typedef struct SCreateTableStmt {
+  ENodeType type;
+  char dbName[TSDB_DB_NAME_LEN];
+  char tableName[TSDB_TABLE_NAME_LEN];
+  bool ignoreExists;
+  SNodeList* pCols;
+  SNodeList* pTags;
+  STableOptions options;
+} SCreateTableStmt;
+
+typedef struct SCreateSubTableClause {
+  ENodeType type;
+  char dbName[TSDB_DB_NAME_LEN];
+  char tableName[TSDB_TABLE_NAME_LEN];
+  char useDbName[TSDB_DB_NAME_LEN];
+  char useTableName[TSDB_TABLE_NAME_LEN];
+  bool ignoreExists;
+  SNodeList* pSpecificTags;
+  SNodeList* pValsOfTags;
+} SCreateSubTableClause;
+
+typedef struct SCreateMultiTableStmt {
+  ENodeType type;
+  SNodeList* pSubTables;
+} SCreateMultiTableStmt;
+
+typedef struct SDropTableClause {
+  ENodeType type;
+  char dbName[TSDB_DB_NAME_LEN];
+  char tableName[TSDB_TABLE_NAME_LEN];
+  bool ignoreNotExists;
+} SDropTableClause;
+
+typedef struct SDropTableStmt {
+  ENodeType type;
+  SNodeList* pTables;
+} SDropTableStmt;
+
+typedef struct SDropSuperTableStmt {
+  ENodeType type;
+  char dbName[TSDB_DB_NAME_LEN];
+  char tableName[TSDB_TABLE_NAME_LEN];
+  bool ignoreNotExists;
+} SDropSuperTableStmt;
+
+typedef struct SCreateUserStmt {
+  ENodeType type;
+  char useName[TSDB_USER_LEN];
+  char password[TSDB_USET_PASSWORD_LEN];
+} SCreateUserStmt;
+
+typedef struct SAlterUserStmt {
+  ENodeType type;
+  char useName[TSDB_USER_LEN];
+  char password[TSDB_USET_PASSWORD_LEN];
+  int8_t alterType;
+} SAlterUserStmt;
+
+typedef struct SDropUserStmt {
+  ENodeType type;
+  char useName[TSDB_USER_LEN];
+} SDropUserStmt;
+
+typedef struct SCreateDnodeStmt {
+  ENodeType type;
+  char fqdn[TSDB_FQDN_LEN];
+  int32_t port;
+} SCreateDnodeStmt;
+
+typedef struct SDropDnodeStmt {
+  ENodeType type;
+  int32_t dnodeId;
+  char fqdn[TSDB_FQDN_LEN];
+  int32_t port;
+} SDropDnodeStmt;
+
+typedef struct SShowStmt {
+  ENodeType type;
+  char dbName[TSDB_DB_NAME_LEN];
+} SShowStmt;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_CMD_NODES_H_*/

include/libs/nodes/nodes.h

@@ -65,24 +65,60 @@ typedef enum ENodeType {
   QUERY_NODE_TARGET,
   QUERY_NODE_DATABLOCK_DESC,
   QUERY_NODE_SLOT_DESC,
+  QUERY_NODE_COLUMN_DEF,
+  QUERY_NODE_DOWNSTREAM_SOURCE,
 
   // Statement nodes are used in parser and planner module.
   QUERY_NODE_SET_OPERATOR,
   QUERY_NODE_SELECT_STMT,
-  QUERY_NODE_SHOW_STMT,
+  QUERY_NODE_VNODE_MODIF_STMT,
+  QUERY_NODE_CREATE_DATABASE_STMT,
+  QUERY_NODE_DROP_DATABASE_STMT,
+  QUERY_NODE_SHOW_DATABASES_STMT, // temp
+  QUERY_NODE_CREATE_TABLE_STMT,
+  QUERY_NODE_CREATE_SUBTABLE_CLAUSE,
+  QUERY_NODE_CREATE_MULTI_TABLE_STMT,
+  QUERY_NODE_DROP_TABLE_CLAUSE,
+  QUERY_NODE_DROP_TABLE_STMT,
+  QUERY_NODE_DROP_SUPER_TABLE_STMT,
+  QUERY_NODE_SHOW_TABLES_STMT, // temp
+  QUERY_NODE_SHOW_STABLES_STMT,
+  QUERY_NODE_CREATE_USER_STMT,
+  QUERY_NODE_ALTER_USER_STMT,
+  QUERY_NODE_DROP_USER_STMT,
+  QUERY_NODE_SHOW_USERS_STMT,
+  QUERY_NODE_USE_DATABASE_STMT,
+  QUERY_NODE_CREATE_DNODE_STMT,
+  QUERY_NODE_DROP_DNODE_STMT,
+  QUERY_NODE_SHOW_DNODES_STMT,
+  QUERY_NODE_SHOW_VGROUPS_STMT,
+  QUERY_NODE_SHOW_MNODES_STMT,
 
   // logic plan node
   QUERY_NODE_LOGIC_PLAN_SCAN,
   QUERY_NODE_LOGIC_PLAN_JOIN,
   QUERY_NODE_LOGIC_PLAN_AGG,
   QUERY_NODE_LOGIC_PLAN_PROJECT,
+  QUERY_NODE_LOGIC_PLAN_VNODE_MODIF,
+  QUERY_NODE_LOGIC_PLAN_EXCHANGE,
+  QUERY_NODE_LOGIC_SUBPLAN,
+  QUERY_NODE_LOGIC_PLAN,
 
   // physical plan node
   QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN,
   QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN,
+  QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN,
+  QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN,
   QUERY_NODE_PHYSICAL_PLAN_PROJECT,
   QUERY_NODE_PHYSICAL_PLAN_JOIN,
-  QUERY_NODE_PHYSICAL_PLAN_AGG
+  QUERY_NODE_PHYSICAL_PLAN_AGG,
+  QUERY_NODE_PHYSICAL_PLAN_EXCHANGE,
+  QUERY_NODE_PHYSICAL_PLAN_SORT,
+  QUERY_NODE_PHYSICAL_PLAN_DISPATCH,
+  QUERY_NODE_PHYSICAL_PLAN_INSERT,
+  QUERY_NODE_PHYSICAL_SUBPLAN,
+  QUERY_NODE_PHYSICAL_PLAN
 } ENodeType;
 
 /**
@@ -105,15 +141,20 @@ typedef struct SNodeList {
   SListCell* pTail;
 } SNodeList;
 
-SNode* nodesMakeNode(ENodeType type);
-void nodesDestroyNode(SNode* pNode);
+#define SNodeptr void*  
+
+SNodeptr nodesMakeNode(ENodeType type);
+void nodesDestroyNode(SNodeptr pNode);
 
 SNodeList* nodesMakeList();
-int32_t nodesListAppend(SNodeList* pList, SNode* pNode);
+int32_t nodesListAppend(SNodeList* pList, SNodeptr pNode);
+int32_t nodesListStrictAppend(SNodeList* pList, SNodeptr pNode);
 int32_t nodesListAppendList(SNodeList* pTarget, SNodeList* pSrc);
 SListCell* nodesListErase(SNodeList* pList, SListCell* pCell);
-SNode* nodesListGetNode(SNodeList* pList, int32_t index);
+SNodeptr nodesListGetNode(SNodeList* pList, int32_t index);
 void nodesDestroyList(SNodeList* pList);
+// Only clear the linked list structure, without releasing the elements inside
+void nodesClearList(SNodeList* pList);
 
 typedef enum EDealRes {
   DEAL_RES_CONTINUE = 1,
@@ -122,9 +163,9 @@ typedef enum EDealRes {
 } EDealRes;
 
 typedef EDealRes (*FNodeWalker)(SNode* pNode, void* pContext);
-void nodesWalkNode(SNode* pNode, FNodeWalker walker, void* pContext);
+void nodesWalkNode(SNodeptr pNode, FNodeWalker walker, void* pContext);
 void nodesWalkList(SNodeList* pList, FNodeWalker walker, void* pContext);
-void nodesWalkNodePostOrder(SNode* pNode, FNodeWalker walker, void* pContext);
+void nodesWalkNodePostOrder(SNodeptr pNode, FNodeWalker walker, void* pContext);
 void nodesWalkListPostOrder(SNodeList* pList, FNodeWalker walker, void* pContext);
 
 typedef EDealRes (*FNodeRewriter)(SNode** pNode, void* pContext);
@@ -133,12 +174,13 @@ void nodesRewriteList(SNodeList* pList, FNodeRewriter rewriter, void* pContext);
 void nodesRewriteNodePostOrder(SNode** pNode, FNodeRewriter rewriter, void* pContext);
 void nodesRewriteListPostOrder(SNodeList* pList, FNodeRewriter rewriter, void* pContext);
 
-bool nodesEqualNode(const SNode* a, const SNode* b);
+bool nodesEqualNode(const SNodeptr a, const SNodeptr b);
 
-SNode* nodesCloneNode(const SNode* pNode);
+SNodeptr nodesCloneNode(const SNodeptr pNode);
 SNodeList* nodesCloneList(const SNodeList* pList);
 
-int32_t nodesNodeToString(const SNode* pNode, bool format, char** pStr, int32_t* pLen);
+const char* nodesNodeName(ENodeType type);
+int32_t nodesNodeToString(const SNodeptr pNode, bool format, char** pStr, int32_t* pLen);
 int32_t nodesStringToNode(const char* pStr, SNode** pNode);
 
 #ifdef __cplusplus

include/libs/nodes/plannodes.h

@@ -21,7 +21,8 @@ extern "C" {
 #endif
 
 #include "querynodes.h"
-#include "tmsg.h"
+#include "query.h"
+#include "tname.h"
 
 typedef struct SLogicNode {
   ENodeType type;
@@ -43,9 +44,11 @@ typedef struct SScanLogicNode {
   SLogicNode node;
   SNodeList* pScanCols;
   struct STableMeta* pMeta;
+  SVgroupsInfo* pVgroupList;
   EScanType scanType;
   uint8_t scanFlag;         // denotes reversed scan of data or not
   STimeWindow scanRange;
+  SName tableName;
 } SScanLogicNode;
 
 typedef struct SJoinLogicNode {
@@ -65,6 +68,49 @@ typedef struct SProjectLogicNode {
   SNodeList* pProjections;
 } SProjectLogicNode;
 
+typedef struct SVnodeModifLogicNode {
+  SLogicNode node;;
+  int32_t msgType;
+  SArray* pDataBlocks;
+  SVgDataBlocks* pVgDataBlocks;
+} SVnodeModifLogicNode;
+
+typedef struct SExchangeLogicNode {
+  SLogicNode node;
+  int32_t srcGroupId;
+} SExchangeLogicNode;
+
+typedef enum ESubplanType {
+  SUBPLAN_TYPE_MERGE = 1,
+  SUBPLAN_TYPE_PARTIAL,
+  SUBPLAN_TYPE_SCAN,
+  SUBPLAN_TYPE_MODIFY
+} ESubplanType;
+
+typedef struct SSubplanId {
+  uint64_t queryId;
+  int32_t groupId;
+  int32_t subplanId;
+} SSubplanId;
+
+typedef struct SSubLogicPlan {
+  ENodeType type;
+  SSubplanId id;
+  SNodeList* pChildren;
+  SNodeList* pParents;
+  SLogicNode* pNode;
+  ESubplanType subplanType;
+  SVgroupsInfo* pVgroupList;
+  int32_t level;
+  int32_t splitFlag;
+} SSubLogicPlan;
+
+typedef struct SQueryLogicPlan {
+  ENodeType type;;
+  int32_t totalLevel;
+  SNodeList* pTopSubplans;
+} SQueryLogicPlan;
+
 typedef struct SSlotDescNode {
   ENodeType type;
   int16_t slotId;
@@ -78,11 +124,13 @@ typedef struct SDataBlockDescNode {
   ENodeType type;
   int16_t dataBlockId;
   SNodeList* pSlots;
+  int32_t resultRowSize;
+  int16_t precision;
 } SDataBlockDescNode;
 
 typedef struct SPhysiNode {
   ENodeType type;
-  SDataBlockDescNode outputDataBlockDesc;
+  SDataBlockDescNode* pOutputDataBlockDesc;
   SNode* pConditions;
   SNodeList* pChildren;
   struct SPhysiNode* pParent;
@@ -96,6 +144,7 @@ typedef struct SScanPhysiNode {
   int32_t order;         // scan order: TSDB_ORDER_ASC|TSDB_ORDER_DESC
   int32_t count;         // repeat count
   int32_t reverse;       // reverse scan count
+  SName tableName;
 } SScanPhysiNode;
 
 typedef SScanPhysiNode SSystemTableScanPhysiNode;
@@ -129,6 +178,56 @@ typedef struct SAggPhysiNode {
   SNodeList* pAggFuncs;
 } SAggPhysiNode;
 
+typedef struct SDownstreamSourceNode {
+  ENodeType type;
+  SQueryNodeAddr addr;
+  uint64_t taskId;
+  uint64_t schedId;
+} SDownstreamSourceNode;
+
+typedef struct SExchangePhysiNode {
+  SPhysiNode node;
+  int32_t srcGroupId;  // group id of datasource suplans
+  SNodeList* pSrcEndPoints;  // element is SDownstreamSource, scheduler fill by calling qSetSuplanExecutionNode
+} SExchangePhysiNode;
+
+typedef struct SDataSinkNode {
+  ENodeType type;
+  SDataBlockDescNode* pInputDataBlockDesc;
+} SDataSinkNode;
+
+typedef struct SDataDispatcherNode {
+  SDataSinkNode sink;
+} SDataDispatcherNode;
+
+typedef struct SDataInserterNode {
+  SDataSinkNode sink;
+  int32_t   numOfTables;
+  uint32_t  size;
+  char     *pData;
+} SDataInserterNode;
+
+typedef struct SSubplan {
+  ENodeType type;
+  SSubplanId id;           // unique id of the subplan
+  ESubplanType subplanType;
+  int32_t msgType;      // message type for subplan, used to denote the send message type to vnode.
+  int32_t level;        // the execution level of current subplan, starting from 0 in a top-down manner.
+  SQueryNodeAddr execNode;    // for the scan/modify subplan, the optional execution node
+  SQueryNodeStat execNodeStat; // only for scan subplan
+  SNodeList* pChildren;    // the datasource subplan,from which to fetch the result
+  SNodeList* pParents;     // the data destination subplan, get data from current subplan
+  SPhysiNode* pNode;        // physical plan of current subplan
+  SDataSinkNode* pDataSink;    // data of the subplan flow into the datasink
+} SSubplan;
+
+typedef struct SQueryPlan {
+  ENodeType type;;
+  uint64_t queryId;
+  int32_t numOfSubplans;
+  SNodeList* pSubplans; // Element is SNodeListNode. The execution level of subplan, starting from 0.
+} SQueryPlan;
+
 #ifdef __cplusplus
 }
 #endif

include/libs/nodes/querynodes.h

@@ -21,6 +21,7 @@ extern "C" {
 #endif
 
 #include "nodes.h"
+#include "tmsg.h"
 
 typedef struct SRawExprNode {
   ENodeType nodeType;
@@ -73,6 +74,7 @@ typedef struct SValueNode {
   SExprNode node; // QUERY_NODE_VALUE
   char* literal;
   bool isDuration;
+  bool translate;
   union {
     bool b;
     int64_t i;
@@ -122,6 +124,7 @@ struct STableMeta;
 typedef struct SRealTableNode {
   STableNode table; // QUERY_NODE_REAL_TABLE
   struct STableMeta* pMeta;
+  SVgroupsInfo* pVgroupList;
 } SRealTableNode;
 
 typedef struct STempTableNode {
@@ -248,6 +251,29 @@ typedef enum ESqlClause {
   SQL_CLAUSE_ORDER_BY
 } ESqlClause;
 
+
+typedef enum {
+  PAYLOAD_TYPE_KV = 0,
+  PAYLOAD_TYPE_RAW = 1,
+} EPayloadType;
+
+typedef struct SVgDataBlocks {
+  SVgroupInfo vg;
+  int32_t     numOfTables;  // number of tables in current submit block
+  uint32_t    size;
+  char       *pData;        // SMsgDesc + SSubmitReq + SSubmitBlk + ...
+} SVgDataBlocks;
+
+typedef struct SVnodeModifOpStmt {
+  ENodeType   nodeType;
+  ENodeType   sqlNodeType;
+  SArray*     pDataBlocks;         // data block for each vgroup, SArray<SVgDataBlocks*>.
+  int8_t      schemaAttache;       // denote if submit block is built with table schema or not
+  uint8_t     payloadType;         // EPayloadType. 0: K-V payload for non-prepare insert, 1: rawPayload for prepare insert
+  uint32_t    insertType;          // insert data from [file|sql statement| bound statement]
+  const char* sql;                 // current sql statement position
+} SVnodeModifOpStmt;
+
 void nodesWalkSelectStmt(SSelectStmt* pSelect, ESqlClause clause, FNodeWalker walker, void* pContext);
 void nodesRewriteSelectStmt(SSelectStmt* pSelect, ESqlClause clause, FNodeRewriter rewriter, void* pContext);
 

include/libs/parser/parsenodes.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_PARSENODES_H_
-#define _TD_PARSENODES_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "catalog.h"
-#include "tcommon.h"
-#include "function.h"
-#include "tmsgtype.h"
-#include "tname.h"
-#include "tvariant.h"
-
-/**
- * The first field of a node of any type is guaranteed to be the int16_t.
- * Hence the type of any node can be gotten by casting it to SQueryNode. 
- */
-typedef struct SQueryNode {
-  int16_t type;
-} SQueryNode;
-
-#define queryNodeType(nodeptr) (((const SQueryNode*)(nodeptr))->type)
-
-typedef struct SFieldInfo {
-  int16_t     numOfOutput;   // number of column in result
-  SField     *final;
-  SArray     *internalField; // SArray<SInternalField>
-} SFieldInfo;
-
-typedef struct SCond {
-  uint64_t uid;
-  int32_t  len;  // length of tag query condition data
-  char *   cond;
-} SCond;
-
-typedef struct SJoinNode {
-  uint64_t uid;
-  int16_t  tagColId;
-  SArray*  tsJoin;
-  SArray*  tagJoin;
-} SJoinNode;
-
-typedef struct SJoinInfo {
-  bool       hasJoin;
-  SJoinNode *joinTables[TSDB_MAX_JOIN_TABLE_NUM];
-} SJoinInfo;
-
-typedef struct STagCond {
-  int16_t   relType;     // relation between tbname list and query condition, including : TK_AND or TK_OR
-  SCond     tbnameCond;  // tbname query condition, only support tbname query condition on one table
-  SJoinInfo joinInfo;    // join condition, only support two tables join currently
-  SArray   *pCond;       // for different table, the query condition must be seperated
-} STagCond;
-
-typedef struct STableMetaInfo {
-  STableMeta    *pTableMeta;      // table meta, cached in client side and acquired by name
-  SVgroupsInfo  *vgroupList;
-  SName         name;
-  char          aliasName[TSDB_TABLE_NAME_LEN];    // alias name of table specified in query sql
-  SArray       *tagColList;                        // SArray<SColumn*>, involved tag columns
-} STableMetaInfo;
-
-typedef struct SColumnIndex {
-  int16_t tableIndex;
-  int16_t columnIndex;
-  int16_t type;               // normal column/tag/ user input constant column
-} SColumnIndex;
-
-// select statement
-typedef struct SQueryStmtInfo {
-  int16_t          command;       // the command may be different for each subclause, so keep it seperately.
-  uint32_t         type;          // query/insert type
-  STimeWindow      window;        // the whole query time window
-  SInterval        interval;      // tumble time window
-  SSessionWindow   sessionWindow; // session time window
-  SStateWindow     stateWindow;   // state window query
-  SGroupbyExpr     groupbyExpr;   // groupby tags info
-  SArray *         colList;       // SArray<SColumn*>
-  SFieldInfo       fieldsInfo;
-  SArray**         exprList;      // SArray<SExprInfo*>
-  SLimit           limit;
-  SLimit           slimit;
-  STagCond         tagCond;
-  SArray *         colCond;
-  SArray *         order;
-  int16_t          numOfTables;
-  int16_t          curTableIdx;
-  STableMetaInfo **pTableMetaInfo;
-  struct STSBuf   *tsBuf;
-
-  int16_t          fillType;      // final result fill type
-  int64_t *        fillVal;       // default value for fill
-  int32_t          numOfFillVal;  // fill value size
-
-  char *           msg;           // pointer to the pCmd->payload to keep error message temporarily
-  int64_t          clauseLimit;   // limit for current sub clause
-
-  int64_t          prjOffset;     // offset value in the original sql expression, only applied at client side
-  int64_t          vgroupLimit;    // table limit in case of super table projection query + global order + limit
-
-  int32_t          udColumnId;    // current user-defined constant output field column id, monotonically decreases from TSDB_UD_COLUMN_INDEX
-  int32_t          bufLen;
-  char*            buf;
-  SArray          *pUdfInfo;
-
-  struct SQueryStmtInfo *sibling;     // sibling
-  SMultiFunctionsDesc    info;
-  SArray            *pDownstream;   // SArray<struct SQueryStmtInfo>
-  int32_t            havingFieldNum;
-  int32_t            exprListLevelIndex;
-} SQueryStmtInfo;
-
-typedef enum {
-  PAYLOAD_TYPE_KV = 0,
-  PAYLOAD_TYPE_RAW = 1,
-} EPayloadType;
-
-typedef struct SVgDataBlocks {
-  SVgroupInfo vg;
-  int32_t     numOfTables;  // number of tables in current submit block
-  uint32_t    size;
-  char       *pData;        // SMsgDesc + SSubmitReq + SSubmitBlk + ...
-} SVgDataBlocks;
-
-typedef struct SVnodeModifOpStmtInfo {
-  int16_t     nodeType;
-  SArray*     pDataBlocks;         // data block for each vgroup, SArray<SVgDataBlocks*>.
-  int8_t      schemaAttache;       // denote if submit block is built with table schema or not
-  uint8_t     payloadType;         // EPayloadType. 0: K-V payload for non-prepare insert, 1: rawPayload for prepare insert
-  uint32_t    insertType;          // insert data from [file|sql statement| bound statement]
-  const char* sql;                 // current sql statement position
-} SVnodeModifOpStmtInfo;
-
-typedef struct SDclStmtInfo {
-  int16_t     nodeType;
-  int16_t     msgType;
-  SEpSet      epSet;
-  char*       pMsg;
-  int32_t     msgLen;
-  void*       pExtension;  // todo remove it soon
-} SDclStmtInfo;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_PARSENODES_H_*/

include/libs/parser/parser.h

@@ -20,7 +20,7 @@
 extern "C" {
 #endif
 
-#include "parsenodes.h"
+#include "querynodes.h"
 
 typedef struct SParseContext {
   uint64_t         requestId;
@@ -32,67 +32,30 @@ typedef struct SParseContext {
   size_t           sqlLen;         // length of the sql string
   char            *pMsg;           // extended error message if exists to help identifying the problem in sql statement.
   int32_t          msgLen;         // max length of the msg
-
   struct SCatalog *pCatalog;
 } SParseContext;
 
-/**
- * Parse the sql statement and then return the SQueryStmtInfo as the result of bounded AST.
- * @param pSql     sql string
- * @param length   length of the sql string
- * @param id       operator id, generated by uuid generator
- * @param msg      extended error message if exists.
- * @return         error code
- */
-int32_t qParseQuerySql(SParseContext* pContext, SQueryNode** pQueryNode);
-
-/**
- * Return true if it is a ddl/dcl sql statement
- * @param pQuery
- * @return
- */
-bool qIsDdlQuery(const SQueryNode* pQueryNode);
-
-/**
- * Destroy logic query plan
- * @param pQueryNode
- */
-void qDestroyQuery(SQueryNode* pQueryNode);
-
-/**
- * Convert a normal sql statement to only query tags information to enable that the subscribe client can be aware quickly of the true vgroup ids that
- * involved in the subscribe procedure.
- * @param pSql
- * @param length
- * @param pConvertSql
- * @return
- */
-int32_t qParserConvertSql(const char* pStr, size_t length, char** pConvertSql);
-
-void assignExprInfo(SExprInfo* dst, const SExprInfo* src);
-void columnListCopy(SArray* dst, const SArray* src, uint64_t uid);
-void columnListDestroy(SArray* pColumnList);
-
-void dropAllExprInfo(SArray** pExprInfo, int32_t numOfLevel);
-void dropOneLevelExprInfo(SArray* pExprInfo);
-
-typedef struct SSourceParam {
-  SArray    *pExprNodeList; //Array<struct tExprNode*>
-  SArray    *pColumnList;   //Array<struct SColumn>
-  int32_t    num;
-} SSourceParam;
-
-SExprInfo* createExprInfo(STableMetaInfo* pTableMetaInfo, const char* funcName, SSourceParam* pSource, SSchema* pResSchema, int16_t interSize);
-int32_t copyExprInfoList(SArray* dst, const SArray* src, uint64_t uid, bool deepcopy);
-int32_t copyAllExprInfo(SArray* dst, const SArray* src, bool deepcopy);
-int32_t getExprFunctionLevel(const SQueryStmtInfo* pQueryInfo);
-
-STableMetaInfo* getMetaInfo(const SQueryStmtInfo* pQueryInfo, int32_t tableIndex);
-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);
+typedef struct SCmdMsgInfo {
+  int16_t msgType;
+  SEpSet epSet;
+  void* pMsg;
+  int32_t msgLen;
+  void* pExtension;  // todo remove it soon
+} SCmdMsgInfo;
+
+typedef struct SQuery {
+  bool directRpc;
+  bool haveResultSet;
+  SNode* pRoot;
+  int32_t numOfResCols;
+  SSchema* pResSchema;
+  SCmdMsgInfo* pCmdMsg;
+  int32_t msgType;
+} SQuery;
+
+int32_t qParseQuerySql(SParseContext* pCxt, SQuery** pQuery);
+
+void qDestroyQuery(SQuery* pQueryNode);
 
 #ifdef __cplusplus
 }

include/libs/planner/planner.h

@@ -20,192 +20,31 @@
 extern "C" {
 #endif
 
-#include "query.h"
-#include "tmsg.h"
-#include "tarray.h"
-#include "trpc.h"
+#include "plannodes.h"
 
-#define QUERY_TYPE_MERGE       1
-#define QUERY_TYPE_PARTIAL     2
-#define QUERY_TYPE_SCAN        3
-#define QUERY_TYPE_MODIFY      4
-
-enum OPERATOR_TYPE_E {
-  OP_Unknown,
-#define INCLUDE_AS_ENUM
-#include "plannerOp.h"
-#undef INCLUDE_AS_ENUM
-  OP_TotalNum
-};
-
-enum DATASINK_TYPE_E {
-  DSINK_Unknown,
-  DSINK_Dispatch,
-  DSINK_Insert,
-  DSINK_TotalNum
-};
-
-struct SEpSet;
-struct SQueryStmtInfo;
-
-typedef SSchema SSlotSchema;
-
-typedef struct SDataBlockSchema {
-  SSlotSchema *pSchema;
-  int32_t      numOfCols;    // number of columns
-  int32_t      resultRowSize;
-  int16_t      precision;
-} SDataBlockSchema;
-
-typedef struct SQueryNodeBasicInfo {
-  int32_t     type;          // operator type
-  const char *name;          // operator name
-} SQueryNodeBasicInfo;
-
-typedef struct SDataSink {
-  SQueryNodeBasicInfo info;
-  SDataBlockSchema schema;
-} SDataSink;
-
-typedef struct SDataDispatcher {
-  SDataSink sink;
-} SDataDispatcher;
-
-typedef struct SDataInserter {
-  SDataSink sink;
-  int32_t   numOfTables;
-  uint32_t  size;
-  char     *pData;
-} SDataInserter;
-
-typedef struct SPhyNode {
-  SQueryNodeBasicInfo info;
-  SArray             *pTargets;      // target list to be computed or scanned at this node
-  SArray             *pConditions;   // implicitly-ANDed qual conditions
-  SDataBlockSchema    targetSchema;
-  // children plan to generated result for current node to process
-  // in case of join, multiple plan nodes exist.
-  SArray             *pChildren;
-  struct SPhyNode    *pParent;
-} SPhyNode;
-
-typedef struct SScanPhyNode {
-  SPhyNode    node;
-  uint64_t    uid;           // unique id of the table
-  int8_t      tableType;
-  int32_t     order;         // scan order: TSDB_ORDER_ASC|TSDB_ORDER_DESC
-  int32_t     count;         // repeat count
-  int32_t     reverse;       // reverse scan count
-} SScanPhyNode;
-
-typedef SScanPhyNode SSystemTableScanPhyNode;
-typedef SScanPhyNode STagScanPhyNode;
-
-typedef struct STableScanPhyNode {
-  SScanPhyNode scan;
-  uint8_t      scanFlag;         // denotes reversed scan of data or not
-  STimeWindow  window;
-  SArray      *pTagsConditions; // implicitly-ANDed tag qual conditions
-} STableScanPhyNode;
-
-typedef STableScanPhyNode STableSeqScanPhyNode;
-
-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;  // SArray<SDownstreamSource>, scheduler fill by calling qSetSuplanExecutionNode
-} SExchangePhyNode;
-
-typedef enum EAggAlgo {
-	AGG_ALGO_PLAIN = 1, // simple agg across all input rows
-	AGG_ALGO_SORTED,    // grouped agg, input must be sorted
-	AGG_ALGO_HASHED     // grouped agg, use internal hashtable
-} EAggAlgo;
-
-typedef enum EAggSplit {
-	AGG_SPLIT_PRE = 1, // first level agg, maybe don't need calculate the final result
-	AGG_SPLIT_FINAL    // second level agg, must calculate the final result
-} EAggSplit;
-
-typedef struct SAggPhyNode {
-  SPhyNode    node;
-  EAggAlgo    aggAlgo;  // algorithm used by agg operator 
-  EAggSplit   aggSplit; // distributed splitting mode
-  SArray     *pExprs;   // SExprInfo list, these are expression list of group_by_clause and parameter expression of aggregate function
-  SArray     *pGroupByList; // SColIndex list, but these must be column node
-} SAggPhyNode;
-
-typedef struct SSubplanId {
-  uint64_t queryId;
-  uint64_t templateId;
-  uint64_t subplanId;
-} SSubplanId;
-
-typedef struct SSubplan {
-  SSubplanId id;           // unique id of the subplan
-  int32_t    type;         // QUERY_TYPE_MERGE|QUERY_TYPE_PARTIAL|QUERY_TYPE_SCAN|QUERY_TYPE_MODIFY
-  int32_t    msgType;      // message type for subplan, used to denote the send message type to vnode.
-  int32_t    level;        // the execution level of current subplan, starting from 0 in a top-down manner.
-  SQueryNodeAddr     execNode;    // for the scan/modify subplan, the optional execution node
-  SArray    *pChildren;    // the datasource subplan,from which to fetch the result
-  SArray    *pParents;     // the data destination subplan, get data from current subplan
-  SPhyNode  *pNode;        // physical plan of current subplan
-  SDataSink *pDataSink;    // data of the subplan flow into the datasink
-} SSubplan;
-
-typedef struct SQueryDag {
+typedef struct SPlanContext {
   uint64_t queryId;
-  int32_t  numOfSubplans;
-  SArray  *pSubplans; // SArray*<SArray*<SSubplan*>>. The execution level of subplan, starting from 0.
-} SQueryDag;
+  int32_t acctId;
+  SNode* pAstRoot;
+} SPlanContext;
 
-struct SQueryNode;
-
- /**
-  * Create the physical plan for the query, according to the AST.
-  * @param pQueryInfo
-  * @param pDag
-  * @param requestId
-  * @return
-  */
- int32_t qCreateQueryDag(const struct SQueryNode* pNode, struct SQueryDag** pDag, SSchema** pResSchema, int32_t* numOfCols, SArray* pNodeList, uint64_t requestId);
+// Create the physical plan for the query, according to the AST.
+int32_t qCreateQueryPlan(SPlanContext* pCxt, SQueryPlan** pPlan, SArray* pExecNodeList);
 
 // Set datasource of this subplan, multiple calls may be made to a subplan.
-// @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, SDownstreamSource* pSource);
+// @pSubplan subplan to be schedule
+// @groupId id of a group of datasource subplans of this @pSubplan
+// @pSource one execution location of this group of datasource subplans 
+int32_t qSetSubplanExecutionNode(SSubplan* pSubplan, int32_t groupId, SDownstreamSourceNode* pSource);
 
-int32_t qExplainQuery(const struct SQueryNode* pQueryInfo, struct SEpSet* pQnode, char** str);
-
-/**
- * Convert to subplan to string for the scheduler to send to the executor
- */
-int32_t qSubPlanToString(const SSubplan* subplan, char** str, int32_t* len);
+// Convert to subplan to string for the scheduler to send to the executor
+int32_t qSubPlanToString(const SSubplan* pSubplan, char** pStr, int32_t* pLen);
+int32_t qStringToSubplan(const char* pStr, SSubplan** pSubplan);
 
-int32_t qStringToSubplan(const char* str, SSubplan** subplan);
-
-void qDestroySubplan(SSubplan* pSubplan);
-
-/**
- * Destroy the physical plan.
- * @param pQueryPhyNode
- * @return
- */
-void qDestroyQueryDag(SQueryDag* pDag);
+char* qQueryPlanToString(const SQueryPlan* pPlan);
+SQueryPlan* qStringToQueryPlan(const char* pStr);
 
-char* qDagToString(const SQueryDag* pDag);
-SQueryDag* qStringToDag(const char* pStr);
+void qDestroyQueryPlan(SQueryPlan* pPlan);
 
 #ifdef __cplusplus
 }

include/libs/planner/plannerOp.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/>.
- */
-
-#if defined(INCLUDE_AS_ENUM)  // enum define mode
-  #undef OP_ENUM_MACRO
-  #define OP_ENUM_MACRO(op)    OP_##op,
-#elif defined(INCLUDE_AS_NAME)  // comment define mode
-  #undef OP_ENUM_MACRO
-  #define OP_ENUM_MACRO(op)    #op,
-#else
-  #error To use this include file, first define either INCLUDE_AS_ENUM or INCLUDE_AS_NAME
-#endif
-
-OP_ENUM_MACRO(StreamScan)
-OP_ENUM_MACRO(TableScan)
-OP_ENUM_MACRO(TableSeqScan)
-OP_ENUM_MACRO(TagScan)
-OP_ENUM_MACRO(SystemTableScan)
-OP_ENUM_MACRO(StreamBlockScan)
-OP_ENUM_MACRO(Aggregate)
-OP_ENUM_MACRO(Project)
-// OP_ENUM_MACRO(Groupby)
-OP_ENUM_MACRO(Limit)
-OP_ENUM_MACRO(SLimit)
-OP_ENUM_MACRO(TimeWindow)
-OP_ENUM_MACRO(SessionWindow)
-OP_ENUM_MACRO(StateWindow)
-OP_ENUM_MACRO(Fill)
-OP_ENUM_MACRO(MultiTableAggregate)
-OP_ENUM_MACRO(MultiTableTimeInterval)
-OP_ENUM_MACRO(Filter)
-OP_ENUM_MACRO(Distinct)
-OP_ENUM_MACRO(Join)
-OP_ENUM_MACRO(AllTimeWindow)
-OP_ENUM_MACRO(AllMultiTableTimeInterval)
-OP_ENUM_MACRO(Order)
-OP_ENUM_MACRO(Exchange)
-OP_ENUM_MACRO(SortedMerge)
-
-//OP_ENUM_MACRO(TableScan)

include/libs/qcom/query.h

@@ -35,7 +35,6 @@ enum {
   JOB_TASK_STATUS_CANCELLING,
   JOB_TASK_STATUS_CANCELLED,
   JOB_TASK_STATUS_DROPPING,
-  JOB_TASK_STATUS_FREEING,
 };
 
 enum {
@@ -85,7 +84,8 @@ typedef struct STableMeta {
 typedef struct SDBVgInfo {
   int32_t   vgVersion;
   int8_t    hashMethod;
-  SHashObj* vgHash;  // key:vgId, value:SVgroupInfo
+  int32_t   numOfTable;  // DB's table num, unit is TSDB_TABLE_NUM_UNIT
+  SHashObj *vgHash;  //key:vgId, value:SVgroupInfo
 } SDBVgInfo;
 
 typedef struct SUseDbOutput {
@@ -129,6 +129,11 @@ typedef struct SQueryNodeAddr {
   SEpSet  epSet;
 } SQueryNodeAddr;
 
+
+typedef struct SQueryNodeStat {
+  int32_t tableNum; // vg table number, unit is TSDB_TABLE_NUM_UNIT
+} SQueryNodeStat;
+
 int32_t initTaskQueue();
 int32_t cleanupTaskQueue();
 

include/libs/qworker/qworker.h

@@ -72,6 +72,8 @@ int32_t qWorkerProcessCancelMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg);
 
 int32_t qWorkerProcessDropMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg);
 
+int32_t qWorkerProcessHbMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg);
+
 int32_t qWorkerProcessShowMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg);
 
 int32_t qWorkerProcessShowFetchMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg);

include/libs/scheduler/scheduler.h

@@ -25,6 +25,7 @@ extern "C" {
 
 typedef struct SSchedulerCfg {
   uint32_t maxJobNum;
+  int32_t  maxNodeTableNum;
 } SSchedulerCfg;
 
 typedef struct SQueryProfileSummary {
@@ -70,7 +71,7 @@ int32_t schedulerInit(SSchedulerCfg *cfg);
  * @param nodeList  Qnode/Vnode address list, element is SQueryNodeAddr
  * @return
  */
-int32_t schedulerExecJob(void *transport, SArray *nodeList, SQueryDag* pDag, int64_t *pJob, const char* sql, SQueryResult *pRes);
+int32_t schedulerExecJob(void *transport, SArray *nodeList, SQueryPlan* pDag, int64_t* pJob, const char* sql, SQueryResult *pRes);
 
 /**
  * Process the query job, generated according to the query physical plan.
@@ -78,7 +79,7 @@ int32_t schedulerExecJob(void *transport, SArray *nodeList, SQueryDag* pDag, int
  * @param pNodeList  Qnode/Vnode address list, element is SQueryNodeAddr
  * @return
  */
-int32_t schedulerAsyncExecJob(void *transport, SArray *pNodeList, SQueryDag* pDag, const char* sql, int64_t *pJob);
+int32_t schedulerAsyncExecJob(void *transport, SArray *pNodeList, SQueryPlan* pDag, const char* sql, int64_t *pJob);
 
 /**
  * Fetch query result from the remote query executor
@@ -110,7 +111,7 @@ void schedulerDestroy(void);
  * @param pTasks SArray**<STaskInfo>
  * @return
  */
-int32_t schedulerConvertDagToTaskList(SQueryDag* pDag, SArray **pTasks);
+int32_t schedulerConvertDagToTaskList(SQueryPlan* pDag, SArray **pTasks);
 
 /**
  * make one task info's multiple copies

include/util/taoserror.h

@@ -460,6 +460,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_SCH_INTERNAL_ERROR            TAOS_DEF_ERROR_CODE(0, 0x2502)
 
 //parser
+#define TSDB_CODE_PAR_SYNTAX_ERROR              TAOS_DEF_ERROR_CODE(0, 0x2600)
 #define TSDB_CODE_PAR_INVALID_COLUMN            TAOS_DEF_ERROR_CODE(0, 0x2601)
 #define TSDB_CODE_PAR_TABLE_NOT_EXIST           TAOS_DEF_ERROR_CODE(0, 0x2602)
 #define TSDB_CODE_PAR_AMBIGUOUS_COLUMN          TAOS_DEF_ERROR_CODE(0, 0x2603)
@@ -472,6 +473,13 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_GROUPBY_LACK_EXPRESSION   TAOS_DEF_ERROR_CODE(0, 0x260A)
 #define TSDB_CODE_PAR_NOT_SELECTED_EXPRESSION   TAOS_DEF_ERROR_CODE(0, 0x260B)
 #define TSDB_CODE_PAR_NOT_SINGLE_GROUP          TAOS_DEF_ERROR_CODE(0, 0x260C) 
+#define TSDB_CODE_PAR_TAGS_NOT_MATCHED          TAOS_DEF_ERROR_CODE(0, 0x260D)
+#define TSDB_CODE_PAR_INVALID_TAG_NAME          TAOS_DEF_ERROR_CODE(0, 0x260E)
+#define TSDB_CODE_PAR_INCOMPLETE_SQL            TAOS_DEF_ERROR_CODE(0, 0x260F)
+#define TSDB_CODE_PAR_NAME_OR_PASSWD_TOO_LONG   TAOS_DEF_ERROR_CODE(0, 0x2610)
+#define TSDB_CODE_PAR_PASSWD_EMPTY              TAOS_DEF_ERROR_CODE(0, 0x2611)
+#define TSDB_CODE_PAR_INVALID_PORT              TAOS_DEF_ERROR_CODE(0, 0x2612)
+#define TSDB_CODE_PAR_INVALID_ENDPOINT          TAOS_DEF_ERROR_CODE(0, 0x2613)
 
 #ifdef __cplusplus
 }

include/util/tdef.h

@@ -345,6 +345,20 @@ typedef enum ELogicConditionType {
 #define TSDB_MAX_DB_QUORUM_OPTION     2
 #define TSDB_DEFAULT_DB_QUORUM_OPTION 1
 
+#define TSDB_MIN_DB_TTL_OPTION          1
+#define TSDB_DEFAULT_DB_TTL_OPTION      0
+
+#define TSDB_MIN_DB_SINGLE_STABLE_OPTION          0
+#define TSDB_MAX_DB_SINGLE_STABLE_OPTION          1
+#define TSDB_DEFAULT_DB_SINGLE_STABLE_OPTION      0
+
+#define TSDB_MIN_DB_STREAM_MODE_OPTION          0
+#define TSDB_MAX_DB_STREAM_MODE_OPTION          1
+#define TSDB_DEFAULT_DB_STREAM_MODE_OPTION      0
+
+#define TSDB_MAX_JOIN_TABLE_NUM         10
+#define TSDB_MAX_UNION_CLAUSE           5
+
 #define TSDB_MIN_DB_UPDATE            0
 #define TSDB_MAX_DB_UPDATE            2
 #define TSDB_DEFAULT_DB_UPDATE_OPTION 0

include/util/tjson.h

@@ -54,10 +54,12 @@ typedef int32_t (*FToJson)(const void* pObj, SJson* pJson);
 
 int32_t tjsonAddObject(SJson* pJson, const char* pName, FToJson func, const void* pObj);
 int32_t tjsonAddItem(SJson* pJson, FToJson func, const void* pObj);
+int32_t tjsonAddArray(SJson* pJson, const char* pName, FToJson func, const void* pArray, int32_t itemSize, int32_t num);
 
 typedef int32_t (*FToObject)(const SJson* pJson, void* pObj);
 
 int32_t tjsonToObject(const SJson* pJson, const char* pName, FToObject func, void* pObj);
+int32_t tjsonToArray(const SJson* pJson, const char* pName, FToObject func, void* pArray, int32_t itemSize);
 
 char* tjsonToString(const SJson* pJson);
 char* tjsonToUnformattedString(const SJson* pJson);

source/client/CMakeLists.txt

@@ -8,7 +8,7 @@ target_include_directories(
 target_link_libraries(
     taos
     INTERFACE api
-    PRIVATE os util common transport parser planner catalog scheduler function qcom
+    PRIVATE os util common transport nodes parser planner catalog scheduler function qcom
 )
 
 if(${BUILD_TEST})

source/client/inc/clientInt.h

@@ -168,7 +168,7 @@ typedef struct SRequestSendRecvBody {
   SShowReqInfo       showInfo;  // todo this attribute will be removed after the query framework being completed.
   SDataBuf           requestMsg;
   int64_t            queryJob;  // query job, created according to sql query DAG.
-  struct SQueryDag* pDag;      // the query dag, generated according to the sql statement.
+  struct SQueryPlan* pDag;       // the query dag, generated according to the sql statement.
   SReqResultInfo     resInfo;
 } SRequestSendRecvBody;
 
@@ -228,7 +228,7 @@ void setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32_t
 
 int32_t buildRequest(STscObj* pTscObj, const char* sql, int sqlLen, SRequestObj** pRequest);
 
-int32_t parseSql(SRequestObj* pRequest, SQueryNode** pQuery);
+int32_t parseSql(SRequestObj* pRequest, SQuery** pQuery);
 
 // --- heartbeat
 // global, called by mgmt

source/client/src/clientEnv.c

@@ -184,7 +184,7 @@ static void doDestroyRequest(void *p) {
   tfree(pRequest->pInfo);
 
   doFreeReqResultInfo(&pRequest->body.resInfo);
-  qDestroyQueryDag(pRequest->body.pDag);
+  qDestroyQueryPlan(pRequest->body.pDag);
 
   if (pRequest->body.showInfo.pArray != NULL) {
     taosArrayDestroy(pRequest->body.showInfo.pArray);

source/client/src/clientHb.c

@@ -224,6 +224,7 @@ int32_t hbGetExpiredDBInfo(SClientHbKey *connKey, struct SCatalog *pCatalog, SCl
     SDbVgVersion *db = &dbs[i];
     db->dbId = htobe64(db->dbId);
     db->vgVersion = htonl(db->vgVersion);
+    db->numOfTable = htonl(db->numOfTable);
   }
 
   SKv kv = {
@@ -434,11 +435,11 @@ static int32_t hbCreateThread() {
   pthread_attr_init(&thAttr);
   pthread_attr_setdetachstate(&thAttr, PTHREAD_CREATE_JOINABLE);
 
-  if (pthread_create(&clientHbMgr.thread, &thAttr, hbThreadFunc, NULL) != 0) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    return -1;
-  }
-  pthread_attr_destroy(&thAttr);
+//  if (pthread_create(&clientHbMgr.thread, &thAttr, hbThreadFunc, NULL) != 0) {
+//    terrno = TAOS_SYSTEM_ERROR(errno);
+//    return -1;
+//  }
+//  pthread_attr_destroy(&thAttr);
   return 0;
 }
 

source/client/src/clientImpl.c

@@ -139,7 +139,7 @@ int32_t buildRequest(STscObj* pTscObj, const char* sql, int sqlLen, SRequestObj*
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t parseSql(SRequestObj* pRequest, SQueryNode** pQuery) {
+int32_t parseSql(SRequestObj* pRequest, SQuery** pQuery) {
   STscObj* pTscObj = pRequest->pTscObj;
 
   SParseContext cxt = {
@@ -161,53 +161,44 @@ int32_t parseSql(SRequestObj* pRequest, SQueryNode** pQuery) {
   }
 
   code = qParseQuerySql(&cxt, pQuery);
+  if (TSDB_CODE_SUCCESS == code && ((*pQuery)->haveResultSet)) {
+    setResSchemaInfo(&pRequest->body.resInfo, (*pQuery)->pResSchema, (*pQuery)->numOfResCols);
+  }
 
   tfree(cxt.db);
   return code;
 }
 
-int32_t execDdlQuery(SRequestObj* pRequest, SQueryNode* pQuery) {
-  SDclStmtInfo* pDcl = (SDclStmtInfo*)pQuery;
-  pRequest->type = pDcl->msgType;
-  pRequest->body.requestMsg = (SDataBuf){.pData = pDcl->pMsg, .len = pDcl->msgLen, .handle = NULL};
+int32_t execDdlQuery(SRequestObj* pRequest, SQuery* pQuery) {
+  SCmdMsgInfo* pMsgInfo = pQuery->pCmdMsg;
+  pRequest->type = pMsgInfo->msgType;
+  pRequest->body.requestMsg = (SDataBuf){.pData = pMsgInfo->pMsg, .len = pMsgInfo->msgLen, .handle = NULL};
+  pMsgInfo->pMsg = NULL; // pMsg transferred to SMsgSendInfo management
 
   STscObj*      pTscObj = pRequest->pTscObj;
   SMsgSendInfo* pSendMsg = buildMsgInfoImpl(pRequest);
 
-  int64_t transporterId = 0;
-  if (pDcl->msgType == TDMT_VND_CREATE_TABLE || pDcl->msgType == TDMT_VND_SHOW_TABLES) {
-    if (pDcl->msgType == TDMT_VND_SHOW_TABLES) {
+  if (pMsgInfo->msgType == TDMT_VND_SHOW_TABLES) {
     SShowReqInfo* pShowReqInfo = &pRequest->body.showInfo;
     if (pShowReqInfo->pArray == NULL) {
       pShowReqInfo->currentIndex = 0;  // set the first vnode/ then iterate the next vnode
-        pShowReqInfo->pArray = pDcl->pExtension;
+      pShowReqInfo->pArray = pMsgInfo->pExtension;
     }
   }
-    asyncSendMsgToServer(pTscObj->pAppInfo->pTransporter, &pDcl->epSet, &transporterId, pSendMsg);
-  } else {
-    asyncSendMsgToServer(pTscObj->pAppInfo->pTransporter, &pDcl->epSet, &transporterId, pSendMsg);
-  }
+  int64_t transporterId = 0;
+  asyncSendMsgToServer(pTscObj->pAppInfo->pTransporter, &pMsgInfo->epSet, &transporterId, pSendMsg);
 
   tsem_wait(&pRequest->body.rspSem);
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t getPlan(SRequestObj* pRequest, SQueryNode* pQueryNode, SQueryDag** pDag, SArray* pNodeList) {
-  pRequest->type = pQueryNode->type;
-
-  SSchema* pSchema = NULL;
-  int32_t  numOfCols = 0;
-  int32_t  code = qCreateQueryDag(pQueryNode, pDag, &pSchema, &numOfCols, pNodeList, pRequest->requestId);
+int32_t getPlan(SRequestObj* pRequest, SQuery* pQuery, SQueryPlan** pPlan, SArray* pNodeList) {
+  pRequest->type = pQuery->msgType;
+  SPlanContext cxt = { .queryId = pRequest->requestId, .pAstRoot = pQuery->pRoot, .acctId = pRequest->pTscObj->acctId };
+  int32_t  code = qCreateQueryPlan(&cxt, pPlan, pNodeList);
   if (code != 0) {
     return code;
   }
-
-  if (pQueryNode->type == TSDB_SQL_SELECT) {
-    setResSchemaInfo(&pRequest->body.resInfo, pSchema, numOfCols);
-    pRequest->type = TDMT_VND_QUERY;
-  }
-
-  tfree(pSchema);
   return code;
 }
 
@@ -224,7 +215,7 @@ void setResSchemaInfo(SReqResultInfo* pResInfo, const SSchema* pSchema, int32_t
   }
 }
 
-int32_t scheduleQuery(SRequestObj* pRequest, SQueryDag* pDag, SArray* pNodeList) {
+int32_t scheduleQuery(SRequestObj* pRequest, SQueryPlan* pDag, SArray* pNodeList) {
   void* pTransporter = pRequest->pTscObj->pAppInfo->pTransporter;
   SQueryResult res = {.code = 0, .numOfRows = 0, .msgSize = ERROR_MSG_BUF_DEFAULT_SIZE, .msg = pRequest->msgBuf};
   int32_t      code = schedulerExecJob(pTransporter, pNodeList, pDag, &pRequest->body.queryJob, pRequest->sqlstr, &res);
@@ -237,7 +228,7 @@ int32_t scheduleQuery(SRequestObj* pRequest, SQueryDag* pDag, SArray* pNodeList)
     return pRequest->code;
   }
 
-  if (TSDB_SQL_INSERT == pRequest->type || TSDB_SQL_CREATE_TABLE == pRequest->type) {
+  if (TDMT_VND_SUBMIT == pRequest->type || TDMT_VND_CREATE_TABLE == pRequest->type) {
     pRequest->body.resInfo.numOfRows = res.numOfRows;
     
     if (pRequest->body.queryJob != 0) {
@@ -258,24 +249,24 @@ TAOS_RES* taos_query_l(TAOS* taos, const char* sql, int sqlLen) {
   }
 
   SRequestObj* pRequest = NULL;
-  SQueryNode*  pQueryNode = NULL;
+  SQuery* pQuery = NULL;
   SArray* pNodeList = taosArrayInit(4, sizeof(struct SQueryNodeAddr));
 
   terrno = TSDB_CODE_SUCCESS;
   CHECK_CODE_GOTO(buildRequest(pTscObj, sql, sqlLen, &pRequest), _return);
-  CHECK_CODE_GOTO(parseSql(pRequest, &pQueryNode), _return);
+  CHECK_CODE_GOTO(parseSql(pRequest, &pQuery), _return);
 
-  if (qIsDdlQuery(pQueryNode)) {
-    CHECK_CODE_GOTO(execDdlQuery(pRequest, pQueryNode), _return);
+  if (pQuery->directRpc) {
+    CHECK_CODE_GOTO(execDdlQuery(pRequest, pQuery), _return);
   } else {
-    CHECK_CODE_GOTO(getPlan(pRequest, pQueryNode, &pRequest->body.pDag, pNodeList), _return);
+    CHECK_CODE_GOTO(getPlan(pRequest, pQuery, &pRequest->body.pDag, pNodeList), _return);
     CHECK_CODE_GOTO(scheduleQuery(pRequest, pRequest->body.pDag, pNodeList), _return);
     pRequest->code = terrno;
   }
 
 _return:
   taosArrayDestroy(pNodeList);
-  qDestroyQuery(pQueryNode);
+  qDestroyQuery(pQuery);
   if (NULL != pRequest && TSDB_CODE_SUCCESS != terrno) {
     pRequest->code = terrno;
   }

source/client/src/tmq.c

@@ -459,7 +459,7 @@ void tmq_conf_set_offset_commit_cb(tmq_conf_t* conf, tmq_commit_cb* cb) { conf->
 TAOS_RES* tmq_create_topic(TAOS* taos, const char* topicName, const char* sql, int sqlLen) {
   STscObj*     pTscObj = (STscObj*)taos;
   SRequestObj* pRequest = NULL;
-  SQueryNode*  pQueryNode = NULL;
+  SQuery*  pQueryNode = NULL;
   char*        pStr = NULL;
 
   terrno = TSDB_CODE_SUCCESS;
@@ -482,7 +482,7 @@ TAOS_RES* tmq_create_topic(TAOS* taos, const char* topicName, const char* sql, i
   }
 
   tscDebug("start to create topic, %s", topicName);
-
+#if 0
   CHECK_CODE_GOTO(buildRequest(pTscObj, sql, sqlLen, &pRequest), _return);
   CHECK_CODE_GOTO(parseSql(pRequest, &pQueryNode), _return);
 
@@ -538,7 +538,7 @@ TAOS_RES* tmq_create_topic(TAOS* taos, const char* topicName, const char* sql, i
   asyncSendMsgToServer(pTscObj->pAppInfo->pTransporter, &epSet, &transporterId, sendInfo);
 
   tsem_wait(&pRequest->body.rspSem);
-
+#endif
 _return:
   qDestroyQuery(pQueryNode);
   /*if (sendInfo != NULL) {*/

source/client/test/clientTests.cpp

@@ -53,7 +53,6 @@ TEST(testCase, driverInit_Test) {
 //  taos_init();
 }
 
-#if 1
 TEST(testCase, connect_Test) {
 //  taos_options(TSDB_OPTION_CONFIGDIR, "/home/ubuntu/first/cfg");
 
@@ -564,20 +563,18 @@ TEST(testCase, insert_test) {
   taos_free_result(pRes);
   taos_close(pConn);
 }
-#endif
-
 
 TEST(testCase, projection_query_tables) {
   TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
   ASSERT_NE(pConn, nullptr);
 
-  TAOS_RES* pRes = taos_query(pConn, "create database if not exists abc1 vgroups 2");
-  if (taos_errno(pRes) != 0) {
-    printf("error in create db, reason:%s\n", taos_errstr(pRes));
-  }
-  taos_free_result(pRes);
+//  TAOS_RES* pRes = taos_query(pConn, "create database if not exists abc1 vgroups 2");
+//  if (taos_errno(pRes) != 0) {
+//    printf("error in create db, reason:%s\n", taos_errstr(pRes));
+//  }
+//  taos_free_result(pRes);
 
-  pRes = taos_query(pConn, "use abc1");
+  TAOS_RES* pRes = taos_query(pConn, "use abc1");
   taos_free_result(pRes);
 
   pRes = taos_query(pConn, "create stable st1 (ts timestamp, k int) tags(a int)");
@@ -592,7 +589,7 @@ TEST(testCase, projection_query_tables) {
   }
   taos_free_result(pRes);
 
-  for(int32_t i = 0; i < 10000000; ++i) {
+  for(int32_t i = 0; i < 10000; ++i) {
     char sql[512] = {0};
     sprintf(sql, "insert into tu values(now+%da, %d)", i, i);
     TAOS_RES* p = taos_query(pConn, sql);
@@ -623,7 +620,6 @@ TEST(testCase, projection_query_tables) {
   taos_free_result(pRes);
   taos_close(pConn);
 }
-#if 0
 
 TEST(testCase, projection_query_stables) {
   TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
@@ -686,6 +682,5 @@ TEST(testCase, agg_query_tables) {
   taos_free_result(pRes);
   taos_close(pConn);
 }
-#endif
 
 #pragma GCC diagnostic pop

source/common/src/tdatablock.c

@@ -239,7 +239,7 @@ int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, uint32_t numOfRow1, co
   return numOfRow1 + numOfRow2;
 }
 
-size_t colDataGetNumOfCols(const SSDataBlock* pBlock) {
+size_t blockDataGetNumOfCols(const SSDataBlock* pBlock) {
   ASSERT(pBlock);
 
   size_t constantCols = (pBlock->pConstantList != NULL)? taosArrayGetSize(pBlock->pConstantList):0;
@@ -247,7 +247,7 @@ size_t colDataGetNumOfCols(const SSDataBlock* pBlock) {
   return pBlock->info.numOfCols;
 }
 
-size_t colDataGetNumOfRows(const SSDataBlock* pBlock) {
+size_t blockDataGetNumOfRows(const SSDataBlock* pBlock) {
   return pBlock->info.rows;
 }
 

source/common/src/tmsg.c

@@ -1007,11 +1007,32 @@ int32_t tDeserializeSMCreateDropQSBNodeReq(void *buf, int32_t bufLen, SMCreateQn
 }
 
 int32_t tSerializeSDropDnodeReq(void *buf, int32_t bufLen, SDropDnodeReq *pReq) {
-  return tSerializeSMCreateDropQSBNodeReq(buf, bufLen, (SMCreateQnodeReq *)pReq);
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->dnodeId) < 0) return -1;
+  if (tEncodeCStr(&encoder, pReq->fqdn) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->port) < 0) return -1;
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tCoderClear(&encoder);
+  return tlen;
 }
 
 int32_t tDeserializeSDropDnodeReq(void *buf, int32_t bufLen, SDropDnodeReq *pReq) {
-  return tDeserializeSMCreateDropQSBNodeReq(buf, bufLen, (SMCreateQnodeReq *)pReq);
+  SCoder decoder = {0};
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->dnodeId) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pReq->fqdn) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->port) < 0) return -1;
+  tEndDecode(&decoder);
+
+  tCoderClear(&decoder);
+  return 0;
 }
 
 int32_t tSerializeSMCreateDropMnodeReq(void *buf, int32_t bufLen, SMCreateMnodeReq *pReq) {
@@ -1423,6 +1444,7 @@ int32_t tSerializeSUseDbReq(void *buf, int32_t bufLen, SUseDbReq *pReq) {
   if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
   if (tEncodeI64(&encoder, pReq->dbId) < 0) return -1;
   if (tEncodeI32(&encoder, pReq->vgVersion) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->numOfTable) < 0) return -1;
   tEndEncode(&encoder);
 
   int32_t tlen = encoder.pos;
@@ -1438,12 +1460,77 @@ int32_t tDeserializeSUseDbReq(void *buf, int32_t bufLen, SUseDbReq *pReq) {
   if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
   if (tDecodeI64(&decoder, &pReq->dbId) < 0) return -1;
   if (tDecodeI32(&decoder, &pReq->vgVersion) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->numOfTable) < 0) return -1;
+  tEndDecode(&decoder);
+
+  tCoderClear(&decoder);
+  return 0;
+}
+
+
+int32_t tSerializeSQnodeListReq(void* buf, int32_t bufLen, SQnodeListReq* pReq) {
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->rowNum) < 0) return -1;
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tCoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSQnodeListReq(void *buf, int32_t bufLen, SQnodeListReq *pReq) {
+  SCoder decoder = {0};
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->rowNum) < 0) return -1;
   tEndDecode(&decoder);
 
   tCoderClear(&decoder);
   return 0;
 }
 
+int32_t tSerializeSQnodeListRsp(void *buf, int32_t bufLen, SQnodeListRsp *pRsp) {
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  int32_t num = taosArrayGetSize(pRsp->epSetList);
+  if (tEncodeI32(&encoder, num) < 0) return -1;    
+  for (int32_t i = 0; i < num; ++i) {
+    SEpSet *epSet = taosArrayGet(pRsp->epSetList, i);
+    if (tEncodeSEpSet(&encoder, epSet) < 0) return -1;
+  }
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tCoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSQnodeListRsp(void *buf, int32_t bufLen, SQnodeListRsp *pRsp) {
+  SCoder decoder = {0};
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  int32_t num = 0;
+  if (tDecodeI32(&decoder, &num) < 0) return -1;
+  pRsp->epSetList = taosArrayInit(num, sizeof(SEpSet));
+  if (NULL == pRsp->epSetList) return -1;
+  for (int32_t i = 0; i < num; ++i) {
+    if (tDecodeSEpSet(&decoder, TARRAY_GET_ELEM(pRsp->epSetList, i)) < 0) return -1;
+  }
+  tEndDecode(&decoder);
+
+  tCoderClear(&decoder);
+  return 0;
+}
+
+void tFreeSQnodeListRsp(SQnodeListRsp *pRsp) { taosArrayDestroy(pRsp->epSetList); }
+
 int32_t tSerializeSSyncDbReq(void *buf, int32_t bufLen, SSyncDbReq *pReq) {
   SCoder encoder = {0};
   tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
@@ -1482,6 +1569,7 @@ static int32_t tSerializeSUseDbRspImp(SCoder *pEncoder, SUseDbRsp *pRsp) {
     if (tEncodeU32(pEncoder, pVgInfo->hashBegin) < 0) return -1;
     if (tEncodeU32(pEncoder, pVgInfo->hashEnd) < 0) return -1;
     if (tEncodeSEpSet(pEncoder, &pVgInfo->epSet) < 0) return -1;
+    if (tEncodeI32(pEncoder, pVgInfo->numOfTable) < 0) return -1;
   }
 
   return 0;
@@ -1542,6 +1630,7 @@ int32_t tDeserializeSUseDbRspImp(SCoder *pDecoder, SUseDbRsp *pRsp) {
     if (tDecodeU32(pDecoder, &vgInfo.hashBegin) < 0) return -1;
     if (tDecodeU32(pDecoder, &vgInfo.hashEnd) < 0) return -1;
     if (tDecodeSEpSet(pDecoder, &vgInfo.epSet) < 0) return -1;
+    if (tDecodeI32(pDecoder, &vgInfo.numOfTable) < 0) return -1;
     taosArrayPush(pRsp->pVgroupInfos, &vgInfo);
   }
 
@@ -2391,6 +2480,149 @@ int32_t tDecodeSMqCMCommitOffsetReq(SCoder *decoder, SMqCMCommitOffsetReq *pReq)
   return 0;
 }
 
+int32_t tSerializeSSchedulerHbReq(void *buf, int32_t bufLen, SSchedulerHbReq *pReq) {
+  int32_t headLen = sizeof(SMsgHead);
+  if (buf != NULL) {
+    buf = (char *)buf + headLen;
+    bufLen -= headLen;
+  }
+
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeU64(&encoder, pReq->sId) < 0) return -1; 
+  if (tEncodeI32(&encoder, pReq->epId.nodeId) < 0) return -1; 
+  if (tEncodeU16(&encoder, pReq->epId.ep.port) < 0) return -1;
+  if (tEncodeCStr(&encoder, pReq->epId.ep.fqdn) < 0) return -1;  
+  if (pReq->taskAction) {
+    int32_t num = taosArrayGetSize(pReq->taskAction);
+    if (tEncodeI32(&encoder, num) < 0) return -1;    
+    for (int32_t i = 0; i < num; ++i) {
+      STaskAction *action = taosArrayGet(pReq->taskAction, i);
+      if (tEncodeU64(&encoder, action->queryId) < 0) return -1;    
+      if (tEncodeU64(&encoder, action->taskId) < 0) return -1;    
+      if (tEncodeI8(&encoder, action->action) < 0) return -1;    
+    }
+  } else {
+    if (tEncodeI32(&encoder, 0) < 0) return -1;    
+  }
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tCoderClear(&encoder);
+  
+  if (buf != NULL) {
+    SMsgHead *pHead = (SMsgHead *)((char *)buf - headLen);
+    pHead->vgId = htonl(pReq->header.vgId);
+    pHead->contLen = htonl(tlen + headLen);
+  }
+
+  return tlen + headLen;
+}
+
+int32_t tDeserializeSSchedulerHbReq(void *buf, int32_t bufLen, SSchedulerHbReq *pReq) {
+  int32_t headLen = sizeof(SMsgHead);
+
+  SMsgHead *pHead = buf;
+  pHead->vgId = pReq->header.vgId;
+  pHead->contLen = pReq->header.contLen;
+
+  SCoder decoder = {0};
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, (char *)buf + headLen, bufLen - headLen, TD_DECODER);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeU64(&decoder, &pReq->sId) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->epId.nodeId) < 0) return -1;
+  if (tDecodeU16(&decoder, &pReq->epId.ep.port) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pReq->epId.ep.fqdn) < 0) return -1;
+  int32_t num = 0;
+  if (tDecodeI32(&decoder, &num) < 0) return -1;
+  if (num > 0) {
+    pReq->taskAction = taosArrayInit(num, sizeof(STaskStatus));
+    if (NULL == pReq->taskAction) return -1;
+    for (int32_t i = 0; i < num; ++i) {
+      STaskAction action = {0};
+      if (tDecodeU64(&decoder, &action.queryId) < 0) return -1;
+      if (tDecodeU64(&decoder, &action.taskId) < 0) return -1;
+      if (tDecodeI8(&decoder, &action.action) < 0) return -1;
+      taosArrayPush(pReq->taskAction, &action);
+    }
+  } else {
+    pReq->taskAction = NULL;
+  }
+  tEndDecode(&decoder);
+
+  tCoderClear(&decoder);
+  return 0;
+}
+
+void tFreeSSchedulerHbReq(SSchedulerHbReq *pReq) { taosArrayDestroy(pReq->taskAction); }
+
+
+
+int32_t tSerializeSSchedulerHbRsp(void *buf, int32_t bufLen, SSchedulerHbRsp *pRsp) {
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeU64(&encoder, pRsp->seqId) < 0) return -1;    
+  if (tEncodeI32(&encoder, pRsp->epId.nodeId) < 0) return -1;    
+  if (tEncodeU16(&encoder, pRsp->epId.ep.port) < 0) return -1;
+  if (tEncodeCStr(&encoder, pRsp->epId.ep.fqdn) < 0) return -1;  
+  if (pRsp->taskStatus) {
+    int32_t num = taosArrayGetSize(pRsp->taskStatus);
+    if (tEncodeI32(&encoder, num) < 0) return -1;    
+    for (int32_t i = 0; i < num; ++i) {
+      STaskStatus *status = taosArrayGet(pRsp->taskStatus, i);
+      if (tEncodeU64(&encoder, status->queryId) < 0) return -1;    
+      if (tEncodeU64(&encoder, status->taskId) < 0) return -1;    
+      if (tEncodeI64(&encoder, status->refId) < 0) return -1;    
+      if (tEncodeI8(&encoder, status->status) < 0) return -1;    
+    }
+  } else {
+    if (tEncodeI32(&encoder, 0) < 0) return -1;    
+  }
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tCoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSSchedulerHbRsp(void *buf, int32_t bufLen, SSchedulerHbRsp *pRsp) {
+  SCoder decoder = {0};
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeU64(&decoder, &pRsp->seqId) < 0) return -1;
+  if (tDecodeI32(&decoder, &pRsp->epId.nodeId) < 0) return -1;
+  if (tDecodeU16(&decoder, &pRsp->epId.ep.port) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pRsp->epId.ep.fqdn) < 0) return -1;
+  int32_t num = 0;
+  if (tDecodeI32(&decoder, &num) < 0) return -1;
+  if (num > 0) {
+    pRsp->taskStatus = taosArrayInit(num, sizeof(STaskStatus));
+    if (NULL == pRsp->taskStatus) return -1;
+    for (int32_t i = 0; i < num; ++i) {
+      STaskStatus status = {0};
+      if (tDecodeU64(&decoder, &status.queryId) < 0) return -1;
+      if (tDecodeU64(&decoder, &status.taskId) < 0) return -1;
+      if (tDecodeI64(&decoder, &status.refId) < 0) return -1;
+      if (tDecodeI8(&decoder, &status.status) < 0) return -1;
+      taosArrayPush(pRsp->taskStatus, &status);
+    }
+  } else {
+    pRsp->taskStatus = NULL;
+  }
+  tEndDecode(&decoder);
+
+  tCoderClear(&decoder);
+  return 0;
+}
+
+void tFreeSSchedulerHbRsp(SSchedulerHbRsp *pRsp) { taosArrayDestroy(pRsp->taskStatus); }
+
 int32_t tSerializeSVCreateTSmaReq(void **buf, SVCreateTSmaReq *pReq) {
   int32_t tlen = 0;
 

source/common/src/tvariant.c

@@ -94,11 +94,11 @@ void taosVariantCreate(SVariant *pVar, const char *z, int32_t n, int32_t type) {
       bool sign = true;
 
       int32_t base = 10;
-      if (type == TK_HEX) {
+      if (type == TK_NK_HEX) {
         base = 16;
-      } else if (type == TK_OCT) {
+      } else if (type == TK_NK_OCT) {
         base = 8;
-      } else if (type == TK_BIN) {
+      } else if (type == TK_NK_BIN) {
         base = 2;
       }
 

source/common/test/commonTests.cpp

@@ -160,8 +160,8 @@ TEST(testCase, Datablock_test) {
 
   printf("binary column length:%d\n", *(int32_t*) p1->pData);
 
-  ASSERT_EQ(colDataGetNumOfCols(b), 2);
-  ASSERT_EQ(colDataGetNumOfRows(b), 40);
+  ASSERT_EQ(blockDataGetNumOfCols(b), 2);
+  ASSERT_EQ(blockDataGetNumOfRows(b), 40);
 
   char* pData = colDataGetData(p1, 3);
   printf("the second row of binary:%s, length:%d\n", (char*)varDataVal(pData), varDataLen(pData));

source/dnode/mgmt/impl/src/dndTransport.c

@@ -152,6 +152,7 @@ static void dndInitMsgFp(STransMgmt *pMgmt) {
   pMgmt->msgFp[TMSG_INDEX(TDMT_VND_MQ_REB)] = dndProcessVnodeWriteMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_VND_MQ_SET_CUR)] = dndProcessVnodeFetchMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_VND_CONSUME)] = dndProcessVnodeFetchMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_VND_QUERY_HEARTBEAT)] = dndProcessVnodeFetchMsg;
 }
 
 static void dndProcessResponse(void *parent, SRpcMsg *pRsp, SEpSet *pEpSet) {

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

@@ -354,6 +354,23 @@ typedef struct {
   char    payload[];
 } SShowObj;
 
+typedef struct {
+  int64_t id;
+  int8_t  type;
+  int8_t  replica;
+  int16_t numOfColumns;
+  int32_t rowSize;
+  int32_t numOfRows;
+  int32_t numOfReads;
+  int32_t payloadLen;
+  void*   pIter;
+  SMnode* pMnode;
+  char    db[TSDB_DB_FNAME_LEN];
+  int16_t offset[TSDB_MAX_COLUMNS];
+  int32_t bytes[TSDB_MAX_COLUMNS];
+  char    payload[];
+} SSysTableRetrieveObj;
+
 typedef struct {
   int32_t vgId;  // -1 for unassigned
   int32_t status;

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

@@ -885,6 +885,29 @@ DROP_DB_OVER:
   return code;
 }
 
+void mndGetDBTableNum(SDbObj *pDb, SMnode *pMnode, int32_t *num) {
+  int32_t vindex = 0;
+  SSdb   *pSdb = pMnode->pSdb;
+
+  void *pIter = NULL;
+  while (vindex < pDb->cfg.numOfVgroups) {
+    SVgObj *pVgroup = NULL;
+    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);
+    if (pIter == NULL) break;
+
+    if (pVgroup->dbUid == pDb->uid) {
+      *num += pVgroup->numOfTables / TSDB_TABLE_NUM_UNIT;
+
+      vindex++;
+    }
+
+    sdbRelease(pSdb, pVgroup);
+  }
+
+  sdbCancelFetch(pSdb, pIter);
+}
+
+
 static void mndBuildDBVgroupInfo(SDbObj *pDb, SMnode *pMnode, SArray *pVgList) {
   int32_t vindex = 0;
   SSdb   *pSdb = pMnode->pSdb;
@@ -900,6 +923,7 @@ static void mndBuildDBVgroupInfo(SDbObj *pDb, SMnode *pMnode, SArray *pVgList) {
       vgInfo.vgId = pVgroup->vgId;
       vgInfo.hashBegin = pVgroup->hashBegin;
       vgInfo.hashEnd = pVgroup->hashEnd;
+      vgInfo.numOfTable = pVgroup->numOfTables / TSDB_TABLE_NUM_UNIT;
       vgInfo.epSet.numOfEps = pVgroup->replica;
       for (int32_t gid = 0; gid < pVgroup->replica; ++gid) {
         SVnodeGid *pVgid = &pVgroup->vnodeGid[gid];
@@ -967,7 +991,10 @@ static int32_t mndProcessUseDbReq(SMnodeMsg *pReq) {
         goto USE_DB_OVER;
       }
 
-      if (usedbReq.vgVersion < pDb->vgVersion || usedbReq.dbId != pDb->uid) {
+      int32_t numOfTable = 0;
+      mndGetDBTableNum(pDb, pMnode, &numOfTable);
+
+      if (usedbReq.vgVersion < pDb->vgVersion || usedbReq.dbId != pDb->uid || numOfTable != usedbReq.numOfTable) {
         mndBuildDBVgroupInfo(pDb, pMnode, usedbRsp.pVgroupInfos);
       }
 
@@ -1017,6 +1044,7 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbVgVersion *pDbs, int32_t numOfDbs,
     SDbVgVersion *pDbVgVersion = &pDbs[i];
     pDbVgVersion->dbId = htobe64(pDbVgVersion->dbId);
     pDbVgVersion->vgVersion = htonl(pDbVgVersion->vgVersion);
+    pDbVgVersion->numOfTable = htonl(pDbVgVersion->numOfTable);
 
     SUseDbRsp usedbRsp = {0};
 
@@ -1027,11 +1055,18 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbVgVersion *pDbs, int32_t numOfDbs,
       usedbRsp.uid = pDbVgVersion->dbId;
       usedbRsp.vgVersion = -1;
       taosArrayPush(batchUseRsp.pArray, &usedbRsp);
-    } else if (pDbVgVersion->vgVersion >= pDb->vgVersion) {
-      mDebug("db:%s, version not changed", pDbVgVersion->dbFName);
+      continue;
+    }
+
+    int32_t numOfTable = 0;
+    mndGetDBTableNum(pDb, pMnode, &numOfTable);
+
+    if (pDbVgVersion->vgVersion >= pDb->vgVersion && numOfTable == pDbVgVersion->numOfTable) {
+      mDebug("db:%s, version & numOfTable not changed", pDbVgVersion->dbFName);
       mndReleaseDb(pMnode, pDb);
       continue;
-    } else {
+    }
+    
     usedbRsp.pVgroupInfos = taosArrayInit(pDb->cfg.numOfVgroups, sizeof(SVgroupInfo));
     if (usedbRsp.pVgroupInfos == NULL) {
       mndReleaseDb(pMnode, pDb);
@@ -1049,7 +1084,6 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbVgVersion *pDbs, int32_t numOfDbs,
     taosArrayPush(batchUseRsp.pArray, &usedbRsp);
     mndReleaseDb(pMnode, pDb);
   }
-  }
 
   int32_t rspLen = tSerializeSUseDbBatchRsp(NULL, 0, &batchUseRsp);
   void   *pRsp = malloc(rspLen);

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

@@ -36,6 +36,7 @@ static int32_t  mndProcessDropQnodeRsp(SMnodeMsg *pRsp);
 static int32_t  mndGetQnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta);
 static int32_t  mndRetrieveQnodes(SMnodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows);
 static void     mndCancelGetNextQnode(SMnode *pMnode, void *pIter);
+static int32_t  mndProcessQnodeListReq(SMnodeMsg *pReq);
 
 int32_t mndInitQnode(SMnode *pMnode) {
   SSdbTable table = {.sdbType = SDB_QNODE,
@@ -48,6 +49,7 @@ int32_t mndInitQnode(SMnode *pMnode) {
 
   mndSetMsgHandle(pMnode, TDMT_MND_CREATE_QNODE, mndProcessCreateQnodeReq);
   mndSetMsgHandle(pMnode, TDMT_MND_DROP_QNODE, mndProcessDropQnodeReq);
+  mndSetMsgHandle(pMnode, TDMT_MND_QNODE_LIST, mndProcessQnodeListReq);
   mndSetMsgHandle(pMnode, TDMT_DND_CREATE_QNODE_RSP, mndProcessCreateQnodeRsp);
   mndSetMsgHandle(pMnode, TDMT_DND_DROP_QNODE_RSP, mndProcessDropQnodeRsp);
 
@@ -430,6 +432,69 @@ DROP_QNODE_OVER:
   return code;
 }
 
+
+static int32_t mndProcessQnodeListReq(SMnodeMsg *pReq) {
+  int32_t        code = -1;
+  SQnodeListReq  qlistReq = {0};
+  int32_t numOfRows = 0;
+  SMnode    *pMnode = pReq->pMnode;
+  SSdb      *pSdb = pMnode->pSdb;
+  SQnodeObj *pObj = NULL;
+  SQnodeListRsp qlistRsp = {0};
+
+  if (tDeserializeSQnodeListReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &qlistReq) != 0) {
+    mError("invalid qnode list msg");
+    terrno = TSDB_CODE_INVALID_MSG;
+    goto QNODE_LIST_OVER;
+  }
+
+  qlistRsp.epSetList = taosArrayInit(5, sizeof(SEpSet));
+  if (NULL == qlistRsp.epSetList) {
+    mError("taosArrayInit epSet failed");
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    goto QNODE_LIST_OVER;
+  }
+  
+  while (true) {
+    void *pIter = sdbFetch(pSdb, SDB_QNODE, NULL, (void **)&pObj);
+    if (pIter == NULL) break;
+
+    SEpSet epSet = {0};
+    strcpy(epSet.eps[0].fqdn, pObj->pDnode->fqdn);
+    epSet.eps[0].port = pObj->pDnode->port;
+    epSet.numOfEps = 1;
+
+    taosArrayPush(qlistRsp.epSetList, &epSet);
+
+    numOfRows++;
+    sdbRelease(pSdb, pObj);
+
+    if (qlistReq.rowNum > 0 && numOfRows >= qlistReq.rowNum) {
+      break;
+    }
+  }
+
+  int32_t rspLen = tSerializeSQnodeListRsp(NULL, 0, &qlistRsp);
+  void   *pRsp = malloc(rspLen);
+  if (pRsp == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    goto QNODE_LIST_OVER;
+  }
+  
+  tSerializeSQnodeListRsp(pRsp, rspLen, &qlistRsp);
+  
+  pReq->contLen = rspLen;
+  pReq->pCont = pRsp;
+  code = 0;
+
+QNODE_LIST_OVER:
+
+  tFreeSQnodeListRsp(&qlistRsp);
+  
+  return code;
+}
+
+
 static int32_t mndProcessCreateQnodeRsp(SMnodeMsg *pRsp) {
   mndTransProcessRsp(pRsp);
   return 0;

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

@@ -32,30 +32,30 @@
 int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscribeObj* pSub) {
   SSdb*      pSdb = pMnode->pSdb;
   SVgObj*    pVgroup = NULL;
-  SQueryDag* pDag = qStringToDag(pTopic->physicalPlan);
-  if (pDag == NULL) {
+  SQueryPlan* pPlan = qStringToQueryPlan(pTopic->physicalPlan);
+  if (pPlan == NULL) {
     terrno = TSDB_CODE_QRY_INVALID_INPUT;
     return -1;
   }
 
   ASSERT(pSub->vgNum == 0);
 
-  int32_t levelNum = taosArrayGetSize(pDag->pSubplans);
+  int32_t levelNum = LIST_LENGTH(pPlan->pSubplans);
   if (levelNum != 1) {
-    qDestroyQueryDag(pDag);
+    qDestroyQueryPlan(pPlan);
     terrno = TSDB_CODE_MND_UNSUPPORTED_TOPIC;
     return -1;
   }
 
-  SArray* plans = taosArrayGetP(pDag->pSubplans, 0);
+  SNodeListNode* inner = nodesListGetNode(pPlan->pSubplans, 0);
 
-  int32_t opNum = taosArrayGetSize(plans);
+  int32_t opNum = LIST_LENGTH(inner->pNodeList);
   if (opNum != 1) {
-    qDestroyQueryDag(pDag);
+    qDestroyQueryPlan(pPlan);
     terrno = TSDB_CODE_MND_UNSUPPORTED_TOPIC;
     return -1;
   }
-  SSubplan* plan = taosArrayGetP(plans, 0);
+  SSubplan* plan = nodesListGetNode(inner->pNodeList, 0);
 
   void* pIter = NULL;
   while (1) {
@@ -78,14 +78,14 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib
     int32_t msgLen;
     if (qSubPlanToString(plan, &consumerEp.qmsg, &msgLen) < 0) {
       sdbRelease(pSdb, pVgroup);
-      qDestroyQueryDag(pDag);
+      qDestroyQueryPlan(pPlan);
       terrno = TSDB_CODE_QRY_INVALID_INPUT;
       return -1;
     }
     taosArrayPush(pSub->unassignedVg, &consumerEp);
   }
 
-  qDestroyQueryDag(pDag);
+  qDestroyQueryPlan(pPlan);
 
   return 0;
 }

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

@@ -25,6 +25,7 @@ static void      mndReleaseShowObj(SShowObj *pShow, bool forceRemove);
 static int32_t   mndProcessShowReq(SMnodeMsg *pReq);
 static int32_t   mndProcessRetrieveReq(SMnodeMsg *pReq);
 static bool      mndCheckRetrieveFinished(SShowObj *pShow);
+static int32_t   mndProcessRetrieveSysTableReq(SMnodeMsg *pReq);
 
 int32_t mndInitShow(SMnode *pMnode) {
   SShowMgmt *pMgmt = &pMnode->showMgmt;
@@ -38,6 +39,7 @@ int32_t mndInitShow(SMnode *pMnode) {
 
   mndSetMsgHandle(pMnode, TDMT_MND_SHOW, mndProcessShowReq);
   mndSetMsgHandle(pMnode, TDMT_MND_SHOW_RETRIEVE, mndProcessRetrieveReq);
+  mndSetMsgHandle(pMnode, TDMT_MND_SYSTABLE_RETRIEVE, mndProcessRetrieveSysTableReq);
   return 0;
 }
 
@@ -261,6 +263,106 @@ static int32_t mndProcessRetrieveReq(SMnodeMsg *pReq) {
   return TSDB_CODE_SUCCESS;
 }
 
+static int32_t mndProcessRetrieveSysTableReq(SMnodeMsg *pReq) {
+  SMnode    *pMnode = pReq->pMnode;
+  SShowMgmt *pMgmt = &pMnode->showMgmt;
+  int32_t    rowsToRead = 0;
+  int32_t    size = 0;
+  int32_t    rowsRead = 0;
+
+  SRetrieveTableReq retrieveReq = {0};
+  if (tDeserializeSRetrieveTableReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &retrieveReq) != 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    return -1;
+  }
+
+  SShowObj* pShow = NULL;
+
+  if (retrieveReq.showId == 0) {
+    SShowReq req = {0};
+    req.type = retrieveReq.type;
+    strncpy(req.db, retrieveReq.db, tListLen(req.db));
+
+    pShow = mndCreateShowObj(pMnode, &req);
+    if (pShow == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      mError("failed to process show-meta req since %s", terrstr());
+      return -1;
+    }
+  } else {
+    pShow = mndAcquireShowObj(pMnode, retrieveReq.showId);
+    if (pShow == NULL) {
+      terrno = TSDB_CODE_MND_INVALID_SHOWOBJ;
+      mError("failed to process show-retrieve req:%p since %s", pShow, terrstr());
+      return -1;
+    }
+  }
+
+  ShowRetrieveFp retrieveFp = pMgmt->retrieveFps[pShow->type];
+  if (retrieveFp == NULL) {
+    mndReleaseShowObj((SShowObj*) pShow, false);
+    terrno = TSDB_CODE_MSG_NOT_PROCESSED;
+    mError("show:0x%" PRIx64 ", failed to retrieve data since %s", pShow->id, terrstr());
+    return -1;
+  }
+
+  mDebug("show:0x%" PRIx64 ", start retrieve data, numOfReads:%d numOfRows:%d type:%s", pShow->id, pShow->numOfReads,
+         pShow->numOfRows, mndShowStr(pShow->type));
+
+  if (mndCheckRetrieveFinished((SShowObj*) pShow)) {
+    mDebug("show:0x%" PRIx64 ", read finished, numOfReads:%d numOfRows:%d", pShow->id, pShow->numOfReads,
+           pShow->numOfRows);
+    pShow->numOfReads = pShow->numOfRows;
+  }
+
+  if ((retrieveReq.free & TSDB_QUERY_TYPE_FREE_RESOURCE) != TSDB_QUERY_TYPE_FREE_RESOURCE) {
+    rowsToRead = pShow->numOfRows - pShow->numOfReads;
+  }
+
+  /* return no more than 100 tables in one round trip */
+  if (rowsToRead > SHOW_STEP_SIZE) rowsToRead = SHOW_STEP_SIZE;
+
+  /*
+   * the actual number of table may be larger than the value of pShow->numOfRows, if a query is
+   * issued during a continuous create table operation. Therefore, rowToRead may be less than 0.
+   */
+  if (rowsToRead < 0) rowsToRead = 0;
+  size = pShow->rowSize * rowsToRead;
+
+  size += SHOW_STEP_SIZE;
+  SRetrieveTableRsp *pRsp = rpcMallocCont(size);
+  if (pRsp == NULL) {
+    mndReleaseShowObj((SShowObj*) pShow, false);
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    mError("show:0x%" PRIx64 ", failed to retrieve data since %s", pShow->id, terrstr());
+    return -1;
+  }
+
+  // if free flag is set, client wants to clean the resources
+  if ((retrieveReq.free & TSDB_QUERY_TYPE_FREE_RESOURCE) != TSDB_QUERY_TYPE_FREE_RESOURCE) {
+    rowsRead = (*retrieveFp)(pReq, (SShowObj*) pShow, pRsp->data, rowsToRead);
+  }
+
+  mDebug("show:0x%" PRIx64 ", stop retrieve data, rowsRead:%d rowsToRead:%d", pShow->id, rowsRead, rowsToRead);
+
+  pRsp->numOfRows = htonl(rowsRead);
+  pRsp->precision = TSDB_TIME_PRECISION_MILLI;  // millisecond time precision
+
+  pReq->pCont = pRsp;
+  pReq->contLen = size;
+
+  if (rowsRead == 0 || rowsToRead == 0 || (rowsRead == rowsToRead && pShow->numOfRows == pShow->numOfReads)) {
+    pRsp->completed = 1;
+    mDebug("show:0x%" PRIx64 ", retrieve completed", pShow->id);
+    mndReleaseShowObj((SShowObj*) pShow, true);
+  } else {
+    mDebug("show:0x%" PRIx64 ", retrieve not completed yet", pShow->id);
+    mndReleaseShowObj((SShowObj*) pShow, false);
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
 char *mndShowStr(int32_t showType) {
   switch (showType) {
     case TSDB_MGMT_TABLE_ACCT:

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

@@ -773,10 +773,10 @@ static int32_t mndProcessDoRebalanceMsg(SMnodeMsg *pMsg) {
 static int32_t mndInitUnassignedVg(SMnode *pMnode, const SMqTopicObj *pTopic, SMqSubscribeObj *pSub) {
   SSdb      *pSdb = pMnode->pSdb;
   SVgObj    *pVgroup = NULL;
-  SQueryDag *pDag = qStringToDag(pTopic->physicalPlan);
+  SQueryPlan *pPlan = qStringToQueryPlan(pTopic->physicalPlan);
   SArray    *pArray = NULL;
-  SArray    *inner = taosArrayGet(pDag->pSubplans, 0);
-  SSubplan  *plan = taosArrayGetP(inner, 0);
+  SNodeListNode    *inner = (SNodeListNode*)nodesListGetNode(pPlan->pSubplans, 0);
+  SSubplan  *plan = (SSubplan*)nodesListGetNode(inner->pNodeList, 0);
   SArray    *unassignedVg = pSub->unassignedVg;
 
   void *pIter = NULL;
@@ -792,7 +792,7 @@ static int32_t mndInitUnassignedVg(SMnode *pMnode, const SMqTopicObj *pTopic, SM
     plan->execNode.nodeId = pVgroup->vgId;
     plan->execNode.epset = mndGetVgroupEpset(pMnode, pVgroup);
 
-    if (schedulerConvertDagToTaskList(pDag, &pArray) < 0) {
+    if (schedulerConvertDagToTaskList(pPlan, &pArray) < 0) {
       terrno = TSDB_CODE_MND_UNSUPPORTED_TOPIC;
       mError("unsupport topic: %s, sql: %s", pTopic->name, pTopic->sql);
       return -1;

source/dnode/qnode/CMakeLists.txt

@@ -11,4 +11,7 @@ target_link_libraries(
     PRIVATE os
     PRIVATE common
     PRIVATE util
+    PRIVATE qworker
+    PRIVATE qcom
+    PRIVATE executor
 )
\ No newline at end of file

source/dnode/qnode/inc/qndInt.h

@@ -28,8 +28,12 @@
 extern "C" {
 #endif
 
+typedef struct SQWorkerMgmt SQHandle;
+
 typedef struct SQnode {
+  int32_t   qndId;
   SQnodeOpt opt;
+  SQHandle*  pQuery;  
 } SQnode;
 
 #ifdef __cplusplus

source/dnode/qnode/src/qnode.c

@@ -14,13 +14,35 @@
  */
 
 #include "qndInt.h"
+#include "query.h"
+#include "qworker.h"
+#include "executor.h"
+
+int32_t qnodePutReqToVQueryQ(SQnode* pQnode, struct SRpcMsg* pReq) {}
+void    qnodeSendReqToDnode(SQnode* pQnode, struct SEpSet* epSet, struct SRpcMsg* pReq) {}
+
 
 SQnode *qndOpen(const SQnodeOpt *pOption) {
   SQnode *pQnode = calloc(1, sizeof(SQnode));
+  if (NULL == pQnode) {
+    qError("calloc SQnode failed");
+    return NULL;
+  }
+
+  if (qWorkerInit(NODE_TYPE_QNODE, pQnode->qndId, NULL, (void **)&pQnode->pQuery, pQnode,
+                     (putReqToQueryQFp)qnodePutReqToVQueryQ, (sendReqToDnodeFp)qnodeSendReqToDnode)) {
+    tfree(pQnode);
+    return NULL;
+  }
+  
   return pQnode;
 }
 
-void qndClose(SQnode *pQnode) { free(pQnode); }
+void qndClose(SQnode *pQnode) { 
+  qWorkerDestroy((void **)&pQnode->pQuery);
+
+  free(pQnode); 
+}
 
 int32_t qndGetLoad(SQnode *pQnode, SQnodeLoad *pLoad) { return 0; }
 
@@ -29,3 +51,51 @@ int32_t qndProcessMsg(SQnode *pQnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
   return 0;
 }
 
+int qnodeProcessQueryMsg(SQnode *pQnode, SRpcMsg *pMsg) {
+  qTrace("message in query queue is processing");
+  SReadHandle handle = {0};
+
+  switch (pMsg->msgType) {
+    case TDMT_VND_QUERY:{
+      return qWorkerProcessQueryMsg(&handle, pQnode->pQuery, pMsg);
+    }
+    case TDMT_VND_QUERY_CONTINUE:
+      return qWorkerProcessCQueryMsg(&handle, pQnode->pQuery, pMsg);
+    default:
+      qError("unknown msg type:%d in query queue", pMsg->msgType);
+      return TSDB_CODE_VND_APP_ERROR;
+  }
+}
+
+int qnodeProcessFetchMsg(SQnode *pQnode, SRpcMsg *pMsg) {
+  qTrace("message in fetch queue is processing");
+  switch (pMsg->msgType) {
+    case TDMT_VND_FETCH:
+      return qWorkerProcessFetchMsg(pQnode, pQnode->pQuery, pMsg);
+    case TDMT_VND_FETCH_RSP:
+      return qWorkerProcessFetchRsp(pQnode, pQnode->pQuery, pMsg);
+    case TDMT_VND_RES_READY:
+      return qWorkerProcessReadyMsg(pQnode, pQnode->pQuery, pMsg);
+    case TDMT_VND_TASKS_STATUS:
+      return qWorkerProcessStatusMsg(pQnode, pQnode->pQuery, pMsg);
+    case TDMT_VND_CANCEL_TASK:
+      return qWorkerProcessCancelMsg(pQnode, pQnode->pQuery, pMsg);
+    case TDMT_VND_DROP_TASK:
+      return qWorkerProcessDropMsg(pQnode, pQnode->pQuery, pMsg);
+    case TDMT_VND_SHOW_TABLES:
+      return qWorkerProcessShowMsg(pQnode, pQnode->pQuery, pMsg);
+    case TDMT_VND_SHOW_TABLES_FETCH:
+      //return vnodeGetTableList(pQnode, pMsg);
+    case TDMT_VND_TABLE_META:
+      //return vnodeGetTableMeta(pQnode, pMsg);
+    case TDMT_VND_CONSUME:
+      //return tqProcessConsumeReq(pQnode->pTq, pMsg);
+    default:
+      qError("unknown msg type:%d in fetch queue", pMsg->msgType);
+      return TSDB_CODE_VND_APP_ERROR;
+  }
+}
+
+
+
+

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

@@ -26,6 +26,7 @@ extern "C" {
 typedef struct SQWorkerMgmt SQHandle;
 
 int vnodeQueryOpen(SVnode *pVnode);
+void vnodeQueryClose(SVnode *pVnode);
 
 #ifdef __cplusplus
 }

source/dnode/vnode/src/tsdb/tsdbRead.c

@@ -13,18 +13,19 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <tdatablock.h>
+#include "os.h"
+#include "talgo.h"
+#include "tcompare.h"
+#include "tdataformat.h"
+#include "texception.h"
 #include "tsdb.h"
 #include "tsdbDef.h"
 #include "tsdbFS.h"
 #include "tsdbLog.h"
 #include "tsdbReadImpl.h"
-#include "ttime.h"
-#include "texception.h"
-#include "os.h"
-#include "talgo.h"
-#include "tcompare.h"
-#include "tdataformat.h"
 #include "tskiplist.h"
+#include "ttime.h"
 
 #include "taosdef.h"
 #include "tlosertree.h"
@@ -1472,6 +1473,8 @@ static int32_t doCopyRowsFromFileBlock(STsdbReadHandle* pTsdbReadHandle, int32_t
   return numOfRows + num;
 }
 
+// TODO fix bug for reverse copy data
+// TODO handle the null data
 // Note: row1 always has high priority
 static void mergeTwoRowFromMem(STsdbReadHandle* pTsdbReadHandle, int32_t capacity, int32_t numOfRows, STSRow* row1,
                                STSRow* row2, int32_t numOfCols, uint64_t uid, STSchema* pSchema1, STSchema* pSchema2,
@@ -1515,7 +1518,6 @@ static void mergeTwoRowFromMem(STsdbReadHandle* pTsdbReadHandle, int32_t capacit
     }
   }
 
-
   int32_t i = 0, j = 0, k = 0;
   while(i < numOfCols && (j < numOfColsOfRow1 || k < numOfColsOfRow2)) {
     SColumnInfoData* pColInfo = taosArrayGet(pTsdbReadHandle->pColumns, i);
@@ -1586,7 +1588,6 @@ static void mergeTwoRowFromMem(STsdbReadHandle* pTsdbReadHandle, int32_t capacit
       tdSKvRowGetVal(row, colId, offset, chosen_itr, &sVal);
     }
 
-
     if (colId == pColInfo->info.colId) {
       if (tdValTypeIsNorm(sVal.valType)) {
         switch (pColInfo->info.type) {
@@ -1594,7 +1595,6 @@ static void mergeTwoRowFromMem(STsdbReadHandle* pTsdbReadHandle, int32_t capacit
           case TSDB_DATA_TYPE_NCHAR:
             memcpy(pData, sVal.val, varDataTLen(sVal.val));
             break;
-          case TSDB_DATA_TYPE_NULL:
           case TSDB_DATA_TYPE_BOOL:
           case TSDB_DATA_TYPE_TINYINT:
           case TSDB_DATA_TYPE_UTINYINT:
@@ -1625,11 +1625,7 @@ static void mergeTwoRowFromMem(STsdbReadHandle* pTsdbReadHandle, int32_t capacit
             memcpy(pData, sVal.val, pColInfo->info.bytes);
         }
       } else if (forceSetNull) {
-        if (pColInfo->info.type == TSDB_DATA_TYPE_BINARY || pColInfo->info.type == TSDB_DATA_TYPE_NCHAR) {
-          setVardataNull(pData, pColInfo->info.type);
-        } else {
-          setNull(pData, pColInfo->info.type, pColInfo->info.bytes);
-        }
+        colDataAppend(pColInfo, numOfRows, NULL, true);
       }
       i++;
 
@@ -1640,11 +1636,7 @@ static void mergeTwoRowFromMem(STsdbReadHandle* pTsdbReadHandle, int32_t capacit
       }
     } else {
       if(forceSetNull) {
-        if (pColInfo->info.type == TSDB_DATA_TYPE_BINARY || pColInfo->info.type == TSDB_DATA_TYPE_NCHAR) {
-          setVardataNull(pData, pColInfo->info.type);
-        } else {
-          setNull(pData, pColInfo->info.type, pColInfo->info.bytes);
-        }
+        colDataAppend(pColInfo, numOfRows, NULL, true);
       }
       i++;
     }
@@ -1653,18 +1645,7 @@ static void mergeTwoRowFromMem(STsdbReadHandle* pTsdbReadHandle, int32_t capacit
   if(forceSetNull) {
     while (i < numOfCols) { // the remain columns are all null data
       SColumnInfoData* pColInfo = taosArrayGet(pTsdbReadHandle->pColumns, i);
-      if (ASCENDING_TRAVERSE(pTsdbReadHandle->order)) {
-        pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;
-      } else {
-        pData = (char*)pColInfo->pData + (capacity - numOfRows - 1) * pColInfo->info.bytes;
-      }
-
-      if (pColInfo->info.type == TSDB_DATA_TYPE_BINARY || pColInfo->info.type == TSDB_DATA_TYPE_NCHAR) {
-        setVardataNull(pData, pColInfo->info.type);
-      } else {
-        setNull(pData, pColInfo->info.type, pColInfo->info.bytes);
-      }
-
+      colDataAppend(pColInfo, numOfRows, NULL, true);
       i++;
     }
   }

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

@@ -154,5 +154,6 @@ static void vnodeCloseImpl(SVnode *pVnode) {
     tsdbClose(pVnode->pTsdb);
     tqClose(pVnode->pTq);
     walClose(pVnode->pWal);
+    vnodeQueryClose(pVnode);
   }
 }

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

@@ -24,6 +24,10 @@ int vnodeQueryOpen(SVnode *pVnode) {
                      (putReqToQueryQFp)vnodePutReqToVQueryQ, (sendReqToDnodeFp)vnodeSendReqToDnode);
 }
 
+void vnodeQueryClose(SVnode *pVnode) {
+  qWorkerDestroy((void **)&pVnode->pQuery);
+}
+
 int vnodeProcessQueryMsg(SVnode *pVnode, SRpcMsg *pMsg) {
   vTrace("message in query queue is processing");
   SReadHandle handle = {.reader = pVnode->pTsdb, .meta = pVnode->pMeta};
@@ -64,6 +68,8 @@ int vnodeProcessFetchMsg(SVnode *pVnode, SRpcMsg *pMsg) {
       return vnodeGetTableMeta(pVnode, pMsg);
     case TDMT_VND_CONSUME:
       return tqProcessPollReq(pVnode->pTq, pMsg);
+    case TDMT_VND_QUERY_HEARTBEAT:
+      return qWorkerProcessHbMsg(pVnode, pVnode->pQuery, pMsg);
     default:
       vError("unknown msg type:%d in fetch queue", pMsg->msgType);
       return TSDB_CODE_VND_APP_ERROR;

source/libs/catalog/src/catalog.c

@@ -558,6 +558,42 @@ int32_t ctgAcquireVgInfoFromCache(SCatalog* pCtg, const char *dbFName, SCtgDBCac
   return TSDB_CODE_SUCCESS;
 }
 
+int32_t ctgGetQnodeListFromMnode(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, SArray **out) {
+  char *msg = NULL;
+  int32_t msgLen = 0;
+
+  ctgDebug("try to get qnode list from mnode, mgmtEpInUse:%d", pMgmtEps->inUse);
+
+  int32_t code = queryBuildMsg[TMSG_INDEX(TDMT_MND_QNODE_LIST)](NULL, &msg, 0, &msgLen);
+  if (code) {
+    ctgError("Build qnode list msg failed, error:%s", tstrerror(code));
+    CTG_ERR_RET(code);
+  }
+  
+  SRpcMsg rpcMsg = {
+      .msgType = TDMT_MND_QNODE_LIST,
+      .pCont   = msg,
+      .contLen = msgLen,
+  };
+
+  SRpcMsg rpcRsp = {0};
+
+  rpcSendRecv(pRpc, (SEpSet*)pMgmtEps, &rpcMsg, &rpcRsp);
+  if (TSDB_CODE_SUCCESS != rpcRsp.code) {
+    ctgError("error rsp for qnode list, error:%s", tstrerror(rpcRsp.code));
+    CTG_ERR_RET(rpcRsp.code);
+  }
+
+  code = queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_QNODE_LIST)](out, rpcRsp.pCont, rpcRsp.contLen);
+  if (code) {
+    ctgError("Process qnode list rsp failed, error:%s", tstrerror(rpcRsp.code));
+    CTG_ERR_RET(code);
+  }
+
+  ctgDebug("Got qnode list from mnode, listNum:%d", (int32_t)taosArrayGetSize(*out));
+
+  return TSDB_CODE_SUCCESS;
+}
 
 
 int32_t ctgGetDBVgInfoFromMnode(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, SBuildUseDBInput *input, SUseDbOutput *out) {
@@ -965,7 +1001,7 @@ int32_t ctgGetVgInfoFromHashValue(SCatalog *pCtg, SDBVgInfo *dbInfo, const SName
   CTG_RET(code);
 }
 
-int32_t ctgStbVersionCompare(const void* key1, const void* key2) {
+int32_t ctgStbVersionSearchCompare(const void* key1, const void* key2) {
   if (*(uint64_t *)key1 < ((SSTableMetaVersion*)key2)->suid) {
     return -1;
   } else if (*(uint64_t *)key1 > ((SSTableMetaVersion*)key2)->suid) {
@@ -975,7 +1011,7 @@ int32_t ctgStbVersionCompare(const void* key1, const void* key2) {
   }
 }
 
-int32_t ctgDbVgVersionCompare(const void* key1, const void* key2) {
+int32_t ctgDbVgVersionSearchCompare(const void* key1, const void* key2) {
   if (*(int64_t *)key1 < ((SDbVgVersion*)key2)->dbId) {
     return -1;
   } else if (*(int64_t *)key1 > ((SDbVgVersion*)key2)->dbId) {
@@ -985,6 +1021,27 @@ int32_t ctgDbVgVersionCompare(const void* key1, const void* key2) {
   }
 }
 
+int32_t ctgStbVersionSortCompare(const void* key1, const void* key2) {
+  if (((SSTableMetaVersion*)key1)->suid < ((SSTableMetaVersion*)key2)->suid) {
+    return -1;
+  } else if (((SSTableMetaVersion*)key1)->suid > ((SSTableMetaVersion*)key2)->suid) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+int32_t ctgDbVgVersionSortCompare(const void* key1, const void* key2) {
+  if (((SDbVgVersion*)key1)->dbId < ((SDbVgVersion*)key2)->dbId) {
+    return -1;
+  } else if (((SDbVgVersion*)key1)->dbId > ((SDbVgVersion*)key2)->dbId) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+
 int32_t ctgMetaRentInit(SCtgRentMgmt *mgmt, uint32_t rentSec, int8_t type) {
   mgmt->slotRIdx = 0;
   mgmt->slotNum = rentSec / CTG_RENT_SLOT_SECOND;
@@ -1034,7 +1091,7 @@ _return:
   CTG_RET(code);
 }
 
-int32_t ctgMetaRentUpdate(SCtgRentMgmt *mgmt, void *meta, int64_t id, int32_t size, __compar_fn_t compare) {
+int32_t ctgMetaRentUpdate(SCtgRentMgmt *mgmt, void *meta, int64_t id, int32_t size, __compar_fn_t sortCompare, __compar_fn_t searchCompare) {
   int16_t widx = abs(id % mgmt->slotNum);
 
   SCtgRentSlot *slot = &mgmt->slots[widx];
@@ -1048,12 +1105,12 @@ int32_t ctgMetaRentUpdate(SCtgRentMgmt *mgmt, void *meta, int64_t id, int32_t si
 
   if (slot->needSort) {
     qDebug("meta slot before sorte, slot idx:%d, type:%d, size:%d", widx, mgmt->type, (int32_t)taosArrayGetSize(slot->meta));
-    taosArraySort(slot->meta, compare);
+    taosArraySort(slot->meta, sortCompare);
     slot->needSort = false;
     qDebug("meta slot sorted, slot idx:%d, type:%d, size:%d", widx, mgmt->type, (int32_t)taosArrayGetSize(slot->meta));
   }
 
-  void *orig = taosArraySearch(slot->meta, &id, compare, TD_EQ);
+  void *orig = taosArraySearch(slot->meta, &id, searchCompare, TD_EQ);
   if (NULL == orig) {
     qError("meta not found in slot, id:%"PRIx64", slot idx:%d, type:%d, size:%d", id, widx, mgmt->type, (int32_t)taosArrayGetSize(slot->meta));
     CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR);
@@ -1075,8 +1132,8 @@ _return:
   CTG_RET(code);
 }
 
-int32_t ctgMetaRentRemove(SCtgRentMgmt *mgmt, int64_t id, __compar_fn_t compare) {
-  int16_t widx = labs(id % mgmt->slotNum);
+int32_t ctgMetaRentRemove(SCtgRentMgmt *mgmt, int64_t id, __compar_fn_t sortCompare, __compar_fn_t searchCompare) {
+  int16_t widx = abs(id % mgmt->slotNum);
 
   SCtgRentSlot *slot = &mgmt->slots[widx];
   int32_t code = 0;
@@ -1088,12 +1145,12 @@ int32_t ctgMetaRentRemove(SCtgRentMgmt *mgmt, int64_t id, __compar_fn_t compare)
   }
 
   if (slot->needSort) {
-    taosArraySort(slot->meta, compare);
+    taosArraySort(slot->meta, sortCompare);
     slot->needSort = false;
     qDebug("meta slot sorted, slot idx:%d, type:%d", widx, mgmt->type);
   }
 
-  int32_t idx = taosArraySearchIdx(slot->meta, &id, compare, TD_EQ);
+  int32_t idx = taosArraySearchIdx(slot->meta, &id, searchCompare, TD_EQ);
   if (idx < 0) {
     qError("meta not found in slot, id:%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type);
     CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR);
@@ -1240,7 +1297,7 @@ void ctgRemoveStbRent(SCatalog* pCtg, SCtgTbMetaCache *cache) {
       uint64_t *suid = NULL;
       suid = taosHashGetKey(pIter, NULL);
 
-      if (TSDB_CODE_SUCCESS == ctgMetaRentRemove(&pCtg->stbRent, *suid, ctgStbVersionCompare)) {
+      if (TSDB_CODE_SUCCESS == ctgMetaRentRemove(&pCtg->stbRent, *suid, ctgStbVersionSortCompare, ctgStbVersionSearchCompare)) {
         ctgDebug("stb removed from rent, suid:%"PRIx64, *suid);
       }
           
@@ -1264,7 +1321,7 @@ int32_t ctgRemoveDB(SCatalog* pCtg, SCtgDBCache *dbCache, const char* dbFName) {
 
   ctgInfo("db removed from cache, dbFName:%s, dbId:%"PRIx64, dbFName, dbCache->dbId);
 
-  CTG_ERR_RET(ctgMetaRentRemove(&pCtg->dbRent, dbCache->dbId, ctgDbVgVersionCompare));
+  CTG_ERR_RET(ctgMetaRentRemove(&pCtg->dbRent, dbCache->dbId, ctgDbVgVersionSortCompare, ctgDbVgVersionSearchCompare));
   
   ctgDebug("db removed from rent, dbFName:%s, dbId:%"PRIx64, dbFName, dbCache->dbId);
 
@@ -1331,7 +1388,7 @@ int32_t ctgUpdateDBVgInfo(SCatalog* pCtg, const char* dbFName, uint64_t dbId, SD
   }
 
   bool newAdded = false;
-  SDbVgVersion vgVersion = {.dbId = dbId, .vgVersion = dbInfo->vgVersion};
+  SDbVgVersion vgVersion = {.dbId = dbId, .vgVersion = dbInfo->vgVersion, .numOfTable = dbInfo->numOfTable};
 
   SCtgDBCache *dbCache = NULL;
   CTG_ERR_RET(ctgGetAddDBCache(pCtg, dbFName, dbId, &dbCache));
@@ -1344,8 +1401,15 @@ int32_t ctgUpdateDBVgInfo(SCatalog* pCtg, const char* dbFName, uint64_t dbId, SD
   CTG_ERR_RET(ctgWAcquireVgInfo(pCtg, dbCache));
   
   if (dbCache->vgInfo) {
-    if (dbInfo->vgVersion <= dbCache->vgInfo->vgVersion) {
-      ctgInfo("db vgVersion is old, dbFName:%s, vgVersion:%d, currentVersion:%d", dbFName, dbInfo->vgVersion, dbCache->vgInfo->vgVersion);
+    if (dbInfo->vgVersion < dbCache->vgInfo->vgVersion) {
+      ctgDebug("db vgVersion is old, dbFName:%s, vgVersion:%d, currentVersion:%d", dbFName, dbInfo->vgVersion, dbCache->vgInfo->vgVersion);
+      ctgWReleaseVgInfo(dbCache);
+      
+      return TSDB_CODE_SUCCESS;
+    }
+
+    if (dbInfo->vgVersion == dbCache->vgInfo->vgVersion && dbInfo->numOfTable == dbCache->vgInfo->numOfTable) {
+      ctgDebug("no new db vgVersion or numOfTable, dbFName:%s, vgVersion:%d, numOfTable:%d", dbFName, dbInfo->vgVersion, dbInfo->numOfTable);
       ctgWReleaseVgInfo(dbCache);
       
       return TSDB_CODE_SUCCESS;
@@ -1365,7 +1429,7 @@ int32_t ctgUpdateDBVgInfo(SCatalog* pCtg, const char* dbFName, uint64_t dbId, SD
   dbCache = NULL;
 
   strncpy(vgVersion.dbFName, dbFName, sizeof(vgVersion.dbFName));
-  CTG_ERR_RET(ctgMetaRentUpdate(&pCtg->dbRent, &vgVersion, vgVersion.dbId, sizeof(SDbVgVersion), ctgDbVgVersionCompare));
+  CTG_ERR_RET(ctgMetaRentUpdate(&pCtg->dbRent, &vgVersion, vgVersion.dbId, sizeof(SDbVgVersion), ctgDbVgVersionSortCompare, ctgDbVgVersionSearchCompare));
   
   CTG_RET(code);
 }
@@ -1398,7 +1462,7 @@ int32_t ctgUpdateTblMeta(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFName, ui
 
         ctgDebug("stb removed from stbCache, dbFName:%s, stb:%s, suid:%"PRIx64, dbFName, tbName, orig->suid);
         
-        ctgMetaRentRemove(&pCtg->stbRent, orig->suid, ctgStbVersionCompare);
+        ctgMetaRentRemove(&pCtg->stbRent, orig->suid, ctgStbVersionSortCompare, ctgStbVersionSearchCompare);
       }
 
       origSuid = orig->suid;
@@ -1511,6 +1575,7 @@ int32_t ctgGetDBVgInfo(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const
   if (inCache) {
     input.dbId = (*dbCache)->dbId;
     input.vgVersion = (*dbCache)->vgInfo->vgVersion;
+    input.numOfTable = (*dbCache)->vgInfo->numOfTable;
   } else {
     input.vgVersion = CTG_DEFAULT_INVALID_VERSION;
   }
@@ -1924,7 +1989,7 @@ int32_t ctgActRemoveStb(SCtgMetaAction *action) {
   
   ctgInfo("stb removed from cache, dbFName:%s, stbName:%s, suid:%"PRIx64, msg->dbFName, msg->stbName, msg->suid);
 
-  CTG_ERR_JRET(ctgMetaRentRemove(&msg->pCtg->stbRent, msg->suid, ctgStbVersionCompare));
+  CTG_ERR_JRET(ctgMetaRentRemove(&msg->pCtg->stbRent, msg->suid, ctgStbVersionSortCompare, ctgStbVersionSearchCompare));
   
   ctgDebug("stb removed from rent, dbFName:%s, stbName:%s, suid:%"PRIx64, msg->dbFName, msg->stbName, msg->suid);
   
@@ -2163,7 +2228,7 @@ void catalogFreeHandle(SCatalog* pCtg) {
   ctgInfo("handle freed, culsterId:%"PRIx64, clusterId);
 }
 
-int32_t catalogGetDBVgVersion(SCatalog* pCtg, const char* dbFName, int32_t* version, int64_t* dbId) {
+int32_t catalogGetDBVgVersion(SCatalog* pCtg, const char* dbFName, int32_t* version, int64_t* dbId, int32_t *tableNum) {
   CTG_API_ENTER();
 
   if (NULL == pCtg || NULL == dbFName || NULL == version || NULL == dbId) {
@@ -2194,6 +2259,7 @@ int32_t catalogGetDBVgVersion(SCatalog* pCtg, const char* dbFName, int32_t* vers
 
   *version = dbCache->vgInfo->vgVersion;
   *dbId = dbCache->dbId;
+  *tableNum = dbCache->vgInfo->numOfTable;
 
   ctgReleaseVgInfo(dbCache);
   ctgReleaseDBCache(pCtg, dbCache);
@@ -2572,6 +2638,10 @@ int32_t catalogGetAllMeta(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps,
     }
   }
 
+  if (pReq->qNodeRequired) {
+    CTG_ERR_JRET(ctgGetQnodeListFromMnode(pCtg, pTrans, pMgmtEps, &pRsp->pEpSetList));
+  }
+
   CTG_API_LEAVE(TSDB_CODE_SUCCESS);
 
 _return:  

source/libs/executor/inc/dataSinkInt.h

@@ -22,6 +22,7 @@ extern "C" {
 
 #include "tcommon.h"
 #include "dataSinkMgt.h"
+#include "plannodes.h"
 
 struct SDataSink;
 struct SDataSinkHandle;
@@ -45,7 +46,7 @@ typedef struct SDataSinkHandle {
   FDestroyDataSinker fDestroy;
 } SDataSinkHandle;
 
-int32_t createDataDispatcher(SDataSinkManager* pManager, const struct SDataSink* pDataSink, DataSinkHandle* pHandle);
+int32_t createDataDispatcher(SDataSinkManager* pManager, const SDataSinkNode* pDataSink, DataSinkHandle* pHandle);
 
 #ifdef __cplusplus
 }

source/libs/executor/inc/executil.h

@@ -92,10 +92,11 @@ typedef struct SResultRowPool {
 struct STaskAttr;
 struct STaskRuntimeEnv;
 struct SUdfInfo;
+struct SqlFunctionCtx;
 
 int32_t getOutputInterResultBufSize(struct STaskAttr* pQueryAttr);
 
-size_t  getResultRowSize(SArray* pExprInfo);
+size_t getResultRowSize(struct SqlFunctionCtx* pCtx, int32_t numOfOutput);
 int32_t initResultRowInfo(SResultRowInfo* pResultRowInfo, int32_t size);
 void    cleanupResultRowInfo(SResultRowInfo* pResultRowInfo);
 
@@ -111,7 +112,6 @@ void    clearResultRow(struct STaskRuntimeEnv* pRuntimeEnv, SResultRow* pResultR
 struct SResultRowEntryInfo* getResultCell(const SResultRow* pRow, int32_t index, int32_t* offset);
 
 void* destroyQueryFuncExpr(SExprInfo* pExprInfo, int32_t numOfExpr);
-void* freeColumnInfo(SColumnInfo* pColumnInfo, int32_t numOfCols);
 int32_t getRowNumForMultioutput(struct STaskAttr* pQueryAttr, bool topBottomQuery, bool stable);
 
 static FORCE_INLINE SResultRow *getResultRow(SResultRowInfo *pResultRowInfo, int32_t slot) {

source/libs/executor/inc/executorimpl.h

@@ -362,8 +362,8 @@ typedef struct STaskParam {
   char*      tbnameCond;
   char*      prevResult;
   SArray*    pTableIdList;
-  SSqlExpr** pExpr;
-  SSqlExpr** pSecExpr;
+  SExprBasicInfo** pExpr;
+  SExprBasicInfo** pSecExpr;
   SExprInfo* pExprs;
   SExprInfo* pSecExprs;
 
@@ -410,12 +410,10 @@ typedef struct STableScanInfo {
   int32_t         numOfSkipped;
   int32_t         numOfBlockStatis;
   int64_t         numOfRows;
-
   int32_t         order;  // scan order
   int32_t         times;  // repeat counts
   int32_t         current;
   int32_t         reverseTimes;  // 0 by default
-
   SqlFunctionCtx* pCtx;  // next operator query context
   SResultRowInfo* pResultRowInfo;
   int32_t*        rowCellInfoOffset;
@@ -424,7 +422,6 @@ typedef struct STableScanInfo {
   int32_t         numOfOutput;
   int64_t         elapsedTime;
   int32_t         prevGroupId;  // previous table group id
-
   int32_t         scanFlag;  // table scan flag to denote if it is a repeat/reverse/main scan
 } STableScanInfo;
 
@@ -443,21 +440,43 @@ typedef struct SStreamBlockScanInfo {
   void*        readerHandle;  // stream block reader handle
 } SStreamBlockScanInfo;
 
+typedef struct SSysTableScanInfo {
+  union {
+    void* pTransporter;
+    void* readHandle;
+  };
+
+  void              *pCur; // cursor
+  SRetrieveTableReq* pReq;
+  SEpSet             epSet;
+  int32_t            type;  // show type
+  tsem_t             ready;
+  SSchema*           pSchema;
+  SSDataBlock*       pRes;
+
+  int32_t            capacity;
+  int64_t            numOfBlocks;  // extract basic running information.
+  int64_t            totalRows;
+  int64_t            elapsedTime;
+  int64_t            totalBytes;
+} SSysTableScanInfo;
+
 typedef struct SOptrBasicInfo {
   SResultRowInfo  resultRowInfo;
   int32_t*        rowCellInfoOffset;  // offset value for each row result cell info
   SqlFunctionCtx* pCtx;
   SSDataBlock*    pRes;
-  uint32_t        resRowSize;
   int32_t         capacity;
 } SOptrBasicInfo;
 
+//TODO move the resultrowsiz together with SOptrBasicInfo:rowCellInfoOffset
 typedef struct SAggSupporter {
   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.
+  int32_t              resultRowSize;        // the result buffer size for each result row, with the meta data size for each row
 } SAggSupporter;
 
 typedef struct STableIntervalOperatorInfo {
@@ -613,13 +632,15 @@ typedef struct SOrderOperatorInfo {
   uint64_t                totalElapsed;  // total elapsed time
 } SOrderOperatorInfo;
 
-SOperatorInfo* createExchangeOperatorInfo(const SArray* pSources, const SArray* pSchema, SExecTaskInfo* pTaskInfo);
+SOperatorInfo* createExchangeOperatorInfo(const SNodeList* pSources, SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo);
 SOperatorInfo* createTableScanOperatorInfo(void* pTsdbReadHandle, int32_t order, int32_t numOfOutput,
                                            int32_t repeatTime, int32_t reverseTime, SExecTaskInfo* pTaskInfo);
 SOperatorInfo* createTableSeqScanOperatorInfo(void* pTsdbReadHandle, STaskRuntimeEnv* pRuntimeEnv);
-SOperatorInfo* createAggregateOperatorInfo(SOperatorInfo* downstream, SArray* pExprInfo, SExecTaskInfo* pTaskInfo, const STableGroupInfo* pTableGroupInfo);
-SOperatorInfo* createMultiTableAggOperatorInfo(SOperatorInfo* downstream, SArray* pExprInfo, SExecTaskInfo* pTaskInfo, const STableGroupInfo* pTableGroupInfo);
+SOperatorInfo* createAggregateOperatorInfo(SOperatorInfo* downstream, SArray* pExprInfo, SSDataBlock* pResultBlock, SExecTaskInfo* pTaskInfo, const STableGroupInfo* pTableGroupInfo);
+SOperatorInfo* createMultiTableAggOperatorInfo(SOperatorInfo* downstream, SArray* pExprInfo, SSDataBlock* pResultBlock, SExecTaskInfo* pTaskInfo, const STableGroupInfo* pTableGroupInfo);
 SOperatorInfo* createProjectOperatorInfo(SOperatorInfo* downstream, SArray* pExprInfo, SExecTaskInfo* pTaskInfo);
+SOperatorInfo* createSysTableScanOperatorInfo(void* pSysTableReadHandle, const SArray* pExprInfo, const SSchema* pSchema,
+                                              int32_t tableType, SEpSet epset, SExecTaskInfo* pTaskInfo);
 
 SOperatorInfo* createLimitOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SOperatorInfo* downstream);
 SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SArray* pExprInfo, SInterval* pInterval, SExecTaskInfo* pTaskInfo);
@@ -650,8 +671,6 @@ SOperatorInfo* createStatewindowOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SOper
                                              int32_t numOfOutput);
 SOperatorInfo* createSLimitOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SOperatorInfo* downstream, SExprInfo* pExpr,
                                         int32_t numOfOutput, void* merger, bool multigroupResult);
-SOperatorInfo* createFilterOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SOperatorInfo* downstream, SExprInfo* pExpr,
-                                        int32_t numOfOutput, SColumnInfo* pCols, int32_t numOfFilter);
 
 SOperatorInfo* createJoinOperatorInfo(SOperatorInfo** pdownstream, int32_t numOfDownstream, SSchema* pSchema,
                                       int32_t numOfOutput);
@@ -676,16 +695,8 @@ void updateOutputBuf(SOptrBasicInfo* pBInfo, int32_t* bufCapacity, int32_t numOf
 void clearOutputBuf(SOptrBasicInfo* pBInfo, int32_t* bufCapacity);
 void copyTsColoum(SSDataBlock* pRes, SqlFunctionCtx* pCtx, int32_t numOfOutput);
 
-int32_t createQueryFunc(SQueriedTableInfo* pTableInfo, int32_t numOfOutput, SExprInfo** pExprInfo, SSqlExpr** pExprMsg,
-                        SColumnInfo* pTagCols, int32_t queryType, void* pMsg, struct SUdfInfo* pUdfInfo);
-
-int32_t createIndirectQueryFuncExprFromMsg(SQueryTableReq* pQueryMsg, int32_t numOfOutput, SExprInfo** pExprInfo,
-                                           SSqlExpr** pExpr, SExprInfo* prevExpr, struct SUdfInfo* pUdfInfo);
-
 int32_t createQueryFilter(char* data, uint16_t len, SFilterInfo** pFilters);
 
-SGroupbyExpr* createGroupbyExprFromMsg(SQueryTableReq* pQueryMsg, SColIndex* pColIndex, int32_t* code);
-
 int32_t initQInfo(STsBufInfo* pTsBufInfo, void* tsdb, void* sourceOptr, SQInfo* pQInfo, STaskParam* param, char* start,
                   int32_t prevResultLen, void* merger);
 

source/libs/executor/src/dataDispatcher.c

@@ -39,7 +39,7 @@ typedef struct SDataCacheEntry {
 typedef struct SDataDispatchHandle {
   SDataSinkHandle sink;
   SDataSinkManager* pManager;
-  SDataBlockSchema schema;
+  SDataBlockDescNode* pSchema;
   STaosQueue* pDataBlocks;
   SDataDispatchBuf nextOutput;
   int32_t status;
@@ -48,12 +48,13 @@ typedef struct SDataDispatchHandle {
   pthread_mutex_t mutex;
 } SDataDispatchHandle;
 
-static bool needCompress(const SSDataBlock* pData, const SDataBlockSchema* pSchema) {
+static bool needCompress(const SSDataBlock* pData, const SDataBlockDescNode* pSchema) {
   if (tsCompressColData < 0 || 0 == pData->info.rows) {
     return false;
   }
 
-  for (int32_t col = 0; col < pSchema->numOfCols; ++col) {
+  int32_t numOfCols = LIST_LENGTH(pSchema->pSlots);
+  for (int32_t col = 0; col < numOfCols; ++col) {
     SColumnInfoData* pColRes = taosArrayGet(pData->pDataBlock, col);
     int32_t colSize = pColRes->info.bytes * pData->info.rows;
     if (NEEDTO_COMPRESS_QUERY(colSize)) {
@@ -70,13 +71,14 @@ static int32_t compressColData(SColumnInfoData *pColRes, int32_t numOfRows, char
       pColRes->pData, colSize, numOfRows, data, colSize + COMP_OVERFLOW_BYTES, compressed, NULL, 0);
 }
 
-static void copyData(const SInputData* pInput, const SDataBlockSchema* pSchema, char* data, int8_t compressed, int32_t *compLen) {
+static void copyData(const SInputData* pInput, const SDataBlockDescNode* pSchema, char* data, int8_t compressed, int32_t *compLen) {
+  int32_t numOfCols = LIST_LENGTH(pSchema->pSlots);
   int32_t *compSizes = (int32_t*)data;
   if (compressed) {
-    data += pSchema->numOfCols * sizeof(int32_t);
+    data += numOfCols * sizeof(int32_t);
   }
 
-  for (int32_t col = 0; col < pSchema->numOfCols; ++col) {
+  for (int32_t col = 0; col < numOfCols; ++col) {
     SColumnInfoData* pColRes = taosArrayGet(pInput->pData->pDataBlock, col);
     if (compressed) {
       compSizes[col] = compressColData(pColRes, pInput->pData->info.rows, data, compressed);
@@ -107,14 +109,14 @@ static void copyData(const SInputData* pInput, const SDataBlockSchema* pSchema,
 // data format: SDataCacheEntry | col1_data col2_data ... | numOfTables | STableIdInfo STableIdInfo ...
 static void toDataCacheEntry(const SDataDispatchHandle* pHandle, const SInputData* pInput, SDataDispatchBuf* pBuf) {
   SDataCacheEntry* pEntry = (SDataCacheEntry*)pBuf->pData;
-  pEntry->compressed = (int8_t)needCompress(pInput->pData, &(pHandle->schema));
+  pEntry->compressed = (int8_t)needCompress(pInput->pData, pHandle->pSchema);
   pEntry->numOfRows = pInput->pData->info.rows;
   pEntry->dataLen = 0;
 
   pBuf->useSize = DATA_META_LENGTH(pInput->pTableRetrieveTsMap);
-  copyData(pInput, &pHandle->schema, pEntry->data, pEntry->compressed, &pEntry->dataLen);
+  copyData(pInput, pHandle->pSchema, pEntry->data, pEntry->compressed, &pEntry->dataLen);
   if (0 == pEntry->compressed) {
-    pEntry->dataLen = pHandle->schema.resultRowSize * pInput->pData->info.rows;
+    pEntry->dataLen = pHandle->pSchema->resultRowSize * pInput->pData->info.rows;
   }
   pBuf->useSize += pEntry->dataLen;
   // todo completed
@@ -128,7 +130,7 @@ static bool allocBuf(SDataDispatchHandle* pDispatcher, const SInputData* pInput,
     return false;
   }
 
-  pBuf->allocSize = DATA_META_LENGTH(pInput->pTableRetrieveTsMap) + pDispatcher->schema.resultRowSize * pInput->pData->info.rows;
+  pBuf->allocSize = DATA_META_LENGTH(pInput->pTableRetrieveTsMap) + pDispatcher->pSchema->resultRowSize * pInput->pData->info.rows;
   pBuf->pData = malloc(pBuf->allocSize);
   if (pBuf->pData == NULL) {
     qError("SinkNode failed to malloc memory, size:%d, code:%d", pBuf->allocSize, TAOS_SYSTEM_ERROR(errno));
@@ -194,7 +196,7 @@ static int32_t getDataBlock(SDataSinkHandle* pHandle, SOutputData* pOutput) {
   if (NULL == pDispatcher->nextOutput.pData) {
     assert(pDispatcher->queryEnd);
     pOutput->useconds = pDispatcher->useconds;
-    pOutput->precision = pDispatcher->schema.precision;
+    pOutput->precision = pDispatcher->pSchema->precision;
     return TSDB_CODE_SUCCESS;
   }
   SDataCacheEntry* pEntry = (SDataCacheEntry*)(pDispatcher->nextOutput.pData);
@@ -206,7 +208,7 @@ static int32_t getDataBlock(SDataSinkHandle* pHandle, SOutputData* pOutput) {
   pthread_mutex_lock(&pDispatcher->mutex);
   pOutput->queryEnd = pDispatcher->queryEnd;
   pOutput->useconds = pDispatcher->useconds;
-  pOutput->precision = pDispatcher->schema.precision;
+  pOutput->precision = pDispatcher->pSchema->precision;
   pthread_mutex_unlock(&pDispatcher->mutex);
   return TSDB_CODE_SUCCESS;
 }
@@ -224,7 +226,7 @@ static int32_t destroyDataSinker(SDataSinkHandle* pHandle) {
   pthread_mutex_destroy(&pDispatcher->mutex);
 }
 
-int32_t createDataDispatcher(SDataSinkManager* pManager, const SDataSink* pDataSink, DataSinkHandle* pHandle) {
+int32_t createDataDispatcher(SDataSinkManager* pManager, const SDataSinkNode* pDataSink, DataSinkHandle* pHandle) {
   SDataDispatchHandle* dispatcher = calloc(1, sizeof(SDataDispatchHandle));
   if (NULL == dispatcher) {
     terrno = TSDB_CODE_QRY_OUT_OF_MEMORY;
@@ -236,7 +238,7 @@ int32_t createDataDispatcher(SDataSinkManager* pManager, const SDataSink* pDataS
   dispatcher->sink.fGetData = getDataBlock;
   dispatcher->sink.fDestroy = destroyDataSinker;
   dispatcher->pManager = pManager;
-  dispatcher->schema = pDataSink->schema;
+  dispatcher->pSchema = pDataSink->pInputDataBlockDesc;
   dispatcher->status = DS_BUF_EMPTY;
   dispatcher->queryEnd = false;
   dispatcher->pDataBlocks = taosOpenQueue();

source/libs/executor/src/dataSinkMgt.c

@@ -25,8 +25,8 @@ int32_t dsDataSinkMgtInit(SDataSinkMgtCfg *cfg) {
   pthread_mutex_init(&gDataSinkManager.mutex, NULL);
 }
 
-int32_t dsCreateDataSinker(const struct SDataSink *pDataSink, DataSinkHandle* pHandle) {
-  if (DSINK_Dispatch == pDataSink->info.type) {
+int32_t dsCreateDataSinker(const SDataSinkNode *pDataSink, DataSinkHandle* pHandle) {
+  if (QUERY_NODE_PHYSICAL_PLAN_DISPATCH == nodeType(pDataSink)) {
     return createDataDispatcher(&gDataSinkManager, pDataSink, pHandle);
   }
   return TSDB_CODE_FAILED;

source/libs/executor/src/executil.c

@@ -46,7 +46,7 @@ int32_t getOutputInterResultBufSize(STaskAttr* pQueryAttr) {
   int32_t size = 0;
 
   for (int32_t i = 0; i < pQueryAttr->numOfOutput; ++i) {
-    size += pQueryAttr->pExpr1[i].base.interBytes;
+//    size += pQueryAttr->pExpr1[i].base.interBytes;
   }
 
   assert(size >= 0);
@@ -172,9 +172,14 @@ SResultRowEntryInfo* getResultCell(const SResultRow* pRow, int32_t index, int32_
   return (SResultRowEntryInfo*)((char*) pRow->pEntryInfo + offset[index]);
 }
 
-size_t getResultRowSize(SArray* pExprInfo) {
-  size_t numOfOutput = taosArrayGetSize(pExprInfo);
-  return (numOfOutput * sizeof(SResultRowEntryInfo)) + /*pQueryAttr->interBufSize +*/ sizeof(SResultRow);
+size_t getResultRowSize(SqlFunctionCtx* pCtx, int32_t numOfOutput) {
+  int32_t rowSize = (numOfOutput * sizeof(SResultRowEntryInfo)) + sizeof(SResultRow);
+
+  for(int32_t i = 0; i < numOfOutput; ++i) {
+    rowSize += pCtx[i].resDataInfo.interBufSize;
+  }
+
+  return rowSize;
 }
 
 SResultRowPool* initResultRowPool(size_t size) {

source/libs/executor/src/executor.c

@@ -20,7 +20,7 @@
 
 static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void* input, char* id) {
   ASSERT(pOperator != NULL);
-  if (pOperator->operatorType != OP_StreamScan) {
+  if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN) {
     if (pOperator->numOfDownstream == 0) {
       qError("failed to find stream scan operator to set the input data block, %s" PRIx64, id);
       return TSDB_CODE_QRY_APP_ERROR;
@@ -99,7 +99,7 @@ int32_t qUpdateQualifiedTableId(qTaskInfo_t tinfo, SArray* tableIdList, bool isA
 
   // traverse to the streamscan node to add this table id
   SOperatorInfo* pInfo = pTaskInfo->pRoot;
-  while (pInfo->operatorType != OP_StreamScan) {
+  while(pInfo->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN) {
     pInfo = pInfo->pDownstream[0];
   }
 

source/libs/parser/inc/astCreateContext.h → source/libs/function/inc/builtinsimpl.h

@@ -13,28 +13,31 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef _TD_AST_CREATER_H_
-#define _TD_AST_CREATER_H_
+#ifndef TDENGINE_BUILTINSIMPL_H
+#define TDENGINE_BUILTINSIMPL_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "nodes.h"
-#include "parser.h"
+#include "function.h"
 
-typedef struct SAstCreateContext {
-  SParseContext* pQueryCxt;
-  bool notSupport;
-  bool valid;
-  SNode* pRootNode;
-} SAstCreateContext;
+bool functionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
+void functionFinalizer(SqlFunctionCtx *pCtx);
 
-int32_t createAstCreateContext(SParseContext* pQueryCxt, SAstCreateContext* pCxt);
-int32_t destroyAstCreateContext(SAstCreateContext* pCxt);
+bool getCountFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv);
+void countFunction(SqlFunctionCtx *pCtx);
+
+bool getSumFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv);
+void sumFunction(SqlFunctionCtx *pCtx);
+
+bool minFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
+bool maxFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
+bool getMinmaxFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv);
+void minFunction(SqlFunctionCtx* pCtx);
+void maxFunction(SqlFunctionCtx *pCtx);
 
 #ifdef __cplusplus
 }
 #endif
-
-#endif /*_TD_AST_CREATER_H_*/
+#endif  // TDENGINE_BUILTINSIMPL_H

source/libs/function/inc/taggfunction.h

@@ -83,9 +83,7 @@ static FORCE_INLINE void initResultRowEntry(SResultRowEntryInfo *pResInfo, int32
   pResInfo->initialized = true;  // the this struct has been initialized flag
   
   pResInfo->complete  = false;
-  pResInfo->hasResult = false;
   pResInfo->numOfRes  = 0;
-  
   memset(GET_ROWCELL_INTERBUF(pResInfo), 0, bufLen);
 }
 

source/libs/function/src/builtins.c

@@ -14,7 +14,9 @@
  */
 
 #include "builtins.h"
+#include "builtinsimpl.h"
 #include "taoserror.h"
+#include "tdatablock.h"
 
 int32_t stubCheckAndGetResultType(SFunctionNode* pFunc);
 
@@ -24,20 +26,40 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .type = FUNCTION_TYPE_COUNT,
     .classification = FUNC_MGT_AGG_FUNC,
     .checkFunc    = stubCheckAndGetResultType,
-    .getEnvFunc = NULL,
-    .initFunc = NULL,
-    .processFunc = NULL,
-    .finalizeFunc = NULL
+    .getEnvFunc   = getCountFuncEnv,
+    .initFunc     = functionSetup,
+    .processFunc  = countFunction,
+    .finalizeFunc = functionFinalizer
   },
   {
     .name = "sum",
     .type = FUNCTION_TYPE_SUM,
     .classification = FUNC_MGT_AGG_FUNC,
     .checkFunc    = stubCheckAndGetResultType,
-    .getEnvFunc = NULL,
-    .initFunc = NULL,
-    .processFunc = NULL,
-    .finalizeFunc = NULL
+    .getEnvFunc   = getSumFuncEnv,
+    .initFunc     = functionSetup,
+    .processFunc  = sumFunction,
+    .finalizeFunc = functionFinalizer
+  },
+  {
+    .name = "min",
+    .type = FUNCTION_TYPE_MIN,
+    .classification = FUNC_MGT_AGG_FUNC,
+    .checkFunc    = stubCheckAndGetResultType,
+    .getEnvFunc   = getMinmaxFuncEnv,
+    .initFunc     = minFunctionSetup,
+    .processFunc  = minFunction,
+    .finalizeFunc = functionFinalizer
+  },
+  {
+    .name = "max",
+    .type = FUNCTION_TYPE_MAX,
+    .classification = FUNC_MGT_AGG_FUNC,
+    .checkFunc    = stubCheckAndGetResultType,
+    .getEnvFunc   = getMinmaxFuncEnv,
+    .initFunc     = maxFunctionSetup,
+    .processFunc  = maxFunction,
+    .finalizeFunc = functionFinalizer
   },
   {
     .name = "concat",
@@ -51,8 +73,44 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
   }
 };
 
-const int funcMgtBuiltinsNum = (sizeof(funcMgtBuiltins) / sizeof(SBuiltinFuncDefinition));
+const int32_t funcMgtBuiltinsNum = (sizeof(funcMgtBuiltins) / sizeof(SBuiltinFuncDefinition));
 
 int32_t stubCheckAndGetResultType(SFunctionNode* pFunc) {
+  switch(pFunc->funcType) {
+    case FUNCTION_TYPE_COUNT:
+      pFunc->node.resType = (SDataType){.bytes = sizeof(int64_t), .type = TSDB_DATA_TYPE_BIGINT};
+      break;
+    case FUNCTION_TYPE_SUM: {
+      SColumnNode* pParam = nodesListGetNode(pFunc->pParameterList, 0);
+      int32_t paraType = pParam->node.resType.type;
+
+      int32_t resType  = 0;
+      if (IS_SIGNED_NUMERIC_TYPE(paraType)) {
+        resType = TSDB_DATA_TYPE_BIGINT;
+      } else if (IS_UNSIGNED_NUMERIC_TYPE(paraType)) {
+        resType = TSDB_DATA_TYPE_UBIGINT;
+      } else if (IS_FLOAT_TYPE(paraType)) {
+        resType = TSDB_DATA_TYPE_DOUBLE;
+      } else {
+        ASSERT(0);
+      }
+
+      pFunc->node.resType = (SDataType) { .bytes = tDataTypes[resType].bytes, .type = resType };
+      break;
+    }
+    case FUNCTION_TYPE_MIN:
+    case FUNCTION_TYPE_MAX: {
+      SColumnNode* pParam = nodesListGetNode(pFunc->pParameterList, 0);
+      int32_t paraType = pParam->node.resType.type;
+      pFunc->node.resType = (SDataType) { .bytes = tDataTypes[paraType].bytes, .type = paraType };
+      break;
+    }
+    case FUNCTION_TYPE_CONCAT:
+      // todo
+      break;
+    default:
+      ASSERT(0); // to found the fault ASAP.
+  }
+
   return TSDB_CODE_SUCCESS;
 }

source/libs/function/src/builtinsimpl.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "builtinsimpl.h"
+#include "querynodes.h"
+#include "taggfunction.h"
+#include "tdatablock.h"
+
+#define SET_VAL(_info, numOfElem, res)  \
+  do {                                  \
+    if ((numOfElem) <= 0) {             \
+      break;                            \
+    }                                   \
+    (_info)->numOfRes = (res);          \
+    (_info)->hasResult = DATA_SET_FLAG; \
+  } while (0)
+
+typedef struct SSumRes {
+  union {
+    int64_t  isum;
+    uint64_t usum;
+    double   dsum;
+  };
+} SSumRes;
+
+bool functionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo) {
+  if (pResultInfo->initialized) {
+    return false;
+  }
+
+  if (pCtx->pOutput != NULL) {
+    memset(pCtx->pOutput, 0, (size_t)pCtx->resDataInfo.bytes);
+  }
+
+  initResultRowEntry(pResultInfo, pCtx->resDataInfo.interBufSize);
+  return true;
+}
+
+static void doFinalizer(SResultRowEntryInfo* pResInfo) { cleanupResultRowEntry(pResInfo); }
+
+void functionFinalizer(SqlFunctionCtx *pCtx) {
+  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
+  if (pResInfo->hasResult != DATA_SET_FLAG) {
+//    setNull(pCtx->pOutput, pCtx->resDataInfo.type, pCtx->resDataInfo.bytes);
+  }
+
+  doFinalizer(pResInfo);
+}
+
+bool getCountFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
+  pEnv->calcMemSize = sizeof(int64_t);
+  return true;
+}
+
+/*
+ * count function does need the finalize, if data is missing, the default value, which is 0, is used
+ * count function does not use the pCtx->interResBuf to keep the intermediate buffer
+ */
+void countFunction(SqlFunctionCtx *pCtx) {
+  int32_t numOfElem = 0;
+
+  /*
+   * 1. column data missing (schema modified) causes pCtx->hasNull == true. pCtx->isAggSet == true;
+   * 2. for general non-primary key columns, pCtx->hasNull may be true or false, pCtx->isAggSet == true;
+   * 3. for primary key column, pCtx->hasNull always be false, pCtx->isAggSet == false;
+   */
+  SInputColumnInfoData* pInput = &pCtx->input;
+  SColumnInfoData* pInputCol = pInput->pData[0];
+
+  if (pInput->colDataAggIsSet && pInput->totalRows == pInput->numOfRows) {
+    numOfElem = pInput->numOfRows - pInput->pColumnDataAgg[0]->numOfNull;
+    ASSERT(numOfElem >= 0);
+  } else {
+    if (pInputCol->hasNull) {
+      for (int32_t i = pInput->startRowIndex; i < pInput->startRowIndex + pInput->numOfRows; ++i) {
+        if (colDataIsNull(pInputCol, pInput->totalRows, i, NULL)) {
+          continue;
+        }
+        numOfElem += 1;
+      }
+    } else {
+      //when counting on the primary time stamp column and no statistics data is presented, use the size value directly.
+      numOfElem = pInput->numOfRows;
+    }
+  }
+
+  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
+  char* buf = GET_ROWCELL_INTERBUF(pResInfo);
+  *((int64_t *)buf) += numOfElem;
+
+  SET_VAL(pResInfo, numOfElem, 1);
+}
+
+#define LIST_ADD_N(_res, _col, _start, _rows, _t, numOfElem)             \
+  do {                                                                   \
+    _t *d = (_t *)(_col->pData);                                         \
+    for (int32_t i = (_start); i < (_rows) + (_start); ++i) {            \
+      if (((_col)->hasNull) && colDataIsNull_f((_col)->nullbitmap, i)) { \
+        continue;                                                        \
+      };                                                                 \
+      (_res) += (d)[i];                                                  \
+      (numOfElem)++;                                                     \
+    }                                                                    \
+  } while (0)
+
+void sumFunction(SqlFunctionCtx *pCtx) {
+  int32_t numOfElem = 0;
+
+  // Only the pre-computing information loaded and actual data does not loaded
+  SInputColumnInfoData* pInput = &pCtx->input;
+  SColumnDataAgg *pAgg = pInput->pColumnDataAgg[0];
+  int32_t type = pInput->pData[0]->info.type;
+
+  SSumRes* pSumRes = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
+  
+  if (pInput->colDataAggIsSet) {
+    numOfElem = pInput->numOfRows - pAgg->numOfNull;
+    ASSERT(numOfElem >= 0);
+
+    if (IS_SIGNED_NUMERIC_TYPE(type)) {
+      pSumRes->isum += pAgg->sum;
+    } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
+      pSumRes->usum += pAgg->sum;
+    } else if (IS_FLOAT_TYPE(type)) {
+      pSumRes->dsum += GET_DOUBLE_VAL((const char*)&(pAgg->sum));
+    }
+  } else {  // computing based on the true data block
+    SColumnInfoData* pCol = pInput->pData[0];
+
+    int32_t start     = pInput->startRowIndex;
+    int32_t numOfRows = pInput->numOfRows;
+
+    if (IS_SIGNED_NUMERIC_TYPE(type)) {
+      if (type == TSDB_DATA_TYPE_TINYINT) {
+        LIST_ADD_N(pSumRes->isum, pCol, start, numOfRows, int8_t, numOfElem);
+      } else if (type == TSDB_DATA_TYPE_SMALLINT) {
+        LIST_ADD_N(pSumRes->isum, pCol, start, numOfRows, int16_t, numOfElem);
+      } else if (type == TSDB_DATA_TYPE_INT) {
+        LIST_ADD_N(pSumRes->isum, pCol, start, numOfRows, int32_t, numOfElem);
+      } else if (type == TSDB_DATA_TYPE_BIGINT) {
+        LIST_ADD_N(pSumRes->isum, pCol, start, numOfRows, int64_t, numOfElem);
+      }
+    } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
+      if (type == TSDB_DATA_TYPE_UTINYINT) {
+        LIST_ADD_N(pSumRes->usum, pCol, start, numOfRows, uint8_t, numOfElem);
+      } else if (type == TSDB_DATA_TYPE_USMALLINT) {
+        LIST_ADD_N(pSumRes->usum, pCol, start, numOfRows, uint16_t, numOfElem);
+      } else if (type == TSDB_DATA_TYPE_UINT) {
+        LIST_ADD_N(pSumRes->usum, pCol, start, numOfRows, uint32_t, numOfElem);
+      } else if (type == TSDB_DATA_TYPE_UBIGINT) {
+        LIST_ADD_N(pSumRes->usum, pCol, start, numOfRows, uint64_t, numOfElem);
+      }
+    } else if (type == TSDB_DATA_TYPE_DOUBLE) {
+      LIST_ADD_N(pSumRes->dsum, pCol, start, numOfRows, double, numOfElem);
+    } else if (type == TSDB_DATA_TYPE_FLOAT) {
+      LIST_ADD_N(pSumRes->dsum, pCol, start, numOfRows, float, numOfElem);
+    }
+  }
+
+  // data in the check operation are all null, not output
+  SET_VAL(GET_RES_INFO(pCtx), numOfElem, 1);
+}
+
+bool getSumFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
+  pEnv->calcMemSize = sizeof(SSumRes);
+  return true;
+}
+
+bool maxFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo) {
+  if (!functionSetup(pCtx, pResultInfo)) {
+    return false;
+  }
+
+  char* buf = GET_ROWCELL_INTERBUF(pResultInfo);
+  switch (pCtx->resDataInfo.type) {
+    case TSDB_DATA_TYPE_INT:
+      *((int32_t *)buf) = INT32_MIN;
+      break;
+    case TSDB_DATA_TYPE_UINT:
+      *((uint32_t *)buf) = 0;
+      break;
+    case TSDB_DATA_TYPE_FLOAT:
+      *((float *)buf) = -FLT_MAX;
+      break;
+    case TSDB_DATA_TYPE_DOUBLE:
+    SET_DOUBLE_VAL(((double *)buf), -DBL_MAX);
+      break;
+    case TSDB_DATA_TYPE_BIGINT:
+      *((int64_t *)buf) = INT64_MIN;
+      break;
+    case TSDB_DATA_TYPE_UBIGINT:
+      *((uint64_t *)buf) = 0;
+      break;
+    case TSDB_DATA_TYPE_SMALLINT:
+      *((int16_t *)buf) = INT16_MIN;
+      break;
+    case TSDB_DATA_TYPE_USMALLINT:
+      *((uint16_t *)buf) = 0;
+      break;
+    case TSDB_DATA_TYPE_TINYINT:
+      *((int8_t *)buf) = INT8_MIN;
+      break;
+    case TSDB_DATA_TYPE_UTINYINT:
+      *((uint8_t *)buf) = 0;
+      break;
+    default:
+      assert(0);
+  }
+  return true;
+}
+
+bool minFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo) {
+  if (!functionSetup(pCtx, pResultInfo)) {
+    return false;  // not initialized since it has been initialized
+  }
+
+  char* buf = GET_ROWCELL_INTERBUF(pResultInfo);
+  switch (pCtx->resDataInfo.type) {
+    case TSDB_DATA_TYPE_TINYINT:
+      *((int8_t *)buf) = INT8_MAX;
+      break;
+    case TSDB_DATA_TYPE_UTINYINT:
+      *(uint8_t *) buf = UINT8_MAX;
+      break;
+    case TSDB_DATA_TYPE_SMALLINT:
+      *((int16_t *)buf) = INT16_MAX;
+      break;
+    case TSDB_DATA_TYPE_USMALLINT:
+      *((uint16_t *)buf) = UINT16_MAX;
+      break;
+    case TSDB_DATA_TYPE_INT:
+      *((int32_t *)buf) = INT32_MAX;
+      break;
+    case TSDB_DATA_TYPE_UINT:
+      *((uint32_t *)buf) = UINT32_MAX;
+      break;
+    case TSDB_DATA_TYPE_BIGINT:
+      *((int64_t *)buf) = INT64_MAX;
+      break;
+    case TSDB_DATA_TYPE_UBIGINT:
+      *((uint64_t *)buf) = UINT64_MAX;
+      break;
+    case TSDB_DATA_TYPE_FLOAT:
+      *((float *)buf) = FLT_MAX;
+      break;
+    case TSDB_DATA_TYPE_DOUBLE:
+      SET_DOUBLE_VAL(((double *)buf), DBL_MAX);
+      break;
+    default:
+      assert(0);
+  }
+
+  return true;
+}
+
+bool getMinmaxFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
+  SNode* pNode = nodesListGetNode(pFunc->pParameterList, 0);
+  pEnv->calcMemSize = sizeof(int64_t);
+  return true;
+}
+
+#define GET_TS_LIST(x)    ((TSKEY*)((x)->ptsList))
+#define GET_TS_DATA(x, y) (GET_TS_LIST(x)[(y)])
+
+#define DO_UPDATE_TAG_COLUMNS_WITHOUT_TS(ctx)                      \
+  do {                                                             \
+    for (int32_t _i = 0; _i < (ctx)->tagInfo.numOfTagCols; ++_i) { \
+      SqlFunctionCtx *__ctx = (ctx)->tagInfo.pTagCtxList[_i];      \
+      __ctx->fpSet.process(__ctx);                       \
+    }                                                              \
+  } while (0);
+
+#define DO_UPDATE_SUBSID_RES(ctx, ts)                             \
+  do {                                                             \
+    for (int32_t _i = 0; _i < (ctx)->subsidiaryRes.numOfCols; ++_i) { \
+      SqlFunctionCtx *__ctx = (ctx)->subsidiaryRes.pCtx[_i];      \
+      if (__ctx->functionId == FUNCTION_TS_DUMMY) {                \
+        __ctx->tag.i = (ts);                                       \
+        __ctx->tag.nType = TSDB_DATA_TYPE_BIGINT;                  \
+      }                                                            \
+      __ctx->fpSet.process(__ctx);                                 \
+    }                                                              \
+  } while (0)
+
+#define UPDATE_DATA(ctx, left, right, num, sign, _ts) \
+  do {                                              \
+    if (((left) < (right)) ^ (sign)) {              \
+      (left) = (right);                             \
+      DO_UPDATE_SUBSID_RES(ctx, _ts);                \
+      (num) += 1;                                   \
+    }                                               \
+  } while (0)
+
+#define LOOPCHECK_N(val, _col, ctx, _t, _nrow, _start, sign, num)       \
+  do {                                                                   \
+    _t* d = (_t*)((_col)->pData);                                        \
+    for (int32_t i = (_start); i < (_nrow) + (_start); ++i) {            \
+      if (((_col)->hasNull) && colDataIsNull_f((_col)->nullbitmap, i)) { \
+        continue;                                                        \
+      }                                                                  \
+      TSKEY ts = (ctx)->ptsList != NULL ? GET_TS_DATA(ctx, i) : 0;       \
+      UPDATE_DATA(ctx, val, d[i], num, sign, ts);                        \
+    }                                                                    \
+  } while (0)
+
+int32_t doMinMaxHelper(SqlFunctionCtx *pCtx, int32_t isMinFunc) {
+  int32_t numOfElems = 0;
+
+  SInputColumnInfoData* pInput = &pCtx->input;
+  SColumnDataAgg *pAgg = pInput->pColumnDataAgg[0];
+
+  SColumnInfoData* pCol = pInput->pData[0];
+  int32_t type = pCol->info.type;
+
+  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
+  char* buf = GET_ROWCELL_INTERBUF(pResInfo);
+
+  // data in current data block are qualified to the query
+  if (pInput->colDataAggIsSet) {
+    numOfElems = pInput->numOfRows - pAgg->numOfNull;
+    ASSERT(pInput->numOfRows == pInput->totalRows && numOfElems >= 0);
+
+    if (numOfElems == 0) {
+      return numOfElems;
+    }
+
+    void*   tval = NULL;
+    int16_t index = 0;
+
+    if (isMinFunc) {
+      tval  = &pInput->pColumnDataAgg[0]->min;
+      index = pInput->pColumnDataAgg[0]->minIndex;
+    } else {
+      tval  = &pInput->pColumnDataAgg[0]->max;
+      index = pInput->pColumnDataAgg[0]->maxIndex;
+    }
+
+    TSKEY key = TSKEY_INITIAL_VAL;
+    if (pCtx->ptsList != NULL) {
+      // the index is the original position, not the relative position
+      key = pCtx->ptsList[index];
+    }
+
+    if (IS_SIGNED_NUMERIC_TYPE(type)) {
+      int64_t val = GET_INT64_VAL(tval);
+
+#if defined(_DEBUG_VIEW)
+      qDebug("max value updated according to pre-cal:%d", *data);
+#endif
+
+      if ((*(int64_t*)buf < val) ^ isMinFunc) {
+        *(int64_t*) buf = val;
+        for (int32_t i = 0; i < (pCtx)->subsidiaryRes.numOfCols; ++i) {
+          SqlFunctionCtx* __ctx = pCtx->subsidiaryRes.pCtx[i];
+          if (__ctx->functionId == FUNCTION_TS_DUMMY) {  // TODO refactor
+            __ctx->tag.i = key;
+            __ctx->tag.nType = TSDB_DATA_TYPE_BIGINT;
+          }
+
+          __ctx->fpSet.process(__ctx);
+        }
+      }
+    } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
+      uint64_t val = GET_UINT64_VAL(tval);
+      UPDATE_DATA(pCtx, *(uint64_t*)buf, val, numOfElems, isMinFunc, key);
+    } else if (type == TSDB_DATA_TYPE_DOUBLE) {
+      double  val = GET_DOUBLE_VAL(tval);
+      UPDATE_DATA(pCtx, *(double*)buf, val, numOfElems, isMinFunc, key);
+    } else if (type == TSDB_DATA_TYPE_FLOAT) {
+      double val = GET_DOUBLE_VAL(tval);
+      UPDATE_DATA(pCtx, *(float*)buf, (float)val, numOfElems, isMinFunc, key);
+    }
+
+    return numOfElems;
+  }
+
+  int32_t start = pInput->startRowIndex;
+  int32_t numOfRows = pInput->numOfRows;
+
+  if (IS_SIGNED_NUMERIC_TYPE(type)) {
+    if (type == TSDB_DATA_TYPE_TINYINT) {
+      LOOPCHECK_N(*(int8_t*)buf, pCol, pCtx, int8_t, numOfRows, start, isMinFunc, numOfElems);
+    } else if (type == TSDB_DATA_TYPE_SMALLINT) {
+      LOOPCHECK_N(*(int16_t*) buf, pCol, pCtx, int16_t, numOfRows, start, isMinFunc, numOfElems);
+    } else if (type == TSDB_DATA_TYPE_INT) {
+      int32_t *pData = (int32_t*)pCol->pData;
+      int32_t *val = (int32_t*) buf;
+
+      for (int32_t i = 0; i < pCtx->size; ++i) {
+        if ((pCol->hasNull) && colDataIsNull_f(pCol->nullbitmap, i)) {
+          continue;
+        }
+
+        if ((*val < pData[i]) ^ isMinFunc) {
+          *val = pData[i];
+          TSKEY ts = (pCtx->ptsList != NULL)? GET_TS_DATA(pCtx, i) : 0;
+          DO_UPDATE_SUBSID_RES(pCtx, ts);
+        }
+
+        numOfElems += 1;
+      }
+
+#if defined(_DEBUG_VIEW)
+      qDebug("max value updated:%d", *retVal);
+#endif
+    } else if (type == TSDB_DATA_TYPE_BIGINT) {
+      LOOPCHECK_N(*(int64_t*) buf, pCol, pCtx, int64_t, numOfRows, start, isMinFunc, numOfElems);
+    }
+  } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
+    if (type == TSDB_DATA_TYPE_UTINYINT) {
+      LOOPCHECK_N(*(uint8_t*) buf, pCol, pCtx, uint8_t, numOfRows, start, isMinFunc, numOfElems);
+    } else if (type == TSDB_DATA_TYPE_USMALLINT) {
+      LOOPCHECK_N(*(uint16_t*) buf, pCol, pCtx, uint16_t, numOfRows, start, isMinFunc, numOfElems);
+    } else if (type == TSDB_DATA_TYPE_UINT) {
+      LOOPCHECK_N(*(uint32_t*) buf, pCol, pCtx, uint32_t, numOfRows, start, isMinFunc, numOfElems);
+    } else if (type == TSDB_DATA_TYPE_UBIGINT) {
+      LOOPCHECK_N(*(uint64_t*) buf, pCol, pCtx, uint64_t, numOfRows, start, isMinFunc, numOfElems);
+    }
+  } else if (type == TSDB_DATA_TYPE_DOUBLE) {
+    LOOPCHECK_N(*(double*) buf, pCol, pCtx, double, numOfRows, start, isMinFunc, numOfElems);
+  } else if (type == TSDB_DATA_TYPE_FLOAT) {
+    LOOPCHECK_N(*(float*) buf, pCol, pCtx, float, numOfRows, start, isMinFunc, numOfElems);
+  }
+
+  return numOfElems;
+}
+
+void minFunction(SqlFunctionCtx *pCtx) {
+  int32_t numOfElems = doMinMaxHelper(pCtx, 1);
+  SET_VAL(GET_RES_INFO(pCtx), numOfElems, 1);
+}
+
+void maxFunction(SqlFunctionCtx *pCtx) {
+  int32_t numOfElems = doMinMaxHelper(pCtx, 0);
+  SET_VAL(GET_RES_INFO(pCtx), numOfElems, 1);
+}
\ No newline at end of file

source/libs/function/src/functionMgt.c

@@ -26,18 +26,27 @@ typedef struct SFuncMgtService {
 } SFuncMgtService;
 
 static SFuncMgtService gFunMgtService;
+static pthread_once_t functionHashTableInit = PTHREAD_ONCE_INIT;
+static int32_t initFunctionCode = 0;
 
-int32_t fmFuncMgtInit() {
+static void doInitFunctionHashTable() {
   gFunMgtService.pFuncNameHashTable = taosHashInit(funcMgtBuiltinsNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
   if (NULL == gFunMgtService.pFuncNameHashTable) {
-    return TSDB_CODE_FAILED;
+    initFunctionCode = TSDB_CODE_FAILED;
+    return;
   }
+
   for (int32_t i = 0; i < funcMgtBuiltinsNum; ++i) {
     if (TSDB_CODE_SUCCESS != taosHashPut(gFunMgtService.pFuncNameHashTable, funcMgtBuiltins[i].name, strlen(funcMgtBuiltins[i].name), &i, sizeof(int32_t))) {
-      return TSDB_CODE_FAILED;
+      initFunctionCode = TSDB_CODE_FAILED;
+      return;
     }
   }
-  return TSDB_CODE_SUCCESS;
+}
+
+int32_t fmFuncMgtInit() {
+  pthread_once(&functionHashTableInit, doInitFunctionHashTable);
+  return initFunctionCode;
 }
 
 int32_t fmGetFuncInfo(const char* pFuncName, int32_t* pFuncId, int32_t* pFuncType) {
@@ -85,3 +94,10 @@ bool fmIsAggFunc(int32_t funcId) {
   }
   return FUNC_MGT_TEST_MASK(funcMgtBuiltins[funcId].classification, FUNC_MGT_AGG_FUNC);
 }
+
+void fmFuncMgtDestroy() {
+  void* m = gFunMgtService.pFuncNameHashTable;
+  if (m != NULL && atomic_val_compare_exchange_ptr(&gFunMgtService.pFuncNameHashTable, m, 0) == m) {
+    taosHashCleanup(m);
+  }
+}

source/libs/function/src/tfill.c

@@ -543,7 +543,7 @@ struct SFillColInfo* createFillColInfo(SExprInfo* pExpr, int32_t numOfOutput, co
     pFillCol[i].col.offset = offset;
     pFillCol[i].col.colId  = pExprInfo->base.resSchema.colId;
     pFillCol[i].tagIndex   = -2;
-    pFillCol[i].flag       = pExprInfo->base.pColumns->flag;    // always be the normal column for table query
+    pFillCol[i].flag       = pExprInfo->base.pParam[0].pCol->flag;    // always be the normal column for table query
 //    pFillCol[i].functionId = pExprInfo->pExpr->_function.functionId;
     pFillCol[i].fillVal.i  = fillVal[i];
 

source/libs/nodes/src/nodesEqualFuncs.c

@@ -95,7 +95,7 @@ static bool functionNodeEqual(const SFunctionNode* a, const SFunctionNode* b) {
   return true;
 }
 
-bool nodesEqualNode(const SNode* a, const SNode* b) {
+bool nodesEqualNode(const SNodeptr a, const SNodeptr b) {
   if (a == b) {
     return true;
   }