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

include/common/common.h

@@ -62,6 +62,12 @@ typedef struct SConstantItem {
   SVariant    value;
 } SConstantItem;
 
+typedef struct {
+  uint32_t  numOfTables;
+  SArray   *pGroupList;
+  SHashObj *map;  // speedup acquire the tableQueryInfo by table uid
+} STableGroupInfo;
+
 typedef struct SSDataBlock {
   SColumnDataAgg *pBlockAgg;
   SArray         *pDataBlock;    // SArray<SColumnInfoData>

include/common/tmsg.h

@@ -133,36 +133,36 @@ typedef enum _mgmt_table {
 #define TSDB_COL_IS_UD_COL(f) ((f & (~(TSDB_COL_NULL))) == TSDB_COL_UDC)
 #define TSDB_COL_REQ_NULL(f) (((f)&TSDB_COL_NULL) != 0)
 
-typedef struct SKv {
+typedef struct {
   int32_t keyLen;
   int32_t valueLen;
   void*   key;
   void*   value;
 } SKv;
 
-typedef struct SClientHbKey {
+typedef struct {
   int32_t connId;
   int32_t hbType;
 } SClientHbKey;
 
-typedef struct SClientHbReq {
+typedef struct {
   SClientHbKey connKey;
   SHashObj*    info;  // hash<Slv.key, Sklv>
 } SClientHbReq;
 
-typedef struct SClientHbBatchReq {
+typedef struct {
   int64_t reqId;
   SArray* reqs;  // SArray<SClientHbReq>
 } SClientHbBatchReq;
 
-typedef struct SClientHbRsp {
+typedef struct {
   SClientHbKey connKey;
   int32_t      status;
   int32_t      bodyLen;
   void*        body;
 } SClientHbRsp;
 
-typedef struct SClientHbBatchRsp {
+typedef struct {
   int64_t reqId;
   int64_t rspId;
   SArray* rsps;  // SArray<SClientHbRsp>
@@ -220,13 +220,13 @@ static FORCE_INLINE void* taosDecodeSClientHbKey(void* buf, SClientHbKey* pKey)
   return buf;
 }
 
-typedef struct SBuildTableMetaInput {
+typedef struct {
   int32_t vgId;
   char*   dbName;
   char*   tableFullName;
 } SBuildTableMetaInput;
 
-typedef struct SBuildUseDBInput {
+typedef struct {
   char    db[TSDB_TABLE_FNAME_LEN];
   int32_t vgVersion;
 } SBuildUseDBInput;
@@ -234,17 +234,12 @@ typedef struct SBuildUseDBInput {
 #pragma pack(push, 1)
 
 // null-terminated string instead of char array to avoid too many memory consumption in case of more than 1M tableMeta
-typedef struct {
-  char     fqdn[TSDB_FQDN_LEN];
-  uint16_t port;
-} SEpAddrMsg;
-
 typedef struct {
   char     fqdn[TSDB_FQDN_LEN];
   uint16_t port;
 } SEpAddr;
 
-typedef struct SMsgHead {
+typedef struct {
   int32_t contLen;
   int32_t vgId;
 } SMsgHead;
@@ -262,7 +257,7 @@ typedef struct SSubmitBlk {
 } SSubmitBlk;
 
 // Submit message for this TSDB
-typedef struct SSubmitMsg {
+typedef struct {
   SMsgHead header;
   int64_t  version;
   int32_t  length;
@@ -301,7 +296,7 @@ typedef struct {
   int32_t              failedRows;    // number of failed records (exclude duplicate records)
   int32_t              numOfFailedBlocks;
   SShellSubmitRspBlock failedBlocks[];
-} SShellSubmitRspMsg;
+} SShellSubmitRsp;
 
 typedef struct SSchema {
   int8_t  type;
@@ -310,98 +305,24 @@ typedef struct SSchema {
   char    name[TSDB_COL_NAME_LEN];
 } SSchema;
 
-typedef struct {
-  int32_t  contLen;
-  int32_t  vgId;
-  int8_t   tableType;
-  int16_t  numOfColumns;
-  int16_t  numOfTags;
-  int32_t  tid;
-  int32_t  sversion;
-  int32_t  tversion;
-  int32_t  tagDataLen;
-  int32_t  sqlDataLen;
-  uint64_t uid;
-  uint64_t superTableUid;
-  uint64_t createdTime;
-  char     tableFname[TSDB_TABLE_FNAME_LEN];
-  char     stbFname[TSDB_TABLE_FNAME_LEN];
-  char     data[];
-} SMDCreateTableMsg;
-
-// typedef struct {
-//  int32_t len;  // one create table message
-//  char    tableName[TSDB_TABLE_FNAME_LEN];
-//  int16_t numOfColumns;
-//  int16_t sqlLen;  // the length of SQL, it starts after schema , sql is a null-terminated string
-//  int8_t  igExists;
-//  int8_t  rspMeta;
-//  int8_t  reserved[16];
-//  char    schema[];
-//} SCreateTableMsg;
-
-typedef struct {
-  char    tableName[TSDB_TABLE_FNAME_LEN];
-  int16_t numOfColumns;
-  int16_t numOfTags;
-  int8_t  igExists;
-  int8_t  rspMeta;
-  char    schema[];
-} SCreateCTableMsg;
-
 typedef struct {
   char    name[TSDB_TABLE_FNAME_LEN];
   int8_t  igExists;
   int32_t numOfTags;
   int32_t numOfColumns;
   SSchema pSchema[];
-} SCreateStbMsg, SCreateTableMsg;
+} SMCreateStbReq;
 
 typedef struct {
   char   name[TSDB_TABLE_FNAME_LEN];
   int8_t igNotExists;
-} SDropStbMsg;
+} SMDropStbReq;
 
 typedef struct {
   char    name[TSDB_TABLE_FNAME_LEN];
   int8_t  alterType;
   SSchema schema;
-} SAlterStbMsg;
-
-typedef struct {
-  SMsgHead head;
-  char     name[TSDB_TABLE_FNAME_LEN];
-  uint64_t suid;
-} SVDropStbReq;
-
-typedef struct {
-  SMsgHead head;
-  char     name[TSDB_TABLE_FNAME_LEN];
-  int8_t   type;      /* operation type   */
-  int32_t  numOfCols; /* number of schema */
-  int32_t  numOfTags;
-  char     data[];
-} SAlterTableMsg;
-
-typedef struct {
-  SMsgHead head;
-  char     name[TSDB_TABLE_FNAME_LEN];
-  int8_t   ignoreNotExists;
-} SDropTableMsg;
-
-typedef struct {
-  SMsgHead head;
-  int64_t  uid;
-  int32_t  tid;
-  int16_t  tversion;
-  int16_t  colId;
-  int8_t   type;
-  int16_t  bytes;
-  int32_t  tagValLen;
-  int16_t  numOfTags;
-  int32_t  schemaLen;
-  char     data[];
-} SUpdateTableTagValMsg;
+} SMAlterStbReq;
 
 typedef struct {
   int32_t pid;
@@ -470,28 +391,13 @@ typedef struct {
 } SCreateUserReq, SAlterUserReq;
 
 typedef struct {
-  int32_t  contLen;
-  int32_t  vgId;
-  int32_t  tid;
-  uint64_t uid;
-  char     tableFname[TSDB_TABLE_FNAME_LEN];
-} SMDDropTableMsg;
-
-typedef struct {
-  int32_t  contLen;
-  int32_t  vgId;
-  uint64_t uid;
-  char     tableFname[TSDB_TABLE_FNAME_LEN];
-} SDropSTableMsg;
-
-typedef struct SColIndex {
   int16_t colId;     // column id
   int16_t colIndex;  // column index in colList if it is a normal column or index in tagColList if a tag
   int16_t flag;      // denote if it is a tag or a normal column
   char    name[TSDB_DB_FNAME_LEN];
 } SColIndex;
 
-typedef struct SColumnFilterInfo {
+typedef struct {
   int16_t lowerRelOptr;
   int16_t upperRelOptr;
   int16_t filterstr;  // denote if current column is char(binary/nchar)
@@ -512,7 +418,7 @@ typedef struct SColumnFilterInfo {
   };
 } SColumnFilterInfo;
 
-typedef struct SColumnFilterList {
+typedef struct {
   int16_t numOfFilters;
   union {
     int64_t            placeholder;
@@ -523,14 +429,14 @@ typedef struct SColumnFilterList {
  * for client side struct, we only need the column id, type, bytes are not necessary
  * But for data in vnode side, we need all the following information.
  */
-typedef struct SColumnInfo {
+typedef struct {
   int16_t           colId;
   int16_t           type;
   int16_t           bytes;
   SColumnFilterList flist;
 } SColumnInfo;
 
-typedef struct STableIdInfo {
+typedef struct {
   uint64_t uid;
   TSKEY    key;  // last accessed ts, for subscription
 } STableIdInfo;
@@ -547,7 +453,7 @@ typedef struct {
   int32_t tsOrder;        // ts comp block order
 } STsBufInfo;
 
-typedef struct SInterval {
+typedef struct {
   int32_t tz;  // query client timezone
   char    intervalUnit;
   char    slidingUnit;
@@ -606,7 +512,7 @@ typedef struct {
   int32_t     udfContentOffset;
   int32_t     udfContentLen;
   SColumnInfo tableCols[];
-} SQueryTableMsg;
+} SQueryTableReq;
 
 typedef struct {
   int32_t code;
@@ -623,7 +529,7 @@ typedef struct {
   int8_t free;
 } SRetrieveTableReq;
 
-typedef struct SRetrieveTableRsp {
+typedef struct {
   int64_t useconds;
   int8_t  completed;  // all results are returned to client
   int8_t  precision;
@@ -655,7 +561,7 @@ typedef struct {
   int8_t  update;
   int8_t  cacheLastRow;
   int8_t  ignoreExist;
-} SCreateDbMsg;
+} SCreateDbReq;
 
 typedef struct {
   char    db[TSDB_DB_FNAME_LEN];
@@ -667,25 +573,25 @@ typedef struct {
   int8_t  walLevel;
   int8_t  quorum;
   int8_t  cacheLastRow;
-} SAlterDbMsg;
+} SAlterDbReq;
 
 typedef struct {
   char   db[TSDB_TABLE_FNAME_LEN];
   int8_t ignoreNotExists;
-} SDropDbMsg;
+} SDropDbReq;
 
 typedef struct {
   char    db[TSDB_TABLE_FNAME_LEN];
   int32_t vgVersion;
-} SUseDbMsg;
+} SUseDbReq;
 
 typedef struct {
   char db[TSDB_TABLE_FNAME_LEN];
-} SSyncDbMsg;
+} SSyncDbReq;
 
 typedef struct {
   char db[TSDB_TABLE_FNAME_LEN];
-} SCompactDbMsg;
+} SCompactDbReq;
 
 typedef struct {
   char    name[TSDB_FUNC_NAME_LEN];
@@ -699,16 +605,16 @@ typedef struct {
   int32_t commentSize;
   int32_t codeSize;
   char    pCont[];
-} SCreateFuncMsg;
+} SCreateFuncReq;
 
 typedef struct {
   char name[TSDB_FUNC_NAME_LEN];
-} SDropFuncMsg;
+} SDropFuncReq;
 
 typedef struct {
   int32_t numOfFuncs;
   char    pFuncNames[];
-} SRetrieveFuncMsg;
+} SRetrieveFuncReq;
 
 typedef struct {
   char    name[TSDB_FUNC_NAME_LEN];
@@ -768,7 +674,7 @@ typedef struct {
 
 typedef struct {
   int32_t reserved;
-} STransMsg;
+} STransReq;
 
 typedef struct {
   int32_t dnodeId;
@@ -843,7 +749,7 @@ typedef struct {
   SMsgHead header;
   char     dbFname[TSDB_DB_FNAME_LEN];
   char     tableFname[TSDB_TABLE_FNAME_LEN];
-} STableInfoMsg;
+} STableInfoReq;
 
 typedef struct {
   int8_t  metaClone;  // create local clone of the cached table meta
@@ -851,7 +757,7 @@ typedef struct {
   int32_t numOfTables;
   int32_t numOfUdfs;
   char    tableNames[];
-} SMultiTableInfoMsg;
+} SMultiTableInfoReq;
 
 typedef struct SVgroupInfo {
   int32_t    vgId;
@@ -859,19 +765,19 @@ typedef struct SVgroupInfo {
   uint32_t   hashEnd;
   int8_t     inUse;
   int8_t     numOfEps;
-  SEpAddrMsg epAddr[TSDB_MAX_REPLICA];
+  SEpAddr epAddr[TSDB_MAX_REPLICA];
 } SVgroupInfo;
 
 typedef struct {
   int32_t    vgId;
   int8_t     numOfEps;
-  SEpAddrMsg epAddr[TSDB_MAX_REPLICA];
+  SEpAddr epAddr[TSDB_MAX_REPLICA];
 } SVgroupMsg;
 
 typedef struct {
   int32_t    numOfVgroups;
   SVgroupMsg vgroups[];
-} SVgroupsMsg, SVgroupsInfo;
+} SVgroupsInfo;
 
 typedef struct {
   char     tbFname[TSDB_TABLE_FNAME_LEN];  // table full name
@@ -888,9 +794,9 @@ typedef struct {
   uint64_t tuid;
   int32_t  vgId;
   SSchema  pSchema[];
-} STableMetaMsg;
+} STableMetaRsp;
 
-typedef struct SMultiTableMeta {
+typedef struct {
   int32_t numOfTables;
   int32_t numOfVgroup;
   int32_t numOfUdf;
@@ -932,11 +838,11 @@ typedef struct {
   char    db[TSDB_DB_FNAME_LEN];
   int32_t numOfVgroup;
   int32_t vgid[];
-} SCompactMsg;
+} SCompactReq;
 
-typedef struct SShowRsp {
+typedef struct {
   int64_t       showId;
-  STableMetaMsg tableMeta;
+  STableMetaRsp tableMeta;
 } SShowRsp;
 
 typedef struct {
@@ -975,17 +881,6 @@ typedef struct {
   int32_t dnodeId;
 } SMCreateBnodeReq, SMDropBnodeReq, SDCreateBnodeReq, SDDropBnodeReq;
 
-typedef struct {
-  int32_t dnodeId;
-  int32_t vgId;
-  int32_t tid;
-} SConfigTableMsg;
-
-typedef struct {
-  int32_t dnodeId;
-  int32_t vgId;
-} SConfigVnodeMsg;
-
 typedef struct {
   char    sql[TSDB_SHOW_SQL_LEN];
   int32_t queryId;
@@ -1042,7 +937,7 @@ typedef struct {
   int8_t align[7];
   char   name[TSDB_STEP_NAME_LEN];
   char   desc[TSDB_STEP_DESC_LEN];
-} SStartupMsg;
+} SStartupReq;
 
 // mq related
 typedef struct {
@@ -1083,46 +978,6 @@ typedef struct {
 } SSubmitReqReader;
 
 typedef struct {
-  /* data */
-} SCreateTableReq;
-
-typedef struct {
-  /* data */
-} SCreateTableRsp;
-
-typedef struct {
-  /* data */
-} SDropTableReq;
-
-typedef struct {
-  /* data */
-} SDropTableRsp;
-
-typedef struct {
-  /* data */
-} SAlterTableReq;
-
-typedef struct {
-  /* data */
-} SAlterTableRsp;
-
-typedef struct {
-  /* data */
-} SDropStableReq;
-
-typedef struct {
-  /* data */
-} SDropStableRsp;
-
-typedef struct {
-  /* data */
-} SUpdateTagValReq;
-
-typedef struct {
-  /* data */
-} SUpdateTagValRsp;
-
-typedef struct SSubQueryMsg {
   SMsgHead header;
   uint64_t sId;
   uint64_t queryId;
@@ -1131,59 +986,67 @@ typedef struct SSubQueryMsg {
   char     msg[];
 } SSubQueryMsg;
 
-typedef struct SResReadyMsg {
+typedef struct {
   SMsgHead header;
   uint64_t sId;
   uint64_t queryId;
   uint64_t taskId;
-} SResReadyMsg;
+} SSinkDataReq;
+
 
-typedef struct SResReadyRsp {
+typedef struct {
+  SMsgHead header;
+  uint64_t sId;
+  uint64_t queryId;
+  uint64_t taskId;
+} SResReadyReq;
+
+typedef struct {
   int32_t code;
 } SResReadyRsp;
 
-typedef struct SResFetchMsg {
+typedef struct {
   SMsgHead header;
   uint64_t sId;
   uint64_t queryId;
   uint64_t taskId;
-} SResFetchMsg;
+} SResFetchReq;
 
-typedef struct SSchTasksStatusMsg {
+typedef struct {
   SMsgHead header;
   uint64_t sId;
-} SSchTasksStatusMsg;
+} SSchTasksStatusReq;
 
-typedef struct STaskStatus {
+typedef struct {
   uint64_t queryId;
   uint64_t taskId;
   int8_t   status;
 } STaskStatus;
 
-typedef struct SSchedulerStatusRsp {
+typedef struct {
   uint32_t    num;
   STaskStatus status[];
 } SSchedulerStatusRsp;
 
-typedef struct STaskCancelMsg {
+typedef struct {
   SMsgHead header;
   uint64_t sId;
   uint64_t queryId;
   uint64_t taskId;
-} STaskCancelMsg;
+} STaskCancelReq;
 
-typedef struct STaskCancelRsp {
+typedef struct {
   int32_t code;
 } STaskCancelRsp;
 
-typedef struct STaskDropMsg {
+typedef struct {
   SMsgHead header;
   uint64_t sId;
   uint64_t queryId;
   uint64_t taskId;
-} STaskDropMsg;
+} STaskDropReq;
 
-typedef struct STaskDropRsp {
+typedef struct {
   int32_t code;
 } STaskDropRsp;
 
@@ -1334,18 +1197,18 @@ typedef struct {
   void*   executor;
   int32_t sqlLen;
   char*   sql;
-} SCreateTopicMsg;
+} SCreateTopicReq;
 
 typedef struct {
   char   name[TSDB_TABLE_FNAME_LEN];
   int8_t igNotExists;
-} SDropTopicMsg;
+} SDropTopicReq;
 
 typedef struct {
   char    name[TSDB_TABLE_FNAME_LEN];
   int8_t  alterType;
   SSchema schema;
-} SAlterTopicMsg;
+} SAlterTopicReq;
 
 typedef struct {
   SMsgHead head;
@@ -1356,13 +1219,13 @@ typedef struct {
   char*    executor;
   int32_t  sqlLen;
   char*    sql;
-} SDCreateTopicMsg;
+} SDCreateTopicReq;
 
 typedef struct {
   SMsgHead head;
   char     name[TSDB_TABLE_FNAME_LEN];
   uint64_t tuid;
-} SDDropTopicMsg;
+} SDDropTopicReq;
 
 typedef struct SVCreateTbReq {
   uint64_t ver;  // use a general definition
@@ -1402,24 +1265,63 @@ void* tDeserializeSVCreateTbReq(void* buf, SVCreateTbReq* pReq);
 int   tSVCreateTbBatchReqSerialize(void** buf, SVCreateTbBatchReq* pReq);
 void* tSVCreateTbBatchReqDeserialize(void* buf, SVCreateTbBatchReq* pReq);
 
-typedef struct SVCreateTbRsp {
+typedef struct {
+  SMsgHead head;
 } SVCreateTbRsp;
 
-typedef struct SVShowTablesReq {
+typedef struct {
+  SMsgHead head;
+  char     name[TSDB_TABLE_FNAME_LEN];
+  int8_t   ignoreNotExists;
+} SVAlterTbReq;
+
+typedef struct {
+  SMsgHead head;
+} SVAlterTbRsp;
+
+typedef struct {
+  SMsgHead head;
+  char     name[TSDB_TABLE_FNAME_LEN];
+  int8_t   ignoreNotExists;
+} SVDropTbReq;
+
+typedef struct {
+  SMsgHead head;
+} SVDropTbRsp;
+
+typedef struct {
+  SMsgHead head;
+  int64_t  uid;
+  int32_t  tid;
+  int16_t  tversion;
+  int16_t  colId;
+  int8_t   type;
+  int16_t  bytes;
+  int32_t  tagValLen;
+  int16_t  numOfTags;
+  int32_t  schemaLen;
+  char     data[];
+} SUpdateTagValReq;
+
+typedef struct {
+  SMsgHead head;
+} SUpdateTagValRsp;
+
+typedef struct {
   SMsgHead head;
 } SVShowTablesReq;
 
-typedef struct SVShowTablesRsp {
+typedef struct {
   int64_t       id;
-  STableMetaMsg metaInfo;
+  STableMetaRsp metaInfo;
 } SVShowTablesRsp;
 
-typedef struct SVShowTablesFetchReq {
+typedef struct {
   SMsgHead head;
   int32_t  id;
 } SVShowTablesFetchReq;
 
-typedef struct SVShowTablesFetchRsp {
+typedef struct {
   int64_t useconds;
   int8_t  completed;  // all results are returned to client
   int8_t  precision;

include/dnode/vnode/tsdb/tsdb.h

@@ -18,6 +18,7 @@
 
 #include "mallocator.h"
 #include "meta.h"
+#include "common.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -39,6 +40,10 @@ typedef struct STable {
   STSchema *pSchema;
 } STable;
 
+#define BLOCK_LOAD_OFFSET_SEQ_ORDER   1
+#define BLOCK_LOAD_TABLE_SEQ_ORDER    2
+#define BLOCK_LOAD_TABLE_RR_ORDER     3
+
 #define TABLE_TID(t) (t)->tid
 #define TABLE_UID(t) (t)->uid
 
@@ -58,6 +63,22 @@ typedef struct STsdbCfg {
   int8_t   compression;
 } STsdbCfg;
 
+// query condition to build multi-table data block iterator
+typedef struct STsdbQueryCond {
+  STimeWindow  twindow;
+  int32_t      order;             // desc|asc order to iterate the data block
+  int32_t      numOfCols;
+  SColumnInfo *colList;
+  bool         loadExternalRows;  // load external rows or not
+  int32_t      type;              // data block load type:
+} STsdbQueryCond;
+
+typedef struct {
+  void    *pTable;
+  TSKEY    lastKey;
+  uint64_t uid;
+} STableKeyInfo;
+
 // STsdb
 STsdb *tsdbOpen(const char *path, int32_t vgId, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF, SMeta *pMeta);
 void   tsdbClose(STsdb *);
@@ -70,6 +91,119 @@ int    tsdbCommit(STsdb *pTsdb);
 int  tsdbOptionsInit(STsdbCfg *);
 void tsdbOptionsClear(STsdbCfg *);
 
+typedef void* tsdbReadHandleT;
+/**
+ * Get the data block iterator, starting from position according to the query condition
+ *
+ * @param tsdb       tsdb handle
+ * @param pCond      query condition, including time window, result set order, and basic required columns for each block
+ * @param tableInfoGroup  table object list in the form of set, grouped into different sets according to the
+ *                        group by condition
+ * @param qinfo      query info handle from query processor
+ * @return
+ */
+tsdbReadHandleT *tsdbQueryTables(STsdb *tsdb, STsdbQueryCond *pCond, STableGroupInfo *tableInfoGroup, uint64_t qId,
+                                  void *pRef);
+
+/**
+ * Get the last row of the given query time window for all the tables in STableGroupInfo object.
+ * Note that only one data block with only row will be returned while invoking retrieve data block function for
+ * all tables in this group.
+ *
+ * @param tsdb   tsdb handle
+ * @param pCond  query condition, including time window, result set order, and basic required columns for each block
+ * @param tableInfo  table list.
+ * @return
+ */
+//tsdbReadHandleT tsdbQueryLastRow(STsdbRepo *tsdb, STsdbQueryCond *pCond, STableGroupInfo *tableInfo, uint64_t qId,
+//                                  SMemRef *pRef);
+
+
+tsdbReadHandleT tsdbQueryCacheLast(STsdb *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList, uint64_t qId, void* pMemRef);
+
+bool isTsdbCacheLastRow(tsdbReadHandleT* pTsdbReadHandle);
+
+/**
+ * get num of rows in mem table
+ *
+ * @param pHandle
+ * @return row size
+ */
+
+int64_t tsdbGetNumOfRowsInMemTable(tsdbReadHandleT* pHandle);
+
+/**
+ * move to next block if exists
+ *
+ * @param pTsdbReadHandle
+ * @return
+ */
+bool tsdbNextDataBlock(tsdbReadHandleT pTsdbReadHandle);
+
+/**
+ * Get current data block information
+ *
+ * @param pTsdbReadHandle
+ * @param pBlockInfo
+ * @return
+ */
+void tsdbRetrieveDataBlockInfo(tsdbReadHandleT *pTsdbReadHandle, SDataBlockInfo *pBlockInfo);
+
+/**
+ *
+ * Get the pre-calculated information w.r.t. current data block.
+ *
+ * In case of data block in cache, the pBlockStatis will always be NULL.
+ * If a block is not completed loaded from disk, the pBlockStatis will be NULL.
+
+ * @pBlockStatis the pre-calculated value for current data blocks. if the block is a cache block, always return 0
+ * @return
+ */
+int32_t tsdbRetrieveDataBlockStatisInfo(tsdbReadHandleT *pTsdbReadHandle, SDataStatis **pBlockStatis);
+
+/**
+ *
+ * The query condition with primary timestamp is passed to iterator during its constructor function,
+ * the returned data block must be satisfied with the time window condition in any cases,
+ * which means the SData data block is not actually the completed disk data blocks.
+ *
+ * @param pTsdbReadHandle      query handle
+ * @param pColumnIdList     required data columns id list
+ * @return
+ */
+SArray *tsdbRetrieveDataBlock(tsdbReadHandleT *pTsdbReadHandle, SArray *pColumnIdList);
+
+/**
+ * destroy the created table group list, which is generated by tag query
+ * @param pGroupList
+ */
+void tsdbDestroyTableGroup(STableGroupInfo *pGroupList);
+
+/**
+ * create the table group result including only one table, used to handle the normal table query
+ *
+ * @param tsdb        tsdbHandle
+ * @param uid         table uid
+ * @param pGroupInfo  the generated result
+ * @return
+ */
+int32_t tsdbGetOneTableGroup(STsdb *tsdb, uint64_t uid, TSKEY startKey, STableGroupInfo *pGroupInfo);
+
+/**
+ *
+ * @param tsdb
+ * @param pTableIdList
+ * @param pGroupInfo
+ * @return
+ */
+int32_t tsdbGetTableGroupFromIdList(STsdb *tsdb, SArray *pTableIdList, STableGroupInfo *pGroupInfo);
+
+/**
+ * clean up the query handle
+ * @param queryHandle
+ */
+void tsdbCleanupQueryHandle(tsdbReadHandleT queryHandle);
+
 #ifdef __cplusplus
 }
 #endif

include/dnode/vnode/vnode.h

@@ -31,8 +31,12 @@ extern "C" {
 
 /* ------------------------ TYPES EXPOSED ------------------------ */
 typedef struct SVnode SVnode;
+typedef struct SDnode SDnode;
+typedef int32_t (*PutReqToVQueryQFp)(SDnode *pDnode, struct SRpcMsg *pReq);
+
 typedef struct SVnodeCfg {
   int32_t vgId;
+  SDnode *pDnode;
 
   /** vnode buffer pool options */
   struct {
@@ -66,15 +70,23 @@ typedef struct SVnodeCfg {
   SWalCfg walCfg;
 } SVnodeCfg;
 
+typedef struct {
+  int32_t           sver;
+  char             *timezone;
+  char             *locale;
+  char             *charset;
+  uint16_t          nthreads;  // number of commit threads. 0 for no threads and a schedule queue should be given (TODO)
+  PutReqToVQueryQFp putReqToVQueryQFp;
+} SVnodeOpt;
+
 /* ------------------------ SVnode ------------------------ */
 /**
  * @brief Initialize the vnode module
  *
- * @param nthreads number of commit threads. 0 for no threads and
- *        a schedule queue should be given (TODO)
+ * @param pOption Option of the vnode mnodule
  * @return int 0 for success and -1 for failure
  */
-int vnodeInit(uint16_t nthreads);
+int vnodeInit(const SVnodeOpt *pOption);
 
 /**
  * @brief clear a vnode
@@ -89,7 +101,7 @@ void vnodeClear();
  * @param pVnodeCfg options of the vnode
  * @return SVnode* The vnode object
  */
-SVnode *vnodeOpen(const char *path, const SVnodeCfg *pVnodeCfg, int32_t vid);
+SVnode *vnodeOpen(const char *path, const SVnodeCfg *pVnodeCfg);
 
 /**
  * @brief Close a VNODE

source/libs/executor/inc/dataSinkMgt.h → include/libs/executor/dataSinkMgt.h

@@ -21,36 +21,38 @@ extern "C" {
 #endif
 
 #include "os.h"
-#include "executorimpl.h"
+#include "thash.h"
+#include "executor.h"
 
-#define DS_CAPACITY_ENOUGH 1
-#define DS_CAPACITY_FULL   2
-#define DS_NEED_SCHEDULE   3
-#define DS_END             4
-#define DS_IN_PROCESS      5
+#define DS_BUF_LOW   1
+#define DS_BUF_FULL  2
+#define DS_BUF_EMPTY 3
 
 struct SDataSink;
 struct SSDataBlock;
 
 typedef struct SDataSinkMgtCfg {
-  uint32_t maxDataBlockNum;
+  uint32_t maxDataBlockNum;           // todo: this should be numOfRows?
   uint32_t maxDataBlockNumPerQuery;
 } SDataSinkMgtCfg;
 
 int32_t dsDataSinkMgtInit(SDataSinkMgtCfg *cfg);
 
-typedef void* DataSinkHandle;
-
 typedef struct SInputData {
-  const SSDataBlock* pData;
+  const struct SSDataBlock* pData;
   SHashObj* pTableRetrieveTsMap;
 } SInputData;
 
-typedef struct SOutPutData {
+typedef struct SOutputData {
   int32_t numOfRows;
   int8_t  compressed;
   char*   pData;
-} SOutPutData;
+  bool    queryEnd;
+  bool    needSchedule;
+  int32_t bufStatus;
+  int64_t useconds;
+  int8_t  precision;
+} SOutputData;
 
 /**
  * Create a subplan's datasinker handle for all later operations. 
@@ -66,16 +68,16 @@ int32_t dsCreateDataSinker(const struct SDataSink *pDataSink, DataSinkHandle* pH
  * @param pRes
  * @return error code
  */
-int32_t dsPutDataBlock(DataSinkHandle handle, const SInputData* pInput, int32_t* pStatus);
+int32_t dsPutDataBlock(DataSinkHandle handle, const SInputData* pInput, bool* pContinue);
 
-void dsEndPut(DataSinkHandle handle);
+void dsEndPut(DataSinkHandle handle, int64_t useconds);
 
 /**
  * Get the length of the data returned by the next call to dsGetDataBlock.
  * @param handle
- * @return data length
+ * @param pLen data length
  */
-int32_t dsGetDataLength(DataSinkHandle handle, int32_t* pStatus);
+void dsGetDataLength(DataSinkHandle handle, int32_t* pLen, bool* pQueryEnd);
 
 /**
  * Get data, the caller needs to allocate data memory.
@@ -84,7 +86,7 @@ int32_t dsGetDataLength(DataSinkHandle handle, int32_t* pStatus);
  * @param pStatus output
  * @return error code
  */
-int32_t dsGetDataBlock(DataSinkHandle handle, SOutPutData* pOutput, int32_t* pStatus);
+int32_t dsGetDataBlock(DataSinkHandle handle, SOutputData* pOutput);
 
 /**
  * After dsGetStatus returns DS_NEED_SCHEDULE, the caller need to put this into the work queue.

include/libs/executor/executor.h

@@ -21,24 +21,30 @@ extern "C" {
 #endif
 
 typedef void* qTaskInfo_t;
+typedef void* DataSinkHandle;
+struct SSubplan;
 
-/**
- * create the qinfo object according to QueryTableMsg
- * @param tsdb
- * @param pQueryTableMsg
- * @param pTaskInfo
- * @return
- */
-int32_t qCreateTask(void* tsdb, int32_t vgId, void* pQueryTableMsg, qTaskInfo_t* pTaskInfo, uint64_t qId);
+
+ /**
+  * Create the exec task object according to task json
+  * @param tsdb
+  * @param vgId
+  * @param pTaskInfoMsg
+  * @param pTaskInfo
+  * @param qId
+  * @return
+  */
+int32_t qCreateExecTask(void* tsdb, int32_t vgId, struct SSubplan* pPlan, qTaskInfo_t* pTaskInfo);
 
 /**
- * the main query execution function, including query on both table and multiple tables,
+ * The main task execution function, including query on both table and multiple tables,
  * which are decided according to the tag or table name query conditions
  *
- * @param qinfo
+ * @param tinfo
+ * @param handle
  * @return
  */
-bool qExecTask(qTaskInfo_t qinfo, uint64_t *qId);
+int32_t qExecTask(qTaskInfo_t tinfo, DataSinkHandle* handle);
 
 /**
  * Retrieve the produced results information, if current query is not paused or completed,
@@ -60,7 +66,7 @@ int32_t qRetrieveQueryResultInfo(qTaskInfo_t qinfo, bool* buildRes, void* pRspCo
  * @param contLen payload length
  * @return
  */
-int32_t qDumpRetrieveResult(qTaskInfo_t qinfo, SRetrieveTableRsp** pRsp, int32_t* contLen, bool* continueExec);
+//int32_t qDumpRetrieveResult(qTaskInfo_t qinfo, SRetrieveTableRsp** pRsp, int32_t* contLen, bool* continueExec);
 
 /**
  * return the transporter context (RPC)
@@ -81,7 +87,7 @@ int32_t qKillTask(qTaskInfo_t qinfo);
  * @param qinfo
  * @return
  */
-int32_t qIsQueryCompleted(qTaskInfo_t qinfo);
+int32_t qIsTaskCompleted(qTaskInfo_t qinfo);
 
 /**
  * destroy query info structure
@@ -113,7 +119,7 @@ int32_t qGetQualifiedTableIdList(void* pTableList, const char* tagCond, int32_t
  * @param numOfIndex
  * @return
  */
-int32_t qCreateTableGroupByGroupExpr(SArray* pTableIdList, TSKEY skey, STableGroupInfo groupInfo, SColIndex* groupByIndex, int32_t numOfIndex);
+//int32_t qCreateTableGroupByGroupExpr(SArray* pTableIdList, TSKEY skey, STableGroupInfo groupInfo, SColIndex* groupByIndex, int32_t numOfIndex);
 
 /**
  * Update the table id list of a given query.

include/libs/planner/planner.h

@@ -114,7 +114,7 @@ typedef struct SProjectPhyNode {
 typedef struct SExchangePhyNode {
   SPhyNode    node;
   uint64_t    srcTemplateId; // template id of datasource suplans
-  SArray     *pSrcEndPoints;  // SEpAddrMsg, scheduler fill by calling qSetSuplanExecutionNode
+  SArray     *pSrcEndPoints;  // SEpAddr, scheduler fill by calling qSetSuplanExecutionNode
 } SExchangePhyNode;
 
 typedef struct SSubplanId {

include/libs/qcom/query.h

@@ -35,6 +35,7 @@ enum {
   JOB_TASK_STATUS_CANCELLING,
   JOB_TASK_STATUS_CANCELLED,
   JOB_TASK_STATUS_DROPPING,
+  JOB_TASK_STATUS_FREEING,
 };
 
 typedef struct STableComInfo {

include/libs/scheduler/scheduler.h

@@ -20,8 +20,10 @@
 extern "C" {
 #endif
 
-#include "planner.h"
 #include "catalog.h"
+#include "planner.h"
+
+struct SSchJob;
 
 typedef struct SSchedulerCfg {
   uint32_t maxJobNum;
@@ -65,7 +67,7 @@ int32_t schedulerInit(SSchedulerCfg *cfg);
  * @param nodeList  Qnode/Vnode address list, element is SQueryNodeAddr
  * @return
  */
-int32_t scheduleExecJob(void *transport, SArray *nodeList, SQueryDag* pDag, void** pJob, SQueryResult *pRes);
+int32_t scheduleExecJob(void *transport, SArray *nodeList, SQueryDag* pDag, struct SSchJob** pJob, SQueryResult *pRes);
 
 /**
  * Process the query job, generated according to the query physical plan.
@@ -73,7 +75,7 @@ int32_t scheduleExecJob(void *transport, SArray *nodeList, SQueryDag* pDag, void
  * @param nodeList  Qnode/Vnode address list, element is SQueryNodeAddr
  * @return
  */
-int32_t scheduleAsyncExecJob(void *transport, SArray *nodeList, SQueryDag* pDag, void** pJob);
+int32_t scheduleAsyncExecJob(void *transport, SArray *nodeList, SQueryDag* pDag, struct SSchJob** pJob);
 
 /**
  * Fetch query result from the remote query executor
@@ -81,7 +83,7 @@ int32_t scheduleAsyncExecJob(void *transport, SArray *nodeList, SQueryDag* pDag,
  * @param data
  * @return
  */
-int32_t scheduleFetchRows(void *pJob, void **data);
+int32_t scheduleFetchRows(struct SSchJob *pJob, void **data);
 
 
 /**
@@ -89,7 +91,7 @@ int32_t scheduleFetchRows(void *pJob, void **data);
  * @param pJob
  * @return
  */
-int32_t scheduleCancelJob(void *pJob);
+//int32_t scheduleCancelJob(void *pJob);
 
 /**
  * Free the query job

include/libs/transport/trpc.h

@@ -101,11 +101,11 @@ typedef struct SMsgSendInfo {
   SDataBuf  msgInfo;
 } SMsgSendInfo;
 
-typedef struct SQueryNodeAddr{
-  int32_t    nodeId; //vgId or qnodeId
-  int8_t     inUse;
-  int8_t     numOfEps;
-  SEpAddrMsg epAddr[TSDB_MAX_REPLICA];
+typedef struct SQueryNodeAddr {
+  int32_t nodeId;  // vgId or qnodeId
+  int8_t  inUse;
+  int8_t  numOfEps;
+  SEpAddr epAddr[TSDB_MAX_REPLICA];
 } SQueryNodeAddr;
 
 bool tIsValidSchema(struct SSchema* pSchema, int32_t numOfCols, int32_t numOfTags);

include/libs/wal/wal.h

@@ -71,6 +71,7 @@ extern int32_t wDebugFlag;
 #define WAL_MAX_SIZE (TSDB_MAX_WAL_SIZE + sizeof(SWalHead))
 #define WAL_PATH_LEN (TSDB_FILENAME_LEN + 12)
 #define WAL_FILE_LEN (WAL_PATH_LEN + 32)
+#define WAL_MAGIC 0xFAFBFCFDULL
 
 #define WAL_CUR_FAILED 1
 
@@ -98,6 +99,7 @@ typedef struct {
 } SWalCfg;
 
 typedef struct {
+  uint64_t     magic;
   uint32_t     cksumHead;
   uint32_t     cksumBody;
   SWalReadHead head;

source/client/inc/clientInt.h

@@ -113,6 +113,7 @@ typedef struct SRequestSendRecvBody {
   tsem_t          rspSem;        // not used now
   void*           fp;
   SShowReqInfo    showInfo;      // todo this attribute will be removed after the query framework being completed.
+  struct SSchJob *pQueryJob;     // query job, created according to sql query DAG.
   SDataBuf        requestMsg;
   SReqResultInfo  resInfo;
 } SRequestSendRecvBody;
@@ -129,7 +130,7 @@ typedef struct SRequestObj {
   char            *msgBuf;
   void            *pInfo;   // sql parse info, generated by parser module
   int32_t          code;
-  uint64_t         affectedRows;
+  uint64_t         affectedRows;  // todo remove it
   SQueryExecMetric metric;
   SRequestSendRecvBody body;
 } SRequestObj;
@@ -161,12 +162,13 @@ int  taos_options_imp(TSDB_OPTION option, const char *str);
 void* openTransporter(const char *user, const char *auth, int32_t numOfThreads);
 
 void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet);
+
 void initMsgHandleFp();
 
 TAOS *taos_connect_internal(const char *ip, const char *user, const char *pass, const char *auth, const char *db, uint16_t port);
-TAOS_RES *taos_query_l(TAOS *taos, const char *sql, int sqlLen);
 
 void *doFetchRow(SRequestObj* pRequest);
+
 void  setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32_t numOfCols, int32_t numOfRows);
 
 #ifdef __cplusplus

source/client/src/clientImpl.c

 
+#include "../../libs/scheduler/inc/schedulerInt.h"
 #include "clientInt.h"
 #include "clientLog.h"
+#include "parser.h"
+#include "planner.h"
+#include "scheduler.h"
 #include "tdef.h"
 #include "tep.h"
 #include "tglobal.h"
@@ -8,9 +12,6 @@
 #include "tnote.h"
 #include "tpagedfile.h"
 #include "tref.h"
-#include "parser.h"
-#include "planner.h"
-#include "scheduler.h"
 
 #define CHECK_CODE_GOTO(expr, lable) \
   do {                               \
@@ -57,6 +58,7 @@ static char* getClusterKey(const char* user, const char* auth, const char* ip, i
 }
 
 static STscObj* taosConnectImpl(const char *ip, const char *user, const char *auth, const char *db, uint16_t port, __taos_async_fn_t fp, void *param, SAppInstInfo* pAppInfo);
+static void  setResSchemaInfo(SReqResultInfo* pResInfo, const SDataBlockSchema* pDataBlockSchema);
 
 TAOS *taos_connect_internal(const char *ip, const char *user, const char *pass, const char *auth, const char *db, uint16_t port) {
   if (taos_init() != TSDB_CODE_SUCCESS) {
@@ -197,19 +199,49 @@ int32_t execDdlQuery(SRequestObj* pRequest, SQueryNode* pQuery) {
 
 int32_t getPlan(SRequestObj* pRequest, SQueryNode* pQueryNode, SQueryDag** pDag) {
   pRequest->type = pQueryNode->type;
-  return qCreateQueryDag(pQueryNode, pDag, pRequest->requestId);
+
+  SReqResultInfo* pResInfo = &pRequest->body.resInfo;
+  int32_t code = qCreateQueryDag(pQueryNode, pDag, pRequest->requestId);
+  if (code != 0) {
+    return code;
+  }
+
+  if (pQueryNode->type == TSDB_SQL_SELECT) {
+    SArray* pa = taosArrayGetP((*pDag)->pSubplans, 0);
+
+    SSubplan* pPlan = taosArrayGetP(pa, 0);
+    SDataBlockSchema* pDataBlockSchema = &(pPlan->pDataSink->schema);
+    setResSchemaInfo(pResInfo, pDataBlockSchema);
+    pRequest->type = TDMT_VND_QUERY;
+  }
+
+  return code;
+}
+
+void setResSchemaInfo(SReqResultInfo* pResInfo, const SDataBlockSchema* pDataBlockSchema) {
+  assert(pDataBlockSchema != NULL && pDataBlockSchema->numOfCols > 0);
+
+  pResInfo->numOfCols = pDataBlockSchema->numOfCols;
+  pResInfo->fields = calloc(pDataBlockSchema->numOfCols, sizeof(pDataBlockSchema->pSchema[0]));
+
+  for (int32_t i = 0; i < pResInfo->numOfCols; ++i) {
+    SSchema* pSchema = &pDataBlockSchema->pSchema[i];
+    pResInfo->fields[i].bytes = pSchema->bytes;
+    pResInfo->fields[i].type  = pSchema->type;
+    tstrncpy(pResInfo->fields[i].name, pSchema[i].name, tListLen(pResInfo->fields[i].name));
+  }
 }
 
-int32_t scheduleQuery(SRequestObj* pRequest, SQueryDag* pDag, void** pJob) {
+int32_t scheduleQuery(SRequestObj* pRequest, SQueryDag* pDag) {
   if (TSDB_SQL_INSERT == pRequest->type || TSDB_SQL_CREATE_TABLE == pRequest->type) {
     SQueryResult res = {.code = 0, .numOfRows = 0, .msgSize = ERROR_MSG_BUF_DEFAULT_SIZE, .msg = pRequest->msgBuf};
 
-    int32_t code = scheduleExecJob(pRequest->pTscObj->pTransporter, NULL, pDag, pJob, &res);
+    int32_t code = scheduleExecJob(pRequest->pTscObj->pTransporter, NULL, pDag, &pRequest->body.pQueryJob, &res);
     if (code != TSDB_CODE_SUCCESS) {
       // handle error and retry
     } else {
-      if (*pJob != NULL) {
-        scheduleFreeJob(*pJob);
+      if (pRequest->body.pQueryJob != NULL) {
+        scheduleFreeJob(pRequest->body.pQueryJob);
       }
     }
 
@@ -217,7 +249,7 @@ int32_t scheduleQuery(SRequestObj* pRequest, SQueryDag* pDag, void** pJob) {
     return res.code;
   }
 
-  return scheduleAsyncExecJob(pRequest->pTscObj->pTransporter, NULL /*todo appInfo.xxx*/, pDag, pJob);
+  return scheduleAsyncExecJob(pRequest->pTscObj->pTransporter, NULL, pDag, &pRequest->body.pQueryJob);
 }
 
 TAOS_RES *tmq_create_topic(TAOS* taos, const char* name, const char* sql, int sqlLen) {
@@ -294,7 +326,6 @@ TAOS_RES *taos_query_l(TAOS *taos, const char *sql, int sqlLen) {
   SRequestObj *pRequest = NULL;
   SQueryNode  *pQuery   = NULL;
   SQueryDag   *pDag     = NULL;
-  void        *pJob     = NULL;
 
   terrno = TSDB_CODE_SUCCESS;
   CHECK_CODE_GOTO(buildRequest(pTscObj, sql, sqlLen, &pRequest), _return);
@@ -304,9 +335,8 @@ TAOS_RES *taos_query_l(TAOS *taos, const char *sql, int sqlLen) {
     CHECK_CODE_GOTO(execDdlQuery(pRequest, pQuery), _return);
   } else {
     CHECK_CODE_GOTO(getPlan(pRequest, pQuery, &pDag), _return);
-    CHECK_CODE_GOTO(scheduleQuery(pRequest, pDag, &pJob), _return);
+    CHECK_CODE_GOTO(scheduleQuery(pRequest, pDag), _return);
     pRequest->code = terrno;
-    return pRequest;
   }
 
 _return:
@@ -315,6 +345,7 @@ _return:
   if (NULL != pRequest && TSDB_CODE_SUCCESS != terrno) {
     pRequest->code = terrno;
   }
+
   return pRequest;
 }
 
@@ -513,7 +544,17 @@ void* doFetchRow(SRequestObj* pRequest) {
   SReqResultInfo* pResultInfo = &pRequest->body.resInfo;
 
   if (pResultInfo->pData == NULL || pResultInfo->current >= pResultInfo->numOfRows) {
-    if (pRequest->type == TDMT_MND_SHOW) {
+    if (pRequest->type == TDMT_VND_QUERY) {
+      pRequest->type = TDMT_VND_FETCH;
+      scheduleFetchRows(pRequest->body.pQueryJob, (void **)&pRequest->body.resInfo.pData);
+      
+      pResultInfo->current = 0;
+      if (pResultInfo->numOfRows <= pResultInfo->current) {
+        return NULL;
+      }
+
+      goto _return;
+    } else if (pRequest->type == TDMT_MND_SHOW) {
       pRequest->type = TDMT_MND_SHOW_RETRIEVE;
     } else if (pRequest->type == TDMT_VND_SHOW_TABLES) {
       pRequest->type = TDMT_VND_SHOW_TABLES_FETCH;
@@ -556,6 +597,8 @@ void* doFetchRow(SRequestObj* pRequest) {
     }
   }
 
+_return:
+
   for(int32_t i = 0; i < pResultInfo->numOfCols; ++i) {
     pResultInfo->row[i] = pResultInfo->pCol[i] + pResultInfo->fields[i].bytes * pResultInfo->current;
     if (IS_VAR_DATA_TYPE(pResultInfo->fields[i].type)) {

source/client/src/clientMsgHandler.c

@@ -130,7 +130,7 @@ int32_t processShowRsp(void* param, const SDataBuf* pMsg, int32_t code) {
   SShowRsp* pShow = (SShowRsp *)pMsg->pData;
   pShow->showId   = htobe64(pShow->showId);
 
-  STableMetaMsg *pMetaMsg = &(pShow->tableMeta);
+  STableMetaRsp *pMetaMsg = &(pShow->tableMeta);
   pMetaMsg->numOfColumns = htonl(pMetaMsg->numOfColumns);
 
   SSchema* pSchema = pMetaMsg->pSchema;

source/common/src/tglobal.c

@@ -37,7 +37,7 @@ uint16_t tsServerPort = 6030;
 int32_t  tsStatusInterval = 1;  // second
 int8_t   tsEnableTelemetryReporting = 0;
 char     tsEmail[TSDB_FQDN_LEN] = {0};
-int32_t  tsNumOfSupportVnodes = 16;
+int32_t  tsNumOfSupportVnodes = 128;
 
 // common
 int32_t tsRpcTimer = 300;

source/dnode/mgmt/impl/inc/dndInt.h

@@ -94,6 +94,7 @@ typedef struct {
   pthread_t   *threadId;
   SRWLatch     latch;
   SDnodeWorker mgmtWorker;
+  SDnodeWorker statusWorker;
 } SDnodeMgmt;
 
 typedef struct {
@@ -167,7 +168,7 @@ typedef struct SDnode {
   SBnodeMgmt  bmgmt;
   SVnodesMgmt vmgmt;
   STransMgmt  tmgmt;
-  SStartupMsg startup;
+  SStartupReq startup;
 } SDnode;
 
 EStat dndGetStat(SDnode *pDnode);
@@ -175,7 +176,7 @@ void  dndSetStat(SDnode *pDnode, EStat stat);
 char *dndStatStr(EStat stat);
 
 void dndReportStartup(SDnode *pDnode, char *pName, char *pDesc);
-void dndGetStartup(SDnode *pDnode, SStartupMsg *pStartup);
+void dndGetStartup(SDnode *pDnode, SStartupReq *pStartup);
 
 #ifdef __cplusplus
 }

source/dnode/mgmt/impl/inc/dndVnodes.h

@@ -36,6 +36,8 @@ int32_t dndProcessAuthVnodeReq(SDnode *pDnode, SRpcMsg *pReq);
 int32_t dndProcessSyncVnodeReq(SDnode *pDnode, SRpcMsg *pReq);
 int32_t dndProcessCompactVnodeReq(SDnode *pDnode, SRpcMsg *pReq);
 
+int32_t dndPutReqToVQueryQ(SDnode *pDnode, SRpcMsg *pReq);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -473,12 +473,12 @@ static int32_t dndProcessConfigDnodeReq(SDnode *pDnode, SRpcMsg *pReq) {
 void dndProcessStartupReq(SDnode *pDnode, SRpcMsg *pReq) {
   dDebug("startup req is received");
 
-  SStartupMsg *pStartup = rpcMallocCont(sizeof(SStartupMsg));
+  SStartupReq *pStartup = rpcMallocCont(sizeof(SStartupReq));
   dndGetStartup(pDnode, pStartup);
 
   dDebug("startup req is sent, step:%s desc:%s finished:%d", pStartup->name, pStartup->desc, pStartup->finished);
 
-  SRpcMsg rpcRsp = {.handle = pReq->handle, .pCont = pStartup, .contLen = sizeof(SStartupMsg)};
+  SRpcMsg rpcRsp = {.handle = pReq->handle, .pCont = pStartup, .contLen = sizeof(SStartupReq)};
   rpcSendResponse(&rpcRsp);
 }
 
@@ -536,6 +536,11 @@ int32_t dndInitMgmt(SDnode *pDnode) {
     return -1;
   }
 
+  if (dndInitWorker(pDnode, &pMgmt->statusWorker, DND_WORKER_SINGLE, "dnode-status", 1, 1, dndProcessMgmtQueue) != 0) {
+    dError("failed to start dnode mgmt worker since %s", terrstr());
+    return -1;
+  }
+
   pMgmt->threadId = taosCreateThread(dnodeThreadRoutine, pDnode);
   if (pMgmt->threadId == NULL) {
     dError("failed to init dnode thread");
@@ -550,6 +555,7 @@ int32_t dndInitMgmt(SDnode *pDnode) {
 void dndStopMgmt(SDnode *pDnode) {
   SDnodeMgmt *pMgmt = &pDnode->dmgmt;
   dndCleanupWorker(&pMgmt->mgmtWorker);
+  dndCleanupWorker(&pMgmt->statusWorker);
 
   if (pMgmt->threadId != NULL) {
     taosDestoryThread(pMgmt->threadId);
@@ -587,7 +593,12 @@ void dndProcessMgmtMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
     dndUpdateMnodeEpSet(pDnode, pEpSet);
   }
 
-  if (dndWriteMsgToWorker(&pMgmt->mgmtWorker, pMsg, sizeof(SRpcMsg)) != 0) {
+  SDnodeWorker *pWorker = &pMgmt->mgmtWorker;
+  if (pMsg->msgType == TDMT_MND_STATUS_RSP) {
+    pWorker = &pMgmt->statusWorker;
+  }
+
+  if (dndWriteMsgToWorker(pWorker, pMsg, sizeof(SRpcMsg)) != 0) {
     if (pMsg->msgType & 1u) {
       SRpcMsg rsp = {.handle = pMsg->handle, .code = TSDB_CODE_OUT_OF_MEMORY};
       rpcSendResponse(&rsp);

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

@@ -381,7 +381,8 @@ static void *dnodeOpenVnodeFunc(void *param) {
              pMgmt->openVnodes, pMgmt->totalVnodes);
     dndReportStartup(pDnode, "open-vnodes", stepDesc);
 
-    SVnode *pImpl = vnodeOpen(pCfg->path, NULL, pCfg->vgId);
+    SVnodeCfg cfg = {.pDnode = pDnode, .vgId = pCfg->vgId};
+    SVnode   *pImpl = vnodeOpen(pCfg->path, &cfg);
     if (pImpl == NULL) {
       dError("vgId:%d, failed to open vnode by thread:%d", pCfg->vgId, pThread->threadIndex);
       pThread->failed++;
@@ -581,7 +582,8 @@ int32_t dndProcessCreateVnodeReq(SDnode *pDnode, SRpcMsg *pReq) {
     return -1;
   }
 
-  SVnode *pImpl = vnodeOpen(wrapperCfg.path, NULL /*pCfg*/, pCreate->vgId);
+  vnodeCfg.pDnode = pDnode;
+  SVnode *pImpl = vnodeOpen(wrapperCfg.path, &vnodeCfg);
   if (pImpl == NULL) {
     dError("vgId:%d, failed to create vnode since %s", pCreate->vgId, terrstr());
     return -1;
@@ -800,7 +802,7 @@ static void dndProcessVnodeSyncQueue(SVnodeObj *pVnode, STaosQall *qall, int32_t
   }
 }
 
-static int32_t dndWriteRpcMsgToVnodeQueue(STaosQueue *pQueue, SRpcMsg *pRpcMsg) {
+static int32_t dndWriteRpcMsgToVnodeQueue(STaosQueue *pQueue, SRpcMsg *pRpcMsg, bool sendRsp) {
   int32_t code = 0;
 
   if (pQueue == NULL) {
@@ -817,13 +819,15 @@ static int32_t dndWriteRpcMsgToVnodeQueue(STaosQueue *pQueue, SRpcMsg *pRpcMsg)
     }
   }
 
-  if (code != TSDB_CODE_SUCCESS) {
+  if (code != TSDB_CODE_SUCCESS && sendRsp) {
     if (pRpcMsg->msgType & 1u) {
       SRpcMsg rsp = {.handle = pRpcMsg->handle, .code = code};
       rpcSendResponse(&rsp);
     }
     rpcFreeCont(pRpcMsg->pCont);
   }
+
+  return code;
 }
 
 static SVnodeObj *dndAcquireVnodeFromMsg(SDnode *pDnode, SRpcMsg *pMsg) {
@@ -846,7 +850,7 @@ static SVnodeObj *dndAcquireVnodeFromMsg(SDnode *pDnode, SRpcMsg *pMsg) {
 void dndProcessVnodeWriteMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
   SVnodeObj *pVnode = dndAcquireVnodeFromMsg(pDnode, pMsg);
   if (pVnode != NULL) {
-    dndWriteRpcMsgToVnodeQueue(pVnode->pWriteQ, pMsg);
+    (void)dndWriteRpcMsgToVnodeQueue(pVnode->pWriteQ, pMsg, true);
     dndReleaseVnode(pDnode, pVnode);
   }
 }
@@ -854,7 +858,7 @@ void dndProcessVnodeWriteMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
 void dndProcessVnodeSyncMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
   SVnodeObj *pVnode = dndAcquireVnodeFromMsg(pDnode, pMsg);
   if (pVnode != NULL) {
-    dndWriteRpcMsgToVnodeQueue(pVnode->pSyncQ, pMsg);
+    (void)dndWriteRpcMsgToVnodeQueue(pVnode->pSyncQ, pMsg, true);
     dndReleaseVnode(pDnode, pVnode);
   }
 }
@@ -862,7 +866,7 @@ void dndProcessVnodeSyncMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
 void dndProcessVnodeQueryMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
   SVnodeObj *pVnode = dndAcquireVnodeFromMsg(pDnode, pMsg);
   if (pVnode != NULL) {
-    dndWriteRpcMsgToVnodeQueue(pVnode->pQueryQ, pMsg);
+    (void)dndWriteRpcMsgToVnodeQueue(pVnode->pQueryQ, pMsg, true);
     dndReleaseVnode(pDnode, pVnode);
   }
 }
@@ -870,11 +874,23 @@ void dndProcessVnodeQueryMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
 void dndProcessVnodeFetchMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
   SVnodeObj *pVnode = dndAcquireVnodeFromMsg(pDnode, pMsg);
   if (pVnode != NULL) {
-    dndWriteRpcMsgToVnodeQueue(pVnode->pFetchQ, pMsg);
+    (void)dndWriteRpcMsgToVnodeQueue(pVnode->pFetchQ, pMsg, true);
     dndReleaseVnode(pDnode, pVnode);
   }
 }
 
+int32_t dndPutReqToVQueryQ(SDnode *pDnode, SRpcMsg *pMsg) {
+  SMsgHead *pHead = pMsg->pCont;
+  // pHead->vgId = htonl(pHead->vgId);
+
+  SVnodeObj *pVnode = dndAcquireVnode(pDnode, pHead->vgId);
+  if (pVnode == NULL) return -1;
+
+  int32_t code = dndWriteRpcMsgToVnodeQueue(pVnode->pFetchQ, pMsg, false);
+  dndReleaseVnode(pDnode, pVnode);
+  return code;
+}
+
 static int32_t dndPutMsgIntoVnodeApplyQueue(SDnode *pDnode, int32_t vgId, SRpcMsg *pMsg) {
   SVnodeObj *pVnode = dndAcquireVnode(pDnode, vgId);
   if (pVnode == NULL) return -1;

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

@@ -22,8 +22,8 @@
 #include "dndTransport.h"
 #include "dndVnodes.h"
 #include "sync.h"
-#include "wal.h"
 #include "tfs.h"
+#include "wal.h"
 
 EStat dndGetStat(SDnode *pDnode) { return pDnode->stat; }
 
@@ -46,14 +46,14 @@ char *dndStatStr(EStat stat) {
 }
 
 void dndReportStartup(SDnode *pDnode, char *pName, char *pDesc) {
-  SStartupMsg *pStartup = &pDnode->startup;
+  SStartupReq *pStartup = &pDnode->startup;
   tstrncpy(pStartup->name, pName, TSDB_STEP_NAME_LEN);
   tstrncpy(pStartup->desc, pDesc, TSDB_STEP_DESC_LEN);
   pStartup->finished = 0;
 }
 
-void dndGetStartup(SDnode *pDnode, SStartupMsg *pStartup) {
-  memcpy(pStartup, &pDnode->startup, sizeof(SStartupMsg));
+void dndGetStartup(SDnode *pDnode, SStartupReq *pStartup) {
+  memcpy(pStartup, &pDnode->startup, sizeof(SStartupReq));
   pStartup->finished = (dndGetStat(pDnode) == DND_STAT_RUNNING);
 }
 
@@ -196,7 +196,15 @@ SDnode *dndInit(SDnodeOpt *pOption) {
     return NULL;
   }
 
-  if (vnodeInit(pDnode->opt.numOfCommitThreads) != 0) {
+  SVnodeOpt vnodeOpt = {
+      .sver = pDnode->opt.sver,
+      .timezone = pDnode->opt.timezone,
+      .locale = pDnode->opt.locale,
+      .charset = pDnode->opt.charset,
+      .nthreads = pDnode->opt.numOfCommitThreads,
+      .putReqToVQueryQFp = dndPutReqToVQueryQ,
+  };
+  if (vnodeInit(&vnodeOpt) != 0) {
     dError("failed to init vnode env");
     dndCleanup(pDnode);
     return NULL;

source/dnode/mgmt/impl/test/sut/inc/sut.h

@@ -53,7 +53,7 @@ class Testbase {
   void SendShowMetaReq(int8_t showType, const char* db);
   void SendShowRetrieveReq();
 
-  STableMetaMsg*     GetShowMeta();
+  STableMetaRsp*     GetShowMeta();
   SRetrieveTableRsp* GetRetrieveRsp();
 
   int32_t     GetMetaNum();
@@ -74,7 +74,7 @@ class Testbase {
 
  private:
   int64_t            showId;
-  STableMetaMsg*     pMeta;
+  STableMetaRsp*     pMeta;
   SRetrieveTableRsp* pRetrieveRsp;
   char*              pData;
   int32_t            pos;

source/dnode/mgmt/impl/test/sut/src/sut.cpp

@@ -179,6 +179,6 @@ const char* Testbase::GetShowBinary(int32_t len) {
 
 int32_t Testbase::GetShowRows() { return pRetrieveRsp->numOfRows; }
 
-STableMetaMsg* Testbase::GetShowMeta() { return pMeta; }
+STableMetaRsp* Testbase::GetShowMeta() { return pMeta; }
 
 SRetrieveTableRsp* Testbase::GetRetrieveRsp() { return pRetrieveRsp; }
\ No newline at end of file

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

@@ -32,7 +32,7 @@ extern "C" {
 typedef int32_t (*MndMsgFp)(SMnodeMsg *pMsg);
 typedef int32_t (*MndInitFp)(SMnode *pMnode);
 typedef void (*MndCleanupFp)(SMnode *pMnode);
-typedef int32_t (*ShowMetaFp)(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta);
+typedef int32_t (*ShowMetaFp)(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaRsp *pMeta);
 typedef int32_t (*ShowRetrieveFp)(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows);
 typedef void (*ShowFreeIterFp)(SMnode *pMnode, void *pIter);
 

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

@@ -31,7 +31,7 @@ static int32_t  mndProcessCreateBnodeReq(SMnodeMsg *pReq);
 static int32_t  mndProcessDropBnodeReq(SMnodeMsg *pReq);
 static int32_t  mndProcessCreateBnodeRsp(SMnodeMsg *pRsp);
 static int32_t  mndProcessDropBnodeRsp(SMnodeMsg *pRsp);
-static int32_t  mndGetBnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaMsg *pMeta);
+static int32_t  mndGetBnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta);
 static int32_t  mndRetrieveBnodes(SMnodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows);
 static void     mndCancelGetNextBnode(SMnode *pMnode, void *pIter);
 
@@ -391,7 +391,7 @@ static int32_t mndProcessDropBnodeRsp(SMnodeMsg *pRsp) {
   return 0;
 }
 
-static int32_t mndGetBnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaMsg *pMeta) {
+static int32_t mndGetBnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta) {
   SMnode *pMnode = pReq->pMnode;
   SSdb   *pSdb = pMnode->pSdb;
 

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

@@ -26,7 +26,7 @@ static int32_t  mndClusterActionInsert(SSdb *pSdb, SClusterObj *pCluster);
 static int32_t  mndClusterActionDelete(SSdb *pSdb, SClusterObj *pCluster);
 static int32_t  mndClusterActionUpdate(SSdb *pSdb, SClusterObj *pOldCluster, SClusterObj *pNewCluster);
 static int32_t  mndCreateDefaultCluster(SMnode *pMnode);
-static int32_t  mndGetClusterMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta);
+static int32_t  mndGetClusterMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaRsp *pMeta);
 static int32_t  mndRetrieveClusters(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows);
 static void     mndCancelGetNextCluster(SMnode *pMnode, void *pIter);
 
@@ -163,7 +163,7 @@ static int32_t mndCreateDefaultCluster(SMnode *pMnode) {
   return sdbWrite(pMnode->pSdb, pRaw);
 }
 
-static int32_t mndGetClusterMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta) {
+static int32_t mndGetClusterMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaRsp *pMeta) {
   int32_t  cols = 0;
   SSchema *pSchema = pMeta->pSchema;
 

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

@@ -39,7 +39,7 @@ static int32_t  mndProcessCreateConsumerMsg(SMnodeMsg *pMsg);
 static int32_t  mndProcessDropConsumerMsg(SMnodeMsg *pMsg);
 static int32_t  mndProcessDropConsumerInRsp(SMnodeMsg *pMsg);
 static int32_t  mndProcessConsumerMetaMsg(SMnodeMsg *pMsg);
-static int32_t  mndGetConsumerMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta);
+static int32_t  mndGetConsumerMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaRsp *pMeta);
 static int32_t  mndRetrieveConsumer(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows);
 static void     mndCancelGetNextConsumer(SMnode *pMnode, void *pIter);
 
@@ -395,7 +395,7 @@ static int32_t mndProcessSubscribeInternalRsp(SMnodeMsg *pMsg) { return 0; }
 
 static int32_t mndProcessConsumerMetaMsg(SMnodeMsg *pMsg) {
   SMnode        *pMnode = pMsg->pMnode;
-  STableInfoMsg *pInfo = pMsg->rpcMsg.pCont;
+  STableInfoReq *pInfo = pMsg->rpcMsg.pCont;
 
   mDebug("consumer:%s, start to retrieve meta", pInfo->tableFname);
 
@@ -417,9 +417,9 @@ static int32_t mndProcessConsumerMetaMsg(SMnodeMsg *pMsg) {
 
   taosRLockLatch(&pConsumer->lock);
   int32_t totalCols = pConsumer->numOfColumns + pConsumer->numOfTags;
-  int32_t contLen = sizeof(STableMetaMsg) + totalCols * sizeof(SSchema);
+  int32_t contLen = sizeof(STableMetaRsp) + totalCols * sizeof(SSchema);
 
-  STableMetaMsg *pMeta = rpcMallocCont(contLen);
+  STableMetaRsp *pMeta = rpcMallocCont(contLen);
   if (pMeta == NULL) {
     taosRUnLockLatch(&pConsumer->lock);
     mndReleaseDb(pMnode, pDb);
@@ -483,7 +483,7 @@ static int32_t mndGetNumOfConsumers(SMnode *pMnode, char *dbName, int32_t *pNumO
   return 0;
 }
 
-static int32_t mndGetConsumerMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta) {
+static int32_t mndGetConsumerMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaRsp *pMeta) {
   SMnode *pMnode = pMsg->pMnode;
   SSdb   *pSdb = pMnode->pSdb;
 

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

@@ -35,7 +35,7 @@ static int32_t  mndProcessDropDbReq(SMnodeMsg *pReq);
 static int32_t  mndProcessUseDbReq(SMnodeMsg *pReq);
 static int32_t  mndProcessSyncDbReq(SMnodeMsg *pReq);
 static int32_t  mndProcessCompactDbReq(SMnodeMsg *pReq);
-static int32_t  mndGetDbMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaMsg *pMeta);
+static int32_t  mndGetDbMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta);
 static int32_t  mndRetrieveDbs(SMnodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows);
 static void     mndCancelGetNextDb(SMnode *pMnode, void *pIter);
 
@@ -194,7 +194,7 @@ static int32_t mndDbActionUpdate(SSdb *pSdb, SDbObj *pOld, SDbObj *pNew) {
 SDbObj *mndAcquireDb(SMnode *pMnode, char *db) {
   SSdb   *pSdb = pMnode->pSdb;
   SDbObj *pDb = sdbAcquire(pSdb, SDB_DB, db);
-  if (pDb == NULL) {
+  if (pDb == NULL && terrno == TSDB_CODE_SDB_OBJ_NOT_THERE) {
     terrno = TSDB_CODE_MND_DB_NOT_EXIST;
   }
   return pDb;
@@ -378,7 +378,7 @@ static int32_t mndSetCreateDbUndoActions(SMnode *pMnode, STrans *pTrans, SDbObj
   return 0;
 }
 
-static int32_t mndCreateDb(SMnode *pMnode, SMnodeMsg *pReq, SCreateDbMsg *pCreate, SUserObj *pUser) {
+static int32_t mndCreateDb(SMnode *pMnode, SMnodeMsg *pReq, SCreateDbReq *pCreate, SUserObj *pUser) {
   SDbObj dbObj = {0};
   memcpy(dbObj.name, pCreate->db, TSDB_DB_FNAME_LEN);
   memcpy(dbObj.acct, pUser->acct, TSDB_USER_LEN);
@@ -449,7 +449,7 @@ CREATE_DB_OVER:
 
 static int32_t mndProcessCreateDbReq(SMnodeMsg *pReq) {
   SMnode       *pMnode = pReq->pMnode;
-  SCreateDbMsg *pCreate = pReq->rpcMsg.pCont;
+  SCreateDbReq *pCreate = pReq->rpcMsg.pCont;
 
   pCreate->numOfVgroups = htonl(pCreate->numOfVgroups);
   pCreate->cacheBlockSize = htonl(pCreate->cacheBlockSize);
@@ -463,7 +463,7 @@ static int32_t mndProcessCreateDbReq(SMnodeMsg *pReq) {
   pCreate->commitTime = htonl(pCreate->commitTime);
   pCreate->fsyncPeriod = htonl(pCreate->fsyncPeriod);
 
-  mDebug("db:%s, start to create", pCreate->db);
+  mDebug("db:%s, start to create, vgroups:%d", pCreate->db, pCreate->numOfVgroups);
 
   SDbObj *pDb = mndAcquireDb(pMnode, pCreate->db);
   if (pDb != NULL) {
@@ -476,6 +476,9 @@ static int32_t mndProcessCreateDbReq(SMnodeMsg *pReq) {
       mError("db:%s, failed to create since %s", pCreate->db, terrstr());
       return -1;
     }
+  } else if (terrno != TSDB_CODE_MND_DB_NOT_EXIST) {
+    mError("db:%s, failed to create since %s", pCreate->db, terrstr());
+    return -1;
   }
 
   SUserObj *pOperUser = mndAcquireUser(pMnode, pReq->user);
@@ -495,7 +498,7 @@ static int32_t mndProcessCreateDbReq(SMnodeMsg *pReq) {
   return TSDB_CODE_MND_ACTION_IN_PROGRESS;
 }
 
-static int32_t mndSetDbCfgFromAlterDbMsg(SDbObj *pDb, SAlterDbMsg *pAlter) {
+static int32_t mndSetDbCfgFromAlterDbMsg(SDbObj *pDb, SAlterDbReq *pAlter) {
   terrno = TSDB_CODE_MND_DB_OPTION_UNCHANGED;
 
   if (pAlter->totalBlocks >= 0 && pAlter->totalBlocks != pDb->cfg.totalBlocks) {
@@ -646,7 +649,7 @@ UPDATE_DB_OVER:
 
 static int32_t mndProcessAlterDbReq(SMnodeMsg *pReq) {
   SMnode      *pMnode = pReq->pMnode;
-  SAlterDbMsg *pAlter = pReq->rpcMsg.pCont;
+  SAlterDbReq *pAlter = pReq->rpcMsg.pCont;
   pAlter->totalBlocks = htonl(pAlter->totalBlocks);
   pAlter->daysToKeep0 = htonl(pAlter->daysToKeep0);
   pAlter->daysToKeep1 = htonl(pAlter->daysToKeep1);
@@ -737,7 +740,7 @@ static int32_t mndBuildDropVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *
     if (pReq == NULL) return -1;
 
     action.pCont = pReq;
-    action.contLen = sizeof(SCreateVnodeReq);
+    action.contLen = sizeof(SDropVnodeReq);
     action.msgType = TDMT_DND_DROP_VNODE;
     action.acceptableCode = TSDB_CODE_DND_VNODE_NOT_DEPLOYED;
     if (mndTransAppendRedoAction(pTrans, &action) != 0) {
@@ -793,7 +796,7 @@ DROP_DB_OVER:
 
 static int32_t mndProcessDropDbReq(SMnodeMsg *pReq) {
   SMnode     *pMnode = pReq->pMnode;
-  SDropDbMsg *pDrop = pReq->rpcMsg.pCont;
+  SDropDbReq *pDrop = pReq->rpcMsg.pCont;
 
   mDebug("db:%s, start to drop", pDrop->db);
 
@@ -823,7 +826,7 @@ static int32_t mndProcessDropDbReq(SMnodeMsg *pReq) {
 static int32_t mndProcessUseDbReq(SMnodeMsg *pReq) {
   SMnode    *pMnode = pReq->pMnode;
   SSdb      *pSdb = pMnode->pSdb;
-  SUseDbMsg *pUse = pReq->rpcMsg.pCont;
+  SUseDbReq *pUse = pReq->rpcMsg.pCont;
   pUse->vgVersion = htonl(pUse->vgVersion);
 
   SDbObj *pDb = mndAcquireDb(pMnode, pUse->db);
@@ -836,6 +839,7 @@ static int32_t mndProcessUseDbReq(SMnodeMsg *pReq) {
   int32_t    contLen = sizeof(SUseDbRsp) + pDb->cfg.numOfVgroups * sizeof(SVgroupInfo);
   SUseDbRsp *pRsp = rpcMallocCont(contLen);
   if (pRsp == NULL) {
+    mndReleaseDb(pMnode, pDb);
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
   }
@@ -857,7 +861,7 @@ static int32_t mndProcessUseDbReq(SMnodeMsg *pReq) {
         pInfo->numOfEps = pVgroup->replica;
         for (int32_t gid = 0; gid < pVgroup->replica; ++gid) {
           SVnodeGid  *pVgid = &pVgroup->vnodeGid[gid];
-          SEpAddrMsg *pEpArrr = &pInfo->epAddr[gid];
+          SEpAddr *pEpArrr = &pInfo->epAddr[gid];
           SDnodeObj  *pDnode = mndAcquireDnode(pMnode, pVgid->dnodeId);
           if (pDnode != NULL) {
             memcpy(pEpArrr->fqdn, pDnode->fqdn, TSDB_FQDN_LEN);
@@ -890,7 +894,7 @@ static int32_t mndProcessUseDbReq(SMnodeMsg *pReq) {
 
 static int32_t mndProcessSyncDbReq(SMnodeMsg *pReq) {
   SMnode     *pMnode = pReq->pMnode;
-  SSyncDbMsg *pSync = pReq->rpcMsg.pCont;
+  SSyncDbReq *pSync = pReq->rpcMsg.pCont;
   SDbObj     *pDb = mndAcquireDb(pMnode, pSync->db);
   if (pDb == NULL) {
     mError("db:%s, failed to process sync db req since %s", pSync->db, terrstr());
@@ -903,7 +907,7 @@ static int32_t mndProcessSyncDbReq(SMnodeMsg *pReq) {
 
 static int32_t mndProcessCompactDbReq(SMnodeMsg *pReq) {
   SMnode        *pMnode = pReq->pMnode;
-  SCompactDbMsg *pCompact = pReq->rpcMsg.pCont;
+  SCompactDbReq *pCompact = pReq->rpcMsg.pCont;
   SDbObj        *pDb = mndAcquireDb(pMnode, pCompact->db);
   if (pDb == NULL) {
     mError("db:%s, failed to process compact db req since %s", pCompact->db, terrstr());
@@ -914,7 +918,7 @@ static int32_t mndProcessCompactDbReq(SMnodeMsg *pReq) {
   return 0;
 }
 
-static int32_t mndGetDbMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaMsg *pMeta) {
+static int32_t mndGetDbMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta) {
   SMnode *pMnode = pReq->pMnode;
   SSdb   *pSdb = pMnode->pSdb;
 

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

@@ -53,10 +53,10 @@ static int32_t mndProcessConfigDnodeReq(SMnodeMsg *pReq);
 static int32_t mndProcessConfigDnodeRsp(SMnodeMsg *pRsp);
 static int32_t mndProcessStatusReq(SMnodeMsg *pReq);
 
-static int32_t mndGetConfigMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaMsg *pMeta);
+static int32_t mndGetConfigMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta);
 static int32_t mndRetrieveConfigs(SMnodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows);
 static void    mndCancelGetNextConfig(SMnode *pMnode, void *pIter);
-static int32_t mndGetDnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaMsg *pMeta);
+static int32_t mndGetDnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta);
 static int32_t mndRetrieveDnodes(SMnodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows);
 static void    mndCancelGetNextDnode(SMnode *pMnode, void *pIter);
 
@@ -582,7 +582,7 @@ static int32_t mndProcessConfigDnodeRsp(SMnodeMsg *pRsp) {
   mInfo("app:%p config rsp from dnode", pRsp->rpcMsg.ahandle);
 }
 
-static int32_t mndGetConfigMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaMsg *pMeta) {
+static int32_t mndGetConfigMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta) {
   int32_t  cols = 0;
   SSchema *pSchema = pMeta->pSchema;
 
@@ -656,7 +656,7 @@ static int32_t mndRetrieveConfigs(SMnodeMsg *pReq, SShowObj *pShow, char *data,
 
 static void mndCancelGetNextConfig(SMnode *pMnode, void *pIter) {}
 
-static int32_t mndGetDnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaMsg *pMeta) {
+static int32_t mndGetDnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta) {
   SMnode *pMnode = pReq->pMnode;
   SSdb   *pSdb = pMnode->pSdb;
 

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

@@ -26,12 +26,12 @@ static SSdbRow *mndFuncActionDecode(SSdbRaw *pRaw);
 static int32_t  mndFuncActionInsert(SSdb *pSdb, SFuncObj *pFunc);
 static int32_t  mndFuncActionDelete(SSdb *pSdb, SFuncObj *pFunc);
 static int32_t  mndFuncActionUpdate(SSdb *pSdb, SFuncObj *pOldFunc, SFuncObj *pNewFunc);
-static int32_t  mndCreateFunc(SMnode *pMnode, SMnodeMsg *pMsg, SCreateFuncMsg *pCreate);
+static int32_t  mndCreateFunc(SMnode *pMnode, SMnodeMsg *pMsg, SCreateFuncReq *pCreate);
 static int32_t  mndDropFunc(SMnode *pMnode, SMnodeMsg *pMsg, SFuncObj *pFunc);
 static int32_t  mndProcessCreateFuncMsg(SMnodeMsg *pMsg);
 static int32_t  mndProcessDropFuncMsg(SMnodeMsg *pMsg);
 static int32_t  mndProcessRetrieveFuncMsg(SMnodeMsg *pMsg);
-static int32_t  mndGetFuncMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta);
+static int32_t  mndGetFuncMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaRsp *pMeta);
 static int32_t  mndRetrieveFuncs(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows);
 static void     mndCancelGetNextFunc(SMnode *pMnode, void *pIter);
 
@@ -156,7 +156,7 @@ static int32_t mndFuncActionUpdate(SSdb *pSdb, SFuncObj *pOldFunc, SFuncObj *pNe
   return 0;
 }
 
-static int32_t mndCreateFunc(SMnode *pMnode, SMnodeMsg *pMsg, SCreateFuncMsg *pCreate) {
+static int32_t mndCreateFunc(SMnode *pMnode, SMnodeMsg *pMsg, SCreateFuncReq *pCreate) {
   SFuncObj *pFunc = calloc(1, sizeof(SFuncObj) + pCreate->commentSize + pCreate->codeSize);
   pFunc->createdTime = taosGetTimestampMs();
   pFunc->funcType = pCreate->funcType;
@@ -264,7 +264,7 @@ static int32_t mndDropFunc(SMnode *pMnode, SMnodeMsg *pMsg, SFuncObj *pFunc) {
 static int32_t mndProcessCreateFuncMsg(SMnodeMsg *pMsg) {
   SMnode *pMnode = pMsg->pMnode;
 
-  SCreateFuncMsg *pCreate = pMsg->rpcMsg.pCont;
+  SCreateFuncReq *pCreate = pMsg->rpcMsg.pCont;
   pCreate->outputLen = htonl(pCreate->outputLen);
   pCreate->bufSize = htonl(pCreate->bufSize);
   pCreate->sigature = htobe64(pCreate->sigature);
@@ -323,7 +323,7 @@ static int32_t mndProcessCreateFuncMsg(SMnodeMsg *pMsg) {
 
 static int32_t mndProcessDropFuncMsg(SMnodeMsg *pMsg) {
   SMnode       *pMnode = pMsg->pMnode;
-  SDropFuncMsg *pDrop = pMsg->rpcMsg.pCont;
+  SDropFuncReq *pDrop = pMsg->rpcMsg.pCont;
 
   mDebug("func:%s, start to drop", pDrop->name);
 
@@ -353,7 +353,7 @@ static int32_t mndProcessDropFuncMsg(SMnodeMsg *pMsg) {
 static int32_t mndProcessRetrieveFuncMsg(SMnodeMsg *pMsg) {
   SMnode *pMnode = pMsg->pMnode;
 
-  SRetrieveFuncMsg *pRetrieve = pMsg->rpcMsg.pCont;
+  SRetrieveFuncReq *pRetrieve = pMsg->rpcMsg.pCont;
   pRetrieve->numOfFuncs = htonl(pRetrieve->numOfFuncs);
 
   int32_t size = sizeof(SRetrieveFuncRsp) + (sizeof(SFuncInfo) + TSDB_FUNC_CODE_LEN) * pRetrieve->numOfFuncs + 16384;
@@ -395,7 +395,7 @@ static int32_t mndProcessRetrieveFuncMsg(SMnodeMsg *pMsg) {
   return 0;
 }
 
-static int32_t mndGetFuncMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta) {
+static int32_t mndGetFuncMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaRsp *pMeta) {
   SMnode *pMnode = pMsg->pMnode;
   SSdb   *pSdb = pMnode->pSdb;
 

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

@@ -33,7 +33,7 @@ static int32_t  mndProcessDropMnodeReq(SMnodeMsg *pReq);
 static int32_t  mndProcessCreateMnodeRsp(SMnodeMsg *pRsp);
 static int32_t  mndProcessAlterMnodeRsp(SMnodeMsg *pRsp);
 static int32_t  mndProcessDropMnodeRsp(SMnodeMsg *pRsp);
-static int32_t  mndGetMnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaMsg *pMeta);
+static int32_t  mndGetMnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta);
 static int32_t  mndRetrieveMnodes(SMnodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows);
 static void     mndCancelGetNextMnode(SMnode *pMnode, void *pIter);
 
@@ -579,7 +579,7 @@ static int32_t mndProcessDropMnodeRsp(SMnodeMsg *pRsp) {
   return 0;
 }
 
-static int32_t mndGetMnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaMsg *pMeta) {
+static int32_t mndGetMnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta) {
   SMnode *pMnode = pReq->pMnode;
   SSdb   *pSdb = pMnode->pSdb;
 

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

@@ -51,9 +51,9 @@ static int32_t   mndProcessHeartBeatReq(SMnodeMsg *pReq);
 static int32_t   mndProcessConnectReq(SMnodeMsg *pReq);
 static int32_t   mndProcessKillQueryReq(SMnodeMsg *pReq);
 static int32_t   mndProcessKillConnReq(SMnodeMsg *pReq);
-static int32_t   mndGetConnsMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaMsg *pMeta);
+static int32_t   mndGetConnsMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta);
 static int32_t   mndRetrieveConns(SMnodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows);
-static int32_t   mndGetQueryMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaMsg *pMeta);
+static int32_t   mndGetQueryMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta);
 static int32_t   mndRetrieveQueries(SMnodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows);
 static void      mndCancelGetNextQuery(SMnode *pMnode, void *pIter);
 
@@ -389,7 +389,7 @@ static int32_t mndProcessKillConnReq(SMnodeMsg *pReq) {
   }
 }
 
-static int32_t mndGetConnsMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaMsg *pMeta) {
+static int32_t mndGetConnsMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta) {
   SMnode       *pMnode = pReq->pMnode;
   SProfileMgmt *pMgmt = &pMnode->profileMgmt;
 
@@ -518,7 +518,7 @@ static int32_t mndRetrieveConns(SMnodeMsg *pReq, SShowObj *pShow, char *data, in
   return numOfRows;
 }
 
-static int32_t mndGetQueryMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaMsg *pMeta) {
+static int32_t mndGetQueryMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta) {
   SMnode       *pMnode = pReq->pMnode;
   SProfileMgmt *pMgmt = &pMnode->profileMgmt;
 

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

@@ -31,7 +31,7 @@ static int32_t  mndProcessCreateQnodeReq(SMnodeMsg *pReq);
 static int32_t  mndProcessDropQnodeReq(SMnodeMsg *pReq);
 static int32_t  mndProcessCreateQnodeRsp(SMnodeMsg *pRsp);
 static int32_t  mndProcessDropQnodeRsp(SMnodeMsg *pRsp);
-static int32_t  mndGetQnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaMsg *pMeta);
+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);
 
@@ -391,7 +391,7 @@ static int32_t mndProcessDropQnodeRsp(SMnodeMsg *pRsp) {
   return 0;
 }
 
-static int32_t mndGetQnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaMsg *pMeta) {
+static int32_t mndGetQnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta) {
   SMnode *pMnode = pReq->pMnode;
   SSdb   *pSdb = pMnode->pSdb;
 

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

@@ -31,7 +31,7 @@ static int32_t  mndProcessCreateSnodeReq(SMnodeMsg *pReq);
 static int32_t  mndProcessDropSnodeReq(SMnodeMsg *pReq);
 static int32_t  mndProcessCreateSnodeRsp(SMnodeMsg *pRsp);
 static int32_t  mndProcessDropSnodeRsp(SMnodeMsg *pRsp);
-static int32_t  mndGetSnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaMsg *pMeta);
+static int32_t  mndGetSnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta);
 static int32_t  mndRetrieveSnodes(SMnodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows);
 static void     mndCancelGetNextSnode(SMnode *pMnode, void *pIter);
 
@@ -393,7 +393,7 @@ static int32_t mndProcessDropSnodeRsp(SMnodeMsg *pRsp) {
   return 0;
 }
 
-static int32_t mndGetSnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaMsg *pMeta) {
+static int32_t mndGetSnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta) {
   SMnode *pMnode = pReq->pMnode;
   SSdb   *pSdb = pMnode->pSdb;
 

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

@@ -32,14 +32,14 @@ static SSdbRow *mndStbActionDecode(SSdbRaw *pRaw);
 static int32_t  mndStbActionInsert(SSdb *pSdb, SStbObj *pStb);
 static int32_t  mndStbActionDelete(SSdb *pSdb, SStbObj *pStb);
 static int32_t  mndStbActionUpdate(SSdb *pSdb, SStbObj *pOldStb, SStbObj *pNewStb);
-static int32_t  mndProcessCreateStbMsg(SMnodeMsg *pMsg);
-static int32_t  mndProcessAlterStbMsg(SMnodeMsg *pMsg);
-static int32_t  mndProcessDropStbMsg(SMnodeMsg *pMsg);
+static int32_t  mndProcesSMCreateStbReq(SMnodeMsg *pMsg);
+static int32_t  mndProcesSMAlterStbReq(SMnodeMsg *pMsg);
+static int32_t  mndProcesSMDropStbReq(SMnodeMsg *pMsg);
 static int32_t  mndProcessCreateStbInRsp(SMnodeMsg *pMsg);
 static int32_t  mndProcessAlterStbInRsp(SMnodeMsg *pMsg);
 static int32_t  mndProcessDropStbInRsp(SMnodeMsg *pMsg);
 static int32_t  mndProcessStbMetaMsg(SMnodeMsg *pMsg);
-static int32_t  mndGetStbMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta);
+static int32_t  mndGetStbMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaRsp *pMeta);
 static int32_t  mndRetrieveStb(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows);
 static void     mndCancelGetNextStb(SMnode *pMnode, void *pIter);
 
@@ -52,9 +52,9 @@ int32_t mndInitStb(SMnode *pMnode) {
                      .updateFp = (SdbUpdateFp)mndStbActionUpdate,
                      .deleteFp = (SdbDeleteFp)mndStbActionDelete};
 
-  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_STB, mndProcessCreateStbMsg);
-  mndSetMsgHandle(pMnode, TDMT_MND_ALTER_STB, mndProcessAlterStbMsg);
-  mndSetMsgHandle(pMnode, TDMT_MND_DROP_STB, mndProcessDropStbMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_STB, mndProcesSMCreateStbReq);
+  mndSetMsgHandle(pMnode, TDMT_MND_ALTER_STB, mndProcesSMAlterStbReq);
+  mndSetMsgHandle(pMnode, TDMT_MND_DROP_STB, mndProcesSMDropStbReq);
   mndSetMsgHandle(pMnode, TDMT_VND_CREATE_STB_RSP, mndProcessCreateStbInRsp);
   mndSetMsgHandle(pMnode, TDMT_VND_ALTER_STB_RSP, mndProcessAlterStbInRsp);
   mndSetMsgHandle(pMnode, TDMT_VND_DROP_STB_RSP, mndProcessDropStbInRsp);
@@ -204,7 +204,7 @@ static int32_t mndStbActionUpdate(SSdb *pSdb, SStbObj *pOldStb, SStbObj *pNewStb
 SStbObj *mndAcquireStb(SMnode *pMnode, char *stbName) {
   SSdb    *pSdb = pMnode->pSdb;
   SStbObj *pStb = sdbAcquire(pSdb, SDB_STB, stbName);
-  if (pStb == NULL) {
+  if (pStb == NULL && terrno == TSDB_CODE_SDB_OBJ_NOT_THERE) {
     terrno = TSDB_CODE_MND_STB_NOT_EXIST;
   }
   return pStb;
@@ -264,10 +264,10 @@ static void *mndBuildCreateStbMsg(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pStb
   return buf;
 }
 
-static SVDropStbReq *mndBuildDropStbMsg(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pStb) {
-  int32_t contLen = sizeof(SVDropStbReq);
+static SVDropTbReq *mndBuildDropStbMsg(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pStb) {
+  int32_t contLen = sizeof(SVDropTbReq);
 
-  SVDropStbReq *pDrop = calloc(1, contLen);
+  SVDropTbReq *pDrop = calloc(1, contLen);
   if (pDrop == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
@@ -276,12 +276,12 @@ static SVDropStbReq *mndBuildDropStbMsg(SMnode *pMnode, SVgObj *pVgroup, SStbObj
   pDrop->head.contLen = htonl(contLen);
   pDrop->head.vgId = htonl(pVgroup->vgId);
   memcpy(pDrop->name, pStb->name, TSDB_TABLE_FNAME_LEN);
-  pDrop->suid = htobe64(pStb->uid);
+  // pDrop->suid = htobe64(pStb->uid);
 
   return pDrop;
 }
 
-static int32_t mndCheckCreateStbMsg(SCreateStbMsg *pCreate) {
+static int32_t mndCheckCreateStbMsg(SMCreateStbReq *pCreate) {
   pCreate->numOfColumns = htonl(pCreate->numOfColumns);
   pCreate->numOfTags = htonl(pCreate->numOfTags);
   int32_t totalCols = pCreate->numOfColumns + pCreate->numOfTags;
@@ -398,7 +398,7 @@ static int32_t mndSetCreateStbUndoActions(SMnode *pMnode, STrans *pTrans, SDbObj
     if (pIter == NULL) break;
     if (pVgroup->dbUid != pDb->uid) continue;
 
-    SVDropStbReq *pMsg = mndBuildDropStbMsg(pMnode, pVgroup, pStb);
+    SVDropTbReq *pMsg = mndBuildDropStbMsg(pMnode, pVgroup, pStb);
     if (pMsg == NULL) {
       sdbCancelFetch(pSdb, pIter);
       sdbRelease(pSdb, pVgroup);
@@ -409,7 +409,7 @@ static int32_t mndSetCreateStbUndoActions(SMnode *pMnode, STrans *pTrans, SDbObj
     STransAction action = {0};
     action.epSet = mndGetVgroupEpset(pMnode, pVgroup);
     action.pCont = pMsg;
-    action.contLen = sizeof(SVDropStbReq);
+    action.contLen = sizeof(SVDropTbReq);
     action.msgType = TDMT_VND_DROP_STB;
     if (mndTransAppendUndoAction(pTrans, &action) != 0) {
       free(pMsg);
@@ -423,7 +423,7 @@ static int32_t mndSetCreateStbUndoActions(SMnode *pMnode, STrans *pTrans, SDbObj
   return 0;
 }
 
-static int32_t mndCreateStb(SMnode *pMnode, SMnodeMsg *pMsg, SCreateStbMsg *pCreate, SDbObj *pDb) {
+static int32_t mndCreateStb(SMnode *pMnode, SMnodeMsg *pMsg, SMCreateStbReq *pCreate, SDbObj *pDb) {
   SStbObj stbObj = {0};
   tstrncpy(stbObj.name, pCreate->name, TSDB_TABLE_FNAME_LEN);
   tstrncpy(stbObj.db, pDb->name, TSDB_DB_FNAME_LEN);
@@ -494,9 +494,9 @@ CREATE_STB_OVER:
   return code;
 }
 
-static int32_t mndProcessCreateStbMsg(SMnodeMsg *pMsg) {
+static int32_t mndProcesSMCreateStbReq(SMnodeMsg *pMsg) {
   SMnode        *pMnode = pMsg->pMnode;
-  SCreateStbMsg *pCreate = pMsg->rpcMsg.pCont;
+  SMCreateStbReq *pCreate = pMsg->rpcMsg.pCont;
 
   mDebug("stb:%s, start to create", pCreate->name);
 
@@ -513,9 +513,11 @@ static int32_t mndProcessCreateStbMsg(SMnodeMsg *pMsg) {
       return 0;
     } else {
       terrno = TSDB_CODE_MND_STB_ALREADY_EXIST;
-      mError("db:%s, failed to create since %s", pCreate->name, terrstr());
+      mError("stb:%s, failed to create since %s", pCreate->name, terrstr());
       return -1;
     }
+  } else if (terrno != TSDB_CODE_MND_STB_NOT_EXIST) {
+    mError("stb:%s, failed to create since %s", pCreate->name, terrstr());
   }
 
   // topic should have different name with stb
@@ -551,7 +553,7 @@ static int32_t mndProcessCreateStbInRsp(SMnodeMsg *pMsg) {
   return 0;
 }
 
-static int32_t mndCheckAlterStbMsg(SAlterStbMsg *pAlter) {
+static int32_t mndCheckAlterStbMsg(SMAlterStbReq *pAlter) {
   SSchema *pSchema = &pAlter->schema;
   pSchema->colId = htonl(pSchema->colId);
   pSchema->bytes = htonl(pSchema->bytes);
@@ -578,9 +580,9 @@ static int32_t mndCheckAlterStbMsg(SAlterStbMsg *pAlter) {
 
 static int32_t mndUpdateStb(SMnode *pMnode, SMnodeMsg *pMsg, SStbObj *pOldStb, SStbObj *pNewStb) { return 0; }
 
-static int32_t mndProcessAlterStbMsg(SMnodeMsg *pMsg) {
+static int32_t mndProcesSMAlterStbReq(SMnodeMsg *pMsg) {
   SMnode       *pMnode = pMsg->pMnode;
-  SAlterStbMsg *pAlter = pMsg->rpcMsg.pCont;
+  SMAlterStbReq *pAlter = pMsg->rpcMsg.pCont;
 
   mDebug("stb:%s, start to alter", pAlter->name);
 
@@ -692,9 +694,9 @@ DROP_STB_OVER:
   return 0;
 }
 
-static int32_t mndProcessDropStbMsg(SMnodeMsg *pMsg) {
+static int32_t mndProcesSMDropStbReq(SMnodeMsg *pMsg) {
   SMnode      *pMnode = pMsg->pMnode;
-  SDropStbMsg *pDrop = pMsg->rpcMsg.pCont;
+  SMDropStbReq *pDrop = pMsg->rpcMsg.pCont;
 
   mDebug("stb:%s, start to drop", pDrop->name);
 
@@ -729,7 +731,7 @@ static int32_t mndProcessDropStbInRsp(SMnodeMsg *pMsg) {
 
 static int32_t mndProcessStbMetaMsg(SMnodeMsg *pMsg) {
   SMnode        *pMnode = pMsg->pMnode;
-  STableInfoMsg *pInfo = pMsg->rpcMsg.pCont;
+  STableInfoReq *pInfo = pMsg->rpcMsg.pCont;
 
   mDebug("stb:%s, start to retrieve meta", pInfo->tableFname);
 
@@ -750,9 +752,9 @@ static int32_t mndProcessStbMetaMsg(SMnodeMsg *pMsg) {
 
   taosRLockLatch(&pStb->lock);
   int32_t totalCols = pStb->numOfColumns + pStb->numOfTags;
-  int32_t contLen = sizeof(STableMetaMsg) + totalCols * sizeof(SSchema);
+  int32_t contLen = sizeof(STableMetaRsp) + totalCols * sizeof(SSchema);
 
-  STableMetaMsg *pMeta = rpcMallocCont(contLen);
+  STableMetaRsp *pMeta = rpcMallocCont(contLen);
   if (pMeta == NULL) {
     taosRUnLockLatch(&pStb->lock);
     mndReleaseDb(pMnode, pDb);
@@ -818,7 +820,7 @@ static int32_t mndGetNumOfStbs(SMnode *pMnode, char *dbName, int32_t *pNumOfStbs
   return 0;
 }
 
-static int32_t mndGetStbMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta) {
+static int32_t mndGetStbMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaRsp *pMeta) {
   SMnode *pMnode = pMsg->pMnode;
   SSdb   *pSdb = pMnode->pSdb;
 

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

@@ -35,7 +35,7 @@ static int32_t mndProcessCreateTopicMsg(SMnodeMsg *pMsg);
 static int32_t mndProcessDropTopicMsg(SMnodeMsg *pMsg);
 static int32_t mndProcessDropTopicInRsp(SMnodeMsg *pMsg);
 static int32_t mndProcessTopicMetaMsg(SMnodeMsg *pMsg);
-static int32_t mndGetTopicMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta);
+static int32_t mndGetTopicMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaRsp *pMeta);
 static int32_t mndRetrieveTopic(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows);
 static void    mndCancelGetNextTopic(SMnode *pMnode, void *pIter);
 
@@ -186,10 +186,10 @@ static SDbObj *mndAcquireDbByTopic(SMnode *pMnode, char *topicName) {
   return mndAcquireDb(pMnode, db);
 }
 
-static SDDropTopicMsg *mndBuildDropTopicMsg(SMnode *pMnode, SVgObj *pVgroup, SMqTopicObj *pTopic) {
-  int32_t contLen = sizeof(SDDropTopicMsg);
+static SDDropTopicReq *mndBuildDropTopicMsg(SMnode *pMnode, SVgObj *pVgroup, SMqTopicObj *pTopic) {
+  int32_t contLen = sizeof(SDDropTopicReq);
 
-  SDDropTopicMsg *pDrop = calloc(1, contLen);
+  SDDropTopicReq *pDrop = calloc(1, contLen);
   if (pDrop == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
@@ -274,7 +274,7 @@ static int32_t mndDropTopic(SMnode *pMnode, SMnodeMsg *pMsg, SMqTopicObj *pTopic
 
 static int32_t mndProcessDropTopicMsg(SMnodeMsg *pMsg) {
   SMnode        *pMnode = pMsg->pMnode;
-  SDropTopicMsg *pDrop = pMsg->rpcMsg.pCont;
+  SDropTopicReq *pDrop = pMsg->rpcMsg.pCont;
 
   mDebug("topic:%s, start to drop", pDrop->name);
 
@@ -309,7 +309,7 @@ static int32_t mndProcessDropTopicInRsp(SMnodeMsg *pMsg) {
 
 static int32_t mndProcessTopicMetaMsg(SMnodeMsg *pMsg) {
   SMnode        *pMnode = pMsg->pMnode;
-  STableInfoMsg *pInfo = pMsg->rpcMsg.pCont;
+  STableInfoReq *pInfo = pMsg->rpcMsg.pCont;
 
   mDebug("topic:%s, start to retrieve meta", pInfo->tableFname);
 
@@ -331,9 +331,9 @@ static int32_t mndProcessTopicMetaMsg(SMnodeMsg *pMsg) {
 
   taosRLockLatch(&pTopic->lock);
   int32_t totalCols = pTopic->numOfColumns + pTopic->numOfTags;
-  int32_t contLen = sizeof(STableMetaMsg) + totalCols * sizeof(SSchema);
+  int32_t contLen = sizeof(STableMetaRsp) + totalCols * sizeof(SSchema);
 
-  STableMetaMsg *pMeta = rpcMallocCont(contLen);
+  STableMetaRsp *pMeta = rpcMallocCont(contLen);
   if (pMeta == NULL) {
     taosRUnLockLatch(&pTopic->lock);
     mndReleaseDb(pMnode, pDb);
@@ -397,7 +397,7 @@ static int32_t mndGetNumOfTopics(SMnode *pMnode, char *dbName, int32_t *pNumOfTo
   return 0;
 }
 
-static int32_t mndGetTopicMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta) {
+static int32_t mndGetTopicMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaRsp *pMeta) {
   SMnode *pMnode = pMsg->pMnode;
   SSdb   *pSdb = pMnode->pSdb;
 

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

@@ -809,7 +809,7 @@ static bool mndTransPerformUndoLogStage(SMnode *pMnode, STrans *pTrans) {
     mDebug("trans:%d, stage from undoLog to rollback", pTrans->id);
     continueExec = true;
   } else {
-    mDebug("trans:%d, stage keep on undoLog since %s", pTrans->id, terrstr());
+    mError("trans:%d, stage keep on undoLog since %s", pTrans->id, terrstr());
     continueExec = false;
   }
 

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

@@ -32,7 +32,7 @@ static int32_t  mndCreateUser(SMnode *pMnode, char *acct, char *user, char *pass
 static int32_t  mndProcessCreateUserReq(SMnodeMsg *pReq);
 static int32_t  mndProcessAlterUserReq(SMnodeMsg *pReq);
 static int32_t  mndProcessDropUserReq(SMnodeMsg *pReq);
-static int32_t  mndGetUserMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaMsg *pMeta);
+static int32_t  mndGetUserMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta);
 static int32_t  mndRetrieveUsers(SMnodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows);
 static void     mndCancelGetNextUser(SMnode *pMnode, void *pIter);
 
@@ -432,7 +432,7 @@ static int32_t mndProcessDropUserReq(SMnodeMsg *pReq) {
   return TSDB_CODE_MND_ACTION_IN_PROGRESS;
 }
 
-static int32_t mndGetUserMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaMsg *pMeta) {
+static int32_t mndGetUserMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta) {
   SMnode *pMnode = pReq->pMnode;
   SSdb   *pSdb = pMnode->pSdb;
 

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

@@ -27,19 +27,19 @@
 static SSdbRow *mndVgroupActionDecode(SSdbRaw *pRaw);
 static int32_t  mndVgroupActionInsert(SSdb *pSdb, SVgObj *pVgroup);
 static int32_t  mndVgroupActionDelete(SSdb *pSdb, SVgObj *pVgroup);
-static int32_t  mndVgroupActionUpdate(SSdb *pSdb, SVgObj *pOldVgroup, SVgObj *pNewVgroup);
+static int32_t  mndVgroupActionUpdate(SSdb *pSdb, SVgObj *pOld, SVgObj *pNew);
 
-static int32_t mndProcessCreateVnodeRsp(SMnodeMsg *pMsg);
-static int32_t mndProcessAlterVnodeRsp(SMnodeMsg *pMsg);
-static int32_t mndProcessDropVnodeRsp(SMnodeMsg *pMsg);
-static int32_t mndProcessSyncVnodeRsp(SMnodeMsg *pMsg);
-static int32_t mndProcessCompactVnodeRsp(SMnodeMsg *pMsg);
+static int32_t mndProcessCreateVnodeRsp(SMnodeMsg *pRsp);
+static int32_t mndProcessAlterVnodeRsp(SMnodeMsg *pRsp);
+static int32_t mndProcessDropVnodeRsp(SMnodeMsg *pRsp);
+static int32_t mndProcessSyncVnodeRsp(SMnodeMsg *pRsp);
+static int32_t mndProcessCompactVnodeRsp(SMnodeMsg *pRsp);
 
-static int32_t mndGetVgroupMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta);
-static int32_t mndRetrieveVgroups(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows);
+static int32_t mndGetVgroupMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta);
+static int32_t mndRetrieveVgroups(SMnodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows);
 static void    mndCancelGetNextVgroup(SMnode *pMnode, void *pIter);
-static int32_t mndGetVnodeMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta);
-static int32_t mndRetrieveVnodes(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows);
+static int32_t mndGetVnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta);
+static int32_t mndRetrieveVnodes(SMnodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows);
 static void    mndCancelGetNextVnode(SMnode *pMnode, void *pIter);
 
 int32_t mndInitVgroup(SMnode *pMnode) {
@@ -164,14 +164,14 @@ static int32_t mndVgroupActionDelete(SSdb *pSdb, SVgObj *pVgroup) {
   return 0;
 }
 
-static int32_t mndVgroupActionUpdate(SSdb *pSdb, SVgObj *pOldVgroup, SVgObj *pNewVgroup) {
-  mTrace("vgId:%d, perform update action, old row:%p new row:%p", pOldVgroup->vgId, pOldVgroup, pNewVgroup);
-  pOldVgroup->updateTime = pNewVgroup->updateTime;
-  pOldVgroup->version = pNewVgroup->version;
-  pOldVgroup->hashBegin = pNewVgroup->hashBegin;
-  pOldVgroup->hashEnd = pNewVgroup->hashEnd;
-  pOldVgroup->replica = pNewVgroup->replica;
-  memcpy(pOldVgroup->vnodeGid, pNewVgroup->vnodeGid, TSDB_MAX_REPLICA * sizeof(SVnodeGid));
+static int32_t mndVgroupActionUpdate(SSdb *pSdb, SVgObj *pOld, SVgObj *pNew) {
+  mTrace("vgId:%d, perform update action, old row:%p new row:%p", pOld->vgId, pOld, pNew);
+  pOld->updateTime = pNew->updateTime;
+  pOld->version = pNew->version;
+  pOld->hashBegin = pNew->hashBegin;
+  pOld->hashEnd = pNew->hashEnd;
+  pOld->replica = pNew->replica;
+  memcpy(pOld->vnodeGid, pNew->vnodeGid, TSDB_MAX_REPLICA * sizeof(SVnodeGid));
   return 0;
 }
 
@@ -273,15 +273,10 @@ static bool mndBuildDnodesArrayFp(SMnode *pMnode, void *pObj, void *p1, void *p2
   SDnodeObj *pDnode = pObj;
   SArray    *pArray = p1;
 
-  pDnode->numOfVnodes = mndGetVnodesNum(pMnode, pDnode->id);
-
   int64_t curMs = taosGetTimestampMs();
   bool    online = mndIsDnodeOnline(pMnode, pDnode, curMs);
-  if (online && pDnode->numOfSupportVnodes > 0) {
-    taosArrayPush(pArray, pDnode);
-  }
-
-  bool isMnode = mndIsMnode(pMnode, pDnode->id);
+  bool    isMnode = mndIsMnode(pMnode, pDnode->id);
+  pDnode->numOfVnodes = mndGetVnodesNum(pMnode, pDnode->id);
 
   mDebug("dnode:%d, vnodes:%d supportVnodes:%d isMnode:%d online:%d", pDnode->id, pDnode->numOfVnodes,
          pDnode->numOfSupportVnodes, isMnode, online);
@@ -290,6 +285,9 @@ static bool mndBuildDnodesArrayFp(SMnode *pMnode, void *pObj, void *p1, void *p2
     pDnode->numOfVnodes++;
   }
 
+  if (online && pDnode->numOfSupportVnodes > 0) {
+    taosArrayPush(pArray, pDnode);
+  }
   return true;
 }
 
@@ -311,7 +309,7 @@ static SArray *mndBuildDnodesArray(SMnode *pMnode) {
 static int32_t mndCompareDnodeVnodes(SDnodeObj *pDnode1, SDnodeObj *pDnode2) {
   float d1Score = (float)pDnode1->numOfVnodes / pDnode1->numOfSupportVnodes;
   float d2Score = (float)pDnode2->numOfVnodes / pDnode2->numOfSupportVnodes;
-  return d1Score > d2Score ? 1 : 0;
+  return d1Score >= d2Score ? 1 : 0;
 }
 
 static int32_t mndGetAvailableDnode(SMnode *pMnode, SVgObj *pVgroup, SArray *pArray) {
@@ -321,6 +319,14 @@ static int32_t mndGetAvailableDnode(SMnode *pMnode, SVgObj *pVgroup, SArray *pAr
 
   taosArraySort(pArray, (__compar_fn_t)mndCompareDnodeVnodes);
 
+  int32_t size = taosArrayGetSize(pArray);
+  if (size < pVgroup->replica) {
+    mError("db:%s, vgId:%d, no enough online dnodes:%d to alloc %d replica", pVgroup->dbName, pVgroup->vgId, size,
+           pVgroup->replica);
+    terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;
+    return -1;
+  }
+
   for (int32_t v = 0; v < pVgroup->replica; ++v) {
     SVnodeGid *pVgid = &pVgroup->vnodeGid[v];
     SDnodeObj *pDnode = taosArrayGet(pArray, v);
@@ -427,24 +433,24 @@ SEpSet mndGetVgroupEpset(SMnode *pMnode, SVgObj *pVgroup) {
   return epset;
 }
 
-static int32_t mndProcessCreateVnodeRsp(SMnodeMsg *pMsg) {
-  mndTransProcessRsp(pMsg);
+static int32_t mndProcessCreateVnodeRsp(SMnodeMsg *pRsp) {
+  mndTransProcessRsp(pRsp);
   return 0;
 }
 
-static int32_t mndProcessAlterVnodeRsp(SMnodeMsg *pMsg) {
-  mndTransProcessRsp(pMsg);
+static int32_t mndProcessAlterVnodeRsp(SMnodeMsg *pRsp) {
+  mndTransProcessRsp(pRsp);
   return 0;
 }
 
-static int32_t mndProcessDropVnodeRsp(SMnodeMsg *pMsg) {
-  mndTransProcessRsp(pMsg);
+static int32_t mndProcessDropVnodeRsp(SMnodeMsg *pRsp) {
+  mndTransProcessRsp(pRsp);
   return 0;
 }
 
-static int32_t mndProcessSyncVnodeRsp(SMnodeMsg *pMsg) { return 0; }
+static int32_t mndProcessSyncVnodeRsp(SMnodeMsg *pRsp) { return 0; }
 
-static int32_t mndProcessCompactVnodeRsp(SMnodeMsg *pMsg) { return 0; }
+static int32_t mndProcessCompactVnodeRsp(SMnodeMsg *pRsp) { return 0; }
 
 static bool mndGetVgroupMaxReplicaFp(SMnode *pMnode, void *pObj, void *p1, void *p2, void *p3) {
   SVgObj  *pVgroup = pObj;
@@ -475,8 +481,8 @@ static int32_t mndGetVgroupMaxReplica(SMnode *pMnode, char *dbName, int8_t *pRep
   return 0;
 }
 
-static int32_t mndGetVgroupMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta) {
-  SMnode *pMnode = pMsg->pMnode;
+static int32_t mndGetVgroupMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta) {
+  SMnode *pMnode = pReq->pMnode;
   SSdb   *pSdb = pMnode->pSdb;
 
   if (mndGetVgroupMaxReplica(pMnode, pShow->db, &pShow->replica, &pShow->numOfRows) != 0) {
@@ -526,8 +532,8 @@ static int32_t mndGetVgroupMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg
   return 0;
 }
 
-static int32_t mndRetrieveVgroups(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows) {
-  SMnode *pMnode = pMsg->pMnode;
+static int32_t mndRetrieveVgroups(SMnodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows) {
+  SMnode *pMnode = pReq->pMnode;
   SSdb   *pSdb = pMnode->pSdb;
   int32_t numOfRows = 0;
   SVgObj *pVgroup = NULL;
@@ -593,8 +599,8 @@ int32_t mndGetVnodesNum(SMnode *pMnode, int32_t dnodeId) {
   return numOfVnodes;
 }
 
-static int32_t mndGetVnodeMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta) {
-  SMnode *pMnode = pMsg->pMnode;
+static int32_t mndGetVnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta) {
+  SMnode *pMnode = pReq->pMnode;
   SSdb   *pSdb = pMnode->pSdb;
 
   int32_t  cols = 0;
@@ -633,8 +639,8 @@ static int32_t mndGetVnodeMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *
   return 0;
 }
 
-static int32_t mndRetrieveVnodes(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows) {
-  SMnode *pMnode = pMsg->pMnode;
+static int32_t mndRetrieveVnodes(SMnodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows) {
+  SMnode *pMnode = pReq->pMnode;
   SSdb   *pSdb = pMnode->pSdb;
   int32_t numOfRows = 0;
   SVgObj *pVgroup = NULL;

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

@@ -61,8 +61,8 @@ void mndSendRedirectRsp(SMnode *pMnode, SRpcMsg *pMsg) {
 static void mndTransReExecute(void *param, void *tmrId) {
   SMnode *pMnode = param;
   if (mndIsMaster(pMnode)) {
-    STransMsg *pMsg = rpcMallocCont(sizeof(STransMsg));
-    SRpcMsg    rpcMsg = {.msgType = TDMT_MND_TRANS, .pCont = pMsg, .contLen = sizeof(STransMsg)};
+    STransReq *pMsg = rpcMallocCont(sizeof(STransReq));
+    SRpcMsg    rpcMsg = {.msgType = TDMT_MND_TRANS, .pCont = pMsg, .contLen = sizeof(STransReq)};
     pMnode->putReqToMWriteQFp(pMnode->pDnode, &rpcMsg);
   }
 

source/dnode/mnode/impl/test/db/db.cpp

@@ -13,28 +13,17 @@
 
 class MndTestDb : public ::testing::Test {
  protected:
-  static void SetUpTestSuite() {
-    test.Init("/tmp/mnode_test_db", 9030);
-    const char* fqdn = "localhost";
-    const char* firstEp = "localhost:9030";
+  static void SetUpTestSuite() { test.Init("/tmp/mnode_test_db", 9030); }
+  static void TearDownTestSuite() { test.Cleanup(); }
 
-    server2.Start("/tmp/mnode_test_db2", fqdn, 9031, firstEp);
-  }
-  static void TearDownTestSuite() {
-    server2.Stop();
-    test.Cleanup();
-  }
-
-  static Testbase   test;
-  static TestServer server2;
+  static Testbase test;
 
  public:
   void SetUp() override {}
   void TearDown() override {}
 };
 
-Testbase   MndTestDb::test;
-TestServer MndTestDb::server2;
+Testbase MndTestDb::test;
 
 TEST_F(MndTestDb, 01_ShowDb) {
   test.SendShowMetaReq(TSDB_MGMT_TABLE_DB, "");
@@ -64,9 +53,9 @@ TEST_F(MndTestDb, 01_ShowDb) {
 
 TEST_F(MndTestDb, 02_Create_Alter_Drop_Db) {
   {
-    int32_t contLen = sizeof(SCreateDbMsg);
+    int32_t contLen = sizeof(SCreateDbReq);
 
-    SCreateDbMsg* pReq = (SCreateDbMsg*)rpcMallocCont(contLen);
+    SCreateDbReq* pReq = (SCreateDbReq*)rpcMallocCont(contLen);
     strcpy(pReq->db, "1.d1");
     pReq->numOfVgroups = htonl(2);
     pReq->cacheBlockSize = htonl(16);
@@ -136,9 +125,9 @@ TEST_F(MndTestDb, 02_Create_Alter_Drop_Db) {
   CheckBinary("master", 9);
 
   {
-    int32_t contLen = sizeof(SAlterDbMsg);
+    int32_t contLen = sizeof(SAlterDbReq);
 
-    SAlterDbMsg* pReq = (SAlterDbMsg*)rpcMallocCont(contLen);
+    SAlterDbReq* pReq = (SAlterDbReq*)rpcMallocCont(contLen);
     strcpy(pReq->db, "1.d1");
     pReq->totalBlocks = htonl(12);
     pReq->daysToKeep0 = htonl(300);
@@ -205,9 +194,9 @@ TEST_F(MndTestDb, 02_Create_Alter_Drop_Db) {
   CheckInt8(0);                    // update
 
   {
-    int32_t contLen = sizeof(SDropDbMsg);
+    int32_t contLen = sizeof(SDropDbReq);
 
-    SDropDbMsg* pReq = (SDropDbMsg*)rpcMallocCont(contLen);
+    SDropDbReq* pReq = (SDropDbReq*)rpcMallocCont(contLen);
     strcpy(pReq->db, "1.d1");
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_DB, pReq, contLen);
@@ -224,9 +213,9 @@ TEST_F(MndTestDb, 02_Create_Alter_Drop_Db) {
 
 TEST_F(MndTestDb, 03_Create_Use_Restart_Use_Db) {
   {
-    int32_t contLen = sizeof(SCreateDbMsg);
+    int32_t contLen = sizeof(SCreateDbReq);
 
-    SCreateDbMsg* pReq = (SCreateDbMsg*)rpcMallocCont(contLen);
+    SCreateDbReq* pReq = (SCreateDbReq*)rpcMallocCont(contLen);
     strcpy(pReq->db, "1.d2");
     pReq->numOfVgroups = htonl(2);
     pReq->cacheBlockSize = htonl(16);
@@ -261,9 +250,9 @@ TEST_F(MndTestDb, 03_Create_Use_Restart_Use_Db) {
   CheckBinary("d2", TSDB_DB_NAME_LEN - 1);
 
   {
-    int32_t contLen = sizeof(SUseDbMsg);
+    int32_t contLen = sizeof(SUseDbReq);
 
-    SUseDbMsg* pReq = (SUseDbMsg*)rpcMallocCont(contLen);
+    SUseDbReq* pReq = (SUseDbReq*)rpcMallocCont(contLen);
     strcpy(pReq->db, "1.d2");
     pReq->vgVersion = htonl(-1);
 
@@ -290,7 +279,7 @@ TEST_F(MndTestDb, 03_Create_Use_Restart_Use_Db) {
       EXPECT_EQ(pInfo->hashEnd, UINT32_MAX / 2 - 1);
       EXPECT_EQ(pInfo->inUse, 0);
       EXPECT_EQ(pInfo->numOfEps, 1);
-      SEpAddrMsg* pAddr = &pInfo->epAddr[0];
+      SEpAddr* pAddr = &pInfo->epAddr[0];
       pAddr->port = htons(pAddr->port);
       EXPECT_EQ(pAddr->port, 9030);
       EXPECT_STREQ(pAddr->fqdn, "localhost");
@@ -306,7 +295,7 @@ TEST_F(MndTestDb, 03_Create_Use_Restart_Use_Db) {
       EXPECT_EQ(pInfo->hashEnd, UINT32_MAX);
       EXPECT_EQ(pInfo->inUse, 0);
       EXPECT_EQ(pInfo->numOfEps, 1);
-      SEpAddrMsg* pAddr = &pInfo->epAddr[0];
+      SEpAddr* pAddr = &pInfo->epAddr[0];
       pAddr->port = htons(pAddr->port);
       EXPECT_EQ(pAddr->port, 9030);
       EXPECT_STREQ(pAddr->fqdn, "localhost");
@@ -314,9 +303,9 @@ TEST_F(MndTestDb, 03_Create_Use_Restart_Use_Db) {
   }
 
   {
-    int32_t contLen = sizeof(SDropDbMsg);
+    int32_t contLen = sizeof(SDropDbReq);
 
-    SDropDbMsg* pReq = (SDropDbMsg*)rpcMallocCont(contLen);
+    SDropDbReq* pReq = (SDropDbReq*)rpcMallocCont(contLen);
     strcpy(pReq->db, "1.d2");
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_DB, pReq, contLen);

source/dnode/mnode/impl/test/profile/profile.cpp

@@ -13,7 +13,7 @@
 
 class MndTestProfile : public ::testing::Test {
  protected:
-  static void SetUpTestSuite() { test.Init("/tmp/mnode_test_profile", 9022); }
+  static void SetUpTestSuite() { test.Init("/tmp/mnode_test_profile", 9031); }
   static void TearDownTestSuite() { test.Cleanup(); }
 
   static Testbase test;
@@ -53,7 +53,7 @@ TEST_F(MndTestProfile, 01_ConnectMsg) {
 
   EXPECT_EQ(pRsp->epSet.inUse, 0);
   EXPECT_EQ(pRsp->epSet.numOfEps, 1);
-  EXPECT_EQ(pRsp->epSet.port[0], 9022);
+  EXPECT_EQ(pRsp->epSet.port[0], 9031);
   EXPECT_STREQ(pRsp->epSet.fqdn[0], "localhost");
 
   connId = pRsp->connId;
@@ -127,7 +127,7 @@ TEST_F(MndTestProfile, 04_HeartBeatMsg) {
 
   EXPECT_EQ(pRsp->epSet.inUse, 0);
   EXPECT_EQ(pRsp->epSet.numOfEps, 1);
-  EXPECT_EQ(pRsp->epSet.port[0], 9022);
+  EXPECT_EQ(pRsp->epSet.port[0], 9031);
   EXPECT_STREQ(pRsp->epSet.fqdn[0], "localhost");
 }
 
@@ -185,7 +185,7 @@ TEST_F(MndTestProfile, 05_KillConnMsg) {
 
     EXPECT_EQ(pRsp->epSet.inUse, 0);
     EXPECT_EQ(pRsp->epSet.numOfEps, 1);
-    EXPECT_EQ(pRsp->epSet.port[0], 9022);
+    EXPECT_EQ(pRsp->epSet.port[0], 9031);
     EXPECT_STREQ(pRsp->epSet.fqdn[0], "localhost");
 
     connId = pRsp->connId;
@@ -249,7 +249,7 @@ TEST_F(MndTestProfile, 07_KillQueryMsg) {
 
     EXPECT_EQ(pRsp->epSet.inUse, 0);
     EXPECT_EQ(pRsp->epSet.numOfEps, 1);
-    EXPECT_EQ(pRsp->epSet.port[0], 9022);
+    EXPECT_EQ(pRsp->epSet.port[0], 9031);
     EXPECT_STREQ(pRsp->epSet.fqdn[0], "localhost");
   }
 }

source/dnode/mnode/impl/test/show/show.cpp

@@ -63,7 +63,7 @@ TEST_F(MndTestShow, 03_ShowMsg_Conn) {
 
   test.SendShowMetaReq(TSDB_MGMT_TABLE_CONNS, "");
 
-  STableMetaMsg* pMeta = test.GetShowMeta();
+  STableMetaRsp* pMeta = test.GetShowMeta();
   EXPECT_STREQ(pMeta->tbFname, "show connections");
   EXPECT_EQ(pMeta->numOfTags, 0);
   EXPECT_EQ(pMeta->numOfColumns, 7);

source/dnode/mnode/impl/test/stb/stb.cpp

@@ -27,9 +27,9 @@ Testbase MndTestStb::test;
 
 TEST_F(MndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) {
   {
-    int32_t contLen = sizeof(SCreateDbMsg);
+    int32_t contLen = sizeof(SCreateDbReq);
 
-    SCreateDbMsg* pReq = (SCreateDbMsg*)rpcMallocCont(contLen);
+    SCreateDbReq* pReq = (SCreateDbReq*)rpcMallocCont(contLen);
     strcpy(pReq->db, "1.d1");
     pReq->numOfVgroups = htonl(2);
     pReq->cacheBlockSize = htonl(16);
@@ -59,9 +59,9 @@ TEST_F(MndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) {
   {
     int32_t cols = 2;
     int32_t tags = 3;
-    int32_t contLen = (tags + cols) * sizeof(SSchema) + sizeof(SCreateStbMsg);
+    int32_t contLen = (tags + cols) * sizeof(SSchema) + sizeof(SMCreateStbReq);
 
-    SCreateStbMsg* pReq = (SCreateStbMsg*)rpcMallocCont(contLen);
+    SMCreateStbReq* pReq = (SMCreateStbReq*)rpcMallocCont(contLen);
     strcpy(pReq->name, "1.d1.stb");
     pReq->numOfTags = htonl(tags);
     pReq->numOfColumns = htonl(cols);
@@ -123,16 +123,16 @@ TEST_F(MndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) {
 
   // ----- meta ------
   {
-    int32_t contLen = sizeof(STableInfoMsg);
+    int32_t contLen = sizeof(STableInfoReq);
 
-    STableInfoMsg* pReq = (STableInfoMsg*)rpcMallocCont(contLen);
+    STableInfoReq* pReq = (STableInfoReq*)rpcMallocCont(contLen);
     strcpy(pReq->tableFname, "1.d1.stb");
 
     SRpcMsg* pMsg = test.SendReq(TDMT_MND_STB_META, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
 
-    STableMetaMsg* pRsp = (STableMetaMsg*)pMsg->pCont;
+    STableMetaRsp* pRsp = (STableMetaRsp*)pMsg->pCont;
     pRsp->numOfTags = htonl(pRsp->numOfTags);
     pRsp->numOfColumns = htonl(pRsp->numOfColumns);
     pRsp->sversion = htonl(pRsp->sversion);
@@ -214,9 +214,9 @@ TEST_F(MndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) {
   CheckInt32(3);
 
   {
-    int32_t contLen = sizeof(SDropStbMsg);
+    int32_t contLen = sizeof(SMDropStbReq);
 
-    SDropStbMsg* pReq = (SDropStbMsg*)rpcMallocCont(contLen);
+    SMDropStbReq* pReq = (SMDropStbReq*)rpcMallocCont(contLen);
     strcpy(pReq->name, "1.d1.stb");
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_STB, pReq, contLen);

source/dnode/vnode/impl/inc/vnodeDef.h

@@ -57,6 +57,8 @@ typedef struct SVnodeMgr {
   pthread_cond_t  hasTask;
   TD_DLIST(SVnodeTask) queue;
   // For vnode Mgmt
+  SDnode*           pDnode;
+  PutReqToVQueryQFp putReqToVQueryQFp;
 } SVnodeMgr;
 
 extern SVnodeMgr vnodeMgr;
@@ -75,10 +77,13 @@ struct SVnode {
   SVnodeFS*   pFs;
   tsem_t      canCommit;
   SQHandle*   pQuery;
+  SDnode*     pDnode;
 };
 
 int vnodeScheduleTask(SVnodeTask* task);
 
+int32_t vnodePutReqToVQueryQ(SVnode *pVnode, struct SRpcMsg *pReq);
+
 #ifdef __cplusplus
 }
 #endif

source/dnode/vnode/impl/inc/vnodeRequest.h

@@ -22,9 +22,9 @@
 extern "C" {
 #endif
 
-// SVDropTableReq
-// int   vnodeBuildDropTableReq(void **buf, const SVDropTableReq *pReq);
-// void *vnodeParseDropTableReq(void *buf, SVDropTableReq *pReq);
+// SVDropTbReq
+// int   vnodeBuildDropTableReq(void **buf, const SVDropTbReq *pReq);
+// void *vnodeParseDropTableReq(void *buf, SVDropTbReq *pReq);
 
 #ifdef __cplusplus
 }

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

@@ -15,27 +15,29 @@
 
 #include "vnodeDef.h"
 
-static SVnode *vnodeNew(const char *path, const SVnodeCfg *pVnodeCfg, int32_t vid);
+static SVnode *vnodeNew(const char *path, const SVnodeCfg *pVnodeCfg);
 static void    vnodeFree(SVnode *pVnode);
 static int     vnodeOpenImpl(SVnode *pVnode);
 static void    vnodeCloseImpl(SVnode *pVnode);
 
-SVnode *vnodeOpen(const char *path, const SVnodeCfg *pVnodeCfg, int32_t vid) {
+SVnode *vnodeOpen(const char *path, const SVnodeCfg *pVnodeCfg) {
   SVnode *pVnode = NULL;
 
   // Set default options
-  //if (pVnodeCfg == NULL) {
-    pVnodeCfg = &defaultVnodeOptions;
-  //}
+  SVnodeCfg cfg = defaultVnodeOptions;
+  if (pVnodeCfg != NULL) {
+    cfg.vgId = pVnodeCfg->vgId;
+    cfg.pDnode = pVnodeCfg->pDnode;
+  }
 
   // Validate options
-  if (vnodeValidateOptions(pVnodeCfg) < 0) {
+  if (vnodeValidateOptions(&cfg) < 0) {
     // TODO
     return NULL;
   }
 
   // Create the handle
-  pVnode = vnodeNew(path, pVnodeCfg, vid);
+  pVnode = vnodeNew(path, &cfg);
   if (pVnode == NULL) {
     // TODO: handle error
     return NULL;
@@ -62,7 +64,7 @@ void vnodeClose(SVnode *pVnode) {
 void vnodeDestroy(const char *path) { taosRemoveDir(path); }
 
 /* ------------------------ STATIC METHODS ------------------------ */
-static SVnode *vnodeNew(const char *path, const SVnodeCfg *pVnodeCfg, int32_t vid) {
+static SVnode *vnodeNew(const char *path, const SVnodeCfg *pVnodeCfg) {
   SVnode *pVnode = NULL;
 
   pVnode = (SVnode *)calloc(1, sizeof(*pVnode));
@@ -71,7 +73,8 @@ static SVnode *vnodeNew(const char *path, const SVnodeCfg *pVnodeCfg, int32_t vi
     return NULL;
   }
 
-  pVnode->vgId = vid;
+  pVnode->vgId = pVnodeCfg->vgId;
+  pVnode->pDnode = pVnodeCfg->pDnode;
   pVnode->path = strdup(path);
   vnodeOptionsCopy(&(pVnode->config), pVnodeCfg);
 

source/dnode/vnode/impl/src/vnodeMgr.c

@@ -19,17 +19,18 @@ SVnodeMgr vnodeMgr = {.vnodeInitFlag = TD_MOD_UNINITIALIZED};
 
 static void* loop(void* arg);
 
-int vnodeInit(uint16_t nthreads) {
+int vnodeInit(const SVnodeOpt *pOption) {
   if (TD_CHECK_AND_SET_MODE_INIT(&(vnodeMgr.vnodeInitFlag)) == TD_MOD_INITIALIZED) {
     return 0;
   }
 
   vnodeMgr.stop = false;
+  vnodeMgr.putReqToVQueryQFp = pOption->putReqToVQueryQFp;
 
   // Start commit handers
-  if (nthreads > 0) {
-    vnodeMgr.nthreads = nthreads;
-    vnodeMgr.threads = (pthread_t*)calloc(nthreads, sizeof(pthread_t));
+  if (pOption->nthreads > 0) {
+    vnodeMgr.nthreads = pOption->nthreads;
+    vnodeMgr.threads = (pthread_t*)calloc(pOption->nthreads, sizeof(pthread_t));
     if (vnodeMgr.threads == NULL) {
       return -1;
     }
@@ -38,7 +39,7 @@ int vnodeInit(uint16_t nthreads) {
     pthread_cond_init(&(vnodeMgr.hasTask), NULL);
     TD_DLIST_INIT(&(vnodeMgr.queue));
 
-    for (uint16_t i = 0; i < nthreads; i++) {
+    for (uint16_t i = 0; i < pOption->nthreads; i++) {
       pthread_create(&(vnodeMgr.threads[i]), NULL, loop, NULL);
       pthread_setname_np(vnodeMgr.threads[i], "VND Commit Thread");
     }
@@ -89,6 +90,14 @@ int vnodeScheduleTask(SVnodeTask* pTask) {
   return 0;
 }
 
+int32_t vnodePutReqToVQueryQ(SVnode* pVnode, struct SRpcMsg* pReq) {
+  if (pVnode == NULL || pVnode->pDnode == NULL || vnodeMgr.putReqToVQueryQFp == NULL) {
+    terrno = TSDB_CODE_VND_APP_ERROR;
+    return -1;
+  }
+  return (*vnodeMgr.putReqToVQueryQFp)(pVnode->pDnode, pReq);
+}
+
 /* ------------------------ STATIC METHODS ------------------------ */
 static void* loop(void* arg) {
   SVnodeTask* pTask;

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

@@ -23,7 +23,7 @@ int vnodeQueryOpen(SVnode *pVnode) { return qWorkerInit(NULL, &pVnode->pQuery);
 
 int vnodeProcessQueryReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
   vTrace("query message is processed");
-  return qWorkerProcessQueryMsg(pVnode, pVnode->pQuery, pMsg);
+  return qWorkerProcessQueryMsg(pVnode->pTsdb, pVnode->pQuery, pMsg);
 }
 
 int vnodeProcessFetchReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
@@ -53,14 +53,14 @@ int vnodeProcessFetchReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
 }
 
 static int vnodeGetTableMeta(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
-  STableInfoMsg * pReq = (STableInfoMsg *)(pMsg->pCont);
+  STableInfoReq * pReq = (STableInfoReq *)(pMsg->pCont);
   STbCfg *        pTbCfg = NULL;
   STbCfg *        pStbCfg = NULL;
   tb_uid_t        uid;
   int32_t         nCols;
   int32_t         nTagCols;
   SSchemaWrapper *pSW;
-  STableMetaMsg * pTbMetaMsg = NULL;
+  STableMetaRsp * pTbMetaMsg = NULL;
   SSchema *       pTagSchema;
   SRpcMsg         rpcMsg;
   int             msgLen = 0;
@@ -94,8 +94,8 @@ static int vnodeGetTableMeta(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
     pTagSchema = NULL;
   }
 
-  msgLen = sizeof(STableMetaMsg) + sizeof(SSchema) * (nCols + nTagCols);
-  pTbMetaMsg = (STableMetaMsg *)rpcMallocCont(msgLen);
+  msgLen = sizeof(STableMetaRsp) + sizeof(SSchema) * (nCols + nTagCols);
+  pTbMetaMsg = (STableMetaRsp *)rpcMallocCont(msgLen);
   if (pTbMetaMsg == NULL) {
     goto _exit;
   }
@@ -167,7 +167,7 @@ static int32_t vnodeGetTableList(SVnode *pVnode, SRpcMsg *pMsg) {
   //  SVShowTablesFetchReq *pFetchReq = pMsg->pCont;
 
   SVShowTablesFetchRsp *pFetchRsp = (SVShowTablesFetchRsp *)rpcMallocCont(sizeof(SVShowTablesFetchRsp) + payloadLen);
-  memset(pFetchRsp, 0, sizeof(struct SVShowTablesFetchRsp) + payloadLen);
+  memset(pFetchRsp, 0, sizeof(SVShowTablesFetchRsp) + payloadLen);
 
   char *p = pFetchRsp->data;
   for (int32_t i = 0; i < numOfTables; ++i) {

source/dnode/vnode/impl/src/vnodeRequest.c

@@ -108,12 +108,12 @@ static void *vnodeParseCreateTableReq(void *buf, SVCreateTableReq *pReq) {
   return buf;
 }
 
-int vnodeBuildDropTableReq(void **buf, const SVDropTableReq *pReq) {
+int vnodeBuildDropTableReq(void **buf, const SVDropTbReq *pReq) {
   // TODO
   return 0;
 }
 
-void *vnodeParseDropTableReq(void *buf, SVDropTableReq *pReq) {
+void *vnodeParseDropTableReq(void *buf, SVDropTbReq *pReq) {
   // TODO
 }
 #endif
\ No newline at end of file

source/dnode/vnode/meta/src/metaIdx.c

@@ -49,9 +49,7 @@ int metaOpenIdx(SMeta *pMeta) {
 
 #ifdef USE_INVERTED_INDEX
   SIndexOpts opts;
-  if (indexOpen(&opts, pMeta->path, &pMeta->pIdx->pIdx) != 0) {
-    return -1;
-  }
+  if (indexOpen(&opts, pMeta->path, &pMeta->pIdx->pIdx) != 0) { return -1; }
 
 #endif
   return 0;
@@ -67,16 +65,14 @@ void metaCloseIdx(SMeta *pMeta) { /* TODO */
 
 #ifdef USE_INVERTED_INDEX
   SIndexOpts opts;
-  if (indexClose(pMeta->pIdx->pIdx) != 0) {
-    return -1;
-  }
+  if (indexClose(pMeta->pIdx->pIdx) != 0) { return -1; }
 
 #endif
 }
 
 int metaSaveTableToIdx(SMeta *pMeta, const STbCfg *pTbCfg) {
 #ifdef USE_INVERTED_INDEX
-  if (pTbCfgs - type == META_CHILD_TABLE) {
+  if (pTbCfgs->type == META_CHILD_TABLE) {
     char    buf[8] = {0};
     int16_t colId = (kvRowColIdx(pTbCfg->ctbCfg.pTag))[0].colId;
     sprintf(buf, "%d", colId);  // colname

source/dnode/vnode/tsdb/CMakeLists.txt

@@ -13,6 +13,7 @@ else(0)
         "src/tsdbReadImpl.c"
         "src/tsdbFile.c"
         "src/tsdbFS.c"
+        "src/tsdbRead.c"
     )
 endif(0)
 

source/dnode/vnode/tsdb/inc/tsdbMemTable.h

@@ -54,7 +54,7 @@ typedef struct STsdbMemTable {
 
 STsdbMemTable *tsdbNewMemTable(STsdb *pTsdb);
 void           tsdbFreeMemTable(STsdb *pTsdb, STsdbMemTable *pMemTable);
-int            tsdbMemTableInsert(STsdb *pTsdb, STsdbMemTable *pMemTable, SSubmitMsg *pMsg, SShellSubmitRspMsg *pRsp);
+int            tsdbMemTableInsert(STsdb *pTsdb, STsdbMemTable *pMemTable, SSubmitMsg *pMsg, SShellSubmitRsp *pRsp);
 int tsdbLoadDataFromCache(STable *pTable, SSkipListIterator *pIter, TSKEY maxKey, int maxRowsToRead, SDataCols *pCols,
                           TKEY *filterKeys, int nFilterKeys, bool keepDup, SMergeInfo *pMergeInfo);
 

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

@@ -1253,7 +1253,7 @@ int tsdbWriteBlockImpl(STsdb *pRepo, STable *pTable, SDFile *pDFile, SDataCols *
   pBlock->keyFirst = dataColsKeyFirst(pDataCols);
   pBlock->keyLast = dataColsKeyLast(pDataCols);
 
-  tsdbDebug("vgId:%d tid:%d a block of data is written to file %s, offset %" PRId64
+  tsdbDebug("vgId:%d uid:%"PRId64" a block of data is written to file %s, offset %" PRId64
             " numOfRows %d len %d numOfCols %" PRId16 " keyFirst %" PRId64 " keyLast %" PRId64,
             REPO_ID(pRepo), TABLE_TID(pTable), TSDB_FILE_FULL_NAME(pDFile), offset, rowsToWrite, pBlock->len,
             pBlock->numOfCols, pBlock->keyFirst, pBlock->keyLast);

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

@@ -73,7 +73,7 @@ void tsdbFreeMemTable(STsdb *pTsdb, STsdbMemTable *pMemTable) {
   }
 }
 
-int tsdbMemTableInsert(STsdb *pTsdb, STsdbMemTable *pMemTable, SSubmitMsg *pMsg, SShellSubmitRspMsg *pRsp) {
+int tsdbMemTableInsert(STsdb *pTsdb, STsdbMemTable *pMemTable, SSubmitMsg *pMsg, SShellSubmitRsp *pRsp) {
   SSubmitBlk *   pBlock = NULL;
   SSubmitMsgIter msgIter = {0};
   int32_t        affectedrows = 0, numOfRows = 0;

source/libs/executor/CMakeLists.txt

 aux_source_directory(src EXECUTOR_SRC)
-add_library(executor ${EXECUTOR_SRC})
+#add_library(executor ${EXECUTOR_SRC})
+
+
+#target_link_libraries(
+#        executor
+#        PRIVATE os util common function parser planner qcom tsdb
+#)
+
+add_library(executor STATIC ${EXECUTOR_SRC})
+#set_target_properties(executor PROPERTIES
+#        IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/libexecutor.a"
+#        INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_SOURCE_DIR}/include/libs/executor"
+#        )
+target_link_libraries(executor
+            PRIVATE os util common function parser planner qcom tsdb
+        )
+
 target_include_directories(
-    executor
-    PUBLIC "${CMAKE_SOURCE_DIR}/include/libs/executor"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+        executor
+        PUBLIC "${CMAKE_SOURCE_DIR}/include/libs/executor"
+        PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
 
-target_link_libraries(
-        executor
-        PRIVATE os util common function parser planner qcom
-)
+#if(${BUILD_TEST})
+    ADD_SUBDIRECTORY(test)
+#endif(${BUILD_TEST})
\ No newline at end of file
\ No newline at end of file

source/libs/executor/inc/dataSinkInt.h

@@ -31,10 +31,10 @@ typedef struct SDataSinkManager {
   pthread_mutex_t mutex;
 } SDataSinkManager;
 
-typedef int32_t (*FPutDataBlock)(struct SDataSinkHandle* pHandle, const SInputData* pInput, int32_t* pStatus);
-typedef void (*FEndPut)(struct SDataSinkHandle* pHandle);
-typedef int32_t (*FGetDataLength)(struct SDataSinkHandle* pHandle, int32_t* pStatus);
-typedef int32_t (*FGetDataBlock)(struct SDataSinkHandle* pHandle, SOutPutData* pOutput, int32_t* pStatus);
+typedef int32_t (*FPutDataBlock)(struct SDataSinkHandle* pHandle, const SInputData* pInput, bool* pContinue);
+typedef void (*FEndPut)(struct SDataSinkHandle* pHandle, int64_t useconds);
+typedef void (*FGetDataLength)(struct SDataSinkHandle* pHandle, int32_t* pLen, bool* pQueryEnd);
+typedef int32_t (*FGetDataBlock)(struct SDataSinkHandle* pHandle, SOutputData* pOutput);
 typedef int32_t (*FDestroyDataSinker)(struct SDataSinkHandle* pHandle);
 
 typedef struct SDataSinkHandle {

source/libs/executor/inc/executil.h

@@ -38,7 +38,7 @@
 #define GET_RES_WINDOW_KEY_LEN(_l) ((_l) + sizeof(uint64_t))
 #define GET_RES_EXT_WINDOW_KEY_LEN(_l) ((_l) + sizeof(uint64_t) + POINTER_BYTES)
 
-#define GET_QID(_r)  (((SQInfo*)((_r)->qinfo))->qId)
+#define GET_TASKID(_t)  (((SExecTaskInfo*)(_t))->id.queryId)
 
 #define curTimeWindowIndex(_winres)        ((_winres)->curIndex)
 
@@ -157,6 +157,6 @@ int32_t getNumOfTotalRes(SGroupResInfo* pGroupResInfo);
 
 int32_t mergeIntoGroupResult(SGroupResInfo* pGroupResInfo, struct STaskRuntimeEnv *pRuntimeEnv, int32_t* offset);
 
-int32_t initUdfInfo(struct SUdfInfo* pUdfInfo);
+//int32_t initUdfInfo(struct SUdfInfo* pUdfInfo);
 
 #endif  // TDENGINE_QUERYUTIL_H

source/libs/executor/inc/executorInt.h

@@ -20,6 +20,7 @@
 extern "C" {
 #endif
 
+
 #ifdef __cplusplus
 }
 #endif

source/libs/executor/inc/executorimpl.h

@@ -20,24 +20,19 @@
 #include "ttszip.h"
 #include "tvariant.h"
 
-#include "thash.h"
+#include "dataSinkMgt.h"
 #include "executil.h"
+#include "planner.h"
 #include "taosdef.h"
 #include "tarray.h"
 #include "tfilter.h"
+#include "thash.h"
 #include "tlockfree.h"
 #include "tpagedfile.h"
-#include "planner.h"
-
+#include "executor.h"
 
 struct SColumnFilterElem;
 
-typedef struct {
-  uint32_t  numOfTables;
-  SArray   *pGroupList;
-  SHashObj *map;  // speedup acquire the tableQueryInfo by table uid
-} STableGroupInfo;
-
 typedef int32_t (*__block_search_fn_t)(char* data, int32_t num, int64_t key, int32_t order);
 
 #define IS_QUERY_KILLED(_q) ((_q)->code == TSDB_CODE_TSC_QUERY_CANCELLED)
@@ -51,19 +46,19 @@ typedef int32_t (*__block_search_fn_t)(char* data, int32_t num, int64_t key, int
 #define NEEDTO_COMPRESS_QUERY(size) ((size) > tsCompressColData? 1 : 0)
 
 enum {
-  // when query starts to execute, this status will set
-      QUERY_NOT_COMPLETED = 0x1u,
+  // when this task starts to execute, this status will set
+  TASK_NOT_COMPLETED = 0x1u,
 
-  /* query is over
+  /* Task is over
    * 1. this status is used in one row result query process, e.g., count/sum/first/last/ avg...etc.
    * 2. when all data within queried time window, it is also denoted as query_completed
    */
-      QUERY_COMPLETED = 0x2u,
+  TASK_COMPLETED = 0x2u,
 
   /* when the result is not completed return to client, this status will be
    * usually used in case of interval query with interpolation option
    */
-      QUERY_OVER = 0x4u,
+  TASK_OVER = 0x4u,
 };
 
 typedef struct SResultRowCell {
@@ -129,6 +124,7 @@ typedef struct {
 } SOperatorProfResult;
 
 typedef struct STaskCostInfo {
+  int64_t   created;
   int64_t   start;
   int64_t   end;
 
@@ -246,13 +242,14 @@ typedef struct STaskIdInfo {
   uint64_t       taskId;     // this is a subplan id
 } STaskIdInfo;
 
-typedef struct STaskInfo {
+typedef struct SExecTaskInfo {
   STaskIdInfo     id;
   char           *content;
   uint32_t        status;
   STimeWindow     window;
   STaskCostInfo   cost;
   int64_t         owner;       // if it is in execution
+  int32_t         code;
 
   STableGroupInfo tableqinfoGroupInfo;  // this is a group array list, including SArray<STableQueryInfo*> structure
   pthread_mutex_t lock;        // used to synchronize the rsp/query threads
@@ -260,8 +257,10 @@ typedef struct STaskInfo {
 //  int32_t          dataReady;   // denote if query result is ready or not
 //  void*            rspContext;  // response context
   char           *sql;         // query sql string
-  jmp_buf         env;
-} STaskInfo;
+  jmp_buf         env;         //
+  DataSinkHandle  dsHandle;
+  struct SOperatorInfo  *pRoot;
+} SExecTaskInfo;
 
 typedef struct STaskRuntimeEnv {
   jmp_buf               env;
@@ -269,7 +268,7 @@ typedef struct STaskRuntimeEnv {
   uint32_t              status;           // query status
   void*                 qinfo;
   uint8_t               scanFlag;         // denotes reversed scan of data or not
-  void*                 pQueryHandle;
+  void*                 pTsdbReadHandle;
 
   int32_t               prevGroupId;      // previous executed group id
   bool                  enableGroupData;
@@ -314,8 +313,8 @@ typedef struct SOperatorInfo {
   char                 *name;          // name, used to show the query execution plan
   void                 *info;          // extension attribution
   SExprInfo            *pExpr;
-  STaskRuntimeEnv      *pRuntimeEnv;
-  STaskInfo            *pTaskInfo;
+  STaskRuntimeEnv      *pRuntimeEnv;   // todo remove it
+  SExecTaskInfo        *pTaskInfo;
 
   struct SOperatorInfo **pDownstream;  // downstram pointer list
   int32_t               numOfDownstream; // number of downstream. The value is always ONE expect for join operator
@@ -376,7 +375,7 @@ typedef struct STaskParam {
 } STaskParam;
 
 typedef struct STableScanInfo {
-  void           *pQueryHandle;
+  void           *pTsdbReadHandle;
   int32_t         numOfBlocks;
   int32_t         numOfSkipped;
   int32_t         numOfBlockStatis;
@@ -544,7 +543,7 @@ typedef struct SOrderOperatorInfo {
 void appendUpstream(SOperatorInfo* p, SOperatorInfo* pUpstream);
 
 SOperatorInfo* createDataBlocksOptScanInfo(void* pTsdbQueryHandle, STaskRuntimeEnv* pRuntimeEnv, int32_t repeatTime, int32_t reverseTime);
-SOperatorInfo* createTableScanOperator(void* pTsdbQueryHandle, int32_t order, int32_t numOfOutput, int32_t repeatTime);
+SOperatorInfo* createTableScanOperator(void* pTsdbQueryHandle, int32_t order, int32_t numOfOutput, int32_t repeatTime, SExecTaskInfo* pTaskInfo);
 SOperatorInfo* createTableSeqScanOperator(void* pTsdbQueryHandle, STaskRuntimeEnv* pRuntimeEnv);
 
 SOperatorInfo* createAggregateOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
@@ -572,11 +571,11 @@ SOperatorInfo* createFilterOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SOperatorI
 SOperatorInfo* createJoinOperatorInfo(SOperatorInfo** pUpstream, int32_t numOfUpstream, SSchema* pSchema, int32_t numOfOutput);
 SOperatorInfo* createOrderOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, SOrder* pOrderVal);
 
-SSDataBlock* doGlobalAggregate(void* param, bool* newgroup);
-SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup);
-SSDataBlock* doSLimit(void* param, bool* newgroup);
+//SSDataBlock* doGlobalAggregate(void* param, bool* newgroup);
+//SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup);
+//SSDataBlock* doSLimit(void* param, bool* newgroup);
 
-int32_t doCreateFilterInfo(SColumnInfo* pCols, int32_t numOfCols, int32_t numOfFilterCols, SSingleColumnFilterInfo** pFilterInfo, uint64_t qId);
+//int32_t doCreateFilterInfo(SColumnInfo* pCols, int32_t numOfCols, int32_t numOfFilterCols, SSingleColumnFilterInfo** pFilterInfo, uint64_t qId);
 void doSetFilterColumnInfo(SSingleColumnFilterInfo* pFilterInfo, int32_t numOfFilterCols, SSDataBlock* pBlock);
 bool doFilterDataBlock(SSingleColumnFilterInfo* pFilterInfo, int32_t numOfFilterCols, int32_t numOfRows, int8_t* p);
 void doCompactSDataBlock(SSDataBlock* pBlock, int32_t numOfRows, int8_t* p);
@@ -593,17 +592,17 @@ void clearOutputBuf(SOptrBasicInfo* pBInfo, int32_t *bufCapacity);
 void copyTsColoum(SSDataBlock* pRes, SQLFunctionCtx* pCtx, int32_t numOfOutput);
 
 void freeParam(STaskParam *param);
-int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, STaskParam* param);
+int32_t convertQueryMsg(SQueryTableReq *pQueryMsg, STaskParam* param);
 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(SQueryTableMsg *pQueryMsg, int32_t numOfOutput, SExprInfo **pExprInfo,
+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(SQueryTableMsg *pQueryMsg, SColIndex *pColIndex, int32_t *code);
-SQInfo *createQInfoImpl(SQueryTableMsg *pQueryMsg, SGroupbyExpr *pGroupbyExpr, SExprInfo *pExprs,
+SGroupbyExpr *createGroupbyExprFromMsg(SQueryTableReq *pQueryMsg, SColIndex *pColIndex, int32_t *code);
+SQInfo *createQInfoImpl(SQueryTableReq *pQueryMsg, SGroupbyExpr *pGroupbyExpr, SExprInfo *pExprs,
                         SExprInfo *pSecExprs, STableGroupInfo *pTableGroupInfo, SColumnInfo* pTagCols, SFilterInfo* pFilters, int32_t vgId, char* sql, uint64_t qId, struct SUdfInfo* pUdfInfo);
 
 int32_t initQInfo(STsBufInfo* pTsBufInfo, void* tsdb, void* sourceOptr, SQInfo* pQInfo, STaskParam* param, char* start,
@@ -617,14 +616,14 @@ STableQueryInfo* createTmpTableQueryInfo(STimeWindow win);
 
 int32_t buildArithmeticExprFromMsg(SExprInfo *pArithExprInfo, void *pQueryMsg);
 
-bool isQueryKilled(SQInfo *pQInfo);
+bool isTaskKilled(SExecTaskInfo *pTaskInfo);
 int32_t checkForQueryBuf(size_t numOfTables);
 bool checkNeedToCompressQueryCol(SQInfo *pQInfo);
 bool doBuildResCheck(SQInfo* pQInfo);
 void setQueryStatus(STaskRuntimeEnv *pRuntimeEnv, int8_t status);
 
 bool onlyQueryTags(STaskAttr* pQueryAttr);
-void destroyUdfInfo(struct SUdfInfo* pUdfInfo);
+//void destroyUdfInfo(struct SUdfInfo* pUdfInfo);
 
 bool isValidQInfo(void *param);
 
@@ -644,5 +643,7 @@ void freeQueryAttr(STaskAttr *pQuery);
 int32_t getMaximumIdleDurationSec();
 
 void doInvokeUdf(struct SUdfInfo* pUdfInfo, SQLFunctionCtx *pCtx, int32_t idx, int32_t type);
+void setTaskStatus(SExecTaskInfo *pTaskInfo, int8_t status);
+int32_t doCreateExecTaskInfo(SSubplan* pPlan, SExecTaskInfo** pTaskInfo, void* readerHandle);
 
 #endif  // TDENGINE_EXECUTORIMPL_H

source/libs/executor/src/dataDispatcher.c

@@ -19,6 +19,7 @@
 #include "tcompression.h"
 #include "tglobal.h"
 #include "tqueue.h"
+#include "executorimpl.h"
 
 #define DATA_META_LENGTH(tables) (sizeof(int32_t) + sizeof(STableIdInfo) * taosHashGetSize(tables) + sizeof(SRetrieveTableRsp))
 
@@ -42,6 +43,8 @@ typedef struct SDataDispatchHandle {
   STaosQueue* pDataBlocks;
   SDataDispatchBuf nextOutput;
   int32_t status;
+  bool queryEnd;
+  int64_t useconds;
   pthread_mutex_t mutex;
 } SDataDispatchHandle;
 
@@ -106,10 +109,14 @@ static void toDataCacheEntry(const SDataDispatchHandle* pHandle, const SInputDat
   SDataCacheEntry* pEntry = (SDataCacheEntry*)pBuf->pData;
   pEntry->compressed = (int8_t)needCompress(pInput->pData, &(pHandle->schema));
   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);
-  pBuf->useSize += (pEntry->compressed ? pEntry->dataLen : pHandle->schema.resultRowSize * pInput->pData->info.rows);
+  if (0 == pEntry->compressed) {
+    pEntry->dataLen = pHandle->schema.resultRowSize * pInput->pData->info.rows;
+  }
+  pBuf->useSize += pEntry->dataLen;
   // todo completed
 }
 
@@ -124,7 +131,9 @@ static bool allocBuf(SDataDispatchHandle* pDispatcher, const SInputData* pInput,
 
 static int32_t updateStatus(SDataDispatchHandle* pDispatcher) {
   pthread_mutex_lock(&pDispatcher->mutex);
-  int32_t status = taosQueueSize(pDispatcher->pDataBlocks) < pDispatcher->pManager->cfg.maxDataBlockNumPerQuery ? DS_CAPACITY_ENOUGH : DS_CAPACITY_FULL;
+  int32_t blockNums = taosQueueSize(pDispatcher->pDataBlocks);
+  int32_t status = (0 == blockNums ? DS_BUF_EMPTY :
+      (blockNums < pDispatcher->pManager->cfg.maxDataBlockNumPerQuery ? DS_BUF_LOW : DS_BUF_FULL));
   pDispatcher->status = status;
   pthread_mutex_unlock(&pDispatcher->mutex);
   return status;
@@ -137,7 +146,7 @@ static int32_t getStatus(SDataDispatchHandle* pDispatcher) {
   return status;
 }
 
-static int32_t putDataBlock(SDataSinkHandle* pHandle, const SInputData* pInput, int32_t* pStatus) {
+static int32_t putDataBlock(SDataSinkHandle* pHandle, const SInputData* pInput, bool* pContinue) {
   SDataDispatchHandle* pDispatcher = (SDataDispatchHandle*)pHandle;
   SDataDispatchBuf* pBuf = taosAllocateQitem(sizeof(SDataDispatchBuf));
   if (NULL == pBuf || !allocBuf(pDispatcher, pInput, pBuf)) {
@@ -145,38 +154,46 @@ static int32_t putDataBlock(SDataSinkHandle* pHandle, const SInputData* pInput,
   }
   toDataCacheEntry(pDispatcher, pInput, pBuf);
   taosWriteQitem(pDispatcher->pDataBlocks, pBuf);
-  *pStatus = updateStatus(pDispatcher);
+  *pContinue = (DS_BUF_LOW == updateStatus(pDispatcher) ? true : false);
   return TSDB_CODE_SUCCESS;
 }
 
-static void endPut(struct SDataSinkHandle* pHandle) {
+static void endPut(struct SDataSinkHandle* pHandle, int64_t useconds) {
   SDataDispatchHandle* pDispatcher = (SDataDispatchHandle*)pHandle;
   pthread_mutex_lock(&pDispatcher->mutex);
-  pDispatcher->status = DS_END;
+  pDispatcher->queryEnd = true;
+  pDispatcher->useconds = useconds;
   pthread_mutex_unlock(&pDispatcher->mutex);
 }
 
-static int32_t getDataLength(SDataSinkHandle* pHandle, int32_t* pStatus) {
+static void getDataLength(SDataSinkHandle* pHandle, int32_t* pLen, bool* pQueryEnd) {
   SDataDispatchHandle* pDispatcher = (SDataDispatchHandle*)pHandle;
   if (taosQueueEmpty(pDispatcher->pDataBlocks)) {
-    *pStatus = getStatus(pDispatcher) ? DS_END : DS_IN_PROCESS;
-    return 0;
+    *pQueryEnd = pDispatcher->queryEnd;
+    *pLen = 0;
+    return;
   }
   SDataDispatchBuf* pBuf = NULL;
   taosReadQitem(pDispatcher->pDataBlocks, (void**)&pBuf);
   memcpy(&pDispatcher->nextOutput, pBuf, sizeof(SDataDispatchBuf));
   taosFreeQitem(pBuf);
-  return ((SDataCacheEntry*)(pDispatcher->nextOutput.pData))->dataLen;
+  *pLen = ((SDataCacheEntry*)(pDispatcher->nextOutput.pData))->dataLen;
 }
 
-static int32_t getDataBlock(SDataSinkHandle* pHandle, SOutPutData* pOutput, int32_t* pStatus) {
+static int32_t getDataBlock(SDataSinkHandle* pHandle, SOutputData* pOutput) {
   SDataDispatchHandle* pDispatcher = (SDataDispatchHandle*)pHandle;
   SDataCacheEntry* pEntry = (SDataCacheEntry*)(pDispatcher->nextOutput.pData);
   memcpy(pOutput->pData, pEntry->data, pEntry->dataLen);
   pOutput->numOfRows = pEntry->numOfRows;
   pOutput->compressed = pEntry->compressed;
   tfree(pDispatcher->nextOutput.pData);  // todo persistent
-  *pStatus = updateStatus(pDispatcher);
+  pOutput->bufStatus = updateStatus(pDispatcher);
+  pthread_mutex_lock(&pDispatcher->mutex);
+  pOutput->queryEnd = pDispatcher->queryEnd;
+  pOutput->needSchedule = false;
+  pOutput->useconds = pDispatcher->useconds;
+  pOutput->precision = pDispatcher->schema.precision;
+  pthread_mutex_unlock(&pDispatcher->mutex);
   return TSDB_CODE_SUCCESS;
 }
 
@@ -200,12 +217,14 @@ int32_t createDataDispatcher(SDataSinkManager* pManager, const SDataSink* pDataS
     return TSDB_CODE_QRY_OUT_OF_MEMORY;
   }
   dispatcher->sink.fPut = putDataBlock;
+  dispatcher->sink.fEndPut = endPut;
   dispatcher->sink.fGetLen = getDataLength;
   dispatcher->sink.fGetData = getDataBlock;
   dispatcher->sink.fDestroy = destroyDataSinker;
   dispatcher->pManager = pManager;
   dispatcher->schema = pDataSink->schema;
-  dispatcher->status = DS_CAPACITY_ENOUGH;
+  dispatcher->status = DS_BUF_EMPTY;
+  dispatcher->queryEnd = false;
   dispatcher->pDataBlocks = taosOpenQueue();
   pthread_mutex_init(&dispatcher->mutex, NULL);
   if (NULL == dispatcher->pDataBlocks) {

source/libs/executor/src/dataSinkMgt.c

@@ -13,6 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "tarray.h"
 #include "dataSinkMgt.h"
 #include "dataSinkInt.h"
 #include "planner.h"
@@ -31,24 +32,24 @@ int32_t dsCreateDataSinker(const struct SDataSink *pDataSink, DataSinkHandle* pH
   return TSDB_CODE_FAILED;
 }
 
-int32_t dsPutDataBlock(DataSinkHandle handle, const SInputData* pInput, int32_t* pStatus) {
+int32_t dsPutDataBlock(DataSinkHandle handle, const SInputData* pInput, bool* pContinue) {
   SDataSinkHandle* pHandleImpl = (SDataSinkHandle*)handle;
-  return pHandleImpl->fPut(pHandleImpl, pInput, pStatus);
+  return pHandleImpl->fPut(pHandleImpl, pInput, pContinue);
 }
 
-void dsEndPut(DataSinkHandle handle) {
+void dsEndPut(DataSinkHandle handle, int64_t useconds) {
   SDataSinkHandle* pHandleImpl = (SDataSinkHandle*)handle;
-  return pHandleImpl->fEndPut(pHandleImpl);
+  return pHandleImpl->fEndPut(pHandleImpl, useconds);
 }
 
-int32_t dsGetDataLength(DataSinkHandle handle, int32_t* pStatus) {
+void dsGetDataLength(DataSinkHandle handle, int32_t* pLen, bool* pQueryEnd) {
   SDataSinkHandle* pHandleImpl = (SDataSinkHandle*)handle;
-  return pHandleImpl->fGetLen(pHandleImpl, pStatus);
+  pHandleImpl->fGetLen(pHandleImpl, pLen, pQueryEnd);
 }
 
-int32_t dsGetDataBlock(DataSinkHandle handle, SOutPutData* pOutput, int32_t* pStatus) {
+int32_t dsGetDataBlock(DataSinkHandle handle, SOutputData* pOutput) {
   SDataSinkHandle* pHandleImpl = (SDataSinkHandle*)handle;
-  return pHandleImpl->fGetData(pHandleImpl, pOutput, pStatus);
+  return pHandleImpl->fGetData(pHandleImpl, pOutput);
 }
 
 void dsScheduleProcess(void* ahandle, void* pItem) {

source/libs/executor/src/executil.c

@@ -547,7 +547,7 @@ static UNUSED_FUNC int32_t mergeIntoGroupResultImpl(STaskRuntimeEnv *pRuntimeEnv
   pTableQueryInfoList = malloc(POINTER_BYTES * size);
 
   if (pTableQueryInfoList == NULL || posList == NULL || pGroupResInfo->pRows == NULL || pGroupResInfo->pRows == NULL) {
-//    qError("QInfo:%"PRIu64" failed alloc memory", GET_QID(pRuntimeEnv));
+//    qError("QInfo:%"PRIu64" failed alloc memory", GET_TASKID(pRuntimeEnv));
     code = TSDB_CODE_QRY_OUT_OF_MEMORY;
     goto _end;
   }
@@ -619,7 +619,7 @@ static UNUSED_FUNC int32_t mergeIntoGroupResultImpl(STaskRuntimeEnv *pRuntimeEnv
 
   int64_t endt = taosGetTimestampMs();
 
-//  qDebug("QInfo:%"PRIx64" result merge completed for group:%d, elapsed time:%" PRId64 " ms", GET_QID(pRuntimeEnv),
+//  qDebug("QInfo:%"PRIx64" result merge completed for group:%d, elapsed time:%" PRId64 " ms", GET_TASKID(pRuntimeEnv),
 //         pGroupResInfo->currentGroup, endt - startt);
 
   _end:
@@ -641,13 +641,13 @@ int32_t mergeIntoGroupResult(SGroupResInfo* pGroupResInfo, STaskRuntimeEnv* pRun
       break;
     }
 
-//    qDebug("QInfo:%"PRIu64" no result in group %d, continue", GET_QID(pRuntimeEnv), pGroupResInfo->currentGroup);
+//    qDebug("QInfo:%"PRIu64" no result in group %d, continue", GET_TASKID(pRuntimeEnv), pGroupResInfo->currentGroup);
     cleanupGroupResInfo(pGroupResInfo);
     incNextGroup(pGroupResInfo);
   }
 
 //  int64_t elapsedTime = taosGetTimestampUs() - st;
-//  qDebug("QInfo:%"PRIu64" merge res data into group, index:%d, total group:%d, elapsed time:%" PRId64 "us", GET_QID(pRuntimeEnv),
+//  qDebug("QInfo:%"PRIu64" merge res data into group, index:%d, total group:%d, elapsed time:%" PRId64 "us", GET_TASKID(pRuntimeEnv),
 //         pGroupResInfo->currentGroup, pGroupResInfo->totalGroup, elapsedTime);
 
   return TSDB_CODE_SUCCESS;

source/libs/executor/src/executorMain.c

@@ -14,10 +14,12 @@
  */
 
 #include "os.h"
+#include "tarray.h"
+#include "dataSinkMgt.h"
+#include "exception.h"
 #include "tcache.h"
 #include "tglobal.h"
 #include "tmsg.h"
-#include "exception.h"
 
 #include "thash.h"
 #include "executorimpl.h"
@@ -66,152 +68,24 @@ void freeParam(STaskParam *param) {
   tfree(param->prevResult);
 }
 
-// todo parse json to get the operator tree.
-
-int32_t qCreateTask(void* tsdb, int32_t vgId, void* pQueryMsg, qTaskInfo_t* pTaskInfo, uint64_t taskId) {
-  assert(pQueryMsg != NULL && tsdb != NULL);
+int32_t qCreateExecTask(void* tsdb, int32_t vgId, SSubplan* pSubplan, qTaskInfo_t* pTaskInfo) {
+  assert(tsdb != NULL && pSubplan != NULL);
+  SExecTaskInfo** pTask = (SExecTaskInfo**)pTaskInfo;
 
-  int32_t code = TSDB_CODE_SUCCESS;
-#if 0
-  STaskParam param = {0};
-  code = convertQueryMsg(pQueryMsg, &param);
+  int32_t code = doCreateExecTaskInfo(pSubplan, pTask, tsdb);
   if (code != TSDB_CODE_SUCCESS) {
-    goto _over;
-  }
-
-  if (pQueryMsg->numOfTables <= 0) {
-    qError("Invalid number of tables to query, numOfTables:%d", pQueryMsg->numOfTables);
-    code = TSDB_CODE_QRY_INVALID_MSG;
-    goto _over;
-  }
-
-  if (param.pTableIdList == NULL || taosArrayGetSize(param.pTableIdList) == 0) {
-    qError("qmsg:%p, SQueryTableMsg wrong format", pQueryMsg);
-    code = TSDB_CODE_QRY_INVALID_MSG;
-    goto _over;
-  }
-
-  SQueriedTableInfo info = { .numOfTags = pQueryMsg->numOfTags, .numOfCols = pQueryMsg->numOfCols, .colList = pQueryMsg->tableCols};
-  if ((code = createQueryFunc(&info, pQueryMsg->numOfOutput, &param.pExprs, param.pExpr, param.pTagColumnInfo,
-                              pQueryMsg->queryType, pQueryMsg, param.pUdfInfo)) != TSDB_CODE_SUCCESS) {
-    goto _over;
-  }
-
-  if (param.pSecExpr != NULL) {
-    if ((code = createIndirectQueryFuncExprFromMsg(pQueryMsg, pQueryMsg->secondStageOutput, &param.pSecExprs, param.pSecExpr, param.pExprs, param.pUdfInfo)) != TSDB_CODE_SUCCESS) {
-      goto _over;
-    }
-  }
-
-  if (param.colCond != NULL) {
-    if ((code = createQueryFilter(param.colCond, pQueryMsg->colCondLen, &param.pFilters)) != TSDB_CODE_SUCCESS) {
-      goto _over;
-    }
-  }
-
-  param.pGroupbyExpr = createGroupbyExprFromMsg(pQueryMsg, param.pGroupColIndex, &code);
-  if ((param.pGroupbyExpr == NULL && pQueryMsg->numOfGroupCols != 0) || code != TSDB_CODE_SUCCESS) {
-    goto _over;
-  }
-
-  bool isSTableQuery = false;
-  STableGroupInfo tableGroupInfo = {0};
-  int64_t st = taosGetTimestampUs();
-
-  if (TSDB_QUERY_HAS_TYPE(pQueryMsg->queryType, TSDB_QUERY_TYPE_TABLE_QUERY)) {
-    STableIdInfo *id = taosArrayGet(param.pTableIdList, 0);
-
-    qDebug("qmsg:%p query normal table, uid:%"PRId64", tid:%d", pQueryMsg, id->uid, id->tid);
-    if ((code = tsdbGetOneTableGroup(tsdb, id->uid, pQueryMsg->window.skey, &tableGroupInfo)) != TSDB_CODE_SUCCESS) {
-      goto _over;
-    }
-  } else if (TSDB_QUERY_HAS_TYPE(pQueryMsg->queryType, TSDB_QUERY_TYPE_MULTITABLE_QUERY|TSDB_QUERY_TYPE_STABLE_QUERY)) {
-    isSTableQuery = true;
-
-    // also note there's possibility that only one table in the super table
-    if (!TSDB_QUERY_HAS_TYPE(pQueryMsg->queryType, TSDB_QUERY_TYPE_MULTITABLE_QUERY)) {
-      STableIdInfo *id = taosArrayGet(param.pTableIdList, 0);
-
-      // group by normal column, do not pass the group by condition to tsdb to group table into different group
-      int32_t numOfGroupByCols = pQueryMsg->numOfGroupCols;
-      if (pQueryMsg->numOfGroupCols == 1 && !TSDB_COL_IS_TAG(param.pGroupColIndex->flag)) {
-        numOfGroupByCols = 0;
-      }
-
-      qDebug("qmsg:%p query stable, uid:%"PRIu64", tid:%d", pQueryMsg, id->uid, id->tid);
-      code = tsdbQuerySTableByTagCond(tsdb, id->uid, pQueryMsg->window.skey, param.tagCond, pQueryMsg->tagCondLen,
-                                      pQueryMsg->tagNameRelType, param.tbnameCond, &tableGroupInfo, param.pGroupColIndex, numOfGroupByCols);
-
-      if (code != TSDB_CODE_SUCCESS) {
-        qError("qmsg:%p failed to query stable, reason: %s", pQueryMsg, tstrerror(code));
-        goto _over;
-      }
-    } else {
-      code = tsdbGetTableGroupFromIdList(tsdb, param.pTableIdList, &tableGroupInfo);
-      if (code != TSDB_CODE_SUCCESS) {
-        goto _over;
-      }
-
-      qDebug("qmsg:%p query on %u tables in one group from client", pQueryMsg, tableGroupInfo.numOfTables);
-    }
-
-    int64_t el = taosGetTimestampUs() - st;
-    qDebug("qmsg:%p tag filter completed, numOfTables:%u, elapsed time:%"PRId64"us", pQueryMsg, tableGroupInfo.numOfTables, el);
-  } else {
-    assert(0);
+    goto _error;
   }
 
-  code = checkForQueryBuf(tableGroupInfo.numOfTables);
-  if (code != TSDB_CODE_SUCCESS) {  // not enough query buffer, abort
-    goto _over;
-  }
-
-  assert(pQueryMsg->stableQuery == isSTableQuery);
-  (*pTaskInfo) = createQInfoImpl(pQueryMsg, param.pGroupbyExpr, param.pExprs, param.pSecExprs, &tableGroupInfo,
-                              param.pTagColumnInfo, param.pFilters, vgId, param.sql, qId, param.pUdfInfo);
-
-  param.sql    = NULL;
-  param.pExprs = NULL;
-  param.pSecExprs = NULL;
-  param.pGroupbyExpr = NULL;
-  param.pTagColumnInfo = NULL;
-  param.pFilters = NULL;
-
-  if ((*pTaskInfo) == NULL) {
-    code = TSDB_CODE_QRY_OUT_OF_MEMORY;
-    goto _over;
-  }
-  param.pUdfInfo = NULL;
-
-  code = initQInfo(&pQueryMsg->tsBuf, tsdb, NULL, *pTaskInfo, &param, (char*)pQueryMsg, pQueryMsg->prevResultLen, NULL);
-
-  _over:
-  if (param.pGroupbyExpr != NULL) {
-    taosArrayDestroy(param.pGroupbyExpr->columnInfo);
-  }
-
-  tfree(param.colCond);
-  
-  destroyUdfInfo(param.pUdfInfo);
-
-  taosArrayDestroy(param.pTableIdList);
-  param.pTableIdList = NULL;
-
-  freeParam(&param);
-
-  for (int32_t i = 0; i < pQueryMsg->numOfCols; i++) {
-    SColumnInfo* column = pQueryMsg->tableCols + i;
-    freeColumnFilterInfo(column->flist.filterInfo, column->flist.numOfFilters);
-  }
-
-  filterFreeInfo(param.pFilters);
-
-  //pTaskInfo already freed in initQInfo, but *pTaskInfo may not pointer to null;
+  SDataSinkMgtCfg cfg = {.maxDataBlockNum = 1000, .maxDataBlockNumPerQuery = 100};
+  code = dsDataSinkMgtInit(&cfg);
   if (code != TSDB_CODE_SUCCESS) {
-    *pTaskInfo = NULL;
+    goto _error;
   }
-#endif
 
+  code = dsCreateDataSinker(pSubplan->pDataSink, &(*pTask)->dsHandle);
+
+  _error:
   // if failed to add ref for all tables in this query, abort current query
   return code;
 }
@@ -250,7 +124,7 @@ int waitMoment(SQInfo* pQInfo){
       while(used_ms < ms) {
         taosMsleep(1000);
         used_ms += 1000;
-        if(isQueryKilled(pQInfo)){
+        if(isTaskKilled(pQInfo)){
           printf("test check query is canceled, sleep break.%s\n", pQInfo->sql);
           break;
         }
@@ -261,68 +135,80 @@ int waitMoment(SQInfo* pQInfo){
 }
 #endif
 
-bool qExecTask(qTaskInfo_t qinfo, uint64_t *qId) {
-  SQInfo *pQInfo = (SQInfo *)qinfo;
-  assert(pQInfo && pQInfo->signature == pQInfo);
-  int64_t threadId = taosGetSelfPthreadId();
+int32_t qExecTask(qTaskInfo_t tinfo, DataSinkHandle* handle) {
+  SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo;
+  int64_t        threadId = taosGetSelfPthreadId();
 
   int64_t curOwner = 0;
-  if ((curOwner = atomic_val_compare_exchange_64(&pQInfo->owner, 0, threadId)) != 0) {
-    qError("QInfo:0x%"PRIx64"-%p qhandle is now executed by thread:%p", pQInfo->qId, pQInfo, (void*) curOwner);
-    pQInfo->code = TSDB_CODE_QRY_IN_EXEC;
-    return false;
+  if ((curOwner = atomic_val_compare_exchange_64(&pTaskInfo->owner, 0, threadId)) != 0) {
+    qError("QInfo:0x%" PRIx64 "-%p qhandle is now executed by thread:%p", GET_TASKID(pTaskInfo), pTaskInfo,
+           (void*)curOwner);
+    pTaskInfo->code = TSDB_CODE_QRY_IN_EXEC;
+    return pTaskInfo->code;
   }
 
-  *qId = pQInfo->qId;
-  if(pQInfo->startExecTs == 0)
-    pQInfo->startExecTs = taosGetTimestampMs();
-
-  if (isQueryKilled(pQInfo)) {
-    qDebug("QInfo:0x%"PRIx64" it is already killed, abort", pQInfo->qId);
-    return doBuildResCheck(pQInfo);
+  if (pTaskInfo->cost.start == 0) {
+    pTaskInfo->cost.start = taosGetTimestampMs();
   }
 
-  STaskRuntimeEnv* pRuntimeEnv = &pQInfo->runtimeEnv;
-  if (pRuntimeEnv->tableqinfoGroupInfo.numOfTables == 0) {
-    qDebug("QInfo:0x%"PRIx64" no table exists for query, abort", pQInfo->qId);
-//    setTaskStatus(pRuntimeEnv, QUERY_COMPLETED);
-    return doBuildResCheck(pQInfo);
+  if (isTaskKilled(pTaskInfo)) {
+    qDebug("QInfo:0x%" PRIx64 " it is already killed, abort", GET_TASKID(pTaskInfo));
+    return pTaskInfo->code;
   }
 
+  //  STaskRuntimeEnv* pRuntimeEnv = &pTaskInfo->runtimeEnv;
+  //  if (pTaskInfo->tableqinfoGroupInfo.numOfTables == 0) {
+  //    qDebug("QInfo:0x%"PRIx64" no table exists for query, abort", GET_TASKID(pTaskInfo));
+  //    setTaskStatus(pTaskInfo, TASK_COMPLETED);
+  //    return doBuildResCheck(pTaskInfo);
+  //  }
+
   // error occurs, record the error code and return to client
-  int32_t ret = setjmp(pQInfo->runtimeEnv.env);
+  int32_t ret = setjmp(pTaskInfo->env);
   if (ret != TSDB_CODE_SUCCESS) {
-    publishQueryAbortEvent(pQInfo, ret);
-    pQInfo->code = ret;
-    qDebug("QInfo:0x%"PRIx64" query abort due to error/cancel occurs, code:%s", pQInfo->qId, tstrerror(pQInfo->code));
-    return doBuildResCheck(pQInfo);
+    publishQueryAbortEvent(pTaskInfo, ret);
+    pTaskInfo->code = ret;
+    qDebug("QInfo:0x%" PRIx64 " query abort due to error/cancel occurs, code:%s", GET_TASKID(pTaskInfo), tstrerror(pTaskInfo->code));
+    return pTaskInfo->code;
   }
 
-  qDebug("QInfo:0x%"PRIx64" query task is launched", pQInfo->qId);
+  qDebug("QInfo:0x%" PRIx64 " query task is launched", GET_TASKID(pTaskInfo));
 
   bool newgroup = false;
-  publishOperatorProfEvent(pRuntimeEnv->proot, QUERY_PROF_BEFORE_OPERATOR_EXEC);
+  publishOperatorProfEvent(pTaskInfo->pRoot, QUERY_PROF_BEFORE_OPERATOR_EXEC);
+  int64_t st = 0;
 
-  int64_t st = taosGetTimestampUs();
-  pRuntimeEnv->outputBuf = pRuntimeEnv->proot->exec(pRuntimeEnv->proot, &newgroup);
-  pQInfo->summary.elapsedTime += (taosGetTimestampUs() - st);
-#ifdef TEST_IMPL
-  waitMoment(pQInfo);
-#endif
-  publishOperatorProfEvent(pRuntimeEnv->proot, QUERY_PROF_AFTER_OPERATOR_EXEC);
-  pRuntimeEnv->resultInfo.total += GET_NUM_OF_RESULTS(pRuntimeEnv);
-
-  if (isQueryKilled(pQInfo)) {
-    qDebug("QInfo:0x%"PRIx64" query is killed", pQInfo->qId);
-  } else if (GET_NUM_OF_RESULTS(pRuntimeEnv) == 0) {
-    qDebug("QInfo:0x%"PRIx64" over, %u tables queried, total %"PRId64" rows returned", pQInfo->qId, pRuntimeEnv->tableqinfoGroupInfo.numOfTables,
-           pRuntimeEnv->resultInfo.total);
-  } else {
-    qDebug("QInfo:0x%"PRIx64" query paused, %d rows returned, total:%" PRId64 " rows", pQInfo->qId,
-        GET_NUM_OF_RESULTS(pRuntimeEnv), pRuntimeEnv->resultInfo.total);
-  }
+  *handle = pTaskInfo->dsHandle;
+
+  while(1) {
+    st = taosGetTimestampUs();
+    SSDataBlock* pRes = pTaskInfo->pRoot->exec(pTaskInfo->pRoot, &newgroup);
 
-  return doBuildResCheck(pQInfo);
+    pTaskInfo->cost.elapsedTime += (taosGetTimestampUs() - st);
+    publishOperatorProfEvent(pTaskInfo->pRoot, QUERY_PROF_AFTER_OPERATOR_EXEC);
+
+    if (pRes == NULL) { // no results generated yet, abort
+      dsEndPut(pTaskInfo->dsHandle, pTaskInfo->cost.elapsedTime);
+      return pTaskInfo->code;
+    }
+
+    bool  qcontinue = false;
+    SInputData inputData = {.pData = pRes, .pTableRetrieveTsMap = NULL};
+    pTaskInfo->code = dsPutDataBlock(pTaskInfo->dsHandle, &inputData, &qcontinue);
+
+    if (isTaskKilled(pTaskInfo)) {
+      qDebug("QInfo:0x%" PRIx64 " task is killed", GET_TASKID(pTaskInfo));
+      //  } else if (GET_NUM_OF_RESULTS(pRuntimeEnv) == 0) {
+      //    qDebug("QInfo:0x%"PRIx64" over, %u tables queried, total %"PRId64" rows returned", pTaskInfo->qId, pRuntimeEnv->tableqinfoGroupInfo.numOfTables,
+      //           pRuntimeEnv->resultInfo.total);
+    }
+
+    if (!qcontinue) {
+          qDebug("QInfo:0x%"PRIx64" query paused, %d rows returned, total:%" PRId64 " rows, in sinkNode:%d", GET_TASKID(pTaskInfo),
+              0, 0L, 0);
+      return pTaskInfo->code;
+    }
+  }
 }
 
 int32_t qRetrieveQueryResultInfo(qTaskInfo_t qinfo, bool* buildRes, void* pRspContext) {
@@ -398,13 +284,13 @@ int32_t qKillTask(qTaskInfo_t qinfo) {
 }
 
 int32_t qIsTaskCompleted(qTaskInfo_t qinfo) {
-  SQInfo *pQInfo = (SQInfo *)qinfo;
+  SExecTaskInfo *pTaskInfo = (SExecTaskInfo *)qinfo;
 
-  if (pQInfo == NULL || !isValidQInfo(pQInfo)) {
+  if (pTaskInfo == NULL /*|| !isValidQInfo(pTaskInfo)*/) {
     return TSDB_CODE_QRY_INVALID_QHANDLE;
   }
 
-  return isQueryKilled(pQInfo) || Q_STATUS_EQUAL(pQInfo->runtimeEnv.status, QUERY_OVER);
+  return isTaskKilled(pTaskInfo) || Q_STATUS_EQUAL(pTaskInfo->status, TASK_OVER);
 }
 
 void qDestroyTask(qTaskInfo_t qHandle) {

source/libs/executor/test/CMakeLists.txt

+
+MESSAGE(STATUS "build parser unit test")
+
+# GoogleTest requires at least C++11
+SET(CMAKE_CXX_STANDARD 11)
+AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SOURCE_LIST)
+
+ADD_EXECUTABLE(executorTest ${SOURCE_LIST})
+TARGET_LINK_LIBRARIES(
+        executorTest
+        PUBLIC os util common transport gtest taos qcom executor function planner
+)
+
+TARGET_INCLUDE_DIRECTORIES(
+        executorTest
+        PUBLIC "${CMAKE_SOURCE_DIR}/include/libs/executor/"
+        PRIVATE "${CMAKE_SOURCE_DIR}/source/libs/executor/inc"
+)

source/libs/executor/test/executorTests.cpp

+/*
+ * 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 <executorimpl.h>
+#include <gtest/gtest.h>
+#include <tglobal.h>
+#include <iostream>
+#pragma GCC diagnostic ignored "-Wwrite-strings"
+
+#pragma GCC diagnostic ignored "-Wunused-function"
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#pragma GCC diagnostic ignored "-Wsign-compare"
+#include "os.h"
+
+#include "taos.h"
+#include "tdef.h"
+#include "tvariant.h"
+#include "tep.h"
+#include "trpc.h"
+#include "stub.h"
+#include "executor.h"
+
+/**
+{
+	"Id":	{
+		"QueryId":	1.3108161807422521e+19,
+		"TemplateId":	0,
+		"SubplanId":	0
+	},
+	"Node":	{
+		"Name":	"TableScan",
+		"Targets":	[{
+				"Base":	{
+					"Schema":	{
+						"Type":	9,
+						"ColId":	5000,
+						"Bytes":	8
+					},
+					"Columns":	[{
+							"TableId":	1,
+							"Flag":	0,
+							"Info":	{
+								"ColId":	1,
+								"Type":	9,
+								"Bytes":	8
+							}
+						}],
+					"InterBytes":	0
+				},
+				"Expr":	{
+					"Type":	4,
+					"Column":	{
+						"Type":	9,
+						"ColId":	1,
+						"Bytes":	8
+					}
+				}
+			}, {
+				"Base":	{
+					"Schema":	{
+						"Type":	4,
+						"ColId":	5001,
+						"Bytes":	4
+					},
+					"Columns":	[{
+							"TableId":	1,
+							"Flag":	0,
+							"Info":	{
+								"ColId":	2,
+								"Type":	4,
+								"Bytes":	4
+							}
+						}],
+					"InterBytes":	0
+				},
+				"Expr":	{
+					"Type":	4,
+					"Column":	{
+						"Type":	4,
+						"ColId":	2,
+						"Bytes":	4
+					}
+				}
+			}],
+		"InputSchema":	[{
+				"Type":	9,
+				"ColId":	5000,
+				"Bytes":	8
+			}, {
+				"Type":	4,
+				"ColId":	5001,
+				"Bytes":	4
+			}],
+		"TableScan":	{
+			"TableId":	1,
+			"TableType":	2,
+			"Flag":	0,
+			"Window":	{
+				"StartKey":	-9.2233720368547758e+18,
+				"EndKey":	9.2233720368547758e+18
+			}
+		}
+	},
+	"DataSink":	{
+		"Name":	"Dispatch",
+		"Dispatch":	{
+		}
+	}
+}
+ */
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
+
+TEST(testCase, build_executor_tree_Test) {
+
+
+  const char* msg = "{\n"
+      "\t\"Id\":\t{\n"
+      "\t\t\"QueryId\":\t1.3108161807422521e+19,\n"
+      "\t\t\"TemplateId\":\t0,\n"
+      "\t\t\"SubplanId\":\t0\n"
+      "\t},\n"
+      "\t\"Node\":\t{\n"
+      "\t\t\"Name\":\t\"TableScan\",\n"
+      "\t\t\"Targets\":\t[{\n"
+      "\t\t\t\t\"Base\":\t{\n"
+      "\t\t\t\t\t\"Schema\":\t{\n"
+      "\t\t\t\t\t\t\"Type\":\t9,\n"
+      "\t\t\t\t\t\t\"ColId\":\t5000,\n"
+      "\t\t\t\t\t\t\"Bytes\":\t8\n"
+      "\t\t\t\t\t},\n"
+      "\t\t\t\t\t\"Columns\":\t[{\n"
+      "\t\t\t\t\t\t\t\"TableId\":\t1,\n"
+      "\t\t\t\t\t\t\t\"Flag\":\t0,\n"
+      "\t\t\t\t\t\t\t\"Info\":\t{\n"
+      "\t\t\t\t\t\t\t\t\"ColId\":\t1,\n"
+      "\t\t\t\t\t\t\t\t\"Type\":\t9,\n"
+      "\t\t\t\t\t\t\t\t\"Bytes\":\t8\n"
+      "\t\t\t\t\t\t\t}\n"
+      "\t\t\t\t\t\t}],\n"
+      "\t\t\t\t\t\"InterBytes\":\t0\n"
+      "\t\t\t\t},\n"
+      "\t\t\t\t\"Expr\":\t{\n"
+      "\t\t\t\t\t\"Type\":\t4,\n"
+      "\t\t\t\t\t\"Column\":\t{\n"
+      "\t\t\t\t\t\t\"Type\":\t9,\n"
+      "\t\t\t\t\t\t\"ColId\":\t1,\n"
+      "\t\t\t\t\t\t\"Bytes\":\t8\n"
+      "\t\t\t\t\t}\n"
+      "\t\t\t\t}\n"
+      "\t\t\t}, {\n"
+      "\t\t\t\t\"Base\":\t{\n"
+      "\t\t\t\t\t\"Schema\":\t{\n"
+      "\t\t\t\t\t\t\"Type\":\t4,\n"
+      "\t\t\t\t\t\t\"ColId\":\t5001,\n"
+      "\t\t\t\t\t\t\"Bytes\":\t4\n"
+      "\t\t\t\t\t},\n"
+      "\t\t\t\t\t\"Columns\":\t[{\n"
+      "\t\t\t\t\t\t\t\"TableId\":\t1,\n"
+      "\t\t\t\t\t\t\t\"Flag\":\t0,\n"
+      "\t\t\t\t\t\t\t\"Info\":\t{\n"
+      "\t\t\t\t\t\t\t\t\"ColId\":\t2,\n"
+      "\t\t\t\t\t\t\t\t\"Type\":\t4,\n"
+      "\t\t\t\t\t\t\t\t\"Bytes\":\t4\n"
+      "\t\t\t\t\t\t\t}\n"
+      "\t\t\t\t\t\t}],\n"
+      "\t\t\t\t\t\"InterBytes\":\t0\n"
+      "\t\t\t\t},\n"
+      "\t\t\t\t\"Expr\":\t{\n"
+      "\t\t\t\t\t\"Type\":\t4,\n"
+      "\t\t\t\t\t\"Column\":\t{\n"
+      "\t\t\t\t\t\t\"Type\":\t4,\n"
+      "\t\t\t\t\t\t\"ColId\":\t2,\n"
+      "\t\t\t\t\t\t\"Bytes\":\t4\n"
+      "\t\t\t\t\t}\n"
+      "\t\t\t\t}\n"
+      "\t\t\t}],\n"
+      "\t\t\"InputSchema\":\t[{\n"
+      "\t\t\t\t\"Type\":\t9,\n"
+      "\t\t\t\t\"ColId\":\t5000,\n"
+      "\t\t\t\t\"Bytes\":\t8\n"
+      "\t\t\t}, {\n"
+      "\t\t\t\t\"Type\":\t4,\n"
+      "\t\t\t\t\"ColId\":\t5001,\n"
+      "\t\t\t\t\"Bytes\":\t4\n"
+      "\t\t\t}],\n"
+      "\t\t\"TableScan\":\t{\n"
+      "\t\t\t\"TableId\":\t1,\n"
+      "\t\t\t\"TableType\":\t2,\n"
+      "\t\t\t\"Flag\":\t0,\n"
+      "\t\t\t\"Window\":\t{\n"
+      "\t\t\t\t\"StartKey\":\t-9.2233720368547758e+18,\n"
+      "\t\t\t\t\"EndKey\":\t9.2233720368547758e+18\n"
+      "\t\t\t}\n"
+      "\t\t}\n"
+      "\t},\n"
+      "\t\"DataSink\":\t{\n"
+      "\t\t\"Name\":\t\"Dispatch\",\n"
+      "\t\t\"Dispatch\":\t{\n"
+      "\t\t}\n"
+      "\t}\n"
+      "}";
+
+  SExecTaskInfo* pTaskInfo = nullptr;
+  int32_t code = qCreateExecTask((void*) 1, 2, NULL, (void**) &pTaskInfo);
+}
\ No newline at end of file

source/libs/index/src/index.c

@@ -59,6 +59,10 @@ static int  indexMergeFinalResults(SArray* interResults, EIndexOperatorType oTyp
 
 static int indexGenTFile(SIndex* index, IndexCache* cache, SArray* batch);
 
+// merge cache and tfile by opera type
+static void indexMergeCacheAndTFile(SArray* result, IterateValue* icache, IterateValue* iTfv);
+static void indexMergeSameKey(SArray* result, TFileValue* tv);
+
 int indexOpen(SIndexOpts* opts, const char* path, SIndex** index) {
   pthread_once(&isInit, indexInit);
   SIndex* sIdx = calloc(1, sizeof(SIndex));
@@ -385,6 +389,27 @@ static void indexMergeSameKey(SArray* result, TFileValue* tv) {
     taosArrayPush(result, &tv);
   }
 }
+static void indexMergeCacheAndTFile(SArray* result, IterateValue* cv, IterateValue* tv) {
+  // opt
+  char* colVal = (cv != NULL) ? cv->colVal : tv->colVal;
+  // design merge-algorithm later, too complicated to handle all kind of situation
+  TFileValue* tfv = tfileValueCreate(colVal);
+  if (cv != NULL) {
+    if (cv->type == ADD_VALUE) {
+      taosArrayAddAll(tfv->tableId, cv->val);
+    } else if (cv->type == DEL_VALUE) {
+    } else if (cv->type == UPDATE_VALUE) {
+    } else {
+      // do nothing
+    }
+  }
+  if (tv != NULL) {
+    // opt later
+    taosArrayAddAll(tfv->tableId, tv->val);
+  }
+
+  indexMergeSameKey(result, tfv);
+}
 static void indexDestroyTempResult(SArray* result) {
   int32_t sz = result ? taosArrayGetSize(result) : 0;
   for (size_t i = 0; i < sz; i++) {
@@ -411,51 +436,30 @@ int indexFlushCacheToTFile(SIndex* sIdx, void* cache) {
 
   bool cn = cacheIter ? cacheIter->next(cacheIter) : false;
   bool tn = tfileIter ? tfileIter->next(tfileIter) : false;
-  while (cn == true && tn == true) {
-    IterateValue* cv = cacheIter->getValue(cacheIter);
-    IterateValue* tv = tfileIter->getValue(tfileIter);
-
-    // dump value
-    int comp = strcmp(cv->colVal, tv->colVal);
+  while (cn == true || tn == true) {
+    IterateValue* cv = (cn == true) ? cacheIter->getValue(cacheIter) : NULL;
+    IterateValue* tv = (tn == true) ? tfileIter->getValue(tfileIter) : NULL;
+
+    int comp = 0;
+    if (cn == true && tn == true) {
+      comp = strcmp(cv->colVal, tv->colVal);
+    } else if (cn == true) {
+      comp = -1;
+    } else {
+      comp = 1;
+    }
     if (comp == 0) {
-      TFileValue* tfv = tfileValueCreate(cv->colVal);
-      taosArrayAddAll(tfv->tableId, cv->val);
-      taosArrayAddAll(tfv->tableId, tv->val);
-      indexMergeSameKey(result, tfv);
-
+      indexMergeCacheAndTFile(result, cv, tv);
       cn = cacheIter->next(cacheIter);
       tn = tfileIter->next(tfileIter);
-      continue;
     } else if (comp < 0) {
-      TFileValue* tfv = tfileValueCreate(cv->colVal);
-      taosArrayAddAll(tfv->tableId, cv->val);
-
-      indexMergeSameKey(result, tfv);
-      // copy to final Result;
+      indexMergeCacheAndTFile(result, cv, NULL);
       cn = cacheIter->next(cacheIter);
     } else {
-      TFileValue* tfv = tfileValueCreate(tv->colVal);
-      taosArrayAddAll(tfv->tableId, tv->val);
-
-      indexMergeSameKey(result, tfv);
-      // copy to final result
+      indexMergeCacheAndTFile(result, NULL, tv);
       tn = tfileIter->next(tfileIter);
     }
   }
-  while (cn == true) {
-    IterateValue* cv = cacheIter->getValue(cacheIter);
-    TFileValue*   tfv = tfileValueCreate(cv->colVal);
-    taosArrayAddAll(tfv->tableId, cv->val);
-    indexMergeSameKey(result, tfv);
-    cn = cacheIter->next(cacheIter);
-  }
-  while (tn == true) {
-    IterateValue* tv = tfileIter->getValue(tfileIter);
-    TFileValue*   tfv = tfileValueCreate(tv->colVal);
-    taosArrayAddAll(tfv->tableId, tv->val);
-    indexMergeSameKey(result, tfv);
-    tn = tfileIter->next(tfileIter);
-  }
   int ret = indexGenTFile(sIdx, pCache, result);
   indexDestroyTempResult(result);
 
@@ -503,7 +507,7 @@ static int indexGenTFile(SIndex* sIdx, IndexCache* cache, SArray* batch) {
   tfileWriterClose(tw);
 
   TFileReader* reader = tfileReaderOpen(sIdx->path, cache->suid, version, cache->colName);
-  if (reader == NULL) { goto END; }
+  if (reader == NULL) { return -1; }
 
   TFileHeader* header = &reader->header;
   ICacheKey    key = {.suid = cache->suid, .colName = header->colName, .nColName = strlen(header->colName)};

source/libs/index/src/index_cache.c

@@ -217,9 +217,9 @@ int indexCachePut(void* cache, SIndexTerm* term, uint64_t uid) {
   // set value
   ct->uid = uid;
   ct->operaType = term->operType;
-
   // ugly code, refactor later
   int64_t estimate = sizeof(ct) + strlen(ct->colVal);
+
   pthread_mutex_lock(&pCache->mtx);
   pCache->occupiedMem += estimate;
   indexCacheMakeRoomForWrite(pCache);
@@ -331,7 +331,6 @@ static char* indexCacheTermGet(const void* pData) {
 static int32_t indexCacheTermCompare(const void* l, const void* r) {
   CacheTerm* lt = (CacheTerm*)l;
   CacheTerm* rt = (CacheTerm*)r;
-
   // compare colVal
   int32_t cmp = strcmp(lt->colVal, rt->colVal);
   if (cmp == 0) { return rt->version - lt->version; }
@@ -359,17 +358,32 @@ static bool indexCacheIteratorNext(Iterate* itera) {
   IterateValue* iv = &itera->val;
   iterateValueDestroy(iv, false);
 
+  // IterateValue* iv = &itera->val;
+  // IterateValue tIterVal = {.colVal = NULL, .val = taosArrayInit(1, sizeof(uint64_t))};
+
   bool next = tSkipListIterNext(iter);
   if (next) {
     SSkipListNode* node = tSkipListIterGet(iter);
     CacheTerm*     ct = (CacheTerm*)SL_GET_NODE_DATA(node);
 
+    // equal func
+    // if (iv->colVal != NULL && ct->colVal != NULL) {
+    //  if (0 == strcmp(iv->colVal, ct->colVal)) { if (iv->type == ADD_VALUE) }
+    //} else {
+    //  tIterVal.colVal = calloc(1, strlen(ct->colVal) + 1);
+    //  tIterval.colVal = tstrdup(ct->colVal);
+    //}
     iv->type = ct->operaType;
-    iv->colVal = calloc(1, strlen(ct->colVal) + 1);
-    memcpy(iv->colVal, ct->colVal, strlen(ct->colVal));
+    iv->colVal = tstrdup(ct->colVal);
+    // iv->colVal = calloc(1, strlen(ct->colVal) + 1);
+    // memcpy(iv->colVal, ct->colVal, strlen(ct->colVal));
 
     taosArrayPush(iv->val, &ct->uid);
   }
+  // IterateValue* iv = &itera->val;
+  // iterateValueDestroy(iv, true);
+  //*iv = tIterVal;
+
   return next;
 }
 

source/libs/index/src/index_fst.c

@@ -936,6 +936,7 @@ Fst* fstCreate(FstSlice* slice) {
   len -= sizeof(checkSum);
   taosDecodeFixedU32(buf + len, &checkSum);
   if (taosCheckChecksum(buf, len, checkSum)) {
+    indexError("index file is corrupted");
     // verify fst
     return NULL;
   }

source/libs/index/src/index_fst_counting_writer.c

@@ -60,9 +60,10 @@ static int writeCtxDoReadFrom(WriterCtx* ctx, uint8_t* buf, int len, int32_t off
   return nRead;
 }
 static int writeCtxGetSize(WriterCtx* ctx) {
-  if (ctx->type == TFile && ctx->file.readOnly) {
-    // refactor later
-    return ctx->file.size;
+  if (ctx->type == TFile) {
+    struct stat fstat;
+    stat(ctx->file.buf, &fstat);
+    return fstat.st_size;
   }
   return 0;
 }
@@ -88,7 +89,7 @@ WriterCtx* writerCtxCreate(WriterType type, const char* path, bool readOnly, int
     if (readOnly == false) {
       // ctx->file.fd = open(path, O_WRONLY | O_CREAT | O_APPEND, S_IRWXU | S_IRWXG | S_IRWXO);
       ctx->file.fd = tfOpenCreateWriteAppend(path);
-
+      tfFtruncate(ctx->file.fd, 0);
       struct stat fstat;
       stat(path, &fstat);
       ctx->file.size = fstat.st_size;
@@ -138,6 +139,11 @@ void writerCtxDestroy(WriterCtx* ctx, bool remove) {
       munmap(ctx->file.ptr, ctx->file.size);
 #endif
     }
+    if (ctx->file.readOnly == false) {
+      struct stat fstat;
+      stat(ctx->file.buf, &fstat);
+      // indexError("write file size: %d", (int)(fstat.st_size));
+    }
     if (remove) { unlink(ctx->file.buf); }
   }
   free(ctx);