Merge branch '3.0' into feature/qnode

source/libs/tkv/inc/tkvRocksdb.h → include/common/tcfg.h

@@ -13,15 +13,23 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef _TD_TVK_ROCKSDB_H_
-#define _TD_TVK_ROCKSDB_H_
+#ifndef _TD_COMMON_CFG_H_
+#define _TD_COMMON_CFG_H_
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+#include "tdef.h"
+
+typedef struct {
+  char dir[TSDB_FILENAME_LEN];
+  int  level;
+  int  primary;
+} SDiskCfg;
+
 #ifdef __cplusplus
 }
 #endif
 
-#endif /*_TD_TVK_ROCKSDB_H_*/
+#endif /*_TD_COMMON_CFG_H_*/
\ No newline at end of file

include/common/tglobal.h

@@ -21,6 +21,7 @@ extern "C" {
 #endif
 
 #include "tdef.h"
+#include "tcfg.h"
 
 // cluster
 extern char     tsFirst[];
@@ -105,11 +106,6 @@ extern uint32_t tsMaxRange;
 extern uint32_t tsCurRange;
 extern char     tsCompressor[];
 
-typedef struct {
-  char dir[TSDB_FILENAME_LEN];
-  int  level;
-  int  primary;
-} SDiskCfg;
 extern int32_t  tsDiskCfgNum;
 extern SDiskCfg tsDiskCfg[];
 

include/common/tmsg.h

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

include/dnode/vnode/meta/meta.h

@@ -58,6 +58,7 @@ int    metaCommit(SMeta *pMeta);
 STbCfg *        metaGetTbInfoByUid(SMeta *pMeta, tb_uid_t uid);
 STbCfg *        metaGetTbInfoByName(SMeta *pMeta, char *tbname, tb_uid_t *uid);
 SSchemaWrapper *metaGetTableSchema(SMeta *pMeta, tb_uid_t uid, int32_t sver, bool isinline);
+STSchema *      metaGetTbTSchema(SMeta *pMeta, tb_uid_t uid, int32_t sver);
 
 SMTbCursor *metaOpenTbCursor(SMeta *pMeta);
 void        metaCloseTbCursor(SMTbCursor *pTbCur);

include/dnode/vnode/tsdb/tsdb.h

@@ -17,6 +17,7 @@
 #define _TD_TSDB_H_
 
 #include "mallocator.h"
+#include "meta.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -33,7 +34,7 @@ typedef struct SDataStatis {
 } SDataStatis;
 
 typedef struct STable {
-  int32_t   tid;
+  uint64_t  tid;
   uint64_t  uid;
   STSchema *pSchema;
 } STable;
@@ -54,10 +55,11 @@ typedef struct STsdbCfg {
   int32_t  keep1;
   int32_t  keep2;
   int8_t   update;
+  int8_t   compression;
 } STsdbCfg;
 
 // STsdb
-STsdb *tsdbOpen(const char *path, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF);
+STsdb *tsdbOpen(const char *path, int32_t vgId, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF, SMeta *pMeta);
 void   tsdbClose(STsdb *);
 void   tsdbRemove(const char *path);
 int    tsdbInsertData(STsdb *pTsdb, SSubmitMsg *pMsg, SSubmitRsp *pRsp);

include/dnode/vnode/tsdb2/tsdb.h

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-#ifndef _TD_TSDB_H_
-#define _TD_TSDB_H_
-
-#include <pthread.h>
-#include <stdbool.h>
-#include <stdint.h>
-
-#include "common.h"
-#include "taosdef.h"
-#include "tarray.h"
-#include "tdataformat.h"
-#include "thash.h"
-#include "tlist.h"
-#include "tlockfree.h"
-#include "tmsg.h"
-#include "tname.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define TSDB_VERSION_MAJOR 1
-#define TSDB_VERSION_MINOR 0
-
-#define TSDB_INVALID_SUPER_TABLE_ID -1
-
-#define TSDB_STATUS_COMMIT_START 1
-#define TSDB_STATUS_COMMIT_OVER 2
-#define TSDB_STATUS_COMMIT_NOBLOCK 3  // commit no block, need to be solved
-
-// TSDB STATE DEFINITION
-#define TSDB_STATE_OK 0x0
-#define TSDB_STATE_BAD_META 0x1
-#define TSDB_STATE_BAD_DATA 0x2
-
-typedef struct SDataStatis {
-  int16_t colId;
-  int64_t sum;
-  int64_t max;
-  int64_t min;
-  int16_t maxIndex;
-  int16_t minIndex;
-  int16_t numOfNull;
-} SDataStatis;
-
-// --------- TSDB APPLICATION HANDLE DEFINITION
-
-// --------- TSDB REPOSITORY CONFIGURATION DEFINITION
-typedef struct {
-  int32_t tsdbId;
-  int32_t cacheBlockSize;
-  int32_t totalBlocks;
-  int32_t daysPerFile;  // day per file sharding policy
-  int32_t keep;         // day of data to keep
-  int32_t keep1;
-  int32_t keep2;
-  int32_t lruCacheSize;
-  int32_t minRowsPerFileBlock;  // minimum rows per file block
-  int32_t maxRowsPerFileBlock;  // maximum rows per file block
-  int8_t  precision;
-  int8_t  compression;
-  int8_t  update;
-  int8_t  cacheLastRow;  // 0:no cache, 1: cache last row, 2: cache last NULL column 3: 1&2
-} STsdbCfg;
-
-#define CACHE_NO_LAST(c) ((c)->cacheLastRow == 0)
-#define CACHE_LAST_ROW(c) (((c)->cacheLastRow & 1) > 0)
-#define CACHE_LAST_NULL_COLUMN(c) (((c)->cacheLastRow & 2) > 0)
-
-// --------- TSDB REPOSITORY USAGE STATISTICS
-typedef struct {
-  int64_t totalStorage;  // total bytes occupie
-  int64_t compStorage;
-  int64_t pointsWritten;  // total data points written
-} STsdbStat;
-
-typedef struct STsdb STsdb;
-
-STsdbCfg *tsdbGetCfg(const STsdb *repo);
-
-// --------- TSDB REPOSITORY DEFINITION
-// int32_t tsdbCreateRepo(int repoid);
-// int32_t tsdbDropRepo(int repoid);
-STsdb * tsdbOpen(STsdbCfg *pCfg, STsdbAppH *pAppH);
-int     tsdbClose(STsdb *repo, int toCommit);
-int32_t tsdbConfigRepo(STsdb *repo, STsdbCfg *pCfg);
-int     tsdbGetState(STsdb *repo);
-int8_t  tsdbGetCompactState(STsdb *repo);
-// --------- TSDB TABLE DEFINITION
-typedef struct {
-  uint64_t uid;  // the unique table ID
-  int32_t  tid;  // the table ID in the repository.
-} STableId;
-
-// --------- TSDB TABLE configuration
-typedef struct {
-  ETableType type;
-  char *     name;
-  STableId   tableId;
-  int32_t    sversion;
-  char *     sname;  // super table name
-  uint64_t   superUid;
-  STSchema * schema;
-  STSchema * tagSchema;
-  SKVRow     tagValues;
-  char *     sql;
-} STableCfg;
-
-void tsdbClearTableCfg(STableCfg *config);
-
-void *tsdbGetTableTagVal(const void *pTable, int32_t colId, int16_t type);
-char *tsdbGetTableName(void *pTable);
-
-#define TSDB_TABLEID(_table) ((STableId *)(_table))
-#define TSDB_PREV_ROW 0x1
-#define TSDB_NEXT_ROW 0x2
-
-STableCfg *tsdbCreateTableCfgFromMsg(SMDCreateTableMsg *pMsg);
-
-int tsdbCreateTable(STsdb *repo, STableCfg *pCfg);
-int tsdbDropTable(STsdb *pRepo, STableId tableId);
-int tsdbUpdateTableTagValue(STsdb *repo, SUpdateTableTagValMsg *pMsg);
-
-uint32_t tsdbGetFileInfo(STsdb *repo, char *name, uint32_t *index, uint32_t eindex, int64_t *size);
-
-// the TSDB repository info
-typedef struct STsdbRepoInfo {
-  STsdbCfg tsdbCfg;
-  uint64_t version;            // version of the repository
-  int64_t  tsdbTotalDataSize;  // the original inserted data size
-  int64_t  tsdbTotalDiskSize;  // the total disk size taken by this TSDB repository
-  // TODO: Other informations to add
-} STsdbRepoInfo;
-STsdbRepoInfo *tsdbGetStatus(STsdb *pRepo);
-
-// the meter information report structure
-typedef struct {
-  STableCfg tableCfg;
-  uint64_t  version;
-  int64_t   tableTotalDataSize;  // In bytes
-  int64_t   tableTotalDiskSize;  // In bytes
-} STableInfo;
-
-// -- FOR INSERT DATA
-/**
- * Insert data to a table in a repository
- * @param pRepo the TSDB repository handle
- * @param pData the data to insert (will give a more specific description)
- *
- * @return the number of points inserted, -1 for failure and the error number is set
- */
-int32_t tsdbInsertData(STsdb *repo, SSubmitMsg *pMsg, SShellSubmitRspMsg *pRsp);
-
-// -- FOR QUERY TIME SERIES DATA
-
-typedef void *TsdbQueryHandleT;  // Use void to hide implementation details
-
-#define BLOCK_LOAD_OFFSET_SEQ_ORDER 1
-#define BLOCK_LOAD_TABLE_SEQ_ORDER 2
-#define BLOCK_LOAD_TABLE_RR_ORDER 3
-
-// query condition to build multi-table data block iterator
-typedef struct STsdbQueryCond {
-  STimeWindow  twindow;
-  int32_t      order;   // desc|asc order to iterate the data block
-  int64_t      offset;  // skip offset put down to tsdb
-  int32_t      numOfCols;
-  SColumnInfo *colList;
-  bool         loadExternalRows;  // load external rows or not
-  int32_t      type;              // data block load type:
-} STsdbQueryCond;
-
-typedef struct STableData STableData;
-typedef struct {
-  T_REF_DECLARE()
-  SRWLatch     latch;
-  TSKEY        keyFirst;
-  TSKEY        keyLast;
-  int64_t      numOfRows;
-  int32_t      maxTables;
-  STableData **tData;
-  SList *      actList;
-  SList *      extraBuffList;
-  SList *      bufBlockList;
-  int64_t      pointsAdd;   // TODO
-  int64_t      storageAdd;  // TODO
-} SMemTable;
-
-typedef struct {
-  SMemTable *mem;
-  SMemTable *imem;
-  SMemTable  mtable;
-  SMemTable *omem;
-} SMemSnapshot;
-
-typedef struct SMemRef {
-  int32_t      ref;
-  SMemSnapshot snapshot;
-} SMemRef;
-
-#if 0
-typedef struct SFileBlockInfo {
-  int32_t numBlocksOfStep;
-} SFileBlockInfo;
-
-typedef struct {
-  void *pTable;
-  TSKEY lastKey;
-} STableKeyInfo;
-
-typedef struct {
-  uint32_t  numOfTables;
-  SArray *  pGroupList;
-  SHashObj *map;  // speedup acquire the tableQueryInfo by table uid
-} STableGroupInfo;
-
-#define TSDB_BLOCK_DIST_STEP_ROWS 16
-typedef struct {
-  uint16_t rowSize;
-  uint16_t numOfFiles;
-  uint32_t numOfTables;
-  uint64_t totalSize;
-  uint64_t totalRows;
-  int32_t  maxRows;
-  int32_t  minRows;
-  int32_t  firstSeekTimeUs;
-  uint32_t numOfRowsInMemTable;
-  uint32_t numOfSmallBlocks;
-  SArray * dataBlockInfos;
-} STableBlockDist;
-
-/**
- * Get the data block iterator, starting from position according to the query condition
- *
- * @param tsdb       tsdb handle
- * @param pCond      query condition, including time window, result set order, and basic required columns for each block
- * @param tableInfoGroup  table object list in the form of set, grouped into different sets according to the
- *                        group by condition
- * @param qinfo      query info handle from query processor
- * @return
- */
-TsdbQueryHandleT *tsdbQueryTables(STsdb *tsdb, STsdbQueryCond *pCond, STableGroupInfo *tableInfoGroup, uint64_t qId,
-                                  SMemRef *pRef);
-
-/**
- * Get the last row of the given query time window for all the tables in STableGroupInfo object.
- * Note that only one data block with only row will be returned while invoking retrieve data block function for
- * all tables in this group.
- *
- * @param tsdb   tsdb handle
- * @param pCond  query condition, including time window, result set order, and basic required columns for each block
- * @param tableInfo  table list.
- * @return
- */
-TsdbQueryHandleT tsdbQueryLastRow(STsdb *tsdb, STsdbQueryCond *pCond, STableGroupInfo *tableInfo, uint64_t qId,
-                                  SMemRef *pRef);
-
-TsdbQueryHandleT tsdbQueryCacheLast(STsdb *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList, uint64_t qId,
-                                    SMemRef *pMemRef);
-
-bool isTsdbCacheLastRow(TsdbQueryHandleT *pQueryHandle);
-
-/**
- * get the queried table object list
- * @param pHandle
- * @return
- */
-SArray *tsdbGetQueriedTableList(TsdbQueryHandleT *pHandle);
-
-/**
- * get the group list according to table id from client
- * @param tsdb
- * @param pCond
- * @param groupList
- * @param qinfo
- * @return
- */
-TsdbQueryHandleT tsdbQueryRowsInExternalWindow(STsdb *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList,
-                                               uint64_t qId, SMemRef *pRef);
-
-/**
- * get num of rows in mem table
- *
- * @param pHandle
- * @return row size
- */
-
-int64_t tsdbGetNumOfRowsInMemTable(TsdbQueryHandleT *pHandle);
-
-/**
- * move to next block if exists
- *
- * @param pQueryHandle
- * @return
- */
-bool tsdbNextDataBlock(TsdbQueryHandleT pQueryHandle);
-
-/**
- * Get current data block information
- *
- * @param pQueryHandle
- * @param pBlockInfo
- * @return
- */
-void tsdbRetrieveDataBlockInfo(TsdbQueryHandleT *pQueryHandle, SDataBlockInfo *pBlockInfo);
-
-/**
- *
- * Get the pre-calculated information w.r.t. current data block.
- *
- * In case of data block in cache, the pBlockStatis will always be NULL.
- * If a block is not completed loaded from disk, the pBlockStatis will be NULL.
-
- * @pBlockStatis the pre-calculated value for current data blocks. if the block is a cache block, always return 0
- * @return
- */
-int32_t tsdbRetrieveDataBlockStatisInfo(TsdbQueryHandleT *pQueryHandle, SDataStatis **pBlockStatis);
-
-/**
- *
- * The query condition with primary timestamp is passed to iterator during its constructor function,
- * the returned data block must be satisfied with the time window condition in any cases,
- * which means the SData data block is not actually the completed disk data blocks.
- *
- * @param pQueryHandle      query handle
- * @param pColumnIdList     required data columns id list
- * @return
- */
-SArray *tsdbRetrieveDataBlock(TsdbQueryHandleT *pQueryHandle, SArray *pColumnIdList);
-
-/**
- * Get the qualified table id for a super table according to the tag query expression.
- * @param stableid. super table sid
- * @param pTagCond. tag query condition
- */
-int32_t tsdbQuerySTableByTagCond(STsdb *tsdb, uint64_t uid, TSKEY key, const char *pTagCond, size_t len,
-                                 STableGroupInfo *pGroupList, SColIndex *pColIndex, int32_t numOfCols);
-
-/**
- * destroy the created table group list, which is generated by tag query
- * @param pGroupList
- */
-void tsdbDestroyTableGroup(STableGroupInfo *pGroupList);
-
-/**
- * create the table group result including only one table, used to handle the normal table query
- *
- * @param tsdb        tsdbHandle
- * @param uid         table uid
- * @param pGroupInfo  the generated result
- * @return
- */
-int32_t tsdbGetOneTableGroup(STsdb *tsdb, uint64_t uid, TSKEY startKey, STableGroupInfo *pGroupInfo);
-
-/**
- *
- * @param tsdb
- * @param pTableIdList
- * @param pGroupInfo
- * @return
- */
-int32_t tsdbGetTableGroupFromIdList(STsdb *tsdb, SArray *pTableIdList, STableGroupInfo *pGroupInfo);
-
-/**
- * clean up the query handle
- * @param queryHandle
- */
-void tsdbCleanupQueryHandle(TsdbQueryHandleT queryHandle);
-
-void tsdbResetQueryHandle(TsdbQueryHandleT queryHandle, STsdbQueryCond *pCond);
-
-void tsdbResetQueryHandleForNewTable(TsdbQueryHandleT queryHandle, STsdbQueryCond *pCond, STableGroupInfo *groupList);
-
-int32_t tsdbGetFileBlocksDistInfo(TsdbQueryHandleT *queryHandle, STableBlockDist *pTableBlockInfo);
-
-// obtain queryHandle attribute
-int64_t tsdbSkipOffset(TsdbQueryHandleT queryHandle);
-
-/**
- * get the statistics of repo usage
- * @param repo. point to the tsdbrepo
- * @param totalPoints. total data point written
- * @param totalStorage. total bytes took by the tsdb
- * @param compStorage. total bytes took by the tsdb after compressed
- */
-void tsdbReportStat(void *repo, int64_t *totalPoints, int64_t *totalStorage, int64_t *compStorage);
-
-int  tsdbInitCommitQueue();
-void tsdbDestroyCommitQueue();
-int  tsdbSyncCommit(STsdb *repo);
-void tsdbIncCommitRef(int vgId);
-void tsdbDecCommitRef(int vgId);
-void tsdbSwitchTable(TsdbQueryHandleT pQueryHandle);
-
-// For TSDB file sync
-int tsdbSyncSend(void *pRepo, SOCKET socketFd);
-int tsdbSyncRecv(void *pRepo, SOCKET socketFd);
-
-// // For TSDB Compact
-// int tsdbCompact(STsdb *pRepo);
-
-// For TSDB Health Monitor
-
-// // no problem return true
-// bool tsdbNoProblem(STsdb *pRepo);
-// // unit of walSize: MB
-// int tsdbCheckWal(STsdb *pRepo, uint32_t walSize);
-
-// // for json tag
-// void *getJsonTagValueElment(void *data, char *key, int32_t keyLen, char *out, int16_t bytes);
-// void  getJsonTagValueAll(void *data, void *dst, int16_t bytes);
-// char *parseTagDatatoJson(void *p);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // _TD_TSDB_H_

include/dnode/vnode/vnode.h

@@ -89,7 +89,7 @@ void vnodeClear();
  * @param pVnodeCfg options of the vnode
  * @return SVnode* The vnode object
  */
-SVnode *vnodeOpen(const char *path, const SVnodeCfg *pVnodeCfg);
+SVnode *vnodeOpen(const char *path, const SVnodeCfg *pVnodeCfg, int32_t vid);
 
 /**
  * @brief Close a VNODE

include/libs/planner/planner.h

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

include/libs/tkv/tkv.h

@@ -16,6 +16,7 @@
 #ifndef _TD_TKV_H_
 #define _TD_TKV_H_
 
+#if 0
 #include "os.h"
 
 #ifdef __cplusplus
@@ -59,4 +60,5 @@ void           tkvWriteOptsDestroy(STkvWriteOpts *);
 }
 #endif
 
+#endif
 #endif /*_TD_TKV_H_*/
\ No newline at end of file

include/libs/transport/trpc.h

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

include/os/osFile.h

@@ -54,7 +54,7 @@ int32_t taosFtruncateFile(FileFd fd, int64_t length);
 int32_t taosFsyncFile(FileFd fd);
 
 int64_t taosReadFile(FileFd fd, void *buf, int64_t count);
-int64_t taosWriteFile(FileFd fd, void *buf, int64_t count);
+int64_t taosWriteFile(FileFd fd, const void *buf, int64_t count);
 
 void taosCloseFile(FileFd fd);
 

include/util/tmacro.h

@@ -26,14 +26,10 @@ extern "C" {
 #define TD_MOD_UNINITIALIZED 0
 #define TD_MOD_INITIALIZED 1
 
-#define TD_MOD_UNCLEARD 0
-#define TD_MOD_CLEARD 1
-
 typedef int8_t td_mode_flag_t;
 
 #define TD_CHECK_AND_SET_MODE_INIT(FLAG) atomic_val_compare_exchange_8((FLAG), TD_MOD_UNINITIALIZED, TD_MOD_INITIALIZED)
-
-#define TD_CHECK_AND_SET_MOD_CLEAR(FLAG) atomic_val_compare_exchange_8((FLAG), TD_MOD_UNCLEARD, TD_MOD_CLEARD)
+#define TD_CHECK_AND_SET_MOD_CLEAR(FLAG) atomic_val_compare_exchange_8((FLAG), TD_MOD_INITIALIZED, TD_MOD_UNINITIALIZED)
 
 #define TD_IS_NULL(PTR) ((PTR) == NULL)
 

source/client/src/clientMsgHandler.c

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

source/dnode/mgmt/impl/CMakeLists.txt

@@ -11,6 +11,7 @@ target_link_libraries(
     PUBLIC wal
     PUBLIC sync
     PUBLIC taos
+    PUBLIC tfs
 )
 target_include_directories(
     dnode

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

@@ -167,7 +167,7 @@ typedef struct SDnode {
   SBnodeMgmt  bmgmt;
   SVnodesMgmt vmgmt;
   STransMgmt  tmgmt;
-  SStartupMsg startup;
+  SStartupReq startup;
 } SDnode;
 
 EStat dndGetStat(SDnode *pDnode);
@@ -175,7 +175,7 @@ void  dndSetStat(SDnode *pDnode, EStat stat);
 char *dndStatStr(EStat stat);
 
 void dndReportStartup(SDnode *pDnode, char *pName, char *pDesc);
-void dndGetStartup(SDnode *pDnode, SStartupMsg *pStartup);
+void dndGetStartup(SDnode *pDnode, SStartupReq *pStartup);
 
 #ifdef __cplusplus
 }

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

@@ -21,8 +21,9 @@ extern "C" {
 #endif
 #include "dndInt.h"
 
-int32_t dndInitDnode(SDnode *pDnode);
-void    dndCleanupDnode(SDnode *pDnode);
+int32_t dndInitMgmt(SDnode *pDnode);
+void    dndStopMgmt(SDnode *pDnode);
+void    dndCleanupMgmt(SDnode *pDnode);
 
 int32_t dndGetDnodeId(SDnode *pDnode);
 int64_t dndGetClusterId(SDnode *pDnode);

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

@@ -473,12 +473,12 @@ static int32_t dndProcessConfigDnodeReq(SDnode *pDnode, SRpcMsg *pReq) {
 void dndProcessStartupReq(SDnode *pDnode, SRpcMsg *pReq) {
   dDebug("startup req is received");
 
-  SStartupMsg *pStartup = rpcMallocCont(sizeof(SStartupMsg));
+  SStartupReq *pStartup = rpcMallocCont(sizeof(SStartupReq));
   dndGetStartup(pDnode, pStartup);
 
   dDebug("startup req is sent, step:%s desc:%s finished:%d", pStartup->name, pStartup->desc, pStartup->finished);
 
-  SRpcMsg rpcRsp = {.handle = pReq->handle, .pCont = pStartup, .contLen = sizeof(SStartupMsg)};
+  SRpcMsg rpcRsp = {.handle = pReq->handle, .pCont = pStartup, .contLen = sizeof(SStartupReq)};
   rpcSendResponse(&rpcRsp);
 }
 
@@ -497,7 +497,7 @@ static void *dnodeThreadRoutine(void *param) {
   }
 }
 
-int32_t dndInitDnode(SDnode *pDnode) {
+int32_t dndInitMgmt(SDnode *pDnode) {
   SDnodeMgmt *pMgmt = &pDnode->dmgmt;
 
   pMgmt->dnodeId = 0;
@@ -547,16 +547,18 @@ int32_t dndInitDnode(SDnode *pDnode) {
   return 0;
 }
 
-void dndCleanupDnode(SDnode *pDnode) {
+void dndStopMgmt(SDnode *pDnode) {
   SDnodeMgmt *pMgmt = &pDnode->dmgmt;
-
   dndCleanupWorker(&pMgmt->mgmtWorker);
 
   if (pMgmt->threadId != NULL) {
     taosDestoryThread(pMgmt->threadId);
     pMgmt->threadId = NULL;
   }
+}
 
+void dndCleanupMgmt(SDnode *pDnode) {
+  SDnodeMgmt *pMgmt = &pDnode->dmgmt;
   taosWLockLatch(&pMgmt->latch);
 
   if (pMgmt->dnodeEps != NULL) {

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

@@ -33,9 +33,9 @@ typedef struct {
   int8_t      dropped;
   int8_t      accessState;
   uint64_t    dbUid;
-  char       *db;
-  char       *path;
-  SVnode     *pImpl;
+  char *      db;
+  char *      path;
+  SVnode *    pImpl;
   STaosQueue *pWriteQ;
   STaosQueue *pSyncQ;
   STaosQueue *pApplyQ;
@@ -49,7 +49,7 @@ typedef struct {
   int32_t      failed;
   int32_t      threadIndex;
   pthread_t    thread;
-  SDnode      *pDnode;
+  SDnode *     pDnode;
   SWrapperCfg *pCfgs;
 } SVnodeThread;
 
@@ -67,7 +67,7 @@ void           dndProcessVnodeWriteMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pE
 void           dndProcessVnodeSyncMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet);
 static int32_t dndPutMsgIntoVnodeApplyQueue(SDnode *pDnode, int32_t vgId, SRpcMsg *pMsg);
 
-static SVnodeObj  *dndAcquireVnode(SDnode *pDnode, int32_t vgId);
+static SVnodeObj * dndAcquireVnode(SDnode *pDnode, int32_t vgId);
 static void        dndReleaseVnode(SDnode *pDnode, SVnodeObj *pVnode);
 static int32_t     dndOpenVnode(SDnode *pDnode, SWrapperCfg *pCfg, SVnode *pImpl);
 static void        dndCloseVnode(SDnode *pDnode, SVnodeObj *pVnode);
@@ -80,7 +80,7 @@ static void    dndCloseVnodes(SDnode *pDnode);
 
 static SVnodeObj *dndAcquireVnode(SDnode *pDnode, int32_t vgId) {
   SVnodesMgmt *pMgmt = &pDnode->vmgmt;
-  SVnodeObj   *pVnode = NULL;
+  SVnodeObj *  pVnode = NULL;
   int32_t      refCount = 0;
 
   taosRLockLatch(&pMgmt->latch);
@@ -111,7 +111,7 @@ static void dndReleaseVnode(SDnode *pDnode, SVnodeObj *pVnode) {
 
 static int32_t dndOpenVnode(SDnode *pDnode, SWrapperCfg *pCfg, SVnode *pImpl) {
   SVnodesMgmt *pMgmt = &pDnode->vmgmt;
-  SVnodeObj   *pVnode = calloc(1, sizeof(SVnodeObj));
+  SVnodeObj *  pVnode = calloc(1, sizeof(SVnodeObj));
   if (pVnode == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -167,6 +167,11 @@ static void dndCloseVnode(SDnode *pDnode, SVnodeObj *pVnode) {
 
   dDebug("vgId:%d, vnode is closed", pVnode->vgId);
 
+  if (pVnode->dropped) {
+    dDebug("vgId:%d, vnode is destroyed for dropped:%d", pVnode->vgId, pVnode->dropped);
+    vnodeDestroy(pVnode->path);
+  }
+
   free(pVnode->path);
   free(pVnode->db);
   free(pVnode);
@@ -183,7 +188,7 @@ static SVnodeObj **dndGetVnodesFromHash(SDnode *pDnode, int32_t *numOfVnodes) {
   void *pIter = taosHashIterate(pMgmt->hash, NULL);
   while (pIter) {
     SVnodeObj **ppVnode = pIter;
-    SVnodeObj  *pVnode = *ppVnode;
+    SVnodeObj * pVnode = *ppVnode;
     if (pVnode && num < size) {
       int32_t refCount = atomic_add_fetch_32(&pVnode->refCount, 1);
       dTrace("vgId:%d, acquire vnode, refCount:%d", pVnode->vgId, refCount);
@@ -205,9 +210,9 @@ static int32_t dndGetVnodesFromFile(SDnode *pDnode, SWrapperCfg **ppCfgs, int32_
   int32_t      code = TSDB_CODE_DND_VNODE_READ_FILE_ERROR;
   int32_t      len = 0;
   int32_t      maxLen = 30000;
-  char        *content = calloc(1, maxLen + 1);
-  cJSON       *root = NULL;
-  FILE        *fp = NULL;
+  char *       content = calloc(1, maxLen + 1);
+  cJSON *      root = NULL;
+  FILE *       fp = NULL;
   char         file[PATH_MAX + 20] = {0};
   SWrapperCfg *pCfgs = NULL;
 
@@ -320,7 +325,7 @@ static int32_t dndWriteVnodesToFile(SDnode *pDnode) {
 
   int32_t len = 0;
   int32_t maxLen = 65536;
-  char   *content = calloc(1, maxLen + 1);
+  char *  content = calloc(1, maxLen + 1);
 
   len += snprintf(content + len, maxLen - len, "{\n");
   len += snprintf(content + len, maxLen - len, "  \"vnodes\": [\n");
@@ -362,8 +367,8 @@ static int32_t dndWriteVnodesToFile(SDnode *pDnode) {
 
 static void *dnodeOpenVnodeFunc(void *param) {
   SVnodeThread *pThread = param;
-  SDnode       *pDnode = pThread->pDnode;
-  SVnodesMgmt  *pMgmt = &pDnode->vmgmt;
+  SDnode *      pDnode = pThread->pDnode;
+  SVnodesMgmt * pMgmt = &pDnode->vmgmt;
 
   dDebug("thread:%d, start to open %d vnodes", pThread->threadIndex, pThread->vnodeNum);
   setThreadName("open-vnodes");
@@ -376,10 +381,7 @@ static void *dnodeOpenVnodeFunc(void *param) {
              pMgmt->openVnodes, pMgmt->totalVnodes);
     dndReportStartup(pDnode, "open-vnodes", stepDesc);
 
-    SVnodeCfg vnodeCfg = {0};
-    vnodeCfg.vgId = pCfg->vgId;
-
-    SVnode *pImpl = vnodeOpen(pCfg->path, &vnodeCfg);
+    SVnode *pImpl = vnodeOpen(pCfg->path, NULL, pCfg->vgId);
     if (pImpl == NULL) {
       dError("vgId:%d, failed to open vnode by thread:%d", pCfg->vgId, pThread->threadIndex);
       pThread->failed++;
@@ -469,6 +471,7 @@ static int32_t dndOpenVnodes(SDnode *pDnode) {
 }
 
 static void dndCloseVnodes(SDnode *pDnode) {
+  dInfo("start to close all vnodes");
   SVnodesMgmt *pMgmt = &pDnode->vmgmt;
 
   int32_t     numOfVnodes = 0;
@@ -578,7 +581,7 @@ int32_t dndProcessCreateVnodeReq(SDnode *pDnode, SRpcMsg *pReq) {
     return -1;
   }
 
-  SVnode *pImpl = vnodeOpen(wrapperCfg.path, &vnodeCfg);
+  SVnode *pImpl = vnodeOpen(wrapperCfg.path, NULL /*pCfg*/, pCreate->vgId);
   if (pImpl == NULL) {
     dError("vgId:%d, failed to create vnode since %s", pCreate->vgId, terrstr());
     return -1;
@@ -661,8 +664,6 @@ int32_t dndProcessDropVnodeReq(SDnode *pDnode, SRpcMsg *pReq) {
   }
 
   dndCloseVnode(pDnode, pVnode);
-  vnodeClose(pVnode->pImpl);
-  vnodeDestroy(pVnode->path);
   dndWriteVnodesToFile(pDnode);
 
   return 0;
@@ -992,12 +993,12 @@ void dndGetVnodeLoads(SDnode *pDnode, SVnodeLoads *pLoads) {
   pLoads->num = taosHashGetSize(pMgmt->hash);
 
   int32_t v = 0;
-  void   *pIter = taosHashIterate(pMgmt->hash, NULL);
+  void *  pIter = taosHashIterate(pMgmt->hash, NULL);
   while (pIter) {
     SVnodeObj **ppVnode = pIter;
     if (ppVnode == NULL || *ppVnode == NULL) continue;
 
-    SVnodeObj  *pVnode = *ppVnode;
+    SVnodeObj * pVnode = *ppVnode;
     SVnodeLoad *pLoad = &pLoads->data[v++];
 
     vnodeGetLoad(pVnode->pImpl, pLoad);

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

@@ -23,6 +23,7 @@
 #include "dndVnodes.h"
 #include "sync.h"
 #include "wal.h"
+#include "tfs.h"
 
 EStat dndGetStat(SDnode *pDnode) { return pDnode->stat; }
 
@@ -45,14 +46,14 @@ char *dndStatStr(EStat stat) {
 }
 
 void dndReportStartup(SDnode *pDnode, char *pName, char *pDesc) {
-  SStartupMsg *pStartup = &pDnode->startup;
+  SStartupReq *pStartup = &pDnode->startup;
   tstrncpy(pStartup->name, pName, TSDB_STEP_NAME_LEN);
   tstrncpy(pStartup->desc, pDesc, TSDB_STEP_DESC_LEN);
   pStartup->finished = 0;
 }
 
-void dndGetStartup(SDnode *pDnode, SStartupMsg *pStartup) {
-  memcpy(pStartup, &pDnode->startup, sizeof(SStartupMsg));
+void dndGetStartup(SDnode *pDnode, SStartupReq *pStartup) {
+  memcpy(pStartup, &pDnode->startup, sizeof(SStartupReq));
   pStartup->finished = (dndGetStat(pDnode) == DND_STAT_RUNNING);
 }
 
@@ -185,13 +186,23 @@ SDnode *dndInit(SDnodeOpt *pOption) {
     return NULL;
   }
 
+  SDiskCfg dCfg;
+  strcpy(dCfg.dir, pDnode->opt.dataDir);
+  dCfg.level = 0;
+  dCfg.primary = 1;
+  if (tfsInit(&dCfg, 1) != 0) {
+    dError("failed to init tfs env");
+    dndCleanup(pDnode);
+    return NULL;
+  }
+
   if (vnodeInit(pDnode->opt.numOfCommitThreads) != 0) {
     dError("failed to init vnode env");
     dndCleanup(pDnode);
     return NULL;
   }
 
-  if (dndInitDnode(pDnode) != 0) {
+  if (dndInitMgmt(pDnode) != 0) {
     dError("failed to init dnode");
     dndCleanup(pDnode);
     return NULL;
@@ -252,13 +263,15 @@ void dndCleanup(SDnode *pDnode) {
   dInfo("start to cleanup TDengine");
   dndSetStat(pDnode, DND_STAT_STOPPED);
   dndCleanupTrans(pDnode);
+  dndStopMgmt(pDnode);
   dndCleanupMnode(pDnode);
   dndCleanupBnode(pDnode);
   dndCleanupSnode(pDnode);
   dndCleanupQnode(pDnode);
   dndCleanupVnodes(pDnode);
-  dndCleanupDnode(pDnode);
+  dndCleanupMgmt(pDnode);
   vnodeClear();
+  tfsDestroy();
   walCleanUp();
   rpcCleanup();
 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -31,7 +31,7 @@ static int32_t  mndProcessCreateQnodeReq(SMnodeMsg *pReq);
 static int32_t  mndProcessDropQnodeReq(SMnodeMsg *pReq);
 static int32_t  mndProcessCreateQnodeRsp(SMnodeMsg *pRsp);
 static int32_t  mndProcessDropQnodeRsp(SMnodeMsg *pRsp);
-static int32_t  mndGetQnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaMsg *pMeta);
+static int32_t  mndGetQnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta);
 static int32_t  mndRetrieveQnodes(SMnodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows);
 static void     mndCancelGetNextQnode(SMnode *pMnode, void *pIter);
 
@@ -391,7 +391,7 @@ static int32_t mndProcessDropQnodeRsp(SMnodeMsg *pRsp) {
   return 0;
 }
 
-static int32_t mndGetQnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaMsg *pMeta) {
+static int32_t mndGetQnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta) {
   SMnode *pMnode = pReq->pMnode;
   SSdb   *pSdb = pMnode->pSdb;
 

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

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

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

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

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

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

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

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

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

@@ -27,19 +27,19 @@
 static SSdbRow *mndVgroupActionDecode(SSdbRaw *pRaw);
 static int32_t  mndVgroupActionInsert(SSdb *pSdb, SVgObj *pVgroup);
 static int32_t  mndVgroupActionDelete(SSdb *pSdb, SVgObj *pVgroup);
-static int32_t  mndVgroupActionUpdate(SSdb *pSdb, SVgObj *pOldVgroup, SVgObj *pNewVgroup);
+static int32_t  mndVgroupActionUpdate(SSdb *pSdb, SVgObj *pOld, SVgObj *pNew);
 
-static int32_t mndProcessCreateVnodeRsp(SMnodeMsg *pMsg);
-static int32_t mndProcessAlterVnodeRsp(SMnodeMsg *pMsg);
-static int32_t mndProcessDropVnodeRsp(SMnodeMsg *pMsg);
-static int32_t mndProcessSyncVnodeRsp(SMnodeMsg *pMsg);
-static int32_t mndProcessCompactVnodeRsp(SMnodeMsg *pMsg);
+static int32_t mndProcessCreateVnodeRsp(SMnodeMsg *pRsp);
+static int32_t mndProcessAlterVnodeRsp(SMnodeMsg *pRsp);
+static int32_t mndProcessDropVnodeRsp(SMnodeMsg *pRsp);
+static int32_t mndProcessSyncVnodeRsp(SMnodeMsg *pRsp);
+static int32_t mndProcessCompactVnodeRsp(SMnodeMsg *pRsp);
 
-static int32_t mndGetVgroupMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta);
-static int32_t mndRetrieveVgroups(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows);
+static int32_t mndGetVgroupMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta);
+static int32_t mndRetrieveVgroups(SMnodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows);
 static void    mndCancelGetNextVgroup(SMnode *pMnode, void *pIter);
-static int32_t mndGetVnodeMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta);
-static int32_t mndRetrieveVnodes(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows);
+static int32_t mndGetVnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta);
+static int32_t mndRetrieveVnodes(SMnodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows);
 static void    mndCancelGetNextVnode(SMnode *pMnode, void *pIter);
 
 int32_t mndInitVgroup(SMnode *pMnode) {
@@ -164,14 +164,14 @@ static int32_t mndVgroupActionDelete(SSdb *pSdb, SVgObj *pVgroup) {
   return 0;
 }
 
-static int32_t mndVgroupActionUpdate(SSdb *pSdb, SVgObj *pOldVgroup, SVgObj *pNewVgroup) {
-  mTrace("vgId:%d, perform update action, old row:%p new row:%p", pOldVgroup->vgId, pOldVgroup, pNewVgroup);
-  pOldVgroup->updateTime = pNewVgroup->updateTime;
-  pOldVgroup->version = pNewVgroup->version;
-  pOldVgroup->hashBegin = pNewVgroup->hashBegin;
-  pOldVgroup->hashEnd = pNewVgroup->hashEnd;
-  pOldVgroup->replica = pNewVgroup->replica;
-  memcpy(pOldVgroup->vnodeGid, pNewVgroup->vnodeGid, TSDB_MAX_REPLICA * sizeof(SVnodeGid));
+static int32_t mndVgroupActionUpdate(SSdb *pSdb, SVgObj *pOld, SVgObj *pNew) {
+  mTrace("vgId:%d, perform update action, old row:%p new row:%p", pOld->vgId, pOld, pNew);
+  pOld->updateTime = pNew->updateTime;
+  pOld->version = pNew->version;
+  pOld->hashBegin = pNew->hashBegin;
+  pOld->hashEnd = pNew->hashEnd;
+  pOld->replica = pNew->replica;
+  memcpy(pOld->vnodeGid, pNew->vnodeGid, TSDB_MAX_REPLICA * sizeof(SVnodeGid));
   return 0;
 }
 
@@ -427,24 +427,24 @@ SEpSet mndGetVgroupEpset(SMnode *pMnode, SVgObj *pVgroup) {
   return epset;
 }
 
-static int32_t mndProcessCreateVnodeRsp(SMnodeMsg *pMsg) {
-  mndTransProcessRsp(pMsg);
+static int32_t mndProcessCreateVnodeRsp(SMnodeMsg *pRsp) {
+  mndTransProcessRsp(pRsp);
   return 0;
 }
 
-static int32_t mndProcessAlterVnodeRsp(SMnodeMsg *pMsg) {
-  mndTransProcessRsp(pMsg);
+static int32_t mndProcessAlterVnodeRsp(SMnodeMsg *pRsp) {
+  mndTransProcessRsp(pRsp);
   return 0;
 }
 
-static int32_t mndProcessDropVnodeRsp(SMnodeMsg *pMsg) {
-  mndTransProcessRsp(pMsg);
+static int32_t mndProcessDropVnodeRsp(SMnodeMsg *pRsp) {
+  mndTransProcessRsp(pRsp);
   return 0;
 }
 
-static int32_t mndProcessSyncVnodeRsp(SMnodeMsg *pMsg) { return 0; }
+static int32_t mndProcessSyncVnodeRsp(SMnodeMsg *pRsp) { return 0; }
 
-static int32_t mndProcessCompactVnodeRsp(SMnodeMsg *pMsg) { return 0; }
+static int32_t mndProcessCompactVnodeRsp(SMnodeMsg *pRsp) { return 0; }
 
 static bool mndGetVgroupMaxReplicaFp(SMnode *pMnode, void *pObj, void *p1, void *p2, void *p3) {
   SVgObj  *pVgroup = pObj;
@@ -475,8 +475,8 @@ static int32_t mndGetVgroupMaxReplica(SMnode *pMnode, char *dbName, int8_t *pRep
   return 0;
 }
 
-static int32_t mndGetVgroupMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta) {
-  SMnode *pMnode = pMsg->pMnode;
+static int32_t mndGetVgroupMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta) {
+  SMnode *pMnode = pReq->pMnode;
   SSdb   *pSdb = pMnode->pSdb;
 
   if (mndGetVgroupMaxReplica(pMnode, pShow->db, &pShow->replica, &pShow->numOfRows) != 0) {
@@ -526,8 +526,8 @@ static int32_t mndGetVgroupMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg
   return 0;
 }
 
-static int32_t mndRetrieveVgroups(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows) {
-  SMnode *pMnode = pMsg->pMnode;
+static int32_t mndRetrieveVgroups(SMnodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows) {
+  SMnode *pMnode = pReq->pMnode;
   SSdb   *pSdb = pMnode->pSdb;
   int32_t numOfRows = 0;
   SVgObj *pVgroup = NULL;
@@ -593,8 +593,8 @@ int32_t mndGetVnodesNum(SMnode *pMnode, int32_t dnodeId) {
   return numOfVnodes;
 }
 
-static int32_t mndGetVnodeMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta) {
-  SMnode *pMnode = pMsg->pMnode;
+static int32_t mndGetVnodeMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta) {
+  SMnode *pMnode = pReq->pMnode;
   SSdb   *pSdb = pMnode->pSdb;
 
   int32_t  cols = 0;
@@ -633,8 +633,8 @@ static int32_t mndGetVnodeMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *
   return 0;
 }
 
-static int32_t mndRetrieveVnodes(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows) {
-  SMnode *pMnode = pMsg->pMnode;
+static int32_t mndRetrieveVnodes(SMnodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows) {
+  SMnode *pMnode = pReq->pMnode;
   SSdb   *pSdb = pMnode->pSdb;
   int32_t numOfRows = 0;
   SVgObj *pVgroup = NULL;

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

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

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

@@ -64,9 +64,9 @@ TEST_F(MndTestDb, 01_ShowDb) {
 
 TEST_F(MndTestDb, 02_Create_Alter_Drop_Db) {
   {
-    int32_t contLen = sizeof(SCreateDbMsg);
+    int32_t contLen = sizeof(SCreateDbReq);
 
-    SCreateDbMsg* pReq = (SCreateDbMsg*)rpcMallocCont(contLen);
+    SCreateDbReq* pReq = (SCreateDbReq*)rpcMallocCont(contLen);
     strcpy(pReq->db, "1.d1");
     pReq->numOfVgroups = htonl(2);
     pReq->cacheBlockSize = htonl(16);
@@ -136,9 +136,9 @@ TEST_F(MndTestDb, 02_Create_Alter_Drop_Db) {
   CheckBinary("master", 9);
 
   {
-    int32_t contLen = sizeof(SAlterDbMsg);
+    int32_t contLen = sizeof(SAlterDbReq);
 
-    SAlterDbMsg* pReq = (SAlterDbMsg*)rpcMallocCont(contLen);
+    SAlterDbReq* pReq = (SAlterDbReq*)rpcMallocCont(contLen);
     strcpy(pReq->db, "1.d1");
     pReq->totalBlocks = htonl(12);
     pReq->daysToKeep0 = htonl(300);
@@ -205,9 +205,9 @@ TEST_F(MndTestDb, 02_Create_Alter_Drop_Db) {
   CheckInt8(0);                    // update
 
   {
-    int32_t contLen = sizeof(SDropDbMsg);
+    int32_t contLen = sizeof(SDropDbReq);
 
-    SDropDbMsg* pReq = (SDropDbMsg*)rpcMallocCont(contLen);
+    SDropDbReq* pReq = (SDropDbReq*)rpcMallocCont(contLen);
     strcpy(pReq->db, "1.d1");
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_DB, pReq, contLen);
@@ -224,9 +224,9 @@ TEST_F(MndTestDb, 02_Create_Alter_Drop_Db) {
 
 TEST_F(MndTestDb, 03_Create_Use_Restart_Use_Db) {
   {
-    int32_t contLen = sizeof(SCreateDbMsg);
+    int32_t contLen = sizeof(SCreateDbReq);
 
-    SCreateDbMsg* pReq = (SCreateDbMsg*)rpcMallocCont(contLen);
+    SCreateDbReq* pReq = (SCreateDbReq*)rpcMallocCont(contLen);
     strcpy(pReq->db, "1.d2");
     pReq->numOfVgroups = htonl(2);
     pReq->cacheBlockSize = htonl(16);
@@ -261,9 +261,9 @@ TEST_F(MndTestDb, 03_Create_Use_Restart_Use_Db) {
   CheckBinary("d2", TSDB_DB_NAME_LEN - 1);
 
   {
-    int32_t contLen = sizeof(SUseDbMsg);
+    int32_t contLen = sizeof(SUseDbReq);
 
-    SUseDbMsg* pReq = (SUseDbMsg*)rpcMallocCont(contLen);
+    SUseDbReq* pReq = (SUseDbReq*)rpcMallocCont(contLen);
     strcpy(pReq->db, "1.d2");
     pReq->vgVersion = htonl(-1);
 
@@ -290,7 +290,7 @@ TEST_F(MndTestDb, 03_Create_Use_Restart_Use_Db) {
       EXPECT_EQ(pInfo->hashEnd, UINT32_MAX / 2 - 1);
       EXPECT_EQ(pInfo->inUse, 0);
       EXPECT_EQ(pInfo->numOfEps, 1);
-      SEpAddrMsg* pAddr = &pInfo->epAddr[0];
+      SEpAddr* pAddr = &pInfo->epAddr[0];
       pAddr->port = htons(pAddr->port);
       EXPECT_EQ(pAddr->port, 9030);
       EXPECT_STREQ(pAddr->fqdn, "localhost");
@@ -306,7 +306,7 @@ TEST_F(MndTestDb, 03_Create_Use_Restart_Use_Db) {
       EXPECT_EQ(pInfo->hashEnd, UINT32_MAX);
       EXPECT_EQ(pInfo->inUse, 0);
       EXPECT_EQ(pInfo->numOfEps, 1);
-      SEpAddrMsg* pAddr = &pInfo->epAddr[0];
+      SEpAddr* pAddr = &pInfo->epAddr[0];
       pAddr->port = htons(pAddr->port);
       EXPECT_EQ(pAddr->port, 9030);
       EXPECT_STREQ(pAddr->fqdn, "localhost");
@@ -314,9 +314,9 @@ TEST_F(MndTestDb, 03_Create_Use_Restart_Use_Db) {
   }
 
   {
-    int32_t contLen = sizeof(SDropDbMsg);
+    int32_t contLen = sizeof(SDropDbReq);
 
-    SDropDbMsg* pReq = (SDropDbMsg*)rpcMallocCont(contLen);
+    SDropDbReq* pReq = (SDropDbReq*)rpcMallocCont(contLen);
     strcpy(pReq->db, "1.d2");
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_DB, pReq, contLen);

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

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

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

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

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

@@ -23,6 +23,7 @@
 #include "tlockfree.h"
 #include "tmacro.h"
 #include "wal.h"
+#include "tfs.h"
 
 #include "vnode.h"
 
@@ -48,7 +49,6 @@ typedef struct SVnodeTask {
 
 typedef struct SVnodeMgr {
   td_mode_flag_t vnodeInitFlag;
-  td_mode_flag_t vnodeClearFlag;
   // For commit
   bool            stop;
   uint16_t        nthreads;

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

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

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

@@ -97,14 +97,17 @@ int vnodeBufPoolSwitch(SVnode *pVnode) {
 
   pVnode->pBufPool->inuse = NULL;
 
-  TD_DLIST_APPEND(&(pVnode->pBufPool->incycle), pvma);
+  if (pvma) {
+    TD_DLIST_APPEND(&(pVnode->pBufPool->incycle), pvma);
+  }
   return 0;
 }
 
 int vnodeBufPoolRecycle(SVnode *pVnode) {
   SVBufPool *     pBufPool = pVnode->pBufPool;
   SVMemAllocator *pvma = TD_DLIST_HEAD(&(pBufPool->incycle));
-  ASSERT(pvma != NULL);
+  if (pvma == NULL) return 0;
+  // ASSERT(pvma != NULL);
 
   TD_DLIST_POP(&(pBufPool->incycle), pvma);
   vmaReset(pvma);

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

@@ -40,6 +40,7 @@ int vnodeAsyncCommit(SVnode *pVnode) {
 int vnodeSyncCommit(SVnode *pVnode) {
   vnodeAsyncCommit(pVnode);
   vnodeWaitCommit(pVnode);
+  tsem_post(&(pVnode->canCommit));
   return 0;
 }
 

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

@@ -15,12 +15,12 @@
 
 #include "vnodeDef.h"
 
-static SVnode *vnodeNew(const char *path, const SVnodeCfg *pVnodeCfg);
+static SVnode *vnodeNew(const char *path, const SVnodeCfg *pVnodeCfg, int32_t vid);
 static void    vnodeFree(SVnode *pVnode);
 static int     vnodeOpenImpl(SVnode *pVnode);
 static void    vnodeCloseImpl(SVnode *pVnode);
 
-SVnode *vnodeOpen(const char *path, const SVnodeCfg *pVnodeCfg) {
+SVnode *vnodeOpen(const char *path, const SVnodeCfg *pVnodeCfg, int32_t vid) {
   SVnode *pVnode = NULL;
 
   // Set default options
@@ -35,7 +35,7 @@ SVnode *vnodeOpen(const char *path, const SVnodeCfg *pVnodeCfg) {
   }
 
   // Create the handle
-  pVnode = vnodeNew(path, pVnodeCfg);
+  pVnode = vnodeNew(path, pVnodeCfg, vid);
   if (pVnode == NULL) {
     // TODO: handle error
     return NULL;
@@ -62,7 +62,7 @@ void vnodeClose(SVnode *pVnode) {
 void vnodeDestroy(const char *path) { taosRemoveDir(path); }
 
 /* ------------------------ STATIC METHODS ------------------------ */
-static SVnode *vnodeNew(const char *path, const SVnodeCfg *pVnodeCfg) {
+static SVnode *vnodeNew(const char *path, const SVnodeCfg *pVnodeCfg, int32_t vid) {
   SVnode *pVnode = NULL;
 
   pVnode = (SVnode *)calloc(1, sizeof(*pVnode));
@@ -71,6 +71,7 @@ static SVnode *vnodeNew(const char *path, const SVnodeCfg *pVnodeCfg) {
     return NULL;
   }
 
+  pVnode->vgId = vid;
   pVnode->path = strdup(path);
   vnodeOptionsCopy(&(pVnode->config), pVnodeCfg);
 
@@ -105,7 +106,7 @@ static int vnodeOpenImpl(SVnode *pVnode) {
 
   // Open tsdb
   sprintf(dir, "%s/tsdb", pVnode->path);
-  pVnode->pTsdb = tsdbOpen(dir, &(pVnode->config.tsdbCfg), vBufPoolGetMAF(pVnode));
+  pVnode->pTsdb = tsdbOpen(dir, pVnode->vgId, &(pVnode->config.tsdbCfg), vBufPoolGetMAF(pVnode), pVnode->pMeta);
   if (pVnode->pTsdb == NULL) {
     // TODO: handle error
     return -1;
@@ -137,7 +138,7 @@ static int vnodeOpenImpl(SVnode *pVnode) {
 }
 
 static void vnodeCloseImpl(SVnode *pVnode) {
-  // vnodeSyncCommit(pVnode);
+  vnodeSyncCommit(pVnode);
   if (pVnode) {
     vnodeCloseBufPool(pVnode);
     metaClose(pVnode->pMeta);

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

@@ -15,7 +15,7 @@
 
 #include "vnodeDef.h"
 
-SVnodeMgr vnodeMgr = {.vnodeInitFlag = TD_MOD_UNINITIALIZED, .vnodeClearFlag = TD_MOD_UNCLEARD, .stop = false};
+SVnodeMgr vnodeMgr = {.vnodeInitFlag = TD_MOD_UNINITIALIZED};
 
 static void* loop(void* arg);
 
@@ -24,6 +24,8 @@ int vnodeInit(uint16_t nthreads) {
     return 0;
   }
 
+  vnodeMgr.stop = false;
+
   // Start commit handers
   if (nthreads > 0) {
     vnodeMgr.nthreads = nthreads;
@@ -38,6 +40,7 @@ int vnodeInit(uint16_t nthreads) {
 
     for (uint16_t i = 0; i < nthreads; i++) {
       pthread_create(&(vnodeMgr.threads[i]), NULL, loop, NULL);
+      pthread_setname_np(vnodeMgr.threads[i], "VND Commit Thread");
     }
   } else {
     // TODO: if no commit thread is set, then another mechanism should be
@@ -53,7 +56,7 @@ int vnodeInit(uint16_t nthreads) {
 }
 
 void vnodeClear() {
-  if (TD_CHECK_AND_SET_MOD_CLEAR(&(vnodeMgr.vnodeClearFlag)) == TD_MOD_CLEARD) {
+  if (TD_CHECK_AND_SET_MOD_CLEAR(&(vnodeMgr.vnodeInitFlag)) == TD_MOD_UNINITIALIZED) {
     return;
   }
 

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

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

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

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

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

@@ -589,4 +589,36 @@ char *metaTbCursorNext(SMTbCursor *pTbCur) {
       return NULL;
     }
   }
+}
+
+STSchema *metaGetTbTSchema(SMeta *pMeta, tb_uid_t uid, int32_t sver) {
+  STSchemaBuilder sb;
+  STSchema *      pTSchema = NULL;
+  SSchema *       pSchema;
+  SSchemaWrapper *pSW;
+  STbCfg *        pTbCfg;
+  tb_uid_t        quid;
+
+  pTbCfg = metaGetTbInfoByUid(pMeta, uid);
+  if (pTbCfg->type == META_CHILD_TABLE) {
+    quid = pTbCfg->ctbCfg.suid;
+  } else {
+    quid = uid;
+  }
+
+  pSW = metaGetTableSchema(pMeta, quid, sver, true);
+  if (pSW == NULL) {
+    return NULL;
+  }
+
+  // Rebuild a schema
+  tdInitTSchemaBuilder(&sb, 0);
+  for (int32_t i = 0; i < pSW->nCols; i++) {
+    pSchema = pSW->pSchema + i;
+    tdAddColToSchema(&sb, pSchema->type, pSchema->colId, pSchema->bytes);
+  }
+  pTSchema = tdGetSchemaFromBuilder(&sb);
+  tdDestroyTSchemaBuilder(&sb);
+
+  return pTSchema;
 }
\ No newline at end of file

source/dnode/vnode/tsdb/CMakeLists.txt

@@ -2,7 +2,7 @@ aux_source_directory(src TSDB_SRC)
 if(0)
     add_library(tsdb ${TSDB_SRC})
 else(0)
-    add_library(tsdb "")
+    add_library(tsdb STATIC "")
     target_sources(tsdb
         PRIVATE
         "src/tsdbCommit.c"
@@ -29,4 +29,5 @@ target_link_libraries(
     PUBLIC common
     PUBLIC tkv
     PUBLIC tfs
+    PUBLIC meta
 )
\ No newline at end of file

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

@@ -39,6 +39,18 @@ static FORCE_INLINE int TSDB_KEY_FID(TSKEY key, int32_t days, int8_t precision)
   }
 }
 
+static FORCE_INLINE int tsdbGetFidLevel(int fid, SRtn *pRtn) {
+  if (fid >= pRtn->maxFid) {
+    return 0;
+  } else if (fid >= pRtn->midFid) {
+    return 1;
+  } else if (fid >= pRtn->minFid) {
+    return 2;
+  } else {
+    return -1;
+  }
+}
+
 #if 0
 #define TSDB_DEFAULT_BLOCK_ROWS(maxRows) ((maxRows)*4 / 5)
 
@@ -52,17 +64,6 @@ int tsdbWriteBlockImpl(STsdbRepo *pRepo, STable *pTable, SDFile *pDFile, SDataCo
                        bool isLast, bool isSuper, void **ppBuf, void **ppCBuf);
 int   tsdbApplyRtn(STsdbRepo *pRepo);
 
-static FORCE_INLINE int tsdbGetFidLevel(int fid, SRtn *pRtn) {
-  if (fid >= pRtn->maxFid) {
-    return 0;
-  } else if (fid >= pRtn->midFid) {
-    return 1;
-  } else if (fid >= pRtn->minFid) {
-    return 2;
-  } else {
-    return -1;
-  }
-}
 #endif
 
 #endif /* _TD_TSDB_COMMIT_H_ */
\ No newline at end of file

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

@@ -12,6 +12,8 @@
  * 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
+
 #ifndef _TD_TSDB_COMPACT_H_
 #define _TD_TSDB_COMPACT_H_
 
@@ -19,14 +21,12 @@
 extern "C" {
 #endif
 
-#if 0
-
 void *tsdbCompactImpl(STsdbRepo *pRepo);
 
-#endif
-
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* _TD_TSDB_COMPACT_H_ */
+#endif /* _TD_TSDB_COMPACT_H_ */
\ No newline at end of file
+
+#endif
\ No newline at end of file

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

@@ -17,6 +17,7 @@
 #define _TD_TSDB_DEF_H_
 
 #include "mallocator.h"
+#include "meta.h"
 #include "tcompression.h"
 #include "tglobal.h"
 #include "thash.h"
@@ -47,12 +48,17 @@ struct STsdb {
   STsdbMemTable *       imem;
   SRtn                  rtn;
   SMemAllocatorFactory *pmaf;
-  STsdbFS               fs;
+  STsdbFS *             fs;
+  SMeta *               pMeta;
 };
 
-#define REPO_ID(r) 0
+#define REPO_ID(r) ((r)->vgId)
 #define REPO_CFG(r) (&(r)->config)
-#define REPO_FS(r) (&(r)->fs)
+#define REPO_FS(r) (r)->fs
+
+static FORCE_INLINE STSchema *tsdbGetTableSchemaImpl(STable *pTable, bool lock, bool copy, int32_t version) {
+  return pTable->pSchema;
+}
 
 #ifdef __cplusplus
 }

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

@@ -70,7 +70,7 @@ typedef struct {
 #define TSDB_FS_ITER_FORWARD TSDB_ORDER_ASC
 #define TSDB_FS_ITER_BACKWARD TSDB_ORDER_DESC
 
-STsdbFS *tsdbNewFS(STsdbCfg *pCfg);
+STsdbFS *tsdbNewFS(const STsdbCfg *pCfg);
 void *   tsdbFreeFS(STsdbFS *pfs);
 int      tsdbOpenFS(STsdb *pRepo);
 void     tsdbCloseFS(STsdb *pRepo);
@@ -79,7 +79,7 @@ int      tsdbEndFSTxn(STsdb *pRepo);
 int      tsdbEndFSTxnWithError(STsdbFS *pfs);
 void     tsdbUpdateFSTxnMeta(STsdbFS *pfs, STsdbFSMeta *pMeta);
 // void     tsdbUpdateMFile(STsdbFS *pfs, const SMFile *pMFile);
-int      tsdbUpdateDFileSet(STsdbFS *pfs, const SDFileSet *pSet);
+int tsdbUpdateDFileSet(STsdbFS *pfs, const SDFileSet *pSet);
 
 void       tsdbFSIterInit(SFSIter *pIter, STsdbFS *pfs, int direction);
 void       tsdbFSIterSeek(SFSIter *pIter, int fid);

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

@@ -22,11 +22,57 @@
 extern "C" {
 #endif
 
-typedef struct STsdbMemTable STsdbMemTable;
+typedef struct {
+  int   rowsInserted;
+  int   rowsUpdated;
+  int   rowsDeleteSucceed;
+  int   rowsDeleteFailed;
+  int   nOperations;
+  TSKEY keyFirst;
+  TSKEY keyLast;
+} SMergeInfo;
+
+typedef struct STbData {
+  tb_uid_t   uid;
+  TSKEY      keyMin;
+  TSKEY      keyMax;
+  int64_t    nrows;
+  SSkipList *pData;
+} STbData;
+
+typedef struct STsdbMemTable {
+  T_REF_DECLARE()
+  SRWLatch       latch;
+  TSKEY          keyMin;
+  TSKEY          keyMax;
+  uint64_t       nRow;
+  SMemAllocator *pMA;
+  // Container
+  SSkipList *pSlIdx;  // SSkiplist<STbData>
+  SHashObj * pHashIdx;
+} STsdbMemTable;
 
 STsdbMemTable *tsdbNewMemTable(STsdb *pTsdb);
 void           tsdbFreeMemTable(STsdb *pTsdb, STsdbMemTable *pMemTable);
-int            tsdbMemTableInsert(STsdb *pTsdb, STsdbMemTable *pMemTable, SSubmitMsg *pMsg, SShellSubmitRspMsg *pRsp);
+int            tsdbMemTableInsert(STsdb *pTsdb, STsdbMemTable *pMemTable, SSubmitMsg *pMsg, SShellSubmitRsp *pRsp);
+int tsdbLoadDataFromCache(STable *pTable, SSkipListIterator *pIter, TSKEY maxKey, int maxRowsToRead, SDataCols *pCols,
+                          TKEY *filterKeys, int nFilterKeys, bool keepDup, SMergeInfo *pMergeInfo);
+
+static FORCE_INLINE SMemRow tsdbNextIterRow(SSkipListIterator *pIter) {
+  if (pIter == NULL) return NULL;
+
+  SSkipListNode *node = tSkipListIterGet(pIter);
+  if (node == NULL) return NULL;
+
+  return (SMemRow)SL_GET_NODE_DATA(node);
+}
+
+static FORCE_INLINE TSKEY tsdbNextIterKey(SSkipListIterator *pIter) {
+  SMemRow row = tsdbNextIterRow(pIter);
+  if (row == NULL) return TSDB_DATA_TIMESTAMP_NULL;
+
+  return memRowKey(row);
+}
 
 #ifdef __cplusplus
 }

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

@@ -12,6 +12,7 @@
  * 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
 #include "tsdbint.h"
 
 typedef struct {
@@ -528,3 +529,5 @@ static int tsdbCompactMeta(STsdbRepo *pRepo) {
     return 0;
 }
 
+#endif
+

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

@@ -191,7 +191,7 @@ static int tsdbAddDFileSetToStatus(SFSStatus *pStatus, const SDFileSet *pSet) {
 }
 
 // ================== STsdbFS
-STsdbFS *tsdbNewFS(STsdbCfg *pCfg) {
+STsdbFS *tsdbNewFS(const STsdbCfg *pCfg) {
   int      keep = pCfg->keep;
   int      days = pCfg->daysPerFile;
   int      maxFSet = TSDB_MAX_FSETS(keep, days);
@@ -1287,7 +1287,7 @@ static int tsdbRestoreCurrent(STsdb *pRepo) {
     return -1;
   }
 
-  if (tsdbSaveFSStatus(pRepo->fs.cstatus, REPO_ID(pRepo)) < 0) {
+  if (tsdbSaveFSStatus(pRepo->fs->cstatus, REPO_ID(pRepo)) < 0) {
     tsdbError("vgId:%d failed to restore corrent since %s", REPO_ID(pRepo), tstrerror(terrno));
     return -1;
   }

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

@@ -15,18 +15,19 @@
 
 #include "tsdbDef.h"
 
-static STsdb *tsdbNew(const char *path, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF);
+static STsdb *tsdbNew(const char *path, int32_t vgId, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF,
+                      SMeta *pMeta);
 static void   tsdbFree(STsdb *pTsdb);
 static int    tsdbOpenImpl(STsdb *pTsdb);
 static void   tsdbCloseImpl(STsdb *pTsdb);
 
-STsdb *tsdbOpen(const char *path, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF) {
+STsdb *tsdbOpen(const char *path, int32_t vgId, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF, SMeta *pMeta) {
   STsdb *pTsdb = NULL;
 
   // Set default TSDB Options
-  if (pTsdbCfg == NULL) {
-    pTsdbCfg = &defautlTsdbOptions;
-  }
+  // if (pTsdbCfg == NULL) {
+  pTsdbCfg = &defautlTsdbOptions;
+  // }
 
   // Validate the options
   if (tsdbValidateOptions(pTsdbCfg) < 0) {
@@ -35,7 +36,7 @@ STsdb *tsdbOpen(const char *path, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory
   }
 
   // Create the handle
-  pTsdb = tsdbNew(path, pTsdbCfg, pMAF);
+  pTsdb = tsdbNew(path, vgId, pTsdbCfg, pMAF, pMeta);
   if (pTsdb == NULL) {
     // TODO: handle error
     return NULL;
@@ -62,7 +63,8 @@ void tsdbClose(STsdb *pTsdb) {
 void tsdbRemove(const char *path) { taosRemoveDir(path); }
 
 /* ------------------------ STATIC METHODS ------------------------ */
-static STsdb *tsdbNew(const char *path, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF) {
+static STsdb *tsdbNew(const char *path, int32_t vgId, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF,
+                      SMeta *pMeta) {
   STsdb *pTsdb = NULL;
 
   pTsdb = (STsdb *)calloc(1, sizeof(STsdb));
@@ -72,25 +74,32 @@ static STsdb *tsdbNew(const char *path, const STsdbCfg *pTsdbCfg, SMemAllocatorF
   }
 
   pTsdb->path = strdup(path);
+  pTsdb->vgId = vgId;
   tsdbOptionsCopy(&(pTsdb->config), pTsdbCfg);
   pTsdb->pmaf = pMAF;
+  pTsdb->pMeta = pMeta;
+
+  pTsdb->fs = tsdbNewFS(pTsdbCfg);
 
   return pTsdb;
 }
 
 static void tsdbFree(STsdb *pTsdb) {
   if (pTsdb) {
+    tsdbFreeFS(pTsdb->fs);
     tfree(pTsdb->path);
     free(pTsdb);
   }
 }
 
 static int tsdbOpenImpl(STsdb *pTsdb) {
+  tsdbOpenFS(pTsdb);
   // TODO
   return 0;
 }
 
 static void tsdbCloseImpl(STsdb *pTsdb) {
+  tsdbCloseFS(pTsdb);
   // TODO
 }
 #if 0
@@ -112,8 +121,8 @@ static void tsdbCloseImpl(STsdb *pTsdb) {
 // no test file errors here
 #include "taosdef.h"
 #include "tsdbint.h"
-#include "ttimer.h"
 #include "tthread.h"
+#include "ttimer.h"
 
 #define IS_VALID_PRECISION(precision) \
   (((precision) >= TSDB_TIME_PRECISION_MILLI) && ((precision) <= TSDB_TIME_PRECISION_NANO))

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

@@ -15,7 +15,16 @@
 
 #include "tsdbDef.h"
 
-const STsdbCfg defautlTsdbOptions = {.lruCacheSize = 0};
+const STsdbCfg defautlTsdbOptions = {.precision = 0,
+                                     .lruCacheSize = 0,
+                                     .daysPerFile = 10,
+                                     .minRowsPerFileBlock = 100,
+                                     .maxRowsPerFileBlock = 4096,
+                                     .keep = 3650,
+                                     .keep1 = 3650,
+                                     .keep2 = 3650,
+                                     .update = 0,
+                                     .compression = TWO_STAGE_COMP};
 
 int tsdbOptionsInit(STsdbCfg *pTsdbOptions) {
   // TODO

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

@@ -25,7 +25,6 @@ static int  tsdbCheckAndDecodeColumnData(SDataCol *pDataCol, void *content, int3
 static int  tsdbLoadBlockDataColsImpl(SReadH *pReadh, SBlock *pBlock, SDataCols *pDataCols, int16_t *colIds,
                                       int numOfColIds);
 static int  tsdbLoadColData(SReadH *pReadh, SDFile *pDFile, SBlock *pBlock, SBlockCol *pBlockCol, SDataCol *pDataCol);
-static STSchema *tsdbGetTableSchemaImpl(STable *pTable, bool lock, bool copy, int32_t version) { return NULL; }
 
 int tsdbInitReadH(SReadH *pReadh, STsdb *pRepo) {
   ASSERT(pReadh != NULL && pRepo != NULL);
@@ -667,4 +666,3 @@ static int tsdbLoadColData(SReadH *pReadh, SDFile *pDFile, SBlock *pBlock, SBloc
 
   return 0;
 }
-

source/dnode/vnode/tsdb2/CMakeLists.txt

-aux_source_directory(src TSDB_SRC)
-add_library(tsdb STATIC ${TSDB_SRC})
-
-target_include_directories(
-    tsdb
-    PUBLIC "${CMAKE_SOURCE_DIR}/include/dnode/vnode/tsdb2"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
-)
-target_link_libraries(tsdb os util common tfs)
\ No newline at end of file

source/dnode/vnode/tsdb2/inc/tsdbBuffer.h

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-// #ifndef _TD_TSDB_BUFFER_H_
-// #define _TD_TSDB_BUFFER_H_
-
-// typedef struct {
-//   int64_t blockId;
-//   int     offset;
-//   int     remain;
-//   char    data[];
-// } STsdbBufBlock;
-
-// typedef struct {
-//   pthread_cond_t poolNotEmpty;
-//   int            bufBlockSize;
-//   int            tBufBlocks;
-//   int            nBufBlocks;
-//   int            nRecycleBlocks;
-//   int            nElasticBlocks;
-//   int64_t        index;
-//   SList*         bufBlockList;  
-// } STsdbBufPool;
-
-// #define TSDB_BUFFER_RESERVE 1024  // Reseve 1K as commit threshold
-
-// STsdbBufPool* tsdbNewBufPool();
-// void          tsdbFreeBufPool(STsdbBufPool* pBufPool);
-// int           tsdbOpenBufPool(STsdb* pRepo);
-// void          tsdbCloseBufPool(STsdb* pRepo);
-// SListNode*    tsdbAllocBufBlockFromPool(STsdb* pRepo);
-// int           tsdbExpandPool(STsdb* pRepo, int32_t oldTotalBlocks);
-// void          tsdbRecycleBufferBlock(STsdbBufPool* pPool, SListNode *pNode, bool bELastic);
-
-// // health cite
-// STsdbBufBlock *tsdbNewBufBlock(int bufBlockSize);
-// void tsdbFreeBufBlock(STsdbBufBlock *pBufBlock);
-
-// #endif /* _TD_TSDB_BUFFER_H_ */

source/dnode/vnode/tsdb2/inc/tsdbCommit.h

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _TD_TSDB_COMMIT_H_
-#define _TD_TSDB_COMMIT_H_
-
-typedef struct {
-  int   minFid;
-  int   midFid;
-  int   maxFid;
-  TSKEY minKey;
-} SRtn;
-
-typedef struct {
-  uint64_t uid;
-  int64_t  offset;
-  int64_t  size;
-} SKVRecord;
-
-#define TSDB_DEFAULT_BLOCK_ROWS(maxRows) ((maxRows)*4 / 5)
-
-void  tsdbGetRtnSnap(STsdb *pRepo, SRtn *pRtn);
-int   tsdbEncodeKVRecord(void **buf, SKVRecord *pRecord);
-void *tsdbDecodeKVRecord(void *buf, SKVRecord *pRecord);
-void *tsdbCommitData(STsdb *pRepo);
-int   tsdbApplyRtnOnFSet(STsdb *pRepo, SDFileSet *pSet, SRtn *pRtn);
-int tsdbWriteBlockInfoImpl(SDFile *pHeadf, STable *pTable, SArray *pSupA, SArray *pSubA, void **ppBuf, SBlockIdx *pIdx);
-int tsdbWriteBlockIdx(SDFile *pHeadf, SArray *pIdxA, void **ppBuf);
-int   tsdbWriteBlockImpl(STsdb *pRepo, STable *pTable, SDFile *pDFile, SDFile *pDFileAggr, SDataCols *pDataCols,
-                         SBlock *pBlock, bool isLast, bool isSuper, void **ppBuf, void **ppCBuf, void **ppExBuf);
-int   tsdbApplyRtn(STsdb *pRepo);
-
-static FORCE_INLINE int tsdbGetFidLevel(int fid, SRtn *pRtn) {
-  if (fid >= pRtn->maxFid) {
-    return 0;
-  } else if (fid >= pRtn->midFid) {
-    return 1;
-  } else if (fid >= pRtn->minFid) {
-    return 2;
-  } else {
-    return -1;
-  }
-}
-
-#endif /* _TD_TSDB_COMMIT_H_ */
\ No newline at end of file

source/dnode/vnode/tsdb2/src/tsdbRecover.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/>.
- */
\ No newline at end of file