TD-12506 merge 3.0

include/common/common.h

@@ -17,7 +17,7 @@
 #define TDENGINE_COMMON_H
 
 #include "taosdef.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "tarray.h"
 #include "tvariant.h"
 //typedef struct STimeWindow {

include/common/tep.h

@@ -2,7 +2,7 @@
 #define TDENGINE_TEP_H
 
 #include "os.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 
 typedef struct SCorEpSet {
   int32_t version;

include/common/tmsg.h

@@ -24,125 +24,32 @@ extern "C" {
 #include "taoserror.h"
 #include "tdataformat.h"
 
-// message type
+#define TD_MSG_NUMBER_
+#undef TD_MSG_DICT_
+#undef TD_MSG_INFO_
+#undef TD_MSG_SEG_CODE_
+#include "tmsgdef.h"
 
-#ifdef TAOS_MESSAGE_C
+#undef TD_MSG_NUMBER_
-#define TAOS_DEFINE_MESSAGE_TYPE( name, msg ) msg, msg "-rsp",
+#undef TD_MSG_DICT_
-char *taosMsg[] = {
+#undef TD_MSG_INFO_
-  "null",
+#define TD_MSG_SEG_CODE_
-#else
+#include "tmsgdef.h"
-#define TAOS_DEFINE_MESSAGE_TYPE( name, msg ) name, name##_RSP,
-enum {
-  TSDB_MESSAGE_NULL = 0,
-#endif
 
-// message from client to vnode
+#undef TD_MSG_NUMBER_
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_SUBMIT, "submit" )
+#undef TD_MSG_DICT_
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_QUERY, "query" )
+#undef TD_MSG_INFO_
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_FETCH, "fetch" )
+#undef TD_MSG_SEG_CODE_
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CREATE_TABLE, "create-table" )
+#include "tmsgdef.h"
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DROP_TABLE, "drop-table" )	
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_ALTER_TABLE, "alter-table" )	
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_UPDATE_TAG_VAL, "update-tag-val" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_TABLE_META, "table-meta" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_TABLES_META, "tables-meta" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_MQ_CONSUME, "mq-consume" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_MQ_QUERY, "mq-query" )
-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
+extern char* tMsgInfo[];
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CONNECT, "connect" )
+extern int   tMsgDict[];
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CREATE_ACCT, "create-acct" )	
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_ALTER_ACCT, "alter-acct" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DROP_ACCT, "drop-acct" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CREATE_USER, "create-user" )	
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_ALTER_USER, "alter-user" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DROP_USER, "drop-user" ) 
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CREATE_DNODE, "create-dnode" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CONFIG_DNODE, "config-dnode" ) 
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DROP_DNODE, "drop-dnode" )   
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CREATE_MNODE, "create-mnode" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DROP_MNODE, "drop-mnode" ) 
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CREATE_DB, "create-db" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DROP_DB, "drop-db" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_USE_DB, "use-db" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_ALTER_DB, "alter-db" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_SYNC_DB, "sync-db" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_COMPACT_DB, "compact-db" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CREATE_FUNCTION, "create-function" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_RETRIEVE_FUNCTION, "retrieve-function" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DROP_FUNCTION, "drop-function" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CREATE_STB, "create-stb" )
-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_CONN, "kill-conn" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_HEARTBEAT, "heartbeat" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_SHOW, "show" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_SHOW_RETRIEVE, "retrieve" )  
-// message from client to qnode
-// message from client to dnode
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_NETWORK_TEST, "nettest" )
 
-// message from vnode to vnode
+#define TMSG_SEG_CODE(TYPE) (((TYPE)&0xff00) >> 8)
-// message from vnode to mnode
+#define TMSG_SEG_SEQ(TYPE) ((TYPE)&0xff)
-// message from vnode to qnode
+#define TMSG_INFO(TYPE) tMsgInfo[tMsgDict[TMSG_SEG_CODE(TYPE)] + TMSG_SEG_SEQ(TYPE)]
-// message from vnode to dnode
 
-// message from mnode to vnode
+typedef uint16_t tmsg_t;
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CREATE_STB_IN, "create-stb-internal" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_ALTER_STB_IN, "alter-stb-internal" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DROP_STB_IN, "drop-stb-internal" )
-// message from mnode to mnode
-// message from mnode to qnode
-// message from mnode to dnode
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CREATE_VNODE_IN, "create-vnode-internal" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_ALTER_VNODE_IN, "alter-vnode-internal" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DROP_VNODE_IN, "drop-vnode-internal" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_AUTH_VNODE_IN, "auth-vnode-internal" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_SYNC_VNODE_IN, "sync-vnode-internal" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_COMPACT_VNODE_IN, "compact-vnode-internal" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CREATE_MNODE_IN, "create-mnode-internal" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_ALTER_MNODE_IN, "alter-mnode-internal" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DROP_MNODE_IN, "drop-mnode-internal" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CONFIG_DNODE_IN, "config-dnode-internal" )
-
-// message from qnode to vnode
-// message from qnode to mnode
-// message from qnode to qnode
-// message from qnode to dnode
-
-// message from dnode to vnode
-// message from dnode to mnode
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_STATUS, "status" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_GRANT, "grant" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_AUTH, "auth" )
-// message from dnode to qnode
-// message from dnode to dnode
-
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY0, "dummy0" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY1, "dummy1" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY2, "dummy2" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY3, "dummy3" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY4, "dummy4" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY5, "dummy5" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY6, "dummy6" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY7, "dummy7" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY8, "dummy8" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY9, "dummy9" )
-
-#ifndef TAOS_MESSAGE_C
-  TSDB_MSG_TYPE_MAX  // 147
-#endif
-
-};
 
 // IE type
 #define TSDB_IE_TYPE_SEC 1
@@ -210,16 +117,14 @@ typedef enum _mgmt_table {
 #define TSDB_COL_TMP 0x4u     // internal column generated by the previous operators
 #define TSDB_COL_NULL 0x8u    // the column filter NULL or not
 
-#define TSDB_COL_IS_TAG(f)          (((f&(~(TSDB_COL_NULL)))&TSDB_COL_TAG) != 0)
+#define TSDB_COL_IS_TAG(f) (((f & (~(TSDB_COL_NULL))) & TSDB_COL_TAG) != 0)
-#define TSDB_COL_IS_NORMAL_COL(f)   ((f&(~(TSDB_COL_NULL))) == TSDB_COL_NORMAL)
+#define TSDB_COL_IS_NORMAL_COL(f) ((f & (~(TSDB_COL_NULL))) == TSDB_COL_NORMAL)
-#define TSDB_COL_IS_UD_COL(f)       ((f&(~(TSDB_COL_NULL))) == TSDB_COL_UDC)
+#define TSDB_COL_IS_UD_COL(f) ((f & (~(TSDB_COL_NULL))) == TSDB_COL_UDC)
 #define TSDB_COL_REQ_NULL(f) (((f)&TSDB_COL_NULL) != 0)
 
-extern char *taosMsg[];
-
 typedef struct SBuildTableMetaInput {
   int32_t vgId;
-  char   *tableFullName;
+  char*   tableFullName;
 } SBuildTableMetaInput;
 
 typedef struct SBuildUseDBInput {
@@ -227,7 +132,6 @@ typedef struct SBuildUseDBInput {
   int32_t vgVersion;
 } SBuildUseDBInput;
 
-
 #pragma pack(push, 1)
 
 // null-terminated string instead of char array to avoid too many memory consumption in case of more than 1M tableMeta
@@ -312,7 +216,7 @@ typedef struct {
   char     data[];
 } SMDCreateTableMsg;
 
-//typedef struct {
+// typedef struct {
 //  int32_t len;  // one create table message
 //  char    tableName[TSDB_TABLE_FNAME_LEN];
 //  int16_t numOfColumns;
@@ -493,7 +397,7 @@ typedef struct SColumnFilterList {
   int16_t numOfFilters;
   union {
     int64_t            placeholder;
-    SColumnFilterInfo *filterInfo;
+    SColumnFilterInfo* filterInfo;
   };
 } SColumnFilterList;
 /*
@@ -578,7 +482,7 @@ typedef struct {
   int32_t     sqlstrLen;      // sql query string
   int32_t     prevResultLen;  // previous result length
   int32_t     numOfOperator;
-  int32_t     tableScanOperator;// table scan operator. -1 means no scan operator
+  int32_t     tableScanOperator;  // table scan operator. -1 means no scan operator
   int32_t     udfNum;             // number of udf function
   int32_t     udfContentOffset;
   int32_t     udfContentLen;
@@ -882,7 +786,7 @@ typedef struct SMultiTableMeta {
 typedef struct {
   int32_t dataLen;
   char    name[TSDB_TABLE_FNAME_LEN];
-  char   *data;
+  char*   data;
 } STagData;
 
 typedef struct {
@@ -1019,35 +923,27 @@ typedef struct {
 
 // mq related
 typedef struct {
-
 } SMqConnectReq;
 
 typedef struct {
-
 } SMqConnectRsp;
 
 typedef struct {
-
 } SMqDisconnectReq;
 
 typedef struct {
-
 } SMqDisconnectRsp;
 
 typedef struct {
-
 } SMqAckReq;
 
 typedef struct {
-
 } SMqAckRsp;
 
 typedef struct {
-
 } SMqResetReq;
 
 typedef struct {
-
 } SMqResetRsp;
 // mq related end
 
@@ -1142,7 +1038,6 @@ typedef struct SSchedulerStatusRsp {
   STaskStatus status[];
 } SSchedulerStatusRsp;
 
-
 typedef struct STaskCancelMsg {
   uint64_t schedulerId;
   uint64_t queryId;
@@ -1163,6 +1058,42 @@ typedef struct STaskDropRsp {
   int32_t code;
 } STaskDropRsp;
 
+typedef struct {
+  char    name[TSDB_TOPIC_FNAME_LEN];
+  int8_t  igExists;
+  int32_t execLen;
+  void*   executor;
+  int32_t sqlLen;
+  char*   sql;
+} SCreateTopicMsg;
+
+typedef struct {
+  char   name[TSDB_TABLE_FNAME_LEN];
+  int8_t igNotExists;
+} SDropTopicMsg;
+
+typedef struct {
+  char    name[TSDB_TABLE_FNAME_LEN];
+  int8_t  alterType;
+  SSchema schema;
+} SAlterTopicMsg;
+
+typedef struct {
+  SMsgHead head;
+  char     name[TSDB_TABLE_FNAME_LEN];
+  uint64_t tuid;
+  int32_t  sverson;
+  int32_t  execLen;
+  char*    executor;
+  int32_t  sqlLen;
+  char*    sql;
+} SCreateTopicInternalMsg;
+
+typedef struct {
+  SMsgHead head;
+  char     name[TSDB_TABLE_FNAME_LEN];
+  uint64_t tuid;
+} SDropTopicInternalMsg;
 
 #pragma pack(pop)
 

include/common/tmsgdef.h

@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if 0
+#undef TD_MSG_INFO_
+#undef TD_MSG_NUMBER_
+#undef TD_MSG_DICT_
+#undef TD_MSG_SEG_CODE_
+#endif
+
+#if defined(TD_MSG_INFO_)
+
+#undef TD_NEW_MSG_SEG
+#undef TD_DEF_MSG_TYPE
+#define TD_NEW_MSG_SEG(TYPE) "null",
+#define TD_DEF_MSG_TYPE(TYPE, MSG, REQ, RSP) MSG, MSG "-rsp",
+
+char *tMsgInfo[] = {
+
+#elif defined(TD_MSG_NUMBER_)
+
+#undef TD_NEW_MSG_SEG
+#undef TD_DEF_MSG_TYPE
+#define TD_NEW_MSG_SEG(TYPE) TYPE##_NUM,
+#define TD_DEF_MSG_TYPE(TYPE, MSG, REQ, RSP) TYPE##_NUM, TYPE##_RSP_NUM,
+
+enum {
+
+#elif defined(TD_MSG_DICT_)
+
+#undef TD_NEW_MSG_SEG
+#undef TD_DEF_MSG_TYPE
+#define TD_NEW_MSG_SEG(TYPE) TYPE##_NUM,
+#define TD_DEF_MSG_TYPE(TYPE, MSG, REQ, RSP)
+
+int tMsgDict[] = {
+
+#elif defined(TD_MSG_SEG_CODE_)
+
+#undef TD_NEW_MSG_SEG
+#undef TD_DEF_MSG_TYPE
+#define TD_NEW_MSG_SEG(TYPE) TYPE##_SEG_CODE,
+#define TD_DEF_MSG_TYPE(TYPE, MSG, REQ, RSP)
+
+enum {
+
+#else
+
+#undef TD_NEW_MSG_SEG
+#undef TD_DEF_MSG_TYPE
+#define TD_NEW_MSG_SEG(TYPE) TYPE = ((TYPE##_SEG_CODE) << 8),
+#define TD_DEF_MSG_TYPE(TYPE, MSG, REQ, RSP) TYPE, TYPE##_RSP,
+
+enum {
+#endif
+  // Requests handled by DNODE
+  TD_NEW_MSG_SEG(TDMT_DND_MSG)
+  TD_DEF_MSG_TYPE(TDMT_DND_NETWORK_TEST, "dnode-nettest", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_DND_CREATE_VNODE, "dnode-create-vnode", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_DND_ALTER_VNODE, "dnode-alter-vnode", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_DND_DROP_VNODE, "dnode-drop-vnode", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_DND_AUTH_VNODE, "dnode-auth-vnode", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_DND_SYNC_VNODE, "dnode-sync-vnode", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_DND_COMPACT_VNODE, "dnode-compact-vnode", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_DND_CREATE_MNODE, "dnode-create-mnode", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_DND_ALTER_MNODE, "dnode-alter-mnode", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_DND_DROP_MNODE, "dnode-drop-mnode", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_DND_CONFIG_DNODE, "dnode-config-dnode", NULL, NULL)
+
+  // Requests handled by MNODE
+  TD_NEW_MSG_SEG(TDMT_MND_MSG)
+  TD_DEF_MSG_TYPE(TDMT_MND_CONNECT, "mnode-connect", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_CREATE_TABLE, "mnode-create-table", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_DROP_TABLE, "mnode-drop-table", NULL, NULL)	
+  TD_DEF_MSG_TYPE(TDMT_MND_CREATE_ACCT, "mnode-create-acct", NULL, NULL)	
+  TD_DEF_MSG_TYPE(TDMT_MND_ALTER_ACCT, "mnode-alter-acct", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_DROP_ACCT, "mnode-drop-acct", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_CREATE_USER, "mnode-create-user", NULL, NULL)	
+  TD_DEF_MSG_TYPE(TDMT_MND_ALTER_USER, "mnode-alter-user", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_DROP_USER, "mnode-drop-user", NULL, NULL) 
+  TD_DEF_MSG_TYPE(TDMT_MND_CREATE_DNODE, "mnode-create-dnode", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_CONFIG_DNODE, "mnode-config-dnode", NULL, NULL) 
+  TD_DEF_MSG_TYPE(TDMT_MND_DROP_DNODE, "mnode-drop-dnode", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_CREATE_MNODE, "mnode-create-mnode", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_DROP_MNODE, "mnode-drop-mnode", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_CREATE_DB, "mnode-create-db", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_DROP_DB, "mnode-drop-db", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_USE_DB, "mnode-use-db", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_ALTER_DB, "mnode-alter-db", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_SYNC_DB, "mnode-sync-db", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_COMPACT_DB, "mnode-compact-db", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_CREATE_FUNCTION, "mnode-create-function", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_RETRIEVE_FUNCTION, "mnode-retrieve-function", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_DROP_FUNCTION, "mnode-drop-function", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_CREATE_STB, "mnode-create-stb", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_ALTER_STB, "mnode-alter-stb", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_DROP_STB, "mnode-drop-stb", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_VGROUP_LIST, "mnode-vgroup-list", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_KILL_QUERY, "mnode-kill-query", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_KILL_CONN, "mnode-kill-conn", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_HEARTBEAT, "mnode-heartbeat", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_SHOW, "mnode-show", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_SHOW_RETRIEVE, "mnode-retrieve", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_STATUS, "mnode-status", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_GRANT, "mnode-grant", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_AUTH, "mnode-auth", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_CREATE_TOPIC, "mnode-create-topic", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_ALTER_TOPIC, "mnode-alter-topic", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_DROP_TOPIC, "mnode-drop-topic", NULL, NULL)
+
+  // Requests handled by VNODE
+  TD_NEW_MSG_SEG(TDMT_VND_MSG)
+  TD_DEF_MSG_TYPE(TDMT_VND_SUBMIT, "vnode-submit", SSubmitReq, SSubmitRsp)
+  TD_DEF_MSG_TYPE(TDMT_VND_QUERY, "vnode-query", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_FETCH, "vnode-fetch", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_ALTER_TABLE, "vnode-alter-table", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_UPDATE_TAG_VAL, "vnode-update-tag-val", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_TABLE_META, "vnode-table-meta", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_TABLES_META, "vnode-tables-meta", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_MQ_CONSUME, "vnode-mq-consume", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_MQ_QUERY, "vnode-mq-query", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_MQ_CONNECT, "vnode-mq-connect", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_MQ_DISCONNECT, "vnode-mq-disconnect", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_MQ_SET_CUR, "vnode-mq-set-cur", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_RES_READY, "vnode-res-ready", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_TASKS_STATUS, "vnode-tasks-status", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_CANCEL_TASK, "vnode-cancel-task", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_DROP_TASK, "vnode-drop-task", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_CREATE_STB, "vnode-create-stb", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_ALTER_STB, "vnode-alter-stb", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_DROP_STB, "vnode-drop-stb", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_CREATE_TOPIC, "vnode-create-topic", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_ALTER_TOPIC, "vnode-alter-topic", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_DROP_TOPIC, "vnode-drop-topic", NULL, NULL)
+
+  // Requests handled by QNODE
+  TD_NEW_MSG_SEG(TDMT_QND_MSG)
+
+  // Requests handled by SNODE
+  TD_NEW_MSG_SEG(TDMT_SND_MSG)
+
+#if defined(TD_MSG_NUMBER_)
+  TDMT_MAX
+#endif
+};

include/common/tname.h

@@ -16,18 +16,22 @@
 #ifndef TDENGINE_TNAME_H
 #define TDENGINE_TNAME_H
 
+#include "tdef.h"
+
 #define TSDB_DB_NAME_T     1
 #define TSDB_TABLE_NAME_T  2
 
 #define T_NAME_ACCT        0x1u
 #define T_NAME_DB          0x2u
 #define T_NAME_TABLE       0x4u
+#define T_NAME_TOPIC       0x8u
 
 typedef struct SName {
   uint8_t type;  //db_name_t, table_name_t
   int32_t acctId;
   char    dbname[TSDB_DB_NAME_LEN];
   char    tname[TSDB_TABLE_NAME_LEN];
+  char    topicName[TSDB_TOPIC_NAME_LEN];
 } SName;
 
 int32_t tNameExtractFullName(const SName* name, char* dst);

include/common/ttime.h

@@ -21,7 +21,7 @@ extern "C" {
 #endif
 
 #include "taosdef.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 
 #define TIME_IS_VAR_DURATION(_t) ((_t) == 'n' || (_t) == 'y' || (_t) == 'N' || (_t) == 'Y')
 

include/dnode/mnode/sdb/sdb.h

@@ -16,6 +16,8 @@
 #ifndef _TD_SDB_H_
 #define _TD_SDB_H_
 
+#include "os.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -159,11 +161,12 @@ typedef enum {
   SDB_USER = 5,
   SDB_AUTH = 6,
   SDB_ACCT = 7,
-  SDB_VGROUP = 8,
+  SDB_TOPIC = 8,
-  SDB_STB = 9,
+  SDB_VGROUP = 9,
-  SDB_DB = 10,
+  SDB_STB = 10,
-  SDB_FUNC = 11,
+  SDB_DB = 11,
-  SDB_MAX = 12
+  SDB_FUNC = 12,
+  SDB_MAX = 13
 } ESdbType;
 
 typedef struct SSdb SSdb;

include/dnode/vnode/tq/tq.h

@@ -20,7 +20,7 @@
 #include "mallocator.h"
 #include "os.h"
 #include "taoserror.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "tlist.h"
 #include "trpc.h"
 #include "ttimer.h"

include/dnode/vnode/vnode.h

@@ -246,8 +246,8 @@ static FORCE_INLINE void vnodeSetCreateNtbReq(SVnodeReq *pReq, char *name, uint3
   pReq->ctReq.ntbCfg.pSchema = pSchema;
 }
 
-int   vnodeBuildReq(void **buf, const SVnodeReq *pReq, uint8_t type);
+int   vnodeBuildReq(void **buf, const SVnodeReq *pReq, tmsg_t type);
-void *vnodeParseReq(void *buf, SVnodeReq *pReq, uint8_t type);
+void *vnodeParseReq(void *buf, SVnodeReq *pReq, tmsg_t type);
 
 /* ------------------------ FOR COMPILE ------------------------ */
 

include/libs/catalog/catalog.h

@@ -26,7 +26,7 @@ extern "C" {
 #include "taosdef.h"
 #include "transport.h"
 #include "common.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "query.h"
 
 struct SCatalog;

include/libs/planner/planner.h

@@ -20,7 +20,7 @@
 extern "C" {
 #endif
 
-#include "taosmsg.h"
+#include "tmsg.h"
 
 #define QUERY_TYPE_MERGE       1
 #define QUERY_TYPE_PARTIAL     2

include/libs/qcom/query.h

@@ -112,8 +112,8 @@ 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 (*queryBuildMsg[TDMT_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);
+extern int32_t (*queryProcessMsgRsp[TDMT_MAX])(void* output, char *msg, int32_t msgSize);
 
 #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)

include/libs/transport/trpc.h

@@ -22,7 +22,7 @@ extern "C" {
 #include <stdbool.h>
 #include <stdint.h>
 #include "taosdef.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 
 #define TAOS_CONN_SERVER 0
 #define TAOS_CONN_CLIENT 1
@@ -37,17 +37,17 @@ typedef struct SRpcConnInfo {
 } SRpcConnInfo;
 
 typedef struct SRpcMsg {
-  uint8_t msgType;
+  tmsg_t  msgType;
-  void   *pCont;
+  void *  pCont;
   int     contLen;
   int32_t code;
-  void   *handle;   // rpc handle returned to app
+  void *  handle;   // rpc handle returned to app
-  void   *ahandle;  // app handle set by client
+  void *  ahandle;  // app handle set by client
 } SRpcMsg;
 
 typedef struct SRpcInit {
   uint16_t localPort;     // local port
-  char  *label;        // for debug purpose
+  char *   label;         // for debug purpose
   int      numOfThreads;  // number of threads to handle connections
   int      sessions;      // number of sessions allowed
   int8_t   connType;      // TAOS_CONN_UDP, TAOS_CONN_TCPC, TAOS_CONN_TCPS
@@ -71,11 +71,11 @@ typedef struct SRpcInit {
 
 int32_t rpcInit();
 void    rpcCleanup();
-void *rpcOpen(const SRpcInit *pRpc);
+void *  rpcOpen(const SRpcInit *pRpc);
 void    rpcClose(void *);
-void *rpcMallocCont(int contLen);
+void *  rpcMallocCont(int contLen);
 void    rpcFreeCont(void *pCont);
-void *rpcReallocCont(void *ptr, int contLen);
+void *  rpcReallocCont(void *ptr, int contLen);
 void    rpcSendRequest(void *thandle, const SEpSet *pEpSet, SRpcMsg *pMsg, int64_t *rid);
 void    rpcSendResponse(const SRpcMsg *pMsg);
 void    rpcSendRedirectRsp(void *pConn, const SEpSet *pEpSet);

include/util/taoserror.h

@@ -220,6 +220,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_MND_COLUMN_ALREAY_EXIST       TAOS_DEF_ERROR_CODE(0, 0x03AA)
 #define TSDB_CODE_MND_COLUMN_NOT_EXIST          TAOS_DEF_ERROR_CODE(0, 0x03AB)
 #define TSDB_CODE_MND_EXCEED_MAX_ROW_BYTES      TAOS_DEF_ERROR_CODE(0, 0x03AC)
+#define TSDB_CODE_MND_NAME_CONFLICT_WITH_TOPIC  TAOS_DEF_ERROR_CODE(0, 0x03AD)
 
 // mnode-func
 #define TSDB_CODE_MND_FUNC_ALREADY_EXIST        TAOS_DEF_ERROR_CODE(0, 0x03C0)
@@ -234,6 +235,15 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_MND_TRANS_ALREADY_EXIST       TAOS_DEF_ERROR_CODE(0, 0x03D0)
 #define TSDB_CODE_MND_TRANS_NOT_EXIST           TAOS_DEF_ERROR_CODE(0, 0x03D1)
 
+// mnode-topic
+#define TSDB_CODE_MND_TOPIC_ALREADY_EXIST       TAOS_DEF_ERROR_CODE(0, 0x03E0)
+#define TSDB_CODE_MND_TOPIC_NOT_EXIST           TAOS_DEF_ERROR_CODE(0, 0x03E1)
+#define TSDB_CODE_MND_TOO_MANY_TOPICS           TAOS_DEF_ERROR_CODE(0, 0x03E2)
+#define TSDB_CODE_MND_INVALID_TOPIC             TAOS_DEF_ERROR_CODE(0, 0x03E3)
+#define TSDB_CODE_MND_INVALID_TOPIC_OPTION      TAOS_DEF_ERROR_CODE(0, 0x03E4)
+#define TSDB_CODE_MND_TOPIC_OPTION_UNCHNAGED    TAOS_DEF_ERROR_CODE(0, 0x03E5)
+#define TSDB_CODE_MND_NAME_CONFLICT_WITH_STB    TAOS_DEF_ERROR_CODE(0, 0x03E6)
+
 // dnode
 #define TSDB_CODE_DND_ACTION_IN_PROGRESS        TAOS_DEF_ERROR_CODE(0, 0x0400)
 #define TSDB_CODE_DND_EXITING                   TAOS_DEF_ERROR_CODE(0, 0x0401)

include/util/tdef.h

@@ -163,6 +163,7 @@ do { \
 
 #define TSDB_NODE_NAME_LEN        64
 #define TSDB_TABLE_NAME_LEN       193     // it is a null-terminated string
+#define TSDB_TOPIC_NAME_LEN       193     // it is a null-terminated string
 #define TSDB_DB_NAME_LEN          65
 #define TSDB_FULL_DB_NAME_LEN     (TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN)
 
@@ -175,6 +176,7 @@ do { \
 
 #define TSDB_TYPE_STR_MAX_LEN     32
 #define TSDB_TABLE_FNAME_LEN      (TSDB_FULL_DB_NAME_LEN + TSDB_TABLE_NAME_LEN)
+#define TSDB_TOPIC_FNAME_LEN      TSDB_TABLE_FNAME_LEN
 #define TSDB_COL_NAME_LEN         65
 #define TSDB_MAX_SAVED_SQL_LEN    TSDB_MAX_COLUMNS * 64
 #define TSDB_MAX_SQL_LEN          TSDB_PAYLOAD_SIZE

source/client/inc/clientInt.h

@@ -22,7 +22,7 @@ extern "C" {
 
 #include "taos.h"
 #include "common.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "tdef.h"
 #include "tep.h"
 #include "thash.h"
@@ -141,7 +141,7 @@ extern int32_t    tscReqRef;
 extern int32_t    tscConnRef;
 
 SRequestMsgBody buildRequestMsgImpl(SRequestObj *pRequest);
-extern int (*handleRequestRspFp[TSDB_MSG_TYPE_MAX])(SRequestObj *pRequest, const char* pMsg, int32_t msgLen);
+extern int (*handleRequestRspFp[TDMT_MAX])(SRequestObj *pRequest, const char* pMsg, int32_t msgLen);
 
 int   taos_init();
 

source/client/src/clientEnv.c

@@ -18,7 +18,7 @@
 #include "clientLog.h"
 #include "os.h"
 #include "query.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "tcache.h"
 #include "tconfig.h"
 #include "tglobal.h"

source/client/src/clientImpl.c

@@ -167,7 +167,7 @@ int32_t execDdlQuery(SRequestObj* pRequest, SQueryNode* pQuery) {
   SRequestMsgBody body = buildRequestMsgImpl(pRequest);
   SEpSet* pEpSet = &pRequest->pTscObj->pAppInfo->mgmtEp.epSet;
 
-  if (pDcl->msgType == TSDB_MSG_TYPE_CREATE_TABLE) {
+  if (pDcl->msgType == TDMT_MND_CREATE_TABLE) {
     struct SCatalog* pCatalog = NULL;
 
     char buf[12] = {0};
@@ -289,7 +289,7 @@ STscObj* taosConnectImpl(const char *ip, const char *user, const char *auth, con
     return pTscObj;
   }
 
-  SRequestObj *pRequest = createRequest(pTscObj, fp, param, TSDB_MSG_TYPE_CONNECT);
+  SRequestObj *pRequest = createRequest(pTscObj, fp, param, TDMT_MND_CONNECT);
   if (pRequest == NULL) {
     destroyTscObj(pTscObj);
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -321,7 +321,7 @@ STscObj* taosConnectImpl(const char *ip, const char *user, const char *auth, con
 }
 
 static int32_t buildConnectMsg(SRequestObj *pRequest, SRequestMsgBody* pMsgBody) {
-  pMsgBody->msgType         = TSDB_MSG_TYPE_CONNECT;
+  pMsgBody->msgType         = TDMT_MND_CONNECT;
   pMsgBody->msgInfo.len     = sizeof(SConnectMsg);
   pMsgBody->requestObjRefId = pRequest->self;
 
@@ -353,7 +353,7 @@ static void destroyRequestMsgBody(SRequestMsgBody* pMsgBody) {
 int32_t sendMsgToServer(void *pTransporter, SEpSet* epSet, const SRequestMsgBody *pBody, int64_t* pTransporterId) {
   char *pMsg = rpcMallocCont(pBody->msgInfo.len);
   if (NULL == pMsg) {
-    tscError("0x%"PRIx64" msg:%s malloc failed", pBody->requestId, taosMsg[pBody->msgType]);
+    tscError("0x%"PRIx64" msg:%s malloc failed", pBody->requestId, TMSG_INFO(pBody->msgType));
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
     return -1;
   }
@@ -398,7 +398,7 @@ void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) {
    * The actual inserted number of points is the first number.
    */
   if (pMsg->code == TSDB_CODE_SUCCESS) {
-    tscDebug("0x%" PRIx64 " message:%s, code:%s rspLen:%d, elapsed:%"PRId64 " ms", pRequest->requestId, taosMsg[pMsg->msgType],
+    tscDebug("0x%" PRIx64 " message:%s, code:%s rspLen:%d, elapsed:%"PRId64 " ms", pRequest->requestId, TMSG_INFO(pMsg->msgType),
              tstrerror(pMsg->code), pMsg->contLen, pRequest->metric.rsp - pRequest->metric.start);
     if (handleRequestRspFp[pRequest->type]) {
       char *p = malloc(pMsg->contLen);
@@ -411,7 +411,7 @@ void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) {
       }
     }
   } else {
-    tscError("0x%" PRIx64 " SQL cmd:%s, code:%s rspLen:%d, elapsed time:%"PRId64" ms", pRequest->requestId, taosMsg[pMsg->msgType],
+    tscError("0x%" PRIx64 " SQL cmd:%s, code:%s rspLen:%d, elapsed time:%"PRId64" ms", pRequest->requestId, TMSG_INFO(pMsg->msgType),
              tstrerror(pMsg->code), pMsg->contLen, pRequest->metric.rsp - pRequest->metric.start);
   }
 
@@ -453,7 +453,7 @@ void* doFetchRow(SRequestObj* pRequest) {
   SReqResultInfo* pResultInfo = &pRequest->body.resInfo;
 
   if (pResultInfo->pData == NULL || pResultInfo->current >= pResultInfo->numOfRows) {
-    pRequest->type = TSDB_MSG_TYPE_SHOW_RETRIEVE;
+    pRequest->type = TDMT_MND_SHOW_RETRIEVE;
 
     SRequestMsgBody body = buildRequestMsgImpl(pRequest);
 

source/client/src/clientMain.c

@@ -2,7 +2,7 @@
 #include "clientInt.h"
 #include "clientLog.h"
 #include "query.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "tglobal.h"
 #include "tref.h"
 #include "trpc.h"

source/client/src/clientMsgHandler.c

@@ -21,10 +21,10 @@
 #include "tmsgtype.h"
 #include "trpc.h"
 
-int (*handleRequestRspFp[TSDB_MSG_TYPE_MAX])(SRequestObj *pRequest, const char* pMsg, int32_t msgLen);
+int (*handleRequestRspFp[TDMT_MAX])(SRequestObj *pRequest, const char* pMsg, int32_t msgLen);
 
 int32_t buildConnectMsg(SRequestObj *pRequest, SRequestMsgBody* pMsgBody) {
-  pMsgBody->msgType         = TSDB_MSG_TYPE_CONNECT;
+  pMsgBody->msgType         = TDMT_MND_CONNECT;
   pMsgBody->msgInfo.len     = sizeof(SConnectMsg);
   pMsgBody->requestObjRefId = pRequest->self;
 
@@ -87,7 +87,7 @@ int processConnectRsp(SRequestObj *pRequest, const char* pMsg, int32_t msgLen) {
 }
 
 static int32_t buildRetrieveMnodeMsg(SRequestObj *pRequest, SRequestMsgBody* pMsgBody) {
-  pMsgBody->msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE;
+  pMsgBody->msgType = TDMT_MND_SHOW_RETRIEVE;
   pMsgBody->msgInfo.len = sizeof(SRetrieveTableMsg);
   pMsgBody->requestObjRefId = pRequest->self;
 
@@ -102,7 +102,7 @@ static int32_t buildRetrieveMnodeMsg(SRequestObj *pRequest, SRequestMsgBody* pMs
 }
 
 SRequestMsgBody buildRequestMsgImpl(SRequestObj *pRequest) {
-  if (pRequest->type == TSDB_MSG_TYPE_SHOW_RETRIEVE) {
+  if (pRequest->type == TDMT_MND_SHOW_RETRIEVE) {
     SRequestMsgBody body = {0};
     buildRetrieveMnodeMsg(pRequest, &body);
     return body;
@@ -273,11 +273,11 @@ void initMsgHandleFp() {
   tscProcessMsgRsp[TSDB_SQL_SHOW_CREATE_DATABASE] = tscProcessShowCreateRsp;
 #endif
 
-  handleRequestRspFp[TSDB_MSG_TYPE_CONNECT]       = processConnectRsp;
+  handleRequestRspFp[TDMT_MND_CONNECT]       = processConnectRsp;
-  handleRequestRspFp[TSDB_MSG_TYPE_SHOW]          = processShowRsp;
+  handleRequestRspFp[TDMT_MND_SHOW]          = processShowRsp;
-  handleRequestRspFp[TSDB_MSG_TYPE_SHOW_RETRIEVE] = processRetrieveMnodeRsp;
+  handleRequestRspFp[TDMT_MND_SHOW_RETRIEVE] = processRetrieveMnodeRsp;
-  handleRequestRspFp[TSDB_MSG_TYPE_CREATE_DB]     = processCreateDbRsp;
+  handleRequestRspFp[TDMT_MND_CREATE_DB]     = processCreateDbRsp;
-  handleRequestRspFp[TSDB_MSG_TYPE_USE_DB]        = processUseDbRsp;
+  handleRequestRspFp[TDMT_MND_USE_DB]        = processUseDbRsp;
-  handleRequestRspFp[TSDB_MSG_TYPE_CREATE_TABLE]  = processCreateTableRsp;
+  handleRequestRspFp[TDMT_MND_CREATE_TABLE]  = processCreateTableRsp;
-  handleRequestRspFp[TSDB_MSG_TYPE_DROP_DB]       = processDropDbRsp;
+  handleRequestRspFp[TDMT_MND_DROP_DB]       = processDropDbRsp;
 }

source/common/src/tmsg.c

@@ -13,8 +13,16 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#define TAOS_MESSAGE_C
+#include "tmsg.h"
-
-#include "taosmsg.h"
 
+#undef TD_MSG_NUMBER_
+#undef TD_MSG_DICT_
+#define TD_MSG_INFO_
+#undef TD_MSG_SEG_CODE_
+#include "tmsgdef.h"
 
+#undef TD_MSG_NUMBER_
+#undef TD_MSG_INFO_
+#define TD_MSG_DICT_
+#undef TD_MSG_SEG_CODE_
+#include "tmsgdef.h"

source/common/src/tname.c

@@ -2,7 +2,7 @@
 #include "tutil.h"
 
 #include "tname.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 
 #define VALID_NAME_TYPE(x)  ((x) == TSDB_DB_NAME_T || (x) == TSDB_TABLE_NAME_T)
 

source/common/test/CMakeLists.txt

@@ -16,3 +16,13 @@ TARGET_INCLUDE_DIRECTORIES(
         PUBLIC "${CMAKE_SOURCE_DIR}/include/libs/common/"
         PRIVATE "${CMAKE_SOURCE_DIR}/source/libs/common/inc"
 )
+
+# tmsg test
+add_executable(tmsgTest "")
+target_sources(tmsgTest 
+        PRIVATE
+        "tmsgTest.cpp"
+        "../src/tmsg.c"
+)
+target_include_directories(tmsgTest PUBLIC "${CMAKE_SOURCE_DIR}/include/common/")
+target_link_libraries(tmsgTest PUBLIC os util gtest gtest_main)

source/common/test/tmsgTest.cpp

@@ -0,0 +1,11 @@
+#include <iostream>
+
+#include "gtest/gtest.h"
+
+#include "tmsg.h"
+
+TEST(td_msg_test, simple_msg_test) {
+  // std::cout << TMSG_INFO(TDMT_VND_DROP_TABLE) << std::endl;
+  // std::cout << TMSG_INFO(TDMT_MND_DROP_SUPER_TABLE) << std::endl;
+  // std::cout << TMSG_INFO(TDMT_MND_CREATE_SUPER_TABLE) << std::endl;
+}

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

@@ -22,7 +22,7 @@ extern "C" {
 
 #include "cJSON.h"
 #include "os.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "thash.h"
 #include "tlockfree.h"
 #include "tlog.h"
@@ -105,7 +105,7 @@ typedef struct {
 typedef struct {
   void    *serverRpc;
   void    *clientRpc;
-  DndMsgFp msgFp[TSDB_MSG_TYPE_MAX];
+  DndMsgFp msgFp[TDMT_MAX];
 } STransMgmt;
 
 typedef struct SDnode {

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

@@ -68,7 +68,7 @@ void dndSendRedirectMsg(SDnode *pDnode, SRpcMsg *pMsg) {
   SEpSet epSet = {0};
   dndGetMnodeEpSet(pDnode, &epSet);
 
-  dDebug("RPC %p, msg:%s is redirected, num:%d inUse:%d", pMsg->handle, taosMsg[msgType], epSet.numOfEps, epSet.inUse);
+  dDebug("RPC %p, msg:%s is redirected, num:%d inUse:%d", pMsg->handle, TMSG_INFO(msgType), epSet.numOfEps, epSet.inUse);
   for (int32_t i = 0; i < epSet.numOfEps; ++i) {
     dDebug("mnode index:%d %s:%u", i, epSet.fqdn[i], epSet.port[i]);
     if (strcmp(epSet.fqdn[i], pDnode->opt.localFqdn) == 0 && epSet.port[i] == pDnode->opt.serverPort) {
@@ -369,7 +369,7 @@ void dndSendStatusMsg(SDnode *pDnode) {
   dndGetVnodeLoads(pDnode, &pStatus->vnodeLoads);
   contLen = sizeof(SStatusMsg) + pStatus->vnodeLoads.num * sizeof(SVnodeLoad);
 
-  SRpcMsg rpcMsg = {.pCont = pStatus, .contLen = contLen, .msgType = TSDB_MSG_TYPE_STATUS};
+  SRpcMsg rpcMsg = {.pCont = pStatus, .contLen = contLen, .msgType = TDMT_MND_STATUS};
   pMgmt->statusSent = 1;
 
   dTrace("pDnode:%p, send status msg to mnode", pDnode);
@@ -556,14 +556,14 @@ void dndCleanupDnode(SDnode *pDnode) {
 
 void dndProcessDnodeReq(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
   switch (pMsg->msgType) {
-    case TSDB_MSG_TYPE_NETWORK_TEST:
+    case TDMT_DND_NETWORK_TEST:
       dndProcessStartupReq(pDnode, pMsg);
       break;
-    case TSDB_MSG_TYPE_CONFIG_DNODE_IN:
+    case TDMT_DND_CONFIG_DNODE:
       dndProcessConfigDnodeReq(pDnode, pMsg);
       break;
     default:
-      dError("RPC %p, dnode req:%s not processed", pMsg->handle, taosMsg[pMsg->msgType]);
+      dError("RPC %p, dnode req:%s not processed", pMsg->handle, TMSG_INFO(pMsg->msgType));
       SRpcMsg rspMsg = {.handle = pMsg->handle, .code = TSDB_CODE_MSG_NOT_PROCESSED};
       rpcSendResponse(&rspMsg);
   }
@@ -574,17 +574,17 @@ void dndProcessDnodeReq(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
 
 void dndProcessDnodeRsp(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
   switch (pMsg->msgType) {
-    case TSDB_MSG_TYPE_STATUS_RSP:
+    case TDMT_MND_STATUS_RSP:
       dndProcessStatusRsp(pDnode, pMsg, pEpSet);
       break;
-    case TSDB_MSG_TYPE_AUTH_RSP:
+    case TDMT_MND_AUTH_RSP:
       dndProcessAuthRsp(pDnode, pMsg, pEpSet);
       break;
-    case TSDB_MSG_TYPE_GRANT_RSP:
+    case TDMT_MND_GRANT_RSP:
       dndProcessGrantRsp(pDnode, pMsg, pEpSet);
       break;
     default:
-      dError("RPC %p, dnode rsp:%s not processed", pMsg->handle, taosMsg[pMsg->msgType]);
+      dError("RPC %p, dnode rsp:%s not processed", pMsg->handle, TMSG_INFO(pMsg->msgType));
   }
 
   rpcFreeCont(pMsg->pCont);

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

@@ -552,13 +552,13 @@ static void dndProcessMnodeMgmtQueue(SDnode *pDnode, SRpcMsg *pMsg) {
   int32_t code = 0;
 
   switch (pMsg->msgType) {
-    case TSDB_MSG_TYPE_CREATE_MNODE_IN:
+    case TDMT_DND_CREATE_MNODE:
       code = dndProcessCreateMnodeReq(pDnode, pMsg);
       break;
-    case TSDB_MSG_TYPE_ALTER_MNODE_IN:
+    case TDMT_DND_ALTER_MNODE:
       code = dndProcessAlterMnodeReq(pDnode, pMsg);
       break;
-    case TSDB_MSG_TYPE_DROP_MNODE_IN:
+    case TDMT_DND_DROP_MNODE:
       code = dndProcessDropMnodeReq(pDnode, pMsg);
       break;
     default:

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

@@ -31,97 +31,97 @@
 
 static void dndInitMsgFp(STransMgmt *pMgmt) {
   // msg from client to dnode
-  pMgmt->msgFp[TSDB_MSG_TYPE_SUBMIT] = dndProcessVnodeWriteMsg;
+  pMgmt->msgFp[TDMT_VND_SUBMIT] = dndProcessVnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_QUERY] = dndProcessVnodeQueryMsg;
+  pMgmt->msgFp[TDMT_VND_QUERY] = dndProcessVnodeQueryMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_FETCH] = dndProcessVnodeFetchMsg;
+  pMgmt->msgFp[TDMT_VND_FETCH] = dndProcessVnodeFetchMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_CREATE_TABLE] = dndProcessVnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_CREATE_TABLE] = dndProcessVnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_DROP_TABLE] = dndProcessVnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_DROP_TABLE] = dndProcessVnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_ALTER_TABLE] = dndProcessVnodeWriteMsg;
+  pMgmt->msgFp[TDMT_VND_ALTER_TABLE] = dndProcessVnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_UPDATE_TAG_VAL] = dndProcessVnodeWriteMsg;
+  pMgmt->msgFp[TDMT_VND_UPDATE_TAG_VAL] = dndProcessVnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_TABLE_META] = dndProcessMnodeReadMsg;
+  pMgmt->msgFp[TDMT_VND_TABLE_META] = dndProcessMnodeReadMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_TABLES_META] = dndProcessVnodeQueryMsg;
+  pMgmt->msgFp[TDMT_VND_TABLES_META] = dndProcessVnodeQueryMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_MQ_QUERY] = dndProcessVnodeQueryMsg;
+  pMgmt->msgFp[TDMT_VND_MQ_QUERY] = dndProcessVnodeQueryMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_MQ_CONSUME] = dndProcessVnodeQueryMsg;
+  pMgmt->msgFp[TDMT_VND_MQ_CONSUME] = dndProcessVnodeQueryMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_MQ_CONNECT] = dndProcessVnodeWriteMsg;
+  pMgmt->msgFp[TDMT_VND_MQ_CONNECT] = dndProcessVnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_MQ_DISCONNECT] = dndProcessVnodeWriteMsg;
+  pMgmt->msgFp[TDMT_VND_MQ_DISCONNECT] = dndProcessVnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_MQ_SET_CUR] = dndProcessVnodeWriteMsg;
+  pMgmt->msgFp[TDMT_VND_MQ_SET_CUR] = dndProcessVnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_RES_READY] = dndProcessVnodeFetchMsg;
+  pMgmt->msgFp[TDMT_VND_RES_READY] = dndProcessVnodeFetchMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_TASKS_STATUS] = dndProcessVnodeFetchMsg;
+  pMgmt->msgFp[TDMT_VND_TASKS_STATUS] = dndProcessVnodeFetchMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_CANCEL_TASK] = dndProcessVnodeFetchMsg;
+  pMgmt->msgFp[TDMT_VND_CANCEL_TASK] = dndProcessVnodeFetchMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_DROP_TASK] = dndProcessVnodeFetchMsg;
+  pMgmt->msgFp[TDMT_VND_DROP_TASK] = dndProcessVnodeFetchMsg;
 
   // msg from client to mnode
-  pMgmt->msgFp[TSDB_MSG_TYPE_CONNECT] = dndProcessMnodeReadMsg;
+  pMgmt->msgFp[TDMT_MND_CONNECT] = dndProcessMnodeReadMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_CREATE_ACCT] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_CREATE_ACCT] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_ALTER_ACCT] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_ALTER_ACCT] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_DROP_ACCT] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_DROP_ACCT] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_CREATE_USER] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_CREATE_USER] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_ALTER_USER] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_ALTER_USER] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_DROP_USER] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_DROP_USER] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_CREATE_DNODE] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_CREATE_DNODE] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_CONFIG_DNODE] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_CONFIG_DNODE] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_DROP_DNODE] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_DROP_DNODE] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_CREATE_MNODE] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_CREATE_MNODE] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_DROP_MNODE] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_DROP_MNODE] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_CREATE_DB] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_CREATE_DB] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_DROP_DB] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_DROP_DB] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_USE_DB] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_USE_DB] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_ALTER_DB] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_ALTER_DB] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_SYNC_DB] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_SYNC_DB] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_COMPACT_DB] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_COMPACT_DB] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_CREATE_FUNCTION] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_CREATE_FUNCTION] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_RETRIEVE_FUNCTION] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_RETRIEVE_FUNCTION] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_DROP_FUNCTION] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_DROP_FUNCTION] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_CREATE_STB] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_CREATE_STB] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_ALTER_STB] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_ALTER_STB] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_DROP_STB] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_DROP_STB] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_VGROUP_LIST] = dndProcessMnodeReadMsg;
+  pMgmt->msgFp[TDMT_MND_VGROUP_LIST] = dndProcessMnodeReadMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_KILL_QUERY] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_KILL_QUERY] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_KILL_CONN] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_KILL_CONN] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_HEARTBEAT] = dndProcessMnodeReadMsg;
+  pMgmt->msgFp[TDMT_MND_HEARTBEAT] = dndProcessMnodeReadMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_SHOW] = dndProcessMnodeReadMsg;
+  pMgmt->msgFp[TDMT_MND_SHOW] = dndProcessMnodeReadMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_SHOW_RETRIEVE] = dndProcessMnodeReadMsg;
+  pMgmt->msgFp[TDMT_MND_SHOW_RETRIEVE] = dndProcessMnodeReadMsg;
 
   // message from client to dnode
-  pMgmt->msgFp[TSDB_MSG_TYPE_NETWORK_TEST] = dndProcessDnodeReq;
+  pMgmt->msgFp[TDMT_DND_NETWORK_TEST] = dndProcessDnodeReq;
 
   // message from mnode to vnode
-  pMgmt->msgFp[TSDB_MSG_TYPE_CREATE_STB_IN] = dndProcessVnodeWriteMsg;
+  pMgmt->msgFp[TDMT_VND_CREATE_STB] = dndProcessVnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_CREATE_STB_IN_RSP] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_VND_CREATE_STB_RSP] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_ALTER_STB_IN] = dndProcessVnodeWriteMsg;
+  pMgmt->msgFp[TDMT_VND_ALTER_STB] = dndProcessVnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_ALTER_STB_IN_RSP] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_VND_ALTER_STB_RSP] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_DROP_STB_IN] = dndProcessVnodeWriteMsg;
+  pMgmt->msgFp[TDMT_VND_DROP_STB] = dndProcessVnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_DROP_STB_IN_RSP] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_VND_DROP_STB_RSP] = dndProcessMnodeWriteMsg;
 
   // message from mnode to dnode
-  pMgmt->msgFp[TSDB_MSG_TYPE_CREATE_VNODE_IN] = dndProcessVnodeMgmtMsg;
+  pMgmt->msgFp[TDMT_DND_CREATE_VNODE] = dndProcessVnodeMgmtMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_CREATE_VNODE_IN_RSP] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_DND_CREATE_VNODE_RSP] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_ALTER_VNODE_IN] = dndProcessVnodeMgmtMsg;
+  pMgmt->msgFp[TDMT_DND_ALTER_VNODE] = dndProcessVnodeMgmtMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_ALTER_VNODE_IN_RSP] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_DND_ALTER_VNODE_RSP] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_DROP_VNODE_IN] = dndProcessVnodeMgmtMsg;
+  pMgmt->msgFp[TDMT_DND_DROP_VNODE] = dndProcessVnodeMgmtMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_DROP_VNODE_IN_RSP] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_DND_DROP_VNODE_RSP] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_SYNC_VNODE_IN] = dndProcessVnodeMgmtMsg;
+  pMgmt->msgFp[TDMT_DND_SYNC_VNODE] = dndProcessVnodeMgmtMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_SYNC_VNODE_IN_RSP] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_DND_SYNC_VNODE_RSP] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_AUTH_VNODE_IN] = dndProcessVnodeMgmtMsg;
+  pMgmt->msgFp[TDMT_DND_AUTH_VNODE] = dndProcessVnodeMgmtMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_AUTH_VNODE_IN_RSP] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_DND_AUTH_VNODE_RSP] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_COMPACT_VNODE_IN] = dndProcessVnodeMgmtMsg;
+  pMgmt->msgFp[TDMT_DND_COMPACT_VNODE] = dndProcessVnodeMgmtMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_COMPACT_VNODE_IN_RSP] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_DND_COMPACT_VNODE_RSP] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_CREATE_MNODE_IN] = dndProcessMnodeMgmtMsg;
+  pMgmt->msgFp[TDMT_DND_CREATE_MNODE] = dndProcessMnodeMgmtMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_CREATE_MNODE_IN_RSP] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_DND_CREATE_MNODE_RSP] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_ALTER_MNODE_IN] = dndProcessMnodeMgmtMsg;
+  pMgmt->msgFp[TDMT_DND_ALTER_MNODE] = dndProcessMnodeMgmtMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_ALTER_MNODE_IN_RSP] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_DND_ALTER_MNODE_RSP] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_DROP_MNODE_IN] = dndProcessMnodeMgmtMsg;
+  pMgmt->msgFp[TDMT_DND_DROP_MNODE] = dndProcessMnodeMgmtMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_DROP_MNODE_IN_RSP] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_DND_DROP_MNODE_RSP] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_CONFIG_DNODE_IN] = dndProcessDnodeReq;
+  pMgmt->msgFp[TDMT_DND_CONFIG_DNODE] = dndProcessDnodeReq;
-  pMgmt->msgFp[TSDB_MSG_TYPE_CONFIG_DNODE_IN_RSP] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_DND_CONFIG_DNODE_RSP] = dndProcessMnodeWriteMsg;
 
   // message from dnode to mnode
-  pMgmt->msgFp[TSDB_MSG_TYPE_GRANT] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_GRANT] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_GRANT_RSP] = dndProcessDnodeRsp;
+  pMgmt->msgFp[TDMT_MND_GRANT_RSP] = dndProcessDnodeRsp;
-  pMgmt->msgFp[TSDB_MSG_TYPE_STATUS] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TDMT_MND_STATUS] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_STATUS_RSP] = dndProcessDnodeRsp;
+  pMgmt->msgFp[TDMT_MND_STATUS_RSP] = dndProcessDnodeRsp;
-  pMgmt->msgFp[TSDB_MSG_TYPE_AUTH] = dndProcessMnodeReadMsg;
+  pMgmt->msgFp[TDMT_MND_AUTH] = dndProcessMnodeReadMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_AUTH_RSP] = dndProcessDnodeRsp;
+  pMgmt->msgFp[TDMT_MND_AUTH_RSP] = dndProcessDnodeRsp;
 }
 
 static void dndProcessResponse(void *parent, SRpcMsg *pMsg, SEpSet *pEpSet) {
@@ -132,7 +132,7 @@ static void dndProcessResponse(void *parent, SRpcMsg *pMsg, SEpSet *pEpSet) {
 
   if (dndGetStat(pDnode) == DND_STAT_STOPPED) {
     if (pMsg == NULL || pMsg->pCont == NULL) return;
-    dTrace("RPC %p, rsp:%s is ignored since dnode is stopping", pMsg->handle, taosMsg[msgType]);
+    dTrace("RPC %p, rsp:%s is ignored since dnode is stopping", pMsg->handle, TMSG_INFO(msgType));
     rpcFreeCont(pMsg->pCont);
     return;
   }
@@ -140,9 +140,9 @@ static void dndProcessResponse(void *parent, SRpcMsg *pMsg, SEpSet *pEpSet) {
   DndMsgFp fp = pMgmt->msgFp[msgType];
   if (fp != NULL) {
     (*fp)(pDnode, pMsg, pEpSet);
-    dTrace("RPC %p, rsp:%s is processed, code:0x%x", pMsg->handle, taosMsg[msgType], pMsg->code & 0XFFFF);
+    dTrace("RPC %p, rsp:%s is processed, code:0x%x", pMsg->handle, TMSG_INFO(msgType), pMsg->code & 0XFFFF);
   } else {
-    dError("RPC %p, rsp:%s not processed", pMsg->handle, taosMsg[msgType]);
+    dError("RPC %p, rsp:%s not processed", pMsg->handle, TMSG_INFO(msgType));
     rpcFreeCont(pMsg->pCont);
   }
 }
@@ -187,20 +187,20 @@ static void dndProcessRequest(void *param, SRpcMsg *pMsg, SEpSet *pEpSet) {
   STransMgmt *pMgmt = &pDnode->tmgmt;
 
   int32_t msgType = pMsg->msgType;
-  if (msgType == TSDB_MSG_TYPE_NETWORK_TEST) {
+  if (msgType == TDMT_DND_NETWORK_TEST) {
     dTrace("RPC %p, network test req, app:%p will be processed, code:0x%x", pMsg->handle, pMsg->ahandle, pMsg->code);
     dndProcessDnodeReq(pDnode, pMsg, pEpSet);
     return;
   }
 
   if (dndGetStat(pDnode) == DND_STAT_STOPPED) {
-    dError("RPC %p, req:%s app:%p is ignored since dnode exiting", pMsg->handle, taosMsg[msgType], pMsg->ahandle);
+    dError("RPC %p, req:%s app:%p is ignored since dnode exiting", pMsg->handle, TMSG_INFO(msgType), pMsg->ahandle);
     SRpcMsg rspMsg = {.handle = pMsg->handle, .code = TSDB_CODE_DND_EXITING};
     rpcSendResponse(&rspMsg);
     rpcFreeCont(pMsg->pCont);
     return;
   } else if (dndGetStat(pDnode) != DND_STAT_RUNNING) {
-    dError("RPC %p, req:%s app:%p is ignored since dnode not running", pMsg->handle, taosMsg[msgType], pMsg->ahandle);
+    dError("RPC %p, req:%s app:%p is ignored since dnode not running", pMsg->handle, TMSG_INFO(msgType), pMsg->ahandle);
     SRpcMsg rspMsg = {.handle = pMsg->handle, .code = TSDB_CODE_APP_NOT_READY};
     rpcSendResponse(&rspMsg);
     rpcFreeCont(pMsg->pCont);
@@ -208,7 +208,7 @@ static void dndProcessRequest(void *param, SRpcMsg *pMsg, SEpSet *pEpSet) {
   }
 
   if (pMsg->pCont == NULL) {
-    dTrace("RPC %p, req:%s app:%p not processed since content is null", pMsg->handle, taosMsg[msgType], pMsg->ahandle);
+    dTrace("RPC %p, req:%s app:%p not processed since content is null", pMsg->handle, TMSG_INFO(msgType), pMsg->ahandle);
     SRpcMsg rspMsg = {.handle = pMsg->handle, .code = TSDB_CODE_DND_INVALID_MSG_LEN};
     rpcSendResponse(&rspMsg);
     return;
@@ -216,10 +216,10 @@ static void dndProcessRequest(void *param, SRpcMsg *pMsg, SEpSet *pEpSet) {
 
   DndMsgFp fp = pMgmt->msgFp[msgType];
   if (fp != NULL) {
-    dTrace("RPC %p, req:%s app:%p will be processed", pMsg->handle, taosMsg[msgType], pMsg->ahandle);
+    dTrace("RPC %p, req:%s app:%p will be processed", pMsg->handle, TMSG_INFO(msgType), pMsg->ahandle);
     (*fp)(pDnode, pMsg, pEpSet);
   } else {
-    dError("RPC %p, req:%s app:%p is not processed since no handle", pMsg->handle, taosMsg[msgType], pMsg->ahandle);
+    dError("RPC %p, req:%s app:%p is not processed since no handle", pMsg->handle, TMSG_INFO(msgType), pMsg->ahandle);
     SRpcMsg rspMsg = {.handle = pMsg->handle, .code = TSDB_CODE_MSG_NOT_PROCESSED};
     rpcSendResponse(&rspMsg);
     rpcFreeCont(pMsg->pCont);
@@ -281,7 +281,7 @@ static int32_t dndRetrieveUserAuthInfo(void *parent, char *user, char *spi, char
   SAuthMsg *pMsg = rpcMallocCont(sizeof(SAuthMsg));
   tstrncpy(pMsg->user, user, TSDB_USER_LEN);
 
-  SRpcMsg rpcMsg = {.pCont = pMsg, .contLen = sizeof(SAuthMsg), .msgType = TSDB_MSG_TYPE_AUTH};
+  SRpcMsg rpcMsg = {.pCont = pMsg, .contLen = sizeof(SAuthMsg), .msgType = TDMT_MND_AUTH};
   SRpcMsg rpcRsp = {0};
   dndSendMsgToMnodeRecv(pDnode, &rpcMsg, &rpcRsp);
 

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

@@ -773,22 +773,22 @@ static void dndProcessVnodeMgmtQueue(SDnode *pDnode, SRpcMsg *pMsg) {
   int32_t code = 0;
 
   switch (pMsg->msgType) {
-    case TSDB_MSG_TYPE_CREATE_VNODE_IN:
+    case TDMT_DND_CREATE_VNODE:
       code = dndProcessCreateVnodeReq(pDnode, pMsg);
       break;
-    case TSDB_MSG_TYPE_ALTER_VNODE_IN:
+    case TDMT_DND_ALTER_VNODE:
       code = dndProcessAlterVnodeReq(pDnode, pMsg);
       break;
-    case TSDB_MSG_TYPE_DROP_VNODE_IN:
+    case TDMT_DND_DROP_VNODE:
       code = dndProcessDropVnodeReq(pDnode, pMsg);
       break;
-    case TSDB_MSG_TYPE_AUTH_VNODE_IN:
+    case TDMT_DND_AUTH_VNODE:
       code = dndProcessAuthVnodeReq(pDnode, pMsg);
       break;
-    case TSDB_MSG_TYPE_SYNC_VNODE_IN:
+    case TDMT_DND_SYNC_VNODE:
       code = dndProcessSyncVnodeReq(pDnode, pMsg);
       break;
-    case TSDB_MSG_TYPE_COMPACT_VNODE_IN:
+    case TDMT_DND_COMPACT_VNODE:
       code = dndProcessCompactVnodeReq(pDnode, pMsg);
       break;
     default:
@@ -829,6 +829,7 @@ static void dndProcessVnodeWriteQueue(SVnodeObj *pVnode, taos_qall qall, int32_t
     SRpcMsg *pMsg = *(SRpcMsg **)taosArrayGet(pArray, i);
     int32_t  code = vnodeApplyWMsg(pVnode->pImpl, pMsg, &pRsp);
     if (pRsp != NULL) {
+      pRsp->ahandle = pMsg->ahandle;
       rpcSendResponse(pRsp);
       free(pRsp);
     } else {

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

@@ -30,7 +30,7 @@ TEST_F(DndTestAcct, 01_CreateAcct) {
 
   SCreateAcctMsg* pReq = (SCreateAcctMsg*)rpcMallocCont(contLen);
 
-  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_ACCT, pReq, contLen);
+  SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_ACCT, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, TSDB_CODE_MND_MSG_NOT_PROCESSED);
 }
@@ -40,7 +40,7 @@ TEST_F(DndTestAcct, 02_AlterAcct) {
 
   SAlterAcctMsg* pReq = (SAlterAcctMsg*)rpcMallocCont(contLen);
 
-  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_ALTER_ACCT, pReq, contLen);
+  SRpcMsg* pMsg = test.SendMsg(TDMT_MND_ALTER_ACCT, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, TSDB_CODE_MND_MSG_NOT_PROCESSED);
 }
@@ -50,7 +50,7 @@ TEST_F(DndTestAcct, 03_DropAcct) {
 
   SDropAcctMsg* pReq = (SDropAcctMsg*)rpcMallocCont(contLen);
 
-  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_DROP_ACCT, pReq, contLen);
+  SRpcMsg* pMsg = test.SendMsg(TDMT_MND_DROP_ACCT, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, TSDB_CODE_MND_MSG_NOT_PROCESSED);
 }
@@ -61,7 +61,7 @@ TEST_F(DndTestAcct, 04_ShowAcct) {
   SShowMsg* pReq = (SShowMsg*)rpcMallocCont(contLen);
   pReq->type = TSDB_MGMT_TABLE_ACCT;
 
-  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_SHOW, pReq, contLen);
+  SRpcMsg* pMsg = test.SendMsg(TDMT_MND_SHOW, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, TSDB_CODE_MND_INVALID_MSG_TYPE);
 }

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

@@ -77,7 +77,7 @@ TEST_F(DndTestDb, 02_Create_Alter_Drop_Db) {
     pReq->cacheLastRow = 0;
     pReq->ignoreExist = 1;
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_DB, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_DB, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
@@ -138,7 +138,7 @@ TEST_F(DndTestDb, 02_Create_Alter_Drop_Db) {
     pReq->quorum = 2;
     pReq->cacheLastRow = 1;
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_ALTER_DB, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_ALTER_DB, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
@@ -199,7 +199,7 @@ TEST_F(DndTestDb, 02_Create_Alter_Drop_Db) {
     SDropDbMsg* pReq = (SDropDbMsg*)rpcMallocCont(contLen);
     strcpy(pReq->db, "1.d1");
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_DROP_DB, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_DROP_DB, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
@@ -237,7 +237,7 @@ TEST_F(DndTestDb, 03_Create_Use_Restart_Use_Db) {
     pReq->cacheLastRow = 0;
     pReq->ignoreExist = 1;
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_DB, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_DB, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
@@ -256,7 +256,7 @@ TEST_F(DndTestDb, 03_Create_Use_Restart_Use_Db) {
     strcpy(pReq->db, "1.d2");
     pReq->vgVersion = htonl(-1);
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_USE_DB, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_USE_DB, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
 

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

@@ -81,7 +81,7 @@ TEST_F(DndTestDnode, 02_ConfigDnode) {
   pReq->dnodeId = htonl(1);
   strcpy(pReq->config, "ddebugflag 131");
 
-  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CONFIG_DNODE, pReq, contLen);
+  SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CONFIG_DNODE, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, 0);
 }
@@ -93,7 +93,7 @@ TEST_F(DndTestDnode, 03_Create_Drop_Restart_Dnode) {
     SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen);
     strcpy(pReq->ep, "localhost:9042");
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_DNODE, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_DNODE, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
@@ -126,7 +126,7 @@ TEST_F(DndTestDnode, 03_Create_Drop_Restart_Dnode) {
     SDropDnodeMsg* pReq = (SDropDnodeMsg*)rpcMallocCont(contLen);
     pReq->dnodeId = htonl(2);
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_DROP_DNODE, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_DROP_DNODE, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
@@ -150,7 +150,7 @@ TEST_F(DndTestDnode, 03_Create_Drop_Restart_Dnode) {
     SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen);
     strcpy(pReq->ep, "localhost:9043");
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_DNODE, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_DNODE, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
@@ -161,7 +161,7 @@ TEST_F(DndTestDnode, 03_Create_Drop_Restart_Dnode) {
     SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen);
     strcpy(pReq->ep, "localhost:9044");
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_DNODE, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_DNODE, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
@@ -172,7 +172,7 @@ TEST_F(DndTestDnode, 03_Create_Drop_Restart_Dnode) {
     SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen);
     strcpy(pReq->ep, "localhost:9045");
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_DNODE, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_DNODE, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }

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

@@ -77,7 +77,7 @@ TEST_F(DndTestMnode, 02_Create_Mnode_Invalid_Id) {
     SCreateMnodeMsg* pReq = (SCreateMnodeMsg*)rpcMallocCont(contLen);
     pReq->dnodeId = htonl(1);
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_MNODE, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_MNODE, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, TSDB_CODE_MND_MNODE_ALREADY_EXIST);
   }
@@ -90,7 +90,7 @@ TEST_F(DndTestMnode, 03_Create_Mnode_Invalid_Id) {
     SCreateMnodeMsg* pReq = (SCreateMnodeMsg*)rpcMallocCont(contLen);
     pReq->dnodeId = htonl(2);
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_MNODE, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_MNODE, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, TSDB_CODE_MND_DNODE_NOT_EXIST);
   }
@@ -104,7 +104,7 @@ TEST_F(DndTestMnode, 04_Create_Mnode) {
     SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen);
     strcpy(pReq->ep, "localhost:9062");
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_DNODE, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_DNODE, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
 
@@ -121,7 +121,7 @@ TEST_F(DndTestMnode, 04_Create_Mnode) {
     SCreateMnodeMsg* pReq = (SCreateMnodeMsg*)rpcMallocCont(contLen);
     pReq->dnodeId = htonl(2);
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_MNODE, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_MNODE, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
 
@@ -148,7 +148,7 @@ TEST_F(DndTestMnode, 04_Create_Mnode) {
     SDropMnodeMsg* pReq = (SDropMnodeMsg*)rpcMallocCont(contLen);
     pReq->dnodeId = htonl(2);
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_DROP_MNODE, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_DROP_MNODE, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
 
@@ -169,7 +169,7 @@ TEST_F(DndTestMnode, 04_Create_Mnode) {
 //   SDropDnodeMsg* pReq = (SDropDnodeMsg*)rpcMallocCont(contLen);
 //   pReq->dnodeId = htonl(2);
 
-//   SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_DROP_DNODE, pReq, contLen);
+//   SRpcMsg* pMsg = test.SendMsg(TDMT_MND_DROP_DNODE, pReq, contLen);
 //   ASSERT_NE(pMsg, nullptr);
 //   ASSERT_EQ(pMsg->code, 0);
 // }
@@ -193,7 +193,7 @@ TEST_F(DndTestMnode, 04_Create_Mnode) {
 //   SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen);
 //   strcpy(pReq->ep, "localhost:9063");
 
-//   SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_DNODE, pReq, contLen);
+//   SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_DNODE, pReq, contLen);
 //   ASSERT_NE(pMsg, nullptr);
 //   ASSERT_EQ(pMsg->code, 0);
 // }
@@ -204,7 +204,7 @@ TEST_F(DndTestMnode, 04_Create_Mnode) {
 //   SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen);
 //   strcpy(pReq->ep, "localhost:9064");
 
-//   SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_DNODE, pReq, contLen);
+//   SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_DNODE, pReq, contLen);
 //   ASSERT_NE(pMsg, nullptr);
 //   ASSERT_EQ(pMsg->code, 0);
 // }
@@ -215,7 +215,7 @@ TEST_F(DndTestMnode, 04_Create_Mnode) {
 //   SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen);
 //   strcpy(pReq->ep, "localhost:9065");
 
-//   SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_DNODE, pReq, contLen);
+//   SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_DNODE, pReq, contLen);
 //   ASSERT_NE(pMsg, nullptr);
 //   ASSERT_EQ(pMsg->code, 0);
 // }

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

@@ -35,7 +35,7 @@ TEST_F(DndTestProfile, 01_ConnectMsg) {
   strcpy(pReq->app, "dnode_test_profile");
   strcpy(pReq->db, "");
 
-  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CONNECT, pReq, contLen);
+  SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CONNECT, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, 0);
 
@@ -67,7 +67,7 @@ TEST_F(DndTestProfile, 02_ConnectMsg_InvalidDB) {
   strcpy(pReq->app, "dnode_test_profile");
   strcpy(pReq->db, "invalid_db");
 
-  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CONNECT, pReq, contLen);
+  SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CONNECT, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, TSDB_CODE_MND_INVALID_DB);
   ASSERT_EQ(pMsg->contLen, 0);
@@ -105,7 +105,7 @@ TEST_F(DndTestProfile, 04_HeartBeatMsg) {
   pReq->numOfStreams = htonl(0);
   strcpy(pReq->app, "dnode_test_profile");
 
-  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_HEARTBEAT, pReq, contLen);
+  SRpcMsg* pMsg = test.SendMsg(TDMT_MND_HEARTBEAT, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, 0);
 
@@ -138,7 +138,7 @@ TEST_F(DndTestProfile, 05_KillConnMsg) {
     SKillConnMsg* pReq = (SKillConnMsg*)rpcMallocCont(contLen);
     pReq->connId = htonl(connId);
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_KILL_CONN, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_KILL_CONN, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
@@ -153,7 +153,7 @@ TEST_F(DndTestProfile, 05_KillConnMsg) {
     pReq->numOfStreams = htonl(0);
     strcpy(pReq->app, "dnode_test_profile");
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_HEARTBEAT, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_HEARTBEAT, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, TSDB_CODE_MND_INVALID_CONNECTION);
     ASSERT_EQ(pMsg->contLen, 0);
@@ -167,7 +167,7 @@ TEST_F(DndTestProfile, 05_KillConnMsg) {
     strcpy(pReq->app, "dnode_test_profile");
     strcpy(pReq->db, "");
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CONNECT, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CONNECT, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
 
@@ -198,7 +198,7 @@ TEST_F(DndTestProfile, 06_KillConnMsg_InvalidConn) {
   SKillConnMsg* pReq = (SKillConnMsg*)rpcMallocCont(contLen);
   pReq->connId = htonl(2345);
 
-  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_KILL_CONN, pReq, contLen);
+  SRpcMsg* pMsg = test.SendMsg(TDMT_MND_KILL_CONN, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, TSDB_CODE_MND_INVALID_CONN_ID);
 }
@@ -211,7 +211,7 @@ TEST_F(DndTestProfile, 07_KillQueryMsg) {
     pReq->connId = htonl(connId);
     pReq->queryId = htonl(1234);
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_KILL_QUERY, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_KILL_QUERY, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
     ASSERT_EQ(pMsg->contLen, 0);
@@ -227,7 +227,7 @@ TEST_F(DndTestProfile, 07_KillQueryMsg) {
     pReq->numOfStreams = htonl(0);
     strcpy(pReq->app, "dnode_test_profile");
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_HEARTBEAT, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_HEARTBEAT, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
 
@@ -261,7 +261,7 @@ TEST_F(DndTestProfile, 08_KillQueryMsg_InvalidConn) {
   pReq->connId = htonl(2345);
   pReq->queryId = htonl(1234);
 
-  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_KILL_QUERY, pReq, contLen);
+  SRpcMsg* pMsg = test.SendMsg(TDMT_MND_KILL_QUERY, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, TSDB_CODE_MND_INVALID_CONN_ID);
 }

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

@@ -32,7 +32,7 @@ TEST_F(DndTestShow, 01_ShowMsg_InvalidMsgMax) {
   pReq->type = TSDB_MGMT_TABLE_MAX;
   strcpy(pReq->db, "");
 
-  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_SHOW, pReq, contLen);
+  SRpcMsg* pMsg = test.SendMsg(TDMT_MND_SHOW, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, TSDB_CODE_MND_INVALID_MSG_TYPE);
 }
@@ -44,7 +44,7 @@ TEST_F(DndTestShow, 02_ShowMsg_InvalidMsgStart) {
   pReq->type = TSDB_MGMT_TABLE_START;
   strcpy(pReq->db, "");
 
-  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_SHOW, pReq, contLen);
+  SRpcMsg* pMsg = test.SendMsg(TDMT_MND_SHOW, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, TSDB_CODE_MND_INVALID_MSG_TYPE);
 }
@@ -57,7 +57,7 @@ TEST_F(DndTestShow, 02_ShowMsg_Conn) {
   strcpy(pReq->app, "dnode_test_show");
   strcpy(pReq->db, "");
 
-  SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CONNECT, pReq, contLen);
+  SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CONNECT, pReq, contLen);
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, 0);
 

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

@@ -51,7 +51,7 @@ TEST_F(DndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) {
     pReq->cacheLastRow = 0;
     pReq->ignoreExist = 1;
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_DB, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_DB, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
@@ -106,7 +106,7 @@ TEST_F(DndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) {
       strcpy(pSchema->name, "tag3");
     }
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_STB, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_STB, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
@@ -133,7 +133,7 @@ TEST_F(DndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) {
     STableInfoMsg* pReq = (STableInfoMsg*)rpcMallocCont(contLen);
     strcpy(pReq->tableFname, "1.d1.stb");
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_TABLE_META, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_VND_TABLE_META, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
 
@@ -192,7 +192,7 @@ TEST_F(DndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) {
     SDropStbMsg* pReq = (SDropStbMsg*)rpcMallocCont(contLen);
     strcpy(pReq->name, "1.d1.stb");
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_DROP_STB, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_DROP_STB, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }

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

@@ -20,7 +20,7 @@
 #include "os.h"
 
 #include "dnode.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "tconfig.h"
 #include "tdataformat.h"
 #include "tglobal.h"
@@ -37,7 +37,7 @@ class Testbase {
   void     Init(const char* path, int16_t port);
   void     Cleanup();
   void     Restart();
-  SRpcMsg* SendMsg(int8_t msgType, void* pCont, int32_t contLen);
+  SRpcMsg* SendMsg(tmsg_t msgType, void* pCont, int32_t contLen);
 
  private:
   void InitLog(const char* path);

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

@@ -60,7 +60,7 @@ void Testbase::Cleanup() {
 
 void Testbase::Restart() { server.Restart(); }
 
-SRpcMsg* Testbase::SendMsg(int8_t msgType, void* pCont, int32_t contLen) {
+SRpcMsg* Testbase::SendMsg(tmsg_t msgType, void* pCont, int32_t contLen) {
   SRpcMsg rpcMsg = {0};
   rpcMsg.pCont = pCont;
   rpcMsg.contLen = contLen;
@@ -75,7 +75,7 @@ void Testbase::SendShowMetaMsg(int8_t showType, const char* db) {
   pShow->type = showType;
   strcpy(pShow->db, db);
 
-  SRpcMsg*  pMsg = SendMsg(TSDB_MSG_TYPE_SHOW, pShow, contLen);
+  SRpcMsg*  pMsg = SendMsg(TDMT_MND_SHOW, pShow, contLen);
   SShowRsp* pShowRsp = (SShowRsp*)pMsg->pCont;
 
   ASSERT(pShowRsp != nullptr);
@@ -124,7 +124,7 @@ void Testbase::SendShowRetrieveMsg() {
   pRetrieve->showId = htonl(showId);
   pRetrieve->free = 0;
 
-  SRpcMsg* pMsg = SendMsg(TSDB_MSG_TYPE_SHOW_RETRIEVE, pRetrieve, contLen);
+  SRpcMsg* pMsg = SendMsg(TDMT_MND_SHOW_RETRIEVE, pRetrieve, contLen);
   pRetrieveRsp = (SRetrieveTableRsp*)pMsg->pCont;
   pRetrieveRsp->numOfRows = htonl(pRetrieveRsp->numOfRows);
   pRetrieveRsp->useconds = htobe64(pRetrieveRsp->useconds);

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

@@ -18,7 +18,7 @@
 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);
+  uInfo("response:%s from dnode, code:0x%x", TMSG_INFO(pMsg->msgType), pMsg->code);
   tsem_post(client->GetSem());
 }
 

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

@@ -51,7 +51,7 @@ TEST_F(DndTestUser, 02_Create_Drop_Alter_User) {
     strcpy(pReq->user, "u1");
     strcpy(pReq->pass, "p1");
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_USER, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_USER, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
@@ -63,7 +63,7 @@ TEST_F(DndTestUser, 02_Create_Drop_Alter_User) {
     strcpy(pReq->user, "u2");
     strcpy(pReq->pass, "p2");
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_USER, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_USER, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
@@ -94,7 +94,7 @@ TEST_F(DndTestUser, 02_Create_Drop_Alter_User) {
     strcpy(pReq->user, "u1");
     strcpy(pReq->pass, "p2");
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_ALTER_USER, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_ALTER_USER, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }
@@ -124,7 +124,7 @@ TEST_F(DndTestUser, 02_Create_Drop_Alter_User) {
     SDropUserMsg* pReq = (SDropUserMsg*)rpcMallocCont(contLen);
     strcpy(pReq->user, "u1");
 
-    SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_DROP_USER, pReq, contLen);
+    SRpcMsg* pMsg = test.SendMsg(TDMT_MND_DROP_USER, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
   }

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

@@ -60,7 +60,7 @@ TEST_F(DndTestVgroup, 01_Create_Restart_Drop_Vnode) {
         pReplica->port = htons(9150);
       }
 
-      SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_VNODE_IN, pReq, contLen);
+      SRpcMsg* pMsg = test.SendMsg(TDMT_DND_CREATE_VNODE, pReq, contLen);
       ASSERT_NE(pMsg, nullptr);
       ASSERT_EQ(pMsg->code, 0);
     }
@@ -100,7 +100,7 @@ TEST_F(DndTestVgroup, 01_Create_Restart_Drop_Vnode) {
         pReplica->port = htons(9150);
       }
 
-      SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_ALTER_VNODE_IN, pReq, contLen);
+      SRpcMsg* pMsg = test.SendMsg(TDMT_DND_ALTER_VNODE, pReq, contLen);
       ASSERT_NE(pMsg, nullptr);
       ASSERT_EQ(pMsg->code, 0);
     }
@@ -119,9 +119,9 @@ TEST_F(DndTestVgroup, 01_Create_Restart_Drop_Vnode) {
       SRpcMsg rpcMsg = {0};
       rpcMsg.pCont = pReq;
       rpcMsg.contLen = sizeof(SDropVnodeMsg);
-      rpcMsg.msgType = TSDB_MSG_TYPE_DROP_VNODE_IN;
+      rpcMsg.msgType = TDMT_DND_DROP_VNODE;
 
-      SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_DROP_VNODE_IN, pReq, contLen);
+      SRpcMsg* pMsg = test.SendMsg(TDMT_DND_DROP_VNODE, pReq, contLen);
       ASSERT_NE(pMsg, nullptr);
       ASSERT_EQ(pMsg->code, 0);
     }

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

@@ -20,7 +20,7 @@
 
 #include "cJSON.h"
 #include "sync.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "thash.h"
 #include "tlog.h"
 #include "trpc.h"
@@ -285,6 +285,21 @@ typedef struct {
   char    payload[];
 } SShowObj;
 
+typedef struct {
+  char name[TSDB_TOPIC_FNAME_LEN];
+  char db[TSDB_FULL_DB_NAME_LEN];
+  int64_t createTime;
+  int64_t updateTime;
+  uint64_t uid;
+  uint64_t dbUid;
+  int32_t version;
+  SRWLatch lock;
+  int32_t  execLen;
+  void*    executor;
+  int32_t  sqlLen;
+  char*    sql;
+} STopicObj;
+
 typedef struct SMnodeMsg {
   char    user[TSDB_USER_LEN];
   char    db[TSDB_FULL_DB_NAME_LEN];

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

@@ -77,7 +77,7 @@ typedef struct SMnode {
   SShowMgmt         showMgmt;
   SProfileMgmt      profileMgmt;
   STelemMgmt        telemMgmt;
-  MndMsgFp          msgFp[TSDB_MSG_TYPE_MAX];
+  MndMsgFp          msgFp[TDMT_MAX];
   SendMsgToDnodeFp  sendMsgToDnodeFp;
   SendMsgToMnodeFp  sendMsgToMnodeFp;
   SendRedirectMsgFp sendRedirectMsgFp;

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

@@ -25,6 +25,9 @@ extern "C" {
 int32_t mndInitStb(SMnode *pMnode);
 void    mndCleanupStb(SMnode *pMnode);
 
+SStbObj *mndAcquireStb(SMnode *pMnode, char *stbName);
+void mndReleaseStb(SMnode *pMnode, SStbObj *pStb);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -0,0 +1,35 @@
+/*
+ * 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_MND_TOPIC_H_
+#define _TD_MND_TOPIC_H_
+
+#include "mndInt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int32_t mndInitTopic(SMnode *pMnode);
+void    mndCleanupTopic(SMnode *pMnode);
+
+STopicObj *mndAcquireTopic(SMnode *pMnode, char *topicName);
+void mndReleaseTopic(SMnode *pMnode, STopicObj *pTopic);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_MND_TOPIC_H_*/

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

@@ -40,9 +40,9 @@ int32_t mndInitAcct(SMnode *pMnode) {
                      .updateFp = (SdbUpdateFp)mndAcctActionUpdate,
                      .deleteFp = (SdbDeleteFp)mndAcctActionDelete};
 
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_CREATE_ACCT, mndProcessCreateAcctMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_ACCT, mndProcessCreateAcctMsg);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_ALTER_ACCT, mndProcessAlterAcctMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_ALTER_ACCT, mndProcessAlterAcctMsg);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_DROP_ACCT, mndProcessDropAcctMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_DROP_ACCT, mndProcessDropAcctMsg);
 
   return sdbSetTable(pMnode->pSdb, table);
 }

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

@@ -48,12 +48,12 @@ int32_t mndInitDb(SMnode *pMnode) {
                      .updateFp = (SdbUpdateFp)mndDbActionUpdate,
                      .deleteFp = (SdbDeleteFp)mndDbActionDelete};
 
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_CREATE_DB, mndProcessCreateDbMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_DB, mndProcessCreateDbMsg);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_ALTER_DB, mndProcessAlterDbMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_ALTER_DB, mndProcessAlterDbMsg);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_DROP_DB, mndProcessDropDbMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_DROP_DB, mndProcessDropDbMsg);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_USE_DB, mndProcessUseDbMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_USE_DB, mndProcessUseDbMsg);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_SYNC_DB, mndProcessSyncDbMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_SYNC_DB, mndProcessSyncDbMsg);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_COMPACT_DB, mndProcessCompactDbMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_COMPACT_DB, mndProcessCompactDbMsg);
 
   mndAddShowMetaHandle(pMnode, TSDB_MGMT_TABLE_DB, mndGetDbMeta);
   mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_DB, mndRetrieveDbs);
@@ -311,7 +311,7 @@ static int32_t mndSetCreateDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj
 
       action.pCont = pMsg;
       action.contLen = sizeof(SCreateVnodeMsg);
-      action.msgType = TSDB_MSG_TYPE_CREATE_VNODE_IN;
+      action.msgType = TDMT_DND_CREATE_VNODE;
       if (mndTransAppendRedoAction(pTrans, &action) != 0) {
         free(pMsg);
         return -1;
@@ -340,7 +340,7 @@ static int32_t mndSetCreateDbUndoActions(SMnode *pMnode, STrans *pTrans, SDbObj
 
       action.pCont = pMsg;
       action.contLen = sizeof(SDropVnodeMsg);
-      action.msgType = TSDB_MSG_TYPE_DROP_VNODE_IN;
+      action.msgType = TDMT_DND_DROP_VNODE;
       if (mndTransAppendUndoAction(pTrans, &action) != 0) {
         free(pMsg);
         return -1;
@@ -541,6 +541,15 @@ static int32_t mndSetDbCfgFromAlterDbMsg(SDbObj *pDb, SAlterDbMsg *pAlter) {
 }
 
 static int32_t mndSetUpdateDbRedoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pOldDb, SDbObj *pNewDb) {
+  SSdbRaw *pRedoRaw = mndDbActionEncode(pOldDb);
+  if (pRedoRaw == NULL) return -1;
+  if (mndTransAppendRedolog(pTrans, pRedoRaw) != 0) return -1;
+  if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_UPDATING) != 0) return -1;
+
+  return 0;
+}
+
+static int32_t mndSetUpdateDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pOldDb, SDbObj *pNewDb) { 
   SSdbRaw *pRedoRaw = mndDbActionEncode(pNewDb);
   if (pRedoRaw == NULL) return -1;
   if (mndTransAppendRedolog(pTrans, pRedoRaw) != 0) return -1;
@@ -549,24 +558,57 @@ static int32_t mndSetUpdateDbRedoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pO
   return 0;
 }
 
-static int32_t mndSetUpdateDbUndoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pOldDb, SDbObj *pNewDb) {
+static int32_t mndBuildUpdateVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup) {
-  SSdbRaw *pUndoRaw = mndDbActionEncode(pOldDb);
+  for (int32_t vn = 0; vn < pVgroup->replica; ++vn) {
-  if (pUndoRaw == NULL) return -1;
+    STransAction action = {0};
-  if (mndTransAppendUndolog(pTrans, pUndoRaw) != 0) return -1;
+    SVnodeGid   *pVgid = pVgroup->vnodeGid + vn;
-  if (sdbSetRawStatus(pUndoRaw, SDB_STATUS_READY) != 0) return -1;
+
+    SDnodeObj *pDnode = mndAcquireDnode(pMnode, pVgid->dnodeId);
+    if (pDnode == NULL) return -1;
+    action.epSet = mndGetDnodeEpset(pDnode);
+    mndReleaseDnode(pMnode, pDnode);
+
+    SAlterVnodeMsg *pMsg = (SAlterVnodeMsg *)mndBuildCreateVnodeMsg(pMnode, pDnode, pDb, pVgroup);
+    if (pMsg == NULL) return -1;
+
+    action.pCont = pMsg;
+    action.contLen = sizeof(SAlterVnodeMsg);
+    action.msgType = TDMT_DND_ALTER_VNODE;
+    if (mndTransAppendRedoAction(pTrans, &action) != 0) {
+      free(pMsg);
+      return -1;
+    }
+  }
 
   return 0;
 }
 
-static int32_t mndSetUpdateDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pOldDb, SDbObj *pNewDb) { return 0; }
+static int32_t mndSetUpdateDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pOldDb, SDbObj *pNewDb) {
+  SSdb *pSdb = pMnode->pSdb;
+  void *pIter = NULL;
 
-static int32_t mndSetUpdateDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pOldDb, SDbObj *pNewDb) { return 0; }
+  while (1) {
+    SVgObj *pVgroup = NULL;
+    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);
+    if (pIter == NULL) break;
 
-static int32_t mndSetUpdateDbUndoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pOldDb, SDbObj *pNewDb) { return 0; }
+    if (pVgroup->dbUid == pNewDb->uid) {
+      if (mndBuildUpdateVgroupAction(pMnode, pTrans, pNewDb, pVgroup) != 0) {
+        sdbCancelFetch(pSdb, pIter);
+        sdbRelease(pSdb, pVgroup);
+        return -1;
+      }
+    }
+
+    sdbRelease(pSdb, pVgroup);
+  }
+
+  return 0;
+}
 
 static int32_t mndUpdateDb(SMnode *pMnode, SMnodeMsg *pMsg, SDbObj *pOldDb, SDbObj *pNewDb) {
   int32_t code = -1;
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, pMsg->rpcMsg.handle);
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, pMsg->rpcMsg.handle);
   if (pTrans == NULL) {
     mError("db:%s, failed to update since %s", pOldDb->name, terrstr());
     return terrno;
@@ -579,11 +621,6 @@ static int32_t mndUpdateDb(SMnode *pMnode, SMnodeMsg *pMsg, SDbObj *pOldDb, SDbO
     goto UPDATE_DB_OVER;
   }
 
-  if (mndSetUpdateDbUndoLogs(pMnode, pTrans, pOldDb, pNewDb) != 0) {
-    mError("trans:%d, failed to set undo log since %s", pTrans->id, terrstr());
-    goto UPDATE_DB_OVER;
-  }
-
   if (mndSetUpdateDbCommitLogs(pMnode, pTrans, pOldDb, pNewDb) != 0) {
     mError("trans:%d, failed to set commit log since %s", pTrans->id, terrstr());
     goto UPDATE_DB_OVER;
@@ -594,11 +631,6 @@ static int32_t mndUpdateDb(SMnode *pMnode, SMnodeMsg *pMsg, SDbObj *pOldDb, SDbO
     goto UPDATE_DB_OVER;
   }
 
-  if (mndSetUpdateDbUndoActions(pMnode, pTrans, pOldDb, pNewDb) != 0) {
-    mError("trans:%d, failed to set redo actions since %s", pTrans->id, terrstr());
-    goto UPDATE_DB_OVER;
-  }
-
   if (mndTransPrepare(pMnode, pTrans) != 0) {
     mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
     goto UPDATE_DB_OVER;
@@ -660,31 +692,87 @@ static int32_t mndSetDropDbRedoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb)
   return 0;
 }
 
-static int32_t mndSetDropDbUndoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {
-  SSdbRaw *pUndoRaw = mndDbActionEncode(pDb);
-  if (pUndoRaw == NULL) return -1;
-  if (mndTransAppendUndolog(pTrans, pUndoRaw) != 0) return -1;
-  if (sdbSetRawStatus(pUndoRaw, SDB_STATUS_READY) != 0) return -1;
-
-  return 0;
-}
-
 static int32_t mndSetDropDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {
   SSdbRaw *pCommitRaw = mndDbActionEncode(pDb);
   if (pCommitRaw == NULL) return -1;
   if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) return -1;
   if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED) != 0) return -1;
 
+  SSdb *pSdb = pMnode->pSdb;
+  void *pIter = NULL;
+
+  while (1) {
+    SVgObj *pVgroup = NULL;
+    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);
+    if (pIter == NULL) break;
+
+    if (pVgroup->dbUid == pDb->uid) {
+      SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroup);
+      if (pVgRaw == NULL || mndTransAppendCommitlog(pTrans, pVgRaw) != 0) {
+        sdbCancelFetch(pSdb, pIter);
+        sdbRelease(pSdb, pVgroup);
+        return -1;
+      }
+      sdbSetRawStatus(pVgRaw, SDB_STATUS_DROPPED);
+    }
+
+    sdbRelease(pSdb, pVgroup);
+  }
+
   return 0;
 }
 
-static int32_t mndSetDropDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) { return 0; }
+static int32_t mndBuildDropVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup) {
+  for (int32_t vn = 0; vn < pVgroup->replica; ++vn) {
+    STransAction action = {0};
+    SVnodeGid *  pVgid = pVgroup->vnodeGid + vn;
 
-static int32_t mndSetDropDbUndoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) { return 0; }
+    SDnodeObj *pDnode = mndAcquireDnode(pMnode, pVgid->dnodeId);
+    if (pDnode == NULL) return -1;
+    action.epSet = mndGetDnodeEpset(pDnode);
+    mndReleaseDnode(pMnode, pDnode);
+
+    SDropVnodeMsg *pMsg = mndBuildDropVnodeMsg(pMnode, pDnode, pDb, pVgroup);
+    if (pMsg == NULL) return -1;
+
+    action.pCont = pMsg;
+    action.contLen = sizeof(SCreateVnodeMsg);
+    action.msgType = TDMT_DND_DROP_VNODE;
+    if (mndTransAppendRedoAction(pTrans, &action) != 0) {
+      free(pMsg);
+      return -1;
+    }
+  }
+
+  return 0;
+}
+
+static int32_t mndSetDropDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {
+  SSdb *pSdb = pMnode->pSdb;
+  void *pIter = NULL;
+
+  while (1) {
+    SVgObj *pVgroup = NULL;
+    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);
+    if (pIter == NULL) break;
+
+    if (pVgroup->dbUid == pDb->uid) {
+      if (mndBuildDropVgroupAction(pMnode, pTrans, pDb, pVgroup) != 0) {
+        sdbCancelFetch(pSdb, pIter);
+        sdbRelease(pSdb, pVgroup);
+        return -1;
+      }
+    }
+
+    sdbRelease(pSdb, pVgroup);
+  }
+
+  return 0;
+}
 
 static int32_t mndDropDb(SMnode *pMnode, SMnodeMsg *pMsg, SDbObj *pDb) {
   int32_t code = -1;
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, pMsg->rpcMsg.handle);
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, pMsg->rpcMsg.handle);
   if (pTrans == NULL) {
     mError("db:%s, failed to drop since %s", pDb->name, terrstr());
     return -1;
@@ -697,11 +785,6 @@ static int32_t mndDropDb(SMnode *pMnode, SMnodeMsg *pMsg, SDbObj *pDb) {
     goto DROP_DB_OVER;
   }
 
-  if (mndSetDropDbUndoLogs(pMnode, pTrans, pDb) != 0) {
-    mError("trans:%d, failed to set undo log since %s", pTrans->id, terrstr());
-    goto DROP_DB_OVER;
-  }
-
   if (mndSetDropDbCommitLogs(pMnode, pTrans, pDb) != 0) {
     mError("trans:%d, failed to set commit log since %s", pTrans->id, terrstr());
     goto DROP_DB_OVER;
@@ -712,11 +795,6 @@ static int32_t mndDropDb(SMnode *pMnode, SMnodeMsg *pMsg, SDbObj *pDb) {
     goto DROP_DB_OVER;
   }
 
-  if (mndSetDropDbUndoActions(pMnode, pTrans, pDb) != 0) {
-    mError("trans:%d, failed to set redo actions since %s", pTrans->id, terrstr());
-    goto DROP_DB_OVER;
-  }
-
   if (mndTransPrepare(pMnode, pTrans) != 0) {
     mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
     goto DROP_DB_OVER;

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

@@ -73,11 +73,11 @@ int32_t mndInitDnode(SMnode *pMnode) {
                      .updateFp = (SdbUpdateFp)mndDnodeActionUpdate,
                      .deleteFp = (SdbDeleteFp)mndDnodeActionDelete};
 
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_CREATE_DNODE, mndProcessCreateDnodeMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_DNODE, mndProcessCreateDnodeMsg);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_DROP_DNODE, mndProcessDropDnodeMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_DROP_DNODE, mndProcessDropDnodeMsg);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_CONFIG_DNODE, mndProcessConfigDnodeMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_CONFIG_DNODE, mndProcessConfigDnodeMsg);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_CONFIG_DNODE_IN_RSP, mndProcessConfigDnodeRsp);
+  mndSetMsgHandle(pMnode, TDMT_DND_CONFIG_DNODE_RSP, mndProcessConfigDnodeRsp);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_STATUS, mndProcessStatusMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_STATUS, mndProcessStatusMsg);
 
   mndAddShowMetaHandle(pMnode, TSDB_MGMT_TABLE_VARIABLES, mndGetConfigMeta);
   mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_VARIABLES, mndRetrieveConfigs);
@@ -527,7 +527,7 @@ static int32_t mndProcessConfigDnodeMsg(SMnodeMsg *pMsg) {
   pCfgDnode->dnodeId = htonl(pCfg->dnodeId);
   memcpy(pCfgDnode->config, pCfg->config, TSDB_DNODE_CONFIG_LEN);
 
-  SRpcMsg rpcMsg = {.msgType = TSDB_MSG_TYPE_CONFIG_DNODE_IN,
+  SRpcMsg rpcMsg = {.msgType = TDMT_DND_CONFIG_DNODE,
                     .pCont = pCfgDnode,
                     .contLen = sizeof(SCfgDnodeMsg),
                     .ahandle = pMsg->rpcMsg.ahandle};

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

@@ -44,9 +44,9 @@ int32_t mndInitFunc(SMnode *pMnode) {
                      .updateFp = (SdbUpdateFp)mndFuncActionUpdate,
                      .deleteFp = (SdbDeleteFp)mndFuncActionDelete};
 
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_CREATE_FUNCTION, mndProcessCreateFuncMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_FUNCTION, mndProcessCreateFuncMsg);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_DROP_FUNCTION, mndProcessDropFuncMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_DROP_FUNCTION, mndProcessDropFuncMsg);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_RETRIEVE_FUNCTION, mndProcessRetrieveFuncMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_RETRIEVE_FUNCTION, mndProcessRetrieveFuncMsg);
 
   mndAddShowMetaHandle(pMnode, TSDB_MGMT_TABLE_FUNCTION, mndGetFuncMeta);
   mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_FUNCTION, mndRetrieveFuncs);

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

@@ -47,11 +47,11 @@ int32_t mndInitMnode(SMnode *pMnode) {
                      .updateFp = (SdbUpdateFp)mndMnodeActionUpdate,
                      .deleteFp = (SdbDeleteFp)mndMnodeActionDelete};
 
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_CREATE_MNODE, mndProcessCreateMnodeReq);
+  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_MNODE, mndProcessCreateMnodeReq);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_DROP_MNODE, mndProcessDropMnodeReq);
+  mndSetMsgHandle(pMnode, TDMT_MND_DROP_MNODE, mndProcessDropMnodeReq);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_CREATE_MNODE_IN_RSP, mndProcessCreateMnodeRsp);
+  mndSetMsgHandle(pMnode, TDMT_DND_CREATE_MNODE_RSP, mndProcessCreateMnodeRsp);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_ALTER_MNODE_IN_RSP, mndProcessAlterMnodeRsp);
+  mndSetMsgHandle(pMnode, TDMT_DND_ALTER_MNODE_RSP, mndProcessAlterMnodeRsp);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_DROP_MNODE_IN_RSP, mndProcessDropMnodeRsp);
+  mndSetMsgHandle(pMnode, TDMT_DND_DROP_MNODE_RSP, mndProcessDropMnodeRsp);
 
   mndAddShowMetaHandle(pMnode, TSDB_MGMT_TABLE_MNODE, mndGetMnodeMeta);
   mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_MNODE, mndRetrieveMnodes);
@@ -293,7 +293,7 @@ static int32_t mndSetCreateMnodeRedoActions(SMnode *pMnode, STrans *pTrans, SDno
     action.epSet = mndGetDnodeEpset(pMObj->pDnode);
     action.pCont = pMsg;
     action.contLen = sizeof(SAlterMnodeInMsg);
-    action.msgType = TSDB_MSG_TYPE_ALTER_MNODE_IN;
+    action.msgType = TDMT_DND_ALTER_MNODE;
 
     if (mndTransAppendRedoAction(pTrans, &action) != 0) {
       free(pMsg);
@@ -317,7 +317,7 @@ static int32_t mndSetCreateMnodeRedoActions(SMnode *pMnode, STrans *pTrans, SDno
     action.epSet = mndGetDnodeEpset(pDnode);
     action.pCont = pMsg;
     action.contLen = sizeof(SCreateMnodeInMsg);
-    action.msgType = TSDB_MSG_TYPE_CREATE_MNODE_IN;
+    action.msgType = TDMT_DND_CREATE_MNODE;
     if (mndTransAppendRedoAction(pTrans, &action) != 0) {
       free(pMsg);
       return -1;
@@ -461,7 +461,7 @@ static int32_t mndSetDropMnodeRedoActions(SMnode *pMnode, STrans *pTrans, SDnode
       action.epSet = mndGetDnodeEpset(pMObj->pDnode);
       action.pCont = pMsg;
       action.contLen = sizeof(SAlterMnodeInMsg);
-      action.msgType = TSDB_MSG_TYPE_ALTER_MNODE_IN;
+      action.msgType = TDMT_DND_ALTER_MNODE;
 
       if (mndTransAppendRedoAction(pTrans, &action) != 0) {
         free(pMsg);
@@ -488,7 +488,7 @@ static int32_t mndSetDropMnodeRedoActions(SMnode *pMnode, STrans *pTrans, SDnode
     action.epSet = mndGetDnodeEpset(pDnode);
     action.pCont = pMsg;
     action.contLen = sizeof(SDropMnodeInMsg);
-    action.msgType = TSDB_MSG_TYPE_DROP_MNODE_IN;
+    action.msgType = TDMT_DND_DROP_MNODE;
     if (mndTransAppendRedoAction(pTrans, &action) != 0) {
       free(pMsg);
       return -1;

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

@@ -68,10 +68,10 @@ int32_t mndInitProfile(SMnode *pMnode) {
     return -1;
   }
 
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_HEARTBEAT, mndProcessHeartBeatMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_HEARTBEAT, mndProcessHeartBeatMsg);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_CONNECT, mndProcessConnectMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_CONNECT, mndProcessConnectMsg);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_KILL_QUERY, mndProcessKillQueryMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_KILL_QUERY, mndProcessKillQueryMsg);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_KILL_CONN, mndProcessKillConnectionMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_KILL_CONN, mndProcessKillConnectionMsg);
 
   mndAddShowMetaHandle(pMnode, TSDB_MGMT_TABLE_CONNS, mndGetConnsMeta);
   mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_CONNS, mndRetrieveConns);

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

@@ -36,8 +36,8 @@ int32_t mndInitShow(SMnode *pMnode) {
     return -1;
   }
 
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_SHOW, mndProcessShowMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_SHOW, mndProcessShowMsg);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_SHOW_RETRIEVE, mndProcessRetrieveMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_SHOW_RETRIEVE, mndProcessRetrieveMsg);
   return 0;
 }
 

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

@@ -52,13 +52,13 @@ int32_t mndInitStb(SMnode *pMnode) {
                      .updateFp = (SdbUpdateFp)mndStbActionUpdate,
                      .deleteFp = (SdbDeleteFp)mndStbActionDelete};
 
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_CREATE_STB, mndProcessCreateStbMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_STB, mndProcessCreateStbMsg);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_ALTER_STB, mndProcessAlterStbMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_ALTER_STB, mndProcessAlterStbMsg);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_DROP_STB, mndProcessDropStbMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_DROP_STB, mndProcessDropStbMsg);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_CREATE_STB_IN_RSP, mndProcessCreateStbInRsp);
+  mndSetMsgHandle(pMnode, TDMT_VND_CREATE_STB_RSP, mndProcessCreateStbInRsp);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_ALTER_STB_IN_RSP, mndProcessAlterStbInRsp);
+  mndSetMsgHandle(pMnode, TDMT_VND_ALTER_STB_RSP, mndProcessAlterStbInRsp);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_DROP_STB_IN_RSP, mndProcessDropStbInRsp);
+  mndSetMsgHandle(pMnode, TDMT_VND_DROP_STB_RSP, mndProcessDropStbInRsp);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_TABLE_META, mndProcessStbMetaMsg);
+  mndSetMsgHandle(pMnode, TDMT_VND_TABLE_META, mndProcessStbMetaMsg);
 
   mndAddShowMetaHandle(pMnode, TSDB_MGMT_TABLE_STB, mndGetStbMeta);
   mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_STB, mndRetrieveStb);
@@ -345,7 +345,7 @@ static int32_t mndSetCreateStbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj
     action.epSet = mndGetVgroupEpset(pMnode, pVgroup);
     action.pCont = pMsg;
     action.contLen = htonl(pMsg->head.contLen);
-    action.msgType = TSDB_MSG_TYPE_CREATE_STB_IN;
+    action.msgType = TDMT_VND_CREATE_STB;
     if (mndTransAppendRedoAction(pTrans, &action) != 0) {
       free(pMsg);
       sdbCancelFetch(pSdb, pIter);
@@ -380,7 +380,7 @@ static int32_t mndSetCreateStbUndoActions(SMnode *pMnode, STrans *pTrans, SDbObj
     action.epSet = mndGetVgroupEpset(pMnode, pVgroup);
     action.pCont = pMsg;
     action.contLen = sizeof(SDropStbInternalMsg);
-    action.msgType = TSDB_MSG_TYPE_DROP_STB_IN;
+    action.msgType = TDMT_VND_DROP_STB;
     if (mndTransAppendUndoAction(pTrans, &action) != 0) {
       free(pMsg);
       sdbCancelFetch(pSdb, pIter);
@@ -484,6 +484,15 @@ static int32_t mndProcessCreateStbMsg(SMnodeMsg *pMsg) {
     }
   }
 
+  //topic should have different name with stb
+  SStbObj *pTopic = mndAcquireStb(pMnode, pCreate->name);
+  if (pTopic != NULL) {
+    sdbRelease(pMnode->pSdb, pTopic);
+    terrno = TSDB_CODE_MND_NAME_CONFLICT_WITH_TOPIC;
+    mError("stb:%s, failed to create since %s", pCreate->name, terrstr());
+    return -1;
+  }
+
   SDbObj *pDb = mndAcquireDbByStb(pMnode, pCreate->name);
   if (pDb == NULL) {
     terrno = TSDB_CODE_MND_DB_NOT_SELECTED;

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

@@ -0,0 +1,857 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "mndStb.h"
+#include "mndDb.h"
+#include "mndDnode.h"
+#include "mndMnode.h"
+#include "mndShow.h"
+#include "mndTrans.h"
+#include "mndUser.h"
+#include "mndVgroup.h"
+#include "tname.h"
+
+#define TSDB_TOPIC_VER_NUMBER 1
+#define TSDB_TOPIC_RESERVE_SIZE 64
+
+static SSdbRaw *mndTopicActionEncode(STopicObj *pTopic);
+static SSdbRow *mndTopicActionDecode(SSdbRaw *pRaw);
+static int32_t  mndTopicActionInsert(SSdb *pSdb, STopicObj *pTopic);
+static int32_t  mndTopicActionDelete(SSdb *pSdb, STopicObj *pTopic);
+static int32_t  mndTopicActionUpdate(SSdb *pSdb, STopicObj *pTopic, STopicObj *pNewTopic);
+static int32_t  mndProcessCreateTopicMsg(SMnodeMsg *pMsg);
+static int32_t  mndProcessAlterTopicMsg(SMnodeMsg *pMsg);
+static int32_t  mndProcessDropTopicMsg(SMnodeMsg *pMsg);
+static int32_t  mndProcessCreateTopicInRsp(SMnodeMsg *pMsg);
+static int32_t  mndProcessAlterTopicInRsp(SMnodeMsg *pMsg);
+static int32_t  mndProcessDropTopicInRsp(SMnodeMsg *pMsg);
+static int32_t  mndProcessTopicMetaMsg(SMnodeMsg *pMsg);
+static int32_t  mndGetTopicMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta);
+static int32_t  mndRetrieveTopic(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows);
+static void     mndCancelGetNextTopic(SMnode *pMnode, void *pIter);
+
+int32_t mndInitTopic(SMnode *pMnode) {
+  SSdbTable table = {.sdbType = SDB_TOPIC,
+                     .keyType = SDB_KEY_BINARY,
+                     .encodeFp = (SdbEncodeFp)mndTopicActionEncode,
+                     .decodeFp = (SdbDecodeFp)mndTopicActionDecode,
+                     .insertFp = (SdbInsertFp)mndTopicActionInsert,
+                     .updateFp = (SdbUpdateFp)mndTopicActionUpdate,
+                     .deleteFp = (SdbDeleteFp)mndTopicActionDelete};
+
+  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_TOPIC, mndProcessCreateTopicMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_ALTER_TOPIC, mndProcessAlterTopicMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_DROP_TOPIC, mndProcessDropTopicMsg);
+  mndSetMsgHandle(pMnode, TDMT_VND_CREATE_TOPIC_RSP, mndProcessCreateTopicInRsp);
+  mndSetMsgHandle(pMnode, TDMT_VND_ALTER_TOPIC_RSP, mndProcessAlterTopicInRsp);
+  mndSetMsgHandle(pMnode, TDMT_VND_DROP_TOPIC_RSP, mndProcessDropTopicInRsp);
+  mndSetMsgHandle(pMnode, TDMT_VND_TABLE_META, mndProcessTopicMetaMsg);
+
+  /*mndAddShowMetaHandle(pMnode, TSDB_MGMT_TOPIC, mndGetTopicMeta);*/
+  /*mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TOPIC, mndRetrieveTopic);*/
+  /*mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TOPIC, mndCancelGetNextTopic);*/
+
+  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_TOPIC, mndProcessCreateTopicMsg);
+  mndSetMsgHandle(pMnode, TDMT_VND_CREATE_TOPIC_RSP, mndProcessCreateTopicInRsp);
+
+  return sdbSetTable(pMnode->pSdb, table);
+}
+
+void mndCleanupTopic(SMnode *pMnode) {}
+
+static SSdbRaw *mndTopicActionEncode(STopicObj *pTopic) {
+  int32_t  size = sizeof(STopicObj) + TSDB_TOPIC_RESERVE_SIZE;
+  SSdbRaw *pRaw = sdbAllocRaw(SDB_TOPIC, TSDB_TOPIC_VER_NUMBER, size);
+  if (pRaw == NULL) return NULL;
+
+  int32_t dataPos = 0;
+  SDB_SET_BINARY(pRaw, dataPos, pTopic->name, TSDB_TABLE_FNAME_LEN);
+  SDB_SET_BINARY(pRaw, dataPos, pTopic->db, TSDB_FULL_DB_NAME_LEN);
+  SDB_SET_INT64(pRaw, dataPos, pTopic->createTime);
+  SDB_SET_INT64(pRaw, dataPos, pTopic->updateTime);
+  SDB_SET_INT64(pRaw, dataPos, pTopic->uid);
+  SDB_SET_INT64(pRaw, dataPos, pTopic->dbUid);
+  SDB_SET_INT32(pRaw, dataPos, pTopic->version);
+  SDB_SET_INT32(pRaw, dataPos, pTopic->execLen);
+  SDB_SET_BINARY(pRaw, dataPos, pTopic->executor, pTopic->execLen);
+  SDB_SET_INT32(pRaw, dataPos, pTopic->sqlLen);
+  SDB_SET_BINARY(pRaw, dataPos, pTopic->sql, pTopic->sqlLen);
+
+  SDB_SET_RESERVE(pRaw, dataPos, TSDB_TOPIC_RESERVE_SIZE);
+  SDB_SET_DATALEN(pRaw, dataPos);
+
+  return pRaw;
+}
+
+static SSdbRow *mndTopicActionDecode(SSdbRaw *pRaw) {
+  int8_t sver = 0;
+  if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL;
+
+  if (sver != TSDB_TOPIC_VER_NUMBER) {
+    mError("failed to decode stable since %s", terrstr());
+    terrno = TSDB_CODE_SDB_INVALID_DATA_VER;
+    return NULL;
+  }
+
+  int32_t  size = sizeof(STopicObj) + TSDB_MAX_COLUMNS * sizeof(SSchema);
+  SSdbRow *pRow = sdbAllocRow(size);
+  STopicObj *pTopic = sdbGetRowObj(pRow);
+  if (pTopic == NULL) return NULL;
+
+  int32_t dataPos = 0;
+  SDB_GET_BINARY(pRaw, pRow, dataPos, pTopic->name, TSDB_TABLE_FNAME_LEN);
+  SDB_GET_BINARY(pRaw, pRow, dataPos, pTopic->db, TSDB_FULL_DB_NAME_LEN);
+  SDB_GET_INT64(pRaw, pRow, dataPos, &pTopic->createTime);
+  SDB_GET_INT64(pRaw, pRow, dataPos, &pTopic->updateTime);
+  SDB_GET_INT64(pRaw, pRow, dataPos, &pTopic->uid);
+  SDB_GET_INT64(pRaw, pRow, dataPos, &pTopic->dbUid);
+  SDB_GET_INT32(pRaw, pRow, dataPos, &pTopic->version);
+  SDB_GET_INT32(pRaw, pRow, dataPos, &pTopic->execLen);
+  SDB_GET_BINARY(pRaw, pRow, dataPos, pTopic->executor, pTopic->execLen);
+  SDB_GET_INT32(pRaw, pRow, dataPos, &pTopic->sqlLen);
+  SDB_GET_BINARY(pRaw, pRow, dataPos, pTopic->sql, pTopic->sqlLen);
+
+  SDB_GET_RESERVE(pRaw, pRow, dataPos, TSDB_TOPIC_RESERVE_SIZE);
+
+  return pRow;
+}
+
+static int32_t mndTopicActionInsert(SSdb *pSdb, STopicObj *pTopic) {
+  mTrace("topic:%s, perform insert action", pTopic->name);
+  return 0;
+}
+
+static int32_t mndTopicActionDelete(SSdb *pSdb, STopicObj *pTopic) {
+  mTrace("topic:%s, perform delete action", pTopic->name);
+  return 0;
+}
+
+static int32_t mndTopicActionUpdate(SSdb *pSdb, STopicObj *pOldTopic, STopicObj *pNewTopic) {
+  mTrace("topic:%s, perform update action", pOldTopic->name);
+  atomic_exchange_32(&pOldTopic->updateTime, pNewTopic->updateTime);
+  atomic_exchange_32(&pOldTopic->version, pNewTopic->version);
+
+  taosWLockLatch(&pOldTopic->lock);
+#if 0
+
+  pOldTopic->numOfColumns = pNewTopic->numOfColumns;
+  pOldTopic->numOfTags = pNewTopic->numOfTags;
+  int32_t totalCols = pNewTopic->numOfTags + pNewTopic->numOfColumns;
+  int32_t totalSize = totalCols * sizeof(SSchema);
+
+  if (pOldTopic->numOfTags + pOldTopic->numOfColumns < totalCols) {
+    void *pSchema = malloc(totalSize);
+    if (pSchema != NULL) {
+      free(pOldTopic->pSchema);
+      pOldTopic->pSchema = pSchema;
+    }
+  }
+
+  memcpy(pOldTopic->pSchema, pNewTopic->pSchema, totalSize);
+
+#endif
+  taosWUnLockLatch(&pOldTopic->lock);
+  return 0;
+}
+
+STopicObj *mndAcquireTopic(SMnode *pMnode, char *topicName) {
+  SSdb    *pSdb = pMnode->pSdb;
+  STopicObj *pTopic = sdbAcquire(pSdb, SDB_TOPIC, topicName);
+  if (pTopic == NULL) {
+    terrno = TSDB_CODE_MND_TOPIC_NOT_EXIST;
+  }
+  return pTopic;
+}
+
+void mndReleaseTopic(SMnode *pMnode, STopicObj *pTopic) {
+  SSdb *pSdb = pMnode->pSdb;
+  sdbRelease(pSdb, pTopic);
+}
+
+static SDbObj *mndAcquireDbByTopic(SMnode *pMnode, char *topicName) {
+  SName name = {0};
+  tNameFromString(&name, topicName, T_NAME_ACCT | T_NAME_DB | T_NAME_TOPIC);
+
+  char db[TSDB_TABLE_FNAME_LEN] = {0};
+  tNameGetFullDbName(&name, db);
+
+  return mndAcquireDb(pMnode, db);
+}
+
+static SCreateTopicInternalMsg *mndBuildCreateTopicMsg(SMnode *pMnode, SVgObj *pVgroup, STopicObj *pTopic) {
+  int32_t totalCols = 0;
+  int32_t contLen = sizeof(SCreateTopicInternalMsg) + pTopic->execLen + pTopic->sqlLen;
+
+  SCreateTopicInternalMsg *pCreate = calloc(1, contLen);
+  if (pCreate == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
+
+  pCreate->head.contLen = htonl(contLen);
+  pCreate->head.vgId = htonl(pVgroup->vgId);
+  memcpy(pCreate->name, pTopic->name, TSDB_TABLE_FNAME_LEN);
+  pCreate->tuid = htobe64(pTopic->uid);
+  pCreate->sverson = htonl(pTopic->version);
+
+  pCreate->sql = malloc(pTopic->sqlLen);
+  if(pCreate->sql == NULL) {
+    free(pCreate);
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
+  memcpy(pCreate->sql, pTopic->sql, pTopic->sqlLen);
+
+  pCreate->executor = malloc(pTopic->execLen);
+  if(pCreate->executor == NULL) {
+    free(pCreate);
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
+  memcpy(pCreate->executor, pTopic->executor, pTopic->execLen);
+
+  return pCreate;
+}
+
+static SDropTopicInternalMsg *mndBuildDropTopicMsg(SMnode *pMnode, SVgObj *pVgroup, STopicObj *pTopic) {
+  int32_t contLen = sizeof(SDropTopicInternalMsg);
+
+  SDropTopicInternalMsg *pDrop = calloc(1, contLen);
+  if (pDrop == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
+
+  pDrop->head.contLen = htonl(contLen);
+  pDrop->head.vgId = htonl(pVgroup->vgId);
+  memcpy(pDrop->name, pTopic->name, TSDB_TABLE_FNAME_LEN);
+  pDrop->tuid = htobe64(pTopic->uid);
+
+  return pDrop;
+}
+
+static int32_t mndCheckCreateTopicMsg(SCreateTopicMsg *pCreate) {
+  //deserialize and other stuff
+  return 0;
+}
+
+static int32_t mndSetCreateTopicRedoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, STopicObj *pTopic) {
+  SSdbRaw *pRedoRaw = mndTopicActionEncode(pTopic);
+  if (pRedoRaw == NULL) return -1;
+  if (mndTransAppendRedolog(pTrans, pRedoRaw) != 0) return -1;
+  if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING) != 0) return -1;
+
+  return 0;
+}
+
+static int32_t mndSetCreateTopicUndoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, STopicObj *pTopic) {
+  SSdbRaw *pUndoRaw = mndTopicActionEncode(pTopic);
+  if (pUndoRaw == NULL) return -1;
+  if (mndTransAppendUndolog(pTrans, pUndoRaw) != 0) return -1;
+  if (sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED) != 0) return -1;
+
+  return 0;
+}
+
+static int32_t mndSetCreateTopicCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, STopicObj *pTopic) {
+  SSdbRaw *pCommitRaw = mndTopicActionEncode(pTopic);
+  if (pCommitRaw == NULL) return -1;
+  if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) return -1;
+  if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY) != 0) return -1;
+
+  return 0;
+}
+
+static int32_t mndSetCreateTopicRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, STopicObj *pTopic) {
+  SSdb   *pSdb = pMnode->pSdb;
+  SVgObj *pVgroup = NULL;
+  void   *pIter = NULL;
+
+  while (1) {
+    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);
+    if (pIter == NULL) break;
+    if (pVgroup->dbUid != pDb->uid) continue;
+
+    SCreateTopicInternalMsg *pMsg = mndBuildCreateTopicMsg(pMnode, pVgroup, pTopic);
+    if (pMsg == NULL) {
+      sdbCancelFetch(pSdb, pIter);
+      sdbRelease(pSdb, pVgroup);
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      return -1;
+    }
+
+    STransAction action = {0};
+    action.epSet = mndGetVgroupEpset(pMnode, pVgroup);
+    action.pCont = pMsg;
+    action.contLen = htonl(pMsg->head.contLen);
+    action.msgType = TDMT_VND_CREATE_TOPIC;
+    if (mndTransAppendRedoAction(pTrans, &action) != 0) {
+      free(pMsg);
+      sdbCancelFetch(pSdb, pIter);
+      sdbRelease(pSdb, pVgroup);
+      return -1;
+    }
+    sdbRelease(pSdb, pVgroup);
+  }
+
+  return 0;
+}
+
+static int32_t mndSetCreateTopicUndoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, STopicObj *pTopic) {
+  SSdb   *pSdb = pMnode->pSdb;
+  SVgObj *pVgroup = NULL;
+  void   *pIter = NULL;
+
+  while (1) {
+    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);
+    if (pIter == NULL) break;
+    if (pVgroup->dbUid != pDb->uid) continue;
+
+    SDropTopicInternalMsg *pMsg = mndBuildDropTopicMsg(pMnode, pVgroup, pTopic);
+    if (pMsg == NULL) {
+      sdbCancelFetch(pSdb, pIter);
+      sdbRelease(pSdb, pVgroup);
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      return -1;
+    }
+
+    STransAction action = {0};
+    action.epSet = mndGetVgroupEpset(pMnode, pVgroup);
+    action.pCont = pMsg;
+    action.contLen = sizeof(SDropTopicInternalMsg);
+    action.msgType = TDMT_VND_DROP_TOPIC;
+    if (mndTransAppendUndoAction(pTrans, &action) != 0) {
+      free(pMsg);
+      sdbCancelFetch(pSdb, pIter);
+      sdbRelease(pSdb, pVgroup);
+      return -1;
+    }
+    sdbRelease(pSdb, pVgroup);
+  }
+
+  return 0;
+}
+
+static int32_t mndCreateTopic(SMnode *pMnode, SMnodeMsg *pMsg, SCreateTopicMsg *pCreate, SDbObj *pDb) {
+  STopicObj topicObj = {0};
+  tstrncpy(topicObj.name, pCreate->name, TSDB_TABLE_FNAME_LEN);
+  tstrncpy(topicObj.db, pDb->name, TSDB_FULL_DB_NAME_LEN);
+  topicObj.createTime = taosGetTimestampMs();
+  topicObj.updateTime = topicObj.createTime;
+  topicObj.uid = mndGenerateUid(pCreate->name, TSDB_TABLE_FNAME_LEN);
+  topicObj.dbUid = pDb->uid;
+  topicObj.version = 1;
+
+#if 0
+  int32_t totalCols = topicObj.numOfColumns + topicObj.numOfTags;
+  int32_t totalSize = totalCols * sizeof(SSchema);
+  topicObj.sql = malloc(totalSize);
+  if (topicObj.sql == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
+  memcpy(topicObj.sql, pCreate->sql, totalSize);
+#endif
+
+  int32_t code = 0;
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, pMsg->rpcMsg.handle);
+  if (pTrans == NULL) {
+    mError("topic:%s, failed to create since %s", pCreate->name, terrstr());
+    return -1;
+  }
+  mDebug("trans:%d, used to create topic:%s", pTrans->id, pCreate->name);
+
+  if (mndSetCreateTopicRedoLogs(pMnode, pTrans, pDb, &topicObj) != 0) {
+    mError("trans:%d, failed to set redo log since %s", pTrans->id, terrstr());
+    goto CREATE_TOPIC_OVER;
+  }
+
+  if (mndSetCreateTopicUndoLogs(pMnode, pTrans, pDb, &topicObj) != 0) {
+    mError("trans:%d, failed to set undo log since %s", pTrans->id, terrstr());
+    goto CREATE_TOPIC_OVER;
+  }
+
+  if (mndSetCreateTopicCommitLogs(pMnode, pTrans, pDb, &topicObj) != 0) {
+    mError("trans:%d, failed to set commit log since %s", pTrans->id, terrstr());
+    goto CREATE_TOPIC_OVER;
+  }
+
+  if (mndSetCreateTopicRedoActions(pMnode, pTrans, pDb, &topicObj) != 0) {
+    mError("trans:%d, failed to set redo actions since %s", pTrans->id, terrstr());
+    goto CREATE_TOPIC_OVER;
+  }
+
+  if (mndSetCreateTopicUndoActions(pMnode, pTrans, pDb, &topicObj) != 0) {
+    mError("trans:%d, failed to set redo actions since %s", pTrans->id, terrstr());
+    goto CREATE_TOPIC_OVER;
+  }
+
+  if (mndTransPrepare(pMnode, pTrans) != 0) {
+    mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
+    mndTransDrop(pTrans);
+    return -1;
+  }
+
+  code = 0;
+
+CREATE_TOPIC_OVER:
+  mndTransDrop(pTrans);
+  return code;
+}
+
+static int32_t mndProcessCreateTopicMsg(SMnodeMsg *pMsg) {
+  SMnode        *pMnode = pMsg->pMnode;
+  SCreateTopicMsg *pCreate = pMsg->rpcMsg.pCont;
+
+  mDebug("topic:%s, start to create", pCreate->name);
+
+  if (mndCheckCreateTopicMsg(pCreate) != 0) {
+    mError("topic:%s, failed to create since %s", pCreate->name, terrstr());
+    return -1;
+  }
+
+  STopicObj *pTopic = mndAcquireTopic(pMnode, pCreate->name);
+  if (pTopic != NULL) {
+    sdbRelease(pMnode->pSdb, pTopic);
+    if (pCreate->igExists) {
+      mDebug("topic:%s, already exist, ignore exist is set", pCreate->name);
+      return 0;
+    } else {
+      terrno = TSDB_CODE_MND_TOPIC_ALREADY_EXIST;
+      mError("db:%s, failed to create since %s", pCreate->name, terrstr());
+      return -1;
+    }
+  }
+
+  //topic should have different name with stb
+  SStbObj *pStb = mndAcquireStb(pMnode, pCreate->name);
+  if (pStb != NULL) {
+    sdbRelease(pMnode->pSdb, pStb);
+    terrno = TSDB_CODE_MND_NAME_CONFLICT_WITH_STB;
+    mError("topic:%s, failed to create since %s", pCreate->name, terrstr());
+    return -1;
+  }
+
+  SDbObj *pDb = mndAcquireDbByTopic(pMnode, pCreate->name);
+  if (pDb == NULL) {
+    terrno = TSDB_CODE_MND_DB_NOT_SELECTED;
+    mError("topic:%s, failed to create since %s", pCreate->name, terrstr());
+    return -1;
+  }
+
+  int32_t code = mndCreateTopic(pMnode, pMsg, pCreate, pDb);
+  mndReleaseDb(pMnode, pDb);
+
+  if (code != 0) {
+    terrno = code;
+    mError("topic:%s, failed to create since %s", pCreate->name, terrstr());
+    return -1;
+  }
+
+  return TSDB_CODE_MND_ACTION_IN_PROGRESS;
+}
+
+static int32_t mndCheckAlterTopicMsg(SAlterTopicMsg *pAlter) {
+  SSchema *pSchema = &pAlter->schema;
+  pSchema->colId = htonl(pSchema->colId);
+  pSchema->bytes = htonl(pSchema->bytes);
+
+  if (pSchema->type <= 0) {
+    terrno = TSDB_CODE_MND_INVALID_TOPIC_OPTION;
+    return -1;
+  }
+  if (pSchema->colId < 0 || pSchema->colId >= (TSDB_MAX_COLUMNS + TSDB_MAX_TAGS)) {
+    terrno = TSDB_CODE_MND_INVALID_TOPIC_OPTION;
+    return -1;
+  }
+  if (pSchema->bytes <= 0) {
+    terrno = TSDB_CODE_MND_INVALID_TOPIC_OPTION;
+    return -1;
+  }
+  if (pSchema->name[0] == 0) {
+    terrno = TSDB_CODE_MND_INVALID_TOPIC_OPTION;
+    return -1;
+  }
+
+  return 0;
+}
+
+static int32_t mndUpdateTopic(SMnode *pMnode, SMnodeMsg *pMsg, STopicObj *pOldTopic, STopicObj *pNewTopic) { return 0; }
+
+static int32_t mndProcessAlterTopicMsg(SMnodeMsg *pMsg) {
+  SMnode       *pMnode = pMsg->pMnode;
+  SAlterTopicMsg *pAlter = pMsg->rpcMsg.pCont;
+
+  mDebug("topic:%s, start to alter", pAlter->name);
+
+  if (mndCheckAlterTopicMsg(pAlter) != 0) {
+    mError("topic:%s, failed to alter since %s", pAlter->name, terrstr());
+    return -1;
+  }
+
+  STopicObj *pTopic = mndAcquireTopic(pMnode, pAlter->name);
+  if (pTopic == NULL) {
+    terrno = TSDB_CODE_MND_TOPIC_NOT_EXIST;
+    mError("topic:%s, failed to alter since %s", pAlter->name, terrstr());
+    return -1;
+  }
+
+  STopicObj topicObj = {0};
+  memcpy(&topicObj, pTopic, sizeof(STopicObj));
+
+  int32_t code = mndUpdateTopic(pMnode, pMsg, pTopic, &topicObj);
+  mndReleaseTopic(pMnode, pTopic);
+
+  if (code != 0) {
+    mError("topic:%s, failed to alter since %s", pAlter->name, tstrerror(code));
+    return code;
+  }
+
+  return TSDB_CODE_MND_ACTION_IN_PROGRESS;
+}
+
+static int32_t mndProcessAlterTopicInRsp(SMnodeMsg *pMsg) {
+  mndTransHandleActionRsp(pMsg);
+  return 0;
+}
+
+static int32_t mndSetDropTopicRedoLogs(SMnode *pMnode, STrans *pTrans, STopicObj *pTopic) {
+  SSdbRaw *pRedoRaw = mndTopicActionEncode(pTopic);
+  if (pRedoRaw == NULL) return -1;
+  if (mndTransAppendRedolog(pTrans, pRedoRaw) != 0) return -1;
+  if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING) != 0) return -1;
+
+  return 0;
+}
+
+static int32_t mndSetDropTopicUndoLogs(SMnode *pMnode, STrans *pTrans, STopicObj *pTopic) {
+  SSdbRaw *pUndoRaw = mndTopicActionEncode(pTopic);
+  if (pUndoRaw == NULL) return -1;
+  if (mndTransAppendUndolog(pTrans, pUndoRaw) != 0) return -1;
+  if (sdbSetRawStatus(pUndoRaw, SDB_STATUS_READY) != 0) return -1;
+
+  return 0;
+}
+
+static int32_t mndSetDropTopicCommitLogs(SMnode *pMnode, STrans *pTrans, STopicObj *pTopic) {
+  SSdbRaw *pCommitRaw = mndTopicActionEncode(pTopic);
+  if (pCommitRaw == NULL) return -1;
+  if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) return -1;
+  if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED) != 0) return -1;
+
+  return 0;
+}
+
+static int32_t mndSetDropTopicRedoActions(SMnode *pMnode, STrans *pTrans, STopicObj *pTopic) { return 0; }
+
+static int32_t mndSetDropTopicUndoActions(SMnode *pMnode, STrans *pTrans, STopicObj *pTopic) { return 0; }
+
+static int32_t mndDropTopic(SMnode *pMnode, SMnodeMsg *pMsg, STopicObj *pTopic) {
+  int32_t code = -1;
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, pMsg->rpcMsg.handle);
+  if (pTrans == NULL) {
+    mError("topic:%s, failed to drop since %s", pTopic->name, terrstr());
+    return -1;
+  }
+  mDebug("trans:%d, used to drop topic:%s", pTrans->id, pTopic->name);
+
+  if (mndSetDropTopicRedoLogs(pMnode, pTrans, pTopic) != 0) {
+    mError("trans:%d, failed to set redo log since %s", pTrans->id, terrstr());
+    goto DROP_TOPIC_OVER;
+  }
+
+  if (mndSetDropTopicUndoLogs(pMnode, pTrans, pTopic) != 0) {
+    mError("trans:%d, failed to set undo log since %s", pTrans->id, terrstr());
+    goto DROP_TOPIC_OVER;
+  }
+
+  if (mndSetDropTopicCommitLogs(pMnode, pTrans, pTopic) != 0) {
+    mError("trans:%d, failed to set commit log since %s", pTrans->id, terrstr());
+    goto DROP_TOPIC_OVER;
+  }
+
+  if (mndSetDropTopicRedoActions(pMnode, pTrans, pTopic) != 0) {
+    mError("trans:%d, failed to set redo actions since %s", pTrans->id, terrstr());
+    goto DROP_TOPIC_OVER;
+  }
+
+  if (mndSetDropTopicUndoActions(pMnode, pTrans, pTopic) != 0) {
+    mError("trans:%d, failed to set redo actions since %s", pTrans->id, terrstr());
+    goto DROP_TOPIC_OVER;
+  }
+
+  if (mndTransPrepare(pMnode, pTrans) != 0) {
+    mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
+    goto DROP_TOPIC_OVER;
+  }
+
+  code = 0;
+
+DROP_TOPIC_OVER:
+  mndTransDrop(pTrans);
+  return 0;
+}
+
+static int32_t mndProcessDropTopicMsg(SMnodeMsg *pMsg) {
+  SMnode      *pMnode = pMsg->pMnode;
+  SDropTopicMsg *pDrop = pMsg->rpcMsg.pCont;
+
+  mDebug("topic:%s, start to drop", pDrop->name);
+
+  STopicObj *pTopic = mndAcquireTopic(pMnode, pDrop->name);
+  if (pTopic == NULL) {
+    if (pDrop->igNotExists) {
+      mDebug("topic:%s, not exist, ignore not exist is set", pDrop->name);
+      return 0;
+    } else {
+      terrno = TSDB_CODE_MND_TOPIC_NOT_EXIST;
+      mError("topic:%s, failed to drop since %s", pDrop->name, terrstr());
+      return -1;
+    }
+  }
+
+  int32_t code = mndDropTopic(pMnode, pMsg, pTopic);
+  mndReleaseTopic(pMnode, pTopic);
+
+  if (code != 0) {
+    terrno = code;
+    mError("topic:%s, failed to drop since %s", pDrop->name, terrstr());
+    return -1;
+  }
+
+  return TSDB_CODE_MND_ACTION_IN_PROGRESS;
+}
+
+static int32_t mndProcessDropTopicInRsp(SMnodeMsg *pMsg) {
+  mndTransHandleActionRsp(pMsg);
+  return 0;
+}
+
+static int32_t mndProcessTopicMetaMsg(SMnodeMsg *pMsg) {
+  SMnode        *pMnode = pMsg->pMnode;
+  STableInfoMsg *pInfo = pMsg->rpcMsg.pCont;
+
+  mDebug("topic:%s, start to retrieve meta", pInfo->tableFname);
+
+#if 0
+  SDbObj *pDb = mndAcquireDbByTopic(pMnode, pInfo->tableFname);
+  if (pDb == NULL) {
+    terrno = TSDB_CODE_MND_DB_NOT_SELECTED;
+    mError("topic:%s, failed to retrieve meta since %s", pInfo->tableFname, terrstr());
+    return -1;
+  }
+
+  STopicObj *pTopic = mndAcquireTopic(pMnode, pInfo->tableFname);
+  if (pTopic == NULL) {
+    mndReleaseDb(pMnode, pDb);
+    terrno = TSDB_CODE_MND_INVALID_TOPIC;
+    mError("topic:%s, failed to get meta since %s", pInfo->tableFname, terrstr());
+    return -1;
+  }
+
+  taosRLockLatch(&pTopic->lock);
+  int32_t totalCols = pTopic->numOfColumns + pTopic->numOfTags;
+  int32_t contLen = sizeof(STableMetaMsg) + totalCols * sizeof(SSchema);
+
+  STableMetaMsg *pMeta = rpcMallocCont(contLen);
+  if (pMeta == NULL) {
+    taosRUnLockLatch(&pTopic->lock);
+    mndReleaseDb(pMnode, pDb);
+    mndReleaseTopic(pMnode, pTopic);
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    mError("topic:%s, failed to get meta since %s", pInfo->tableFname, terrstr());
+    return -1;
+  }
+
+  memcpy(pMeta->topicFname, pTopic->name, TSDB_TABLE_FNAME_LEN);
+  pMeta->numOfTags = htonl(pTopic->numOfTags);
+  pMeta->numOfColumns = htonl(pTopic->numOfColumns);
+  pMeta->precision = pDb->cfg.precision;
+  pMeta->tableType = TSDB_SUPER_TABLE;
+  pMeta->update = pDb->cfg.update;
+  pMeta->sversion = htonl(pTopic->version);
+  pMeta->tuid = htonl(pTopic->uid);
+
+  for (int32_t i = 0; i < totalCols; ++i) {
+    SSchema *pSchema = &pMeta->pSchema[i];
+    SSchema *pSrcSchema = &pTopic->pSchema[i];
+    memcpy(pSchema->name, pSrcSchema->name, TSDB_COL_NAME_LEN);
+    pSchema->type = pSrcSchema->type;
+    pSchema->colId = htonl(pSrcSchema->colId);
+    pSchema->bytes = htonl(pSrcSchema->bytes);
+  }
+  taosRUnLockLatch(&pTopic->lock);
+  mndReleaseDb(pMnode, pDb);
+  mndReleaseTopic(pMnode, pTopic);
+
+  pMsg->pCont = pMeta;
+  pMsg->contLen = contLen;
+
+  mDebug("topic:%s, meta is retrieved, cols:%d tags:%d", pInfo->tableFname, pTopic->numOfColumns, pTopic->numOfTags);
+#endif
+  return 0;
+}
+
+static int32_t mndProcessCreateTopicInRsp(SMnodeMsg* pMsg) {
+  mndTransHandleActionRsp(pMsg);
+  return 0;
+}
+
+static int32_t mndGetNumOfTopics(SMnode *pMnode, char *dbName, int32_t *pNumOfTopics) {
+  SSdb *pSdb = pMnode->pSdb;
+
+  SDbObj *pDb = mndAcquireDb(pMnode, dbName);
+  if (pDb == NULL) {
+    terrno = TSDB_CODE_MND_DB_NOT_SELECTED;
+    return -1;
+  }
+
+  int32_t numOfTopics = 0;
+  void   *pIter = NULL;
+  while (1) {
+    STopicObj *pTopic = NULL;
+    pIter = sdbFetch(pSdb, SDB_TOPIC, pIter, (void **)&pTopic);
+    if (pIter == NULL) break;
+
+    if (strcmp(pTopic->db, dbName) == 0) {
+      numOfTopics++;
+    }
+
+    sdbRelease(pSdb, pTopic);
+  }
+
+  *pNumOfTopics = numOfTopics;
+  return 0;
+}
+
+static int32_t mndGetTopicMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta) {
+  SMnode *pMnode = pMsg->pMnode;
+  SSdb   *pSdb = pMnode->pSdb;
+
+  if (mndGetNumOfTopics(pMnode, pShow->db, &pShow->numOfRows) != 0) {
+    return -1;
+  }
+
+  int32_t  cols = 0;
+  SSchema *pSchema = pMeta->pSchema;
+
+  pShow->bytes[cols] = TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE;
+  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
+  strcpy(pSchema[cols].name, "name");
+  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] = 4;
+  pSchema[cols].type = TSDB_DATA_TYPE_INT;
+  strcpy(pSchema[cols].name, "columns");
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
+  cols++;
+
+  pShow->bytes[cols] = 4;
+  pSchema[cols].type = TSDB_DATA_TYPE_INT;
+  strcpy(pSchema[cols].name, "tags");
+  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 = sdbGetSize(pSdb, SDB_TOPIC);
+  pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
+  strcpy(pMeta->tbFname, mndShowStr(pShow->type));
+
+  return 0;
+}
+
+static void mndExtractTableName(char *tableId, char *name) {
+  int pos = -1;
+  int num = 0;
+  for (pos = 0; tableId[pos] != 0; ++pos) {
+    if (tableId[pos] == '.') num++;
+    if (num == 2) break;
+  }
+
+  if (num == 2) {
+    strcpy(name, tableId + pos + 1);
+  }
+}
+
+static int32_t mndRetrieveTopic(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows) {
+  SMnode  *pMnode = pMsg->pMnode;
+  SSdb    *pSdb = pMnode->pSdb;
+  int32_t  numOfRows = 0;
+  STopicObj *pTopic = NULL;
+  int32_t  cols = 0;
+  char    *pWrite;
+  char     prefix[64] = {0};
+
+  tstrncpy(prefix, pShow->db, 64);
+  strcat(prefix, TS_PATH_DELIMITER);
+  int32_t prefixLen = (int32_t)strlen(prefix);
+
+  while (numOfRows < rows) {
+    pShow->pIter = sdbFetch(pSdb, SDB_TOPIC, pShow->pIter, (void **)&pTopic);
+    if (pShow->pIter == NULL) break;
+
+    if (strncmp(pTopic->name, prefix, prefixLen) != 0) {
+      sdbRelease(pSdb, pTopic);
+      continue;
+    }
+
+    cols = 0;
+
+    char topicName[TSDB_TABLE_NAME_LEN] = {0};
+    tstrncpy(topicName, pTopic->name + prefixLen, TSDB_TABLE_NAME_LEN);
+    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+    STR_TO_VARSTR(pWrite, topicName);
+    cols++;
+
+    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+    *(int64_t *)pWrite = pTopic->createTime;
+    cols++;
+
+    /*pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;*/
+    /**(int32_t *)pWrite = pTopic->numOfColumns;*/
+    /*cols++;*/
+
+    /*pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;*/
+    /**(int32_t *)pWrite = pTopic->numOfTags;*/
+    /*cols++;*/
+
+    numOfRows++;
+    sdbRelease(pSdb, pTopic);
+  }
+
+  pShow->numOfReads += numOfRows;
+  mndVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
+  return numOfRows;
+}
+
+static void mndCancelGetNextTopic(SMnode *pMnode, void *pIter) {
+  SSdb *pSdb = pMnode->pSdb;
+  sdbCancelFetch(pSdb, pIter);
+}

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

@@ -466,13 +466,13 @@ static int32_t mndTransAppendAction(SArray *pArray, STransAction *pAction) {
 
 int32_t mndTransAppendRedoAction(STrans *pTrans, STransAction *pAction) {
   int32_t code = mndTransAppendAction(pTrans->redoActions, pAction);
-  mTrace("trans:%d, msg:%s append to redo actions, code:0x%x", pTrans->id, taosMsg[pAction->msgType], code);
+  mTrace("trans:%d, msg:%s append to redo actions, code:0x%x", pTrans->id, TMSG_INFO(pAction->msgType), code);
   return code;
 }
 
 int32_t mndTransAppendUndoAction(STrans *pTrans, STransAction *pAction) {
   int32_t code = mndTransAppendAction(pTrans->undoActions, pAction);
-  mTrace("trans:%d, msg:%s append to undo actions, code:0x%x", pTrans->id, taosMsg[pAction->msgType], code);
+  mTrace("trans:%d, msg:%s append to undo actions, code:0x%x", pTrans->id, TMSG_INFO(pAction->msgType), code);
   return code;
 }
 
@@ -696,7 +696,8 @@ static int32_t mndTransExecuteActions(SMnode *pMnode, STrans *pTrans, SArray *pA
   for (int32_t action = 0; action < numOfActions; ++action) {
     STransAction *pAction = taosArrayGet(pArray, action);
     if (pAction == NULL) continue;
-    if (pAction->msgReceived && pAction->errCode == 0) continue;
+    if (pAction->msgSent && !pAction->msgReceived) continue;
+    if (pAction->msgSent && pAction->msgReceived && pAction->errCode == 0) continue;
 
     int64_t signature = pTrans->id;
     signature = (signature << 32);

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

@@ -47,9 +47,9 @@ int32_t mndInitUser(SMnode *pMnode) {
                      .updateFp = (SdbUpdateFp)mndUserActionUpdate,
                      .deleteFp = (SdbDeleteFp)mndUserActionDelete};
 
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_CREATE_USER, mndProcessCreateUserMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_USER, mndProcessCreateUserMsg);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_ALTER_USER, mndProcessAlterUserMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_ALTER_USER, mndProcessAlterUserMsg);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_DROP_USER, mndProcessDropUserMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_DROP_USER, mndProcessDropUserMsg);
 
   mndAddShowMetaHandle(pMnode, TSDB_MGMT_TABLE_USER, mndGetUserMeta);
   mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_USER, mndRetrieveUsers);

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

@@ -51,11 +51,11 @@ int32_t mndInitVgroup(SMnode *pMnode) {
                      .updateFp = (SdbUpdateFp)mndVgroupActionDelete,
                      .deleteFp = (SdbDeleteFp)mndVgroupActionUpdate};
 
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_CREATE_VNODE_IN_RSP, mndProcessCreateVnodeRsp);
+  mndSetMsgHandle(pMnode, TDMT_DND_CREATE_VNODE_RSP, mndProcessCreateVnodeRsp);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_ALTER_VNODE_IN_RSP, mndProcessAlterVnodeRsp);
+  mndSetMsgHandle(pMnode, TDMT_DND_ALTER_VNODE_RSP, mndProcessAlterVnodeRsp);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_DROP_VNODE_IN_RSP, mndProcessDropVnodeRsp);
+  mndSetMsgHandle(pMnode, TDMT_DND_DROP_VNODE_RSP, mndProcessDropVnodeRsp);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_SYNC_VNODE_IN_RSP, mndProcessSyncVnodeRsp);
+  mndSetMsgHandle(pMnode, TDMT_DND_SYNC_VNODE_RSP, mndProcessSyncVnodeRsp);
-  mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_COMPACT_VNODE_IN_RSP, mndProcessCompactVnodeRsp);
+  mndSetMsgHandle(pMnode, TDMT_DND_COMPACT_VNODE_RSP, mndProcessCompactVnodeRsp);
 
   mndAddShowMetaHandle(pMnode, TSDB_MGMT_TABLE_VGROUP, mndGetVgroupMeta);
   mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_VGROUP, mndRetrieveVgroups);
@@ -337,8 +337,16 @@ static int32_t mndProcessCreateVnodeRsp(SMnodeMsg *pMsg) {
   return 0;
 }
 
-static int32_t mndProcessAlterVnodeRsp(SMnodeMsg *pMsg) { return 0; }
+static int32_t mndProcessAlterVnodeRsp(SMnodeMsg *pMsg) {
-static int32_t mndProcessDropVnodeRsp(SMnodeMsg *pMsg) { return 0; }
+  mndTransHandleActionRsp(pMsg);
+  return 0;
+}
+
+static int32_t mndProcessDropVnodeRsp(SMnodeMsg *pMsg) {
+  mndTransHandleActionRsp(pMsg);
+  return 0;
+}
+
 static int32_t mndProcessSyncVnodeRsp(SMnodeMsg *pMsg) { return 0; }
 static int32_t mndProcessCompactVnodeRsp(SMnodeMsg *pMsg) { return 0; }
 

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

@@ -27,6 +27,7 @@
 #include "mndStb.h"
 #include "mndSync.h"
 #include "mndTelem.h"
+#include "mndTopic.h"
 #include "mndTrans.h"
 #include "mndUser.h"
 #include "mndVgroup.h"
@@ -132,6 +133,7 @@ static int32_t mndInitSteps(SMnode *pMnode) {
   if (mndAllocStep(pMnode, "mnode-db", mndInitDb, mndCleanupDb) != 0) return -1;
   if (mndAllocStep(pMnode, "mnode-vgroup", mndInitVgroup, mndCleanupVgroup) != 0) return -1;
   if (mndAllocStep(pMnode, "mnode-stb", mndInitStb, mndCleanupStb) != 0) return -1;
+  if (mndAllocStep(pMnode, "mnode-topic", mndInitTopic, mndCleanupTopic) != 0) return -1;
   if (mndAllocStep(pMnode, "mnode-func", mndInitFunc, mndCleanupFunc) != 0) return -1;
   if (pMnode->clusterId <= 0) {
     if (mndAllocStep(pMnode, "mnode-sdb-deploy", mndDeploySdb, NULL) != 0) return -1;
@@ -376,7 +378,7 @@ static void mndProcessRpcMsg(SMnodeMsg *pMsg) {
   void   *ahandle = pMsg->rpcMsg.ahandle;
   bool    isReq = (msgType & 1U);
 
-  mTrace("msg:%p, app:%p type:%s will be processed", pMsg, ahandle, taosMsg[msgType]);
+  mTrace("msg:%p, app:%p type:%s will be processed", pMsg, ahandle, TMSG_INFO(msgType));
 
   if (isReq && !mndIsMaster(pMnode)) {
     code = TSDB_CODE_APP_NOT_READY;
@@ -424,7 +426,7 @@ PROCESS_RPC_END:
 }
 
 void mndSetMsgHandle(SMnode *pMnode, int32_t msgType, MndMsgFp fp) {
-  if (msgType >= 0 && msgType < TSDB_MSG_TYPE_MAX) {
+  if (msgType >= 0 && msgType < TDMT_MAX) {
     pMnode->msgFp[msgType] = fp;
   }
 }

source/dnode/mnode/sdb/inc/sdbInt.h

@@ -18,7 +18,7 @@
 
 #include "os.h"
 #include "sdb.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "thash.h"
 #include "tlockfree.h"
 #include "tlog.h"

source/dnode/mnode/sdb/src/sdbHash.c

@@ -199,6 +199,7 @@ void *sdbAcquire(SSdb *pSdb, ESdbType type, void *pKey) {
   SSdbRow *pRow = *ppRow;
   switch (pRow->status) {
     case SDB_STATUS_READY:
+    case SDB_STATUS_UPDATING:
       atomic_add_fetch_32(&pRow->refCount, 1);
       pRet = pRow->pObj;
       break;

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

@@ -22,17 +22,14 @@
 extern "C" {
 #endif
 
-typedef struct SVArenaNode    SVArenaNode;
+typedef struct SVArenaNode {
-typedef struct SVMemAllocator SVMemAllocator;
-
-struct SVArenaNode {
   TD_SLIST_NODE(SVArenaNode);
   uint64_t size;  // current node size
   void *   ptr;
   char     data[];
-};
+} SVArenaNode;
 
-struct SVMemAllocator {
+typedef struct SVMemAllocator {
   T_REF_DECLARE()
   TD_DLIST_NODE(SVMemAllocator);
   uint64_t     capacity;
@@ -40,7 +37,7 @@ struct SVMemAllocator {
   uint64_t     lsize;
   SVArenaNode *pNode;
   TD_SLIST(SVArenaNode) nlist;
-};
+} SVMemAllocator;
 
 SVMemAllocator *vmaCreate(uint64_t capacity, uint64_t ssize, uint64_t lsize);
 void            vmaDestroy(SVMemAllocator *pVMA);

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

@@ -18,15 +18,15 @@
 static int   vnodeBuildCreateTableReq(void **buf, const SVCreateTableReq *pReq);
 static void *vnodeParseCreateTableReq(void *buf, SVCreateTableReq *pReq);
 
-int vnodeBuildReq(void **buf, const SVnodeReq *pReq, uint8_t type) {
+int vnodeBuildReq(void **buf, const SVnodeReq *pReq, tmsg_t type) {
   int tsize = 0;
 
   tsize += taosEncodeFixedU64(buf, pReq->ver);
   switch (type) {
-    case TSDB_MSG_TYPE_CREATE_TABLE:
+    case TDMT_MND_CREATE_TABLE:
       tsize += vnodeBuildCreateTableReq(buf, &(pReq->ctReq));
       break;
-    case TSDB_MSG_TYPE_SUBMIT:
+    case TDMT_VND_SUBMIT:
       /* code */
       break;
     default:
@@ -36,11 +36,11 @@ int vnodeBuildReq(void **buf, const SVnodeReq *pReq, uint8_t type) {
   return tsize;
 }
 
-void *vnodeParseReq(void *buf, SVnodeReq *pReq, uint8_t type) {
+void *vnodeParseReq(void *buf, SVnodeReq *pReq, tmsg_t type) {
   buf = taosDecodeFixedU64(buf, &(pReq->ver));
 
   switch (type) {
-    case TSDB_MSG_TYPE_CREATE_TABLE:
+    case TDMT_MND_CREATE_TABLE:
       buf = vnodeParseCreateTableReq(buf, &(pReq->ctReq));
       break;
 

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

@@ -17,7 +17,7 @@
 
 int vnodeProcessNoWalWMsgs(SVnode *pVnode, SRpcMsg *pMsg) {
   switch (pMsg->msgType) {
-    case TSDB_MSG_TYPE_MQ_SET_CUR:
+    case TDMT_VND_MQ_SET_CUR:
       if (tqSetCursor(pVnode->pTq, pMsg->pCont) < 0) {
         // TODO: handle error
       }
@@ -70,21 +70,21 @@ int vnodeApplyWMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
   vnodeParseReq(pMsg->pCont, &vReq, pMsg->msgType);
 
   switch (pMsg->msgType) {
-    case TSDB_MSG_TYPE_CREATE_STB_IN:
+    case TDMT_VND_CREATE_STB:
-    case TSDB_MSG_TYPE_CREATE_TABLE:
+    case TDMT_MND_CREATE_TABLE:
       if (metaCreateTable(pVnode->pMeta, &(vReq.ctReq)) < 0) {
         // TODO: handle error
       }
 
       // TODO: maybe need to clear the requst struct
       break;
-    case TSDB_MSG_TYPE_DROP_STB_IN:
+    case TDMT_VND_DROP_STB:
-    case TSDB_MSG_TYPE_DROP_TABLE:
+    case TDMT_MND_DROP_TABLE:
       if (metaDropTable(pVnode->pMeta, vReq.dtReq.uid) < 0) {
         // TODO: handle error
       }
       break;
-    case TSDB_MSG_TYPE_SUBMIT:
+    case TDMT_VND_SUBMIT:
       if (tsdbInsertData(pVnode->pTsdb, (SSubmitMsg *)ptr) < 0) {
         // TODO: handle error
       }

source/dnode/vnode/impl/test/vnodeApiTests.cpp

@@ -84,14 +84,14 @@ static void vtBuildCreateStbReq(tb_uid_t suid, char *tbname, SRpcMsg **ppMsg) {
   SVnodeReq vCreateSTbReq;
   vnodeSetCreateStbReq(&vCreateSTbReq, tbname, UINT32_MAX, UINT32_MAX, suid, pSchema, pTagSchema);
 
-  zs = vnodeBuildReq(NULL, &vCreateSTbReq, TSDB_MSG_TYPE_CREATE_TABLE);
+  zs = vnodeBuildReq(NULL, &vCreateSTbReq, TDMT_MND_CREATE_TABLE);
   pMsg = (SRpcMsg *)malloc(sizeof(SRpcMsg) + zs);
-  pMsg->msgType = TSDB_MSG_TYPE_CREATE_TABLE;
+  pMsg->msgType = TDMT_MND_CREATE_TABLE;
   pMsg->contLen = zs;
   pMsg->pCont = POINTER_SHIFT(pMsg, sizeof(SRpcMsg));
 
   pBuf = pMsg->pCont;
-  vnodeBuildReq(&pBuf, &vCreateSTbReq, TSDB_MSG_TYPE_CREATE_TABLE);
+  vnodeBuildReq(&pBuf, &vCreateSTbReq, TDMT_MND_CREATE_TABLE);
   META_CLEAR_TB_CFG(&vCreateSTbReq);
 
   tdFreeSchema(pSchema);
@@ -108,14 +108,14 @@ static void vtBuildCreateCtbReq(tb_uid_t suid, char *tbname, SRpcMsg **ppMsg) {
   SVnodeReq vCreateCTbReq;
   vnodeSetCreateCtbReq(&vCreateCTbReq, tbname, UINT32_MAX, UINT32_MAX, suid, pTag);
 
-  tz = vnodeBuildReq(NULL, &vCreateCTbReq, TSDB_MSG_TYPE_CREATE_TABLE);
+  tz = vnodeBuildReq(NULL, &vCreateCTbReq, TDMT_MND_CREATE_TABLE);
   pMsg = (SRpcMsg *)malloc(sizeof(SRpcMsg) + tz);
-  pMsg->msgType = TSDB_MSG_TYPE_CREATE_TABLE;
+  pMsg->msgType = TDMT_MND_CREATE_TABLE;
   pMsg->contLen = tz;
   pMsg->pCont = POINTER_SHIFT(pMsg, sizeof(*pMsg));
   void *pBuf = pMsg->pCont;
 
-  vnodeBuildReq(&pBuf, &vCreateCTbReq, TSDB_MSG_TYPE_CREATE_TABLE);
+  vnodeBuildReq(&pBuf, &vCreateCTbReq, TDMT_MND_CREATE_TABLE);
   META_CLEAR_TB_CFG(&vCreateCTbReq);
   free(pTag);
 
@@ -133,7 +133,7 @@ static void vtBuildSubmitReq(SRpcMsg **ppMsg) {
   int         tz = 1024;  // TODO
 
   pMsg = (SRpcMsg *)malloc(sizeof(*pMsg) + tz);
-  pMsg->msgType = TSDB_MSG_TYPE_SUBMIT;
+  pMsg->msgType = TDMT_VND_SUBMIT;
   pMsg->contLen = tz;
   pMsg->pCont = POINTER_SHIFT(pMsg, sizeof(*pMsg));
 

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

@@ -17,7 +17,7 @@
 #define _TD_TSDB_DEF_H_
 
 #include "mallocator.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "tlist.h"
 #include "thash.h"
 #include "tskiplist.h"

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

@@ -14,7 +14,7 @@
  */
 
 #include "os.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "tarray.h"
 #include "query.h"
 #include "tglobal.h"

source/libs/catalog/src/catalog.c

@@ -49,7 +49,7 @@ int32_t ctgGetDBVgroupFromMnode(struct SCatalog* pCatalog, void *pRpc, const SEp
   SEpSet *pVnodeEpSet = NULL;
   int32_t msgLen = 0;
 
-  CTG_ERR_RET(queryBuildMsg[TSDB_MSG_TYPE_USE_DB](input, &msg, 0, &msgLen));
+  CTG_ERR_RET(queryBuildMsg[TDMT_MND_USE_DB](input, &msg, 0, &msgLen));
 
   char *pMsg = rpcMallocCont(msgLen);
   if (NULL == pMsg) {
@@ -63,7 +63,7 @@ int32_t ctgGetDBVgroupFromMnode(struct SCatalog* pCatalog, void *pRpc, const SEp
   tfree(msg);
   
   SRpcMsg rpcMsg = {
-      .msgType = TSDB_MSG_TYPE_USE_DB,
+      .msgType = TDMT_MND_USE_DB,
       .pCont   = pMsg,
       .contLen = msgLen,
   };
@@ -76,7 +76,7 @@ int32_t ctgGetDBVgroupFromMnode(struct SCatalog* pCatalog, void *pRpc, const SEp
     CTG_ERR_RET(rpcRsp.code);
   }
 
-  CTG_ERR_RET(queryProcessMsgRsp[TSDB_MSG_TYPE_USE_DB](out, rpcRsp.pCont, rpcRsp.contLen));
+  CTG_ERR_RET(queryProcessMsgRsp[TDMT_MND_USE_DB](out, rpcRsp.pCont, rpcRsp.contLen));
 
   return TSDB_CODE_SUCCESS;
 }
@@ -161,10 +161,10 @@ int32_t ctgGetTableMetaFromMnode(struct SCatalog* pCatalog, void *pRpc, const SE
   SEpSet *pVnodeEpSet = NULL;
   int32_t msgLen = 0;
 
-  CTG_ERR_RET(queryBuildMsg[TSDB_MSG_TYPE_TABLE_META](&bInput, &msg, 0, &msgLen));
+  CTG_ERR_RET(queryBuildMsg[TDMT_VND_TABLE_META](&bInput, &msg, 0, &msgLen));
 
   SRpcMsg rpcMsg = {
-      .msgType = TSDB_MSG_TYPE_TABLE_META,
+      .msgType = TDMT_VND_TABLE_META,
       .pCont   = msg,
       .contLen = msgLen,
   };
@@ -181,7 +181,7 @@ int32_t ctgGetTableMetaFromMnode(struct SCatalog* pCatalog, void *pRpc, const SE
     CTG_ERR_RET(rpcRsp.code);
   }
 
-  CTG_ERR_RET(queryProcessMsgRsp[TSDB_MSG_TYPE_TABLE_META](output, rpcRsp.pCont, rpcRsp.contLen));
+  CTG_ERR_RET(queryProcessMsgRsp[TDMT_VND_TABLE_META](output, rpcRsp.pCont, rpcRsp.contLen));
 
   return TSDB_CODE_SUCCESS;
 }

source/libs/catalog/test/catalogTests.cpp

@@ -79,7 +79,7 @@ void sendCreateDbMsg(void *shandle, SEpSet *pEpSet) {
   SRpcMsg rpcMsg = {0};
   rpcMsg.pCont = pReq;
   rpcMsg.contLen = sizeof(SCreateDbMsg);
-  rpcMsg.msgType = TSDB_MSG_TYPE_CREATE_DB;
+  rpcMsg.msgType = TDMT_MND_CREATE_DB;
 
   SRpcMsg rpcRsp = {0};
 

source/libs/executor/src/executil.c

@@ -14,7 +14,7 @@
  */
 
 #include "os.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "thash.h"
 
 #include "executil.h"

source/libs/executor/src/executorimpl.c

@@ -14,7 +14,7 @@
  */
 #include <function.h>
 #include "os.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "tglobal.h"
 #include "ttime.h"
 

source/libs/function/inc/texpr.h

@@ -22,7 +22,7 @@ extern "C" {
 
 #include "os.h"
 
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "taosdef.h"
 #include "tskiplist.h"
 #include "function.h"

source/libs/function/src/taggfunction.c

@@ -16,7 +16,7 @@
 #include "tscalarfunction.h"
 #include "os.h"
 #include "taosdef.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "tglobal.h"
 #include "thash.h"
 #include "ttypes.h"

source/libs/function/src/texpr.c

@@ -18,7 +18,7 @@
 
 #include "exception.h"
 #include "taosdef.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "tarray.h"
 #include "tbuffer.h"
 #include "tcompare.h"

source/libs/function/src/tfill.c

@@ -17,7 +17,7 @@
 #include "os.h"
 
 #include "taosdef.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "ttypes.h"
 
 #include "tfill.h"

source/libs/function/src/thistogram.c

@@ -16,7 +16,7 @@
 
 #include "thistogram.h"
 #include "taosdef.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "tlosertree.h"
 
 /**

source/libs/parser/inc/astToMsg.h

@@ -2,7 +2,7 @@
 #define TDENGINE_ASTTOMSG_H
 
 #include "parserInt.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 
 SCreateUserMsg* buildUserManipulationMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, char* msgBuf, int32_t msgLen);
 SCreateAcctMsg* buildAcctManipulationMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, char* msgBuf, int32_t msgLen);

source/libs/parser/src/astValidate.c

@@ -4358,7 +4358,7 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
       }
 
       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;
+      pDcl->msgType = (pInfo->type == TSDB_SQL_CREATE_USER)? TDMT_MND_CREATE_USER:TDMT_MND_ALTER_USER;
       break;
     }
 
@@ -4395,20 +4395,20 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
       }
 
       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;
+      pDcl->msgType = (pInfo->type == TSDB_SQL_CREATE_ACCT)? TDMT_MND_CREATE_ACCT:TDMT_MND_ALTER_ACCT;
       break;
     }
 
     case TSDB_SQL_DROP_ACCT:
     case TSDB_SQL_DROP_USER: {
       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;
+      pDcl->msgType = (pInfo->type == TSDB_SQL_DROP_ACCT)? TDMT_MND_DROP_ACCT:TDMT_MND_DROP_USER;
       break;
     }
     
     case TSDB_SQL_SHOW: {
       code = setShowInfo(&pInfo->pMiscInfo->showOpt, pCtx, (void**)&pDcl->pMsg, &pDcl->msgLen, pMsgBuf);
-      pDcl->msgType = TSDB_MSG_TYPE_SHOW;
+      pDcl->msgType = TDMT_MND_SHOW;
       break;
     }
 
@@ -4431,7 +4431,7 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
 
       pDcl->pMsg = (char*)pUseDbMsg;
       pDcl->msgLen = sizeof(SUseDbMsg);
-      pDcl->msgType = TSDB_MSG_TYPE_USE_DB;
+      pDcl->msgType = TDMT_MND_USE_DB;
       break;
     }
 
@@ -4459,7 +4459,7 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
 
       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;
+      pDcl->msgType = (pInfo->type == TSDB_SQL_CREATE_DB)? TDMT_MND_CREATE_DB:TDMT_MND_ALTER_DB;
       break;
     }
 
@@ -4481,7 +4481,7 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
       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->msgType = TDMT_MND_DROP_DB;
       pDcl->msgLen = sizeof(SDropDbMsg);
       pDcl->pMsg = (char*)pDropDbMsg;
       return TSDB_CODE_SUCCESS;
@@ -4495,7 +4495,7 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
           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;
+        pDcl->msgType = (pCreateTable->type == TSQL_CREATE_TABLE)? TDMT_MND_CREATE_TABLE:TDMT_MND_CREATE_STB;
       } else if (pCreateTable->type == TSQL_CREATE_CTABLE) {
         //        if ((code = doCheckForCreateFromStable(pSql, pInfo)) != TSDB_CODE_SUCCESS) {
         //          return code;
@@ -4515,7 +4515,7 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
         return terrno;
       }
 
-      pDcl->msgType = TSDB_MSG_TYPE_DROP_STB;
+      pDcl->msgType = TDMT_MND_DROP_STB;
       return TSDB_CODE_SUCCESS;
       break;
     }

source/libs/parser/src/dataBlockMgt.c

@@ -18,7 +18,7 @@
 #include "catalog.h"
 #include "parserUtil.h"
 #include "queryInfoUtil.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 
 #define IS_RAW_PAYLOAD(t) \
   (((int)(t)) == PAYLOAD_TYPE_RAW)  // 0: K-V payload for non-prepare insert, 1: rawPayload for prepare insert

source/libs/parser/src/parserUtil.c

@@ -14,7 +14,7 @@
  */
 
 
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "parser.h"
 #include "taoserror.h"
 #include "tutil.h"
@@ -1825,7 +1825,7 @@ int tscTransferTableNameList(SSqlObj *pSql, const char *pNameList, int32_t lengt
   SSqlCmd *pCmd = &pSql->cmd;
 
   pCmd->command = TSDB_SQL_MULTI_META;
-  pCmd->msgType = TSDB_MSG_TYPE_TABLES_META;
+  pCmd->msgType = TDMT_VND_TABLES_META;
 
   int   code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
   char *str = (char *)pNameList;

source/libs/planner/inc/plannerInt.h

@@ -24,7 +24,7 @@ extern "C" {
 #include "tarray.h"
 #include "planner.h"
 #include "parser.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 
 #define QNODE_TAGSCAN       1
 #define QNODE_TABLESCAN     2

source/libs/qcom/src/queryUtil.c

@@ -1,5 +1,5 @@
 #include "os.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "query.h"
 #include "tglobal.h"
 #include "tsched.h"

source/libs/qcom/src/querymsg.c

@@ -13,13 +13,13 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "queryInt.h"
 #include "query.h"
 
-int32_t (*queryBuildMsg[TSDB_MSG_TYPE_MAX])(void* input, char **msg, int32_t msgSize, int32_t *msgLen) = {0};
+int32_t (*queryBuildMsg[TDMT_MAX])(void* input, char **msg, int32_t msgSize, int32_t *msgLen) = {0};
 
-int32_t (*queryProcessMsgRsp[TSDB_MSG_TYPE_MAX])(void* output, char *msg, int32_t msgSize) = {0};
+int32_t (*queryProcessMsgRsp[TDMT_MAX])(void* output, char *msg, int32_t msgSize) = {0};
 
 int32_t queryBuildTableMetaReqMsg(void* input, char **msg, int32_t msgSize, int32_t *msgLen) {
   if (NULL == input || NULL == msg || NULL == msgLen) {
@@ -264,11 +264,11 @@ int32_t queryProcessTableMetaRsp(void* output, char *msg, int32_t msgSize) {
 
 
 void initQueryModuleMsgHandle() {
-  queryBuildMsg[TSDB_MSG_TYPE_TABLE_META] = queryBuildTableMetaReqMsg;
+  queryBuildMsg[TDMT_VND_TABLE_META] = queryBuildTableMetaReqMsg;
-  queryBuildMsg[TSDB_MSG_TYPE_USE_DB] = queryBuildUseDbMsg;
+  queryBuildMsg[TDMT_MND_USE_DB] = queryBuildUseDbMsg;
 
-  queryProcessMsgRsp[TSDB_MSG_TYPE_TABLE_META] = queryProcessTableMetaRsp;
+  queryProcessMsgRsp[TDMT_VND_TABLE_META] = queryProcessTableMetaRsp;
-  queryProcessMsgRsp[TSDB_MSG_TYPE_USE_DB] = queryProcessUseDBRsp;
+  queryProcessMsgRsp[TDMT_MND_USE_DB] = queryProcessUseDBRsp;
 }
 
 

source/libs/qcom/test/queryTest.cpp

@@ -15,7 +15,7 @@
 
 #include <gtest/gtest.h>
 #include <iostream>
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "query.h"
 #pragma GCC diagnostic ignored "-Wwrite-strings"
 

source/libs/qworker/src/qworker.c

@@ -1,4 +1,4 @@
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "query.h"
 #include "qworker.h"
 #include "qworkerInt.h"

source/libs/scheduler/src/scheduler.c

@@ -14,7 +14,7 @@
  */
 
 #include "schedulerInt.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "query.h"
 #include "catalog.h"
 
@@ -310,7 +310,7 @@ int32_t schAsyncSendMsg(SQueryJob *job, SQueryTask *task, int32_t msgType) {
   void *msg = NULL;
   
   switch (msgType) {
-    case TSDB_MSG_TYPE_SUBMIT: {
+    case TDMT_VND_SUBMIT: {
       if (NULL == task->msg || task->msgLen <= 0) {
         qError("submit msg is NULL");
         SCH_ERR_RET(TSDB_CODE_SCH_INTERNAL_ERROR);
@@ -320,7 +320,7 @@ int32_t schAsyncSendMsg(SQueryJob *job, SQueryTask *task, int32_t msgType) {
       msg = task->msg;
       break;
     }
-    case TSDB_MSG_TYPE_QUERY: {
+    case TDMT_VND_QUERY: {
       if (NULL == task->msg) {
         qError("query msg is NULL");
         SCH_ERR_RET(TSDB_CODE_SCH_INTERNAL_ERROR);
@@ -342,7 +342,7 @@ int32_t schAsyncSendMsg(SQueryJob *job, SQueryTask *task, int32_t msgType) {
       memcpy(pMsg->msg, task->msg, task->msgLen);
       break;
     }    
-    case TSDB_MSG_TYPE_RES_READY: {
+    case TDMT_VND_RES_READY: {
       msgSize = sizeof(SResReadyMsg);
       msg = calloc(1, msgSize);
       if (NULL == msg) {
@@ -356,7 +356,7 @@ int32_t schAsyncSendMsg(SQueryJob *job, SQueryTask *task, int32_t msgType) {
       pMsg->taskId = htobe64(task->taskId);      
       break;
     }
-    case TSDB_MSG_TYPE_FETCH: {
+    case TDMT_VND_FETCH: {
       msgSize = sizeof(SResFetchMsg);
       msg = calloc(1, msgSize);
       if (NULL == msg) {
@@ -370,7 +370,7 @@ int32_t schAsyncSendMsg(SQueryJob *job, SQueryTask *task, int32_t msgType) {
       pMsg->taskId = htobe64(task->taskId);      
       break;
     }
-    case TSDB_MSG_TYPE_DROP_TASK:{
+    case TDMT_VND_DROP_TASK:{
       msgSize = sizeof(STaskDropMsg);
       msg = calloc(1, msgSize);
       if (NULL == msg) {
@@ -413,7 +413,7 @@ int32_t schFetchFromRemote(SQueryJob *job) {
     return TSDB_CODE_SUCCESS;
   }
 
-  SCH_ERR_JRET(schAsyncSendMsg(job, NULL, TSDB_MSG_TYPE_FETCH));
+  SCH_ERR_JRET(schAsyncSendMsg(job, NULL, TDMT_VND_FETCH));
 
   return TSDB_CODE_SUCCESS;
   
@@ -564,17 +564,17 @@ int32_t schHandleRspMsg(SQueryJob *job, SQueryTask *task, int32_t msgType, int32
   int32_t code = 0;
   
   switch (msgType) {
-    case TSDB_MSG_TYPE_QUERY:
+    case TDMT_VND_QUERY:
       if (rspCode != TSDB_CODE_SUCCESS) {
         SCH_ERR_JRET(schProcessOnTaskFailure(job, task, rspCode));
       } else {
-        code = schAsyncSendMsg(job, task, TSDB_MSG_TYPE_RES_READY);
+        code = schAsyncSendMsg(job, task, TDMT_VND_RES_READY);
         if (code) {
           goto _task_error;
         }
       }
       break;
-    case TSDB_MSG_TYPE_RES_READY:
+    case TDMT_VND_RES_READY:
       if (rspCode != TSDB_CODE_SUCCESS) {
         SCH_ERR_JRET(schProcessOnTaskFailure(job, task, rspCode));
       } else {
@@ -584,7 +584,7 @@ int32_t schHandleRspMsg(SQueryJob *job, SQueryTask *task, int32_t msgType, int32
         }        
       }
       break;
-    case TSDB_MSG_TYPE_FETCH:
+    case TDMT_VND_FETCH:
       SCH_ERR_JRET(rspCode);
       SCH_ERR_JRET(schProcessOnDataFetched(job));
       break;
@@ -619,7 +619,7 @@ int32_t schLaunchTask(SQueryJob *job, SQueryTask *task) {
     SCH_ERR_RET(TSDB_CODE_SCH_INTERNAL_ERROR);
   }
 
-  int32_t msgType = (plan->type == QUERY_TYPE_MODIFY) ? TSDB_MSG_TYPE_SUBMIT : TSDB_MSG_TYPE_QUERY;
+  int32_t msgType = (plan->type == QUERY_TYPE_MODIFY) ? TDMT_VND_SUBMIT : TDMT_VND_QUERY;
   
   SCH_ERR_RET(schAsyncSendMsg(job, task, msgType));
 
@@ -647,7 +647,7 @@ void schDropJobAllTasks(SQueryJob *job) {
   while (pIter) {
     SQueryTask *task = *(SQueryTask **)pIter;
   
-    schAsyncSendMsg(job, task, TSDB_MSG_TYPE_DROP_TASK);
+    schAsyncSendMsg(job, task, TDMT_VND_DROP_TASK);
     
     pIter = taosHashIterate(job->succTasks, pIter);
   }  
@@ -656,7 +656,7 @@ void schDropJobAllTasks(SQueryJob *job) {
   while (pIter) {
     SQueryTask *task = *(SQueryTask **)pIter;
   
-    schAsyncSendMsg(job, task, TSDB_MSG_TYPE_DROP_TASK);
+    schAsyncSendMsg(job, task, TDMT_VND_DROP_TASK);
     
     pIter = taosHashIterate(job->succTasks, pIter);
   }  

source/libs/transport/src/rpcMain.c

@@ -23,7 +23,7 @@
 #include "tref.h"
 #include "taoserror.h"
 #include "tglobal.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "trpc.h"
 #include "thash.h"
 #include "rpcLog.h"
@@ -410,10 +410,10 @@ void rpcSendRequest(void *shandle, const SEpSet *pEpSet, SRpcMsg *pMsg, int64_t
   // connection type is application specific. 
   // for TDengine, all the query, show commands shall have TCP connection
   char type = pMsg->msgType;
-  if (type == TSDB_MSG_TYPE_QUERY || type == TSDB_MSG_TYPE_SHOW_RETRIEVE
+  if (type == TDMT_VND_QUERY || type == TDMT_MND_SHOW_RETRIEVE
-    || type == TSDB_MSG_TYPE_FETCH || type == TSDB_MSG_TYPE_VGROUP_LIST
+    || type == TDMT_VND_FETCH || type == TDMT_MND_VGROUP_LIST
-    || type == TSDB_MSG_TYPE_TABLES_META || type == TSDB_MSG_TYPE_TABLE_META
+    || type == TDMT_VND_TABLES_META || type == TDMT_VND_TABLE_META
-    || type == TSDB_MSG_TYPE_SHOW || type == TSDB_MSG_TYPE_STATUS || type == TSDB_MSG_TYPE_ALTER_TABLE)
+    || type == TDMT_MND_SHOW || type == TDMT_MND_STATUS || type == TDMT_VND_ALTER_TABLE)
     pContext->connType = RPC_CONN_TCPC;
 
   pContext->rid = taosAddRef(tsRpcRefId, pContext);
@@ -837,16 +837,16 @@ static int rpcProcessReqHead(SRpcConn *pConn, SRpcHead *pHead) {
     if (pConn->inTranId == pHead->tranId) {
       if (pConn->inType == pHead->msgType) {
         if (pHead->code == 0) {
-          tDebug("%s, %s is retransmitted", pConn->info, taosMsg[pHead->msgType]);
+          tDebug("%s, %s is retransmitted", pConn->info, TMSG_INFO(pHead->msgType));
           rpcSendQuickRsp(pConn, TSDB_CODE_RPC_ACTION_IN_PROGRESS);
         } else {
           // do nothing, it is heart beat from client
         }
       } else if (pConn->inType == 0) {
-        tDebug("%s, %s is already processed, tranId:%d", pConn->info, taosMsg[pHead->msgType], pConn->inTranId);
+        tDebug("%s, %s is already processed, tranId:%d", pConn->info, TMSG_INFO(pHead->msgType), pConn->inTranId);
         rpcSendMsgToPeer(pConn, pConn->pRspMsg, pConn->rspMsgLen); // resend the response
       } else {
-        tDebug("%s, mismatched message %s and tranId", pConn->info, taosMsg[pHead->msgType]);
+        tDebug("%s, mismatched message %s and tranId", pConn->info, TMSG_INFO(pHead->msgType));
       }
 
       // do not reply any message
@@ -957,19 +957,19 @@ static SRpcConn *rpcProcessMsgHead(SRpcInfo *pRpc, SRecvInfo *pRecv, SRpcReqCont
   sid = htonl(pHead->destId);
   *ppContext = NULL;
 
-  if (pHead->msgType >= TSDB_MSG_TYPE_MAX || pHead->msgType <= 0) {
+  if (pHead->msgType >= TDMT_MAX || pHead->msgType <= 0) {
     tDebug("%s sid:%d, invalid message type:%d", pRpc->label, sid, pHead->msgType);
     terrno = TSDB_CODE_RPC_INVALID_MSG_TYPE; return NULL;
   }
 
   if (sid < 0 || sid >= pRpc->sessions) {
     tDebug("%s sid:%d, sid is out of range, max sid:%d, %s discarded", pRpc->label, sid,
-           pRpc->sessions, taosMsg[pHead->msgType]);
+           pRpc->sessions, TMSG_INFO(pHead->msgType));
     terrno = TSDB_CODE_RPC_INVALID_SESSION_ID; return NULL;
   }
 
   if (rpcIsReq(pHead->msgType) && htonl(pHead->msgVer) != tsVersion >> 8) {
-    tDebug("%s sid:%d, invalid client version:%x/%x %s", pRpc->label, sid, htonl(pHead->msgVer), tsVersion, taosMsg[pHead->msgType]);
+    tDebug("%s sid:%d, invalid client version:%x/%x %s", pRpc->label, sid, htonl(pHead->msgVer), tsVersion, TMSG_INFO(pHead->msgType));
     terrno = TSDB_CODE_RPC_INVALID_VERSION; return NULL;
   }
 
@@ -1094,9 +1094,9 @@ static void *rpcProcessMsgFromPeer(SRecvInfo *pRecv) {
   SRpcReqContext *pContext;
   pConn = rpcProcessMsgHead(pRpc, pRecv, &pContext);
 
-  if (pHead->msgType >= 1 && pHead->msgType < TSDB_MSG_TYPE_MAX) {
+  if (pHead->msgType >= 1 && pHead->msgType < TDMT_MAX) {
     tDebug("%s %p %p, %s received from 0x%x:%hu, parse code:0x%x len:%d sig:0x%08x:0x%08x:%d code:0x%x", pRpc->label,
-           pConn, (void *)pHead->ahandle, taosMsg[pHead->msgType], pRecv->ip, pRecv->port, terrno, pRecv->msgLen,
+           pConn, (void *)pHead->ahandle, TMSG_INFO(pHead->msgType), pRecv->ip, pRecv->port, terrno, pRecv->msgLen,
            pHead->sourceId, pHead->destId, pHead->tranId, pHead->code);
   } else {
     tDebug("%s %p %p, %d received from 0x%x:%hu, parse code:0x%x len:%d sig:0x%08x:0x%08x:%d code:0x%x", pRpc->label,
@@ -1112,10 +1112,10 @@ static void *rpcProcessMsgFromPeer(SRecvInfo *pRecv) {
         if (code == TSDB_CODE_RPC_INVALID_TIME_STAMP || code == TSDB_CODE_RPC_AUTH_FAILURE) {
           rpcCloseConn(pConn);
         }
-        if (pHead->msgType + 1 > 1 && pHead->msgType+1 < TSDB_MSG_TYPE_MAX) {
+        if (pHead->msgType + 1 > 1 && pHead->msgType+1 < TDMT_MAX) {
-          tDebug("%s %p %p, %s is sent with error code:0x%x", pRpc->label, pConn, (void *)pHead->ahandle, taosMsg[pHead->msgType+1], code);
+          tDebug("%s %p %p, %s is sent with error code:0x%x", pRpc->label, pConn, (void *)pHead->ahandle, TMSG_INFO(pHead->msgType+1), code);
         } else {
-          tError("%s %p %p, %s is sent with error code:0x%x", pRpc->label, pConn, (void *)pHead->ahandle, taosMsg[pHead->msgType], code);
+          tError("%s %p %p, %s is sent with error code:0x%x", pRpc->label, pConn, (void *)pHead->ahandle, TMSG_INFO(pHead->msgType), code);
         }     
       } 
     } else { // msg is passed to app only parsing is ok 
@@ -1343,12 +1343,12 @@ static void rpcSendMsgToPeer(SRpcConn *pConn, void *msg, int msgLen) {
 
   if ( rpcIsReq(pHead->msgType)) {
     tDebug("%s, %s is sent to %s:%hu, len:%d sig:0x%08x:0x%08x:%d",
-           pConn->info, taosMsg[pHead->msgType], pConn->peerFqdn, pConn->peerPort, 
+           pConn->info, TMSG_INFO(pHead->msgType), pConn->peerFqdn, pConn->peerPort, 
            msgLen, pHead->sourceId, pHead->destId, pHead->tranId);
   } else {
     if (pHead->code == 0) pConn->secured = 1; // for success response, set link as secured
     tDebug("%s, %s is sent to 0x%x:%hu, code:0x%x len:%d sig:0x%08x:0x%08x:%d",
-           pConn->info, taosMsg[pHead->msgType], pConn->peerIp, pConn->peerPort, 
+           pConn->info, TMSG_INFO(pHead->msgType), pConn->peerIp, pConn->peerPort, 
            htonl(pHead->code), msgLen, pHead->sourceId, pHead->destId, pHead->tranId);
   }
 
@@ -1373,7 +1373,7 @@ static void rpcProcessConnError(void *param, void *id) {
   
   tDebug("%s %p, connection error happens", pRpc->label, pContext->ahandle);
 
-  if (pContext->numOfTry >= pContext->epSet.numOfEps || pContext->msgType == TSDB_MSG_TYPE_FETCH) {
+  if (pContext->numOfTry >= pContext->epSet.numOfEps || pContext->msgType == TDMT_VND_FETCH) {
     rpcMsg.msgType = pContext->msgType+1;
     rpcMsg.ahandle = pContext->ahandle;
     rpcMsg.code = pContext->code;
@@ -1396,17 +1396,17 @@ static void rpcProcessRetryTimer(void *param, void *tmrId) {
   rpcLockConn(pConn);
 
   if (pConn->outType && pConn->user[0]) {
-    tDebug("%s, expected %s is not received", pConn->info, taosMsg[(int)pConn->outType + 1]);
+    tDebug("%s, expected %s is not received", pConn->info, TMSG_INFO((int)pConn->outType + 1));
     pConn->pTimer = NULL;
     pConn->retry++;
 
     if (pConn->retry < 4) {
-      tDebug("%s, re-send msg:%s to %s:%hu", pConn->info, taosMsg[pConn->outType], pConn->peerFqdn, pConn->peerPort);
+      tDebug("%s, re-send msg:%s to %s:%hu", pConn->info, TMSG_INFO(pConn->outType), pConn->peerFqdn, pConn->peerPort);
       rpcSendMsgToPeer(pConn, pConn->pReqMsg, pConn->reqMsgLen);      
       pConn->pTimer = taosTmrStart(rpcProcessRetryTimer, tsRpcTimer, pConn, pRpc->tmrCtrl);
     } else {
       // close the connection
-      tDebug("%s, failed to send msg:%s to %s:%hu", pConn->info, taosMsg[pConn->outType], pConn->peerFqdn, pConn->peerPort);
+      tDebug("%s, failed to send msg:%s to %s:%hu", pConn->info, TMSG_INFO(pConn->outType), pConn->peerFqdn, pConn->peerPort);
       if (pConn->pContext) {
         pConn->pContext->code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
         pConn->pContext->pConn = NULL;

source/util/test/skiplistTest.cpp

@@ -5,7 +5,7 @@
 #include <iostream>
 
 #include "os.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "tskiplist.h"
 #include "tutil.h"
 

src/client/inc/tscGlobalmerge.h

@@ -22,7 +22,7 @@ extern "C" {
 
 #include "qExtbuffer.h"
 #include "qFill.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "tlosertree.h"
 #include "qExecutor.h"
 

src/client/inc/tsclient.h

@@ -25,7 +25,7 @@ extern "C" {
 #include "../../../include/client/taos.h"
 #include "qAggMain.h"
 #include "taosdef.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "tarray.h"
 #include "tcache.h"
 #include "tglobal.h"

src/client/src/tscLocal.c

@@ -14,7 +14,7 @@
  */
 
 #include "os.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 
 #include "../../../include/client/taos.h"
 #include "qTableMeta.h"

src/client/src/tscPrepare.c

@@ -15,7 +15,7 @@
 #include "os.h"
 
 #include "../../../include/client/taos.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "tscLog.h"
 #include "tscSubquery.h"
 #include "tscUtil.h"

src/client/src/tscProfile.c

@@ -18,7 +18,7 @@
 #include "tsclient.h"
 #include "tsocket.h"
 #include "ttimer.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "tcq.h"
 
 #include "../../../include/client/taos.h"

src/client/src/tscSQLParser.c

@@ -28,7 +28,7 @@
 #include "qTableMeta.h"
 #include "qUtil.h"
 #include "regex.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "tcompare.h"
 #include "texpr.h"
 #include "tfilter.h"

src/client/src/tscServer.c

@@ -313,7 +313,7 @@ int tscSendMsgToServer(SSqlObj *pSql) {
   
   char *pMsg = rpcMallocCont(pCmd->payloadLen);
   if (NULL == pMsg) {
-    tscError("0x%"PRIx64" msg:%s malloc failed", pSql->self, taosMsg[pSql->cmd.msgType]);
+    tscError("0x%"PRIx64" msg:%s malloc failed", pSql->self, TMSG_INFO(pSql->cmd.msgType));
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
@@ -489,7 +489,7 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcEpSet *pEpSet) {
      * There is not response callback function for submit response.
      * The actual inserted number of points is the first number.
      */
-    if (rpcMsg->msgType == TSDB_MSG_TYPE_SUBMIT_RSP && pRes->pRsp != NULL) {
+    if (rpcMsg->msgType == TDMT_VND_SUBMIT_RSP && pRes->pRsp != NULL) {
       SShellSubmitRspMsg *pMsg = (SShellSubmitRspMsg*)pRes->pRsp;
       pMsg->code = htonl(pMsg->code);
       pMsg->numOfRows = htonl(pMsg->numOfRows);
@@ -639,7 +639,7 @@ int tscBuildFetchMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   }
 
   pSql->cmd.payloadLen = sizeof(SRetrieveTableMsg);
-  pSql->cmd.msgType = TSDB_MSG_TYPE_FETCH;
+  pSql->cmd.msgType = TDMT_VND_FETCH;
 
   pRetrieveMsg->header.contLen = htonl(sizeof(SRetrieveTableMsg));
 
@@ -651,7 +651,7 @@ int tscBuildSubmitMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   STableMeta* pTableMeta = tscGetMetaInfo(pQueryInfo, 0)->pTableMeta;
 
   // pSql->cmd.payloadLen is set during copying data into payload
-  pSql->cmd.msgType = TSDB_MSG_TYPE_SUBMIT;
+  pSql->cmd.msgType = TDMT_VND_SUBMIT;
 
   SNewVgroupInfo vgroupInfo = {0};
   taosHashGetClone(tscVgroupMap, &pTableMeta->vgId, sizeof(pTableMeta->vgId), NULL, &vgroupInfo);
@@ -1150,7 +1150,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   tscDebug("0x%"PRIx64" msg built success, len:%d bytes", pSql->self, msgLen);
   pCmd->payloadLen = msgLen;
-  pSql->cmd.msgType = TSDB_MSG_TYPE_QUERY;
+  pSql->cmd.msgType = TDMT_VND_QUERY;
 
   pQueryMsg->head.contLen = htonl(msgLen);
   assert(msgLen + minMsgSize() <= (int32_t)pCmd->allocSize);
@@ -1166,7 +1166,7 @@ int32_t tscBuildCreateDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *pCmd = &pSql->cmd;
   pCmd->payloadLen = sizeof(SCreateDbMsg);
   
-  pCmd->msgType = (pInfo->pMiscInfo->dbOpt.dbType == TSDB_DB_TYPE_DEFAULT) ? TSDB_MSG_TYPE_CREATE_DB : TSDB_MSG_TYPE_CREATE_TP;
+  pCmd->msgType = (pInfo->pMiscInfo->dbOpt.dbType == TSDB_DB_TYPE_DEFAULT) ? TDMT_MND_CREATE_DB : TSDB_MSG_TYPE_CREATE_TP;
 
   SCreateDbMsg *pCreateDbMsg = (SCreateDbMsg *)pCmd->payload;
 
@@ -1182,7 +1182,7 @@ int32_t tscBuildCreateFuncMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *pCmd = &pSql->cmd;
   SCreateFuncMsg *pCreateFuncMsg = (SCreateFuncMsg *)pCmd->payload;
 
-  pCmd->msgType = TSDB_MSG_TYPE_CREATE_FUNCTION;
+  pCmd->msgType = TDMT_MND_CREATE_FUNCTION;
 
   pCmd->payloadLen = sizeof(SCreateFuncMsg) + htonl(pCreateFuncMsg->codeLen);
 
@@ -1203,7 +1203,7 @@ int32_t tscBuildCreateDnodeMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SStrToken* t0 = taosArrayGet(pInfo->pMiscInfo->a, 0);
   strncpy(pCreate->ep, t0->z, t0->n);
   
-  pCmd->msgType = TSDB_MSG_TYPE_CREATE_DNODE;
+  pCmd->msgType = TDMT_MND_CREATE_DNODE;
 
   return TSDB_CODE_SUCCESS;
 }
@@ -1249,7 +1249,7 @@ int32_t tscBuildAcctMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
     }
   }
 
-  pCmd->msgType = TSDB_MSG_TYPE_CREATE_ACCT;
+  pCmd->msgType = TDMT_MND_CREATE_ACCT;
   return TSDB_CODE_SUCCESS;
 }
 
@@ -1277,9 +1277,9 @@ int32_t tscBuildUserMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   }
 
   if (pUser->type == TSDB_ALTER_USER_PASSWD || pUser->type == TSDB_ALTER_USER_PRIVILEGES) {
-    pCmd->msgType = TSDB_MSG_TYPE_ALTER_USER;
+    pCmd->msgType = TDMT_MND_ALTER_USER;
   } else {
-    pCmd->msgType = TSDB_MSG_TYPE_CREATE_USER;
+    pCmd->msgType = TDMT_MND_CREATE_USER;
   }
 
   return TSDB_CODE_SUCCESS;
@@ -1288,7 +1288,7 @@ int32_t tscBuildUserMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 int32_t tscBuildCfgDnodeMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *pCmd = &pSql->cmd;
   pCmd->payloadLen = sizeof(SCfgDnodeMsg);
-  pCmd->msgType = TSDB_MSG_TYPE_CONFIG_DNODE;
+  pCmd->msgType = TDMT_MND_CONFIG_DNODE;
   return TSDB_CODE_SUCCESS;
 }
 
@@ -1310,14 +1310,14 @@ int32_t tscBuildDropDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   pDropDbMsg->ignoreNotExists = pInfo->pMiscInfo->existsCheck ? 1 : 0;
 
-  pCmd->msgType = (pInfo->pMiscInfo->dbType == TSDB_DB_TYPE_DEFAULT) ? TSDB_MSG_TYPE_DROP_DB : TSDB_MSG_TYPE_DROP_TP;
+  pCmd->msgType = (pInfo->pMiscInfo->dbType == TSDB_DB_TYPE_DEFAULT) ? TDMT_MND_DROP_DB : TSDB_MSG_TYPE_DROP_TP;
   return TSDB_CODE_SUCCESS;
 }
 
 int32_t tscBuildDropFuncMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *pCmd = &pSql->cmd;
 
-  pCmd->msgType = TSDB_MSG_TYPE_DROP_FUNCTION;
+  pCmd->msgType = TDMT_MND_DROP_FUNCTION;
 
   pCmd->payloadLen = sizeof(SDropFuncMsg);
 
@@ -1340,7 +1340,7 @@ int32_t tscBuildDropTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   pDropTableMsg->supertable = (pInfo->pMiscInfo->tableType == TSDB_SUPER_TABLE)? 1:0;
   pDropTableMsg->igNotExists = pInfo->pMiscInfo->existsCheck ? 1 : 0;
-  pCmd->msgType = TSDB_MSG_TYPE_DROP_TABLE;
+  pCmd->msgType = TDMT_MND_DROP_TABLE;
   return TSDB_CODE_SUCCESS;
 }
 
@@ -1358,7 +1358,7 @@ int32_t tscBuildDropDnodeMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   SDropDnodeMsg * pDrop = (SDropDnodeMsg *)pCmd->payload;
   tstrncpy(pDrop->ep, dnodeEp, tListLen(pDrop->ep));
-  pCmd->msgType = TSDB_MSG_TYPE_DROP_DNODE;
+  pCmd->msgType = TDMT_MND_DROP_DNODE;
 
   return TSDB_CODE_SUCCESS;
 }
@@ -1370,7 +1370,7 @@ int32_t tscBuildDropUserAcctMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   tstrncpy(user, pCmd->payload, TSDB_USER_LEN);
 
   pCmd->payloadLen = sizeof(SDropUserMsg);
-  pCmd->msgType = (pInfo->type == TSDB_SQL_DROP_USER)? TSDB_MSG_TYPE_DROP_USER:TSDB_MSG_TYPE_DROP_ACCT;
+  pCmd->msgType = (pInfo->type == TSDB_SQL_DROP_USER)? TDMT_MND_DROP_USER:TDMT_MND_DROP_ACCT;
 
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
     tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
@@ -1395,7 +1395,7 @@ int32_t tscBuildUseDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SUseDbMsg *pUseDbMsg = (SUseDbMsg *)pCmd->payload;
   STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
   tNameExtractFullName(&pTableMetaInfo->name, pUseDbMsg->db);
-  pCmd->msgType = TSDB_MSG_TYPE_USE_DB;
+  pCmd->msgType = TDMT_MND_USE_DB;
 
   return TSDB_CODE_SUCCESS;
 }
@@ -1412,14 +1412,14 @@ int32_t tscBuildSyncDbReplicaMsg(SSqlObj* pSql, SSqlInfo *pInfo) {
   SSyncDbMsg *pSyncMsg = (SSyncDbMsg *)pCmd->payload;
   STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
   tNameExtractFullName(&pTableMetaInfo->name, pSyncMsg->db);
-  pCmd->msgType = TSDB_MSG_TYPE_SYNC_DB;
+  pCmd->msgType = TDMT_MND_SYNC_DB;
 
   return TSDB_CODE_SUCCESS;
 }
 
 int32_t tscBuildShowMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *pCmd = &pSql->cmd;
-  pCmd->msgType = TSDB_MSG_TYPE_SHOW;
+  pCmd->msgType = TDMT_MND_SHOW;
   pCmd->payloadLen = sizeof(SShowMsg) + 100;
 
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
@@ -1473,10 +1473,10 @@ int32_t tscBuildKillMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   switch (pCmd->command) {
     case TSDB_SQL_KILL_QUERY:
-      pCmd->msgType = TSDB_MSG_TYPE_KILL_QUERY;
+      pCmd->msgType = TDMT_MND_KILL_QUERY;
       break;
     case TSDB_SQL_KILL_CONNECTION:
-      pCmd->msgType = TSDB_MSG_TYPE_KILL_CONN;
+      pCmd->msgType = TDMT_MND_KILL_CONN;
       break;
     case TSDB_SQL_KILL_STREAM:
       pCmd->msgType = TSDB_MSG_TYPE_KILL_STREAM;
@@ -1592,7 +1592,7 @@ int tscBuildCreateTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   msgLen = (int32_t)(pMsg - (char*)pCreateTableMsg);
   pCreateTableMsg->contLen = htonl(msgLen);
   pCmd->payloadLen = msgLen;
-  pCmd->msgType = TSDB_MSG_TYPE_CREATE_TABLE;
+  pCmd->msgType = TDMT_MND_CREATE_TABLE;
 
   assert(msgLen + minMsgSize() <= size);
   return TSDB_CODE_SUCCESS;
@@ -1645,7 +1645,7 @@ int tscBuildAlterTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   msgLen = (int32_t)(pMsg - (char*)pAlterTableMsg);
 
   pCmd->payloadLen = msgLen;
-  pCmd->msgType = TSDB_MSG_TYPE_ALTER_TABLE;
+  pCmd->msgType = TDMT_VND_ALTER_TABLE;
 
   assert(msgLen + minMsgSize() <= size);
 
@@ -1654,7 +1654,7 @@ int tscBuildAlterTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
 int tscBuildUpdateTagMsg(SSqlObj* pSql, SSqlInfo *pInfo) {
   SSqlCmd* pCmd = &pSql->cmd;
-  pCmd->msgType = TSDB_MSG_TYPE_UPDATE_TAG_VAL;
+  pCmd->msgType = TDMT_VND_UPDATE_TAG_VAL;
   
   SUpdateTableTagValMsg* pUpdateMsg = (SUpdateTableTagValMsg*) pCmd->payload;
   pCmd->payloadLen = htonl(pUpdateMsg->head.contLen);
@@ -1674,7 +1674,7 @@ int tscBuildUpdateTagMsg(SSqlObj* pSql, SSqlInfo *pInfo) {
 int tscAlterDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *pCmd = &pSql->cmd;
   pCmd->payloadLen = sizeof(SAlterDbMsg);
-  pCmd->msgType = (pInfo->pMiscInfo->dbOpt.dbType == TSDB_DB_TYPE_DEFAULT) ? TSDB_MSG_TYPE_ALTER_DB : TSDB_MSG_TYPE_ALTER_TP;
+  pCmd->msgType = (pInfo->pMiscInfo->dbOpt.dbType == TSDB_DB_TYPE_DEFAULT) ? TDMT_MND_ALTER_DB : TSDB_MSG_TYPE_ALTER_TP;
 
   SAlterDbMsg *pAlterDbMsg = (SAlterDbMsg* )pCmd->payload;
   pAlterDbMsg->dbType = -1;
@@ -1741,7 +1741,7 @@ int tscBuildCompactMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
 int tscBuildRetrieveFromMgmtMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *pCmd = &pSql->cmd;
-  pCmd->msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE;
+  pCmd->msgType = TDMT_MND_SHOW_RETRIEVE;
   pCmd->payloadLen = sizeof(SRetrieveTableMsg);
 
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
@@ -1861,7 +1861,7 @@ int tscProcessEmptyResultRsp(SSqlObj *pSql) { return tscLocalResultCommonBuilder
 int tscBuildConnectMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   STscObj *pObj = pSql->pTscObj;
   SSqlCmd *pCmd = &pSql->cmd;
-  pCmd->msgType = TSDB_MSG_TYPE_CONNECT;
+  pCmd->msgType = TDMT_MND_CONNECT;
   pCmd->payloadLen = sizeof(SConnectMsg);
 
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
@@ -1898,7 +1898,7 @@ int tscBuildConnectMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 int tscBuildMultiTableMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *pCmd = &pSql->cmd;
 
-  pCmd->msgType = TSDB_MSG_TYPE_TABLES_META;
+  pCmd->msgType = TDMT_VND_TABLES_META;
   assert(pCmd->payloadLen + minMsgSize() <= pCmd->allocSize);
 
   tscDebug("0x%"PRIx64" build load multi-tablemeta msg completed, numOfTables:%d, msg size:%d", pSql->self, pCmd->count,
@@ -1996,7 +1996,7 @@ int tscBuildHeartBeatMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   pthread_mutex_unlock(&pObj->mutex);
 
   pCmd->payloadLen = msgLen;
-  pCmd->msgType = TSDB_MSG_TYPE_HEARTBEAT;
+  pCmd->msgType = TDMT_MND_HEARTBEAT;
 
   return TSDB_CODE_SUCCESS;
 }
@@ -2838,7 +2838,7 @@ static int32_t getTableMetaFromMnode(SSqlObj *pSql, STableMetaInfo *pTableMetaIn
     }
 
     pNew->cmd.payloadLen = (int32_t)(pMsg - (char*)pInfoMsg);
-    pNew->cmd.msgType = TSDB_MSG_TYPE_TABLE_META;
+    pNew->cmd.msgType = TDMT_VND_TABLE_META;
   }
 
   int32_t code = tscBuildAndSendRequest(pNew, NULL);
@@ -2913,7 +2913,7 @@ int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVg
   }
 
   pNew->cmd.payloadLen = (int32_t) ((start - pInfo->tableNames) + sizeof(SMultiTableInfoMsg));
-  pNew->cmd.msgType = TSDB_MSG_TYPE_TABLES_META;
+  pNew->cmd.msgType = TDMT_VND_TABLES_META;
 
   registerSqlObj(pNew);
   tscDebug("0x%"PRIx64" new pSqlObj:0x%"PRIx64" to get %d tableMeta, vgroupInfo:%d, udf:%d, msg size:%d", pSql->self,

src/client/src/tscStream.c

@@ -14,7 +14,7 @@
  */
 
 #include "os.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "tscLog.h"
 #include "tscUtil.h"
 #include "tsched.h"

src/client/src/tscSystem.c

@@ -14,7 +14,7 @@
  */
 
 #include "os.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "tconfig.h"
 #include "tglobal.h"
 #include "tnote.h"

src/client/src/tscUtil.c

@@ -16,7 +16,7 @@
 #include "tscUtil.h"
 #include "hash.h"
 #include "os.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "texpr.h"
 #include "tkey.h"
 #include "tmd5.h"
@@ -5011,7 +5011,7 @@ int tscTransferTableNameList(SSqlObj *pSql, const char *pNameList, int32_t lengt
   SSqlCmd *pCmd = &pSql->cmd;
 
   pCmd->command = TSDB_SQL_MULTI_META;
-  pCmd->msgType = TSDB_MSG_TYPE_TABLES_META;
+  pCmd->msgType = TDMT_VND_TABLES_META;
 
   int   code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
   char *str = (char *)pNameList;

src/cq/src/cqMain.c

@@ -22,7 +22,7 @@
 
 #include "../../../include/client/taos.h"
 #include "taosdef.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "tcq.h"
 #include "tdataformat.h"
 #include "tglobal.h"
@@ -520,7 +520,7 @@ static void cqProcessStreamRes(void *param, TAOS_RES *tres, TAOS_ROW row) {
   pMsg->length = pMsg->header.contLen;
   pMsg->numOfBlocks = htonl(1);
 
-  pHead->msgType = TSDB_MSG_TYPE_SUBMIT;
+  pHead->msgType = TDMT_VND_SUBMIT;
   pHead->version = 0;
 
   // write into vnode write queue

src/cq/test/cqtest.c

@@ -16,7 +16,7 @@
 //#define _DEFAULT_SOURCE
 #include "os.h"
 #include "taosdef.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "tglobal.h"
 #include "tlog.h"
 #include "tcq.h"

src/inc/tsdb.h

@@ -20,7 +20,7 @@
 #include <stdint.h>
 
 #include "taosdef.h"
-#include "taosmsg.h"
+#include "tmsg.h"
 #include "tarray.h"
 #include "tdataformat.h"
 #include "tname.h"