Merge pull request #9163 from taosdata/feature/dnode3

fix compile errors

CMakeLists.txt

@@ -25,6 +25,7 @@ if(${BUILD_TEST})
     enable_testing()
 endif(${BUILD_TEST})
 add_subdirectory(source)
+add_subdirectory(tools)
 
 # docs 
 add_subdirectory(docs)

include/common/taosmsg.h

@@ -783,12 +783,8 @@ typedef struct {
 } SAuthVnodeMsg;
 
 typedef struct {
-  char name[TSDB_TABLE_FNAME_LEN];
-} SStbInfoMsg;
-
-typedef struct {
-  SMsgHead msgHead;
-  char     tableFname[TSDB_TABLE_FNAME_LEN];
+  int32_t vgId;
+  char    tableFname[TSDB_TABLE_FNAME_LEN];
 } STableInfoMsg;
 
 typedef struct {
@@ -799,10 +795,6 @@ typedef struct {
   char    tableNames[];
 } SMultiTableInfoMsg;
 
-typedef struct SSTableVgroupMsg {
-  int32_t numOfTables;
-} SSTableVgroupMsg, SSTableVgroupRspMsg;
-
 typedef struct SVgroupInfo {
   int32_t    vgId;
   uint32_t   hashBegin;
@@ -812,12 +804,6 @@ typedef struct SVgroupInfo {
   SEpAddrMsg epAddr[TSDB_MAX_REPLICA];
 } SVgroupInfo;
 
-typedef struct SVgroupListRspMsg {
-  int32_t     vgroupNum;
-  int32_t     vgroupVersion;
-  SVgroupInfo vgroupInfo[];
-} SVgroupListRspMsg;
-
 typedef struct {
   int32_t    vgId;
   int8_t     numOfEps;
@@ -839,8 +825,8 @@ typedef struct {
   int8_t   update;
   int32_t  sversion;
   int32_t  tversion;
-  uint64_t tuid;
   uint64_t suid;
+  uint64_t tuid;
   int32_t  vgId;
   SSchema  pSchema[];
 } STableMetaMsg;

include/libs/query/query.h

@@ -24,8 +24,6 @@ extern "C" {
 #include "thash.h"
 #include "tlog.h"
 
-typedef SVgroupListRspMsg SVgroupListInfo;
-
 typedef struct STableComInfo {
   uint8_t numOfTags;      // the number of tags in schema
   uint8_t precision;      // the number of precision

include/util/taoserror.h

@@ -206,44 +206,28 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_MND_VGROUP_ALREADY_IN_DNODE   TAOS_DEF_ERROR_CODE(0, 0x0392)
 
 // mnode-stable
-#define TSDB_CODE_MND_STB_NOT_EXIST             TAOS_DEF_ERROR_CODE(0, 0x0360)
-#define TSDB_CODE_MND_STB_ALREADY_EXIST         TAOS_DEF_ERROR_CODE(0, 0x0360)
-#define TSDB_CODE_MND_STB_INVALID_IGEXIST       TAOS_DEF_ERROR_CODE(0, 0x0360)
-#define TSDB_CODE_MND_STB_INVALID_COLS_NUM      TAOS_DEF_ERROR_CODE(0, 0x0360)
-#define TSDB_CODE_MND_STB_INVALID_TAGS_NUM      TAOS_DEF_ERROR_CODE(0, 0x0360)
-#define TSDB_CODE_MND_STB_INVALID_COL_TYPE      TAOS_DEF_ERROR_CODE(0, 0x0360)
-#define TSDB_CODE_MND_STB_INVALID_COL_ID        TAOS_DEF_ERROR_CODE(0, 0x0360)
-#define TSDB_CODE_MND_STB_INVALID_COL_BYTES     TAOS_DEF_ERROR_CODE(0, 0x0360)
-#define TSDB_CODE_MND_STB_INVALID_COL_NAME      TAOS_DEF_ERROR_CODE(0, 0x0360)
-
-
-#define TSDB_CODE_MND_INVALID_TABLE_ID          TAOS_DEF_ERROR_CODE(0, 0x0361)  //"Table name too long")
-#define TSDB_CODE_MND_INVALID_TABLE_NAME        TAOS_DEF_ERROR_CODE(0, 0x0362)  //"Table does not exist")
-#define TSDB_CODE_MND_INVALID_TABLE_TYPE        TAOS_DEF_ERROR_CODE(0, 0x0363)  //"Invalid table type in tsdb")
-#define TSDB_CODE_MND_TOO_MANY_TAGS             TAOS_DEF_ERROR_CODE(0, 0x0364)  //"Too many tags")
-#define TSDB_CODE_MND_TOO_MANY_COLUMNS          TAOS_DEF_ERROR_CODE(0, 0x0365)  //"Too many columns")
-#define TSDB_CODE_MND_TOO_MANY_TIMESERIES       TAOS_DEF_ERROR_CODE(0, 0x0366)  //"Too many time series")
-#define TSDB_CODE_MND_NOT_SUPER_TABLE           TAOS_DEF_ERROR_CODE(0, 0x0367)  //"Not super table")           // operation only available for super table
-#define TSDB_CODE_MND_COL_NAME_TOO_LONG         TAOS_DEF_ERROR_CODE(0, 0x0368)  //"Tag name too long")
-#define TSDB_CODE_MND_TAG_ALREAY_EXIST          TAOS_DEF_ERROR_CODE(0, 0x0369)  //"Tag already exists")
-#define TSDB_CODE_MND_TAG_NOT_EXIST             TAOS_DEF_ERROR_CODE(0, 0x036A)  //"Tag does not exist")
-#define TSDB_CODE_MND_FIELD_ALREAY_EXIST        TAOS_DEF_ERROR_CODE(0, 0x036B)  //"Field already exists")
-#define TSDB_CODE_MND_FIELD_NOT_EXIST           TAOS_DEF_ERROR_CODE(0, 0x036C)  //"Field does not exist")
-#define TSDB_CODE_MND_INVALID_STABLE_NAME       TAOS_DEF_ERROR_CODE(0, 0x036D)  //"Super table does not exist")
-#define TSDB_CODE_MND_INVALID_CREATE_TABLE_MSG  TAOS_DEF_ERROR_CODE(0, 0x036E)  //"Invalid create table message")
-#define TSDB_CODE_MND_EXCEED_MAX_ROW_BYTES      TAOS_DEF_ERROR_CODE(0, 0x036F)  //"Exceed max row bytes")
-
-#define TSDB_CODE_MND_FUNC_ALREADY_EXIST        TAOS_DEF_ERROR_CODE(0, 0x0370)
-#define TSDB_CODE_MND_FUNC_NOT_EXIST            TAOS_DEF_ERROR_CODE(0, 0x0371)
-#define TSDB_CODE_MND_INVALID_FUNC              TAOS_DEF_ERROR_CODE(0, 0x0372)
-#define TSDB_CODE_MND_INVALID_FUNC_NAME         TAOS_DEF_ERROR_CODE(0, 0x0373)
-#define TSDB_CODE_MND_INVALID_FUNC_COMMENT      TAOS_DEF_ERROR_CODE(0, 0x0374)
-#define TSDB_CODE_MND_INVALID_FUNC_CODE         TAOS_DEF_ERROR_CODE(0, 0x0375)
-#define TSDB_CODE_MND_INVALID_FUNC_BUFSIZE      TAOS_DEF_ERROR_CODE(0, 0x0376)
-
-#define TSDB_CODE_MND_INVALID_TAG_LENGTH        TAOS_DEF_ERROR_CODE(0, 0x0376)  //"invalid tag length")
-#define TSDB_CODE_MND_INVALID_COLUMN_LENGTH     TAOS_DEF_ERROR_CODE(0, 0x0377)   //"invalid column length")
-
+#define TSDB_CODE_MND_STB_ALREADY_EXIST         TAOS_DEF_ERROR_CODE(0, 0x03A0)
+#define TSDB_CODE_MND_STB_NOT_EXIST             TAOS_DEF_ERROR_CODE(0, 0x03A1)
+#define TSDB_CODE_MND_TOO_MANY_STBS             TAOS_DEF_ERROR_CODE(0, 0x03A2)
+#define TSDB_CODE_MND_INVALID_STB               TAOS_DEF_ERROR_CODE(0, 0x03A3)
+#define TSDB_CODE_MND_INVALID_STB_OPTION        TAOS_DEF_ERROR_CODE(0, 0x03A4)
+#define TSDB_CODE_MND_STB_OPTION_UNCHNAGED      TAOS_DEF_ERROR_CODE(0, 0x03A5)
+#define TSDB_CODE_MND_TOO_MANY_TAGS             TAOS_DEF_ERROR_CODE(0, 0x03A6)
+#define TSDB_CODE_MND_TAG_ALREAY_EXIST          TAOS_DEF_ERROR_CODE(0, 0x03A7)
+#define TSDB_CODE_MND_TAG_NOT_EXIST             TAOS_DEF_ERROR_CODE(0, 0x03A8)
+#define TSDB_CODE_MND_TOO_MANY_COLUMNS          TAOS_DEF_ERROR_CODE(0, 0x03A9)
+#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)
+
+// mnode-func
+#define TSDB_CODE_MND_FUNC_ALREADY_EXIST        TAOS_DEF_ERROR_CODE(0, 0x03C0)
+#define TSDB_CODE_MND_FUNC_NOT_EXIST            TAOS_DEF_ERROR_CODE(0, 0x03C1)
+#define TSDB_CODE_MND_INVALID_FUNC              TAOS_DEF_ERROR_CODE(0, 0x03C2)
+#define TSDB_CODE_MND_INVALID_FUNC_NAME         TAOS_DEF_ERROR_CODE(0, 0x03C3)
+#define TSDB_CODE_MND_INVALID_FUNC_COMMENT      TAOS_DEF_ERROR_CODE(0, 0x03C4)
+#define TSDB_CODE_MND_INVALID_FUNC_CODE         TAOS_DEF_ERROR_CODE(0, 0x03C5)
+#define TSDB_CODE_MND_INVALID_FUNC_BUFSIZE      TAOS_DEF_ERROR_CODE(0, 0x03C6)
 
 // dnode
 #define TSDB_CODE_DND_ACTION_IN_PROGRESS        TAOS_DEF_ERROR_CODE(0, 0x0400)

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

@@ -38,7 +38,7 @@ static void dndInitMsgFp(STransMgmt *pMgmt) {
   pMgmt->msgFp[TSDB_MSG_TYPE_DROP_TABLE] = dndProcessVnodeWriteMsg;
   pMgmt->msgFp[TSDB_MSG_TYPE_ALTER_TABLE] = dndProcessVnodeWriteMsg;
   pMgmt->msgFp[TSDB_MSG_TYPE_UPDATE_TAG_VAL] = dndProcessVnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_TABLE_META] = dndProcessVnodeQueryMsg;
+  pMgmt->msgFp[TSDB_MSG_TYPE_TABLE_META] = dndProcessMnodeReadMsg;
   pMgmt->msgFp[TSDB_MSG_TYPE_TABLES_META] = dndProcessVnodeQueryMsg;
   pMgmt->msgFp[TSDB_MSG_TYPE_MQ_QUERY] = dndProcessVnodeQueryMsg;
   pMgmt->msgFp[TSDB_MSG_TYPE_MQ_CONSUME] = dndProcessVnodeQueryMsg;

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

+enable_testing()
 
 add_subdirectory(acct)
 # add_subdirectory(auth)
 # add_subdirectory(balance)
-# add_subdirectory(cluster)
+add_subdirectory(cluster)
 add_subdirectory(db)
 add_subdirectory(dnode)
 # add_subdirectory(func)
 # add_subdirectory(mnode)
 # add_subdirectory(profile)
 # add_subdirectory(show)
-# add_subdirectory(stb)
+add_subdirectory(stb)
 # add_subdirectory(sync)
 # add_subdirectory(telem)
 # add_subdirectory(trans)

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

@@ -21,8 +21,6 @@ target_include_directories(dnode_test_acct
     "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
 )
 
-enable_testing()
-
 add_test(
     NAME dnode_test_acct
     COMMAND dnode_test_acct

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

 /**
- * @file vnodeApiTests.cpp
+ * @file acct.cpp
  * @author slguan (slguan@taosdata.com)
  * @brief DNODE module acct-msg tests
  * @version 0.1

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

-add_executable(dndTestCluster "")
+add_executable(dnode_test_cluster "")
 
-target_sources(dndTestCluster
+target_sources(dnode_test_cluster
     PRIVATE
     "cluster.cpp"
     "../sut/deploy.cpp"
 )
 
 target_link_libraries(
-    dndTestCluster
+    dnode_test_cluster
     PUBLIC dnode
     PUBLIC util
     PUBLIC os
     PUBLIC gtest_main
 )
 
-target_include_directories(dndTestCluster
+target_include_directories(dnode_test_cluster
     PUBLIC
     "${CMAKE_SOURCE_DIR}/include/server/dnode/mgmt"
     "${CMAKE_CURRENT_SOURCE_DIR}/../../inc"
     "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
 )
 
-enable_testing()
-
 add_test(
-    NAME dndTestCluster
-    COMMAND dndTestCluster
+    NAME dnode_test_cluster
+    COMMAND dnode_test_cluster
 )

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

 /**
- * @file vnodeApiTests.cpp
+ * @file cluster.cpp
  * @author slguan (slguan@taosdata.com)
  * @brief DNODE module cluster-msg tests
  * @version 0.1
@@ -13,154 +13,158 @@
 
 class DndTestCluster : public ::testing::Test {
  protected:
-  void SetUp() override {}
-  void TearDown() override {}
+  static SServer* CreateServer(const char* path, const char* fqdn, uint16_t port, const char* firstEp) {
+    SServer* pServer = createServer(path, fqdn, port, firstEp);
+    ASSERT(pServer);
+    return pServer;
+  }
 
   static void SetUpTestSuite() {
-    const char* user = "root";
-    const char* pass = "taosdata";
-    const char* path = "/tmp/dndTestCluster";
-    const char* fqdn = "localhost";
-    uint16_t    port = 9521;
+    initLog("/tmp/tdlog");
 
-    pServer = createServer(path, fqdn, port);
-    ASSERT(pServer);
-    pClient = createClient(user, pass, fqdn, port);
+    const char* fqdn = "localhost";
+    const char* firstEp = "localhost:9030";
+    pServer = CreateServer("/tmp/dnode_test_cluster", fqdn, 9030, firstEp);
+    pClient = createClient("root", "taosdata", fqdn, 9030);
+    taosMsleep(1100);
   }
 
   static void TearDownTestSuite() {
     stopServer(pServer);
     dropClient(pClient);
+    pServer = NULL;
+    pClient = NULL;
   }
 
   static SServer* pServer;
   static SClient* pClient;
   static int32_t  connId;
-};
 
-SServer* DndTestCluster::pServer;
-SClient* DndTestCluster::pClient;
-int32_t  DndTestCluster::connId;
+ public:
+  void SetUp() override {}
+  void TearDown() override {}
 
-TEST_F(DndTestCluster, ShowCluster) {
-  ASSERT_NE(pClient, nullptr);
-  int32_t showId = 0;
-
-  {
-    SShowMsg* pReq = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));
-    pReq->type = TSDB_MGMT_TABLE_CLUSTER;
-    strcpy(pReq->db, "");
-
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SShowMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_SHOW;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
-    ASSERT_NE(pMsg, nullptr);
-
-    SShowRsp* pRsp = (SShowRsp*)pMsg->pCont;
-    ASSERT_NE(pRsp, nullptr);
-    pRsp->showId = htonl(pRsp->showId);
-    STableMetaMsg* pMeta = &pRsp->tableMeta;
-    pMeta->contLen = htonl(pMeta->contLen);
-    pMeta->numOfColumns = htons(pMeta->numOfColumns);
-    pMeta->sversion = htons(pMeta->sversion);
-    pMeta->tversion = htons(pMeta->tversion);
-    pMeta->tid = htonl(pMeta->tid);
-    pMeta->uid = htobe64(pMeta->uid);
+  void SendTheCheckShowMetaMsg(int8_t showType, const char* showName, int32_t columns, const char* db) {
+    SShowMsg* pShow = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));
+    pShow->type = showType;
+    if (db != NULL) {
+      strcpy(pShow->db, db);
+    }
+    SRpcMsg showRpcMsg = {0};
+    showRpcMsg.pCont = pShow;
+    showRpcMsg.contLen = sizeof(SShowMsg);
+    showRpcMsg.msgType = TSDB_MSG_TYPE_SHOW;
+
+    sendMsg(pClient, &showRpcMsg);
+    ASSERT_NE(pClient->pRsp, nullptr);
+    ASSERT_EQ(pClient->pRsp->code, 0);
+    ASSERT_NE(pClient->pRsp->pCont, nullptr);
+
+    SShowRsp* pShowRsp = (SShowRsp*)pClient->pRsp->pCont;
+    ASSERT_NE(pShowRsp, nullptr);
+    pShowRsp->showId = htonl(pShowRsp->showId);
+    pMeta = &pShowRsp->tableMeta;
+    pMeta->numOfTags = htonl(pMeta->numOfTags);
+    pMeta->numOfColumns = htonl(pMeta->numOfColumns);
+    pMeta->sversion = htonl(pMeta->sversion);
+    pMeta->tversion = htonl(pMeta->tversion);
+    pMeta->tuid = htobe64(pMeta->tuid);
     pMeta->suid = htobe64(pMeta->suid);
 
-    showId = pRsp->showId;
+    showId = pShowRsp->showId;
 
-    EXPECT_NE(pRsp->showId, 0);
-    EXPECT_EQ(pMeta->contLen, 0);
-    EXPECT_STREQ(pMeta->tbFname, "show cluster");
+    EXPECT_NE(pShowRsp->showId, 0);
+    EXPECT_STREQ(pMeta->tbFname, showName);
     EXPECT_EQ(pMeta->numOfTags, 0);
+    EXPECT_EQ(pMeta->numOfColumns, columns);
     EXPECT_EQ(pMeta->precision, 0);
     EXPECT_EQ(pMeta->tableType, 0);
-    EXPECT_EQ(pMeta->numOfColumns, 3);
+    EXPECT_EQ(pMeta->update, 0);
     EXPECT_EQ(pMeta->sversion, 0);
     EXPECT_EQ(pMeta->tversion, 0);
-    EXPECT_EQ(pMeta->tid, 0);
-    EXPECT_EQ(pMeta->uid, 0);
-    EXPECT_STREQ(pMeta->sTableName, "");
+    EXPECT_EQ(pMeta->tuid, 0);
     EXPECT_EQ(pMeta->suid, 0);
+  }
 
-    SSchema* pSchema = NULL;
-    pSchema = &pMeta->pSchema[0];
-    pSchema->bytes = htons(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_INT);
-    EXPECT_EQ(pSchema->bytes, 4);
-    EXPECT_STREQ(pSchema->name, "id");
-
-    pSchema = &pMeta->pSchema[1];
-    pSchema->bytes = htons(pSchema->bytes);
+  void CheckSchema(int32_t index, int8_t type, int32_t bytes, const char* name) {
+    SSchema* pSchema = &pMeta->pSchema[index];
+    pSchema->bytes = htonl(pSchema->bytes);
     EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_BINARY);
-    EXPECT_EQ(pSchema->bytes, TSDB_CLUSTER_ID_LEN + VARSTR_HEADER_SIZE);
-    EXPECT_STREQ(pSchema->name, "name");
+    EXPECT_EQ(pSchema->type, type);
+    EXPECT_EQ(pSchema->bytes, bytes);
+    EXPECT_STREQ(pSchema->name, name);
+  }
 
-    pSchema = &pMeta->pSchema[2];
-    pSchema->bytes = htons(pSchema->bytes);
-    EXPECT_EQ(pSchema->colId, 0);
-    EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_TIMESTAMP);
-    EXPECT_EQ(pSchema->bytes, 8);
-    EXPECT_STREQ(pSchema->name, "create_time");
+  void SendThenCheckShowRetrieveMsg(int32_t rows) {
+    SRetrieveTableMsg* pRetrieve = (SRetrieveTableMsg*)rpcMallocCont(sizeof(SRetrieveTableMsg));
+    pRetrieve->showId = htonl(showId);
+    pRetrieve->free = 0;
+
+    SRpcMsg retrieveRpcMsg = {0};
+    retrieveRpcMsg.pCont = pRetrieve;
+    retrieveRpcMsg.contLen = sizeof(SRetrieveTableMsg);
+    retrieveRpcMsg.msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE;
+
+    sendMsg(pClient, &retrieveRpcMsg);
+
+    ASSERT_NE(pClient->pRsp, nullptr);
+    ASSERT_EQ(pClient->pRsp->code, 0);
+    ASSERT_NE(pClient->pRsp->pCont, nullptr);
+
+    pRetrieveRsp = (SRetrieveTableRsp*)pClient->pRsp->pCont;
+    ASSERT_NE(pRetrieveRsp, nullptr);
+    pRetrieveRsp->numOfRows = htonl(pRetrieveRsp->numOfRows);
+    pRetrieveRsp->useconds = htobe64(pRetrieveRsp->useconds);
+    pRetrieveRsp->compLen = htonl(pRetrieveRsp->compLen);
+
+    EXPECT_EQ(pRetrieveRsp->numOfRows, rows);
+    EXPECT_EQ(pRetrieveRsp->useconds, 0);
+    // EXPECT_EQ(pRetrieveRsp->completed, completed);
+    EXPECT_EQ(pRetrieveRsp->precision, TSDB_TIME_PRECISION_MILLI);
+    EXPECT_EQ(pRetrieveRsp->compressed, 0);
+    EXPECT_EQ(pRetrieveRsp->compLen, 0);
+
+    pData = pRetrieveRsp->data;
+    pos = 0;
   }
 
-  {
-    SRetrieveTableMsg* pReq = (SRetrieveTableMsg*)rpcMallocCont(sizeof(SRetrieveTableMsg));
-    pReq->showId = htonl(showId);
-    pReq->free = 0;
-
-    SRpcMsg rpcMsg = {0};
-    rpcMsg.pCont = pReq;
-    rpcMsg.contLen = sizeof(SRetrieveTableMsg);
-    rpcMsg.msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE;
-
-    sendMsg(pClient, &rpcMsg);
-    SRpcMsg* pMsg = pClient->pRsp;
-    ASSERT_NE(pMsg, nullptr);
-    ASSERT_EQ(pMsg->code, 0);
-
-    SRetrieveTableRsp* pRsp = (SRetrieveTableRsp*)pMsg->pCont;
-    ASSERT_NE(pRsp, nullptr);
-    pRsp->numOfRows = htonl(pRsp->numOfRows);
-    pRsp->offset = htobe64(pRsp->offset);
-    pRsp->useconds = htobe64(pRsp->useconds);
-    pRsp->compLen = htonl(pRsp->compLen);
-
-    EXPECT_EQ(pRsp->numOfRows, 1);
-    EXPECT_EQ(pRsp->offset, 0);
-    EXPECT_EQ(pRsp->useconds, 0);
-    EXPECT_EQ(pRsp->completed, 1);
-    EXPECT_EQ(pRsp->precision, TSDB_TIME_PRECISION_MILLI);
-    EXPECT_EQ(pRsp->compressed, 0);
-    EXPECT_EQ(pRsp->reserved, 0);
-    EXPECT_EQ(pRsp->compLen, 0);
-
-    char*   pData = pRsp->data;
-    int32_t pos = 0;
-
-    int32_t id = *((int32_t*)(pData + pos));
+  void CheckInt32() {
+    int32_t data = *((int32_t*)(pData + pos));
     pos += sizeof(int32_t);
+    EXPECT_GT(data, 0);
+  }
 
-    int32_t nameLen = varDataLen(pData + pos);
+  void CheckTimestamp() {
+    int64_t data = *((int64_t*)(pData + pos));
+    pos += sizeof(int64_t);
+    EXPECT_GT(data, 0);
+  }
+
+  void CheckBinary(int32_t len) {
     pos += sizeof(VarDataLenT);
+    char* data = (char*)(pData + pos);
+    pos += len;
+  }
 
-    char* name = (char*)(pData + pos);
-    pos += TSDB_CLUSTER_ID_LEN;
+  int32_t            showId;
+  STableMetaMsg*     pMeta;
+  SRetrieveTableRsp* pRetrieveRsp;
+  char*              pData;
+  int32_t            pos;
+};
 
-    int64_t create_time = *((int64_t*)(pData + pos));
-    pos += sizeof(int64_t);
+SServer* DndTestCluster::pServer;
+SClient* DndTestCluster::pClient;
+int32_t  DndTestCluster::connId;
 
-    EXPECT_NE(id, 0);
-    EXPECT_EQ(nameLen, 36);
-    EXPECT_STRNE(name, "");
-    EXPECT_GT(create_time, 0);
-    printf("--- id:%d nameLen:%d name:%s time:%" PRId64 " --- \n", id, nameLen, name, create_time);
-  }
+TEST_F(DndTestCluster, 01_ShowCluster) {
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_CLUSTER, "show cluster", 3, NULL);
+  CheckSchema(0, TSDB_DATA_TYPE_INT, 4, "id");
+  CheckSchema(1, TSDB_DATA_TYPE_BINARY, TSDB_CLUSTER_ID_LEN + VARSTR_HEADER_SIZE, "name");
+  CheckSchema(2, TSDB_DATA_TYPE_TIMESTAMP, 8, "create_time");
+
+  SendThenCheckShowRetrieveMsg(1);
+  CheckInt32();
+  CheckBinary(TSDB_CLUSTER_ID_LEN);
+  CheckTimestamp();
 }
\ No newline at end of file

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

@@ -21,8 +21,6 @@ target_include_directories(dnode_test_db
     "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
 )
 
-enable_testing()
-
 add_test(
     NAME dnode_test_db
     COMMAND dnode_test_db

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

 /**
- * @file vnodeApiTests.cpp
+ * @file db.cpp
  * @author slguan (slguan@taosdata.com)
  * @brief DNODE module db-msg tests
  * @version 0.1
@@ -88,7 +88,7 @@ class DndTestDb : public ::testing::Test {
 
   void CheckSchema(int32_t index, int8_t type, int32_t bytes, const char* name) {
     SSchema* pSchema = &pMeta->pSchema[index];
-    pSchema->bytes = htons(pSchema->bytes);
+    pSchema->bytes = htonl(pSchema->bytes);
     EXPECT_EQ(pSchema->colId, 0);
     EXPECT_EQ(pSchema->type, type);
     EXPECT_EQ(pSchema->bytes, bytes);
@@ -114,17 +114,14 @@ class DndTestDb : public ::testing::Test {
     pRetrieveRsp = (SRetrieveTableRsp*)pClient->pRsp->pCont;
     ASSERT_NE(pRetrieveRsp, nullptr);
     pRetrieveRsp->numOfRows = htonl(pRetrieveRsp->numOfRows);
-    pRetrieveRsp->offset = htobe64(pRetrieveRsp->offset);
     pRetrieveRsp->useconds = htobe64(pRetrieveRsp->useconds);
     pRetrieveRsp->compLen = htonl(pRetrieveRsp->compLen);
 
     EXPECT_EQ(pRetrieveRsp->numOfRows, rows);
-    EXPECT_EQ(pRetrieveRsp->offset, 0);
     EXPECT_EQ(pRetrieveRsp->useconds, 0);
     // EXPECT_EQ(pRetrieveRsp->completed, completed);
     EXPECT_EQ(pRetrieveRsp->precision, TSDB_TIME_PRECISION_MILLI);
     EXPECT_EQ(pRetrieveRsp->compressed, 0);
-    EXPECT_EQ(pRetrieveRsp->reserved, 0);
     EXPECT_EQ(pRetrieveRsp->compLen, 0);
 
     pData = pRetrieveRsp->data;
@@ -182,13 +179,13 @@ int32_t  DndTestDb::connId;
 TEST_F(DndTestDb, 01_ShowDb) {
   SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 17, NULL);
   CheckSchema(0, TSDB_DATA_TYPE_BINARY, TSDB_DB_NAME_LEN - 1 + VARSTR_HEADER_SIZE, "name");
-  CheckSchema(1, TSDB_DATA_TYPE_TIMESTAMP, 8, "create time");
+  CheckSchema(1, TSDB_DATA_TYPE_TIMESTAMP, 8, "create_time");
   CheckSchema(2, TSDB_DATA_TYPE_SMALLINT, 2, "vgroups");
   CheckSchema(3, TSDB_DATA_TYPE_SMALLINT, 2, "replica");
   CheckSchema(4, TSDB_DATA_TYPE_SMALLINT, 2, "quorum");
   CheckSchema(5, TSDB_DATA_TYPE_SMALLINT, 2, "days");
   CheckSchema(6, TSDB_DATA_TYPE_BINARY, 24 + VARSTR_HEADER_SIZE, "keep0,keep1,keep2");
-  CheckSchema(7, TSDB_DATA_TYPE_INT, 4, "cache(MB)");
+  CheckSchema(7, TSDB_DATA_TYPE_INT, 4, "cache");
   CheckSchema(8, TSDB_DATA_TYPE_INT, 4, "blocks");
   CheckSchema(9, TSDB_DATA_TYPE_INT, 4, "minrows");
   CheckSchema(10, TSDB_DATA_TYPE_INT, 4, "maxrows");

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

@@ -21,8 +21,6 @@ target_include_directories(dnode_test_dnode
     "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
 )
 
-enable_testing()
-
 add_test(
     NAME dnode_test_dnode
     COMMAND dnode_test_dnode

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

 /**
- * @file vnodeApiTests.cpp
+ * @file dnode.cpp
  * @author slguan (slguan@taosdata.com)
  * @brief DNODE module dnode-msg tests
  * @version 0.1
@@ -81,8 +81,8 @@ class DndTestDnode : public ::testing::Test {
     pMeta->numOfTags = htonl(pMeta->numOfTags);
     pMeta->numOfColumns = htonl(pMeta->numOfColumns);
     pMeta->sversion = htonl(pMeta->sversion);
-    pMeta->tversion = htons(pMeta->tversion);
-    pMeta->tuid = htonl(pMeta->tuid);
+    pMeta->tversion = htonl(pMeta->tversion);
+    pMeta->tuid = htobe64(pMeta->tuid);
     pMeta->suid = htobe64(pMeta->suid);
 
     showId = pShowRsp->showId;
@@ -102,7 +102,7 @@ class DndTestDnode : public ::testing::Test {
 
   void CheckSchema(int32_t index, int8_t type, int32_t bytes, const char* name) {
     SSchema* pSchema = &pMeta->pSchema[index];
-    pSchema->bytes = htons(pSchema->bytes);
+    pSchema->bytes = htonl(pSchema->bytes);
     EXPECT_EQ(pSchema->colId, 0);
     EXPECT_EQ(pSchema->type, type);
     EXPECT_EQ(pSchema->bytes, bytes);
@@ -128,17 +128,14 @@ class DndTestDnode : public ::testing::Test {
     pRetrieveRsp = (SRetrieveTableRsp*)pClient->pRsp->pCont;
     ASSERT_NE(pRetrieveRsp, nullptr);
     pRetrieveRsp->numOfRows = htonl(pRetrieveRsp->numOfRows);
-    pRetrieveRsp->offset = htobe64(pRetrieveRsp->offset);
     pRetrieveRsp->useconds = htobe64(pRetrieveRsp->useconds);
     pRetrieveRsp->compLen = htonl(pRetrieveRsp->compLen);
 
     EXPECT_EQ(pRetrieveRsp->numOfRows, rows);
-    EXPECT_EQ(pRetrieveRsp->offset, 0);
     EXPECT_EQ(pRetrieveRsp->useconds, 0);
     // EXPECT_EQ(pRetrieveRsp->completed, completed);
     EXPECT_EQ(pRetrieveRsp->precision, TSDB_TIME_PRECISION_MILLI);
     EXPECT_EQ(pRetrieveRsp->compressed, 0);
-    EXPECT_EQ(pRetrieveRsp->reserved, 0);
     EXPECT_EQ(pRetrieveRsp->compLen, 0);
 
     pData = pRetrieveRsp->data;
@@ -187,12 +184,12 @@ SClient* DndTestDnode::pClient;
 TEST_F(DndTestDnode, 01_ShowDnode) {
   SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DNODE, "show dnodes", 7);
   CheckSchema(0, TSDB_DATA_TYPE_SMALLINT, 2, "id");
-  CheckSchema(1, TSDB_DATA_TYPE_BINARY, TSDB_EP_LEN + VARSTR_HEADER_SIZE, "end point");
+  CheckSchema(1, TSDB_DATA_TYPE_BINARY, TSDB_EP_LEN + VARSTR_HEADER_SIZE, "endpoint");
   CheckSchema(2, TSDB_DATA_TYPE_SMALLINT, 2, "vnodes");
-  CheckSchema(3, TSDB_DATA_TYPE_SMALLINT, 2, "max vnodes");
+  CheckSchema(3, TSDB_DATA_TYPE_SMALLINT, 2, "max_vnodes");
   CheckSchema(4, TSDB_DATA_TYPE_BINARY, 10 + VARSTR_HEADER_SIZE, "status");
-  CheckSchema(5, TSDB_DATA_TYPE_TIMESTAMP, 8, "create time");
-  CheckSchema(6, TSDB_DATA_TYPE_BINARY, 24 + VARSTR_HEADER_SIZE, "offline reason");
+  CheckSchema(5, TSDB_DATA_TYPE_TIMESTAMP, 8, "create_time");
+  CheckSchema(6, TSDB_DATA_TYPE_BINARY, 24 + VARSTR_HEADER_SIZE, "offline_reason");
 
   SendThenCheckShowRetrieveMsg(1);
   CheckInt16(1);

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

@@ -21,8 +21,6 @@ target_include_directories(dndTestProfile
     "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
 )
 
-enable_testing()
-
 add_test(
     NAME dndTestProfile
     COMMAND dndTestProfile

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

 /**
- * @file vnodeApiTests.cpp
+ * @file profile.cpp
  * @author slguan (slguan@taosdata.com)
  * @brief DNODE module profile-msg tests
  * @version 0.1
@@ -216,17 +216,14 @@ TEST_F(DndTestProfile, SConnectMsg_03) {
     SRetrieveTableRsp* pRsp = (SRetrieveTableRsp*)pMsg->pCont;
     ASSERT_NE(pRsp, nullptr);
     pRsp->numOfRows = htonl(pRsp->numOfRows);
-    pRsp->offset = htobe64(pRsp->offset);
     pRsp->useconds = htobe64(pRsp->useconds);
     pRsp->compLen = htonl(pRsp->compLen);
 
     EXPECT_EQ(pRsp->numOfRows, 1);
-    EXPECT_EQ(pRsp->offset, 0);
     EXPECT_EQ(pRsp->useconds, 0);
     EXPECT_EQ(pRsp->completed, 1);
     EXPECT_EQ(pRsp->precision, TSDB_TIME_PRECISION_MILLI);
     EXPECT_EQ(pRsp->compressed, 0);
-    EXPECT_EQ(pRsp->reserved, 0);
     EXPECT_EQ(pRsp->compLen, 0);
   }
 }
@@ -497,7 +494,7 @@ TEST_F(DndTestProfile, SKillQueryMsg_03) {
     EXPECT_STREQ(pSchema->name, "queryId");
 
     pSchema = &pMeta->pSchema[1];
-    pSchema->bytes = htons(pSchema->bytes);
+    pSchema->bytes = htonl(pSchema->bytes);
     EXPECT_EQ(pSchema->colId, 0);
     EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_INT);
     EXPECT_EQ(pSchema->bytes, 4);

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

-add_executable(dndTestShow "")
+add_executable(dnode_test_show "")
 
-target_sources(dndTestShow
+target_sources(dnode_test_show
     PRIVATE
     "show.cpp"
     "../sut/deploy.cpp"
 )
 
 target_link_libraries(
-    dndTestShow
+    dnode_test_show
     PUBLIC dnode
     PUBLIC util
     PUBLIC os
     PUBLIC gtest_main
 )
 
-target_include_directories(dndTestShow
+target_include_directories(dnode_test_show
     PUBLIC
     "${CMAKE_SOURCE_DIR}/include/server/dnode/mgmt"
     "${CMAKE_CURRENT_SOURCE_DIR}/../../inc"
     "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
 )
 
-enable_testing()
-
 add_test(
-    NAME dndTestShow
-    COMMAND dndTestShow
+    NAME dnode_test_show
+    COMMAND dnode_test_show
 )

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

 /**
- * @file vnodeApiTests.cpp
+ * @file show.cpp
  * @author slguan (slguan@taosdata.com)
  * @brief DNODE module show-msg tests
  * @version 0.1
@@ -151,49 +151,49 @@ TEST_F(DndTestShow, SShowMsg_04) {
 
     SSchema* pSchema = NULL;
     pSchema = &pMeta->pSchema[0];
-    pSchema->bytes = htons(pSchema->bytes);
+    pSchema->bytes = htonl(pSchema->bytes);
     EXPECT_EQ(pSchema->colId, 0);
     EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_INT);
     EXPECT_EQ(pSchema->bytes, 4);
     EXPECT_STREQ(pSchema->name, "connId");
 
     pSchema = &pMeta->pSchema[1];
-    pSchema->bytes = htons(pSchema->bytes);
+    pSchema->bytes = htonl(pSchema->bytes);
     EXPECT_EQ(pSchema->colId, 0);
     EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_BINARY);
     EXPECT_EQ(pSchema->bytes, TSDB_USER_LEN + VARSTR_HEADER_SIZE);
     EXPECT_STREQ(pSchema->name, "user");
 
     pSchema = &pMeta->pSchema[2];
-    pSchema->bytes = htons(pSchema->bytes);
+    pSchema->bytes = htonl(pSchema->bytes);
     EXPECT_EQ(pSchema->colId, 0);
     EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_BINARY);
     EXPECT_EQ(pSchema->bytes, TSDB_USER_LEN + VARSTR_HEADER_SIZE);
     EXPECT_STREQ(pSchema->name, "program");
 
     pSchema = &pMeta->pSchema[3];
-    pSchema->bytes = htons(pSchema->bytes);
+    pSchema->bytes = htonl(pSchema->bytes);
     EXPECT_EQ(pSchema->colId, 0);
     EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_INT);
     EXPECT_EQ(pSchema->bytes, 4);
     EXPECT_STREQ(pSchema->name, "pid");
 
     pSchema = &pMeta->pSchema[4];
-    pSchema->bytes = htons(pSchema->bytes);
+    pSchema->bytes = htonl(pSchema->bytes);
     EXPECT_EQ(pSchema->colId, 0);
     EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_BINARY);
     EXPECT_EQ(pSchema->bytes, TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE);
     EXPECT_STREQ(pSchema->name, "ip:port");
 
     pSchema = &pMeta->pSchema[5];
-    pSchema->bytes = htons(pSchema->bytes);
+    pSchema->bytes = htonl(pSchema->bytes);
     EXPECT_EQ(pSchema->colId, 0);
     EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_TIMESTAMP);
     EXPECT_EQ(pSchema->bytes, 8);
     EXPECT_STREQ(pSchema->name, "login_time");
 
     pSchema = &pMeta->pSchema[6];
-    pSchema->bytes = htons(pSchema->bytes);
+    pSchema->bytes = htonl(pSchema->bytes);
     EXPECT_EQ(pSchema->colId, 0);
     EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_TIMESTAMP);
     EXPECT_EQ(pSchema->bytes, 8);

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

+add_executable(dnode_test_stb "")
+
+target_sources(dnode_test_stb
+    PRIVATE
+    "stb.cpp"
+    "../sut/deploy.cpp"
+)
+
+target_link_libraries(
+    dnode_test_stb
+    PUBLIC dnode
+    PUBLIC util
+    PUBLIC os
+    PUBLIC gtest_main
+)
+
+target_include_directories(dnode_test_stb
+    PUBLIC
+    "${CMAKE_SOURCE_DIR}/include/server/dnode/mgmt"
+    "${CMAKE_CURRENT_SOURCE_DIR}/../../inc"
+    "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
+)
+
+add_test(
+    NAME dnode_test_stb
+    COMMAND dnode_test_stb
+)

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

+/**
+ * @file stb.cpp
+ * @author slguan (slguan@taosdata.com)
+ * @brief DNODE module db-msg tests
+ * @version 0.1
+ * @date 2021-12-17
+ *
+ * @copyright Copyright (c) 2021
+ *
+ */
+
+#include "deploy.h"
+
+class DndTestStb : public ::testing::Test {
+ protected:
+  static SServer* CreateServer(const char* path, const char* fqdn, uint16_t port, const char* firstEp) {
+    SServer* pServer = createServer(path, fqdn, port, firstEp);
+    ASSERT(pServer);
+    return pServer;
+  }
+
+  static void SetUpTestSuite() {
+    initLog("/tmp/tdlog");
+
+    const char* fqdn = "localhost";
+    const char* firstEp = "localhost:9101";
+    pServer = CreateServer("/tmp/dnode_test_stb", fqdn, 9101, firstEp);
+    pClient = createClient("root", "taosdata", fqdn, 9101);
+    taosMsleep(1100);
+  }
+
+  static void TearDownTestSuite() {
+    stopServer(pServer);
+    dropClient(pClient);
+    pServer = NULL;
+    pClient = NULL;
+  }
+
+  static SServer* pServer;
+  static SClient* pClient;
+  static int32_t  connId;
+
+ public:
+  void SetUp() override {}
+  void TearDown() override {}
+
+  void SendTheCheckShowMetaMsg(int8_t showType, const char* showName, int32_t columns, const char* db) {
+    SShowMsg* pShow = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));
+    pShow->type = showType;
+    if (db != NULL) {
+      strcpy(pShow->db, db);
+    }
+    SRpcMsg showRpcMsg = {0};
+    showRpcMsg.pCont = pShow;
+    showRpcMsg.contLen = sizeof(SShowMsg);
+    showRpcMsg.msgType = TSDB_MSG_TYPE_SHOW;
+
+    sendMsg(pClient, &showRpcMsg);
+    ASSERT_NE(pClient->pRsp, nullptr);
+    ASSERT_EQ(pClient->pRsp->code, 0);
+    ASSERT_NE(pClient->pRsp->pCont, nullptr);
+
+    SShowRsp* pShowRsp = (SShowRsp*)pClient->pRsp->pCont;
+    ASSERT_NE(pShowRsp, nullptr);
+    pShowRsp->showId = htonl(pShowRsp->showId);
+    pMeta = &pShowRsp->tableMeta;
+    pMeta->numOfTags = htonl(pMeta->numOfTags);
+    pMeta->numOfColumns = htonl(pMeta->numOfColumns);
+    pMeta->sversion = htonl(pMeta->sversion);
+    pMeta->tversion = htonl(pMeta->tversion);
+    pMeta->tuid = htobe64(pMeta->tuid);
+    pMeta->suid = htobe64(pMeta->suid);
+
+    showId = pShowRsp->showId;
+
+    EXPECT_NE(pShowRsp->showId, 0);
+    EXPECT_STREQ(pMeta->tbFname, showName);
+    EXPECT_EQ(pMeta->numOfTags, 0);
+    EXPECT_EQ(pMeta->numOfColumns, columns);
+    EXPECT_EQ(pMeta->precision, 0);
+    EXPECT_EQ(pMeta->tableType, 0);
+    EXPECT_EQ(pMeta->update, 0);
+    EXPECT_EQ(pMeta->sversion, 0);
+    EXPECT_EQ(pMeta->tversion, 0);
+    EXPECT_EQ(pMeta->tuid, 0);
+    EXPECT_EQ(pMeta->suid, 0);
+  }
+
+  void CheckSchema(int32_t index, int8_t type, int32_t bytes, const char* name) {
+    SSchema* pSchema = &pMeta->pSchema[index];
+    pSchema->bytes = htonl(pSchema->bytes);
+    EXPECT_EQ(pSchema->colId, 0);
+    EXPECT_EQ(pSchema->type, type);
+    EXPECT_EQ(pSchema->bytes, bytes);
+    EXPECT_STREQ(pSchema->name, name);
+  }
+
+  void SendThenCheckShowRetrieveMsg(int32_t rows) {
+    SRetrieveTableMsg* pRetrieve = (SRetrieveTableMsg*)rpcMallocCont(sizeof(SRetrieveTableMsg));
+    pRetrieve->showId = htonl(showId);
+    pRetrieve->free = 0;
+
+    SRpcMsg retrieveRpcMsg = {0};
+    retrieveRpcMsg.pCont = pRetrieve;
+    retrieveRpcMsg.contLen = sizeof(SRetrieveTableMsg);
+    retrieveRpcMsg.msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE;
+
+    sendMsg(pClient, &retrieveRpcMsg);
+
+    ASSERT_NE(pClient->pRsp, nullptr);
+    ASSERT_EQ(pClient->pRsp->code, 0);
+    ASSERT_NE(pClient->pRsp->pCont, nullptr);
+
+    pRetrieveRsp = (SRetrieveTableRsp*)pClient->pRsp->pCont;
+    ASSERT_NE(pRetrieveRsp, nullptr);
+    pRetrieveRsp->numOfRows = htonl(pRetrieveRsp->numOfRows);
+    pRetrieveRsp->useconds = htobe64(pRetrieveRsp->useconds);
+    pRetrieveRsp->compLen = htonl(pRetrieveRsp->compLen);
+
+    EXPECT_EQ(pRetrieveRsp->numOfRows, rows);
+    EXPECT_EQ(pRetrieveRsp->useconds, 0);
+    // EXPECT_EQ(pRetrieveRsp->completed, completed);
+    EXPECT_EQ(pRetrieveRsp->precision, TSDB_TIME_PRECISION_MILLI);
+    EXPECT_EQ(pRetrieveRsp->compressed, 0);
+    EXPECT_EQ(pRetrieveRsp->compLen, 0);
+
+    pData = pRetrieveRsp->data;
+    pos = 0;
+  }
+
+  void CheckInt8(int8_t val) {
+    int8_t data = *((int8_t*)(pData + pos));
+    pos += sizeof(int8_t);
+    EXPECT_EQ(data, val);
+  }
+
+  void CheckInt16(int16_t val) {
+    int16_t data = *((int16_t*)(pData + pos));
+    pos += sizeof(int16_t);
+    EXPECT_EQ(data, val);
+  }
+
+  void CheckInt32(int32_t val) {
+    int32_t data = *((int32_t*)(pData + pos));
+    pos += sizeof(int32_t);
+    EXPECT_EQ(data, val);
+  }
+
+  void CheckInt64(int64_t val) {
+    int64_t data = *((int64_t*)(pData + pos));
+    pos += sizeof(int64_t);
+    EXPECT_EQ(data, val);
+  }
+
+  void CheckTimestamp() {
+    int64_t data = *((int64_t*)(pData + pos));
+    pos += sizeof(int64_t);
+    EXPECT_GT(data, 0);
+  }
+
+  void CheckBinary(const char* val, int32_t len) {
+    pos += sizeof(VarDataLenT);
+    char* data = (char*)(pData + pos);
+    pos += len;
+    EXPECT_STREQ(data, val);
+  }
+
+  int32_t            showId;
+  STableMetaMsg*     pMeta;
+  SRetrieveTableRsp* pRetrieveRsp;
+  char*              pData;
+  int32_t            pos;
+};
+
+SServer* DndTestStb::pServer;
+SClient* DndTestStb::pClient;
+int32_t  DndTestStb::connId;
+
+TEST_F(DndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) {
+  {
+    SCreateDbMsg* pReq = (SCreateDbMsg*)rpcMallocCont(sizeof(SCreateDbMsg));
+    strcpy(pReq->db, "1.d1");
+    pReq->numOfVgroups = htonl(2);
+    pReq->cacheBlockSize = htonl(16);
+    pReq->totalBlocks = htonl(10);
+    pReq->daysPerFile = htonl(10);
+    pReq->daysToKeep0 = htonl(3650);
+    pReq->daysToKeep1 = htonl(3650);
+    pReq->daysToKeep2 = htonl(3650);
+    pReq->minRowsPerFileBlock = htonl(100);
+    pReq->maxRowsPerFileBlock = htonl(4096);
+    pReq->commitTime = htonl(3600);
+    pReq->fsyncPeriod = htonl(3000);
+    pReq->walLevel = 1;
+    pReq->precision = 0;
+    pReq->compression = 2;
+    pReq->replications = 1;
+    pReq->quorum = 1;
+    pReq->update = 0;
+    pReq->cacheLastRow = 0;
+    pReq->ignoreExist = 1;
+
+    SRpcMsg rpcMsg = {0};
+    rpcMsg.pCont = pReq;
+    rpcMsg.contLen = sizeof(SCreateDbMsg);
+    rpcMsg.msgType = TSDB_MSG_TYPE_CREATE_DB;
+
+    sendMsg(pClient, &rpcMsg);
+    SRpcMsg* pMsg = pClient->pRsp;
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, 0);
+  }
+
+  {
+    int32_t cols = 2;
+    int32_t tags = 3;
+    int32_t size = (tags + cols) * sizeof(SSchema) + sizeof(SCreateStbMsg);
+
+    SCreateStbMsg* pReq = (SCreateStbMsg*)rpcMallocCont(size);
+    strcpy(pReq->name, "1.d1.stb");
+    pReq->numOfTags = htonl(tags);
+    pReq->numOfColumns = htonl(cols);
+
+    {
+      SSchema* pSchema = &pReq->pSchema[0];
+      pSchema->colId = htonl(0);
+      pSchema->bytes = htonl(8);
+      pSchema->type = TSDB_DATA_TYPE_TIMESTAMP;
+      strcpy(pSchema->name, "ts");
+    }
+
+    {
+      SSchema* pSchema = &pReq->pSchema[1];
+      pSchema->colId = htonl(1);
+      pSchema->bytes = htonl(4);
+      pSchema->type = TSDB_DATA_TYPE_INT;
+      strcpy(pSchema->name, "col1");
+    }
+
+    {
+      SSchema* pSchema = &pReq->pSchema[2];
+      pSchema->colId = htonl(2);
+      pSchema->bytes = htonl(2);
+      pSchema->type = TSDB_DATA_TYPE_TINYINT;
+      strcpy(pSchema->name, "tag1");
+    }
+
+    {
+      SSchema* pSchema = &pReq->pSchema[3];
+      pSchema->colId = htonl(3);
+      pSchema->bytes = htonl(8);
+      pSchema->type = TSDB_DATA_TYPE_BIGINT;
+      strcpy(pSchema->name, "tag2");
+    }
+
+    {
+      SSchema* pSchema = &pReq->pSchema[4];
+      pSchema->colId = htonl(4);
+      pSchema->bytes = htonl(16);
+      pSchema->type = TSDB_DATA_TYPE_BINARY;
+      strcpy(pSchema->name, "tag3");
+    }
+
+    SRpcMsg rpcMsg = {0};
+    rpcMsg.pCont = pReq;
+    rpcMsg.contLen = size;
+    rpcMsg.msgType = TSDB_MSG_TYPE_CREATE_STB;
+
+    sendMsg(pClient, &rpcMsg);
+    SRpcMsg* pMsg = pClient->pRsp;
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, 0);
+  }
+
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_STB, "show stables", 4, "1.d1");
+  CheckSchema(0, TSDB_DATA_TYPE_BINARY, TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE, "name");
+  CheckSchema(1, TSDB_DATA_TYPE_TIMESTAMP, 8, "create_time");
+  CheckSchema(2, TSDB_DATA_TYPE_INT, 4, "columns");
+  CheckSchema(3, TSDB_DATA_TYPE_INT, 4, "tags");
+
+  SendThenCheckShowRetrieveMsg(1);
+  CheckBinary("stb", TSDB_TABLE_NAME_LEN);
+  CheckTimestamp();
+  CheckInt32(2);
+  CheckInt32(3);
+
+  // ----- meta ------
+  {
+    STableInfoMsg* pReq = (STableInfoMsg*)rpcMallocCont(sizeof(STableInfoMsg));
+    strcpy(pReq->tableFname, "1.d1.stb");
+
+    SRpcMsg rpcMsg = {0};
+    rpcMsg.pCont = pReq;
+    rpcMsg.contLen = sizeof(STableInfoMsg);
+    rpcMsg.msgType = TSDB_MSG_TYPE_TABLE_META;
+
+    sendMsg(pClient, &rpcMsg);
+    SRpcMsg* pMsg = pClient->pRsp;
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, 0);
+
+    STableMetaMsg* pRsp = (STableMetaMsg*)pMsg->pCont;
+    pRsp->numOfTags = htonl(pRsp->numOfTags);
+    pRsp->numOfColumns = htonl(pRsp->numOfColumns);
+    pRsp->sversion = htonl(pRsp->sversion);
+    pRsp->tversion = htonl(pRsp->tversion);
+    pRsp->suid = htobe64(pRsp->suid);
+    pRsp->tuid = htobe64(pRsp->tuid);
+    pRsp->vgId = htobe64(pRsp->vgId);
+    for (int32_t i = 0; i < pRsp->numOfTags + pRsp->numOfColumns; ++i) {
+      SSchema* pSchema = &pRsp->pSchema[i];
+      pSchema->colId = htonl(pSchema->colId);
+      pSchema->bytes = htonl(pSchema->bytes);
+    }
+
+    EXPECT_STREQ(pRsp->tbFname, "");
+    EXPECT_STREQ(pRsp->stbFname, "1.d1.stb");
+    EXPECT_EQ(pRsp->numOfColumns, 2);
+    EXPECT_EQ(pRsp->numOfTags, 3);
+    EXPECT_EQ(pRsp->precision, TSDB_TIME_PRECISION_MILLI);
+    EXPECT_EQ(pRsp->tableType, TSDB_SUPER_TABLE);
+    EXPECT_EQ(pRsp->update, 0);
+    EXPECT_EQ(pRsp->sversion, 1);
+    EXPECT_EQ(pRsp->tversion, 0);
+    EXPECT_GT(pRsp->suid, 0);
+    EXPECT_EQ(pRsp->tuid, 0);
+    EXPECT_EQ(pRsp->vgId, 0);
+
+    {
+      SSchema* pSchema = &pRsp->pSchema[0];
+      EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_TIMESTAMP);
+      EXPECT_EQ(pSchema->colId, 0);
+      EXPECT_EQ(pSchema->bytes, 8);
+      EXPECT_STREQ(pSchema->name, "ts");
+    }
+  }
+
+  // restart
+  stopServer(pServer);
+  pServer = NULL;
+
+  uInfo("start all server");
+
+  const char* fqdn = "localhost";
+  const char* firstEp = "localhost:9101";
+  pServer = startServer("/tmp/dnode_test_stb", fqdn, 9101, firstEp);
+
+  uInfo("all server is running");
+
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_STB, "show stables", 4, "1.d1");
+  SendThenCheckShowRetrieveMsg(1);
+  CheckBinary("stb", TSDB_TABLE_NAME_LEN);
+  CheckTimestamp();
+  CheckInt32(2);
+  CheckInt32(3);
+
+  {
+    SDropStbMsg* pReq = (SDropStbMsg*)rpcMallocCont(sizeof(SDropStbMsg));
+    strcpy(pReq->name, "1.d1.stb");
+
+    SRpcMsg rpcMsg = {0};
+    rpcMsg.pCont = pReq;
+    rpcMsg.contLen = sizeof(SDropStbMsg);
+    rpcMsg.msgType = TSDB_MSG_TYPE_DROP_STB;
+
+    sendMsg(pClient, &rpcMsg);
+    SRpcMsg* pMsg = pClient->pRsp;
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, 0);
+  }
+
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_STB, "show stables", 4, "1.d1");
+  SendThenCheckShowRetrieveMsg(0);
+}

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

@@ -21,8 +21,6 @@ target_include_directories(dnode_test_user
     "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
 )
 
-enable_testing()
-
 add_test(
     NAME dnode_test_user
     COMMAND dnode_test_user

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

 /**
- * @file vnodeApiTests.cpp
+ * @file user.cpp
  * @author slguan (slguan@taosdata.com)
  * @brief DNODE module user-msg tests
  * @version 0.1
@@ -87,7 +87,7 @@ class DndTestUser : public ::testing::Test {
 
   void CheckSchema(int32_t index, int8_t type, int32_t bytes, const char* name) {
     SSchema* pSchema = &pMeta->pSchema[index];
-    pSchema->bytes = htons(pSchema->bytes);
+    pSchema->bytes = htonl(pSchema->bytes);
     EXPECT_EQ(pSchema->colId, 0);
     EXPECT_EQ(pSchema->type, type);
     EXPECT_EQ(pSchema->bytes, bytes);
@@ -113,17 +113,14 @@ class DndTestUser : public ::testing::Test {
     pRetrieveRsp = (SRetrieveTableRsp*)pClient->pRsp->pCont;
     ASSERT_NE(pRetrieveRsp, nullptr);
     pRetrieveRsp->numOfRows = htonl(pRetrieveRsp->numOfRows);
-    pRetrieveRsp->offset = htobe64(pRetrieveRsp->offset);
     pRetrieveRsp->useconds = htobe64(pRetrieveRsp->useconds);
     pRetrieveRsp->compLen = htonl(pRetrieveRsp->compLen);
 
     EXPECT_EQ(pRetrieveRsp->numOfRows, rows);
-    EXPECT_EQ(pRetrieveRsp->offset, 0);
     EXPECT_EQ(pRetrieveRsp->useconds, 0);
     // EXPECT_EQ(pRetrieveRsp->completed, completed);
     EXPECT_EQ(pRetrieveRsp->precision, TSDB_TIME_PRECISION_MILLI);
     EXPECT_EQ(pRetrieveRsp->compressed, 0);
-    EXPECT_EQ(pRetrieveRsp->reserved, 0);
     EXPECT_EQ(pRetrieveRsp->compLen, 0);
 
     pData = pRetrieveRsp->data;
@@ -170,7 +167,7 @@ TEST_F(DndTestUser, 01_ShowUser) {
   SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_USER, "show users", 4);
   CheckSchema(0, TSDB_DATA_TYPE_BINARY, TSDB_USER_LEN + VARSTR_HEADER_SIZE, "name");
   CheckSchema(1, TSDB_DATA_TYPE_BINARY, 10 + VARSTR_HEADER_SIZE, "privilege");
-  CheckSchema(2, TSDB_DATA_TYPE_TIMESTAMP, 8, "create time");
+  CheckSchema(2, TSDB_DATA_TYPE_TIMESTAMP, 8, "create_time");
   CheckSchema(3, TSDB_DATA_TYPE_BINARY, TSDB_USER_LEN + VARSTR_HEADER_SIZE, "account");
 
   SendThenCheckShowRetrieveMsg(1);

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

@@ -747,7 +747,7 @@ static int32_t mndGetDbMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMe
   pShow->bytes[cols] = 2;
   pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
   strcpy(pSchema[cols].name, "vgroups");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 2;

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

@@ -291,7 +291,7 @@ char *mndShowStr(int32_t showType) {
     case TSDB_MGMT_TABLE_VNODES:
       return "show vnodes";
     case TSDB_MGMT_TABLE_CLUSTER:
-      return "show clusters";
+      return "show cluster";
     case TSDB_MGMT_TABLE_STREAMTABLES:
       return "show streamtables";
     case TSDB_MGMT_TABLE_TP:

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

@@ -80,7 +80,7 @@ static SSdbRaw *mndStbActionEncode(SStbObj *pStb) {
   SDB_SET_INT64(pRaw, dataPos, pStb->updateTime)
   SDB_SET_INT64(pRaw, dataPos, pStb->uid)
   SDB_SET_INT64(pRaw, dataPos, pStb->dbUid)
-  SDB_SET_INT64(pRaw, dataPos, pStb->version)
+  SDB_SET_INT32(pRaw, dataPos, pStb->version)
   SDB_SET_INT32(pRaw, dataPos, pStb->numOfColumns)
   SDB_SET_INT32(pRaw, dataPos, pStb->numOfTags)
 
@@ -157,11 +157,17 @@ static int32_t mndStbActionUpdate(SSdb *pSdb, SStbObj *pOldStb, SStbObj *pNewStb
   atomic_exchange_32(&pOldStb->version, pNewStb->version);
 
   taosWLockLatch(&pOldStb->lock);
+  pOldStb->numOfColumns = pNewStb->numOfColumns;
+  pOldStb->numOfTags = pNewStb->numOfTags;
   int32_t totalCols = pNewStb->numOfTags + pNewStb->numOfColumns;
   int32_t totalSize = totalCols * sizeof(SSchema);
 
   if (pOldStb->numOfTags + pOldStb->numOfColumns < totalCols) {
-    pOldStb->pSchema = malloc(totalSize);
+    void *pSchema = malloc(totalSize);
+    if (pSchema != NULL) {
+      free(pOldStb->pSchema);
+      pOldStb->pSchema = pSchema;
+    }
   }
 
   memcpy(pOldStb->pSchema, pNewStb->pSchema, totalSize);
@@ -200,37 +206,37 @@ static int32_t mndCheckStbMsg(SCreateStbMsg *pCreate) {
   }
 
   if (pCreate->igExists < 0 || pCreate->igExists > 1) {
-    terrno = TSDB_CODE_MND_STB_INVALID_IGEXIST;
+    terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
     return -1;
   }
 
   if (pCreate->numOfColumns < TSDB_MIN_COLUMNS || pCreate->numOfColumns > TSDB_MAX_COLUMNS) {
-    terrno = TSDB_CODE_MND_STB_INVALID_COLS_NUM;
+    terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
     return -1;
   }
 
   if (pCreate->numOfTags <= 0 || pCreate->numOfTags > TSDB_MAX_TAGS) {
-    terrno = TSDB_CODE_MND_STB_INVALID_TAGS_NUM;
+    terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
     return -1;
   }
 
   int32_t maxColId = (TSDB_MAX_COLUMNS + TSDB_MAX_TAGS);
   for (int32_t i = 0; i < totalCols; ++i) {
     SSchema *pSchema = &pCreate->pSchema[i];
-    if (pSchema->type <= 0) {
-      terrno = TSDB_CODE_MND_STB_INVALID_COL_TYPE;
+    if (pSchema->type < 0) {
+      terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
       return -1;
     }
     if (pSchema->colId < 0 || pSchema->colId >= maxColId) {
-      terrno = TSDB_CODE_MND_STB_INVALID_COL_ID;
+      terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
       return -1;
     }
     if (pSchema->bytes <= 0) {
-      terrno = TSDB_CODE_MND_STB_INVALID_COL_BYTES;
+      terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
       return -1;
     }
     if (pSchema->name[0] == 0) {
-      terrno = TSDB_CODE_MND_STB_INVALID_COL_NAME;
+      terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
       return -1;
     }
   }
@@ -245,6 +251,7 @@ static int32_t mndCreateStb(SMnode *pMnode, SMnodeMsg *pMsg, SCreateStbMsg *pCre
   stbObj.createdTime = taosGetTimestampMs();
   stbObj.updateTime = stbObj.createdTime;
   stbObj.uid = mndGenerateUid(pCreate->name, TSDB_TABLE_FNAME_LEN);
+  stbObj.dbUid = pDb->uid;
   stbObj.version = 1;
   stbObj.numOfColumns = pCreate->numOfColumns;
   stbObj.numOfTags = pCreate->numOfTags;
@@ -350,19 +357,19 @@ static int32_t mndCheckAlterStbMsg(SAlterStbMsg *pAlter) {
   pSchema->bytes = htonl(pSchema->bytes);
 
   if (pSchema->type <= 0) {
-    terrno = TSDB_CODE_MND_STB_INVALID_COL_TYPE;
+    terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
     return -1;
   }
   if (pSchema->colId < 0 || pSchema->colId >= (TSDB_MAX_COLUMNS + TSDB_MAX_TAGS)) {
-    terrno = TSDB_CODE_MND_STB_INVALID_COL_ID;
+    terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
     return -1;
   }
   if (pSchema->bytes <= 0) {
-    terrno = TSDB_CODE_MND_STB_INVALID_COL_BYTES;
+    terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
     return -1;
   }
   if (pSchema->name[0] == 0) {
-    terrno = TSDB_CODE_MND_STB_INVALID_COL_NAME;
+    terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
     return -1;
   }
 
@@ -480,31 +487,37 @@ static int32_t mndProcessDropStbMsg(SMnodeMsg *pMsg) {
 static int32_t mndProcessDropStbInRsp(SMnodeMsg *pMsg) { return 0; }
 
 static int32_t mndProcessStbMetaMsg(SMnodeMsg *pMsg) {
-  SMnode      *pMnode = pMsg->pMnode;
-  SStbInfoMsg *pInfo = pMsg->rpcMsg.pCont;
+  SMnode        *pMnode = pMsg->pMnode;
+  STableInfoMsg *pInfo = pMsg->rpcMsg.pCont;
 
-  mDebug("stb:%s, start to retrieve meta", pInfo->name);
+  mDebug("stb:%s, start to retrieve meta", pInfo->tableFname);
 
-  SDbObj *pDb = mndAcquireDbByStb(pMnode, pInfo->name);
+  SDbObj *pDb = mndAcquireDbByStb(pMnode, pInfo->tableFname);
   if (pDb == NULL) {
     terrno = TSDB_CODE_MND_DB_NOT_SELECTED;
-    mError("stb:%s, failed to retrieve meta since %s", pInfo->name, terrstr());
+    mError("stb:%s, failed to retrieve meta since %s", pInfo->tableFname, terrstr());
     return -1;
   }
 
-  SStbObj *pStb = mndAcquireStb(pMnode, pInfo->name);
+  SStbObj *pStb = mndAcquireStb(pMnode, pInfo->tableFname);
   if (pStb == NULL) {
     mndReleaseDb(pMnode, pDb);
-    terrno = TSDB_CODE_MND_INVALID_TABLE_NAME;
-    mError("stb:%s, failed to get meta since %s", pInfo->name, terrstr());
+    terrno = TSDB_CODE_MND_INVALID_STB;
+    mError("stb:%s, failed to get meta since %s", pInfo->tableFname, terrstr());
     return -1;
   }
 
-  int32_t        contLen = sizeof(STableMetaMsg) + (pStb->numOfColumns + pStb->numOfTags) * sizeof(SSchema);
+  taosRLockLatch(&pStb->lock);
+  int32_t totalCols = pStb->numOfColumns + pStb->numOfTags;
+  int32_t contLen = sizeof(STableMetaMsg) + totalCols * sizeof(SSchema);
+
   STableMetaMsg *pMeta = rpcMallocCont(contLen);
   if (pMeta == NULL) {
+    taosRUnLockLatch(&pStb->lock);
+    mndReleaseDb(pMnode, pDb);
+    mndReleaseStb(pMnode, pStb);
     terrno = TSDB_CODE_OUT_OF_MEMORY;
-    mError("stb:%s, failed to get meta since %s", pInfo->name, terrstr());
+    mError("stb:%s, failed to get meta since %s", pInfo->tableFname, terrstr());
     return -1;
   }
 
@@ -517,7 +530,7 @@ static int32_t mndProcessStbMetaMsg(SMnodeMsg *pMsg) {
   pMeta->sversion = htonl(pStb->version);
   pMeta->suid = htonl(pStb->uid);
 
-  for (int32_t i = 0; i < pStb->numOfColumns; ++i) {
+  for (int32_t i = 0; i < totalCols; ++i) {
     SSchema *pSchema = &pMeta->pSchema[i];
     SSchema *pSrcSchema = &pStb->pSchema[i];
     memcpy(pSchema->name, pSrcSchema->name, TSDB_COL_NAME_LEN);
@@ -525,11 +538,14 @@ static int32_t mndProcessStbMetaMsg(SMnodeMsg *pMsg) {
     pSchema->colId = htonl(pSrcSchema->colId);
     pSchema->bytes = htonl(pSrcSchema->bytes);
   }
+  taosRUnLockLatch(&pStb->lock);
+  mndReleaseDb(pMnode, pDb);
+  mndReleaseStb(pMnode, pStb);
 
   pMsg->pCont = pMeta;
   pMsg->contLen = contLen;
 
-  mDebug("stb:%s, meta is retrieved, cols:%d tags:%d", pInfo->name, pStb->numOfColumns, pStb->numOfTags);
+  mDebug("stb:%s, meta is retrieved, cols:%d tags:%d", pInfo->tableFname, pStb->numOfColumns, pStb->numOfTags);
   return 0;
 }
 
@@ -546,7 +562,7 @@ static int32_t mndGetNumOfStbs(SMnode *pMnode, char *dbName, int32_t *pNumOfStbs
   void   *pIter = NULL;
   while (1) {
     SStbObj *pStb = NULL;
-    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pStb);
+    pIter = sdbFetch(pSdb, SDB_STB, pIter, (void **)&pStb);
     if (pIter == NULL) break;
 
     if (strcmp(pStb->db, dbName) == 0) {
@@ -583,14 +599,14 @@ static int32_t mndGetStbMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pM
   pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
-  pShow->bytes[cols] = 2;
-  pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
+  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] = 2;
-  pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
+  pShow->bytes[cols] = 4;
+  pSchema[cols].type = TSDB_DATA_TYPE_INT;
   strcpy(pSchema[cols].name, "tags");
   pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
@@ -603,6 +619,7 @@ static int32_t mndGetStbMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pM
     pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
   }
 
+  pShow->numOfRows = sdbGetSize(pSdb, SDB_STB);
   pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
   strcpy(pMeta->tbFname, mndShowStr(pShow->type));
 
@@ -646,8 +663,8 @@ static int32_t mndRetrieveStb(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int3
 
     cols = 0;
 
-    char stbName[TSDB_TABLE_FNAME_LEN] = {0};
-    memcpy(stbName, pStb->name + prefixLen, TSDB_TABLE_FNAME_LEN - prefixLen);
+    char stbName[TSDB_TABLE_NAME_LEN] = {0};
+    tstrncpy(stbName, pStb->name + prefixLen, TSDB_TABLE_NAME_LEN);
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
     STR_TO_VARSTR(pWrite, stbName);
     cols++;
@@ -657,11 +674,11 @@ static int32_t mndRetrieveStb(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int3
     cols++;
 
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int16_t *)pWrite = pStb->numOfColumns;
+    *(int32_t *)pWrite = pStb->numOfColumns;
     cols++;
 
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int16_t *)pWrite = pStb->numOfTags;
+    *(int32_t *)pWrite = pStb->numOfTags;
     cols++;
 
     numOfRows++;

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

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mndInt.h"
+#include "mndTrans.h"
+
+int32_t mndInitSync(SMnode *pMnode) { return 0; }
+void    mndCleanupSync(SMnode *pMnode) {}
+
+int32_t mndSyncPropose(SMnode *pMnode, SSdbRaw *pRaw) {
+  int32_t code = 0;
+
+  // int32_t  len = sdbGetRawTotalSize(pRaw);
+  // SSdbRaw *pReceived = calloc(1, len);
+  // memcpy(pReceived, pRaw, len);
+  // mDebug("trans:%d, data:%p recv from sync, code:0x%x pMsg:%p", pMsg->id, pReceived, code & 0xFFFF, pMsg);
+
+  // mndTransApply(pMnode, pReceived, code);
+  return code;
+}
+
+bool mndIsMaster(SMnode *pMnode) { return true; }
\ No newline at end of file

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

@@ -421,7 +421,7 @@ static int32_t mndGetUserMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *p
 
   pShow->bytes[cols] = 8;
   pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
-  strcpy(pSchema[cols].name, "create time");
+  strcpy(pSchema[cols].name, "create_time");
   pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 

source/dnode/vnode/impl/CMakeLists.txt

@@ -19,5 +19,5 @@ target_link_libraries(
 
 # test
 if(${BUILD_TEST})
-   add_subdirectory(test)
+   #add_subdirectory(test)
 endif(${BUILD_TEST})
\ No newline at end of file

source/libs/query/src/querymsg.c

@@ -39,7 +39,7 @@ int32_t queryBuildTableMetaReqMsg(void* input, char **msg, int32_t msgSize, int3
 
   STableInfoMsg *bMsg = (STableInfoMsg *)*msg;
 
-  bMsg->msgHead.vgId = bInput->vgId;
+  bMsg->vgId = bInput->vgId;
 
   strncpy(bMsg->tableFname, bInput->tableFullName, sizeof(bMsg->tableFname));
   bMsg->tableFname[sizeof(bMsg->tableFname) - 1] = 0;

source/util/src/terror.c

@@ -217,22 +217,20 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_VGROUP_NOT_EXIST,         "VGroup does not exist
 
 // mnode-stable
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_STB_ALREADY_EXIST,        "Stable already exists")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TABLE_ID,         "Table name too long")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TABLE_NAME,       "Table does not exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TABLE_TYPE,       "Invalid table type in tsdb")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_STB_NOT_EXIST,            "Stable not exist")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_STBS,            "Too many stables")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_STB,              "Invalid stable name")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_STB_OPTION,       "Invalid stable options")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_STB_OPTION_UNCHNAGED,     "Stable options not changed")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_TAGS,            "Too many tags")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_COLUMNS,         "Too many columns")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_TIMESERIES,      "Too many time series")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_NOT_SUPER_TABLE,          "Not super table")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_COL_NAME_TOO_LONG,        "Tag name too long")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_TAG_ALREAY_EXIST,         "Tag already exists")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_TAG_NOT_EXIST,            "Tag does not exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_FIELD_ALREAY_EXIST,       "Field already exists")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_FIELD_NOT_EXIST,          "Field does not exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_STABLE_NAME,      "Super table does not exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_CREATE_TABLE_MSG, "Invalid create table message")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_COLUMNS,         "Too many columns")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_COLUMN_ALREAY_EXIST,       "Column already exists")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_COLUMN_NOT_EXIST,          "Column does not exist")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_EXCEED_MAX_ROW_BYTES,     "Exceed max row bytes")
 
+// mnode-func
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_FUNC_ALREADY_EXIST,       "Func already exists")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_FUNC_NOT_EXIST,           "Func not exists")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC,             "Invalid func")
@@ -241,9 +239,6 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC_COMMENT,     "Invalid func comment"
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC_CODE,        "Invalid func code")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC_BUFSIZE,     "Invalid func bufSize")
 
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TAG_LENGTH,        "invalid tag length")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_COLUMN_LENGTH,     "invalid column length")
-
 // dnode
 TAOS_DEFINE_ERROR(TSDB_CODE_DND_ACTION_IN_PROGRESS,       "Action in progress")
 TAOS_DEFINE_ERROR(TSDB_CODE_DND_EXITING,                  "Dnode is exiting")

src/kit/CMakeLists.txt

-CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
-PROJECT(TDengine)
-
-ADD_SUBDIRECTORY(shell)
-ADD_SUBDIRECTORY(taosdemo)
-ADD_SUBDIRECTORY(taosdump)
-ADD_SUBDIRECTORY(taospack)

src/kit/shell/CMakeLists.txt

-CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
-PROJECT(TDengine)
-
-INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/client/inc)
-INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc)
-INCLUDE_DIRECTORIES(inc)
-
-IF (TD_LINUX)
-  AUX_SOURCE_DIRECTORY(./src SRC)
-  LIST(REMOVE_ITEM SRC ./src/shellWindows.c)
-  LIST(REMOVE_ITEM SRC ./src/shellDarwin.c)
-  ADD_EXECUTABLE(shell ${SRC})
-
-IF (TD_LINUX_64 AND JEMALLOC_ENABLED)
-  ADD_DEFINITIONS(-DTD_JEMALLOC_ENABLED -I${CMAKE_BINARY_DIR}/build/include -L${CMAKE_BINARY_DIR}/build/lib -Wl,-rpath,${CMAKE_BINARY_DIR}/build/lib -ljemalloc)
-  SET(LINK_JEMALLOC "-L${CMAKE_BINARY_DIR}/build/lib -ljemalloc")
-ELSE ()
-  SET(LINK_JEMALLOC "")
-ENDIF ()
-
-  IF (TD_SOMODE_STATIC)
-      TARGET_LINK_LIBRARIES(shell taos_static lua ${LINK_JEMALLOC})
-  ELSE ()
-      TARGET_LINK_LIBRARIES(shell taos lua ${LINK_JEMALLOC})
-  ENDIF ()
-
-  SET_TARGET_PROPERTIES(shell PROPERTIES OUTPUT_NAME taos)
-ELSEIF (TD_WINDOWS)
-  LIST(APPEND SRC ./src/shellEngine.c)
-  LIST(APPEND SRC ./src/shellMain.c)
-  LIST(APPEND SRC ./src/shellWindows.c)
-  ADD_EXECUTABLE(shell ${SRC})
-  TARGET_LINK_LIBRARIES(shell taos_static)
-
-  IF (TD_POWER)
-    SET_TARGET_PROPERTIES(shell PROPERTIES OUTPUT_NAME power)
-  ELSE ()
-    SET_TARGET_PROPERTIES(shell PROPERTIES OUTPUT_NAME taos)
-  ENDIF ()
-ELSEIF (TD_DARWIN)
-  LIST(APPEND SRC ./src/shellEngine.c)
-  LIST(APPEND SRC ./src/shellMain.c)
-  LIST(APPEND SRC ./src/shellDarwin.c)
-  LIST(APPEND SRC ./src/shellCommand.c)
-  LIST(APPEND SRC ./src/shellImport.c)
-  LIST(APPEND SRC ./src/shellCheck.c)
-  ADD_EXECUTABLE(shell ${SRC})
-  # linking with dylib
-  TARGET_LINK_LIBRARIES(shell taos)
-  # linking taos statically
-  # TARGET_LINK_LIBRARIES(shell taos_static)
-  SET_TARGET_PROPERTIES(shell PROPERTIES OUTPUT_NAME taos)
-ENDIF ()
-

tools/CMakeLists.txt

+#add_subdirectory(shell)
\ No newline at end of file

tools/shell/CMakeLists.txt

+aux_source_directory(src SHELL_SRC)
+list(REMOVE_ITEM SHELL_SRC ./src/shellWindows.c)
+list(REMOVE_ITEM SHELL_SRC ./src/shellDarwin.c)
+
+add_executable(shell ${SHELL_SRC})
+target_link_libraries(
+    shell
+    PUBLIC taos
+    PUBLIC util
+    PUBLIC os
+)
+
+SET_TARGET_PROPERTIES(shell PROPERTIES OUTPUT_NAME taos)