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

include/common/taosmsg.h

@@ -52,6 +52,10 @@ TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_MQ_CONNECT, "mq-connect" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_MQ_DISCONNECT, "mq-disconnect" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_MQ_SET_CUR, "mq-set-cur" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_RES_READY, "res-ready" )
+TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_TASKS_STATUS, "tasks-status" )
+TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CANCEL_TASK, "cancel-task" )
+TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DROP_TASK, "drop-task" )
+
 // message from client to mnode
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CONNECT, "connect" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CREATE_ACCT, "create-acct" )	
@@ -79,7 +83,6 @@ TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_ALTER_STB, "alter-stb" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DROP_STB, "drop-stb" )	
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_VGROUP_LIST, "vgroup-list" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_KILL_QUERY, "kill-query" )		
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_KILL_STREAM, "kill-stream" )	
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_KILL_CONN, "kill-conn" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_HEARTBEAT, "heartbeat" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_SHOW, "show" )
@@ -290,13 +293,52 @@ 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;
+} SCreateStbMsg, SCreateTableMsg;
 
 typedef struct {
   char   name[TSDB_TABLE_FNAME_LEN];
@@ -327,19 +369,6 @@ typedef struct {
   uint64_t suid;
 } SDropStbInternalMsg;
 
-typedef struct {
-  SMsgHead head;
-  char     name[TSDB_TABLE_FNAME_LEN];
-  char     stbFname[TSDB_TABLE_FNAME_LEN];
-  int8_t   tableType;
-  uint64_t suid;
-  int32_t  sversion;
-  int32_t  numOfTags;
-  int32_t  numOfColumns;
-  int32_t  tagDataLen;
-  char     data[];
-} SCreateTableMsg;
-
 typedef struct {
   SMsgHead head;
   char     name[TSDB_TABLE_FNAME_LEN];
@@ -352,6 +381,7 @@ typedef struct {
 typedef struct {
   SMsgHead head;
   char     name[TSDB_TABLE_FNAME_LEN];
+  int8_t   ignoreNotExists;
 } SDropTableMsg;
 
 typedef struct {
@@ -946,18 +976,6 @@ typedef struct {
   char    subSqlInfo[TSDB_SHOW_SUBQUERY_LEN];  // include subqueries' index, Obj IDs and states(C-complete/I-imcomplete)
 } SQueryDesc;
 
-typedef struct {
-  char    sql[TSDB_SHOW_SQL_LEN];
-  char    dstTable[TSDB_TABLE_NAME_LEN];
-  int32_t streamId;
-  int64_t num;  // number of computing/cycles
-  int64_t useconds;
-  int64_t ctime;
-  int64_t stime;
-  int64_t slidingTime;
-  int64_t interval;
-} SStreamDesc;
-
 typedef struct {
   int32_t connId;
   int32_t pid;
@@ -1093,29 +1111,29 @@ typedef struct {
   /* data */
 } SUpdateTagValRsp;
 
-typedef struct SSchedulerQueryMsg {
+typedef struct SSubQueryMsg {
   uint64_t  schedulerId;
   uint64_t  queryId;
   uint64_t  taskId;
   uint32_t  contentLen;
   char      msg[];
-} SSchedulerQueryMsg;
+} SSubQueryMsg;
 
-typedef struct SSchedulerReadyMsg {
+typedef struct SResReadyMsg {
   uint64_t  schedulerId;
   uint64_t  queryId;
   uint64_t  taskId;
-} SSchedulerReadyMsg;
+} SResReadyMsg;
 
-typedef struct SSchedulerFetchMsg {
+typedef struct SResFetchMsg {
   uint64_t  schedulerId;
   uint64_t  queryId;
   uint64_t  taskId;
-} SSchedulerFetchMsg;
+} SResFetchMsg;
 
-typedef struct SSchedulerStatusMsg {
+typedef struct SSchTasksStatusMsg {
   uint64_t  schedulerId;
-} SSchedulerStatusMsg;
+} SSchTasksStatusMsg;
 
 typedef struct STaskStatus {
   uint64_t  queryId;
@@ -1129,11 +1147,17 @@ typedef struct SSchedulerStatusRsp {
 } SSchedulerStatusRsp;
 
 
-typedef struct SSchedulerCancelMsg {
+typedef struct STaskCancelMsg {
   uint64_t  schedulerId;
   uint64_t  queryId;
   uint64_t  taskId;
-} SSchedulerCancelMsg;
+} STaskCancelMsg;
+
+typedef struct STaskDropMsg {
+  uint64_t  schedulerId;
+  uint64_t  queryId;
+  uint64_t  taskId;
+} STaskDropMsg;
 
 
 #pragma pack(pop)

include/common/tmsgtype.h

@@ -102,14 +102,6 @@ enum {
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_MAX, "max" )
 };
 
-// create table operation type
-enum TSQL_CREATE_TABLE_TYPE {
-  TSQL_CREATE_TABLE  = 0x1,
-  TSQL_CREATE_STABLE = 0x2,
-  TSQL_CREATE_CTABLE = 0x3,
-  TSQL_CREATE_STREAM = 0x4,
-};
-
 #ifdef __cplusplus
 }
 #endif

include/common/tname.h

@@ -16,8 +16,6 @@
 #ifndef TDENGINE_TNAME_H
 #define TDENGINE_TNAME_H
 
-//#include "taosmsg.h"
-
 #define TSDB_DB_NAME_T     1
 #define TSDB_TABLE_NAME_T  2
 

include/dnode/vnode/tq/tq.h

@@ -22,6 +22,8 @@
 #include "taoserror.h"
 #include "taosmsg.h"
 #include "tlist.h"
+#include "trpc.h"
+#include "ttimer.h"
 #include "tutil.h"
 
 #ifdef __cplusplus
@@ -54,6 +56,7 @@ typedef struct STqSetCurReq {
 
 typedef struct STqConsumeReq {
   STqMsgHead head;
+  int64_t    blockingTime;  // milisec
   STqAcks    acks;
 } STqConsumeReq;
 
@@ -101,33 +104,44 @@ typedef struct STqTopicVhandle {
 typedef struct STqExec {
   void* runtimeEnv;
   SSDataBlock* (*exec)(void* runtimeEnv);
-  void* (*assign)(void* runtimeEnv, SSubmitBlk* inputData);
+  void* (*assign)(void* runtimeEnv, void* inputData);
   void (*clear)(void* runtimeEnv);
   char* (*serialize)(struct STqExec*);
   struct STqExec* (*deserialize)(char*);
 } STqExec;
 
+typedef struct STqRspHandle {
+  void* handle;
+  void* ahandle;
+} STqRspHandle;
+
+typedef enum { TQ_ITEM_READY, TQ_ITEM_PROCESS, TQ_ITEM_EMPTY } STqItemStatus;
+
+typedef struct STqTopic STqTopic;
+
 typedef struct STqBufferItem {
   int64_t offset;
   // executors are identical but not concurrent
   // so there must be a copy in each item
-  STqExec* executor;
-  int32_t  status;
-  int64_t  size;
-  void*    content;
+  STqExec*  executor;
+  int32_t   status;
+  int64_t   size;
+  void*     content;
+  STqTopic* pTopic;
 } STqMsgItem;
 
-typedef struct STqTopic {
+struct STqTopic {
   // char* topic; //c style, end with '\0'
   // int64_t cgId;
   // void* ahandle;
+  // int32_t    head;
+  // int32_t    tail;
   int64_t    nextConsumeOffset;
   int64_t    floatingCursor;
   int64_t    topicId;
-  int32_t    head;
-  int32_t    tail;
+  void*      logReader;
   STqMsgItem buffer[TQ_BUFFER_SIZE];
-} STqTopic;
+};
 
 typedef struct STqListHandle {
   STqTopic              topic;
@@ -135,13 +149,13 @@ typedef struct STqListHandle {
 } STqList;
 
 typedef struct STqGroup {
-  int64_t  clientId;
-  int64_t  cgId;
-  void*    ahandle;
-  int32_t  topicNum;
-  STqList* head;
-  SList*   topicList;  // SList<STqTopic>
-  void*    returnMsg;  // SVReadMsg
+  int64_t clientId;
+  int64_t cgId;
+  void*   ahandle;
+  int32_t topicNum;
+  STqList*     head;
+  SList*       topicList;  // SList<STqTopic>
+  STqRspHandle rspHandle;
 } STqGroup;
 
 typedef struct STqQueryMsg {
@@ -149,20 +163,23 @@ typedef struct STqQueryMsg {
   struct STqQueryMsg* next;
 } STqQueryMsg;
 
-typedef struct STqLogReader {
+typedef struct STqLogHandle {
   void* logHandle;
-  int32_t (*logRead)(void* logHandle, void** data, int64_t ver);
+  void* (*openLogReader)(void* logHandle);
+  void (*closeLogReader)(void* logReader);
+  int32_t (*logRead)(void* logReader, void** data, int64_t ver);
+
   int64_t (*logGetFirstVer)(void* logHandle);
   int64_t (*logGetSnapshotVer)(void* logHandle);
   int64_t (*logGetLastVer)(void* logHandle);
-} STqLogReader;
+} STqLogHandle;
 
 typedef struct STqCfg {
   // TODO
 } STqCfg;
 
 typedef struct STqMemRef {
-  SMemAllocatorFactory* pAlloctorFactory;
+  SMemAllocatorFactory* pAllocatorFactory;
   SMemAllocator*        pAllocator;
 } STqMemRef;
 
@@ -252,19 +269,30 @@ typedef struct STQ {
   // the handle of meta kvstore
   char*         path;
   STqCfg*       tqConfig;
-  STqLogReader* tqLogReader;
+  STqLogHandle* tqLogHandle;
   STqMemRef     tqMemRef;
   STqMetaStore* tqMeta;
 } STQ;
 
+typedef struct STqMgmt {
+  int8_t inited;
+  tmr_h  timer;
+} STqMgmt;
+
+static STqMgmt tqMgmt;
+
+// init once
+int  tqInit();
+void tqCleanUp();
+
 // open in each vnode
-STQ* tqOpen(const char* path, STqCfg* tqConfig, STqLogReader* tqLogReader, SMemAllocatorFactory* allocFac);
+STQ* tqOpen(const char* path, STqCfg* tqConfig, STqLogHandle* tqLogHandle, SMemAllocatorFactory* allocFac);
 void tqClose(STQ*);
 
 // void* will be replace by a msg type
 int tqPushMsg(STQ*, void* msg, int64_t version);
 int tqCommit(STQ*);
-int tqConsume(STQ*, STqConsumeReq*);
+int tqConsume(STQ*, SRpcMsg* pReq, SRpcMsg** pRsp);
 
 int tqSetCursor(STQ*, STqSetCurReq* pMsg);
 int tqBufferSetOffset(STqTopic*, int64_t offset);

include/dnode/vnode/vnode.h

@@ -122,6 +122,16 @@ int vnodeProcessWMsgs(SVnode *pVnode, SArray *pMsgs);
  */
 int vnodeApplyWMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp);
 
+/**
+ * @brief Process a consume message.
+ *
+ * @param pVnode The vnode object.
+ * @param pMsg The request message
+ * @param pRsp The response message
+ * @return int 0 for success, -1 for failure
+ */
+int vnodeProcessCMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp);
+
 /**
  * @brief Process the sync request
  *

include/libs/catalog/catalog.h

@@ -115,14 +115,14 @@ int32_t catalogGetTableDistVgroup(struct SCatalog* pCatalog, void *pRpc, const S
 /**
  * Get a table's vgroup from its name's hash value.
  * @param pCatalog (input, got with catalogGetHandle)
- * @param pRpc (input, rpc object)
+ * @param pTransporter (input, rpc object)
  * @param pMgmtEps (input, mnode EPs)
  * @param pDBName (input, full db name)
  * @param pTableName (input, table name, NOT including db name)
  * @param vgInfo (output, vgroup info)
  * @return error code
  */
-int32_t catalogGetTableHashVgroup(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName, SVgroupInfo* vgInfo);
+int32_t catalogGetTableHashVgroup(struct SCatalog* pCatalog, void * pTransporter, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName, SVgroupInfo* vgInfo);
 
 
 /**

include/libs/parser/parsenodes.h

@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_PARSENODES_H_
+#define _TD_PARSENODES_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "catalog.h"
+#include "common.h"
+#include "function.h"
+#include "tmsgtype.h"
+#include "tname.h"
+#include "tvariant.h"
+
+/*
+ * The first field of a node of any type is guaranteed to be the int16_t.
+ * Hence the type of any node can be gotten by casting it to SQueryNode. 
+ */
+typedef struct SQueryNode {
+  int16_t type;
+} SQueryNode;
+
+#define nodeType(nodeptr) (((const SQueryNode*)(nodeptr))->type)
+
+typedef struct SField {
+  char     name[TSDB_COL_NAME_LEN];
+  uint8_t  type;
+  int32_t  bytes;
+} SField;
+
+typedef struct SParseBasicCtx {
+  const char *db;
+  int32_t     acctId;
+  uint64_t    requestId;
+} SParseBasicCtx;
+
+typedef struct SFieldInfo {
+  int16_t     numOfOutput;   // number of column in result
+  SField     *final;
+  SArray     *internalField; // SArray<SInternalField>
+} SFieldInfo;
+
+typedef struct SCond {
+  uint64_t uid;
+  int32_t  len;  // length of tag query condition data
+  char *   cond;
+} SCond;
+
+typedef struct SJoinNode {
+  uint64_t uid;
+  int16_t  tagColId;
+  SArray*  tsJoin;
+  SArray*  tagJoin;
+} SJoinNode;
+
+typedef struct SJoinInfo {
+  bool       hasJoin;
+  SJoinNode *joinTables[TSDB_MAX_JOIN_TABLE_NUM];
+} SJoinInfo;
+
+typedef struct STagCond {
+  int16_t   relType;     // relation between tbname list and query condition, including : TK_AND or TK_OR
+  SCond     tbnameCond;  // tbname query condition, only support tbname query condition on one table
+  SJoinInfo joinInfo;    // join condition, only support two tables join currently
+  SArray   *pCond;       // for different table, the query condition must be seperated
+} STagCond;
+
+typedef struct STableMetaInfo {
+  STableMeta    *pTableMeta;      // table meta, cached in client side and acquired by name
+  SVgroupsInfo  *vgroupList;
+  SName         name;
+  char          aliasName[TSDB_TABLE_NAME_LEN];    // alias name of table specified in query sql
+  SArray       *tagColList;                        // SArray<SColumn*>, involved tag columns
+} STableMetaInfo;
+
+typedef struct SColumnIndex {
+  int16_t tableIndex;
+  int16_t columnIndex;
+  int16_t type;               // normal column/tag/ user input constant column
+} SColumnIndex;
+
+// select statement
+typedef struct SQueryStmtInfo {
+  int16_t          command;       // the command may be different for each subclause, so keep it seperately.
+  uint32_t         type;          // query/insert type
+  STimeWindow      window;        // the whole query time window
+  SInterval        interval;      // tumble time window
+  SSessionWindow   sessionWindow; // session time window
+  SStateWindow     stateWindow;   // state window query
+  SGroupbyExpr     groupbyExpr;   // groupby tags info
+  SArray *         colList;       // SArray<SColumn*>
+  SFieldInfo       fieldsInfo;
+  SArray**         exprList;      // SArray<SExprInfo*>
+  SLimit           limit;
+  SLimit           slimit;
+  STagCond         tagCond;
+  SArray *         colCond;
+  SArray *         order;
+  int16_t          numOfTables;
+  int16_t          curTableIdx;
+  STableMetaInfo **pTableMetaInfo;
+  struct STSBuf   *tsBuf;
+
+  int16_t          fillType;      // final result fill type
+  int64_t *        fillVal;       // default value for fill
+  int32_t          numOfFillVal;  // fill value size
+
+  char *           msg;           // pointer to the pCmd->payload to keep error message temporarily
+  int64_t          clauseLimit;   // limit for current sub clause
+
+  int64_t          prjOffset;     // offset value in the original sql expression, only applied at client side
+  int64_t          vgroupLimit;    // table limit in case of super table projection query + global order + limit
+
+  int32_t          udColumnId;    // current user-defined constant output field column id, monotonically decreases from TSDB_UD_COLUMN_INDEX
+  int32_t          bufLen;
+  char*            buf;
+  SArray          *pUdfInfo;
+
+  struct SQueryStmtInfo *sibling;     // sibling
+  struct SQueryStmtInfo *pDownstream;
+  SMultiFunctionsDesc    info;
+  SArray            *pUpstream;   // SArray<struct SQueryStmtInfo>
+  int32_t            havingFieldNum;
+  int32_t            exprListLevelIndex;
+} SQueryStmtInfo;
+
+typedef enum {
+  PAYLOAD_TYPE_KV = 0,
+  PAYLOAD_TYPE_RAW = 1,
+} EPayloadType;
+
+typedef struct SVgDataBlocks {
+  SVgroupInfo vg;
+  int32_t     numOfTables;  // number of tables in current submit block
+  uint32_t    size;
+  char       *pData;        // SMsgDesc + SSubmitMsg + SSubmitBlk + ...
+} SVgDataBlocks;
+
+typedef struct SInsertStmtInfo {
+  int16_t     nodeType;
+  SArray*     pDataBlocks;         // data block for each vgroup, SArray<SVgDataBlocks*>.
+  int8_t      schemaAttache;        // denote if submit block is built with table schema or not
+  uint8_t     payloadType;         // EPayloadType. 0: K-V payload for non-prepare insert, 1: rawPayload for prepare insert
+  uint32_t    insertType;          // insert data from [file|sql statement| bound statement]
+  const char* sql;                 // current sql statement position
+} SInsertStmtInfo;
+
+typedef struct SDclStmtInfo {
+  int16_t     nodeType;
+  int16_t     msgType;
+  char*       pMsg;
+  int32_t     msgLen;
+} SDclStmtInfo;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_PARSENODES_H_*/

include/libs/parser/parser.h

@@ -20,130 +20,18 @@
 extern "C" {
 #endif
 
-#include "catalog.h"
-#include "common.h"
-#include "tname.h"
-#include "tvariant.h"
-#include "function.h"
-
-typedef struct SField {
-  char     name[TSDB_COL_NAME_LEN];
-  uint8_t  type;
-  int16_t  bytes;
-} SField;
-
-typedef struct SFieldInfo {
-  int16_t     numOfOutput;   // number of column in result
-  SField     *final;
-  SArray     *internalField; // SArray<SInternalField>
-} SFieldInfo;
-
-typedef struct SCond {
-  uint64_t uid;
-  int32_t  len;  // length of tag query condition data
-  char *   cond;
-} SCond;
-
-typedef struct SJoinNode {
-  uint64_t uid;
-  int16_t  tagColId;
-  SArray*  tsJoin;
-  SArray*  tagJoin;
-} SJoinNode;
-
-typedef struct SJoinInfo {
-  bool       hasJoin;
-  SJoinNode *joinTables[TSDB_MAX_JOIN_TABLE_NUM];
-} SJoinInfo;
-
-typedef struct STagCond {
-  int16_t   relType;     // relation between tbname list and query condition, including : TK_AND or TK_OR
-  SCond     tbnameCond;  // tbname query condition, only support tbname query condition on one table
-  SJoinInfo joinInfo;    // join condition, only support two tables join currently
-  SArray   *pCond;       // for different table, the query condition must be seperated
-} STagCond;
-
-typedef struct STableMetaInfo {
-  STableMeta    *pTableMeta;      // table meta, cached in client side and acquired by name
-  SVgroupsInfo  *vgroupList;
-  SName         name;
-  char          aliasName[TSDB_TABLE_NAME_LEN];    // alias name of table specified in query sql
-  SArray       *tagColList;                        // SArray<SColumn*>, involved tag columns
-} STableMetaInfo;
-
-typedef struct SQueryStmtInfo {
-  int16_t          command;       // the command may be different for each subclause, so keep it seperately.
-  uint32_t         type;          // query/insert type
-  STimeWindow      window;        // the whole query time window
-  SInterval        interval;      // tumble time window
-  SSessionWindow   sessionWindow; // session time window
-  SStateWindow     stateWindow;   // state window query
-  SGroupbyExpr     groupbyExpr;   // groupby tags info
-  SArray *         colList;       // SArray<SColumn*>
-  SFieldInfo       fieldsInfo;
-  SArray**         exprList;      // SArray<SExprInfo*>
-  SLimit           limit;
-  SLimit           slimit;
-  STagCond         tagCond;
-  SArray *         colCond;
-  SArray *         order;
-  int16_t          numOfTables;
-  int16_t          curTableIdx;
-  STableMetaInfo **pTableMetaInfo;
-  struct STSBuf   *tsBuf;
-
-  int16_t          fillType;      // final result fill type
-  int64_t *        fillVal;       // default value for fill
-  int32_t          numOfFillVal;  // fill value size
-
-  char *           msg;           // pointer to the pCmd->payload to keep error message temporarily
-  int64_t          clauseLimit;   // limit for current sub clause
-
-  int64_t          prjOffset;     // offset value in the original sql expression, only applied at client side
-  int64_t          vgroupLimit;    // table limit in case of super table projection query + global order + limit
-
-  int32_t          udColumnId;    // current user-defined constant output field column id, monotonically decreases from TSDB_UD_COLUMN_INDEX
-  int32_t          bufLen;
-  char*            buf;
-  SArray          *pUdfInfo;
-
-  struct SQueryStmtInfo *sibling;     // sibling
-  struct SQueryStmtInfo *pDownstream;
-  SMultiFunctionsDesc    info;
-  SArray            *pUpstream;   // SArray<struct SQueryStmtInfo>
-  int32_t            havingFieldNum;
-  int32_t            exprListLevelIndex;
-} SQueryStmtInfo;
-
-typedef struct SColumnIndex {
-  int16_t tableIndex;
-  int16_t columnIndex;
-  int16_t type;               // normal column/tag/ user input constant column
-} SColumnIndex;
-
-struct SInsertStmtInfo;
-
-/**
- * True will be returned if the input sql string is insert, false otherwise.
- * @param pStr    sql string
- * @param length  length of the sql string
- * @return
- */
-bool qIsInsertSql(const char* pStr, size_t length);
+#include "parsenodes.h"
 
 typedef struct SParseContext {
-  const char* pAcctId;
-  const char* pDbname;
-  void *pRpc;
-  const char* pClusterId;
-  struct SCatalog* pCatalog;
-  const SEpSet* pEpSet;
-  int64_t id;          // query id, generated by uuid generator
-  int8_t schemaAttached; // denote if submit block is built with table schema or not
-  const char* pSql;    // sql string
-  size_t sqlLen;       // length of the sql string
-  char* pMsg;           // extended error message if exists to help avoid the problem in sql statement.
-  int32_t msgLen;      // max length of the msg
+  SParseBasicCtx  ctx;
+  void            *pRpc;
+  struct SCatalog *pCatalog;
+  const SEpSet    *pEpSet;
+  int8_t           schemaAttached; // denote if submit block is built with table schema or not
+  const char      *pSql;           // sql string
+  size_t           sqlLen;         // length of the sql string
+  char            *pMsg;           // extended error message if exists to help avoid the problem in sql statement.
+  int32_t          msgLen;         // max length of the msg
 } SParseContext;
 
 /**
@@ -154,37 +42,9 @@ typedef struct SParseContext {
  * @param msg      extended error message if exists.
  * @return         error code
  */
-int32_t qParseQuerySql(const char* pStr, size_t length, int64_t id, int32_t* type, void** pOutput, int32_t* outputLen, char* msg, int32_t msgLen);
+int32_t qParseQuerySql(SParseContext* pContext, SQueryNode** pQuery);
 
-typedef enum {
-  PAYLOAD_TYPE_KV = 0,
-  PAYLOAD_TYPE_RAW = 1,
-} EPayloadType;
-
-typedef struct SVgDataBlocks {
-  int64_t     vgId;         // virtual group id
-  int32_t     numOfTables;  // number of tables in current submit block
-  uint32_t    size;
-  char       *pData;        // SMsgDesc + SSubmitMsg + SSubmitBlk + ...
-} SVgDataBlocks;
-
-typedef struct SInsertStmtInfo {
-  SArray*     pDataBlocks;         // data block for each vgroup, SArray<SVgDataBlocks*>.
-  int8_t      schemaAttache;        // denote if submit block is built with table schema or not
-  uint8_t     payloadType;         // EPayloadType. 0: K-V payload for non-prepare insert, 1: rawPayload for prepare insert
-  uint32_t    insertType;          // insert data from [file|sql statement| bound statement]
-  const char* sql;                 // current sql statement position
-} SInsertStmtInfo;
-
-/**
- * Parse the insert sql statement.
- * @param pStr            sql string
- * @param length          length of the sql string
- * @param id              operator id, generated by uuid generator.
- * @param msg             extended error message if exists to help avoid the problem in sql statement.
- * @return                data in binary format to submit to vnode directly.
- */
- int32_t qParseInsertSql(SParseContext* pContext, struct SInsertStmtInfo** pInfo);
+bool qIsDclQuery(const SQueryNode* pQuery);
 
 /**
  * Convert a normal sql statement to only query tags information to enable that the subscribe client can be aware quickly of the true vgroup ids that
@@ -211,9 +71,9 @@ typedef struct SSourceParam {
 SExprInfo* createExprInfo(STableMetaInfo* pTableMetaInfo, const char* funcName, SSourceParam* pSource, SSchema* pResSchema, int16_t interSize);
 int32_t copyExprInfoList(SArray* dst, const SArray* src, uint64_t uid, bool deepcopy);
 int32_t copyAllExprInfo(SArray* dst, const SArray* src, bool deepcopy);
-int32_t getExprFunctionLevel(SQueryStmtInfo* pQueryInfo);
+int32_t getExprFunctionLevel(const SQueryStmtInfo* pQueryInfo);
 
-STableMetaInfo* getMetaInfo(SQueryStmtInfo* pQueryInfo, int32_t tableIndex);
+STableMetaInfo* getMetaInfo(const SQueryStmtInfo* pQueryInfo, int32_t tableIndex);
 SSchema *getOneColumnSchema(const STableMeta* pTableMeta, int32_t colIndex);
 SSchema createSchema(uint8_t type, int16_t bytes, int16_t colId, const char* name);
 

include/libs/planner/planner.h

@@ -25,6 +25,7 @@ extern "C" {
 #define QUERY_TYPE_MERGE       1
 #define QUERY_TYPE_PARTIAL     2
 #define QUERY_TYPE_SCAN        3
+#define QUERY_TYPE_MODIFY      4
 
 enum OPERATOR_TYPE_E {
   OP_Unknown,
@@ -58,18 +59,17 @@ typedef struct SQueryNodeBasicInfo {
 
 typedef struct SDataSink {
   SQueryNodeBasicInfo info;
-  SDataBlockSchema schema;
 } SDataSink;
 
 typedef struct SDataDispatcher {
   SDataSink sink;
-  // todo
 } SDataDispatcher;
 
 typedef struct SDataInserter {
   SDataSink sink;
-  uint64_t    uid;  // unique id of the table
-  // todo data field
+  int32_t   numOfTables;
+  uint32_t  size;
+  char     *pData;
 } SDataInserter;
 
 typedef struct SPhyNode {
@@ -119,12 +119,13 @@ typedef struct SSubplanId {
 
 typedef struct SSubplan {
   SSubplanId id;          // unique id of the subplan
-  int32_t   type;         // QUERY_TYPE_MERGE|QUERY_TYPE_PARTIAL|QUERY_TYPE_SCAN
-  int32_t   level;        // the execution level of current subplan, starting from 0.
-  SEpSet    execEpSet;    // for the scan sub plan, the optional execution node
-  SArray   *pChildern;    // the datasource subplan,from which to fetch the result
-  SArray   *pParents;     // the data destination subplan, get data from current subplan
-  SPhyNode *pNode;        // physical plan of current subplan
+  int32_t    type;         // QUERY_TYPE_MERGE|QUERY_TYPE_PARTIAL|QUERY_TYPE_SCAN|QUERY_TYPE_MODIFY
+  int32_t    level;        // the execution level of current subplan, starting from 0.
+  SEpSet     execEpSet;    // for the scan/modify subplan, the optional execution node
+  SArray    *pChildern;    // the datasource subplan,from which to fetch the result
+  SArray    *pParents;     // the data destination subplan, get data from current subplan
+  SPhyNode  *pNode;        // physical plan of current subplan
+  SDataSink *pDataSink;    // data of the subplan flow into the datasink
 } SSubplan;
 
 typedef struct SQueryDag {
@@ -133,10 +134,12 @@ typedef struct SQueryDag {
   SArray  *pSubplans; // Element is SArray*, and nested element is SSubplan. The execution level of subplan, starting from 0.
 } SQueryDag;
 
+struct SQueryNode;
+
 /**
  * Create the physical plan for the query, according to the AST.
  */
-int32_t qCreateQueryDag(const struct SQueryStmtInfo* pQueryInfo, struct SEpSet* pQnode, struct SQueryDag** pDag);
+int32_t qCreateQueryDag(const struct SQueryNode* pQueryInfo, struct SEpSet* pQnode, struct SQueryDag** pDag);
 
 // Set datasource of this subplan, multiple calls may be made to a subplan.
 // @subplan subplan to be schedule
@@ -144,12 +147,12 @@ int32_t qCreateQueryDag(const struct SQueryStmtInfo* pQueryInfo, struct SEpSet*
 // @ep one execution location of this group of datasource subplans 
 int32_t qSetSubplanExecutionNode(SSubplan* subplan, uint64_t templateId, SEpAddr* ep);
 
-int32_t qExplainQuery(const struct SQueryStmtInfo* pQueryInfo, struct SEpSet* pQnode, char** str);
+int32_t qExplainQuery(const struct SQueryNode* pQueryInfo, struct SEpSet* pQnode, char** str);
 
 /**
  * Convert to subplan to string for the scheduler to send to the executor
  */
-int32_t qSubPlanToString(const SSubplan* subplan, char** str);
+int32_t qSubPlanToString(const SSubplan* subplan, char** str, int32_t* len);
 
 int32_t qStringToSubplan(const char* str, SSubplan** subplan);
 

include/libs/qcom/query.h

@@ -25,12 +25,15 @@ extern "C" {
 #include "tlog.h"
 
 enum {
+  JOB_TASK_STATUS_NULL = 0,
   JOB_TASK_STATUS_NOT_START = 1,
   JOB_TASK_STATUS_EXECUTING,
+  JOB_TASK_STATUS_PARTIAL_SUCCEED,
   JOB_TASK_STATUS_SUCCEED,
   JOB_TASK_STATUS_FAILED,
   JOB_TASK_STATUS_CANCELLING,
-  JOB_TASK_STATUS_CANCELLED
+  JOB_TASK_STATUS_CANCELLED,
+  JOB_TASK_STATUS_DROPPING,
 };
 
 typedef struct STableComInfo {
@@ -90,16 +93,28 @@ typedef struct STableMetaOutput {
   STableMeta *tbMeta;
 } STableMetaOutput;
 
+typedef int32_t __async_exec_fn_t(void* param);
+
 bool tIsValidSchema(struct SSchema* pSchema, int32_t numOfCols, int32_t numOfTags);
 
+int32_t initTaskQueue();
+int32_t cleanupTaskQueue();
+
+/**
+ *
+ * @param execFn      The asynchronously execution function
+ * @param execParam   The parameters of the execFn
+ * @param code        The response code during execution the execFn
+ * @return
+ */
+int32_t taosAsyncExec(__async_exec_fn_t execFn, void* execParam, int32_t* code);
+
+SSchema* tGetTbnameColumnSchema();
+void initQueryModuleMsgHandle();
+
 extern int32_t (*queryBuildMsg[TSDB_MSG_TYPE_MAX])(void* input, char **msg, int32_t msgSize, int32_t *msgLen);
 extern int32_t (*queryProcessMsgRsp[TSDB_MSG_TYPE_MAX])(void* output, char *msg, int32_t msgSize);
 
-SSchema* tGetTbnameColumnSchema();
-extern void msgInit();
-
-extern int32_t qDebugFlag;
-
 #define qFatal(...)  do { if (qDebugFlag & DEBUG_FATAL) { taosPrintLog("QRY FATAL ", qDebugFlag, __VA_ARGS__); }} while(0)
 #define qError(...)  do { if (qDebugFlag & DEBUG_ERROR) { taosPrintLog("QRY ERROR ", qDebugFlag, __VA_ARGS__); }} while(0)
 #define qWarn(...)   do { if (qDebugFlag & DEBUG_WARN)  { taosPrintLog("QRY WARN ", qDebugFlag, __VA_ARGS__); }}  while(0)

include/libs/qworker/qworker.h

@@ -42,15 +42,17 @@ typedef struct {
 
 int32_t qWorkerInit(SQWorkerCfg *cfg, void **qWorkerMgmt);
 
-int32_t qWorkerProcessQueryMsg(void *qWorkerMgmt, SSchedulerQueryMsg *msg, SRpcMsg *rsp);
+int32_t qWorkerProcessQueryMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, SRpcMsg **rsp);
 
-int32_t qWorkerProcessReadyMsg(void *qWorkerMgmt, SSchedulerReadyMsg *msg, SRpcMsg *rsp);
+int32_t qWorkerProcessReadyMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, SRpcMsg *rsp);
 
-int32_t qWorkerProcessStatusMsg(void *qWorkerMgmt, SSchedulerStatusMsg *msg, SRpcMsg *rsp);
+int32_t qWorkerProcessStatusMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, SRpcMsg *rsp);
 
-int32_t qWorkerProcessFetchMsg(void *qWorkerMgmt, SSchedulerFetchMsg *msg, SRpcMsg *rsp);
+int32_t qWorkerProcessFetchMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, SRpcMsg *rsp);
 
-int32_t qWorkerProcessCancelMsg(void *qWorkerMgmt, SSchedulerCancelMsg *msg, SRpcMsg *rsp);
+int32_t qWorkerProcessCancelMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, SRpcMsg *rsp);
+
+int32_t qWorkerProcessDropMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, SRpcMsg *rsp);
 
 void qWorkerDestroy(void **qWorkerMgmt);
 

include/libs/wal/wal.h

@@ -174,8 +174,11 @@ SWalReadHandle *walOpenReadHandle(SWal *);
 void            walCloseReadHandle(SWalReadHandle *);
 int32_t         walReadWithHandle(SWalReadHandle *pRead, int64_t ver);
 
+// deprecated
+#if 0
 int32_t walRead(SWal *, SWalHead **, int64_t ver);
-// int32_t walReadWithFp(SWal *, FWalWrite writeFp, int64_t verStart, int32_t readNum);
+int32_t walReadWithFp(SWal *, FWalWrite writeFp, int64_t verStart, int32_t readNum);
+#endif
 
 // lifecycle check
 int64_t walGetFirstVer(SWal *);

include/util/taoserror.h

@@ -314,6 +314,11 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_QRY_INVALID_TIME_CONDITION    TAOS_DEF_ERROR_CODE(0, 0x070D)  //"invalid time condition")
 #define TSDB_CODE_QRY_SYS_ERROR                 TAOS_DEF_ERROR_CODE(0, 0x070E)  //"System error")
 #define TSDB_CODE_QRY_INVALID_INPUT             TAOS_DEF_ERROR_CODE(0, 0x070F)  //"invalid input")
+#define TSDB_CODE_QRY_SCH_NOT_EXIST             TAOS_DEF_ERROR_CODE(0, 0x0710)  //"Scheduler not exist")
+#define TSDB_CODE_QRY_TASK_NOT_EXIST            TAOS_DEF_ERROR_CODE(0, 0x0711)  //"Task not exist")
+#define TSDB_CODE_QRY_TASK_ALREADY_EXIST        TAOS_DEF_ERROR_CODE(0, 0x0712)  //"Task already exist")
+#define TSDB_CODE_QRY_RES_CACHE_NOT_EXIST       TAOS_DEF_ERROR_CODE(0, 0x0713)  //"Task result cache not exist")
+#define TSDB_CODE_QRY_TASK_CANCELLED            TAOS_DEF_ERROR_CODE(0, 0x0714)  //"Task cancelled")
 
 
 // grant

include/util/thash.h

@@ -33,6 +33,8 @@ typedef void (*_hash_free_fn_t)(void *);
 
 #define HASH_INDEX(v, c) ((v) & ((c)-1))
 
+#define HASH_NODE_EXIST(code) (code == -2)
+
 /**
  * murmur hash algorithm
  * @key  usually string

include/util/ttimer.h

@@ -16,6 +16,8 @@
 #ifndef _TD_UTIL_TIMER_H
 #define _TD_UTIL_TIMER_H
 
+#include "os.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif

source/client/inc/clientInt.h

@@ -137,24 +137,26 @@ typedef struct SRequestMsgBody {
 
 extern SAppInfo   appInfo;
 extern int32_t    tscReqRef;
-extern void      *tscQhandle;
 extern int32_t    tscConnRef;
 
-extern int (*buildRequestMsgFp[TSDB_SQL_MAX])(SRequestObj *pRequest, SRequestMsgBody *pMsgBody);
-extern int (*handleRequestRspFp[TSDB_SQL_MAX])(SRequestObj *pRequest, const char* pMsg, int32_t msgLen);
+SRequestMsgBody buildRequestMsgImpl(SRequestObj *pRequest);
+extern int (*handleRequestRspFp[TSDB_MSG_TYPE_MAX])(SRequestObj *pRequest, const char* pMsg, int32_t msgLen);
 
 int   taos_init();
 
-void* createTscObj(const char* user, const char* auth, const char *ip, uint32_t port, SAppInstInfo* pAppInfo);
+void* createTscObj(const char* user, const char* auth, const char *db, SAppInstInfo* pAppInfo);
 void  destroyTscObj(void*pObj);
 
-void* createRequest(STscObj* pObj, __taos_async_fn_t fp, void* param, int32_t type);
-void destroyRequest(SRequestObj* pRequest);
+void *createRequest(STscObj* pObj, __taos_async_fn_t fp, void* param, int32_t type);
+void  destroyRequest(SRequestObj* pRequest);
+
+char *getConnectionDB(STscObj* pObj);
+void  setConnectionDB(STscObj* pTscObj, const char* db);
 
 void taos_init_imp(void);
 int taos_options_imp(TSDB_OPTION option, const char *str);
 
-void* openTransporter(const char *user, const char *auth);
+void* openTransporter(const char *user, const char *auth, int32_t numOfThreads);
 
 void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet);
 void initMsgHandleFp();

source/client/src/clientEnv.c

@@ -13,9 +13,11 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <catalog.h>
 #include "clientInt.h"
 #include "clientLog.h"
 #include "os.h"
+#include "query.h"
 #include "taosmsg.h"
 #include "tcache.h"
 #include "tconfig.h"
@@ -23,7 +25,6 @@
 #include "tnote.h"
 #include "tref.h"
 #include "trpc.h"
-#include "tsched.h"
 #include "ttime.h"
 #include "ttimezone.h"
 
@@ -33,10 +34,8 @@
 SAppInfo   appInfo;
 int32_t    tscReqRef  = -1;
 int32_t    tscConnRef = -1;
-void      *tscQhandle = NULL;
 
 static pthread_once_t tscinit = PTHREAD_ONCE_INIT;
-int32_t tsNumOfThreads = 1;
 volatile int32_t tscInitRes = 0;
 
 static void registerRequest(SRequestObj* pRequest) {
@@ -98,12 +97,12 @@ void closeTransporter(STscObj* pTscObj)  {
 }
 
 // TODO refactor
-void* openTransporter(const char *user, const char *auth) {
+void* openTransporter(const char *user, const char *auth, int32_t numOfThread) {
   SRpcInit rpcInit;
   memset(&rpcInit, 0, sizeof(rpcInit));
   rpcInit.localPort = 0;
   rpcInit.label = "TSC";
-  rpcInit.numOfThreads = tsNumOfThreads;
+  rpcInit.numOfThreads = numOfThread;
   rpcInit.cfp = processMsgFromServer;
   rpcInit.sessions = tsMaxConnections;
   rpcInit.connType = TAOS_CONN_CLIENT;
@@ -131,7 +130,7 @@ void destroyTscObj(void *pObj) {
   tfree(pTscObj);
 }
 
-void* createTscObj(const char* user, const char* auth, const char *ip, uint32_t port, SAppInstInfo* pAppInfo) {
+void* createTscObj(const char* user, const char* auth, const char *db, SAppInstInfo* pAppInfo) {
   STscObj *pObj = (STscObj *)calloc(1, sizeof(STscObj));
   if (NULL == pObj) {
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -146,6 +145,10 @@ void* createTscObj(const char* user, const char* auth, const char *ip, uint32_t
   tstrncpy(pObj->user, user, sizeof(pObj->user));
   memcpy(pObj->pass, auth, TSDB_PASSWORD_LEN);
 
+  if (db != NULL) {
+    tstrncpy(pObj->db, db, tListLen(pObj->db));
+  }
+
   pthread_mutex_init(&pObj->mutex, NULL);
   pObj->id = taosAddRef(tscConnRef, pObj);
 
@@ -222,25 +225,19 @@ void taos_init_imp(void) {
 
   taosInitNotes();
   initMsgHandleFp();
+  initQueryModuleMsgHandle();
 
   rpcInit();
 
+  SCatalogCfg cfg = {.enableVgroupCache = true, .maxDBCacheNum = 100, .maxTblCacheNum = 100};
+  catalogInit(&cfg);
+
   tscDebug("starting to initialize TAOS driver, local ep: %s", tsLocalEp);
 
   taosSetCoreDump(true);
 
-  double factor = 4.0;
-  int32_t numOfThreads = MAX((int)(tsNumOfCores * tsNumOfThreadsPerCore / factor), 2);
+  initTaskQueue();
 
-  int32_t queueSize = tsMaxConnections * 2;
-  tscQhandle = taosInitScheduler(queueSize, numOfThreads, "tsc");
-  if (NULL == tscQhandle) {
-    tscError("failed to init task queue");
-    tscInitRes = -1;
-    return;
-  }
-
-  tscDebug("client task queue is initialized, numOfThreads: %d", numOfThreads);
   tscConnRef = taosOpenRef(200, destroyTscObj);
   tscReqRef  = taosOpenRef(40960, doDestroyRequest);
 

source/client/src/clientImpl.c

@@ -102,9 +102,8 @@ TAOS *taos_connect_internal(const char *ip, const char *user, const char *pass,
   SAppInstInfo** pInst = taosHashGet(appInfo.pInstMap, key, strlen(key));
   if (pInst == NULL) {
     SAppInstInfo* p = calloc(1, sizeof(struct SAppInstInfo));
-
     p->mgmtEp       = epSet;
-    p->pTransporter = openTransporter(user, secretEncrypt);
+    p->pTransporter = openTransporter(user, secretEncrypt, tsNumOfCores);
     taosHashPut(appInfo.pInstMap, key, strlen(key), &p, POINTER_BYTES);
 
     pInst = &p;
@@ -145,33 +144,66 @@ TAOS_RES *taos_query_l(TAOS *taos, const char *sql, int sqlLen) {
 
   tscDebugL("0x%"PRIx64" SQL: %s", pRequest->requestId, pRequest->sqlstr);
 
-  int32_t code = 0;
-  if (qIsInsertSql(pRequest->sqlstr, sqlLen)) {
-    // todo add
-  } else {
-    int32_t type = 0;
-    void*   output = NULL;
-    int32_t outputLen = 0;
-    code = qParseQuerySql(pRequest->sqlstr, sqlLen, pRequest->requestId, &type, &output, &outputLen, pRequest->msgBuf, ERROR_MSG_BUF_DEFAULT_SIZE);
-    if (type == TSDB_SQL_CREATE_USER || type == TSDB_SQL_SHOW || type == TSDB_SQL_DROP_USER || type == TSDB_SQL_DROP_ACCT || type == TSDB_SQL_CREATE_DB || type == TSDB_SQL_CREATE_ACCT) {
-      pRequest->type = type;
-      pRequest->body.requestMsg = (SReqMsgInfo){.pMsg = output, .len = outputLen};
+  SParseContext cxt = {
+    .ctx = {.requestId = pRequest->requestId, .acctId = pTscObj->acctId, .db = getConnectionDB(pTscObj)},
+    .pSql = pRequest->sqlstr,
+    .sqlLen = sqlLen,
+    .pMsg = pRequest->msgBuf,
+    .msgLen = ERROR_MSG_BUF_DEFAULT_SIZE
+  };
+  SQueryNode* pQuery = NULL;
+  int32_t code = qParseQuerySql(&cxt, &pQuery);
+  if (qIsDclQuery(pQuery)) {
+    SDclStmtInfo* pDcl = (SDclStmtInfo*)pQuery;
+    pRequest->type = pDcl->msgType;
+    pRequest->body.requestMsg = (SReqMsgInfo){.pMsg = pDcl->pMsg, .len = pDcl->msgLen};
 
-      SRequestMsgBody body = {0};
-      buildRequestMsgFp[type](pRequest, &body);
+    SRequestMsgBody body = buildRequestMsgImpl(pRequest);
+    SEpSet* pEpSet = &pTscObj->pAppInfo->mgmtEp.epSet;
+
+    if (pDcl->msgType == TSDB_MSG_TYPE_CREATE_TABLE) {
+      struct SCatalog* pCatalog = NULL;
+
+      char buf[12] = {0};
+      sprintf(buf, "%d", pTscObj->pAppInfo->clusterId);
+      code = catalogGetHandle(buf, &pCatalog);
+      if (code != 0) {
+        pRequest->code = code;
+        return pRequest;
+      }
+
+      SCreateTableMsg* pMsg = body.msgInfo.pMsg;
+
+      SName t = {0};
+      tNameFromString(&t, pMsg->name, T_NAME_ACCT|T_NAME_DB|T_NAME_TABLE);
+
+      char db[TSDB_DB_NAME_LEN + TS_PATH_DELIMITER_LEN + TSDB_ACCT_ID_LEN] = {0};
+      tNameGetFullDbName(&t, db);
+
+      SVgroupInfo info = {0};
+      catalogGetTableHashVgroup(pCatalog, pTscObj->pTransporter, pEpSet, db, tNameGetTableName(&t), &info);
 
       int64_t transporterId = 0;
-      sendMsgToServer(pTscObj->pTransporter, &pTscObj->pAppInfo->mgmtEp.epSet, &body, &transporterId);
+      SEpSet ep = {0};
+      ep.inUse = info.inUse;
+      ep.numOfEps = info.numOfEps;
+      for(int32_t i = 0; i < ep.numOfEps; ++i) {
+        ep.port[i] = info.epAddr[i].port;
+        tstrncpy(ep.fqdn[i], info.epAddr[i].fqdn, tListLen(ep.fqdn[i]));
+      }
 
-      tsem_wait(&pRequest->body.rspSem);
-
-
-      destroyRequestMsgBody(&body);
+      sendMsgToServer(pTscObj->pTransporter, &ep, &body, &transporterId);
     } else {
-      assert(0);
+      int64_t transporterId = 0;
+      sendMsgToServer(pTscObj->pTransporter, pEpSet, &body, &transporterId);
     }
+
+    tsem_wait(&pRequest->body.rspSem);
+    destroyRequestMsgBody(&body);
   }
 
+  tfree(cxt.ctx.db);
+
   if (code != TSDB_CODE_SUCCESS) {
     pRequest->code = code;
     return pRequest;
@@ -217,13 +249,13 @@ int initEpSetFromCfg(const char *firstEp, const char *secondEp, SCorEpSet *pEpSe
 }
 
 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) {
-  STscObj *pTscObj = createTscObj(user, auth, ip, port, pAppInfo);
+  STscObj *pTscObj = createTscObj(user, auth, db, pAppInfo);
   if (NULL == pTscObj) {
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
     return pTscObj;
   }
 
-  SRequestObj *pRequest = createRequest(pTscObj, fp, param, TSDB_SQL_CONNECT);
+  SRequestObj *pRequest = createRequest(pTscObj, fp, param, TSDB_MSG_TYPE_CONNECT);
   if (pRequest == NULL) {
     destroyTscObj(pTscObj);
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -265,16 +297,11 @@ static int32_t buildConnectMsg(SRequestObj *pRequest, SRequestMsgBody* pMsgBody)
     return -1;
   }
 
-  // TODO refactor full_name
-  char *db;  // ugly code to move the space
-
   STscObj *pObj = pRequest->pTscObj;
-  pthread_mutex_lock(&pObj->mutex);
-  db = strstr(pObj->db, TS_PATH_DELIMITER);
 
-  db = (db == NULL) ? pObj->db : db + 1;
+  char* db = getConnectionDB(pObj);
   tstrncpy(pConnect->db, db, sizeof(pConnect->db));
-  pthread_mutex_unlock(&pObj->mutex);
+  tfree(db);
 
   pConnect->pid = htonl(appInfo.pid);
   pConnect->startTime = htobe64(appInfo.startTime);
@@ -392,10 +419,9 @@ void* doFetchRow(SRequestObj* pRequest) {
   SReqResultInfo* pResultInfo = &pRequest->body.resInfo;
 
   if (pResultInfo->pData == NULL || pResultInfo->current >= pResultInfo->numOfRows) {
-    pRequest->type = TSDB_SQL_RETRIEVE_MNODE;
+    pRequest->type = TSDB_MSG_TYPE_SHOW_RETRIEVE;
 
-    SRequestMsgBody body = {0};
-    buildRequestMsgFp[pRequest->type](pRequest, &body);
+    SRequestMsgBody body = buildRequestMsgImpl(pRequest);
 
     int64_t transporterId = 0;
     STscObj* pTscObj = pRequest->pTscObj;
@@ -437,8 +463,19 @@ void setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32_t
   }
 }
 
-const char *taos_get_client_info() { return version; }
+char* getConnectionDB(STscObj* pObj) {
+  char *p = NULL;
+  pthread_mutex_lock(&pObj->mutex);
+  p = strndup(pObj->db, tListLen(pObj->db));
+  pthread_mutex_unlock(&pObj->mutex);
 
-int taos_affected_rows(TAOS_RES *res) { return 1; }
+  return p;
+}
+
+void setConnectionDB(STscObj* pTscObj, const char* db) {
+  assert(db != NULL && pTscObj != NULL);
+  pthread_mutex_lock(&pTscObj->mutex);
+  tstrncpy(pTscObj->db, db, tListLen(pTscObj->db));
+  pthread_mutex_unlock(&pTscObj->mutex);
+}
 
-int taos_result_precision(TAOS_RES *res) { return TSDB_TIME_PRECISION_MILLI; }

source/client/src/clientMain.c

@@ -1,16 +1,11 @@
+#include "os.h"
 #include "clientInt.h"
 #include "clientLog.h"
-#include "os.h"
+#include "query.h"
 #include "taosmsg.h"
-#include "tcache.h"
-#include "tconfig.h"
 #include "tglobal.h"
-#include "tnote.h"
 #include "tref.h"
 #include "trpc.h"
-#include "tsched.h"
-#include "ttime.h"
-#include "ttimezone.h"
 
 #define TSC_VAR_NOT_RELEASE 1
 #define TSC_VAR_RELEASED    0
@@ -44,9 +39,7 @@ void taos_cleanup(void) {
   tscReqRef = -1;
   taosCloseRef(id);
 
-  void* p = tscQhandle;
-  tscQhandle = NULL;
-  taosCleanUpScheduler(p);
+  cleanupTaskQueue();
 
   id = tscConnRef;
   tscConnRef = -1;
@@ -262,3 +255,9 @@ const char *taos_data_type(int type) {
     default: return "UNKNOWN";
   }
 }
+
+const char *taos_get_client_info() { return version; }
+
+int taos_affected_rows(TAOS_RES *res) { return 1; }
+
+int taos_result_precision(TAOS_RES *res) { return TSDB_TIME_PRECISION_MILLI; }

source/client/test/clientTests.cpp

@@ -16,7 +16,6 @@
 #include <gtest/gtest.h>
 #include <taoserror.h>
 #include <iostream>
-#include "tglobal.h"
 #pragma GCC diagnostic ignored "-Wwrite-strings"
 
 #pragma GCC diagnostic ignored "-Wunused-function"
@@ -25,8 +24,22 @@
 
 #include "../inc/clientInt.h"
 #include "taos.h"
+#include "tglobal.h"
 
 namespace {
+void showDB(TAOS* pConn) {
+  TAOS_RES* pRes = taos_query(pConn, "show databases");
+  TAOS_ROW  pRow = NULL;
+
+  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
+  int32_t     numOfFields = taos_num_fields(pRes);
+
+  char str[512] = {0};
+  while ((pRow = taos_fetch_row(pRes)) != NULL) {
+    int32_t code = taos_print_row(str, pRow, pFields, numOfFields);
+    printf("%s\n", str);
+  }
+}
 }  // namespace
 
 int main(int argc, char** argv) {
@@ -34,111 +47,112 @@ int main(int argc, char** argv) {
   return RUN_ALL_TESTS();
 }
 
-TEST(testCase, driverInit_Test) {
-  taos_init();
-}
+TEST(testCase, driverInit_Test) { taos_init(); }
 
-TEST(testCase, connect_Test) {
-  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+// TEST(testCase, connect_Test) {
+//  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+////  assert(pConn != NULL);
+//  taos_close(pConn);
+//}
+//
+// TEST(testCase, create_user_Test) {
+//  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
 //  assert(pConn != NULL);
-  taos_close(pConn);
-}
-
-TEST(testCase, create_user_Test) {
-  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+//
+//  TAOS_RES* pRes = taos_query(pConn, "create user abc pass 'abc'");
+//  if (taos_errno(pRes) != TSDB_CODE_SUCCESS) {
+//    printf("failed to create user, reason:%s\n", taos_errstr(pRes));
+//  }
+//
+//  taos_free_result(pRes);
+//  taos_close(pConn);
+//}
+//
+// TEST(testCase, create_account_Test) {
+//  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
 //  assert(pConn != NULL);
-
-  TAOS_RES* pRes = taos_query(pConn, "create user abc pass 'abc'");
-  if (taos_errno(pRes) != TSDB_CODE_SUCCESS) {
-    printf("failed to create user, reason:%s\n", taos_errstr(pRes));
-  }
-
-  taos_free_result(pRes);
-  taos_close(pConn);
-}
-
-TEST(testCase, create_account_Test) {
-  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
-  assert(pConn != NULL);
-
-  TAOS_RES* pRes = taos_query(pConn, "create account aabc pass 'abc'");
-  if (taos_errno(pRes) != TSDB_CODE_SUCCESS) {
-    printf("failed to create user, reason:%s\n", taos_errstr(pRes));
-  }
-
-  taos_free_result(pRes);
-  taos_close(pConn);
-}
-
-TEST(testCase, drop_account_Test) {
-  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
-  assert(pConn != NULL);
-
-  TAOS_RES* pRes = taos_query(pConn, "drop account aabc");
-  if (taos_errno(pRes) != TSDB_CODE_SUCCESS) {
-    printf("failed to create user, reason:%s\n", taos_errstr(pRes));
-  }
-
-  taos_free_result(pRes);
-  taos_close(pConn);
-}
-
-TEST(testCase, show_user_Test) {
-  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+//
+//  TAOS_RES* pRes = taos_query(pConn, "create account aabc pass 'abc'");
+//  if (taos_errno(pRes) != TSDB_CODE_SUCCESS) {
+//    printf("failed to create user, reason:%s\n", taos_errstr(pRes));
+//  }
+//
+//  taos_free_result(pRes);
+//  taos_close(pConn);
+//}
+//
+// TEST(testCase, drop_account_Test) {
+//  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
 //  assert(pConn != NULL);
-
-  TAOS_RES* pRes = taos_query(pConn, "show users");
-  TAOS_ROW pRow = NULL;
-
-  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
-  int32_t numOfFields = taos_num_fields(pRes);
-
-  char str[512] = {0};
-  while((pRow = taos_fetch_row(pRes)) != NULL) {
-    int32_t code = taos_print_row(str, pRow, pFields, numOfFields);
-    printf("%s\n", str);
-  }
-
-  taos_close(pConn);
-}
-
-TEST(testCase, drop_user_Test) {
-  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
-  assert(pConn != NULL);
-
-  TAOS_RES* pRes = taos_query(pConn, "drop user abc");
-  if (taos_errno(pRes) != TSDB_CODE_SUCCESS) {
-    printf("failed to create user, reason:%s\n", taos_errstr(pRes));
-  }
-
-  taos_free_result(pRes);
-  taos_close(pConn);
-}
-
-TEST(testCase, show_db_Test) {
-  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+//
+//  TAOS_RES* pRes = taos_query(pConn, "drop account aabc");
+//  if (taos_errno(pRes) != TSDB_CODE_SUCCESS) {
+//    printf("failed to create user, reason:%s\n", taos_errstr(pRes));
+//  }
+//
+//  taos_free_result(pRes);
+//  taos_close(pConn);
+//}
+//
+// TEST(testCase, show_user_Test) {
+//  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+////  assert(pConn != NULL);
+//
+//  TAOS_RES* pRes = taos_query(pConn, "show users");
+//  TAOS_ROW pRow = NULL;
+//
+//  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
+//  int32_t numOfFields = taos_num_fields(pRes);
+//
+//  char str[512] = {0};
+//  while((pRow = taos_fetch_row(pRes)) != NULL) {
+//    int32_t code = taos_print_row(str, pRow, pFields, numOfFields);
+//    printf("%s\n", str);
+//  }
+//
+//  taos_close(pConn);
+//}
+//
+// TEST(testCase, drop_user_Test) {
+//  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
 //  assert(pConn != NULL);
-
-  TAOS_RES* pRes = taos_query(pConn, "show databases");
-  TAOS_ROW pRow = NULL;
-
-  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
-  int32_t numOfFields = taos_num_fields(pRes);
-
-  char str[512] = {0};
-  while((pRow = taos_fetch_row(pRes)) != NULL) {
-    int32_t code = taos_print_row(str, pRow, pFields, numOfFields);
-    printf("%s\n", str);
-  }
-
-  taos_close(pConn);
-}
+//
+//  TAOS_RES* pRes = taos_query(pConn, "drop user abc");
+//  if (taos_errno(pRes) != TSDB_CODE_SUCCESS) {
+//    printf("failed to create user, reason:%s\n", taos_errstr(pRes));
+//  }
+//
+//  taos_free_result(pRes);
+//  taos_close(pConn);
+//}
+//
+// TEST(testCase, show_db_Test) {
+//  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+////  assert(pConn != NULL);
+//
+//  TAOS_RES* pRes = taos_query(pConn, "show databases");
+//  TAOS_ROW pRow = NULL;
+//
+//  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
+//  int32_t numOfFields = taos_num_fields(pRes);
+//
+//  char str[512] = {0};
+//  while((pRow = taos_fetch_row(pRes)) != NULL) {
+//    int32_t code = taos_print_row(str, pRow, pFields, numOfFields);
+//    printf("%s\n", str);
+//  }
+//
+//  taos_close(pConn);
+//}
 
 TEST(testCase, create_db_Test) {
   TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
   assert(pConn != NULL);
 
   TAOS_RES* pRes = taos_query(pConn, "create database abc1");
+  if (taos_errno(pRes) != 0) {
+    printf("error in create db, reason:%s\n", taos_errstr(pRes));
+  }
 
   TAOS_FIELD* pFields = taos_fetch_fields(pRes);
   ASSERT_TRUE(pFields == NULL);
@@ -148,3 +162,143 @@ TEST(testCase, create_db_Test) {
 
   taos_close(pConn);
 }
+
+TEST(testCase, use_db_test) {
+  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+  assert(pConn != NULL);
+
+  TAOS_RES* pRes = taos_query(pConn, "use abc1");
+  if (taos_errno(pRes) != 0) {
+    printf("error in use db, reason:%s\n", taos_errstr(pRes));
+  }
+
+  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
+  ASSERT_TRUE(pFields == NULL);
+
+  int32_t numOfFields = taos_num_fields(pRes);
+  ASSERT_EQ(numOfFields, 0);
+
+  taos_close(pConn);
+}
+
+TEST(testCase, drop_db_test) {
+  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+  assert(pConn != NULL);
+
+  showDB(pConn);
+
+  TAOS_RES* pRes = taos_query(pConn, "drop database abc1");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to drop db, reason:%s\n", taos_errstr(pRes));
+  }
+
+  taos_free_result(pRes);
+
+  showDB(pConn);
+  taos_close(pConn);
+}
+
+// TEST(testCase, create_stable_Test) {
+//  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+//  assert(pConn != NULL);
+//
+//  TAOS_RES* pRes = taos_query(pConn, "create database abc1");
+//  if (taos_errno(pRes) != 0) {
+//    printf("error in create db, reason:%s\n", taos_errstr(pRes));
+//  }
+//  taos_free_result(pRes);
+//
+//  pRes = taos_query(pConn, "use abc1");
+//  if (taos_errno(pRes) != 0) {
+//    printf("error in use db, reason:%s\n", taos_errstr(pRes));
+//  }
+//  taos_free_result(pRes);
+//
+//  pRes = taos_query(pConn, "create stable st1(ts timestamp, k int) tags(a int)");
+//  if (taos_errno(pRes) != 0) {
+//    printf("error in create stable, reason:%s\n", taos_errstr(pRes));
+//  }
+//
+//  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
+//  ASSERT_TRUE(pFields == NULL);
+//
+//  int32_t numOfFields = taos_num_fields(pRes);
+//  ASSERT_EQ(numOfFields, 0);
+//
+//  taos_free_result(pRes);
+//  taos_close(pConn);
+//}
+
+TEST(testCase, create_table_Test) {
+  //  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+  //  assert(pConn != NULL);
+  //
+  //  TAOS_RES* pRes = taos_query(pConn, "use abc1");
+  //  taos_free_result(pRes);
+  //
+  //  pRes = taos_query(pConn, "create table tm0(ts timestamp, k int)");
+  //  taos_free_result(pRes);
+  //
+  //  taos_close(pConn);
+}
+
+TEST(testCase, create_ctable_Test) {}
+
+TEST(testCase, show_stable_Test) {
+  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+  assert(pConn != NULL);
+
+  TAOS_RES* pRes = taos_query(pConn, "show stables");
+  TAOS_ROW pRow = NULL;
+
+  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
+  int32_t numOfFields = taos_num_fields(pRes);
+
+  char str[512] = {0};
+  while((pRow = taos_fetch_row(pRes)) != NULL) {
+    int32_t code = taos_print_row(str, pRow, pFields, numOfFields);
+    printf("%s\n", str);
+  }
+
+  taos_free_result(pRes);
+
+  taos_close(pConn);
+}
+
+TEST(testCase, drop_stable_Test) {
+  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+  assert(pConn != NULL);
+
+  TAOS_RES* pRes = taos_query(pConn, "create database abc1");
+  if (taos_errno(pRes) != 0) {
+    printf("error in creating db, reason:%s\n", taos_errstr(pRes));
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "use abc1");
+  if (taos_errno(pRes) != 0) {
+    printf("error in using db, reason:%s\n", taos_errstr(pRes));
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "drop stable st1");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to drop stable, reason:%s\n", taos_errstr(pRes));
+  }
+
+  taos_free_result(pRes);
+  taos_close(pConn);
+}
+
+//TEST(testCase, show_table_Test) {
+//  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+//  assert(pConn != NULL);
+//
+//  TAOS_RES* pRes = taos_query(pConn, "use abc1");
+//  taos_free_result(pRes);
+//
+//  pRes = taos_query(pConn, "show tables");
+//  taos_free_result(pRes);
+//
+//  taos_close(pConn);
+//}

source/common/src/tname.c

@@ -6,21 +6,6 @@
 
 #define VALID_NAME_TYPE(x)  ((x) == TSDB_DB_NAME_T || (x) == TSDB_TABLE_NAME_T)
 
-char* extractDBName(const char* tableId, char* name) {
-  size_t offset1 = strcspn(tableId, &TS_PATH_DELIMITER[0]);
-  size_t len = strcspn(&tableId[offset1 + 1], &TS_PATH_DELIMITER[0]);
-  
-  return strncpy(name, &tableId[offset1 + 1], len);
-}
-
-// todo remove it
-size_t tableIdPrefix(const char* name, char* prefix, int32_t len) {
-  tstrncpy(prefix, name, len);
-  strcat(prefix, TS_PATH_DELIMITER);
-
-  return strlen(prefix);
-}
-
 bool tscValidateTableNameLength(size_t len) {
   return len < TSDB_TABLE_NAME_LEN;
 }
@@ -125,7 +110,7 @@ int32_t tNameExtractFullName(const SName* name, char* dst) {
     return -1;
   }
 
-  int32_t len = snprintf(dst, TSDB_FULL_DB_NAME_LEN, "%s.%s", name->acctId, name->dbname);
+  int32_t len = snprintf(dst, TSDB_FULL_DB_NAME_LEN, "%d.%s", name->acctId, name->dbname);
 
   size_t tnameLen = strlen(name->tname);
   if (tnameLen > 0) {
@@ -141,7 +126,9 @@ int32_t tNameExtractFullName(const SName* name, char* dst) {
 
 int32_t tNameLen(const SName* name) {
   assert(name != NULL);
-  int32_t len  = (int32_t) strlen(name->acctId);
+
+  char tmp[12] = {0};
+  int32_t len = sprintf(tmp, "%d", name->acctId);
   int32_t len1 = (int32_t) strlen(name->dbname);
   int32_t len2 = (int32_t) strlen(name->tname);
 
@@ -161,10 +148,6 @@ bool tNameIsValid(const SName* name) {
     return false;
   }
 
-  if (strlen(name->acctId) <= 0) {
-    return false;
-  }
-
   if (name->type == TSDB_DB_NAME_T) {
     return strlen(name->dbname) > 0;
   } else {
@@ -237,13 +220,6 @@ int32_t tNameFromString(SName* dst, const char* str, uint32_t type) {
       return -1;
     }
 
-    int32_t len = (int32_t)(p - str);
-
-    // too long account id or too long db name
-//    if ((len >= tListLen(dst->acctId)) || (len <= 0)) {
-//      return -1;
-//    }
-//    memcpy (dst->acctId, str, len);
     dst->acctId = strtoll(str, NULL, 10);
   }
 
@@ -272,9 +248,8 @@ int32_t tNameFromString(SName* dst, const char* str, uint32_t type) {
     dst->type = TSDB_TABLE_NAME_T;
     char* start = (char*) ((p == NULL)? str: (p+1));
 
-    int32_t len = (int32_t) strlen(start);
-
     // too long account id or too long db name
+    int32_t len = (int32_t) strlen(start);
     if ((len >= tListLen(dst->tname)) || (len <= 0)) {
       return -1;
     }

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

@@ -45,6 +45,10 @@ static void dndInitMsgFp(STransMgmt *pMgmt) {
   pMgmt->msgFp[TSDB_MSG_TYPE_MQ_CONNECT] = dndProcessVnodeWriteMsg;
   pMgmt->msgFp[TSDB_MSG_TYPE_MQ_DISCONNECT] = dndProcessVnodeWriteMsg;
   pMgmt->msgFp[TSDB_MSG_TYPE_MQ_SET_CUR] = dndProcessVnodeWriteMsg;
+  pMgmt->msgFp[TSDB_MSG_TYPE_RES_READY] = dndProcessVnodeFetchMsg;
+  pMgmt->msgFp[TSDB_MSG_TYPE_TASKS_STATUS] = dndProcessVnodeFetchMsg;
+  pMgmt->msgFp[TSDB_MSG_TYPE_CANCEL_TASK] = dndProcessVnodeFetchMsg;
+  pMgmt->msgFp[TSDB_MSG_TYPE_DROP_TASK] = dndProcessVnodeFetchMsg;
 
   // msg from client to mnode
   pMgmt->msgFp[TSDB_MSG_TYPE_CONNECT] = dndProcessMnodeReadMsg;
@@ -73,7 +77,6 @@ static void dndInitMsgFp(STransMgmt *pMgmt) {
   pMgmt->msgFp[TSDB_MSG_TYPE_DROP_STB] = dndProcessMnodeWriteMsg;
   pMgmt->msgFp[TSDB_MSG_TYPE_VGROUP_LIST] = dndProcessMnodeReadMsg;
   pMgmt->msgFp[TSDB_MSG_TYPE_KILL_QUERY] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_KILL_STREAM] = dndProcessMnodeWriteMsg;
   pMgmt->msgFp[TSDB_MSG_TYPE_KILL_CONN] = dndProcessMnodeWriteMsg;
   pMgmt->msgFp[TSDB_MSG_TYPE_HEARTBEAT] = dndProcessMnodeReadMsg;
   pMgmt->msgFp[TSDB_MSG_TYPE_SHOW] = dndProcessMnodeReadMsg;

source/dnode/mgmt/impl/test/CMakeLists.txt

@@ -8,8 +8,8 @@ add_subdirectory(db)
 add_subdirectory(dnode)
 # add_subdirectory(func)
 # add_subdirectory(mnode)
-# add_subdirectory(profile)
-# add_subdirectory(show)
+add_subdirectory(profile)
+add_subdirectory(show)
 add_subdirectory(stb)
 # add_subdirectory(sync)
 # add_subdirectory(telem)
@@ -17,4 +17,4 @@ add_subdirectory(stb)
 add_subdirectory(user)
 add_subdirectory(vgroup)
 
-# add_subdirectory(common)
+add_subdirectory(sut)

source/dnode/mgmt/impl/test/acct/CMakeLists.txt

@@ -1,24 +1,8 @@
-add_executable(dnode_test_acct "")
-
-target_sources(dnode_test_acct
-    PRIVATE
-    "acct.cpp"
-    "../sut/deploy.cpp"
-)
-
+aux_source_directory(. ACCT_SRC)
+add_executable(dnode_test_acct ${ACCT_SRC})
 target_link_libraries(
     dnode_test_acct
-    PUBLIC dnode
-    PUBLIC util
-    PUBLIC os
-    PUBLIC gtest_main
-)
-
-target_include_directories(dnode_test_acct
-    PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/server/dnode/mgmt"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../../inc"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
+    PUBLIC sut
 )
 
 add_test(

source/dnode/mgmt/impl/test/acct/acct.cpp

@@ -9,103 +9,59 @@
  *
  */
 
-#include "deploy.h"
+#include "base.h"
 
 class DndTestAcct : public ::testing::Test {
  protected:
-   static SServer* CreateServer(const char* path, const char* fqdn, uint16_t port, const char* firstEp) {
-    SServer* pServer = createServer(path, fqdn, port, firstEp);
-    ASSERT(pServer);
-    return pServer;
-  }
+  static void SetUpTestSuite() { test.Init("/tmp/dnode_test_acct", 9012); }
+  static void TearDownTestSuite() { test.Cleanup(); }
 
-  static void SetUpTestSuite() {
-    initLog("/tmp/tdlog");
+  static Testbase test;
 
-    const char* fqdn = "localhost";
-    const char* firstEp = "localhost:9012";
-    pServer = CreateServer("/tmp/dnode_test_user", fqdn, 9012, firstEp);
-    pClient = createClient("root", "taosdata", fqdn, 9012);
-    taosMsleep(300);
-  }
-
-  static void TearDownTestSuite() {
-    stopServer(pServer);
-    dropClient(pClient);
-    pServer = NULL;
-    pClient = NULL;
-  }
-
-  static SServer* pServer;
-  static SClient* pClient;
-  static int32_t  connId;
+ public:
+  void SetUp() override {}
+  void TearDown() override {}
 };
 
-SServer* DndTestAcct::pServer;
-SClient* DndTestAcct::pClient;
-int32_t  DndTestAcct::connId;
+Testbase DndTestAcct::test;
 
 TEST_F(DndTestAcct, 01_CreateAcct) {
-  ASSERT_NE(pClient, nullptr);
+  int32_t contLen = sizeof(SCreateAcctMsg);
 
-  SCreateAcctMsg* pReq = (SCreateAcctMsg*)rpcMallocCont(sizeof(SCreateAcctMsg));
+  SCreateAcctMsg* pReq = (SCreateAcctMsg*)rpcMallocCont(contLen);
 
-  SRpcMsg rpcMsg = {0};
-  rpcMsg.pCont = pReq;
-  rpcMsg.contLen = sizeof(SCreateAcctMsg);
-  rpcMsg.msgType = TSDB_MSG_TYPE_CREATE_ACCT;
-
-  sendMsg(pClient, &rpcMsg);
-  SRpcMsg* pMsg = pClient->pRsp;
+  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_ACCT, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, TSDB_CODE_MND_MSG_NOT_PROCESSED);
 }
 
 TEST_F(DndTestAcct, 02_AlterAcct) {
-  ASSERT_NE(pClient, nullptr);
+  int32_t contLen = sizeof(SCreateAcctMsg);
 
-  SAlterAcctMsg* pReq = (SAlterAcctMsg*)rpcMallocCont(sizeof(SAlterAcctMsg));
+  SAlterAcctMsg* pReq = (SAlterAcctMsg*)rpcMallocCont(contLen);
 
-  SRpcMsg rpcMsg = {0};
-  rpcMsg.pCont = pReq;
-  rpcMsg.contLen = sizeof(SAlterAcctMsg);
-  rpcMsg.msgType = TSDB_MSG_TYPE_ALTER_ACCT;
-
-  sendMsg(pClient, &rpcMsg);
-  SRpcMsg* pMsg = pClient->pRsp;
+  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_ALTER_ACCT, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, TSDB_CODE_MND_MSG_NOT_PROCESSED);
 }
 
 TEST_F(DndTestAcct, 03_DropAcct) {
-  ASSERT_NE(pClient, nullptr);
+  int32_t contLen = sizeof(SDropAcctMsg);
 
-  SDropAcctMsg* pReq = (SDropAcctMsg*)rpcMallocCont(sizeof(SDropAcctMsg));
+  SDropAcctMsg* pReq = (SDropAcctMsg*)rpcMallocCont(contLen);
 
-  SRpcMsg rpcMsg = {0};
-  rpcMsg.pCont = pReq;
-  rpcMsg.contLen = sizeof(SDropAcctMsg);
-  rpcMsg.msgType = TSDB_MSG_TYPE_DROP_ACCT;
-
-  sendMsg(pClient, &rpcMsg);
-  SRpcMsg* pMsg = pClient->pRsp;
+  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_DROP_ACCT, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, TSDB_CODE_MND_MSG_NOT_PROCESSED);
 }
 
 TEST_F(DndTestAcct, 04_ShowAcct) {
-  ASSERT_NE(pClient, nullptr);
+  int32_t contLen = sizeof(SShowMsg);
 
-  SShowMsg* pReq = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));
+  SShowMsg* pReq = (SShowMsg*)rpcMallocCont(contLen);
   pReq->type = TSDB_MGMT_TABLE_ACCT;
 
-  SRpcMsg rpcMsg = {0};
-  rpcMsg.pCont = pReq;
-  rpcMsg.contLen = sizeof(SShowMsg);
-  rpcMsg.msgType = TSDB_MSG_TYPE_SHOW;
-
-  sendMsg(pClient, &rpcMsg);
-  SRpcMsg* pMsg = pClient->pRsp;
+  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_SHOW, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, TSDB_CODE_MND_INVALID_MSG_TYPE);
 }

source/dnode/mgmt/impl/test/cluster/CMakeLists.txt

@@ -1,24 +1,8 @@
-add_executable(dnode_test_cluster "")
-
-target_sources(dnode_test_cluster
-    PRIVATE
-    "cluster.cpp"
-    "../sut/deploy.cpp"
-)
-
+aux_source_directory(. CLUSTER_SRC)
+add_executable(dnode_test_cluster ${CLUSTER_SRC})
 target_link_libraries(
     dnode_test_cluster
-    PUBLIC dnode
-    PUBLIC util
-    PUBLIC os
-    PUBLIC gtest_main
-)
-
-target_include_directories(dnode_test_cluster
-    PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/server/dnode/mgmt"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../../inc"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
+    PUBLIC sut
 )
 
 add_test(

source/dnode/mgmt/impl/test/cluster/cluster.cpp

@@ -9,162 +9,33 @@
  *
  */
 
-#include "deploy.h"
+#include "base.h"
 
 class DndTestCluster : public ::testing::Test {
  protected:
-  static SServer* CreateServer(const char* path, const char* fqdn, uint16_t port, const char* firstEp) {
-    SServer* pServer = createServer(path, fqdn, port, firstEp);
-    ASSERT(pServer);
-    return pServer;
-  }
+  static void SetUpTestSuite() { test.Init("/tmp/dnode_test_cluster", 9030); }
+  static void TearDownTestSuite() { test.Cleanup(); }
 
-  static void SetUpTestSuite() {
-    initLog("/tmp/tdlog");
-
-    const char* fqdn = "localhost";
-    const char* firstEp = "localhost:9030";
-    pServer = CreateServer("/tmp/dnode_test_cluster", fqdn, 9030, firstEp);
-    pClient = createClient("root", "taosdata", fqdn, 9030);
-    taosMsleep(1100);
-  }
-
-  static void TearDownTestSuite() {
-    stopServer(pServer);
-    dropClient(pClient);
-    pServer = NULL;
-    pClient = NULL;
-  }
-
-  static SServer* pServer;
-  static SClient* pClient;
-  static int32_t  connId;
+  static Testbase test;
 
  public:
   void SetUp() override {}
   void TearDown() override {}
-
-  void SendTheCheckShowMetaMsg(int8_t showType, const char* showName, int32_t columns, const char* db) {
-    SShowMsg* pShow = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));
-    pShow->type = showType;
-    if (db != NULL) {
-      strcpy(pShow->db, db);
-    }
-    SRpcMsg showRpcMsg = {0};
-    showRpcMsg.pCont = pShow;
-    showRpcMsg.contLen = sizeof(SShowMsg);
-    showRpcMsg.msgType = TSDB_MSG_TYPE_SHOW;
-
-    sendMsg(pClient, &showRpcMsg);
-    ASSERT_NE(pClient->pRsp, nullptr);
-    ASSERT_EQ(pClient->pRsp->code, 0);
-    ASSERT_NE(pClient->pRsp->pCont, nullptr);
-
-    SShowRsp* pShowRsp = (SShowRsp*)pClient->pRsp->pCont;
-    ASSERT_NE(pShowRsp, nullptr);
-    pShowRsp->showId = htonl(pShowRsp->showId);
-    pMeta = &pShowRsp->tableMeta;
-    pMeta->numOfTags = htonl(pMeta->numOfTags);
-    pMeta->numOfColumns = htonl(pMeta->numOfColumns);
-    pMeta->sversion = htonl(pMeta->sversion);
-    pMeta->tversion = htonl(pMeta->tversion);
-    pMeta->tuid = htobe64(pMeta->tuid);
-    pMeta->suid = htobe64(pMeta->suid);
-
-    showId = pShowRsp->showId;
-
-    EXPECT_NE(pShowRsp->showId, 0);
-    EXPECT_STREQ(pMeta->tbFname, showName);
-    EXPECT_EQ(pMeta->numOfTags, 0);
-    EXPECT_EQ(pMeta->numOfColumns, columns);
-    EXPECT_EQ(pMeta->precision, 0);
-    EXPECT_EQ(pMeta->tableType, 0);
-    EXPECT_EQ(pMeta->update, 0);
-    EXPECT_EQ(pMeta->sversion, 0);
-    EXPECT_EQ(pMeta->tversion, 0);
-    EXPECT_EQ(pMeta->tuid, 0);
-    EXPECT_EQ(pMeta->suid, 0);
-  }
-
-  void CheckSchema(int32_t index, int8_t type, int32_t bytes, const char* name) {
-    SSchema* pSchema = &pMeta->pSchema[index];
-    pSchema->bytes = htonl(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, type);
-    EXPECT_EQ(pSchema->bytes, bytes);
-    EXPECT_STREQ(pSchema->name, name);
-  }
-
-  void SendThenCheckShowRetrieveMsg(int32_t rows) {
-    SRetrieveTableMsg* pRetrieve = (SRetrieveTableMsg*)rpcMallocCont(sizeof(SRetrieveTableMsg));
-    pRetrieve->showId = htonl(showId);
-    pRetrieve->free = 0;
-
-    SRpcMsg retrieveRpcMsg = {0};
-    retrieveRpcMsg.pCont = pRetrieve;
-    retrieveRpcMsg.contLen = sizeof(SRetrieveTableMsg);
-    retrieveRpcMsg.msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE;
-
-    sendMsg(pClient, &retrieveRpcMsg);
-
-    ASSERT_NE(pClient->pRsp, nullptr);
-    ASSERT_EQ(pClient->pRsp->code, 0);
-    ASSERT_NE(pClient->pRsp->pCont, nullptr);
-
-    pRetrieveRsp = (SRetrieveTableRsp*)pClient->pRsp->pCont;
-    ASSERT_NE(pRetrieveRsp, nullptr);
-    pRetrieveRsp->numOfRows = htonl(pRetrieveRsp->numOfRows);
-    pRetrieveRsp->useconds = htobe64(pRetrieveRsp->useconds);
-    pRetrieveRsp->compLen = htonl(pRetrieveRsp->compLen);
-
-    EXPECT_EQ(pRetrieveRsp->numOfRows, rows);
-    EXPECT_EQ(pRetrieveRsp->useconds, 0);
-    // EXPECT_EQ(pRetrieveRsp->completed, completed);
-    EXPECT_EQ(pRetrieveRsp->precision, TSDB_TIME_PRECISION_MILLI);
-    EXPECT_EQ(pRetrieveRsp->compressed, 0);
-    EXPECT_EQ(pRetrieveRsp->compLen, 0);
-
-    pData = pRetrieveRsp->data;
-    pos = 0;
-  }
-
-  void CheckInt32() {
-    int32_t data = *((int32_t*)(pData + pos));
-    pos += sizeof(int32_t);
-    EXPECT_GT(data, 0);
-  }
-
-  void CheckTimestamp() {
-    int64_t data = *((int64_t*)(pData + pos));
-    pos += sizeof(int64_t);
-    EXPECT_GT(data, 0);
-  }
-
-  void CheckBinary(int32_t len) {
-    pos += sizeof(VarDataLenT);
-    char* data = (char*)(pData + pos);
-    pos += len;
-  }
-
-  int32_t            showId;
-  STableMetaMsg*     pMeta;
-  SRetrieveTableRsp* pRetrieveRsp;
-  char*              pData;
-  int32_t            pos;
 };
 
-SServer* DndTestCluster::pServer;
-SClient* DndTestCluster::pClient;
-int32_t  DndTestCluster::connId;
+Testbase DndTestCluster::test;
 
 TEST_F(DndTestCluster, 01_ShowCluster) {
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_CLUSTER, "show cluster", 3, NULL);
-  CheckSchema(0, TSDB_DATA_TYPE_INT, 4, "id");
-  CheckSchema(1, TSDB_DATA_TYPE_BINARY, TSDB_CLUSTER_ID_LEN + VARSTR_HEADER_SIZE, "name");
-  CheckSchema(2, TSDB_DATA_TYPE_TIMESTAMP, 8, "create_time");
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_CLUSTER, "");
+  CHECK_META( "show cluster", 3);
+  CHECK_SCHEMA(0, TSDB_DATA_TYPE_INT, 4, "id");
+  CHECK_SCHEMA(1, TSDB_DATA_TYPE_BINARY, TSDB_CLUSTER_ID_LEN + VARSTR_HEADER_SIZE, "name");
+  CHECK_SCHEMA(2, TSDB_DATA_TYPE_TIMESTAMP, 8, "create_time");
 
-  SendThenCheckShowRetrieveMsg(1);
-  CheckInt32();
-  CheckBinary(TSDB_CLUSTER_ID_LEN);
+  test.SendShowRetrieveMsg();
+  EXPECT_EQ(test.GetShowRows(), 1);
+
+  IgnoreInt32();
+  IgnoreBinary(TSDB_CLUSTER_ID_LEN);
   CheckTimestamp();
 }

source/dnode/mgmt/impl/test/db/CMakeLists.txt

@@ -1,24 +1,8 @@
-add_executable(dnode_test_db "")
-
-target_sources(dnode_test_db
-    PRIVATE
-    "db.cpp"
-    "../sut/deploy.cpp"
-)
-
+aux_source_directory(. DB_SRC)
+add_executable(dnode_test_db ${DB_SRC})
 target_link_libraries(
     dnode_test_db
-    PUBLIC dnode
-    PUBLIC util
-    PUBLIC os
-    PUBLIC gtest_main
-)
-
-target_include_directories(dnode_test_db
-    PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/server/dnode/mgmt"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../../inc"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
+    PUBLIC sut
 )
 
 add_test(

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

@@ -9,199 +9,52 @@
  *
  */
 
-#include "deploy.h"
+#include "base.h"
 
 class DndTestDb : public ::testing::Test {
  protected:
-  static SServer* CreateServer(const char* path, const char* fqdn, uint16_t port, const char* firstEp) {
-    SServer* pServer = createServer(path, fqdn, port, firstEp);
-    ASSERT(pServer);
-    return pServer;
-  }
+  static void SetUpTestSuite() { test.Init("/tmp/dnode_test_db", 9040); }
+  static void TearDownTestSuite() { test.Cleanup(); }
 
-  static void SetUpTestSuite() {
-    initLog("/tmp/tdlog");
-
-    const char* fqdn = "localhost";
-    const char* firstEp = "localhost:9040";
-    pServer = CreateServer("/tmp/dnode_test_db", fqdn, 9040, firstEp);
-    pClient = createClient("root", "taosdata", fqdn, 9040);
-    taosMsleep(1100);
-  }
-
-  static void TearDownTestSuite() {
-    stopServer(pServer);
-    dropClient(pClient);
-    pServer = NULL;
-    pClient = NULL;
-  }
-
-  static SServer* pServer;
-  static SClient* pClient;
-  static int32_t  connId;
+  static Testbase test;
 
  public:
   void SetUp() override {}
   void TearDown() override {}
-
-  void SendTheCheckShowMetaMsg(int8_t showType, const char* showName, int32_t columns, const char* db) {
-    SShowMsg* pShow = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));
-    pShow->type = showType;
-    if (db != NULL) {
-      strcpy(pShow->db, db);
-    }
-    SRpcMsg showRpcMsg = {0};
-    showRpcMsg.pCont = pShow;
-    showRpcMsg.contLen = sizeof(SShowMsg);
-    showRpcMsg.msgType = TSDB_MSG_TYPE_SHOW;
-
-    sendMsg(pClient, &showRpcMsg);
-    ASSERT_NE(pClient->pRsp, nullptr);
-    ASSERT_EQ(pClient->pRsp->code, 0);
-    ASSERT_NE(pClient->pRsp->pCont, nullptr);
-
-    SShowRsp* pShowRsp = (SShowRsp*)pClient->pRsp->pCont;
-    ASSERT_NE(pShowRsp, nullptr);
-    pShowRsp->showId = htonl(pShowRsp->showId);
-    pMeta = &pShowRsp->tableMeta;
-    pMeta->numOfTags = htonl(pMeta->numOfTags);
-    pMeta->numOfColumns = htonl(pMeta->numOfColumns);
-    pMeta->sversion = htonl(pMeta->sversion);
-    pMeta->tversion = htonl(pMeta->tversion);
-    pMeta->tuid = htobe64(pMeta->tuid);
-    pMeta->suid = htobe64(pMeta->suid);
-
-    showId = pShowRsp->showId;
-
-    EXPECT_NE(pShowRsp->showId, 0);
-    EXPECT_STREQ(pMeta->tbFname, showName);
-    EXPECT_EQ(pMeta->numOfTags, 0);
-    EXPECT_EQ(pMeta->numOfColumns, columns);
-    EXPECT_EQ(pMeta->precision, 0);
-    EXPECT_EQ(pMeta->tableType, 0);
-    EXPECT_EQ(pMeta->update, 0);
-    EXPECT_EQ(pMeta->sversion, 0);
-    EXPECT_EQ(pMeta->tversion, 0);
-    EXPECT_EQ(pMeta->tuid, 0);
-    EXPECT_EQ(pMeta->suid, 0);
-  }
-
-  void CheckSchema(int32_t index, int8_t type, int32_t bytes, const char* name) {
-    SSchema* pSchema = &pMeta->pSchema[index];
-    pSchema->bytes = htonl(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, type);
-    EXPECT_EQ(pSchema->bytes, bytes);
-    EXPECT_STREQ(pSchema->name, name);
-  }
-
-  void SendThenCheckShowRetrieveMsg(int32_t rows) {
-    SRetrieveTableMsg* pRetrieve = (SRetrieveTableMsg*)rpcMallocCont(sizeof(SRetrieveTableMsg));
-    pRetrieve->showId = htonl(showId);
-    pRetrieve->free = 0;
-
-    SRpcMsg retrieveRpcMsg = {0};
-    retrieveRpcMsg.pCont = pRetrieve;
-    retrieveRpcMsg.contLen = sizeof(SRetrieveTableMsg);
-    retrieveRpcMsg.msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE;
-
-    sendMsg(pClient, &retrieveRpcMsg);
-
-    ASSERT_NE(pClient->pRsp, nullptr);
-    ASSERT_EQ(pClient->pRsp->code, 0);
-    ASSERT_NE(pClient->pRsp->pCont, nullptr);
-
-    pRetrieveRsp = (SRetrieveTableRsp*)pClient->pRsp->pCont;
-    ASSERT_NE(pRetrieveRsp, nullptr);
-    pRetrieveRsp->numOfRows = htonl(pRetrieveRsp->numOfRows);
-    pRetrieveRsp->useconds = htobe64(pRetrieveRsp->useconds);
-    pRetrieveRsp->compLen = htonl(pRetrieveRsp->compLen);
-
-    EXPECT_EQ(pRetrieveRsp->numOfRows, rows);
-    EXPECT_EQ(pRetrieveRsp->useconds, 0);
-    // EXPECT_EQ(pRetrieveRsp->completed, completed);
-    EXPECT_EQ(pRetrieveRsp->precision, TSDB_TIME_PRECISION_MILLI);
-    EXPECT_EQ(pRetrieveRsp->compressed, 0);
-    EXPECT_EQ(pRetrieveRsp->compLen, 0);
-
-    pData = pRetrieveRsp->data;
-    pos = 0;
-  }
-
-  void CheckInt8(int8_t val) {
-    int8_t data = *((int8_t*)(pData + pos));
-    pos += sizeof(int8_t);
-    EXPECT_EQ(data, val);
-  }
-
-  void CheckInt16(int16_t val) {
-    int16_t data = *((int16_t*)(pData + pos));
-    pos += sizeof(int16_t);
-    EXPECT_EQ(data, val);
-  }
-
-  void CheckInt32(int32_t val) {
-    int32_t data = *((int32_t*)(pData + pos));
-    pos += sizeof(int32_t);
-    EXPECT_EQ(data, val);
-  }
-
-  void CheckInt64(int64_t val) {
-    int64_t data = *((int64_t*)(pData + pos));
-    pos += sizeof(int64_t);
-    EXPECT_EQ(data, val);
-  }
-
-  void CheckTimestamp() {
-    int64_t data = *((int64_t*)(pData + pos));
-    pos += sizeof(int64_t);
-    EXPECT_GT(data, 0);
-  }
-
-  void CheckBinary(const char* val, int32_t len) {
-    pos += sizeof(VarDataLenT);
-    char* data = (char*)(pData + pos);
-    pos += len;
-    EXPECT_STREQ(data, val);
-  }
-
-  int32_t            showId;
-  STableMetaMsg*     pMeta;
-  SRetrieveTableRsp* pRetrieveRsp;
-  char*              pData;
-  int32_t            pos;
 };
 
-SServer* DndTestDb::pServer;
-SClient* DndTestDb::pClient;
-int32_t  DndTestDb::connId;
+Testbase DndTestDb::test;
 
 TEST_F(DndTestDb, 01_ShowDb) {
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 17, NULL);
-  CheckSchema(0, TSDB_DATA_TYPE_BINARY, TSDB_DB_NAME_LEN - 1 + VARSTR_HEADER_SIZE, "name");
-  CheckSchema(1, TSDB_DATA_TYPE_TIMESTAMP, 8, "create_time");
-  CheckSchema(2, TSDB_DATA_TYPE_SMALLINT, 2, "vgroups");
-  CheckSchema(3, TSDB_DATA_TYPE_SMALLINT, 2, "replica");
-  CheckSchema(4, TSDB_DATA_TYPE_SMALLINT, 2, "quorum");
-  CheckSchema(5, TSDB_DATA_TYPE_SMALLINT, 2, "days");
-  CheckSchema(6, TSDB_DATA_TYPE_BINARY, 24 + VARSTR_HEADER_SIZE, "keep0,keep1,keep2");
-  CheckSchema(7, TSDB_DATA_TYPE_INT, 4, "cache");
-  CheckSchema(8, TSDB_DATA_TYPE_INT, 4, "blocks");
-  CheckSchema(9, TSDB_DATA_TYPE_INT, 4, "minrows");
-  CheckSchema(10, TSDB_DATA_TYPE_INT, 4, "maxrows");
-  CheckSchema(11, TSDB_DATA_TYPE_TINYINT, 1, "wallevel");
-  CheckSchema(12, TSDB_DATA_TYPE_INT, 4, "fsync");
-  CheckSchema(13, TSDB_DATA_TYPE_TINYINT, 1, "comp");
-  CheckSchema(14, TSDB_DATA_TYPE_TINYINT, 1, "cachelast");
-  CheckSchema(15, TSDB_DATA_TYPE_BINARY, 3 + VARSTR_HEADER_SIZE, "precision");
-  CheckSchema(16, TSDB_DATA_TYPE_TINYINT, 1, "update");
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_DB, "");
+  CHECK_META("show databases", 17);
+  CHECK_SCHEMA(0, TSDB_DATA_TYPE_BINARY, TSDB_DB_NAME_LEN - 1 + VARSTR_HEADER_SIZE, "name");
+  CHECK_SCHEMA(1, TSDB_DATA_TYPE_TIMESTAMP, 8, "create_time");
+  CHECK_SCHEMA(2, TSDB_DATA_TYPE_SMALLINT, 2, "vgroups");
+  CHECK_SCHEMA(3, TSDB_DATA_TYPE_SMALLINT, 2, "replica");
+  CHECK_SCHEMA(4, TSDB_DATA_TYPE_SMALLINT, 2, "quorum");
+  CHECK_SCHEMA(5, TSDB_DATA_TYPE_SMALLINT, 2, "days");
+  CHECK_SCHEMA(6, TSDB_DATA_TYPE_BINARY, 24 + VARSTR_HEADER_SIZE, "keep0,keep1,keep2");
+  CHECK_SCHEMA(7, TSDB_DATA_TYPE_INT, 4, "cache");
+  CHECK_SCHEMA(8, TSDB_DATA_TYPE_INT, 4, "blocks");
+  CHECK_SCHEMA(9, TSDB_DATA_TYPE_INT, 4, "minrows");
+  CHECK_SCHEMA(10, TSDB_DATA_TYPE_INT, 4, "maxrows");
+  CHECK_SCHEMA(11, TSDB_DATA_TYPE_TINYINT, 1, "wallevel");
+  CHECK_SCHEMA(12, TSDB_DATA_TYPE_INT, 4, "fsync");
+  CHECK_SCHEMA(13, TSDB_DATA_TYPE_TINYINT, 1, "comp");
+  CHECK_SCHEMA(14, TSDB_DATA_TYPE_TINYINT, 1, "cachelast");
+  CHECK_SCHEMA(15, TSDB_DATA_TYPE_BINARY, 3 + VARSTR_HEADER_SIZE, "precision");
+  CHECK_SCHEMA(16, TSDB_DATA_TYPE_TINYINT, 1, "update");
 
-  SendThenCheckShowRetrieveMsg(0);
+  test.SendShowRetrieveMsg();
+  EXPECT_EQ(test.GetShowRows(), 0);
 }
 
 TEST_F(DndTestDb, 02_Create_Alter_Drop_Db) {
   {
-    SCreateDbMsg* pReq = (SCreateDbMsg*)rpcMallocCont(sizeof(SCreateDbMsg));
+    int32_t contLen = sizeof(SCreateDbMsg);
+
+    SCreateDbMsg* pReq = (SCreateDbMsg*)rpcMallocCont(contLen);
     strcpy(pReq->db, "1.d1");
     pReq->numOfVgroups = htonl(2);
     pReq->cacheBlockSize = htonl(16);
@@ -223,20 +76,16 @@ TEST_F(DndTestDb, 02_Create_Alter_Drop_Db) {
     pReq->cacheLastRow = 0;
     pReq->ignoreExist = 1;
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SCreateDbMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_CREATE_DB;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
+    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_DB, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
-    // taosMsleep(1000000);
   }
 
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 17, NULL);
-  SendThenCheckShowRetrieveMsg(1);
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_DB, "");
+  CHECK_META("show databases", 17);
+
+  test.SendShowRetrieveMsg();
+  EXPECT_EQ(test.GetShowRows(), 1);
   CheckBinary("d1", TSDB_DB_NAME_LEN - 1);
   CheckTimestamp();
   CheckInt16(2);                      // vgroups
@@ -255,12 +104,15 @@ TEST_F(DndTestDb, 02_Create_Alter_Drop_Db) {
   CheckBinary("ms", 3);               // precision
   CheckInt8(0);                       // update
 
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_VGROUP, "show vgroups", 4, "1.d1");
-  CheckSchema(0, TSDB_DATA_TYPE_INT, 4, "vgId");
-  CheckSchema(1, TSDB_DATA_TYPE_INT, 4, "tables");
-  CheckSchema(2, TSDB_DATA_TYPE_SMALLINT, 2, "v1_dnode");
-  CheckSchema(3, TSDB_DATA_TYPE_BINARY, 9 + VARSTR_HEADER_SIZE, "v1_status");
-  SendThenCheckShowRetrieveMsg(2);
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_VGROUP, "1.d1");
+  CHECK_META("show vgroups", 4);
+  CHECK_SCHEMA(0, TSDB_DATA_TYPE_INT, 4, "vgId");
+  CHECK_SCHEMA(1, TSDB_DATA_TYPE_INT, 4, "tables");
+  CHECK_SCHEMA(2, TSDB_DATA_TYPE_SMALLINT, 2, "v1_dnode");
+  CHECK_SCHEMA(3, TSDB_DATA_TYPE_BINARY, 9 + VARSTR_HEADER_SIZE, "v1_status");
+
+  test.SendShowRetrieveMsg();
+  EXPECT_EQ(test.GetShowRows(), 2);
   CheckInt32(1);
   CheckInt32(2);
   CheckInt32(0);
@@ -271,7 +123,9 @@ TEST_F(DndTestDb, 02_Create_Alter_Drop_Db) {
   CheckBinary("master", 9);
 
   {
-    SAlterDbMsg* pReq = (SAlterDbMsg*)rpcMallocCont(sizeof(SAlterDbMsg));
+    int32_t contLen = sizeof(SAlterDbMsg);
+
+    SAlterDbMsg* pReq = (SAlterDbMsg*)rpcMallocCont(contLen);
     strcpy(pReq->db, "1.d1");
     pReq->totalBlocks = htonl(12);
     pReq->daysToKeep0 = htonl(300);
@@ -282,19 +136,14 @@ TEST_F(DndTestDb, 02_Create_Alter_Drop_Db) {
     pReq->quorum = 2;
     pReq->cacheLastRow = 1;
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SAlterDbMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_ALTER_DB;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
+    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_ALTER_DB, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
 
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 17, NULL);
-  SendThenCheckShowRetrieveMsg(1);
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_DB, "");
+  test.SendShowRetrieveMsg();
+  EXPECT_EQ(test.GetShowRows(), 1);
   CheckBinary("d1", TSDB_DB_NAME_LEN - 1);
   CheckTimestamp();
   CheckInt16(2);                   // vgroups
@@ -314,19 +163,14 @@ TEST_F(DndTestDb, 02_Create_Alter_Drop_Db) {
   CheckInt8(0);                    // update
 
   // restart
-  stopServer(pServer);
-  pServer = NULL;
+  test.Restart();
 
-  uInfo("start all server");
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_DB, "");
+  CHECK_META("show databases", 17);
 
-  const char* fqdn = "localhost";
-  const char* firstEp = "localhost:9040";
-  pServer = startServer("/tmp/dnode_test_db", fqdn, 9040, firstEp);
+  test.SendShowRetrieveMsg();
+  EXPECT_EQ(test.GetShowRows(), 1);
 
-  uInfo("all server is running");
-
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 17, NULL);
-  SendThenCheckShowRetrieveMsg(1);
   CheckBinary("d1", TSDB_DB_NAME_LEN - 1);
   CheckTimestamp();
   CheckInt16(2);                   // vgroups
@@ -346,27 +190,28 @@ TEST_F(DndTestDb, 02_Create_Alter_Drop_Db) {
   CheckInt8(0);                    // update
 
   {
-    SDropDbMsg* pReq = (SDropDbMsg*)rpcMallocCont(sizeof(SDropDbMsg));
+    int32_t contLen = sizeof(SDropDbMsg);
+
+    SDropDbMsg* pReq = (SDropDbMsg*)rpcMallocCont(contLen);
     strcpy(pReq->db, "1.d1");
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SDropDbMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_DROP_DB;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
+    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_DROP_DB, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
 
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 17, NULL);
-  SendThenCheckShowRetrieveMsg(0);
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_DB, "");
+  CHECK_META("show databases", 17);
+
+  test.SendShowRetrieveMsg();
+  EXPECT_EQ(test.GetShowRows(), 0);
 }
 
 TEST_F(DndTestDb, 03_Create_Use_Restart_Use_Db) {
   {
-    SCreateDbMsg* pReq = (SCreateDbMsg*)rpcMallocCont(sizeof(SCreateDbMsg));
+    int32_t contLen = sizeof(SCreateDbMsg);
+
+    SCreateDbMsg* pReq = (SCreateDbMsg*)rpcMallocCont(contLen);
     strcpy(pReq->db, "1.d2");
     pReq->numOfVgroups = htonl(2);
     pReq->cacheBlockSize = htonl(16);
@@ -388,33 +233,26 @@ TEST_F(DndTestDb, 03_Create_Use_Restart_Use_Db) {
     pReq->cacheLastRow = 0;
     pReq->ignoreExist = 1;
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SCreateDbMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_CREATE_DB;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
+    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_DB, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
 
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 17, NULL);
-  SendThenCheckShowRetrieveMsg(1);
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_DB, "");
+  CHECK_META("show databases", 17);
+
+  test.SendShowRetrieveMsg();
+  EXPECT_EQ(test.GetShowRows(), 1);
   CheckBinary("d2", TSDB_DB_NAME_LEN - 1);
 
   {
-    SUseDbMsg* pReq = (SUseDbMsg*)rpcMallocCont(sizeof(SUseDbMsg));
+    int32_t contLen = sizeof(SUseDbMsg);
+
+    SUseDbMsg* pReq = (SUseDbMsg*)rpcMallocCont(contLen);
     strcpy(pReq->db, "1.d2");
     pReq->vgVersion = htonl(-1);
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SUseDbMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_USE_DB;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
+    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_USE_DB, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
 

source/dnode/mgmt/impl/test/dnode/CMakeLists.txt

@@ -1,24 +1,8 @@
-add_executable(dnode_test_dnode "")
-
-target_sources(dnode_test_dnode
-    PRIVATE
-    "dnode.cpp"
-    "../sut/deploy.cpp"
-)
-
+aux_source_directory(. DTEST_SRC)
+add_executable(dnode_test_dnode ${DTEST_SRC})
 target_link_libraries(
     dnode_test_dnode
-    PUBLIC dnode
-    PUBLIC util
-    PUBLIC os
-    PUBLIC gtest_main
-)
-
-target_include_directories(dnode_test_dnode
-    PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/server/dnode/mgmt"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../../inc"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
+    PUBLIC sut
 )
 
 add_test(

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

@@ -9,189 +9,62 @@
  *
  */
 
-#include "deploy.h"
+#include "base.h"
 
 class DndTestDnode : public ::testing::Test {
- public:
-  static SServer* CreateServer(const char* path, const char* fqdn, uint16_t port, const char* firstEp) {
-    SServer* pServer = createServer(path, fqdn, port, firstEp);
-    ASSERT(pServer);
-    return pServer;
-  }
-
-  static void SetUpTestSuite() {
-    initLog("/tmp/tdlog");
-
-    const char* fqdn = "localhost";
-    const char* firstEp = "localhost:9041";
-    pServer1 = CreateServer("/tmp/dnode_test_dnode1", fqdn, 9041, firstEp);
-    pServer2 = CreateServer("/tmp/dnode_test_dnode2", fqdn, 9042, firstEp);
-    pServer3 = CreateServer("/tmp/dnode_test_dnode3", fqdn, 9043, firstEp);
-    pServer4 = CreateServer("/tmp/dnode_test_dnode4", fqdn, 9044, firstEp);
-    pServer5 = CreateServer("/tmp/dnode_test_dnode5", fqdn, 9045, firstEp);
-    pClient = createClient("root", "taosdata", fqdn, 9041);
-    taosMsleep(300);
-  }
-
-  static void TearDownTestSuite() {
-    stopServer(pServer1);
-    stopServer(pServer2);
-    stopServer(pServer3);
-    stopServer(pServer4);
-    stopServer(pServer5);
-    dropClient(pClient);
-    pServer1 = NULL;
-    pServer2 = NULL;
-    pServer3 = NULL;
-    pServer4 = NULL;
-    pServer5 = NULL;
-    pClient = NULL;
-  }
-
-  static SServer* pServer1;
-  static SServer* pServer2;
-  static SServer* pServer3;
-  static SServer* pServer4;
-  static SServer* pServer5;
-  static SClient* pClient;
-
  public:
   void SetUp() override {}
   void TearDown() override {}
 
-  void SendTheCheckShowMetaMsg(int8_t showType, const char* showName, int32_t columns) {
-    SShowMsg* pShow = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));
-    pShow->type = showType;
-    strcpy(pShow->db, "");
+ public:
+  static void SetUpTestSuite() {
+    test.Init("/tmp/dnode_test_dnode1", 9041);
+    const char* fqdn = "localhost";
+    const char* firstEp = "localhost:9041";
 
-    SRpcMsg showRpcMsg = {0};
-    showRpcMsg.pCont = pShow;
-    showRpcMsg.contLen = sizeof(SShowMsg);
-    showRpcMsg.msgType = TSDB_MSG_TYPE_SHOW;
-
-    sendMsg(pClient, &showRpcMsg);
-    ASSERT_NE(pClient->pRsp, nullptr);
-    ASSERT_EQ(pClient->pRsp->code, 0);
-    ASSERT_NE(pClient->pRsp->pCont, nullptr);
-
-    SShowRsp* pShowRsp = (SShowRsp*)pClient->pRsp->pCont;
-    ASSERT_NE(pShowRsp, nullptr);
-    pShowRsp->showId = htonl(pShowRsp->showId);
-    pMeta = &pShowRsp->tableMeta;
-    pMeta->numOfTags = htonl(pMeta->numOfTags);
-    pMeta->numOfColumns = htonl(pMeta->numOfColumns);
-    pMeta->sversion = htonl(pMeta->sversion);
-    pMeta->tversion = htonl(pMeta->tversion);
-    pMeta->tuid = htobe64(pMeta->tuid);
-    pMeta->suid = htobe64(pMeta->suid);
-
-    showId = pShowRsp->showId;
-
-    EXPECT_NE(pShowRsp->showId, 0);
-    EXPECT_STREQ(pMeta->tbFname, showName);
-    EXPECT_EQ(pMeta->numOfTags, 0);
-    EXPECT_EQ(pMeta->numOfColumns, columns);
-    EXPECT_EQ(pMeta->precision, 0);
-    EXPECT_EQ(pMeta->tableType, 0);
-    EXPECT_EQ(pMeta->update, 0);
-    EXPECT_EQ(pMeta->sversion, 0);
-    EXPECT_EQ(pMeta->tversion, 0);
-    EXPECT_EQ(pMeta->tuid, 0);
-    EXPECT_EQ(pMeta->suid, 0);
+    server2.Start("/tmp/dnode_test_dnode2", fqdn, 9042, firstEp);
+    server3.Start("/tmp/dnode_test_dnode3", fqdn, 9043, firstEp);
+    server4.Start("/tmp/dnode_test_dnode4", fqdn, 9044, firstEp);
+    server5.Start("/tmp/dnode_test_dnode5", fqdn, 9045, firstEp);
+    taosMsleep(300);
   }
 
-  void CheckSchema(int32_t index, int8_t type, int32_t bytes, const char* name) {
-    SSchema* pSchema = &pMeta->pSchema[index];
-    pSchema->bytes = htonl(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, type);
-    EXPECT_EQ(pSchema->bytes, bytes);
-    EXPECT_STREQ(pSchema->name, name);
+  static void TearDownTestSuite() {
+    server2.Stop();
+    server3.Stop();
+    server4.Stop();
+    server5.Stop();
+    test.Cleanup();
   }
 
-  void SendThenCheckShowRetrieveMsg(int32_t rows) {
-    SRetrieveTableMsg* pRetrieve = (SRetrieveTableMsg*)rpcMallocCont(sizeof(SRetrieveTableMsg));
-    pRetrieve->showId = htonl(showId);
-    pRetrieve->free = 0;
-
-    SRpcMsg retrieveRpcMsg = {0};
-    retrieveRpcMsg.pCont = pRetrieve;
-    retrieveRpcMsg.contLen = sizeof(SRetrieveTableMsg);
-    retrieveRpcMsg.msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE;
-
-    sendMsg(pClient, &retrieveRpcMsg);
-
-    ASSERT_NE(pClient->pRsp, nullptr);
-    ASSERT_EQ(pClient->pRsp->code, 0);
-    ASSERT_NE(pClient->pRsp->pCont, nullptr);
-
-    pRetrieveRsp = (SRetrieveTableRsp*)pClient->pRsp->pCont;
-    ASSERT_NE(pRetrieveRsp, nullptr);
-    pRetrieveRsp->numOfRows = htonl(pRetrieveRsp->numOfRows);
-    pRetrieveRsp->useconds = htobe64(pRetrieveRsp->useconds);
-    pRetrieveRsp->compLen = htonl(pRetrieveRsp->compLen);
-
-    EXPECT_EQ(pRetrieveRsp->numOfRows, rows);
-    EXPECT_EQ(pRetrieveRsp->useconds, 0);
-    // EXPECT_EQ(pRetrieveRsp->completed, completed);
-    EXPECT_EQ(pRetrieveRsp->precision, TSDB_TIME_PRECISION_MILLI);
-    EXPECT_EQ(pRetrieveRsp->compressed, 0);
-    EXPECT_EQ(pRetrieveRsp->compLen, 0);
-
-    pData = pRetrieveRsp->data;
-    pos = 0;
-  }
-
-  void CheckInt16(int16_t val) {
-    int16_t data = *((int16_t*)(pData + pos));
-    pos += sizeof(int16_t);
-    EXPECT_EQ(data, val);
-  }
-
-  void CheckInt64(int64_t val) {
-    int64_t data = *((int64_t*)(pData + pos));
-    pos += sizeof(int64_t);
-    EXPECT_EQ(data, val);
-  }
-
-  void CheckTimestamp() {
-    int64_t data = *((int64_t*)(pData + pos));
-    pos += sizeof(int64_t);
-    EXPECT_GT(data, 0);
-  }
-
-  void CheckBinary(const char* val, int32_t len) {
-    pos += sizeof(VarDataLenT);
-    char* data = (char*)(pData + pos);
-    pos += len;
-    EXPECT_STREQ(data, val);
-  }
-
-  int32_t            showId;
-  STableMetaMsg*     pMeta;
-  SRetrieveTableRsp* pRetrieveRsp;
-  char*              pData;
-  int32_t            pos;
+  static Testbase   test;
+  static TestServer server2;
+  static TestServer server3;
+  static TestServer server4;
+  static TestServer server5;
 };
 
-SServer* DndTestDnode::pServer1;
-SServer* DndTestDnode::pServer2;
-SServer* DndTestDnode::pServer3;
-SServer* DndTestDnode::pServer4;
-SServer* DndTestDnode::pServer5;
-SClient* DndTestDnode::pClient;
+Testbase   DndTestDnode::test;
+TestServer DndTestDnode::server2;
+TestServer DndTestDnode::server3;
+TestServer DndTestDnode::server4;
+TestServer DndTestDnode::server5;
 
 TEST_F(DndTestDnode, 01_ShowDnode) {
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DNODE, "show dnodes", 7);
-  CheckSchema(0, TSDB_DATA_TYPE_SMALLINT, 2, "id");
-  CheckSchema(1, TSDB_DATA_TYPE_BINARY, TSDB_EP_LEN + VARSTR_HEADER_SIZE, "endpoint");
-  CheckSchema(2, TSDB_DATA_TYPE_SMALLINT, 2, "vnodes");
-  CheckSchema(3, TSDB_DATA_TYPE_SMALLINT, 2, "max_vnodes");
-  CheckSchema(4, TSDB_DATA_TYPE_BINARY, 10 + VARSTR_HEADER_SIZE, "status");
-  CheckSchema(5, TSDB_DATA_TYPE_TIMESTAMP, 8, "create_time");
-  CheckSchema(6, TSDB_DATA_TYPE_BINARY, 24 + VARSTR_HEADER_SIZE, "offline_reason");
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_DNODE, "");
+  CHECK_META("show dnodes", 7);
+
+  CHECK_SCHEMA(0, TSDB_DATA_TYPE_SMALLINT, 2, "id");
+  CHECK_SCHEMA(1, TSDB_DATA_TYPE_BINARY, TSDB_EP_LEN + VARSTR_HEADER_SIZE, "endpoint");
+  CHECK_SCHEMA(2, TSDB_DATA_TYPE_SMALLINT, 2, "vnodes");
+  CHECK_SCHEMA(3, TSDB_DATA_TYPE_SMALLINT, 2, "max_vnodes");
+  CHECK_SCHEMA(4, TSDB_DATA_TYPE_BINARY, 10 + VARSTR_HEADER_SIZE, "status");
+  CHECK_SCHEMA(5, TSDB_DATA_TYPE_TIMESTAMP, 8, "create_time");
+  CHECK_SCHEMA(6, TSDB_DATA_TYPE_BINARY, 24 + VARSTR_HEADER_SIZE, "offline_reason");
+
+  test.SendShowRetrieveMsg();
+  EXPECT_EQ(test.GetShowRows(), 1);
 
-  SendThenCheckShowRetrieveMsg(1);
   CheckInt16(1);
   CheckBinary("localhost:9041", TSDB_EP_LEN);
   CheckInt16(0);
@@ -202,40 +75,36 @@ TEST_F(DndTestDnode, 01_ShowDnode) {
 }
 
 TEST_F(DndTestDnode, 02_ConfigDnode) {
-  SCfgDnodeMsg* pReq = (SCfgDnodeMsg*)rpcMallocCont(sizeof(SCfgDnodeMsg));
+  int32_t contLen = sizeof(SCfgDnodeMsg);
+
+  SCfgDnodeMsg* pReq = (SCfgDnodeMsg*)rpcMallocCont(contLen);
   pReq->dnodeId = htonl(1);
   strcpy(pReq->config, "ddebugflag 131");
 
-  SRpcMsg rpcMsg = {0};
-  rpcMsg.pCont = pReq;
-  rpcMsg.contLen = sizeof(SCfgDnodeMsg);
-  rpcMsg.msgType = TSDB_MSG_TYPE_CONFIG_DNODE;
-
-  sendMsg(pClient, &rpcMsg);
-  SRpcMsg* pMsg = pClient->pRsp;
+  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CONFIG_DNODE, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, 0);
 }
 
 TEST_F(DndTestDnode, 03_Create_Drop_Restart_Dnode) {
   {
-    SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(sizeof(SCreateDnodeMsg));
+    int32_t contLen = sizeof(SCreateDnodeMsg);
+
+    SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen);
     strcpy(pReq->ep, "localhost:9042");
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SCreateDnodeMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_CREATE_DNODE;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
+    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_DNODE, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
 
   taosMsleep(1300);
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DNODE, "show dnodes", 7);
-  SendThenCheckShowRetrieveMsg(2);
+
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_DNODE, "");
+  CHECK_META("show dnodes", 7);
+  test.SendShowRetrieveMsg();
+  EXPECT_EQ(test.GetShowRows(), 2);
+
   CheckInt16(1);
   CheckInt16(2);
   CheckBinary("localhost:9041", TSDB_EP_LEN);
@@ -252,22 +121,21 @@ TEST_F(DndTestDnode, 03_Create_Drop_Restart_Dnode) {
   CheckBinary("", 24);
 
   {
-    SDropDnodeMsg* pReq = (SDropDnodeMsg*)rpcMallocCont(sizeof(SDropDnodeMsg));
+    int32_t contLen = sizeof(SDropDnodeMsg);
+
+    SDropDnodeMsg* pReq = (SDropDnodeMsg*)rpcMallocCont(contLen);
     pReq->dnodeId = htonl(2);
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SDropDnodeMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_DROP_DNODE;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
+    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_DROP_DNODE, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
 
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DNODE, "show dnodes", 7);
-  SendThenCheckShowRetrieveMsg(1);
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_DNODE, "");
+  CHECK_META("show dnodes", 7);
+  test.SendShowRetrieveMsg();
+  EXPECT_EQ(test.GetShowRows(), 1);
+
   CheckInt16(1);
   CheckBinary("localhost:9041", TSDB_EP_LEN);
   CheckInt16(0);
@@ -277,53 +145,44 @@ TEST_F(DndTestDnode, 03_Create_Drop_Restart_Dnode) {
   CheckBinary("", 24);
 
   {
-    SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(sizeof(SCreateDnodeMsg));
+    int32_t contLen = sizeof(SCreateDnodeMsg);
+
+    SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen);
     strcpy(pReq->ep, "localhost:9043");
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SCreateDnodeMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_CREATE_DNODE;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
+    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_DNODE, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
 
   {
-    SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(sizeof(SCreateDnodeMsg));
+    int32_t contLen = sizeof(SCreateDnodeMsg);
+
+    SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen);
     strcpy(pReq->ep, "localhost:9044");
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SCreateDnodeMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_CREATE_DNODE;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
+    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_DNODE, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
 
   {
-    SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(sizeof(SCreateDnodeMsg));
+    int32_t contLen = sizeof(SCreateDnodeMsg);
+
+    SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen);
     strcpy(pReq->ep, "localhost:9045");
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SCreateDnodeMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_CREATE_DNODE;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
+    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_DNODE, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
 
   taosMsleep(1300);
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DNODE, "show dnodes", 7);
-  SendThenCheckShowRetrieveMsg(4);
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_DNODE, "");
+  CHECK_META("show dnodes", 7);
+  test.SendShowRetrieveMsg();
+  EXPECT_EQ(test.GetShowRows(), 4);
+
   CheckInt16(1);
   CheckInt16(3);
   CheckInt16(4);
@@ -355,31 +214,18 @@ TEST_F(DndTestDnode, 03_Create_Drop_Restart_Dnode) {
 
   // restart
   uInfo("stop all server");
-  stopServer(pServer1);
-  stopServer(pServer2);
-  stopServer(pServer3);
-  stopServer(pServer4);
-  stopServer(pServer5);
-  pServer1 = NULL;
-  pServer2 = NULL;
-  pServer3 = NULL;
-  pServer4 = NULL;
-  pServer5 = NULL;
-
-  uInfo("start all server");
-
-  const char* fqdn = "localhost";
-  const char* firstEp = "localhost:9041";
-  pServer1 = startServer("/tmp/dnode_test_dnode1", fqdn, 9041, firstEp);
-  pServer3 = startServer("/tmp/dnode_test_dnode3", fqdn, 9043, firstEp);
-  pServer4 = startServer("/tmp/dnode_test_dnode4", fqdn, 9044, firstEp);
-  pServer5 = startServer("/tmp/dnode_test_dnode5", fqdn, 9045, firstEp);
-
-  uInfo("all server is running");
+  test.Restart();
+  server2.Restart();
+  server3.Restart();
+  server4.Restart();
+  server5.Restart();
 
   taosMsleep(1300);
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DNODE, "show dnodes", 7);
-  SendThenCheckShowRetrieveMsg(4);
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_DNODE, "");
+  CHECK_META("show dnodes", 7);
+  test.SendShowRetrieveMsg();
+  EXPECT_EQ(test.GetShowRows(), 4);
+
   CheckInt16(1);
   CheckInt16(3);
   CheckInt16(4);

source/dnode/mgmt/impl/test/profile/CMakeLists.txt

@@ -1,27 +1,11 @@
-add_executable(dndTestProfile "")
-
-target_sources(dndTestProfile
-    PRIVATE
-    "profile.cpp"
-    "../sut/deploy.cpp"
-)
-
+aux_source_directory(. PROFILE_SRC)
+add_executable(dnode_test_profile ${PROFILE_SRC})
 target_link_libraries(
-    dndTestProfile
-    PUBLIC dnode
-    PUBLIC util
-    PUBLIC os
-    PUBLIC gtest_main
-)
-
-target_include_directories(dndTestProfile
-    PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/server/dnode/mgmt"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../../inc"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
+    dnode_test_profile
+    PUBLIC sut
 )
 
 add_test(
-    NAME dndTestProfile
-    COMMAND dndTestProfile
+    NAME dnode_test_profile
+    COMMAND dnode_test_profile
 )

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

@@ -9,55 +9,35 @@
  *
  */
 
-#include "deploy.h"
+#include "base.h"
 
 class DndTestProfile : public ::testing::Test {
  protected:
+  static void SetUpTestSuite() { test.Init("/tmp/dnode_test_profile", 9080); }
+  static void TearDownTestSuite() { test.Cleanup(); }
+
+  static Testbase test;
+
+ public:
   void SetUp() override {}
   void TearDown() override {}
 
-  static void SetUpTestSuite() {
-    const char* user = "root";
-    const char* pass = "taosdata";
-    const char* path = "/tmp/dndTestProfile";
-    const char* fqdn = "localhost";
-    uint16_t    port = 9522;
-
-    pServer = createServer(path, fqdn, port);
-    ASSERT(pServer);
-    pClient = createClient(user, pass, fqdn, port);
-  }
-
-  static void TearDownTestSuite() {
-    stopServer(pServer);
-    dropClient(pClient);
-  }
-
-  static SServer* pServer;
-  static SClient* pClient;
-  static int32_t  connId;
+  int32_t connId;
 };
 
-SServer* DndTestProfile::pServer;
-SClient* DndTestProfile::pClient;
-int32_t  DndTestProfile::connId;
+Testbase DndTestProfile::test;
 
-TEST_F(DndTestProfile, SConnectMsg_01) {
-  ASSERT_NE(pClient, nullptr);
+TEST_F(DndTestProfile, 01_ConnectMsg) {
+  int32_t contLen = sizeof(SConnectMsg);
 
-  SConnectMsg* pReq = (SConnectMsg*)rpcMallocCont(sizeof(SConnectMsg));
+  SConnectMsg* pReq = (SConnectMsg*)rpcMallocCont(contLen);
   pReq->pid = htonl(1234);
-  strcpy(pReq->app, "dndTestProfile");
+  strcpy(pReq->app, "dnode_test_profile");
   strcpy(pReq->db, "");
 
-  SRpcMsg rpcMsg = {0};
-  rpcMsg.pCont = pReq;
-  rpcMsg.contLen = sizeof(SConnectMsg);
-  rpcMsg.msgType = TSDB_MSG_TYPE_CONNECT;
-
-  sendMsg(pClient, &rpcMsg);
-  SRpcMsg* pMsg = pClient->pRsp;
+  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CONNECT, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
+  ASSERT_EQ(pMsg->code, 0);
 
   SConnectRsp* pRsp = (SConnectRsp*)pMsg->pCont;
   ASSERT_NE(pRsp, nullptr);
@@ -69,183 +49,65 @@ TEST_F(DndTestProfile, SConnectMsg_01) {
   EXPECT_EQ(pRsp->acctId, 1);
   EXPECT_GT(pRsp->clusterId, 0);
   EXPECT_EQ(pRsp->connId, 1);
-  EXPECT_EQ(pRsp->superAuth, 1);
-  EXPECT_EQ(pRsp->readAuth, 1);
-  EXPECT_EQ(pRsp->writeAuth, 1);
+  EXPECT_EQ(pRsp->superUser, 1);
 
   EXPECT_EQ(pRsp->epSet.inUse, 0);
   EXPECT_EQ(pRsp->epSet.numOfEps, 1);
-  EXPECT_EQ(pRsp->epSet.port[0], 9522);
+  EXPECT_EQ(pRsp->epSet.port[0], 9080);
   EXPECT_STREQ(pRsp->epSet.fqdn[0], "localhost");
 
   connId = pRsp->connId;
 }
 
-TEST_F(DndTestProfile, SConnectMsg_02) {
-  ASSERT_NE(pClient, nullptr);
+TEST_F(DndTestProfile, 02_ConnectMsg_InvalidDB) {
+  int32_t contLen = sizeof(SConnectMsg);
 
-  SConnectMsg* pReq = (SConnectMsg*)rpcMallocCont(sizeof(SConnectMsg));
+  SConnectMsg* pReq = (SConnectMsg*)rpcMallocCont(contLen);
   pReq->pid = htonl(1234);
-  strcpy(pReq->app, "dndTestProfile");
+  strcpy(pReq->app, "dnode_test_profile");
   strcpy(pReq->db, "invalid_db");
 
-  SRpcMsg rpcMsg = {0};
-  rpcMsg.pCont = pReq;
-  rpcMsg.contLen = sizeof(SConnectMsg);
-  rpcMsg.msgType = TSDB_MSG_TYPE_CONNECT;
-
-  sendMsg(pClient, &rpcMsg);
-  SRpcMsg* pMsg = pClient->pRsp;
+  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CONNECT, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, TSDB_CODE_MND_INVALID_DB);
   ASSERT_EQ(pMsg->contLen, 0);
 }
 
-TEST_F(DndTestProfile, SConnectMsg_03) {
-  ASSERT_NE(pClient, nullptr);
-  int32_t showId = 0;
+TEST_F(DndTestProfile, 03_ConnectMsg_Show) {
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_CONNS, "");
+  CHECK_META("show connections", 7);
+  CHECK_SCHEMA(0, TSDB_DATA_TYPE_INT, 4, "connId");
+  CHECK_SCHEMA(1, TSDB_DATA_TYPE_BINARY, TSDB_USER_LEN + VARSTR_HEADER_SIZE, "user");
+  CHECK_SCHEMA(2, TSDB_DATA_TYPE_BINARY, TSDB_APP_NAME_LEN + VARSTR_HEADER_SIZE, "program");
+  CHECK_SCHEMA(3, TSDB_DATA_TYPE_INT, 4, "pid");
+  CHECK_SCHEMA(4, TSDB_DATA_TYPE_BINARY, TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE, "ip:port");
+  CHECK_SCHEMA(5, TSDB_DATA_TYPE_TIMESTAMP, 8, "login_time");
+  CHECK_SCHEMA(6, TSDB_DATA_TYPE_TIMESTAMP, 8, "last_access");
 
-  {
-    SShowMsg* pReq = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));
-    pReq->type = TSDB_MGMT_TABLE_CONNS;
-    strcpy(pReq->db, "");
-
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SShowMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_SHOW;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
-    ASSERT_NE(pMsg, nullptr);
-
-    SShowRsp* pRsp = (SShowRsp*)pMsg->pCont;
-    ASSERT_NE(pRsp, nullptr);
-    pRsp->showId = htonl(pRsp->showId);
-    STableMetaMsg* pMeta = &pRsp->tableMeta;
-    pMeta->contLen = htonl(pMeta->contLen);
-    pMeta->numOfColumns = htons(pMeta->numOfColumns);
-    pMeta->sversion = htons(pMeta->sversion);
-    pMeta->tversion = htons(pMeta->tversion);
-    pMeta->tid = htonl(pMeta->tid);
-    pMeta->uid = htobe64(pMeta->uid);
-    pMeta->suid = htobe64(pMeta->suid);
-
-    showId = pRsp->showId;
-
-    EXPECT_NE(pRsp->showId, 0);
-    EXPECT_EQ(pMeta->contLen, 0);
-    EXPECT_STREQ(pMeta->tbFname, "");
-    EXPECT_EQ(pMeta->numOfTags, 0);
-    EXPECT_EQ(pMeta->precision, 0);
-    EXPECT_EQ(pMeta->tableType, 0);
-    EXPECT_EQ(pMeta->numOfColumns, 7);
-    EXPECT_EQ(pMeta->sversion, 0);
-    EXPECT_EQ(pMeta->tversion, 0);
-    EXPECT_EQ(pMeta->tid, 0);
-    EXPECT_EQ(pMeta->uid, 0);
-    EXPECT_STREQ(pMeta->sTableName, "");
-    EXPECT_EQ(pMeta->suid, 0);
-
-    SSchema* pSchema = NULL;
-    pSchema = &pMeta->pSchema[0];
-    pSchema->bytes = htons(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_INT);
-    EXPECT_EQ(pSchema->bytes, 4);
-    EXPECT_STREQ(pSchema->name, "connId");
-
-    pSchema = &pMeta->pSchema[1];
-    pSchema->bytes = htons(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_BINARY);
-    EXPECT_EQ(pSchema->bytes, TSDB_USER_LEN + VARSTR_HEADER_SIZE);
-    EXPECT_STREQ(pSchema->name, "user");
-
-    pSchema = &pMeta->pSchema[2];
-    pSchema->bytes = htons(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_BINARY);
-    EXPECT_EQ(pSchema->bytes, TSDB_USER_LEN + VARSTR_HEADER_SIZE);
-    EXPECT_STREQ(pSchema->name, "program");
-
-    pSchema = &pMeta->pSchema[3];
-    pSchema->bytes = htons(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_INT);
-    EXPECT_EQ(pSchema->bytes, 4);
-    EXPECT_STREQ(pSchema->name, "pid");
-
-    pSchema = &pMeta->pSchema[4];
-    pSchema->bytes = htons(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_BINARY);
-    EXPECT_EQ(pSchema->bytes, TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE);
-    EXPECT_STREQ(pSchema->name, "ip:port");
-
-    pSchema = &pMeta->pSchema[5];
-    pSchema->bytes = htons(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_TIMESTAMP);
-    EXPECT_EQ(pSchema->bytes, 8);
-    EXPECT_STREQ(pSchema->name, "login_time");
-
-    pSchema = &pMeta->pSchema[6];
-    pSchema->bytes = htons(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_TIMESTAMP);
-    EXPECT_EQ(pSchema->bytes, 8);
-    EXPECT_STREQ(pSchema->name, "last_access");
-  }
-
-  {
-    SRetrieveTableMsg* pReq = (SRetrieveTableMsg*)rpcMallocCont(sizeof(SRetrieveTableMsg));
-    pReq->showId = htonl(showId);
-    pReq->free = 0;
-
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SRetrieveTableMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
-    ASSERT_NE(pMsg, nullptr);
-    ASSERT_EQ(pMsg->code, 0);
-
-    SRetrieveTableRsp* pRsp = (SRetrieveTableRsp*)pMsg->pCont;
-    ASSERT_NE(pRsp, nullptr);
-    pRsp->numOfRows = htonl(pRsp->numOfRows);
-    pRsp->useconds = htobe64(pRsp->useconds);
-    pRsp->compLen = htonl(pRsp->compLen);
-
-    EXPECT_EQ(pRsp->numOfRows, 1);
-    EXPECT_EQ(pRsp->useconds, 0);
-    EXPECT_EQ(pRsp->completed, 1);
-    EXPECT_EQ(pRsp->precision, TSDB_TIME_PRECISION_MILLI);
-    EXPECT_EQ(pRsp->compressed, 0);
-    EXPECT_EQ(pRsp->compLen, 0);
-  }
+  test.SendShowRetrieveMsg();
+  EXPECT_EQ(test.GetShowRows(), 1);
+  CheckInt32(1);
+  CheckBinary("root", TSDB_USER_LEN);
+  CheckBinary("dnode_test_profile", TSDB_APP_NAME_LEN);
+  CheckInt32(1234);
+  IgnoreBinary(TSDB_IPv4ADDR_LEN + 6);
+  CheckTimestamp();
+  CheckTimestamp();
 }
 
-TEST_F(DndTestProfile, SHeartBeatMsg_01) {
-  ASSERT_NE(pClient, nullptr);
+TEST_F(DndTestProfile, 04_HeartBeatMsg) {
+  int32_t contLen = sizeof(SHeartBeatMsg);
 
-  SHeartBeatMsg* pReq = (SHeartBeatMsg*)rpcMallocCont(sizeof(SHeartBeatMsg));
+  SHeartBeatMsg* pReq = (SHeartBeatMsg*)rpcMallocCont(contLen);
   pReq->connId = htonl(connId);
   pReq->pid = htonl(1234);
   pReq->numOfQueries = htonl(0);
   pReq->numOfStreams = htonl(0);
-  strcpy(pReq->app, "dndTestProfile");
+  strcpy(pReq->app, "dnode_test_profile");
 
-  SRpcMsg rpcMsg = {0};
-  rpcMsg.pCont = pReq;
-  rpcMsg.contLen = sizeof(SHeartBeatMsg);
-  rpcMsg.msgType = TSDB_MSG_TYPE_HEARTBEAT;
-
-  sendMsg(pClient, &rpcMsg);
-  SRpcMsg* pMsg = pClient->pRsp;
+  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_HEARTBEAT, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
+  ASSERT_EQ(pMsg->code, 0);
 
   SHeartBeatRsp* pRsp = (SHeartBeatRsp*)pMsg->pCont;
   ASSERT_NE(pRsp, nullptr);
@@ -265,62 +127,49 @@ TEST_F(DndTestProfile, SHeartBeatMsg_01) {
 
   EXPECT_EQ(pRsp->epSet.inUse, 0);
   EXPECT_EQ(pRsp->epSet.numOfEps, 1);
-  EXPECT_EQ(pRsp->epSet.port[0], 9522);
+  EXPECT_EQ(pRsp->epSet.port[0], 9080);
   EXPECT_STREQ(pRsp->epSet.fqdn[0], "localhost");
 }
 
-TEST_F(DndTestProfile, SKillConnMsg_01) {
-  ASSERT_NE(pClient, nullptr);
-
+TEST_F(DndTestProfile, 05_KillConnMsg) {
   {
-    SKillConnMsg* pReq = (SKillConnMsg*)rpcMallocCont(sizeof(SKillConnMsg));
+    int32_t contLen = sizeof(SKillConnMsg);
+
+    SKillConnMsg* pReq = (SKillConnMsg*)rpcMallocCont(contLen);
     pReq->connId = htonl(connId);
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SKillConnMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_KILL_CONN;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
+    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_KILL_CONN, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
 
   {
-    SHeartBeatMsg* pReq = (SHeartBeatMsg*)rpcMallocCont(sizeof(SHeartBeatMsg));
+    int32_t contLen = sizeof(SHeartBeatMsg);
+
+    SHeartBeatMsg* pReq = (SHeartBeatMsg*)rpcMallocCont(contLen);
     pReq->connId = htonl(connId);
     pReq->pid = htonl(1234);
     pReq->numOfQueries = htonl(0);
     pReq->numOfStreams = htonl(0);
-    strcpy(pReq->app, "dndTestProfile");
+    strcpy(pReq->app, "dnode_test_profile");
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SHeartBeatMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_HEARTBEAT;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
+    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_HEARTBEAT, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, TSDB_CODE_MND_INVALID_CONNECTION);
     ASSERT_EQ(pMsg->contLen, 0);
   }
 
   {
-    SConnectMsg* pReq = (SConnectMsg*)rpcMallocCont(sizeof(SConnectMsg));
+    int32_t contLen = sizeof(SConnectMsg);
+
+    SConnectMsg* pReq = (SConnectMsg*)rpcMallocCont(contLen);
     pReq->pid = htonl(1234);
-    strcpy(pReq->app, "dndTestProfile");
+    strcpy(pReq->app, "dnode_test_profile");
     strcpy(pReq->db, "");
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SConnectMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_CONNECT;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
+    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CONNECT, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, 0);
 
     SConnectRsp* pRsp = (SConnectRsp*)pMsg->pCont;
     ASSERT_NE(pRsp, nullptr);
@@ -332,71 +181,55 @@ TEST_F(DndTestProfile, SKillConnMsg_01) {
     EXPECT_EQ(pRsp->acctId, 1);
     EXPECT_GT(pRsp->clusterId, 0);
     EXPECT_GT(pRsp->connId, connId);
-    EXPECT_EQ(pRsp->readAuth, 1);
-    EXPECT_EQ(pRsp->writeAuth, 1);
+    EXPECT_EQ(pRsp->superUser, 1);
 
     EXPECT_EQ(pRsp->epSet.inUse, 0);
     EXPECT_EQ(pRsp->epSet.numOfEps, 1);
-    EXPECT_EQ(pRsp->epSet.port[0], 9522);
+    EXPECT_EQ(pRsp->epSet.port[0], 9080);
     EXPECT_STREQ(pRsp->epSet.fqdn[0], "localhost");
 
     connId = pRsp->connId;
   }
 }
 
-TEST_F(DndTestProfile, SKillConnMsg_02) {
-  ASSERT_NE(pClient, nullptr);
+TEST_F(DndTestProfile, 06_KillConnMsg_InvalidConn) {
+  int32_t contLen = sizeof(SKillConnMsg);
 
-  SKillConnMsg* pReq = (SKillConnMsg*)rpcMallocCont(sizeof(SKillConnMsg));
+  SKillConnMsg* pReq = (SKillConnMsg*)rpcMallocCont(contLen);
   pReq->connId = htonl(2345);
 
-  SRpcMsg rpcMsg = {0};
-  rpcMsg.pCont = pReq;
-  rpcMsg.contLen = sizeof(SKillConnMsg);
-  rpcMsg.msgType = TSDB_MSG_TYPE_KILL_CONN;
-
-  sendMsg(pClient, &rpcMsg);
-  SRpcMsg* pMsg = pClient->pRsp;
+  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_KILL_CONN, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, TSDB_CODE_MND_INVALID_CONN_ID);
 }
 
-TEST_F(DndTestProfile, SKillQueryMsg_01) {
-  ASSERT_NE(pClient, nullptr);
-
+TEST_F(DndTestProfile, 07_KillQueryMsg) {
   {
-    SKillQueryMsg* pReq = (SKillQueryMsg*)rpcMallocCont(sizeof(SKillQueryMsg));
+    int32_t contLen = sizeof(SKillQueryMsg);
+
+    SKillQueryMsg* pReq = (SKillQueryMsg*)rpcMallocCont(contLen);
     pReq->connId = htonl(connId);
     pReq->queryId = htonl(1234);
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SKillQueryMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_KILL_QUERY;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
+    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_KILL_QUERY, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
     ASSERT_EQ(pMsg->contLen, 0);
   }
 
   {
-    SHeartBeatMsg* pReq = (SHeartBeatMsg*)rpcMallocCont(sizeof(SHeartBeatMsg));
+    int32_t contLen = sizeof(SHeartBeatMsg);
+
+    SHeartBeatMsg* pReq = (SHeartBeatMsg*)rpcMallocCont(contLen);
     pReq->connId = htonl(connId);
     pReq->pid = htonl(1234);
     pReq->numOfQueries = htonl(0);
     pReq->numOfStreams = htonl(0);
-    strcpy(pReq->app, "dndTestProfile");
+    strcpy(pReq->app, "dnode_test_profile");
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SHeartBeatMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_HEARTBEAT;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
+    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_HEARTBEAT, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, 0);
 
     SHeartBeatRsp* pRsp = (SHeartBeatRsp*)pMsg->pCont;
     ASSERT_NE(pRsp, nullptr);
@@ -416,314 +249,42 @@ TEST_F(DndTestProfile, SKillQueryMsg_01) {
 
     EXPECT_EQ(pRsp->epSet.inUse, 0);
     EXPECT_EQ(pRsp->epSet.numOfEps, 1);
-    EXPECT_EQ(pRsp->epSet.port[0], 9522);
+    EXPECT_EQ(pRsp->epSet.port[0], 9080);
     EXPECT_STREQ(pRsp->epSet.fqdn[0], "localhost");
   }
 }
 
-TEST_F(DndTestProfile, SKillQueryMsg_02) {
-  ASSERT_NE(pClient, nullptr);
+TEST_F(DndTestProfile, 08_KillQueryMsg_InvalidConn) {
+  int32_t contLen = sizeof(SKillQueryMsg);
 
-  SKillQueryMsg* pReq = (SKillQueryMsg*)rpcMallocCont(sizeof(SKillQueryMsg));
+  SKillQueryMsg* pReq = (SKillQueryMsg*)rpcMallocCont(contLen);
   pReq->connId = htonl(2345);
   pReq->queryId = htonl(1234);
 
-  SRpcMsg rpcMsg = {0};
-  rpcMsg.pCont = pReq;
-  rpcMsg.contLen = sizeof(SKillQueryMsg);
-  rpcMsg.msgType = TSDB_MSG_TYPE_KILL_QUERY;
-
-  sendMsg(pClient, &rpcMsg);
-  SRpcMsg* pMsg = pClient->pRsp;
+  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_KILL_QUERY, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, TSDB_CODE_MND_INVALID_CONN_ID);
 }
 
-TEST_F(DndTestProfile, SKillQueryMsg_03) {
-  ASSERT_NE(pClient, nullptr);
-  int32_t showId = 0;
+TEST_F(DndTestProfile, 09_KillQueryMsg) {
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_QUERIES, "");
+  CHECK_META("show queries", 14);
 
-  {
-    SShowMsg* pReq = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));
-    pReq->type = TSDB_MGMT_TABLE_QUERIES;
-    strcpy(pReq->db, "");
+  CHECK_SCHEMA(0, TSDB_DATA_TYPE_INT, 4, "queryId");
+  CHECK_SCHEMA(1, TSDB_DATA_TYPE_INT, 4, "connId");
+  CHECK_SCHEMA(2, TSDB_DATA_TYPE_BINARY, TSDB_USER_LEN + VARSTR_HEADER_SIZE, "user");
+  CHECK_SCHEMA(3, TSDB_DATA_TYPE_BINARY, TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE, "ip:port");
+  CHECK_SCHEMA(4, TSDB_DATA_TYPE_BINARY, 22 + VARSTR_HEADER_SIZE, "qid");
+  CHECK_SCHEMA(5, TSDB_DATA_TYPE_TIMESTAMP, 8, "created_time");
+  CHECK_SCHEMA(6, TSDB_DATA_TYPE_BIGINT, 8, "time");
+  CHECK_SCHEMA(7, TSDB_DATA_TYPE_BINARY, 18 + VARSTR_HEADER_SIZE, "sql_obj_id");
+  CHECK_SCHEMA(8, TSDB_DATA_TYPE_INT, 4, "pid");
+  CHECK_SCHEMA(9, TSDB_DATA_TYPE_BINARY, TSDB_EP_LEN + VARSTR_HEADER_SIZE, "ep");
+  CHECK_SCHEMA(10, TSDB_DATA_TYPE_BOOL, 1, "stable_query");
+  CHECK_SCHEMA(11, TSDB_DATA_TYPE_INT, 4, "sub_queries");
+  CHECK_SCHEMA(12, TSDB_DATA_TYPE_BINARY, TSDB_SHOW_SUBQUERY_LEN + VARSTR_HEADER_SIZE, "sub_query_info");
+  CHECK_SCHEMA(13, TSDB_DATA_TYPE_BINARY, TSDB_SHOW_SQL_LEN + VARSTR_HEADER_SIZE, "sql");
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SShowMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_SHOW;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
-    ASSERT_NE(pMsg, nullptr);
-
-    SShowRsp* pRsp = (SShowRsp*)pMsg->pCont;
-    ASSERT_NE(pRsp, nullptr);
-    pRsp->showId = htonl(pRsp->showId);
-    STableMetaMsg* pMeta = &pRsp->tableMeta;
-    pMeta->contLen = htonl(pMeta->contLen);
-    pMeta->numOfColumns = htons(pMeta->numOfColumns);
-    pMeta->sversion = htons(pMeta->sversion);
-    pMeta->tversion = htons(pMeta->tversion);
-    pMeta->tid = htonl(pMeta->tid);
-    pMeta->uid = htobe64(pMeta->uid);
-    pMeta->suid = htobe64(pMeta->suid);
-
-    showId = pRsp->showId;
-
-    EXPECT_NE(pRsp->showId, 0);
-    EXPECT_EQ(pMeta->contLen, 0);
-    EXPECT_STREQ(pMeta->tbFname, "");
-    EXPECT_EQ(pMeta->numOfTags, 0);
-    EXPECT_EQ(pMeta->precision, 0);
-    EXPECT_EQ(pMeta->tableType, 0);
-    EXPECT_EQ(pMeta->numOfColumns, 14);
-    EXPECT_EQ(pMeta->sversion, 0);
-    EXPECT_EQ(pMeta->tversion, 0);
-    EXPECT_EQ(pMeta->tid, 0);
-    EXPECT_EQ(pMeta->uid, 0);
-    EXPECT_STREQ(pMeta->sTableName, "");
-    EXPECT_EQ(pMeta->suid, 0);
-
-    SSchema* pSchema = NULL;
-    pSchema = &pMeta->pSchema[0];
-    pSchema->bytes = htons(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_INT);
-    EXPECT_EQ(pSchema->bytes, 4);
-    EXPECT_STREQ(pSchema->name, "queryId");
-
-    pSchema = &pMeta->pSchema[1];
-    pSchema->bytes = htonl(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_INT);
-    EXPECT_EQ(pSchema->bytes, 4);
-    EXPECT_STREQ(pSchema->name, "connId");
-
-    pSchema = &pMeta->pSchema[2];
-    pSchema->bytes = htons(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_BINARY);
-    EXPECT_EQ(pSchema->bytes, TSDB_USER_LEN + VARSTR_HEADER_SIZE);
-    EXPECT_STREQ(pSchema->name, "user");
-
-    pSchema = &pMeta->pSchema[3];
-    pSchema->bytes = htons(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_BINARY);
-    EXPECT_EQ(pSchema->bytes, TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE);
-    EXPECT_STREQ(pSchema->name, "ip:port");
-  }
-
-  {
-    SRetrieveTableMsg* pReq = (SRetrieveTableMsg*)rpcMallocCont(sizeof(SRetrieveTableMsg));
-    pReq->showId = htonl(showId);
-    pReq->free = 0;
-
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SRetrieveTableMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
-    ASSERT_NE(pMsg, nullptr);
-    ASSERT_EQ(pMsg->code, 0);
-
-    SRetrieveTableRsp* pRsp = (SRetrieveTableRsp*)pMsg->pCont;
-    ASSERT_NE(pRsp, nullptr);
-    pRsp->numOfRows = htonl(pRsp->numOfRows);
-    pRsp->offset = htobe64(pRsp->offset);
-    pRsp->useconds = htobe64(pRsp->useconds);
-    pRsp->compLen = htonl(pRsp->compLen);
-
-    EXPECT_EQ(pRsp->numOfRows, 0);
-    EXPECT_EQ(pRsp->offset, 0);
-    EXPECT_EQ(pRsp->useconds, 0);
-    EXPECT_EQ(pRsp->completed, 1);
-    EXPECT_EQ(pRsp->precision, TSDB_TIME_PRECISION_MILLI);
-    EXPECT_EQ(pRsp->compressed, 0);
-    EXPECT_EQ(pRsp->reserved, 0);
-    EXPECT_EQ(pRsp->compLen, 0);
-  }
-}
-
-TEST_F(DndTestProfile, SKillStreamMsg_01) {
-  ASSERT_NE(pClient, nullptr);
-
-  {
-    SKillStreamMsg* pReq = (SKillStreamMsg*)rpcMallocCont(sizeof(SKillStreamMsg));
-    pReq->connId = htonl(connId);
-    pReq->streamId = htonl(3579);
-
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SKillStreamMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_KILL_STREAM;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
-    ASSERT_NE(pMsg, nullptr);
-    ASSERT_EQ(pMsg->code, 0);
-    ASSERT_EQ(pMsg->contLen, 0);
-  }
-
-  {
-    SHeartBeatMsg* pReq = (SHeartBeatMsg*)rpcMallocCont(sizeof(SHeartBeatMsg));
-    pReq->connId = htonl(connId);
-    pReq->pid = htonl(1234);
-    pReq->numOfQueries = htonl(0);
-    pReq->numOfStreams = htonl(0);
-    strcpy(pReq->app, "dndTestProfile");
-
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SHeartBeatMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_HEARTBEAT;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
-    ASSERT_NE(pMsg, nullptr);
-
-    SHeartBeatRsp* pRsp = (SHeartBeatRsp*)pMsg->pCont;
-    ASSERT_NE(pRsp, nullptr);
-    pRsp->connId = htonl(pRsp->connId);
-    pRsp->queryId = htonl(pRsp->queryId);
-    pRsp->streamId = htonl(pRsp->streamId);
-    pRsp->totalDnodes = htonl(pRsp->totalDnodes);
-    pRsp->onlineDnodes = htonl(pRsp->onlineDnodes);
-    pRsp->epSet.port[0] = htons(pRsp->epSet.port[0]);
-
-    EXPECT_EQ(pRsp->connId, connId);
-    EXPECT_EQ(pRsp->queryId, 0);
-    EXPECT_EQ(pRsp->streamId, 3579);
-    EXPECT_EQ(pRsp->totalDnodes, 1);
-    EXPECT_EQ(pRsp->onlineDnodes, 1);
-    EXPECT_EQ(pRsp->killConnection, 0);
-
-    EXPECT_EQ(pRsp->epSet.inUse, 0);
-    EXPECT_EQ(pRsp->epSet.numOfEps, 1);
-    EXPECT_EQ(pRsp->epSet.port[0], 9522);
-    EXPECT_STREQ(pRsp->epSet.fqdn[0], "localhost");
-  }
-}
-
-TEST_F(DndTestProfile, SKillStreamMsg_02) {
-  ASSERT_NE(pClient, nullptr);
-
-  SKillStreamMsg* pReq = (SKillStreamMsg*)rpcMallocCont(sizeof(SKillStreamMsg));
-  pReq->connId = htonl(2345);
-  pReq->streamId = htonl(1234);
-
-  SRpcMsg rpcMsg = {0};
-  rpcMsg.pCont = pReq;
-  rpcMsg.contLen = sizeof(SKillStreamMsg);
-  rpcMsg.msgType = TSDB_MSG_TYPE_KILL_QUERY;
-
-  sendMsg(pClient, &rpcMsg);
-  SRpcMsg* pMsg = pClient->pRsp;
-  ASSERT_NE(pMsg, nullptr);
-  ASSERT_EQ(pMsg->code, TSDB_CODE_MND_INVALID_CONN_ID);
-}
-
-TEST_F(DndTestProfile, SKillStreamMsg_03) {
-  ASSERT_NE(pClient, nullptr);
-  int32_t showId = 0;
-
-  {
-    SShowMsg* pReq = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));
-    pReq->type = TSDB_MGMT_TABLE_STREAMS;
-    strcpy(pReq->db, "");
-
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SShowMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_SHOW;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
-    ASSERT_NE(pMsg, nullptr);
-
-    SShowRsp* pRsp = (SShowRsp*)pMsg->pCont;
-    ASSERT_NE(pRsp, nullptr);
-    pRsp->showId = htonl(pRsp->showId);
-    STableMetaMsg* pMeta = &pRsp->tableMeta;
-    pMeta->contLen = htonl(pMeta->contLen);
-    pMeta->numOfColumns = htons(pMeta->numOfColumns);
-    pMeta->sversion = htons(pMeta->sversion);
-    pMeta->tversion = htons(pMeta->tversion);
-    pMeta->tid = htonl(pMeta->tid);
-    pMeta->uid = htobe64(pMeta->uid);
-    pMeta->suid = htobe64(pMeta->suid);
-
-    showId = pRsp->showId;
-
-    EXPECT_NE(pRsp->showId, 0);
-    EXPECT_EQ(pMeta->contLen, 0);
-    EXPECT_STREQ(pMeta->tbFname, "");
-    EXPECT_EQ(pMeta->numOfTags, 0);
-    EXPECT_EQ(pMeta->precision, 0);
-    EXPECT_EQ(pMeta->tableType, 0);
-    EXPECT_EQ(pMeta->numOfColumns, 10);
-    EXPECT_EQ(pMeta->sversion, 0);
-    EXPECT_EQ(pMeta->tversion, 0);
-    EXPECT_EQ(pMeta->tid, 0);
-    EXPECT_EQ(pMeta->uid, 0);
-    EXPECT_STREQ(pMeta->sTableName, "");
-    EXPECT_EQ(pMeta->suid, 0);
-
-    SSchema* pSchema = NULL;
-    pSchema = &pMeta->pSchema[0];
-    pSchema->bytes = htons(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_INT);
-    EXPECT_EQ(pSchema->bytes, 4);
-    EXPECT_STREQ(pSchema->name, "streamId");
-
-    pSchema = &pMeta->pSchema[1];
-    pSchema->bytes = htons(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_INT);
-    EXPECT_EQ(pSchema->bytes, 4);
-    EXPECT_STREQ(pSchema->name, "connId");
-
-    pSchema = &pMeta->pSchema[2];
-    pSchema->bytes = htons(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_BINARY);
-    EXPECT_EQ(pSchema->bytes, TSDB_USER_LEN + VARSTR_HEADER_SIZE);
-    EXPECT_STREQ(pSchema->name, "user");
-  }
-
-  {
-    SRetrieveTableMsg* pReq = (SRetrieveTableMsg*)rpcMallocCont(sizeof(SRetrieveTableMsg));
-    pReq->showId = htonl(showId);
-    pReq->free = 0;
-
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SRetrieveTableMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
-    ASSERT_NE(pMsg, nullptr);
-    ASSERT_EQ(pMsg->code, 0);
-
-    SRetrieveTableRsp* pRsp = (SRetrieveTableRsp*)pMsg->pCont;
-    ASSERT_NE(pRsp, nullptr);
-    pRsp->numOfRows = htonl(pRsp->numOfRows);
-    pRsp->offset = htobe64(pRsp->offset);
-    pRsp->useconds = htobe64(pRsp->useconds);
-    pRsp->compLen = htonl(pRsp->compLen);
-
-    EXPECT_EQ(pRsp->numOfRows, 0);
-    EXPECT_EQ(pRsp->offset, 0);
-    EXPECT_EQ(pRsp->useconds, 0);
-    EXPECT_EQ(pRsp->completed, 1);
-    EXPECT_EQ(pRsp->precision, TSDB_TIME_PRECISION_MILLI);
-    EXPECT_EQ(pRsp->compressed, 0);
-    EXPECT_EQ(pRsp->reserved, 0);
-    EXPECT_EQ(pRsp->compLen, 0);
-  }
+  test.SendShowRetrieveMsg();
+  EXPECT_EQ(test.GetShowRows(), 0);
 }

source/dnode/mgmt/impl/test/show/CMakeLists.txt

@@ -1,24 +1,8 @@
-add_executable(dnode_test_show "")
-
-target_sources(dnode_test_show
-    PRIVATE
-    "show.cpp"
-    "../sut/deploy.cpp"
-)
-
+aux_source_directory(. SHOW_SRC)
+add_executable(dnode_test_show ${SHOW_SRC})
 target_link_libraries(
     dnode_test_show
-    PUBLIC dnode
-    PUBLIC util
-    PUBLIC os
-    PUBLIC gtest_main
-)
-
-target_include_directories(dnode_test_show
-    PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/server/dnode/mgmt"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../../inc"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
+    PUBLIC sut
 )
 
 add_test(

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

@@ -9,226 +9,79 @@
  *
  */
 
-#include "deploy.h"
+#include "base.h"
 
 class DndTestShow : public ::testing::Test {
  protected:
+  static void SetUpTestSuite() { test.Init("/tmp/dnode_test_show", 9091); }
+  static void TearDownTestSuite() { test.Cleanup(); }
+
+  static Testbase test;
+
+ public:
   void SetUp() override {}
   void TearDown() override {}
-
-  static void SetUpTestSuite() {
-    const char* user = "root";
-    const char* pass = "taosdata";
-    const char* path = "/tmp/dndTestShow";
-    const char* fqdn = "localhost";
-    uint16_t    port = 9523;
-
-    pServer = createServer(path, fqdn, port);
-    ASSERT(pServer);
-    pClient = createClient(user, pass, fqdn, port);
-  }
-
-  static void TearDownTestSuite() {
-    stopServer(pServer);
-    dropClient(pClient);
-  }
-
-  static SServer* pServer;
-  static SClient* pClient;
-  static int32_t  connId;
 };
 
-SServer* DndTestShow::pServer;
-SClient* DndTestShow::pClient;
-int32_t  DndTestShow::connId;
+Testbase DndTestShow::test;
 
-TEST_F(DndTestShow, SShowMsg_01) {
-  ASSERT_NE(pClient, nullptr);
+TEST_F(DndTestShow, 01_ShowMsg_InvalidMsgMax) {
+  int32_t contLen = sizeof(SShowMsg);
 
-  SConnectMsg* pReq = (SConnectMsg*)rpcMallocCont(sizeof(SConnectMsg));
-  pReq->pid = htonl(1234);
-  strcpy(pReq->app, "dndTestShow");
-  strcpy(pReq->db, "");
-
-  SRpcMsg rpcMsg = {0};
-  rpcMsg.pCont = pReq;
-  rpcMsg.contLen = sizeof(SConnectMsg);
-  rpcMsg.msgType = TSDB_MSG_TYPE_CONNECT;
-
-  sendMsg(pClient, &rpcMsg);
-  SRpcMsg* pMsg = pClient->pRsp;
-  ASSERT_NE(pMsg, nullptr);
-
-  SConnectRsp* pRsp = (SConnectRsp*)pMsg->pCont;
-  ASSERT_NE(pRsp, nullptr);
-  pRsp->connId = htonl(pRsp->connId);
-
-  EXPECT_EQ(pRsp->connId, 1);
-  connId = pRsp->connId;
-}
-
-TEST_F(DndTestShow, SShowMsg_02) {
-  ASSERT_NE(pClient, nullptr);
-
-  SShowMsg* pReq = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));
+  SShowMsg* pReq = (SShowMsg*)rpcMallocCont(contLen);
   pReq->type = TSDB_MGMT_TABLE_MAX;
   strcpy(pReq->db, "");
 
-  SRpcMsg rpcMsg = {0};
-  rpcMsg.pCont = pReq;
-  rpcMsg.contLen = sizeof(SShowMsg);
-  rpcMsg.msgType = TSDB_MSG_TYPE_SHOW;
-
-  sendMsg(pClient, &rpcMsg);
-  SRpcMsg* pMsg = pClient->pRsp;
+  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_SHOW, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, TSDB_CODE_MND_INVALID_MSG_TYPE);
 }
 
-TEST_F(DndTestShow, SShowMsg_03) {
-  ASSERT_NE(pClient, nullptr);
+TEST_F(DndTestShow, 02_ShowMsg_InvalidMsgStart) {
+  int32_t contLen = sizeof(SShowMsg);
 
   SShowMsg* pReq = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));
   pReq->type = TSDB_MGMT_TABLE_START;
   strcpy(pReq->db, "");
 
-  SRpcMsg rpcMsg = {0};
-  rpcMsg.pCont = pReq;
-  rpcMsg.contLen = sizeof(SShowMsg);
-  rpcMsg.msgType = TSDB_MSG_TYPE_SHOW;
-
-  sendMsg(pClient, &rpcMsg);
-  SRpcMsg* pMsg = pClient->pRsp;
+  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_SHOW, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, TSDB_CODE_MND_INVALID_MSG_TYPE);
 }
 
-TEST_F(DndTestShow, SShowMsg_04) {
-  ASSERT_NE(pClient, nullptr);
-  int32_t showId = 0;
+TEST_F(DndTestShow, 02_ShowMsg_Conn) {
+  int32_t contLen = sizeof(SConnectMsg);
 
-  {
-    SShowMsg* pReq = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));
-    pReq->type = TSDB_MGMT_TABLE_CONNS;
-    strcpy(pReq->db, "");
+  SConnectMsg* pReq = (SConnectMsg*)rpcMallocCont(contLen);
+  pReq->pid = htonl(1234);
+  strcpy(pReq->app, "dnode_test_show");
+  strcpy(pReq->db, "");
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SShowMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_SHOW;
+  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CONNECT, pReq, contLen);
+  ASSERT_NE(pMsg, nullptr);
+  ASSERT_EQ(pMsg->code, 0);
 
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
-    ASSERT_NE(pMsg, nullptr);
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_CONNS, "");
 
-    SShowRsp* pRsp = (SShowRsp*)pMsg->pCont;
-    ASSERT_NE(pRsp, nullptr);
-    pRsp->showId = htonl(pRsp->showId);
-    STableMetaMsg* pMeta = &pRsp->tableMeta;
-    pMeta->contLen = htonl(pMeta->contLen);
-    pMeta->numOfColumns = htons(pMeta->numOfColumns);
-    pMeta->sversion = htons(pMeta->sversion);
-    pMeta->tversion = htons(pMeta->tversion);
-    pMeta->tid = htonl(pMeta->tid);
-    pMeta->uid = htobe64(pMeta->uid);
-    pMeta->suid = htobe64(pMeta->suid);
+  STableMetaMsg* pMeta = test.GetShowMeta();
+  EXPECT_STREQ(pMeta->tbFname, "show connections");
+  EXPECT_EQ(pMeta->numOfTags, 0);
+  EXPECT_EQ(pMeta->numOfColumns, 7);
+  EXPECT_EQ(pMeta->precision, 0);
+  EXPECT_EQ(pMeta->tableType, 0);
+  EXPECT_EQ(pMeta->update, 0);
+  EXPECT_EQ(pMeta->sversion, 0);
+  EXPECT_EQ(pMeta->tversion, 0);
+  EXPECT_EQ(pMeta->tuid, 0);
+  EXPECT_EQ(pMeta->suid, 0);
 
-    showId = pRsp->showId;
+  test.SendShowRetrieveMsg();
 
-    EXPECT_NE(pRsp->showId, 0);
-    EXPECT_EQ(pMeta->contLen, 0);
-    EXPECT_STREQ(pMeta->tbFname, "");
-    EXPECT_EQ(pMeta->numOfTags, 0);
-    EXPECT_EQ(pMeta->precision, 0);
-    EXPECT_EQ(pMeta->tableType, 0);
-    EXPECT_EQ(pMeta->numOfColumns, 7);
-    EXPECT_EQ(pMeta->sversion, 0);
-    EXPECT_EQ(pMeta->tversion, 0);
-    EXPECT_EQ(pMeta->tid, 0);
-    EXPECT_EQ(pMeta->uid, 0);
-    EXPECT_STREQ(pMeta->sTableName, "");
-    EXPECT_EQ(pMeta->suid, 0);
-
-    SSchema* pSchema = NULL;
-    pSchema = &pMeta->pSchema[0];
-    pSchema->bytes = htonl(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_INT);
-    EXPECT_EQ(pSchema->bytes, 4);
-    EXPECT_STREQ(pSchema->name, "connId");
-
-    pSchema = &pMeta->pSchema[1];
-    pSchema->bytes = htonl(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_BINARY);
-    EXPECT_EQ(pSchema->bytes, TSDB_USER_LEN + VARSTR_HEADER_SIZE);
-    EXPECT_STREQ(pSchema->name, "user");
-
-    pSchema = &pMeta->pSchema[2];
-    pSchema->bytes = htonl(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_BINARY);
-    EXPECT_EQ(pSchema->bytes, TSDB_USER_LEN + VARSTR_HEADER_SIZE);
-    EXPECT_STREQ(pSchema->name, "program");
-
-    pSchema = &pMeta->pSchema[3];
-    pSchema->bytes = htonl(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_INT);
-    EXPECT_EQ(pSchema->bytes, 4);
-    EXPECT_STREQ(pSchema->name, "pid");
-
-    pSchema = &pMeta->pSchema[4];
-    pSchema->bytes = htonl(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_BINARY);
-    EXPECT_EQ(pSchema->bytes, TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE);
-    EXPECT_STREQ(pSchema->name, "ip:port");
-
-    pSchema = &pMeta->pSchema[5];
-    pSchema->bytes = htonl(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_TIMESTAMP);
-    EXPECT_EQ(pSchema->bytes, 8);
-    EXPECT_STREQ(pSchema->name, "login_time");
-
-    pSchema = &pMeta->pSchema[6];
-    pSchema->bytes = htonl(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_TIMESTAMP);
-    EXPECT_EQ(pSchema->bytes, 8);
-    EXPECT_STREQ(pSchema->name, "last_access");
-  }
-
-  {
-    SRetrieveTableMsg* pReq = (SRetrieveTableMsg*)rpcMallocCont(sizeof(SRetrieveTableMsg));
-    pReq->showId = htonl(showId);
-    pReq->free = 0;
-
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SRetrieveTableMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
-    ASSERT_NE(pMsg, nullptr);
-    ASSERT_EQ(pMsg->code, 0);
-
-    SRetrieveTableRsp* pRsp = (SRetrieveTableRsp*)pMsg->pCont;
-    ASSERT_NE(pRsp, nullptr);
-    pRsp->numOfRows = htonl(pRsp->numOfRows);
-    pRsp->offset = htobe64(pRsp->offset);
-    pRsp->useconds = htobe64(pRsp->useconds);
-    pRsp->compLen = htonl(pRsp->compLen);
-
-    EXPECT_EQ(pRsp->numOfRows, 1);
-    EXPECT_EQ(pRsp->offset, 0);
-    EXPECT_EQ(pRsp->useconds, 0);
-    EXPECT_EQ(pRsp->completed, 1);
-    EXPECT_EQ(pRsp->precision, TSDB_TIME_PRECISION_MILLI);
-    EXPECT_EQ(pRsp->compressed, 0);
-    EXPECT_EQ(pRsp->reserved, 0);
-    EXPECT_EQ(pRsp->compLen, 0);
-  }
+  SRetrieveTableRsp* pRetrieveRsp = test.GetRetrieveRsp();
+  EXPECT_EQ(pRetrieveRsp->numOfRows, 1);
+  EXPECT_EQ(pRetrieveRsp->useconds, 0);
+  EXPECT_EQ(pRetrieveRsp->completed, 1);
+  EXPECT_EQ(pRetrieveRsp->precision, TSDB_TIME_PRECISION_MILLI);
+  EXPECT_EQ(pRetrieveRsp->compressed, 0);
+  EXPECT_EQ(pRetrieveRsp->compLen, 0);
 }

source/dnode/mgmt/impl/test/stb/CMakeLists.txt

@@ -1,24 +1,8 @@
-add_executable(dnode_test_stb "")
-
-target_sources(dnode_test_stb
-    PRIVATE
-    "stb.cpp"
-    "../sut/deploy.cpp"
-)
-
+aux_source_directory(. STB_SRC)
+add_executable(dnode_test_stb ${STB_SRC})
 target_link_libraries(
     dnode_test_stb
-    PUBLIC dnode
-    PUBLIC util
-    PUBLIC os
-    PUBLIC gtest_main
-)
-
-target_include_directories(dnode_test_stb
-    PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/server/dnode/mgmt"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../../inc"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
+    PUBLIC sut
 )
 
 add_test(

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

@@ -9,176 +9,27 @@
  *
  */
 
-#include "deploy.h"
+#include "base.h"
 
 class DndTestStb : public ::testing::Test {
  protected:
-  static SServer* CreateServer(const char* path, const char* fqdn, uint16_t port, const char* firstEp) {
-    SServer* pServer = createServer(path, fqdn, port, firstEp);
-    ASSERT(pServer);
-    return pServer;
-  }
+  static void SetUpTestSuite() { test.Init("/tmp/dnode_test_stb", 9101); }
+  static void TearDownTestSuite() { test.Cleanup(); }
 
-  static void SetUpTestSuite() {
-    initLog("/tmp/tdlog");
-
-    const char* fqdn = "localhost";
-    const char* firstEp = "localhost:9101";
-    pServer = CreateServer("/tmp/dnode_test_stb", fqdn, 9101, firstEp);
-    pClient = createClient("root", "taosdata", fqdn, 9101);
-    taosMsleep(1100);
-  }
-
-  static void TearDownTestSuite() {
-    stopServer(pServer);
-    dropClient(pClient);
-    pServer = NULL;
-    pClient = NULL;
-  }
-
-  static SServer* pServer;
-  static SClient* pClient;
-  static int32_t  connId;
+  static Testbase test;
 
  public:
   void SetUp() override {}
   void TearDown() override {}
-
-  void SendTheCheckShowMetaMsg(int8_t showType, const char* showName, int32_t columns, const char* db) {
-    SShowMsg* pShow = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));
-    pShow->type = showType;
-    if (db != NULL) {
-      strcpy(pShow->db, db);
-    }
-    SRpcMsg showRpcMsg = {0};
-    showRpcMsg.pCont = pShow;
-    showRpcMsg.contLen = sizeof(SShowMsg);
-    showRpcMsg.msgType = TSDB_MSG_TYPE_SHOW;
-
-    sendMsg(pClient, &showRpcMsg);
-    ASSERT_NE(pClient->pRsp, nullptr);
-    ASSERT_EQ(pClient->pRsp->code, 0);
-    ASSERT_NE(pClient->pRsp->pCont, nullptr);
-
-    SShowRsp* pShowRsp = (SShowRsp*)pClient->pRsp->pCont;
-    ASSERT_NE(pShowRsp, nullptr);
-    pShowRsp->showId = htonl(pShowRsp->showId);
-    pMeta = &pShowRsp->tableMeta;
-    pMeta->numOfTags = htonl(pMeta->numOfTags);
-    pMeta->numOfColumns = htonl(pMeta->numOfColumns);
-    pMeta->sversion = htonl(pMeta->sversion);
-    pMeta->tversion = htonl(pMeta->tversion);
-    pMeta->tuid = htobe64(pMeta->tuid);
-    pMeta->suid = htobe64(pMeta->suid);
-
-    showId = pShowRsp->showId;
-
-    EXPECT_NE(pShowRsp->showId, 0);
-    EXPECT_STREQ(pMeta->tbFname, showName);
-    EXPECT_EQ(pMeta->numOfTags, 0);
-    EXPECT_EQ(pMeta->numOfColumns, columns);
-    EXPECT_EQ(pMeta->precision, 0);
-    EXPECT_EQ(pMeta->tableType, 0);
-    EXPECT_EQ(pMeta->update, 0);
-    EXPECT_EQ(pMeta->sversion, 0);
-    EXPECT_EQ(pMeta->tversion, 0);
-    EXPECT_EQ(pMeta->tuid, 0);
-    EXPECT_EQ(pMeta->suid, 0);
-  }
-
-  void CheckSchema(int32_t index, int8_t type, int32_t bytes, const char* name) {
-    SSchema* pSchema = &pMeta->pSchema[index];
-    pSchema->bytes = htonl(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, type);
-    EXPECT_EQ(pSchema->bytes, bytes);
-    EXPECT_STREQ(pSchema->name, name);
-  }
-
-  void SendThenCheckShowRetrieveMsg(int32_t rows) {
-    SRetrieveTableMsg* pRetrieve = (SRetrieveTableMsg*)rpcMallocCont(sizeof(SRetrieveTableMsg));
-    pRetrieve->showId = htonl(showId);
-    pRetrieve->free = 0;
-
-    SRpcMsg retrieveRpcMsg = {0};
-    retrieveRpcMsg.pCont = pRetrieve;
-    retrieveRpcMsg.contLen = sizeof(SRetrieveTableMsg);
-    retrieveRpcMsg.msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE;
-
-    sendMsg(pClient, &retrieveRpcMsg);
-
-    ASSERT_NE(pClient->pRsp, nullptr);
-    ASSERT_EQ(pClient->pRsp->code, 0);
-    ASSERT_NE(pClient->pRsp->pCont, nullptr);
-
-    pRetrieveRsp = (SRetrieveTableRsp*)pClient->pRsp->pCont;
-    ASSERT_NE(pRetrieveRsp, nullptr);
-    pRetrieveRsp->numOfRows = htonl(pRetrieveRsp->numOfRows);
-    pRetrieveRsp->useconds = htobe64(pRetrieveRsp->useconds);
-    pRetrieveRsp->compLen = htonl(pRetrieveRsp->compLen);
-
-    EXPECT_EQ(pRetrieveRsp->numOfRows, rows);
-    EXPECT_EQ(pRetrieveRsp->useconds, 0);
-    // EXPECT_EQ(pRetrieveRsp->completed, completed);
-    EXPECT_EQ(pRetrieveRsp->precision, TSDB_TIME_PRECISION_MILLI);
-    EXPECT_EQ(pRetrieveRsp->compressed, 0);
-    EXPECT_EQ(pRetrieveRsp->compLen, 0);
-
-    pData = pRetrieveRsp->data;
-    pos = 0;
-  }
-
-  void CheckInt8(int8_t val) {
-    int8_t data = *((int8_t*)(pData + pos));
-    pos += sizeof(int8_t);
-    EXPECT_EQ(data, val);
-  }
-
-  void CheckInt16(int16_t val) {
-    int16_t data = *((int16_t*)(pData + pos));
-    pos += sizeof(int16_t);
-    EXPECT_EQ(data, val);
-  }
-
-  void CheckInt32(int32_t val) {
-    int32_t data = *((int32_t*)(pData + pos));
-    pos += sizeof(int32_t);
-    EXPECT_EQ(data, val);
-  }
-
-  void CheckInt64(int64_t val) {
-    int64_t data = *((int64_t*)(pData + pos));
-    pos += sizeof(int64_t);
-    EXPECT_EQ(data, val);
-  }
-
-  void CheckTimestamp() {
-    int64_t data = *((int64_t*)(pData + pos));
-    pos += sizeof(int64_t);
-    EXPECT_GT(data, 0);
-  }
-
-  void CheckBinary(const char* val, int32_t len) {
-    pos += sizeof(VarDataLenT);
-    char* data = (char*)(pData + pos);
-    pos += len;
-    EXPECT_STREQ(data, val);
-  }
-
-  int32_t            showId;
-  STableMetaMsg*     pMeta;
-  SRetrieveTableRsp* pRetrieveRsp;
-  char*              pData;
-  int32_t            pos;
 };
 
-SServer* DndTestStb::pServer;
-SClient* DndTestStb::pClient;
-int32_t  DndTestStb::connId;
+Testbase DndTestStb::test;
 
 TEST_F(DndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) {
   {
-    SCreateDbMsg* pReq = (SCreateDbMsg*)rpcMallocCont(sizeof(SCreateDbMsg));
+    int32_t contLen = sizeof(SCreateDbMsg);
+
+    SCreateDbMsg* pReq = (SCreateDbMsg*)rpcMallocCont(contLen);
     strcpy(pReq->db, "1.d1");
     pReq->numOfVgroups = htonl(2);
     pReq->cacheBlockSize = htonl(16);
@@ -200,13 +51,7 @@ TEST_F(DndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) {
     pReq->cacheLastRow = 0;
     pReq->ignoreExist = 1;
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SCreateDbMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_CREATE_DB;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
+    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_DB, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
@@ -214,9 +59,9 @@ TEST_F(DndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) {
   {
     int32_t cols = 2;
     int32_t tags = 3;
-    int32_t size = (tags + cols) * sizeof(SSchema) + sizeof(SCreateStbMsg);
+    int32_t contLen = (tags + cols) * sizeof(SSchema) + sizeof(SCreateStbMsg);
 
-    SCreateStbMsg* pReq = (SCreateStbMsg*)rpcMallocCont(size);
+    SCreateStbMsg* pReq = (SCreateStbMsg*)rpcMallocCont(contLen);
     strcpy(pReq->name, "1.d1.stb");
     pReq->numOfTags = htonl(tags);
     pReq->numOfColumns = htonl(cols);
@@ -261,24 +106,21 @@ TEST_F(DndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) {
       strcpy(pSchema->name, "tag3");
     }
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = size;
-    rpcMsg.msgType = TSDB_MSG_TYPE_CREATE_STB;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
+    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_STB, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
 
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_STB, "show stables", 4, "1.d1");
-  CheckSchema(0, TSDB_DATA_TYPE_BINARY, TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE, "name");
-  CheckSchema(1, TSDB_DATA_TYPE_TIMESTAMP, 8, "create_time");
-  CheckSchema(2, TSDB_DATA_TYPE_INT, 4, "columns");
-  CheckSchema(3, TSDB_DATA_TYPE_INT, 4, "tags");
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_STB, "1.d1");
+  CHECK_META("show stables", 4);
 
-  SendThenCheckShowRetrieveMsg(1);
+  CHECK_SCHEMA(0, TSDB_DATA_TYPE_BINARY, TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE, "name");
+  CHECK_SCHEMA(1, TSDB_DATA_TYPE_TIMESTAMP, 8, "create_time");
+  CHECK_SCHEMA(2, TSDB_DATA_TYPE_INT, 4, "columns");
+  CHECK_SCHEMA(3, TSDB_DATA_TYPE_INT, 4, "tags");
+
+  test.SendShowRetrieveMsg();
+  EXPECT_EQ(test.GetShowRows(), 1);
   CheckBinary("stb", TSDB_TABLE_NAME_LEN);
   CheckTimestamp();
   CheckInt32(2);
@@ -286,16 +128,12 @@ TEST_F(DndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) {
 
   // ----- meta ------
   {
-    STableInfoMsg* pReq = (STableInfoMsg*)rpcMallocCont(sizeof(STableInfoMsg));
+    int32_t contLen = sizeof(STableInfoMsg);
+
+    STableInfoMsg* pReq = (STableInfoMsg*)rpcMallocCont(contLen);
     strcpy(pReq->tableFname, "1.d1.stb");
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(STableInfoMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_TABLE_META;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
+    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_TABLE_META, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
 
@@ -336,39 +174,31 @@ TEST_F(DndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) {
   }
 
   // restart
-  stopServer(pServer);
-  pServer = NULL;
+  test.Restart();
 
-  uInfo("start all server");
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_STB, "1.d1");
+  CHECK_META("show stables", 4);
+  test.SendShowRetrieveMsg();
+  EXPECT_EQ(test.GetShowRows(), 1);
 
-  const char* fqdn = "localhost";
-  const char* firstEp = "localhost:9101";
-  pServer = startServer("/tmp/dnode_test_stb", fqdn, 9101, firstEp);
-
-  uInfo("all server is running");
-
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_STB, "show stables", 4, "1.d1");
-  SendThenCheckShowRetrieveMsg(1);
   CheckBinary("stb", TSDB_TABLE_NAME_LEN);
   CheckTimestamp();
   CheckInt32(2);
   CheckInt32(3);
 
   {
-    SDropStbMsg* pReq = (SDropStbMsg*)rpcMallocCont(sizeof(SDropStbMsg));
+    int32_t contLen = sizeof(SDropStbMsg);
+
+    SDropStbMsg* pReq = (SDropStbMsg*)rpcMallocCont(contLen);
     strcpy(pReq->name, "1.d1.stb");
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SDropStbMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_DROP_STB;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
+    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_DROP_STB, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
 
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_STB, "show stables", 4, "1.d1");
-  SendThenCheckShowRetrieveMsg(0);
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_STB, "1.d1");
+  CHECK_META("show stables", 4);
+  test.SendShowRetrieveMsg();
+  EXPECT_EQ(test.GetShowRows(), 0);
 }

source/dnode/mgmt/impl/test/sut/CMakeLists.txt

@@ -0,0 +1,14 @@
+aux_source_directory(src SUT_SRC)
+add_library(sut STATIC ${SUT_SRC})
+target_link_libraries(
+    sut
+    PUBLIC dnode
+    PUBLIC util
+    PUBLIC os
+    PUBLIC gtest_main
+)
+
+target_include_directories(
+    sut
+    PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+)

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

@@ -1,161 +0,0 @@
-/*
- * 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 "deploy.h"
-
-void initLog(const char* path) {
-  dDebugFlag = 207;
-  vDebugFlag = 0;
-  mDebugFlag = 207;
-  cDebugFlag = 0;
-  jniDebugFlag = 0;
-  tmrDebugFlag = 0;
-  uDebugFlag = 143;
-  rpcDebugFlag = 0;
-  odbcDebugFlag = 0;
-  qDebugFlag = 0;
-  wDebugFlag = 0;
-  sDebugFlag = 0;
-  tsdbDebugFlag = 0;
-  cqDebugFlag = 0;
-  tscEmbeddedInUtil = 1;
-
-  taosRemoveDir(path);
-  taosMkDir(path);
-
-  char temp[PATH_MAX];
-  snprintf(temp, PATH_MAX, "%s/taosdlog", path);
-  if (taosInitLog(temp, tsNumOfLogLines, 1) != 0) {
-    printf("failed to init log file\n");
-  }
-}
-
-void* runServer(void* param) {
-  SServer* pServer = (SServer*)param;
-  while (1) {
-    taosMsleep(100);
-    pthread_testcancel();
-  }
-}
-
-void initOption(SDnodeOpt* pOption, const char* path, const char* fqdn, uint16_t port, const char* firstEp) {
-  pOption->sver = 1;
-  pOption->numOfCores = 1;
-  pOption->numOfSupportMnodes = 1;
-  pOption->numOfSupportVnodes = 1;
-  pOption->numOfSupportQnodes = 1;
-  pOption->statusInterval = 1;
-  pOption->numOfThreadsPerCore = 1;
-  pOption->ratioOfQueryCores = 1;
-  pOption->maxShellConns = 1000;
-  pOption->shellActivityTimer = 30;
-  pOption->serverPort = port;
-  strcpy(pOption->dataDir, path);
-  snprintf(pOption->localEp, TSDB_EP_LEN, "%s:%u", fqdn, port);
-  snprintf(pOption->localFqdn, TSDB_FQDN_LEN, "%s", fqdn);
-  snprintf(pOption->firstEp, TSDB_EP_LEN, "%s", firstEp);
-}
-
-SServer* startServer(const char* path, const char* fqdn, uint16_t port, const char* firstEp) {
-  taosMkDir(path);
-
-  SDnodeOpt option = {0};
-  initOption(&option, path, fqdn, port, firstEp);
-
-  SDnode* pDnode = dndInit(&option);
-  ASSERT(pDnode);
-
-  SServer* pServer = (SServer*)calloc(1, sizeof(SServer));
-  ASSERT(pServer);
-
-  pServer->pDnode = pDnode;
-  pServer->threadId = taosCreateThread(runServer, pServer);
-  ASSERT(pServer->threadId);
-
-  return pServer;
-}
-
-SServer* createServer(const char* path, const char* fqdn, uint16_t port, const char* firstEp) {
-  taosRemoveDir(path);
-  return startServer(path, fqdn, port, firstEp);
-}
-
-void stopServer(SServer* pServer) {
-  if (pServer == NULL) return;
-  if (pServer->threadId != NULL) {
-    taosDestoryThread(pServer->threadId);
-  }
-
-  if (pServer->pDnode != NULL) {
-    dndCleanup(pServer->pDnode);
-    pServer->pDnode = NULL;
-  }
-}
-
-void processClientRsp(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) {
-  SClient* pClient = (SClient*)parent;
-  pClient->pRsp = pMsg;
-  uInfo("response:%s from dnode, pCont:%p contLen:%d code:0x%X", taosMsg[pMsg->msgType], pMsg->pCont, pMsg->contLen,
-        pMsg->code);
-  tsem_post(&pClient->sem);
-}
-
-SClient* createClient(const char* user, const char* pass, const char* fqdn, uint16_t port) {
-  SClient* pClient = (SClient*)calloc(1, sizeof(SClient));
-  ASSERT(pClient);
-
-  char secretEncrypt[TSDB_PASSWORD_LEN] = {0};
-  taosEncryptPass((uint8_t*)pass, strlen(pass), secretEncrypt);
-
-  SRpcInit rpcInit;
-  memset(&rpcInit, 0, sizeof(rpcInit));
-  rpcInit.label = (char*)"DND-C";
-  rpcInit.numOfThreads = 1;
-  rpcInit.cfp = processClientRsp;
-  rpcInit.sessions = 1024;
-  rpcInit.connType = TAOS_CONN_CLIENT;
-  rpcInit.idleTime = 30 * 1000;
-  rpcInit.user = (char*)user;
-  rpcInit.ckey = (char*)"key";
-  rpcInit.parent = pClient;
-  rpcInit.secret = (char*)secretEncrypt;
-  rpcInit.parent = pClient;
-  // rpcInit.spi = 1;
-
-  pClient->clientRpc = rpcOpen(&rpcInit);
-  ASSERT(pClient->clientRpc);
-
-  tsem_init(&pClient->sem, 0, 0);
-  strcpy(pClient->fqdn, fqdn);
-  pClient->port = port;
-
-  return pClient;
-}
-
-void dropClient(SClient* pClient) {
-  tsem_destroy(&pClient->sem);
-  rpcClose(pClient->clientRpc);
-}
-
-void sendMsg(SClient* pClient, SRpcMsg* pMsg) {
-  SEpSet epSet = {0};
-  epSet.inUse = 0;
-  epSet.numOfEps = 1;
-  epSet.port[0] = pClient->port;
-  memcpy(epSet.fqdn[0], pClient->fqdn, TSDB_FQDN_LEN);
-
-  rpcSendRequest(pClient->clientRpc, &epSet, pMsg, NULL);
-  tsem_wait(&pClient->sem);
-}

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

@@ -1,49 +0,0 @@
-/*
- * 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 <gtest/gtest.h>
-#include "os.h"
-
-#include "dnode.h"
-#include "taosmsg.h"
-#include "tconfig.h"
-#include "tglobal.h"
-#include "tnote.h"
-#include "trpc.h"
-#include "tthread.h"
-#include "ulog.h"
-#include "tdataformat.h"
-
-typedef struct {
-  SDnode*    pDnode;
-  pthread_t* threadId;
-} SServer;
-
-typedef struct {
-  char     fqdn[TSDB_FQDN_LEN];
-  uint16_t port;
-  void*    clientRpc;
-  SRpcMsg* pRsp;
-  tsem_t   sem;
-} SClient;
-
-void     initLog(const char* path);
-SServer* createServer(const char* path, const char* fqdn, uint16_t port, const char* firstEp);
-SServer* startServer(const char* path, const char* fqdn, uint16_t port, const char* firstEp);
-void     stopServer(SServer* pServer);
-SClient* createClient(const char* user, const char* pass, const char* fqdn, uint16_t port);
-void     dropClient(SClient* pClient);
-void     sendMsg(SClient* pClient, SRpcMsg* pMsg);
-

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

@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_TEST_BASE_H_
+#define _TD_TEST_BASE_H_
+
+#include <gtest/gtest.h>
+#include "os.h"
+
+#include "dnode.h"
+#include "taosmsg.h"
+#include "tconfig.h"
+#include "tdataformat.h"
+#include "tglobal.h"
+#include "tnote.h"
+#include "trpc.h"
+#include "tthread.h"
+#include "ulog.h"
+
+#include "client.h"
+#include "server.h"
+
+class Testbase {
+ public:
+  void     Init(const char* path, int16_t port);
+  void     Cleanup();
+  void     Restart();
+  SRpcMsg* SendMsg(int8_t msgType, void* pCont, int32_t contLen);
+
+ private:
+  void InitLog(const char* path);
+
+ private:
+  TestServer server;
+  TestClient client;
+  int32_t    connId;
+
+ public:
+  void SendShowMetaMsg(int8_t showType, const char* db);
+  void SendShowRetrieveMsg();
+
+  STableMetaMsg*     GetShowMeta();
+  SRetrieveTableRsp* GetRetrieveRsp();
+
+  int32_t     GetMetaNum();
+  const char* GetMetaTbName();
+  int32_t     GetMetaColId(int32_t index);
+  int8_t      GetMetaType(int32_t index);
+  int32_t     GetMetaBytes(int32_t index);
+  const char* GetMetaName(int32_t index);
+
+  const char* GetShowName();
+  int32_t     GetShowRows();
+  int8_t      GetShowInt8();
+  int16_t     GetShowInt16();
+  int32_t     GetShowInt32();
+  int64_t     GetShowInt64();
+  int64_t     GetShowTimestamp();
+  const char* GetShowBinary(int32_t len);
+
+ private:
+  int32_t            showId;
+  STableMetaMsg*     pMeta;
+  SRetrieveTableRsp* pRetrieveRsp;
+  char*              pData;
+  int32_t            pos;
+};
+
+#define CHECK_META(tbName, numOfColumns)        \
+  {                                             \
+    EXPECT_EQ(test.GetMetaNum(), numOfColumns); \
+    EXPECT_STREQ(test.GetMetaTbName(), tbName); \
+  }
+
+#define CHECK_SCHEMA(colId, type, bytes, colName)   \
+  {                                                 \
+    EXPECT_EQ(test.GetMetaType(colId), type);       \
+    EXPECT_EQ(test.GetMetaBytes(colId), bytes);     \
+    EXPECT_STREQ(test.GetMetaName(colId), colName); \
+  }
+
+#define CheckBinary(val, len) \
+  { EXPECT_STREQ(test.GetShowBinary(len), val); }
+
+#define CheckInt8(val) \
+  { EXPECT_EQ(test.GetShowInt8(), val); }
+
+#define CheckInt16(val) \
+  { EXPECT_EQ(test.GetShowInt16(), val); }
+
+#define CheckInt32(val) \
+  { EXPECT_EQ(test.GetShowInt32(), val); }
+
+#define CheckInt64(val) \
+  { EXPECT_EQ(test.GetShowInt64(), val); }
+
+#define CheckTimestamp() \
+  { EXPECT_GT(test.GetShowTimestamp(), 0); }
+
+#define IgnoreBinary(len) \
+  { test.GetShowBinary(len); }
+
+#define IgnoreInt8() \
+  { test.GetShowInt8(); }
+
+#define IgnoreInt16() \
+  { test.GetShowInt16(); }
+
+#define IgnoreInt32() \
+  { test.GetShowInt32(); }
+
+#define IgnoreInt64() \
+  { test.GetShowInt64(); }
+
+#define IgnoreTimestamp() \
+  { test.GetShowTimestamp(); }
+
+#endif /* _TD_TEST_BASE_H_ */

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

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_TEST_CLIENT_H_
+#define _TD_TEST_CLIENT_H_
+
+class TestClient {
+ public:
+  bool Init(const char* user, const char* pass, const char* fqdn, uint16_t port);
+  void Cleanup();
+
+  SRpcMsg* SendMsg(SRpcMsg* pMsg);
+  void     SetRpcRsp(SRpcMsg* pRsp);
+  tsem_t*  GetSem();
+
+ private:
+  char     fqdn[TSDB_FQDN_LEN];
+  uint16_t port;
+  void*    clientRpc;
+  SRpcMsg* pRsp;
+  tsem_t   sem;
+};
+
+#endif /* _TD_TEST_CLIENT_H_ */

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

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_TEST_SERVER_H_
+#define _TD_TEST_SERVER_H_
+
+class TestServer {
+ public:
+  bool Start(const char* path, const char* fqdn, uint16_t port, const char* firstEp);
+  void Stop();
+  void Restart();
+
+ private:
+  SDnodeOpt BuildOption(const char* path, const char* fqdn, uint16_t port, const char* firstEp);
+  bool      DoStart();
+
+ private:
+  SDnode*    pDnode;
+  pthread_t* threadId;
+  char       path[PATH_MAX];
+  char       fqdn[TSDB_FQDN_LEN];
+  char       firstEp[TSDB_EP_LEN];
+  uint16_t   port;
+};
+
+#endif /* _TD_TEST_SERVER_H_ */

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

@@ -0,0 +1,180 @@
+/*
+ * 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 "base.h"
+
+void Testbase::InitLog(const char* path) {
+  dDebugFlag = 207;
+  vDebugFlag = 0;
+  mDebugFlag = 207;
+  cDebugFlag = 0;
+  jniDebugFlag = 0;
+  tmrDebugFlag = 0;
+  uDebugFlag = 143;
+  rpcDebugFlag = 0;
+  odbcDebugFlag = 0;
+  qDebugFlag = 0;
+  wDebugFlag = 0;
+  sDebugFlag = 0;
+  tsdbDebugFlag = 0;
+  cqDebugFlag = 0;
+  tscEmbeddedInUtil = 1;
+
+  taosRemoveDir(path);
+  taosMkDir(path);
+
+  char temp[PATH_MAX];
+  snprintf(temp, PATH_MAX, "%s/taosdlog", path);
+  if (taosInitLog(temp, tsNumOfLogLines, 1) != 0) {
+    printf("failed to init log file\n");
+  }
+}
+
+void Testbase::Init(const char* path, int16_t port) {
+  char fqdn[] = "localhost";
+  char firstEp[TSDB_EP_LEN] = {0};
+  snprintf(firstEp, TSDB_EP_LEN, "%s:%u", fqdn, port);
+
+  InitLog("/tmp/tdlog");
+  server.Start(path, fqdn, port, firstEp);
+  client.Init("root", "taosdata", fqdn, port);
+  taosMsleep(1100);
+}
+
+void Testbase::Cleanup() {
+  server.Stop();
+  client.Cleanup();
+}
+
+void Testbase::Restart() { server.Restart(); }
+
+SRpcMsg* Testbase::SendMsg(int8_t msgType, void* pCont, int32_t contLen) {
+  SRpcMsg rpcMsg = {0};
+  rpcMsg.pCont = pCont;
+  rpcMsg.contLen = contLen;
+  rpcMsg.msgType = msgType;
+
+  return client.SendMsg(&rpcMsg);
+}
+
+void Testbase::SendShowMetaMsg(int8_t showType, const char* db) {
+  int32_t   contLen = sizeof(SShowMsg);
+  SShowMsg* pShow = (SShowMsg*)rpcMallocCont(contLen);
+  pShow->type = showType;
+  strcpy(pShow->db, db);
+
+  SRpcMsg*  pMsg = SendMsg(TSDB_MSG_TYPE_SHOW, pShow, contLen);
+  SShowRsp* pShowRsp = (SShowRsp*)pMsg->pCont;
+
+  ASSERT(pShowRsp != nullptr);
+  pShowRsp->showId = htonl(pShowRsp->showId);
+  pMeta = &pShowRsp->tableMeta;
+  pMeta->numOfTags = htonl(pMeta->numOfTags);
+  pMeta->numOfColumns = htonl(pMeta->numOfColumns);
+  pMeta->sversion = htonl(pMeta->sversion);
+  pMeta->tversion = htonl(pMeta->tversion);
+  pMeta->tuid = htobe64(pMeta->tuid);
+  pMeta->suid = htobe64(pMeta->suid);
+
+  showId = pShowRsp->showId;
+}
+
+int32_t Testbase::GetMetaColId(int32_t index) {
+  SSchema* pSchema = &pMeta->pSchema[index];
+  pSchema->colId = htonl(pSchema->colId);
+  return pSchema->colId;
+}
+
+int8_t Testbase::GetMetaType(int32_t index) {
+  SSchema* pSchema = &pMeta->pSchema[index];
+  return pSchema->type;
+}
+
+int32_t Testbase::GetMetaBytes(int32_t index) {
+  SSchema* pSchema = &pMeta->pSchema[index];
+  pSchema->bytes = htonl(pSchema->bytes);
+  return pSchema->bytes;
+}
+
+const char* Testbase::GetMetaName(int32_t index) {
+  SSchema* pSchema = &pMeta->pSchema[index];
+  return pSchema->name;
+}
+
+int32_t Testbase::GetMetaNum() { return pMeta->numOfColumns; }
+
+const char* Testbase::GetMetaTbName() { return pMeta->tbFname; }
+
+void Testbase::SendShowRetrieveMsg() {
+  int32_t contLen = sizeof(SRetrieveTableMsg);
+
+  SRetrieveTableMsg* pRetrieve = (SRetrieveTableMsg*)rpcMallocCont(contLen);
+  pRetrieve->showId = htonl(showId);
+  pRetrieve->free = 0;
+
+  SRpcMsg* pMsg = SendMsg(TSDB_MSG_TYPE_SHOW_RETRIEVE, pRetrieve, contLen);
+  pRetrieveRsp = (SRetrieveTableRsp*)pMsg->pCont;
+  pRetrieveRsp->numOfRows = htonl(pRetrieveRsp->numOfRows);
+  pRetrieveRsp->useconds = htobe64(pRetrieveRsp->useconds);
+  pRetrieveRsp->compLen = htonl(pRetrieveRsp->compLen);
+
+  pData = pRetrieveRsp->data;
+  pos = 0;
+}
+
+const char* Testbase::GetShowName() { return pMeta->tbFname; }
+
+int8_t Testbase::GetShowInt8() {
+  int8_t data = *((int8_t*)(pData + pos));
+  pos += sizeof(int8_t);
+  return data;
+}
+
+int16_t Testbase::GetShowInt16() {
+  int16_t data = *((int16_t*)(pData + pos));
+  pos += sizeof(int16_t);
+  return data;
+}
+
+int32_t Testbase::GetShowInt32() {
+  int32_t data = *((int32_t*)(pData + pos));
+  pos += sizeof(int32_t);
+  return data;
+}
+
+int64_t Testbase::GetShowInt64() {
+  int64_t data = *((int64_t*)(pData + pos));
+  pos += sizeof(int64_t);
+  return data;
+}
+
+int64_t Testbase::GetShowTimestamp() {
+  int64_t data = *((int64_t*)(pData + pos));
+  pos += sizeof(int64_t);
+  return data;
+}
+
+const char* Testbase::GetShowBinary(int32_t len) {
+  pos += sizeof(VarDataLenT);
+  char* data = (char*)(pData + pos);
+  pos += len;
+  return data;
+}
+
+int32_t Testbase::GetShowRows() { return pRetrieveRsp->numOfRows; }
+
+STableMetaMsg* Testbase::GetShowMeta() { return pMeta; }
+
+SRetrieveTableRsp* Testbase::GetRetrieveRsp() { return pRetrieveRsp; }

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

@@ -0,0 +1,73 @@
+/*
+ * 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 "base.h"
+
+static void processClientRsp(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) {
+  TestClient* client = (TestClient*)parent;
+  client->SetRpcRsp(pMsg);
+  uInfo("response:%s from dnode, code:0x%x", taosMsg[pMsg->msgType], pMsg->code);
+  tsem_post(client->GetSem());
+}
+
+void TestClient::SetRpcRsp(SRpcMsg* pRsp) { this->pRsp = pRsp; };
+
+tsem_t* TestClient::GetSem() { return &sem; }
+
+bool TestClient::Init(const char* user, const char* pass, const char* fqdn, uint16_t port) {
+  char secretEncrypt[TSDB_PASSWORD_LEN] = {0};
+  taosEncryptPass((uint8_t*)pass, strlen(pass), secretEncrypt);
+
+  SRpcInit rpcInit;
+  memset(&rpcInit, 0, sizeof(rpcInit));
+  rpcInit.label = (char*)"DND-C";
+  rpcInit.numOfThreads = 1;
+  rpcInit.cfp = processClientRsp;
+  rpcInit.sessions = 1024;
+  rpcInit.connType = TAOS_CONN_CLIENT;
+  rpcInit.idleTime = 30 * 1000;
+  rpcInit.user = (char*)user;
+  rpcInit.ckey = (char*)"key";
+  rpcInit.parent = this;
+  rpcInit.secret = (char*)secretEncrypt;
+  // rpcInit.spi = 1;
+
+  clientRpc = rpcOpen(&rpcInit);
+  ASSERT(clientRpc);
+
+  tsem_init(&sem, 0, 0);
+  strcpy(this->fqdn, fqdn);
+  this->port = port;
+
+  return true;
+}
+
+void TestClient::Cleanup() {
+  tsem_destroy(&sem);
+  rpcClose(clientRpc);
+}
+
+SRpcMsg* TestClient::SendMsg(SRpcMsg* pMsg) {
+  SEpSet epSet = {0};
+  epSet.inUse = 0;
+  epSet.numOfEps = 1;
+  epSet.port[0] = port;
+  memcpy(epSet.fqdn[0], fqdn, TSDB_FQDN_LEN);
+
+  rpcSendRequest(clientRpc, &epSet, pMsg, NULL);
+  tsem_wait(&sem);
+
+  return pRsp;
+}

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

@@ -0,0 +1,88 @@
+/*
+ * 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 "base.h"
+
+void* serverLoop(void* param) {
+  while (1) {
+    taosMsleep(100);
+    pthread_testcancel();
+  }
+}
+
+SDnodeOpt TestServer::BuildOption(const char* path, const char* fqdn, uint16_t port, const char* firstEp) {
+  SDnodeOpt option = {0};
+  option.sver = 1;
+  option.numOfCores = 1;
+  option.numOfSupportMnodes = 1;
+  option.numOfSupportVnodes = 1;
+  option.numOfSupportQnodes = 1;
+  option.statusInterval = 1;
+  option.numOfThreadsPerCore = 1;
+  option.ratioOfQueryCores = 1;
+  option.maxShellConns = 1000;
+  option.shellActivityTimer = 30;
+  option.serverPort = port;
+  strcpy(option.dataDir, path);
+  snprintf(option.localEp, TSDB_EP_LEN, "%s:%u", fqdn, port);
+  snprintf(option.localFqdn, TSDB_FQDN_LEN, "%s", fqdn);
+  snprintf(option.firstEp, TSDB_EP_LEN, "%s", firstEp);
+  return option;
+}
+
+bool TestServer::DoStart() {
+  SDnodeOpt option = BuildOption(path, fqdn, port, firstEp);
+  taosMkDir(path);
+
+  pDnode = dndInit(&option);
+  if (pDnode != NULL) {
+    return false;
+  }
+
+  threadId = taosCreateThread(serverLoop, NULL);
+  if (threadId != NULL) {
+    return false;
+  }
+  return true;
+}
+
+void TestServer::Restart() {
+  uInfo("start all server");
+  Stop();
+  DoStart();
+  uInfo("all server is running");
+}
+
+bool TestServer::Start(const char* path, const char* fqdn, uint16_t port, const char* firstEp) {
+  strcpy(this->path, path);
+  strcpy(this->fqdn, fqdn);
+  this->port = port;
+  strcpy(this->firstEp, firstEp);
+
+  taosRemoveDir(path);
+  return DoStart();
+}
+
+void TestServer::Stop() {
+  if (threadId != NULL) {
+    taosDestoryThread(threadId);
+    threadId = NULL;
+  }
+
+  if (pDnode != NULL) {
+    dndCleanup(pDnode);
+    pDnode = NULL;
+  }
+}

source/dnode/mgmt/impl/test/user/CMakeLists.txt

@@ -1,24 +1,8 @@
-add_executable(dnode_test_user "")
-
-target_sources(dnode_test_user
-    PRIVATE
-    "user.cpp"
-    "../sut/deploy.cpp"
-)
-
+aux_source_directory(. USER_SRC)
+add_executable(dnode_test_user ${USER_SRC})
 target_link_libraries(
     dnode_test_user
-    PUBLIC dnode
-    PUBLIC util
-    PUBLIC os
-    PUBLIC gtest_main
-)
-
-target_include_directories(dnode_test_user
-    PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/server/dnode/mgmt"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../../inc"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
+    PUBLIC sut
 )
 
 add_test(

source/dnode/mgmt/impl/test/user/user.cpp

@@ -9,168 +9,34 @@
  *
  */
 
-#include "deploy.h"
+#include "base.h"
 
 class DndTestUser : public ::testing::Test {
  protected:
-  static SServer* CreateServer(const char* path, const char* fqdn, uint16_t port, const char* firstEp) {
-    SServer* pServer = createServer(path, fqdn, port, firstEp);
-    ASSERT(pServer);
-    return pServer;
-  }
+  static void SetUpTestSuite() { test.Init("/tmp/dnode_test_user", 9140); }
+  static void TearDownTestSuite() { test.Cleanup(); }
 
-  static void SetUpTestSuite() {
-    initLog("/tmp/tdlog");
-
-    const char* fqdn = "localhost";
-    const char* firstEp = "localhost:9140";
-    pServer = CreateServer("/tmp/dnode_test_user", fqdn, 9140, firstEp);
-    pClient = createClient("root", "taosdata", fqdn, 9140);
-    taosMsleep(300);
-  }
-
-  static void TearDownTestSuite() {
-    stopServer(pServer);
-    dropClient(pClient);
-    pServer = NULL;
-    pClient = NULL;
-  }
-
-  static SServer* pServer;
-  static SClient* pClient;
-  static int32_t  connId;
+  static Testbase test;
 
  public:
   void SetUp() override {}
   void TearDown() override {}
-
-  void SendTheCheckShowMetaMsg(int8_t showType, const char* showName, int32_t columns) {
-    SShowMsg* pShow = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));
-    pShow->type = showType;
-    strcpy(pShow->db, "");
-
-    SRpcMsg showRpcMsg = {0};
-    showRpcMsg.pCont = pShow;
-    showRpcMsg.contLen = sizeof(SShowMsg);
-    showRpcMsg.msgType = TSDB_MSG_TYPE_SHOW;
-
-    sendMsg(pClient, &showRpcMsg);
-    ASSERT_NE(pClient->pRsp, nullptr);
-    ASSERT_EQ(pClient->pRsp->code, 0);
-    ASSERT_NE(pClient->pRsp->pCont, nullptr);
-
-    SShowRsp* pShowRsp = (SShowRsp*)pClient->pRsp->pCont;
-    ASSERT_NE(pShowRsp, nullptr);
-    pShowRsp->showId = htonl(pShowRsp->showId);
-    pMeta = &pShowRsp->tableMeta;
-    pMeta->numOfTags = htonl(pMeta->numOfTags);
-    pMeta->numOfColumns = htonl(pMeta->numOfColumns);
-    pMeta->sversion = htonl(pMeta->sversion);
-    pMeta->tversion = htonl(pMeta->tversion);
-    pMeta->tuid = htobe64(pMeta->tuid);
-    pMeta->suid = htobe64(pMeta->suid);
-
-    showId = pShowRsp->showId;
-
-    EXPECT_NE(pShowRsp->showId, 0);
-    EXPECT_STREQ(pMeta->tbFname, showName);
-    EXPECT_EQ(pMeta->numOfTags, 0);
-    EXPECT_EQ(pMeta->numOfColumns, columns);
-    EXPECT_EQ(pMeta->precision, 0);
-    EXPECT_EQ(pMeta->tableType, 0);
-    EXPECT_EQ(pMeta->update, 0);
-    EXPECT_EQ(pMeta->sversion, 0);
-    EXPECT_EQ(pMeta->tversion, 0);
-    EXPECT_EQ(pMeta->tuid, 0);
-    EXPECT_EQ(pMeta->suid, 0);
-  }
-
-  void CheckSchema(int32_t index, int8_t type, int32_t bytes, const char* name) {
-    SSchema* pSchema = &pMeta->pSchema[index];
-    pSchema->bytes = htonl(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, type);
-    EXPECT_EQ(pSchema->bytes, bytes);
-    EXPECT_STREQ(pSchema->name, name);
-  }
-
-  void SendThenCheckShowRetrieveMsg(int32_t rows) {
-    SRetrieveTableMsg* pRetrieve = (SRetrieveTableMsg*)rpcMallocCont(sizeof(SRetrieveTableMsg));
-    pRetrieve->showId = htonl(showId);
-    pRetrieve->free = 0;
-
-    SRpcMsg retrieveRpcMsg = {0};
-    retrieveRpcMsg.pCont = pRetrieve;
-    retrieveRpcMsg.contLen = sizeof(SRetrieveTableMsg);
-    retrieveRpcMsg.msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE;
-
-    sendMsg(pClient, &retrieveRpcMsg);
-
-    ASSERT_NE(pClient->pRsp, nullptr);
-    ASSERT_EQ(pClient->pRsp->code, 0);
-    ASSERT_NE(pClient->pRsp->pCont, nullptr);
-
-    pRetrieveRsp = (SRetrieveTableRsp*)pClient->pRsp->pCont;
-    ASSERT_NE(pRetrieveRsp, nullptr);
-    pRetrieveRsp->numOfRows = htonl(pRetrieveRsp->numOfRows);
-    pRetrieveRsp->useconds = htobe64(pRetrieveRsp->useconds);
-    pRetrieveRsp->compLen = htonl(pRetrieveRsp->compLen);
-
-    EXPECT_EQ(pRetrieveRsp->numOfRows, rows);
-    EXPECT_EQ(pRetrieveRsp->useconds, 0);
-    // EXPECT_EQ(pRetrieveRsp->completed, completed);
-    EXPECT_EQ(pRetrieveRsp->precision, TSDB_TIME_PRECISION_MILLI);
-    EXPECT_EQ(pRetrieveRsp->compressed, 0);
-    EXPECT_EQ(pRetrieveRsp->compLen, 0);
-
-    pData = pRetrieveRsp->data;
-    pos = 0;
-  }
-
-  void CheckInt16(int16_t val) {
-    int16_t data = *((int16_t*)(pData + pos));
-    pos += sizeof(int16_t);
-    EXPECT_EQ(data, val);
-  }
-
-  void CheckInt64(int64_t val) {
-    int64_t data = *((int64_t*)(pData + pos));
-    pos += sizeof(int64_t);
-    EXPECT_EQ(data, val);
-  }
-
-  void CheckTimestamp() {
-    int64_t data = *((int64_t*)(pData + pos));
-    pos += sizeof(int64_t);
-    EXPECT_GT(data, 0);
-  }
-
-  void CheckBinary(const char* val, int32_t len) {
-    pos += sizeof(VarDataLenT);
-    char* data = (char*)(pData + pos);
-    pos += len;
-    EXPECT_STREQ(data, val);
-  }
-
-  int32_t            showId;
-  STableMetaMsg*     pMeta;
-  SRetrieveTableRsp* pRetrieveRsp;
-  char*              pData;
-  int32_t            pos;
 };
 
-SServer* DndTestUser::pServer;
-SClient* DndTestUser::pClient;
-int32_t  DndTestUser::connId;
+Testbase DndTestUser::test;
 
 TEST_F(DndTestUser, 01_ShowUser) {
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_USER, "show users", 4);
-  CheckSchema(0, TSDB_DATA_TYPE_BINARY, TSDB_USER_LEN + VARSTR_HEADER_SIZE, "name");
-  CheckSchema(1, TSDB_DATA_TYPE_BINARY, 10 + VARSTR_HEADER_SIZE, "privilege");
-  CheckSchema(2, TSDB_DATA_TYPE_TIMESTAMP, 8, "create_time");
-  CheckSchema(3, TSDB_DATA_TYPE_BINARY, TSDB_USER_LEN + VARSTR_HEADER_SIZE, "account");
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_USER, "");
+  CHECK_META("show users", 4);
+
+  CHECK_SCHEMA(0, TSDB_DATA_TYPE_BINARY, TSDB_USER_LEN + VARSTR_HEADER_SIZE, "name");
+  CHECK_SCHEMA(1, TSDB_DATA_TYPE_BINARY, 10 + VARSTR_HEADER_SIZE, "privilege");
+  CHECK_SCHEMA(2, TSDB_DATA_TYPE_TIMESTAMP, 8, "create_time");
+  CHECK_SCHEMA(3, TSDB_DATA_TYPE_BINARY, TSDB_USER_LEN + VARSTR_HEADER_SIZE, "account");
+
+  test.SendShowRetrieveMsg();
+  EXPECT_EQ(test.GetShowRows(), 1);
 
-  SendThenCheckShowRetrieveMsg(1);
   CheckBinary("root", TSDB_USER_LEN);
   CheckBinary("super", 10);
   CheckTimestamp();
@@ -179,39 +45,35 @@ TEST_F(DndTestUser, 01_ShowUser) {
 
 TEST_F(DndTestUser, 02_Create_Drop_Alter_User) {
   {
-    SCreateUserMsg* pReq = (SCreateUserMsg*)rpcMallocCont(sizeof(SCreateUserMsg));
+    int32_t contLen = sizeof(SCreateUserMsg);
+
+    SCreateUserMsg* pReq = (SCreateUserMsg*)rpcMallocCont(contLen);
     strcpy(pReq->user, "u1");
     strcpy(pReq->pass, "p1");
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SCreateUserMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_CREATE_USER;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
+    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_USER, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
 
   {
-    SCreateUserMsg* pReq = (SCreateUserMsg*)rpcMallocCont(sizeof(SCreateUserMsg));
+    int32_t contLen = sizeof(SCreateUserMsg);
+
+    SCreateUserMsg* pReq = (SCreateUserMsg*)rpcMallocCont(contLen);
     strcpy(pReq->user, "u2");
     strcpy(pReq->pass, "p2");
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SCreateUserMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_CREATE_USER;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
+    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_USER, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
 
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_USER, "show users", 4);
-  SendThenCheckShowRetrieveMsg(3);
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_USER, "");
+  CHECK_META("show users", 4);
+
+  test.SendShowRetrieveMsg();
+  EXPECT_EQ(test.GetShowRows(), 3);
+
   CheckBinary("u1", TSDB_USER_LEN);
   CheckBinary("root", TSDB_USER_LEN);
   CheckBinary("u2", TSDB_USER_LEN);
@@ -226,22 +88,23 @@ TEST_F(DndTestUser, 02_Create_Drop_Alter_User) {
   CheckBinary("root", TSDB_USER_LEN);
 
   {
-    SAlterUserMsg* pReq = (SAlterUserMsg*)rpcMallocCont(sizeof(SAlterUserMsg));
+    int32_t contLen = sizeof(SAlterUserMsg);
+
+    SAlterUserMsg* pReq = (SAlterUserMsg*)rpcMallocCont(contLen);
     strcpy(pReq->user, "u1");
     strcpy(pReq->pass, "p2");
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SAlterUserMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_ALTER_USER;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
+    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_ALTER_USER, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_USER, "show users", 4);
-  SendThenCheckShowRetrieveMsg(3);
+
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_USER, "");
+  CHECK_META("show users", 4);
+
+  test.SendShowRetrieveMsg();
+  EXPECT_EQ(test.GetShowRows(), 3);
+
   CheckBinary("u1", TSDB_USER_LEN);
   CheckBinary("root", TSDB_USER_LEN);
   CheckBinary("u2", TSDB_USER_LEN);
@@ -256,21 +119,22 @@ TEST_F(DndTestUser, 02_Create_Drop_Alter_User) {
   CheckBinary("root", TSDB_USER_LEN);
 
   {
-    SDropUserMsg* pReq = (SDropUserMsg*)rpcMallocCont(sizeof(SDropUserMsg));
+    int32_t contLen = sizeof(SDropUserMsg);
+
+    SDropUserMsg* pReq = (SDropUserMsg*)rpcMallocCont(contLen);
     strcpy(pReq->user, "u1");
 
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SDropUserMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_DROP_USER;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
+    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_DROP_USER, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_USER, "show users", 4);
-  SendThenCheckShowRetrieveMsg(2);
+
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_USER, "");
+  CHECK_META("show users", 4);
+
+  test.SendShowRetrieveMsg();
+  EXPECT_EQ(test.GetShowRows(), 2);
+
   CheckBinary("root", TSDB_USER_LEN);
   CheckBinary("u2", TSDB_USER_LEN);
   CheckBinary("super", 10);
@@ -281,19 +145,14 @@ TEST_F(DndTestUser, 02_Create_Drop_Alter_User) {
   CheckBinary("root", TSDB_USER_LEN);
 
   // restart
-  stopServer(pServer);
-  pServer = NULL;
+  test.Restart();
 
-  uInfo("start all server");
+  test.SendShowMetaMsg(TSDB_MGMT_TABLE_USER, "");
+  CHECK_META("show users", 4);
 
-  const char* fqdn = "localhost";
-  const char* firstEp = "localhost:9140";
-  pServer = startServer("/tmp/dnode_test_user", fqdn, 9140, firstEp);
+  test.SendShowRetrieveMsg();
+  EXPECT_EQ(test.GetShowRows(), 2);
 
-  uInfo("all server is running");
-
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_USER, "show users", 4);
-  SendThenCheckShowRetrieveMsg(2);
   CheckBinary("root", TSDB_USER_LEN);
   CheckBinary("u2", TSDB_USER_LEN);
   CheckBinary("super", 10);

source/dnode/mgmt/impl/test/vgroup/CMakeLists.txt

@@ -1,24 +1,8 @@
-add_executable(dnode_test_vgroup "")
-
-target_sources(dnode_test_vgroup
-    PRIVATE
-    "vgroup.cpp"
-    "../sut/deploy.cpp"
-)
-
+aux_source_directory(. VGROUP_SRC)
+add_executable(dnode_test_vgroup ${VGROUP_SRC})
 target_link_libraries(
     dnode_test_vgroup
-    PUBLIC dnode
-    PUBLIC util
-    PUBLIC os
-    PUBLIC gtest_main
-)
-
-target_include_directories(dnode_test_vgroup
-    PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/server/dnode/mgmt"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../../inc"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
+    PUBLIC sut
 )
 
 add_test(

source/dnode/mgmt/impl/test/vgroup/vgroup.cpp

@@ -9,177 +9,28 @@
  *
  */
 
-#include "deploy.h"
+#include "base.h"
 
 class DndTestVgroup : public ::testing::Test {
  protected:
-  static SServer* CreateServer(const char* path, const char* fqdn, uint16_t port, const char* firstEp) {
-    SServer* pServer = createServer(path, fqdn, port, firstEp);
-    ASSERT(pServer);
-    return pServer;
-  }
+  static void SetUpTestSuite() { test.Init("/tmp/dnode_test_vgroup", 9150); }
+  static void TearDownTestSuite() { test.Cleanup(); }
 
-  static void SetUpTestSuite() {
-    initLog("/tmp/tdlog");
-
-    const char* fqdn = "localhost";
-    const char* firstEp = "localhost:9150";
-    pServer = CreateServer("/tmp/dnode_test_vgroup", fqdn, 9150, firstEp);
-    pClient = createClient("root", "taosdata", fqdn, 9150);
-    taosMsleep(1100);
-  }
-
-  static void TearDownTestSuite() {
-    stopServer(pServer);
-    dropClient(pClient);
-    pServer = NULL;
-    pClient = NULL;
-  }
-
-  static SServer* pServer;
-  static SClient* pClient;
-  static int32_t  connId;
+  static Testbase test;
 
  public:
   void SetUp() override {}
   void TearDown() override {}
-
-  void SendTheCheckShowMetaMsg(int8_t showType, const char* showName, int32_t columns, const char* db) {
-    SShowMsg* pShow = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));
-    pShow->type = showType;
-    if (db != NULL) {
-      strcpy(pShow->db, db);
-    }
-    SRpcMsg showRpcMsg = {0};
-    showRpcMsg.pCont = pShow;
-    showRpcMsg.contLen = sizeof(SShowMsg);
-    showRpcMsg.msgType = TSDB_MSG_TYPE_SHOW;
-
-    sendMsg(pClient, &showRpcMsg);
-    ASSERT_NE(pClient->pRsp, nullptr);
-    ASSERT_EQ(pClient->pRsp->code, 0);
-    ASSERT_NE(pClient->pRsp->pCont, nullptr);
-
-    SShowRsp* pShowRsp = (SShowRsp*)pClient->pRsp->pCont;
-    ASSERT_NE(pShowRsp, nullptr);
-    pShowRsp->showId = htonl(pShowRsp->showId);
-    pMeta = &pShowRsp->tableMeta;
-    pMeta->numOfTags = htonl(pMeta->numOfTags);
-    pMeta->numOfColumns = htonl(pMeta->numOfColumns);
-    pMeta->sversion = htonl(pMeta->sversion);
-    pMeta->tversion = htonl(pMeta->tversion);
-    pMeta->tuid = htobe64(pMeta->tuid);
-    pMeta->suid = htobe64(pMeta->suid);
-
-    showId = pShowRsp->showId;
-
-    EXPECT_NE(pShowRsp->showId, 0);
-    EXPECT_STREQ(pMeta->tbFname, showName);
-    EXPECT_EQ(pMeta->numOfTags, 0);
-    EXPECT_EQ(pMeta->numOfColumns, columns);
-    EXPECT_EQ(pMeta->precision, 0);
-    EXPECT_EQ(pMeta->tableType, 0);
-    EXPECT_EQ(pMeta->update, 0);
-    EXPECT_EQ(pMeta->sversion, 0);
-    EXPECT_EQ(pMeta->tversion, 0);
-    EXPECT_EQ(pMeta->tuid, 0);
-    EXPECT_EQ(pMeta->suid, 0);
-  }
-
-  void CheckSchema(int32_t index, int8_t type, int32_t bytes, const char* name) {
-    SSchema* pSchema = &pMeta->pSchema[index];
-    pSchema->bytes = htonl(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, type);
-    EXPECT_EQ(pSchema->bytes, bytes);
-    EXPECT_STREQ(pSchema->name, name);
-  }
-
-  void SendThenCheckShowRetrieveMsg(int32_t rows) {
-    SRetrieveTableMsg* pRetrieve = (SRetrieveTableMsg*)rpcMallocCont(sizeof(SRetrieveTableMsg));
-    pRetrieve->showId = htonl(showId);
-    pRetrieve->free = 0;
-
-    SRpcMsg retrieveRpcMsg = {0};
-    retrieveRpcMsg.pCont = pRetrieve;
-    retrieveRpcMsg.contLen = sizeof(SRetrieveTableMsg);
-    retrieveRpcMsg.msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE;
-
-    sendMsg(pClient, &retrieveRpcMsg);
-
-    ASSERT_NE(pClient->pRsp, nullptr);
-    ASSERT_EQ(pClient->pRsp->code, 0);
-    ASSERT_NE(pClient->pRsp->pCont, nullptr);
-
-    pRetrieveRsp = (SRetrieveTableRsp*)pClient->pRsp->pCont;
-    ASSERT_NE(pRetrieveRsp, nullptr);
-    pRetrieveRsp->numOfRows = htonl(pRetrieveRsp->numOfRows);
-    pRetrieveRsp->useconds = htobe64(pRetrieveRsp->useconds);
-    pRetrieveRsp->compLen = htonl(pRetrieveRsp->compLen);
-
-    EXPECT_EQ(pRetrieveRsp->numOfRows, rows);
-    EXPECT_EQ(pRetrieveRsp->useconds, 0);
-    // EXPECT_EQ(pRetrieveRsp->completed, completed);
-    EXPECT_EQ(pRetrieveRsp->precision, TSDB_TIME_PRECISION_MILLI);
-    EXPECT_EQ(pRetrieveRsp->compressed, 0);
-    EXPECT_EQ(pRetrieveRsp->compLen, 0);
-
-    pData = pRetrieveRsp->data;
-    pos = 0;
-  }
-
-  void CheckInt8(int8_t val) {
-    int8_t data = *((int8_t*)(pData + pos));
-    pos += sizeof(int8_t);
-    EXPECT_EQ(data, val);
-  }
-
-  void CheckInt16(int16_t val) {
-    int16_t data = *((int16_t*)(pData + pos));
-    pos += sizeof(int16_t);
-    EXPECT_EQ(data, val);
-  }
-
-  void CheckInt32(int32_t val) {
-    int32_t data = *((int32_t*)(pData + pos));
-    pos += sizeof(int32_t);
-    EXPECT_EQ(data, val);
-  }
-
-  void CheckInt64(int64_t val) {
-    int64_t data = *((int64_t*)(pData + pos));
-    pos += sizeof(int64_t);
-    EXPECT_EQ(data, val);
-  }
-
-  void CheckTimestamp() {
-    int64_t data = *((int64_t*)(pData + pos));
-    pos += sizeof(int64_t);
-    EXPECT_GT(data, 0);
-  }
-
-  void CheckBinary(const char* val, int32_t len) {
-    pos += sizeof(VarDataLenT);
-    char* data = (char*)(pData + pos);
-    pos += len;
-    EXPECT_STREQ(data, val);
-  }
-
-  int32_t            showId;
-  STableMetaMsg*     pMeta;
-  SRetrieveTableRsp* pRetrieveRsp;
-  char*              pData;
-  int32_t            pos;
 };
 
-SServer* DndTestVgroup::pServer;
-SClient* DndTestVgroup::pClient;
-int32_t  DndTestVgroup::connId;
+Testbase DndTestVgroup::test;
 
 TEST_F(DndTestVgroup, 01_Create_Restart_Drop_Vnode) {
   {
     for (int i = 0; i < 3; ++i) {
-      SCreateVnodeMsg* pReq = (SCreateVnodeMsg*)rpcMallocCont(sizeof(SCreateVnodeMsg));
+      int32_t contLen = sizeof(SCreateVnodeMsg);
+
+      SCreateVnodeMsg* pReq = (SCreateVnodeMsg*)rpcMallocCont(contLen);
       pReq->vgId = htonl(2);
       pReq->dnodeId = htonl(1);
       strcpy(pReq->db, "1.d1");
@@ -209,13 +60,7 @@ TEST_F(DndTestVgroup, 01_Create_Restart_Drop_Vnode) {
         pReplica->port = htons(9150);
       }
 
-      SRpcMsg rpcMsg = {0};
-      rpcMsg.pCont = pReq;
-      rpcMsg.contLen = sizeof(SCreateVnodeMsg);
-      rpcMsg.msgType = TSDB_MSG_TYPE_CREATE_VNODE_IN;
-
-      sendMsg(pClient, &rpcMsg);
-      SRpcMsg* pMsg = pClient->pRsp;
+      SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_VNODE_IN, pReq, contLen);
       ASSERT_NE(pMsg, nullptr);
       ASSERT_EQ(pMsg->code, 0);
     }
@@ -223,7 +68,9 @@ TEST_F(DndTestVgroup, 01_Create_Restart_Drop_Vnode) {
 
   {
     for (int i = 0; i < 3; ++i) {
-      SAlterVnodeMsg* pReq = (SAlterVnodeMsg*)rpcMallocCont(sizeof(SAlterVnodeMsg));
+      int32_t contLen = sizeof(SAlterVnodeMsg);
+
+      SAlterVnodeMsg* pReq = (SAlterVnodeMsg*)rpcMallocCont(contLen);
       pReq->vgId = htonl(2);
       pReq->dnodeId = htonl(1);
       strcpy(pReq->db, "1.d1");
@@ -253,13 +100,7 @@ TEST_F(DndTestVgroup, 01_Create_Restart_Drop_Vnode) {
         pReplica->port = htons(9150);
       }
 
-      SRpcMsg rpcMsg = {0};
-      rpcMsg.pCont = pReq;
-      rpcMsg.contLen = sizeof(SAlterVnodeMsg);
-      rpcMsg.msgType = TSDB_MSG_TYPE_ALTER_VNODE_IN;
-
-      sendMsg(pClient, &rpcMsg);
-      SRpcMsg* pMsg = pClient->pRsp;
+      SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_ALTER_VNODE_IN, pReq, contLen);
       ASSERT_NE(pMsg, nullptr);
       ASSERT_EQ(pMsg->code, 0);
     }
@@ -267,7 +108,9 @@ TEST_F(DndTestVgroup, 01_Create_Restart_Drop_Vnode) {
 
   {
     for (int i = 0; i < 3; ++i) {
-      SDropVnodeMsg* pReq = (SDropVnodeMsg*)rpcMallocCont(sizeof(SDropVnodeMsg));
+      int32_t contLen = sizeof(SDropVnodeMsg);
+
+      SDropVnodeMsg* pReq = (SDropVnodeMsg*)rpcMallocCont(contLen);
       pReq->vgId = htonl(2);
       pReq->dnodeId = htonl(1);
       strcpy(pReq->db, "1.d1");
@@ -278,8 +121,7 @@ TEST_F(DndTestVgroup, 01_Create_Restart_Drop_Vnode) {
       rpcMsg.contLen = sizeof(SDropVnodeMsg);
       rpcMsg.msgType = TSDB_MSG_TYPE_DROP_VNODE_IN;
 
-      sendMsg(pClient, &rpcMsg);
-      SRpcMsg* pMsg = pClient->pRsp;
+      SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_DROP_VNODE_IN, pReq, contLen);
       ASSERT_NE(pMsg, nullptr);
       ASSERT_EQ(pMsg->code, 0);
     }

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

@@ -23,29 +23,25 @@
 #define QUERY_ID_SIZE 20
 #define QUERY_OBJ_ID_SIZE 18
 #define SUBQUERY_INFO_SIZE 6
-#define QUERY_STREAM_SAVE_SIZE 20
+#define QUERY_SAVE_SIZE 20
 
 typedef struct {
-  char         user[TSDB_USER_LEN];
-  char         app[TSDB_APP_NAME_LEN];  // app name that invokes taosc
-  int32_t      pid;                     // pid of app that invokes taosc
-  int64_t      appStartTime;            // app start time
-  int32_t      id;
-  int8_t       killed;
-  int8_t       align;
-  uint16_t     port;
-  uint32_t     ip;
-  int64_t      stime;
-  int64_t      lastAccess;
-  int32_t      queryId;
-  int32_t      streamId;
-  int32_t      numOfQueries;
-  int32_t      numOfStreams;
-  SStreamDesc *pStreams;
-  SQueryDesc  *pQueries;
+  int32_t     id;
+  char        user[TSDB_USER_LEN];
+  char        app[TSDB_APP_NAME_LEN];  // app name that invokes taosc
+  int64_t     appStartTimeMs;          // app start time
+  int32_t     pid;                     // pid of app that invokes taosc
+  uint32_t    ip;
+  uint16_t    port;
+  int8_t      killed;
+  int64_t     loginTimeMs;
+  int64_t     lastAccessTimeMs;
+  int32_t     queryId;
+  int32_t     numOfQueries;
+  SQueryDesc *pQueries;
 } SConnObj;
 
-static SConnObj *mndCreateConn(SMnode *pMnode, char *user, uint32_t ip, uint16_t port, int32_t pid, const char *app, int64_t startTime);
+static SConnObj *mndCreateConn(SMnode *pMnode, SRpcConnInfo *pInfo, int32_t pid, const char *app, int64_t startTime);
 static void      mndFreeConn(SConnObj *pConn);
 static SConnObj *mndAcquireConn(SMnode *pMnode, int32_t connId);
 static void      mndReleaseConn(SMnode *pMnode, SConnObj *pConn);
@@ -54,16 +50,12 @@ static void      mndCancelGetNextConn(SMnode *pMnode, void *pIter);
 static int32_t   mndProcessHeartBeatMsg(SMnodeMsg *pMsg);
 static int32_t   mndProcessConnectMsg(SMnodeMsg *pMsg);
 static int32_t   mndProcessKillQueryMsg(SMnodeMsg *pMsg);
-static int32_t   mndProcessKillStreamMsg(SMnodeMsg *pMsg);
 static int32_t   mndProcessKillConnectionMsg(SMnodeMsg *pMsg);
 static int32_t   mndGetConnsMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta);
 static int32_t   mndRetrieveConns(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows);
 static int32_t   mndGetQueryMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta);
 static int32_t   mndRetrieveQueries(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows);
 static void      mndCancelGetNextQuery(SMnode *pMnode, void *pIter);
-static int32_t   mndGetStreamMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta);
-static int32_t   mndRetrieveStreams(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows);
-static void      mndCancelGetNextStream(SMnode *pMnode, void *pIter);
 
 int32_t mndInitProfile(SMnode *pMnode) {
   SProfileMgmt *pMgmt = &pMnode->profileMgmt;
@@ -79,7 +71,6 @@ int32_t mndInitProfile(SMnode *pMnode) {
   mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_HEARTBEAT, mndProcessHeartBeatMsg);
   mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_CONNECT, mndProcessConnectMsg);
   mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_KILL_QUERY, mndProcessKillQueryMsg);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_KILL_STREAM, mndProcessKillStreamMsg);
   mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_KILL_CONN, mndProcessKillConnectionMsg);
 
   mndAddShowMetaHandle(pMnode, TSDB_MGMT_TABLE_CONNS, mndGetConnsMeta);
@@ -88,9 +79,6 @@ int32_t mndInitProfile(SMnode *pMnode) {
   mndAddShowMetaHandle(pMnode, TSDB_MGMT_TABLE_QUERIES, mndGetQueryMeta);
   mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_QUERIES, mndRetrieveQueries);
   mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_QUERIES, mndCancelGetNextQuery);
-  mndAddShowMetaHandle(pMnode, TSDB_MGMT_TABLE_STREAMS, mndGetStreamMeta);
-  mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_STREAMS, mndRetrieveStreams);
-  mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_STREAMS, mndCancelGetNextStream);
 
   return 0;
 }
@@ -103,46 +91,43 @@ void mndCleanupProfile(SMnode *pMnode) {
   }
 }
 
-static SConnObj *mndCreateConn(SMnode *pMnode, char *user, uint32_t ip, uint16_t port, int32_t pid, const char *app, int64_t startTime) {
+static SConnObj *mndCreateConn(SMnode *pMnode, SRpcConnInfo *pInfo, int32_t pid, const char *app, int64_t startTime) {
   SProfileMgmt *pMgmt = &pMnode->profileMgmt;
 
   int32_t connId = atomic_add_fetch_32(&pMgmt->connId, 1);
   if (connId == 0) atomic_add_fetch_32(&pMgmt->connId, 1);
+  if (startTime == 0) startTime = taosGetTimestampMs();
 
-  SConnObj connObj = {.pid = pid,
-                      .appStartTime = startTime,
-                      .id = connId,
+  SConnObj connObj = {.id = connId,
+                      .appStartTimeMs = startTime,
+                      .pid = pid,
+                      .ip = pInfo->clientIp,
+                      .port = pInfo->clientPort,
                       .killed = 0,
-                      .port = port,
-                      .ip = ip,
-                      .stime = taosGetTimestampMs(),
-                      .lastAccess = 0,
+                      .loginTimeMs = taosGetTimestampMs(),
+                      .lastAccessTimeMs = 0,
                       .queryId = 0,
-                      .streamId = 0,
                       .numOfQueries = 0,
-                      .numOfStreams = 0,
-                      .pStreams = NULL,
                       .pQueries = NULL};
 
-  connObj.lastAccess = connObj.stime;
-  tstrncpy(connObj.user, user, TSDB_USER_LEN);
+  connObj.lastAccessTimeMs = connObj.loginTimeMs;
+  tstrncpy(connObj.user, pInfo->user, TSDB_USER_LEN);
   tstrncpy(connObj.app, app, TSDB_APP_NAME_LEN);
 
   int32_t   keepTime = pMnode->cfg.shellActivityTimer * 3;
   SConnObj *pConn = taosCachePut(pMgmt->cache, &connId, sizeof(int32_t), &connObj, sizeof(connObj), keepTime * 1000);
   if (pConn == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
-    mError("conn:%d, data:%p failed to put into cache since %s, user:%s", connId, pConn, user, terrstr());
+    mError("conn:%d, data:%p failed to put into cache since %s, user:%s", connId, pConn, pInfo->user, terrstr());
     return NULL;
   } else {
-    mTrace("conn:%d, data:%p created, user:%s", pConn->id, pConn, user);
+    mTrace("conn:%d, data:%p created, user:%s", pConn->id, pConn, pInfo->user);
     return pConn;
   }
 }
 
 static void mndFreeConn(SConnObj *pConn) {
   tfree(pConn->pQueries);
-  tfree(pConn->pStreams);
   mTrace("conn:%d, data:%p destroyed", pConn->id, pConn);
 }
 
@@ -156,7 +141,7 @@ static SConnObj *mndAcquireConn(SMnode *pMnode, int32_t connId) {
   }
 
   int32_t keepTime = pMnode->cfg.shellActivityTimer * 3;
-  pConn->lastAccess = keepTime * 1000 + (uint64_t)taosGetTimestampMs();
+  pConn->lastAccessTimeMs = keepTime * 1000 + (uint64_t)taosGetTimestampMs();
 
   mTrace("conn:%d, data:%p acquired from cache", pConn->id, pConn);
   return pConn;
@@ -219,7 +204,7 @@ static int32_t mndProcessConnectMsg(SMnodeMsg *pMsg) {
     mndReleaseDb(pMnode, pDb);
   }
 
-  SConnObj *pConn = mndCreateConn(pMnode, info.user, info.clientIp, info.clientPort, pReq->pid, pReq->app, pReq->startTime);
+  SConnObj *pConn = mndCreateConn(pMnode, &info, pReq->pid, pReq->app, pReq->startTime);
   if (pConn == NULL) {
     mError("user:%s, failed to login from %s while create connection since %s", pMsg->user, ip, terrstr());
     return -1;
@@ -254,16 +239,14 @@ static int32_t mndProcessConnectMsg(SMnodeMsg *pMsg) {
 
 static int32_t mndSaveQueryStreamList(SConnObj *pConn, SHeartBeatMsg *pMsg) {
   pConn->numOfQueries = 0;
-  pConn->numOfStreams = 0;
   int32_t numOfQueries = htonl(pMsg->numOfQueries);
-  int32_t numOfStreams = htonl(pMsg->numOfStreams);
 
   if (numOfQueries > 0) {
     if (pConn->pQueries == NULL) {
-      pConn->pQueries = calloc(sizeof(SQueryDesc), QUERY_STREAM_SAVE_SIZE);
+      pConn->pQueries = calloc(sizeof(SQueryDesc), QUERY_SAVE_SIZE);
     }
 
-    pConn->numOfQueries = MIN(QUERY_STREAM_SAVE_SIZE, numOfQueries);
+    pConn->numOfQueries = MIN(QUERY_SAVE_SIZE, numOfQueries);
 
     int32_t saveSize = pConn->numOfQueries * sizeof(SQueryDesc);
     if (saveSize > 0 && pConn->pQueries != NULL) {
@@ -271,19 +254,6 @@ static int32_t mndSaveQueryStreamList(SConnObj *pConn, SHeartBeatMsg *pMsg) {
     }
   }
 
-  if (numOfStreams > 0) {
-    if (pConn->pStreams == NULL) {
-      pConn->pStreams = calloc(sizeof(SStreamDesc), QUERY_STREAM_SAVE_SIZE);
-    }
-
-    pConn->numOfStreams = MIN(QUERY_STREAM_SAVE_SIZE, numOfStreams);
-
-    int32_t saveSize = pConn->numOfStreams * sizeof(SStreamDesc);
-    if (saveSize > 0 && pConn->pStreams != NULL) {
-      memcpy(pConn->pStreams, pMsg->pData + numOfQueries * sizeof(SQueryDesc), saveSize);
-    }
-  }
-
   return TSDB_CODE_SUCCESS;
 }
 
@@ -303,7 +273,7 @@ static int32_t mndProcessHeartBeatMsg(SMnodeMsg *pMsg) {
 
   SConnObj *pConn = mndAcquireConn(pMnode, pReq->connId);
   if (pConn == NULL) {
-    pConn = mndCreateConn(pMnode, info.user, info.clientIp, info.clientPort, pReq->pid, pReq->app, 0);
+    pConn = mndCreateConn(pMnode, &info, pReq->pid, pReq->app, 0);
     if (pConn == NULL) {
       mError("user:%s, conn:%d is freed and failed to create new conn since %s", pMsg->user, pReq->connId, terrstr());
       return -1;
@@ -343,11 +313,6 @@ static int32_t mndProcessHeartBeatMsg(SMnodeMsg *pMsg) {
     pRsp->killConnection = 1;
   }
 
-  if (pConn->streamId != 0) {
-    pRsp->streamId = htonl(pConn->streamId);
-    pConn->streamId = 0;
-  }
-
   if (pConn->queryId != 0) {
     pRsp->queryId = htonl(pConn->queryId);
     pConn->queryId = 0;
@@ -395,37 +360,6 @@ static int32_t mndProcessKillQueryMsg(SMnodeMsg *pMsg) {
   }
 }
 
-static int32_t mndProcessKillStreamMsg(SMnodeMsg *pMsg) {
-  SMnode       *pMnode = pMsg->pMnode;
-  SProfileMgmt *pMgmt = &pMnode->profileMgmt;
-
-  SUserObj *pUser = mndAcquireUser(pMnode, pMsg->user);
-  if (pUser == NULL) return 0;
-  if (!pUser->superUser) {
-    mndReleaseUser(pMnode, pUser);
-    terrno = TSDB_CODE_MND_NO_RIGHTS;
-    return -1;
-  }
-  mndReleaseUser(pMnode, pUser);
-
-  SKillStreamMsg *pKill = pMsg->rpcMsg.pCont;
-  int32_t         connId = htonl(pKill->connId);
-  int32_t         streamId = htonl(pKill->streamId);
-  mDebug("kill stream msg is received, streamId:%d", streamId);
-
-  SConnObj *pConn = taosCacheAcquireByKey(pMgmt->cache, &connId, sizeof(int32_t));
-  if (pConn == NULL) {
-    mError("connId:%d, failed to kill streamId:%d, conn not exist", connId, streamId);
-    terrno = TSDB_CODE_MND_INVALID_CONN_ID;
-    return -1;
-  } else {
-    mInfo("connId:%d, streamId:%d is killed by user:%s", connId, streamId, pMsg->user);
-    pConn->streamId = streamId;
-    taosCacheRelease(pMgmt->cache, (void **)&pConn, false);
-    return TSDB_CODE_SUCCESS;
-  }
-}
-
 static int32_t mndProcessKillConnectionMsg(SMnodeMsg *pMsg) {
   SMnode       *pMnode = pMsg->pMnode;
   SProfileMgmt *pMgmt = &pMnode->profileMgmt;
@@ -525,6 +459,7 @@ static int32_t mndGetConnsMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *
 
   pShow->numOfRows = taosHashGetSize(pMgmt->cache->pHashTable);
   pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
+  strcpy(pMeta->tbFname, mndShowStr(pShow->type));
 
   return 0;
 }
@@ -567,12 +502,12 @@ static int32_t mndRetrieveConns(SMnodeMsg *pMsg, SShowObj *pShow, char *data, in
     cols++;
 
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int64_t *)pWrite = pConn->stime;
+    *(int64_t *)pWrite = pConn->loginTimeMs;
     cols++;
 
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    if (pConn->lastAccess < pConn->stime) pConn->lastAccess = pConn->stime;
-    *(int64_t *)pWrite = pConn->lastAccess;
+    if (pConn->lastAccessTimeMs < pConn->loginTimeMs) pConn->lastAccessTimeMs = pConn->loginTimeMs;
+    *(int64_t *)pWrite = pConn->lastAccessTimeMs;
     cols++;
 
     numOfRows++;
@@ -623,7 +558,7 @@ static int32_t mndGetQueryMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *
   pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
-  pShow->bytes[cols] = 24;
+  pShow->bytes[cols] = 22 + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "qid");
   pSchema[cols].bytes = htonl(pShow->bytes[cols]);
@@ -693,6 +628,7 @@ static int32_t mndGetQueryMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *
 
   pShow->numOfRows = 1000000;
   pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
+  strcpy(pMeta->tbFname, mndShowStr(pShow->type));
 
   return 0;
 }
@@ -790,6 +726,7 @@ static int32_t mndRetrieveQueries(SMnodeMsg *pMsg, SShowObj *pShow, char *data,
     }
   }
 
+  mndVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
   pShow->numOfReads += numOfRows;
   return numOfRows;
 }
@@ -798,173 +735,3 @@ static void mndCancelGetNextQuery(SMnode *pMnode, void *pIter) {
   SProfileMgmt *pMgmt = &pMnode->profileMgmt;
   taosHashCancelIterate(pMgmt->cache->pHashTable, pIter);
 }
-
-static int32_t mndGetStreamMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta) {
-  SMnode       *pMnode = pMsg->pMnode;
-  SProfileMgmt *pMgmt = &pMnode->profileMgmt;
-
-  SUserObj *pUser = mndAcquireUser(pMnode, pMsg->user);
-  if (pUser == NULL) return 0;
-  if (!pUser->superUser) {
-    mndReleaseUser(pMnode, pUser);
-    terrno = TSDB_CODE_MND_NO_RIGHTS;
-    return -1;
-  }
-  mndReleaseUser(pMnode, pUser);
-
-  int32_t  cols = 0;
-  SSchema *pSchema = pMeta->pSchema;
-
-  pShow->bytes[cols] = 4;
-  pSchema[cols].type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema[cols].name, "streamId");
-  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 4;
-  pSchema[cols].type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema[cols].name, "connId");
-  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = TSDB_USER_LEN + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "user");
-  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "destination");
-  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "ip:port");
-  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 8;
-  pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
-  strcpy(pSchema[cols].name, "create_time");
-  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 8;
-  pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
-  strcpy(pSchema[cols].name, "exec");
-  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 8;
-  pSchema[cols].type = TSDB_DATA_TYPE_BIGINT;
-  strcpy(pSchema[cols].name, "time(us)");
-  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = TSDB_SHOW_SQL_LEN + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "sql");
-  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 4;
-  pSchema[cols].type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema[cols].name, "cycles");
-  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
-  cols++;
-
-  pMeta->numOfColumns = htonl(cols);
-  pShow->numOfColumns = cols;
-
-  pShow->offset[0] = 0;
-  for (int32_t i = 1; i < cols; ++i) {
-    pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
-  }
-
-  pShow->numOfRows = 1000000;
-  pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-
-  return 0;
-}
-
-static int32_t mndRetrieveStreams(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows) {
-  SMnode   *pMnode = pMsg->pMnode;
-  int32_t   numOfRows = 0;
-  SConnObj *pConn = NULL;
-  int32_t   cols = 0;
-  char     *pWrite;
-  void     *pIter;
-  char      ipStr[TSDB_IPv4ADDR_LEN + 6];
-
-  while (numOfRows < rows) {
-    pIter = mndGetNextConn(pMnode, pShow->pIter, &pConn);
-    if (pConn == NULL) {
-      pShow->pIter = pIter;
-      break;
-    }
-
-    if (numOfRows + pConn->numOfStreams >= rows) {
-      mndCancelGetNextConn(pMnode, pIter);
-      break;
-    }
-
-    pShow->pIter = pIter;
-    for (int32_t i = 0; i < pConn->numOfStreams; ++i) {
-      SStreamDesc *pDesc = pConn->pStreams + i;
-      cols = 0;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int64_t *)pWrite = htobe64(pDesc->streamId);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int64_t *)pWrite = htobe64(pConn->id);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pConn->user, pShow->bytes[cols]);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pDesc->dstTable, pShow->bytes[cols]);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      snprintf(ipStr, sizeof(ipStr), "%s:%u", taosIpStr(pConn->ip), pConn->port);
-      STR_WITH_MAXSIZE_TO_VARSTR(pWrite, ipStr, pShow->bytes[cols]);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int64_t *)pWrite = htobe64(pDesc->ctime);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int64_t *)pWrite = htobe64(pDesc->stime);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int64_t *)pWrite = htobe64(pDesc->useconds);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pDesc->sql, pShow->bytes[cols]);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int32_t *)pWrite = (int32_t)htobe64(pDesc->num);
-      cols++;
-
-      numOfRows++;
-    }
-  }
-
-  pShow->numOfReads += numOfRows;
-  return numOfRows;
-}
-
-static void mndCancelGetNextStream(SMnode *pMnode, void *pIter) {
-  SProfileMgmt *pMgmt = &pMnode->profileMgmt;
-  taosHashCancelIterate(pMgmt->cache->pHashTable, pIter);
-}

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

@@ -138,7 +138,7 @@ static int32_t mndProcessShowMsg(SMnodeMsg *pMnodeMsg) {
   ShowMetaFp metaFp = pMgmt->metaFps[type];
   if (metaFp == NULL) {
     terrno = TSDB_CODE_MND_INVALID_MSG_TYPE;
-    mError("failed to process show-meta msg:%s since no message handle", mndShowStr(type));
+    mError("failed to process show-meta msg:%s since %s", mndShowStr(type), terrstr());
     return -1;
   }
 

source/dnode/vnode/tq/CMakeLists.txt

@@ -12,6 +12,7 @@ target_link_libraries(
     PUBLIC os
     PUBLIC util
     PUBLIC common
+    PUBLIC transport
 )
 
 if(${BUILD_TEST})

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

@@ -18,6 +18,7 @@
 
 #include "tq.h"
 #include "tlog.h"
+#include "trpc.h"
 #ifdef __cplusplus
 extern "C" {
 #endif

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

@@ -35,7 +35,22 @@ void* tqSerializeItem(STqMsgItem* pItem, void* ptr);
 const void* tqDeserializeTopic(const void* pBytes, STqTopic* pTopic);
 const void* tqDeserializeItem(const void* pBytes, STqMsgItem* pItem);
 
-STQ* tqOpen(const char* path, STqCfg* tqConfig, STqLogReader* tqLogReader, SMemAllocatorFactory* allocFac) {
+int tqInit() {
+  int8_t old = atomic_val_compare_exchange_8(&tqMgmt.inited, 0, 1);
+  if(old == 1) return 0;
+
+  tqMgmt.timer = taosTmrInit(0, 0, 0, "TQ");
+  return 0;
+}
+
+void tqCleanUp() {
+  int8_t old = atomic_val_compare_exchange_8(&tqMgmt.inited, 1, 0);
+  if(old == 0) return;
+  taosTmrStop(tqMgmt.timer);
+  taosTmrCleanUp(tqMgmt.timer);
+}
+
+STQ* tqOpen(const char* path, STqCfg* tqConfig, STqLogHandle* tqLogHandle, SMemAllocatorFactory* allocFac) {
   STQ* pTq = malloc(sizeof(STQ));
   if (pTq == NULL) {
     terrno = TSDB_CODE_TQ_OUT_OF_MEMORY;
@@ -43,9 +58,9 @@ STQ* tqOpen(const char* path, STqCfg* tqConfig, STqLogReader* tqLogReader, SMemA
   }
   pTq->path = strdup(path);
   pTq->tqConfig = tqConfig;
-  pTq->tqLogReader = tqLogReader;
+  pTq->tqLogHandle = tqLogHandle;
 #if 0
-  pTq->tqMemRef.pAlloctorFactory = allocFac;
+  pTq->tqMemRef.pAllocatorFactory = allocFac;
   pTq->tqMemRef.pAllocator = allocFac->create(allocFac);
   if (pTq->tqMemRef.pAllocator == NULL) {
     // TODO: error code of buffer pool
@@ -53,16 +68,24 @@ STQ* tqOpen(const char* path, STqCfg* tqConfig, STqLogReader* tqLogReader, SMemA
 #endif
   pTq->tqMeta = tqStoreOpen(path, (FTqSerialize)tqSerializeGroup, (FTqDeserialize)tqDeserializeGroup, free, 0);
   if (pTq->tqMeta == NULL) {
-    // TODO: free STQ
+    free(pTq);
+#if 0
+    allocFac->destroy(allocFac, pTq->tqMemRef.pAllocator);
+#endif
     return NULL;
   }
+
   return pTq;
 }
+
 void tqClose(STQ* pTq) {
   // TODO
 }
 
-static int tqProtoCheck(STqMsgHead* pMsg) { return pMsg->protoVer == 0; }
+static int tqProtoCheck(STqMsgHead* pMsg) {
+  // TODO
+  return pMsg->protoVer == 0;
+}
 
 static int tqAckOneTopic(STqTopic* pTopic, STqOneAck* pAck, STqQueryMsg** ppQuery) {
   // clean old item and move forward
@@ -126,6 +149,13 @@ int tqCreateGroup(STQ* pTq, int64_t topicId, int64_t cgId, int64_t cId, STqGroup
   *ppGroup = pGroup;
   memset(pGroup, 0, sizeof(STqGroup));
 
+  pGroup->topicList = tdListNew(sizeof(STqTopic));
+  if(pGroup->topicList == NULL) {
+    free(pGroup);
+    return -1;
+  }
+  *ppGroup = pGroup;
+
   return 0;
 }
 
@@ -154,46 +184,55 @@ int tqDropGroup(STQ* pTq, int64_t topicId, int64_t cgId, int64_t cId) {
   return 0;
 }
 
-static int tqFetch(STqGroup* pGroup, void** msg) {
-  STqList* head = pGroup->head;
-  STqList* node = head;
+static int tqFetch(STqGroup* pGroup, STqConsumeRsp** pRsp) {
+  STqList* pHead = pGroup->head;
+  STqList* pNode = pHead;
   int      totSize = 0;
+  int      numOfMsgs = 0;
   // TODO: make it a macro
-  int            sizeLimit = 4 * 1024;
-  STqMsgContent* buffer = malloc(sizeLimit);
-  if (buffer == NULL) {
-    // TODO:memory insufficient
+  int   sizeLimit = 4 * 1024;
+
+  void* ptr = realloc(*pRsp, sizeof(STqConsumeRsp) + sizeLimit);
+  if (ptr == NULL) {
+    terrno = TSDB_CODE_TQ_OUT_OF_MEMORY;
     return -1;
   }
+  *pRsp = ptr;
+  STqMsgContent* buffer = (*pRsp)->msgs;
+
   // iterate the list to get msgs of all topics
   // until all topic iterated or msgs over sizeLimit
-  while (node->next) {
-    node = node->next;
-    STqTopic* topicHandle = &node->topic;
-    int       idx = topicHandle->nextConsumeOffset % TQ_BUFFER_SIZE;
-    if (topicHandle->buffer[idx].content != NULL && topicHandle->buffer[idx].offset == topicHandle->nextConsumeOffset) {
-      totSize += topicHandle->buffer[idx].size;
+  while (pNode->next) {
+    pNode = pNode->next;
+    STqTopic* pTopic = &pNode->topic;
+    int       idx = pTopic->nextConsumeOffset % TQ_BUFFER_SIZE;
+    if (pTopic->buffer[idx].content != NULL && pTopic->buffer[idx].offset == pTopic->nextConsumeOffset) {
+      totSize += pTopic->buffer[idx].size;
       if (totSize > sizeLimit) {
-        void* ptr = realloc(buffer, totSize);
+        void* ptr = realloc(*pRsp, sizeof(STqConsumeRsp) + totSize);
         if (ptr == NULL) {
-          totSize -= topicHandle->buffer[idx].size;
-          // TODO:memory insufficient
+          totSize -= pTopic->buffer[idx].size;
+          terrno = TSDB_CODE_TQ_OUT_OF_MEMORY;
           // return msgs already copied
           break;
         }
+        *pRsp = ptr;
+        break;
       }
-      *((int64_t*)buffer) = topicHandle->topicId;
+      *((int64_t*)buffer) = pTopic->topicId;
       buffer = POINTER_SHIFT(buffer, sizeof(int64_t));
-      *((int64_t*)buffer) = topicHandle->buffer[idx].size;
+      *((int64_t*)buffer) = pTopic->buffer[idx].size;
       buffer = POINTER_SHIFT(buffer, sizeof(int64_t));
-      memcpy(buffer, topicHandle->buffer[idx].content, topicHandle->buffer[idx].size);
-      buffer = POINTER_SHIFT(buffer, topicHandle->buffer[idx].size);
+      memcpy(buffer, pTopic->buffer[idx].content, pTopic->buffer[idx].size);
+      buffer = POINTER_SHIFT(buffer, pTopic->buffer[idx].size);
+      numOfMsgs++;
       if (totSize > sizeLimit) {
         break;
       }
     }
   }
-  return totSize;
+  (*pRsp)->bodySize = totSize;
+  return numOfMsgs;
 }
 
 STqGroup* tqGetGroup(STQ* pTq, int64_t clientId) { return tqHandleGet(pTq->tqMeta, clientId); }
@@ -275,7 +314,22 @@ int tqSetCursor(STQ* pTq, STqSetCurReq* pMsg) {
   return 0;
 }
 
-int tqConsume(STQ* pTq, STqConsumeReq* pMsg) {
+// temporary
+int tqProcessCMsg(STQ* pTq, STqConsumeReq* pMsg, STqRspHandle* pRsp) {
+  int64_t   clientId = pMsg->head.clientId;
+  STqGroup* pGroup = tqGetGroup(pTq, clientId);
+  if (pGroup == NULL) {
+    terrno = TSDB_CODE_TQ_GROUP_NOT_SET;
+    return -1;
+  }
+  pGroup->rspHandle.handle = pRsp->handle;
+  pGroup->rspHandle.ahandle = pRsp->ahandle;
+
+  return 0;
+}
+
+int tqConsume(STQ* pTq, SRpcMsg* pReq, SRpcMsg** pRsp) {
+  STqConsumeReq *pMsg = pReq->pCont;
   int64_t   clientId = pMsg->head.clientId;
   STqGroup* pGroup = tqGetGroup(pTq, clientId);
   if (pGroup == NULL) {
@@ -283,20 +337,107 @@ int tqConsume(STQ* pTq, STqConsumeReq* pMsg) {
     return -1;
   }
 
-  STqConsumeRsp* pRsp = (STqConsumeRsp*)pMsg;
-  int            numOfMsgs = tqFetch(pGroup, (void**)&pRsp->msgs);
-  if (numOfMsgs < 0) {
+  SList* topicList = pGroup->topicList;
+
+  int totSize = 0;
+  int numOfMsgs = 0;
+  int sizeLimit = 4096;
+
+
+  STqConsumeRsp *pCsmRsp = (*pRsp)->pCont;
+  void* ptr = realloc((*pRsp)->pCont, sizeof(STqConsumeRsp) + sizeLimit);
+  if (ptr == NULL) {
+    terrno = TSDB_CODE_TQ_OUT_OF_MEMORY;
     return -1;
   }
-  if (numOfMsgs == 0) {
+  (*pRsp)->pCont = ptr;
+
+  SListIter iter;
+  tdListInitIter(topicList, &iter, TD_LIST_FORWARD);
+
+  STqMsgContent* buffer = NULL;
+  SArray* pArray = taosArrayInit(0, sizeof(void*));
+
+  SListNode *pn;
+  while((pn = tdListNext(&iter)) != NULL) {
+    STqTopic* pTopic = *(STqTopic**)pn->data;
+    int idx = pTopic->floatingCursor % TQ_BUFFER_SIZE;
+    STqMsgItem* pItem = &pTopic->buffer[idx];
+    if (pItem->content != NULL && pItem->offset == pTopic->floatingCursor) {
+      if(pItem->status == TQ_ITEM_READY) {
+        //if has data
+        totSize += pTopic->buffer[idx].size;
+        if (totSize > sizeLimit) {
+          void* ptr = realloc((*pRsp)->pCont, sizeof(STqConsumeRsp) + totSize);
+          if (ptr == NULL) {
+            totSize -= pTopic->buffer[idx].size;
+            terrno = TSDB_CODE_TQ_OUT_OF_MEMORY;
+            // return msgs already copied
+            break;
+          }
+          (*pRsp)->pCont = ptr;
+          break;
+        }
+        *((int64_t*)buffer) = htobe64(pTopic->topicId);
+        buffer = POINTER_SHIFT(buffer, sizeof(int64_t));
+        *((int64_t*)buffer) = htobe64(pTopic->buffer[idx].size);
+        buffer = POINTER_SHIFT(buffer, sizeof(int64_t));
+        memcpy(buffer, pTopic->buffer[idx].content, pTopic->buffer[idx].size);
+        buffer = POINTER_SHIFT(buffer, pTopic->buffer[idx].size);
+        numOfMsgs++;
+        if (totSize > sizeLimit) {
+          break;
+        }
+      } else if(pItem->status == TQ_ITEM_PROCESS) {
+        //if not have data but in process
+
+      } else if(pItem->status == TQ_ITEM_EMPTY){
+        //if not have data and not in process
+        int32_t old = atomic_val_compare_exchange_32(&pItem->status, TQ_ITEM_EMPTY, TQ_ITEM_PROCESS);
+        if(old != TQ_ITEM_EMPTY) {
+          continue;
+        }
+        pItem->offset = pTopic->floatingCursor;
+        taosArrayPush(pArray, &pItem);
+      } else {
+        ASSERT(0);
+      }
+    }
+  }
+
+  if (numOfMsgs > 0) {
+    // set code and other msg
+    rpcSendResponse(*pRsp);
+  } else {
     // most recent data has been fetched
 
     // enable timer for blocking wait
-    // once new data written during wait time
-    // launch query and response
+    // once new data written when waiting, launch query and rsp
   }
 
   // fetched a num of msgs, rpc response
+  for(int i = 0; i < pArray->size; i++) {
+    STqMsgItem* pItem = taosArrayGet(pArray, i);
+
+    //read from wal
+    void* raw = NULL;
+    /*int code = pTq->tqLogReader->logRead(, &raw, pItem->offset);*/
+    int code = pTq->tqLogHandle->logRead(pItem->pTopic->logReader, &raw, pItem->offset);
+    if(code < 0) {
+      //TODO: error
+    }
+    //get msgType
+    //if submitblk
+    pItem->executor->assign(pItem->executor->runtimeEnv, raw);
+    SSDataBlock* content = pItem->executor->exec(pItem->executor->runtimeEnv);
+    pItem->content = content;
+    //if other type, send just put into buffer
+    /*pItem->content = raw;*/
+
+    int32_t old = atomic_val_compare_exchange_32(&pItem->status, TQ_ITEM_PROCESS, TQ_ITEM_READY);
+    ASSERT(old == TQ_ITEM_PROCESS);
+  }
+  taosArrayDestroy(pArray);
 
   return 0;
 }
@@ -378,10 +519,10 @@ void* tqSerializeTopic(STqTopic* pTopic, void* ptr) {
   ptr = POINTER_SHIFT(ptr, sizeof(int64_t));
   *(int64_t*)ptr = pTopic->topicId;
   ptr = POINTER_SHIFT(ptr, sizeof(int64_t));
-  *(int32_t*)ptr = pTopic->head;
-  ptr = POINTER_SHIFT(ptr, sizeof(int32_t));
-  *(int32_t*)ptr = pTopic->tail;
-  ptr = POINTER_SHIFT(ptr, sizeof(int32_t));
+  /**(int32_t*)ptr = pTopic->head;*/
+  /*ptr = POINTER_SHIFT(ptr, sizeof(int32_t));*/
+  /**(int32_t*)ptr = pTopic->tail;*/
+  /*ptr = POINTER_SHIFT(ptr, sizeof(int32_t));*/
   for (int i = 0; i < TQ_BUFFER_SIZE; i++) {
     ptr = tqSerializeItem(&pTopic->buffer[i], ptr);
   }
@@ -435,10 +576,10 @@ const void* tqDeserializeTopic(const void* pBytes, STqTopic* topic) {
   ptr = POINTER_SHIFT(ptr, sizeof(int64_t));
   topic->topicId = *(int64_t*)ptr;
   ptr = POINTER_SHIFT(ptr, sizeof(int64_t));
-  topic->head = *(int32_t*)ptr;
-  ptr = POINTER_SHIFT(ptr, sizeof(int32_t));
-  topic->tail = *(int32_t*)ptr;
-  ptr = POINTER_SHIFT(ptr, sizeof(int32_t));
+  /*topic->head = *(int32_t*)ptr;*/
+  /*ptr = POINTER_SHIFT(ptr, sizeof(int32_t));*/
+  /*topic->tail = *(int32_t*)ptr;*/
+  /*ptr = POINTER_SHIFT(ptr, sizeof(int32_t));*/
   for (int i = 0; i < TQ_BUFFER_SIZE; i++) {
     ptr = tqDeserializeItem(ptr, &topic->buffer[i]);
   }

source/libs/catalog/inc/catalogInt.h

@@ -59,8 +59,6 @@ typedef struct SCatalogMgmt {
 
 typedef uint32_t (*tableNameHashFp)(const char *, uint32_t);
 
-extern int32_t ctgDebugFlag;
-
 #define ctgFatal(...)  do { if (ctgDebugFlag & DEBUG_FATAL) { taosPrintLog("CTG FATAL ", ctgDebugFlag, __VA_ARGS__); }} while(0)
 #define ctgError(...)  do { if (ctgDebugFlag & DEBUG_ERROR) { taosPrintLog("CTG ERROR ", ctgDebugFlag, __VA_ARGS__); }} while(0)
 #define ctgWarn(...)   do { if (ctgDebugFlag & DEBUG_WARN)  { taosPrintLog("CTG WARN ", ctgDebugFlag, __VA_ARGS__); }}  while(0)
@@ -75,7 +73,6 @@ extern int32_t ctgDebugFlag;
 #define CTG_ERR_LRET(c,...) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { ctgError(__VA_ARGS__); terrno = _code; return _code; } } while (0)
 #define CTG_ERR_JRET(c) do { code = c; if (code != TSDB_CODE_SUCCESS) { terrno = code; goto _return; } } while (0)
 
-
 #ifdef __cplusplus
 }
 #endif

source/libs/catalog/src/catalog.c

@@ -371,7 +371,7 @@ int32_t catalogInit(SCatalogCfg *cfg) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t catalogGetHandle(const char *clusterId, struct SCatalog** catalogHandle) {
+int32_t catalogGetHandle(const char* clusterId , struct SCatalog** catalogHandle) {
   if (NULL == clusterId || NULL == catalogHandle) {
     CTG_ERR_RET(TSDB_CODE_CTG_INVALID_INPUT);
   }
@@ -565,12 +565,12 @@ _return:
 }
 
 
-int32_t catalogGetTableHashVgroup(struct SCatalog *pCatalog, void *pRpc, const SEpSet *pMgmtEps, const char *pDBName, const char *pTableName, SVgroupInfo *pVgroup) {
+int32_t catalogGetTableHashVgroup(struct SCatalog *pCatalog, void *pTransporter, const SEpSet *pMgmtEps, const char *pDBName, const char *pTableName, SVgroupInfo *pVgroup) {
   SDBVgroupInfo dbInfo = {0};
   int32_t code = 0;
   int32_t vgId = 0;
 
-  CTG_ERR_RET(catalogGetDBVgroup(pCatalog, pRpc, pMgmtEps, pDBName, false, &dbInfo));
+  CTG_ERR_RET(catalogGetDBVgroup(pCatalog, pTransporter, pMgmtEps, pDBName, false, &dbInfo));
 
   if (dbInfo.vgVersion < 0 || NULL == dbInfo.vgInfo) {
     ctgError("db[%s] vgroup cache invalid, vgroup version:%d, vgInfo:%p", pDBName, dbInfo.vgVersion, dbInfo.vgInfo);
@@ -605,7 +605,7 @@ int32_t catalogGetAllMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* p
       SName *name = taosArrayGet(pReq->pTableName, i);
       STableMeta *pTableMeta = NULL;
       
-      snprintf(dbName, sizeof(dbName), "%s.%s", name->acctId, name->dbname);
+      snprintf(dbName, sizeof(dbName), "%d.%s", name->acctId, name->dbname);
 
       CTG_ERR_JRET(catalogGetTableMeta(pCatalog, pRpc, pMgmtEps, dbName, name->tname, &pTableMeta));
 

source/libs/catalog/test/catalogTests.cpp

@@ -29,6 +29,8 @@
 #include "catalog.h"
 #include "tep.h"
 #include "trpc.h"
+#include "stub.h"
+#include "addr_any.h"
 
 typedef struct SAppInstInfo {
   int64_t           numOfConns;
@@ -86,6 +88,27 @@ void sendCreateDbMsg(void *shandle, SEpSet *pEpSet) {
   ASSERT_EQ(rpcRsp.code, 0);
 }
 
+void __rpcSendRecv(void *shandle, SEpSet *pEpSet, SRpcMsg *pMsg, SRpcMsg *pRsp) {
+  SUseDbRsp *rspMsg = NULL; //todo
+
+  return;
+}
+
+
+void initTestEnv() {
+  static Stub stub;
+  stub.set(rpcSendRecv, __rpcSendRecv);
+  {
+    AddrAny any("libtransport.so");
+    std::map<std::string,void*> result;
+    any.get_global_func_addr_dynsym("^rpcSendRecv$", result);
+    for (const auto& f : result) {
+      stub.set(f.second, __rpcSendRecv);
+    }
+  }
+}
+
+
 }
 
 TEST(testCase, normalCase) {
@@ -99,7 +122,7 @@ TEST(testCase, normalCase) {
   void *mockPointer = (void *)0x1;
   SVgroupInfo vgInfo = {0};
 
-  msgInit();
+  initQueryModuleMsgHandle();
 
   sendCreateDbMsg(pConn->pTransporter, &pConn->pAppInfo->mgmtEp.epSet);
   

source/libs/index/inc/index_fst_counting_writer.h

@@ -31,6 +31,7 @@ typedef struct WriterCtx {
   int (*write)(struct WriterCtx* ctx, uint8_t* buf, int len);
   int (*read)(struct WriterCtx* ctx, uint8_t* buf, int len);
   int (*flush)(struct WriterCtx* ctx);
+  int (*readFrom)(struct WriterCtx* ctx, uint8_t* buf, int len, int32_t offset);
   WriterType type;
   union {
     struct {
@@ -48,6 +49,7 @@ typedef struct WriterCtx {
 
 static int writeCtxDoWrite(WriterCtx* ctx, uint8_t* buf, int len);
 static int writeCtxDoRead(WriterCtx* ctx, uint8_t* buf, int len);
+static int writeCtxDoReadFrom(WriterCtx* ctx, uint8_t* buf, int len, int32_t offset);
 static int writeCtxDoFlush(WriterCtx* ctx);
 
 WriterCtx* writerCtxCreate(WriterType type, const char* path, bool readOnly, int32_t capacity);

source/libs/index/inc/index_tfile.h

@@ -27,23 +27,31 @@ extern "C" {
 #endif
 
 // tfile header content
-// |<---suid--->|<---version--->|<--colLen-->|<-colName->|<---type-->|
-// |<-uint64_t->|<---int32_t--->|<--int32_t->|<-colLen-->|<-uint8_t->|
+// |<---suid--->|<---version--->|<-------colName------>|<---type-->|<--fstOffset->|
+// |<-uint64_t->|<---int32_t--->|<--TSDB_COL_NAME_LEN-->|<-uint8_t->|<---int32_t-->|
 
+#pragma pack(push, 1)
 typedef struct TFileHeader {
   uint64_t suid;
   int32_t  version;
-  char     colName[128];  //
+  char     colName[TSDB_COL_NAME_LEN];  //
   uint8_t  colType;
+  int32_t  fstOffset;
 } TFileHeader;
+#pragma pack(pop)
 
-#define TFILE_HEADER_SIZE (sizeof(TFileHeader) + sizeof(uint32_t))
-#define TFILE_HADER_PRE_SIZE (sizeof(uint64_t) + sizeof(int32_t) + sizeof(int32_t))
+#define TFILE_HEADER_SIZE (sizeof(TFileHeader))
+#define TFILE_HEADER_NO_FST (TFILE_HEADER_SIZE - sizeof(int32_t))
+
+typedef struct TFileValue {
+  char*   colVal;  // null terminated
+  SArray* tableId;
+  int32_t offset;
+} TFileValue;
 
 typedef struct TFileCacheKey {
   uint64_t suid;
   uint8_t  colType;
-  int32_t  version;
   char*    colName;
   int32_t  nColName;
 } TFileCacheKey;
@@ -63,6 +71,7 @@ typedef struct TFileWriter {
   uint32_t    offset;
 } TFileWriter;
 
+// multi reader and single write
 typedef struct TFileReader {
   T_REF_DECLARE()
   Fst*        fst;

source/libs/index/src/index.c

@@ -41,7 +41,7 @@ static pthread_once_t isInit = PTHREAD_ONCE_INIT;
 static void           indexInit();
 
 static int indexTermSearch(SIndex* sIdx, SIndexTermQuery* term, SArray** result);
-static int indexMergeCacheIntoTindex(SIndex* sIdx);
+static int indexFlushCacheToTindex(SIndex* sIdx);
 
 static void indexInterResultsDestroy(SArray* results);
 static int  indexMergeFinalResults(SArray* interResults, EIndexOperatorType oType, SArray* finalResult);
@@ -49,9 +49,7 @@ static int  indexMergeFinalResults(SArray* interResults, EIndexOperatorType oTyp
 int indexOpen(SIndexOpts* opts, const char* path, SIndex** index) {
   pthread_once(&isInit, indexInit);
   SIndex* sIdx = calloc(1, sizeof(SIndex));
-  if (sIdx == NULL) {
-    return -1;
-  }
+  if (sIdx == NULL) { return -1; }
 
 #ifdef USE_LUCENE
   index_t* index = index_open(path);
@@ -131,9 +129,7 @@ int indexPut(SIndex* index, SIndexMultiTerm* fVals, uint64_t uid) {
     int32_t colId = fi->colId;
     int32_t version = index->cVersion;
     int     ret = indexCachePut(index->cache, p, colId, version, uid);
-    if (ret != 0) {
-      return ret;
-    }
+    if (ret != 0) { return ret; }
   }
 #endif
 
@@ -221,9 +217,7 @@ void indexOptsDestroy(SIndexOpts* opts){
 
 SIndexMultiTermQuery* indexMultiTermQueryCreate(EIndexOperatorType opera) {
   SIndexMultiTermQuery* p = (SIndexMultiTermQuery*)malloc(sizeof(SIndexMultiTermQuery));
-  if (p == NULL) {
-    return NULL;
-  }
+  if (p == NULL) { return NULL; }
   p->opera = opera;
   p->query = taosArrayInit(4, sizeof(SIndexTermQuery));
   return p;
@@ -250,9 +244,7 @@ SIndexTerm* indexTermCreate(int64_t            suid,
                             const char*        colVal,
                             int32_t            nColVal) {
   SIndexTerm* t = (SIndexTerm*)calloc(1, (sizeof(SIndexTerm)));
-  if (t == NULL) {
-    return NULL;
-  }
+  if (t == NULL) { return NULL; }
 
   t->suid = suid;
   t->operType = oper;
@@ -332,9 +324,7 @@ static int indexTermSearch(SIndex* sIdx, SIndexTermQuery* query, SArray** result
   return 0;
 }
 static void indexInterResultsDestroy(SArray* results) {
-  if (results == NULL) {
-    return;
-  }
+  if (results == NULL) { return; }
 
   size_t sz = taosArrayGetSize(results);
   for (size_t i = 0; i < sz; i++) {
@@ -363,10 +353,10 @@ static int indexMergeFinalResults(SArray* interResults, EIndexOperatorType oType
   }
   return 0;
 }
-static int indexMergeCacheIntoTindex(SIndex* sIdx) {
-  if (sIdx == NULL) {
-    return -1;
-  }
+static int indexFlushCacheToTindex(SIndex* sIdx) {
+  if (sIdx == NULL) { return -1; }
+
   indexWarn("suid %" PRIu64 " merge cache into tindex", sIdx->suid);
+
   return 0;
 }

source/libs/index/src/index_cache.c

@@ -151,8 +151,7 @@ int indexCacheSearch(void* cache, SIndexTermQuery* query, int16_t colId, int32_t
   EIndexQueryType qtype = query->qType;
 
   int32_t keyLen = CACHE_KEY_LEN(term);
-
-  char* buf = calloc(1, keyLen);
+  char*   buf = calloc(1, keyLen);
   if (qtype == QUERY_TERM) {
     //
   } else if (qtype == QUERY_PREFIX) {

source/libs/index/src/index_fst_counting_writer.c

@@ -39,6 +39,17 @@ static int writeCtxDoRead(WriterCtx* ctx, uint8_t* buf, int len) {
 
   return nRead;
 }
+static int writeCtxDoReadFrom(WriterCtx* ctx, uint8_t* buf, int len, int32_t offset) {
+  int nRead = 0;
+  if (ctx->type == TFile) {
+    tfLseek(ctx->file.fd, offset, 0);
+    nRead = tfRead(ctx->file.fd, buf, len);
+  } else {
+    // refactor later
+    assert(0);
+  }
+  return nRead;
+}
 static int writeCtxDoFlush(WriterCtx* ctx) {
   if (ctx->type == TFile) {
     // tfFsync(ctx->fd);
@@ -58,9 +69,9 @@ WriterCtx* writerCtxCreate(WriterType type, const char* path, bool readOnly, int
     // ugly code, refactor later
     ctx->file.readOnly = readOnly;
     if (readOnly == false) {
-      ctx->file.fd = tfOpenCreateWriteAppend(tmpFile);
+      ctx->file.fd = tfOpenCreateWriteAppend(path);
     } else {
-      ctx->file.fd = tfOpenReadWrite(tmpFile);
+      ctx->file.fd = tfOpenReadWrite(path);
     }
     if (ctx->file.fd < 0) {
       indexError("open file error %d", errno);
@@ -73,6 +84,7 @@ WriterCtx* writerCtxCreate(WriterType type, const char* path, bool readOnly, int
   ctx->write = writeCtxDoWrite;
   ctx->read = writeCtxDoRead;
   ctx->flush = writeCtxDoFlush;
+  ctx->readFrom = writeCtxDoReadFrom;
 
   ctx->offset = 0;
   ctx->limit = capacity;
@@ -81,6 +93,7 @@ WriterCtx* writerCtxCreate(WriterType type, const char* path, bool readOnly, int
 END:
   if (ctx->type == TMemory) { free(ctx->mem.buf); }
   free(ctx);
+  return NULL;
 }
 void writerCtxDestroy(WriterCtx* ctx) {
   if (ctx->type == TMemory) {

source/libs/index/src/index_tfile.c

@@ -25,130 +25,27 @@
 
 #define TF_TABLE_TATOAL_SIZE(sz) (sizeof(sz) + sz * sizeof(uint64_t))
 
-typedef struct TFileValue {
-  char*   colVal;  // null terminated
-  SArray* tableId;
-  int32_t offset;
-} TFileValue;
+static int  tfileStrCompare(const void* a, const void* b);
+static int  tfileValueCompare(const void* a, const void* b, const void* param);
+static void tfileSerialTableIdsToBuf(char* buf, SArray* tableIds);
 
-// static tfileGetCompareFunc(uint8_t byte) {}
-static int tfileValueCompare(const void* a, const void* b, const void* param) {
-  __compar_fn_t fn = *(__compar_fn_t*)param;
+static int tfileWriteHeader(TFileWriter* writer);
+static int tfileWriteFstOffset(TFileWriter* tw, int32_t offset);
+static int tfileWriteData(TFileWriter* write, TFileValue* tval);
 
-  TFileValue* av = (TFileValue*)a;
-  TFileValue* bv = (TFileValue*)b;
+static int  tfileReadLoadHeader(TFileReader* reader);
+static int  tfileReadLoadFst(TFileReader* reader);
+static int  tfileReadLoadTableIds(TFileReader* reader, int32_t offset, SArray* result);
+static void tfileReadRef(TFileReader* reader);
+static void tfileReadUnRef(TFileReader* reader);
 
-  return fn(av->colVal, bv->colVal);
-}
-static void tfileSerialTableIdsToBuf(char* buf, SArray* tableIds) {
-  int tbSz = taosArrayGetSize(tableIds);
-  SERIALIZE_VAR_TO_BUF(buf, tbSz, int32_t);
-  for (size_t i = 0; i < tbSz; i++) {
-    uint64_t* v = taosArrayGet(tableIds, i);
-    SERIALIZE_VAR_TO_BUF(buf, *v, uint64_t);
-  }
-}
-static FORCE_INLINE int tfileWriteHeader(TFileWriter* writer) {
-  char  buf[TFILE_HEADER_SIZE] = {0};
-  char* p = buf;
-
-  TFileHeader* header = &writer->header;
-  SERIALIZE_MEM_TO_BUF(p, header, suid);
-  SERIALIZE_MEM_TO_BUF(p, header, version);
-  SERIALIZE_VAR_TO_BUF(p, strlen(header->colName), int32_t);
-
-  SERIALIZE_STR_MEM_TO_BUF(p, header, colName, strlen(header->colName));
-  SERIALIZE_MEM_TO_BUF(p, header, colType);
-  int offset = p - buf;
-  int nwrite = writer->ctx->write(writer->ctx, buf, offset);
-  if (offset != nwrite) { return -1; }
-  writer->offset = offset;
-  return 0;
-}
-static int tfileWriteData(TFileWriter* write, TFileValue* tval) {
-  TFileHeader* header = &write->header;
-  uint8_t      colType = header->colType;
-  if (colType == TSDB_DATA_TYPE_BINARY || colType == TSDB_DATA_TYPE_NCHAR) {
-    FstSlice key = fstSliceCreate((uint8_t*)(tval->colVal), (size_t)strlen(tval->colVal));
-    if (fstBuilderInsert(write->fb, key, tval->offset)) {
-      fstSliceDestroy(&key);
-      return 0;
-    }
-    fstSliceDestroy(&key);
-    return -1;
-  } else {
-    // handle other type later
-  }
-}
-static FORCE_INLINE int tfileReadLoadHeader(TFileReader* reader) {
-  // TODO simple tfile header later
-  char  buf[TFILE_HADER_PRE_SIZE];
-  char* p = buf;
-
-  int64_t nread = reader->ctx->read(reader->ctx, buf, TFILE_HADER_PRE_SIZE);
-  assert(nread == TFILE_HADER_PRE_SIZE);
-
-  TFileHeader* header = &reader->header;
-  memcpy(&header->suid, p, sizeof(header->suid));
-  p += sizeof(header->suid);
-
-  memcpy(&header->version, p, sizeof(header->version));
-  p += sizeof(header->version);
-
-  int32_t colLen = 0;
-  memcpy(&colLen, p, sizeof(colLen));
-  assert(colLen < sizeof(header->colName));
-  nread = reader->ctx->read(reader->ctx, header->colName, colLen);
-  assert(nread == colLen);
-
-  nread = reader->ctx->read(reader->ctx, &header->colType, sizeof(header->colType));
-  return 0;
-}
-
-static int tfileGetFileList(const char* path, SArray* result) {
-  DIR* dir = opendir(path);
-  if (NULL == dir) { return -1; }
-
-  struct dirent* entry;
-  while ((entry = readdir(dir)) != NULL) {
-    size_t len = strlen(entry->d_name);
-    char*  buf = calloc(1, len + 1);
-    memcpy(buf, entry->d_name, len);
-    taosArrayPush(result, &buf);
-  }
-  closedir(dir);
-  return 0;
-}
-static void tfileDestroyFileName(void* elem) {
-  char* p = *(char**)elem;
-  free(p);
-}
-static int tfileCompare(const void* a, const void* b) {
-  const char* aName = *(char**)a;
-  const char* bName = *(char**)b;
-
-  size_t aLen = strlen(aName);
-  size_t bLen = strlen(bName);
-
-  return strncmp(aName, bName, aLen > bLen ? aLen : bLen);
-}
-// tfile name suid-colId-version.tindex
-static int tfileParseFileName(const char* filename, uint64_t* suid, int* colId, int* version) {
-  if (3 == sscanf(filename, "%" PRIu64 "-%d-%d.tindex", suid, colId, version)) {
-    // read suid & colid & version  success
-    return 0;
-  }
-  return -1;
-}
-static void tfileSerialCacheKey(TFileCacheKey* key, char* buf) {
-  SERIALIZE_MEM_TO_BUF(buf, key, suid);
-  SERIALIZE_VAR_TO_BUF(buf, '_', char);
-  SERIALIZE_MEM_TO_BUF(buf, key, colType);
-  SERIALIZE_VAR_TO_BUF(buf, '_', char);
-  SERIALIZE_MEM_TO_BUF(buf, key, version);
-  SERIALIZE_VAR_TO_BUF(buf, '_', char);
-  SERIALIZE_STR_MEM_TO_BUF(buf, key, colName, key->nColName);
-}
+static int  tfileGetFileList(const char* path, SArray* result);
+static int  tfileRmExpireFile(SArray* result);
+static void tfileDestroyFileName(void* elem);
+static int  tfileCompare(const void* a, const void* b);
+static int  tfileParseFileName(const char* filename, uint64_t* suid, int* colId, int* version);
+static void tfileGenFileName(char* filename, uint64_t suid, int colId, int version);
+static void tfileSerialCacheKey(TFileCacheKey* key, char* buf);
 
 TFileCache* tfileCacheCreate(const char* path) {
   TFileCache* tcache = calloc(1, sizeof(TFileCache));
@@ -160,6 +57,8 @@ TFileCache* tfileCacheCreate(const char* path) {
   SArray* files = taosArrayInit(4, sizeof(void*));
   tfileGetFileList(path, files);
   taosArraySort(files, tfileCompare);
+  tfileRmExpireFile(files);
+
   uint64_t suid;
   int32_t  colId, version;
   for (size_t i = 0; i < taosArrayGetSize(files); i++) {
@@ -168,25 +67,29 @@ TFileCache* tfileCacheCreate(const char* path) {
       indexInfo("try parse invalid file:  %s, skip it", file);
       continue;
     }
+
     WriterCtx* wc = writerCtxCreate(TFile, file, true, 1024 * 64);
     if (wc == NULL) {
       indexError("failed to open index:  %s", file);
       goto End;
     }
+
     TFileReader* reader = tfileReaderCreate(wc);
     if (0 != tfileReadLoadHeader(reader)) {
       tfileReaderDestroy(reader);
-      indexError("failed to load index header, index Id: %s", file);
+      indexError("failed to load index header, index file: %s", file);
       goto End;
     }
-    // loader fst and validate it
 
+    if (0 != tfileReadLoadFst(reader)) {
+      tfileReaderDestroy(reader);
+      indexError("failed to load index fst, index file: %s", file);
+      goto End;
+    }
+    tfileReadRef(reader);
+    // loader fst and validate it
     TFileHeader*  header = &reader->header;
-    TFileCacheKey key = {.suid = header->suid,
-                         .version = header->version,
-                         .colName = header->colName,
-                         .nColName = strlen(header->colName),
-                         .colType = header->colType};
+    TFileCacheKey key = {.suid = header->suid, .colName = header->colName, .nColName = strlen(header->colName), .colType = header->colType};
 
     char buf[128] = {0};
     tfileSerialCacheKey(&key, buf);
@@ -208,7 +111,7 @@ void tfileCacheDestroy(TFileCache* tcache) {
     TFileReader* p = *reader;
     indexInfo("drop table cache suid: %" PRIu64 ", colName: %s, colType: %d", p->header.suid, p->header.colName, p->header.colType);
 
-    tfileReaderDestroy(p);
+    tfileReadUnRef(p);
     reader = taosHashIterate(tcache->tableCache, reader);
   }
   taosHashCleanup(tcache->tableCache);
@@ -218,12 +121,24 @@ void tfileCacheDestroy(TFileCache* tcache) {
 TFileReader* tfileCacheGet(TFileCache* tcache, TFileCacheKey* key) {
   char buf[128] = {0};
   tfileSerialCacheKey(key, buf);
+
   TFileReader* reader = taosHashGet(tcache->tableCache, buf, strlen(buf));
+  tfileReadRef(reader);
+
   return reader;
 }
 void tfileCachePut(TFileCache* tcache, TFileCacheKey* key, TFileReader* reader) {
   char buf[128] = {0};
   tfileSerialCacheKey(key, buf);
+  // remove last version index reader
+  TFileReader** p = taosHashGet(tcache->tableCache, buf, strlen(buf));
+  if (*p != NULL) {
+    TFileReader* oldReader = *p;
+    taosHashRemove(tcache->tableCache, buf, strlen(buf));
+    tfileReadUnRef(oldReader);
+  }
+
+  tfileReadRef(reader);
   taosHashPut(tcache->tableCache, buf, strlen(buf), &reader, sizeof(void*));
   return;
 }
@@ -239,27 +154,35 @@ TFileReader* tfileReaderCreate(WriterCtx* ctx) {
 void tfileReaderDestroy(TFileReader* reader) {
   if (reader == NULL) { return; }
   // T_REF_INC(reader);
+  fstDestroy(reader->fst);
   writerCtxDestroy(reader->ctx);
   free(reader);
 }
 
 int tfileReaderSearch(TFileReader* reader, SIndexTermQuery* query, SArray* result) {
-  SIndexTerm* term = query->term;
+  SIndexTerm*     term = query->term;
+  EIndexQueryType qtype = query->qType;
+
+  int ret = -1;
   // refactor to callback later
-  if (query->qType == QUERY_TERM) {
+  if (qtype == QUERY_TERM) {
     uint64_t offset;
     FstSlice key = fstSliceCreate(term->colVal, term->nColVal);
     if (fstGet(reader->fst, &key, &offset)) {
-      //
+      indexInfo("index: %" PRIu64 ", col: %s, colVal: %s, found table info in tindex", term->suid, term->colName, term->colVal);
+      ret = tfileReadLoadTableIds(reader, offset, result);
     } else {
-      indexInfo("index: %" PRIu64 ", col: %s, colVal: %s, not found in tindex", term->suid, term->colName, term->colVal);
+      indexInfo("index: %" PRIu64 ", col: %s, colVal: %s, not found table info in tindex", term->suid, term->colName, term->colVal);
     }
-    return 0;
-  } else if (query->qType == QUERY_PREFIX) {
-    //
+    fstSliceDestroy(&key);
+  } else if (qtype == QUERY_PREFIX) {
+    // handle later
     //
+  } else {
+    // handle later
   }
-  return 0;
+  tfileReadUnRef(reader);
+  return ret;
 }
 
 TFileWriter* tfileWriterCreate(WriterCtx* ctx, TFileHeader* header) {
@@ -282,18 +205,41 @@ TFileWriter* tfileWriterCreate(WriterCtx* ctx, TFileHeader* header) {
   tw->ctx = ctx;
   tw->header = *header;
   tfileWriteHeader(tw);
+  tw->fb = fstBuilderCreate(ctx, 0);
+  if (tw->fb == NULL) {
+    tfileWriterDestroy(tw);
+    return NULL;
+  }
   return tw;
 }
 
-int TFileWriterPut(TFileWriter* tw, void* data) {
+int tfileWriterPut(TFileWriter* tw, void* data) {
   // sort by coltype and write to tindex
-  __compar_fn_t fn = getComparFunc(tw->header.colType, 0);
+  __compar_fn_t fn;
+
+  int8_t colType = tw->header.colType;
+  if (colType == TSDB_DATA_TYPE_BINARY || colType == TSDB_DATA_TYPE_NCHAR) {
+    fn = tfileStrCompare;
+  } else {
+    fn = getComparFunc(colType, 0);
+  }
   taosArraySortPWithExt((SArray*)(data), tfileValueCompare, &fn);
 
   int32_t bufLimit = 4096, offset = 0;
-  char*   buf = calloc(1, sizeof(bufLimit));
+  char*   buf = calloc(1, sizeof(char) * bufLimit);
   char*   p = buf;
   int32_t sz = taosArrayGetSize((SArray*)data);
+  int32_t fstOffset = tw->offset;
+
+  // ugly code, refactor later
+  for (size_t i = 0; i < sz; i++) {
+    TFileValue* v = taosArrayGetP((SArray*)data, i);
+
+    int32_t tbsz = taosArrayGetSize(v->tableId);
+    fstOffset += TF_TABLE_TATOAL_SIZE(tbsz);
+  }
+  tfileWriteFstOffset(tw, fstOffset);
+
   for (size_t i = 0; i < sz; i++) {
     TFileValue* v = taosArrayGetP((SArray*)data, i);
 
@@ -311,7 +257,7 @@ int TFileWriterPut(TFileWriter* tw, void* data) {
     tfileSerialTableIdsToBuf(p, v->tableId);
     offset += ttsz;
     p = buf + offset;
-    // set up value offset and
+    // set up value offset
     v->offset = tw->offset;
     tw->offset += ttsz;
   }
@@ -319,6 +265,7 @@ int TFileWriterPut(TFileWriter* tw, void* data) {
     // write reversed data in buf to tindex
     tw->ctx->write(tw->ctx, buf, offset);
   }
+  tfree(buf);
 
   // write fst
   for (size_t i = 0; i < sz; i++) {
@@ -326,11 +273,11 @@ int TFileWriterPut(TFileWriter* tw, void* data) {
     TFileValue* v = taosArrayGetP((SArray*)data, i);
     if (tfileWriteData(tw, v) == 0) {
       //
-      //
     }
   }
-
-  tfree(buf);
+  fstBuilderFinish(tw->fb);
+  fstBuilderDestroy(tw->fb);
+  tw->fb = NULL;
   return 0;
 }
 void tfileWriterDestroy(TFileWriter* tw) {
@@ -352,17 +299,184 @@ void IndexTFileDestroy(IndexTFile* tfile) {
 }
 
 int indexTFileSearch(void* tfile, SIndexTermQuery* query, SArray* result) {
-  if (tfile == NULL) { return -1; }
+  int ret = -1;
+  if (tfile == NULL) { return ret; }
   IndexTFile* pTfile = (IndexTFile*)tfile;
 
   SIndexTerm*   term = query->term;
-  TFileCacheKey key = {.suid = term->suid, .colType = term->colType, .version = 0, .colName = term->colName, .nColName = term->nColName};
+  TFileCacheKey key = {.suid = term->suid, .colType = term->colType, .colName = term->colName, .nColName = term->nColName};
+  TFileReader*  reader = tfileCacheGet(pTfile->cache, &key);
 
-  TFileReader* reader = tfileCacheGet(pTfile->cache, &key);
   return tfileReaderSearch(reader, query, result);
 }
 int indexTFilePut(void* tfile, SIndexTerm* term, uint64_t uid) {
-  TFileWriterOpt wOpt = {.suid = term->suid, .colType = term->colType, .colName = term->colName, .nColName = term->nColName, .version = 1};
+  // TFileWriterOpt wOpt = {.suid = term->suid, .colType = term->colType, .colName = term->colName, .nColName = term->nColName, .version =
+  // 1};
 
   return 0;
 }
+
+static int tfileStrCompare(const void* a, const void* b) {
+  int ret = strcmp((char*)a, (char*)b);
+  if (ret == 0) { return ret; }
+  return ret < 0 ? -1 : 1;
+}
+
+static int tfileValueCompare(const void* a, const void* b, const void* param) {
+  __compar_fn_t fn = *(__compar_fn_t*)param;
+
+  TFileValue* av = (TFileValue*)a;
+  TFileValue* bv = (TFileValue*)b;
+
+  return fn(av->colVal, bv->colVal);
+}
+static void tfileSerialTableIdsToBuf(char* buf, SArray* ids) {
+  int sz = taosArrayGetSize(ids);
+  SERIALIZE_VAR_TO_BUF(buf, sz, int32_t);
+  for (size_t i = 0; i < sz; i++) {
+    uint64_t* v = taosArrayGet(ids, i);
+    SERIALIZE_VAR_TO_BUF(buf, *v, uint64_t);
+  }
+}
+
+static int tfileWriteFstOffset(TFileWriter* tw, int32_t offset) {
+  int32_t fstOffset = offset + sizeof(tw->header.fstOffset);
+  tw->header.fstOffset = fstOffset;
+  if (sizeof(fstOffset) != tw->ctx->write(tw->ctx, (char*)&fstOffset, sizeof(fstOffset))) { return -1; }
+  return 0;
+}
+static int tfileWriteHeader(TFileWriter* writer) {
+  char buf[TFILE_HEADER_NO_FST] = {0};
+
+  TFileHeader* header = &writer->header;
+  memcpy(buf, (char*)header, sizeof(buf));
+
+  int nwrite = writer->ctx->write(writer->ctx, buf, sizeof(buf));
+  if (sizeof(buf) != nwrite) { return -1; }
+  writer->offset = nwrite;
+  return 0;
+}
+static int tfileWriteData(TFileWriter* write, TFileValue* tval) {
+  TFileHeader* header = &write->header;
+  uint8_t      colType = header->colType;
+  if (colType == TSDB_DATA_TYPE_BINARY || colType == TSDB_DATA_TYPE_NCHAR) {
+    FstSlice key = fstSliceCreate((uint8_t*)(tval->colVal), (size_t)strlen(tval->colVal));
+    if (fstBuilderInsert(write->fb, key, tval->offset)) {
+      fstSliceDestroy(&key);
+      return 0;
+    }
+    fstSliceDestroy(&key);
+    return -1;
+  } else {
+    // handle other type later
+  }
+  return 0;
+}
+static int tfileReadLoadHeader(TFileReader* reader) {
+  // TODO simple tfile header later
+  char buf[TFILE_HEADER_SIZE] = {0};
+
+  int64_t nread = reader->ctx->read(reader->ctx, buf, sizeof(buf));
+  assert(nread == sizeof(buf));
+  memcpy(&reader->header, buf, sizeof(buf));
+  return 0;
+}
+static int tfileReadLoadFst(TFileReader* reader) {
+  // current load fst into memory, refactor it later
+  static int FST_MAX_SIZE = 16 * 1024;
+
+  char* buf = calloc(1, sizeof(char) * FST_MAX_SIZE);
+  if (buf == NULL) { return -1; }
+
+  WriterCtx* ctx = reader->ctx;
+  int32_t    nread = ctx->readFrom(ctx, buf, FST_MAX_SIZE, reader->header.fstOffset);
+  // we assuse fst size less than FST_MAX_SIZE
+  assert(nread > 0 && nread < FST_MAX_SIZE);
+
+  FstSlice st = fstSliceCreate((uint8_t*)buf, nread);
+  reader->fst = fstCreate(&st);
+  free(buf);
+  fstSliceDestroy(&st);
+
+  return reader->fst == NULL ? 0 : -1;
+}
+static int tfileReadLoadTableIds(TFileReader* reader, int32_t offset, SArray* result) {
+  int32_t    nid;
+  WriterCtx* ctx = reader->ctx;
+
+  int32_t nread = ctx->readFrom(ctx, (char*)&nid, sizeof(nid), offset);
+  assert(sizeof(nid) == nread);
+
+  int32_t total = sizeof(uint64_t) * nid;
+  char*   buf = calloc(1, total);
+  if (buf == NULL) { return -1; }
+
+  nread = ctx->read(ctx, buf, total);
+  assert(total == nread);
+
+  for (int32_t i = 0; i < nid; i++) {
+    taosArrayPush(result, (uint64_t*)buf + i);
+  }
+  free(buf);
+  return 0;
+}
+static void tfileReadRef(TFileReader* reader) {
+  int ref = T_REF_INC(reader);
+  UNUSED(ref);
+}
+
+static void tfileReadUnRef(TFileReader* reader) {
+  int ref = T_REF_DEC(reader);
+  if (ref == 0) { tfileReaderDestroy(reader); }
+}
+
+static int tfileGetFileList(const char* path, SArray* result) {
+  DIR* dir = opendir(path);
+  if (NULL == dir) { return -1; }
+
+  struct dirent* entry;
+  while ((entry = readdir(dir)) != NULL) {
+    size_t len = strlen(entry->d_name);
+    char*  buf = calloc(1, len + 1);
+    memcpy(buf, entry->d_name, len);
+    taosArrayPush(result, &buf);
+  }
+  closedir(dir);
+  return 0;
+}
+static int tfileRmExpireFile(SArray* result) {
+  // TODO(yihao): remove expire tindex after restart
+  return 0;
+}
+static void tfileDestroyFileName(void* elem) {
+  char* p = *(char**)elem;
+  free(p);
+}
+static int tfileCompare(const void* a, const void* b) {
+  const char* aName = *(char**)a;
+  const char* bName = *(char**)b;
+
+  size_t aLen = strlen(aName);
+  size_t bLen = strlen(bName);
+
+  return strncmp(aName, bName, aLen > bLen ? aLen : bLen);
+}
+// tfile name suid-colId-version.tindex
+static void tfileGenFileName(char* filename, uint64_t suid, int colId, int version) {
+  sprintf(filename, "%" PRIu64 "-%d-%d.tindex", suid, colId, version);
+  return;
+}
+static int tfileParseFileName(const char* filename, uint64_t* suid, int* colId, int* version) {
+  if (3 == sscanf(filename, "%" PRIu64 "-%d-%d.tindex", suid, colId, version)) {
+    // read suid & colid & version  success
+    return 0;
+  }
+  return -1;
+}
+static void tfileSerialCacheKey(TFileCacheKey* key, char* buf) {
+  SERIALIZE_MEM_TO_BUF(buf, key, suid);
+  SERIALIZE_VAR_TO_BUF(buf, '_', char);
+  SERIALIZE_MEM_TO_BUF(buf, key, colType);
+  SERIALIZE_VAR_TO_BUF(buf, '_', char);
+  SERIALIZE_STR_MEM_TO_BUF(buf, key, colName, key->nColName);
+}

source/libs/index/test/indexTests.cc

@@ -2,8 +2,7 @@
  * 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.
+ * 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
@@ -13,105 +12,105 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 #include <gtest/gtest.h>
-#include <string>
 #include <iostream>
+#include <string>
 #include "index.h"
-#include "tutil.h"
 #include "indexInt.h"
 #include "index_fst.h"
-#include "index_fst_util.h"
 #include "index_fst_counting_writer.h"
-
+#include "index_fst_util.h"
+#include "index_tfile.h"
+#include "tutil.h"
 
 class FstWriter {
-  public:
-    FstWriter() {
-      _wc = writerCtxCreate(TFile, "/tmp/tindex", false, 0); 
-      _b = fstBuilderCreate(NULL, 0);
-    }  
-   bool Put(const std::string &key, uint64_t val) {
-      FstSlice skey = fstSliceCreate((uint8_t *)key.c_str(), key.size());   
-      bool ok = fstBuilderInsert(_b, skey, val);
-      fstSliceDestroy(&skey);
-      return ok;
-   }
-   ~FstWriter() {
-     fstBuilderFinish(_b);
-     fstBuilderDestroy(_b);
+ public:
+  FstWriter() {
+    _wc = writerCtxCreate(TFile, "/tmp/tindex", false, 64 * 1024 * 1024);
+    _b = fstBuilderCreate(NULL, 0);
+  }
+  bool Put(const std::string& key, uint64_t val) {
+    FstSlice skey = fstSliceCreate((uint8_t*)key.c_str(), key.size());
+    bool     ok = fstBuilderInsert(_b, skey, val);
+    fstSliceDestroy(&skey);
+    return ok;
+  }
+  ~FstWriter() {
+    fstBuilderFinish(_b);
+    fstBuilderDestroy(_b);
 
-     writerCtxDestroy(_wc);
-   }
-  private:
-    FstBuilder *_b; 
-    WriterCtx *_wc;
+    writerCtxDestroy(_wc);
+  }
+
+ private:
+  FstBuilder* _b;
+  WriterCtx*  _wc;
 };
 
 class FstReadMemory {
-  public:
-   FstReadMemory(size_t size) {
-     _wc   = writerCtxCreate(TFile, "/tmp/tindex", true, 0);   
-     _w    = fstCountingWriterCreate(_wc); 
-     _size = size; 
-     memset((void *)&_s, 0, sizeof(_s));
-   }
-   bool init() {
-     char *buf = (char *)calloc(1,  sizeof(char) * _size);
-     int nRead = fstCountingWriterRead(_w, (uint8_t *)buf, _size); 
-     if (nRead <= 0) { return false; } 
-      _size = nRead;
-     _s   = fstSliceCreate((uint8_t *)buf, _size);  
-     _fst = fstCreate(&_s); 
-     free(buf);
-     return _fst != NULL;
-   }
-   bool Get(const std::string &key, uint64_t *val) {
-     FstSlice skey = fstSliceCreate((uint8_t *)key.c_str(), key.size());   
-     bool ok = fstGet(_fst, &skey, val); 
-     fstSliceDestroy(&skey);
-     return ok;
-   }
-   bool GetWithTimeCostUs(const std::string &key, uint64_t *val, uint64_t *elapse) {
-     int64_t s = taosGetTimestampUs();
-     bool ok = this->Get(key, val); 
-     int64_t e = taosGetTimestampUs();
-     *elapse = e - s;
-     return ok; 
-   }
-   // add later
-   bool Search(AutomationCtx *ctx, std::vector<uint64_t> &result) { 
-      FstStreamBuilder *sb = fstSearch(_fst, ctx);
-      StreamWithState  *st = streamBuilderIntoStream(sb);  
-      StreamWithStateResult *rt = NULL;  
+ public:
+  FstReadMemory(size_t size) {
+    _wc = writerCtxCreate(TFile, "/tmp/tindex", true, 64 * 1024);
+    _w = fstCountingWriterCreate(_wc);
+    _size = size;
+    memset((void*)&_s, 0, sizeof(_s));
+  }
+  bool init() {
+    char* buf = (char*)calloc(1, sizeof(char) * _size);
+    int   nRead = fstCountingWriterRead(_w, (uint8_t*)buf, _size);
+    if (nRead <= 0) { return false; }
+    _size = nRead;
+    _s = fstSliceCreate((uint8_t*)buf, _size);
+    _fst = fstCreate(&_s);
+    free(buf);
+    return _fst != NULL;
+  }
+  bool Get(const std::string& key, uint64_t* val) {
+    FstSlice skey = fstSliceCreate((uint8_t*)key.c_str(), key.size());
+    bool     ok = fstGet(_fst, &skey, val);
+    fstSliceDestroy(&skey);
+    return ok;
+  }
+  bool GetWithTimeCostUs(const std::string& key, uint64_t* val, uint64_t* elapse) {
+    int64_t s = taosGetTimestampUs();
+    bool    ok = this->Get(key, val);
+    int64_t e = taosGetTimestampUs();
+    *elapse = e - s;
+    return ok;
+  }
+  // add later
+  bool Search(AutomationCtx* ctx, std::vector<uint64_t>& result) {
+    FstStreamBuilder*      sb = fstSearch(_fst, ctx);
+    StreamWithState*       st = streamBuilderIntoStream(sb);
+    StreamWithStateResult* rt = NULL;
 
-      while ((rt = streamWithStateNextWith(st, NULL)) != NULL) {
-        result.push_back((uint64_t)(rt->out.out));
-      }
-      return true;
-   }
-   bool SearchWithTimeCostUs(AutomationCtx *ctx, std::vector<uint64_t> &result) {
-     int64_t s = taosGetTimestampUs();
-     bool ok = this->Search(ctx, result); 
-     int64_t e = taosGetTimestampUs();
-     return ok;
-   }
+    while ((rt = streamWithStateNextWith(st, NULL)) != NULL) {
+      result.push_back((uint64_t)(rt->out.out));
+    }
+    return true;
+  }
+  bool SearchWithTimeCostUs(AutomationCtx* ctx, std::vector<uint64_t>& result) {
+    int64_t s = taosGetTimestampUs();
+    bool    ok = this->Search(ctx, result);
+    int64_t e = taosGetTimestampUs();
+    return ok;
+  }
 
-   ~FstReadMemory() {
+  ~FstReadMemory() {
     fstCountingWriterDestroy(_w);
     fstDestroy(_fst);
     fstSliceDestroy(&_s);
     writerCtxDestroy(_wc);
   }
 
-  private:
-   FstCountingWriter *_w; 
-   Fst *_fst;
-   FstSlice _s;  
-   WriterCtx *_wc;
-   size_t _size;
-   
+ private:
+  FstCountingWriter* _w;
+  Fst*               _fst;
+  FstSlice           _s;
+  WriterCtx*         _wc;
+  size_t             _size;
 };
 
-//TEST(IndexTest, index_create_test) {
+// TEST(IndexTest, index_create_test) {
 //  SIndexOpts *opts = indexOptsCreate();
 //  SIndex *index = indexOpen(opts, "./test");
 //  if (index == NULL) {
@@ -163,17 +162,16 @@ class FstReadMemory {
 //  //
 //}
 
-
 #define L 100
 #define M 100
 #define N 100
 
-int Performance_fstWriteRecords(FstWriter *b) {
+int Performance_fstWriteRecords(FstWriter* b) {
   std::string str("aa");
   for (int i = 0; i < L; i++) {
     str[0] = 'a' + i;
     str.resize(2);
-    for(int j = 0; j < M; j++) {
+    for (int j = 0; j < M; j++) {
       str[1] = 'a' + j;
       str.resize(2);
       for (int k = 0; k < N; k++) {
@@ -186,19 +184,19 @@ int Performance_fstWriteRecords(FstWriter *b) {
   return L * M * N;
 }
 
-void Performance_fstReadRecords(FstReadMemory *m) {
+void Performance_fstReadRecords(FstReadMemory* m) {
   std::string str("aa");
   for (int i = 0; i < M; i++) {
     str[0] = 'a' + i;
     str.resize(2);
-    for(int j = 0; j < N; j++) {
+    for (int j = 0; j < N; j++) {
       str[1] = 'a' + j;
       str.resize(2);
       for (int k = 0; k < L; k++) {
         str.push_back('a');
         uint64_t val, cost;
         if (m->GetWithTimeCostUs(str, &val, &cost)) {
-          printf("succes to get kv(%s, %" PRId64"), cost: %" PRId64"\n", str.c_str(), val, cost);
+          printf("succes to get kv(%s, %" PRId64 "), cost: %" PRId64 "\n", str.c_str(), val, cost);
         } else {
           printf("failed to get key: %s\n", str.c_str());
         }
@@ -207,26 +205,24 @@ void Performance_fstReadRecords(FstReadMemory *m) {
   }
 }
 void checkFstPerf() {
-  FstWriter *fw = new FstWriter;
-  int64_t s = taosGetTimestampUs();
+  FstWriter* fw = new FstWriter;
+  int64_t    s = taosGetTimestampUs();
 
-  int num = Performance_fstWriteRecords(fw);
+  int     num = Performance_fstWriteRecords(fw);
   int64_t e = taosGetTimestampUs();
-  printf("write %d record cost %" PRId64"us\n", num,  e - s);
+  printf("write %d record cost %" PRId64 "us\n", num, e - s);
   delete fw;
 
-  FstReadMemory *m = new FstReadMemory(1024 * 64);
-  if (m->init()) {
-    printf("success to init fst read");  
-  }  
+  FstReadMemory* m = new FstReadMemory(1024 * 64);
+  if (m->init()) { printf("success to init fst read"); }
   Performance_fstReadRecords(m);
   delete m;
 }
 
 void checkFstPrefixSearch() {
-  FstWriter *fw = new FstWriter;
-  int64_t s = taosGetTimestampUs();
-  int count = 2;
+  FstWriter*  fw = new FstWriter;
+  int64_t     s = taosGetTimestampUs();
+  int         count = 2;
   std::string key("ab");
 
   for (int i = 0; i < count; i++) {
@@ -238,7 +234,7 @@ void checkFstPrefixSearch() {
   std::cout << "insert data count :  " << count << "elapas time: " << e - s << std::endl;
   delete fw;
 
-  FstReadMemory *m = new FstReadMemory(1024 * 64);
+  FstReadMemory* m = new FstReadMemory(1024 * 64);
   if (m->init() == false) {
     std::cout << "init readMemory failed" << std::endl;
     delete m;
@@ -247,20 +243,21 @@ void checkFstPrefixSearch() {
 
   // prefix search
   std::vector<uint64_t> result;
-  AutomationCtx *ctx = automCtxCreate((void *)"ab", AUTOMATION_PREFIX); 
+
+  AutomationCtx* ctx = automCtxCreate((void*)"ab", AUTOMATION_PREFIX);
   m->Search(ctx, result);
   assert(result.size() == count);
   for (int i = 0; i < result.size(); i++) {
-    assert(result[i] == i); // check result
+    assert(result[i] == i);  // check result
   }
 
   free(ctx);
   delete m;
 }
 void validateFst() {
-  int val = 100;
-  int count = 100;
-  FstWriter *fw = new FstWriter;
+  int        val = 100;
+  int        count = 100;
+  FstWriter* fw = new FstWriter;
   // write
   {
     std::string key("ab");
@@ -272,7 +269,7 @@ void validateFst() {
   delete fw;
 
   // read
-  FstReadMemory *m = new FstReadMemory(1024 * 64);
+  FstReadMemory* m = new FstReadMemory(1024 * 64);
   if (m->init() == false) {
     std::cout << "init readMemory failed" << std::endl;
     delete m;
@@ -280,91 +277,153 @@ void validateFst() {
   }
 
   {
-   std::string key("ab");
-   uint64_t out;
-   if (m->Get(key, &out)) {
-     printf("success to get (%s, %" PRId64")\n", key.c_str(), out);
-   } else {
-     printf("failed to get(%s)\n", key.c_str());
-   }
-   for (int i = 0; i < count; i++) {
-     key.push_back('a' + i);
-     if (m->Get(key, &out) ) {
-       assert(val - i ==  out);
-       printf("success to get (%s, %" PRId64")\n", key.c_str(), out);
-     } else {
-       printf("failed to get(%s)\n", key.c_str());
+    std::string key("ab");
+    uint64_t    out;
+    if (m->Get(key, &out)) {
+      printf("success to get (%s, %" PRId64 ")\n", key.c_str(), out);
+    } else {
+      printf("failed to get(%s)\n", key.c_str());
+    }
+    for (int i = 0; i < count; i++) {
+      key.push_back('a' + i);
+      if (m->Get(key, &out)) {
+        assert(val - i == out);
+        printf("success to get (%s, %" PRId64 ")\n", key.c_str(), out);
+      } else {
+        printf("failed to get(%s)\n", key.c_str());
+      }
     }
-   }
   }
   delete m;
 }
 
 class IndexEnv : public ::testing::Test {
-  protected:
-    virtual void SetUp() {
-      taosRemoveDir(path);  
-      opts = indexOptsCreate(); 
-      int ret = indexOpen(opts, path, &index); 
-      assert(ret == 0);
-    } 
-    virtual void TearDown() {
-      indexClose(index);
-      indexOptsDestroy(opts);
-    }
+ protected:
+  virtual void SetUp() {
+    taosRemoveDir(path);
+    opts = indexOptsCreate();
+    int ret = indexOpen(opts, path, &index);
+    assert(ret == 0);
+  }
+  virtual void TearDown() {
+    indexClose(index);
+    indexOptsDestroy(opts);
+  }
 
-    const char *path = "/tmp/tindex";
-    SIndexOpts *opts;  
-    SIndex *index; 
+  const char* path = "/tmp/tindex";
+  SIndexOpts* opts;
+  SIndex*     index;
 };
 
-TEST_F(IndexEnv, testPut) {
+// TEST_F(IndexEnv, testPut) {
+//  // single index column
+//  {
+//    std::string colName("tag1"), colVal("Hello world");
+//    SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(),
+//    colVal.size()); SIndexMultiTerm* terms = indexMultiTermCreate(); indexMultiTermAdd(terms, term);
+//
+//    for (size_t i = 0; i < 100; i++) {
+//      int tableId = i;
+//      int ret = indexPut(index, terms, tableId);
+//      assert(ret == 0);
+//    }
+//    indexMultiTermDestroy(terms);
+//  }
+//  // multi index column
+//  {
+//    SIndexMultiTerm* terms = indexMultiTermCreate();
+//    {
+//      std::string colName("tag1"), colVal("Hello world");
+//      SIndexTerm* term =
+//          indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), colVal.size());
+//      indexMultiTermAdd(terms, term);
+//    }
+//    {
+//      std::string colName("tag2"), colVal("Hello world");
+//      SIndexTerm* term =
+//          indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), colVal.size());
+//      indexMultiTermAdd(terms, term);
+//    }
+//
+//    for (int i = 0; i < 100; i++) {
+//      int tableId = i;
+//      int ret = indexPut(index, terms, tableId);
+//      assert(ret == 0);
+//    }
+//    indexMultiTermDestroy(terms);
+//  }
+//  //
+//}
 
-   // single index column 
-   {
+class IndexTFileEnv : public ::testing::Test {
+ protected:
+  virtual void SetUp() {
+    taosRemoveDir(dir);
+    taosMkDir(dir);
+    tfInit();
+    std::string colName("voltage");
+    header.suid = 1;
+    header.version = 1;
+    memcpy(header.colName, colName.c_str(), colName.size());
+    header.colType = TSDB_DATA_TYPE_BINARY;
 
-    std::string colName("tag1"), colVal("Hello world");
-    SIndexTerm *term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), colVal.size());  
-    SIndexMultiTerm *terms = indexMultiTermCreate();
-    indexMultiTermAdd(terms, term);
+    std::string path(dir);
+    int         colId = 2;
+    char        buf[64] = {0};
+    sprintf(buf, "%" PRIu64 "-%d-%d.tindex", header.suid, colId, header.version);
+    path.append("/").append(buf);
 
-    for (size_t i = 0; i < 100; i++) {
-      int tableId = i;
-      int ret = indexPut(index, terms, tableId);
-      assert(ret == 0); 
-    }
-    indexMultiTermDestroy(terms);
-   }
-   // multi index column
-   {
+    ctx = writerCtxCreate(TFile, path.c_str(), false, 64 * 1024 * 1024);
 
-    SIndexMultiTerm *terms = indexMultiTermCreate();
-    {
-      std::string colName("tag1"), colVal("Hello world");
-      SIndexTerm *term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), colVal.size());  
-      indexMultiTermAdd(terms, term);
-    }
-    {
-      std::string colName("tag2"), colVal("Hello world");
-      SIndexTerm *term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), colVal.size());  
-      indexMultiTermAdd(terms, term);
-    }
+    twrite = tfileWriterCreate(ctx, &header);
+  }
 
-    for (int i = 0; i < 100; i++) {
-      int tableId = i;
-      int ret = indexPut(index, terms, tableId);
-      assert(ret == 0); 
-    } 
-    indexMultiTermDestroy(terms);
-   }
-   //   
+  virtual void TearDown() {
+    // indexClose(index);
+    // indexeptsDestroy(opts);
+    tfCleanup();
+    tfileWriterDestroy(twrite);
+  }
+  const char*  dir = "/tmp/tindex";
+  WriterCtx*   ctx = NULL;
+  TFileHeader  header;
+  TFileWriter* twrite = NULL;
+};
+
+static TFileValue* genTFileValue(const char* val) {
+  TFileValue* tv = (TFileValue*)calloc(1, sizeof(TFileValue));
+  int32_t     vlen = strlen(val) + 1;
+  tv->colVal = (char*)calloc(1, vlen);
+  memcpy(tv->colVal, val, vlen);
+
+  tv->tableId = (SArray*)taosArrayInit(1, sizeof(uint64_t));
+  for (size_t i = 0; i < 10; i++) {
+    uint64_t v = i;
+    taosArrayPush(tv->tableId, &v);
+  }
+  return tv;
+}
+static void destroyTFileValue(void* val) {
+  TFileValue* tv = (TFileValue*)val;
+  free(tv->colVal);
+  taosArrayDestroy(tv->tableId);
+  free(tv);
 }
 
-TEST_F(IndexEnv, testDel) {
+TEST_F(IndexTFileEnv, test_tfile_write) {
+  TFileValue* v1 = genTFileValue("c");
+  TFileValue* v2 = genTFileValue("a");
 
+  SArray* data = (SArray*)taosArrayInit(4, sizeof(void*));
+
+  taosArrayPush(data, &v1);
+  taosArrayPush(data, &v2);
+
+  tfileWriterPut(twrite, data);
+  // tfileWriterDestroy(twrite);
+
+  for (size_t i = 0; i < taosArrayGetSize(data); i++) {
+    destroyTFileValue(taosArrayGetP(data, i));
+  }
+  taosArrayDestroy(data);
 }
-
-
-
-
-

source/libs/parser/inc/astToMsg.h

@@ -8,6 +8,8 @@ SCreateUserMsg* buildUserManipulationMsg(SSqlInfo* pInfo, int32_t* outputLen, in
 SCreateAcctMsg* buildAcctManipulationMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, char* msgBuf, int32_t msgLen);
 SDropUserMsg* buildDropUserMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, char* msgBuf, int32_t msgLen);
 SShowMsg* buildShowMsg(SShowInfo* pShowInfo, int64_t id, char* msgBuf, int32_t msgLen);
-SCreateDbMsg* buildCreateDbMsg(SCreateDbInfo* pCreateDbInfo, char* msgBuf, int32_t msgLen);
+SCreateDbMsg* buildCreateDbMsg(SCreateDbInfo* pCreateDbInfo, SParseBasicCtx *pCtx, SMsgBuf* pMsgBuf);
+SCreateStbMsg* buildCreateTableMsg(SCreateTableSql* pCreateTableSql, int32_t* len, SParseBasicCtx* pParseCtx, SMsgBuf* pMsgBuf);
+SDropTableMsg* buildDropTableMsg(SSqlInfo* pInfo, int32_t* len, SParseBasicCtx* pParseCtx, SMsgBuf* pMsgBuf);
 
 #endif  // TDENGINE_ASTTOMSG_H

source/libs/parser/inc/dataBlockMgt.h

@@ -78,7 +78,7 @@ typedef struct {
 typedef struct STableDataBlocks {
   int8_t      tsSource;     // where does the UNIX timestamp come from, server or client
   bool        ordered;      // if current rows are ordered or not
-  int64_t     vgId;         // virtual group id
+  int32_t     vgId;         // virtual group id
   int64_t     prevTS;       // previous timestamp, recorded to decide if the records array is ts ascending
   int32_t     numOfTables;  // number of tables in current submit block
   int32_t     rowSize;      // row size for current table

source/libs/parser/inc/parserInt.h

@@ -38,6 +38,14 @@ typedef struct SMsgBuf {
   char   *buf;
 } SMsgBuf;
 
+// create table operation type
+enum TSQL_CREATE_TABLE_TYPE {
+  TSQL_CREATE_TABLE  = 0x1,
+  TSQL_CREATE_STABLE = 0x2,
+  TSQL_CREATE_CTABLE = 0x3,
+  TSQL_CREATE_STREAM = 0x4,
+};
+
 void clearTableMetaInfo(STableMetaInfo* pTableMetaInfo);
 
 void clearAllTableMetaInfo(SQueryStmtInfo* pQueryInfo, bool removeMeta, uint64_t id);
@@ -60,7 +68,7 @@ int32_t qParserValidateSqlNode(struct SCatalog* pCatalog, SSqlInfo* pSqlInfo, SQ
  * @param type
  * @return
  */
-int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, int64_t id, void** output, int32_t* outputLen, int32_t* type, char* msgBuf, int32_t msgBufLen);
+int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStmtInfo* pDcl, char* msgBuf, int32_t msgBufLen);
 
 /**
  * Evaluate the numeric and timestamp arithmetic expression in the WHERE clause.

source/libs/parser/inc/parserUtil.h

@@ -67,6 +67,8 @@ int32_t    getExprFunctionId(SExprInfo *pExprInfo);
 STableMeta* tableMetaDup(const STableMeta* pTableMeta);
 
 bool isDclSqlStatement(SSqlInfo* pSqlInfo);
+bool isDdlSqlStatement(SSqlInfo* pSqlInfo);
+bool isDqlSqlStatement(SSqlInfo* pSqlInfo);
 
 #ifdef __cplusplus
 }

source/libs/parser/inc/sql.y

@@ -31,6 +31,7 @@
 #include "ttoken.h"
 #include "ttokendef.h"
 #include "tvariant.h"
+#include "parserInt.h"
 }
 
 %syntax_error {
@@ -173,7 +174,7 @@ cmd ::= ALTER DNODE ids(X) ids(Y) ids(Z).       { setDCLSqlElems(pInfo, TSDB_SQL
 cmd ::= ALTER LOCAL ids(X).                     { setDCLSqlElems(pInfo, TSDB_SQL_CFG_LOCAL, 1, &X);              }
 cmd ::= ALTER LOCAL ids(X) ids(Y).              { setDCLSqlElems(pInfo, TSDB_SQL_CFG_LOCAL, 2, &X, &Y);          }
 cmd ::= ALTER DATABASE ids(X) alter_db_optr(Y). { SToken t = {0};  setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &X, &Y, &t);}
-cmd ::= ALTER TOPIC ids(X) alter_topic_optr(Y). { SToken t = {0};  setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &X, &Y, &t);}
+//cmd ::= ALTER TOPIC ids(X) alter_topic_optr(Y). { SToken t = {0};  setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &X, &Y, &t);}
 
 cmd ::= ALTER ACCOUNT ids(X) acct_optr(Z).      { setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &X, NULL, &Z);}
 cmd ::= ALTER ACCOUNT ids(X) PASS ids(Y) acct_optr(Z).      { setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &X, &Y, &Z);}
@@ -203,7 +204,7 @@ cmd ::= CREATE DNODE   ids(X).     { setDCLSqlElems(pInfo, TSDB_SQL_CREATE_DNODE
 cmd ::= CREATE ACCOUNT ids(X) PASS ids(Y) acct_optr(Z).
                                 { setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &X, &Y, &Z);}
 cmd ::= CREATE DATABASE ifnotexists(Z) ids(X) db_optr(Y).  { setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &X, &Y, &Z);}
-cmd ::= CREATE TOPIC ifnotexists(Z) ids(X) topic_optr(Y).  { setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &X, &Y, &Z);}
+//cmd ::= CREATE TOPIC ifnotexists(Z) ids(X) topic_optr(Y).  { setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &X, &Y, &Z);}
 cmd ::= CREATE FUNCTION ids(X) AS ids(Y) OUTPUTTYPE typename(Z) bufsize(B).   { setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &X, &Y, &Z, &B, 1);}
 cmd ::= CREATE AGGREGATE FUNCTION ids(X) AS ids(Y) OUTPUTTYPE typename(Z) bufsize(B).   { setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &X, &Y, &Z, &B, 2);}
 cmd ::= CREATE USER ids(X) PASS ids(Y).     { setCreateUserSql(pInfo, &X, &Y);}
@@ -278,10 +279,10 @@ comp(Y)    ::= COMP INTEGER(X).               { Y = X; }
 prec(Y)    ::= PRECISION STRING(X).           { Y = X; }
 update(Y)  ::= UPDATE INTEGER(X).             { Y = X; }     
 cachelast(Y) ::= CACHELAST INTEGER(X).        { Y = X; }
-partitions(Y) ::= PARTITIONS INTEGER(X).      { Y = X; }
+//partitions(Y) ::= PARTITIONS INTEGER(X).      { Y = X; }
 
 %type db_optr {SCreateDbInfo}
-db_optr(Y) ::= . {setDefaultCreateDbOption(&Y); Y.dbType = TSDB_DB_TYPE_DEFAULT;}
+db_optr(Y) ::= . {setDefaultCreateDbOption(&Y);}
 
 db_optr(Y) ::= db_optr(Z) cache(X).          { Y = Z; Y.cacheBlockSize = strtol(X.z, NULL, 10); }
 db_optr(Y) ::= db_optr(Z) replica(X).        { Y = Z; Y.replica = strtol(X.z, NULL, 10); }
@@ -299,13 +300,13 @@ db_optr(Y) ::= db_optr(Z) keep(X).           { Y = Z; Y.keep = X; }
 db_optr(Y) ::= db_optr(Z) update(X).         { Y = Z; Y.update = strtol(X.z, NULL, 10); }
 db_optr(Y) ::= db_optr(Z) cachelast(X).      { Y = Z; Y.cachelast = strtol(X.z, NULL, 10); }
 
-%type topic_optr {SCreateDbInfo}
-
-topic_optr(Y) ::= db_optr(Z).                       { Y = Z; Y.dbType = TSDB_DB_TYPE_TOPIC; }
-topic_optr(Y) ::= topic_optr(Z) partitions(X).      { Y = Z; Y.partitions = strtol(X.z, NULL, 10); }
+//%type topic_optr {SCreateDbInfo}
+//
+//topic_optr(Y) ::= db_optr(Z).                       { Y = Z; Y.dbType = TSDB_DB_TYPE_TOPIC; }
+//topic_optr(Y) ::= topic_optr(Z) partitions(X).      { Y = Z; Y.partitions = strtol(X.z, NULL, 10); }
 
 %type alter_db_optr {SCreateDbInfo}
-alter_db_optr(Y) ::= . { setDefaultCreateDbOption(&Y); Y.dbType = TSDB_DB_TYPE_DEFAULT;}
+alter_db_optr(Y) ::= . { setDefaultCreateDbOption(&Y);}
 
 alter_db_optr(Y) ::= alter_db_optr(Z) replica(X).     { Y = Z; Y.replica = strtol(X.z, NULL, 10); }
 alter_db_optr(Y) ::= alter_db_optr(Z) quorum(X).      { Y = Z; Y.quorum = strtol(X.z, NULL, 10); }
@@ -319,10 +320,10 @@ alter_db_optr(Y) ::= alter_db_optr(Z) cachelast(X).   { Y = Z; Y.cachelast = str
 //alter_db_optr(Y) ::= alter_db_optr(Z) fsync(X).       { Y = Z; Y.fsyncPeriod = strtol(X.z, NULL, 10); }
 //alter_db_optr(Y) ::= alter_db_optr(Z) wal(X).         { Y = Z; Y.walLevel = strtol(X.z, NULL, 10); } not support yet
 
-%type alter_topic_optr {SCreateDbInfo}
+//%type alter_topic_optr {SCreateDbInfo}
 
-alter_topic_optr(Y) ::= alter_db_optr(Z).                       { Y = Z; Y.dbType = TSDB_DB_TYPE_TOPIC; }
-alter_topic_optr(Y) ::= alter_topic_optr(Z) partitions(X).      { Y = Z; Y.partitions = strtol(X.z, NULL, 10); }
+//alter_topic_optr(Y) ::= alter_db_optr(Z).                       { Y = Z; Y.dbType = TSDB_DB_TYPE_TOPIC; }
+//alter_topic_optr(Y) ::= alter_topic_optr(Z) partitions(X).      { Y = Z; Y.partitions = strtol(X.z, NULL, 10); }
 
 %type typename {SField}
 typename(A) ::= ids(X). { 

source/libs/parser/inc/ttokendef.h

@@ -130,88 +130,88 @@
 #define TK_PRECISION                      112
 #define TK_UPDATE                         113
 #define TK_CACHELAST                      114
-#define TK_PARTITIONS                     115
-#define TK_UNSIGNED                       116
-#define TK_TAGS                           117
-#define TK_USING                          118
-#define TK_NULL                           119
-#define TK_NOW                            120
-#define TK_SELECT                         121
-#define TK_UNION                          122
-#define TK_ALL                            123
-#define TK_DISTINCT                       124
-#define TK_FROM                           125
-#define TK_VARIABLE                       126
-#define TK_INTERVAL                       127
-#define TK_EVERY                          128
-#define TK_SESSION                        129
-#define TK_STATE_WINDOW                   130
-#define TK_FILL                           131
-#define TK_SLIDING                        132
-#define TK_ORDER                          133
-#define TK_BY                             134
-#define TK_ASC                            135
-#define TK_GROUP                          136
-#define TK_HAVING                         137
-#define TK_LIMIT                          138
-#define TK_OFFSET                         139
-#define TK_SLIMIT                         140
-#define TK_SOFFSET                        141
-#define TK_WHERE                          142
-#define TK_RESET                          143
-#define TK_QUERY                          144
-#define TK_SYNCDB                         145
-#define TK_ADD                            146
-#define TK_COLUMN                         147
-#define TK_MODIFY                         148
-#define TK_TAG                            149
-#define TK_CHANGE                         150
-#define TK_SET                            151
-#define TK_KILL                           152
-#define TK_CONNECTION                     153
-#define TK_STREAM                         154
-#define TK_COLON                          155
-#define TK_ABORT                          156
-#define TK_AFTER                          157
-#define TK_ATTACH                         158
-#define TK_BEFORE                         159
-#define TK_BEGIN                          160
-#define TK_CASCADE                        161
-#define TK_CLUSTER                        162
-#define TK_CONFLICT                       163
-#define TK_COPY                           164
-#define TK_DEFERRED                       165
-#define TK_DELIMITERS                     166
-#define TK_DETACH                         167
-#define TK_EACH                           168
-#define TK_END                            169
-#define TK_EXPLAIN                        170
-#define TK_FAIL                           171
-#define TK_FOR                            172
-#define TK_IGNORE                         173
-#define TK_IMMEDIATE                      174
-#define TK_INITIALLY                      175
-#define TK_INSTEAD                        176
-#define TK_KEY                            177
-#define TK_OF                             178
-#define TK_RAISE                          179
-#define TK_REPLACE                        180
-#define TK_RESTRICT                       181
-#define TK_ROW                            182
-#define TK_STATEMENT                      183
-#define TK_TRIGGER                        184
-#define TK_VIEW                           185
-#define TK_IPTOKEN                        186
-#define TK_SEMI                           187
-#define TK_NONE                           188
-#define TK_PREV                           189
-#define TK_LINEAR                         190
-#define TK_IMPORT                         191
-#define TK_TBNAME                         192
-#define TK_JOIN                           193
-#define TK_INSERT                         194
-#define TK_INTO                           195
-#define TK_VALUES                         196
+#define TK_UNSIGNED                       115
+#define TK_TAGS                           116
+#define TK_USING                          117
+#define TK_NULL                           118
+#define TK_NOW                            119
+#define TK_SELECT                         120
+#define TK_UNION                          121
+#define TK_ALL                            122
+#define TK_DISTINCT                       123
+#define TK_FROM                           124
+#define TK_VARIABLE                       125
+#define TK_INTERVAL                       126
+#define TK_EVERY                          127
+#define TK_SESSION                        128
+#define TK_STATE_WINDOW                   129
+#define TK_FILL                           130
+#define TK_SLIDING                        131
+#define TK_ORDER                          132
+#define TK_BY                             133
+#define TK_ASC                            134
+#define TK_GROUP                          135
+#define TK_HAVING                         136
+#define TK_LIMIT                          137
+#define TK_OFFSET                         138
+#define TK_SLIMIT                         139
+#define TK_SOFFSET                        140
+#define TK_WHERE                          141
+#define TK_RESET                          142
+#define TK_QUERY                          143
+#define TK_SYNCDB                         144
+#define TK_ADD                            145
+#define TK_COLUMN                         146
+#define TK_MODIFY                         147
+#define TK_TAG                            148
+#define TK_CHANGE                         149
+#define TK_SET                            150
+#define TK_KILL                           151
+#define TK_CONNECTION                     152
+#define TK_STREAM                         153
+#define TK_COLON                          154
+#define TK_ABORT                          155
+#define TK_AFTER                          156
+#define TK_ATTACH                         157
+#define TK_BEFORE                         158
+#define TK_BEGIN                          159
+#define TK_CASCADE                        160
+#define TK_CLUSTER                        161
+#define TK_CONFLICT                       162
+#define TK_COPY                           163
+#define TK_DEFERRED                       164
+#define TK_DELIMITERS                     165
+#define TK_DETACH                         166
+#define TK_EACH                           167
+#define TK_END                            168
+#define TK_EXPLAIN                        169
+#define TK_FAIL                           170
+#define TK_FOR                            171
+#define TK_IGNORE                         172
+#define TK_IMMEDIATE                      173
+#define TK_INITIALLY                      174
+#define TK_INSTEAD                        175
+#define TK_KEY                            176
+#define TK_OF                             177
+#define TK_RAISE                          178
+#define TK_REPLACE                        179
+#define TK_RESTRICT                       180
+#define TK_ROW                            181
+#define TK_STATEMENT                      182
+#define TK_TRIGGER                        183
+#define TK_VIEW                           184
+#define TK_IPTOKEN                        185
+#define TK_SEMI                           186
+#define TK_NONE                           187
+#define TK_PREV                           188
+#define TK_LINEAR                         189
+#define TK_IMPORT                         190
+#define TK_TBNAME                         191
+#define TK_JOIN                           192
+#define TK_INSERT                         193
+#define TK_INTO                           194
+#define TK_VALUES                         195
+
 
 
 #define TK_SPACE                          300

source/libs/parser/src/astGenerator.c

@@ -13,9 +13,10 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "taos.h"
-#include "os.h"
 #include "astGenerator.h"
+#include <parserInt.h>
+#include "os.h"
+#include "taos.h"
 #include "tmsgtype.h"
 
 SArray *tListItemAppend(SArray *pList, SVariant *pVar, uint8_t sortOrder) {

source/libs/parser/src/astToMsg.c

@@ -1,3 +1,4 @@
+#include <astGenerator.h>
 #include "parserInt.h"
 #include "parserUtil.h"
 
@@ -206,16 +207,166 @@ int32_t setDbOptions(SCreateDbMsg* pCreateDbMsg, const SCreateDbInfo* pCreateDbS
   return TSDB_CODE_SUCCESS;
 }
 
-SCreateDbMsg* buildCreateDbMsg(SCreateDbInfo* pCreateDbInfo, char* msgBuf, int32_t msgLen) {
+SCreateDbMsg* buildCreateDbMsg(SCreateDbInfo* pCreateDbInfo, SParseBasicCtx *pCtx, SMsgBuf* pMsgBuf) {
   SCreateDbMsg* pCreateMsg = calloc(1, sizeof(SCreateDbMsg));
-
-  SMsgBuf msg = {.buf = msgBuf, .len = msgLen};
-  if (setDbOptions(pCreateMsg, pCreateDbInfo, &msg) != TSDB_CODE_SUCCESS) {
+  if (setDbOptions(pCreateMsg, pCreateDbInfo, pMsgBuf) != TSDB_CODE_SUCCESS) {
     tfree(pCreateMsg);
     terrno = TSDB_CODE_TSC_INVALID_OPERATION;
 
     return NULL;
   }
 
+  SName   name = {0};
+  int32_t ret = tNameSetDbName(&name, pCtx->acctId, pCreateDbInfo->dbname.z, pCreateDbInfo->dbname.n);
+  if (ret != TSDB_CODE_SUCCESS) {
+    terrno = ret;
+    return NULL;
+  }
+
+  tNameGetFullDbName(&name, pCreateMsg->db);
   return pCreateMsg;
 }
+
+int32_t createSName(SName* pName, SToken* pTableName, SParseBasicCtx* pParseCtx, SMsgBuf* pMsgBuf) {
+  const char* msg1 = "name too long";
+  const char* msg2 = "acctId too long";
+
+  int32_t  code = TSDB_CODE_SUCCESS;
+  char* p  = strnchr(pTableName->z, TS_PATH_DELIMITER[0], pTableName->n, false);
+
+  if (p != NULL) { // db has been specified in sql string so we ignore current db path
+    code = tNameSetAcctId(pName, pParseCtx->acctId);
+    if (code != 0) {
+      return buildInvalidOperationMsg(pMsgBuf, msg2);
+    }
+
+    char name[TSDB_TABLE_FNAME_LEN] = {0};
+    strncpy(name, pTableName->z, pTableName->n);
+
+    code = tNameFromString(pName, name, T_NAME_DB|T_NAME_TABLE);
+    if (code != 0) {
+      return buildInvalidOperationMsg(pMsgBuf, msg1);
+    }
+  } else {  // get current DB name first, and then set it into path
+    if (pTableName->n >= TSDB_TABLE_NAME_LEN) {
+      return buildInvalidOperationMsg(pMsgBuf, msg1);
+    }
+
+    tNameSetDbName(pName, pParseCtx->acctId, pParseCtx->db, strlen(pParseCtx->db));
+
+    char name[TSDB_TABLE_FNAME_LEN] = {0};
+    strncpy(name, pTableName->z, pTableName->n);
+
+    code = tNameFromString(pName, name, T_NAME_TABLE);
+    if (code != 0) {
+      code = buildInvalidOperationMsg(pMsgBuf, msg1);
+    }
+  }
+
+  return code;
+}
+
+SCreateStbMsg* buildCreateTableMsg(SCreateTableSql* pCreateTableSql, int32_t* len, SParseBasicCtx* pParseCtx, SMsgBuf* pMsgBuf) {
+  SSchema* pSchema;
+
+  int32_t numOfTags = 0;
+  int32_t numOfCols = (int32_t) taosArrayGetSize(pCreateTableSql->colInfo.pColumns);
+  if (pCreateTableSql->colInfo.pTagColumns != NULL) {
+    numOfTags = (int32_t) taosArrayGetSize(pCreateTableSql->colInfo.pTagColumns);
+  }
+
+  SCreateStbMsg* pCreateTableMsg = (SCreateStbMsg*)calloc(1, sizeof(SCreateStbMsg) + (numOfCols + numOfTags) * sizeof(SSchema));
+
+  char* pMsg = NULL;
+  int32_t tableType = pCreateTableSql->type;
+  if (tableType != TSQL_CREATE_TABLE && tableType != TSQL_CREATE_STABLE) {  // create by using super table, tags value
+#if 0
+    SArray* list = pInfo->pCreateTableInfo->childTableInfo;
+
+    int32_t numOfTables = (int32_t)taosArrayGetSize(list);
+    pCreateTableMsg->numOfTables = htonl(numOfTables);
+
+    pMsg = (char*)pCreateMsg;
+    for (int32_t i = 0; i < numOfTables; ++i) {
+      SCreateTableMsg* pCreate = (SCreateTableMsg*)pMsg;
+
+      pCreate->numOfColumns = htons(pCmd->numOfCols);
+      pCreate->numOfTags = htons(pCmd->count);
+      pMsg += sizeof(SCreateTableMsg);
+
+      SCreatedTableInfo* p = taosArrayGet(list, i);
+      strcpy(pCreate->tableName, p->fullname);
+      pCreate->igExists = (p->igExist) ? 1 : 0;
+
+      // use dbinfo from table id without modifying current db info
+      pMsg = serializeTagData(&p->tagdata, pMsg);
+
+      int32_t len = (int32_t)(pMsg - (char*)pCreate);
+      pCreate->len = htonl(len);
+    }
+#endif
+  } else { // create (super) table
+    SName n = {0};
+    int32_t code = createSName(&n, &pCreateTableSql->name, pParseCtx, pMsgBuf);
+    if (code != 0) {
+      return NULL;
+    }
+
+    code = tNameExtractFullName(&n, pCreateTableMsg->name);
+    if (code != 0) {
+      buildInvalidOperationMsg(pMsgBuf, "invalid table name or database not specified");
+      return NULL;
+    }
+
+    pCreateTableMsg->igExists     = pCreateTableSql->existCheck ? 1 : 0;
+    pCreateTableMsg->numOfColumns = htonl(numOfCols);
+    pCreateTableMsg->numOfTags    = htonl(numOfTags);
+
+    pSchema = (SSchema*) pCreateTableMsg->pSchema;
+    for (int i = 0; i < numOfCols; ++i) {
+      SField* pField = taosArrayGet(pCreateTableSql->colInfo.pColumns, i);
+      pSchema->type  = pField->type;
+      pSchema->bytes = htonl(pField->bytes);
+      strcpy(pSchema->name, pField->name);
+
+      pSchema++;
+    }
+
+    for(int32_t i = 0; i < numOfTags; ++i) {
+      SField* pField = taosArrayGet(pCreateTableSql->colInfo.pTagColumns, i);
+      pSchema->type  = pField->type;
+      pSchema->bytes = htonl(pField->bytes);
+      strcpy(pSchema->name, pField->name);
+
+      pSchema++;
+    }
+
+    pMsg = (char*)pSchema;
+  }
+
+  int32_t msgLen = (int32_t)(pMsg - (char*)pCreateTableMsg);
+  *len = msgLen;
+
+  return pCreateTableMsg;
+}
+
+SDropTableMsg* buildDropTableMsg(SSqlInfo* pInfo, int32_t* len, SParseBasicCtx* pParseCtx, SMsgBuf* pMsgBuf) {
+  SToken* tableName = taosArrayGet(pInfo->pMiscInfo->a, 0);
+
+  SName name = {0};
+  int32_t code = createSName(&name, tableName, pParseCtx, pMsgBuf);
+  if (code != TSDB_CODE_SUCCESS) {
+    terrno = buildInvalidOperationMsg(pMsgBuf, "invalid table name");
+    return NULL;
+  }
+
+  SDropTableMsg *pDropTableMsg = (SDropTableMsg*) calloc(1, sizeof(SDropTableMsg));
+
+  code = tNameExtractFullName(&name, pDropTableMsg->name);
+  assert(code == TSDB_CODE_SUCCESS && name.type == TSDB_TABLE_NAME_T);
+
+  pDropTableMsg->ignoreNotExists = pInfo->pMiscInfo->existsCheck ? 1 : 0;
+  *len = sizeof(SDropTableMsg);
+  return pDropTableMsg;
+}
+

source/libs/parser/src/astValidate.c

@@ -4028,7 +4028,7 @@ int32_t qParserValidateSqlNode(struct SCatalog* pCatalog, SSqlInfo* pInfo, SQuer
 }
 
 // todo remove it
-static int32_t setShowInfo(struct SSqlInfo* pInfo, void** output, int32_t* msgLen, SMsgBuf* pMsgBuf) {
+static int32_t setShowInfo(SShowInfo* pShowInfo, SParseBasicCtx *pCtx, void** output, int32_t* outputLen, SMsgBuf* pMsgBuf) {
   const char* msg1 = "invalid name";
   const char* msg2 = "wildcard string should be less than %d characters";
   const char* msg3 = "database name too long";
@@ -4040,9 +4040,8 @@ static int32_t setShowInfo(struct SSqlInfo* pInfo, void** output, int32_t* msgLe
    * database prefix in pInfo->pMiscInfo->a[0]
    * wildcard in like clause in pInfo->pMiscInfo->a[1]
    */
-  SShowInfo* pShowInfo = &pInfo->pMiscInfo->showOpt;
   int16_t    showType = pShowInfo->showType;
-  if (showType == TSDB_MGMT_TABLE_TABLE || showType == TSDB_MGMT_TABLE_VGROUP) {
+  if (showType == TSDB_MGMT_TABLE_STB || showType == TSDB_MGMT_TABLE_VGROUP) {
     SToken* pDbPrefixToken = &pShowInfo->prefix;
     if (pDbPrefixToken->type != 0) {
       if (pDbPrefixToken->n >= TSDB_DB_NAME_LEN) {  // db name is too long
@@ -4091,8 +4090,8 @@ static int32_t setShowInfo(struct SSqlInfo* pInfo, void** output, int32_t* msgLe
     }
   }
 
-  *output = buildShowMsg(pShowInfo, 0, pMsgBuf->buf, pMsgBuf->len);
-  *msgLen = sizeof(SShowMsg)/* + htons(pShowMsg->payloadLen)*/;
+  *output = buildShowMsg(pShowInfo, pCtx->requestId, pMsgBuf->buf, pMsgBuf->len);
+  *outputLen = sizeof(SShowMsg)/* + htons(pShowMsg->payloadLen)*/;
   return TSDB_CODE_SUCCESS;
 }
 
@@ -4171,14 +4170,148 @@ static int32_t doCheckDbOptions(SCreateDbMsg* pCreate, SMsgBuf* pMsgBuf) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, int64_t id, void** output, int32_t* outputLen, int32_t* type, char* msgBuf, int32_t msgBufLen) {
+/* is contained in pFieldList or not */
+static bool has(SArray* pFieldList, int32_t startIndex, const char* name) {
+  size_t numOfCols = taosArrayGetSize(pFieldList);
+  for (int32_t j = startIndex; j < numOfCols; ++j) {
+    TAOS_FIELD* field = taosArrayGet(pFieldList, j);
+    if (strncasecmp(name, field->name, sizeof(field->name) - 1) == 0) return true;
+  }
+
+  return false;
+}
+
+static int32_t validateTableColumns(SArray* pFieldList, int32_t maxRowLength, int32_t maxColumns, SMsgBuf* pMsgBuf) {
+  const char* msg2 = "row length exceeds max length";
+  const char* msg3 = "duplicated column names";
+  const char* msg4 = "invalid data type";
+  const char* msg5 = "invalid binary/nchar column length";
+  const char* msg6 = "invalid column name";
+  const char* msg7 = "too many columns";
+  const char* msg8 = "illegal number of columns";
+
+  size_t numOfCols = taosArrayGetSize(pFieldList);
+  if (numOfCols > maxColumns) {
+    return buildInvalidOperationMsg(pMsgBuf, msg7);
+  }
+
+  int32_t rowLen = 0;
+  for (int32_t i = 0; i < numOfCols; ++i) {
+    TAOS_FIELD* pField = taosArrayGet(pFieldList, i);
+    if (!isValidDataType(pField->type)) {
+      return buildInvalidOperationMsg(pMsgBuf, msg4);
+    }
+
+    if (pField->bytes == 0) {
+      return buildInvalidOperationMsg(pMsgBuf, msg5);
+    }
+
+    if ((pField->type == TSDB_DATA_TYPE_BINARY && (pField->bytes <= 0 || pField->bytes > TSDB_MAX_BINARY_LEN)) ||
+        (pField->type == TSDB_DATA_TYPE_NCHAR && (pField->bytes <= 0 || pField->bytes > TSDB_MAX_NCHAR_LEN))) {
+      return buildInvalidOperationMsg(pMsgBuf, msg5);
+    }
+
+    SToken nameToken = {.z = pField->name, .n = strlen(pField->name), .type = TK_ID};
+    if (parserValidateNameToken(&nameToken) != TSDB_CODE_SUCCESS) {
+      return buildInvalidOperationMsg(pMsgBuf, msg6);
+    }
+
+    // field name must be unique
+    if (has(pFieldList, i + 1, pField->name) == true) {
+      return buildInvalidOperationMsg(pMsgBuf, msg3);
+    }
+
+    rowLen += pField->bytes;
+  }
+
+  // max row length must be less than TSDB_MAX_BYTES_PER_ROW
+  if (rowLen > maxRowLength) {
+    return buildInvalidOperationMsg(pMsgBuf, msg2);
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t validateTableColumnInfo(SArray* pFieldList, SMsgBuf* pMsgBuf) {
+  assert(pFieldList != NULL);
+
+  const char* msg1 = "first column must be timestamp";
+  const char* msg2 = "row length exceeds max length";
+  const char* msg3 = "duplicated column names";
+  const char* msg4 = "invalid data type";
+  const char* msg5 = "invalid binary/nchar column length";
+  const char* msg6 = "invalid column name";
+  const char* msg7 = "too many columns";
+  const char* msg8 = "illegal number of columns";
+
+  // first column must be timestamp
+  SField* pField = taosArrayGet(pFieldList, 0);
+  if (pField->type != TSDB_DATA_TYPE_TIMESTAMP) {
+    return buildInvalidOperationMsg(pMsgBuf, msg1);
+  }
+
+  // number of fields no less than 2
+  size_t numOfCols = taosArrayGetSize(pFieldList);
+  if (numOfCols <= 1) {
+    return buildInvalidOperationMsg(pMsgBuf, msg8);
+  }
+
+  return validateTableColumns(pFieldList, TSDB_MAX_BYTES_PER_ROW, TSDB_MAX_COLUMNS, pMsgBuf);
+}
+
+static int32_t validateTagParams(SArray* pTagsList, SArray* pFieldList, SMsgBuf* pMsgBuf) {
+  assert(pTagsList != NULL);
+
+  const char* msg1 = "invalid number of tag columns";
+  const char* msg3 = "duplicated column names";
+
+  // number of fields at least 1
+  size_t numOfTags = taosArrayGetSize(pTagsList);
+  if (numOfTags < 1) {
+    return buildInvalidOperationMsg(pMsgBuf, msg1);
+  }
+
+  // field name must be unique
+  for (int32_t i = 0; i < numOfTags; ++i) {
+    SField* p = taosArrayGet(pTagsList, i);
+    if (has(pFieldList, 0, p->name) == true) {
+      return buildInvalidOperationMsg(pMsgBuf, msg3);
+    }
+  }
+
+  return validateTableColumns(pFieldList, TSDB_MAX_TAGS_LEN, TSDB_MAX_TAGS, pMsgBuf);
+}
+
+int32_t doCheckForCreateTable(SSqlInfo* pInfo, SMsgBuf* pMsgBuf) {
+  const char* msg1 = "invalid table name";
+
+  SCreateTableSql* pCreateTable = pInfo->pCreateTableInfo;
+
+  SArray* pFieldList = pCreateTable->colInfo.pColumns;
+  SArray* pTagList = pCreateTable->colInfo.pTagColumns;
+  assert(pFieldList != NULL);
+
+  // if sql specifies db, use it, otherwise use default db
+  SToken* pzTableName = &(pCreateTable->name);
+
+  if (parserValidateNameToken(pzTableName) != TSDB_CODE_SUCCESS) {
+    return buildInvalidOperationMsg(pMsgBuf, msg1);
+  }
+
+  if (validateTableColumnInfo(pFieldList, pMsgBuf) != TSDB_CODE_SUCCESS ||
+      (pTagList != NULL && validateTagParams(pTagList, pFieldList, pMsgBuf) != TSDB_CODE_SUCCESS)) {
+    return TSDB_CODE_TSC_INVALID_OPERATION;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStmtInfo* pDcl, char* msgBuf, int32_t msgBufLen) {
   int32_t code = 0;
 
   SMsgBuf m = {.buf = msgBuf, .len = msgBufLen};
   SMsgBuf *pMsgBuf = &m;
 
-  *type = pInfo->type;
-
   switch (pInfo->type) {
     case TSDB_SQL_CREATE_USER:
     case TSDB_SQL_ALTER_USER: {
@@ -4224,7 +4357,8 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, int64_t id, void** output, in
         }
       }
 
-      *output = buildUserManipulationMsg(pInfo, outputLen, id, msgBuf, msgBufLen);
+      pDcl->pMsg = (char*)buildUserManipulationMsg(pInfo, &pDcl->msgLen, pCtx->requestId, msgBuf, msgBufLen);
+      pDcl->msgType = (pInfo->type == TSDB_SQL_CREATE_USER)? TSDB_MSG_TYPE_CREATE_USER:TSDB_MSG_TYPE_ALTER_USER;
       break;
     }
 
@@ -4260,18 +4394,44 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, int64_t id, void** output, in
         }
       }
 
-      *output = buildAcctManipulationMsg(pInfo, outputLen, id, msgBuf, msgBufLen);
+      pDcl->pMsg = (char*)buildAcctManipulationMsg(pInfo, &pDcl->msgLen, pCtx->requestId, msgBuf, msgBufLen);
+      pDcl->msgType = (pInfo->type == TSDB_SQL_CREATE_ACCT)? TSDB_MSG_TYPE_CREATE_ACCT:TSDB_MSG_TYPE_ALTER_ACCT;
       break;
     }
 
     case TSDB_SQL_DROP_ACCT:
     case TSDB_SQL_DROP_USER: {
-      *output = buildDropUserMsg(pInfo, outputLen, id, msgBuf, msgBufLen);
+      pDcl->pMsg = (char*)buildDropUserMsg(pInfo, &pDcl->msgLen, pCtx->requestId, msgBuf, msgBufLen);
+      pDcl->msgType = (pInfo->type == TSDB_SQL_DROP_ACCT)? TSDB_MSG_TYPE_DROP_ACCT:TSDB_MSG_TYPE_DROP_USER;
       break;
     }
     
     case TSDB_SQL_SHOW: {
-      code = setShowInfo(pInfo, output, outputLen, pMsgBuf);
+      code = setShowInfo(&pInfo->pMiscInfo->showOpt, pCtx, (void**)&pDcl->pMsg, &pDcl->msgLen, pMsgBuf);
+      pDcl->msgType = TSDB_MSG_TYPE_SHOW;
+      break;
+    }
+
+    case TSDB_SQL_USE_DB: {
+      const char* msg = "invalid db name";
+
+      SToken* pToken = taosArrayGet(pInfo->pMiscInfo->a, 0);
+      if (parserValidateNameToken(pToken) != TSDB_CODE_SUCCESS) {
+        return buildInvalidOperationMsg(pMsgBuf, msg);
+      }
+
+      SName n = {0};
+      int32_t ret = tNameSetDbName(&n, pCtx->acctId, pToken->z, pToken->n);
+      if (ret != TSDB_CODE_SUCCESS) {
+        return buildInvalidOperationMsg(pMsgBuf, msg);
+      }
+
+      SUseDbMsg *pUseDbMsg = (SUseDbMsg *) calloc(1, sizeof(SUseDbMsg));
+      tNameExtractFullName(&n, pUseDbMsg->db);
+
+      pDcl->pMsg = (char*)pUseDbMsg;
+      pDcl->msgLen = sizeof(SUseDbMsg);
+      pDcl->msgType = TSDB_MSG_TYPE_USE_DB;
       break;
     }
 
@@ -4292,15 +4452,73 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, int64_t id, void** output, in
         return buildInvalidOperationMsg(pMsgBuf, msg1);
       }
 
-      SCreateDbMsg* pCreateMsg = buildCreateDbMsg(pCreateDB, pMsgBuf->buf, pMsgBuf->len);
+      SCreateDbMsg* pCreateMsg = buildCreateDbMsg(pCreateDB, pCtx, pMsgBuf);
       if (doCheckDbOptions(pCreateMsg, pMsgBuf) != TSDB_CODE_SUCCESS) {
         return TSDB_CODE_TSC_INVALID_OPERATION;
       }
 
       strncpy(pCreateMsg->db, token.z, token.n);
 
-      *output = pCreateMsg;
-      *outputLen = sizeof(SCreateDbMsg);
+      pDcl->pMsg = (char*)pCreateMsg;
+      pDcl->msgLen = sizeof(SCreateDbMsg);
+      pDcl->msgType = (pInfo->type == TSDB_SQL_CREATE_DB)? TSDB_MSG_TYPE_CREATE_DB:TSDB_MSG_TYPE_ALTER_DB;
+      break;
+    }
+
+    case TSDB_SQL_DROP_DB: {
+      const char* msg1 = "invalid database name";
+
+      assert(taosArrayGetSize(pInfo->pMiscInfo->a) == 1);
+      SToken* dbName = taosArrayGet(pInfo->pMiscInfo->a, 0);
+
+      SName name = {0};
+      code = tNameSetDbName(&name, pCtx->acctId, dbName->z, dbName->n);
+      if (code != TSDB_CODE_SUCCESS) {
+        return buildInvalidOperationMsg(pMsgBuf, msg1);
+      }
+
+      SDropDbMsg *pDropDbMsg = (SDropDbMsg*) calloc(1, sizeof(SDropDbMsg));
+
+      code = tNameExtractFullName(&name, pDropDbMsg->db);
+      pDropDbMsg->ignoreNotExists = pInfo->pMiscInfo->existsCheck ? 1 : 0;
+      assert(code == TSDB_CODE_SUCCESS && name.type == TSDB_DB_NAME_T);
+
+      pDcl->msgType = TSDB_MSG_TYPE_DROP_DB;
+      pDcl->msgLen = sizeof(SDropDbMsg);
+      pDcl->pMsg = (char*)pDropDbMsg;
+      return TSDB_CODE_SUCCESS;
+    }
+
+    case TSDB_SQL_CREATE_TABLE: {
+      SCreateTableSql* pCreateTable = pInfo->pCreateTableInfo;
+
+      if (pCreateTable->type == TSQL_CREATE_TABLE || pCreateTable->type == TSQL_CREATE_STABLE) {
+        if ((code = doCheckForCreateTable(pInfo, pMsgBuf)) != TSDB_CODE_SUCCESS) {
+          return code;
+        }
+        pDcl->pMsg = (char*)buildCreateTableMsg(pCreateTable, &pDcl->msgLen, pCtx, pMsgBuf);
+        pDcl->msgType = (pCreateTable->type == TSQL_CREATE_TABLE)? TSDB_MSG_TYPE_CREATE_TABLE:TSDB_MSG_TYPE_CREATE_STB;
+      } else if (pCreateTable->type == TSQL_CREATE_CTABLE) {
+        //        if ((code = doCheckForCreateFromStable(pSql, pInfo)) != TSDB_CODE_SUCCESS) {
+        //          return code;
+        //        }
+
+      } else if (pCreateTable->type == TSQL_CREATE_STREAM) {
+        //        if ((code = doCheckForStream(pSql, pInfo)) != TSDB_CODE_SUCCESS) {
+        //          return code;
+      }
+
+      break;
+    }
+
+    case TSDB_SQL_DROP_TABLE: {
+      pDcl->pMsg = (char*)buildDropTableMsg(pInfo, &pDcl->msgLen, pCtx, pMsgBuf);
+      if (pDcl->pMsg == NULL) {
+        return terrno;
+      }
+
+      pDcl->msgType = TSDB_MSG_TYPE_DROP_STB;
+      return TSDB_CODE_SUCCESS;
       break;
     }
 

source/libs/parser/src/dataBlockMgt.c

@@ -123,7 +123,6 @@ static int32_t createDataBlock(size_t defaultSize, int32_t rowSize, int32_t star
     dataBuf->nAllocSize = dataBuf->headerSize * 2;
   }
 
-  //dataBuf->pData = calloc(1, dataBuf->nAllocSize);
   dataBuf->pData = malloc(dataBuf->nAllocSize);
   if (dataBuf->pData == NULL) {
     tfree(dataBuf);
@@ -145,8 +144,6 @@ static int32_t createDataBlock(size_t defaultSize, int32_t rowSize, int32_t star
   dataBuf->tsSource = -1;
   dataBuf->vgId     = dataBuf->pTableMeta->vgId;
 
-  // tNameAssign(&dataBuf->tableName, name);
-
   assert(defaultSize > 0 && pTableMeta != NULL && dataBuf->pTableMeta != NULL);
 
   *dataBlocks = dataBuf;

source/libs/parser/src/insertParser.c

@@ -50,15 +50,16 @@ enum {
 };
 
 typedef struct SInsertParseContext {
-  SParseContext* pComCxt;
-  const char* pSql;
-  SMsgBuf msg;
-  STableMeta* pTableMeta;
-  SParsedDataColInfo tags;
-  SKVRowBuilder tagsBuilder;
-  SHashObj* pTableBlockHashObj;
-  SArray* pTableDataBlocks;
-  SArray* pVgDataBlocks;
+  SParseContext* pComCxt;       // input
+  const char* pSql;             // input
+  SMsgBuf msg;                  // input
+  STableMeta* pTableMeta;       // each table
+  SParsedDataColInfo tags;      // each table
+  SKVRowBuilder tagsBuilder;    // each table
+  SHashObj* pVgroupsHashObj;    // global
+  SHashObj* pTableBlockHashObj; // global
+  SArray* pTableDataBlocks;     // global
+  SArray* pVgDataBlocks;        // global
   int32_t totalNum;
   SInsertStmtInfo* pOutput;
 } SInsertParseContext;
@@ -157,14 +158,14 @@ static int32_t buildName(SInsertParseContext* pCxt, SToken* pStname, char* fullD
 
   char* p = strnchr(pStname->z, TS_PATH_DELIMITER[0], pStname->n, false);
   if (NULL != p) { // db.table
-    strcpy(fullDbName, pCxt->pComCxt->pAcctId);
-    fullDbName[strlen(pCxt->pComCxt->pAcctId)] = TS_PATH_DELIMITER[0];
-    strncpy(fullDbName, pStname->z, p - pStname->z);
+    int32_t n = sprintf(fullDbName, "%d.", pCxt->pComCxt->ctx.acctId);
+    strncpy(fullDbName + n, pStname->z, p - pStname->z);
     strncpy(tableName, p + 1, pStname->n - (p - pStname->z) - 1);
   } else {
-    snprintf(fullDbName, TSDB_FULL_DB_NAME_LEN, "%s.%s", pCxt->pComCxt->pAcctId, pCxt->pComCxt->pDbname);
+    snprintf(fullDbName, TSDB_FULL_DB_NAME_LEN, "%d.%s", pCxt->pComCxt->ctx.acctId, pCxt->pComCxt->ctx.db);
     strncpy(tableName, pStname->z, pStname->n);
   }
+
   return TSDB_CODE_SUCCESS;
 }
 
@@ -173,10 +174,12 @@ static int32_t getTableMeta(SInsertParseContext* pCxt, SToken* pTname) {
   char tableName[TSDB_TABLE_NAME_LEN] = {0};
   CHECK_CODE(buildName(pCxt, pTname, fullDbName, tableName));
   CHECK_CODE(catalogGetTableMeta(pCxt->pComCxt->pCatalog, pCxt->pComCxt->pRpc, pCxt->pComCxt->pEpSet, fullDbName, tableName, &pCxt->pTableMeta));
+  SVgroupInfo vg;
+  CHECK_CODE(catalogGetTableHashVgroup(pCxt->pComCxt->pCatalog, pCxt->pComCxt->pRpc, pCxt->pComCxt->pEpSet, fullDbName, tableName, &vg));
+  CHECK_CODE(taosHashPut(pCxt->pVgroupsHashObj, (const char*)&vg.vgId, sizeof(vg.vgId), (char*)&vg, sizeof(vg)));
   return TSDB_CODE_SUCCESS;
 }
 
-// todo speedup by using hash list
 static int32_t findCol(SToken* pColname, int32_t start, int32_t end, SSchema* pSchema) {
   while (start < end) {
     if (strlen(pSchema[start].name) == pColname->n && strncmp(pColname->z, pSchema[start].name, pColname->n) == 0) {
@@ -187,16 +190,16 @@ static int32_t findCol(SToken* pColname, int32_t start, int32_t end, SSchema* pS
   return -1;
 }
 
-static void fillMsgHeader(SVgDataBlocks* dst) {
-    SMsgDesc* desc = (SMsgDesc*)dst->pData;
+static void buildMsgHeader(SVgDataBlocks* blocks) {
+    SMsgDesc* desc = (SMsgDesc*)blocks->pData;
     desc->numOfVnodes = htonl(1);
     SSubmitMsg* submit = (SSubmitMsg*)(desc + 1);
-    submit->header.vgId    = htonl(dst->vgId);
-    submit->header.contLen = htonl(dst->size - sizeof(SMsgDesc));
+    submit->header.vgId    = htonl(blocks->vg.vgId);
+    submit->header.contLen = htonl(blocks->size - sizeof(SMsgDesc));
     submit->length         = submit->header.contLen;
-    submit->numOfBlocks    = htonl(dst->numOfTables);
+    submit->numOfBlocks    = htonl(blocks->numOfTables);
     SSubmitBlk* blk = (SSubmitBlk*)(submit + 1);
-    int32_t numOfBlocks = dst->numOfTables;
+    int32_t numOfBlocks = blocks->numOfTables;
     while (numOfBlocks--) {
       int32_t dataLen = blk->dataLen;
       blk->uid = htobe64(blk->uid);
@@ -222,11 +225,11 @@ static int32_t buildOutput(SInsertParseContext* pCxt) {
     if (NULL == dst) {
       return TSDB_CODE_TSC_OUT_OF_MEMORY;
     }
-    dst->vgId = src->vgId;
+    taosHashGetClone(pCxt->pVgroupsHashObj, (const char*)&src->vgId, sizeof(src->vgId), &dst->vg);
     dst->numOfTables = src->numOfTables;
     dst->size = src->size;
     SWAP(dst->pData, src->pData, char*);
-    fillMsgHeader(dst);
+    buildMsgHeader(dst);
     taosArrayPush(pCxt->pOutput->pDataBlocks, &dst);
   }
   return TSDB_CODE_SUCCESS;
@@ -546,7 +549,7 @@ static FORCE_INLINE int32_t parseOneValue(SInsertParseContext* pCxt, SToken* pTo
     }
     case TSDB_DATA_TYPE_BINARY: {
       // too long values will return invalid sql, not be truncated automatically
-      if (pToken->n + VARSTR_HEADER_SIZE > pSchema->bytes) {  // todo refactor
+      if (pToken->n + VARSTR_HEADER_SIZE > pSchema->bytes) {
         return buildSyntaxErrMsg(&pCxt->msg, "string data overflow", pToken->z);
       }
       return func(pToken->z, pToken->n, param);
@@ -644,9 +647,7 @@ static int32_t parseTagsClause(SInsertParseContext* pCxt, SSchema* pTagsSchema,
     CHECK_CODE(parseOneValue(pCxt, &sToken, pSchema, precision, tmpTokenBuf, KvRowAppend, &param));
   }
 
-  destroyBoundColumnInfo(&pCxt->tags);
   SKVRow row = tdGetKVRowFromBuilder(&pCxt->tagsBuilder);
-  tdDestroyKVRowBuilder(&pCxt->tagsBuilder);
   if (NULL == row) {
     return buildInvalidOperationMsg(&pCxt->msg, "tag value expected");
   }
@@ -799,13 +800,30 @@ static int32_t parseValuesClause(SInsertParseContext* pCxt, STableDataBlocks* da
   return TSDB_CODE_SUCCESS;
 }
 
+static void destroyInsertParseContextForTable(SInsertParseContext* pCxt) {
+  tfree(pCxt->pTableMeta);
+  destroyBoundColumnInfo(&pCxt->tags);
+  tdDestroyKVRowBuilder(&pCxt->tagsBuilder);
+}
+
+static void destroyInsertParseContext(SInsertParseContext* pCxt) {
+  destroyInsertParseContextForTable(pCxt);
+  taosHashCleanup(pCxt->pVgroupsHashObj);
+  taosHashCleanup(pCxt->pTableBlockHashObj);
+  destroyBlockArrayList(pCxt->pTableDataBlocks);
+  destroyBlockArrayList(pCxt->pVgDataBlocks);
+}
+
 //   tb_name
 //       [USING stb_name [(tag1_name, ...)] TAGS (tag1_value, ...)]
 //       [(field1_name, ...)]
 //       VALUES (field1_value, ...) [(field1_value2, ...) ...] | FILE csv_file_path
 //   [...];
 static int32_t parseInsertBody(SInsertParseContext* pCxt) {
+  // for each table
   while (1) {
+    destroyInsertParseContextForTable(pCxt);
+
     SToken sToken;
     // pSql -> tb_name ...
     NEXT_TOKEN(pCxt->pSql, sToken);
@@ -867,15 +885,6 @@ static int32_t parseInsertBody(SInsertParseContext* pCxt) {
   return buildOutput(pCxt);
 }
 
-static void destroyInsertParseContext(SInsertParseContext* pCxt) {
-  tfree(pCxt->pTableMeta);
-  destroyBoundColumnInfo(&pCxt->tags);
-  tdDestroyKVRowBuilder(&pCxt->tagsBuilder);
-  taosHashCleanup(pCxt->pTableBlockHashObj);
-  destroyBlockArrayList(pCxt->pTableDataBlocks);
-  destroyBlockArrayList(pCxt->pVgDataBlocks);
-}
-
 // INSERT INTO
 //   tb_name
 //       [USING stb_name [(tag1_name, ...)] TAGS (tag1_value, ...)]
@@ -888,17 +897,19 @@ int32_t parseInsertSql(SParseContext* pContext, SInsertStmtInfo** pInfo) {
     .pSql = pContext->pSql,
     .msg = {.buf = pContext->pMsg, .len = pContext->msgLen},
     .pTableMeta = NULL,
+    .pVgroupsHashObj = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, false),
     .pTableBlockHashObj = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false),
     .totalNum = 0,
     .pOutput = calloc(1, sizeof(SInsertStmtInfo))
   };
 
-  if (NULL == context.pTableBlockHashObj || NULL == context.pOutput) {
+  if (NULL == context.pVgroupsHashObj || NULL == context.pTableBlockHashObj || NULL == context.pOutput) {
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
     return TSDB_CODE_FAILED;
   }
 
   *pInfo = context.pOutput;
+  context.pOutput->nodeType = TSDB_SQL_INSERT;
   context.pOutput->schemaAttache = pContext->schemaAttached;
   context.pOutput->payloadType = PAYLOAD_TYPE_KV;
 

source/libs/parser/src/parser.c

@@ -20,7 +20,7 @@
 #include "function.h"
 #include "insertParser.h"
 
-bool qIsInsertSql(const char* pStr, size_t length) {
+bool isInsertSql(const char* pStr, size_t length) {
   int32_t index = 0;
 
   do {
@@ -31,18 +31,28 @@ bool qIsInsertSql(const char* pStr, size_t length) {
   } while (1);
 }
 
-int32_t qParseQuerySql(const char* pStr, size_t length, int64_t id, int32_t *type, void** pOutput, int32_t* outputLen, char* msg, int32_t msgLen) {
-  SSqlInfo info = doGenerateAST(pStr);
+bool qIsDclQuery(const SQueryNode* pQuery) {
+  return TSDB_SQL_INSERT != pQuery->type && TSDB_SQL_SELECT != pQuery->type;
+}
+
+int32_t parseQuerySql(SParseContext* pCxt, SQueryNode** pQuery) {
+  SSqlInfo info = doGenerateAST(pCxt->pSql);
   if (!info.valid) {
-    strncpy(msg, info.msg, msgLen);
+    strncpy(pCxt->pMsg, info.msg, pCxt->msgLen);
     terrno = TSDB_CODE_TSC_SQL_SYNTAX_ERROR;
     return terrno;
   }
 
-  if (isDclSqlStatement(&info)) {
-    int32_t code = qParserValidateDclSqlNode(&info, id, pOutput, outputLen, type, msg, msgLen);
+  if (!isDqlSqlStatement(&info)) {
+    SDclStmtInfo* pDcl = calloc(1, sizeof(SQueryStmtInfo));
+    if (NULL == pDcl) {
+      terrno = TSDB_CODE_TSC_OUT_OF_MEMORY; // set correct error code.
+      return terrno;
+    }
+    pDcl->nodeType = info.type;
+    int32_t code = qParserValidateDclSqlNode(&info, &pCxt->ctx, pDcl, pCxt->pMsg, pCxt->msgLen);
     if (code == TSDB_CODE_SUCCESS) {
-      // do nothing
+      *pQuery = (SQueryNode*)pDcl;
     }
   } else {
     SQueryStmtInfo* pQueryInfo = calloc(1, sizeof(SQueryStmtInfo));
@@ -53,9 +63,9 @@ int32_t qParseQuerySql(const char* pStr, size_t length, int64_t id, int32_t *typ
 
     struct SCatalog* pCatalog = NULL;
     int32_t code = catalogGetHandle(NULL, &pCatalog);
-    code = qParserValidateSqlNode(pCatalog, &info, pQueryInfo, id, msg, msgLen);
+    code = qParserValidateSqlNode(pCatalog, &info, pQueryInfo, pCxt->ctx.requestId, pCxt->pMsg, pCxt->msgLen);
     if (code == TSDB_CODE_SUCCESS) {
-      *pOutput = pQueryInfo;
+      *pQuery = (SQueryNode*)pQueryInfo;
     }
   }
 
@@ -63,8 +73,12 @@ int32_t qParseQuerySql(const char* pStr, size_t length, int64_t id, int32_t *typ
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t qParseInsertSql(SParseContext* pContext, SInsertStmtInfo** pInfo) {
-  return parseInsertSql(pContext, pInfo);
+int32_t qParseQuerySql(SParseContext* pCxt, SQueryNode** pQuery) {
+  if (isInsertSql(pCxt->pSql, pCxt->sqlLen)) {
+    return parseInsertSql(pCxt, (SInsertStmtInfo**)pQuery);
+  } else {
+    return parseQuerySql(pCxt, pQuery);
+  }
 }
 
 int32_t qParserConvertSql(const char* pStr, size_t length, char** pConvertSql) {

source/libs/parser/src/parserUtil.c

@@ -1167,7 +1167,7 @@ void cleanupTagCond(STagCond* pTagCond) {
  * @param tableIndex  denote the table index for join query, where more than one table exists
  * @return
  */
-STableMetaInfo* getMetaInfo(SQueryStmtInfo* pQueryInfo, int32_t tableIndex) {
+STableMetaInfo* getMetaInfo(const SQueryStmtInfo* pQueryInfo, int32_t tableIndex) {
   assert(pQueryInfo != NULL);
   if (pQueryInfo->pTableMetaInfo == NULL) {
     assert(pQueryInfo->numOfTables == 0);
@@ -1613,7 +1613,18 @@ uint32_t convertRelationalOperator(SToken *pToken) {
 }
 
 bool isDclSqlStatement(SSqlInfo* pSqlInfo) {
-  return (pSqlInfo->type != TSDB_SQL_SELECT);
+  int32_t type = pSqlInfo->type;
+  return (type == TSDB_SQL_CREATE_USER || type == TSDB_SQL_CREATE_ACCT || type == TSDB_SQL_DROP_USER ||
+          type == TSDB_SQL_DROP_ACCT || type == TSDB_SQL_SHOW);
+}
+
+bool isDdlSqlStatement(SSqlInfo* pSqlInfo) {
+  int32_t type = pSqlInfo->type;
+  return (type == TSDB_SQL_CREATE_TABLE || type == TSDB_SQL_CREATE_DB || type == TSDB_SQL_DROP_DB);
+}
+
+bool isDqlSqlStatement(SSqlInfo* pSqlInfo) {
+  return pSqlInfo->type == TSDB_SQL_SELECT;
 }
 
 #if 0

source/libs/parser/src/queryInfoUtil.c

@@ -354,7 +354,7 @@ bool tscHasColumnFilter(SQueryStmtInfo* pQueryInfo) {
   return false;
 }
 
-int32_t getExprFunctionLevel(SQueryStmtInfo* pQueryInfo) {
+int32_t getExprFunctionLevel(const SQueryStmtInfo* pQueryInfo) {
   int32_t n = 10;
 
   int32_t level = 0;

source/libs/parser/src/ttokenizer.c

@@ -217,7 +217,7 @@ static SKeyword keywordTable[] = {
     {"UNION",        TK_UNION},
     {"CACHELAST",    TK_CACHELAST},
     {"DISTINCT",     TK_DISTINCT},
-    {"PARTITIONS",   TK_PARTITIONS},
+//    {"PARTITIONS",   TK_PARTITIONS},
     {"TOPIC",        TK_TOPIC},
     {"TOPICS",       TK_TOPICS},
     {"COMPACT",      TK_COMPACT},

source/libs/parser/test/insertParserTest.cpp

@@ -43,8 +43,8 @@ protected:
 
   void bind(const char* sql) {
     reset();
-    cxt_.pAcctId = acctId_.c_str();
-    cxt_.pDbname = db_.c_str();
+    cxt_.ctx.acctId = atoi(acctId_.c_str());
+    cxt_.ctx.db = (char*) db_.c_str();
     strcpy(sqlBuf_, sql);
     cxt_.sqlLen = strlen(sql);
     sqlBuf_[cxt_.sqlLen] = '\0';
@@ -69,7 +69,7 @@ protected:
     cout << "schemaAttache:" << (int32_t)res_->schemaAttache << ", payloadType:" << (int32_t)res_->payloadType << ", insertType:" << res_->insertType << ", numOfVgs:" << num << endl;    
     for (size_t i = 0; i < num; ++i) {
       SVgDataBlocks* vg = (SVgDataBlocks*)taosArrayGetP(res_->pDataBlocks, i);
-      cout << "vgId:" << vg->vgId << ", numOfTables:" << vg->numOfTables << ", dataSize:" << vg->size << endl;
+      cout << "vgId:" << vg->vg.vgId << ", numOfTables:" << vg->numOfTables << ", dataSize:" << vg->size << endl;
       SMsgDesc* desc = (SMsgDesc*)(vg->pData);
       cout << "numOfVnodes:" << ntohl(desc->numOfVnodes) << endl;
       SSubmitMsg* submit = (SSubmitMsg*)(desc + 1);

source/libs/parser/test/mockCatalog.cpp

@@ -23,30 +23,34 @@
 namespace {
 
 void generateTestT1(MockCatalogService* mcs) {
-  ITableBuilder& builder = mcs->createTableBuilder("root.test", "t1", TSDB_NORMAL_TABLE, 3)
+  ITableBuilder& builder = mcs->createTableBuilder("test", "t1", TSDB_NORMAL_TABLE, 3)
       .setPrecision(TSDB_TIME_PRECISION_MILLI).setVgid(1).addColumn("ts", TSDB_DATA_TYPE_TIMESTAMP)
       .addColumn("c1", TSDB_DATA_TYPE_INT).addColumn("c2", TSDB_DATA_TYPE_BINARY, 20);
   builder.done();
 }
 
 void generateTestST1(MockCatalogService* mcs) {
-  ITableBuilder& builder = mcs->createTableBuilder("root.test", "st1", TSDB_SUPER_TABLE, 3, 2)
+  ITableBuilder& builder = mcs->createTableBuilder("test", "st1", TSDB_SUPER_TABLE, 3, 2)
       .setPrecision(TSDB_TIME_PRECISION_MILLI).addColumn("ts", TSDB_DATA_TYPE_TIMESTAMP)
       .addTag("tag1", TSDB_DATA_TYPE_INT).addTag("tag2", TSDB_DATA_TYPE_BINARY, 20)
       .addColumn("c1", TSDB_DATA_TYPE_INT).addColumn("c2", TSDB_DATA_TYPE_BINARY, 20);
   builder.done();
-  mcs->createSubTable("root.test", "st1", "st1s1", 1);
-  mcs->createSubTable("root.test", "st1", "st1s2", 2);
+  mcs->createSubTable("test", "st1", "st1s1", 1);
+  mcs->createSubTable("test", "st1", "st1s2", 2);
 }
 
 }
 
 int32_t __catalogGetHandle(const char *clusterId, struct SCatalog** catalogHandle) {
-  return mockCatalogService->catalogGetHandle(clusterId, catalogHandle);
+  return 0;
 }
 
 int32_t __catalogGetTableMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName, STableMeta** pTableMeta) {
-  return mockCatalogService->catalogGetTableMeta(pCatalog, pRpc, pMgmtEps, pDBName, pTableName, pTableMeta);
+  return mockCatalogService->catalogGetTableMeta(pDBName, pTableName, pTableMeta);
+}
+
+int32_t __catalogGetTableHashVgroup(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName, SVgroupInfo* vgInfo) {
+  return mockCatalogService->catalogGetTableHashVgroup(pDBName, pTableName, vgInfo);
 }
 
 void initMetaDataEnv() {
@@ -55,6 +59,7 @@ void initMetaDataEnv() {
   static Stub stub;
   stub.set(catalogGetHandle, __catalogGetHandle);
   stub.set(catalogGetTableMeta, __catalogGetTableMeta);
+  stub.set(catalogGetTableHashVgroup, __catalogGetTableHashVgroup);
   {
     AddrAny any("libcatalog.so");
     std::map<std::string,void*> result;
@@ -71,6 +76,14 @@ void initMetaDataEnv() {
       stub.set(f.second, __catalogGetTableMeta);
     }
   }
+  {
+    AddrAny any("libcatalog.so");
+    std::map<std::string,void*> result;
+    any.get_global_func_addr_dynsym("^catalogGetTableHashVgroup$", result);
+    for (const auto& f : result) {
+      stub.set(f.second, __catalogGetTableHashVgroup);
+    }
+  }
 }
 
 void generateMetaData() {

source/libs/parser/test/mockCatalogService.cpp

@@ -90,13 +90,13 @@ public:
   MockCatalogServiceImpl() : id_(1) {
   }
 
-  int32_t catalogGetHandle(const char *clusterId, struct SCatalog** catalogHandle) const {
+  int32_t catalogGetHandle() const {
     return 0;
   }
 
-  int32_t catalogGetTableMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName, STableMeta** pTableMeta) const {
+  int32_t catalogGetTableMeta(const char* pDbFullName, const char* pTableName, STableMeta** pTableMeta) const {
     std::unique_ptr<STableMeta> table;
-    int32_t code = copyTableSchemaMeta(pDBName, pTableName, &table);
+    int32_t code = copyTableSchemaMeta(toDbname(pDbFullName), pTableName, &table);
     if (TSDB_CODE_SUCCESS != code) {
       return code;
     }
@@ -104,6 +104,11 @@ public:
     return TSDB_CODE_SUCCESS;
   }
 
+  int32_t catalogGetTableHashVgroup(const char* pDbFullName, const char* pTableName, SVgroupInfo* vgInfo) const {
+    // todo
+    return 0;
+  }
+
   TableBuilder& createTableBuilder(const std::string& db, const std::string& tbname, int8_t tableType, int32_t numOfColumns, int32_t numOfTags) {
     builder_ = TableBuilder::createTableBuilder(tableType, numOfColumns, numOfTags);
     meta_[db][tbname] = builder_->table();
@@ -190,6 +195,14 @@ private:
   typedef std::map<std::string, std::shared_ptr<MockTableMeta>> TableMetaCache;
   typedef std::map<std::string, TableMetaCache> DbMetaCache;
 
+  std::string toDbname(const std::string& dbFullName) const {
+    std::string::size_type n = dbFullName.find(".");
+    if (n == std::string::npos) {
+      return dbFullName;
+    }
+    return dbFullName.substr(n + 1);
+  }
+
   std::string ttToString(int8_t tableType) const {
     switch (tableType) {
       case TSDB_SUPER_TABLE:
@@ -270,10 +283,10 @@ std::shared_ptr<MockTableMeta> MockCatalogService::getTableMeta(const std::strin
   return impl_->getTableMeta(db, tbname);
 }
 
-int32_t MockCatalogService::catalogGetHandle(const char *clusterId, struct SCatalog** catalogHandle) const {
-  return impl_->catalogGetHandle(clusterId, catalogHandle);
+int32_t MockCatalogService::catalogGetTableMeta(const char* pDBName, const char* pTableName, STableMeta** pTableMeta) const {
+  return impl_->catalogGetTableMeta(pDBName, pTableName, pTableMeta);
 }
 
-int32_t MockCatalogService::catalogGetTableMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName, STableMeta** pTableMeta) const {
-  return impl_->catalogGetTableMeta(pCatalog, pRpc, pMgmtEps, pDBName, pTableName, pTableMeta);
+int32_t MockCatalogService::catalogGetTableHashVgroup(const char* pDBName, const char* pTableName, SVgroupInfo* vgInfo) const {
+  return impl_->catalogGetTableHashVgroup(pDBName, pTableName, vgInfo);
 }

source/libs/parser/test/mockCatalogService.h

@@ -57,9 +57,8 @@ public:
   void showTables() const;
   std::shared_ptr<MockTableMeta> getTableMeta(const std::string& db, const std::string& tbname) const;
 
-  // mock interface
-  int32_t catalogGetHandle(const char *clusterId, struct SCatalog** catalogHandle) const;
-  int32_t catalogGetTableMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName, STableMeta** pTableMeta) const;
+  int32_t catalogGetTableMeta(const char* pDBName, const char* pTableName, STableMeta** pTableMeta) const;
+  int32_t catalogGetTableHashVgroup(const char* pDBName, const char* pTableName, SVgroupInfo* vgInfo) const;
 
 private:
   std::unique_ptr<MockCatalogServiceImpl> impl_;

source/libs/parser/test/parserTests.cpp

@@ -714,10 +714,9 @@ TEST(testCase, show_user_Test) {
   SSqlInfo info1 = doGenerateAST(sql1);
   ASSERT_EQ(info1.valid, true);
 
-  void* output = NULL;
-  int32_t type = 0;
-  int32_t len = 0;
-  int32_t code = qParserValidateDclSqlNode(&info1, 1, &output, &len, &type, msg, buf.len);
+  SDclStmtInfo output;
+  SParseBasicCtx ct= {.db= "abc", .acctId = 1, .requestId = 1};
+  int32_t code = qParserValidateDclSqlNode(&info1, &ct, &output, msg, buf.len);
   ASSERT_EQ(code, 0);
 
   // convert the show command to be the select query
@@ -734,13 +733,11 @@ TEST(testCase, create_user_Test) {
 
   SSqlInfo info1 = doGenerateAST(sql);
   ASSERT_EQ(info1.valid, true);
-
   ASSERT_EQ(isDclSqlStatement(&info1), true);
 
-  void* output = NULL;
-  int32_t type = 0;
-  int32_t len = 0;
-  int32_t code = qParserValidateDclSqlNode(&info1, 1, &output, &len, &type, msg, buf.len);
+  SDclStmtInfo output;
+  SParseBasicCtx ct= {.db= "abc", .acctId = 1, .requestId = 1};
+  int32_t code = qParserValidateDclSqlNode(&info1, &ct, &output, msg, buf.len);
   ASSERT_EQ(code, 0);
 
   destroySqlInfo(&info1);

source/libs/parser/test/plannerTest.cpp

@@ -93,7 +93,7 @@ void generateLogicplan(const char* sql) {
   ASSERT_EQ(ret, 0);
 
   struct SQueryPlanNode* n = nullptr;
-  code = createQueryPlan(pQueryInfo, &n);
+  code = createQueryPlan((const SQueryNode*)pQueryInfo, &n);
 
   char* str = NULL;
   queryPlanToString(n, &str);
@@ -156,7 +156,7 @@ TEST(testCase, planner_test) {
   ASSERT_EQ(pQueryInfo->fieldsInfo.numOfOutput, 2);
 
   struct SQueryPlanNode* n = nullptr;
-  code = createQueryPlan(pQueryInfo, &n);
+  code = createQueryPlan((const SQueryNode*)pQueryInfo, &n);
 
   char* str = NULL;
   queryPlanToString(n, &str);

source/libs/planner/inc/plannerInt.h

@@ -40,6 +40,7 @@ extern "C" {
 #define QNODE_SESSIONWINDOW 12
 #define QNODE_STATEWINDOW   13
 #define QNODE_FILL          14
+#define QNODE_INSERT        15
 
 typedef struct SQueryDistPlanNodeInfo {
   bool      stableQuery;   // super table query or not
@@ -82,7 +83,7 @@ int32_t optimizeQueryPlan(struct SQueryPlanNode* pQueryNode);
  * @param pQueryNode
  * @return
  */
-int32_t createQueryPlan(const struct SQueryStmtInfo* pQueryInfo, struct SQueryPlanNode** pQueryNode);
+int32_t createQueryPlan(const SQueryNode* pNode, struct SQueryPlanNode** pQueryPlan);
 
 /**
  * Convert the query plan to string, in order to display it in the shell.
@@ -101,7 +102,7 @@ int32_t queryPlanToSql(struct SQueryPlanNode* pQueryNode, char** sql);
 
 int32_t createDag(SQueryPlanNode* pQueryNode, struct SCatalog* pCatalog, SQueryDag** pDag);
 int32_t setSubplanExecutionNode(SSubplan* subplan, uint64_t templateId, SEpAddr* ep);
-int32_t subPlanToString(const SSubplan *pPhyNode, char** str);
+int32_t subPlanToString(const SSubplan *pPhyNode, char** str, int32_t* len);
 int32_t stringToSubplan(const char* str, SSubplan** subplan);
 
 /**
@@ -120,6 +121,9 @@ void* destroyQueryPhyPlan(struct SPhyNode* pQueryPhyNode);
 const char* opTypeToOpName(int32_t type);
 int32_t opNameToOpType(const char* name);
 
+const char* dsinkTypeToDsinkName(int32_t type);
+int32_t dsinkNameToDsinkType(const char* name);
+
 #ifdef __cplusplus
 }
 #endif

source/libs/planner/src/logicPlan.c

@@ -29,7 +29,7 @@ typedef struct SJoinCond {
   SColumn *colCond[2];
 } SJoinCond;
 
-static SArray* createQueryPlanImpl(SQueryStmtInfo* pQueryInfo);
+static SArray* createQueryPlanImpl(const SQueryStmtInfo* pQueryInfo);
 static void doDestroyQueryNode(SQueryPlanNode* pQueryNode);
 
 int32_t printExprInfo(char* buf, const SQueryPlanNode* pQueryNode, int32_t len);
@@ -37,16 +37,40 @@ int32_t optimizeQueryPlan(struct SQueryPlanNode* pQueryNode) {
   return 0;
 }
 
-int32_t createQueryPlan(const struct SQueryStmtInfo* pQueryInfo, struct SQueryPlanNode** pQueryNode) {
-  SArray* upstream = createQueryPlanImpl((struct SQueryStmtInfo*) pQueryInfo);
+int32_t createInsertPlan(const SInsertStmtInfo* pInsert, SQueryPlanNode** pQueryPlan) {
+  *pQueryPlan = calloc(1, sizeof(SQueryPlanNode));
+  SArray* blocks = taosArrayInit(taosArrayGetSize(pInsert->pDataBlocks), POINTER_BYTES);
+  if (NULL == *pQueryPlan || NULL == blocks) {
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+  (*pQueryPlan)->info.type = QNODE_INSERT;
+  taosArrayAddAll(blocks, pInsert->pDataBlocks);
+  (*pQueryPlan)->pExtInfo = blocks;
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t createSelectPlan(const SQueryStmtInfo* pSelect, SQueryPlanNode** pQueryPlan) {
+  SArray* upstream = createQueryPlanImpl(pSelect);
   assert(taosArrayGetSize(upstream) == 1);
-
-  *pQueryNode = taosArrayGetP(upstream, 0);
-
+  *pQueryPlan = taosArrayGetP(upstream, 0);
   taosArrayDestroy(upstream);
   return TSDB_CODE_SUCCESS;
 }
 
+int32_t createQueryPlan(const SQueryNode* pNode, SQueryPlanNode** pQueryPlan) {
+  switch (nodeType(pNode)) {
+    case TSDB_SQL_SELECT: {
+      return createSelectPlan((const SQueryStmtInfo*)pNode, pQueryPlan);
+    }
+    case TSDB_SQL_INSERT:
+      return createInsertPlan((const SInsertStmtInfo*)pNode, pQueryPlan);
+    default:
+      return TSDB_CODE_FAILED;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
 int32_t queryPlanToSql(struct SQueryPlanNode* pQueryNode, char** sql) {
   return 0;
 }
@@ -62,7 +86,7 @@ void destroyQueryPlan(SQueryPlanNode* pQueryNode) {
 //======================================================================================================================
 
 static SQueryPlanNode* createQueryNode(int32_t type, const char* name, SQueryPlanNode** prev, int32_t numOfPrev,
-                                   SExprInfo** pExpr, int32_t numOfOutput, void* pExtInfo) {
+                                   SExprInfo** pExpr, int32_t numOfOutput, const void* pExtInfo) {
   SQueryPlanNode* pNode = calloc(1, sizeof(SQueryPlanNode));
 
   pNode->info.type = type;
@@ -123,7 +147,7 @@ static SQueryPlanNode* createQueryNode(int32_t type, const char* name, SQueryPla
     }
 
     case QNODE_FILL: { // todo !!
-      pNode->pExtInfo = pExtInfo;
+      pNode->pExtInfo = (void*)pExtInfo;
       break;
     }
 
@@ -145,7 +169,7 @@ static SQueryPlanNode* createQueryNode(int32_t type, const char* name, SQueryPla
   return pNode;
 }
 
-static SQueryPlanNode* doAddTableColumnNode(SQueryStmtInfo* pQueryInfo, STableMetaInfo* pTableMetaInfo, SQueryTableInfo* info,
+static SQueryPlanNode* doAddTableColumnNode(const SQueryStmtInfo* pQueryInfo, STableMetaInfo* pTableMetaInfo, SQueryTableInfo* info,
                                         SArray* pExprs, SArray* tableCols) {
   if (pQueryInfo->info.onlyTagQuery) {
     int32_t num = (int32_t) taosArrayGetSize(pExprs);
@@ -186,7 +210,7 @@ static SQueryPlanNode* doAddTableColumnNode(SQueryStmtInfo* pQueryInfo, STableMe
   return pNode;
 }
 
-static SQueryPlanNode* doCreateQueryPlanForSingleTableImpl(SQueryStmtInfo* pQueryInfo, SQueryPlanNode* pNode, SQueryTableInfo* info) {
+static SQueryPlanNode* doCreateQueryPlanForSingleTableImpl(const SQueryStmtInfo* pQueryInfo, SQueryPlanNode* pNode, SQueryTableInfo* info) {
   // group by column not by tag
   size_t numOfGroupCols = taosArrayGetSize(pQueryInfo->groupbyExpr.columnInfo);
 
@@ -239,7 +263,7 @@ static SQueryPlanNode* doCreateQueryPlanForSingleTableImpl(SQueryStmtInfo* pQuer
     memcpy(pInfo->val, pQueryInfo->fillVal, pNode->numOfExpr);
 
     SArray* p = pQueryInfo->exprList[0];  // top expression in select clause
-    pNode = createQueryNode(QNODE_FILL, "Fill", &pNode, 1, p, taosArrayGetSize(p), pInfo);
+    pNode = createQueryNode(QNODE_FILL, "Fill", &pNode, 1, p->pData, taosArrayGetSize(p), pInfo);
   }
 
   if (pQueryInfo->order != NULL) {
@@ -254,7 +278,7 @@ static SQueryPlanNode* doCreateQueryPlanForSingleTableImpl(SQueryStmtInfo* pQuer
   return pNode;
 }
 
-static SQueryPlanNode* doCreateQueryPlanForSingleTable(SQueryStmtInfo* pQueryInfo, STableMetaInfo* pTableMetaInfo, SArray* pExprs,
+static SQueryPlanNode* doCreateQueryPlanForSingleTable(const SQueryStmtInfo* pQueryInfo, STableMetaInfo* pTableMetaInfo, SArray* pExprs,
                                                 SArray* tableCols) {
   char name[TSDB_TABLE_FNAME_LEN] = {0};
   tstrncpy(name, pTableMetaInfo->name.tname, TSDB_TABLE_FNAME_LEN);
@@ -286,7 +310,7 @@ static bool isAllAggExpr(SArray* pList) {
   return true;
 }
 
-SArray* createQueryPlanImpl(SQueryStmtInfo* pQueryInfo) {
+SArray* createQueryPlanImpl(const SQueryStmtInfo* pQueryInfo) {
   SArray* upstream = NULL;
 
   if (pQueryInfo->pUpstream != NULL && taosArrayGetSize(pQueryInfo->pUpstream) > 0) {  // subquery in the from clause

source/libs/planner/src/physicalPlan.c

@@ -14,6 +14,7 @@
  */
 
 #include "plannerInt.h"
+#include "exception.h"
 #include "parser.h"
 
 #define STORE_CURRENT_SUBPLAN(cxt) SSubplan* _ = cxt->pCurrentSubplan
@@ -33,19 +34,67 @@ static const char* gOpName[] = {
 #undef INCLUDE_AS_NAME
 };
 
+static void* vailidPointer(void* p) {
+  if (NULL == p) {
+    THROW(TSDB_CODE_TSC_OUT_OF_MEMORY);
+  }
+  return p;
+}
+
 const char* opTypeToOpName(int32_t type) {
   return gOpName[type];
 }
 
 int32_t opNameToOpType(const char* name) {
   for (int32_t i = 1; i < sizeof(gOpName) / sizeof(gOpName[0]); ++i) {
-    if (strcmp(name, gOpName[i])) {
+    if (0 == strcmp(name, gOpName[i])) {
       return i;
     }
   }
   return OP_Unknown;
 }
 
+const char* dsinkTypeToDsinkName(int32_t type) {
+  switch (type) {
+    case DSINK_Dispatch:
+      return "Dispatch";
+    case DSINK_Insert:
+      return "Insert";
+    default:
+      break;
+  }
+  return "Unknown";
+}
+
+int32_t dsinkNameToDsinkType(const char* name) {
+  if (0 == strcmp(name, "Dispatch")) {
+    return DSINK_Dispatch;
+  } else if (0 == strcmp(name, "Insert")) {
+    return DSINK_Insert;
+  }
+  return DSINK_Unknown;
+}
+
+static SDataSink* initDataSink(int32_t type, int32_t size) {
+  SDataSink* sink = (SDataSink*)vailidPointer(calloc(1, size));
+  sink->info.type = type;
+  sink->info.name = dsinkTypeToDsinkName(type);
+  return sink;
+}
+
+static SDataSink* createDataDispatcher(SPlanContext* pCxt, SQueryPlanNode* pPlanNode) {
+  SDataDispatcher* dispatcher = (SDataDispatcher*)initDataSink(DSINK_Dispatch, sizeof(SDataDispatcher));
+  return (SDataSink*)dispatcher;
+}
+
+static SDataSink* createDataInserter(SPlanContext* pCxt, SVgDataBlocks* pBlocks) {
+  SDataInserter* inserter = (SDataInserter*)initDataSink(DSINK_Insert, sizeof(SDataInserter));
+  inserter->numOfTables = pBlocks->numOfTables;
+  inserter->size = pBlocks->size;
+  SWAP(inserter->pData, pBlocks->pData, char*);
+  return (SDataSink*)inserter;
+}
+
 static bool toDataBlockSchema(SQueryPlanNode* pPlanNode, SDataBlockSchema* dataBlockSchema) {
   dataBlockSchema->numOfCols = pPlanNode->numOfCols;
   dataBlockSchema->pSchema = malloc(sizeof(SSlotSchema) * pPlanNode->numOfCols);
@@ -72,10 +121,7 @@ static bool cloneExprArray(SArray** dst, SArray* src) {
 }
 
 static SPhyNode* initPhyNode(SQueryPlanNode* pPlanNode, int32_t type, int32_t size) {
-  SPhyNode* node = (SPhyNode*)calloc(1, size);
-  if (NULL == node) {
-    return NULL;
-  }
+  SPhyNode* node = (SPhyNode*)vailidPointer(calloc(1, size));
   node->info.type = type;
   node->info.name = opTypeToOpName(type);
   if (!cloneExprArray(&node->pTargets, pPlanNode->pExpr) || !toDataBlockSchema(pPlanNode, &(node->targetSchema))) {
@@ -138,7 +184,7 @@ static SPhyNode* createMultiTableScanNode(SQueryPlanNode* pPlanNode, SQueryTable
 }
 
 static SSubplan* initSubplan(SPlanContext* pCxt, int32_t type) {
-  SSubplan* subplan = calloc(1, sizeof(SSubplan));
+  SSubplan* subplan = vailidPointer(calloc(1, sizeof(SSubplan)));
   subplan->id = pCxt->nextId;
   ++(pCxt->nextId.subplanId);
   subplan->type = type;
@@ -146,15 +192,15 @@ static SSubplan* initSubplan(SPlanContext* pCxt, int32_t type) {
   if (NULL != pCxt->pCurrentSubplan) {
     subplan->level = pCxt->pCurrentSubplan->level + 1;
     if (NULL == pCxt->pCurrentSubplan->pChildern) {
-      pCxt->pCurrentSubplan->pChildern = taosArrayInit(TARRAY_MIN_SIZE, POINTER_BYTES);
+      pCxt->pCurrentSubplan->pChildern = vailidPointer(taosArrayInit(TARRAY_MIN_SIZE, POINTER_BYTES));
     }
     taosArrayPush(pCxt->pCurrentSubplan->pChildern, &subplan);
-    subplan->pParents = taosArrayInit(TARRAY_MIN_SIZE, POINTER_BYTES);
+    subplan->pParents = vailidPointer(taosArrayInit(TARRAY_MIN_SIZE, POINTER_BYTES));
     taosArrayPush(subplan->pParents, &pCxt->pCurrentSubplan);
   }
   SArray* currentLevel;
   if (subplan->level >= taosArrayGetSize(pCxt->pDag->pSubplans)) {
-    currentLevel = taosArrayInit(TARRAY_MIN_SIZE, POINTER_BYTES);
+    currentLevel = vailidPointer(taosArrayInit(TARRAY_MIN_SIZE, POINTER_BYTES));
     taosArrayPush(pCxt->pDag->pSubplans, &currentLevel);
   } else {
     currentLevel = taosArrayGetP(pCxt->pDag->pSubplans, subplan->level);
@@ -164,7 +210,17 @@ static SSubplan* initSubplan(SPlanContext* pCxt, int32_t type) {
   return subplan;
 }
 
-static void vgroupToEpSet(const SVgroupMsg* vg, SEpSet* epSet) {
+static void vgroupInfoToEpSet(const SVgroupInfo* vg, SEpSet* epSet) {
+  epSet->inUse = 0; // todo
+  epSet->numOfEps = vg->numOfEps;
+  for (int8_t i = 0; i < vg->numOfEps; ++i) {
+    epSet->port[i] = vg->epAddr[i].port;
+    strcpy(epSet->fqdn[i], vg->epAddr[i].fqdn);
+  }
+  return;
+}
+
+static void vgroupMsgToEpSet(const SVgroupMsg* vg, SEpSet* epSet) {
   epSet->inUse = 0; // todo
   epSet->numOfEps = vg->numOfEps;
   for (int8_t i = 0; i < vg->numOfEps; ++i) {
@@ -179,8 +235,9 @@ static uint64_t splitSubplanByTable(SPlanContext* pCxt, SQueryPlanNode* pPlanNod
   for (int32_t i = 0; i < pTable->pMeta->vgroupList->numOfVgroups; ++i) {
     STORE_CURRENT_SUBPLAN(pCxt);
     SSubplan* subplan = initSubplan(pCxt, QUERY_TYPE_SCAN);
-    vgroupToEpSet(&(pTable->pMeta->vgroupList->vgroups[i]), &subplan->execEpSet);
+    vgroupMsgToEpSet(&(pTable->pMeta->vgroupList->vgroups[i]), &subplan->execEpSet);
     subplan->pNode = createMultiTableScanNode(pPlanNode, pTable);
+    subplan->pDataSink = createDataDispatcher(pCxt, pPlanNode);
     RECOVERY_CURRENT_SUBPLAN(pCxt);
   }
   return pCxt->nextId.templateId++;
@@ -214,6 +271,9 @@ static SPhyNode* createPhyNode(SPlanContext* pCxt, SQueryPlanNode* pPlanNode) {
     case QNODE_TABLESCAN:
       node = createTableScanNode(pCxt, pPlanNode);
       break;
+    case QNODE_INSERT:
+      // Insert is not an operator in a physical plan.
+      break;
     default:
       assert(false);
   }
@@ -229,26 +289,46 @@ static SPhyNode* createPhyNode(SPlanContext* pCxt, SQueryPlanNode* pPlanNode) {
   return node;
 }
 
+static void splitInsertSubplan(SPlanContext* pCxt, SQueryPlanNode* pPlanNode) {
+  SArray* vgs = (SArray*)pPlanNode->pExtInfo;
+  size_t numOfVg = taosArrayGetSize(vgs);
+  for (int32_t i = 0; i < numOfVg; ++i) {
+    SSubplan* subplan = initSubplan(pCxt, QUERY_TYPE_MODIFY);
+    SVgDataBlocks* blocks = (SVgDataBlocks*)taosArrayGetP(vgs, i);
+    vgroupInfoToEpSet(&blocks->vg, &subplan->execEpSet);
+    subplan->pNode = NULL;
+    subplan->pDataSink = createDataInserter(pCxt, blocks);
+  }
+}
+
 static void createSubplanByLevel(SPlanContext* pCxt, SQueryPlanNode* pRoot) {
-  SSubplan* subplan = initSubplan(pCxt, QUERY_TYPE_MERGE);
-  ++(pCxt->nextId.templateId);
-  subplan->pNode = createPhyNode(pCxt, pRoot);
+  if (QNODE_INSERT == pRoot->info.type) {
+    splitInsertSubplan(pCxt, pRoot);
+  } else {
+    SSubplan* subplan = initSubplan(pCxt, QUERY_TYPE_MERGE);
+    ++(pCxt->nextId.templateId);
+    subplan->pNode = createPhyNode(pCxt, pRoot);
+    subplan->pDataSink = createDataDispatcher(pCxt, pRoot);
+  }
   // todo deal subquery
 }
 
 int32_t createDag(SQueryPlanNode* pQueryNode, struct SCatalog* pCatalog, SQueryDag** pDag) {
-  SPlanContext context = {
-    .pCatalog = pCatalog,
-    .pDag = calloc(1, sizeof(SQueryDag)),
-    .pCurrentSubplan = NULL,
-    .nextId = {0} // todo queryid
-  };
-  if (NULL == context.pDag) {
-    return TSDB_CODE_TSC_OUT_OF_MEMORY;
-  }
-  context.pDag->pSubplans = taosArrayInit(TARRAY_MIN_SIZE, POINTER_BYTES);
-  createSubplanByLevel(&context, pQueryNode);
-  *pDag = context.pDag;
+  TRY(TSDB_MAX_TAG_CONDITIONS) {
+    SPlanContext context = {
+      .pCatalog = pCatalog,
+      .pDag = vailidPointer(calloc(1, sizeof(SQueryDag))),
+      .pCurrentSubplan = NULL,
+      .nextId = {0} // todo queryid
+    };
+    *pDag = context.pDag;
+    context.pDag->pSubplans = vailidPointer(taosArrayInit(TARRAY_MIN_SIZE, POINTER_BYTES));
+    createSubplanByLevel(&context, pQueryNode);
+  } CATCH(code) {
+    CLEANUP_EXECUTE();
+    terrno = code;
+    return TSDB_CODE_FAILED;
+  } END_TRY
   return TSDB_CODE_SUCCESS;
 }
 

source/libs/planner/src/physicalPlanJson.c

@@ -651,7 +651,7 @@ static bool specificPhyNodeFromJson(const cJSON* json, void* obj) {
 static const char* jkPnodeName = "Name";
 static const char* jkPnodeTargets = "Targets";
 static const char* jkPnodeConditions = "Conditions";
-static const char* jkPnodeSchema = "Schema";
+static const char* jkPnodeSchema = "InputSchema";
 static const char* jkPnodeChildren = "Children";
 // The 'pParent' field do not need to be serialized.
 static bool phyNodeToJson(const void* obj, cJSON* jNode) {
@@ -695,6 +695,70 @@ static bool phyNodeFromJson(const cJSON* json, void* obj) {
   return res;
 }
 
+static const char* jkInserterNumOfTables = "NumOfTables";
+static const char* jkInserterDataSize = "DataSize";
+
+static bool inserterToJson(const void* obj, cJSON* json) {
+  const SDataInserter* inserter = (const SDataInserter*)obj;
+  bool res = cJSON_AddNumberToObject(json, jkInserterNumOfTables, inserter->numOfTables);
+  if (res) {
+    res = cJSON_AddNumberToObject(json, jkInserterDataSize, inserter->size);
+  }
+  // todo pData
+  return res;
+}
+
+static bool inserterFromJson(const cJSON* json, void* obj) {
+  SDataInserter* inserter = (SDataInserter*)obj;
+  inserter->numOfTables = getNumber(json, jkInserterNumOfTables);
+  inserter->size = getNumber(json, jkInserterDataSize);
+  // todo pData
+}
+
+static bool specificDataSinkToJson(const void* obj, cJSON* json) {
+  const SDataSink* dsink = (const SDataSink*)obj;
+  switch (dsink->info.type) {
+    case DSINK_Dispatch:
+      return true;
+    case DSINK_Insert:
+      return inserterToJson(obj, json);
+    default:
+      break;
+  }
+  return false;
+}
+
+static bool specificDataSinkFromJson(const cJSON* json, void* obj) {
+  SDataSink* dsink = (SDataSink*)obj;
+  switch (dsink->info.type) {
+    case DSINK_Dispatch:
+      return true;
+    case DSINK_Insert:
+      return inserterFromJson(json, obj);
+    default:
+      break;
+  }
+  return false;
+}
+
+static const char* jkDataSinkName = "Name";
+
+static bool dataSinkToJson(const void* obj, cJSON* json) {
+  const SDataSink* dsink = (const SDataSink*)obj;
+  bool res = cJSON_AddStringToObject(json, jkDataSinkName, dsink->info.name);
+  if (res) {
+    res = addObject(json, dsink->info.name, specificDataSinkToJson, dsink);
+  }
+  return res;
+}
+
+static bool dataSinkFromJson(const cJSON* json, void* obj) {
+  SDataSink* dsink = (SDataSink*)obj;
+  dsink->info.name = getString(json, jkDataSinkName);
+  dsink->info.type = dsinkNameToDsinkType(dsink->info.name);
+  return fromObject(json, dsink->info.name, specificDataSinkFromJson, dsink, true);
+}
+
 static const char* jkIdQueryId = "QueryId";
 static const char* jkIdTemplateId = "TemplateId";
 static const char* jkIdSubplanId = "SubplanId";
@@ -721,6 +785,7 @@ static bool subplanIdFromJson(const cJSON* json, void* obj) {
 
 static const char* jkSubplanId = "Id";
 static const char* jkSubplanNode = "Node";
+static const char* jkSubplanDataSink = "DataSink";
 
 static cJSON* subplanToJson(const SSubplan* subplan) {
   cJSON* jSubplan = cJSON_CreateObject();
@@ -734,6 +799,9 @@ static cJSON* subplanToJson(const SSubplan* subplan) {
   if (res) {
     res = addObject(jSubplan, jkSubplanNode, phyNodeToJson, subplan->pNode);
   }
+  if (res) {
+    res = addObject(jSubplan, jkSubplanDataSink, dataSinkToJson, subplan->pDataSink);
+  }
 
   if (!res) {
     cJSON_Delete(jSubplan);
@@ -751,6 +819,9 @@ static SSubplan* subplanFromJson(const cJSON* json) {
   if (res) {
     res = fromObjectWithAlloc(json, jkSubplanNode, phyNodeFromJson, (void**)&subplan->pNode, sizeof(SPhyNode), false);
   }
+  if (res) {
+    res = fromObjectWithAlloc(json, jkSubplanDataSink, dataSinkFromJson, (void**)&subplan->pDataSink, sizeof(SDataSink), false);
+  }
   
   if (!res) {
     qDestroySubplan(subplan);
@@ -759,13 +830,22 @@ static SSubplan* subplanFromJson(const cJSON* json) {
   return subplan;
 }
 
-int32_t subPlanToString(const SSubplan* subplan, char** str) {
+int32_t subPlanToString(const SSubplan* subplan, char** str, int32_t* len) {
+  if (QUERY_TYPE_MODIFY == subplan->type) {
+    SDataInserter* insert = (SDataInserter*)(subplan->pDataSink);
+    *len = insert->size;
+    *str = insert->pData;
+    insert->pData == NULL;
+    return TSDB_CODE_SUCCESS;
+  }
+
   cJSON* json = subplanToJson(subplan);
   if (NULL == json) {
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
     return TSDB_CODE_FAILED;
   }
   *str = cJSON_Print(json);
+  *len = strlen(*str) + 1;
   return TSDB_CODE_SUCCESS;
 }
 

source/libs/planner/src/planner.c

@@ -24,9 +24,9 @@ void qDestroyQueryDag(struct SQueryDag* pDag) {
   // todo
 }
 
-int32_t qCreateQueryDag(const struct SQueryStmtInfo* pQueryInfo, struct SEpSet* pQnode, struct SQueryDag** pDag) {
+int32_t qCreateQueryDag(const struct SQueryNode* pNode, struct SEpSet* pEpSet, struct SQueryDag** pDag) {
   SQueryPlanNode* logicPlan;
-  int32_t code = createQueryPlan(pQueryInfo, &logicPlan);
+  int32_t code = createQueryPlan(pNode, &logicPlan);
   if (TSDB_CODE_SUCCESS != code) {
     destroyQueryPlan(logicPlan);
     return code;
@@ -50,8 +50,8 @@ int32_t qSetSubplanExecutionNode(SSubplan* subplan, uint64_t templateId, SEpAddr
   return setSubplanExecutionNode(subplan, templateId, ep);
 }
 
-int32_t qSubPlanToString(const SSubplan *subplan, char** str) {
-  return subPlanToString(subplan, str);
+int32_t qSubPlanToString(const SSubplan *subplan, char** str, int32_t* len) {
+  return subPlanToString(subplan, str, len);
 }
 
 int32_t qStringToSubplan(const char* str, SSubplan** subplan) {

source/libs/planner/test/phyPlanTests.cpp

@@ -33,10 +33,6 @@ protected:
   void pushScan(const string& db, const string& table, int32_t scanOp) {
     shared_ptr<MockTableMeta> meta = mockCatalogService->getTableMeta(db, table);
     EXPECT_TRUE(meta);
-// typedef struct SQueryPlanNode {
-//   SArray             *pExpr;        // the query functions or sql aggregations
-//   int32_t             numOfExpr;  // number of result columns, which is also the number of pExprs
-// } SQueryPlanNode;
     unique_ptr<SQueryPlanNode> scan((SQueryPlanNode*)calloc(1, sizeof(SQueryPlanNode)));
     scan->info.type = scanOp;
     scan->numOfCols = meta->schema->tableInfo.numOfColumns;
@@ -54,6 +50,21 @@ protected:
     return code;
   }
 
+  int32_t run(const string& db, const string& sql) {
+    SParseContext cxt;
+    buildParseContext(db, sql, &cxt);
+    SQueryNode* query;
+    int32_t code = qParseQuerySql(&cxt, &query);
+    if (TSDB_CODE_SUCCESS != code) {
+      cout << "error no:" << code << ", msg:" << cxt.pMsg << endl;
+      return code;
+    }
+    SQueryDag* dag = nullptr;
+    code = qCreateQueryDag(query, nullptr, &dag);
+    dag_.reset(dag);
+    return code;
+  }
+
   void explain() {
     size_t level = taosArrayGetSize(dag_->pSubplans);
     for (size_t i = 0; i < level; ++i) {
@@ -62,8 +73,10 @@ protected:
       size_t num = taosArrayGetSize(subplans);
       for (size_t j = 0; j < num; ++j) {
         std::cout << "no " << j << ":" << std::endl;
+        int32_t len = 0;
         char* str = nullptr;
-        ASSERT_EQ (TSDB_CODE_SUCCESS, qSubPlanToString((const SSubplan*)taosArrayGetP(subplans, j), &str));
+        ASSERT_EQ(TSDB_CODE_SUCCESS, qSubPlanToString((const SSubplan*)taosArrayGetP(subplans, j), &str, &len));
+        std::cout << "len:" << len << std::endl;
         std::cout << str << std::endl;
         free(str);
       }
@@ -107,6 +120,25 @@ private:
     return info;
   }
 
+  void buildParseContext(const string& db, const string& sql, SParseContext* pCxt) {
+    static string _db;
+    static string _sql;
+    static const int32_t _msgMaxLen = 4096;
+    static char _msg[_msgMaxLen];
+  
+    _db = db;
+    _sql = sql;
+    memset(_msg, 0, _msgMaxLen);
+  
+    pCxt->ctx.acctId = 1;
+    pCxt->ctx.db = _db.c_str();
+    pCxt->ctx.requestId = 1;
+    pCxt->pSql = _sql.c_str();
+    pCxt->sqlLen = _sql.length();
+    pCxt->pMsg = _msg;
+    pCxt->msgLen = _msgMaxLen;
+  }
+
   shared_ptr<MockTableMeta> meta_;
   unique_ptr<SQueryPlanNode> logicPlan_;
   unique_ptr<SQueryDag> dag_;
@@ -114,7 +146,7 @@ private:
 
 // select * from table
 TEST_F(PhyPlanTest, tableScanTest) {
-  pushScan("root.test", "t1", QNODE_TABLESCAN);
+  pushScan("test", "t1", QNODE_TABLESCAN);
   ASSERT_EQ(run(), TSDB_CODE_SUCCESS);
   explain();
   SQueryDag* dag = reslut();
@@ -123,9 +155,17 @@ TEST_F(PhyPlanTest, tableScanTest) {
 
 // select * from supertable
 TEST_F(PhyPlanTest, superTableScanTest) {
-  pushScan("root.test", "st1", QNODE_TABLESCAN);
+  pushScan("test", "st1", QNODE_TABLESCAN);
   ASSERT_EQ(run(), TSDB_CODE_SUCCESS);
   explain();
   SQueryDag* dag = reslut();
   // todo check
 }
+
+// insert into t values(...)
+TEST_F(PhyPlanTest, insertTest) {
+  ASSERT_EQ(run("test", "insert into t1 values (now, 1, \"beijing\")"), TSDB_CODE_SUCCESS);
+  explain();
+  SQueryDag* dag = reslut();
+  // todo check
+}

source/libs/qcom/CMakeLists.txt

@@ -10,3 +10,5 @@ target_link_libraries(
    qcom
    PRIVATE os util transport
 )
+
+ADD_SUBDIRECTORY(test)

source/libs/qcom/src/queryUtil.c

@@ -1,5 +1,8 @@
 #include "os.h"
 #include "taosmsg.h"
+#include "query.h"
+#include "tglobal.h"
+#include "tsched.h"
 
 #define VALIDNUMOFCOLS(x)  ((x) >= TSDB_MIN_COLUMNS && (x) <= TSDB_MAX_COLUMNS)
 #define VALIDNUMOFTAGS(x)  ((x) >= 0 && (x) <= TSDB_MAX_TAGS)
@@ -76,3 +79,45 @@ bool tIsValidSchema(struct SSchema* pSchema, int32_t numOfCols, int32_t numOfTag
 
   return true;
 }
+
+static void* pTaskQueue = NULL;
+
+int32_t initTaskQueue() {
+  double factor = 4.0;
+  int32_t numOfThreads = MAX((int)(tsNumOfCores * tsNumOfThreadsPerCore / factor), 2);
+
+  int32_t queueSize = tsMaxConnections * 2;
+  pTaskQueue = taosInitScheduler(queueSize, numOfThreads, "tsc");
+  if (NULL == pTaskQueue) {
+    qError("failed to init task queue");
+    return -1;
+  }
+
+  qDebug("task queue is initialized, numOfThreads: %d", numOfThreads);
+}
+
+int32_t cleanupTaskQueue() {
+  taosCleanUpScheduler(pTaskQueue);
+}
+
+static void execHelper(struct SSchedMsg* pSchedMsg) {
+  assert(pSchedMsg != NULL && pSchedMsg->ahandle != NULL);
+
+  __async_exec_fn_t* execFn = (__async_exec_fn_t*) pSchedMsg->ahandle;
+  int32_t code = execFn(pSchedMsg->thandle);
+  if (code != 0 && pSchedMsg->msg != NULL) {
+    *(int32_t*) pSchedMsg->msg = code;
+  }
+}
+
+int32_t taosAsyncExec(__async_exec_fn_t execFn, void* execParam, int32_t* code) {
+  assert(execFn != NULL);
+
+  SSchedMsg schedMsg = {0};
+  schedMsg.fp      = execHelper;
+  schedMsg.ahandle = execFn;
+  schedMsg.thandle = execParam;
+  schedMsg.msg     = code;
+
+  taosScheduleTask(pTaskQueue, &schedMsg);
+}

source/libs/qcom/src/querymsg.c

@@ -263,87 +263,12 @@ int32_t queryProcessTableMetaRsp(void* output, char *msg, int32_t msgSize) {
 }
 
 
-void msgInit() {
+void initQueryModuleMsgHandle() {
   queryBuildMsg[TSDB_MSG_TYPE_TABLE_META] = queryBuildTableMetaReqMsg;
   queryBuildMsg[TSDB_MSG_TYPE_USE_DB] = queryBuildUseDbMsg;
 
   queryProcessMsgRsp[TSDB_MSG_TYPE_TABLE_META] = queryProcessTableMetaRsp;
   queryProcessMsgRsp[TSDB_MSG_TYPE_USE_DB] = queryProcessUseDBRsp;
-
-/*
-  tscBuildMsg[TSDB_SQL_SELECT] = tscBuildQueryMsg;
-  tscBuildMsg[TSDB_SQL_INSERT] = tscBuildSubmitMsg;
-  tscBuildMsg[TSDB_SQL_FETCH] = tscBuildFetchMsg;
-
-  tscBuildMsg[TSDB_SQL_CREATE_DB] = tscBuildCreateDbMsg;
-  tscBuildMsg[TSDB_SQL_CREATE_USER] = tscBuildUserMsg;
-  tscBuildMsg[TSDB_SQL_CREATE_FUNCTION] = tscBuildCreateFuncMsg;
-
-  tscBuildMsg[TSDB_SQL_CREATE_ACCT] = tscBuildAcctMsg;
-  tscBuildMsg[TSDB_SQL_ALTER_ACCT] = tscBuildAcctMsg;
-
-  tscBuildMsg[TSDB_SQL_CREATE_TABLE] = tscBuildCreateTableMsg;
-  tscBuildMsg[TSDB_SQL_DROP_USER] = tscBuildDropUserAcctMsg;
-  tscBuildMsg[TSDB_SQL_DROP_ACCT] = tscBuildDropUserAcctMsg;
-  tscBuildMsg[TSDB_SQL_DROP_DB] = tscBuildDropDbMsg;
-  tscBuildMsg[TSDB_SQL_DROP_FUNCTION] = tscBuildDropFuncMsg;
-  tscBuildMsg[TSDB_SQL_SYNC_DB_REPLICA] = tscBuildSyncDbReplicaMsg;
-  tscBuildMsg[TSDB_SQL_DROP_TABLE] = tscBuildDropTableMsg;
-  tscBuildMsg[TSDB_SQL_ALTER_USER] = tscBuildUserMsg;
-  tscBuildMsg[TSDB_SQL_CREATE_DNODE] = tscBuildCreateDnodeMsg;
-  tscBuildMsg[TSDB_SQL_DROP_DNODE] = tscBuildDropDnodeMsg;
-  tscBuildMsg[TSDB_SQL_CFG_DNODE] = tscBuildCfgDnodeMsg;
-  tscBuildMsg[TSDB_SQL_ALTER_TABLE] = tscBuildAlterTableMsg;
-  tscBuildMsg[TSDB_SQL_UPDATE_TAG_VAL] = tscBuildUpdateTagMsg;
-  tscBuildMsg[TSDB_SQL_ALTER_DB] = tscAlterDbMsg;
-  tscBuildMsg[TSDB_SQL_COMPACT_VNODE] = tscBuildCompactMsg;  
-
-  tscBuildMsg[TSDB_SQL_CONNECT] = tscBuildConnectMsg;
-  tscBuildMsg[TSDB_SQL_USE_DB] = tscBuildUseDbMsg;
-  tscBuildMsg[TSDB_SQL_STABLEVGROUP] = tscBuildSTableVgroupMsg;
-  tscBuildMsg[TSDB_SQL_RETRIEVE_FUNC] = tscBuildRetrieveFuncMsg;
-
-  tscBuildMsg[TSDB_SQL_HB] = tscBuildHeartBeatMsg;
-  tscBuildMsg[TSDB_SQL_SHOW] = tscBuildShowMsg;
-  tscBuildMsg[TSDB_SQL_RETRIEVE_MNODE] = tscBuildRetrieveFromMgmtMsg;
-  tscBuildMsg[TSDB_SQL_KILL_QUERY] = tscBuildKillMsg;
-  tscBuildMsg[TSDB_SQL_KILL_STREAM] = tscBuildKillMsg;
-  tscBuildMsg[TSDB_SQL_KILL_CONNECTION] = tscBuildKillMsg;
-
-  tscProcessMsgRsp[TSDB_SQL_SELECT] = tscProcessQueryRsp;
-  tscProcessMsgRsp[TSDB_SQL_FETCH] = tscProcessRetrieveRspFromNode;
-
-  tscProcessMsgRsp[TSDB_SQL_DROP_DB] = tscProcessDropDbRsp;
-  tscProcessMsgRsp[TSDB_SQL_DROP_TABLE] = tscProcessDropTableRsp;
-  tscProcessMsgRsp[TSDB_SQL_CONNECT] = tscProcessConnectRsp;
-  tscProcessMsgRsp[TSDB_SQL_USE_DB] = tscProcessUseDbRsp;
-  tscProcessMsgRsp[TSDB_SQL_META] = tscProcessTableMetaRsp;
-  tscProcessMsgRsp[TSDB_SQL_STABLEVGROUP] = tscProcessSTableVgroupRsp;
-  tscProcessMsgRsp[TSDB_SQL_MULTI_META] = tscProcessMultiTableMetaRsp;
-  tscProcessMsgRsp[TSDB_SQL_RETRIEVE_FUNC] = tscProcessRetrieveFuncRsp;
-
-  tscProcessMsgRsp[TSDB_SQL_SHOW] = tscProcessShowRsp;
-  tscProcessMsgRsp[TSDB_SQL_RETRIEVE_MNODE] = tscProcessRetrieveRspFromNode;  // rsp handled by same function.
-  tscProcessMsgRsp[TSDB_SQL_DESCRIBE_TABLE] = tscProcessDescribeTableRsp;
-
-  tscProcessMsgRsp[TSDB_SQL_CURRENT_DB]   = tscProcessLocalRetrieveRsp;
-  tscProcessMsgRsp[TSDB_SQL_CURRENT_USER] = tscProcessLocalRetrieveRsp;
-  tscProcessMsgRsp[TSDB_SQL_SERV_VERSION] = tscProcessLocalRetrieveRsp;
-  tscProcessMsgRsp[TSDB_SQL_CLI_VERSION]  = tscProcessLocalRetrieveRsp;
-  tscProcessMsgRsp[TSDB_SQL_SERV_STATUS]  = tscProcessLocalRetrieveRsp;
-
-  tscProcessMsgRsp[TSDB_SQL_RETRIEVE_EMPTY_RESULT] = tscProcessEmptyResultRsp;
-
-  tscProcessMsgRsp[TSDB_SQL_RETRIEVE_GLOBALMERGE] = tscProcessRetrieveGlobalMergeRsp;
-
-  tscProcessMsgRsp[TSDB_SQL_ALTER_TABLE] = tscProcessAlterTableMsgRsp;
-  tscProcessMsgRsp[TSDB_SQL_ALTER_DB] = tscProcessAlterDbMsgRsp;
-  tscProcessMsgRsp[TSDB_SQL_COMPACT_VNODE] = tscProcessCompactRsp; 
-
-  tscProcessMsgRsp[TSDB_SQL_SHOW_CREATE_TABLE] = tscProcessShowCreateRsp;
-  tscProcessMsgRsp[TSDB_SQL_SHOW_CREATE_STABLE] = tscProcessShowCreateRsp;
-  tscProcessMsgRsp[TSDB_SQL_SHOW_CREATE_DATABASE] = tscProcessShowCreateRsp;
-*/
 }
 
 

source/libs/qcom/test/CMakeLists.txt

@@ -0,0 +1,19 @@
+
+MESSAGE(STATUS "build qcom unit test")
+
+# GoogleTest requires at least C++11
+SET(CMAKE_CXX_STANDARD 11)
+AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SOURCE_LIST)
+
+ADD_EXECUTABLE(queryUtilTest ${SOURCE_LIST})
+
+TARGET_INCLUDE_DIRECTORIES(
+        queryUtilTest
+        PUBLIC "${CMAKE_SOURCE_DIR}/include/libs/qcom/"
+        PRIVATE "${CMAKE_SOURCE_DIR}/source/libs/qcom/inc"
+)
+
+TARGET_LINK_LIBRARIES(
+        queryUtilTest
+        PUBLIC os util gtest qcom common
+)

source/libs/qcom/test/queryTest.cpp

@@ -0,0 +1,83 @@
+/*
+ * 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 <gtest/gtest.h>
+#include <iostream>
+#include "taosmsg.h"
+#include "query.h"
+#pragma GCC diagnostic ignored "-Wwrite-strings"
+
+#pragma GCC diagnostic ignored "-Wunused-function"
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#pragma GCC diagnostic ignored "-Wsign-compare"
+
+namespace {
+typedef struct SParam {
+  int32_t v;
+} SParam;
+int32_t testPrint(void* p) {
+  SParam* param = (SParam*)p;
+  printf("hello world, %d\n", param->v);
+  tfree(p);
+  return 0;
+}
+
+int32_t testPrintError(void* p) {
+  SParam* param = (SParam*) p;
+  tfree(p);
+
+  return -1;
+}
+}  // namespace
+
+class QueryTestEnv : public testing::Environment {
+ public:
+  virtual void SetUp() { initTaskQueue(); }
+
+  virtual void TearDown() { cleanupTaskQueue(); }
+
+  QueryTestEnv() {}
+  virtual ~QueryTestEnv() {}
+};
+
+int main(int argc, char** argv) {
+  testing::AddGlobalTestEnvironment(new QueryTestEnv());
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
+
+TEST(testCase, async_task_test) {
+  SParam* p = (SParam*)calloc(1, sizeof(SParam));
+  taosAsyncExec(testPrint, p, NULL);
+  usleep(5000);
+}
+
+TEST(testCase, many_async_task_test) {
+  for(int32_t i = 0; i < 50; ++i) {
+    SParam* p = (SParam*) calloc(1, sizeof(SParam));
+    p->v = i;
+    taosAsyncExec(testPrint, p, NULL);
+  }
+
+  usleep(10000);
+}
+
+TEST(testCase, error_in_async_test) {
+  int32_t code = 0;
+  SParam* p = (SParam*) calloc(1, sizeof(SParam));
+  taosAsyncExec(testPrintError, p, &code);
+  usleep(1000);
+  printf("Error code:%d after asynchronously exec function\n", code);
+}

source/libs/qworker/inc/qworkerInt.h

@@ -20,6 +20,8 @@
 extern "C" {
 #endif
 
+#include "tlockfree.h"
+
 #define QWORKER_DEFAULT_SCHEDULER_NUMBER 10000
 #define QWORKER_DEFAULT_RES_CACHE_NUMBER 10000
 #define QWORKER_DEFAULT_SCH_TASK_NUMBER 10000
@@ -30,36 +32,63 @@ enum {
   QW_READY_RESPONSED,
 };
 
+enum {
+  QW_TASK_INFO_STATUS = 1,
+  QW_TASK_INFO_READY,
+};
+
+enum {
+  QW_READ = 1,
+  QW_WRITE,
+};
+
 typedef struct SQWorkerTaskStatus {  
-  int8_t status;
-  int8_t ready; 
+  SRWLatch lock;
+  int32_t  code;
+  int8_t   status;
+  int8_t   ready; 
+  bool     cancel;
+  bool     drop;
 } SQWorkerTaskStatus;
 
 typedef struct SQWorkerResCache {
+  SRWLatch lock;
   void *data;
 } SQWorkerResCache;
 
-typedef struct SQWorkerSchTaskStatus {
+typedef struct SQWorkerSchStatus {
   int32_t   lastAccessTs; // timestamp in second
-  SHashObj *taskStatus;   // key:queryId+taskId, value: SQWorkerTaskStatus
-} SQWorkerSchTaskStatus;
+  SRWLatch  tasksLock;
+  SHashObj *tasksHash;   // key:queryId+taskId, value: SQWorkerTaskStatus
+} SQWorkerSchStatus;
 
 // Qnode/Vnode level task management
 typedef struct SQWorkerMgmt {
   SQWorkerCfg cfg;
-  SHashObj *scheduleHash;    //key: schedulerId, value: SQWorkerSchTaskStatus
+  SRWLatch  schLock;
+  SRWLatch  resLock;
+  SHashObj *schHash;    //key: schedulerId, value: SQWorkerSchStatus
   SHashObj *resHash;       //key: queryId+taskId, value: SQWorkerResCache
 } SQWorkerMgmt;
 
-#define QW_TASK_DONE(status) (status == JOB_TASK_STATUS_SUCCEED || status == JOB_TASK_STATUS_FAILED || status == status == JOB_TASK_STATUS_CANCELLED)
+#define QW_GOT_RES_DATA(data) (false)
+#define QW_LOW_RES_DATA(data) (false)
+
+#define QW_TASK_NOT_EXIST(code) (TSDB_CODE_QRY_SCH_NOT_EXIST == (code) || TSDB_CODE_QRY_TASK_NOT_EXIST == (code))
+#define QW_TASK_ALREADY_EXIST(code) (TSDB_CODE_QRY_TASK_ALREADY_EXIST == (code))
+#define QW_TASK_READY_RESP(status) (status == JOB_TASK_STATUS_SUCCEED || status == JOB_TASK_STATUS_FAILED || status == JOB_TASK_STATUS_CANCELLED || status == JOB_TASK_STATUS_PARTIAL_SUCCEED)
 #define QW_SET_QTID(id, qid, tid) do { *(uint64_t *)(id) = (qid); *(uint64_t *)((char *)(id) + sizeof(qid)) = (tid); } while (0)
 #define QW_GET_QTID(id, qid, tid) do { (qid) = *(uint64_t *)(id); (tid) = *(uint64_t *)((char *)(id) + sizeof(qid)); } while (0)
 
+
 #define QW_ERR_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { terrno = _code; return _code; } } while (0)
 #define QW_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { terrno = _code; } return _code; } while (0)
 #define QW_ERR_LRET(c,...) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { qError(__VA_ARGS__); terrno = _code; return _code; } } while (0)
 #define QW_ERR_JRET(c) do { code = c; if (code != TSDB_CODE_SUCCESS) { terrno = code; goto _return; } } while (0)
 
+#define QW_LOCK(type, _lock) (QW_READ == (type) ? taosRLockLatch(_lock) : taosWLockLatch(_lock))
+#define QW_UNLOCK(type, _lock) (QW_READ == (type) ? taosRUnLockLatch(_lock) : taosWUnLockLatch(_lock))
+
 
 #ifdef __cplusplus
 }