diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile
deleted file mode 100644
index fc9a51af65..0000000000
--- a/.devcontainer/Dockerfile
+++ /dev/null
@@ -1,9 +0,0 @@
-# See here for image contents: https://github.com/microsoft/vscode-dev-containers/tree/v0.209.3/containers/cpp/.devcontainer/base.Dockerfile
-
-# [Choice] Debian / Ubuntu version (use Debian 11/9, Ubuntu 18.04/21.04 on local arm64/Apple Silicon): debian-11, debian-10, debian-9, ubuntu-21.04, ubuntu-20.04, ubuntu-18.04
-ARG VARIANT="bullseye"
-FROM mcr.microsoft.com/vscode/devcontainers/cpp:0-${VARIANT}
-
-# [Optional] Uncomment this section to install additional packages.
-# RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
-#     && apt-get -y install --no-install-recommends <your-package-list-here>
diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
deleted file mode 100644
index 9b752d091d..0000000000
--- a/.devcontainer/devcontainer.json
+++ /dev/null
@@ -1,32 +0,0 @@
-// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
-// https://github.com/microsoft/vscode-dev-containers/tree/v0.209.3/containers/cpp
-{
-	"name": "C++",
-	"build": {
-		"dockerfile": "Dockerfile",
-		// Update 'VARIANT' to pick an Debian / Ubuntu OS version: debian-11, debian-10, debian-9, ubuntu-21.04, ubuntu-20.04, ubuntu-18.04
-		// Use Debian 11, Debian 9, Ubuntu 18.04 or Ubuntu 21.04 on local arm64/Apple Silicon
-		"args": { "VARIANT": "ubuntu-21.04" }
-	},
-	"runArgs": ["--cap-add=SYS_PTRACE", "--security-opt", "seccomp=unconfined"],
-
-	// Set *default* container specific settings.json values on container create.
-	"settings": {},
-
-	// Add the IDs of extensions you want installed when the container is created.
-	"extensions": [
-		"ms-vscode.cpptools",
-		"ms-vscode.cmake-tools",
-		"austin.code-gnu-global",
-		"visualstudioexptteam.vscodeintel"
-	],
-
-	// Use 'forwardPorts' to make a list of ports inside the container available locally.
-	// "forwardPorts": [],
-
-	// Use 'postCreateCommand' to run commands after the container is created.
-	// "postCreateCommand": "gcc -v",
-
-	// Comment out connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
-	"remoteUser": "vscode"
-}
diff --git a/include/client/taos.h b/include/client/taos.h
index 0f7edc9fed..19d191b84e 100644
--- a/include/client/taos.h
+++ b/include/client/taos.h
@@ -73,10 +73,12 @@ typedef struct taosField {
   #define DLL_EXPORT 
 #endif
 
-DLL_EXPORT int   taos_init();
+typedef void (*__taos_async_fn_t)(void *param, TAOS_RES *, int code);
+
 DLL_EXPORT void  taos_cleanup(void);
 DLL_EXPORT int   taos_options(TSDB_OPTION option, const void *arg, ...);
 DLL_EXPORT TAOS *taos_connect(const char *ip, const char *user, const char *pass, const char *db, uint16_t port);
+DLL_EXPORT TAOS *taos_connect_l(const char *ip, int ipLen, const char *user, int userLen, const char *pass, int passLen, const char *db, int dbLen, uint16_t port);
 DLL_EXPORT TAOS *taos_connect_auth(const char *ip, const char *user, const char *auth, const char *db, uint16_t port);
 DLL_EXPORT void  taos_close(TAOS *taos);
 
@@ -154,14 +156,14 @@ DLL_EXPORT int* taos_fetch_lengths(TAOS_RES *res);
 // TAOS_RES   *taos_list_dbs(TAOS *mysql, const char *wild);
 
 // TODO: the return value should be `const`
-DLL_EXPORT char *taos_get_server_info(TAOS *taos);
-DLL_EXPORT char *taos_get_client_info();
-DLL_EXPORT char *taos_errstr(TAOS_RES *tres);
+DLL_EXPORT const char *taos_get_server_info(TAOS *taos);
+DLL_EXPORT const char *taos_get_client_info();
+DLL_EXPORT const char *taos_errstr(TAOS_RES *tres);
 
 DLL_EXPORT int taos_errno(TAOS_RES *tres);
 
-DLL_EXPORT void taos_query_a(TAOS *taos, const char *sql, void (*fp)(void *param, TAOS_RES *, int code), void *param);
-DLL_EXPORT void taos_fetch_rows_a(TAOS_RES *res, void (*fp)(void *param, TAOS_RES *, int numOfRows), void *param);
+DLL_EXPORT void taos_query_a(TAOS *taos, const char *sql, __taos_async_fn_t fp, void *param);
+DLL_EXPORT void taos_fetch_rows_a(TAOS_RES *res, __taos_async_fn_t fp, void *param);
 
 typedef void (*TAOS_SUBSCRIBE_CALLBACK)(TAOS_SUB* tsub, TAOS_RES *res, void* param, int code);
 DLL_EXPORT TAOS_SUB *taos_subscribe(TAOS* taos, int restart, const char* topic, const char *sql, TAOS_SUBSCRIBE_CALLBACK fp, void *param, int interval);
diff --git a/include/common/taosmsg.h b/include/common/taosmsg.h
index 6f25d0fb87..2fc458fd90 100644
--- a/include/common/taosmsg.h
+++ b/include/common/taosmsg.h
@@ -77,7 +77,7 @@ TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DROP_FUNCTION, "drop-function" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CREATE_STB, "create-stb" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_ALTER_STB, "alter-stb" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DROP_STB, "drop-stb" )	
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_STB_VGROUP, "stb-vgroup" )
+TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_VGROUP_LIST, "vgroup-list" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_KILL_QUERY, "kill-query" )	
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_KILL_STREAM, "kill-stream" )	
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_KILL_CONN, "kill-conn" )
@@ -168,8 +168,8 @@ typedef enum _mgmt_table {
   TSDB_MGMT_TABLE_SCORES,
   TSDB_MGMT_TABLE_GRANTS,
   TSDB_MGMT_TABLE_VNODES,
-  TSDB_MGMT_TABLE_STREAMTABLES,
   TSDB_MGMT_TABLE_CLUSTER,
+  TSDB_MGMT_TABLE_STREAMTABLES,
   TSDB_MGMT_TABLE_TP,
   TSDB_MGMT_TABLE_FUNCTION,
   TSDB_MGMT_TABLE_MAX,
@@ -214,6 +214,18 @@ typedef enum _mgmt_table {
 
 extern char *taosMsg[];
 
+typedef struct SBuildTableMetaInput {
+  int32_t   vgId;
+  char     *tableFullName;
+} SBuildTableMetaInput;
+
+typedef struct SBuildUseDBInput {
+  char    db[TSDB_TABLE_FNAME_LEN];
+  int32_t vgroupVersion;
+  int32_t dbGroupVersion;
+} 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
@@ -358,6 +370,7 @@ typedef struct {
   int32_t pid;
   char    app[TSDB_APP_NAME_LEN];
   char    db[TSDB_DB_NAME_LEN];
+  int64_t startTime;
 } SConnectMsg;
 
 typedef struct SEpSet {
@@ -368,34 +381,35 @@ typedef struct SEpSet {
 } SEpSet;
 
 typedef struct {
-  int32_t acctId;
-  int32_t clusterId;
-  int32_t connId;
-  int8_t  superAuth;
-  int8_t  readAuth;
-  int8_t  writeAuth;
-  int8_t  reserved[5];
-  SEpSet  epSet;
+  int32_t  acctId;
+  uint32_t clusterId;
+  int32_t  connId;
+  int8_t   superUser;
+  int8_t   reserved[5];
+  SEpSet   epSet;
 } SConnectRsp;
 
 typedef struct {
   char    user[TSDB_USER_LEN];
-  char    pass[TSDB_KEY_LEN];
+  char    pass[TSDB_PASSWORD_LEN];
   int32_t maxUsers;
   int32_t maxDbs;
   int32_t maxTimeSeries;
   int32_t maxStreams;
-  int64_t maxStorage;   // In unit of GB
   int32_t accessState;  // Configured only by command
+  int64_t maxStorage;   // In unit of GB
+  int32_t reserve[8];
 } SCreateAcctMsg, SAlterAcctMsg;
 
 typedef struct {
-  char user[TSDB_USER_LEN];
+  char    user[TSDB_USER_LEN];
+  int32_t reserve[8];
 } SDropUserMsg, SDropAcctMsg;
 
 typedef struct {
-  char user[TSDB_USER_LEN];
-  char pass[TSDB_KEY_LEN];
+  char    user[TSDB_USER_LEN];
+  char    pass[TSDB_PASSWORD_LEN];
+  int32_t reserve[8];
 } SCreateUserMsg, SAlterUserMsg;
 
 typedef struct {
@@ -613,6 +627,8 @@ typedef struct {
 typedef struct {
   char    db[TSDB_TABLE_FNAME_LEN];
   int8_t  ignoreNotExists;
+  int32_t vgroupVersion;
+  int32_t dbGroupVersion;
   int32_t reserve[8];
 } SUseDbMsg;
 
@@ -774,9 +790,8 @@ typedef struct {
 } SStbInfoMsg;
 
 typedef struct {
+  SMsgHead  msgHead;
   char   tableFname[TSDB_TABLE_FNAME_LEN];
-  int8_t createFlag;
-  char   tags[];
 } STableInfoMsg;
 
 typedef struct {
@@ -791,6 +806,18 @@ typedef struct SSTableVgroupMsg {
   int32_t numOfTables;
 } SSTableVgroupMsg, SSTableVgroupRspMsg;
 
+typedef struct SVgroupInfo {
+  int32_t    vgId;
+  int8_t     numOfEps;
+  SEpAddrMsg epAddr[TSDB_MAX_REPLICA];
+} SVgroupInfo;
+
+typedef struct SVgroupListRspMsg {
+  int32_t     vgroupNum;
+  int32_t     vgroupVersion;
+  SVgroupInfo vgroupInfo[];
+} SVgroupListRspMsg;
+
 typedef struct {
   int32_t    vgId;
   int8_t     numOfEps;
@@ -835,6 +862,19 @@ typedef struct {
   char   *data;
 } STagData;
 
+typedef struct {
+  int32_t     vgroupNum;
+  int32_t     vgroupVersion;
+  char        db[TSDB_TABLE_FNAME_LEN];
+  int32_t     dbVgroupVersion;
+  int32_t     dbVgroupNum;
+  int32_t     dbHashRange;
+  SVgroupInfo vgroupInfo[];
+//int32_t     vgIdList[];
+} SUseDbRspMsg;
+
+
+
 /*
  * sql: show tables like '%a_%'
  * payload is the query condition, e.g., '%a_%'
@@ -859,16 +899,19 @@ typedef struct SShowRsp {
 } SShowRsp;
 
 typedef struct {
-  char ep[TSDB_EP_LEN];  // end point, hostname:port
+  char    ep[TSDB_EP_LEN];  // end point, hostname:port
+  int32_t reserve[8];
 } SCreateDnodeMsg;
 
 typedef struct {
   int32_t dnodeId;
+  int32_t reserve[8];
 } SDropDnodeMsg;
 
 typedef struct {
   int32_t dnodeId;
   char    config[TSDB_DNODE_CONFIG_LEN];
+  int32_t reserve[8];
 } SCfgDnodeMsg;
 
 typedef struct {
@@ -961,8 +1004,8 @@ typedef struct {
   char user[TSDB_USER_LEN];
   char spi;
   char encrypt;
-  char secret[TSDB_KEY_LEN];
-  char ckey[TSDB_KEY_LEN];
+  char secret[TSDB_PASSWORD_LEN];
+  char ckey[TSDB_PASSWORD_LEN];
 } SAuthMsg, SAuthRsp;
 
 typedef struct {
diff --git a/include/common/tep.h b/include/common/tep.h
new file mode 100644
index 0000000000..2addc11e5a
--- /dev/null
+++ b/include/common/tep.h
@@ -0,0 +1,17 @@
+#ifndef TDENGINE_TEP_H
+#define TDENGINE_TEP_H
+
+#include "os.h"
+#include "taosmsg.h"
+
+typedef struct SCorEpSet {
+  int32_t version;
+  SEpSet  epSet;
+} SCorEpSet;
+
+int taosGetFqdnPortFromEp(const char *ep, char *fqdn, uint16_t *port);
+bool isEpsetEqual(const SEpSet *s1, const SEpSet *s2);
+
+void updateEpSet_s(SCorEpSet *pEpSet, SEpSet *pNewEpSet);
+
+#endif  // TDENGINE_TEP_H
diff --git a/include/common/tglobal.h b/include/common/tglobal.h
index aedf4122bb..a9b0e60761 100644
--- a/include/common/tglobal.h
+++ b/include/common/tglobal.h
@@ -81,8 +81,6 @@ extern int64_t tsMaxRetentWindow;
 // db parameters in client
 extern int32_t tsCacheBlockSize;
 extern int32_t tsBlocksPerVnode;
-extern int32_t tsMinTablePerVnode;
-extern int32_t tsMaxTablePerVnode;
 extern int32_t tsTableIncStepPerVnode;
 extern int32_t tsMaxVgroupsPerDb;
 extern int16_t tsDaysPerFile;
@@ -113,16 +111,8 @@ extern int8_t  tsEnableSlaveQuery;
 extern int8_t  tsEnableAdjustMaster;
 
 // restful
-extern int8_t   tsEnableHttpModule;
 extern int32_t  tsRestRowLimit;
-extern uint16_t tsHttpPort;
-extern int32_t  tsHttpCacheSessions;
-extern int32_t  tsHttpSessionExpire;
-extern int32_t  tsHttpMaxThreads;
-extern int8_t   tsHttpEnableCompress;
-extern int8_t   tsHttpEnableRecordSql;
 extern int8_t   tsTelegrafUseFieldNum;
-extern int8_t   tsHttpDbNameMandatory;
 
 // mqtt
 extern int8_t tsEnableMqttModule;
@@ -144,7 +134,6 @@ extern int8_t tsEnableStream;
 
 // internal
 extern int8_t  tsPrintAuth;
-extern int8_t  tscEmbedded;
 extern char    tsVnodeDir[];
 extern char    tsMnodeDir[];
 extern int64_t tsTickPerDay[3];
@@ -193,7 +182,7 @@ extern SDiskCfg tsDiskCfg[];
 #define NEEDTO_COMPRESSS_MSG(size) (tsCompressMsgSize != -1 && (size) > tsCompressMsgSize)
 
 void    taosInitGlobalCfg();
-int32_t taosCheckGlobalCfg();
+int32_t taosCheckAndPrintCfg();
 int32_t taosCfgDynamicOptions(char *msg);
 bool    taosCheckBalanceCfgOptions(const char *option, int32_t *vnodeId, int32_t *dnodeId);
 void    taosAddDataDir(int index, char *v1, int level, int primary);
diff --git a/include/dnode/mnode/sdb/sdb.h b/include/dnode/mnode/sdb/sdb.h
index 7e7afc9774..51d7ca7202 100644
--- a/include/dnode/mnode/sdb/sdb.h
+++ b/include/dnode/mnode/sdb/sdb.h
@@ -99,7 +99,7 @@ extern "C" {
       sdbFreeRaw(pRaw);                            \
       return NULL;                                 \
     }                                              \
-    dataPos += sizeof(int16_t);                     \
+    dataPos += sizeof(int16_t);                    \
   }
 
 #define SDB_SET_INT8(pRaw, dataPos, val)          \
@@ -144,9 +144,10 @@ typedef struct SSdbRow SSdbRow;
 typedef enum { SDB_KEY_BINARY = 1, SDB_KEY_INT32 = 2, SDB_KEY_INT64 = 3 } EKeyType;
 typedef enum {
   SDB_STATUS_CREATING = 1,
-  SDB_STATUS_READY = 2,
+  SDB_STATUS_UPDATING = 2,
   SDB_STATUS_DROPPING = 3,
-  SDB_STATUS_DROPPED = 4
+  SDB_STATUS_READY = 4,
+  SDB_STATUS_DROPPED = 5
 } ESdbStatus;
 
 typedef enum {
@@ -174,67 +175,19 @@ typedef SSdbRow *(*SdbDecodeFp)(SSdbRaw *pRaw);
 typedef SSdbRaw *(*SdbEncodeFp)(void *pObj);
 
 typedef struct {
-  /**
-   * @brief The sdb type of the table.
-   *
-   */
-  ESdbType sdbType;
-
-  /**
-   * @brief The key type of the table.
-   *
-   */
-  EKeyType keyType;
-
-  /**
-   * @brief The callback function when the table is first deployed.
-   *
-   */
+  ESdbType    sdbType;
+  EKeyType    keyType;
   SdbDeployFp deployFp;
-
-  /**
-   * @brief Encode one row of the table into rawdata.
-   *
-   */
   SdbEncodeFp encodeFp;
-
-  /**
-   * @brief Decode one row of the table from rawdata.
-   *
-   */
   SdbDecodeFp decodeFp;
-
-  /**
-   * @brief The callback function when insert a row to sdb.
-   *
-   */
   SdbInsertFp insertFp;
-
-  /**
-   * @brief The callback function when undate a row in sdb.
-   *
-   */
   SdbUpdateFp updateFp;
-
-  /**
-   * @brief The callback function when delete a row from sdb.
-   *
-   */
   SdbDeleteFp deleteFp;
 } SSdbTable;
 
 typedef struct SSdbOpt {
-  /**
-   * @brief The path of the sdb file.
-   *
-   */
   const char *path;
-
-  /**
-   * @brief The mnode object.
-   *
-   */
-  SMnode *pMnode;
+  SMnode     *pMnode;
 } SSdbOpt;
 
 /**
@@ -342,6 +295,15 @@ void sdbCancelFetch(SSdb *pSdb, void *pIter);
  */
 int32_t sdbGetSize(SSdb *pSdb, ESdbType type);
 
+/**
+ * @brief Get the max id of the table, keyType of table should be INT32
+ *
+ * @param pSdb The sdb object.
+ * @param pIter The type of the table.
+ * @record int32_t The max id of the table
+ */
+int32_t sdbGetMaxId(SSdb *pSdb, ESdbType type);
+
 SSdbRaw *sdbAllocRaw(ESdbType type, int8_t sver, int32_t dataLen);
 void     sdbFreeRaw(SSdbRaw *pRaw);
 int32_t  sdbSetRawInt8(SSdbRaw *pRaw, int32_t dataPos, int8_t val);
diff --git a/include/dnode/vnode/tsdb/tsdb.h b/include/dnode/vnode/tsdb/tsdb.h
index 26efce5d43..f8eac9768f 100644
--- a/include/dnode/vnode/tsdb/tsdb.h
+++ b/include/dnode/vnode/tsdb/tsdb.h
@@ -21,15 +21,14 @@ extern "C" {
 #endif
 
 // TYPES EXPOSED
-typedef struct STsdb             STsdb;
-typedef struct STsdbCfg          STsdbCfg;
-typedef struct STsdbMemAllocator STsdbMemAllocator;
+typedef struct STsdb    STsdb;
+typedef struct STsdbCfg STsdbCfg;
 
 // STsdb
-STsdb *tsdbOpen(const char *path, const STsdbCfg *);
+STsdb *tsdbOpen(const char *path, const STsdbCfg *pTsdbCfg);
 void   tsdbClose(STsdb *);
 void   tsdbRemove(const char *path);
-int    tsdbInsertData(STsdb *pTsdb, void *pData, int len);
+int    tsdbInsertData(STsdb *pTsdb, SSubmitMsg *pMsg);
 
 // STsdbCfg
 int  tsdbOptionsInit(STsdbCfg *);
@@ -41,7 +40,6 @@ struct STsdbCfg {
   uint32_t keep0;
   uint32_t keep1;
   uint32_t keep2;
-  /* TODO */
 };
 
 #ifdef __cplusplus
diff --git a/include/dnode/vnode/vnode.h b/include/dnode/vnode/vnode.h
index 007ce83812..8458ad9da3 100644
--- a/include/dnode/vnode/vnode.h
+++ b/include/dnode/vnode/vnode.h
@@ -68,9 +68,11 @@ typedef struct SVnodeCfg {
 /**
  * @brief Initialize the vnode module
  *
+ * @param nthreads number of commit threads. 0 for no threads and
+ *        a schedule queue should be given (TODO)
  * @return int 0 for success and -1 for failure
  */
-int vnodeInit();
+int vnodeInit(uint16_t nthreads);
 
 /**
  * @brief clear a vnode
diff --git a/include/libs/catalog/catalog.h b/include/libs/catalog/catalog.h
index 050b9c904f..f9d3b3c8c1 100644
--- a/include/libs/catalog/catalog.h
+++ b/include/libs/catalog/catalog.h
@@ -27,19 +27,20 @@ extern "C" {
 #include "transport.h"
 #include "common.h"
 #include "taosmsg.h"
+#include "query.h"
 
 struct SCatalog;
 
-typedef struct SMetaReq {
-  char    clusterId[TSDB_CLUSTER_ID_LEN];
+typedef struct SCatalogReq {
+  char    clusterId[TSDB_CLUSTER_ID_LEN];  //????
   SArray *pTableName;     // table full name
   SArray *pUdf;           // udf name
-  bool    qNodeEpset;     // valid qnode
-} SMetaReq;
+  bool    qNodeRequired;  // valid qnode
+} SCatalogReq;
 
 typedef struct SMetaData {
-  SArray    *pTableMeta;  // tableMeta
-  SArray    *pVgroupInfo; // vgroupInfo list
+  SArray    *pTableMeta;  // STableMeta array
+  SArray    *pVgroupInfo; // SVgroupInfo list
   SArray    *pUdfList;    // udf info list
   SEpSet    *pEpSet;      // qnode epset list
 } SMetaData;
@@ -78,32 +79,71 @@ typedef struct STableMeta {
   SSchema        schema[];
 } STableMeta;
 
+typedef struct SCatalogCfg {
+
+} SCatalogCfg;
+
+int32_t catalogInit(SCatalogCfg *cfg);
+
 /**
  * Catalog service object, which is utilized to hold tableMeta (meta/vgroupInfo/udfInfo) at the client-side.
  * There is ONLY one SCatalog object for one process space, and this function returns a singleton.
- * @param pMgmtEps
+ * @param clusterId
  * @return
  */
-struct SCatalog* getCatalogHandle(const SEpSet* pMgmtEps);
+int32_t catalogGetHandle(const char *clusterId, struct SCatalog** catalogHandle);
+
+
+
+int32_t catalogGetVgroupVersion(struct SCatalog* pCatalog, int32_t* version);
+int32_t catalogGetVgroup(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, SArray** pVgroupList);
+int32_t catalogUpdateVgroup(struct SCatalog* pCatalog, SVgroupListInfo* pVgroup);
+
+
+
+int32_t catalogGetDBVgroupVersion(struct SCatalog* pCatalog, const char* dbName, int32_t* version);
+int32_t catalogGetDBVgroup(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* dbName, int32_t forceUpdate, SDBVgroupInfo** dbInfo);
+int32_t catalogUpdateDBVgroup(struct SCatalog* pCatalog, const char* dbName, SDBVgroupInfo* dbInfo);
+
+
+int32_t catalogGetTableMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pTableName, STableMeta* pTableMeta);
+int32_t catalogRenewTableMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const STableMeta* pTableMeta);
+int32_t catalogRenewAndGetTableMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const STableMeta* pTableMeta, STableMeta* pNewTableMeta);
+
+
+/**
+ * get table's vgroup list.
+ * @param clusterId
+ * @pVgroupList  - array of SVgroupInfo
+ * @return
+ */
+int32_t catalogGetTableVgroup(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pTableName, SArray* pVgroupList);
+
 
 /**
  * Get the required meta data from mnode.
  * Note that this is a synchronized API and is also thread-safety.
  * @param pCatalog
+ * @param pMgmtEps
  * @param pMetaReq
  * @param pMetaData
  * @return
  */
-int32_t catalogGetMetaData(struct SCatalog* pCatalog, const SMetaReq* pMetaReq, SMetaData* pMetaData);
+int32_t catalogGetAllMeta(struct SCatalog* pCatalog, const SEpSet* pMgmtEps, const SCatalogReq* pReq, SMetaData* pRsp);
+
+
+int32_t catalogGetQnodeList(struct SCatalog* pCatalog, const SEpSet* pMgmtEps, SEpSet* pQnodeEpSet);
+
+
 
 /**
- * Destroy catalog service handle
+ * Destroy catalog and relase all resources
  * @param pCatalog
  */
-void destroyCatalog(struct SCatalog* pCatalog);
+void catalogDestroy(void);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /*_TD_CATALOG_H_*/
\ No newline at end of file
+#endif /*_TD_CATALOG_H_*/
diff --git a/include/libs/planner/planner.h b/include/libs/planner/planner.h
index 1ff3f02da5..8f217a0deb 100644
--- a/include/libs/planner/planner.h
+++ b/include/libs/planner/planner.h
@@ -22,6 +22,7 @@ extern "C" {
 
 #define QUERY_TYPE_MERGE       1
 #define QUERY_TYPE_PARTIAL     2
+#define QUERY_TYPE_SCAN        3
 
 enum OPERATOR_TYPE_E {
   OP_TableScan         = 1,
@@ -54,90 +55,37 @@ enum OPERATOR_TYPE_E {
 
 struct SEpSet;
 struct SQueryPlanNode;
-struct SQueryDistPlanNode;
+struct SPhyNode;
 struct SQueryStmtInfo;
 
-typedef struct SSubquery {
-  int64_t   queryId;            // the subquery id created by qnode
-  int32_t   type;               // QUERY_TYPE_MERGE|QUERY_TYPE_PARTIAL
-  int32_t   level;              // the execution level of current subquery, starting from 0.
-  SArray   *pUpstream;          // the upstream,from which to fetch the result
-  struct SQueryDistPlanNode *pNode;  // physical plan of current subquery
-} SSubquery;
-
-typedef struct SQueryJob {
-  SArray  **pSubqueries;
-  int32_t   numOfLevels;
-  int32_t   currentLevel;
-} SQueryJob;
+typedef struct SSubplan {
+  int32_t   type;               // QUERY_TYPE_MERGE|QUERY_TYPE_PARTIAL|QUERY_TYPE_SCAN
+  SArray   *pDatasource;          // the datasource subplan,from which to fetch the result
+  struct SPhyNode *pNode;  // physical plan of current subplan
+} SSubplan;
 
+typedef struct SQueryDag {
+  SArray  **pSubplans;
+} SQueryDag;
 
 /**
- * Optimize the query execution plan, currently not implement yet.
- * @param pQueryNode
- * @return
+ * Create the physical plan for the query, according to the AST.
  */
-int32_t qOptimizeQueryPlan(struct SQueryPlanNode* pQueryNode);
+int32_t qCreateQueryDag(const struct SQueryStmtInfo* pQueryInfo, struct SEpSet* pQnode, struct SQueryDag** pDag);
+
+int32_t qExplainQuery(const struct SQueryStmtInfo* pQueryInfo, struct SEpSet* pQnode, char** str);
 
 /**
- * Create the query plan according to the bound AST, which is in the form of pQueryInfo
- * @param pQueryInfo
- * @param pQueryNode
- * @return
+ * Convert to subplan to string for the scheduler to send to the executor
  */
-int32_t qCreateQueryPlan(const struct SQueryStmtInfo* pQueryInfo, struct SQueryPlanNode** pQueryNode);
-
-/**
- * Convert the query plan to string, in order to display it in the shell.
- * @param pQueryNode
- * @return
- */
-int32_t qQueryPlanToString(struct SQueryPlanNode* pQueryNode, char** str);
-
-/**
- * Restore the SQL statement according to the logic query plan.
- * @param pQueryNode
- * @param sql
- * @return
- */
-int32_t qQueryPlanToSql(struct SQueryPlanNode* pQueryNode, char** sql);
-
-/**
- * Create the physical plan for the query, according to the logic plan.
- * @param pQueryNode
- * @param pPhyNode
- * @return
- */
-int32_t qCreatePhysicalPlan(struct SQueryPlanNode* pQueryNode, struct SEpSet* pQnode, struct SQueryDistPlanNode *pPhyNode);
-
-/**
- * Convert to physical plan to string to enable to print it out in the shell.
- * @param pPhyNode
- * @param str
- * @return
- */
-int32_t qPhyPlanToString(struct SQueryDistPlanNode *pPhyNode, char** str);
-
-/**
- * Destroy the query plan object.
- * @return
- */
-void* qDestroyQueryPlan(struct SQueryPlanNode* pQueryNode);
+int32_t qSubPlanToString(struct SSubplan *pPhyNode, char** str);
 
 /**
  * Destroy the physical plan.
  * @param pQueryPhyNode
  * @return
  */
-void* qDestroyQueryPhyPlan(struct SQueryDistPlanNode* pQueryPhyNode);
-
-/**
- * Create the query job from the physical execution plan
- * @param pPhyNode
- * @param pJob
- * @return
- */
-int32_t qCreateQueryJob(const struct SQueryDistPlanNode* pPhyNode, struct SQueryJob** pJob);
+void* qDestroyQueryDag(struct SQueryDag* pDag);
 
 #ifdef __cplusplus
 }
diff --git a/include/libs/query/query.h b/include/libs/query/query.h
new file mode 100644
index 0000000000..02ae708874
--- /dev/null
+++ b/include/libs/query/query.h
@@ -0,0 +1,48 @@
+/*
+ * 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_QUERY_H_
+#define _TD_QUERY_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "tarray.h"
+
+typedef SVgroupListRspMsg SVgroupListInfo;
+
+typedef struct SDBVgroupInfo {
+  int32_t vgroupVersion;
+  SArray *vgId;
+  int32_t hashRange;
+} SDBVgroupInfo;
+
+typedef struct SUseDbOutput {
+  SVgroupListInfo *vgroupList;
+  char db[TSDB_TABLE_FNAME_LEN];
+  SDBVgroupInfo *dbVgroup;
+} SUseDbOutput;
+
+
+extern int32_t (*queryBuildMsg[TSDB_MSG_TYPE_MAX])(void* input, char **msg, int32_t msgSize, int32_t *msgLen);
+extern int32_t (*queryProcessMsgRsp[TSDB_MSG_TYPE_MAX])(void* output, char *msg, int32_t msgSize);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_QUERY_H_*/
diff --git a/include/libs/scheduler/scheduler.h b/include/libs/scheduler/scheduler.h
index d9653046cf..6b3c9ed021 100644
--- a/include/libs/scheduler/scheduler.h
+++ b/include/libs/scheduler/scheduler.h
@@ -20,7 +20,42 @@
 extern "C" {
 #endif
 
-struct SQueryJob;
+typedef struct SQueryProfileSummary {
+  int64_t startTs;      // Object created and added into the message queue
+  int64_t endTs;        // the timestamp when the task is completed
+  int64_t cputime;      // total cpu cost, not execute elapsed time
+
+  int64_t loadRemoteDataDuration;       // remote io time
+  int64_t loadNativeDataDuration;       // native disk io time
+
+  uint64_t loadNativeData; // blocks + SMA + header files
+  uint64_t loadRemoteData; // remote data acquired by exchange operator.
+
+  uint64_t waitDuration; // the time to waiting to be scheduled in queue does matter, so we need to record it
+  int64_t  addQTs;       // the time to be added into the message queue, used to calculate the waiting duration in queue.
+
+  uint64_t totalRows;
+  uint64_t loadRows;
+  uint32_t totalBlocks;
+  uint32_t loadBlocks;
+  uint32_t loadBlockAgg;
+  uint32_t skipBlocks;
+  uint64_t resultSize;   // generated result size in Kb.
+} SQueryProfileSummary;
+
+typedef struct SQueryTask {
+  uint64_t            queryId; // query id
+  uint64_t            taskId;  // task id
+  char     *pSubplan;   // operator tree
+  uint64_t            status;  // task status
+  SQueryProfileSummary summary; // task execution summary
+  void               *pOutputHandle; // result buffer handle, to temporarily keep the output result for next stage
+} SQueryTask;
+
+typedef struct SQueryJob {
+  SArray  **pSubtasks;
+  // todo
+} SQueryJob;
 
 /**
  * Process the query job, generated according to the query physical plan.
diff --git a/include/libs/transport/trpc.h b/include/libs/transport/trpc.h
index 2a8a7aad4b..2afd9d48b7 100644
--- a/include/libs/transport/trpc.h
+++ b/include/libs/transport/trpc.h
@@ -29,11 +29,6 @@ extern "C" {
 
 extern int tsRpcHeadSize;
 
-typedef struct SRpcCorEpSet {
-  int32_t version; 
-  SEpSet epSet; 
-} SRpcCorEpSet;
-
 typedef struct SRpcConnInfo {
   uint32_t  clientIp;
   uint16_t  clientPort;
diff --git a/include/os/osMemory.h b/include/os/osMemory.h
index 10c90cd9aa..5f1d5a9a8a 100644
--- a/include/os/osMemory.h
+++ b/include/os/osMemory.h
@@ -23,8 +23,8 @@ extern "C" {
 #define tfree(x)       \
   do {                 \
     if (x) {           \
-      free((void *)x); \
-      x = 0;           \
+      free((void *)(x)); \
+      (x) = 0;           \
     }                  \
   } while (0)
 
diff --git a/include/os/osSemaphore.h b/include/os/osSemaphore.h
index 86a9f10819..78112fc7a0 100644
--- a/include/os/osSemaphore.h
+++ b/include/os/osSemaphore.h
@@ -57,7 +57,7 @@ int64_t taosGetPthreadId(pthread_t thread);
 void    taosResetPthread(pthread_t* thread);
 bool    taosComparePthread(pthread_t first, pthread_t second);
 int32_t taosGetPId();
-int32_t taosGetCurrentAPPName(char* name, int32_t* len);
+int32_t taosGetAppName(char* name, int32_t* len);
 
 #ifdef __cplusplus
 }
diff --git a/include/util/taoserror.h b/include/util/taoserror.h
index 64a1fa84ad..4f1ef7da7b 100644
--- a/include/util/taoserror.h
+++ b/include/util/taoserror.h
@@ -117,72 +117,93 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_TSC_INVALID_JSON              TAOS_DEF_ERROR_CODE(0, 0x0221)  //"Invalid JSON format")
 #define TSDB_CODE_TSC_INVALID_JSON_TYPE         TAOS_DEF_ERROR_CODE(0, 0x0222)  //"Invalid JSON data type")
 #define TSDB_CODE_TSC_VALUE_OUT_OF_RANGE        TAOS_DEF_ERROR_CODE(0, 0x0223)  //"Value out of range")
+#define TSDB_CODE_TSC_INVALID_INPUT             TAOS_DEF_ERROR_CODE(0, 0X0224)  //"Invalid tsc input")
 
-// mnode
-#define TSDB_CODE_MND_MSG_NOT_PROCESSED         TAOS_DEF_ERROR_CODE(0, 0x0300)
-#define TSDB_CODE_MND_ACTION_IN_PROGRESS        TAOS_DEF_ERROR_CODE(0, 0x0301)
-#define TSDB_CODE_MND_ACTION_NEED_REPROCESSED   TAOS_DEF_ERROR_CODE(0, 0x0302)
-#define TSDB_CODE_MND_NO_RIGHTS                 TAOS_DEF_ERROR_CODE(0, 0x0303)
-#define TSDB_CODE_MND_INVALID_OPTIONS           TAOS_DEF_ERROR_CODE(0, 0x0304)
-#define TSDB_CODE_MND_INVALID_CONNECTION        TAOS_DEF_ERROR_CODE(0, 0x0305)
-#define TSDB_CODE_MND_INVALID_MSG_VERSION       TAOS_DEF_ERROR_CODE(0, 0x0306)
-#define TSDB_CODE_MND_INVALID_MSG_LEN           TAOS_DEF_ERROR_CODE(0, 0x0307)
-#define TSDB_CODE_MND_INVALID_MSG_TYPE          TAOS_DEF_ERROR_CODE(0, 0x0308)
-#define TSDB_CODE_MND_TOO_MANY_SHELL_CONNS      TAOS_DEF_ERROR_CODE(0, 0x0309)
-#define TSDB_CODE_MND_INVALID_SHOWOBJ           TAOS_DEF_ERROR_CODE(0, 0x030B)
-#define TSDB_CODE_MND_INVALID_QUERY_ID          TAOS_DEF_ERROR_CODE(0, 0x030C)
-#define TSDB_CODE_MND_INVALID_STREAM_ID         TAOS_DEF_ERROR_CODE(0, 0x030D)
-#define TSDB_CODE_MND_INVALID_CONN_ID           TAOS_DEF_ERROR_CODE(0, 0x030E)
-#define TSDB_CODE_MND_MNODE_IS_RUNNING          TAOS_DEF_ERROR_CODE(0, 0x0310)
-#define TSDB_CODE_MND_FAILED_TO_CONFIG_SYNC     TAOS_DEF_ERROR_CODE(0, 0x0311)
-#define TSDB_CODE_MND_FAILED_TO_START_SYNC      TAOS_DEF_ERROR_CODE(0, 0x0312)
-#define TSDB_CODE_MND_FAILED_TO_CREATE_DIR      TAOS_DEF_ERROR_CODE(0, 0x0313)
-#define TSDB_CODE_MND_FAILED_TO_INIT_STEP       TAOS_DEF_ERROR_CODE(0, 0x0314)
+// mnode-common
+#define TSDB_CODE_MND_NOT_READY                 TAOS_DEF_ERROR_CODE(0, 0x0300)
+#define TSDB_CODE_MND_MSG_NOT_PROCESSED         TAOS_DEF_ERROR_CODE(0, 0x0301)
+#define TSDB_CODE_MND_ACTION_IN_PROGRESS        TAOS_DEF_ERROR_CODE(0, 0x0302)
+#define TSDB_CODE_MND_ACTION_NEED_REPROCESSED   TAOS_DEF_ERROR_CODE(0, 0x0303)
+#define TSDB_CODE_MND_NO_RIGHTS                 TAOS_DEF_ERROR_CODE(0, 0x0304)
+#define TSDB_CODE_MND_INVALID_OPTIONS           TAOS_DEF_ERROR_CODE(0, 0x0305)
+#define TSDB_CODE_MND_INVALID_CONNECTION        TAOS_DEF_ERROR_CODE(0, 0x0306)
+#define TSDB_CODE_MND_INVALID_MSG_VERSION       TAOS_DEF_ERROR_CODE(0, 0x0307)
+#define TSDB_CODE_MND_INVALID_MSG_LEN           TAOS_DEF_ERROR_CODE(0, 0x0308)
+#define TSDB_CODE_MND_INVALID_MSG_TYPE          TAOS_DEF_ERROR_CODE(0, 0x0309)
+#define TSDB_CODE_MND_TOO_MANY_SHELL_CONNS      TAOS_DEF_ERROR_CODE(0, 0x030A)
 
-#define TSDB_CODE_SDB_APP_ERROR                 TAOS_DEF_ERROR_CODE(0, 0x0320)
-#define TSDB_CODE_SDB_OBJ_ALREADY_THERE         TAOS_DEF_ERROR_CODE(0, 0x0321)
-#define TSDB_CODE_SDB_OBJ_NOT_THERE             TAOS_DEF_ERROR_CODE(0, 0x0322)
-#define TSDB_CODE_SDB_OBJ_CREATING              TAOS_DEF_ERROR_CODE(0, 0x0323)
-#define TSDB_CODE_SDB_OBJ_DROPPING              TAOS_DEF_ERROR_CODE(0, 0x0324)
-#define TSDB_CODE_SDB_INVALID_TABLE_TYPE        TAOS_DEF_ERROR_CODE(0, 0x0325)
-#define TSDB_CODE_SDB_INVALID_KEY_TYPE          TAOS_DEF_ERROR_CODE(0, 0x0326)
-#define TSDB_CODE_SDB_INVALID_ACTION_TYPE       TAOS_DEF_ERROR_CODE(0, 0x0327)
-#define TSDB_CODE_SDB_INVALID_STATUS_TYPE       TAOS_DEF_ERROR_CODE(0, 0x0328)
-#define TSDB_CODE_SDB_INVALID_DATA_VER          TAOS_DEF_ERROR_CODE(0, 0x0329)
-#define TSDB_CODE_SDB_INVALID_DATA_LEN          TAOS_DEF_ERROR_CODE(0, 0x032A)
-#define TSDB_CODE_SDB_INVALID_DATA_CONTENT      TAOS_DEF_ERROR_CODE(0, 0x032B)
+// mnode-show
+#define TSDB_CODE_MND_INVALID_SHOWOBJ           TAOS_DEF_ERROR_CODE(0, 0x0310)
+
+// mnode-profile
+#define TSDB_CODE_MND_INVALID_QUERY_ID          TAOS_DEF_ERROR_CODE(0, 0x0320)
+#define TSDB_CODE_MND_INVALID_STREAM_ID         TAOS_DEF_ERROR_CODE(0, 0x0321)
+#define TSDB_CODE_MND_INVALID_CONN_ID           TAOS_DEF_ERROR_CODE(0, 0x0322)
+#define TSDB_CODE_MND_MNODE_IS_RUNNING          TAOS_DEF_ERROR_CODE(0, 0x0323)
+#define TSDB_CODE_MND_FAILED_TO_CONFIG_SYNC     TAOS_DEF_ERROR_CODE(0, 0x0324)
+#define TSDB_CODE_MND_FAILED_TO_START_SYNC      TAOS_DEF_ERROR_CODE(0, 0x0325)
+#define TSDB_CODE_MND_FAILED_TO_CREATE_DIR      TAOS_DEF_ERROR_CODE(0, 0x0326)
+#define TSDB_CODE_MND_FAILED_TO_INIT_STEP       TAOS_DEF_ERROR_CODE(0, 0x0327)
+
+// mnode-sdb
+#define TSDB_CODE_SDB_APP_ERROR                 TAOS_DEF_ERROR_CODE(0, 0x0330)
+#define TSDB_CODE_SDB_OBJ_ALREADY_THERE         TAOS_DEF_ERROR_CODE(0, 0x0331)
+#define TSDB_CODE_SDB_OBJ_NOT_THERE             TAOS_DEF_ERROR_CODE(0, 0x0332)
+#define TSDB_CODE_SDB_OBJ_CREATING              TAOS_DEF_ERROR_CODE(0, 0x0333)
+#define TSDB_CODE_SDB_OBJ_DROPPING              TAOS_DEF_ERROR_CODE(0, 0x0334)
+#define TSDB_CODE_SDB_INVALID_TABLE_TYPE        TAOS_DEF_ERROR_CODE(0, 0x0335)
+#define TSDB_CODE_SDB_INVALID_KEY_TYPE          TAOS_DEF_ERROR_CODE(0, 0x0336)
+#define TSDB_CODE_SDB_INVALID_ACTION_TYPE       TAOS_DEF_ERROR_CODE(0, 0x0337)
+#define TSDB_CODE_SDB_INVALID_STATUS_TYPE       TAOS_DEF_ERROR_CODE(0, 0x0338)
+#define TSDB_CODE_SDB_INVALID_DATA_VER          TAOS_DEF_ERROR_CODE(0, 0x0339)
+#define TSDB_CODE_SDB_INVALID_DATA_LEN          TAOS_DEF_ERROR_CODE(0, 0x033A)
+#define TSDB_CODE_SDB_INVALID_DATA_CONTENT      TAOS_DEF_ERROR_CODE(0, 0x033B)
 
 // mnode-dnode
-#define TSDB_CODE_MND_DNODE_ALREADY_EXIST       TAOS_DEF_ERROR_CODE(0, 0x0330)
-#define TSDB_CODE_MND_DNODE_NOT_EXIST           TAOS_DEF_ERROR_CODE(0, 0x0331)
-#define TSDB_CODE_MND_NO_ENOUGH_DNODES          TAOS_DEF_ERROR_CODE(0, 0x0332)
-#define TSDB_CODE_MND_INVALID_CLUSTER_CFG       TAOS_DEF_ERROR_CODE(0, 0x0333)
-#define TSDB_CODE_MND_INVALID_CLUSTER_ID        TAOS_DEF_ERROR_CODE(0, 0x0334)
-#define TSDB_CODE_MND_INVALID_DNODE_CFG         TAOS_DEF_ERROR_CODE(0, 0x0335)
-#define TSDB_CODE_MND_INVALID_DNODE_EP          TAOS_DEF_ERROR_CODE(0, 0x0336)
-#define TSDB_CODE_MND_INVALID_DNODE_ID          TAOS_DEF_ERROR_CODE(0, 0x0337)
+#define TSDB_CODE_MND_DNODE_ALREADY_EXIST       TAOS_DEF_ERROR_CODE(0, 0x0340)
+#define TSDB_CODE_MND_DNODE_NOT_EXIST           TAOS_DEF_ERROR_CODE(0, 0x0341)
+#define TSDB_CODE_MND_TOO_MANY_DNODES           TAOS_DEF_ERROR_CODE(0, 0x0342)
+#define TSDB_CODE_MND_NO_ENOUGH_DNODES          TAOS_DEF_ERROR_CODE(0, 0x0343)
+#define TSDB_CODE_MND_INVALID_CLUSTER_CFG       TAOS_DEF_ERROR_CODE(0, 0x0344)
+#define TSDB_CODE_MND_INVALID_CLUSTER_ID        TAOS_DEF_ERROR_CODE(0, 0x0345)
+#define TSDB_CODE_MND_INVALID_DNODE_CFG         TAOS_DEF_ERROR_CODE(0, 0x0346)
+#define TSDB_CODE_MND_INVALID_DNODE_EP          TAOS_DEF_ERROR_CODE(0, 0x0347)
+#define TSDB_CODE_MND_INVALID_DNODE_ID          TAOS_DEF_ERROR_CODE(0, 0x0348)
 
-// mnode-vgroup
-#define TSDB_CODE_MND_VGROUP_NOT_EXIST          TAOS_DEF_ERROR_CODE(0, 0x0332)  //"VGroup does not exist")
-#define TSDB_CODE_MND_VGROUP_NOT_IN_DNODE       TAOS_DEF_ERROR_CODE(0, 0x0338)  //"Vgroup not in dnode")
-#define TSDB_CODE_MND_VGROUP_ALREADY_IN_DNODE   TAOS_DEF_ERROR_CODE(0, 0x0339)  //"Vgroup already in dnode")
-#define TSDB_CODE_MND_NOT_READY                 TAOS_DEF_ERROR_CODE(0, 0x033C)  //"Cluster not ready")
+// mnode-mnode
+#define TSDB_CODE_MND_MNODE_ALREADY_EXIST       TAOS_DEF_ERROR_CODE(0, 0x0350)
+#define TSDB_CODE_MND_MNODE_NOT_EXIST           TAOS_DEF_ERROR_CODE(0, 0x0351)
+#define TSDB_CODE_MND_TOO_MANY_MNODES           TAOS_DEF_ERROR_CODE(0, 0x0352)
 
 // mnode-acct
-#define TSDB_CODE_MND_ACCT_ALREADY_EXIST        TAOS_DEF_ERROR_CODE(0, 0x0340)  //"Account already exists")
-#define TSDB_CODE_MND_ACCT_NOT_EXIST            TAOS_DEF_ERROR_CODE(0, 0x0341)  //"Invalid account")
-#define TSDB_CODE_MND_INVALID_ACCT_OPTION       TAOS_DEF_ERROR_CODE(0, 0x0342)  //"Invalid account options")
-#define TSDB_CODE_MND_ACCT_EXPIRED              TAOS_DEF_ERROR_CODE(0, 0x0343)  //"Account authorization has expired")
+#define TSDB_CODE_MND_ACCT_ALREADY_EXIST        TAOS_DEF_ERROR_CODE(0, 0x0360)
+#define TSDB_CODE_MND_ACCT_NOT_EXIST            TAOS_DEF_ERROR_CODE(0, 0x0361)
+#define TSDB_CODE_MND_TOO_MANY_ACCTS            TAOS_DEF_ERROR_CODE(0, 0x0362)
+#define TSDB_CODE_MND_INVALID_ACCT_OPTION       TAOS_DEF_ERROR_CODE(0, 0x0363)
+#define TSDB_CODE_MND_ACCT_EXPIRED              TAOS_DEF_ERROR_CODE(0, 0x0364)
 
-#define TSDB_CODE_MND_USER_ALREADY_EXIST        TAOS_DEF_ERROR_CODE(0, 0x0350)  //"User already exists")
-#define TSDB_CODE_MND_USER_NOT_EXIST            TAOS_DEF_ERROR_CODE(0, 0x0351)  //"Invalid user")
-#define TSDB_CODE_MND_INVALID_USER_FORMAT       TAOS_DEF_ERROR_CODE(0, 0x0352)  //"Invalid user format")
-#define TSDB_CODE_MND_INVALID_PASS_FORMAT       TAOS_DEF_ERROR_CODE(0, 0x0353)  //"Invalid password format")
-#define TSDB_CODE_MND_NO_USER_FROM_CONN         TAOS_DEF_ERROR_CODE(0, 0x0354)  //"Can not get user from conn")
-#define TSDB_CODE_MND_TOO_MANY_USERS            TAOS_DEF_ERROR_CODE(0, 0x0355)  //"Too many users")
+// mnode-user
+#define TSDB_CODE_MND_USER_ALREADY_EXIST        TAOS_DEF_ERROR_CODE(0, 0x0370)
+#define TSDB_CODE_MND_USER_NOT_EXIST            TAOS_DEF_ERROR_CODE(0, 0x0371)
+#define TSDB_CODE_MND_TOO_MANY_USERS            TAOS_DEF_ERROR_CODE(0, 0x0372)
+#define TSDB_CODE_MND_INVALID_USER_FORMAT       TAOS_DEF_ERROR_CODE(0, 0x0373)
+#define TSDB_CODE_MND_INVALID_PASS_FORMAT       TAOS_DEF_ERROR_CODE(0, 0x0374)
+#define TSDB_CODE_MND_NO_USER_FROM_CONN         TAOS_DEF_ERROR_CODE(0, 0x0375)
 
-#define TSDB_CODE_MND_MNODE_ALREADY_EXIST       TAOS_DEF_ERROR_CODE(0, 0x0348)  //"Mnode already exists")
-#define TSDB_CODE_MND_MNODE_NOT_EXIST           TAOS_DEF_ERROR_CODE(0, 0x0349)  //"Mnode not there")
+// mnode-db
+#define TSDB_CODE_MND_DB_ALREADY_EXIST          TAOS_DEF_ERROR_CODE(0, 0x0380)
+#define TSDB_CODE_MND_DB_NOT_EXIST              TAOS_DEF_ERROR_CODE(0, 0x0381) 
+#define TSDB_CODE_MND_TOO_MANY_DATABASES        TAOS_DEF_ERROR_CODE(0, 0x0382)
+#define TSDB_CODE_MND_DB_NOT_SELECTED           TAOS_DEF_ERROR_CODE(0, 0x0383)
+#define TSDB_CODE_MND_INVALID_DB                TAOS_DEF_ERROR_CODE(0, 0x0384)
+#define TSDB_CODE_MND_INVALID_DB_OPTION         TAOS_DEF_ERROR_CODE(0, 0x0385)
+#define TSDB_CODE_MND_INVALID_DB_ACCT           TAOS_DEF_ERROR_CODE(0, 0x0386)
+#define TSDB_CODE_MND_DB_OPTION_UNCHANGED       TAOS_DEF_ERROR_CODE(0, 0x0387)
+
+// mnode-vgroup
+#define TSDB_CODE_MND_VGROUP_NOT_EXIST          TAOS_DEF_ERROR_CODE(0, 0x0390)
+#define TSDB_CODE_MND_VGROUP_NOT_IN_DNODE       TAOS_DEF_ERROR_CODE(0, 0x0391)
+#define TSDB_CODE_MND_VGROUP_ALREADY_IN_DNODE   TAOS_DEF_ERROR_CODE(0, 0x0392)
 
 // mnode-stable
 #define TSDB_CODE_MND_STB_NOT_EXIST             TAOS_DEF_ERROR_CODE(0, 0x0360)
@@ -223,30 +244,6 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_MND_INVALID_TAG_LENGTH        TAOS_DEF_ERROR_CODE(0, 0x0376)  //"invalid tag length")
 #define TSDB_CODE_MND_INVALID_COLUMN_LENGTH     TAOS_DEF_ERROR_CODE(0, 0x0377)   //"invalid column length")
 
-#define TSDB_CODE_MND_DB_NOT_SELECTED           TAOS_DEF_ERROR_CODE(0, 0x0380)
-#define TSDB_CODE_MND_DB_NOT_EXIST              TAOS_DEF_ERROR_CODE(0, 0x0381) 
-#define TSDB_CODE_MND_DB_ALREADY_EXIST          TAOS_DEF_ERROR_CODE(0, 0x0381)
-#define TSDB_CODE_MND_INVALID_DB                TAOS_DEF_ERROR_CODE(0, 0x0383)
-#define TSDB_CODE_MND_INVALID_DB_OPTION         TAOS_DEF_ERROR_CODE(0, 0x0382)
-#define TSDB_CODE_MND_INVALID_DB_CACHE_SIZE     TAOS_DEF_ERROR_CODE(0, 0x0383)
-#define TSDB_CODE_MND_INVALID_DB_TOTAL_BLOCKS   TAOS_DEF_ERROR_CODE(0, 0x0383)
-#define TSDB_CODE_MND_INVALID_DB_DAYS           TAOS_DEF_ERROR_CODE(0, 0x0383)
-#define TSDB_CODE_MND_INVALID_DB_KEEP0          TAOS_DEF_ERROR_CODE(0, 0x0383)
-#define TSDB_CODE_MND_INVALID_DB_KEEP1          TAOS_DEF_ERROR_CODE(0, 0x0383)
-#define TSDB_CODE_MND_INVALID_DB_KEEP2          TAOS_DEF_ERROR_CODE(0, 0x0383)
-#define TSDB_CODE_MND_INVALID_DB_MIN_ROWS       TAOS_DEF_ERROR_CODE(0, 0x0383)
-#define TSDB_CODE_MND_INVALID_DB_MAX_ROWS       TAOS_DEF_ERROR_CODE(0, 0x0383)
-#define TSDB_CODE_MND_INVALID_DB_COMMIT_TIME    TAOS_DEF_ERROR_CODE(0, 0x0383)
-#define TSDB_CODE_MND_INVALID_DB_FSYNC_PERIOD   TAOS_DEF_ERROR_CODE(0, 0x0383)
-#define TSDB_CODE_MND_INVALID_DB_WAL_LEVEL      TAOS_DEF_ERROR_CODE(0, 0x0383)
-#define TSDB_CODE_MND_INVALID_DB_PRECISION      TAOS_DEF_ERROR_CODE(0, 0x0383)
-#define TSDB_CODE_MND_INVALID_DB_COMP           TAOS_DEF_ERROR_CODE(0, 0x0383)
-#define TSDB_CODE_MND_INVALID_DB_REPLICA        TAOS_DEF_ERROR_CODE(0, 0x0383)
-#define TSDB_CODE_MND_INVALID_DB_QUORUM         TAOS_DEF_ERROR_CODE(0, 0x0383)
-#define TSDB_CODE_MND_INVALID_DB_UPDATE         TAOS_DEF_ERROR_CODE(0, 0x0383)
-#define TSDB_CODE_MND_INVALID_DB_CACHE_LAST     TAOS_DEF_ERROR_CODE(0, 0x0383)
-#define TSDB_CODE_MND_DB_OPTION_UNCHANGED       TAOS_DEF_ERROR_CODE(0, 0x0383)
-#define TSDB_CODE_MND_TOO_MANY_DATABASES        TAOS_DEF_ERROR_CODE(0, 0x0385)  //"Too many databases for account")
 
 // dnode
 #define TSDB_CODE_DND_ACTION_IN_PROGRESS        TAOS_DEF_ERROR_CODE(0, 0x0400)
@@ -501,6 +498,13 @@ int32_t* taosGetErrno();
 // monitor
 #define TSDB_CODE_MON_CONNECTION_INVALID        TAOS_DEF_ERROR_CODE(0, 0x2300)  //"monitor invalid monitor db connection")
 
+// catalog
+#define TSDB_CODE_CTG_INTERNAL_ERROR            TAOS_DEF_ERROR_CODE(0, 0x2400)  //catalog interval error
+#define TSDB_CODE_CTG_INVALID_INPUT             TAOS_DEF_ERROR_CODE(0, 0x2401)  //invalid catalog input parameters
+#define TSDB_CODE_CTG_NOT_READY                 TAOS_DEF_ERROR_CODE(0, 0x2402)  //catalog is not ready
+#define TSDB_CODE_CTG_MEM_ERROR                 TAOS_DEF_ERROR_CODE(0, 0x2403)  //catalog memory error
+#define TSDB_CODE_CTG_SYS_ERROR                 TAOS_DEF_ERROR_CODE(0, 0x2404)  //catalog system error
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/util/tconfig.h b/include/util/tconfig.h
index 15100423d5..7dee01247b 100644
--- a/include/util/tconfig.h
+++ b/include/util/tconfig.h
@@ -20,7 +20,7 @@
 extern "C" {
 #endif
 
-#define TSDB_CFG_MAX_NUM    123
+#define TSDB_CFG_MAX_NUM    115
 #define TSDB_CFG_PRINT_LEN  23
 #define TSDB_CFG_OPTION_LEN 24
 #define TSDB_CFG_VALUE_LEN  41
@@ -83,11 +83,11 @@ extern int32_t    tsGlobalConfigNum;
 extern char *     tsCfgStatusStr[];
 
 void    taosReadGlobalLogCfg();
-int32_t taosReadGlobalCfg();
-void    taosPrintGlobalCfg();
+int32_t taosReadCfgFromFile();
+void    taosPrintCfg();
 void    taosDumpGlobalCfg();
 
-void        taosInitConfigOption(SGlobalCfg cfg);
+void        taosAddConfigOption(SGlobalCfg cfg);
 SGlobalCfg *taosGetConfigOption(const char *option);
 
 #ifdef __cplusplus
diff --git a/include/util/tdef.h b/include/util/tdef.h
index 28a1e24581..85b51b6eff 100644
--- a/include/util/tdef.h
+++ b/include/util/tdef.h
@@ -25,7 +25,9 @@ extern "C" {
 #define TSDB__packed
 
 #define TSKEY int64_t
-#define TSKEY_INITIAL_VAL    INT64_MIN
+#define TSKEY_MIN INT64_MIN
+#define TSKEY_MAX (INT64_MAX - 1)
+#define TSKEY_INITIAL_VAL TSKEY_MIN
 
 // Bytes for each type.
 extern const int32_t TYPE_BYTES[15];
@@ -161,7 +163,7 @@ do { \
 
 #define TSDB_NODE_NAME_LEN        64
 #define TSDB_TABLE_NAME_LEN       193     // it is a null-terminated string
-#define TSDB_DB_NAME_LEN          33
+#define TSDB_DB_NAME_LEN          65
 #define TSDB_FULL_DB_NAME_LEN     (TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN)
 
 #define TSDB_FUNC_NAME_LEN         65
@@ -193,7 +195,7 @@ do { \
 #define TSDB_MAX_TAG_CONDITIONS   1024
 
 #define TSDB_AUTH_LEN             16
-#define TSDB_KEY_LEN              16
+#define TSDB_PASSWORD_LEN         32
 #define TSDB_VERSION_LEN          12
 #define TSDB_LABEL_LEN            8 
 
@@ -209,6 +211,7 @@ do { \
 #define TSDB_STEP_NAME_LEN        32
 #define TSDB_STEP_DESC_LEN        128
 
+#define TSDB_ERROR_MSG_LEN        1024
 #define TSDB_DNODE_CONFIG_LEN     128
 
 #define TSDB_MQTT_HOSTNAME_LEN    64
diff --git a/include/util/tdlist.h b/include/util/tdlist.h
index a19f3bebec..d047a57770 100644
--- a/include/util/tdlist.h
+++ b/include/util/tdlist.h
@@ -58,8 +58,8 @@ extern "C" {
 // Double linked list
 #define TD_DLIST_NODE(TYPE) \
   struct {                  \
-    TYPE *dl_prev_;         \
-    TYPE *dl_next_;         \
+    struct TYPE *dl_prev_;         \
+    struct TYPE *dl_next_;         \
   }
 
 #define TD_DLIST(TYPE)      \
diff --git a/include/util/tlog.h b/include/util/tlog.h
index 2ee60e4324..9b6033e7fe 100644
--- a/include/util/tlog.h
+++ b/include/util/tlog.h
@@ -45,6 +45,8 @@ extern int32_t sDebugFlag;
 extern int32_t tsdbDebugFlag;
 extern int32_t cqDebugFlag;
 extern int32_t debugFlag;
+extern int32_t ctgDebugFlag;
+
 
 #define DEBUG_FATAL 1U
 #define DEBUG_ERROR DEBUG_FATAL
diff --git a/include/util/tmacro.h b/include/util/tmacro.h
index 74056cfe07..5cca8a1062 100644
--- a/include/util/tmacro.h
+++ b/include/util/tmacro.h
@@ -29,13 +29,11 @@ extern "C" {
 #define TD_MOD_UNCLEARD 0
 #define TD_MOD_CLEARD 1
 
-#define TD_DEF_MOD_INIT_FLAG(MOD) static int8_t MOD##InitFlag = TD_MOD_UNINITIALIZED
-#define TD_DEF_MOD_CLEAR_FLAG(MOD) static int8_t MOD##ClearFlag = TD_MOD_UNCLEARD
+typedef int8_t td_mode_flag_t;
 
-#define TD_CHECK_AND_SET_MODE_INIT(MOD) \
-  atomic_val_compare_exchange_8(&(MOD##InitFlag), TD_MOD_UNINITIALIZED, TD_MOD_INITIALIZED)
+#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(MOD) atomic_val_compare_exchange_8(&(MOD##ClearFlag), TD_MOD_UNCLEARD, TD_MOD_CLEARD)
+#define TD_CHECK_AND_SET_MOD_CLEAR(FLAG) atomic_val_compare_exchange_8((FLAG), TD_MOD_UNCLEARD, TD_MOD_CLEARD)
 
 #ifdef __cplusplus
 }
diff --git a/include/util/tutil.h b/include/util/tutil.h
index 3a07b898c0..c315948702 100644
--- a/include/util/tutil.h
+++ b/include/util/tutil.h
@@ -45,14 +45,25 @@ char    *taosIpStr(uint32_t ipInt);
 uint32_t ip2uint(const char *const ip_addr);
 void     taosIp2String(uint32_t ip, char *str);
 void     taosIpPort2String(uint32_t ip, uint16_t port, char *str);
-int32_t  taosGetFqdnPortFromEp(const char *ep, char *fqdn, uint16_t *port);
 
 static FORCE_INLINE void taosEncryptPass(uint8_t *inBuf, size_t inLen, char *target) {
   T_MD5_CTX context;
   tMD5Init(&context);
   tMD5Update(&context, inBuf, (unsigned int)inLen);
   tMD5Final(&context);
-  memcpy(target, context.digest, TSDB_KEY_LEN);
+  memcpy(target, context.digest, tListLen(context.digest));
+}
+
+static FORCE_INLINE void taosEncryptPass_c(uint8_t *inBuf, size_t len, char *target) {
+  T_MD5_CTX context;
+  tMD5Init(&context);
+  tMD5Update(&context, inBuf, (unsigned int)len);
+  tMD5Final(&context);
+
+  sprintf(target, "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", context.digest[0], context.digest[1], context.digest[2],
+          context.digest[3], context.digest[4], context.digest[5], context.digest[6], context.digest[7],
+          context.digest[8], context.digest[9], context.digest[10], context.digest[11], context.digest[12],
+          context.digest[13], context.digest[14], context.digest[15]);
 }
 
 #ifdef __cplusplus
diff --git a/source/client/CMakeLists.txt b/source/client/CMakeLists.txt
index bc0d439407..b46afa31b9 100644
--- a/source/client/CMakeLists.txt
+++ b/source/client/CMakeLists.txt
@@ -2,9 +2,14 @@ aux_source_directory(src CLIENT_SRC)
 add_library(taos ${CLIENT_SRC})
 target_include_directories(
     taos
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+        PUBLIC "${CMAKE_SOURCE_DIR}/include/client"
+        PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
 target_link_libraries(
     taos
+    PRIVATE common
     INTERFACE api
+    PRIVATE os util common transport parser
 )
+
+ADD_SUBDIRECTORY(test)
\ No newline at end of file
diff --git a/source/client/inc/clientInt.h b/source/client/inc/clientInt.h
new file mode 100644
index 0000000000..3180923aff
--- /dev/null
+++ b/source/client/inc/clientInt.h
@@ -0,0 +1,146 @@
+/*
+ * 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 TDENGINE_CLIENTINT_H
+#define TDENGINE_CLIENTINT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "taos.h"
+#include "taosmsg.h"
+#include "thash.h"
+#include "tlist.h"
+#include "trpc.h"
+#include "tdef.h"
+#include "tmsgtype.h"
+#include "tep.h"
+
+typedef struct SQueryExecMetric {
+  int64_t      start;    // start timestamp
+  int64_t      parsed;   // start to parse
+  int64_t      send;     // start to send to server
+  int64_t      rsp;      // receive response from server
+} SQueryExecMetric;
+
+typedef struct SInstanceActivity {
+  uint64_t     numOfInsertsReq;
+  uint64_t     numOfInsertRows;
+  uint64_t     insertElapsedTime;
+  uint64_t     insertBytes;         // submit to tsdb since launched.
+
+  uint64_t     fetchBytes;
+  uint64_t     queryElapsedTime;
+  uint64_t     numOfSlowQueries;
+  uint64_t     totalRequests;
+  uint64_t     currentRequests;      // the number of SRequestObj
+} SInstanceActivity;
+
+typedef struct SHeartBeatInfo {
+  void  *pTimer;   // timer, used to send request msg to mnode
+} SHeartBeatInfo;
+
+typedef struct SAppInstInfo {
+  int64_t           numOfConns;
+  SCorEpSet         mgmtEp;
+  SInstanceActivity summary;
+  SList            *pConnList;  // STscObj linked list
+  uint32_t          clusterId;
+  void             *pTransporter;
+} SAppInstInfo;
+
+typedef struct SAppInfo {
+  int64_t        startTime;
+  char           appName[TSDB_APP_NAME_LEN];
+  char          *ep;
+  int32_t        pid;
+  int32_t        numOfThreads;
+  SHeartBeatInfo hb;
+  SHashObj      *pInstMap;
+} SAppInfo;
+
+typedef struct STscObj {
+  char               user[TSDB_USER_LEN];
+  char               pass[TSDB_PASSWORD_LEN];
+  char               acctId[TSDB_ACCT_ID_LEN];
+  char               db[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN];
+  uint32_t           connId;
+  uint64_t           id;       // ref ID returned by taosAddRef
+//  struct SSqlObj    *sqlList;
+  void              *pTransporter;
+  pthread_mutex_t    mutex;     // used to protect the operation on db
+  int32_t            numOfReqs; // number of sqlObj from this tscObj
+  SAppInstInfo      *pAppInfo;
+} STscObj;
+
+typedef struct SReqBody {
+  tsem_t    rspSem;        // not used now
+  void*     fp;
+  void*     param;
+} SRequestBody;
+
+typedef struct SRequestObj {
+  uint64_t         requestId;
+  int32_t          type;   // request type
+  STscObj         *pTscObj;
+  SQueryExecMetric metric;
+  char            *sqlstr;  // sql string
+  SRequestBody     body;
+  int64_t          self;
+  char            *msgBuf;
+  int32_t          code;
+  void            *pInfo;   // sql parse info, generated by parser module
+} SRequestObj;
+
+typedef struct SRequestMsgBody {
+  int32_t  msgType;
+  void    *pData;
+  int32_t  msgLen;
+  uint64_t requestId;
+  uint64_t requestObjRefId;
+} SRequestMsgBody;
+
+extern SAppInfo   appInfo;
+extern int32_t    tscReqRef;
+extern void      *tscQhandle;
+extern int32_t    tscConnRef;
+
+extern int (*tscBuildMsg[TSDB_SQL_MAX])(SRequestObj *pRequest, SRequestMsgBody *pMsg);
+extern int (*handleRequestRspFp[TSDB_SQL_MAX])(SRequestObj *pRequest, const char* pMsg, int32_t msgLen);
+
+int   taos_init();
+
+void* createTscObj(const char* user, const char* auth, const char *ip, uint32_t port, SAppInstInfo* pAppInfo);
+void  destroyTscObj(void*pObj);
+
+void* createRequest(STscObj* pObj, __taos_async_fn_t fp, void* param, int32_t type);
+void destroyRequest(SRequestObj* pRequest);
+
+TAOS *taos_connect_internal(const char *ip, const char *user, const char *pass, const char *auth, const char *db, uint16_t port);
+
+void taos_init_imp(void);
+int taos_options_imp(TSDB_OPTION option, const char *str);
+
+void* openTransporter(const char *user, const char *auth);
+
+void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet);
+void initMsgHandleFp();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TDENGINE_CLIENTINT_H
diff --git a/source/client/inc/tscLog.h b/source/client/inc/tscLog.h
new file mode 100644
index 0000000000..f205a50227
--- /dev/null
+++ b/source/client/inc/tscLog.h
@@ -0,0 +1,37 @@
+/*
+ * 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 TDENGINE_TSCLOG_H
+#define TDENGINE_TSCLOG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "tlog.h"
+
+#define tscFatal(...)  do { if (cDebugFlag & DEBUG_FATAL) { taosPrintLog("TSC FATAL ", cDebugFlag, __VA_ARGS__); }} while(0)
+#define tscError(...)  do { if (cDebugFlag & DEBUG_ERROR) { taosPrintLog("TSC ERROR ", cDebugFlag, __VA_ARGS__); }} while(0)
+#define tscWarn(...)   do { if (cDebugFlag & DEBUG_WARN)  { taosPrintLog("TSC WARN ", cDebugFlag, __VA_ARGS__); }}  while(0)
+#define tscInfo(...)   do { if (cDebugFlag & DEBUG_INFO)  { taosPrintLog("TSC ", cDebugFlag, __VA_ARGS__); }} while(0)
+#define tscDebug(...)  do { if (cDebugFlag & DEBUG_DEBUG) { taosPrintLog("TSC ", cDebugFlag, __VA_ARGS__); }} while(0)
+#define tscTrace(...)  do { if (cDebugFlag & DEBUG_TRACE) { taosPrintLog("TSC ", cDebugFlag, __VA_ARGS__); }} while(0)
+#define tscDebugL(...) do { if (cDebugFlag & DEBUG_DEBUG) { taosPrintLongString("TSC ", cDebugFlag, __VA_ARGS__); }} while(0)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/source/client/src/client.c b/source/client/src/client.c
index b1663239e6..863e96aa74 100644
--- a/source/client/src/client.c
+++ b/source/client/src/client.c
@@ -13,11 +13,51 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-//#include "taos.h"
+#include "os.h"
+#include "tdef.h"
+#include "tglobal.h"
+#include "clientInt.h"
+#include "tscLog.h"
 
-//TAOS_RES *taos_query(TAOS *taos, const char *sql) {
-//
-//}
+TAOS *taos_connect(const char *ip, const char *user, const char *pass, const char *db, uint16_t port) {
+  int32_t p = (port != 0)? port:tsServerPort;
+
+  tscDebug("try to connect to %s:%u, user:%s db:%s", ip, p, user, db);
+  if (user == NULL) {
+    user = TSDB_DEFAULT_USER;
+  }
+
+  if (pass == NULL) {
+    pass = TSDB_DEFAULT_PASS;
+  }
+
+  return taos_connect_internal(ip, user, pass, NULL, db, p);
+}
+
+TAOS *taos_connect_auth(const char *ip, const char *user, const char *auth, const char *db, uint16_t port) {
+  tscDebug("try to connect to %s:%u by auth, user:%s db:%s", ip, port, user, db);
+  if (user == NULL) {
+    user = TSDB_DEFAULT_USER;
+  }
+
+  if (auth == NULL) {
+    tscError("No auth info is given, failed to connect to server");
+    return NULL;
+  }
+
+  return taos_connect_internal(ip, user, NULL, auth, db, port);
+}
+
+TAOS *taos_connect_l(const char *ip, int ipLen, const char *user, int userLen, const char *pass, int passLen, const char *db, int dbLen, uint16_t port) {
+  char ipStr[TSDB_EP_LEN]      = {0};
+  char dbStr[TSDB_DB_NAME_LEN] = {0};
+  char userStr[TSDB_USER_LEN]  = {0};
+  char passStr[TSDB_PASSWORD_LEN]   = {0};
+
+  strncpy(ipStr,   ip,   MIN(TSDB_EP_LEN - 1, ipLen));
+  strncpy(userStr, user, MIN(TSDB_USER_LEN - 1, userLen));
+  strncpy(passStr, pass, MIN(TSDB_PASSWORD_LEN - 1, passLen));
+  strncpy(dbStr,   db,   MIN(TSDB_DB_NAME_LEN - 1, dbLen));
+  return taos_connect(ipStr, userStr, passStr, dbStr, port);
+}
 
-int  taos_init() { return 0; }
-void taos_cleanup(void) {}
diff --git a/source/client/src/clientImpl.c b/source/client/src/clientImpl.c
new file mode 100644
index 0000000000..2ae79f1947
--- /dev/null
+++ b/source/client/src/clientImpl.c
@@ -0,0 +1,283 @@
+#include <tpagedfile.h>
+#include "clientInt.h"
+#include "tdef.h"
+#include "tep.h"
+#include "tglobal.h"
+#include "tmsgtype.h"
+#include "tref.h"
+#include "tscLog.h"
+
+static int32_t initEpSetFromCfg(const char *firstEp, const char *secondEp, SCorEpSet *pEpSet);
+static int32_t buildConnectMsg(SRequestObj *pRequest, SRequestMsgBody* pMsgBody);
+static void destroyConnectMsg(SRequestMsgBody* pMsgBody);
+
+static int32_t sendMsgToServer(void *pTransporter, SEpSet* epSet, const SRequestMsgBody *pBody, int64_t* pTransporterId);
+
+static bool stringLengthCheck(const char* str, size_t maxsize) {
+  if (str == NULL) {
+    return false;
+  }
+
+  size_t len = strlen(str);
+  if (len <= 0 || len > maxsize) {
+    return false;
+  }
+
+  return true;
+}
+
+static bool validateUserName(const char* user) {
+  return stringLengthCheck(user, TSDB_USER_LEN - 1);
+}
+
+static bool validatePassword(const char* passwd) {
+  return stringLengthCheck(passwd, TSDB_PASSWORD_LEN - 1);
+}
+
+static bool validateDbName(const char* db) {
+  return stringLengthCheck(db, TSDB_DB_NAME_LEN - 1);
+}
+
+static char* getClusterKey(const char* user, const char* auth, const char* ip, int32_t port) {
+  char key[512] = {0};
+  snprintf(key, sizeof(key), "%s:%s:%s:%d", user, auth, ip, port);
+  return strdup(key);
+}
+
+static STscObj* taosConnectImpl(const char *ip, const char *user, const char *auth, const char *db, uint16_t port, __taos_async_fn_t fp, void *param, SAppInstInfo* pAppInfo);
+
+TAOS *taos_connect_internal(const char *ip, const char *user, const char *pass, const char *auth, const char *db, uint16_t port) {
+  if (taos_init() != TSDB_CODE_SUCCESS) {
+    return NULL;
+  }
+
+  if (!validateUserName(user)) {
+    terrno = TSDB_CODE_TSC_INVALID_USER_LENGTH;
+    return NULL;
+  }
+
+  char tmp[TSDB_DB_NAME_LEN] = {0};
+  if (db != NULL) {
+    if(!validateDbName(db)) {
+      terrno = TSDB_CODE_TSC_INVALID_DB_LENGTH;
+      return NULL;
+    }
+
+    tstrncpy(tmp, db, sizeof(tmp));
+    strdequote(tmp);
+  }
+
+  char secretEncrypt[32] = {0};
+  if (auth == NULL) {
+    if (!validatePassword(pass)) {
+      terrno = TSDB_CODE_TSC_INVALID_PASS_LENGTH;
+      return NULL;
+    }
+
+    taosEncryptPass_c((uint8_t *)pass, strlen(pass), secretEncrypt);
+  } else {
+    tstrncpy(secretEncrypt, auth, tListLen(secretEncrypt));
+  }
+
+  SCorEpSet epSet = {0};
+  if (ip) {
+    if (initEpSetFromCfg(ip, NULL, &epSet) < 0) {
+      return NULL;
+    }
+
+    if (port) {
+      epSet.epSet.port[0] = port;
+    }
+  } else {
+    if (initEpSetFromCfg(tsFirst, tsSecond, &epSet) < 0) {
+      return NULL;
+    }
+  }
+
+  char* key = getClusterKey(user, secretEncrypt, ip, port);
+
+  SAppInstInfo* pInst = taosHashGet(appInfo.pInstMap, key, strlen(key));
+  if (pInst == NULL) {
+    pInst = calloc(1, sizeof(struct SAppInstInfo));
+
+    pInst->mgmtEp       = epSet;
+    pInst->pTransporter = openTransporter(user, secretEncrypt);
+
+    taosHashPut(appInfo.pInstMap, key, strlen(key), &pInst, POINTER_BYTES);
+  }
+
+  return taosConnectImpl(ip, user, &secretEncrypt[0], db, port, NULL, NULL, pInst);
+}
+
+int initEpSetFromCfg(const char *firstEp, const char *secondEp, SCorEpSet *pEpSet) {
+  pEpSet->version = 0;
+
+  // init mgmt ip set
+  SEpSet *mgmtEpSet   = &(pEpSet->epSet);
+  mgmtEpSet->numOfEps = 0;
+  mgmtEpSet->inUse    = 0;
+
+  if (firstEp && firstEp[0] != 0) {
+    if (strlen(firstEp) >= TSDB_EP_LEN) {
+      terrno = TSDB_CODE_TSC_INVALID_FQDN;
+      return -1;
+    }
+
+    taosGetFqdnPortFromEp(firstEp, mgmtEpSet->fqdn[0], &(mgmtEpSet->port[0]));
+    mgmtEpSet->numOfEps++;
+  }
+
+  if (secondEp && secondEp[0] != 0) {
+    if (strlen(secondEp) >= TSDB_EP_LEN) {
+      terrno = TSDB_CODE_TSC_INVALID_FQDN;
+      return -1;
+    }
+
+    taosGetFqdnPortFromEp(secondEp, mgmtEpSet->fqdn[mgmtEpSet->numOfEps], &(mgmtEpSet->port[mgmtEpSet->numOfEps]));
+    mgmtEpSet->numOfEps++;
+  }
+
+  if (mgmtEpSet->numOfEps == 0) {
+    terrno = TSDB_CODE_TSC_INVALID_FQDN;
+    return -1;
+  }
+
+  return 0;
+}
+
+STscObj* taosConnectImpl(const char *ip, const char *user, const char *auth, const char *db, uint16_t port, __taos_async_fn_t fp, void *param, SAppInstInfo* pAppInfo) {
+  STscObj *pTscObj = createTscObj(user, auth, ip, port, pAppInfo);
+  if (NULL == pTscObj) {
+    terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    return pTscObj;
+  }
+
+  SRequestObj *pRequest = createRequest(pTscObj, fp, param, TSDB_SQL_CONNECT);
+  if (pRequest == NULL) {
+    destroyTscObj(pTscObj);
+    terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    return NULL;
+  }
+
+  SRequestMsgBody body = {0};
+  buildConnectMsg(pRequest, &body);
+
+  int64_t transporterId = 0;
+  sendMsgToServer(pTscObj->pTransporter, &pTscObj->pAppInfo->mgmtEp.epSet, &body, &transporterId);
+
+  tsem_wait(&pRequest->body.rspSem);
+  destroyConnectMsg(&body);
+
+  if (pRequest->code != TSDB_CODE_SUCCESS) {
+    const char *errorMsg = (pRequest->code == TSDB_CODE_RPC_FQDN_ERROR) ? taos_errstr(pRequest) : tstrerror(terrno);
+    printf("failed to connect to server, reason: %s\n\n", errorMsg);
+
+    destroyRequest(pRequest);
+    taos_close(pTscObj);
+    pTscObj = NULL;
+  } else {
+    tscDebug("0x%"PRIx64" connection is opening, connId:%d, dnodeConn:%p", pTscObj->id, pTscObj->connId, pTscObj->pTransporter);
+    destroyRequest(pRequest);
+  }
+
+  return pTscObj;
+}
+
+static int32_t buildConnectMsg(SRequestObj *pRequest, SRequestMsgBody* pMsgBody) {
+  pMsgBody->msgType         = TSDB_MSG_TYPE_CONNECT;
+  pMsgBody->msgLen          = sizeof(SConnectMsg);
+  pMsgBody->requestObjRefId = pRequest->self;
+
+  SConnectMsg *pConnect = calloc(1, sizeof(SConnectMsg));
+  if (pConnect == NULL) {
+    terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    return -1;
+  }
+
+  // TODO refactor full_name
+  char *db;  // ugly code to move the space
+
+  STscObj *pObj = pRequest->pTscObj;
+  pthread_mutex_lock(&pObj->mutex);
+  db = strstr(pObj->db, TS_PATH_DELIMITER);
+
+  db = (db == NULL) ? pObj->db : db + 1;
+  tstrncpy(pConnect->db, db, sizeof(pConnect->db));
+  pthread_mutex_unlock(&pObj->mutex);
+
+  pConnect->pid = htonl(appInfo.pid);
+  pConnect->startTime = htobe64(appInfo.startTime);
+  tstrncpy(pConnect->app, appInfo.appName, tListLen(pConnect->app));
+
+  pMsgBody->pData = pConnect;
+  return 0;
+}
+
+static void destroyConnectMsg(SRequestMsgBody* pMsgBody) {
+  assert(pMsgBody != NULL);
+  tfree(pMsgBody->pData);
+}
+
+int32_t sendMsgToServer(void *pTransporter, SEpSet* epSet, const SRequestMsgBody *pBody, int64_t* pTransporterId) {
+  char *pMsg = rpcMallocCont(pBody->msgLen);
+  if (NULL == pMsg) {
+    tscError("0x%"PRIx64" msg:%s malloc failed", pBody->requestId, taosMsg[pBody->msgType]);
+    terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    return -1;
+  }
+
+  memcpy(pMsg, pBody->pData, pBody->msgLen);
+  SRpcMsg rpcMsg = {
+      .msgType = pBody->msgType,
+      .pCont   = pMsg,
+      .contLen = pBody->msgLen,
+      .ahandle = (void*) pBody->requestObjRefId,
+      .handle  = NULL,
+      .code    = 0
+  };
+
+  rpcSendRequest(pTransporter, epSet, &rpcMsg, pTransporterId);
+  return TSDB_CODE_SUCCESS;
+}
+
+void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) {
+  int64_t requestRefId = (int64_t)pMsg->ahandle;
+
+  SRequestObj *pRequest = (SRequestObj *)taosAcquireRef(tscReqRef, requestRefId);
+  if (pRequest == NULL) {
+    rpcFreeCont(pMsg->pCont);
+    return;
+  }
+
+  assert(pRequest->self == requestRefId);
+  pRequest->metric.rsp = taosGetTimestampMs();
+
+  pRequest->code = pMsg->code;
+
+  STscObj *pTscObj = pRequest->pTscObj;
+  if (pEpSet) {
+    if (!isEpsetEqual(&pTscObj->pAppInfo->mgmtEp.epSet, pEpSet)) {
+      updateEpSet_s(&pTscObj->pAppInfo->mgmtEp, pEpSet);
+    }
+  }
+
+  /*
+   * There is not response callback function for submit response.
+   * The actual inserted number of points is the first number.
+   */
+  if (pMsg->code == TSDB_CODE_SUCCESS) {
+    tscDebug("0x%" PRIx64 " message:%s, code:%s rspLen:%d, elapsed:%"PRId64 " ms", pRequest->requestId, taosMsg[pMsg->msgType],
+             tstrerror(pMsg->code), pMsg->contLen, pRequest->metric.rsp - pRequest->metric.start);
+    if (handleRequestRspFp[pRequest->type]) {
+      pMsg->code = (*handleRequestRspFp[pRequest->type])(pRequest, pMsg->pCont, pMsg->contLen);
+    }
+  } else {
+    tscError("0x%" PRIx64 " SQL cmd:%s, code:%s rspLen:%d", pRequest->requestId, taosMsg[pMsg->msgType],
+             tstrerror(pMsg->code), pMsg->contLen);
+  }
+
+  taosReleaseRef(tscReqRef, requestRefId);
+  rpcFreeCont(pMsg->pCont);
+
+  sem_post(&pRequest->body.rspSem);
+}
diff --git a/source/client/src/clientMsgHandler.c b/source/client/src/clientMsgHandler.c
new file mode 100644
index 0000000000..62466a096d
--- /dev/null
+++ b/source/client/src/clientMsgHandler.c
@@ -0,0 +1,3212 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "os.h"
+#include "clientInt.h"
+#include "tmsgtype.h"
+#include "trpc.h"
+#include "tscLog.h"
+
+int (*buildRequestMsgFp[TSDB_SQL_MAX])(SRequestObj *pRequest, SRequestMsgBody *pMsgBody) = {0};
+int (*handleRequestRspFp[TSDB_SQL_MAX])(SRequestObj *pRequest, const char* pMsg, int32_t msgLen);
+
+#if 0
+void tscProcessActivityTimer(void *handle, void *tmrId);
+
+static int32_t extractSTableQueryVgroupId(STableMetaInfo* pTableMetaInfo);
+
+static int32_t minMsgSize() { return tsRpcHeadSize + 100; }
+static int32_t getWaitingTimeInterval(int32_t count) {
+  int32_t initial = 100; // 100 ms by default
+  if (count <= 1) {
+    return 0;
+  }
+
+  return initial * ((2u)<<(count - 2));
+}
+
+static int32_t vgIdCompare(const void *lhs, const void *rhs) {
+  int32_t left = *(int32_t *)lhs;
+  int32_t right = *(int32_t *)rhs;
+
+  if (left == right) {
+    return 0;
+  } else {
+    return left > right ? 1 : -1;
+  }
+}
+static int32_t removeDupVgid(int32_t *src, int32_t sz) {
+  if (src == NULL || sz <= 0) {
+    return 0;
+  }
+  qsort(src, sz, sizeof(src[0]), vgIdCompare);
+
+  int32_t ret = 1;
+  for (int i = 1; i < sz; i++) {
+    if (src[i] != src[i - 1]) {
+      src[ret++] = src[i];
+    }
+  }
+  return ret;
+}
+
+static void tscSetDnodeEpSet(SRpcEpSet* pEpSet, SVgroupMsg* pVgroupInfo) {
+  assert(pEpSet != NULL && pVgroupInfo != NULL && pVgroupInfo->numOfEps > 0);
+
+  // Issue the query to one of the vnode among a vgroup randomly.
+  // change the inUse property would not affect the isUse attribute of STableMeta
+  pEpSet->inUse = rand() % pVgroupInfo->numOfEps;
+
+  // apply the FQDN string length check here
+  bool existed = false;
+
+  pEpSet->numOfEps = pVgroupInfo->numOfEps;
+  for(int32_t i = 0; i < pVgroupInfo->numOfEps; ++i) {
+    pEpSet->port[i] = pVgroupInfo->epAddr[i].port;
+
+    int32_t len = (int32_t) strnlen(pVgroupInfo->epAddr[i].fqdn, TSDB_FQDN_LEN);
+    if (len > 0) {
+      tstrncpy(pEpSet->fqdn[i], pVgroupInfo->epAddr[i].fqdn, tListLen(pEpSet->fqdn[i]));
+      existed = true;
+    }
+  }
+
+  assert(existed);
+}
+
+static void tscDumpMgmtEpSet(SSqlObj *pSql) {
+  SCorEpSet *pCorEpSet = pSql->pTscObj->tscCorMgmtEpSet;
+  taosCorBeginRead(&pCorEpSet->version);
+  pSql->epSet = pCorEpSet->epSet;
+  taosCorEndRead(&pCorEpSet->version);
+}
+static void tscEpSetHtons(SRpcEpSet *s) {
+  for (int32_t i = 0; i < s->numOfEps; i++) {
+    s->port[i] = htons(s->port[i]);
+  }
+}
+
+bool tscEpSetIsEqual(SRpcEpSet *s1, SRpcEpSet *s2) {
+  if (s1->numOfEps != s2->numOfEps || s1->inUse != s2->inUse) {
+    return false;
+  }
+
+  for (int32_t i = 0; i < s1->numOfEps; i++) {
+    if (s1->port[i] != s2->port[i]
+        || strncmp(s1->fqdn[i], s2->fqdn[i], TSDB_FQDN_LEN) != 0)
+      return false;
+  }
+  return true;
+}
+
+void tscUpdateMgmtEpSet(SSqlObj *pSql, SRpcEpSet *pEpSet) {
+  // no need to update if equal
+  SCorEpSet *pCorEpSet = pSql->pTscObj->tscCorMgmtEpSet;
+  taosCorBeginWrite(&pCorEpSet->version);
+  pCorEpSet->epSet = *pEpSet;
+  taosCorEndWrite(&pCorEpSet->version);
+}
+
+static void tscDumpEpSetFromVgroupInfo(SRpcEpSet *pEpSet, SNewVgroupInfo *pVgroupInfo) {
+  if (pVgroupInfo == NULL) { return;}
+  int8_t inUse = pVgroupInfo->inUse;
+  pEpSet->inUse = (inUse >= 0 && inUse < TSDB_MAX_REPLICA) ? inUse: 0;
+  pEpSet->numOfEps = pVgroupInfo->numOfEps;
+  for (int32_t i = 0; i < pVgroupInfo->numOfEps; ++i) {
+    tstrncpy(pEpSet->fqdn[i], pVgroupInfo->ep[i].fqdn, sizeof(pEpSet->fqdn[i]));
+    pEpSet->port[i] = pVgroupInfo->ep[i].port;
+  }
+}
+
+static void tscUpdateVgroupInfo(SSqlObj *pSql, SRpcEpSet *pEpSet) {
+  SSqlCmd *pCmd = &pSql->cmd;
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
+  if (pTableMetaInfo == NULL || pTableMetaInfo->pTableMeta == NULL) {
+    return;
+  }
+
+  int32_t vgId = -1;
+  if (pTableMetaInfo->pTableMeta->tableType == TSDB_SUPER_TABLE) {
+    vgId = extractSTableQueryVgroupId(pTableMetaInfo);
+  } else {
+    vgId = pTableMetaInfo->pTableMeta->vgId;
+  }
+
+  assert(vgId > 0);
+
+  SNewVgroupInfo vgroupInfo = {.vgId = -1};
+  taosHashGetClone(tscVgroupMap, &vgId, sizeof(vgId), NULL, &vgroupInfo);
+  assert(vgroupInfo.numOfEps > 0 && vgroupInfo.vgId > 0);
+
+  tscDebug("before: Endpoint in use:%d, numOfEps:%d", vgroupInfo.inUse, vgroupInfo.numOfEps);
+  vgroupInfo.inUse    = pEpSet->inUse;
+  vgroupInfo.numOfEps = pEpSet->numOfEps;
+  for (int32_t i = 0; i < vgroupInfo.numOfEps; i++) {
+    tstrncpy(vgroupInfo.ep[i].fqdn, pEpSet->fqdn[i], TSDB_FQDN_LEN);
+    vgroupInfo.ep[i].port = pEpSet->port[i];
+  }
+
+  tscDebug("after: EndPoint in use:%d, numOfEps:%d", vgroupInfo.inUse, vgroupInfo.numOfEps);
+  taosHashPut(tscVgroupMap, &vgId, sizeof(vgId), &vgroupInfo, sizeof(SNewVgroupInfo));
+
+  // Update the local cached epSet info cached by SqlObj
+  int32_t inUse = pSql->epSet.inUse;
+  tscDumpEpSetFromVgroupInfo(&pSql->epSet, &vgroupInfo);
+  tscDebug("0x%"PRIx64" update the epSet in SqlObj, in use before:%d, after:%d", pSql->self, inUse, pSql->epSet.inUse);
+
+}
+
+int32_t extractSTableQueryVgroupId(STableMetaInfo* pTableMetaInfo) {
+  assert(pTableMetaInfo != NULL);
+
+  int32_t vgIndex = pTableMetaInfo->vgroupIndex;
+  int32_t vgId = -1;
+
+  if (pTableMetaInfo->pVgroupTables == NULL) {
+    SVgroupsInfo *pVgroupInfo = pTableMetaInfo->vgroupList;
+    assert(pVgroupInfo->vgroups[vgIndex].vgId > 0 && vgIndex < pTableMetaInfo->vgroupList->numOfVgroups);
+    vgId = pVgroupInfo->vgroups[vgIndex].vgId;
+  } else {
+    int32_t numOfVgroups = (int32_t)taosArrayGetSize(pTableMetaInfo->pVgroupTables);
+    assert(vgIndex >= 0 && vgIndex < numOfVgroups);
+
+    SVgroupTableInfo *pTableIdList = taosArrayGet(pTableMetaInfo->pVgroupTables, vgIndex);
+    vgId = pTableIdList->vgInfo.vgId;
+  }
+
+  return vgId;
+}
+
+void tscProcessHeartBeatRsp(void *param, TAOS_RES *tres, int code) {
+  STscObj *pObj = (STscObj *)param;
+  if (pObj == NULL) return;
+
+  if (pObj != pObj->signature) {
+    tscError("heartbeat msg, pObj:%p, signature:%p invalid", pObj, pObj->signature);
+    return;
+  }
+
+  SSqlObj *pSql = tres;
+  SSqlRes *pRes = &pSql->res;
+
+  if (code == TSDB_CODE_SUCCESS) {
+    SHeartBeatRsp *pRsp = (SHeartBeatRsp *)pRes->pRsp;
+    SRpcEpSet     *epSet = &pRsp->epSet;
+    if (epSet->numOfEps > 0) {
+      tscEpSetHtons(epSet);
+
+      //SCorEpSet *pCorEpSet = pSql->pTscObj->tscCorMgmtEpSet;
+      //if (!tscEpSetIsEqual(&pCorEpSet->epSet, epSet)) {
+      //  tscTrace("%p updating epset: numOfEps: %d, inUse: %d", pSql, epSet->numOfEps, epSet->inUse);
+      //  for (int8_t i = 0; i < epSet->numOfEps; i++) {
+      //    tscTrace("endpoint %d: fqdn=%s, port=%d", i, epSet->fqdn[i], epSet->port[i]);
+      //  }
+      //}
+      //concurrency problem, update mgmt epset anyway
+      tscUpdateMgmtEpSet(pSql, epSet);
+    }
+
+    pSql->pTscObj->connId = htonl(pRsp->connId);
+
+    if (pRsp->killConnection) {
+      tscKillConnection(pObj);
+      return;
+    } else {
+      if (pRsp->queryId) {
+        tscKillQuery(pObj, htonl(pRsp->queryId));
+      }
+
+      if (pRsp->streamId) {
+        tscKillStream(pObj, htonl(pRsp->streamId));
+      }
+    }
+
+    int32_t total  = htonl(pRsp->totalDnodes);
+    int32_t online = htonl(pRsp->onlineDnodes);
+    assert(online <= total);
+
+    if (online < total) {
+      tscError("0x%"PRIx64", HB, total dnode:%d, online dnode:%d", pSql->self, total, online);
+      pSql->res.code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
+    }
+
+    if (pRes->length == NULL) {
+      pRes->length = calloc(2,  sizeof(int32_t));
+    }
+
+    pRes->length[0] = total;
+    pRes->length[1] = online;
+  } else {
+    tscDebug("%" PRId64 " heartbeat failed, code:%s", pObj->hbrid, tstrerror(code));
+    if (pRes->length == NULL) {
+      pRes->length = calloc(2, sizeof(int32_t));
+    }
+
+    pRes->length[1] = 0;
+    if (pRes->length[0] == 0) {
+      pRes->length[0] = 1; // make sure that the value of the total node is greater than the online node
+    }
+  }
+
+  if (pObj->hbrid != 0) {
+    int32_t waitingDuring = tsShellActivityTimer * 500;
+    tscDebug("0x%"PRIx64" send heartbeat in %dms", pSql->self, waitingDuring);
+
+    taosTmrReset(tscProcessActivityTimer, waitingDuring, (void *)pObj->rid, tscTmr, &pObj->pTimer);
+  } else {
+    tscDebug("0x%"PRIx64" start to close tscObj:%p, not send heartbeat again", pSql->self, pObj);
+  }
+}
+
+void tscProcessActivityTimer(void *handle, void *tmrId) {
+  int64_t rid = (int64_t) handle;
+  STscObj *pObj = taosAcquireRef(tscRefId, rid);
+  if (pObj == NULL) {
+    return;
+  }
+
+  SSqlObj* pHB = taosAcquireRef(tscObjRef, pObj->hbrid);
+  if (pHB == NULL) {
+    taosReleaseRef(tscRefId, rid);
+    return;
+  }
+
+  assert(pHB->self == pObj->hbrid);
+
+  pHB->retry = 0;
+  int32_t code = tscBuildAndSendRequest(pHB, NULL);
+  taosReleaseRef(tscObjRef, pObj->hbrid);
+
+  if (code != TSDB_CODE_SUCCESS) {
+    tscError("0x%"PRIx64" failed to sent HB to server, reason:%s", pHB->self, tstrerror(code));
+  }
+
+  taosReleaseRef(tscRefId, rid);
+}
+
+int tscSendMsgToServer(SSqlObj *pSql) {
+  STscObj* pObj = pSql->pTscObj;
+  SSqlCmd* pCmd = &pSql->cmd;
+
+  char *pMsg = rpcMallocCont(pCmd->payloadLen);
+  if (NULL == pMsg) {
+    tscError("0x%"PRIx64" msg:%s malloc failed", pSql->self, taosMsg[pSql->cmd.msgType]);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  // set the mgmt ip list
+  if (pSql->cmd.command >= TSDB_SQL_MGMT) {
+    tscDumpMgmtEpSet(pSql);
+  }
+
+  memcpy(pMsg, pSql->cmd.payload, pSql->cmd.payloadLen);
+
+  SRpcMsg rpcMsg = {
+      .msgType = pSql->cmd.msgType,
+      .pCont   = pMsg,
+      .contLen = pSql->cmd.payloadLen,
+      .ahandle = (void*)pSql->self,
+      .handle  = NULL,
+      .code    = 0
+  };
+
+  rpcSendRequest(pObj->pRpcObj->pDnodeConn, &pSql->epSet, &rpcMsg, &pSql->rpcRid);
+  return TSDB_CODE_SUCCESS;
+}
+
+// handle three situation
+// 1. epset retry, only return last failure ep
+// 2. no epset retry, like 'taos -h invalidFqdn', return invalidFqdn
+// 3. other situation, no expected
+void tscSetFqdnErrorMsg(SSqlObj* pSql, SRpcEpSet* pEpSet) {
+  SSqlCmd* pCmd = &pSql->cmd;
+  SSqlRes* pRes = &pSql->res;
+
+  char* msgBuf = tscGetErrorMsgPayload(pCmd);
+
+  if (pEpSet) {
+    sprintf(msgBuf, "%s\"%s\"", tstrerror(pRes->code),pEpSet->fqdn[(pEpSet->inUse)%(pEpSet->numOfEps)]);
+  } else if (pCmd->command >= TSDB_SQL_MGMT) {
+    SRpcEpSet tEpset;
+
+    SCorEpSet *pCorEpSet = pSql->pTscObj->tscCorMgmtEpSet;
+    taosCorBeginRead(&pCorEpSet->version);
+    tEpset = pCorEpSet->epSet;
+    taosCorEndRead(&pCorEpSet->version);
+
+    sprintf(msgBuf, "%s\"%s\"", tstrerror(pRes->code),tEpset.fqdn[(tEpset.inUse)%(tEpset.numOfEps)]);
+  } else {
+    sprintf(msgBuf, "%s", tstrerror(pRes->code));
+  }
+}
+
+void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcEpSet *pEpSet) {
+  TSDB_CACHE_PTR_TYPE handle = (TSDB_CACHE_PTR_TYPE) rpcMsg->ahandle;
+  SSqlObj* pSql = (SSqlObj*)taosAcquireRef(tscObjRef, handle);
+  if (pSql == NULL) {
+    rpcFreeCont(rpcMsg->pCont);
+    return;
+  }
+
+  assert(pSql->self == handle);
+
+  STscObj *pObj = pSql->pTscObj;
+  SSqlRes *pRes = &pSql->res;
+  SSqlCmd *pCmd = &pSql->cmd;
+
+  pSql->rpcRid = -1;
+  if (pObj->signature != pObj) {
+    tscDebug("0x%"PRIx64" DB connection is closed, cmd:%d pObj:%p signature:%p", pSql->self, pCmd->command, pObj, pObj->signature);
+
+    taosRemoveRef(tscObjRef, handle);
+    taosReleaseRef(tscObjRef, handle);
+    rpcFreeCont(rpcMsg->pCont);
+    return;
+  }
+
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
+  if (pQueryInfo != NULL && pQueryInfo->type == TSDB_QUERY_TYPE_FREE_RESOURCE) {
+    tscDebug("0x%"PRIx64" sqlObj needs to be released or DB connection is closed, cmd:%d type:%d, pObj:%p signature:%p",
+        pSql->self, pCmd->command, pQueryInfo->type, pObj, pObj->signature);
+
+    taosRemoveRef(tscObjRef, handle);
+    taosReleaseRef(tscObjRef, handle);
+    rpcFreeCont(rpcMsg->pCont);
+    return;
+  }
+
+  if (pEpSet) {
+    if (!tscEpSetIsEqual(&pSql->epSet, pEpSet)) {
+      if (pCmd->command < TSDB_SQL_MGMT) {
+        tscUpdateVgroupInfo(pSql, pEpSet);
+      } else {
+        tscUpdateMgmtEpSet(pSql, pEpSet);
+      }
+    }
+  }
+
+  int32_t cmd = pCmd->command;
+
+  // set the flag to denote that sql string needs to be re-parsed and build submit block with table schema
+  if (cmd == TSDB_SQL_INSERT && rpcMsg->code == TSDB_CODE_TDB_TABLE_RECONFIGURE) {
+    pSql->cmd.insertParam.schemaAttached = 1;
+  }
+
+  // single table query error need to be handled here.
+  if ((cmd == TSDB_SQL_SELECT || cmd == TSDB_SQL_UPDATE_TAGS_VAL) &&
+      (((rpcMsg->code == TSDB_CODE_TDB_INVALID_TABLE_ID || rpcMsg->code == TSDB_CODE_VND_INVALID_VGROUP_ID)) ||
+       rpcMsg->code == TSDB_CODE_RPC_NETWORK_UNAVAIL || rpcMsg->code == TSDB_CODE_APP_NOT_READY)) {
+
+    // 1. super table subquery
+    // 2. nest queries are all not updated the tablemeta and retry parse the sql after cleanup local tablemeta/vgroup id buffer
+    if ((TSDB_QUERY_HAS_TYPE(pQueryInfo->type, (TSDB_QUERY_TYPE_STABLE_SUBQUERY | TSDB_QUERY_TYPE_SUBQUERY |
+                                                TSDB_QUERY_TYPE_TAG_FILTER_QUERY)) &&
+         !TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_PROJECTION_QUERY)) ||
+        (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_NEST_SUBQUERY)) || (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_STABLE_SUBQUERY) &&  pQueryInfo->distinct)) {
+      // do nothing in case of super table subquery
+    }  else {
+      pSql->retry += 1;
+      tscWarn("0x%" PRIx64 " it shall renew table meta, code:%s, retry:%d", pSql->self, tstrerror(rpcMsg->code), pSql->retry);
+
+      pSql->res.code = rpcMsg->code;  // keep the previous error code
+      if (pSql->retry > pSql->maxRetry) {
+        tscError("0x%" PRIx64 " max retry %d reached, give up", pSql->self, pSql->maxRetry);
+      } else {
+        // wait for a little bit moment and then retry
+        // todo do not sleep in rpc callback thread, add this process into queue to process
+        if (rpcMsg->code == TSDB_CODE_APP_NOT_READY || rpcMsg->code == TSDB_CODE_VND_INVALID_VGROUP_ID) {
+          int32_t duration = getWaitingTimeInterval(pSql->retry);
+          taosMsleep(duration);
+        }
+
+        pSql->retryReason = rpcMsg->code;
+        rpcMsg->code = tscRenewTableMeta(pSql, 0);
+        // if there is an error occurring, proceed to the following error handling procedure.
+        if (rpcMsg->code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+          taosReleaseRef(tscObjRef, handle);
+          rpcFreeCont(rpcMsg->pCont);
+          return;
+        }
+      }
+    }
+  }
+
+  pRes->rspLen = 0;
+
+  if (pRes->code == TSDB_CODE_TSC_QUERY_CANCELLED) {
+    tscDebug("0x%"PRIx64" query is cancelled, code:%s", pSql->self, tstrerror(pRes->code));
+  } else {
+    pRes->code = rpcMsg->code;
+  }
+
+  if (pRes->code == TSDB_CODE_SUCCESS) {
+    tscDebug("0x%"PRIx64" reset retry counter to be 0 due to success rsp, old:%d", pSql->self, pSql->retry);
+    pSql->retry = 0;
+  }
+
+  if (pRes->code != TSDB_CODE_TSC_QUERY_CANCELLED) {
+    assert(rpcMsg->msgType == pCmd->msgType + 1);
+    pRes->code    = rpcMsg->code;
+    pRes->rspType = rpcMsg->msgType;
+    pRes->rspLen  = rpcMsg->contLen;
+
+    if (pRes->rspLen > 0 && rpcMsg->pCont) {
+      char *tmp = (char *)realloc(pRes->pRsp, pRes->rspLen);
+      if (tmp == NULL) {
+        pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+      } else {
+        pRes->pRsp = tmp;
+        memcpy(pRes->pRsp, rpcMsg->pCont, pRes->rspLen);
+      }
+    } else {
+      tfree(pRes->pRsp);
+    }
+
+    /*
+     * There is not response callback function for submit response.
+     * The actual inserted number of points is the first number.
+     */
+    if (rpcMsg->msgType == TSDB_MSG_TYPE_SUBMIT_RSP && pRes->pRsp != NULL) {
+      SShellSubmitRspMsg *pMsg = (SShellSubmitRspMsg*)pRes->pRsp;
+      pMsg->code = htonl(pMsg->code);
+      pMsg->numOfRows = htonl(pMsg->numOfRows);
+      pMsg->affectedRows = htonl(pMsg->affectedRows);
+      pMsg->failedRows = htonl(pMsg->failedRows);
+      pMsg->numOfFailedBlocks = htonl(pMsg->numOfFailedBlocks);
+
+      pRes->numOfRows += pMsg->affectedRows;
+      tscDebug("0x%"PRIx64" SQL cmd:%s, code:%s inserted rows:%d rspLen:%d", pSql->self, sqlCmd[pCmd->command],
+          tstrerror(pRes->code), pMsg->affectedRows, pRes->rspLen);
+    } else {
+      tscDebug("0x%"PRIx64" SQL cmd:%s, code:%s rspLen:%d", pSql->self, sqlCmd[pCmd->command], tstrerror(pRes->code), pRes->rspLen);
+    }
+  }
+
+  if (pRes->code == TSDB_CODE_SUCCESS && tscProcessMsgRsp[pCmd->command]) {
+    rpcMsg->code = (*tscProcessMsgRsp[pCmd->command])(pSql);
+  }
+
+  bool shouldFree = tscShouldBeFreed(pSql);
+  if (rpcMsg->code != TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+    if (rpcMsg->code != TSDB_CODE_SUCCESS) {
+      pRes->code = rpcMsg->code;
+    }
+
+    rpcMsg->code = (pRes->code == TSDB_CODE_SUCCESS) ? (int32_t)pRes->numOfRows : pRes->code;
+    if (rpcMsg->code == TSDB_CODE_RPC_FQDN_ERROR) {
+      tscAllocPayload(pCmd, TSDB_FQDN_LEN + 64);
+      tscSetFqdnErrorMsg(pSql, pEpSet);
+    }
+
+    (*pSql->fp)(pSql->param, pSql, rpcMsg->code);
+  }
+
+  if (shouldFree) { // in case of table-meta/vgrouplist query, automatically free it
+    tscDebug("0x%"PRIx64" sqlObj is automatically freed", pSql->self);
+    taosRemoveRef(tscObjRef, handle);
+  }
+
+  taosReleaseRef(tscObjRef, handle);
+  rpcFreeCont(rpcMsg->pCont);
+}
+
+int doBuildAndSendMsg(SSqlObj *pSql) {
+  SSqlCmd *pCmd = &pSql->cmd;
+  SSqlRes *pRes = &pSql->res;
+
+  if (pCmd->command == TSDB_SQL_SELECT ||
+      pCmd->command == TSDB_SQL_FETCH ||
+      pCmd->command == TSDB_SQL_RETRIEVE ||
+      pCmd->command == TSDB_SQL_INSERT ||
+      pCmd->command == TSDB_SQL_CONNECT ||
+      pCmd->command == TSDB_SQL_HB ||
+      pCmd->command == TSDB_SQL_RETRIEVE_FUNC ||
+      pCmd->command == TSDB_SQL_STABLEVGROUP) {
+    pRes->code = tscBuildMsg[pCmd->command](pSql, NULL);
+  }
+
+  if (pRes->code != TSDB_CODE_SUCCESS) {
+    tscAsyncResultOnError(pSql);
+    return TSDB_CODE_SUCCESS;
+  }
+
+  int32_t code = tscSendMsgToServer(pSql);
+
+  // NOTE: if code is TSDB_CODE_SUCCESS, pSql may have been released here already by other threads.
+  if (code != TSDB_CODE_SUCCESS) {
+    pRes->code = code;
+    tscAsyncResultOnError(pSql);
+    return  TSDB_CODE_SUCCESS;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int tscBuildAndSendRequest(SSqlObj *pSql, SQueryInfo* pQueryInfo) {
+  char name[TSDB_TABLE_FNAME_LEN] = {0};
+
+  SSqlCmd *pCmd = &pSql->cmd;
+  uint32_t type = 0;
+
+  if (pQueryInfo == NULL) {
+    pQueryInfo = tscGetQueryInfo(pCmd);
+  }
+
+  STableMetaInfo *pTableMetaInfo = NULL;
+
+  if (pQueryInfo != NULL) {
+    pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+    if (pTableMetaInfo != NULL) {
+      tNameExtractFullName(&pTableMetaInfo->name, name);
+    }
+
+    type = pQueryInfo->type;
+
+    // while numOfTables equals to 0, it must be Heartbeat
+    assert((pQueryInfo->numOfTables == 0 && (pQueryInfo->command == TSDB_SQL_HB || pSql->cmd.command == TSDB_SQL_RETRIEVE_FUNC)) || pQueryInfo->numOfTables > 0);
+  }
+
+  tscDebug("0x%"PRIx64" SQL cmd:%s will be processed, name:%s, type:%d", pSql->self, sqlCmd[pCmd->command], name, type);
+  if (pCmd->command < TSDB_SQL_MGMT) { // the pTableMetaInfo cannot be NULL
+    if (pTableMetaInfo == NULL) {
+      pSql->res.code = TSDB_CODE_TSC_APP_ERROR;
+      return pSql->res.code;
+    }
+  } else if (pCmd->command >= TSDB_SQL_LOCAL) {
+    return (*tscProcessMsgRsp[pCmd->command])(pSql);
+  }
+
+  return doBuildAndSendMsg(pSql);
+}
+
+int tscBuildFetchMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SRetrieveTableMsg *pRetrieveMsg = (SRetrieveTableMsg *) pSql->cmd.payload;
+
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd);
+
+  pRetrieveMsg->free = htons(pQueryInfo->type);
+  pRetrieveMsg->qId  = htobe64(pSql->res.qId);
+
+  // todo valid the vgroupId at the client side
+  STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+
+  if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
+    int32_t vgIndex = pTableMetaInfo->vgroupIndex;
+    int32_t vgId = -1;
+
+    if (pTableMetaInfo->pVgroupTables == NULL) {
+      SVgroupsInfo *pVgroupInfo = pTableMetaInfo->vgroupList;
+      assert(pVgroupInfo->vgroups[vgIndex].vgId > 0 && vgIndex < pTableMetaInfo->vgroupList->numOfVgroups);
+      vgId = pVgroupInfo->vgroups[vgIndex].vgId;
+    } else {
+      int32_t numOfVgroups = (int32_t)taosArrayGetSize(pTableMetaInfo->pVgroupTables);
+      assert(vgIndex >= 0 && vgIndex < numOfVgroups);
+
+      SVgroupTableInfo* pTableIdList = taosArrayGet(pTableMetaInfo->pVgroupTables, vgIndex);
+      vgId = pTableIdList->vgInfo.vgId;
+    }
+
+    pRetrieveMsg->header.vgId = htonl(vgId);
+    tscDebug("0x%"PRIx64" build fetch msg from vgId:%d, vgIndex:%d, qId:0x%" PRIx64, pSql->self, vgId, vgIndex, pSql->res.qId);
+  } else {
+    STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
+    pRetrieveMsg->header.vgId = htonl(pTableMeta->vgId);
+    tscDebug("0x%"PRIx64" build fetch msg from only one vgroup, vgId:%d, qId:0x%" PRIx64, pSql->self, pTableMeta->vgId,
+        pSql->res.qId);
+  }
+
+  pSql->cmd.payloadLen = sizeof(SRetrieveTableMsg);
+  pSql->cmd.msgType = TSDB_MSG_TYPE_FETCH;
+
+  pRetrieveMsg->header.contLen = htonl(sizeof(SRetrieveTableMsg));
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int tscBuildSubmitMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd);
+  STableMeta* pTableMeta = tscGetMetaInfo(pQueryInfo, 0)->pTableMeta;
+
+  // pSql->cmd.payloadLen is set during copying data into payload
+  pSql->cmd.msgType = TSDB_MSG_TYPE_SUBMIT;
+
+  SNewVgroupInfo vgroupInfo = {0};
+  taosHashGetClone(tscVgroupMap, &pTableMeta->vgId, sizeof(pTableMeta->vgId), NULL, &vgroupInfo);
+  tscDumpEpSetFromVgroupInfo(&pSql->epSet, &vgroupInfo);
+
+  tscDebug("0x%"PRIx64" submit msg built, numberOfEP:%d", pSql->self, pSql->epSet.numOfEps);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+/*
+ * for table query, simply return the size <= 1k
+ */
+static int32_t tscEstimateQueryMsgSize(SSqlObj *pSql) {
+  const static int32_t MIN_QUERY_MSG_PKT_SIZE = TSDB_MAX_BYTES_PER_ROW * 5;
+
+  SSqlCmd* pCmd = &pSql->cmd;
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
+
+  int32_t srcColListSize = (int32_t)(taosArrayGetSize(pQueryInfo->colList) * sizeof(SColumnInfo));
+  int32_t srcColFilterSize = 0;
+  int32_t srcTagFilterSize = tscGetTagFilterSerializeLen(pQueryInfo);
+
+  size_t  numOfExprs = tscNumOfExprs(pQueryInfo);
+  int32_t exprSize = (int32_t)(sizeof(SSqlExpr) * numOfExprs * 2);
+
+  int32_t tsBufSize = (pQueryInfo->tsBuf != NULL) ? pQueryInfo->tsBuf->fileSize : 0;
+  int32_t sqlLen = (int32_t) strlen(pSql->sqlstr) + 1;
+
+  int32_t tableSerialize = 0;
+  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+  STableMeta * pTableMeta = pTableMetaInfo->pTableMeta;
+  if (pTableMetaInfo->pVgroupTables != NULL) {
+    size_t numOfGroups = taosArrayGetSize(pTableMetaInfo->pVgroupTables);
+
+    int32_t totalTables = 0;
+    for (int32_t i = 0; i < numOfGroups; ++i) {
+      SVgroupTableInfo *pTableInfo = taosArrayGet(pTableMetaInfo->pVgroupTables, i);
+      totalTables += (int32_t) taosArrayGetSize(pTableInfo->itemList);
+    }
+
+    tableSerialize = totalTables * sizeof(STableIdInfo);
+  }
+
+  if (pQueryInfo->colCond && taosArrayGetSize(pQueryInfo->colCond) > 0) {
+    STblCond *pCond = tsGetTableFilter(pQueryInfo->colCond, pTableMeta->id.uid, 0);
+    if (pCond != NULL && pCond->cond != NULL) {
+      srcColFilterSize = pCond->len;
+    }
+  }
+
+  SCond* pCond = &pQueryInfo->tagCond.tbnameCond;
+  if (pCond->len > 0) {
+    srcColListSize += pCond->len;
+  }
+
+  return MIN_QUERY_MSG_PKT_SIZE + minMsgSize() + sizeof(SQueryTableMsg) + srcColListSize + srcColFilterSize + srcTagFilterSize +
+         exprSize + tsBufSize + tableSerialize + sqlLen + 4096 + pQueryInfo->bufLen;
+}
+
+static char *doSerializeTableInfo(SQueryTableMsg *pQueryMsg, SSqlObj *pSql, STableMetaInfo *pTableMetaInfo, char *pMsg,
+                                  int32_t *succeed) {
+  TSKEY dfltKey = htobe64(pQueryMsg->window.skey);
+
+  STableMeta * pTableMeta = pTableMetaInfo->pTableMeta;
+  if (UTIL_TABLE_IS_NORMAL_TABLE(pTableMetaInfo) || pTableMetaInfo->pVgroupTables == NULL) {
+
+    int32_t vgId = -1;
+    if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
+      int32_t index = pTableMetaInfo->vgroupIndex;
+      assert(index >= 0);
+
+      SVgroupMsg* pVgroupInfo = NULL;
+      if (pTableMetaInfo->vgroupList && pTableMetaInfo->vgroupList->numOfVgroups > 0) {
+        assert(index < pTableMetaInfo->vgroupList->numOfVgroups);
+        pVgroupInfo = &pTableMetaInfo->vgroupList->vgroups[index];
+      } else {
+        tscError("0x%"PRIx64" No vgroup info found", pSql->self);
+
+        *succeed = 0;
+        return pMsg;
+      }
+
+      vgId = pVgroupInfo->vgId;
+      tscSetDnodeEpSet(&pSql->epSet, pVgroupInfo);
+      tscDebug("0x%"PRIx64" query on stable, vgIndex:%d, numOfVgroups:%d", pSql->self, index, pTableMetaInfo->vgroupList->numOfVgroups);
+    } else {
+      vgId = pTableMeta->vgId;
+
+      SNewVgroupInfo vgroupInfo = {0};
+      taosHashGetClone(tscVgroupMap, &pTableMeta->vgId, sizeof(pTableMeta->vgId), NULL, &vgroupInfo);
+      tscDumpEpSetFromVgroupInfo(&pSql->epSet, &vgroupInfo);
+    }
+
+    if (pSql->epSet.numOfEps > 0){
+      pSql->epSet.inUse = rand()%pSql->epSet.numOfEps;
+    }
+    pQueryMsg->head.vgId = htonl(vgId);
+
+    STableIdInfo *pTableIdInfo = (STableIdInfo *)pMsg;
+    pTableIdInfo->tid = htonl(pTableMeta->id.tid);
+    pTableIdInfo->uid = htobe64(pTableMeta->id.uid);
+    pTableIdInfo->key = htobe64(tscGetSubscriptionProgress(pSql->pSubscription, pTableMeta->id.uid, dfltKey));
+
+    pQueryMsg->numOfTables = htonl(1);  // set the number of tables
+    pMsg += sizeof(STableIdInfo);
+  } else { // it is a subquery of the super table query, this EP info is acquired from vgroupInfo
+    int32_t index = pTableMetaInfo->vgroupIndex;
+    int32_t numOfVgroups = (int32_t)taosArrayGetSize(pTableMetaInfo->pVgroupTables);
+    assert(index >= 0 && index < numOfVgroups);
+
+    SVgroupTableInfo* pTableIdList = taosArrayGet(pTableMetaInfo->pVgroupTables, index);
+
+    // set the vgroup info
+    tscSetDnodeEpSet(&pSql->epSet, &pTableIdList->vgInfo);
+    pQueryMsg->head.vgId = htonl(pTableIdList->vgInfo.vgId);
+
+    int32_t numOfTables = (int32_t)taosArrayGetSize(pTableIdList->itemList);
+    pQueryMsg->numOfTables = htonl(numOfTables);  // set the number of tables
+
+    tscDebug("0x%"PRIx64" query on stable, vgId:%d, numOfTables:%d, vgIndex:%d, numOfVgroups:%d", pSql->self,
+        pTableIdList->vgInfo.vgId, numOfTables, index, numOfVgroups);
+
+    // serialize each table id info
+    for(int32_t i = 0; i < numOfTables; ++i) {
+      STableIdInfo* pItem = taosArrayGet(pTableIdList->itemList, i);
+
+      STableIdInfo *pTableIdInfo = (STableIdInfo *)pMsg;
+      pTableIdInfo->tid = htonl(pItem->tid);
+      pTableIdInfo->uid = htobe64(pItem->uid);
+      pTableIdInfo->key = htobe64(tscGetSubscriptionProgress(pSql->pSubscription, pItem->uid, dfltKey));
+      pMsg += sizeof(STableIdInfo);
+    }
+  }
+
+  char n[TSDB_TABLE_FNAME_LEN] = {0};
+  tNameExtractFullName(&pTableMetaInfo->name, n);
+
+  tscDebug("0x%"PRIx64" vgId:%d, query on table:%s, tid:%d, uid:%" PRIu64, pSql->self, htonl(pQueryMsg->head.vgId), n, pTableMeta->id.tid, pTableMeta->id.uid);
+  return pMsg;
+}
+
+// TODO refactor
+static int32_t serializeColFilterInfo(SColumnFilterInfo* pColFilters, int16_t numOfFilters, char** pMsg) {
+  // append the filter information after the basic column information
+  for (int32_t f = 0; f < numOfFilters; ++f) {
+    SColumnFilterInfo *pColFilter = &pColFilters[f];
+
+    SColumnFilterInfo *pFilterMsg = (SColumnFilterInfo *)(*pMsg);
+    pFilterMsg->filterstr = htons(pColFilter->filterstr);
+
+    (*pMsg) += sizeof(SColumnFilterInfo);
+
+    if (pColFilter->filterstr) {
+      pFilterMsg->len = htobe64(pColFilter->len);
+      memcpy(*pMsg, (void *)pColFilter->pz, (size_t)(pColFilter->len + 1));
+      (*pMsg) += (pColFilter->len + 1);  // append the additional filter binary info
+    } else {
+      pFilterMsg->lowerBndi = htobe64(pColFilter->lowerBndi);
+      pFilterMsg->upperBndi = htobe64(pColFilter->upperBndi);
+    }
+
+    pFilterMsg->lowerRelOptr = htons(pColFilter->lowerRelOptr);
+    pFilterMsg->upperRelOptr = htons(pColFilter->upperRelOptr);
+
+    if (pColFilter->lowerRelOptr == TSDB_RELATION_INVALID && pColFilter->upperRelOptr == TSDB_RELATION_INVALID) {
+      tscError("invalid filter info");
+      return TSDB_CODE_TSC_INVALID_OPERATION;
+    }
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t serializeSqlExpr(SSqlExpr* pExpr, STableMetaInfo* pTableMetaInfo, char** pMsg, int64_t id, bool validateColumn) {
+  STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
+
+  // the queried table has been removed and a new table with the same name has already been created already
+  // return error msg
+  if (pExpr->uid != pTableMeta->id.uid) {
+    tscError("0x%"PRIx64" table has already been destroyed", id);
+    return TSDB_CODE_TSC_INVALID_TABLE_NAME;
+  }
+
+  if (validateColumn && !tscValidateColumnId(pTableMetaInfo, pExpr->colInfo.colId, pExpr->numOfParams)) {
+    tscError("0x%"PRIx64" table schema is not matched with parsed sql", id);
+    return TSDB_CODE_TSC_INVALID_OPERATION;
+  }
+
+  assert(pExpr->resColId < 0);
+  SSqlExpr* pSqlExpr = (SSqlExpr *)(*pMsg);
+
+  SColIndex* pIndex = &pSqlExpr->colInfo;
+
+  pIndex->colId         = htons(pExpr->colInfo.colId);
+  pIndex->colIndex      = htons(pExpr->colInfo.colIndex);
+  pIndex->flag          = htons(pExpr->colInfo.flag);
+  pSqlExpr->uid         = htobe64(pExpr->uid);
+  pSqlExpr->colType     = htons(pExpr->colType);
+  pSqlExpr->colBytes    = htons(pExpr->colBytes);
+  pSqlExpr->resType     = htons(pExpr->resType);
+  pSqlExpr->resBytes    = htons(pExpr->resBytes);
+  pSqlExpr->interBytes  = htonl(pExpr->interBytes);
+  pSqlExpr->functionId  = htons(pExpr->functionId);
+  pSqlExpr->numOfParams = htons(pExpr->numOfParams);
+  pSqlExpr->resColId    = htons(pExpr->resColId);
+  pSqlExpr->flist.numOfFilters = htons(pExpr->flist.numOfFilters);
+
+  (*pMsg) += sizeof(SSqlExpr);
+  for (int32_t j = 0; j < pExpr->numOfParams; ++j) { // todo add log
+    pSqlExpr->param[j].nType = htonl(pExpr->param[j].nType);
+    pSqlExpr->param[j].nLen  = htonl(pExpr->param[j].nLen);
+
+    if (pExpr->param[j].nType == TSDB_DATA_TYPE_BINARY) {
+      memcpy((*pMsg), pExpr->param[j].pz, pExpr->param[j].nLen);
+      (*pMsg) += pExpr->param[j].nLen;
+    } else {
+      pSqlExpr->param[j].i64 = htobe64(pExpr->param[j].i64);
+    }
+  }
+
+  serializeColFilterInfo(pExpr->flist.filterInfo, pExpr->flist.numOfFilters, pMsg);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+
+  SQueryInfo     *pQueryInfo = NULL;
+  STableMeta     *pTableMeta = NULL;
+  STableMetaInfo *pTableMetaInfo = NULL;
+
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t size = tscEstimateQueryMsgSize(pSql);
+  assert(size > 0);
+
+  if (TSDB_CODE_SUCCESS != tscAllocPayloadFast(pCmd, size)) {
+    tscError("%p failed to malloc for query msg", pSql);
+    return TSDB_CODE_TSC_INVALID_OPERATION;  // todo add test for this
+  }
+
+  pQueryInfo = tscGetQueryInfo(pCmd);
+  pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+  pTableMeta = pTableMetaInfo->pTableMeta;
+
+  SQueryAttr query = {{0}};
+  tscCreateQueryFromQueryInfo(pQueryInfo, &query, pSql);
+  query.vgId = pTableMeta->vgId;
+
+  SArray* tableScanOperator = createTableScanPlan(&query);
+  SArray* queryOperator = createExecOperatorPlan(&query);
+
+  SQueryTableMsg *pQueryMsg = (SQueryTableMsg *)pCmd->payload;
+  tstrncpy(pQueryMsg->version, version, tListLen(pQueryMsg->version));
+
+  int32_t numOfTags = query.numOfTags;
+  int32_t sqlLen = (int32_t) strlen(pSql->sqlstr);
+
+  if (taosArrayGetSize(tableScanOperator) == 0) {
+    pQueryMsg->tableScanOperator = htonl(-1);
+  } else {
+    int32_t* tablescanOp = taosArrayGet(tableScanOperator, 0);
+    pQueryMsg->tableScanOperator = htonl(*tablescanOp);
+  }
+
+  pQueryMsg->window.skey = htobe64(query.window.skey);
+  pQueryMsg->window.ekey = htobe64(query.window.ekey);
+
+  pQueryMsg->order          = htons(query.order.order);
+  pQueryMsg->orderColId     = htons(query.order.orderColId);
+  pQueryMsg->fillType       = htons(query.fillType);
+  pQueryMsg->limit          = htobe64(query.limit.limit);
+  pQueryMsg->offset         = htobe64(query.limit.offset);
+  pQueryMsg->numOfCols      = htons(query.numOfCols);
+
+  pQueryMsg->interval.interval     = htobe64(query.interval.interval);
+  pQueryMsg->interval.sliding      = htobe64(query.interval.sliding);
+  pQueryMsg->interval.offset       = htobe64(query.interval.offset);
+  pQueryMsg->interval.intervalUnit = query.interval.intervalUnit;
+  pQueryMsg->interval.slidingUnit  = query.interval.slidingUnit;
+  pQueryMsg->interval.offsetUnit   = query.interval.offsetUnit;
+
+  pQueryMsg->stableQuery      = query.stableQuery;
+  pQueryMsg->topBotQuery      = query.topBotQuery;
+  pQueryMsg->groupbyColumn    = query.groupbyColumn;
+  pQueryMsg->hasTagResults    = query.hasTagResults;
+  pQueryMsg->timeWindowInterpo = query.timeWindowInterpo;
+  pQueryMsg->queryBlockDist   = query.queryBlockDist;
+  pQueryMsg->stabledev        = query.stabledev;
+  pQueryMsg->tsCompQuery      = query.tsCompQuery;
+  pQueryMsg->simpleAgg        = query.simpleAgg;
+  pQueryMsg->pointInterpQuery = query.pointInterpQuery;
+  pQueryMsg->needReverseScan  = query.needReverseScan;
+  pQueryMsg->stateWindow      = query.stateWindow;
+  pQueryMsg->numOfTags        = htonl(numOfTags);
+  pQueryMsg->sqlstrLen        = htonl(sqlLen);
+  pQueryMsg->sw.gap           = htobe64(query.sw.gap);
+  pQueryMsg->sw.primaryColId  = htonl(PRIMARYKEY_TIMESTAMP_COL_INDEX);
+
+  pQueryMsg->secondStageOutput = htonl(query.numOfExpr2);
+  pQueryMsg->numOfOutput    = htons((int16_t)query.numOfOutput);  // this is the stage one output column number
+
+  pQueryMsg->numOfGroupCols = htons(pQueryInfo->groupbyExpr.numOfGroupCols);
+  pQueryMsg->tagNameRelType = htons(pQueryInfo->tagCond.relType);
+  pQueryMsg->tbnameCondLen  = htonl(pQueryInfo->tagCond.tbnameCond.len);
+  pQueryMsg->queryType      = htonl(pQueryInfo->type);
+  pQueryMsg->prevResultLen  = htonl(pQueryInfo->bufLen);
+
+  // set column list ids
+  size_t numOfCols = taosArrayGetSize(pQueryInfo->colList);
+  char *pMsg = (char *)(pQueryMsg->tableCols) + numOfCols * sizeof(SColumnInfo);
+
+  for (int32_t i = 0; i < numOfCols; ++i) {
+    SColumnInfo *pCol = &query.tableCols[i];
+
+    pQueryMsg->tableCols[i].colId = htons(pCol->colId);
+    pQueryMsg->tableCols[i].bytes = htons(pCol->bytes);
+    pQueryMsg->tableCols[i].type  = htons(pCol->type);
+    //pQueryMsg->tableCols[i].flist.numOfFilters = htons(pCol->flist.numOfFilters);
+    pQueryMsg->tableCols[i].flist.numOfFilters = 0;
+    pQueryMsg->tableCols[i].flist.filterInfo = 0;
+    // append the filter information after the basic column information
+    //serializeColFilterInfo(pCol->flist.filterInfo, pCol->flist.numOfFilters, &pMsg);
+  }
+
+  if (pQueryInfo->colCond && taosArrayGetSize(pQueryInfo->colCond) > 0 && !onlyQueryTags(&query) ) {
+    STblCond *pCond = tsGetTableFilter(pQueryInfo->colCond, pTableMeta->id.uid, 0);
+    if (pCond != NULL && pCond->cond != NULL) {
+      pQueryMsg->colCondLen = htons(pCond->len);
+      memcpy(pMsg, pCond->cond, pCond->len);
+
+      pMsg += pCond->len;
+    }
+  } else {
+    pQueryMsg->colCondLen = 0;
+  }
+
+  for (int32_t i = 0; i < query.numOfOutput; ++i) {
+    code = serializeSqlExpr(&query.pExpr1[i].base, pTableMetaInfo, &pMsg, pSql->self, true);
+    if (code != TSDB_CODE_SUCCESS) {
+      goto _end;
+    }
+  }
+
+  for (int32_t i = 0; i < query.numOfExpr2; ++i) {
+    code = serializeSqlExpr(&query.pExpr2[i].base, pTableMetaInfo, &pMsg, pSql->self, false);
+    if (code != TSDB_CODE_SUCCESS) {
+      goto _end;
+    }
+  }
+
+  int32_t succeed = 1;
+
+  // serialize the table info (sid, uid, tags)
+  pMsg = doSerializeTableInfo(pQueryMsg, pSql, pTableMetaInfo, pMsg, &succeed);
+  if (succeed == 0) {
+    code = TSDB_CODE_TSC_APP_ERROR;
+    goto _end;
+  }
+
+  SGroupbyExpr *pGroupbyExpr = query.pGroupbyExpr;
+  if (pGroupbyExpr != NULL && pGroupbyExpr->numOfGroupCols > 0) {
+    pQueryMsg->orderByIdx = htons(pGroupbyExpr->orderIndex);
+    pQueryMsg->orderType = htons(pGroupbyExpr->orderType);
+
+    for (int32_t j = 0; j < pGroupbyExpr->numOfGroupCols; ++j) {
+      SColIndex* pCol = taosArrayGet(pGroupbyExpr->columnInfo, j);
+
+      *((int16_t *)pMsg) = htons(pCol->colId);
+      pMsg += sizeof(pCol->colId);
+
+      *((int16_t *)pMsg) += htons(pCol->colIndex);
+      pMsg += sizeof(pCol->colIndex);
+
+      *((int16_t *)pMsg) += htons(pCol->flag);
+      pMsg += sizeof(pCol->flag);
+
+      memcpy(pMsg, pCol->name, tListLen(pCol->name));
+      pMsg += tListLen(pCol->name);
+    }
+  }
+
+  if (query.fillType != TSDB_FILL_NONE) {
+    for (int32_t i = 0; i < query.numOfOutput; ++i) {
+      *((int64_t *)pMsg) = htobe64(query.fillVal[i]);
+      pMsg += sizeof(query.fillVal[0]);
+    }
+  }
+
+  if (query.numOfTags > 0 && query.tagColList != NULL) {
+    for (int32_t i = 0; i < query.numOfTags; ++i) {
+      SColumnInfo* pTag = &query.tagColList[i];
+
+      SColumnInfo* pTagCol = (SColumnInfo*) pMsg;
+      pTagCol->colId = htons(pTag->colId);
+      pTagCol->bytes = htons(pTag->bytes);
+      pTagCol->type  = htons(pTag->type);
+      pTagCol->flist.numOfFilters = 0;
+
+      pMsg += sizeof(SColumnInfo);
+    }
+  }
+
+  // serialize tag column query condition
+  if (pQueryInfo->tagCond.pCond != NULL && taosArrayGetSize(pQueryInfo->tagCond.pCond) > 0) {
+    STagCond* pTagCond = &pQueryInfo->tagCond;
+
+    SCond *pCond = tsGetSTableQueryCond(pTagCond, pTableMeta->id.uid);
+    if (pCond != NULL && pCond->cond != NULL) {
+      pQueryMsg->tagCondLen = htons(pCond->len);
+      memcpy(pMsg, pCond->cond, pCond->len);
+
+      pMsg += pCond->len;
+    }
+  } else {
+    pQueryMsg->tagCondLen = 0;
+  }
+
+  if (pQueryInfo->bufLen > 0) {
+    memcpy(pMsg, pQueryInfo->buf, pQueryInfo->bufLen);
+    pMsg += pQueryInfo->bufLen;
+  }
+
+  SCond* pCond = &pQueryInfo->tagCond.tbnameCond;
+  if (pCond->len > 0) {
+    strncpy(pMsg, pCond->cond, pCond->len);
+    pMsg += pCond->len;
+  }
+
+  // compressed ts block
+  pQueryMsg->tsBuf.tsOffset = htonl((int32_t)(pMsg - pCmd->payload));
+
+  if (pQueryInfo->tsBuf != NULL) {
+    // note: here used the index instead of actual vnode id.
+    int32_t vnodeIndex = pTableMetaInfo->vgroupIndex;
+    code = dumpFileBlockByGroupId(pQueryInfo->tsBuf, vnodeIndex, pMsg, &pQueryMsg->tsBuf.tsLen, &pQueryMsg->tsBuf.tsNumOfBlocks);
+    if (code != TSDB_CODE_SUCCESS) {
+      goto _end;
+    }
+
+    pMsg += pQueryMsg->tsBuf.tsLen;
+
+    pQueryMsg->tsBuf.tsOrder = htonl(pQueryInfo->tsBuf->tsOrder);
+    pQueryMsg->tsBuf.tsLen   = htonl(pQueryMsg->tsBuf.tsLen);
+    pQueryMsg->tsBuf.tsNumOfBlocks = htonl(pQueryMsg->tsBuf.tsNumOfBlocks);
+  } else {
+    pQueryMsg->tsBuf.tsLen = 0;
+    pQueryMsg->tsBuf.tsNumOfBlocks = 0;
+  }
+
+  int32_t numOfOperator = (int32_t) taosArrayGetSize(queryOperator);
+  pQueryMsg->numOfOperator = htonl(numOfOperator);
+  for(int32_t i = 0; i < numOfOperator; ++i) {
+    int32_t *operator = taosArrayGet(queryOperator, i);
+    *(int32_t*)pMsg = htonl(*operator);
+
+    pMsg += sizeof(int32_t);
+  }
+
+  // support only one udf
+  if (pQueryInfo->pUdfInfo != NULL && taosArrayGetSize(pQueryInfo->pUdfInfo) > 0) {
+    pQueryMsg->udfContentOffset = htonl((int32_t) (pMsg - pCmd->payload));
+    for(int32_t i = 0; i < taosArrayGetSize(pQueryInfo->pUdfInfo); ++i) {
+      SUdfInfo* pUdfInfo = taosArrayGet(pQueryInfo->pUdfInfo, i);
+      *(int8_t*) pMsg = pUdfInfo->resType;
+      pMsg += sizeof(pUdfInfo->resType);
+
+      *(int16_t*) pMsg = htons(pUdfInfo->resBytes);
+      pMsg += sizeof(pUdfInfo->resBytes);
+
+      STR_TO_VARSTR(pMsg, pUdfInfo->name);
+
+      pMsg += varDataTLen(pMsg);
+
+      *(int32_t*) pMsg = htonl(pUdfInfo->funcType);
+      pMsg += sizeof(pUdfInfo->funcType);
+
+      *(int32_t*) pMsg = htonl(pUdfInfo->bufSize);
+      pMsg += sizeof(pUdfInfo->bufSize);
+
+      pQueryMsg->udfContentLen = htonl(pUdfInfo->contLen);
+      memcpy(pMsg, pUdfInfo->content, pUdfInfo->contLen);
+
+      pMsg += pUdfInfo->contLen;
+    }
+  } else {
+    pQueryMsg->udfContentOffset = 0;
+    pQueryMsg->udfContentLen = 0;
+  }
+
+  memcpy(pMsg, pSql->sqlstr, sqlLen);
+  pMsg += sqlLen;
+
+  int32_t msgLen = (int32_t)(pMsg - pCmd->payload);
+
+  tscDebug("0x%"PRIx64" msg built success, len:%d bytes", pSql->self, msgLen);
+  pCmd->payloadLen = msgLen;
+  pSql->cmd.msgType = TSDB_MSG_TYPE_QUERY;
+
+  pQueryMsg->head.contLen = htonl(msgLen);
+  assert(msgLen + minMsgSize() <= (int32_t)pCmd->allocSize);
+
+  _end:
+  freeQueryAttr(&query);
+  taosArrayDestroy(tableScanOperator);
+  taosArrayDestroy(queryOperator);
+  return code;
+}
+
+int32_t tscBuildCreateDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+  pCmd->payloadLen = sizeof(SCreateDbMsg);
+
+  pCmd->msgType = (pInfo->pMiscInfo->dbOpt.dbType == TSDB_DB_TYPE_DEFAULT) ? TSDB_MSG_TYPE_CREATE_DB : TSDB_MSG_TYPE_CREATE_TP;
+
+  SCreateDbMsg *pCreateDbMsg = (SCreateDbMsg *)pCmd->payload;
+
+//  assert(pCmd->numOfClause == 1);
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
+  int32_t code = tNameExtractFullName(&pTableMetaInfo->name, pCreateDbMsg->db);
+  assert(code == TSDB_CODE_SUCCESS);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t tscBuildCreateFuncMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+  SCreateFuncMsg *pCreateFuncMsg = (SCreateFuncMsg *)pCmd->payload;
+
+  pCmd->msgType = TSDB_MSG_TYPE_CREATE_FUNCTION;
+
+  pCmd->payloadLen = sizeof(SCreateFuncMsg) + htonl(pCreateFuncMsg->codeLen);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t tscBuildCreateDnodeMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+  pCmd->payloadLen = sizeof(SCreateDnodeMsg);
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  SCreateDnodeMsg *pCreate = (SCreateDnodeMsg *)pCmd->payload;
+
+  SStrToken* t0 = taosArrayGet(pInfo->pMiscInfo->a, 0);
+  strncpy(pCreate->ep, t0->z, t0->n);
+
+  pCmd->msgType = TSDB_MSG_TYPE_CREATE_DNODE;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t tscBuildAcctMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+  pCmd->payloadLen = sizeof(SCreateAcctMsg);
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  SCreateAcctMsg *pAlterMsg = (SCreateAcctMsg *)pCmd->payload;
+
+  SStrToken *pName = &pInfo->pMiscInfo->user.user;
+  SStrToken *pPwd = &pInfo->pMiscInfo->user.passwd;
+
+  strncpy(pAlterMsg->user, pName->z, pName->n);
+  strncpy(pAlterMsg->pass, pPwd->z, pPwd->n);
+
+  SCreateAcctInfo *pAcctOpt = &pInfo->pMiscInfo->acctOpt;
+
+  pAlterMsg->cfg.maxUsers = htonl(pAcctOpt->maxUsers);
+  pAlterMsg->cfg.maxDbs = htonl(pAcctOpt->maxDbs);
+  pAlterMsg->cfg.maxTimeSeries = htonl(pAcctOpt->maxTimeSeries);
+  pAlterMsg->cfg.maxStreams = htonl(pAcctOpt->maxStreams);
+  pAlterMsg->cfg.maxPointsPerSecond = htonl(pAcctOpt->maxPointsPerSecond);
+  pAlterMsg->cfg.maxStorage = htobe64(pAcctOpt->maxStorage);
+  pAlterMsg->cfg.maxQueryTime = htobe64(pAcctOpt->maxQueryTime);
+  pAlterMsg->cfg.maxConnections = htonl(pAcctOpt->maxConnections);
+
+  if (pAcctOpt->stat.n == 0) {
+    pAlterMsg->cfg.accessState = -1;
+  } else {
+    if (pAcctOpt->stat.z[0] == 'r' && pAcctOpt->stat.n == 1) {
+      pAlterMsg->cfg.accessState = TSDB_VN_READ_ACCCESS;
+    } else if (pAcctOpt->stat.z[0] == 'w' && pAcctOpt->stat.n == 1) {
+      pAlterMsg->cfg.accessState = TSDB_VN_WRITE_ACCCESS;
+    } else if (strncmp(pAcctOpt->stat.z, "all", 3) == 0 && pAcctOpt->stat.n == 3) {
+      pAlterMsg->cfg.accessState = TSDB_VN_ALL_ACCCESS;
+    } else if (strncmp(pAcctOpt->stat.z, "no", 2) == 0 && pAcctOpt->stat.n == 2) {
+      pAlterMsg->cfg.accessState = 0;
+    }
+  }
+
+  pCmd->msgType = TSDB_MSG_TYPE_CREATE_ACCT;
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t tscBuildUserMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+  pCmd->payloadLen = sizeof(SCreateUserMsg);
+
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  SCreateUserMsg *pAlterMsg = (SCreateUserMsg *)pCmd->payload;
+
+  SUserInfo *pUser = &pInfo->pMiscInfo->user;
+  strncpy(pAlterMsg->user, pUser->user.z, pUser->user.n);
+  pAlterMsg->flag = (int8_t)pUser->type;
+
+  if (pUser->type == TSDB_ALTER_USER_PRIVILEGES) {
+    pAlterMsg->privilege = (char)pCmd->count;
+  } else if (pUser->type == TSDB_ALTER_USER_PASSWD) {
+    strncpy(pAlterMsg->pass, pUser->passwd.z, pUser->passwd.n);
+  } else { // create user password info
+    strncpy(pAlterMsg->pass, pUser->passwd.z, pUser->passwd.n);
+  }
+
+  if (pUser->type == TSDB_ALTER_USER_PASSWD || pUser->type == TSDB_ALTER_USER_PRIVILEGES) {
+    pCmd->msgType = TSDB_MSG_TYPE_ALTER_USER;
+  } else {
+    pCmd->msgType = TSDB_MSG_TYPE_CREATE_USER;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t tscBuildCfgDnodeMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+  pCmd->payloadLen = sizeof(SCfgDnodeMsg);
+  pCmd->msgType = TSDB_MSG_TYPE_CONFIG_DNODE;
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t tscBuildDropDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+  pCmd->payloadLen = sizeof(SDropDbMsg);
+
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  SDropDbMsg *pDropDbMsg = (SDropDbMsg*)pCmd->payload;
+
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
+
+  int32_t code = tNameExtractFullName(&pTableMetaInfo->name, pDropDbMsg->db);
+  assert(code == TSDB_CODE_SUCCESS && pTableMetaInfo->name.type == TSDB_DB_NAME_T);
+
+  pDropDbMsg->ignoreNotExists = pInfo->pMiscInfo->existsCheck ? 1 : 0;
+
+  pCmd->msgType = (pInfo->pMiscInfo->dbType == TSDB_DB_TYPE_DEFAULT) ? TSDB_MSG_TYPE_DROP_DB : TSDB_MSG_TYPE_DROP_TP;
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t tscBuildDropFuncMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+
+  pCmd->msgType = TSDB_MSG_TYPE_DROP_FUNCTION;
+
+  pCmd->payloadLen = sizeof(SDropFuncMsg);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
+int32_t tscBuildDropTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+  pCmd->payloadLen = sizeof(SCMDropTableMsg);
+
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  SCMDropTableMsg *pDropTableMsg = (SCMDropTableMsg*)pCmd->payload;
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
+  tNameExtractFullName(&pTableMetaInfo->name, pDropTableMsg->name);
+
+  pDropTableMsg->supertable = (pInfo->pMiscInfo->tableType == TSDB_SUPER_TABLE)? 1:0;
+  pDropTableMsg->igNotExists = pInfo->pMiscInfo->existsCheck ? 1 : 0;
+  pCmd->msgType = TSDB_MSG_TYPE_DROP_TABLE;
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t tscBuildDropDnodeMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+
+  char dnodeEp[TSDB_EP_LEN] = {0};
+  tstrncpy(dnodeEp, pCmd->payload, TSDB_EP_LEN);
+
+  pCmd->payloadLen = sizeof(SDropDnodeMsg);
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  SDropDnodeMsg * pDrop = (SDropDnodeMsg *)pCmd->payload;
+  tstrncpy(pDrop->ep, dnodeEp, tListLen(pDrop->ep));
+  pCmd->msgType = TSDB_MSG_TYPE_DROP_DNODE;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t tscBuildDropUserAcctMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+
+  char user[TSDB_USER_LEN] = {0};
+  tstrncpy(user, pCmd->payload, TSDB_USER_LEN);
+
+  pCmd->payloadLen = sizeof(SDropUserMsg);
+  pCmd->msgType = (pInfo->type == TSDB_SQL_DROP_USER)? TSDB_MSG_TYPE_DROP_USER:TSDB_MSG_TYPE_DROP_ACCT;
+
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  SDropUserMsg *pDropMsg = (SDropUserMsg *)pCmd->payload;
+  tstrncpy(pDropMsg->user, user, tListLen(user));
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t tscBuildUseDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+  pCmd->payloadLen = sizeof(SUseDbMsg);
+
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  SUseDbMsg *pUseDbMsg = (SUseDbMsg *)pCmd->payload;
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
+  tNameExtractFullName(&pTableMetaInfo->name, pUseDbMsg->db);
+  pCmd->msgType = TSDB_MSG_TYPE_USE_DB;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t tscBuildSyncDbReplicaMsg(SSqlObj* pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+  pCmd->payloadLen = sizeof(SSyncDbMsg);
+
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  SSyncDbMsg *pSyncMsg = (SSyncDbMsg *)pCmd->payload;
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
+  tNameExtractFullName(&pTableMetaInfo->name, pSyncMsg->db);
+  pCmd->msgType = TSDB_MSG_TYPE_SYNC_DB;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t tscBuildShowMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+  pCmd->msgType = TSDB_MSG_TYPE_SHOW;
+  pCmd->payloadLen = sizeof(SShowMsg) + 100;
+
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  SShowInfo *pShowInfo = &pInfo->pMiscInfo->showOpt;
+  SShowMsg  *pShowMsg = (SShowMsg *)pCmd->payload;
+
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
+  if (pShowInfo->showType == TSDB_MGMT_TABLE_FUNCTION) {
+    pShowMsg->type = pShowInfo->showType;
+    pShowMsg->payloadLen = 0;
+    pCmd->payloadLen = sizeof(SShowMsg);
+
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if (tNameIsEmpty(&pTableMetaInfo->name)) {
+    char *p = cloneCurrentDBName(pSql);
+    tstrncpy(pShowMsg->db, p, sizeof(pShowMsg->db));
+    tfree(p);
+  } else {
+    tNameGetFullDbName(&pTableMetaInfo->name, pShowMsg->db);
+  }
+
+  pShowMsg->type = pShowInfo->showType;
+
+  if (pShowInfo->showType != TSDB_MGMT_TABLE_VNODES) {
+    SStrToken *pPattern = &pShowInfo->pattern;
+    if (pPattern->type > 0) {  // only show tables support wildcard query
+      strncpy(pShowMsg->payload, pPattern->z, pPattern->n);
+      pShowMsg->payloadLen = htons(pPattern->n);
+    }
+  } else {
+    SStrToken *pEpAddr = &pShowInfo->prefix;
+    assert(pEpAddr->n > 0 && pEpAddr->type > 0);
+
+    strncpy(pShowMsg->payload, pEpAddr->z, pEpAddr->n);
+    pShowMsg->payloadLen = htons(pEpAddr->n);
+  }
+
+  pCmd->payloadLen = sizeof(SShowMsg) + htons(pShowMsg->payloadLen);
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t tscBuildKillMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+  pCmd->payloadLen = sizeof(SKillQueryMsg);
+
+  switch (pCmd->command) {
+    case TSDB_SQL_KILL_QUERY:
+      pCmd->msgType = TSDB_MSG_TYPE_KILL_QUERY;
+      break;
+    case TSDB_SQL_KILL_CONNECTION:
+      pCmd->msgType = TSDB_MSG_TYPE_KILL_CONN;
+      break;
+    case TSDB_SQL_KILL_STREAM:
+      pCmd->msgType = TSDB_MSG_TYPE_KILL_STREAM;
+      break;
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
+int tscEstimateCreateTableMsgLength(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &(pSql->cmd);
+  int32_t size = minMsgSize() + sizeof(SCMCreateTableMsg) + sizeof(SCreateTableMsg);
+
+  SCreateTableSql *pCreateTableInfo = pInfo->pCreateTableInfo;
+  if (pCreateTableInfo->type == TSQL_CREATE_TABLE_FROM_STABLE) {
+    int32_t numOfTables = (int32_t)taosArrayGetSize(pInfo->pCreateTableInfo->childTableInfo);
+    size += numOfTables * (sizeof(SCreateTableMsg) + TSDB_MAX_TAGS_LEN);
+  } else {
+    size += sizeof(SSchema) * (pCmd->numOfCols + pCmd->count);
+  }
+
+  if (pCreateTableInfo->pSelect != NULL) {
+    size += (pCreateTableInfo->pSelect->sqlstr.n + 1);
+  }
+
+  return size + TSDB_EXTRA_PAYLOAD_SIZE;
+}
+
+int tscBuildCreateTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  int      msgLen = 0;
+  int      size = 0;
+  SSchema *pSchema;
+  SSqlCmd *pCmd = &pSql->cmd;
+
+  SQueryInfo     *pQueryInfo = tscGetQueryInfo(pCmd);
+  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+
+  // Reallocate the payload size
+  size = tscEstimateCreateTableMsgLength(pSql, pInfo);
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, size)) {
+    tscError("0x%"PRIx64" failed to malloc for create table msg", pSql->self);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  SCMCreateTableMsg *pCreateTableMsg = (SCMCreateTableMsg *)pCmd->payload;
+
+  SCreateTableMsg* pCreateMsg = (SCreateTableMsg*)((char*) pCreateTableMsg + sizeof(SCMCreateTableMsg));
+  char* pMsg = NULL;
+
+  int8_t type = pInfo->pCreateTableInfo->type;
+  if (type == TSQL_CREATE_TABLE_FROM_STABLE) {  // create by using super table, tags value
+    SArray* list = pInfo->pCreateTableInfo->childTableInfo;
+
+    int32_t numOfTables = (int32_t) taosArrayGetSize(list);
+    pCreateTableMsg->numOfTables = htonl(numOfTables);
+
+    pMsg = (char*) pCreateMsg;
+    for(int32_t i = 0; i < numOfTables; ++i) {
+      SCreateTableMsg* pCreate = (SCreateTableMsg*) pMsg;
+
+      pCreate->numOfColumns = htons(pCmd->numOfCols);
+      pCreate->numOfTags = htons(pCmd->count);
+      pMsg += sizeof(SCreateTableMsg);
+
+      SCreatedTableInfo* p = taosArrayGet(list, i);
+      strcpy(pCreate->tableName, p->fullname);
+      pCreate->igExists = (p->igExist)? 1 : 0;
+
+      // use dbinfo from table id without modifying current db info
+      pMsg = serializeTagData(&p->tagdata, pMsg);
+
+      int32_t len = (int32_t)(pMsg - (char*) pCreate);
+      pCreate->len = htonl(len);
+    }
+  } else {  // create (super) table
+    pCreateTableMsg->numOfTables = htonl(1); // only one table will be created
+
+    int32_t code = tNameExtractFullName(&pTableMetaInfo->name, pCreateMsg->tableName);
+    assert(code == 0);
+
+    SCreateTableSql *pCreateTable = pInfo->pCreateTableInfo;
+
+    pCreateMsg->igExists = pCreateTable->existCheck ? 1 : 0;
+    pCreateMsg->numOfColumns = htons(pCmd->numOfCols);
+    pCreateMsg->numOfTags = htons(pCmd->count);
+
+    pCreateMsg->sqlLen = 0;
+    pMsg = (char *)pCreateMsg->schema;
+
+    pSchema = (SSchema *)pCreateMsg->schema;
+
+    for (int i = 0; i < pCmd->numOfCols + pCmd->count; ++i) {
+      TAOS_FIELD *pField = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, i);
+
+      pSchema->type = pField->type;
+      strcpy(pSchema->name, pField->name);
+      pSchema->bytes = htons(pField->bytes);
+
+      pSchema++;
+    }
+
+    pMsg = (char *)pSchema;
+    if (type == TSQL_CREATE_STREAM) {  // check if it is a stream sql
+      SSqlNode *pQuerySql = pInfo->pCreateTableInfo->pSelect;
+
+      strncpy(pMsg, pQuerySql->sqlstr.z, pQuerySql->sqlstr.n + 1);
+      pCreateMsg->sqlLen = htons(pQuerySql->sqlstr.n + 1);
+      pMsg += pQuerySql->sqlstr.n + 1;
+    }
+  }
+
+  tscFieldInfoClear(&pQueryInfo->fieldsInfo);
+
+  msgLen = (int32_t)(pMsg - (char*)pCreateTableMsg);
+  pCreateTableMsg->contLen = htonl(msgLen);
+  pCmd->payloadLen = msgLen;
+  pCmd->msgType = TSDB_MSG_TYPE_CREATE_TABLE;
+
+  assert(msgLen + minMsgSize() <= size);
+  return TSDB_CODE_SUCCESS;
+}
+
+int tscEstimateAlterTableMsgLength(SSqlCmd *pCmd) {
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
+  return minMsgSize() + sizeof(SAlterTableMsg) + sizeof(SSchema) * tscNumOfFields(pQueryInfo) + TSDB_EXTRA_PAYLOAD_SIZE;
+}
+
+int tscBuildAlterTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  char *pMsg;
+  int   msgLen = 0;
+
+  SSqlCmd    *pCmd = &pSql->cmd;
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
+
+  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+
+  SAlterTableInfo *pAlterInfo = pInfo->pAlterInfo;
+  int size = tscEstimateAlterTableMsgLength(pCmd);
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, size)) {
+    tscError("0x%"PRIx64" failed to malloc for alter table msg", pSql->self);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  SAlterTableMsg *pAlterTableMsg = (SAlterTableMsg *)pCmd->payload;
+
+  tNameExtractFullName(&pTableMetaInfo->name, pAlterTableMsg->tableFname);
+  pAlterTableMsg->type = htons(pAlterInfo->type);
+
+  pAlterTableMsg->numOfCols = htons(tscNumOfFields(pQueryInfo));
+  SSchema *pSchema = pAlterTableMsg->schema;
+  for (int i = 0; i < tscNumOfFields(pQueryInfo); ++i) {
+    TAOS_FIELD *pField = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, i);
+
+    pSchema->type = pField->type;
+    strcpy(pSchema->name, pField->name);
+    pSchema->bytes = htons(pField->bytes);
+    pSchema++;
+  }
+
+  pMsg = (char *)pSchema;
+  pAlterTableMsg->tagValLen = htonl(pAlterInfo->tagData.dataLen);
+  if (pAlterInfo->tagData.dataLen > 0) {
+    memcpy(pMsg, pAlterInfo->tagData.data, pAlterInfo->tagData.dataLen);
+  }
+  pMsg += pAlterInfo->tagData.dataLen;
+
+  msgLen = (int32_t)(pMsg - (char*)pAlterTableMsg);
+
+  pCmd->payloadLen = msgLen;
+  pCmd->msgType = TSDB_MSG_TYPE_ALTER_TABLE;
+
+  assert(msgLen + minMsgSize() <= size);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int tscBuildUpdateTagMsg(SSqlObj* pSql, SSqlInfo *pInfo) {
+  SSqlCmd* pCmd = &pSql->cmd;
+  pCmd->msgType = TSDB_MSG_TYPE_UPDATE_TAG_VAL;
+
+  SUpdateTableTagValMsg* pUpdateMsg = (SUpdateTableTagValMsg*) pCmd->payload;
+  pCmd->payloadLen = htonl(pUpdateMsg->head.contLen);
+
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
+  STableMeta *pTableMeta = tscGetMetaInfo(pQueryInfo, 0)->pTableMeta;
+
+  SNewVgroupInfo vgroupInfo = {.vgId = -1};
+  taosHashGetClone(tscVgroupMap, &pTableMeta->vgId, sizeof(pTableMeta->vgId), NULL, &vgroupInfo);
+  assert(vgroupInfo.vgId > 0);
+
+  tscDumpEpSetFromVgroupInfo(&pSql->epSet, &vgroupInfo);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int tscAlterDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+  pCmd->payloadLen = sizeof(SAlterDbMsg);
+  pCmd->msgType = (pInfo->pMiscInfo->dbOpt.dbType == TSDB_DB_TYPE_DEFAULT) ? TSDB_MSG_TYPE_ALTER_DB : TSDB_MSG_TYPE_ALTER_TP;
+
+  SAlterDbMsg *pAlterDbMsg = (SAlterDbMsg* )pCmd->payload;
+  pAlterDbMsg->dbType = -1;
+
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
+  tNameExtractFullName(&pTableMetaInfo->name, pAlterDbMsg->db);
+
+  return TSDB_CODE_SUCCESS;
+}
+int tscBuildCompactMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  if (pInfo->list == NULL || taosArrayGetSize(pInfo->list) <= 0) {
+    return TSDB_CODE_TSC_INVALID_OPERATION;
+  }
+  STscObj *pObj = pSql->pTscObj;
+  SSqlCmd *pCmd = &pSql->cmd;
+  SArray *pList = pInfo->list;
+  int32_t size  = (int32_t)taosArrayGetSize(pList);
+
+  int32_t *result = malloc(sizeof(int32_t) * size);
+  if (result == NULL) {
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  for (int32_t i = 0; i < size; i++) {
+    tSqlExprItem* pSub = taosArrayGet(pList, i);
+    tVariant* pVar = &pSub->pNode->value;
+    if (pVar->nType >= TSDB_DATA_TYPE_TINYINT && pVar->nType <= TSDB_DATA_TYPE_BIGINT) {
+      result[i] = (int32_t)(pVar->i64);
+    } else {
+      free(result);
+      return TSDB_CODE_TSC_INVALID_OPERATION;
+    }
+  }
+
+  int count = removeDupVgid(result, size);
+  pCmd->payloadLen = sizeof(SCompactMsg) + count * sizeof(int32_t);
+  pCmd->msgType = TSDB_MSG_TYPE_COMPACT_VNODE;
+
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
+    free(result);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+  SCompactMsg *pCompactMsg = (SCompactMsg *)pCmd->payload;
+
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0);
+
+  if (tNameIsEmpty(&pTableMetaInfo->name)) {
+    pthread_mutex_lock(&pObj->mutex);
+    tstrncpy(pCompactMsg->db, pObj->db, sizeof(pCompactMsg->db));
+    pthread_mutex_unlock(&pObj->mutex);
+  } else {
+    tNameGetFullDbName(&pTableMetaInfo->name, pCompactMsg->db);
+  }
+
+  pCompactMsg->numOfVgroup = htons(count);
+  for (int32_t i = 0; i < count; i++) {
+    pCompactMsg->vgid[i] = htons(result[i]);
+  }
+  free(result);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int tscBuildRetrieveFromMgmtMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+  pCmd->msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE;
+  pCmd->payloadLen = sizeof(SRetrieveTableMsg);
+
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
+  SRetrieveTableMsg *pRetrieveMsg = (SRetrieveTableMsg*)pCmd->payload;
+  pRetrieveMsg->qId  = htobe64(pSql->res.qId);
+  pRetrieveMsg->free = htons(pQueryInfo->type);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+/*
+ * this function can only be called once.
+ * by using pRes->rspType to denote its status
+ *
+ * if pRes->rspType is 1, no more result
+ */
+static int tscLocalResultCommonBuilder(SSqlObj *pSql, int32_t numOfRes) {
+  SSqlRes *pRes = &pSql->res;
+  SSqlCmd *pCmd = &pSql->cmd;
+
+  pRes->code = TSDB_CODE_SUCCESS;
+  if (pRes->rspType == 0) {
+    pRes->numOfRows = numOfRes;
+    pRes->row = 0;
+    pRes->rspType = 1;
+
+    SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
+    if (tscCreateResPointerInfo(pRes, pQueryInfo) != TSDB_CODE_SUCCESS) {
+      return pRes->code;
+    }
+
+    tscSetResRawPtr(pRes, pQueryInfo);
+  } else {
+    tscResetForNextRetrieve(pRes);
+  }
+
+  uint8_t code = pSql->res.code;
+  if (pSql->fp) {
+    if (code == TSDB_CODE_SUCCESS) {
+      (*pSql->fp)(pSql->param, pSql, pSql->res.numOfRows);
+    } else {
+      tscAsyncResultOnError(pSql);
+    }
+  }
+
+  return code;
+}
+
+int tscProcessDescribeTableRsp(SSqlObj *pSql) {
+  SSqlCmd *       pCmd = &pSql->cmd;
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
+
+  STableComInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
+
+  int32_t numOfRes = tinfo.numOfColumns + tinfo.numOfTags;
+  return tscLocalResultCommonBuilder(pSql, numOfRes);
+}
+
+int tscProcessLocalRetrieveRsp(SSqlObj *pSql) {
+  int32_t numOfRes = 1;
+  pSql->res.completed = true;
+  return tscLocalResultCommonBuilder(pSql, numOfRes);
+}
+
+int tscProcessRetrieveGlobalMergeRsp(SSqlObj *pSql) {
+  SSqlRes *pRes = &pSql->res;
+  SSqlCmd* pCmd = &pSql->cmd;
+
+  int32_t code = pRes->code;
+  if (pRes->code != TSDB_CODE_SUCCESS) {
+    tscAsyncResultOnError(pSql);
+    return code;
+  }
+
+  if (pRes->pMerger == NULL) { // no result from subquery, so abort here directly.
+    (*pSql->fp)(pSql->param, pSql, pRes->numOfRows);
+    return code;
+  }
+
+  // global aggregation may be the upstream for parent query
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
+  if (pQueryInfo->pQInfo == NULL) {
+    STableGroupInfo tableGroupInfo = {.numOfTables = 1, .pGroupList = taosArrayInit(1, POINTER_BYTES),};
+    tableGroupInfo.map = taosHashInit(1, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_NO_LOCK);
+
+    STableKeyInfo tableKeyInfo = {.pTable = NULL, .lastKey = INT64_MIN};
+
+    SArray* group = taosArrayInit(1, sizeof(STableKeyInfo));
+    taosArrayPush(group, &tableKeyInfo);
+    taosArrayPush(tableGroupInfo.pGroupList, &group);
+
+    tscDebug("0x%"PRIx64" create QInfo 0x%"PRIx64" to execute query processing", pSql->self, pSql->self);
+    pQueryInfo->pQInfo = createQInfoFromQueryNode(pQueryInfo, &tableGroupInfo, NULL, NULL, pRes->pMerger, MERGE_STAGE, pSql->self);
+  }
+
+  uint64_t localQueryId = pSql->self;
+  qTableQuery(pQueryInfo->pQInfo, &localQueryId);
+  convertQueryResult(pRes, pQueryInfo, pSql->self, true);
+
+  code = pRes->code;
+  if (pRes->code == TSDB_CODE_SUCCESS) {
+    (*pSql->fp)(pSql->param, pSql, pRes->numOfRows);
+  } else {
+    tscAsyncResultOnError(pSql);
+  }
+
+  return code;
+}
+
+int tscProcessEmptyResultRsp(SSqlObj *pSql) { return tscLocalResultCommonBuilder(pSql, 0); }
+
+int tscBuildConnectMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  STscObj *pObj = pSql->pTscObj;
+  SSqlCmd *pCmd = &pSql->cmd;
+  pCmd->msgType = TSDB_MSG_TYPE_CONNECT;
+  pCmd->payloadLen = sizeof(SConnectMsg);
+
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  SConnectMsg *pConnect = (SConnectMsg*)pCmd->payload;
+
+  // TODO refactor full_name
+  char *db;  // ugly code to move the space
+
+  pthread_mutex_lock(&pObj->mutex);
+  db = strstr(pObj->db, TS_PATH_DELIMITER);
+
+  db = (db == NULL) ? pObj->db : db + 1;
+  tstrncpy(pConnect->db, db, sizeof(pConnect->db));
+  pthread_mutex_unlock(&pObj->mutex);
+
+  tstrncpy(pConnect->clientVersion, version, sizeof(pConnect->clientVersion));
+  tstrncpy(pConnect->msgVersion, "", sizeof(pConnect->msgVersion));
+
+  pConnect->pid = htonl(taosGetPId());
+  taosGetCurrentAPPName(pConnect->appName, NULL);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+/**
+ *  multi table meta req pkg format:
+ *  |SMultiTableInfoMsg | tableId0 | tableId1 | tableId2 | ......
+ *      4B
+ **/
+int tscBuildMultiTableMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+
+  pCmd->msgType = TSDB_MSG_TYPE_TABLES_META;
+  assert(pCmd->payloadLen + minMsgSize() <= pCmd->allocSize);
+
+  tscDebug("0x%"PRIx64" build load multi-tablemeta msg completed, numOfTables:%d, msg size:%d", pSql->self, pCmd->count,
+      pCmd->payloadLen);
+
+  return pCmd->payloadLen;
+}
+
+int tscBuildSTableVgroupMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+
+  char* pMsg = pCmd->payload;
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
+
+  SSTableVgroupMsg *pStableVgroupMsg = (SSTableVgroupMsg *)pMsg;
+  pStableVgroupMsg->numOfTables = htonl(pQueryInfo->numOfTables);
+  pMsg += sizeof(SSTableVgroupMsg);
+
+  for (int32_t i = 0; i < pQueryInfo->numOfTables; ++i) {
+    STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, i);
+    int32_t code = tNameExtractFullName(&pTableMetaInfo->name, pMsg);
+    assert(code == TSDB_CODE_SUCCESS);
+
+    pMsg += TSDB_TABLE_FNAME_LEN;
+  }
+
+  pCmd->msgType = TSDB_MSG_TYPE_STABLE_VGROUP;
+  pCmd->payloadLen = (int32_t)(pMsg - pCmd->payload);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int tscBuildRetrieveFuncMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+
+  char *pMsg = pCmd->payload;
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
+  int32_t numOfFuncs = (int32_t)taosArrayGetSize(pQueryInfo->pUdfInfo);
+
+  SRetrieveFuncMsg *pRetrieveFuncMsg = (SRetrieveFuncMsg *)pMsg;
+  pRetrieveFuncMsg->num = htonl(numOfFuncs);
+
+  pMsg += sizeof(SRetrieveFuncMsg);
+  for(int32_t i = 0; i < numOfFuncs; ++i) {
+    SUdfInfo* pUdf = taosArrayGet(pQueryInfo->pUdfInfo, i);
+    STR_TO_NET_VARSTR(pMsg, pUdf->name);
+    pMsg += varDataNetTLen(pMsg);
+  }
+
+  pCmd->msgType = TSDB_MSG_TYPE_RETRIEVE_FUNC;
+  pCmd->payloadLen = (int32_t)(pMsg - pCmd->payload);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int tscBuildHeartBeatMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+  STscObj *pObj = pSql->pTscObj;
+
+  pthread_mutex_lock(&pObj->mutex);
+
+  int32_t numOfQueries = 2;
+  SSqlObj *tpSql = pObj->sqlList;
+  while (tpSql) {
+    tpSql = tpSql->next;
+    numOfQueries++;
+  }
+
+  int32_t numOfStreams = 2;
+  SSqlStream *pStream = pObj->streamList;
+  while (pStream) {
+    pStream = pStream->next;
+    numOfStreams++;
+  }
+
+  int size = numOfQueries * sizeof(SQueryDesc) + numOfStreams * sizeof(SStreamDesc) + sizeof(SHeartBeatMsg) + 100;
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, size)) {
+    pthread_mutex_unlock(&pObj->mutex);
+    tscError("0x%"PRIx64" failed to create heartbeat msg", pSql->self);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  // TODO the expired hb and client can not be identified by server till now.
+  SHeartBeatMsg *pHeartbeat = (SHeartBeatMsg *)pCmd->payload;
+  tstrncpy(pHeartbeat->clientVer, version, tListLen(pHeartbeat->clientVer));
+
+  pHeartbeat->numOfQueries = numOfQueries;
+  pHeartbeat->numOfStreams = numOfStreams;
+
+  pHeartbeat->pid = htonl(taosGetPId());
+  taosGetCurrentAPPName(pHeartbeat->appName, NULL);
+
+  int msgLen = tscBuildQueryStreamDesc(pHeartbeat, pObj);
+
+  pthread_mutex_unlock(&pObj->mutex);
+
+  pCmd->payloadLen = msgLen;
+  pCmd->msgType = TSDB_MSG_TYPE_HEARTBEAT;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t tableMetaMsgConvert(STableMetaMsg* pMetaMsg) {
+  pMetaMsg->tid = htonl(pMetaMsg->tid);
+  pMetaMsg->sversion = htons(pMetaMsg->sversion);
+  pMetaMsg->tversion = htons(pMetaMsg->tversion);
+  pMetaMsg->vgroup.vgId = htonl(pMetaMsg->vgroup.vgId);
+
+  pMetaMsg->uid = htobe64(pMetaMsg->uid);
+  pMetaMsg->numOfColumns = htons(pMetaMsg->numOfColumns);
+
+  if ((pMetaMsg->tableType != TSDB_SUPER_TABLE) &&
+      (pMetaMsg->tid <= 0 || pMetaMsg->vgroup.vgId < 2 || pMetaMsg->vgroup.numOfEps <= 0)) {
+    tscError("invalid value in table numOfEps:%d, vgId:%d tid:%d, name:%s", pMetaMsg->vgroup.numOfEps, pMetaMsg->vgroup.vgId,
+             pMetaMsg->tid, pMetaMsg->tableFname);
+    return TSDB_CODE_TSC_INVALID_VALUE;
+  }
+
+  if (pMetaMsg->numOfTags > TSDB_MAX_TAGS) {
+    tscError("invalid numOfTags:%d", pMetaMsg->numOfTags);
+    return TSDB_CODE_TSC_INVALID_VALUE;
+  }
+
+  if (pMetaMsg->numOfColumns > TSDB_MAX_COLUMNS || pMetaMsg->numOfColumns <= 0) {
+    tscError("invalid numOfColumns:%d", pMetaMsg->numOfColumns);
+    return TSDB_CODE_TSC_INVALID_VALUE;
+  }
+
+  for (int i = 0; i < pMetaMsg->vgroup.numOfEps; ++i) {
+    pMetaMsg->vgroup.epAddr[i].port = htons(pMetaMsg->vgroup.epAddr[i].port);
+  }
+
+  SSchema* pSchema = pMetaMsg->schema;
+
+  int32_t numOfTotalCols = pMetaMsg->numOfColumns + pMetaMsg->numOfTags;
+  for (int i = 0; i < numOfTotalCols; ++i) {
+    pSchema->bytes = htons(pSchema->bytes);
+    pSchema->colId = htons(pSchema->colId);
+
+    if (pSchema->colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
+      assert(i == 0);
+    }
+
+    pSchema++;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+// update the vgroupInfo if needed
+static void doUpdateVgroupInfo(int32_t vgId, SVgroupMsg *pVgroupMsg) {
+  assert(vgId > 0);
+
+  SNewVgroupInfo vgroupInfo = {.inUse = -1};
+  taosHashGetClone(tscVgroupMap, &vgId, sizeof(vgId), NULL, &vgroupInfo);
+
+  // vgroup info exists, compare with it
+  if (((vgroupInfo.inUse >= 0) && !vgroupInfoIdentical(&vgroupInfo, pVgroupMsg)) || (vgroupInfo.inUse < 0)) {
+    vgroupInfo = createNewVgroupInfo(pVgroupMsg);
+    taosHashPut(tscVgroupMap, &vgId, sizeof(vgId), &vgroupInfo, sizeof(vgroupInfo));
+    tscDebug("add/update new VgroupInfo, vgId:%d, total cached:%d", vgId, (int32_t) taosHashGetSize(tscVgroupMap));
+  }
+}
+
+static void doAddTableMetaToLocalBuf(STableMeta* pTableMeta, STableMetaMsg* pMetaMsg, bool updateSTable) {
+  if (pTableMeta->tableType == TSDB_CHILD_TABLE) {
+    // add or update the corresponding super table meta data info
+    int32_t len = (int32_t) strnlen(pTableMeta->sTableName, TSDB_TABLE_FNAME_LEN);
+
+    // The super tableMeta already exists, create it according to tableMeta and add it to hash map
+    if (updateSTable) {
+      STableMeta* pSupTableMeta = createSuperTableMeta(pMetaMsg);
+      uint32_t size = tscGetTableMetaSize(pSupTableMeta);
+      int32_t code = taosHashPut(tscTableMetaMap, pTableMeta->sTableName, len, pSupTableMeta, size);
+      assert(code == TSDB_CODE_SUCCESS);
+
+      tfree(pSupTableMeta);
+    }
+
+    CChildTableMeta* cMeta = tscCreateChildMeta(pTableMeta);
+    taosHashPut(tscTableMetaMap, pMetaMsg->tableFname, strlen(pMetaMsg->tableFname), cMeta, sizeof(CChildTableMeta));
+    tfree(cMeta);
+  } else {
+    uint32_t s = tscGetTableMetaSize(pTableMeta);
+    taosHashPut(tscTableMetaMap, pMetaMsg->tableFname, strlen(pMetaMsg->tableFname), pTableMeta, s);
+  }
+}
+
+int tscProcessTableMetaRsp(SSqlObj *pSql) {
+  STableMetaMsg *pMetaMsg = (STableMetaMsg *)pSql->res.pRsp;
+  int32_t code = tableMetaMsgConvert(pMetaMsg);
+  if (code != TSDB_CODE_SUCCESS) {
+    return code;
+  }
+
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0);
+  assert(pTableMetaInfo->pTableMeta == NULL);
+
+  STableMeta* pTableMeta = tscCreateTableMetaFromMsg(pMetaMsg);
+  if (pTableMeta == NULL){
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+  if (!tIsValidSchema(pTableMeta->schema, pTableMeta->tableInfo.numOfColumns, pTableMeta->tableInfo.numOfTags)) {
+    tscError("0x%"PRIx64" invalid table meta from mnode, name:%s", pSql->self, tNameGetTableName(&pTableMetaInfo->name));
+    tfree(pTableMeta);
+    return TSDB_CODE_TSC_INVALID_VALUE;
+  }
+
+  char name[TSDB_TABLE_FNAME_LEN] = {0};
+  tNameExtractFullName(&pTableMetaInfo->name, name);
+  assert(strncmp(pMetaMsg->tableFname, name, tListLen(pMetaMsg->tableFname)) == 0);
+
+  doAddTableMetaToLocalBuf(pTableMeta, pMetaMsg, true);
+  if (pTableMeta->tableType != TSDB_SUPER_TABLE) {
+    doUpdateVgroupInfo(pTableMeta->vgId, &pMetaMsg->vgroup);
+  }
+
+  tscDebug("0x%"PRIx64" recv table meta, uid:%" PRIu64 ", tid:%d, name:%s, numOfCols:%d, numOfTags:%d", pSql->self,
+      pTableMeta->id.uid, pTableMeta->id.tid, tNameGetTableName(&pTableMetaInfo->name), pTableMeta->tableInfo.numOfColumns,
+      pTableMeta->tableInfo.numOfTags);
+
+  free(pTableMeta);
+  return TSDB_CODE_SUCCESS;
+}
+
+static SArray* createVgroupIdListFromMsg(char* pMsg, SHashObj* pSet, char* name, int32_t* size, uint64_t id) {
+  SVgroupsMsg *pVgroupMsg = (SVgroupsMsg *)pMsg;
+
+  pVgroupMsg->numOfVgroups = htonl(pVgroupMsg->numOfVgroups);
+  *size = (int32_t)(sizeof(SVgroupMsg) * pVgroupMsg->numOfVgroups + sizeof(SVgroupsMsg));
+
+  SArray* vgroupIdList = taosArrayInit(pVgroupMsg->numOfVgroups, sizeof(int32_t));
+
+  if (pVgroupMsg->numOfVgroups <= 0) {
+    tscDebug("0x%" PRIx64 " empty vgroup id list, no corresponding tables for stable:%s", id, name);
+  } else {
+    // just init, no need to lock
+    for (int32_t j = 0; j < pVgroupMsg->numOfVgroups; ++j) {
+      SVgroupMsg *vmsg = &pVgroupMsg->vgroups[j];
+      vmsg->vgId = htonl(vmsg->vgId);
+      for (int32_t k = 0; k < vmsg->numOfEps; ++k) {
+        vmsg->epAddr[k].port = htons(vmsg->epAddr[k].port);
+      }
+
+      taosArrayPush(vgroupIdList, &vmsg->vgId);
+
+      if (taosHashGet(pSet, &vmsg->vgId, sizeof(vmsg->vgId)) == NULL) {
+        taosHashPut(pSet, &vmsg->vgId, sizeof(vmsg->vgId), "", 0);
+        doUpdateVgroupInfo(vmsg->vgId, vmsg);
+      }
+    }
+  }
+
+  return vgroupIdList;
+}
+
+static SVgroupsInfo* createVgroupInfoFromMsg(char* pMsg, int32_t* size, uint64_t id) {
+  SVgroupsMsg *pVgroupMsg = (SVgroupsMsg *)pMsg;
+  pVgroupMsg->numOfVgroups = htonl(pVgroupMsg->numOfVgroups);
+
+  *size = (int32_t)(sizeof(SVgroupMsg) * pVgroupMsg->numOfVgroups + sizeof(SVgroupsMsg));
+
+  size_t        vgroupsz = sizeof(SVgroupMsg) * pVgroupMsg->numOfVgroups + sizeof(SVgroupsInfo);
+  SVgroupsInfo *pVgroupInfo = calloc(1, vgroupsz);
+  assert(pVgroupInfo != NULL);
+
+  pVgroupInfo->numOfVgroups = pVgroupMsg->numOfVgroups;
+  if (pVgroupInfo->numOfVgroups <= 0) {
+    tscDebug("0x%" PRIx64 " empty vgroup info, no corresponding tables for stable", id);
+  } else {
+    for (int32_t j = 0; j < pVgroupInfo->numOfVgroups; ++j) {
+      // just init, no need to lock
+      SVgroupMsg *pVgroup = &pVgroupInfo->vgroups[j];
+
+      SVgroupMsg *vmsg = &pVgroupMsg->vgroups[j];
+      vmsg->vgId = htonl(vmsg->vgId);
+      for (int32_t k = 0; k < vmsg->numOfEps; ++k) {
+        vmsg->epAddr[k].port = htons(vmsg->epAddr[k].port);
+      }
+
+      pVgroup->numOfEps = vmsg->numOfEps;
+      pVgroup->vgId = vmsg->vgId;
+      for (int32_t k = 0; k < vmsg->numOfEps; ++k) {
+        pVgroup->epAddr[k].port = vmsg->epAddr[k].port;
+        tstrncpy(pVgroup->epAddr[k].fqdn, vmsg->epAddr[k].fqdn, TSDB_FQDN_LEN);
+//        pVgroup->epAddr[k].fqdn = strndup(vmsg->epAddr[k].fqdn, TSDB_FQDN_LEN);
+      }
+
+      doUpdateVgroupInfo(pVgroup->vgId, vmsg);
+    }
+  }
+
+  return pVgroupInfo;
+}
+
+int tscProcessRetrieveFuncRsp(SSqlObj* pSql) {
+  SSqlCmd* pCmd = &pSql->cmd;
+  SUdfFuncMsg* pFuncMsg = (SUdfFuncMsg *)pSql->res.pRsp;
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
+
+  pFuncMsg->num = htonl(pFuncMsg->num);
+  assert(pFuncMsg->num == taosArrayGetSize(pQueryInfo->pUdfInfo));
+
+  char* pMsg = pFuncMsg->content;
+  for(int32_t i = 0; i < pFuncMsg->num; ++i) {
+    SFunctionInfoMsg* pFunc = (SFunctionInfoMsg*) pMsg;
+
+    for(int32_t j = 0; j < pFuncMsg->num; ++j) {
+      SUdfInfo* pUdfInfo = taosArrayGet(pQueryInfo->pUdfInfo, j);
+      if (strcmp(pUdfInfo->name, pFunc->name) != 0) {
+        continue;
+      }
+
+      if (pUdfInfo->content) {
+        continue;
+      }
+
+      pUdfInfo->resBytes = htons(pFunc->resBytes);
+      pUdfInfo->resType  = pFunc->resType;
+      pUdfInfo->funcType = htonl(pFunc->funcType);
+      pUdfInfo->contLen  = htonl(pFunc->len);
+      pUdfInfo->bufSize  = htonl(pFunc->bufSize);
+
+      pUdfInfo->content = malloc(pUdfInfo->contLen);
+      memcpy(pUdfInfo->content, pFunc->content, pUdfInfo->contLen);
+
+      pMsg += sizeof(SFunctionInfoMsg) + pUdfInfo->contLen;
+    }
+  }
+
+  // master sqlObj locates in param
+  SSqlObj* parent = (SSqlObj*)taosAcquireRef(tscObjRef, (int64_t)pSql->param);
+  if(parent == NULL) {
+    return pSql->res.code;
+  }
+
+  SQueryInfo* parQueryInfo = tscGetQueryInfo(&parent->cmd);
+
+  assert(parent->signature == parent && (int64_t)pSql->param == parent->self);
+  taosArrayDestroy(parQueryInfo->pUdfInfo);
+
+  parQueryInfo->pUdfInfo = pQueryInfo->pUdfInfo;   // assigned to parent sql obj.
+  pQueryInfo->pUdfInfo = NULL;
+  return TSDB_CODE_SUCCESS;
+}
+
+int tscProcessMultiTableMetaRsp(SSqlObj *pSql) {
+  char *rsp = pSql->res.pRsp;
+
+  SMultiTableMeta *pMultiMeta = (SMultiTableMeta *)rsp;
+  pMultiMeta->numOfTables = htonl(pMultiMeta->numOfTables);
+  pMultiMeta->numOfVgroup = htonl(pMultiMeta->numOfVgroup);
+  pMultiMeta->numOfUdf = htonl(pMultiMeta->numOfUdf);
+
+  rsp += sizeof(SMultiTableMeta);
+
+  SSqlObj* pParentSql = (SSqlObj*)taosAcquireRef(tscObjRef, (int64_t)pSql->param);
+  if(pParentSql == NULL) {
+    return pSql->res.code;
+  }
+
+  SSqlCmd *pParentCmd = &pParentSql->cmd;
+  SHashObj *pSet = taosHashInit(pMultiMeta->numOfVgroup, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
+
+  char* buf = NULL;
+  char* pMsg = pMultiMeta->meta;
+
+  // decompresss the message payload
+  if (pMultiMeta->compressed) {
+    buf = malloc(pMultiMeta->rawLen - sizeof(SMultiTableMeta));
+    int32_t len = tsDecompressString(pMultiMeta->meta, pMultiMeta->contLen - sizeof(SMultiTableMeta), 1,
+                                     buf, pMultiMeta->rawLen - sizeof(SMultiTableMeta), ONE_STAGE_COMP, NULL, 0);
+    assert(len == pMultiMeta->rawLen - sizeof(SMultiTableMeta));
+
+    pMsg = buf;
+  }
+
+  if (pParentCmd->pTableMetaMap == NULL) {
+    pParentCmd->pTableMetaMap = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
+  }
+
+  for (int32_t i = 0; i < pMultiMeta->numOfTables; i++) {
+    STableMetaMsg *pMetaMsg = (STableMetaMsg *)pMsg;
+    int32_t code = tableMetaMsgConvert(pMetaMsg);
+    if (code != TSDB_CODE_SUCCESS) {
+      taosHashCleanup(pSet);
+      taosReleaseRef(tscObjRef, pParentSql->self);
+
+      tfree(buf);
+      return code;
+    }
+
+    bool freeMeta = false;
+    STableMeta* pTableMeta = tscCreateTableMetaFromMsg(pMetaMsg);
+    if (!tIsValidSchema(pTableMeta->schema, pTableMeta->tableInfo.numOfColumns, pTableMeta->tableInfo.numOfTags)) {
+      tscError("0x%"PRIx64" invalid table meta from mnode, name:%s", pSql->self, pMetaMsg->tableFname);
+      tfree(pTableMeta);
+      taosHashCleanup(pSet);
+      taosReleaseRef(tscObjRef, pParentSql->self);
+
+      tfree(buf);
+      return TSDB_CODE_TSC_INVALID_VALUE;
+    }
+
+    if (pMultiMeta->metaClone == 1 || pTableMeta->tableType == TSDB_SUPER_TABLE) {
+      STableMetaVgroupInfo p = {.pTableMeta = pTableMeta,};
+      size_t keyLen = strnlen(pMetaMsg->tableFname, TSDB_TABLE_FNAME_LEN);
+      void* t = taosHashGet(pParentCmd->pTableMetaMap, pMetaMsg->tableFname, keyLen);
+      assert(t == NULL);
+
+      taosHashPut(pParentCmd->pTableMetaMap, pMetaMsg->tableFname, keyLen, &p, sizeof(STableMetaVgroupInfo));
+    } else {
+      freeMeta = true;
+    }
+
+    // for each super table, only update meta information once
+    bool updateStableMeta = false;
+    if (pTableMeta->tableType == TSDB_CHILD_TABLE && taosHashGet(pSet, &pMetaMsg->suid, sizeof(pMetaMsg->suid)) == NULL) {
+      updateStableMeta = true;
+      taosHashPut(pSet, &pTableMeta->suid, sizeof(pMetaMsg->suid), "", 0);
+    }
+
+    // create the tableMeta and add it into the TableMeta map
+    doAddTableMetaToLocalBuf(pTableMeta, pMetaMsg, updateStableMeta);
+
+    // for each vgroup, only update the information once.
+    int64_t vgId = pMetaMsg->vgroup.vgId;
+    if (pTableMeta->tableType != TSDB_SUPER_TABLE && taosHashGet(pSet, &vgId, sizeof(vgId)) == NULL) {
+      doUpdateVgroupInfo((int32_t) vgId, &pMetaMsg->vgroup);
+      taosHashPut(pSet, &vgId, sizeof(vgId), "", 0);
+    }
+
+    pMsg += pMetaMsg->contLen;
+    if (freeMeta) {
+      tfree(pTableMeta);
+    }
+  }
+
+  for(int32_t i = 0; i < pMultiMeta->numOfVgroup; ++i) {
+    char fname[TSDB_TABLE_FNAME_LEN] = {0};
+    tstrncpy(fname, pMsg, TSDB_TABLE_FNAME_LEN);
+    size_t len = strnlen(fname, TSDB_TABLE_FNAME_LEN);
+
+    pMsg += TSDB_TABLE_FNAME_LEN;
+
+    STableMetaVgroupInfo* p = taosHashGet(pParentCmd->pTableMetaMap, fname, len);
+    assert(p != NULL);
+
+    int32_t size = 0;
+    if (p->vgroupIdList!= NULL) {
+      taosArrayDestroy(p->vgroupIdList);
+    }
+
+    p->vgroupIdList = createVgroupIdListFromMsg(pMsg, pSet, fname, &size, pSql->self);
+
+    int32_t numOfVgId = (int32_t) taosArrayGetSize(p->vgroupIdList);
+    int32_t s = sizeof(tFilePage) + numOfVgId * sizeof(int32_t);
+
+    tFilePage* idList = calloc(1, s);
+    idList->num = numOfVgId;
+    memcpy(idList->data, TARRAY_GET_START(p->vgroupIdList), numOfVgId * sizeof(int32_t));
+
+    void* idListInst = taosCachePut(tscVgroupListBuf, fname, len, idList, s, 5000);
+    taosCacheRelease(tscVgroupListBuf, (void*) &idListInst, false);
+
+    tfree(idList);
+    pMsg += size;
+  }
+
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pParentCmd);
+  if (pMultiMeta->numOfUdf > 0) {
+    assert(pQueryInfo->pUdfInfo != NULL);
+  }
+
+  for(int32_t i = 0; i < pMultiMeta->numOfUdf; ++i) {
+    SFunctionInfoMsg* pFunc = (SFunctionInfoMsg*) pMsg;
+
+    for(int32_t j = 0; j < pMultiMeta->numOfUdf; ++j) {
+      SUdfInfo* pUdfInfo = taosArrayGet(pQueryInfo->pUdfInfo, j);
+      if (strcmp(pUdfInfo->name, pFunc->name) != 0) {
+        continue;
+      }
+
+      if (pUdfInfo->content) {
+        continue;
+      }
+
+      pUdfInfo->resBytes = htons(pFunc->resBytes);
+      pUdfInfo->resType  = pFunc->resType;
+      pUdfInfo->funcType = htonl(pFunc->funcType);
+      pUdfInfo->contLen  = htonl(pFunc->len);
+      pUdfInfo->bufSize  = htonl(pFunc->bufSize);
+
+      pUdfInfo->content = malloc(pUdfInfo->contLen);
+      memcpy(pUdfInfo->content, pFunc->content, pUdfInfo->contLen);
+
+      pMsg += sizeof(SFunctionInfoMsg) + pUdfInfo->contLen;
+    }
+  }
+
+  pSql->res.code = TSDB_CODE_SUCCESS;
+  pSql->res.numOfTotal = pMultiMeta->numOfTables;
+  tscDebug("0x%"PRIx64" load multi-tableMeta from mnode, numOfTables:%d", pSql->self, pMultiMeta->numOfTables);
+
+  taosHashCleanup(pSet);
+  taosReleaseRef(tscObjRef, pParentSql->self);
+
+  tfree(buf);
+  return TSDB_CODE_SUCCESS;
+}
+
+int tscProcessSTableVgroupRsp(SSqlObj *pSql) {
+  // master sqlObj locates in param
+  SSqlObj* parent = (SSqlObj*)taosAcquireRef(tscObjRef, (int64_t)pSql->param);
+  if(parent == NULL) {
+    return pSql->res.code;
+  }
+
+  assert(parent->signature == parent && (int64_t)pSql->param == parent->self);
+
+  SSqlRes* pRes = &pSql->res;
+
+  // NOTE: the order of several table must be preserved.
+  SSTableVgroupRspMsg *pStableVgroup = (SSTableVgroupRspMsg *)pRes->pRsp;
+  pStableVgroup->numOfTables = htonl(pStableVgroup->numOfTables);
+  char *pMsg = pRes->pRsp + sizeof(SSTableVgroupRspMsg);
+
+  SSqlCmd* pCmd = &parent->cmd;
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
+
+  char fName[TSDB_TABLE_FNAME_LEN] = {0};
+  for(int32_t i = 0; i < pStableVgroup->numOfTables; ++i) {
+    char* name = pMsg;
+    pMsg += TSDB_TABLE_FNAME_LEN;
+
+    STableMetaInfo *pInfo = NULL;
+    for(int32_t j = 0; j < pQueryInfo->numOfTables; ++j) {
+      STableMetaInfo *pInfo1 = tscGetTableMetaInfoFromCmd(pCmd, j);
+      memset(fName, 0, tListLen(fName));
+
+      tNameExtractFullName(&pInfo1->name, fName);
+      if (strcmp(name, fName) != 0) {
+        continue;
+      }
+
+      pInfo = pInfo1;
+      break;
+    }
+
+    if (!pInfo){
+      continue;
+    }
+    int32_t size = 0;
+    pInfo->vgroupList = createVgroupInfoFromMsg(pMsg, &size, pSql->self);
+    pMsg += size;
+  }
+
+  taosReleaseRef(tscObjRef, parent->self);
+  return pSql->res.code;
+}
+
+int tscProcessShowRsp(SSqlObj *pSql) {
+  STableMetaMsg *pMetaMsg;
+  SShowRsp *     pShow;
+  SSchema *      pSchema;
+
+  SSqlRes *pRes = &pSql->res;
+  SSqlCmd *pCmd = &pSql->cmd;
+
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
+
+  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+
+  pShow = (SShowRsp *)pRes->pRsp;
+  pShow->qhandle = htobe64(pShow->qhandle);
+  pRes->qId = pShow->qhandle;
+
+  tscResetForNextRetrieve(pRes);
+  pMetaMsg = &(pShow->tableMeta);
+
+  pMetaMsg->numOfColumns = ntohs(pMetaMsg->numOfColumns);
+
+  pSchema = pMetaMsg->schema;
+  pMetaMsg->tid = ntohs(pMetaMsg->tid);
+  for (int i = 0; i < pMetaMsg->numOfColumns; ++i) {
+    pSchema->bytes = htons(pSchema->bytes);
+    pSchema++;
+  }
+
+  tfree(pTableMetaInfo->pTableMeta);
+  pTableMetaInfo->pTableMeta = tscCreateTableMetaFromMsg(pMetaMsg);
+
+  SSchema *pTableSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
+  if (pQueryInfo->colList == NULL) {
+    pQueryInfo->colList = taosArrayInit(4, POINTER_BYTES);
+  }
+
+  SFieldInfo* pFieldInfo = &pQueryInfo->fieldsInfo;
+
+  SColumnIndex index = {0};
+  pSchema = pMetaMsg->schema;
+
+  uint64_t uid = pTableMetaInfo->pTableMeta->id.uid;
+  for (int16_t i = 0; i < pMetaMsg->numOfColumns; ++i, ++pSchema) {
+    index.columnIndex = i;
+    tscColumnListInsert(pQueryInfo->colList, i, uid, pSchema);
+
+    TAOS_FIELD f = tscCreateField(pSchema->type, pSchema->name, pSchema->bytes);
+    SInternalField* pInfo = tscFieldInfoAppend(pFieldInfo, &f);
+
+    pInfo->pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index,
+                                 pTableSchema[i].type, pTableSchema[i].bytes, getNewResColId(pCmd), pTableSchema[i].bytes, false);
+  }
+
+  pCmd->numOfCols = pQueryInfo->fieldsInfo.numOfOutput;
+  tscFieldInfoUpdateOffset(pQueryInfo);
+  return 0;
+}
+
+static void createHbObj(STscObj* pObj) {
+  if (pObj->hbrid != 0) {
+    return;
+  }
+
+  SSqlObj *pSql = (SSqlObj *)calloc(1, sizeof(SSqlObj));
+  if (NULL == pSql) return;
+
+  pSql->fp = tscProcessHeartBeatRsp;
+
+  SQueryInfo *pQueryInfo = tscGetQueryInfoS(&pSql->cmd);
+  if (pQueryInfo == NULL) {
+    terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    tfree(pSql);
+    return;
+  }
+
+  pQueryInfo->command = TSDB_SQL_HB;
+
+  pSql->cmd.command = pQueryInfo->command;
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(&(pSql->cmd), TSDB_DEFAULT_PAYLOAD_SIZE)) {
+    terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    tfree(pSql);
+    return;
+  }
+
+  pSql->param = pObj;
+  pSql->pTscObj = pObj;
+  pSql->signature = pSql;
+
+  registerSqlObj(pSql);
+  tscDebug("0x%"PRIx64" HB is allocated, pObj:%p", pSql->self, pObj);
+
+  pObj->hbrid = pSql->self;
+}
+
+int tscProcessUseDbRsp(SSqlObj *pSql) {
+  STscObj *       pObj = pSql->pTscObj;
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0);
+
+  pthread_mutex_lock(&pObj->mutex);
+  int ret = tNameExtractFullName(&pTableMetaInfo->name, pObj->db);
+  pthread_mutex_unlock(&pObj->mutex);
+
+  return ret;
+}
+
+//todo only invalid the buffered data that belongs to dropped databases
+int tscProcessDropDbRsp(SSqlObj *pSql) {
+  //TODO LOCK DB WHEN MODIFY IT
+  //pSql->pTscObj->db[0] = 0;
+
+  taosHashClear(tscTableMetaMap);
+  taosHashClear(tscVgroupMap);
+  taosCacheEmpty(tscVgroupListBuf);
+  return 0;
+}
+
+int tscProcessDropTableRsp(SSqlObj *pSql) {
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0);
+  tscRemoveCachedTableMeta(pTableMetaInfo, pSql->self);
+  tfree(pTableMetaInfo->pTableMeta);
+  return 0;
+}
+
+int tscProcessAlterTableMsgRsp(SSqlObj *pSql) {
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0);
+
+  char name[TSDB_TABLE_FNAME_LEN] = {0};
+  tNameExtractFullName(&pTableMetaInfo->name, name);
+
+  tscDebug("0x%"PRIx64" remove tableMeta in hashMap after alter-table: %s", pSql->self, name);
+
+  bool isSuperTable = UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo);
+  taosHashRemove(tscTableMetaMap, name, strnlen(name, TSDB_TABLE_FNAME_LEN));
+  tfree(pTableMetaInfo->pTableMeta);
+
+  if (isSuperTable) {  // if it is a super table, iterate the hashTable and remove all the childTableMeta
+    if (pSql->res.pRsp == NULL) {
+      tscDebug("0x%"PRIx64" unexpected resp from mnode, super table: %s failed to update super table meta ", pSql->self, name);
+      return 0;
+    }
+    return tscProcessTableMetaRsp(pSql);
+  }
+
+  return 0;
+}
+
+int tscProcessAlterDbMsgRsp(SSqlObj *pSql) {
+  UNUSED(pSql);
+  return 0;
+}
+int tscProcessCompactRsp(SSqlObj *pSql) {
+  UNUSED(pSql);
+  return TSDB_CODE_SUCCESS;
+}
+
+int tscProcessShowCreateRsp(SSqlObj *pSql) {
+  return tscLocalResultCommonBuilder(pSql, 1);
+}
+
+int tscProcessQueryRsp(SSqlObj *pSql) {
+  SSqlRes *pRes = &pSql->res;
+
+  SQueryTableRsp *pQueryAttr = (SQueryTableRsp *)pRes->pRsp;
+  pQueryAttr->qId = htobe64(pQueryAttr->qId);
+
+  pRes->qId  = pQueryAttr->qId;
+  pRes->data = NULL;
+
+  tscResetForNextRetrieve(pRes);
+  tscDebug("0x%"PRIx64" query rsp received, qId:0x%"PRIx64, pSql->self, pRes->qId);
+  return 0;
+}
+
+static void decompressQueryColData(SSqlObj *pSql, SSqlRes *pRes, SQueryInfo* pQueryInfo, char **data, int8_t compressed, int32_t compLen) {
+  int32_t decompLen = 0;
+  int32_t numOfCols = pQueryInfo->fieldsInfo.numOfOutput;
+  int32_t *compSizes;
+  char    *pData = *data;
+  compSizes = (int32_t *)(pData + compLen);
+
+  TAOS_FIELD *pField = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, numOfCols - 1);
+  int16_t     offset = tscFieldInfoGetOffset(pQueryInfo, numOfCols - 1);
+  char       *outputBuf = tcalloc(pRes->numOfRows, (pField->bytes + offset));
+
+  char *p = outputBuf;
+  int32_t bufOffset;
+  for (int32_t i = 0; i < numOfCols; ++i) {
+    SInternalField* pInfo = (SInternalField*)TARRAY_GET_ELEM(pQueryInfo->fieldsInfo.internalField, i);
+    bufOffset = pInfo->field.bytes * pRes->numOfRows;
+
+    int32_t flen = (*(tDataTypes[pInfo->field.type].decompFunc))(pData, htonl(compSizes[i]), pRes->numOfRows, p, bufOffset,
+                                                                 compressed, NULL, 0);
+
+    p += flen;
+    decompLen +=flen;
+    pData += htonl(compSizes[i]);
+  }
+
+  /* Resize rsp as decompressed data will occupy more space */
+  pRes->rspLen = pRes->rspLen - (compLen + numOfCols * sizeof(int32_t)) + decompLen;
+  char *new_rsp = (char *)realloc(pRes->pRsp, pRes->rspLen);
+  if (new_rsp == NULL) {
+    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    return;
+  } else {
+    pRes->pRsp = new_rsp;
+    *data = ((SRetrieveTableRsp *)pRes->pRsp)->data;
+    pData = *data + compLen + numOfCols * sizeof(int32_t);
+  }
+
+  tscDebug("0x%"PRIx64" decompress col data, compressed size:%d, decompressed size:%d",
+      pSql->self, (int32_t)(compLen + numOfCols * sizeof(int32_t)), decompLen);
+
+  int32_t tailLen = pRes->rspLen - sizeof(SRetrieveTableRsp) - decompLen;
+  memmove(*data + decompLen, pData, tailLen);
+  memmove(*data, outputBuf, decompLen);
+
+  tfree(outputBuf);
+}
+
+int tscProcessRetrieveRspFromNode(SSqlObj *pSql) {
+  SSqlRes *pRes = &pSql->res;
+  SSqlCmd *pCmd = &pSql->cmd;
+
+  assert(pRes->rspLen >= sizeof(SRetrieveTableRsp));
+
+  SRetrieveTableRsp *pRetrieve = (SRetrieveTableRsp *)pRes->pRsp;
+  if (pRetrieve == NULL) {
+    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    return pRes->code;
+  }
+
+  pRes->numOfRows  = htonl(pRetrieve->numOfRows);
+  pRes->precision  = htons(pRetrieve->precision);
+  pRes->offset     = htobe64(pRetrieve->offset);
+  pRes->useconds   = htobe64(pRetrieve->useconds);
+  pRes->completed  = (pRetrieve->completed == 1);
+  pRes->data       = pRetrieve->data;
+
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
+  if (tscCreateResPointerInfo(pRes, pQueryInfo) != TSDB_CODE_SUCCESS) {
+    return pRes->code;
+  }
+
+  //Decompress col data if compressed from server
+  if (pRetrieve->compressed) {
+    int32_t compLen = htonl(pRetrieve->compLen);
+    decompressQueryColData(pSql, pRes, pQueryInfo, &pRes->data, pRetrieve->compressed, compLen);
+  }
+
+  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+  if ((pCmd->command == TSDB_SQL_RETRIEVE) ||
+      ((UTIL_TABLE_IS_CHILD_TABLE(pTableMetaInfo) || UTIL_TABLE_IS_NORMAL_TABLE(pTableMetaInfo)) &&
+       !TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_SUBQUERY)) ||
+      (tscNonOrderedProjectionQueryOnSTable(pQueryInfo, 0) &&
+       !TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_JOIN_QUERY) &&
+       !TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_JOIN_SEC_STAGE))) {
+    tscSetResRawPtr(pRes, pQueryInfo);
+  }
+
+  if (pSql->pSubscription != NULL) {
+    int32_t numOfCols = pQueryInfo->fieldsInfo.numOfOutput;
+
+    TAOS_FIELD *pField = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, numOfCols - 1);
+    int16_t     offset = tscFieldInfoGetOffset(pQueryInfo, numOfCols - 1);
+
+    char* p = pRes->data + (pField->bytes + offset) * pRes->numOfRows;
+
+    int32_t numOfTables = htonl(*(int32_t*)p);
+    p += sizeof(int32_t);
+    for (int i = 0; i < numOfTables; i++) {
+      int64_t uid = htobe64(*(int64_t*)p);
+      p += sizeof(int64_t);
+      p += sizeof(int32_t); // skip tid
+      TSKEY key = htobe64(*(TSKEY*)p);
+      p += sizeof(TSKEY);
+      tscUpdateSubscriptionProgress(pSql->pSubscription, uid, key);
+    }
+  }
+
+  pRes->row = 0;
+  tscDebug("0x%"PRIx64" numOfRows:%d, offset:%" PRId64 ", complete:%d, qId:0x%"PRIx64, pSql->self, pRes->numOfRows, pRes->offset,
+      pRes->completed, pRes->qId);
+
+  return 0;
+}
+
+void tscTableMetaCallBack(void *param, TAOS_RES *res, int code);
+
+static int32_t getTableMetaFromMnode(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo, bool autocreate) {
+  SSqlObj *pNew = calloc(1, sizeof(SSqlObj));
+  if (NULL == pNew) {
+    tscError("0x%"PRIx64" malloc failed for new sqlobj to get table meta", pSql->self);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  pNew->pTscObj     = pSql->pTscObj;
+  pNew->signature   = pNew;
+  pNew->cmd.command = TSDB_SQL_META;
+
+  tscAddQueryInfo(&pNew->cmd);
+
+  SQueryInfo *pNewQueryInfo = tscGetQueryInfoS(&pNew->cmd);
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(&pNew->cmd, TSDB_DEFAULT_PAYLOAD_SIZE + pSql->cmd.payloadLen)) {
+    tscError("0x%"PRIx64" malloc failed for payload to get table meta", pSql->self);
+
+    tscFreeSqlObj(pNew);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  STableMetaInfo *pNewTableMetaInfo = tscAddEmptyMetaInfo(pNewQueryInfo);
+  assert(pNewQueryInfo->numOfTables == 1);
+
+  tNameAssign(&pNewTableMetaInfo->name, &pTableMetaInfo->name);
+
+  registerSqlObj(pNew);
+
+  pNew->fp    = tscTableMetaCallBack;
+  pNew->param = (void *)pSql->self;
+
+  tscDebug("0x%"PRIx64" new pSqlObj:0x%"PRIx64" to get tableMeta, auto create:%d, metaRid from %"PRId64" to %"PRId64,
+      pSql->self, pNew->self, autocreate, pSql->metaRid, pNew->self);
+  pSql->metaRid = pNew->self;
+
+  {
+    STableInfoMsg  *pInfoMsg = (STableInfoMsg *)pNew->cmd.payload;
+    int32_t code = tNameExtractFullName(&pNewTableMetaInfo->name, pInfoMsg->tableFname);
+    if (code != TSDB_CODE_SUCCESS) {
+      return TSDB_CODE_TSC_INVALID_OPERATION;
+    }
+
+    pInfoMsg->createFlag = htons(autocreate? 1 : 0);
+    char *pMsg = (char *)pInfoMsg + sizeof(STableInfoMsg);
+
+    // tag data exists
+    if (autocreate && pSql->cmd.insertParam.tagData.dataLen != 0) {
+      pMsg = serializeTagData(&pSql->cmd.insertParam.tagData, pMsg);
+    }
+
+    pNew->cmd.payloadLen = (int32_t)(pMsg - (char*)pInfoMsg);
+    pNew->cmd.msgType = TSDB_MSG_TYPE_TABLE_META;
+  }
+
+  int32_t code = tscBuildAndSendRequest(pNew, NULL);
+  if (code == TSDB_CODE_SUCCESS) {
+    code = TSDB_CODE_TSC_ACTION_IN_PROGRESS;  // notify application that current process needs to be terminated
+  }
+
+  return code;
+}
+
+int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVgroupNameList, SArray* pUdfList, __async_cb_func_t fp, bool metaClone) {
+  SSqlObj *pNew = calloc(1, sizeof(SSqlObj));
+  if (NULL == pNew) {
+    tscError("0x%"PRIx64" failed to allocate sqlobj to get multiple table meta", pSql->self);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  pNew->pTscObj     = pSql->pTscObj;
+  pNew->signature   = pNew;
+  pNew->cmd.command = TSDB_SQL_MULTI_META;
+
+  int32_t numOfTable      = (int32_t) taosArrayGetSize(pNameList);
+  int32_t numOfVgroupList = (int32_t) taosArrayGetSize(pVgroupNameList);
+  int32_t numOfUdf        = pUdfList ? (int32_t)taosArrayGetSize(pUdfList) : 0;
+
+  int32_t size = (numOfTable + numOfVgroupList) * TSDB_TABLE_FNAME_LEN + TSDB_FUNC_NAME_LEN * numOfUdf + sizeof(SMultiTableInfoMsg);
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(&pNew->cmd, size)) {
+    tscError("0x%"PRIx64" malloc failed for payload to get table meta", pSql->self);
+    tscFreeSqlObj(pNew);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  SMultiTableInfoMsg* pInfo = (SMultiTableInfoMsg*) pNew->cmd.payload;
+  pInfo->metaClone    = metaClone? 1:0;
+  pInfo->numOfTables  = htonl((uint32_t) taosArrayGetSize(pNameList));
+  pInfo->numOfVgroups = htonl((uint32_t) taosArrayGetSize(pVgroupNameList));
+  pInfo->numOfUdfs    = htonl(numOfUdf);
+
+  char* start = pInfo->tableNames;
+  int32_t len = 0;
+  for(int32_t i = 0; i < numOfTable; ++i) {
+    char* name = taosArrayGetP(pNameList, i);
+    if (i < numOfTable - 1 || numOfVgroupList > 0 || numOfUdf > 0) {
+      len = sprintf(start, "%s,", name);
+    } else {
+      len = sprintf(start, "%s", name);
+    }
+
+    start += len;
+  }
+
+  for(int32_t i = 0; i < numOfVgroupList; ++i) {
+    char* name = taosArrayGetP(pVgroupNameList, i);
+    if (i < numOfVgroupList - 1 || numOfUdf > 0) {
+      len = sprintf(start, "%s,", name);
+    } else {
+      len = sprintf(start, "%s", name);
+    }
+
+    start += len;
+  }
+
+  for(int32_t i = 0; i < numOfUdf; ++i) {
+    SUdfInfo * u = taosArrayGet(pUdfList, i);
+    if (i < numOfUdf - 1) {
+      len = sprintf(start, "%s,", u->name);
+    } else {
+      len = sprintf(start, "%s", u->name);
+    }
+
+    start += len;
+  }
+
+  pNew->cmd.payloadLen = (int32_t) ((start - pInfo->tableNames) + sizeof(SMultiTableInfoMsg));
+  pNew->cmd.msgType = TSDB_MSG_TYPE_TABLES_META;
+
+  registerSqlObj(pNew);
+  tscDebug("0x%"PRIx64" new pSqlObj:0x%"PRIx64" to get %d tableMeta, vgroupInfo:%d, udf:%d, msg size:%d", pSql->self,
+      pNew->self, numOfTable, numOfVgroupList, numOfUdf, pNew->cmd.payloadLen);
+
+  pNew->fp = fp;
+  pNew->param = (void *)pSql->self;
+
+  tscDebug("0x%"PRIx64" metaRid from 0x%" PRIx64 " to 0x%" PRIx64 , pSql->self, pSql->metaRid, pNew->self);
+
+  pSql->metaRid = pNew->self;
+  int32_t code = tscBuildAndSendRequest(pNew, NULL);
+  if (code == TSDB_CODE_SUCCESS) {
+    code = TSDB_CODE_TSC_ACTION_IN_PROGRESS;  // notify application that current process needs to be terminated
+  }
+
+  return code;
+}
+
+int32_t tscGetTableMetaImpl(SSqlObj* pSql, STableMetaInfo *pTableMetaInfo, bool autocreate, bool onlyLocal) {
+  assert(tIsValidName(&pTableMetaInfo->name));
+
+  char name[TSDB_TABLE_FNAME_LEN] = {0};
+  tNameExtractFullName(&pTableMetaInfo->name, name);
+
+  size_t len = strlen(name);
+  // just make runtime happy
+  if (pTableMetaInfo->tableMetaCapacity != 0 && pTableMetaInfo->pTableMeta != NULL) {
+    memset(pTableMetaInfo->pTableMeta, 0, pTableMetaInfo->tableMetaCapacity);
+  }
+
+  if (NULL == taosHashGetCloneExt(tscTableMetaMap, name, len, NULL, (void **)&(pTableMetaInfo->pTableMeta), &pTableMetaInfo->tableMetaCapacity)) {
+    tfree(pTableMetaInfo->pTableMeta);
+  }
+
+  STableMeta* pMeta   = pTableMetaInfo->pTableMeta;
+  STableMeta* pSTMeta = (STableMeta *)(pSql->pBuf);
+
+  if (pMeta && pMeta->id.uid > 0) {
+    // in case of child table, here only get the
+    if (pMeta->tableType == TSDB_CHILD_TABLE) {
+      int32_t code = tscCreateTableMetaFromSTableMeta(&pTableMetaInfo->pTableMeta, name, &pTableMetaInfo->tableMetaCapacity, (STableMeta **)(&pSTMeta));
+      pSql->pBuf   = (void *)(pSTMeta);
+      if (code != TSDB_CODE_SUCCESS) {
+        return getTableMetaFromMnode(pSql, pTableMetaInfo, autocreate);
+      }
+    }
+
+    tscDebug("0x%"PRIx64 " %s retrieve tableMeta from cache, numOfCols:%d, numOfTags:%d", pSql->self, name, pMeta->tableInfo.numOfColumns, pMeta->tableInfo.numOfTags);
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if (onlyLocal) {
+    return TSDB_CODE_TSC_NO_META_CACHED;
+  }
+
+  return getTableMetaFromMnode(pSql, pTableMetaInfo, autocreate);
+}
+
+int32_t tscGetTableMeta(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo) {
+  return tscGetTableMetaImpl(pSql, pTableMetaInfo, false, false);
+}
+
+int tscGetTableMetaEx(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo, bool createIfNotExists, bool onlyLocal) {
+  return tscGetTableMetaImpl(pSql, pTableMetaInfo, createIfNotExists, onlyLocal);
+}
+
+int32_t tscGetUdfFromNode(SSqlObj *pSql, SQueryInfo* pQueryInfo) {
+  SSqlObj *pNew = calloc(1, sizeof(SSqlObj));
+  if (NULL == pNew) {
+    tscError("%p malloc failed for new sqlobj to get user-defined functions", pSql);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  pNew->pTscObj = pSql->pTscObj;
+  pNew->signature = pNew;
+  pNew->cmd.command = TSDB_SQL_RETRIEVE_FUNC;
+
+  if (tscAddQueryInfo(&pNew->cmd) != TSDB_CODE_SUCCESS) {
+    tscError("%p malloc failed for new queryinfo", pSql);
+    tscFreeSqlObj(pNew);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  SQueryInfo *pNewQueryInfo = tscGetQueryInfo(&pNew->cmd);
+
+  pNewQueryInfo->pUdfInfo = taosArrayInit(4, sizeof(SUdfInfo));
+  for(int32_t i = 0; i < taosArrayGetSize(pQueryInfo->pUdfInfo); ++i) {
+    SUdfInfo info = {0};
+    SUdfInfo* p1 = taosArrayGet(pQueryInfo->pUdfInfo, i);
+    info = *p1;
+    info.name = strdup(p1->name);
+    taosArrayPush(pNewQueryInfo->pUdfInfo, &info);
+  }
+
+  pNew->cmd.active = pNewQueryInfo;
+
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(&pNew->cmd, TSDB_DEFAULT_PAYLOAD_SIZE + pSql->cmd.payloadLen)) {
+    tscError("%p malloc failed for payload to get table meta", pSql);
+    tscFreeSqlObj(pNew);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  tscDebug("%p new pSqlObj:%p to retrieve udf", pSql, pNew);
+  registerSqlObj(pNew);
+
+  pNew->fp = tscTableMetaCallBack;
+  pNew->param = (void *)pSql->self;
+
+  tscDebug("%p metaRid from %" PRId64 " to %" PRId64 , pSql, pSql->metaRid, pNew->self);
+
+  pSql->metaRid = pNew->self;
+
+  int32_t code = tscBuildAndSendRequest(pNew, NULL);
+  if (code == TSDB_CODE_SUCCESS) {
+    code = TSDB_CODE_TSC_ACTION_IN_PROGRESS;  // notify application that current process needs to be terminated
+  }
+
+  return code;
+}
+
+static void freeElem(void* p) {
+  tfree(*(char**)p);
+}
+
+/**
+ * retrieve table meta from mnode, and then update the local table meta hashmap.
+ * @param pSql          sql object
+ * @param tableIndex    table index
+ * @return              status code
+ */
+int tscRenewTableMeta(SSqlObj *pSql, int32_t tableIndex) {
+  SSqlCmd* pCmd = &pSql->cmd;
+
+  SQueryInfo     *pQueryInfo = tscGetQueryInfo(pCmd);
+  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, tableIndex);
+
+  char name[TSDB_TABLE_FNAME_LEN] = {0};
+  int32_t code = tNameExtractFullName(&pTableMetaInfo->name, name);
+  if (code != TSDB_CODE_SUCCESS) {
+    tscError("0x%"PRIx64" failed to generate the table full name", pSql->self);
+    return TSDB_CODE_TSC_INVALID_OPERATION;
+  }
+
+  STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
+  if (pTableMeta) {
+    tscDebug("0x%"PRIx64" update table meta:%s, old meta numOfTags:%d, numOfCols:%d, uid:%" PRIu64, pSql->self, name,
+        tscGetNumOfTags(pTableMeta), tscGetNumOfColumns(pTableMeta), pTableMeta->id.uid);
+  }
+
+
+  // remove stored tableMeta info in hash table
+  tscResetSqlCmd(pCmd, true, pSql->self);
+
+  SArray* pNameList  = taosArrayInit(1, POINTER_BYTES);
+  SArray* vgroupList = taosArrayInit(1, POINTER_BYTES);
+
+  char* n = strdup(name);
+  taosArrayPush(pNameList, &n);
+  code = getMultiTableMetaFromMnode(pSql, pNameList, vgroupList, NULL, tscTableMetaCallBack, true);
+  taosArrayDestroyEx(pNameList, freeElem);
+  taosArrayDestroyEx(vgroupList, freeElem);
+
+  return code;
+}
+
+static bool allVgroupInfoRetrieved(SQueryInfo* pQueryInfo) {
+  for (int32_t i = 0; i < pQueryInfo->numOfTables; ++i) {
+    STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, i);
+    if (pTableMetaInfo->vgroupList == NULL) {
+      return false;
+    }
+  }
+
+  // all super tables vgroupinfo are retrieved, no need to retrieve vgroup info anymore
+  return true;
+}
+
+int tscGetSTableVgroupInfo(SSqlObj *pSql, SQueryInfo* pQueryInfo) {
+  int32_t code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
+  if (allVgroupInfoRetrieved(pQueryInfo)) {
+    return TSDB_CODE_SUCCESS;
+  }
+  SSqlObj *pNew = calloc(1, sizeof(SSqlObj));
+  pNew->pTscObj = pSql->pTscObj;
+  pNew->signature = pNew;
+
+  pNew->cmd.command = TSDB_SQL_STABLEVGROUP;
+
+  // TODO TEST IT
+  SQueryInfo *pNewQueryInfo = tscGetQueryInfoS(&pNew->cmd);
+  if (pNewQueryInfo == NULL) {
+    tscFreeSqlObj(pNew);
+    return code;
+  }
+
+  for (int32_t i = 0; i < pQueryInfo->numOfTables; ++i) {
+    STableMetaInfo *pMInfo = tscGetMetaInfo(pQueryInfo, i);
+    STableMeta* pTableMeta = tscTableMetaDup(pMInfo->pTableMeta);
+    tscAddTableMetaInfo(pNewQueryInfo, &pMInfo->name, pTableMeta, NULL, pMInfo->tagColList, pMInfo->pVgroupTables);
+  }
+
+  if ((code = tscAllocPayload(&pNew->cmd, TSDB_DEFAULT_PAYLOAD_SIZE)) != TSDB_CODE_SUCCESS) {
+    tscFreeSqlObj(pNew);
+    return code;
+  }
+
+  pNewQueryInfo->numOfTables = pQueryInfo->numOfTables;
+  registerSqlObj(pNew);
+
+  tscDebug("0x%"PRIx64" svgroupRid from %" PRId64 " to %" PRId64 , pSql->self, pSql->svgroupRid, pNew->self);
+
+  pSql->svgroupRid = pNew->self;
+  tscDebug("0x%"PRIx64" new sqlObj:%p to get vgroupInfo, numOfTables:%d", pSql->self, pNew, pNewQueryInfo->numOfTables);
+
+  pNew->fp = tscTableMetaCallBack;
+  pNew->param = (void *)pSql->self;
+  code = tscBuildAndSendRequest(pNew, NULL);
+  if (code == TSDB_CODE_SUCCESS) {
+    code = TSDB_CODE_TSC_ACTION_IN_PROGRESS;
+  }
+
+  return code;
+}
+
+#endif
+
+int processConnectRsp(SRequestObj *pRequest, const char* pMsg, int32_t msgLen) {
+  STscObj *pTscObj = pRequest->pTscObj;
+
+  SConnectRsp *pConnect = (SConnectRsp *)pMsg;
+  pConnect->acctId    = htonl(pConnect->acctId);
+  pConnect->connId    = htonl(pConnect->connId);
+  pConnect->clusterId = htonl(pConnect->clusterId);
+
+  // TODO refactor
+  pthread_mutex_lock(&pTscObj->mutex);
+  char temp[TSDB_TABLE_FNAME_LEN * 2] = {0};
+  int32_t len = sprintf(temp, "%s%s%s", pTscObj->acctId, TS_PATH_DELIMITER, pTscObj->db);
+
+  assert(len <= sizeof(pTscObj->db));
+  tstrncpy(pTscObj->db, temp, sizeof(pTscObj->db));
+  pthread_mutex_unlock(&pTscObj->mutex);
+
+  assert(pConnect->epSet.numOfEps > 0);
+  if (!isEpsetEqual(&pTscObj->pAppInfo->mgmtEp.epSet, &pConnect->epSet)) {
+    updateEpSet_s(&pTscObj->pAppInfo->mgmtEp, &pConnect->epSet);
+  }
+
+  for (int i = 0; i < pConnect->epSet.numOfEps; ++i) {
+    tscDebug("0x%" PRIx64 " epSet.fqdn[%d]: %s, connObj:0x%"PRIx64, pRequest->requestId, i, pConnect->epSet.fqdn[i], pTscObj->id);
+  }
+
+  pTscObj->connId = pConnect->connId;
+
+  // update the appInstInfo
+  pTscObj->pAppInfo->clusterId = pConnect->clusterId;
+  atomic_add_fetch_64(&pTscObj->pAppInfo->numOfConns, 1);
+
+  tscDebug("0x%" PRIx64 " clusterId:%d, totalConn:%"PRId64, pRequest->requestId, pConnect->clusterId, pTscObj->pAppInfo->numOfConns);
+  //  createHbObj(pTscObj);
+
+  // launch a timer to send heartbeat to maintain the connection and send status to mnode
+  //  taosTmrReset(tscProcessActivityTimer, tsShellActivityTimer * 500, (void *)pTscObj->rid, tscTmr, &pTscObj->pTimer);
+  return 0;
+}
+
+void initMsgHandleFp() {
+#if 0
+  tscBuildMsg[TSDB_SQL_SELECT] = tscBuildQueryMsg;
+  tscBuildMsg[TSDB_SQL_INSERT] = tscBuildSubmitMsg;
+  tscBuildMsg[TSDB_SQL_FETCH] = tscBuildFetchMsg;
+
+  tscBuildMsg[TSDB_SQL_CREATE_DB] = tscBuildCreateDbMsg;
+  tscBuildMsg[TSDB_SQL_CREATE_USER] = tscBuildUserMsg;
+  tscBuildMsg[TSDB_SQL_CREATE_FUNCTION] = tscBuildCreateFuncMsg;
+
+  tscBuildMsg[TSDB_SQL_CREATE_ACCT] = tscBuildAcctMsg;
+  tscBuildMsg[TSDB_SQL_ALTER_ACCT] = tscBuildAcctMsg;
+
+  tscBuildMsg[TSDB_SQL_CREATE_TABLE] = tscBuildCreateTableMsg;
+  tscBuildMsg[TSDB_SQL_DROP_USER] = tscBuildDropUserAcctMsg;
+  tscBuildMsg[TSDB_SQL_DROP_ACCT] = tscBuildDropUserAcctMsg;
+  tscBuildMsg[TSDB_SQL_DROP_DB] = tscBuildDropDbMsg;
+  tscBuildMsg[TSDB_SQL_DROP_FUNCTION] = tscBuildDropFuncMsg;
+  tscBuildMsg[TSDB_SQL_SYNC_DB_REPLICA] = tscBuildSyncDbReplicaMsg;
+  tscBuildMsg[TSDB_SQL_DROP_TABLE] = tscBuildDropTableMsg;
+  tscBuildMsg[TSDB_SQL_ALTER_USER] = tscBuildUserMsg;
+  tscBuildMsg[TSDB_SQL_CREATE_DNODE] = tscBuildCreateDnodeMsg;
+  tscBuildMsg[TSDB_SQL_DROP_DNODE] = tscBuildDropDnodeMsg;
+  tscBuildMsg[TSDB_SQL_CFG_DNODE] = tscBuildCfgDnodeMsg;
+  tscBuildMsg[TSDB_SQL_ALTER_TABLE] = tscBuildAlterTableMsg;
+  tscBuildMsg[TSDB_SQL_UPDATE_TAGS_VAL] = tscBuildUpdateTagMsg;
+  tscBuildMsg[TSDB_SQL_ALTER_DB] = tscAlterDbMsg;
+  tscBuildMsg[TSDB_SQL_COMPACT_VNODE] = tscBuildCompactMsg;
+
+
+  tscBuildMsg[TSDB_SQL_USE_DB] = tscBuildUseDbMsg;
+  tscBuildMsg[TSDB_SQL_STABLEVGROUP] = tscBuildSTableVgroupMsg;
+  tscBuildMsg[TSDB_SQL_RETRIEVE_FUNC] = tscBuildRetrieveFuncMsg;
+
+  tscBuildMsg[TSDB_SQL_HB] = tscBuildHeartBeatMsg;
+  tscBuildMsg[TSDB_SQL_SHOW] = tscBuildShowMsg;
+  tscBuildMsg[TSDB_SQL_RETRIEVE] = tscBuildRetrieveFromMgmtMsg;
+  tscBuildMsg[TSDB_SQL_KILL_QUERY] = tscBuildKillMsg;
+  tscBuildMsg[TSDB_SQL_KILL_STREAM] = tscBuildKillMsg;
+  tscBuildMsg[TSDB_SQL_KILL_CONNECTION] = tscBuildKillMsg;
+
+  tscProcessMsgRsp[TSDB_SQL_SELECT] = tscProcessQueryRsp;
+  tscProcessMsgRsp[TSDB_SQL_FETCH] = tscProcessRetrieveRspFromNode;
+
+  tscProcessMsgRsp[TSDB_SQL_DROP_DB] = tscProcessDropDbRsp;
+  tscProcessMsgRsp[TSDB_SQL_DROP_TABLE] = tscProcessDropTableRsp;
+
+  tscProcessMsgRsp[TSDB_SQL_USE_DB] = tscProcessUseDbRsp;
+  tscProcessMsgRsp[TSDB_SQL_META] = tscProcessTableMetaRsp;
+  tscProcessMsgRsp[TSDB_SQL_STABLEVGROUP] = tscProcessSTableVgroupRsp;
+  tscProcessMsgRsp[TSDB_SQL_MULTI_META] = tscProcessMultiTableMetaRsp;
+  tscProcessMsgRsp[TSDB_SQL_RETRIEVE_FUNC] = tscProcessRetrieveFuncRsp;
+
+  tscProcessMsgRsp[TSDB_SQL_SHOW] = tscProcessShowRsp;
+  tscProcessMsgRsp[TSDB_SQL_RETRIEVE] = tscProcessRetrieveRspFromNode;  // rsp handled by same function.
+  tscProcessMsgRsp[TSDB_SQL_DESCRIBE_TABLE] = tscProcessDescribeTableRsp;
+
+  tscProcessMsgRsp[TSDB_SQL_CURRENT_DB]   = tscProcessLocalRetrieveRsp;
+  tscProcessMsgRsp[TSDB_SQL_CURRENT_USER] = tscProcessLocalRetrieveRsp;
+  tscProcessMsgRsp[TSDB_SQL_SERV_VERSION] = tscProcessLocalRetrieveRsp;
+  tscProcessMsgRsp[TSDB_SQL_CLI_VERSION]  = tscProcessLocalRetrieveRsp;
+  tscProcessMsgRsp[TSDB_SQL_SERV_STATUS]  = tscProcessLocalRetrieveRsp;
+
+  tscProcessMsgRsp[TSDB_SQL_RETRIEVE_EMPTY_RESULT] = tscProcessEmptyResultRsp;
+
+  tscProcessMsgRsp[TSDB_SQL_RETRIEVE_GLOBALMERGE] = tscProcessRetrieveGlobalMergeRsp;
+
+  tscProcessMsgRsp[TSDB_SQL_ALTER_TABLE] = tscProcessAlterTableMsgRsp;
+  tscProcessMsgRsp[TSDB_SQL_ALTER_DB] = tscProcessAlterDbMsgRsp;
+  tscProcessMsgRsp[TSDB_SQL_COMPACT_VNODE] = tscProcessCompactRsp;
+
+  tscProcessMsgRsp[TSDB_SQL_SHOW_CREATE_TABLE] = tscProcessShowCreateRsp;
+  tscProcessMsgRsp[TSDB_SQL_SHOW_CREATE_STABLE] = tscProcessShowCreateRsp;
+  tscProcessMsgRsp[TSDB_SQL_SHOW_CREATE_DATABASE] = tscProcessShowCreateRsp;
+#endif
+
+//  buildRequestMsgFp[TSDB_SQL_CONNECT]  = tscBuildConnectMsg;
+  handleRequestRspFp[TSDB_SQL_CONNECT] = processConnectRsp;
+}
\ No newline at end of file
diff --git a/source/client/src/clientmain.c b/source/client/src/clientmain.c
new file mode 100644
index 0000000000..ba80135850
--- /dev/null
+++ b/source/client/src/clientmain.c
@@ -0,0 +1,85 @@
+#include "clientInt.h"
+#include "trpc.h"
+#include "os.h"
+#include "taosmsg.h"
+#include "tcache.h"
+#include "tconfig.h"
+#include "tglobal.h"
+#include "tnote.h"
+#include "tref.h"
+#include "tscLog.h"
+#include "tsched.h"
+#include "ttime.h"
+#include "ttimezone.h"
+
+#define TSC_VAR_NOT_RELEASE 1
+#define TSC_VAR_RELEASED    0
+
+static int32_t sentinel = TSC_VAR_NOT_RELEASE;
+static pthread_once_t tscinit = PTHREAD_ONCE_INIT;
+
+extern int32_t tscInitRes;
+
+int taos_options(TSDB_OPTION option, const void *arg, ...) {
+  static int32_t lock = 0;
+
+  for (int i = 1; atomic_val_compare_exchange_32(&lock, 0, 1) != 0; ++i) {
+    if (i % 1000 == 0) {
+      tscInfo("haven't acquire lock after spin %d times.", i);
+      sched_yield();
+    }
+  }
+
+  int ret = taos_options_imp(option, (const char*)arg);
+
+  atomic_store_32(&lock, 0);
+  return ret;
+}
+
+int taos_init() {
+  pthread_once(&tscinit, taos_init_imp);
+  return tscInitRes;
+}
+
+// this function may be called by user or system, or by both simultaneously.
+void taos_cleanup(void) {
+  tscDebug("start to cleanup client environment");
+
+  if (atomic_val_compare_exchange_32(&sentinel, TSC_VAR_NOT_RELEASE, TSC_VAR_RELEASED) != TSC_VAR_NOT_RELEASE) {
+    return;
+  }
+
+  int32_t id = tscReqRef;
+  tscReqRef = -1;
+  taosCloseRef(id);
+
+  void* p = tscQhandle;
+  tscQhandle = NULL;
+  taosCleanUpScheduler(p);
+
+  id = tscConnRef;
+  tscConnRef = -1;
+  taosCloseRef(id);
+
+  rpcCleanup();
+  taosCloseLog();
+}
+
+void taos_close(TAOS* taos) {
+  if (taos == NULL) {
+    return;
+  }
+
+  STscObj *pTscObj = (STscObj *)taos;
+  tscDebug("0x%"PRIx64" try to close connection, numOfReq:%d", pTscObj->id, pTscObj->numOfReqs);
+
+  taosRemoveRef(tscConnRef, pTscObj->id);
+}
+
+const char *taos_errstr(TAOS_RES *res) {
+
+}
+
+void taos_free_result(TAOS_RES *res) {
+
+}
\ No newline at end of file
diff --git a/source/client/src/tscEnv.c b/source/client/src/tscEnv.c
new file mode 100644
index 0000000000..43d73bf3db
--- /dev/null
+++ b/source/client/src/tscEnv.c
@@ -0,0 +1,471 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "os.h"
+#include "taosmsg.h"
+#include "tcache.h"
+#include "tconfig.h"
+#include "tglobal.h"
+#include "tnote.h"
+#include "tref.h"
+#include "tscLog.h"
+#include "tsched.h"
+#include "ttime.h"
+#include "trpc.h"
+#include "ttimezone.h"
+#include "clientInt.h"
+
+#define TSC_VAR_NOT_RELEASE 1
+#define TSC_VAR_RELEASED    0
+
+SAppInfo   appInfo;
+int32_t    tscReqRef  = -1;
+int32_t    tscConnRef = -1;
+void      *tscQhandle = NULL;
+
+int32_t tsNumOfThreads = 1;
+volatile int32_t tscInitRes = 0;
+
+static void registerRequest(SRequestObj* pRequest) {
+  STscObj *pTscObj = (STscObj *)taosAcquireRef(tscConnRef, pRequest->pTscObj->id);
+  assert(pTscObj != NULL);
+
+  // connection has been released already, abort creating request.
+  pRequest->self = taosAddRef(tscReqRef, pRequest);
+
+  int32_t num = atomic_add_fetch_32(&pTscObj->numOfReqs, 1);
+
+  if (pTscObj->pAppInfo) {
+    SInstanceActivity *pActivity = &pTscObj->pAppInfo->summary;
+
+    int32_t total = atomic_add_fetch_32(&pActivity->totalRequests, 1);
+    int32_t currentInst = atomic_add_fetch_32(&pActivity->currentRequests, 1);
+    tscDebug("0x%" PRIx64 " new Request from connObj:0x%" PRIx64 ", current:%d, app current:%d, total:%d", pRequest->self,
+             pRequest->pTscObj->id, num, currentInst, total);
+  }
+}
+
+static void deregisterRequest(SRequestObj* pRequest) {
+  assert(pRequest != NULL);
+
+  STscObj* pTscObj = pRequest->pTscObj;
+  SInstanceActivity* pActivity = &pTscObj->pAppInfo->summary;
+
+  int32_t currentInst = atomic_sub_fetch_32(&pActivity->currentRequests, 1);
+  int32_t num   = atomic_sub_fetch_32(&pTscObj->numOfReqs, 1);
+
+  tscDebug("0x%"PRIx64" free Request from connObj: 0x%"PRIx64", current:%d, app current:%d", pRequest->self, pTscObj->id, num, currentInst);
+  taosReleaseRef(tscConnRef, pTscObj->id);
+}
+
+static void tscInitLogFile() {
+  taosReadGlobalLogCfg();
+  if (mkdir(tsLogDir, 0755) != 0 && errno != EEXIST) {
+    printf("failed to create log dir:%s\n", tsLogDir);
+  }
+
+  const char    *defaultLogFileNamePrefix = "taoslog";
+  const int32_t  maxLogFileNum = 10;
+
+  char temp[128] = {0};
+  sprintf(temp, "%s/%s", tsLogDir, defaultLogFileNamePrefix);
+  if (taosInitLog(temp, tsNumOfLogLines, maxLogFileNum) < 0) {
+    printf("failed to open log file in directory:%s\n", tsLogDir);
+  }
+}
+
+void closeTransporter(STscObj* pTscObj)  {
+  if (pTscObj == NULL || pTscObj->pTransporter == NULL) {
+    return;
+  }
+
+  tscDebug("free transporter:%p in connObj: 0x%"PRIx64, pTscObj->pTransporter, pTscObj->id);
+  rpcClose(pTscObj->pTransporter);
+  pTscObj->pTransporter = NULL;
+}
+
+// TODO refactor
+void* openTransporter(const char *user, const char *auth) {
+  SRpcInit rpcInit;
+  memset(&rpcInit, 0, sizeof(rpcInit));
+  rpcInit.localPort = 0;
+  rpcInit.label = "TSC";
+  rpcInit.numOfThreads = tsNumOfThreads;
+  rpcInit.cfp = processMsgFromServer;
+  rpcInit.sessions = tsMaxConnections;
+  rpcInit.connType = TAOS_CONN_CLIENT;
+  rpcInit.user = (char *)user;
+  rpcInit.idleTime = tsShellActivityTimer * 1000;
+  rpcInit.ckey = "key";
+//  rpcInit.spi = 1;
+  rpcInit.secret = (char *)auth;
+
+  void* pDnodeConn = rpcOpen(&rpcInit);
+  if (pDnodeConn == NULL) {
+    tscError("failed to init connection to server");
+    return NULL;
+  }
+
+  return pDnodeConn;
+}
+
+void destroyTscObj(void *pObj) {
+  STscObj *pTscObj = pObj;
+
+  atomic_sub_fetch_64(&pTscObj->pAppInfo->numOfConns, 1);
+  tscDebug("connObj 0x%"PRIx64" destroyed, totalConn:%"PRId64, pTscObj->id, pTscObj->pAppInfo->numOfConns);
+
+  closeTransporter(pTscObj);
+  pthread_mutex_destroy(&pTscObj->mutex);
+  tfree(pTscObj);
+}
+
+void* createTscObj(const char* user, const char* auth, const char *ip, uint32_t port, SAppInstInfo* pAppInfo) {
+  STscObj *pObj = (STscObj *)calloc(1, sizeof(STscObj));
+  if (NULL == pObj) {
+    terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    return NULL;
+  }
+
+  pObj->pAppInfo = pAppInfo;
+  if (pAppInfo != NULL) {
+    pObj->pTransporter = pAppInfo->pTransporter;
+  }
+
+  tstrncpy(pObj->user, user, sizeof(pObj->user));
+  memcpy(pObj->pass, auth, TSDB_PASSWORD_LEN);
+
+  pthread_mutex_init(&pObj->mutex, NULL);
+  pObj->id = taosAddRef(tscConnRef, pObj);
+
+  tscDebug("connObj created, 0x%"PRIx64, pObj->id);
+  return pObj;
+}
+
+void* createRequest(STscObj* pObj, __taos_async_fn_t fp, void* param, int32_t type) {
+  assert(pObj != NULL);
+
+  SRequestObj *pRequest = (SRequestObj *)calloc(1, sizeof(SRequestObj));
+  if (NULL == pRequest) {
+    terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    return NULL;
+  }
+
+  // TODO generated request uuid
+  pRequest->requestId  = 0;
+
+  pRequest->metric.start = taosGetTimestampMs();
+
+  pRequest->type       = type;
+  pRequest->pTscObj    = pObj;
+  pRequest->body.fp    = fp;
+  pRequest->body.param = param;
+  tsem_init(&pRequest->body.rspSem, 0, 0);
+
+  registerRequest(pRequest);
+  return pRequest;
+}
+
+static void doDestroyRequest(void* p) {
+  assert(p != NULL);
+  SRequestObj* pRequest = (SRequestObj*)p;
+
+  assert(RID_VALID(pRequest->self));
+
+  tfree(pRequest->msgBuf);
+  tfree(pRequest->sqlstr);
+  tfree(pRequest->pInfo);
+
+  deregisterRequest(pRequest);
+  tfree(pRequest);
+}
+
+void destroyRequest(SRequestObj* pRequest) {
+  if (pRequest == NULL) {
+    return;
+  }
+
+  taosReleaseRef(tscReqRef, pRequest->self);
+}
+
+void taos_init_imp(void) {
+  // In the APIs of other program language, taos_cleanup is not available yet.
+  // So, to make sure taos_cleanup will be invoked to clean up the allocated resource to suppress the valgrind warning.
+  atexit(taos_cleanup);
+
+  errno = TSDB_CODE_SUCCESS;
+  srand(taosGetTimestampSec());
+
+  deltaToUtcInitOnce();
+  taosInitGlobalCfg();
+  taosReadCfgFromFile();
+
+  tscInitLogFile();
+  if (taosCheckAndPrintCfg()) {
+    tscInitRes = -1;
+    return;
+  }
+
+  taosInitNotes();
+  initMsgHandleFp();
+
+  rpcInit();
+
+  tscDebug("starting to initialize TAOS driver, local ep: %s", tsLocalEp);
+
+  taosSetCoreDump(true);
+
+  double factor = 4.0;
+  int32_t numOfThreads = MAX((int)(tsNumOfCores * tsNumOfThreadsPerCore / factor), 2);
+
+  int32_t queueSize = tsMaxConnections * 2;
+  tscQhandle = taosInitScheduler(queueSize, numOfThreads, "tsc");
+  if (NULL == tscQhandle) {
+    tscError("failed to init task queue");
+    tscInitRes = -1;
+    return;
+  }
+
+  tscDebug("client task queue is initialized, numOfThreads: %d", numOfThreads);
+  tscConnRef = taosOpenRef(200, destroyTscObj);
+  tscReqRef  = taosOpenRef(40960, doDestroyRequest);
+
+  taosGetAppName(appInfo.appName, NULL);
+  appInfo.pid       = taosGetPId();
+  appInfo.startTime = taosGetTimestampMs();
+  appInfo.pInstMap  = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
+
+  tscDebug("client is initialized successfully");
+}
+
+int taos_options_imp(TSDB_OPTION option, const char *str) {
+  SGlobalCfg *cfg = NULL;
+
+  switch (option) {
+    case TSDB_OPTION_CONFIGDIR:
+      cfg = taosGetConfigOption("configDir");
+      assert(cfg != NULL);
+
+      if (cfg->cfgStatus <= TAOS_CFG_CSTATUS_OPTION) {
+        tstrncpy(configDir, str, TSDB_FILENAME_LEN);
+        cfg->cfgStatus = TAOS_CFG_CSTATUS_OPTION;
+        tscInfo("set config file directory:%s", str);
+      } else {
+        tscWarn("config option:%s, input value:%s, is configured by %s, use %s", cfg->option, str, tsCfgStatusStr[cfg->cfgStatus], (char *)cfg->ptr);
+      }
+      break;
+
+    case TSDB_OPTION_SHELL_ACTIVITY_TIMER:
+      cfg = taosGetConfigOption("shellActivityTimer");
+      assert(cfg != NULL);
+
+      if (cfg->cfgStatus <= TAOS_CFG_CSTATUS_OPTION) {
+        tsShellActivityTimer = atoi(str);
+        if (tsShellActivityTimer < 1) tsShellActivityTimer = 1;
+        if (tsShellActivityTimer > 3600) tsShellActivityTimer = 3600;
+        cfg->cfgStatus = TAOS_CFG_CSTATUS_OPTION;
+        tscInfo("set shellActivityTimer:%d", tsShellActivityTimer);
+      } else {
+        tscWarn("config option:%s, input value:%s, is configured by %s, use %d", cfg->option, str, tsCfgStatusStr[cfg->cfgStatus], *(int32_t *)cfg->ptr);
+      }
+      break;
+
+    case TSDB_OPTION_LOCALE: {  // set locale
+      cfg = taosGetConfigOption("locale");
+      assert(cfg != NULL);
+
+      size_t len = strlen(str);
+      if (len == 0 || len > TSDB_LOCALE_LEN) {
+        tscInfo("Invalid locale:%s, use default", str);
+        return -1;
+      }
+
+      if (cfg->cfgStatus <= TAOS_CFG_CSTATUS_OPTION) {
+        char sep = '.';
+
+        if (strlen(tsLocale) == 0) { // locale does not set yet
+          char* defaultLocale = setlocale(LC_CTYPE, "");
+
+          // The locale of the current OS does not be set correctly, so the default locale cannot be acquired.
+          // The launch of current system will abort soon.
+          if (defaultLocale == NULL) {
+            tscError("failed to get default locale, please set the correct locale in current OS");
+            return -1;
+          }
+
+          tstrncpy(tsLocale, defaultLocale, TSDB_LOCALE_LEN);
+        }
+
+        // set the user specified locale
+        char *locale = setlocale(LC_CTYPE, str);
+
+        if (locale != NULL) { // failed to set the user specified locale
+          tscInfo("locale set, prev locale:%s, new locale:%s", tsLocale, locale);
+          cfg->cfgStatus = TAOS_CFG_CSTATUS_OPTION;
+        } else { // set the user specified locale failed, use default LC_CTYPE as current locale
+          locale = setlocale(LC_CTYPE, tsLocale);
+          tscInfo("failed to set locale:%s, current locale:%s", str, tsLocale);
+        }
+
+        tstrncpy(tsLocale, locale, TSDB_LOCALE_LEN);
+
+        char *charset = strrchr(tsLocale, sep);
+        if (charset != NULL) {
+          charset += 1;
+
+          charset = taosCharsetReplace(charset);
+
+          if (taosValidateEncodec(charset)) {
+            if (strlen(tsCharset) == 0) {
+              tscInfo("charset set:%s", charset);
+            } else {
+              tscInfo("charset changed from %s to %s", tsCharset, charset);
+            }
+
+            tstrncpy(tsCharset, charset, TSDB_LOCALE_LEN);
+            cfg->cfgStatus = TAOS_CFG_CSTATUS_OPTION;
+
+          } else {
+            tscInfo("charset:%s is not valid in locale, charset remains:%s", charset, tsCharset);
+          }
+
+          free(charset);
+        } else { // it may be windows system
+          tscInfo("charset remains:%s", tsCharset);
+        }
+      } else {
+        tscWarn("config option:%s, input value:%s, is configured by %s, use %s", cfg->option, str, tsCfgStatusStr[cfg->cfgStatus], (char *)cfg->ptr);
+      }
+      break;
+    }
+
+    case TSDB_OPTION_CHARSET: {
+      /* set charset will override the value of charset, assigned during system locale changed */
+      cfg = taosGetConfigOption("charset");
+      assert(cfg != NULL);
+
+      size_t len = strlen(str);
+      if (len == 0 || len > TSDB_LOCALE_LEN) {
+        tscInfo("failed to set charset:%s", str);
+        return -1;
+      }
+
+      if (cfg->cfgStatus <= TAOS_CFG_CSTATUS_OPTION) {
+        if (taosValidateEncodec(str)) {
+          if (strlen(tsCharset) == 0) {
+            tscInfo("charset is set:%s", str);
+          } else {
+            tscInfo("charset changed from %s to %s", tsCharset, str);
+          }
+
+          tstrncpy(tsCharset, str, TSDB_LOCALE_LEN);
+          cfg->cfgStatus = TAOS_CFG_CSTATUS_OPTION;
+        } else {
+          tscInfo("charset:%s not valid", str);
+        }
+      } else {
+        tscWarn("config option:%s, input value:%s, is configured by %s, use %s", cfg->option, str, tsCfgStatusStr[cfg->cfgStatus], (char *)cfg->ptr);
+      }
+
+      break;
+    }
+
+    case TSDB_OPTION_TIMEZONE:
+      cfg = taosGetConfigOption("timezone");
+      assert(cfg != NULL);
+
+      if (cfg->cfgStatus <= TAOS_CFG_CSTATUS_OPTION) {
+        tstrncpy(tsTimezone, str, TSDB_TIMEZONE_LEN);
+        tsSetTimeZone();
+        cfg->cfgStatus = TAOS_CFG_CSTATUS_OPTION;
+        tscDebug("timezone set:%s, input:%s by taos_options", tsTimezone, str);
+      } else {
+        tscWarn("config option:%s, input value:%s, is configured by %s, use %s", cfg->option, str, tsCfgStatusStr[cfg->cfgStatus], (char *)cfg->ptr);
+      }
+      break;
+
+    default:
+      // TODO return the correct error code to client in the format for taos_errstr()
+      tscError("Invalid option %d", option);
+      return -1;
+  }
+
+  return 0;
+}
+
+#if 0
+#include "cJSON.h"
+static setConfRet taos_set_config_imp(const char *config){
+  setConfRet ret = {SET_CONF_RET_SUCC, {0}};
+  static bool setConfFlag = false;
+  if (setConfFlag) {
+    ret.retCode = SET_CONF_RET_ERR_ONLY_ONCE;
+    strcpy(ret.retMsg, "configuration can only set once");
+    return ret;
+  }
+  taosInitGlobalCfg();
+  cJSON *root = cJSON_Parse(config);
+  if (root == NULL){
+    ret.retCode = SET_CONF_RET_ERR_JSON_PARSE;
+    strcpy(ret.retMsg, "parse json error");
+    return ret;
+  }
+
+  int size = cJSON_GetArraySize(root);
+  if(!cJSON_IsObject(root) || size == 0) {
+    ret.retCode = SET_CONF_RET_ERR_JSON_INVALID;
+    strcpy(ret.retMsg, "json content is invalid, must be not empty object");
+    return ret;
+  }
+
+  if(size >= 1000) {
+    ret.retCode = SET_CONF_RET_ERR_TOO_LONG;
+    strcpy(ret.retMsg, "json object size is too long");
+    return ret;
+  }
+
+  for(int i = 0; i < size; i++){
+    cJSON *item = cJSON_GetArrayItem(root, i);
+    if(!item) {
+      ret.retCode = SET_CONF_RET_ERR_INNER;
+      strcpy(ret.retMsg, "inner error");
+      return ret;
+    }
+    if(!taosReadConfigOption(item->string, item->valuestring, NULL, NULL, TAOS_CFG_CSTATUS_OPTION, TSDB_CFG_CTYPE_B_CLIENT)){
+      ret.retCode = SET_CONF_RET_ERR_PART;
+      if (strlen(ret.retMsg) == 0){
+        snprintf(ret.retMsg, RET_MSG_LENGTH, "part error|%s", item->string);
+      }else{
+        int tmp = RET_MSG_LENGTH - 1 - (int)strlen(ret.retMsg);
+        size_t leftSize = tmp >= 0 ? tmp : 0;
+        strncat(ret.retMsg, "|",  leftSize);
+        tmp = RET_MSG_LENGTH - 1 - (int)strlen(ret.retMsg);
+        leftSize = tmp >= 0 ? tmp : 0;
+        strncat(ret.retMsg, item->string, leftSize);
+      }
+    }
+  }
+  cJSON_Delete(root);
+  setConfFlag = true;
+  return ret;
+}
+
+setConfRet taos_set_config(const char *config){
+  pthread_mutex_lock(&setConfMutex);
+  setConfRet ret = taos_set_config_imp(config);
+  pthread_mutex_unlock(&setConfMutex);
+  return ret;
+}
+#endif
\ No newline at end of file
diff --git a/source/client/test/CMakeLists.txt b/source/client/test/CMakeLists.txt
new file mode 100644
index 0000000000..a3f2ad88bb
--- /dev/null
+++ b/source/client/test/CMakeLists.txt
@@ -0,0 +1,18 @@
+
+MESSAGE(STATUS "build parser unit test")
+
+# GoogleTest requires at least C++11
+SET(CMAKE_CXX_STANDARD 11)
+AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SOURCE_LIST)
+
+ADD_EXECUTABLE(clientTest ${SOURCE_LIST})
+TARGET_LINK_LIBRARIES(
+        clientTest
+        PUBLIC os util common transport gtest taos
+)
+
+TARGET_INCLUDE_DIRECTORIES(
+        clientTest
+        PUBLIC "${CMAKE_SOURCE_DIR}/include/libs/client/"
+        PRIVATE "${CMAKE_SOURCE_DIR}/source/libs/client/inc"
+)
diff --git a/source/client/test/clientTests.cpp b/source/client/test/clientTests.cpp
index e69de29bb2..8da4caf7eb 100644
--- a/source/client/test/clientTests.cpp
+++ b/source/client/test/clientTests.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <gtest/gtest.h>
+#include <iostream>
+#include "tglobal.h"
+#pragma GCC diagnostic ignored "-Wwrite-strings"
+
+#pragma GCC diagnostic ignored "-Wunused-function"
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#pragma GCC diagnostic ignored "-Wsign-compare"
+
+#include "taos.h"
+
+namespace {
+}  // namespace
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
+
+TEST(testCase, driverInit_Test) {
+  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+  assert(pConn != NULL);
+
+  taos_close(pConn);
+}
\ No newline at end of file
diff --git a/source/common/inc/commonInt.h b/source/common/inc/commonInt.h
index b8be8899f3..e7d2dba95c 100644
--- a/source/common/inc/commonInt.h
+++ b/source/common/inc/commonInt.h
@@ -20,8 +20,11 @@
 extern "C" {
 #endif
 
+
+
+
 #ifdef __cplusplus
 }
 #endif
 
-#endif /*_TD_COMMON_INT_H_*/
\ No newline at end of file
+#endif /*_TD_COMMON_INT_H_*/
diff --git a/source/common/src/tmessage.c b/source/common/src/taosmsg.c
similarity index 99%
rename from source/common/src/tmessage.c
rename to source/common/src/taosmsg.c
index 0b6dbfdb51..b35e3f1478 100644
--- a/source/common/src/tmessage.c
+++ b/source/common/src/taosmsg.c
@@ -16,3 +16,5 @@
 #define TAOS_MESSAGE_C
 
 #include "taosmsg.h"
+
+
diff --git a/source/common/src/tep.c b/source/common/src/tep.c
new file mode 100644
index 0000000000..ef47a0e0c2
--- /dev/null
+++ b/source/common/src/tep.c
@@ -0,0 +1,41 @@
+#include "tep.h"
+#include "tglobal.h"
+#include "tlockfree.h"
+
+int taosGetFqdnPortFromEp(const char *ep, char *fqdn, uint16_t *port) {
+  *port = 0;
+  strcpy(fqdn, ep);
+
+  char *temp = strchr(fqdn, ':');
+  if (temp) {
+    *temp = 0;
+    *port = atoi(temp+1);
+  }
+
+  if (*port == 0) {
+    *port = tsServerPort;
+    return -1;
+  }
+
+  return 0;
+}
+
+bool isEpsetEqual(const SEpSet *s1, const SEpSet *s2) {
+  if (s1->numOfEps != s2->numOfEps || s1->inUse != s2->inUse) {
+    return false;
+  }
+
+  for (int32_t i = 0; i < s1->numOfEps; i++) {
+    if (s1->port[i] != s2->port[i]
+        || strncmp(s1->fqdn[i], s2->fqdn[i], TSDB_FQDN_LEN) != 0)
+      return false;
+  }
+  return true;
+}
+
+void updateEpSet_s(SCorEpSet *pEpSet, SEpSet *pNewEpSet) {
+  taosCorBeginWrite(&pEpSet->version);
+  pEpSet->epSet = *pNewEpSet;
+  taosCorEndWrite(&pEpSet->version);
+}
+
diff --git a/source/common/src/tglobal.c b/source/common/src/tglobal.c
index 7e71c6bfc7..dfbbe33b59 100644
--- a/source/common/src/tglobal.c
+++ b/source/common/src/tglobal.c
@@ -25,6 +25,7 @@
 #include "tutil.h"
 #include "ttimezone.h"
 #include "tlocale.h"
+#include "tep.h"
 
 // cluster
 char     tsFirst[TSDB_EP_LEN] = {0};
@@ -161,16 +162,8 @@ int8_t  tsEnableSlaveQuery = 1;
 int8_t  tsEnableAdjustMaster = 1;
 
 // restful
-int8_t   tsEnableHttpModule = 1;
 int32_t  tsRestRowLimit = 10240;
-uint16_t tsHttpPort = 6041;  // only tcp, range tcp[6041]
-int32_t  tsHttpCacheSessions = 1000;
-int32_t  tsHttpSessionExpire = 36000;
-int32_t  tsHttpMaxThreads = 2;
-int8_t   tsHttpEnableCompress = 1;
-int8_t   tsHttpEnableRecordSql = 0;
 int8_t   tsTelegrafUseFieldNum = 0;
-int8_t   tsHttpDbNameMandatory = 0;
 
 // mqtt
 int8_t tsEnableMqttModule = 0;  // not finished yet, not started it by default
@@ -193,7 +186,6 @@ int8_t  tsEnableStream = 1;
 // internal
 int8_t tsCompactMnodeWal = 0;
 int8_t tsPrintAuth = 0;
-int8_t tscEmbedded = 0;
 char   tsVnodeDir[PATH_MAX] = {0};
 char   tsDnodeDir[PATH_MAX] = {0};
 char   tsMnodeDir[PATH_MAX] = {0};
@@ -256,7 +248,6 @@ void taosSetAllDebugFlag() {
     sdbDebugFlag = debugFlag;
     dDebugFlag = debugFlag;
     vDebugFlag = debugFlag;
-    cDebugFlag = debugFlag;
     jniDebugFlag = debugFlag;
     odbcDebugFlag = debugFlag;
     httpDebugFlag = debugFlag;
@@ -330,7 +321,7 @@ int32_t taosCfgDynamicOptions(char *msg) {
 
   if (strncasecmp(option, "resetlog", 8) == 0) {
     taosResetLog();
-    taosPrintGlobalCfg();
+    taosPrintCfg();
     return 0;
   }
 
@@ -394,7 +385,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 0;
   cfg.ptrLength = TSDB_EP_LEN;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "secondEp";
   cfg.ptr = tsSecond;
@@ -404,7 +395,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 0;
   cfg.ptrLength = TSDB_EP_LEN;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "fqdn";
   cfg.ptr = tsLocalFqdn;
@@ -414,7 +405,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 0;
   cfg.ptrLength = TSDB_FQDN_LEN;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   // port
   cfg.option = "serverPort";
@@ -425,7 +416,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 65056;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   // directory
   cfg.option = "configDir";
@@ -436,7 +427,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 0;
   cfg.ptrLength = TSDB_FILENAME_LEN;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "logDir";
   cfg.ptr = tsLogDir;
@@ -446,7 +437,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 0;
   cfg.ptrLength = TSDB_FILENAME_LEN;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "scriptDir";
   cfg.ptr = tsScriptDir;
@@ -456,7 +447,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 0;
   cfg.ptrLength = TSDB_FILENAME_LEN;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "dataDir";
   cfg.ptr = tsDataDir;
@@ -466,7 +457,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 0;
   cfg.ptrLength = TSDB_FILENAME_LEN;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "arbitrator";
   cfg.ptr = tsArbitrator;
@@ -476,7 +467,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 0;
   cfg.ptrLength = TSDB_EP_LEN;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   // dnode configs
   cfg.option = "numOfThreadsPerCore";
@@ -487,7 +478,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 10;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "numOfCommitThreads";
   cfg.ptr = &tsNumOfCommitThreads;
@@ -497,7 +488,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 100;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "ratioOfQueryCores";
   cfg.ptr = &tsRatioOfQueryCores;
@@ -507,7 +498,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 2.0f;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "maxNumOfDistinctRes";
   cfg.ptr = &tsMaxNumOfDistinctResults;
@@ -517,7 +508,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 10000*10000;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
   
   cfg.option = "numOfMnodes";
   cfg.ptr = &tsNumOfMnodes;
@@ -527,7 +518,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 3;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "vnodeBak";
   cfg.ptr = &tsEnableVnodeBak;
@@ -537,7 +528,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 1;
   cfg.ptrLength = 1;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "telemetryReporting";
   cfg.ptr = &tsEnableTelemetryReporting;
@@ -547,7 +538,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 1;
   cfg.ptrLength = 1;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "balance";
   cfg.ptr = &tsEnableBalance;
@@ -557,7 +548,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 1;
   cfg.ptrLength = 1;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "balanceInterval";
   cfg.ptr = &tsBalanceInterval;
@@ -567,7 +558,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 30000;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   // 0-any; 1-mnode; 2-vnode
   cfg.option = "role";
@@ -578,7 +569,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 2;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   // timer
   cfg.option = "maxTmrCtrl";
@@ -589,7 +580,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 2048;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "monitorInterval";
   cfg.ptr = &tsMonitorInterval;
@@ -599,7 +590,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 600;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_SECOND;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "offlineThreshold";
   cfg.ptr = &tsOfflineThreshold;
@@ -609,7 +600,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 86400 * 365;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_SECOND;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "rpcTimer";
   cfg.ptr = &tsRpcTimer;
@@ -619,7 +610,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 3000;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_MS;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "rpcForceTcp";
   cfg.ptr = &tsRpcForceTcp;
@@ -629,7 +620,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 1;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "rpcMaxTime";
   cfg.ptr = &tsRpcMaxTime;
@@ -639,7 +630,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 7200;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_SECOND;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "statusInterval";
   cfg.ptr = &tsStatusInterval;
@@ -649,7 +640,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 10;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_SECOND;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "shellActivityTimer";
   cfg.ptr = &tsShellActivityTimer;
@@ -659,7 +650,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 120;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_SECOND;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "minSlidingTime";
   cfg.ptr = &tsMinSlidingTime;
@@ -669,7 +660,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 1000000;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_MS;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "minIntervalTime";
   cfg.ptr = &tsMinIntervalTime;
@@ -679,7 +670,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 1000000;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_MS;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "maxStreamCompDelay";
   cfg.ptr = &tsMaxStreamComputDelay;
@@ -689,7 +680,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 1000000000;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_MS;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "maxFirstStreamCompDelay";
   cfg.ptr = &tsStreamCompStartDelay;
@@ -699,7 +690,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 1000000000;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_MS;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "retryStreamCompDelay";
   cfg.ptr = &tsRetryStreamCompDelay;
@@ -710,7 +701,7 @@ static void doInitGlobalConfig(void) {
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_MS;
 
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
   cfg.option = "streamCompDelayRatio";
   cfg.ptr = &tsStreamComputDelayRatio;
   cfg.valType = TAOS_CFG_VTYPE_FLOAT;
@@ -719,7 +710,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 0.9f;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "maxVgroupsPerDb";
   cfg.ptr = &tsMaxVgroupsPerDb;
@@ -729,7 +720,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 8192;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "cache";
   cfg.ptr = &tsCacheBlockSize;
@@ -739,7 +730,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = TSDB_MAX_CACHE_BLOCK_SIZE;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_MB;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "blocks";
   cfg.ptr = &tsBlocksPerVnode;
@@ -749,7 +740,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = TSDB_MAX_TOTAL_BLOCKS;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "days";
   cfg.ptr = &tsDaysPerFile;
@@ -759,7 +750,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = TSDB_MAX_DAYS_PER_FILE;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "keep";
   cfg.ptr = &tsDaysToKeep;
@@ -769,7 +760,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = TSDB_MAX_KEEP;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "minRows";
   cfg.ptr = &tsMinRowsInFileBlock;
@@ -779,7 +770,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = TSDB_MAX_MIN_ROW_FBLOCK;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "maxRows";
   cfg.ptr = &tsMaxRowsInFileBlock;
@@ -789,7 +780,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = TSDB_MAX_MAX_ROW_FBLOCK;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "precision";
   cfg.ptr = &tsTimePrecision;
@@ -799,7 +790,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = TSDB_MAX_PRECISION;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "comp";
   cfg.ptr = &tsCompression;
@@ -809,7 +800,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = TSDB_MAX_COMP_LEVEL;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "walLevel";
   cfg.ptr = &tsWAL;
@@ -819,7 +810,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = TSDB_MAX_WAL_LEVEL;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "fsync";
   cfg.ptr = &tsFsyncPeriod;
@@ -829,7 +820,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = TSDB_MAX_FSYNC_PERIOD;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "replica";
   cfg.ptr = &tsReplications;
@@ -839,7 +830,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = TSDB_MAX_DB_REPLICA_OPTION;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "quorum";
   cfg.ptr = &tsQuorum;
@@ -849,7 +840,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = TSDB_MAX_DB_QUORUM_OPTION;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "update";
   cfg.ptr = &tsUpdate;
@@ -859,7 +850,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = TSDB_MAX_DB_UPDATE;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "cachelast";
   cfg.ptr = &tsCacheLastRow;
@@ -869,7 +860,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = TSDB_MAX_DB_CACHE_LAST_ROW;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "mqttHostName";
   cfg.ptr = tsMqttHostName;
@@ -879,7 +870,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 0;
   cfg.ptrLength = TSDB_MQTT_HOSTNAME_LEN;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "mqttPort";
   cfg.ptr = tsMqttPort;
@@ -889,7 +880,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 0;
   cfg.ptrLength = TSDB_MQTT_PORT_LEN;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "mqttTopic";
   cfg.ptr = tsMqttTopic;
@@ -899,7 +890,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 0;
   cfg.ptrLength = TSDB_MQTT_TOPIC_LEN;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "compressMsgSize";
   cfg.ptr = &tsCompressMsgSize;
@@ -909,7 +900,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 100000000.0f;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "compressColData";
   cfg.ptr = &tsCompressColData;
@@ -919,7 +910,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 100000000.0f;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "maxSQLLength";
   cfg.ptr = &tsMaxSQLStringLen;
@@ -929,7 +920,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = TSDB_MAX_ALLOWED_SQL_LEN;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_BYTE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "maxWildCardsLength";
   cfg.ptr = &tsMaxWildCardsLen;
@@ -939,7 +930,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = TSDB_MAX_FIELD_LEN;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_BYTE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "maxRegexStringLen";
   cfg.ptr = &tsMaxRegexStringLen;
@@ -949,7 +940,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = TSDB_MAX_FIELD_LEN;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_BYTE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "maxNumOfOrderedRes";
   cfg.ptr = &tsMaxNumOfOrderedResults;
@@ -959,7 +950,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = TSDB_MAX_ALLOWED_SQL_LEN;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "queryBufferSize";
   cfg.ptr = &tsQueryBufferSize;
@@ -969,7 +960,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 500000000000.0f;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_BYTE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "retrieveBlockingModel";
   cfg.ptr = &tsRetrieveBlockingModel;
@@ -979,7 +970,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 1;
   cfg.ptrLength = 1;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "keepColumnName";
   cfg.ptr = &tsKeepOriginalColumnName;
@@ -989,7 +980,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 1;
   cfg.ptrLength = 1;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   // locale & charset
   cfg.option = "timezone";
@@ -1000,7 +991,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 0;
   cfg.ptrLength = TSDB_TIMEZONE_LEN;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "locale";
   cfg.ptr = tsLocale;
@@ -1010,7 +1001,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 0;
   cfg.ptrLength = TSDB_LOCALE_LEN;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "charset";
   cfg.ptr = tsCharset;
@@ -1020,7 +1011,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 0;
   cfg.ptrLength = TSDB_LOCALE_LEN;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   // connect configs
   cfg.option = "maxShellConns";
@@ -1031,7 +1022,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 50000000;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "maxConnections";
   cfg.ptr = &tsMaxConnections;
@@ -1041,7 +1032,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 100000;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "minimalLogDirGB";
   cfg.ptr = &tsMinimalLogDirGB;
@@ -1051,7 +1042,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 10000000;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_GB;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "minimalTmpDirGB";
   cfg.ptr = &tsReservedTmpDirectorySpace;
@@ -1061,7 +1052,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 10000000;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_GB;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "minimalDataDirGB";
   cfg.ptr = &tsMinimalDataDirGB;
@@ -1071,7 +1062,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 10000000;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_GB;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
     // module configs
   cfg.option = "flowctrl";
@@ -1082,7 +1073,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 1;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "slaveQuery";
   cfg.ptr = &tsEnableSlaveQuery;
@@ -1092,7 +1083,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 1;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "adjustMaster";
   cfg.ptr = &tsEnableAdjustMaster;
@@ -1102,17 +1093,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 1;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
-
-  cfg.option = "http";
-  cfg.ptr = &tsEnableHttpModule;
-  cfg.valType = TAOS_CFG_VTYPE_INT8;
-  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW;
-  cfg.minValue = 0;
-  cfg.maxValue = 1;
-  cfg.ptrLength = 1;
-  cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "mqtt";
   cfg.ptr = &tsEnableMqttModule;
@@ -1122,7 +1103,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 1;
   cfg.ptrLength = 1;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "monitor";
   cfg.ptr = &tsEnableMonitorModule;
@@ -1132,7 +1113,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 1;
   cfg.ptrLength = 1;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "stream";
   cfg.ptr = &tsEnableStream;
@@ -1142,7 +1123,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 1;
   cfg.ptrLength = 1;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "topicBianryLen";
   cfg.ptr = &tsTopicBianryLen;
@@ -1152,17 +1133,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 16000;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
-
-  cfg.option = "httpEnableRecordSql";
-  cfg.ptr = &tsHttpEnableRecordSql;
-  cfg.valType = TAOS_CFG_VTYPE_INT8;
-  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG;
-  cfg.minValue = 0;
-  cfg.maxValue = 1;
-  cfg.ptrLength = 0;
-  cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "telegrafUseFieldNum";
   cfg.ptr = &tsTelegrafUseFieldNum;
@@ -1172,17 +1143,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 1;
   cfg.ptrLength = 1;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
-
-  cfg.option = "httpMaxThreads";
-  cfg.ptr = &tsHttpMaxThreads;
-  cfg.valType = TAOS_CFG_VTYPE_INT32;
-  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG;
-  cfg.minValue = 2;
-  cfg.maxValue = 1000000;
-  cfg.ptrLength = 0;
-  cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "restfulRowLimit";
   cfg.ptr = &tsRestRowLimit;
@@ -1192,17 +1153,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 10000000;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
-
-  cfg.option = "httpDbNameMandatory";
-  cfg.ptr = &tsHttpDbNameMandatory;
-  cfg.valType = TAOS_CFG_VTYPE_INT8;
-  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG;
-  cfg.minValue = 0;
-  cfg.maxValue = 1;
-  cfg.ptrLength = 0;
-  cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   // debug flag
   cfg.option = "numOfLogLines";
@@ -1213,7 +1164,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 2000000000;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "logKeepDays";
   cfg.ptr = &tsLogKeepDays;
@@ -1223,7 +1174,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 365000;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "asyncLog";
   cfg.ptr = &tsAsyncLog;
@@ -1233,7 +1184,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 1;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "debugFlag";
   cfg.ptr = &debugFlag;
@@ -1243,7 +1194,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 255;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "mDebugFlag";
   cfg.ptr = &mDebugFlag;
@@ -1253,7 +1204,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 255;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "dDebugFlag";
   cfg.ptr = &dDebugFlag;
@@ -1263,7 +1214,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 255;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "sDebugFlag";
   cfg.ptr = &sDebugFlag;
@@ -1273,7 +1224,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 255;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "wDebugFlag";
   cfg.ptr = &wDebugFlag;
@@ -1283,7 +1234,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 255;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
 
   cfg.option = "sdbDebugFlag";
@@ -1294,7 +1245,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 255;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "rpcDebugFlag";
   cfg.ptr = &rpcDebugFlag;
@@ -1304,7 +1255,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 255;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "tmrDebugFlag";
   cfg.ptr = &tmrDebugFlag;
@@ -1314,7 +1265,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 255;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "cDebugFlag";
   cfg.ptr = &cDebugFlag;
@@ -1324,7 +1275,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 255;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "jniDebugFlag";
   cfg.ptr = &jniDebugFlag;
@@ -1334,7 +1285,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 255;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "odbcDebugFlag";
   cfg.ptr = &odbcDebugFlag;
@@ -1344,7 +1295,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 255;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "uDebugFlag";
   cfg.ptr = &uDebugFlag;
@@ -1354,7 +1305,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 255;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "httpDebugFlag";
   cfg.ptr = &httpDebugFlag;
@@ -1364,7 +1315,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 255;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "mqttDebugFlag";
   cfg.ptr = &mqttDebugFlag;
@@ -1374,7 +1325,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 255;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "monDebugFlag";
   cfg.ptr = &monDebugFlag;
@@ -1384,7 +1335,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 255;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "qDebugFlag";
   cfg.ptr = &qDebugFlag;
@@ -1394,7 +1345,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 255;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "vDebugFlag";
   cfg.ptr = &vDebugFlag;
@@ -1404,7 +1355,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 255;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "tsdbDebugFlag";
   cfg.ptr = &tsdbDebugFlag;
@@ -1414,7 +1365,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 255;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "cqDebugFlag";
   cfg.ptr = &cqDebugFlag;
@@ -1424,7 +1375,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 255;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "enableRecordSql";
   cfg.ptr = &tsTscEnableRecordSql;
@@ -1434,7 +1385,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 1;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "enableCoreFile";
   cfg.ptr = &tsEnableCoreFile;
@@ -1444,7 +1395,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 1;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   // version info
   cfg.option = "gitinfo";
@@ -1455,7 +1406,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 0;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "gitinfoOfInternal";
   cfg.ptr = gitinfoOfInternal;
@@ -1465,7 +1416,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 0;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "buildinfo";
   cfg.ptr = buildinfo;
@@ -1475,7 +1426,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 0;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "version";
   cfg.ptr = version;
@@ -1485,7 +1436,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 0;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "maxBinaryDisplayWidth";
   cfg.ptr = &tsMaxBinaryDisplayWidth;
@@ -1495,7 +1446,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 65536;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "tempDir";
   cfg.ptr = tsTempDir;
@@ -1505,7 +1456,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 0;
   cfg.ptrLength = PATH_MAX;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "tsdbMetaCompactRatio";
   cfg.ptr = &tsTsdbMetaCompactRatio;
@@ -1515,7 +1466,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 100;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
    // enable kill long query
   cfg.option = "deadLockKillQuery";
@@ -1526,7 +1477,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 1;
   cfg.ptrLength = 1;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
 #ifdef TD_TSZ
   // lossy compress
@@ -1538,7 +1489,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 0;
   cfg.ptrLength = tListLen(lossyColumns);
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "fPrecision";
   cfg.ptr = &fPrecision;
@@ -1550,7 +1501,7 @@ static void doInitGlobalConfig(void) {
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
 
   
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "dPrecision";
   cfg.ptr = &dPrecision;
@@ -1560,7 +1511,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = MAX_FLOAT;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "maxRange";
   cfg.ptr = &maxRange;
@@ -1570,7 +1521,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 65536;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
 
   cfg.option = "range";
   cfg.ptr = &curRange;
@@ -1580,7 +1531,7 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = 65536;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
+  taosAddConfigOption(cfg);
   assert(tsGlobalConfigNum == TSDB_CFG_MAX_NUM);
 #else
   //assert(tsGlobalConfigNum == TSDB_CFG_MAX_NUM - 5);
@@ -1592,7 +1543,7 @@ void taosInitGlobalCfg() {
   pthread_once(&tsInitGlobalCfgOnce, doInitGlobalConfig);
 }
 
-int32_t taosCheckGlobalCfg() {
+int32_t taosCheckAndPrintCfg() {
   char fqdn[TSDB_FQDN_LEN];
   uint16_t port;
 
@@ -1640,37 +1591,13 @@ int32_t taosCheckGlobalCfg() {
     tsNumOfCores = 1;
   }
 
-  if (tsHttpMaxThreads == 2) {
-    int32_t halfNumOfCores = tsNumOfCores >> 1;
-    if (halfNumOfCores > 2) {
-      tsHttpMaxThreads = halfNumOfCores;
-    }
-  }
-
-  // todo refactor
-  tsVersion = 0;
-  for (int ver = 0, i = 0; i < TSDB_VERSION_LEN; ++i) {
-    if (version[i] >= '0' && version[i] <= '9') {
-      ver = ver * 10 + (version[i] - '0');
-    } else if (version[i] == '.') {
-      tsVersion |= ver & 0xFF;
-      tsVersion <<= 8;
-
-      ver = 0;
-    } else if (version[i] == 0) {
-      tsVersion |= ver & 0xFF;
-
-      break;
-    }
-  }
-
   if (tsQueryBufferSize >= 0) {
     tsQueryBufferSizeBytes = tsQueryBufferSize * 1048576UL;
   }
 
   uInfo("   check global cfg completed");
   uInfo("==================================");
-  taosPrintGlobalCfg();
+  taosPrintCfg();
 
   return 0;
 }
@@ -1703,3 +1630,4 @@ bool taosCheckBalanceCfgOptions(const char *option, int32_t *vnodeId, int32_t *d
 
   return true;
 }
+
\ No newline at end of file
diff --git a/source/dnode/mgmt/daemon/src/daemon.c b/source/dnode/mgmt/daemon/src/daemon.c
index 82201df072..0a725d9975 100644
--- a/source/dnode/mgmt/daemon/src/daemon.c
+++ b/source/dnode/mgmt/daemon/src/daemon.c
@@ -112,12 +112,12 @@ int dmnReadConfig(const char *path) {
     return -1;
   }
 
-  if (taosReadGlobalCfg() != 0) {
+  if (taosReadCfgFromFile() != 0) {
     uError("failed to read global config");
     return -1;
   }
 
-  if (taosCheckGlobalCfg() != 0) {
+  if (taosCheckAndPrintCfg() != 0) {
     uError("failed to check global config");
     return -1;
   }
diff --git a/source/dnode/mgmt/impl/src/dndDnode.c b/source/dnode/mgmt/impl/src/dndDnode.c
index 130cbbef07..9e2d4d4c9b 100644
--- a/source/dnode/mgmt/impl/src/dndDnode.c
+++ b/source/dnode/mgmt/impl/src/dndDnode.c
@@ -17,6 +17,7 @@
 #include "dndDnode.h"
 #include "dndTransport.h"
 #include "dndVnodes.h"
+#include "tep.h"
 
 int32_t dndGetDnodeId(SDnode *pDnode) {
   SDnodeMgmt *pMgmt = &pDnode->dmgmt;
diff --git a/source/dnode/mgmt/impl/src/dndTransport.c b/source/dnode/mgmt/impl/src/dndTransport.c
index 2ec02ac203..6dc46cefcd 100644
--- a/source/dnode/mgmt/impl/src/dndTransport.c
+++ b/source/dnode/mgmt/impl/src/dndTransport.c
@@ -72,7 +72,7 @@ static void dndInitMsgFp(STransMgmt *pMgmt) {
   pMgmt->msgFp[TSDB_MSG_TYPE_CREATE_STB] = dndProcessMnodeWriteMsg;
   pMgmt->msgFp[TSDB_MSG_TYPE_ALTER_STB] = dndProcessMnodeWriteMsg;
   pMgmt->msgFp[TSDB_MSG_TYPE_DROP_STB] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_STB_VGROUP] = dndProcessMnodeReadMsg;
+  pMgmt->msgFp[TSDB_MSG_TYPE_VGROUP_LIST] = dndProcessMnodeReadMsg;
   pMgmt->msgFp[TSDB_MSG_TYPE_KILL_QUERY] = dndProcessMnodeWriteMsg;
   pMgmt->msgFp[TSDB_MSG_TYPE_KILL_STREAM] = dndProcessMnodeWriteMsg;
   pMgmt->msgFp[TSDB_MSG_TYPE_KILL_CONN] = dndProcessMnodeWriteMsg;
@@ -235,18 +235,18 @@ static void dndSendMsgToMnodeRecv(SDnode *pDnode, SRpcMsg *pRpcMsg, SRpcMsg *pRp
 static int32_t dndAuthInternalMsg(SDnode *pDnode, char *user, char *spi, char *encrypt, char *secret, char *ckey) {
   if (strcmp(user, INTERNAL_USER) == 0) {
     // A simple temporary implementation
-    char pass[32] = {0};
+    char pass[TSDB_PASSWORD_LEN] = {0};
     taosEncryptPass((uint8_t *)(INTERNAL_SECRET), strlen(INTERNAL_SECRET), pass);
-    memcpy(secret, pass, TSDB_KEY_LEN);
+    memcpy(secret, pass, TSDB_PASSWORD_LEN);
     *spi = 0;
     *encrypt = 0;
     *ckey = 0;
     return 0;
   } else if (strcmp(user, TSDB_NETTEST_USER) == 0) {
     // A simple temporary implementation
-    char pass[32] = {0};
+    char pass[TSDB_PASSWORD_LEN] = {0};
     taosEncryptPass((uint8_t *)(TSDB_NETTEST_USER), strlen(TSDB_NETTEST_USER), pass);
-    memcpy(secret, pass, TSDB_KEY_LEN);
+    memcpy(secret, pass, TSDB_PASSWORD_LEN);
     *spi = 0;
     *encrypt = 0;
     *ckey = 0;
@@ -288,8 +288,8 @@ static int32_t dndRetrieveUserAuthInfo(void *parent, char *user, char *spi, char
     dError("user:%s, failed to get user auth from other mnodes since %s", user, terrstr());
   } else {
     SAuthRsp *pRsp = rpcRsp.pCont;
-    memcpy(secret, pRsp->secret, TSDB_KEY_LEN);
-    memcpy(ckey, pRsp->ckey, TSDB_KEY_LEN);
+    memcpy(secret, pRsp->secret, TSDB_PASSWORD_LEN);
+    memcpy(ckey, pRsp->ckey, TSDB_PASSWORD_LEN);
     *spi = pRsp->spi;
     *encrypt = pRsp->encrypt;
     dDebug("user:%s, success to get user auth from other mnodes", user);
@@ -368,4 +368,4 @@ void dndSendMsgToMnode(SDnode *pDnode, SRpcMsg *pMsg) {
   SEpSet epSet = {0};
   dndGetMnodeEpSet(pDnode, &epSet);
   dndSendMsgToDnode(pDnode, &epSet, pMsg);
-}
\ No newline at end of file
+}
diff --git a/source/dnode/mgmt/impl/test/CMakeLists.txt b/source/dnode/mgmt/impl/test/CMakeLists.txt
index b340029044..86186f77de 100644
--- a/source/dnode/mgmt/impl/test/CMakeLists.txt
+++ b/source/dnode/mgmt/impl/test/CMakeLists.txt
@@ -1,6 +1,19 @@
-# add_subdirectory(acct)
+
+add_subdirectory(acct)
+# add_subdirectory(auth)
+# add_subdirectory(balance)
 # add_subdirectory(cluster)
+add_subdirectory(db)
 add_subdirectory(dnode)
+# add_subdirectory(func)
+# add_subdirectory(mnode)
 # add_subdirectory(profile)
 # add_subdirectory(show)
+# add_subdirectory(stb)
+# add_subdirectory(sync)
+# add_subdirectory(telem)
+# add_subdirectory(trans)
 add_subdirectory(user)
+# add_subdirectory(vgroup)
+
+# add_subdirectory(common)
diff --git a/source/dnode/mgmt/impl/test/acct/CMakeLists.txt b/source/dnode/mgmt/impl/test/acct/CMakeLists.txt
index 3e963df2e6..a548c2adc2 100644
--- a/source/dnode/mgmt/impl/test/acct/CMakeLists.txt
+++ b/source/dnode/mgmt/impl/test/acct/CMakeLists.txt
@@ -1,20 +1,20 @@
-add_executable(dndTestAcct "")
+add_executable(dnode_test_acct "")
 
-target_sources(dndTestAcct
+target_sources(dnode_test_acct
     PRIVATE
     "acct.cpp"
     "../sut/deploy.cpp"
 )
 
 target_link_libraries(
-    dndTestAcct
+    dnode_test_acct
     PUBLIC dnode
     PUBLIC util
     PUBLIC os
     PUBLIC gtest_main
 )
 
-target_include_directories(dndTestAcct
+target_include_directories(dnode_test_acct
     PUBLIC
     "${CMAKE_SOURCE_DIR}/include/server/dnode/mgmt"
     "${CMAKE_CURRENT_SOURCE_DIR}/../../inc"
@@ -24,6 +24,6 @@ target_include_directories(dndTestAcct
 enable_testing()
 
 add_test(
-    NAME dndTestAcct
-    COMMAND dndTestAcct
+    NAME dnode_test_acct
+    COMMAND dnode_test_acct
 )
diff --git a/source/dnode/mgmt/impl/test/acct/acct.cpp b/source/dnode/mgmt/impl/test/acct/acct.cpp
index 9050a938fa..e1a71c5c9d 100644
--- a/source/dnode/mgmt/impl/test/acct/acct.cpp
+++ b/source/dnode/mgmt/impl/test/acct/acct.cpp
@@ -17,24 +17,27 @@
 
 class DndTestAcct : public ::testing::Test {
  protected:
-  void SetUp() override {}
-  void TearDown() override {}
+   static SServer* CreateServer(const char* path, const char* fqdn, uint16_t port, const char* firstEp) {
+    SServer* pServer = createServer(path, fqdn, port, firstEp);
+    ASSERT(pServer);
+    return pServer;
+  }
 
   static void SetUpTestSuite() {
-    const char* user = "root";
-    const char* pass = "taosdata";
-    const char* path = "/tmp/dndTestAcct";
-    const char* fqdn = "localhost";
-    uint16_t    port = 9520;
+    initLog("/tmp/tdlog");
 
-    pServer = createServer(path, fqdn, port);
-    ASSERT(pServer);
-    pClient = createClient(user, pass, fqdn, port);
+    const char* fqdn = "localhost";
+    const char* firstEp = "localhost:9012";
+    pServer = CreateServer("/tmp/dnode_test_user", fqdn, 9012, firstEp);
+    pClient = createClient("root", "taosdata", fqdn, 9012);
+    taosMsleep(300);
   }
 
   static void TearDownTestSuite() {
     stopServer(pServer);
     dropClient(pClient);
+    pServer = NULL;
+    pClient = NULL;
   }
 
   static SServer* pServer;
diff --git a/source/dnode/mgmt/impl/test/db/CMakeLists.txt b/source/dnode/mgmt/impl/test/db/CMakeLists.txt
new file mode 100644
index 0000000000..b778e3854f
--- /dev/null
+++ b/source/dnode/mgmt/impl/test/db/CMakeLists.txt
@@ -0,0 +1,29 @@
+add_executable(dnode_test_db "")
+
+target_sources(dnode_test_db
+    PRIVATE
+    "db.cpp"
+    "../sut/deploy.cpp"
+)
+
+target_link_libraries(
+    dnode_test_db
+    PUBLIC dnode
+    PUBLIC util
+    PUBLIC os
+    PUBLIC gtest_main
+)
+
+target_include_directories(dnode_test_db
+    PUBLIC
+    "${CMAKE_SOURCE_DIR}/include/server/dnode/mgmt"
+    "${CMAKE_CURRENT_SOURCE_DIR}/../../inc"
+    "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
+)
+
+enable_testing()
+
+add_test(
+    NAME dnode_test_db
+    COMMAND dnode_test_db
+)
diff --git a/source/dnode/mgmt/impl/test/db/db.cpp b/source/dnode/mgmt/impl/test/db/db.cpp
new file mode 100644
index 0000000000..b0ee00cb64
--- /dev/null
+++ b/source/dnode/mgmt/impl/test/db/db.cpp
@@ -0,0 +1,355 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "deploy.h"
+
+class DndTestDb : public ::testing::Test {
+ protected:
+  static SServer* CreateServer(const char* path, const char* fqdn, uint16_t port, const char* firstEp) {
+    SServer* pServer = createServer(path, fqdn, port, firstEp);
+    ASSERT(pServer);
+    return pServer;
+  }
+
+  static void SetUpTestSuite() {
+    initLog("/tmp/tdlog");
+
+    const char* fqdn = "localhost";
+    const char* firstEp = "localhost:9040";
+    pServer = CreateServer("/tmp/dnode_test_db", fqdn, 9040, firstEp);
+    pClient = createClient("root", "taosdata", fqdn, 9040);
+    taosMsleep(300);
+  }
+
+  static void TearDownTestSuite() {
+    stopServer(pServer);
+    dropClient(pClient);
+    pServer = NULL;
+    pClient = NULL;
+  }
+
+  static SServer* pServer;
+  static SClient* pClient;
+  static int32_t  connId;
+
+ public:
+  void SetUp() override {}
+  void TearDown() override {}
+
+  void SendTheCheckShowMetaMsg(int8_t showType, const char* showName, int32_t columns) {
+    SShowMsg* pShow = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));
+    pShow->type = showType;
+    strcpy(pShow->db, "");
+
+    SRpcMsg showRpcMsg = {0};
+    showRpcMsg.pCont = pShow;
+    showRpcMsg.contLen = sizeof(SShowMsg);
+    showRpcMsg.msgType = TSDB_MSG_TYPE_SHOW;
+
+    sendMsg(pClient, &showRpcMsg);
+    ASSERT_NE(pClient->pRsp, nullptr);
+    ASSERT_EQ(pClient->pRsp->code, 0);
+    ASSERT_NE(pClient->pRsp->pCont, nullptr);
+
+    SShowRsp* pShowRsp = (SShowRsp*)pClient->pRsp->pCont;
+    ASSERT_NE(pShowRsp, nullptr);
+    pShowRsp->showId = htonl(pShowRsp->showId);
+    pMeta = &pShowRsp->tableMeta;
+    pMeta->numOfTags = htons(pMeta->numOfTags);
+    pMeta->numOfColumns = htons(pMeta->numOfColumns);
+    pMeta->sversion = htons(pMeta->sversion);
+    pMeta->tversion = htons(pMeta->tversion);
+    pMeta->tuid = htobe64(pMeta->tuid);
+    pMeta->suid = htobe64(pMeta->suid);
+
+    showId = pShowRsp->showId;
+
+    EXPECT_NE(pShowRsp->showId, 0);
+    EXPECT_STREQ(pMeta->tbFname, showName);
+    EXPECT_EQ(pMeta->numOfTags, 0);
+    EXPECT_EQ(pMeta->numOfColumns, columns);
+    EXPECT_EQ(pMeta->precision, 0);
+    EXPECT_EQ(pMeta->tableType, 0);
+    EXPECT_EQ(pMeta->update, 0);
+    EXPECT_EQ(pMeta->sversion, 0);
+    EXPECT_EQ(pMeta->tversion, 0);
+    EXPECT_EQ(pMeta->tuid, 0);
+    EXPECT_EQ(pMeta->suid, 0);
+  }
+
+  void CheckSchema(int32_t index, int8_t type, int32_t bytes, const char* name) {
+    SSchema* pSchema = &pMeta->pSchema[index];
+    pSchema->bytes = htons(pSchema->bytes);
+    EXPECT_EQ(pSchema->colId, 0);
+    EXPECT_EQ(pSchema->type, type);
+    EXPECT_EQ(pSchema->bytes, bytes);
+    EXPECT_STREQ(pSchema->name, name);
+  }
+
+  void SendThenCheckShowRetrieveMsg(int32_t rows) {
+    SRetrieveTableMsg* pRetrieve = (SRetrieveTableMsg*)rpcMallocCont(sizeof(SRetrieveTableMsg));
+    pRetrieve->showId = htonl(showId);
+    pRetrieve->free = 0;
+
+    SRpcMsg retrieveRpcMsg = {0};
+    retrieveRpcMsg.pCont = pRetrieve;
+    retrieveRpcMsg.contLen = sizeof(SRetrieveTableMsg);
+    retrieveRpcMsg.msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE;
+
+    sendMsg(pClient, &retrieveRpcMsg);
+
+    ASSERT_NE(pClient->pRsp, nullptr);
+    ASSERT_EQ(pClient->pRsp->code, 0);
+    ASSERT_NE(pClient->pRsp->pCont, nullptr);
+
+    pRetrieveRsp = (SRetrieveTableRsp*)pClient->pRsp->pCont;
+    ASSERT_NE(pRetrieveRsp, nullptr);
+    pRetrieveRsp->numOfRows = htonl(pRetrieveRsp->numOfRows);
+    pRetrieveRsp->offset = htobe64(pRetrieveRsp->offset);
+    pRetrieveRsp->useconds = htobe64(pRetrieveRsp->useconds);
+    pRetrieveRsp->compLen = htonl(pRetrieveRsp->compLen);
+
+    EXPECT_EQ(pRetrieveRsp->numOfRows, rows);
+    EXPECT_EQ(pRetrieveRsp->offset, 0);
+    EXPECT_EQ(pRetrieveRsp->useconds, 0);
+    // EXPECT_EQ(pRetrieveRsp->completed, completed);
+    EXPECT_EQ(pRetrieveRsp->precision, TSDB_TIME_PRECISION_MILLI);
+    EXPECT_EQ(pRetrieveRsp->compressed, 0);
+    EXPECT_EQ(pRetrieveRsp->reserved, 0);
+    EXPECT_EQ(pRetrieveRsp->compLen, 0);
+
+    pData = pRetrieveRsp->data;
+    pos = 0;
+  }
+
+  void CheckInt8(int8_t val) {
+    int8_t data = *((int8_t*)(pData + pos));
+    pos += sizeof(int8_t);
+    EXPECT_EQ(data, val);
+  }
+
+  void CheckInt16(int16_t val) {
+    int16_t data = *((int16_t*)(pData + pos));
+    pos += sizeof(int16_t);
+    EXPECT_EQ(data, val);
+  }
+
+  void CheckInt32(int32_t val) {
+    int32_t data = *((int32_t*)(pData + pos));
+    pos += sizeof(int32_t);
+    EXPECT_EQ(data, val);
+  }
+
+  void CheckInt64(int64_t val) {
+    int64_t data = *((int64_t*)(pData + pos));
+    pos += sizeof(int64_t);
+    EXPECT_EQ(data, val);
+  }
+
+  void CheckTimestamp() {
+    int64_t data = *((int64_t*)(pData + pos));
+    pos += sizeof(int64_t);
+    EXPECT_GT(data, 0);
+  }
+
+  void CheckBinary(const char* val, int32_t len) {
+    pos += sizeof(VarDataLenT);
+    char* data = (char*)(pData + pos);
+    pos += len;
+    EXPECT_STREQ(data, val);
+  }
+
+  int32_t            showId;
+  STableMetaMsg*     pMeta;
+  SRetrieveTableRsp* pRetrieveRsp;
+  char*              pData;
+  int32_t            pos;
+};
+
+SServer* DndTestDb::pServer;
+SClient* DndTestDb::pClient;
+int32_t  DndTestDb::connId;
+
+TEST_F(DndTestDb, 01_ShowDb) {
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 16);
+  CheckSchema(0, TSDB_DATA_TYPE_BINARY, TSDB_DB_NAME_LEN - 1 + VARSTR_HEADER_SIZE, "name");
+  CheckSchema(1, TSDB_DATA_TYPE_TIMESTAMP, 8, "create time");
+  CheckSchema(2, TSDB_DATA_TYPE_SMALLINT, 2, "replica");
+  CheckSchema(3, TSDB_DATA_TYPE_SMALLINT, 2, "quorum");
+  CheckSchema(4, TSDB_DATA_TYPE_SMALLINT, 2, "days");
+  CheckSchema(5, TSDB_DATA_TYPE_BINARY, 24 + VARSTR_HEADER_SIZE, "keep0,keep1,keep2");
+  CheckSchema(6, TSDB_DATA_TYPE_INT, 4, "cache(MB)");
+  CheckSchema(7, TSDB_DATA_TYPE_INT, 4, "blocks");
+  CheckSchema(8, TSDB_DATA_TYPE_INT, 4, "minrows");
+  CheckSchema(9, TSDB_DATA_TYPE_INT, 4, "maxrows");
+  CheckSchema(10, TSDB_DATA_TYPE_TINYINT, 1, "wallevel");
+  CheckSchema(11, TSDB_DATA_TYPE_INT, 4, "fsync");
+  CheckSchema(12, TSDB_DATA_TYPE_TINYINT, 1, "comp");
+  CheckSchema(13, TSDB_DATA_TYPE_TINYINT, 1, "cachelast");
+  CheckSchema(14, TSDB_DATA_TYPE_BINARY, 3 + VARSTR_HEADER_SIZE, "precision");
+  CheckSchema(15, TSDB_DATA_TYPE_TINYINT, 1, "update");
+
+  SendThenCheckShowRetrieveMsg(0);
+}
+
+TEST_F(DndTestDb, 02_CreateDb) {
+  {
+    SCreateDbMsg* pReq = (SCreateDbMsg*)rpcMallocCont(sizeof(SCreateDbMsg));
+    strcpy(pReq->db, "1.d1");
+    pReq->cacheBlockSize = htonl(16);
+    pReq->totalBlocks = htonl(10);
+    pReq->daysPerFile = htonl(10);
+    pReq->daysToKeep0 = htonl(3650);
+    pReq->daysToKeep1 = htonl(3650);
+    pReq->daysToKeep2 = htonl(3650);
+    pReq->minRowsPerFileBlock = htonl(100);
+    pReq->maxRowsPerFileBlock = htonl(4096);
+    pReq->commitTime = htonl(3600);
+    pReq->fsyncPeriod = htonl(3000);
+    pReq->walLevel = 1;
+    pReq->precision = 0;
+    pReq->compression = 2;
+    pReq->replications = 1;
+    pReq->quorum = 1;
+    pReq->update = 0;
+    pReq->cacheLastRow = 0;
+    pReq->ignoreExist = 1;
+
+    SRpcMsg rpcMsg = {0};
+    rpcMsg.pCont = pReq;
+    rpcMsg.contLen = sizeof(SCreateDbMsg);
+    rpcMsg.msgType = TSDB_MSG_TYPE_CREATE_DB;
+
+    sendMsg(pClient, &rpcMsg);
+    SRpcMsg* pMsg = pClient->pRsp;
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, 0);
+  }
+
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 16);
+  SendThenCheckShowRetrieveMsg(1);
+  CheckBinary("d1", TSDB_DB_NAME_LEN - 1);
+  CheckTimestamp();
+  CheckInt16(1);                      // replica
+  CheckInt16(1);                      // quorum
+  CheckInt16(10);                     // days
+  CheckBinary("3650,3650,3650", 24);  // days
+  CheckInt32(16);                     // cache
+  CheckInt32(10);                     // blocks
+  CheckInt32(100);                    // minrows
+  CheckInt32(4096);                   // maxrows
+  CheckInt8(1);                       // wallevel
+  CheckInt32(3000);                   // fsync
+  CheckInt8(2);                       // comp
+  CheckInt8(0);                       // cachelast
+  CheckBinary("ms", 3);               // precision
+  CheckInt8(0);                       // update
+}
+
+TEST_F(DndTestDb, 03_AlterDb) {
+  {
+    SAlterDbMsg* pReq = (SAlterDbMsg*)rpcMallocCont(sizeof(SAlterDbMsg));
+    strcpy(pReq->db, "1.d1");
+    pReq->totalBlocks = htonl(12);
+    pReq->daysToKeep0 = htonl(300);
+    pReq->daysToKeep1 = htonl(400);
+    pReq->daysToKeep2 = htonl(500);
+    pReq->fsyncPeriod = htonl(4000);
+    pReq->walLevel = 2;
+    pReq->quorum = 2;
+    pReq->cacheLastRow = 1;
+
+    SRpcMsg rpcMsg = {0};
+    rpcMsg.pCont = pReq;
+    rpcMsg.contLen = sizeof(SAlterDbMsg);
+    rpcMsg.msgType = TSDB_MSG_TYPE_ALTER_DB;
+
+    sendMsg(pClient, &rpcMsg);
+    SRpcMsg* pMsg = pClient->pRsp;
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, 0);
+  }
+
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 16);
+  SendThenCheckShowRetrieveMsg(1);
+  CheckBinary("d1", TSDB_DB_NAME_LEN - 1);
+  CheckTimestamp();
+  CheckInt16(1);                   // replica
+  CheckInt16(2);                   // quorum
+  CheckInt16(10);                  // days
+  CheckBinary("300,400,500", 24);  // days
+  CheckInt32(16);                  // cache
+  CheckInt32(12);                  // blocks
+  CheckInt32(100);                 // minrows
+  CheckInt32(4096);                // maxrows
+  CheckInt8(2);                    // wallevel
+  CheckInt32(4000);                // fsync
+  CheckInt8(2);                    // comp
+  CheckInt8(1);                    // cachelast
+  CheckBinary("ms", 3);            // precision
+  CheckInt8(0);                    // update
+}
+
+TEST_F(DndTestDb, 04_RestartDnode) {
+  stopServer(pServer);
+  pServer = NULL;
+
+  uInfo("start all server");
+
+  const char* fqdn = "localhost";
+  const char* firstEp = "localhost:9040";
+  pServer = startServer("/tmp/dnode_test_db", fqdn, 9040, firstEp);
+
+  uInfo("all server is running");
+
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 16);
+  SendThenCheckShowRetrieveMsg(1);
+  CheckBinary("d1", TSDB_DB_NAME_LEN - 1);
+  CheckTimestamp();
+  CheckInt16(1);                   // replica
+  CheckInt16(2);                   // quorum
+  CheckInt16(10);                  // days
+  CheckBinary("300,400,500", 24);  // days
+  CheckInt32(16);                  // cache
+  CheckInt32(12);                  // blocks
+  CheckInt32(100);                 // minrows
+  CheckInt32(4096);                // maxrows
+  CheckInt8(2);                    // wallevel
+  CheckInt32(4000);                // fsync
+  CheckInt8(2);                    // comp
+  CheckInt8(1);                    // cachelast
+  CheckBinary("ms", 3);            // precision
+  CheckInt8(0);                    // update
+}
+
+TEST_F(DndTestDb, 05_DropDb) {
+  {
+    SDropDbMsg* pReq = (SDropDbMsg*)rpcMallocCont(sizeof(SAlterDbMsg));
+    strcpy(pReq->db, "1.d1");
+
+    SRpcMsg rpcMsg = {0};
+    rpcMsg.pCont = pReq;
+    rpcMsg.contLen = sizeof(SDropDbMsg);
+    rpcMsg.msgType = TSDB_MSG_TYPE_DROP_DB;
+
+    sendMsg(pClient, &rpcMsg);
+    SRpcMsg* pMsg = pClient->pRsp;
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, 0);
+  }
+
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 16);
+  SendThenCheckShowRetrieveMsg(0);
+}
\ No newline at end of file
diff --git a/source/dnode/mgmt/impl/test/dnode/CMakeLists.txt b/source/dnode/mgmt/impl/test/dnode/CMakeLists.txt
index e118cb8725..ebe2f3c5eb 100644
--- a/source/dnode/mgmt/impl/test/dnode/CMakeLists.txt
+++ b/source/dnode/mgmt/impl/test/dnode/CMakeLists.txt
@@ -1,20 +1,20 @@
-add_executable(dndTestDnode "")
+add_executable(dnode_test_dnode "")
 
-target_sources(dndTestDnode
+target_sources(dnode_test_dnode
     PRIVATE
     "dnode.cpp"
     "../sut/deploy.cpp"
 )
 
 target_link_libraries(
-    dndTestDnode
+    dnode_test_dnode
     PUBLIC dnode
     PUBLIC util
     PUBLIC os
     PUBLIC gtest_main
 )
 
-target_include_directories(dndTestDnode
+target_include_directories(dnode_test_dnode
     PUBLIC
     "${CMAKE_SOURCE_DIR}/include/server/dnode/mgmt"
     "${CMAKE_CURRENT_SOURCE_DIR}/../../inc"
@@ -24,6 +24,6 @@ target_include_directories(dndTestDnode
 enable_testing()
 
 add_test(
-    NAME dndTestDnode
-    COMMAND dndTestDnode
+    NAME dnode_test_dnode
+    COMMAND dnode_test_dnode
 )
diff --git a/source/dnode/mgmt/impl/test/dnode/dnode.cpp b/source/dnode/mgmt/impl/test/dnode/dnode.cpp
index fba3794f6a..5a4512e16c 100644
--- a/source/dnode/mgmt/impl/test/dnode/dnode.cpp
+++ b/source/dnode/mgmt/impl/test/dnode/dnode.cpp
@@ -24,16 +24,16 @@ class DndTestDnode : public ::testing::Test {
   }
 
   static void SetUpTestSuite() {
-    initLog("/tmp/dndTestDnode");
+    initLog("/tmp/tdlog");
 
     const char* fqdn = "localhost";
-    const char* firstEp = "localhost:9521";
-    pServer1 = CreateServer("/tmp/dndTestDnode1", fqdn, 9521, firstEp);
-    pServer2 = CreateServer("/tmp/dndTestDnode2", fqdn, 9522, firstEp);
-    pServer3 = CreateServer("/tmp/dndTestDnode3", fqdn, 9523, firstEp);
-    pServer4 = CreateServer("/tmp/dndTestDnode4", fqdn, 9524, firstEp);
-    pServer5 = CreateServer("/tmp/dndTestDnode5", fqdn, 9525, firstEp);
-    pClient = createClient("root", "taosdata", fqdn, 9521);
+    const char* firstEp = "localhost:9041";
+    pServer1 = CreateServer("/tmp/dnode_test_dnode1", fqdn, 9041, firstEp);
+    pServer2 = CreateServer("/tmp/dnode_test_dnode2", fqdn, 9042, firstEp);
+    pServer3 = CreateServer("/tmp/dnode_test_dnode3", fqdn, 9043, firstEp);
+    pServer4 = CreateServer("/tmp/dnode_test_dnode4", fqdn, 9044, firstEp);
+    pServer5 = CreateServer("/tmp/dnode_test_dnode5", fqdn, 9045, firstEp);
+    pClient = createClient("root", "taosdata", fqdn, 9041);
     taosMsleep(300);
   }
 
@@ -188,7 +188,7 @@ SServer* DndTestDnode::pServer4;
 SServer* DndTestDnode::pServer5;
 SClient* DndTestDnode::pClient;
 
-TEST_F(DndTestDnode, ShowDnode) {
+TEST_F(DndTestDnode, 01_ShowDnode) {
   SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DNODE, "show dnodes", 7);
   CheckSchema(0, TSDB_DATA_TYPE_SMALLINT, 2, "id");
   CheckSchema(1, TSDB_DATA_TYPE_BINARY, TSDB_EP_LEN + VARSTR_HEADER_SIZE, "end point");
@@ -200,7 +200,7 @@ TEST_F(DndTestDnode, ShowDnode) {
 
   SendThenCheckShowRetrieveMsg(1);
   CheckInt16(1);
-  CheckBinary("localhost:9521", TSDB_EP_LEN);
+  CheckBinary("localhost:9041", TSDB_EP_LEN);
   CheckInt16(0);
   CheckInt16(1);
   CheckBinary("ready", 10);
@@ -208,7 +208,7 @@ TEST_F(DndTestDnode, ShowDnode) {
   CheckBinary("", 24);
 }
 
-TEST_F(DndTestDnode, ConfigDnode_01) {
+TEST_F(DndTestDnode, 02_ConfigDnode) {
   SCfgDnodeMsg* pReq = (SCfgDnodeMsg*)rpcMallocCont(sizeof(SCfgDnodeMsg));
   pReq->dnodeId = htonl(1);
   strcpy(pReq->config, "ddebugflag 131");
@@ -224,9 +224,9 @@ TEST_F(DndTestDnode, ConfigDnode_01) {
   ASSERT_EQ(pMsg->code, 0);
 }
 
-TEST_F(DndTestDnode, CreateDnode_01) {
+TEST_F(DndTestDnode, 03_CreateDnode) {
   SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(sizeof(SCreateDnodeMsg));
-  strcpy(pReq->ep, "localhost:9522");
+  strcpy(pReq->ep, "localhost:9042");
 
   SRpcMsg rpcMsg = {0};
   rpcMsg.pCont = pReq;
@@ -243,8 +243,8 @@ TEST_F(DndTestDnode, CreateDnode_01) {
   SendThenCheckShowRetrieveMsg(2);
   CheckInt16(1);
   CheckInt16(2);
-  CheckBinary("localhost:9521", TSDB_EP_LEN);
-  CheckBinary("localhost:9522", TSDB_EP_LEN);
+  CheckBinary("localhost:9041", TSDB_EP_LEN);
+  CheckBinary("localhost:9042", TSDB_EP_LEN);
   CheckInt16(0);
   CheckInt16(0);
   CheckInt16(1);
@@ -257,7 +257,7 @@ TEST_F(DndTestDnode, CreateDnode_01) {
   CheckBinary("", 24);
 }
 
-TEST_F(DndTestDnode, DropDnode_01) {
+TEST_F(DndTestDnode, 04_DropDnode) {
   SDropDnodeMsg* pReq = (SDropDnodeMsg*)rpcMallocCont(sizeof(SDropDnodeMsg));
   pReq->dnodeId = htonl(2);
 
@@ -274,7 +274,7 @@ TEST_F(DndTestDnode, DropDnode_01) {
   SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DNODE, "show dnodes", 7);
   SendThenCheckShowRetrieveMsg(1);
   CheckInt16(1);
-  CheckBinary("localhost:9521", TSDB_EP_LEN);
+  CheckBinary("localhost:9041", TSDB_EP_LEN);
   CheckInt16(0);
   CheckInt16(1);
   CheckBinary("ready", 10);
@@ -282,10 +282,10 @@ TEST_F(DndTestDnode, DropDnode_01) {
   CheckBinary("", 24);
 }
 
-TEST_F(DndTestDnode, CreateDnode_02) {
+TEST_F(DndTestDnode, 05_CreateDnode) {
   {
     SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(sizeof(SCreateDnodeMsg));
-    strcpy(pReq->ep, "localhost:9523");
+    strcpy(pReq->ep, "localhost:9043");
 
     SRpcMsg rpcMsg = {0};
     rpcMsg.pCont = pReq;
@@ -300,7 +300,7 @@ TEST_F(DndTestDnode, CreateDnode_02) {
 
   {
     SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(sizeof(SCreateDnodeMsg));
-    strcpy(pReq->ep, "localhost:9524");
+    strcpy(pReq->ep, "localhost:9044");
 
     SRpcMsg rpcMsg = {0};
     rpcMsg.pCont = pReq;
@@ -315,7 +315,7 @@ TEST_F(DndTestDnode, CreateDnode_02) {
 
   {
     SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(sizeof(SCreateDnodeMsg));
-    strcpy(pReq->ep, "localhost:9525");
+    strcpy(pReq->ep, "localhost:9045");
 
     SRpcMsg rpcMsg = {0};
     rpcMsg.pCont = pReq;
@@ -335,10 +335,10 @@ TEST_F(DndTestDnode, CreateDnode_02) {
   CheckInt16(3);
   CheckInt16(4);
   CheckInt16(5);
-  CheckBinary("localhost:9521", TSDB_EP_LEN);
-  CheckBinary("localhost:9523", TSDB_EP_LEN);
-  CheckBinary("localhost:9524", TSDB_EP_LEN);
-  CheckBinary("localhost:9525", TSDB_EP_LEN);
+  CheckBinary("localhost:9041", TSDB_EP_LEN);
+  CheckBinary("localhost:9043", TSDB_EP_LEN);
+  CheckBinary("localhost:9044", TSDB_EP_LEN);
+  CheckBinary("localhost:9045", TSDB_EP_LEN);
   CheckInt16(0);
   CheckInt16(0);
   CheckInt16(0);
@@ -361,7 +361,7 @@ TEST_F(DndTestDnode, CreateDnode_02) {
   CheckBinary("", 24);
 }
 
-TEST_F(DndTestDnode, RestartDnode_01) {
+TEST_F(DndTestDnode, 06_RestartDnode) {
   uInfo("stop all server");
   stopServer(pServer1);
   stopServer(pServer2);
@@ -377,43 +377,43 @@ TEST_F(DndTestDnode, RestartDnode_01) {
   uInfo("start all server");
 
   const char* fqdn = "localhost";
-  const char* firstEp = "localhost:9521";
-  pServer1 = startServer("/tmp/dndTestDnode1", fqdn, 9521, firstEp);
-  // pServer1 = startServer("/tmp/dndTestDnode3", fqdn, 9523, firstEp);
-  // pServer1 = startServer("/tmp/dndTestDnode4", fqdn, 9524, firstEp);
-  // pServer1 = startServer("/tmp/dndTestDnode5", fqdn, 9525, firstEp);
+  const char* firstEp = "localhost:9041";
+  pServer1 = startServer("/tmp/dnode_test_dnode1", fqdn, 9041, firstEp);
+  pServer3 = startServer("/tmp/dnode_test_dnode3", fqdn, 9043, firstEp);
+  pServer4 = startServer("/tmp/dnode_test_dnode4", fqdn, 9044, firstEp);
+  pServer5 = startServer("/tmp/dnode_test_dnode5", fqdn, 9045, firstEp);
 
   uInfo("all server is running");
 
-  // taosMsleep(1300);
-  // SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DNODE, "show dnodes", 7);
-  // SendThenCheckShowRetrieveMsg(4);
-  // CheckInt16(1);
-  // CheckInt16(3);
-  // CheckInt16(4);
-  // CheckInt16(5);
-  // CheckBinary("localhost:9521", TSDB_EP_LEN);
-  // CheckBinary("localhost:9523", TSDB_EP_LEN);
-  // CheckBinary("localhost:9524", TSDB_EP_LEN);
-  // CheckBinary("localhost:9525", TSDB_EP_LEN);
-  // CheckInt16(0);
-  // CheckInt16(0);
-  // CheckInt16(0);
-  // CheckInt16(0);
-  // CheckInt16(1);
-  // CheckInt16(1);
-  // CheckInt16(1);
-  // CheckInt16(1);
-  // CheckBinary("ready", 10);
-  // CheckBinary("ready", 10);
-  // CheckBinary("ready", 10);
-  // CheckBinary("ready", 10);
-  // CheckTimestamp();
-  // CheckTimestamp();
-  // CheckTimestamp();
-  // CheckTimestamp();
-  // CheckBinary("", 24);
-  // CheckBinary("", 24);
-  // CheckBinary("", 24);
-  // CheckBinary("", 24);
+  taosMsleep(1300);
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DNODE, "show dnodes", 7);
+  SendThenCheckShowRetrieveMsg(4);
+  CheckInt16(1);
+  CheckInt16(3);
+  CheckInt16(4);
+  CheckInt16(5);
+  CheckBinary("localhost:9041", TSDB_EP_LEN);
+  CheckBinary("localhost:9043", TSDB_EP_LEN);
+  CheckBinary("localhost:9044", TSDB_EP_LEN);
+  CheckBinary("localhost:9045", TSDB_EP_LEN);
+  CheckInt16(0);
+  CheckInt16(0);
+  CheckInt16(0);
+  CheckInt16(0);
+  CheckInt16(1);
+  CheckInt16(1);
+  CheckInt16(1);
+  CheckInt16(1);
+  CheckBinary("ready", 10);
+  CheckBinary("ready", 10);
+  CheckBinary("ready", 10);
+  CheckBinary("ready", 10);
+  CheckTimestamp();
+  CheckTimestamp();
+  CheckTimestamp();
+  CheckTimestamp();
+  CheckBinary("", 24);
+  CheckBinary("", 24);
+  CheckBinary("", 24);
+  CheckBinary("", 24);
 }
diff --git a/source/dnode/mgmt/impl/test/sut/deploy.cpp b/source/dnode/mgmt/impl/test/sut/deploy.cpp
index 61fc27a595..be1506bccf 100644
--- a/source/dnode/mgmt/impl/test/sut/deploy.cpp
+++ b/source/dnode/mgmt/impl/test/sut/deploy.cpp
@@ -18,7 +18,7 @@
 void initLog(const char* path) {
   dDebugFlag = 143;
   vDebugFlag = 0;
-  mDebugFlag = 143;
+  mDebugFlag = 207;
   cDebugFlag = 0;
   jniDebugFlag = 0;
   tmrDebugFlag = 0;
@@ -120,7 +120,7 @@ SClient* createClient(const char* user, const char* pass, const char* fqdn, uint
   SClient* pClient = (SClient*)calloc(1, sizeof(SClient));
   ASSERT(pClient);
 
-  char secretEncrypt[32] = {0};
+  char secretEncrypt[TSDB_PASSWORD_LEN] = {0};
   taosEncryptPass((uint8_t*)pass, strlen(pass), secretEncrypt);
 
   SRpcInit rpcInit;
diff --git a/source/dnode/mgmt/impl/test/user/CMakeLists.txt b/source/dnode/mgmt/impl/test/user/CMakeLists.txt
index b5f02e41f4..ca8f2ec6db 100644
--- a/source/dnode/mgmt/impl/test/user/CMakeLists.txt
+++ b/source/dnode/mgmt/impl/test/user/CMakeLists.txt
@@ -1,20 +1,20 @@
-add_executable(dndTestUser "")
+add_executable(dnode_test_user "")
 
-target_sources(dndTestUser
+target_sources(dnode_test_user
     PRIVATE
     "user.cpp"
     "../sut/deploy.cpp"
 )
 
 target_link_libraries(
-    dndTestUser
+    dnode_test_user
     PUBLIC dnode
     PUBLIC util
     PUBLIC os
     PUBLIC gtest_main
 )
 
-target_include_directories(dndTestUser
+target_include_directories(dnode_test_user
     PUBLIC
     "${CMAKE_SOURCE_DIR}/include/server/dnode/mgmt"
     "${CMAKE_CURRENT_SOURCE_DIR}/../../inc"
@@ -24,6 +24,6 @@ target_include_directories(dndTestUser
 enable_testing()
 
 add_test(
-    NAME dndTestUser
-    COMMAND dndTestUser
+    NAME dnode_test_user
+    COMMAND dnode_test_user
 )
diff --git a/source/dnode/mgmt/impl/test/user/user.cpp b/source/dnode/mgmt/impl/test/user/user.cpp
index 48be2635cd..2b30dcbb1b 100644
--- a/source/dnode/mgmt/impl/test/user/user.cpp
+++ b/source/dnode/mgmt/impl/test/user/user.cpp
@@ -24,12 +24,12 @@ class DndTestUser : public ::testing::Test {
   }
 
   static void SetUpTestSuite() {
-    initLog("/tmp/dndTestUser");
+    initLog("/tmp/tdlog");
 
     const char* fqdn = "localhost";
-    const char* firstEp = "localhost:9530";
-    pServer = CreateServer("/tmp/dndTestUser", fqdn, 9530, firstEp);
-    pClient = createClient("root", "taosdata", fqdn, 9530);
+    const char* firstEp = "localhost:9140";
+    pServer = CreateServer("/tmp/dnode_test_user", fqdn, 9140, firstEp);
+    pClient = createClient("root", "taosdata", fqdn, 9140);
     taosMsleep(300);
   }
 
@@ -170,7 +170,7 @@ SServer* DndTestUser::pServer;
 SClient* DndTestUser::pClient;
 int32_t  DndTestUser::connId;
 
-TEST_F(DndTestUser, ShowUser) {
+TEST_F(DndTestUser, 01_ShowUser) {
   SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_USER, "show users", 4);
   CheckSchema(0, TSDB_DATA_TYPE_BINARY, TSDB_USER_LEN + VARSTR_HEADER_SIZE, "name");
   CheckSchema(1, TSDB_DATA_TYPE_BINARY, 10 + VARSTR_HEADER_SIZE, "privilege");
@@ -184,7 +184,7 @@ TEST_F(DndTestUser, ShowUser) {
   CheckBinary("root", TSDB_USER_LEN);
 }
 
-TEST_F(DndTestUser, CreateUser_01) {
+TEST_F(DndTestUser, 02_CreateUser) {
   {
     SCreateUserMsg* pReq = (SCreateUserMsg*)rpcMallocCont(sizeof(SCreateUserMsg));
     strcpy(pReq->user, "u1");
@@ -233,7 +233,7 @@ TEST_F(DndTestUser, CreateUser_01) {
   CheckBinary("root", TSDB_USER_LEN);
 }
 
-TEST_F(DndTestUser, AlterUser_01) {
+TEST_F(DndTestUser, 03_AlterUser) {
   SAlterUserMsg* pReq = (SAlterUserMsg*)rpcMallocCont(sizeof(SAlterUserMsg));
   strcpy(pReq->user, "u1");
   strcpy(pReq->pass, "p2");
@@ -264,7 +264,7 @@ TEST_F(DndTestUser, AlterUser_01) {
   CheckBinary("root", TSDB_USER_LEN);
 }
 
-TEST_F(DndTestUser, DropUser_01) {
+TEST_F(DndTestUser, 04_DropUser) {
   SDropUserMsg* pReq = (SDropUserMsg*)rpcMallocCont(sizeof(SDropUserMsg));
   strcpy(pReq->user, "u1");
 
@@ -290,15 +290,15 @@ TEST_F(DndTestUser, DropUser_01) {
   CheckBinary("root", TSDB_USER_LEN);
 }
 
-TEST_F(DndTestUser, RestartDnode) {
+TEST_F(DndTestUser, 05_RestartDnode) {
   stopServer(pServer);
   pServer = NULL;
 
   uInfo("start all server");
 
   const char* fqdn = "localhost";
-  const char* firstEp = "localhost:9530";
-  pServer = startServer("/tmp/dndTestUser", fqdn, 9530, firstEp);
+  const char* firstEp = "localhost:9140";
+  pServer = startServer("/tmp/dnode_test_user", fqdn, 9140, firstEp);
 
   uInfo("all server is running");
 
diff --git a/source/dnode/mnode/impl/inc/mndDef.h b/source/dnode/mnode/impl/inc/mndDef.h
index aace3f4ee3..30c18d3e18 100644
--- a/source/dnode/mnode/impl/inc/mndDef.h
+++ b/source/dnode/mnode/impl/inc/mndDef.h
@@ -17,14 +17,16 @@
 #define _TD_MND_DEF_H_
 
 #include "os.h"
+
+#include "cJSON.h"
+#include "sync.h"
 #include "taosmsg.h"
+#include "thash.h"
 #include "tlog.h"
 #include "trpc.h"
 #include "ttimer.h"
-#include "thash.h"
-#include "cJSON.h"
+
 #include "mnode.h"
-#include "sync.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -41,11 +43,8 @@ extern int32_t mDebugFlag;
 #define mTrace(...) { if (mDebugFlag & DEBUG_TRACE) { taosPrintLog("MND ", mDebugFlag, __VA_ARGS__); }}
 
 typedef struct SClusterObj SClusterObj;
-typedef struct SDnodeObj   SDnodeObj;
 typedef struct SMnodeObj   SMnodeObj;
 typedef struct SAcctObj    SAcctObj;
-typedef struct SUserObj    SUserObj;
-typedef struct SDbObj      SDbObj;
 typedef struct SVgObj      SVgObj;
 typedef struct SFuncObj    SFuncObj;
 typedef struct SOperObj    SOperObj;
@@ -73,7 +72,8 @@ typedef enum {
   TRN_STAGE_EXECUTE = 2,
   TRN_STAGE_COMMIT = 3,
   TRN_STAGE_ROLLBACK = 4,
-  TRN_STAGE_RETRY = 5
+  TRN_STAGE_RETRY = 5,
+  TRN_STAGE_OVER = 6,
 } ETrnStage;
 
 typedef enum { TRN_POLICY_ROLLBACK = 1, TRN_POLICY_RETRY = 2 } ETrnPolicy;
@@ -103,7 +103,6 @@ typedef struct STrans {
   int32_t    id;
   ETrnStage  stage;
   ETrnPolicy policy;
-  SMnode    *pMnode;
   void      *rpcHandle;
   SArray    *redoLogs;
   SArray    *undoLogs;
@@ -119,7 +118,7 @@ typedef struct SClusterObj {
   int64_t updateTime;
 } SClusterObj;
 
-typedef struct SDnodeObj {
+typedef struct {
   int32_t    id;
   int64_t    createdTime;
   int64_t    updateTime;
@@ -178,15 +177,13 @@ typedef struct SAcctObj {
   SAcctInfo info;
 } SAcctObj;
 
-typedef struct SUserObj {
+typedef struct {
   char      user[TSDB_USER_LEN];
-  char      pass[TSDB_KEY_LEN];
+  char      pass[TSDB_PASSWORD_LEN];
   char      acct[TSDB_USER_LEN];
   int64_t   createdTime;
   int64_t   updateTime;
-  int8_t    superAuth;
-  int8_t    readAuth;
-  int8_t    writeAuth;
+  int8_t    superUser;
   int32_t   acctId;
   SHashObj *prohibitDbHash;
 } SUserObj;
@@ -211,7 +208,7 @@ typedef struct {
   int8_t  cacheLastRow;
 } SDbCfg;
 
-typedef struct SDbObj {
+typedef struct {
   char    name[TSDB_FULL_DB_NAME_LEN];
   char    acct[TSDB_USER_LEN];
   int64_t createdTime;
@@ -306,6 +303,7 @@ typedef struct SMnodeMsg {
 
 typedef struct {
   int32_t id;
+  int32_t code;
   void   *rpcHandle;
 } STransMsg;
 
diff --git a/source/dnode/mnode/impl/inc/mndShow.h b/source/dnode/mnode/impl/inc/mndShow.h
index 37fb9159dc..67e277677c 100644
--- a/source/dnode/mnode/impl/inc/mndShow.h
+++ b/source/dnode/mnode/impl/inc/mndShow.h
@@ -27,7 +27,7 @@ void    mndCleanupShow(SMnode *pMnode);
 void    mndAddShowMetaHandle(SMnode *pMnode, EShowType showType, ShowMetaFp fp);
 void    mndAddShowRetrieveHandle(SMnode *pMnode, EShowType showType, ShowRetrieveFp fp);
 void    mndAddShowFreeIterHandle(SMnode *pMnode, EShowType msgType, ShowFreeIterFp fp);
-void    mnodeVacuumResult(char *data, int32_t numOfCols, int32_t rows, int32_t capacity, SShowObj *pShow);
+void    mndVacuumResult(char *data, int32_t numOfCols, int32_t rows, int32_t capacity, SShowObj *pShow);
 char   *mndShowStr(int32_t showType);
 
 #ifdef __cplusplus
diff --git a/source/dnode/mnode/impl/inc/mndSync.h b/source/dnode/mnode/impl/inc/mndSync.h
index 02ba725be1..fe557cdeac 100644
--- a/source/dnode/mnode/impl/inc/mndSync.h
+++ b/source/dnode/mnode/impl/inc/mndSync.h
@@ -25,7 +25,7 @@ extern "C" {
 int32_t mndInitSync(SMnode *pMnode);
 void    mndCleanupSync(SMnode *pMnode);
 bool    mndIsMaster(SMnode *pMnode);
-int32_t mndSyncPropose(SMnode *pMnode, SSdbRaw *pRaw, STransMsg *pMsg);
+int32_t mndSyncPropose(SMnode *pMnode, SSdbRaw *pRaw);
 
 #ifdef __cplusplus
 }
diff --git a/source/dnode/mnode/impl/inc/mndTrans.h b/source/dnode/mnode/impl/inc/mndTrans.h
index 878337e4be..5da1d1ca2b 100644
--- a/source/dnode/mnode/impl/inc/mndTrans.h
+++ b/source/dnode/mnode/impl/inc/mndTrans.h
@@ -32,10 +32,10 @@ int32_t mndTransAppendUndolog(STrans *pTrans, SSdbRaw *pRaw);
 int32_t mndTransAppendCommitlog(STrans *pTrans, SSdbRaw *pRaw);
 int32_t mndTransAppendRedoAction(STrans *pTrans, SEpSet *, void *pMsg);
 int32_t mndTransAppendUndoAction(STrans *pTrans, SEpSet *, void *pMsg);
-
-int32_t mndTransPrepare(STrans *pTrans);
+int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans);
 void    mndTransApply(SMnode *pMnode, SSdbRaw *pRaw, STransMsg *pMsg, int32_t code);
-int32_t mndTransExecute(SSdb *pSdb, int32_t tranId);
+char   *mndTransStageStr(ETrnStage stage);
+char   *mndTransPolicyStr(ETrnPolicy policy);
 
 #ifdef __cplusplus
 }
diff --git a/source/dnode/mnode/impl/src/mndAcct.c b/source/dnode/mnode/impl/src/mndAcct.c
index a365ad7326..75b0acbd0a 100644
--- a/source/dnode/mnode/impl/src/mndAcct.c
+++ b/source/dnode/mnode/impl/src/mndAcct.c
@@ -19,12 +19,12 @@
 
 #define SDB_ACCT_VER 1
 
-static int32_t  mnodeCreateDefaultAcct(SMnode *pMnode);
-static SSdbRaw *mnodeAcctActionEncode(SAcctObj *pAcct);
-static SSdbRow *mnodeAcctActionDecode(SSdbRaw *pRaw);
-static int32_t  mnodeAcctActionInsert(SSdb *pSdb, SAcctObj *pAcct);
-static int32_t  mnodeAcctActionDelete(SSdb *pSdb, SAcctObj *pAcct);
-static int32_t  mnodeAcctActionUpdate(SSdb *pSdb, SAcctObj *pOldAcct, SAcctObj *pNewAcct);
+static int32_t  mndCreateDefaultAcct(SMnode *pMnode);
+static SSdbRaw *mndAcctActionEncode(SAcctObj *pAcct);
+static SSdbRow *mndAcctActionDecode(SSdbRaw *pRaw);
+static int32_t  mndAcctActionInsert(SSdb *pSdb, SAcctObj *pAcct);
+static int32_t  mndAcctActionDelete(SSdb *pSdb, SAcctObj *pAcct);
+static int32_t  mndAcctActionUpdate(SSdb *pSdb, SAcctObj *pOldAcct, SAcctObj *pNewAcct);
 static int32_t  mndProcessCreateAcctMsg(SMnodeMsg *pMnodeMsg);
 static int32_t  mndProcessAlterAcctMsg(SMnodeMsg *pMnodeMsg);
 static int32_t  mndProcessDropAcctMsg(SMnodeMsg *pMnodeMsg);
@@ -32,12 +32,12 @@ static int32_t  mndProcessDropAcctMsg(SMnodeMsg *pMnodeMsg);
 int32_t mndInitAcct(SMnode *pMnode) {
   SSdbTable table = {.sdbType = SDB_ACCT,
                      .keyType = SDB_KEY_BINARY,
-                     .deployFp = mnodeCreateDefaultAcct,
-                     .encodeFp = (SdbEncodeFp)mnodeAcctActionEncode,
-                     .decodeFp = (SdbDecodeFp)mnodeAcctActionDecode,
-                     .insertFp = (SdbInsertFp)mnodeAcctActionInsert,
-                     .updateFp = (SdbUpdateFp)mnodeAcctActionUpdate,
-                     .deleteFp = (SdbDeleteFp)mnodeAcctActionDelete};
+                     .deployFp = mndCreateDefaultAcct,
+                     .encodeFp = (SdbEncodeFp)mndAcctActionEncode,
+                     .decodeFp = (SdbDecodeFp)mndAcctActionDecode,
+                     .insertFp = (SdbInsertFp)mndAcctActionInsert,
+                     .updateFp = (SdbUpdateFp)mndAcctActionUpdate,
+                     .deleteFp = (SdbDeleteFp)mndAcctActionDelete};
 
   mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_CREATE_ACCT, mndProcessCreateAcctMsg);
   mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_ALTER_ACCT, mndProcessAlterAcctMsg);
@@ -48,7 +48,7 @@ int32_t mndInitAcct(SMnode *pMnode) {
 
 void mndCleanupAcct(SMnode *pMnode) {}
 
-static int32_t mnodeCreateDefaultAcct(SMnode *pMnode) {
+static int32_t mndCreateDefaultAcct(SMnode *pMnode) {
   SAcctObj acctObj = {0};
   tstrncpy(acctObj.acct, TSDB_DEFAULT_USER, TSDB_USER_LEN);
   acctObj.createdTime = taosGetTimestampMs();
@@ -61,7 +61,7 @@ static int32_t mnodeCreateDefaultAcct(SMnode *pMnode) {
                            .maxStorage = INT64_MAX,
                            .accessState = TSDB_VN_ALL_ACCCESS};
 
-  SSdbRaw *pRaw = mnodeAcctActionEncode(&acctObj);
+  SSdbRaw *pRaw = mndAcctActionEncode(&acctObj);
   if (pRaw == NULL) return -1;
   sdbSetRawStatus(pRaw, SDB_STATUS_READY);
 
@@ -69,7 +69,7 @@ static int32_t mnodeCreateDefaultAcct(SMnode *pMnode) {
   return sdbWrite(pMnode->pSdb, pRaw);
 }
 
-static SSdbRaw *mnodeAcctActionEncode(SAcctObj *pAcct) {
+static SSdbRaw *mndAcctActionEncode(SAcctObj *pAcct) {
   SSdbRaw *pRaw = sdbAllocRaw(SDB_ACCT, SDB_ACCT_VER, sizeof(SAcctObj));
   if (pRaw == NULL) return NULL;
 
@@ -90,7 +90,7 @@ static SSdbRaw *mnodeAcctActionEncode(SAcctObj *pAcct) {
   return pRaw;
 }
 
-static SSdbRow *mnodeAcctActionDecode(SSdbRaw *pRaw) {
+static SSdbRow *mndAcctActionDecode(SSdbRaw *pRaw) {
   int8_t sver = 0;
   if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL;
 
@@ -120,18 +120,18 @@ static SSdbRow *mnodeAcctActionDecode(SSdbRaw *pRaw) {
   return pRow;
 }
 
-static int32_t mnodeAcctActionInsert(SSdb *pSdb, SAcctObj *pAcct) {
+static int32_t mndAcctActionInsert(SSdb *pSdb, SAcctObj *pAcct) {
   mTrace("acct:%s, perform insert action", pAcct->acct);
   memset(&pAcct->info, 0, sizeof(SAcctInfo));
   return 0;
 }
 
-static int32_t mnodeAcctActionDelete(SSdb *pSdb, SAcctObj *pAcct) {
+static int32_t mndAcctActionDelete(SSdb *pSdb, SAcctObj *pAcct) {
   mTrace("acct:%s, perform delete action", pAcct->acct);
   return 0;
 }
 
-static int32_t mnodeAcctActionUpdate(SSdb *pSdb, SAcctObj *pOldAcct, SAcctObj *pNewAcct) {
+static int32_t mndAcctActionUpdate(SSdb *pSdb, SAcctObj *pOldAcct, SAcctObj *pNewAcct) {
   mTrace("acct:%s, perform update action", pOldAcct->acct);
 
   memcpy(pOldAcct->acct, pNewAcct->acct, TSDB_USER_LEN);
diff --git a/source/dnode/mnode/impl/src/mndCluster.c b/source/dnode/mnode/impl/src/mndCluster.c
index 7edeb73647..0eaa184907 100644
--- a/source/dnode/mnode/impl/src/mndCluster.c
+++ b/source/dnode/mnode/impl/src/mndCluster.c
@@ -203,7 +203,7 @@ static int32_t mndRetrieveClusters(SMnodeMsg *pMsg, SShowObj *pShow, char *data,
     numOfRows++;
   }
 
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
+  mndVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
   pShow->numOfReads += numOfRows;
   return numOfRows;
 }
diff --git a/source/dnode/mnode/impl/src/mndDb.c b/source/dnode/mnode/impl/src/mndDb.c
index fd02c6e251..1cf9423da8 100644
--- a/source/dnode/mnode/impl/src/mndDb.c
+++ b/source/dnode/mnode/impl/src/mndDb.c
@@ -65,7 +65,7 @@ int32_t mndInitDb(SMnode *pMnode) {
 void mndCleanupDb(SMnode *pMnode) {}
 
 static SSdbRaw *mndDbActionEncode(SDbObj *pDb) {
-  SSdbRaw *pRaw = sdbAllocRaw(SDB_DB, TSDB_DB_VER_NUM, sizeof(SDbObj));
+  SSdbRaw *pRaw = sdbAllocRaw(SDB_DB, TSDB_DB_VER_NUM, sizeof(SDbObj) + TSDB_DB_RESERVE_SIZE);
   if (pRaw == NULL) return NULL;
 
   int32_t dataPos = 0;
@@ -151,7 +151,8 @@ static int32_t mndDbActionDelete(SSdb *pSdb, SDbObj *pDb) {
 
 static int32_t mndDbActionUpdate(SSdb *pSdb, SDbObj *pOldDb, SDbObj *pNewDb) {
   mTrace("db:%s, perform update action", pOldDb->name);
-  memcpy(pOldDb, pNewDb, sizeof(SDbObj));
+  pOldDb->updateTime = pNewDb->createdTime;
+  memcpy(&pOldDb->cfg, &pNewDb->cfg, sizeof(SDbCfg));
   return 0;
 }
 
@@ -165,109 +166,146 @@ void mndReleaseDb(SMnode *pMnode, SDbObj *pDb) {
   sdbRelease(pSdb, pDb);
 }
 
-static int32_t mndCheckDbCfg(SMnode *pMnode, SDbCfg *pCfg) {
+static int32_t mndCheckDbName(char *dbName, SUserObj *pUser) {
+  char *pos = strstr(dbName, TS_PATH_DELIMITER);
+  if (pos == NULL) {
+    terrno = TSDB_CODE_MND_INVALID_DB;
+    return -1;
+  }
+
+  int32_t acctId = atoi(dbName);
+  if (acctId != pUser->acctId) {
+    terrno = TSDB_CODE_MND_INVALID_DB_ACCT;
+    return -1;
+  }
+
+  return 0;
+}
+
+static int32_t mndCheckDbCfg(SMnode *pMnode, SDbCfg *pCfg, char *errMsg, int32_t len) {
   if (pCfg->cacheBlockSize < TSDB_MIN_CACHE_BLOCK_SIZE || pCfg->cacheBlockSize > TSDB_MAX_CACHE_BLOCK_SIZE) {
-    terrno = TSDB_CODE_MND_INVALID_DB_CACHE_SIZE;
+    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+    tstrncpy(errMsg, "Invalid database cache block size option", len);
     return -1;
   }
 
   if (pCfg->totalBlocks < TSDB_MIN_TOTAL_BLOCKS || pCfg->totalBlocks > TSDB_MAX_TOTAL_BLOCKS) {
-    terrno = TSDB_CODE_MND_INVALID_DB_TOTAL_BLOCKS;
+    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+    tstrncpy(errMsg, "Invalid database total blocks option", len);
     return -1;
   }
 
   if (pCfg->daysPerFile < TSDB_MIN_DAYS_PER_FILE || pCfg->daysPerFile > TSDB_MAX_DAYS_PER_FILE) {
-    terrno = TSDB_CODE_MND_INVALID_DB_DAYS;
+    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+    tstrncpy(errMsg, "Invalid database days option", len);
     return -1;
   }
 
   if (pCfg->daysToKeep0 < pCfg->daysPerFile) {
-    terrno = TSDB_CODE_MND_INVALID_DB_KEEP0;
+    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+    tstrncpy(errMsg, "Invalid database days option", len);
     return -1;
   }
 
   if (pCfg->daysToKeep0 < TSDB_MIN_KEEP || pCfg->daysToKeep0 > TSDB_MAX_KEEP || pCfg->daysToKeep0 > pCfg->daysToKeep1) {
-    terrno = TSDB_CODE_MND_INVALID_DB_KEEP0;
+    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+    tstrncpy(errMsg, "Invalid database keep0 option", len);
     return -1;
   }
 
   if (pCfg->daysToKeep1 < TSDB_MIN_KEEP || pCfg->daysToKeep1 > TSDB_MAX_KEEP || pCfg->daysToKeep1 > pCfg->daysToKeep2) {
-    terrno = TSDB_CODE_MND_INVALID_DB_KEEP1;
+    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+    tstrncpy(errMsg, "Invalid database keep1 option", len);
     return -1;
   }
 
   if (pCfg->daysToKeep2 < TSDB_MIN_KEEP || pCfg->daysToKeep2 > TSDB_MAX_KEEP) {
-    terrno = TSDB_CODE_MND_INVALID_DB_KEEP1;
+    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+    tstrncpy(errMsg, "Invalid database keep2 option", len);
     return -1;
   }
 
   if (pCfg->minRowsPerFileBlock < TSDB_MIN_MIN_ROW_FBLOCK || pCfg->minRowsPerFileBlock > TSDB_MAX_MIN_ROW_FBLOCK) {
-    terrno = TSDB_CODE_MND_INVALID_DB_MIN_ROWS;
+    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+    tstrncpy(errMsg, "Invalid database minrows option", len);
     return -1;
   }
 
   if (pCfg->maxRowsPerFileBlock < TSDB_MIN_MAX_ROW_FBLOCK || pCfg->maxRowsPerFileBlock > TSDB_MAX_MAX_ROW_FBLOCK) {
-    terrno = TSDB_CODE_MND_INVALID_DB_MAX_ROWS;
+    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+    tstrncpy(errMsg, "Invalid database maxrows option", len);
     return -1;
   }
 
   if (pCfg->minRowsPerFileBlock > pCfg->maxRowsPerFileBlock) {
-    terrno = TSDB_CODE_MND_INVALID_DB_MIN_ROWS;
+    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+    tstrncpy(errMsg, "Invalid database minrows option", len);
     return -1;
   }
 
   if (pCfg->commitTime < TSDB_MIN_COMMIT_TIME || pCfg->commitTime > TSDB_MAX_COMMIT_TIME) {
-    terrno = TSDB_CODE_MND_INVALID_DB_COMMIT_TIME;
+    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+    tstrncpy(errMsg, "Invalid database commit option", len);
     return -1;
   }
 
   if (pCfg->fsyncPeriod < TSDB_MIN_FSYNC_PERIOD || pCfg->fsyncPeriod > TSDB_MAX_FSYNC_PERIOD) {
-    terrno = TSDB_CODE_MND_INVALID_DB_FSYNC_PERIOD;
+    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+    tstrncpy(errMsg, "Invalid database fsync option", len);
     return -1;
   }
 
   if (pCfg->walLevel < TSDB_MIN_WAL_LEVEL || pCfg->walLevel > TSDB_MAX_WAL_LEVEL) {
-    terrno = TSDB_CODE_MND_INVALID_DB_WAL_LEVEL;
+    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+    tstrncpy(errMsg, "Invalid database wal level option", len);
     return -1;
   }
 
   if (pCfg->precision < TSDB_MIN_PRECISION && pCfg->precision > TSDB_MAX_PRECISION) {
-    terrno = TSDB_CODE_MND_INVALID_DB_PRECISION;
+    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+    tstrncpy(errMsg, "Invalid precision option", len);
     return -1;
   }
 
   if (pCfg->compression < TSDB_MIN_COMP_LEVEL || pCfg->compression > TSDB_MAX_COMP_LEVEL) {
-    terrno = TSDB_CODE_MND_INVALID_DB_COMP;
+    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+    tstrncpy(errMsg, "Invalid database compression option", len);
     return -1;
   }
 
   if (pCfg->replications < TSDB_MIN_DB_REPLICA_OPTION || pCfg->replications > TSDB_MAX_DB_REPLICA_OPTION) {
-    terrno = TSDB_CODE_MND_INVALID_DB_REPLICA;
+    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+    tstrncpy(errMsg, "Invalid database replication option", len);
     return -1;
   }
 
   if (pCfg->replications > mndGetDnodeSize(pMnode)) {
-    terrno = TSDB_CODE_MND_INVALID_DB_REPLICA;
+    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+    tstrncpy(errMsg, "Invalid database replication option", len);
     return -1;
   }
 
   if (pCfg->quorum < TSDB_MIN_DB_QUORUM_OPTION || pCfg->quorum > TSDB_MAX_DB_QUORUM_OPTION) {
-    terrno = TSDB_CODE_MND_INVALID_DB_QUORUM;
+    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+    tstrncpy(errMsg, "Invalid database quorum option", len);
     return -1;
   }
 
   if (pCfg->quorum > pCfg->replications) {
-    terrno = TSDB_CODE_MND_INVALID_DB_QUORUM;
+    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+    tstrncpy(errMsg, "Invalid database quorum option", len);
     return -1;
   }
 
   if (pCfg->update < TSDB_MIN_DB_UPDATE || pCfg->update > TSDB_MAX_DB_UPDATE) {
-    terrno = TSDB_CODE_MND_INVALID_DB_UPDATE;
+    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+    tstrncpy(errMsg, "Invalid database update option", len);
     return -1;
   }
 
   if (pCfg->cacheLastRow < TSDB_MIN_DB_CACHE_LAST_ROW || pCfg->cacheLastRow > TSDB_MAX_DB_CACHE_LAST_ROW) {
-    terrno = TSDB_CODE_MND_INVALID_DB_CACHE_LAST;
+    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+    tstrncpy(errMsg, "Invalid database cachelast option", len);
     return -1;
   }
 
@@ -294,13 +332,13 @@ static void mndSetDefaultDbCfg(SDbCfg *pCfg) {
   if (pCfg->cacheLastRow < 0) pCfg->cacheLastRow = TSDB_DEFAULT_CACHE_LAST_ROW;
 }
 
-static int32_t mndCreateDb(SMnode *pMnode, SMnodeMsg *pMsg, SCreateDbMsg *pCreate, char *acct) {
+static int32_t mndCreateDb(SMnode *pMnode, SMnodeMsg *pMsg, SCreateDbMsg *pCreate, SUserObj *pUser) {
   SDbObj dbObj = {0};
   tstrncpy(dbObj.name, pCreate->db, TSDB_FULL_DB_NAME_LEN);
-  tstrncpy(dbObj.acct, acct, TSDB_USER_LEN);
+  tstrncpy(dbObj.acct, pUser->acct, TSDB_USER_LEN);
   dbObj.createdTime = taosGetTimestampMs();
   dbObj.updateTime = dbObj.createdTime;
-  dbObj.uid = 1234;
+  dbObj.uid = mndGenerateUid(dbObj.name, TSDB_FULL_DB_NAME_LEN);
   dbObj.cfg = (SDbCfg){.cacheBlockSize = pCreate->cacheBlockSize,
                        .totalBlocks = pCreate->totalBlocks,
                        .daysPerFile = pCreate->daysPerFile,
@@ -321,7 +359,13 @@ static int32_t mndCreateDb(SMnode *pMnode, SMnodeMsg *pMsg, SCreateDbMsg *pCreat
 
   mndSetDefaultDbCfg(&dbObj.cfg);
 
-  if (mndCheckDbCfg(pMnode, &dbObj.cfg) != 0) {
+  if (mndCheckDbName(dbObj.name, pUser) != 0) {
+    mError("db:%s, failed to create since %s", pCreate->db, terrstr());
+    return -1;
+  }
+
+  char errMsg[TSDB_ERROR_MSG_LEN] = {0};
+  if (mndCheckDbCfg(pMnode, &dbObj.cfg, errMsg, TSDB_ERROR_MSG_LEN) != 0) {
     mError("db:%s, failed to create since %s", pCreate->db, terrstr());
     return -1;
   }
@@ -357,7 +401,7 @@ static int32_t mndCreateDb(SMnode *pMnode, SMnodeMsg *pMsg, SCreateDbMsg *pCreat
   }
   sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
 
-  if (mndTransPrepare(pTrans) != 0) {
+  if (mndTransPrepare(pMnode, pTrans) != 0) {
     mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
     mndTransDrop(pTrans);
     return -1;
@@ -403,11 +447,10 @@ static int32_t mndProcessCreateDbMsg(SMnodeMsg *pMsg) {
     return -1;
   }
 
-  int32_t code = mndCreateDb(pMnode, pMsg, pCreate, pOperUser->acct);
+  int32_t code = mndCreateDb(pMnode, pMsg, pCreate, pOperUser);
   mndReleaseUser(pMnode, pOperUser);
 
   if (code != 0) {
-    terrno = code;
     mError("db:%s, failed to create since %s", pCreate->db, terrstr());
     return -1;
   }
@@ -415,7 +458,7 @@ static int32_t mndProcessCreateDbMsg(SMnodeMsg *pMsg) {
   return TSDB_CODE_MND_ACTION_IN_PROGRESS;
 }
 
-static int32_t mnodeSetDbCfgFromAlterDbMsg(SDbObj *pDb, SAlterDbMsg *pAlter) {
+static int32_t mndSetDbCfgFromAlterDbMsg(SDbObj *pDb, SAlterDbMsg *pAlter) {
   bool changed = false;
 
   if (pAlter->totalBlocks >= 0 && pAlter->totalBlocks != pDb->cfg.totalBlocks) {
@@ -491,7 +534,7 @@ static int32_t mndUpdateDb(SMnode *pMnode, SMnodeMsg *pMsg, SDbObj *pOldDb, SDbO
   }
   sdbSetRawStatus(pUndoRaw, SDB_STATUS_READY);
 
-  if (mndTransPrepare(pTrans) != 0) {
+  if (mndTransPrepare(pMnode, pTrans) != 0) {
     mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
     mndTransDrop(pTrans);
     return -1;
@@ -521,7 +564,7 @@ static int32_t mndProcessAlterDbMsg(SMnodeMsg *pMsg) {
   SDbObj dbObj = {0};
   memcpy(&dbObj, pDb, sizeof(SDbObj));
 
-  int32_t code = mnodeSetDbCfgFromAlterDbMsg(&dbObj, pAlter);
+  int32_t code = mndSetDbCfgFromAlterDbMsg(&dbObj, pAlter);
   if (code != 0) {
     mndReleaseDb(pMnode, pDb);
     mError("db:%s, failed to alter since %s", pAlter->db, tstrerror(code));
@@ -571,7 +614,7 @@ static int32_t mndDropDb(SMnode *pMnode, SMnodeMsg *pMsg, SDbObj *pDb) {
   }
   sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED);
 
-  if (mndTransPrepare(pTrans) != 0) {
+  if (mndTransPrepare(pMnode, pTrans) != 0) {
     mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
     mndTransDrop(pTrans);
     return -1;
@@ -603,7 +646,6 @@ static int32_t mndProcessDropDbMsg(SMnodeMsg *pMsg) {
   mndReleaseDb(pMnode, pDb);
 
   if (code != 0) {
-    terrno = code;
     mError("db:%s, failed to drop since %s", pDrop->db, terrstr());
     return code;
   }
@@ -772,10 +814,14 @@ static int32_t mndGetDbMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMe
   return 0;
 }
 
-char *mnodeGetDbStr(char *src) {
+char *mnGetDbStr(char *src) {
   char *pos = strstr(src, TS_PATH_DELIMITER);
   if (pos != NULL) ++pos;
 
+  if (pos == NULL) {
+    return src;
+  }
+
   return pos;
 }
 
@@ -794,7 +840,7 @@ static int32_t mndRetrieveDbs(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int3
     cols = 0;
 
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    char *name = mnodeGetDbStr(pDb->name);
+    char *name = mnGetDbStr(pDb->name);
     if (name != NULL) {
       STR_WITH_MAXSIZE_TO_VARSTR(pWrite, name, pShow->bytes[cols]);
     } else {
@@ -887,7 +933,7 @@ static int32_t mndRetrieveDbs(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int3
     sdbRelease(pSdb, pDb);
   }
 
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
+  mndVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
   pShow->numOfReads += numOfRows;
 
   return numOfRows;
diff --git a/source/dnode/mnode/impl/src/mndDnode.c b/source/dnode/mnode/impl/src/mndDnode.c
index cf46d044ca..ec5f68a713 100644
--- a/source/dnode/mnode/impl/src/mndDnode.c
+++ b/source/dnode/mnode/impl/src/mndDnode.c
@@ -19,7 +19,7 @@
 #include "mndShow.h"
 #include "mndTrans.h"
 #include "ttime.h"
-#include "tutil.h"
+#include "tep.h"
 
 #define TSDB_DNODE_VER 1
 #define TSDB_DNODE_RESERVE_SIZE 64
@@ -27,8 +27,6 @@
 #define TSDB_CONIIG_VALUE_LEN 48
 #define TSDB_CONFIG_NUMBER 8
 
-static int32_t id = 2;
-
 static const char *offlineReason[] = {
     "",
     "status msg timeout",
@@ -110,7 +108,7 @@ static int32_t mndCreateDefaultDnode(SMnode *pMnode) {
 }
 
 static SSdbRaw *mndDnodeActionEncode(SDnodeObj *pDnode) {
-  SSdbRaw *pRaw = sdbAllocRaw(SDB_DNODE, TSDB_DNODE_VER, sizeof(SDnodeObj));
+  SSdbRaw *pRaw = sdbAllocRaw(SDB_DNODE, TSDB_DNODE_VER, sizeof(SDnodeObj) + TSDB_DNODE_RESERVE_SIZE);
   if (pRaw == NULL) return NULL;
 
   int32_t dataPos = 0;
@@ -177,6 +175,7 @@ static int32_t mndDnodeActionDelete(SSdb *pSdb, SDnodeObj *pDnode) {
 
 static int32_t mndDnodeActionUpdate(SSdb *pSdb, SDnodeObj *pOldDnode, SDnodeObj *pNewDnode) {
   mTrace("dnode:%d, perform update action", pOldDnode->id);
+  pOldDnode->updateTime = pNewDnode->updateTime;
   return 0;
 }
 
@@ -389,7 +388,7 @@ static int32_t mndProcessStatusMsg(SMnodeMsg *pMsg) {
 
 static int32_t mndCreateDnode(SMnode *pMnode, SMnodeMsg *pMsg, SCreateDnodeMsg *pCreate) {
   SDnodeObj dnodeObj = {0};
-  dnodeObj.id = id++;
+  dnodeObj.id = sdbGetMaxId(pMnode->pSdb, SDB_DNODE);
   dnodeObj.createdTime = taosGetTimestampMs();
   dnodeObj.updateTime = dnodeObj.createdTime;
   taosGetFqdnPortFromEp(pCreate->ep, dnodeObj.fqdn, &dnodeObj.port);
@@ -413,25 +412,9 @@ static int32_t mndCreateDnode(SMnode *pMnode, SMnodeMsg *pMsg, SCreateDnodeMsg *
     mndTransDrop(pTrans);
     return -1;
   }
-  sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING);
+  sdbSetRawStatus(pRedoRaw, SDB_STATUS_READY);
 
-  SSdbRaw *pUndoRaw = mndDnodeActionEncode(&dnodeObj);
-  if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) {
-    mError("trans:%d, failed to append undo log since %s", pTrans->id, terrstr());
-    mndTransDrop(pTrans);
-    return -1;
-  }
-  sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED);
-
-  SSdbRaw *pCommitRaw = mndDnodeActionEncode(&dnodeObj);
-  if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
-    mError("trans:%d, failed to append commit log since %s", pTrans->id, terrstr());
-    mndTransDrop(pTrans);
-    return -1;
-  }
-  sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
-
-  if (mndTransPrepare(pTrans) != 0) {
+  if (mndTransPrepare(pMnode, pTrans) != 0) {
     mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
     mndTransDrop(pTrans);
     return -1;
@@ -485,25 +468,9 @@ static int32_t mndDropDnode(SMnode *pMnode, SMnodeMsg *pMsg, SDnodeObj *pDnode)
     mndTransDrop(pTrans);
     return -1;
   }
-  sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING);
+  sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPED);
 
-  SSdbRaw *pUndoRaw = mndDnodeActionEncode(pDnode);
-  if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) {
-    mError("trans:%d, failed to append undo log since %s", pTrans->id, terrstr());
-    mndTransDrop(pTrans);
-    return -1;
-  }
-  sdbSetRawStatus(pUndoRaw, SDB_STATUS_READY);
-
-  SSdbRaw *pCommitRaw = mndDnodeActionEncode(pDnode);
-  if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
-    mError("trans:%d, failed to append commit log since %s", pTrans->id, terrstr());
-    mndTransDrop(pTrans);
-    return -1;
-  }
-  sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED);
-
-  if (mndTransPrepare(pTrans) != 0) {
+  if (mndTransPrepare(pMnode, pTrans) != 0) {
     mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
     mndTransDrop(pTrans);
     return -1;
@@ -645,7 +612,7 @@ static int32_t mndRetrieveConfigs(SMnodeMsg *pMsg, SShowObj *pShow, char *data,
     cols++;
   }
 
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
+  mndVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
   pShow->numOfReads += numOfRows;
   return numOfRows;
 }
@@ -767,7 +734,7 @@ static int32_t mndRetrieveDnodes(SMnodeMsg *pMsg, SShowObj *pShow, char *data, i
     sdbRelease(pSdb, pDnode);
   }
 
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
+  mndVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
   pShow->numOfReads += numOfRows;
 
   return numOfRows;
diff --git a/source/dnode/mnode/impl/src/mndFunc.c b/source/dnode/mnode/impl/src/mndFunc.c
index e407b271fd..b7158bb094 100644
--- a/source/dnode/mnode/impl/src/mndFunc.c
+++ b/source/dnode/mnode/impl/src/mndFunc.c
@@ -183,7 +183,7 @@ static int32_t mndCreateFunc(SMnode *pMnode, SMnodeMsg *pMsg, SCreateFuncMsg *pC
   }
   sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
 
-  if (mndTransPrepare(pTrans) != 0) {
+  if (mndTransPrepare(pMnode, pTrans) != 0) {
     mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
     mndTransDrop(pTrans);
     return -1;
@@ -226,7 +226,7 @@ static int32_t mndDropFunc(SMnode *pMnode, SMnodeMsg *pMsg, SFuncObj *pFunc) {
   }
   sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED);
 
-  if (mndTransPrepare(pTrans) != 0) {
+  if (mndTransPrepare(pMnode, pTrans) != 0) {
     mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
     mndTransDrop(pTrans);
     return -1;
@@ -500,7 +500,7 @@ static int32_t mndRetrieveFuncs(SMnodeMsg *pMsg, SShowObj *pShow, char *data, in
     sdbRelease(pSdb, pFunc);
   }
 
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
+  mndVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
   pShow->numOfReads += numOfRows;
   return numOfRows;
 }
diff --git a/source/dnode/mnode/impl/src/mndMnode.c b/source/dnode/mnode/impl/src/mndMnode.c
index 6278e3ffef..7b6804d43e 100644
--- a/source/dnode/mnode/impl/src/mndMnode.c
+++ b/source/dnode/mnode/impl/src/mndMnode.c
@@ -238,7 +238,7 @@ static int32_t mndCreateMnode(SMnode *pMnode, SMnodeMsg *pMsg, SCreateMnodeMsg *
   }
   sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
 
-  if (mndTransPrepare(pTrans) != 0) {
+  if (mndTransPrepare(pMnode, pTrans) != 0) {
     mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
     mndTransDrop(pTrans);
     return -1;
@@ -313,7 +313,7 @@ static int32_t mndDropMnode(SMnode *pMnode, SMnodeMsg *pMsg, SMnodeObj *pMnodeOb
   }
   sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED);
 
-  if (mndTransPrepare(pTrans) != 0) {
+  if (mndTransPrepare(pMnode, pTrans) != 0) {
     mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
     mndTransDrop(pTrans);
     return -1;
@@ -457,7 +457,7 @@ static int32_t mndRetrieveMnodes(SMnodeMsg *pMsg, SShowObj *pShow, char *data, i
     sdbRelease(pSdb, pMnodeObj);
   }
 
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
+  mndVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
   pShow->numOfReads += numOfRows;
 
   return numOfRows;
diff --git a/source/dnode/mnode/impl/src/mndProfile.c b/source/dnode/mnode/impl/src/mndProfile.c
index b429879789..45a63f2dc5 100644
--- a/source/dnode/mnode/impl/src/mndProfile.c
+++ b/source/dnode/mnode/impl/src/mndProfile.c
@@ -29,6 +29,7 @@ typedef struct {
   char         user[TSDB_USER_LEN];
   char         app[TSDB_APP_NAME_LEN];  // app name that invokes taosc
   int32_t      pid;                     // pid of app that invokes taosc
+  int64_t      appStartTime;            // app start time
   int32_t      id;
   int8_t       killed;
   int8_t       align;
@@ -44,7 +45,7 @@ typedef struct {
   SQueryDesc  *pQueries;
 } SConnObj;
 
-static SConnObj *mndCreateConn(SMnode *pMnode, char *user, uint32_t ip, uint16_t port, int32_t pid, const char *app);
+static SConnObj *mndCreateConn(SMnode *pMnode, char *user, uint32_t ip, uint16_t port, int32_t pid, const char *app, int64_t startTime);
 static void      mndFreeConn(SConnObj *pConn);
 static SConnObj *mndAcquireConn(SMnode *pMnode, int32_t connId);
 static void      mndReleaseConn(SMnode *pMnode, SConnObj *pConn);
@@ -102,13 +103,14 @@ void mndCleanupProfile(SMnode *pMnode) {
   }
 }
 
-static SConnObj *mndCreateConn(SMnode *pMnode, char *user, uint32_t ip, uint16_t port, int32_t pid, const char *app) {
+static SConnObj *mndCreateConn(SMnode *pMnode, char *user, uint32_t ip, uint16_t port, int32_t pid, const char *app, int64_t startTime) {
   SProfileMgmt *pMgmt = &pMnode->profileMgmt;
 
   int32_t connId = atomic_add_fetch_32(&pMgmt->connId, 1);
   if (connId == 0) atomic_add_fetch_32(&pMgmt->connId, 1);
 
   SConnObj connObj = {.pid = pid,
+                      .appStartTime = startTime,
                       .id = connId,
                       .killed = 0,
                       .port = port,
@@ -195,6 +197,7 @@ static int32_t mndProcessConnectMsg(SMnodeMsg *pMsg) {
   SMnode      *pMnode = pMsg->pMnode;
   SConnectMsg *pReq = pMsg->rpcMsg.pCont;
   pReq->pid = htonl(pReq->pid);
+  pReq->startTime = htobe64(pReq->startTime);
 
   SRpcConnInfo info = {0};
   if (rpcGetConnInfo(pMsg->rpcMsg.handle, &info) != 0) {
@@ -216,7 +219,7 @@ static int32_t mndProcessConnectMsg(SMnodeMsg *pMsg) {
     mndReleaseDb(pMnode, pDb);
   }
 
-  SConnObj *pConn = mndCreateConn(pMnode, info.user, info.clientIp, info.clientPort, pReq->pid, pReq->app);
+  SConnObj *pConn = mndCreateConn(pMnode, info.user, info.clientIp, info.clientPort, pReq->pid, pReq->app, pReq->startTime);
   if (pConn == NULL) {
     mError("user:%s, failed to login from %s while create connection since %s", pMsg->user, ip, terrstr());
     return -1;
@@ -233,9 +236,7 @@ static int32_t mndProcessConnectMsg(SMnodeMsg *pMsg) {
   SUserObj *pUser = mndAcquireUser(pMnode, pMsg->user);
   if (pUser != NULL) {
     pRsp->acctId = htonl(pUser->acctId);
-    pRsp->superAuth = pUser->superAuth;
-    pRsp->readAuth = pUser->readAuth;
-    pRsp->writeAuth = pUser->writeAuth;
+    pRsp->superUser = pUser->superUser;
     mndReleaseUser(pMnode, pUser);
   }
 
@@ -246,11 +247,12 @@ static int32_t mndProcessConnectMsg(SMnodeMsg *pMsg) {
 
   pMsg->contLen = sizeof(SConnectRsp);
   pMsg->pCont = pRsp;
-  mDebug("user:%s, login from %s, conn:%d", info.user, ip, pConn->id);
+
+  mDebug("user:%s, login from %s, conn:%d, app:%s", info.user, ip, pConn->id, pReq->app);
   return 0;
 }
 
-static int32_t mnodeSaveQueryStreamList(SConnObj *pConn, SHeartBeatMsg *pMsg) {
+static int32_t mndSaveQueryStreamList(SConnObj *pConn, SHeartBeatMsg *pMsg) {
   pConn->numOfQueries = 0;
   pConn->numOfStreams = 0;
   int32_t numOfQueries = htonl(pMsg->numOfQueries);
@@ -301,7 +303,7 @@ static int32_t mndProcessHeartBeatMsg(SMnodeMsg *pMsg) {
 
   SConnObj *pConn = mndAcquireConn(pMnode, pReq->connId);
   if (pConn == NULL) {
-    pConn = mndCreateConn(pMnode, info.user, info.clientIp, info.clientPort, pReq->pid, pReq->app);
+    pConn = mndCreateConn(pMnode, info.user, info.clientIp, info.clientPort, pReq->pid, pReq->app, 0);
     if (pConn == NULL) {
       mError("user:%s, conn:%d is freed and failed to create new conn since %s", pMsg->user, pReq->connId, terrstr());
       return -1;
@@ -336,7 +338,7 @@ static int32_t mndProcessHeartBeatMsg(SMnodeMsg *pMsg) {
     return -1;
   }
 
-  mnodeSaveQueryStreamList(pConn, pReq);
+  mndSaveQueryStreamList(pConn, pReq);
   if (pConn->killed != 0) {
     pRsp->killConnection = 1;
   }
@@ -368,7 +370,7 @@ static int32_t mndProcessKillQueryMsg(SMnodeMsg *pMsg) {
 
   SUserObj *pUser = mndAcquireUser(pMnode, pMsg->user);
   if (pUser == NULL) return 0;
-  if (!pUser->superAuth) {
+  if (!pUser->superUser) {
     mndReleaseUser(pMnode, pUser);
     terrno = TSDB_CODE_MND_NO_RIGHTS;
     return -1;
@@ -399,7 +401,7 @@ static int32_t mndProcessKillStreamMsg(SMnodeMsg *pMsg) {
 
   SUserObj *pUser = mndAcquireUser(pMnode, pMsg->user);
   if (pUser == NULL) return 0;
-  if (!pUser->superAuth) {
+  if (!pUser->superUser) {
     mndReleaseUser(pMnode, pUser);
     terrno = TSDB_CODE_MND_NO_RIGHTS;
     return -1;
@@ -430,7 +432,7 @@ static int32_t mndProcessKillConnectionMsg(SMnodeMsg *pMsg) {
 
   SUserObj *pUser = mndAcquireUser(pMnode, pMsg->user);
   if (pUser == NULL) return 0;
-  if (!pUser->superAuth) {
+  if (!pUser->superUser) {
     mndReleaseUser(pMnode, pUser);
     terrno = TSDB_CODE_MND_NO_RIGHTS;
     return -1;
@@ -459,7 +461,7 @@ static int32_t mndGetConnsMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *
 
   SUserObj *pUser = mndAcquireUser(pMnode, pMsg->user);
   if (pUser == NULL) return 0;
-  if (!pUser->superAuth) {
+  if (!pUser->superUser) {
     mndReleaseUser(pMnode, pUser);
     terrno = TSDB_CODE_MND_NO_RIGHTS;
     return -1;
@@ -587,7 +589,7 @@ static int32_t mndGetQueryMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *
 
   SUserObj *pUser = mndAcquireUser(pMnode, pMsg->user);
   if (pUser == NULL) return 0;
-  if (!pUser->superAuth) {
+  if (!pUser->superUser) {
     mndReleaseUser(pMnode, pUser);
     terrno = TSDB_CODE_MND_NO_RIGHTS;
     return -1;
@@ -803,7 +805,7 @@ static int32_t mndGetStreamMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg
 
   SUserObj *pUser = mndAcquireUser(pMnode, pMsg->user);
   if (pUser == NULL) return 0;
-  if (!pUser->superAuth) {
+  if (!pUser->superUser) {
     mndReleaseUser(pMnode, pUser);
     terrno = TSDB_CODE_MND_NO_RIGHTS;
     return -1;
diff --git a/source/dnode/mnode/impl/src/mndShow.c b/source/dnode/mnode/impl/src/mndShow.c
index c2b2acfa0c..91a229956f 100644
--- a/source/dnode/mnode/impl/src/mndShow.c
+++ b/source/dnode/mnode/impl/src/mndShow.c
@@ -296,6 +296,8 @@ char *mndShowStr(int32_t showType) {
       return "show streamtables";
     case TSDB_MGMT_TABLE_TP:
       return "show topics";
+    case TSDB_MGMT_TABLE_FUNCTION:
+      return "show functions";
     default:
       return "undefined";
   }
@@ -308,7 +310,7 @@ static bool mndCheckRetrieveFinished(SShowObj *pShow) {
   return false;
 }
 
-void mnodeVacuumResult(char *data, int32_t numOfCols, int32_t rows, int32_t capacity, SShowObj *pShow) {
+void mndVacuumResult(char *data, int32_t numOfCols, int32_t rows, int32_t capacity, SShowObj *pShow) {
   if (rows < capacity) {
     for (int32_t i = 0; i < numOfCols; ++i) {
       memmove(data + pShow->offset[i] * rows, data + pShow->offset[i] * capacity, pShow->bytes[i] * rows);
diff --git a/source/dnode/mnode/impl/src/mndStb.c b/source/dnode/mnode/impl/src/mndStb.c
index c3afbf37c8..d06099416b 100644
--- a/source/dnode/mnode/impl/src/mndStb.c
+++ b/source/dnode/mnode/impl/src/mndStb.c
@@ -285,7 +285,7 @@ static int32_t mndCreateStb(SMnode *pMnode, SMnodeMsg *pMsg, SCreateStbMsg *pCre
   }
   sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
 
-  if (mndTransPrepare(pTrans) != 0) {
+  if (mndTransPrepare(pMnode, pTrans) != 0) {
     mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
     mndTransDrop(pTrans);
     return -1;
@@ -433,7 +433,7 @@ static int32_t mndDropStb(SMnode *pMnode, SMnodeMsg *pMsg, SStbObj *pStb) {
   }
   sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED);
 
-  if (mndTransPrepare(pTrans) != 0) {
+  if (mndTransPrepare(pMnode, pTrans) != 0) {
     mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
     mndTransDrop(pTrans);
     return -1;
@@ -605,7 +605,7 @@ static int32_t mndGetStbMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pM
   return 0;
 }
 
-static void mnodeExtractTableName(char *tableId, char *name) {
+static void mndExtractTableName(char *tableId, char *name) {
   int pos = -1;
   int num = 0;
   for (pos = 0; tableId[pos] != 0; ++pos) {
@@ -665,7 +665,7 @@ static int32_t mndRetrieveStb(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int3
   }
 
   pShow->numOfReads += numOfRows;
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
+  mndVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
   return numOfRows;
 }
 
diff --git a/source/dnode/mnode/impl/src/mndSync.c b/source/dnode/mnode/impl/src/mndSync.c
index 6e7ee662f8..59161b32f2 100644
--- a/source/dnode/mnode/impl/src/mndSync.c
+++ b/source/dnode/mnode/impl/src/mndSync.c
@@ -21,16 +21,16 @@
 int32_t mndInitSync(SMnode *pMnode) { return 0; }
 void    mndCleanupSync(SMnode *pMnode) {}
 
-int32_t mndSyncPropose(SMnode *pMnode, SSdbRaw *pRaw, STransMsg *pMsg) {
+int32_t mndSyncPropose(SMnode *pMnode, SSdbRaw *pRaw) {
   int32_t code = 0;
 
-  int32_t  len = sdbGetRawTotalSize(pRaw);
-  SSdbRaw *pReceived = calloc(1, len);
-  memcpy(pReceived, pRaw, len);
-  mDebug("trans:%d, data:%p recv from sync, code:0x%x pMsg:%p", pMsg->id, pReceived, code & 0xFFFF, pMsg);
+  // int32_t  len = sdbGetRawTotalSize(pRaw);
+  // SSdbRaw *pReceived = calloc(1, len);
+  // memcpy(pReceived, pRaw, len);
+  // mDebug("trans:%d, data:%p recv from sync, code:0x%x pMsg:%p", pMsg->id, pReceived, code & 0xFFFF, pMsg);
 
-  mndTransApply(pMnode, pReceived, pMsg, code);
-  return 0;
+  // mndTransApply(pMnode, pReceived, code);
+  return code;
 }
 
 bool mndIsMaster(SMnode *pMnode) { return true; }
\ No newline at end of file
diff --git a/source/dnode/mnode/impl/src/mndTrans.c b/source/dnode/mnode/impl/src/mndTrans.c
index 3a53472d45..32ac795301 100644
--- a/source/dnode/mnode/impl/src/mndTrans.c
+++ b/source/dnode/mnode/impl/src/mndTrans.c
@@ -17,8 +17,9 @@
 #include "mndTrans.h"
 #include "mndSync.h"
 
-#define SDB_TRANS_VER 1
-#define TRN_DEFAULT_ARRAY_SIZE 8
+#define TSDB_TRANS_VER 1
+#define TSDB_TRN_ARRAY_SIZE 8
+#define TSDB_TRN_RESERVE_SIZE 64
 
 static SSdbRaw *mndTransActionEncode(STrans *pTrans);
 static SSdbRow *mndTransActionDecode(SSdbRaw *pRaw);
@@ -26,6 +27,22 @@ static int32_t  mndTransActionInsert(SSdb *pSdb, STrans *pTrans);
 static int32_t  mndTransActionUpdate(SSdb *pSdb, STrans *OldTrans, STrans *pOldTrans);
 static int32_t  mndTransActionDelete(SSdb *pSdb, STrans *pTrans);
 
+static void    mndTransSetRpcHandle(STrans *pTrans, void *rpcHandle);
+static void    mndTransSendRpcRsp(STrans *pTrans, int32_t code);
+static int32_t mndTransAppendArray(SArray *pArray, SSdbRaw *pRaw);
+static void    mndTransDropArray(SArray *pArray);
+static int32_t mndTransExecuteArray(SMnode *pMnode, SArray *pArray);
+static int32_t mndTransExecuteRedoLogs(SMnode *pMnode, STrans *pTrans);
+static int32_t mndTransExecuteUndoLogs(SMnode *pMnode, STrans *pTrans);
+static int32_t mndTransExecuteCommitLogs(SMnode *pMnode, STrans *pTrans);
+static int32_t mndTransExecuteRedoActions(SMnode *pMnode, STrans *pTrans);
+static int32_t mndTransExecuteUndoActions(SMnode *pMnode, STrans *pTrans);
+static int32_t mndTransPerformPrepareStage(SMnode *pMnode, STrans *pTrans);
+static int32_t mndTransPerformExecuteStage(SMnode *pMnode, STrans *pTrans);
+static int32_t mndTransPerformCommitStage(SMnode *pMnode, STrans *pTrans);
+static int32_t mndTransPerformRollbackStage(SMnode *pMnode, STrans *pTrans);
+static void    mndTransExecute(SMnode *pMnode, STrans *pTrans);
+
 int32_t mndInitTrans(SMnode *pMnode) {
   SSdbTable table = {.sdbType = SDB_TRANS,
                      .keyType = SDB_KEY_INT32,
@@ -41,7 +58,7 @@ int32_t mndInitTrans(SMnode *pMnode) {
 void mndCleanupTrans(SMnode *pMnode) {}
 
 static SSdbRaw *mndTransActionEncode(STrans *pTrans) {
-  int32_t rawDataLen = 16 * sizeof(int32_t);
+  int32_t rawDataLen = 16 * sizeof(int32_t) + TSDB_TRN_RESERVE_SIZE;
   int32_t redoLogNum = taosArrayGetSize(pTrans->redoLogs);
   int32_t undoLogNum = taosArrayGetSize(pTrans->undoLogs);
   int32_t commitLogNum = taosArrayGetSize(pTrans->commitLogs);
@@ -63,7 +80,7 @@ static SSdbRaw *mndTransActionEncode(STrans *pTrans) {
     rawDataLen += sdbGetRawTotalSize(pTmp);
   }
 
-  SSdbRaw *pRaw = sdbAllocRaw(SDB_TRANS, SDB_TRANS_VER, rawDataLen);
+  SSdbRaw *pRaw = sdbAllocRaw(SDB_TRANS, TSDB_TRANS_VER, rawDataLen);
   if (pRaw == NULL) {
     mError("trans:%d, failed to alloc raw since %s", pTrans->id, terrstr());
     return NULL;
@@ -71,7 +88,6 @@ static SSdbRaw *mndTransActionEncode(STrans *pTrans) {
 
   int32_t dataPos = 0;
   SDB_SET_INT32(pRaw, dataPos, pTrans->id)
-  SDB_SET_INT8(pRaw, dataPos, pTrans->stage)
   SDB_SET_INT8(pRaw, dataPos, pTrans->policy)
   SDB_SET_INT32(pRaw, dataPos, redoLogNum)
   SDB_SET_INT32(pRaw, dataPos, undoLogNum)
@@ -100,6 +116,8 @@ static SSdbRaw *mndTransActionEncode(STrans *pTrans) {
     SDB_SET_BINARY(pRaw, dataPos, (void *)pTmp, len)
   }
 
+  SDB_SET_RESERVE(pRaw, dataPos, TSDB_TRN_RESERVE_SIZE)
+  SDB_SET_DATALEN(pRaw, dataPos);
   mTrace("trans:%d, encode to raw:%p, len:%d", pTrans->id, pRaw, dataPos);
   return pRaw;
 }
@@ -113,7 +131,7 @@ static SSdbRow *mndTransActionDecode(SSdbRaw *pRaw) {
     return NULL;
   }
 
-  if (sver != SDB_TRANS_VER) {
+  if (sver != TSDB_TRANS_VER) {
     terrno = TSDB_CODE_SDB_INVALID_DATA_VER;
     mError("failed to get check soft ver from raw:%p since %s", pRaw, terrstr());
     return NULL;
@@ -126,11 +144,11 @@ static SSdbRow *mndTransActionDecode(SSdbRaw *pRaw) {
     return NULL;
   }
 
-  pTrans->redoLogs = taosArrayInit(TRN_DEFAULT_ARRAY_SIZE, sizeof(void *));
-  pTrans->undoLogs = taosArrayInit(TRN_DEFAULT_ARRAY_SIZE, sizeof(void *));
-  pTrans->commitLogs = taosArrayInit(TRN_DEFAULT_ARRAY_SIZE, sizeof(void *));
-  pTrans->redoActions = taosArrayInit(TRN_DEFAULT_ARRAY_SIZE, sizeof(void *));
-  pTrans->undoActions = taosArrayInit(TRN_DEFAULT_ARRAY_SIZE, sizeof(void *));
+  pTrans->redoLogs = taosArrayInit(TSDB_TRN_ARRAY_SIZE, sizeof(void *));
+  pTrans->undoLogs = taosArrayInit(TSDB_TRN_ARRAY_SIZE, sizeof(void *));
+  pTrans->commitLogs = taosArrayInit(TSDB_TRN_ARRAY_SIZE, sizeof(void *));
+  pTrans->redoActions = taosArrayInit(TSDB_TRN_ARRAY_SIZE, sizeof(void *));
+  pTrans->undoActions = taosArrayInit(TSDB_TRN_ARRAY_SIZE, sizeof(void *));
 
   if (pTrans->redoLogs == NULL || pTrans->undoLogs == NULL || pTrans->commitLogs == NULL ||
       pTrans->redoActions == NULL || pTrans->undoActions == NULL) {
@@ -147,7 +165,6 @@ static SSdbRow *mndTransActionDecode(SSdbRaw *pRaw) {
 
   int32_t dataPos = 0;
   SDB_GET_INT32(pRaw, pRow, dataPos, &pTrans->id)
-  SDB_GET_INT8(pRaw, pRow, dataPos, (int8_t *)&pTrans->stage)
   SDB_GET_INT8(pRaw, pRow, dataPos, (int8_t *)&pTrans->policy)
   SDB_GET_INT32(pRaw, pRow, dataPos, &redoLogNum)
   SDB_GET_INT32(pRaw, pRow, dataPos, &undoLogNum)
@@ -197,6 +214,8 @@ static SSdbRow *mndTransActionDecode(SSdbRaw *pRaw) {
     }
   }
 
+  SDB_GET_RESERVE(pRaw, pRow, dataPos, TSDB_TRN_RESERVE_SIZE)
+
 TRANS_DECODE_OVER:
   if (code != 0) {
     mError("trans:%d, failed to parse from raw:%p since %s", pTrans->id, pRaw, tstrerror(errno));
@@ -210,62 +229,65 @@ TRANS_DECODE_OVER:
 }
 
 static int32_t mndTransActionInsert(SSdb *pSdb, STrans *pTrans) {
-  mTrace("trans:%d, perform insert action, stage:%d", pTrans->id, pTrans->stage);
-
-  SArray *pArray = pTrans->redoLogs;
-  int32_t arraySize = taosArrayGetSize(pArray);
-
-  for (int32_t i = 0; i < arraySize; ++i) {
-    SSdbRaw *pRaw = taosArrayGetP(pArray, i);
-    int32_t  code = sdbWrite(pSdb, pRaw);
-    if (code != 0) {
-      mError("trans:%d, failed to write raw:%p to sdb since %s", pTrans->id, pRaw, terrstr());
-      return code;
-    }
-  }
+  pTrans->stage = TRN_STAGE_PREPARE;
+  mTrace("trans:%d, perform insert action, stage:%s", pTrans->id, mndTransStageStr(pTrans->stage));
   return 0;
 }
 
 static int32_t mndTransActionDelete(SSdb *pSdb, STrans *pTrans) {
-  mTrace("trans:%d, perform delete action, stage:%d", pTrans->id, pTrans->stage);
+  mTrace("trans:%d, perform delete action, stage:%s", pTrans->id, mndTransStageStr(pTrans->stage));
 
-  SArray *pArray = pTrans->undoLogs;
-  int32_t arraySize = taosArrayGetSize(pArray);
-
-  for (int32_t i = 0; i < arraySize; ++i) {
-    SSdbRaw *pRaw = taosArrayGetP(pArray, i);
-    int32_t  code = sdbWrite(pSdb, pRaw);
-    if (code != 0) {
-      mError("trans:%d, failed to write raw:%p to sdb since %s", pTrans->id, pRaw, terrstr());
-      return code;
-    }
-  }
+  mndTransDropArray(pTrans->redoLogs);
+  mndTransDropArray(pTrans->undoLogs);
+  mndTransDropArray(pTrans->commitLogs);
+  mndTransDropArray(pTrans->redoActions);
+  mndTransDropArray(pTrans->undoActions);
 
   return 0;
 }
 
 static int32_t mndTransActionUpdate(SSdb *pSdb, STrans *pOldTrans, STrans *pNewTrans) {
-  mTrace("trans:%d, perform update action, stage:%d", pOldTrans->id, pNewTrans->stage);
-
-  SArray *pArray = pOldTrans->commitLogs;
-  int32_t arraySize = taosArrayGetSize(pArray);
-
-  for (int32_t i = 0; i < arraySize; ++i) {
-    SSdbRaw *pRaw = taosArrayGetP(pArray, i);
-    int32_t  code = sdbWrite(pSdb, pRaw);
-    if (code != 0) {
-      mError("trans:%d, failed to write raw:%p to sdb since %s", pOldTrans->id, pRaw, terrstr());
-      return code;
-    }
-  }
-
+  mTrace("trans:%d, perform update action, stage:%s", pOldTrans->id, mndTransStageStr(pNewTrans->stage));
   pOldTrans->stage = pNewTrans->stage;
   return 0;
 }
 
-static int32_t trnGenerateTransId() {
-  static int32_t tmp = 0;
-  return ++tmp;
+STrans *mndAcquireTrans(SMnode *pMnode, int32_t transId) {
+  SSdb *pSdb = pMnode->pSdb;
+  return sdbAcquire(pSdb, SDB_TRANS, &transId);
+}
+
+void mndReleaseTrans(SMnode *pMnode, STrans *pTrans) {
+  SSdb *pSdb = pMnode->pSdb;
+  sdbRelease(pSdb, pTrans);
+}
+
+char *mndTransStageStr(ETrnStage stage) {
+  switch (stage) {
+    case TRN_STAGE_PREPARE:
+      return "prepare";
+    case TRN_STAGE_EXECUTE:
+      return "execute";
+    case TRN_STAGE_COMMIT:
+      return "commit";
+    case TRN_STAGE_ROLLBACK:
+      return "rollback";
+    case TRN_STAGE_RETRY:
+      return "retry";
+    default:
+      return "undefined";
+  }
+}
+
+char *mndTransPolicyStr(ETrnPolicy policy) {
+  switch (policy) {
+    case TRN_POLICY_ROLLBACK:
+      return "prepare";
+    case TRN_POLICY_RETRY:
+      return "retry";
+    default:
+      return "undefined";
+  }
 }
 
 STrans *mndTransCreate(SMnode *pMnode, ETrnPolicy policy, void *rpcHandle) {
@@ -276,16 +298,15 @@ STrans *mndTransCreate(SMnode *pMnode, ETrnPolicy policy, void *rpcHandle) {
     return NULL;
   }
 
-  pTrans->id = trnGenerateTransId();
+  pTrans->id = sdbGetMaxId(pMnode->pSdb, SDB_TRANS);
   pTrans->stage = TRN_STAGE_PREPARE;
   pTrans->policy = policy;
-  pTrans->pMnode = pMnode;
   pTrans->rpcHandle = rpcHandle;
-  pTrans->redoLogs = taosArrayInit(TRN_DEFAULT_ARRAY_SIZE, sizeof(void *));
-  pTrans->undoLogs = taosArrayInit(TRN_DEFAULT_ARRAY_SIZE, sizeof(void *));
-  pTrans->commitLogs = taosArrayInit(TRN_DEFAULT_ARRAY_SIZE, sizeof(void *));
-  pTrans->redoActions = taosArrayInit(TRN_DEFAULT_ARRAY_SIZE, sizeof(void *));
-  pTrans->undoActions = taosArrayInit(TRN_DEFAULT_ARRAY_SIZE, sizeof(void *));
+  pTrans->redoLogs = taosArrayInit(TSDB_TRN_ARRAY_SIZE, sizeof(void *));
+  pTrans->undoLogs = taosArrayInit(TSDB_TRN_ARRAY_SIZE, sizeof(void *));
+  pTrans->commitLogs = taosArrayInit(TSDB_TRN_ARRAY_SIZE, sizeof(void *));
+  pTrans->redoActions = taosArrayInit(TSDB_TRN_ARRAY_SIZE, sizeof(void *));
+  pTrans->undoActions = taosArrayInit(TSDB_TRN_ARRAY_SIZE, sizeof(void *));
 
   if (pTrans->redoLogs == NULL || pTrans->undoLogs == NULL || pTrans->commitLogs == NULL ||
       pTrans->redoActions == NULL || pTrans->undoActions == NULL) {
@@ -298,7 +319,7 @@ STrans *mndTransCreate(SMnode *pMnode, ETrnPolicy policy, void *rpcHandle) {
   return pTrans;
 }
 
-static void trnDropArray(SArray *pArray) {
+static void mndTransDropArray(SArray *pArray) {
   for (int32_t i = 0; i < pArray->size; ++i) {
     SSdbRaw *pRaw = taosArrayGetP(pArray, i);
     tfree(pRaw);
@@ -308,17 +329,17 @@ static void trnDropArray(SArray *pArray) {
 }
 
 void mndTransDrop(STrans *pTrans) {
-  trnDropArray(pTrans->redoLogs);
-  trnDropArray(pTrans->undoLogs);
-  trnDropArray(pTrans->commitLogs);
-  trnDropArray(pTrans->redoActions);
-  trnDropArray(pTrans->undoActions);
+  mndTransDropArray(pTrans->redoLogs);
+  mndTransDropArray(pTrans->undoLogs);
+  mndTransDropArray(pTrans->commitLogs);
+  mndTransDropArray(pTrans->redoActions);
+  mndTransDropArray(pTrans->undoActions);
 
   mDebug("trans:%d, data:%p is dropped", pTrans->id, pTrans);
   tfree(pTrans);
 }
 
-void mndTransSetRpcHandle(STrans *pTrans, void *rpcHandle) {
+static void mndTransSetRpcHandle(STrans *pTrans, void *rpcHandle) {
   pTrans->rpcHandle = rpcHandle;
   mTrace("trans:%d, set rpc handle:%p", pTrans->id, rpcHandle);
 }
@@ -340,19 +361,19 @@ static int32_t mndTransAppendArray(SArray *pArray, SSdbRaw *pRaw) {
 
 int32_t mndTransAppendRedolog(STrans *pTrans, SSdbRaw *pRaw) {
   int32_t code = mndTransAppendArray(pTrans->redoLogs, pRaw);
-  mTrace("trans:%d, raw:%p append to redo logs, code:%d", pTrans->id, pRaw, code);
+  mTrace("trans:%d, raw:%p append to redo logs, code:0x%x", pTrans->id, pRaw, code);
   return code;
 }
 
 int32_t mndTransAppendUndolog(STrans *pTrans, SSdbRaw *pRaw) {
   int32_t code = mndTransAppendArray(pTrans->undoLogs, pRaw);
-  mTrace("trans:%d, raw:%p append to undo logs, code:%d", pTrans->id, pRaw, code);
+  mTrace("trans:%d, raw:%p append to undo logs, code:0x%x", pTrans->id, pRaw, code);
   return code;
 }
 
 int32_t mndTransAppendCommitlog(STrans *pTrans, SSdbRaw *pRaw) {
   int32_t code = mndTransAppendArray(pTrans->commitLogs, pRaw);
-  mTrace("trans:%d, raw:%p append to commit logs, code:%d", pTrans->id, pRaw, code);
+  mTrace("trans:%d, raw:%p append to commit logs, code:0x%x", pTrans->id, pRaw, code);
   return code;
 }
 
@@ -368,7 +389,7 @@ int32_t mndTransAppendUndoAction(STrans *pTrans, SEpSet *pEpSet, void *pMsg) {
   return code;
 }
 
-int32_t mndTransPrepare(STrans *pTrans) {
+int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans) {
   mDebug("trans:%d, prepare transaction", pTrans->id);
 
   SSdbRaw *pRaw = mndTransActionEncode(pTrans);
@@ -376,180 +397,295 @@ int32_t mndTransPrepare(STrans *pTrans) {
     mError("trans:%d, failed to decode trans since %s", pTrans->id, terrstr());
     return -1;
   }
-  sdbSetRawStatus(pRaw, SDB_STATUS_CREATING);
+  sdbSetRawStatus(pRaw, SDB_STATUS_READY);
 
-  if (sdbWriteNotFree(pTrans->pMnode->pSdb, pRaw) != 0) {
-    mError("trans:%d, failed to write trans since %s", pTrans->id, terrstr());
-    return -1;
-  }
-
-  STransMsg *pMsg = calloc(1, sizeof(STransMsg));
-  pMsg->id = pTrans->id;
-  pMsg->rpcHandle = pTrans->rpcHandle;
-
-  mDebug("trans:%d, start sync, RPC:%p pMsg:%p", pTrans->id, pTrans->rpcHandle, pMsg);
-  if (mndSyncPropose(pTrans->pMnode, pRaw, pMsg) != 0) {
+  mTrace("trans:%d, start sync", pTrans->id);
+  int32_t code = mndSyncPropose(pMnode, pRaw);
+  if (code != 0) {
     mError("trans:%d, failed to sync since %s", pTrans->id, terrstr());
-    free(pMsg);
     sdbFreeRaw(pRaw);
     return -1;
   }
 
-  sdbFreeRaw(pRaw);
+  mTrace("trans:%d, sync finished", pTrans->id);
+
+  code = sdbWrite(pMnode->pSdb, pRaw);
+  if (code != 0) {
+    mError("trans:%d, failed to write sdb since %s", pTrans->id, terrstr());
+    return -1;
+  }
+
+  STrans *pNewTrans = mndAcquireTrans(pMnode, pTrans->id);
+  if (pNewTrans == NULL) {
+    mError("trans:%d, failed to ready from sdb since %s", pTrans->id, terrstr());
+    return -1;
+  }
+
+  mDebug("trans:%d, prepare finished", pNewTrans->id);
+  pNewTrans->rpcHandle = pTrans->rpcHandle;
+  mndTransExecute(pMnode, pNewTrans);
+  mndReleaseTrans(pMnode, pNewTrans);
   return 0;
 }
 
-static void trnSendRpcRsp(STransMsg *pMsg, int32_t code) {
-  mDebug("trans:%d, send rpc rsp, RPC:%p code:0x%x pMsg:%p", pMsg->id, pMsg->rpcHandle, code & 0xFFFF, pMsg);
-  if (pMsg->rpcHandle != NULL) {
-    SRpcMsg rspMsg = {.handle = pMsg->rpcHandle, .code = code};
-    rpcSendResponse(&rspMsg);
+int32_t mndTransCommit(SMnode *pMnode, STrans *pTrans) {
+  mDebug("trans:%d, commit transaction", pTrans->id);
+
+  SSdbRaw *pRaw = mndTransActionEncode(pTrans);
+  if (pRaw == NULL) {
+    mError("trans:%d, failed to decode trans since %s", pTrans->id, terrstr());
+    return -1;
+  }
+  sdbSetRawStatus(pRaw, SDB_STATUS_DROPPED);
+
+  if (taosArrayGetSize(pTrans->commitLogs) != 0) {
+    mTrace("trans:%d, start sync", pTrans->id);
+    int32_t code = mndSyncPropose(pMnode, pRaw);
+    if (code != 0) {
+      mError("trans:%d, failed to sync since %s", pTrans->id, terrstr());
+      sdbFreeRaw(pRaw);
+      return -1;
+    }
+
+    mTrace("trans:%d, sync finished", pTrans->id);
+    code = sdbWrite(pMnode->pSdb, pRaw);
+    if (code != 0) {
+      mError("trans:%d, failed to write sdb since %s", pTrans->id, terrstr());
+      return -1;
+    }
   }
 
-  free(pMsg);
+  mDebug("trans:%d, commit finished", pTrans->id);
+  return 0;
+}
+
+int32_t mndTransRollback(SMnode *pMnode, STrans *pTrans) {
+  mDebug("trans:%d, rollback transaction", pTrans->id);
+
+  SSdbRaw *pRaw = mndTransActionEncode(pTrans);
+  if (pRaw == NULL) {
+    mError("trans:%d, failed to decode trans since %s", pTrans->id, terrstr());
+    return -1;
+  }
+  sdbSetRawStatus(pRaw, SDB_STATUS_DROPPED);
+
+  mTrace("trans:%d, start sync", pTrans->id);
+  int32_t code = mndSyncPropose(pMnode, pRaw);
+  if (code != 0) {
+    mError("trans:%d, failed to sync since %s", pTrans->id, terrstr());
+    sdbFreeRaw(pRaw);
+    return -1;
+  }
+
+  mTrace("trans:%d, sync finished", pTrans->id);
+  code = sdbWrite(pMnode->pSdb, pRaw);
+  if (code != 0) {
+    mError("trans:%d, failed to write sdb since %s", pTrans->id, terrstr());
+    return -1;
+  }
+
+  mDebug("trans:%d, rollback finished", pTrans->id);
+  return 0;
+}
+
+static void mndTransSendRpcRsp(STrans *pTrans, int32_t code) {
+  if (code == TSDB_CODE_MND_ACTION_IN_PROGRESS) return;
+  mDebug("trans:%d, send rpc rsp, RPC:%p code:0x%x", pTrans->id, pTrans->rpcHandle, code & 0xFFFF);
+
+  if (pTrans->rpcHandle != NULL) {
+    SRpcMsg rspMsg = {.handle = pTrans->rpcHandle, .code = code};
+    rpcSendResponse(&rspMsg);
+  }
 }
 
 void mndTransApply(SMnode *pMnode, SSdbRaw *pRaw, STransMsg *pMsg, int32_t code) {
-  if (code == 0) {
-    mDebug("trans:%d, commit transaction", pMsg->id);
-    sdbSetRawStatus(pRaw, SDB_STATUS_READY);
-    if (sdbWrite(pMnode->pSdb, pRaw) != 0) {
-      code = terrno;
-      mError("trans:%d, failed to write sdb while commit since %s", pMsg->id, terrstr());
-    }
-    trnSendRpcRsp(pMsg, code);
-  } else {
-    mDebug("trans:%d, rollback transaction", pMsg->id);
-    sdbSetRawStatus(pRaw, SDB_STATUS_DROPPED);
-    if (sdbWrite(pMnode->pSdb, pRaw) != 0) {
-      mError("trans:%d, failed to write sdb while rollback since %s", pMsg->id, terrstr());
-    }
-    trnSendRpcRsp(pMsg, code);
-  }
+  // todo
 }
 
-static int32_t trnExecuteArray(SMnode *pMnode, SArray *pArray) {
-  for (int32_t i = 0; i < pArray->size; ++i) {
+static int32_t mndTransExecuteArray(SMnode *pMnode, SArray *pArray) {
+  SSdb   *pSdb = pMnode->pSdb;
+  int32_t arraySize = taosArrayGetSize(pArray);
+
+  for (int32_t i = 0; i < arraySize; ++i) {
     SSdbRaw *pRaw = taosArrayGetP(pArray, i);
-    if (sdbWrite(pMnode->pSdb, pRaw) != 0) {
-      return -1;
+    int32_t  code = sdbWriteNotFree(pSdb, pRaw);
+    if (code != 0) {
+      return code;
     }
   }
 
   return 0;
 }
 
-static int32_t trnExecuteRedoLogs(STrans *pTrans) { return trnExecuteArray(pTrans->pMnode, pTrans->redoLogs); }
-
-static int32_t trnExecuteUndoLogs(STrans *pTrans) { return trnExecuteArray(pTrans->pMnode, pTrans->undoLogs); }
-
-static int32_t trnExecuteCommitLogs(STrans *pTrans) { return trnExecuteArray(pTrans->pMnode, pTrans->commitLogs); }
-
-static int32_t trnExecuteRedoActions(STrans *pTrans) { return trnExecuteArray(pTrans->pMnode, pTrans->redoActions); }
-
-static int32_t trnExecuteUndoActions(STrans *pTrans) { return trnExecuteArray(pTrans->pMnode, pTrans->undoActions); }
-
-static int32_t trnPerformPrepareStage(STrans *pTrans) {
-  if (trnExecuteRedoLogs(pTrans) == 0) {
-    pTrans->stage = TRN_STAGE_EXECUTE;
-    return 0;
-  } else {
-    pTrans->stage = TRN_STAGE_ROLLBACK;
-    return -1;
+static int32_t mndTransExecuteRedoLogs(SMnode *pMnode, STrans *pTrans) {
+  int32_t code = 0;
+  if (taosArrayGetSize(pTrans->redoLogs) != 0) {
+    code = mndTransExecuteArray(pMnode, pTrans->redoLogs);
+    if (code != 0) {
+      mError("trans:%d, failed to execute redo logs since %s", pTrans->id, terrstr())
+    } else {
+      mTrace("trans:%d, execute redo logs finished", pTrans->id)
+    }
   }
+
+  return code;
 }
 
-static int32_t trnPerformExecuteStage(STrans *pTrans) {
-  int32_t code = trnExecuteRedoActions(pTrans);
+static int32_t mndTransExecuteUndoLogs(SMnode *pMnode, STrans *pTrans) {
+  int32_t code = 0;
+  if (taosArrayGetSize(pTrans->undoLogs) != 0) {
+    code = mndTransExecuteArray(pMnode, pTrans->undoLogs);
+    if (code != 0) {
+      mError("trans:%d, failed to execute undo logs since %s", pTrans->id, terrstr())
+    } else {
+      mTrace("trans:%d, execute undo logs finished", pTrans->id)
+    }
+  }
+
+  return code;
+}
+
+static int32_t mndTransExecuteCommitLogs(SMnode *pMnode, STrans *pTrans) {
+  int32_t code = 0;
+  if (taosArrayGetSize(pTrans->commitLogs) != 0) {
+    code = mndTransExecuteArray(pMnode, pTrans->commitLogs);
+    if (code != 0) {
+      mError("trans:%d, failed to execute commit logs since %s", pTrans->id, terrstr())
+    } else {
+      mTrace("trans:%d, execute commit logs finished", pTrans->id)
+    }
+  }
+
+  return code;
+}
+
+static int32_t mndTransExecuteRedoActions(SMnode *pMnode, STrans *pTrans) {
+  if (taosArrayGetSize(pTrans->redoActions) != 0) {
+    mTrace("trans:%d, execute redo actions finished", pTrans->id);
+  }
+  return 0;
+}
+
+static int32_t mndTransExecuteUndoActions(SMnode *pMnode, STrans *pTrans) {
+  if (taosArrayGetSize(pTrans->undoActions) != 0) {
+    mTrace("trans:%d, execute undo actions finished", pTrans->id);
+  }
+  return 0;
+}
+
+static int32_t mndTransPerformPrepareStage(SMnode *pMnode, STrans *pTrans) {
+  int32_t code = mndTransExecuteRedoLogs(pMnode, pTrans);
+
+  if (code == 0) {
+    pTrans->stage = TRN_STAGE_EXECUTE;
+    mTrace("trans:%d, stage from prepare to execute", pTrans->id);
+  } else {
+    pTrans->stage = TRN_STAGE_ROLLBACK;
+    mError("trans:%d, stage from prepare to rollback since %s", pTrans->id, terrstr());
+  }
+
+  return 0;
+}
+
+static int32_t mndTransPerformExecuteStage(SMnode *pMnode, STrans *pTrans) {
+  int32_t code = mndTransExecuteRedoActions(pMnode, pTrans);
 
   if (code == 0) {
     pTrans->stage = TRN_STAGE_COMMIT;
-    return 0;
+    mTrace("trans:%d, stage from execute to commit", pTrans->id);
   } else if (code == TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-    return -1;
+    mTrace("trans:%d, stage keep on execute since %s", pTrans->id, terrstr(code));
+    return code;
   } else {
-    if (pTrans->policy == TRN_POLICY_RETRY) {
-      pTrans->stage = TRN_STAGE_RETRY;
-    } else {
+    if (pTrans->policy == TRN_POLICY_ROLLBACK) {
       pTrans->stage = TRN_STAGE_ROLLBACK;
+      mError("trans:%d, stage from execute to rollback since %s", pTrans->id, terrstr());
+    } else {
+      pTrans->stage = TRN_STAGE_RETRY;
+      mError("trans:%d, stage from execute to retry since %s", pTrans->id, terrstr());
     }
-    return 0;
   }
+
+  return 0;
 }
 
-static int32_t trnPerformCommitStage(STrans *pTrans) {
-  if (trnExecuteCommitLogs(pTrans) == 0) {
-    pTrans->stage = TRN_STAGE_EXECUTE;
-    return 0;
+static int32_t mndTransPerformCommitStage(SMnode *pMnode, STrans *pTrans) {
+  int32_t code = mndTransExecuteCommitLogs(pMnode, pTrans);
+
+  if (code == 0) {
+    pTrans->stage = TRN_STAGE_OVER;
+    mTrace("trans:%d, commit stage finished", pTrans->id);
+  } else {
+    if (pTrans->policy == TRN_POLICY_ROLLBACK) {
+      pTrans->stage = TRN_STAGE_ROLLBACK;
+      mError("trans:%d, stage from commit to rollback since %s", pTrans->id, terrstr());
+    } else {
+      pTrans->stage = TRN_STAGE_RETRY;
+      mError("trans:%d, stage from commit to retry since %s", pTrans->id, terrstr());
+    }
+  }
+
+  return code;
+}
+
+static int32_t mndTransPerformRollbackStage(SMnode *pMnode, STrans *pTrans) {
+  int32_t code = mndTransExecuteUndoActions(pMnode, pTrans);
+
+  if (code == 0) {
+    mTrace("trans:%d, rollbacked", pTrans->id);
   } else {
     pTrans->stage = TRN_STAGE_ROLLBACK;
-    return -1;
+    mError("trans:%d, stage keep on rollback since %s", pTrans->id, terrstr());
   }
+
+  return code;
 }
 
-static int32_t trnPerformRollbackStage(STrans *pTrans) {
-  if (trnExecuteCommitLogs(pTrans) == 0) {
-    pTrans->stage = TRN_STAGE_EXECUTE;
-    return 0;
+static int32_t mndTransPerformRetryStage(SMnode *pMnode, STrans *pTrans) {
+  int32_t code = mndTransExecuteRedoActions(pMnode, pTrans);
+
+  if (code == 0) {
+    pTrans->stage = TRN_STAGE_COMMIT;
+    mTrace("trans:%d, stage from retry to commit", pTrans->id);
   } else {
-    pTrans->stage = TRN_STAGE_ROLLBACK;
-    return -1;
+    pTrans->stage = TRN_STAGE_RETRY;
+    mError("trans:%d, stage keep on retry since %s", pTrans->id, terrstr());
   }
+
+  return code;
 }
 
-static int32_t trnPerformRetryStage(STrans *pTrans) {
-  if (trnExecuteCommitLogs(pTrans) == 0) {
-    pTrans->stage = TRN_STAGE_EXECUTE;
-    return 0;
-  } else {
-    pTrans->stage = TRN_STAGE_ROLLBACK;
-    return -1;
-  }
-}
-
-int32_t mndTransExecute(SSdb *pSdb, int32_t tranId) {
+static void mndTransExecute(SMnode *pMnode, STrans *pTrans) {
   int32_t code = 0;
 
-  STrans *pTrans = sdbAcquire(pSdb, SDB_TRANS, &tranId);
-  if (pTrans == NULL) {
-    return -1;
-  }
-
-  if (pTrans->stage == TRN_STAGE_PREPARE) {
-    if (trnPerformPrepareStage(pTrans) != 0) {
-      sdbRelease(pSdb, pTrans);
-      return -1;
+  while (code == 0) {
+    switch (pTrans->stage) {
+      case TRN_STAGE_PREPARE:
+        code = mndTransPerformPrepareStage(pMnode, pTrans);
+        break;
+      case TRN_STAGE_EXECUTE:
+        code = mndTransPerformExecuteStage(pMnode, pTrans);
+        break;
+      case TRN_STAGE_COMMIT:
+        code = mndTransCommit(pMnode, pTrans);
+        if (code == 0) {
+          code = mndTransPerformCommitStage(pMnode, pTrans);
+        }
+        break;
+      case TRN_STAGE_ROLLBACK:
+        code = mndTransPerformRollbackStage(pMnode, pTrans);
+        if (code == 0) {
+          code = mndTransRollback(pMnode, pTrans);
+        }
+        break;
+      case TRN_STAGE_RETRY:
+        code = mndTransPerformRetryStage(pMnode, pTrans);
+        break;
+      default:
+        mndTransSendRpcRsp(pTrans, 0);
+        return;
     }
   }
 
-  if (pTrans->stage == TRN_STAGE_EXECUTE) {
-    if (trnPerformExecuteStage(pTrans) != 0) {
-      sdbRelease(pSdb, pTrans);
-      return -1;
-    }
-  }
-
-  if (pTrans->stage == TRN_STAGE_COMMIT) {
-    if (trnPerformCommitStage(pTrans) != 0) {
-      sdbRelease(pSdb, pTrans);
-      return -1;
-    }
-  }
-
-  if (pTrans->stage == TRN_STAGE_ROLLBACK) {
-    if (trnPerformRollbackStage(pTrans) != 0) {
-      sdbRelease(pSdb, pTrans);
-      return -1;
-    }
-  }
-
-  if (pTrans->stage == TRN_STAGE_RETRY) {
-    if (trnPerformRetryStage(pTrans) != 0) {
-      sdbRelease(pSdb, pTrans);
-      return -1;
-    }
-  }
-
-  sdbRelease(pSdb, pTrans);
-  return 0;
-}
\ No newline at end of file
+  mndTransSendRpcRsp(pTrans, code);
+}
diff --git a/source/dnode/mnode/impl/src/mndUser.c b/source/dnode/mnode/impl/src/mndUser.c
index 2f582a810d..7219342d59 100644
--- a/source/dnode/mnode/impl/src/mndUser.c
+++ b/source/dnode/mnode/impl/src/mndUser.c
@@ -20,7 +20,8 @@
 #include "mndTrans.h"
 #include "tkey.h"
 
-#define SDB_USER_VER 1
+#define TSDB_USER_VER 1
+#define TSDB_USER_RESERVE_SIZE 64
 
 static int32_t  mndCreateDefaultUsers(SMnode *pMnode);
 static SSdbRaw *mndUserActionEncode(SUserObj *pUser);
@@ -65,11 +66,9 @@ static int32_t mndCreateDefaultUser(SMnode *pMnode, char *acct, char *user, char
   taosEncryptPass((uint8_t *)pass, strlen(pass), userObj.pass);
   userObj.createdTime = taosGetTimestampMs();
   userObj.updateTime = userObj.createdTime;
-  userObj.readAuth = 1;
-  userObj.writeAuth = 1;
 
   if (strcmp(user, TSDB_DEFAULT_USER) == 0) {
-    userObj.superAuth = 1;
+    userObj.superUser = 1;
   }
 
   SSdbRaw *pRaw = mndUserActionEncode(&userObj);
@@ -89,24 +88,23 @@ static int32_t mndCreateDefaultUsers(SMnode *pMnode) {
   if (mndCreateDefaultUser(pMnode, TSDB_DEFAULT_USER, "_" TSDB_DEFAULT_USER, TSDB_DEFAULT_PASS) != 0) {
     return -1;
   }
-#endif  
+#endif
 
   return 0;
 }
 
 static SSdbRaw *mndUserActionEncode(SUserObj *pUser) {
-  SSdbRaw *pRaw = sdbAllocRaw(SDB_USER, SDB_USER_VER, sizeof(SUserObj));
+  SSdbRaw *pRaw = sdbAllocRaw(SDB_USER, TSDB_USER_VER, sizeof(SUserObj) + TSDB_USER_RESERVE_SIZE);
   if (pRaw == NULL) return NULL;
 
   int32_t dataPos = 0;
   SDB_SET_BINARY(pRaw, dataPos, pUser->user, TSDB_USER_LEN)
-  SDB_SET_BINARY(pRaw, dataPos, pUser->pass, TSDB_KEY_LEN)
+  SDB_SET_BINARY(pRaw, dataPos, pUser->pass, TSDB_PASSWORD_LEN)
   SDB_SET_BINARY(pRaw, dataPos, pUser->acct, TSDB_USER_LEN)
   SDB_SET_INT64(pRaw, dataPos, pUser->createdTime)
   SDB_SET_INT64(pRaw, dataPos, pUser->updateTime)
-  SDB_SET_INT8(pRaw, dataPos, pUser->superAuth)
-  SDB_SET_INT8(pRaw, dataPos, pUser->readAuth)
-  SDB_SET_INT8(pRaw, dataPos, pUser->writeAuth)
+  SDB_SET_INT8(pRaw, dataPos, pUser->superUser)
+  SDB_SET_RESERVE(pRaw, dataPos, TSDB_USER_RESERVE_SIZE)
   SDB_SET_DATALEN(pRaw, dataPos);
 
   return pRaw;
@@ -116,7 +114,7 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) {
   int8_t sver = 0;
   if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL;
 
-  if (sver != SDB_USER_VER) {
+  if (sver != TSDB_USER_VER) {
     mError("failed to decode user since %s", terrstr());
     terrno = TSDB_CODE_SDB_INVALID_DATA_VER;
     return NULL;
@@ -128,13 +126,12 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) {
 
   int32_t dataPos = 0;
   SDB_GET_BINARY(pRaw, pRow, dataPos, pUser->user, TSDB_USER_LEN)
-  SDB_GET_BINARY(pRaw, pRow, dataPos, pUser->pass, TSDB_KEY_LEN)
+  SDB_GET_BINARY(pRaw, pRow, dataPos, pUser->pass, TSDB_PASSWORD_LEN)
   SDB_GET_BINARY(pRaw, pRow, dataPos, pUser->acct, TSDB_USER_LEN)
   SDB_GET_INT64(pRaw, pRow, dataPos, &pUser->createdTime)
   SDB_GET_INT64(pRaw, pRow, dataPos, &pUser->updateTime)
-  SDB_GET_INT8(pRaw, pRow, dataPos, &pUser->superAuth)
-  SDB_GET_INT8(pRaw, pRow, dataPos, &pUser->readAuth)
-  SDB_GET_INT8(pRaw, pRow, dataPos, &pUser->writeAuth)
+  SDB_GET_INT8(pRaw, pRow, dataPos, &pUser->superUser)
+  SDB_GET_RESERVE(pRaw, pRow, dataPos, TSDB_USER_RESERVE_SIZE)
 
   return pRow;
 }
@@ -172,14 +169,8 @@ static int32_t mndUserActionDelete(SSdb *pSdb, SUserObj *pUser) {
 
 static int32_t mndUserActionUpdate(SSdb *pSdb, SUserObj *pOldUser, SUserObj *pNewUser) {
   mTrace("user:%s, perform update action", pOldUser->user);
-  memcpy(pOldUser->user, pNewUser->user, TSDB_USER_LEN);
-  memcpy(pOldUser->pass, pNewUser->pass, TSDB_KEY_LEN);
-  memcpy(pOldUser->acct, pNewUser->acct, TSDB_USER_LEN);
-  pOldUser->createdTime = pNewUser->createdTime;
+  memcpy(pOldUser->pass, pNewUser->pass, TSDB_PASSWORD_LEN);
   pOldUser->updateTime = pNewUser->updateTime;
-  pOldUser->superAuth = pNewUser->superAuth;
-  pOldUser->readAuth = pNewUser->readAuth;
-  pOldUser->writeAuth = pNewUser->writeAuth;
   return 0;
 }
 
@@ -200,9 +191,7 @@ static int32_t mndCreateUser(SMnode *pMnode, char *acct, char *user, char *pass,
   taosEncryptPass((uint8_t *)pass, strlen(pass), userObj.pass);
   userObj.createdTime = taosGetTimestampMs();
   userObj.updateTime = userObj.createdTime;
-  userObj.superAuth = 0;
-  userObj.readAuth = 1;
-  userObj.writeAuth = 1;
+  userObj.superUser = 0;
 
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, pMsg->rpcMsg.handle);
   if (pTrans == NULL) {
@@ -217,101 +206,9 @@ static int32_t mndCreateUser(SMnode *pMnode, char *acct, char *user, char *pass,
     mndTransDrop(pTrans);
     return -1;
   }
-  sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING);
-
-  SSdbRaw *pUndoRaw = mndUserActionEncode(&userObj);
-  if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) {
-    mError("trans:%d, failed to append undo log since %s", pTrans->id, terrstr());
-    mndTransDrop(pTrans);
-    return -1;
-  }
-  sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED);
-
-  SSdbRaw *pCommitRaw = mndUserActionEncode(&userObj);
-  if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
-    mError("trans:%d, failed to append commit log since %s", pTrans->id, terrstr());
-    mndTransDrop(pTrans);
-    return -1;
-  }
-  sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
-
-  if (mndTransPrepare(pTrans) != 0) {
-    mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
-    mndTransDrop(pTrans);
-    return -1;
-  }
-
-  mndTransDrop(pTrans);
-  return 0;
-}
-
-static int32_t mndUpdateUser(SMnode *pMnode, SUserObj *pOldUser, SUserObj *pNewUser, SMnodeMsg *pMsg) {
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, pMsg->rpcMsg.handle);
-  if (pTrans == NULL) {
-    mError("user:%s, failed to update since %s", pOldUser->user, terrstr());
-    return -1;
-  }
-  mDebug("trans:%d, used to update user:%s", pTrans->id, pOldUser->user);
-
-  SSdbRaw *pRedoRaw = mndUserActionEncode(pNewUser);
-  if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) {
-    mError("trans:%d, failed to append redo log since %s", pTrans->id, terrstr());
-    mndTransDrop(pTrans);
-    return -1;
-  }
   sdbSetRawStatus(pRedoRaw, SDB_STATUS_READY);
 
-  SSdbRaw *pUndoRaw = mndUserActionEncode(pOldUser);
-  if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) {
-    mError("trans:%d, failed to append undo log since %s", pTrans->id, terrstr());
-    mndTransDrop(pTrans);
-    return -1;
-  }
-  sdbSetRawStatus(pUndoRaw, SDB_STATUS_READY);
-
-  if (mndTransPrepare(pTrans) != 0) {
-    mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
-    mndTransDrop(pTrans);
-    return -1;
-  }
-
-  mndTransDrop(pTrans);
-  return 0;
-}
-
-static int32_t mndDropUser(SMnode *pMnode, SMnodeMsg *pMsg, SUserObj *pUser) {
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, pMsg->rpcMsg.handle);
-  if (pTrans == NULL) {
-    mError("user:%s, failed to drop since %s", pUser->user, terrstr());
-    return -1;
-  }
-  mDebug("trans:%d, used to drop user:%s", pTrans->id, pUser->user);
-
-  SSdbRaw *pRedoRaw = mndUserActionEncode(pUser);
-  if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) {
-    mError("trans:%d, failed to append redo log since %s", pTrans->id, terrstr());
-    mndTransDrop(pTrans);
-    return -1;
-  }
-  sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING);
-
-  SSdbRaw *pUndoRaw = mndUserActionEncode(pUser);
-  if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) {
-    mError("trans:%d, failed to append undo log since %s", pTrans->id, terrstr());
-    mndTransDrop(pTrans);
-    return -1;
-  }
-  sdbSetRawStatus(pUndoRaw, SDB_STATUS_READY);
-
-  SSdbRaw *pCommitRaw = mndUserActionEncode(pUser);
-  if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
-    mError("trans:%d, failed to append commit log since %s", pTrans->id, terrstr());
-    mndTransDrop(pTrans);
-    return -1;
-  }
-  sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED);
-
-  if (mndTransPrepare(pTrans) != 0) {
+  if (mndTransPrepare(pMnode, pTrans) != 0) {
     mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
     mndTransDrop(pTrans);
     return -1;
@@ -365,6 +262,32 @@ static int32_t mndProcessCreateUserMsg(SMnodeMsg *pMsg) {
   return TSDB_CODE_MND_ACTION_IN_PROGRESS;
 }
 
+static int32_t mndUpdateUser(SMnode *pMnode, SUserObj *pOldUser, SUserObj *pNewUser, SMnodeMsg *pMsg) {
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, pMsg->rpcMsg.handle);
+  if (pTrans == NULL) {
+    mError("user:%s, failed to update since %s", pOldUser->user, terrstr());
+    return -1;
+  }
+  mDebug("trans:%d, used to update user:%s", pTrans->id, pOldUser->user);
+
+  SSdbRaw *pRedoRaw = mndUserActionEncode(pNewUser);
+  if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) {
+    mError("trans:%d, failed to append redo log since %s", pTrans->id, terrstr());
+    mndTransDrop(pTrans);
+    return -1;
+  }
+  sdbSetRawStatus(pRedoRaw, SDB_STATUS_READY);
+
+  if (mndTransPrepare(pMnode, pTrans) != 0) {
+    mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
+    mndTransDrop(pTrans);
+    return -1;
+  }
+
+  mndTransDrop(pTrans);
+  return 0;
+}
+
 static int32_t mndProcessAlterUserMsg(SMnodeMsg *pMsg) {
   SMnode        *pMnode = pMsg->pMnode;
   SAlterUserMsg *pAlter = pMsg->rpcMsg.pCont;
@@ -401,6 +324,7 @@ static int32_t mndProcessAlterUserMsg(SMnodeMsg *pMsg) {
   memcpy(&newUser, pUser, sizeof(SUserObj));
   memset(pUser->pass, 0, sizeof(pUser->pass));
   taosEncryptPass((uint8_t *)pAlter->pass, strlen(pAlter->pass), pUser->pass);
+  newUser.updateTime = taosGetTimestampMs();
 
   int32_t code = mndUpdateUser(pMnode, pUser, &newUser, pMsg);
   sdbRelease(pMnode->pSdb, pOperUser);
@@ -413,6 +337,32 @@ static int32_t mndProcessAlterUserMsg(SMnodeMsg *pMsg) {
   return TSDB_CODE_MND_ACTION_IN_PROGRESS;
 }
 
+static int32_t mndDropUser(SMnode *pMnode, SMnodeMsg *pMsg, SUserObj *pUser) {
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, pMsg->rpcMsg.handle);
+  if (pTrans == NULL) {
+    mError("user:%s, failed to drop since %s", pUser->user, terrstr());
+    return -1;
+  }
+  mDebug("trans:%d, used to drop user:%s", pTrans->id, pUser->user);
+
+  SSdbRaw *pRedoRaw = mndUserActionEncode(pUser);
+  if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) {
+    mError("trans:%d, failed to append redo log since %s", pTrans->id, terrstr());
+    mndTransDrop(pTrans);
+    return -1;
+  }
+  sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPED);
+
+  if (mndTransPrepare(pMnode, pTrans) != 0) {
+    mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
+    mndTransDrop(pTrans);
+    return -1;
+  }
+
+  mndTransDrop(pTrans);
+  return 0;
+}
+
 static int32_t mndProcessDropUserMsg(SMnodeMsg *pMsg) {
   SMnode       *pMnode = pMsg->pMnode;
   SDropUserMsg *pDrop = pMsg->rpcMsg.pCont;
@@ -515,7 +465,7 @@ static int32_t mndRetrieveUsers(SMnodeMsg *pMsg, SShowObj *pShow, char *data, in
     cols++;
 
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    if (pUser->superAuth) {
+    if (pUser->superUser) {
       const char *src = "super";
       STR_WITH_SIZE_TO_VARSTR(pWrite, src, strlen(src));
     } else {
@@ -536,7 +486,7 @@ static int32_t mndRetrieveUsers(SMnodeMsg *pMsg, SShowObj *pShow, char *data, in
     sdbRelease(pSdb, pUser);
   }
 
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
+  mndVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
   pShow->numOfReads += numOfRows;
   return numOfRows;
 }
diff --git a/source/dnode/mnode/impl/src/mndVgroup.c b/source/dnode/mnode/impl/src/mndVgroup.c
index 44d13d1fb4..ca244fed9f 100644
--- a/source/dnode/mnode/impl/src/mndVgroup.c
+++ b/source/dnode/mnode/impl/src/mndVgroup.c
@@ -284,7 +284,7 @@ static int32_t mndRetrieveVgroups(SMnodeMsg *pMsg, SShowObj *pShow, char *data,
     numOfRows++;
   }
 
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
+  mndVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
   pShow->numOfReads += numOfRows;
   return numOfRows;
 }
@@ -374,7 +374,7 @@ static int32_t mndRetrieveVnodes(SMnodeMsg *pMsg, SShowObj *pShow, char *data, i
     sdbRelease(pSdb, pVgroup);
   }
 
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
+  mndVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
   pShow->numOfReads += numOfRows;
   return numOfRows;
 }
diff --git a/source/dnode/mnode/impl/src/mnode.c b/source/dnode/mnode/impl/src/mnode.c
index e543478608..24155a4e53 100644
--- a/source/dnode/mnode/impl/src/mnode.c
+++ b/source/dnode/mnode/impl/src/mnode.c
@@ -69,7 +69,7 @@ static void mndCleanupTimer(SMnode *pMnode) {
   }
 }
 
-static int32_t mnodeCreateDir(SMnode *pMnode, const char *path) {
+static int32_t mndCreateDir(SMnode *pMnode, const char *path) {
   pMnode->path = strdup(path);
   if (pMnode->path == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -245,7 +245,7 @@ SMnode *mndOpen(const char *path, const SMnodeOpt *pOption) {
     return NULL;
   }
 
-  int32_t code = mnodeCreateDir(pMnode, path);
+  int32_t code = mndCreateDir(pMnode, path);
   if (code != 0) {
     code = terrno;
     mError("failed to open mnode since %s", terrstr());
diff --git a/source/dnode/mnode/sdb/inc/sdbInt.h b/source/dnode/mnode/sdb/inc/sdbInt.h
index a160533bf2..7e2e2602a8 100644
--- a/source/dnode/mnode/sdb/inc/sdbInt.h
+++ b/source/dnode/mnode/sdb/inc/sdbInt.h
@@ -59,6 +59,7 @@ typedef struct SSdb {
   char       *tmpDir;
   int64_t     lastCommitVer;
   int64_t     curVer;
+  int32_t     maxId[SDB_MAX];
   EKeyType    keyTypes[SDB_MAX];
   SHashObj   *hashObjs[SDB_MAX];
   SRWLatch    locks[SDB_MAX];
diff --git a/source/dnode/mnode/sdb/src/sdb.c b/source/dnode/mnode/sdb/src/sdb.c
index ccff5b6c82..77614e399e 100644
--- a/source/dnode/mnode/sdb/src/sdb.c
+++ b/source/dnode/mnode/sdb/src/sdb.c
@@ -127,6 +127,7 @@ int32_t sdbSetTable(SSdb *pSdb, SSdbTable table) {
     return -1;
   }
 
+  pSdb->maxId[sdbType] = 0;
   pSdb->hashObjs[sdbType] = hash;
   taosInitRWLatch(&pSdb->locks[sdbType]);
   mDebug("sdb table:%d is initialized", sdbType);
diff --git a/source/dnode/mnode/sdb/src/sdbHash.c b/source/dnode/mnode/sdb/src/sdbHash.c
index 8d8daf5ce5..f63f7236fb 100644
--- a/source/dnode/mnode/sdb/src/sdbHash.c
+++ b/source/dnode/mnode/sdb/src/sdbHash.c
@@ -72,6 +72,10 @@ static int32_t sdbInsertRow(SSdb *pSdb, SHashObj *hash, SSdbRaw *pRaw, SSdbRow *
 
   taosWUnLockLatch(pLock);
 
+  if (pSdb->keyTypes[pRow->type] == SDB_KEY_INT32) {
+    pSdb->maxId[pRow->type] = MAX(pSdb->maxId[pRow->type], *((int32_t *)pRow->pObj));
+  }
+
   SdbInsertFp insertFp = pSdb->insertFps[pRow->type];
   if (insertFp != NULL) {
     code = (*insertFp)(pSdb, pRow->pObj);
@@ -132,11 +136,6 @@ static int32_t sdbDeleteRow(SSdb *pSdb, SHashObj *hash, SSdbRaw *pRaw, SSdbRow *
   taosHashRemove(hash, pOldRow->pObj, keySize);
   taosWUnLockLatch(pLock);
 
-  SdbDeleteFp deleteFp = pSdb->deleteFps[pOldRow->type];
-  if (deleteFp != NULL) {
-    code = (*deleteFp)(pSdb, pOldRow->pObj);
-  }
-
   sdbRelease(pSdb, pOldRow->pObj);
   sdbFreeRow(pRow);
   return code;
@@ -161,6 +160,7 @@ int32_t sdbWriteNotFree(SSdb *pSdb, SSdbRaw *pRaw) {
     case SDB_STATUS_CREATING:
       code = sdbInsertRow(pSdb, hash, pRaw, pRow, keySize);
       break;
+    case SDB_STATUS_UPDATING:
     case SDB_STATUS_READY:
     case SDB_STATUS_DROPPING:
       code = sdbUpdateRow(pSdb, hash, pRaw, pRow, keySize);
@@ -228,6 +228,11 @@ void sdbRelease(SSdb *pSdb, void *pObj) {
 
   int32_t ref = atomic_sub_fetch_32(&pRow->refCount, 1);
   if (ref <= 0 && pRow->status == SDB_STATUS_DROPPED) {
+    SdbDeleteFp deleteFp = pSdb->deleteFps[pRow->type];
+    if (deleteFp != NULL) {
+      (*deleteFp)(pSdb, pRow->pObj);
+    }
+
     sdbFreeRow(pRow);
   }
 
@@ -289,3 +294,28 @@ int32_t sdbGetSize(SSdb *pSdb, ESdbType type) {
 
   return size;
 }
+
+int32_t sdbGetMaxId(SSdb *pSdb, ESdbType type) {
+  SHashObj *hash = sdbGetHash(pSdb, type);
+  if (hash == NULL) return -1;
+
+  if (pSdb->keyTypes[type] != SDB_KEY_INT32) return -1;
+
+  int32_t maxId = 0;
+
+  SRWLatch *pLock = &pSdb->locks[type];
+  taosRLockLatch(pLock);
+
+  SSdbRow **ppRow = taosHashIterate(hash, NULL);
+  while (ppRow != NULL) {
+    SSdbRow *pRow = *ppRow;
+    int32_t  id = *(int32_t *)pRow->pObj;
+    maxId = MAX(id, maxId);
+    ppRow = taosHashIterate(hash, ppRow);
+  }
+
+  taosRUnLockLatch(pLock);
+
+  maxId = MAX(maxId, pSdb->maxId[type]);
+  return maxId + 1;
+}
diff --git a/source/dnode/vnode/impl/inc/vnodeBufferPool.h b/source/dnode/vnode/impl/inc/vnodeBufferPool.h
index bfc4de9e12..d96671d2bd 100644
--- a/source/dnode/vnode/impl/inc/vnodeBufferPool.h
+++ b/source/dnode/vnode/impl/inc/vnodeBufferPool.h
@@ -27,6 +27,8 @@ typedef struct SVBufPool SVBufPool;
 
 int   vnodeOpenBufPool(SVnode *pVnode);
 void  vnodeCloseBufPool(SVnode *pVnode);
+int   vnodeBufPoolSwitch(SVnode *pVnode);
+int   vnodeBufPoolRecycle(SVnode *pVnode);
 void *vnodeMalloc(SVnode *pVnode, uint64_t size);
 bool  vnodeBufPoolIsFull(SVnode *pVnode);
 
diff --git a/source/dnode/vnode/impl/inc/vnodeCommit.h b/source/dnode/vnode/impl/inc/vnodeCommit.h
index a60e8feac2..031089ba14 100644
--- a/source/dnode/vnode/impl/inc/vnodeCommit.h
+++ b/source/dnode/vnode/impl/inc/vnodeCommit.h
@@ -24,6 +24,7 @@ extern "C" {
 
 #define vnodeShouldCommit vnodeBufPoolIsFull
 int vnodeAsyncCommit(SVnode *pVnode);
+int vnodeCommit(void *arg);
 
 #ifdef __cplusplus
 }
diff --git a/source/dnode/vnode/impl/inc/vnodeDef.h b/source/dnode/vnode/impl/inc/vnodeDef.h
index e3a3fac6b9..e6a88c7629 100644
--- a/source/dnode/vnode/impl/inc/vnodeDef.h
+++ b/source/dnode/vnode/impl/inc/vnodeDef.h
@@ -21,9 +21,11 @@
 #include "tcoding.h"
 #include "tdlist.h"
 #include "tlockfree.h"
+#include "tmacro.h"
 #include "wal.h"
 
 #include "vnode.h"
+
 #include "vnodeBufferPool.h"
 #include "vnodeCfg.h"
 #include "vnodeCommit.h"
@@ -37,6 +39,27 @@
 extern "C" {
 #endif
 
+typedef struct SVnodeTask {
+  TD_DLIST_NODE(SVnodeTask);
+  void* arg;
+  int (*execute)(void*);
+} SVnodeTask;
+
+typedef struct SVnodeMgr {
+  td_mode_flag_t vnodeInitFlag;
+  td_mode_flag_t vnodeClearFlag;
+  // For commit
+  bool            stop;
+  uint16_t        nthreads;
+  pthread_t*      threads;
+  pthread_mutex_t mutex;
+  pthread_cond_t  hasTask;
+  TD_DLIST(SVnodeTask) queue;
+  // For vnode Mgmt
+} SVnodeMgr;
+
+extern SVnodeMgr vnodeMgr;
+
 struct SVnode {
   char*       path;
   SVnodeCfg   config;
@@ -50,6 +73,8 @@ struct SVnode {
   SVnodeFS*   pFs;
 };
 
+int vnodeScheduleTask(SVnodeTask* task);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/dnode/vnode/impl/inc/vnodeMemAllocator.h b/source/dnode/vnode/impl/inc/vnodeMemAllocator.h
index c8c58e9f69..bdafbf31a7 100644
--- a/source/dnode/vnode/impl/inc/vnodeMemAllocator.h
+++ b/source/dnode/vnode/impl/inc/vnodeMemAllocator.h
@@ -33,6 +33,7 @@ struct SVArenaNode {
 };
 
 struct SVMemAllocator {
+  T_REF_DECLARE()
   TD_DLIST_NODE(SVMemAllocator);
   uint64_t     capacity;
   uint64_t     ssize;
diff --git a/source/dnode/vnode/impl/src/vnodeBufferPool.c b/source/dnode/vnode/impl/src/vnodeBufferPool.c
index 1db15c3990..152a346f0a 100644
--- a/source/dnode/vnode/impl/src/vnodeBufferPool.c
+++ b/source/dnode/vnode/impl/src/vnodeBufferPool.c
@@ -19,6 +19,8 @@
 #define VNODE_BUF_POOL_SHARDS 3
 
 struct SVBufPool {
+  pthread_mutex_t mutex;
+  pthread_cond_t  hasFree;
   TD_DLIST(SVMemAllocator) free;
   TD_DLIST(SVMemAllocator) incycle;
   SVMemAllocator *inuse;
@@ -28,7 +30,6 @@ struct SVBufPool {
 
 int vnodeOpenBufPool(SVnode *pVnode) {
   uint64_t capacity;
-  // EVMemAllocatorT type = E_V_ARENA_ALLOCATOR;
 
   if ((pVnode->pBufPool = (SVBufPool *)calloc(1, sizeof(SVBufPool))) == NULL) {
     /* TODO */
@@ -79,6 +80,27 @@ void vnodeCloseBufPool(SVnode *pVnode) {
   }
 }
 
+int vnodeBufPoolSwitch(SVnode *pVnode) {
+  SVMemAllocator *pvma = pVnode->pBufPool->inuse;
+
+  pVnode->pBufPool->inuse = NULL;
+
+  tDListAppend(&(pVnode->pBufPool->incycle), pvma);
+  return 0;
+}
+
+int vnodeBufPoolRecycle(SVnode *pVnode) {
+  SVBufPool *     pBufPool = pVnode->pBufPool;
+  SVMemAllocator *pvma = TD_DLIST_HEAD(&(pBufPool->incycle));
+  ASSERT(pvma != NULL);
+
+  tDListPop(&(pBufPool->incycle), pvma);
+  vmaReset(pvma);
+  tDListAppend(&(pBufPool->free), pvma);
+
+  return 0;
+}
+
 void *vnodeMalloc(SVnode *pVnode, uint64_t size) {
   SVBufPool *pBufPool = pVnode->pBufPool;
 
@@ -89,6 +111,8 @@ void *vnodeMalloc(SVnode *pVnode, uint64_t size) {
       if (pBufPool->inuse) {
         tDListPop(&(pBufPool->free), pBufPool->inuse);
         break;
+      } else {
+        // tsem_wait(&(pBufPool->hasFree));
       }
     }
   }
diff --git a/source/dnode/vnode/impl/src/vnodeCfg.c b/source/dnode/vnode/impl/src/vnodeCfg.c
index f5bb7e35d2..97c3cc9cee 100644
--- a/source/dnode/vnode/impl/src/vnodeCfg.c
+++ b/source/dnode/vnode/impl/src/vnodeCfg.c
@@ -15,7 +15,8 @@
 
 #include "vnodeDef.h"
 
-const SVnodeCfg defaultVnodeOptions = {.wsize = 16 * 1024 * 1024, .walCfg = {.level = TAOS_WAL_WRITE}}; /* TODO */
+const SVnodeCfg defaultVnodeOptions = {
+    .wsize = 96 * 1024 * 1024, .ssize = 1 * 1024 * 1024, .lsize = 1024, .walCfg = {.level = TAOS_WAL_WRITE}}; /* TODO */
 
 void vnodeOptionsInit(SVnodeCfg *pVnodeOptions) { /* TODO */
   vnodeOptionsCopy(pVnodeOptions, &defaultVnodeOptions);
diff --git a/source/dnode/vnode/impl/src/vnodeCommit.c b/source/dnode/vnode/impl/src/vnodeCommit.c
index cac7999f59..a728de0ebb 100644
--- a/source/dnode/vnode/impl/src/vnodeCommit.c
+++ b/source/dnode/vnode/impl/src/vnodeCommit.c
@@ -19,28 +19,21 @@ static int vnodeStartCommit(SVnode *pVnode);
 static int vnodeEndCommit(SVnode *pVnode);
 
 int vnodeAsyncCommit(SVnode *pVnode) {
-#if 0
-  if (vnodeStartCommit(pVnode) < 0) {
-    // TODO
-  }
+  vnodeBufPoolSwitch(pVnode);
+  SVnodeTask *pTask = (SVnodeTask *)malloc(sizeof(*pTask));
 
-  if (tqCommit(pVnode->pTQ) < 0) {
-    // TODO
-  }
+  pTask->execute = vnodeCommit;  // TODO
+  pTask->arg = pVnode;           // TODO
 
-  if (metaCommit(pVnode->pMeta) < 0) {
-    // TODO
-  }
+  vnodeScheduleTask(pTask);
+  return 0;
+}
 
-  if (tsdbCommit(pVnode->pTsdb) < 0) {
-    // TODO
-  }
+int vnodeCommit(void *arg) {
+  SVnode *pVnode = (SVnode *)arg;
 
-  if (vnodeEndCommit(pVnode) < 0) {
-    // TODO
-  }
-
-#endif
+  vnodeBufPoolRecycle(pVnode);
+  // TODO
   return 0;
 }
 
diff --git a/source/dnode/vnode/impl/src/vnodeMain.c b/source/dnode/vnode/impl/src/vnodeMain.c
index 9b94b4a361..59e3bae5d7 100644
--- a/source/dnode/vnode/impl/src/vnodeMain.c
+++ b/source/dnode/vnode/impl/src/vnodeMain.c
@@ -13,7 +13,6 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "tmacro.h"
 #include "vnodeDef.h"
 
 static SVnode *vnodeNew(const char *path, const SVnodeCfg *pVnodeCfg);
@@ -21,29 +20,6 @@ static void    vnodeFree(SVnode *pVnode);
 static int     vnodeOpenImpl(SVnode *pVnode);
 static void    vnodeCloseImpl(SVnode *pVnode);
 
-TD_DEF_MOD_INIT_FLAG(vnode);
-TD_DEF_MOD_CLEAR_FLAG(vnode);
-
-int vnodeInit() {
-  if (TD_CHECK_AND_SET_MODE_INIT(vnode) == TD_MOD_INITIALIZED) {
-    return 0;
-  }
-
-  if (walInit() < 0) {
-    return -1;
-  }
-
-  return 0;
-}
-
-void vnodeClear() {
-  if (TD_CHECK_AND_SET_MOD_CLEAR(vnode) == TD_MOD_CLEARD) {
-    return;
-  }
-
-  walCleanUp();
-}
-
 SVnode *vnodeOpen(const char *path, const SVnodeCfg *pVnodeCfg) {
   SVnode *pVnode = NULL;
 
diff --git a/source/dnode/vnode/impl/src/vnodeMgr.c b/source/dnode/vnode/impl/src/vnodeMgr.c
new file mode 100644
index 0000000000..964cbe77da
--- /dev/null
+++ b/source/dnode/vnode/impl/src/vnodeMgr.c
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "vnodeDef.h"
+
+SVnodeMgr vnodeMgr = {.vnodeInitFlag = TD_MOD_UNINITIALIZED, .vnodeClearFlag = TD_MOD_UNCLEARD, .stop = false};
+
+static void* loop(void* arg);
+
+int vnodeInit(uint16_t nthreads) {
+  if (TD_CHECK_AND_SET_MODE_INIT(&(vnodeMgr.vnodeInitFlag)) == TD_MOD_INITIALIZED) {
+    return 0;
+  }
+
+  // Start commit handers
+  if (nthreads > 0) {
+    vnodeMgr.nthreads = nthreads;
+    vnodeMgr.threads = (pthread_t*)calloc(nthreads, sizeof(pthread_t));
+    if (vnodeMgr.threads == NULL) {
+      return -1;
+    }
+
+    pthread_mutex_init(&(vnodeMgr.mutex), NULL);
+    pthread_cond_init(&(vnodeMgr.hasTask), NULL);
+    tDListInit(&(vnodeMgr.queue));
+
+    for (uint16_t i = 0; i < nthreads; i++) {
+      pthread_create(&(vnodeMgr.threads[i]), NULL, loop, NULL);
+    }
+  } else {
+    // TODO: if no commit thread is set, then another mechanism should be
+    // given. Otherwise, it is a false.
+    ASSERT(0);
+  }
+
+  if (walInit() < 0) {
+    return -1;
+  }
+
+  return 0;
+}
+
+void vnodeClear() {
+  if (TD_CHECK_AND_SET_MOD_CLEAR(&(vnodeMgr.vnodeClearFlag)) == TD_MOD_CLEARD) {
+    return;
+  }
+
+  walCleanUp();
+
+  // Stop commit handler
+  pthread_mutex_lock(&(vnodeMgr.mutex));
+  vnodeMgr.stop = true;
+  pthread_cond_broadcast(&(vnodeMgr.hasTask));
+  pthread_mutex_unlock(&(vnodeMgr.mutex));
+
+  for (uint16_t i = 0; i < vnodeMgr.nthreads; i++) {
+    pthread_join(vnodeMgr.threads[i], NULL);
+  }
+
+  tfree(vnodeMgr.threads);
+  pthread_cond_destroy(&(vnodeMgr.hasTask));
+  pthread_mutex_destroy(&(vnodeMgr.mutex));
+}
+
+int vnodeScheduleTask(SVnodeTask* pTask) {
+  pthread_mutex_lock(&(vnodeMgr.mutex));
+
+  tDListAppend(&(vnodeMgr.queue), pTask);
+
+  pthread_cond_signal(&(vnodeMgr.hasTask));
+
+  pthread_mutex_unlock(&(vnodeMgr.mutex));
+
+  return 0;
+}
+
+/* ------------------------ STATIC METHODS ------------------------ */
+static void* loop(void* arg) {
+  SVnodeTask* pTask;
+  for (;;) {
+    pthread_mutex_lock(&(vnodeMgr.mutex));
+    for (;;) {
+      pTask = TD_DLIST_HEAD(&(vnodeMgr.queue));
+      if (pTask == NULL) {
+        if (vnodeMgr.stop) {
+          pthread_mutex_unlock(&(vnodeMgr.mutex));
+          return NULL;
+        } else {
+          pthread_cond_wait(&(vnodeMgr.hasTask), &(vnodeMgr.mutex));
+        }
+      } else {
+        tDListPop(&(vnodeMgr.queue), pTask);
+        break;
+      }
+    }
+
+    pthread_mutex_unlock(&(vnodeMgr.mutex));
+
+    (*(pTask->execute))(pTask->arg);
+  }
+
+  return NULL;
+}
\ No newline at end of file
diff --git a/source/dnode/vnode/impl/src/vnodeWrite.c b/source/dnode/vnode/impl/src/vnodeWrite.c
index cdeb894932..85460e8d91 100644
--- a/source/dnode/vnode/impl/src/vnodeWrite.c
+++ b/source/dnode/vnode/impl/src/vnodeWrite.c
@@ -72,7 +72,9 @@ int vnodeProcessWMsgs(SVnode *pVnode, SArray *pMsgs) {
           }
           break;
         case TSDB_MSG_TYPE_SUBMIT:
-          /* code */
+          if (tsdbInsertData(pVnode->pTsdb, (SSubmitMsg *)ptr) < 0) {
+            // TODO: handle error
+          }
           break;
         default:
           break;
diff --git a/source/dnode/vnode/impl/test/vnodeApiTests.cpp b/source/dnode/vnode/impl/test/vnodeApiTests.cpp
index ac2ccbc132..f0bca3aa2e 100644
--- a/source/dnode/vnode/impl/test/vnodeApiTests.cpp
+++ b/source/dnode/vnode/impl/test/vnodeApiTests.cpp
@@ -92,7 +92,9 @@ TEST(vnodeApiTest, test_create_table_encode_and_decode_function) {
 #endif
 
 TEST(vnodeApiTest, vnodeOpen_vnodeClose_test) {
-  GTEST_ASSERT_GE(vnodeInit(), 0);
+  vnodeDestroy("vnode1");
+
+  GTEST_ASSERT_GE(vnodeInit(2), 0);
 
   // Create and open a vnode
   SVnode *pVnode = vnodeOpen("vnode1", NULL);
diff --git a/source/dnode/vnode/tsdb/inc/tsdbDef.h b/source/dnode/vnode/tsdb/inc/tsdbDef.h
index 0a57f5f670..7c593cb4c7 100644
--- a/source/dnode/vnode/tsdb/inc/tsdbDef.h
+++ b/source/dnode/vnode/tsdb/inc/tsdbDef.h
@@ -17,6 +17,10 @@
 #define _TD_TSDB_DEF_H_
 
 #include "mallocator.h"
+#include "taosmsg.h"
+#include "tdlist.h"
+#include "thash.h"
+#include "tskiplist.h"
 
 #include "tsdb.h"
 #include "tsdbMemTable.h"
@@ -29,6 +33,8 @@ extern "C" {
 struct STsdb {
   char *                path;
   STsdbCfg              options;
+  STsdbMemTable *       mem;
+  STsdbMemTable *       imem;
   SMemAllocatorFactory *pmaf;
 };
 
diff --git a/source/dnode/vnode/tsdb/inc/tsdbMemTable.h b/source/dnode/vnode/tsdb/inc/tsdbMemTable.h
index 6be90ef53c..e7787af7cf 100644
--- a/source/dnode/vnode/tsdb/inc/tsdbMemTable.h
+++ b/source/dnode/vnode/tsdb/inc/tsdbMemTable.h
@@ -22,10 +22,11 @@
 extern "C" {
 #endif
 
-typedef struct SMemTable {
-  /* TODO */
-  SMemAllocator *pma;
-} SMemTable;
+typedef struct STsdbMemTable STsdbMemTable;
+
+STsdbMemTable *tsdbNewMemTable(SMemAllocatorFactory *pMAF);
+void           tsdbFreeMemTable(SMemAllocatorFactory *pMAF, STsdbMemTable *pMemTable);
+int            tsdbInsertDataToMemTable(STsdbMemTable *pMemTable, SSubmitMsg *pMsg);
 
 #ifdef __cplusplus
 }
diff --git a/src/tsdb/inc/tsdbCommitQueue.h b/source/dnode/vnode/tsdb/src/tsdbCommit.c
similarity index 72%
rename from src/tsdb/inc/tsdbCommitQueue.h
rename to source/dnode/vnode/tsdb/src/tsdbCommit.c
index b690e3bdc2..b124197736 100644
--- a/src/tsdb/inc/tsdbCommitQueue.h
+++ b/source/dnode/vnode/tsdb/src/tsdbCommit.c
@@ -13,11 +13,9 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef _TD_TSDB_COMMIT_QUEUE_H_
-#define _TD_TSDB_COMMIT_QUEUE_H_
+#include "tsdbDef.h"
 
-typedef enum { COMMIT_REQ, COMPACT_REQ,COMMIT_CONFIG_REQ } TSDB_REQ_T;
-
-int tsdbScheduleCommit(STsdbRepo *pRepo, TSDB_REQ_T req);
-
-#endif /* _TD_TSDB_COMMIT_QUEUE_H_ */
\ No newline at end of file
+int tsdbCommit(STsdb *pTsdb) {
+  // TODO
+  return 0;
+}
\ No newline at end of file
diff --git a/source/dnode/vnode/tsdb/src/tsdbMemTable.c b/source/dnode/vnode/tsdb/src/tsdbMemTable.c
index 6dea4a4e57..e3d1f8673e 100644
--- a/source/dnode/vnode/tsdb/src/tsdbMemTable.c
+++ b/source/dnode/vnode/tsdb/src/tsdbMemTable.c
@@ -11,4 +11,84 @@
  *
  * 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
+ */
+
+#include "tsdbDef.h"
+
+#if 1
+typedef struct STbData {
+  TD_SLIST_NODE(STbData);
+  SSubmitMsg *pMsg;
+} STbData;
+#else
+typedef struct STbData {
+  TD_SLIST_NODE(STbData);
+  uint64_t   uid;  // TODO: change here as tb_uid_t
+  TSKEY      keyMin;
+  TSKEY      keyMax;
+  uint64_t   nRows;
+  SSkipList *pData;  // Here need a container, may not use the SL
+  T_REF_DECLARE()
+} STbData;
+#endif
+
+struct STsdbMemTable {
+  T_REF_DECLARE()
+  SRWLatch       latch;
+  TSKEY          keyMin;
+  TSKEY          keyMax;
+  uint64_t       nRow;
+  SMemAllocator *pMA;
+  // Container
+  TD_SLIST(STbData) list;
+};
+
+STsdbMemTable *tsdbNewMemTable(SMemAllocatorFactory *pMAF) {
+  STsdbMemTable *pMemTable;
+  SMemAllocator *pMA;
+
+  pMA = (*pMAF->create)(pMAF);
+  ASSERT(pMA != NULL);
+
+  pMemTable = (STsdbMemTable *)((*pMA->malloc)(pMA, sizeof(*pMemTable)));
+  if (pMemTable == NULL) {
+    (*pMAF->destroy)(pMAF, pMA);
+    return NULL;
+  }
+
+  T_REF_INIT_VAL(pMemTable, 1);
+  taosInitRWLatch(&(pMemTable->latch));
+  pMemTable->keyMin = TSKEY_MAX;
+  pMemTable->keyMax = TSKEY_MIN;
+  pMemTable->nRow = 0;
+  pMemTable->pMA = pMA;
+  tSListInit(&(pMemTable->list));
+
+  // TODO
+  return pMemTable;
+}
+
+void tsdbFreeMemTable(SMemAllocatorFactory *pMAF, STsdbMemTable *pMemTable) {
+  SMemAllocator *pMA = pMemTable->pMA;
+
+  if (pMA->free) {
+    // TODO
+    ASSERT(0);
+  }
+
+  (*pMAF->destroy)(pMAF, pMA);
+}
+
+int tsdbInsertDataToMemTable(STsdbMemTable *pMemTable, SSubmitMsg *pMsg) {
+  SMemAllocator *pMA = pMemTable->pMA;
+  STbData *      pTbData = (STbData *)((*pMA->malloc)(pMA, sizeof(*pTbData)));
+  if (pTbData == NULL) {
+    // TODO
+  }
+
+  tSListPush(&(pMemTable->list), pTbData);
+
+  return 0;
+}
+
+/* ------------------------ STATIC METHODS ------------------------ */
\ No newline at end of file
diff --git a/source/dnode/vnode/tsdb/src/tsdbWrite.c b/source/dnode/vnode/tsdb/src/tsdbWrite.c
new file mode 100644
index 0000000000..f9441cbe44
--- /dev/null
+++ b/source/dnode/vnode/tsdb/src/tsdbWrite.c
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "tsdbDef.h"
+
+int tsdbInsertData(STsdb *pTsdb, SSubmitMsg *pMsg) {
+  // Check if mem is there. If not, create one.
+  pTsdb->mem = tsdbNewMemTable(pTsdb->pmaf);
+  if (pTsdb->mem == NULL) {
+    return -1;
+  }
+  return tsdbInsertDataToMemTable(pTsdb->mem, pMsg);
+}
\ No newline at end of file
diff --git a/source/libs/CMakeLists.txt b/source/libs/CMakeLists.txt
index 007bb1e967..57a5023807 100644
--- a/source/libs/CMakeLists.txt
+++ b/source/libs/CMakeLists.txt
@@ -9,4 +9,5 @@ add_subdirectory(cache)
 add_subdirectory(catalog)
 add_subdirectory(executor)
 add_subdirectory(planner)
-add_subdirectory(function)
\ No newline at end of file
+add_subdirectory(function)
+add_subdirectory(query)
diff --git a/source/libs/catalog/CMakeLists.txt b/source/libs/catalog/CMakeLists.txt
index ff3e62700a..25c80d502a 100644
--- a/source/libs/catalog/CMakeLists.txt
+++ b/source/libs/catalog/CMakeLists.txt
@@ -8,5 +8,5 @@ target_include_directories(
 
 target_link_libraries(
    catalog
-   PRIVATE os util common transport
-)
\ No newline at end of file
+   PRIVATE os util common transport query
+)
diff --git a/source/libs/catalog/inc/catalogInt.h b/source/libs/catalog/inc/catalogInt.h
index 5b50bbff4c..a08b64f9a9 100644
--- a/source/libs/catalog/inc/catalogInt.h
+++ b/source/libs/catalog/inc/catalogInt.h
@@ -21,14 +21,59 @@ extern "C" {
 #endif
 
 #include "catalog.h"
+#include "common.h"
+#include "tlog.h"
+
+#define CTG_DEFAULT_CLUSTER_NUMBER 6
+#define CTG_DEFAULT_VGROUP_NUMBER 100
+#define CTG_DEFAULT_DB_NUMBER 20
+
+#define CTG_DEFAULT_INVALID_VERSION (-1)
+
+typedef struct SVgroupListCache {
+  int32_t vgroupVersion;
+  SHashObj *cache;        // key:vgId, value:SVgroupInfo*
+  SArray   *arrayCache;   // SVgroupInfo
+} SVgroupListCache;
+
+typedef struct SDBVgroupCache {
+  SHashObj *cache;      //key:dbname, value:SDBVgroupInfo
+} SDBVgroupCache;
+
+typedef struct STableMetaCache {
+  SHashObj *cache;     //key:fulltablename, value:STableMeta
+} STableMetaCache;
 
 typedef struct SCatalog {
-  void       *pMsgSender;   // used to send messsage to mnode to fetch necessary metadata
-  SHashObj   *pData;        // items cached for each cluster, the hash key is the cluster-id, returned by mgmt node
+  SVgroupListCache vgroupCache;
+  SDBVgroupCache dbCache;
+  STableMetaCache tableCache;
 } SCatalog;
 
+typedef struct SCatalogMgmt {
+  void       *pMsgSender;   // used to send messsage to mnode to fetch necessary metadata
+  SHashObj   *pCluster;     // items cached for each cluster, the hash key is the cluster-id got from mgmt node
+} SCatalogMgmt;
+
+
+extern int32_t ctgDebugFlag;
+
+#define ctgFatal(...)  do { if (ctgDebugFlag & DEBUG_FATAL) { taosPrintLog("CTG FATAL ", ctgDebugFlag, __VA_ARGS__); }} while(0)
+#define ctgError(...)  do { if (ctgDebugFlag & DEBUG_ERROR) { taosPrintLog("CTG ERROR ", ctgDebugFlag, __VA_ARGS__); }} while(0)
+#define ctgWarn(...)   do { if (ctgDebugFlag & DEBUG_WARN)  { taosPrintLog("CTG WARN ", ctgDebugFlag, __VA_ARGS__); }}  while(0)
+#define ctgInfo(...)   do { if (ctgDebugFlag & DEBUG_INFO)  { taosPrintLog("CTG ", ctgDebugFlag, __VA_ARGS__); }} while(0)
+#define ctgDebug(...)  do { if (ctgDebugFlag & DEBUG_DEBUG) { taosPrintLog("CTG ", ctgDebugFlag, __VA_ARGS__); }} while(0)
+#define ctgTrace(...)  do { if (ctgDebugFlag & DEBUG_TRACE) { taosPrintLog("CTG ", ctgDebugFlag, __VA_ARGS__); }} while(0)
+#define ctgDebugL(...) do { if (ctgDebugFlag & DEBUG_DEBUG) { taosPrintLongString("CTG ", ctgDebugFlag, __VA_ARGS__); }} while(0)
+
+
+#define CTG_ERR_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { return _code; } } while (0)
+#define CTG_ERR_LRET(c,...) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { ctgError(__VA_ARGS__); return _code; } } while (0)
+#define CTG_ERR_JRET(c) do { code = c; if (code != TSDB_CODE_SUCCESS) { goto _return; } } while (0)
+
+
 #ifdef __cplusplus
 }
 #endif
 
-#endif /*_TD_CATALOG_INT_H_*/
\ No newline at end of file
+#endif /*_TD_CATALOG_INT_H_*/
diff --git a/source/libs/catalog/src/catalog.c b/source/libs/catalog/src/catalog.c
index 08e2172adb..92b6094529 100644
--- a/source/libs/catalog/src/catalog.c
+++ b/source/libs/catalog/src/catalog.c
@@ -14,11 +14,429 @@
  */
 
 #include "catalogInt.h"
+#include "trpc.h"
+#include "query.h"
 
-struct SCatalog* getCatalogHandle(const SEpSet* pMgmtEps) {
-  return (struct SCatalog*) 0x1;
+SCatalogMgmt ctgMgmt = {0};
+
+int32_t ctgGetVgroupFromMnode(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, SVgroupListInfo** pVgroup) {
+  char *msg = NULL;
+  SEpSet *pVnodeEpSet = NULL;
+  int32_t msgLen = 0;
+
+  int32_t code = queryBuildMsg[TSDB_MSG_TYPE_VGROUP_LIST](NULL, &msg, 0, &msgLen);
+  if (code) {
+    return code;
+  }
+
+  SRpcMsg rpcMsg = {
+      .msgType = TSDB_MSG_TYPE_VGROUP_LIST,
+      .pCont   = msg,
+      .contLen = msgLen,
+  };
+
+  SRpcMsg rpcRsp = {0};
+
+  rpcSendRecv(pRpc, (SEpSet*)pMgmtEps, &rpcMsg, &rpcRsp);
+
+  code = queryProcessMsgRsp[TSDB_MSG_TYPE_VGROUP_LIST](pVgroup, rpcRsp.pCont, rpcRsp.contLen);
+  if (code) {
+    return code;
+  }
+
+  return TSDB_CODE_SUCCESS;
 }
 
-int32_t catalogGetMetaData(struct SCatalog* pCatalog, const SMetaReq* pMetaReq, SMetaData* pMetaData) {
+int32_t ctgGetVgroupFromCache(SCatalog* pCatalog, SArray** pVgroupList, int32_t* exist) {
+  if (NULL == pCatalog->vgroupCache.arrayCache || pCatalog->vgroupCache.vgroupVersion < 0) {
+    *exist = 0;
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if (pVgroupList) {
+    *pVgroupList = taosArrayDup(pCatalog->vgroupCache.arrayCache);
+  }
+
+  *exist = 1;
+  
+  return TSDB_CODE_SUCCESS;
+}
+
+
+int32_t ctgGetDBVgroupFromCache(SCatalog* pCatalog, const char *dbName, SDBVgroupInfo **dbInfo, int32_t *exist) {
+  if (NULL == pCatalog->dbCache.cache) {
+    *exist = 0;
+    return TSDB_CODE_SUCCESS;
+  }
+
+  SDBVgroupInfo *info = taosHashGet(pCatalog->dbCache.cache, dbName, strlen(dbName));
+
+  if (NULL == info || info->vgroupVersion < pCatalog->vgroupCache.vgroupVersion) {
+    *exist = 0;
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if (dbInfo) {
+    *dbInfo = calloc(1, sizeof(**dbInfo));
+    if (NULL == *dbInfo) {
+      ctgError("calloc size[%d] failed", (int32_t)sizeof(**dbInfo));
+      return TSDB_CODE_CTG_MEM_ERROR;
+    }
+    
+    (*dbInfo)->vgId = taosArrayDup(info->vgId);
+    if (NULL == (*dbInfo)->vgId) {
+      ctgError("taos array duplicate failed");
+      tfree(*dbInfo);
+      return TSDB_CODE_CTG_MEM_ERROR;
+    }
+
+    (*dbInfo)->vgroupVersion = info->vgroupVersion;
+    (*dbInfo)->hashRange = info->hashRange;
+  }
+
+  *exist = 1;
+  
+  return TSDB_CODE_SUCCESS;
+}
+
+
+
+int32_t ctgGetDBVgroupFromMnode(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, SBuildUseDBInput *input, SUseDbOutput *out) {
+  char *msg = NULL;
+  SEpSet *pVnodeEpSet = NULL;
+  int32_t msgLen = 0;
+
+  int32_t code = queryBuildMsg[TSDB_MSG_TYPE_USE_DB](input, &msg, 0, &msgLen);
+  if (code) {
+    return code;
+  }
+
+  SRpcMsg rpcMsg = {
+      .msgType = TSDB_MSG_TYPE_USE_DB,
+      .pCont   = msg,
+      .contLen = msgLen,
+  };
+
+  SRpcMsg rpcRsp = {0};
+
+  rpcSendRecv(pRpc, (SEpSet*)pMgmtEps, &rpcMsg, &rpcRsp);
+
+  code = queryProcessMsgRsp[TSDB_MSG_TYPE_USE_DB](out, rpcRsp.pCont, rpcRsp.contLen);
+  if (code) {
+    return code;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
+int32_t catalogInit(SCatalogCfg *cfg) {
+  ctgMgmt.pCluster = taosHashInit(CTG_DEFAULT_CLUSTER_NUMBER, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
+  if (NULL == ctgMgmt.pCluster) {
+    CTG_ERR_LRET(TSDB_CODE_CTG_INTERNAL_ERROR, "init %d cluster cache failed", CTG_DEFAULT_CLUSTER_NUMBER);
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
+int32_t catalogGetHandle(const char *clusterId, struct SCatalog** catalogHandle) {
+  if (NULL == clusterId || NULL == catalogHandle) {
+    return TSDB_CODE_CTG_INVALID_INPUT;
+  }
+
+  if (NULL == ctgMgmt.pCluster) {
+    ctgError("cluster cache are not ready");
+    return TSDB_CODE_CTG_NOT_READY;
+  }
+
+  size_t clen = strlen(clusterId);
+  SCatalog *clusterCtg = (SCatalog *)taosHashGet(ctgMgmt.pCluster, clusterId, clen);
+
+  if (clusterCtg) {
+    *catalogHandle = clusterCtg;
+    return TSDB_CODE_SUCCESS;
+  }
+
+  clusterCtg = calloc(1, sizeof(*clusterCtg));
+  if (NULL == clusterCtg) {
+    ctgError("calloc %d failed", (int32_t)sizeof(*clusterCtg));
+    return TSDB_CODE_CTG_MEM_ERROR;
+  }
+
+  clusterCtg->vgroupCache.vgroupVersion = CTG_DEFAULT_INVALID_VERSION;
+
+  if (taosHashPut(ctgMgmt.pCluster, clusterId, clen, &clusterCtg, POINTER_BYTES)) {
+    ctgError("put cluster %s cache to hash failed", clusterId);
+    tfree(clusterCtg);
+    return TSDB_CODE_CTG_INTERNAL_ERROR;
+  }
+
+  *catalogHandle = clusterCtg;
+  
+  return TSDB_CODE_SUCCESS;
+}
+
+
+int32_t catalogGetVgroupVersion(struct SCatalog* pCatalog, int32_t* version) {
+  if (NULL == pCatalog || NULL == version) {
+    return TSDB_CODE_CTG_INVALID_INPUT;
+  }
+  
+  *version = pCatalog->vgroupCache.vgroupVersion;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
+
+int32_t catalogUpdateVgroup(struct SCatalog* pCatalog, SVgroupListInfo* pVgroup) {
+  if (NULL == pVgroup) {
+    ctgError("no valid vgroup list info to update");
+    return TSDB_CODE_CTG_INTERNAL_ERROR;
+  }
+
+  if (pVgroup->vgroupVersion < 0) {
+    ctgError("vgroup version[%d] is invalid", pVgroup->vgroupVersion);
+    return TSDB_CODE_CTG_INVALID_INPUT;
+  }
+  
+
+  if (NULL == pCatalog->vgroupCache.arrayCache) {
+    pCatalog->vgroupCache.arrayCache = taosArrayInit(pVgroup->vgroupNum, sizeof(pVgroup->vgroupInfo[0]));
+    if (NULL == pCatalog->vgroupCache.arrayCache) {
+      ctgError("init array[%d] for cluster cache failed", pVgroup->vgroupNum);
+      return TSDB_CODE_CTG_MEM_ERROR;
+    }
+  } else {
+    taosArrayClear(pCatalog->vgroupCache.arrayCache);
+  }
+
+  if (NULL == pCatalog->vgroupCache.cache) {
+    pCatalog->vgroupCache.cache = taosHashInit(CTG_DEFAULT_VGROUP_NUMBER, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_ENTRY_LOCK);
+    if (NULL == pCatalog->vgroupCache.cache) {
+      ctgError("init hash[%d] for cluster cache failed", CTG_DEFAULT_VGROUP_NUMBER);
+      return TSDB_CODE_CTG_MEM_ERROR;
+    }
+  } else {
+    taosHashClear(pCatalog->vgroupCache.cache);
+  }
+
+  SVgroupInfo *vInfo = NULL;
+  for (int32_t i = 0; i < pVgroup->vgroupNum; ++i) {
+    vInfo = taosArrayPush(pCatalog->vgroupCache.arrayCache, &pVgroup->vgroupInfo[i]);
+    if (NULL == vInfo) {
+      ctgError("push to vgroup array cache failed");
+      goto error_exit;
+    }
+    
+    if (taosHashPut(pCatalog->vgroupCache.cache, &pVgroup->vgroupInfo[i].vgId, sizeof(pVgroup->vgroupInfo[i].vgId), &vInfo, POINTER_BYTES) != 0) {
+      ctgError("push to vgroup hash cache failed");
+      goto error_exit;
+    }
+  }
+
+  pCatalog->vgroupCache.vgroupVersion = pVgroup->vgroupVersion;
+
+  return TSDB_CODE_SUCCESS;
+
+error_exit:
+  if (pCatalog->vgroupCache.arrayCache) {
+    taosArrayDestroy(pCatalog->vgroupCache.arrayCache);
+    pCatalog->vgroupCache.arrayCache = NULL;
+  }
+
+  if (pCatalog->vgroupCache.cache) {
+    taosHashCleanup(pCatalog->vgroupCache.cache);
+    pCatalog->vgroupCache.cache = NULL;
+  }
+
+  pCatalog->vgroupCache.vgroupVersion = CTG_DEFAULT_INVALID_VERSION;
+
+  return TSDB_CODE_CTG_INTERNAL_ERROR;
+}
+
+
+int32_t catalogGetVgroup(SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, SArray** pVgroupList) {
+  if (NULL == pCatalog || NULL == pMgmtEps || NULL == pRpc) {
+    return TSDB_CODE_CTG_INVALID_INPUT;
+  }
+
+  int32_t exist = 0;
+  
+  CTG_ERR_RET(ctgGetVgroupFromCache(pCatalog, pVgroupList, &exist));
+
+  if (exist) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  SVgroupListInfo *pVgroup = NULL;
+  
+  CTG_ERR_RET(ctgGetVgroupFromMnode(pCatalog, pRpc, pMgmtEps, &pVgroup));
+
+  CTG_ERR_RET(catalogUpdateVgroup(pCatalog, pVgroup));
+
+  if (pVgroupList) {
+    CTG_ERR_RET(ctgGetVgroupFromCache(pCatalog, pVgroupList, &exist));
+  }
+
+  if (0 == exist) {
+    ctgError("catalog fetched but get from cache failed");
+    return TSDB_CODE_CTG_INTERNAL_ERROR;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t catalogGetDBVgroupVersion(struct SCatalog* pCatalog, const char* dbName, int32_t* version) {
+  if (NULL == pCatalog || NULL == dbName || NULL == version) {
+    return TSDB_CODE_CTG_INVALID_INPUT;
+  }
+
+  if (NULL == pCatalog->dbCache.cache) {
+    *version = CTG_DEFAULT_INVALID_VERSION;
+    return TSDB_CODE_SUCCESS;
+  }
+
+  SDBVgroupInfo * dbInfo = taosHashGet(pCatalog->dbCache.cache, dbName, strlen(dbName));
+  if (NULL == dbInfo) {
+    *version = CTG_DEFAULT_INVALID_VERSION;
+    return TSDB_CODE_SUCCESS;
+  }
+
+  *version = dbInfo->vgroupVersion;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t catalogUpdateDBVgroup(struct SCatalog* pCatalog, const char* dbName, SDBVgroupInfo* dbInfo) {
+  if (NULL == pCatalog || NULL == dbName || NULL == dbInfo) {
+    return TSDB_CODE_CTG_INVALID_INPUT;
+  }
+
+  if (dbInfo->vgroupVersion < 0) {
+    if (pCatalog->dbCache.cache) {
+      taosHashRemove(pCatalog->dbCache.cache, dbName, strlen(dbName));
+    }
+    
+    ctgWarn("remove db [%s] from cache", dbName);
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if (NULL == pCatalog->dbCache.cache) {
+    pCatalog->dbCache.cache = taosHashInit(CTG_DEFAULT_DB_NUMBER, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
+    if (NULL == pCatalog->dbCache.cache) {
+      ctgError("init hash[%d] for db cache failed", CTG_DEFAULT_DB_NUMBER);
+      return TSDB_CODE_CTG_MEM_ERROR;
+    }
+  }
+
+  if (taosHashPut(pCatalog->dbCache.cache, dbName, strlen(dbName), dbInfo, sizeof(*dbInfo)) != 0) {
+    ctgError("push to vgroup hash cache failed");
+    return TSDB_CODE_CTG_MEM_ERROR;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
+
+
+int32_t catalogGetDBVgroup(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* dbName, int32_t forceUpdate, SDBVgroupInfo** dbInfo) {
+  if (NULL == pCatalog || NULL == dbName || NULL == pRpc || NULL == pMgmtEps) {
+    return TSDB_CODE_CTG_INVALID_INPUT;
+  }
+
+  int32_t exist = 0;
+  int32_t code = 0;
+
+  if (0 == forceUpdate) {
+    CTG_ERR_RET(ctgGetDBVgroupFromCache(pCatalog, dbName, dbInfo, &exist));
+
+    if (exist) {
+      return TSDB_CODE_SUCCESS;
+    }
+  }
+
+  SUseDbOutput DbOut = {0};
+  SBuildUseDBInput input = {0};
+
+  strncpy(input.db, dbName, sizeof(input.db));
+  input.db[sizeof(input.db) - 1] = 0;
+  input.vgroupVersion = pCatalog->vgroupCache.vgroupVersion;
+  input.dbGroupVersion = CTG_DEFAULT_INVALID_VERSION;
+  
+  CTG_ERR_RET(ctgGetDBVgroupFromMnode(pCatalog, pRpc, pMgmtEps, &input, &DbOut));
+
+  if (DbOut.vgroupList) {
+    CTG_ERR_JRET(catalogUpdateVgroup(pCatalog, DbOut.vgroupList));
+  }
+
+  if (DbOut.dbVgroup) {
+    CTG_ERR_JRET(catalogUpdateDBVgroup(pCatalog, dbName, DbOut.dbVgroup));
+  }
+
+  if (dbInfo) {
+    *dbInfo = DbOut.dbVgroup;
+    DbOut.dbVgroup = NULL;
+  }
+
+_return:
+  tfree(DbOut.dbVgroup);
+  tfree(DbOut.vgroupList);
+
+  return code;
+}
+
+
+
+int32_t catalogGetTableMetaFromMnode(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pTableName, const STagData* tagData, STableMeta* pTableMeta) {
+  if (NULL == pCatalog || NULL == pMgmtEps || NULL == pTableName || NULL == pTableMeta) {
+    return TSDB_CODE_CTG_INVALID_INPUT;
+  }
+
+  SBuildTableMetaInput bInput = {0};
+  char *msg = NULL;
+  SEpSet *pVnodeEpSet = NULL;
+  int32_t msgLen = 0;
+
+  int32_t code = queryBuildMsg[TSDB_MSG_TYPE_TABLE_META](&bInput, &msg, 0, &msgLen);
+  if (code) {
+    return code;
+  }
+
+  SRpcMsg rpcMsg = {
+      .msgType = TSDB_MSG_TYPE_TABLE_META,
+      .pCont   = msg,
+      .contLen = msgLen,
+  };
+
+  SRpcMsg rpcRsp = {0};
+
+  rpcSendRecv(pRpc, (SEpSet*)pMgmtEps, &rpcMsg, &rpcRsp);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t catalogGetTableMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pTableName, STableMeta* pTableMeta) {
+
+}
+
+
+int32_t catalogGetAllMeta(struct SCatalog* pCatalog, const SEpSet* pMgmtEps, const SCatalogReq* pReq, SMetaData* pRsp) {
+  if (NULL == pCatalog || NULL == pMgmtEps || NULL == pReq || NULL == pRsp) {
+    return TSDB_CODE_CTG_INVALID_INPUT;
+  }
+  
   return 0;
 }
+
+void catalogDestroy(void) {
+  if (ctgMgmt.pCluster) {
+    taosHashCleanup(ctgMgmt.pCluster); //TBD
+    ctgMgmt.pCluster = NULL;
+  }
+}
+
+
+
diff --git a/source/libs/index/inc/index_fst_automation.h b/source/libs/index/inc/index_fst_automation.h
index c2ab61bf5f..8050b85b08 100644
--- a/source/libs/index/inc/index_fst_automation.h
+++ b/source/libs/index/inc/index_fst_automation.h
@@ -20,6 +20,8 @@ extern "C" {
 #endif
 
 #include "index_fst_util.h"
+
+
 typedef struct AutomationCtx AutomationCtx;
 
 typedef enum AutomationType {
@@ -38,18 +40,30 @@ typedef struct Complement {
 // automation 
 typedef struct AutomationCtx {
   AutomationType type; 
-  void *data;
+  void *stdata;
+  char *data; 
 } AutomationCtx;
 
 
-
+typedef enum ValueType { FST_INT, FST_CHAR, FST_ARRAY} ValueType;
 typedef enum StartWithStateKind { Done, Running } StartWithStateKind; 
 
 typedef struct StartWithStateValue {
   StartWithStateKind kind;
-  void *value;
+  ValueType type;
+  union {
+    int    val; 
+    char   *ptr;
+    SArray *arr;
+    // add more type
+  } ;
 } StartWithStateValue;
 
+StartWithStateValue *startWithStateValueCreate(StartWithStateKind kind, ValueType ty, void *val);
+StartWithStateValue *startWithStateValueDump(StartWithStateValue *sv); 
+void startWithStateValueDestroy(void *sv);
+
+
 typedef struct AutomationFunc {
   void* (*start)(AutomationCtx *ctx) ; 
   bool (*isMatch)(AutomationCtx *ctx, void *);
@@ -59,7 +73,7 @@ typedef struct AutomationFunc {
   void* (*acceptEof)(AutomationCtx *ct, void *state);
 } AutomationFunc; 
 
-AutomationCtx *automCtxCreate(void *data, AutomationType type);
+AutomationCtx *automCtxCreate(void *data, AutomationType atype);
 void automCtxDestroy(AutomationCtx *ctx);
 
 extern AutomationFunc automFuncs[]; 
diff --git a/source/libs/index/src/index_fst.c b/source/libs/index/src/index_fst.c
index 07f1e343bd..37bdcb0ecf 100644
--- a/source/libs/index/src/index_fst.c
+++ b/source/libs/index/src/index_fst.c
@@ -17,6 +17,7 @@
 #include "tcoding.h"
 #include "tchecksum.h"
 #include "indexInt.h" 
+#include "index_fst_automation.h"
 
 
 static void fstPackDeltaIn(FstCountingWriter *wrt, CompiledAddr nodeAddr, CompiledAddr transAddr, uint8_t nBytes) {
@@ -1322,6 +1323,7 @@ StreamWithStateResult *streamWithStateNextWith(StreamWithState *sws, StreamCallb
       return swsResultCreate(&s, output, callback(start));
     }
   }
+  SArray *nodes = taosArrayInit(8, sizeof(FstNode *));  
   while (taosArrayGetSize(sws->stack) > 0) {
     StreamState *p = (StreamState *)taosArrayPop(sws->stack);     
     if (p->trans >= FST_NODE_LEN(p->node) || automFuncs[aut->type].canMatch(aut, p->autState)) {
@@ -1337,8 +1339,8 @@ StreamWithStateResult *streamWithStateNextWith(StreamWithState *sws, StreamCallb
     void* nextState = automFuncs[aut->type].accept(aut, p->autState, trn.inp);
     void* tState = callback(nextState);
     bool isMatch = automFuncs[aut->type].isMatch(aut, nextState);
-    //bool isMatch = sws->aut->isMatch(nextState);
     FstNode *nextNode = fstGetNode(sws->fst, trn.addr); 
+    taosArrayPush(nodes, &nextNode); 
     taosArrayPush(sws->inp, &(trn.inp)); 
 
     if (FST_NODE_IS_FINAL(nextNode)) {
@@ -1354,26 +1356,35 @@ StreamWithStateResult *streamWithStateNextWith(StreamWithState *sws, StreamCallb
     StreamState s2 = {.node = nextNode, .trans = 0, .out = {.null = false, .out = out}, .autState = nextState};
     taosArrayPush(sws->stack, &s2);
     
-    uint8_t *buf = (uint8_t *)malloc(taosArrayGetSize(sws->inp) * sizeof(uint8_t)); 
-    for (uint32_t i = 0; i < taosArrayGetSize(sws->inp); i++) {
-      uint8_t *t = (uint8_t *)taosArrayGet(sws->inp, i);
-      buf[i] = *t; 
+
+    size_t isz = taosArrayGetSize(sws->inp);
+    uint8_t *buf = (uint8_t *)malloc(isz * sizeof(uint8_t)); 
+    for (uint32_t i = 0; i < isz; i++) {
+      buf[i] = *(uint8_t *)taosArrayGet(sws->inp, i);
     }
     FstSlice slice = fstSliceCreate(buf, taosArrayGetSize(sws->inp));
     if (fstBoundWithDataExceededBy(sws->endAt, &slice)) {
       taosArrayDestroyEx(sws->stack, streamStateDestroy);
       sws->stack = (SArray *)taosArrayInit(256, sizeof(StreamState)); 
+      free(buf);
       fstSliceDestroy(&slice);
       return NULL;
     }
     if (FST_NODE_IS_FINAL(nextNode) && isMatch) {
       FstOutput fOutput = {.null = false, .out = out + FST_NODE_FINAL_OUTPUT(nextNode)};
-      StreamWithStateResult *result =  swsResultCreate(&slice, fOutput , tState);     
+      StreamWithStateResult *result =  swsResultCreate(&slice, fOutput, tState);     
+      free(buf);
       fstSliceDestroy(&slice);
       return result; 
     }
+    free(buf);
     fstSliceDestroy(&slice);
   }
+  for (size_t i = 0; i < taosArrayGetSize(nodes); i++) {
+    FstNode** node = (FstNode **)taosArrayGet(nodes, i);
+    fstNodeDestroy(*node);
+  }
+  taosArrayDestroy(nodes);
   return NULL; 
   
 }
@@ -1392,6 +1403,7 @@ void swsResultDestroy(StreamWithStateResult *result) {
   if (NULL == result) { return; }
   
   fstSliceDestroy(&result->data);
+  startWithStateValueDestroy(result->state); 
   free(result);
 }
 
diff --git a/source/libs/index/src/index_fst_automation.c b/source/libs/index/src/index_fst_automation.c
index 6a08b41b12..d905147654 100644
--- a/source/libs/index/src/index_fst_automation.c
+++ b/source/libs/index/src/index_fst_automation.c
@@ -16,21 +16,81 @@
 #include "index_fst_automation.h"
 
 
+StartWithStateValue *startWithStateValueCreate(StartWithStateKind kind, ValueType ty, void *val) {
+  StartWithStateValue *nsv = calloc(1, sizeof(StartWithStateValue));
+  if (nsv == NULL) { return NULL; }
+
+  nsv->kind = kind;
+  nsv->type = ty;
+  if (ty == FST_INT) {
+    nsv->val = *(int *)val;
+  } else if (ty == FST_CHAR) {
+    size_t len = strlen((char *)val);  
+    nsv->ptr = (char *)calloc(1, len + 1);  
+    memcpy(nsv->ptr, val, len);
+  } else if (ty == FST_ARRAY) {
+    //TODO, 
+    //nsv->arr = taosArrayFromList() 
+  }
+  return nsv;
+}
+void startWithStateValueDestroy(void *val) {
+  StartWithStateValue *sv = (StartWithStateValue *)val;
+  if (sv == NULL) { return; }
+
+  if (sv->type == FST_INT) {
+    //  
+  } else if (sv->type == FST_CHAR) {
+    free(sv->ptr);
+  } else if (sv->type == FST_ARRAY) {
+    taosArrayDestroy(sv->arr);
+  }
+  free(sv); 
+}
+StartWithStateValue *startWithStateValueDump(StartWithStateValue *sv) {
+  StartWithStateValue *nsv = calloc(1, sizeof(StartWithStateValue));
+  if (nsv == NULL) { return NULL; }
+
+  nsv->kind = sv->kind;
+  nsv->type= sv->type;
+  if (nsv->type == FST_INT) {
+    nsv->val = sv->val;
+  } else if (nsv->type == FST_CHAR) {
+    size_t len = strlen(sv->ptr);
+    nsv->ptr = (char *)calloc(1, len + 1);
+    memcpy(nsv->ptr, sv->ptr, len);
+  } else if (nsv->type == FST_ARRAY) {
+  }
+  return nsv;
+}
+
+
 // prefix query, impl later
+
 static void* prefixStart(AutomationCtx *ctx) {  
   StartWithStateValue *data = (StartWithStateValue *)(ctx->data);
-  return data;
+  return startWithStateValueDump(data);     
 };
-static bool prefixIsMatch(AutomationCtx *ctx, void *data) {
-  return true;
+static bool prefixIsMatch(AutomationCtx *ctx, void *sv) {
+  StartWithStateValue* ssv = (StartWithStateValue *)sv;  
+  return ssv->val == strlen(ctx->data); 
 } 
-static bool prefixCanMatch(AutomationCtx *ctx, void *data) {
-  return true;
+static bool prefixCanMatch(AutomationCtx *ctx, void *sv) {
+  StartWithStateValue* ssv = (StartWithStateValue *)sv;  
+  return ssv->val >= 0; 
 }
 static bool prefixWillAlwaysMatch(AutomationCtx *ctx, void *state) {
   return true;
 }
 static void* prefixAccept(AutomationCtx *ctx, void *state, uint8_t byte) {
+  StartWithStateValue* ssv = (StartWithStateValue *)state;  
+  if (ssv == NULL || ctx == NULL) {return NULL;}
+
+  char *data = ctx->data;
+  if ((strlen(data) > ssv->val) && data[ssv->val] == byte) {
+    int val = ssv->val + 1;
+    return startWithStateValueCreate(Running, FST_INT, &val);
+  } 
   return NULL;
 }
 static void* prefixAcceptEof(AutomationCtx *ctx, void *state) {
@@ -79,28 +139,33 @@ AutomationFunc automFuncs[]  = {{
   // add more search type
 };
 
-AutomationCtx* automCtxCreate(void *data, AutomationType type) {
+AutomationCtx* automCtxCreate(void *data,AutomationType atype) {
   AutomationCtx *ctx = calloc(1, sizeof(AutomationCtx));
   if (ctx == NULL) { return NULL; }
 
-  if (type == AUTOMATION_PREFIX) {
-    StartWithStateValue *swsv = (StartWithStateValue *)calloc(1, sizeof(StartWithStateValue));   
-    swsv->kind  = Done; 
-    swsv->value = NULL; 
-    ctx->data = (void *)swsv;
-  } else if (type == AUTMMATION_MATCH) {
+  StartWithStateValue *sv = NULL;
+  if (atype == AUTOMATION_PREFIX) {
+    sv = startWithStateValueCreate(Running, FST_INT, 0);
+    ctx->stdata = (void *)sv;
+  } else if (atype == AUTMMATION_MATCH) {
       
   } else {
     // add more search type
   }
 
-  ctx->type = type;
+  char*  src = (char *)data; 
+  size_t len = strlen(src);
+  char*  dst = (char *)malloc(len * sizeof(char) + 1); 
+  memcpy(dst, src, len);
+  dst[len] = 0;
+  
+  ctx->data   = dst; 
+  ctx->type   = atype;
+  ctx->stdata = (void *)sv; 
   return ctx; 
 } 
 void automCtxDestroy(AutomationCtx *ctx) {
-  if (ctx->type == AUTOMATION_PREFIX) {
-    free(ctx->data);
-  } else if (ctx->type == AUTMMATION_MATCH) {
-  }
+  startWithStateValueDestroy(ctx->stdata);
+  free(ctx->data);
   free(ctx);
 }
diff --git a/source/libs/parser/CMakeLists.txt b/source/libs/parser/CMakeLists.txt
index 155b72c1f9..5e635aa6a1 100644
--- a/source/libs/parser/CMakeLists.txt
+++ b/source/libs/parser/CMakeLists.txt
@@ -8,7 +8,7 @@ target_include_directories(
 
 target_link_libraries(
         parser
-        PRIVATE os util common catalog function transport
+        PRIVATE os util common catalog function transport query
 )
 
-ADD_SUBDIRECTORY(test)
\ No newline at end of file
+ADD_SUBDIRECTORY(test)
diff --git a/source/libs/parser/inc/parserInt.h b/source/libs/parser/inc/parserInt.h
index 47f655d446..e3925d3446 100644
--- a/source/libs/parser/inc/parserInt.h
+++ b/source/libs/parser/inc/parserInt.h
@@ -79,13 +79,13 @@ int32_t checkForInvalidExpr(SQueryStmtInfo* pQueryInfo, SMsgBuf* pMsgBuf);
  * @param msgBufLen
  * @return
  */
-int32_t qParserExtractRequestedMetaInfo(const SSqlInfo* pSqlInfo, SMetaReq* pMetaInfo, char* msg, int32_t msgBufLen);
+int32_t qParserExtractRequestedMetaInfo(const SSqlInfo* pSqlInfo, SCatalogReq* pMetaInfo, char* msg, int32_t msgBufLen);
 
 /**
  * Destroy the meta data request structure.
  * @param pMetaInfo
  */
-void qParserClearupMetaRequestInfo(SMetaReq* pMetaInfo);
+void qParserClearupMetaRequestInfo(SCatalogReq* pMetaInfo);
 
 #ifdef __cplusplus
 }
diff --git a/source/libs/parser/src/astValidate.c b/source/libs/parser/src/astValidate.c
index 7b6c423fb6..d2813886b3 100644
--- a/source/libs/parser/src/astValidate.c
+++ b/source/libs/parser/src/astValidate.c
@@ -4077,18 +4077,18 @@ int32_t qParserValidateSqlNode(struct SCatalog* pCatalog, SSqlInfo* pInfo, SQuer
   }
 #endif
 
-  SMetaReq req = {0};
+  SCatalogReq req = {0};
   SMetaData data = {0};
 
   // TODO: check if the qnode info has been cached already
-  req.qNodeEpset = true;
+  req.qNodeRequired = true;
   code = qParserExtractRequestedMetaInfo(pInfo, &req, msgBuf, msgBufLen);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
 
   // load the meta data from catalog
-  code = catalogGetMetaData(pCatalog, &req, &data);
+  code = catalogGetAllMeta(pCatalog, NULL, &req, &data);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
diff --git a/source/libs/parser/src/insertParser.c b/source/libs/parser/src/insertParser.c
index c6ae149f1f..fa59bc6ca7 100644
--- a/source/libs/parser/src/insertParser.c
+++ b/source/libs/parser/src/insertParser.c
@@ -178,15 +178,15 @@ static int32_t buildTableName(SInsertParseContext* pCxt, SToken* pStname, SArray
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t buildMetaReq(SInsertParseContext* pCxt, SToken* pStname, SMetaReq* pMetaReq) {
+static int32_t buildMetaReq(SInsertParseContext* pCxt, SToken* pStname, SCatalogReq* pMetaReq) {
   pMetaReq->pTableName = taosArrayInit(4, sizeof(SName));
   return buildTableName(pCxt, pStname, pMetaReq->pTableName);
 }
 
 static int32_t getTableMeta(SInsertParseContext* pCxt, SToken* pTname) {
-  SMetaReq req;
+  SCatalogReq req;
   CHECK_CODE(buildMetaReq(pCxt, pTname, &req));
-  CHECK_CODE(catalogGetMetaData(pCxt->pCatalog, &req, &pCxt->meta));
+  CHECK_CODE(catalogGetTableMeta(pCxt->pCatalog, NULL, NULL, NULL, &pCxt->meta)); //TODO
   pCxt->pTableMeta = (STableMeta*)taosArrayGetP(pCxt->meta.pTableMeta, 0);
   return TSDB_CODE_SUCCESS;
 }
@@ -861,13 +861,15 @@ int32_t parseInsertSql(SParseContext* pContext, SInsertStmtInfo** pInfo) {
     .pComCxt = pContext,
     .pSql = pContext->pSql,
     .msg = {.buf = pContext->pMsg, .len = pContext->msgLen},
-    .pCatalog = getCatalogHandle(pContext->pEpSet),
+    .pCatalog = NULL,
     .pTableMeta = NULL,
     .pTableBlockHashObj = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false),
     .totalNum = 0,
     .pOutput = *pInfo
   };
 
+  CHECK_CODE(catalogGetHandle(NULL, &context.pCatalog)); //TODO
+
   if (NULL == context.pTableBlockHashObj) {
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
diff --git a/source/libs/parser/src/parser.c b/source/libs/parser/src/parser.c
index a8642e2535..d167f7ad3c 100644
--- a/source/libs/parser/src/parser.c
+++ b/source/libs/parser/src/parser.c
@@ -43,7 +43,12 @@ int32_t qParseQuerySql(const char* pStr, size_t length, struct SQueryStmtInfo**
     return TSDB_CODE_TSC_SQL_SYNTAX_ERROR;
   }
 
-  struct SCatalog* pCatalog = getCatalogHandle(NULL);
+  struct SCatalog* pCatalog = NULL;
+  int32_t code = catalogGetHandle(NULL, &pCatalog);
+  if (code) {
+    return code;
+  }
+  
   return qParserValidateSqlNode(pCatalog, &info, *pQueryInfo, id, msg, msgLen);
 }
 
@@ -132,7 +137,7 @@ static void freePtrElem(void* p) {
   tfree(*(char**)p);
 }
 
-int32_t qParserExtractRequestedMetaInfo(const SSqlInfo* pSqlInfo, SMetaReq* pMetaInfo, char* msg, int32_t msgBufLen) {
+int32_t qParserExtractRequestedMetaInfo(const SSqlInfo* pSqlInfo, SCatalogReq* pMetaInfo, char* msg, int32_t msgBufLen) {
   int32_t code  = TSDB_CODE_SUCCESS;
   SMsgBuf msgBuf = {.buf = msg, .len = msgBufLen};
 
@@ -189,7 +194,7 @@ int32_t qParserExtractRequestedMetaInfo(const SSqlInfo* pSqlInfo, SMetaReq* pMet
   return code;
 }
 
-void qParserClearupMetaRequestInfo(SMetaReq* pMetaReq) {
+void qParserClearupMetaRequestInfo(SCatalogReq* pMetaReq) {
   if (pMetaReq == NULL) {
     return;
   }
diff --git a/source/libs/parser/src/parserUtil.c b/source/libs/parser/src/parserUtil.c
index 7b3239c0dd..28d01b9e66 100644
--- a/source/libs/parser/src/parserUtil.c
+++ b/source/libs/parser/src/parserUtil.c
@@ -1448,23 +1448,6 @@ void* vgroupInfoClear(SVgroupsInfo *vgroupList) {
   return NULL;
 }
 
-char* serializeTagData(STagData* pTagData, char* pMsg) {
-  int32_t n = (int32_t) strlen(pTagData->name);
-  *(int32_t*) pMsg = htonl(n);
-  pMsg += sizeof(n);
-
-  memcpy(pMsg, pTagData->name, n);
-  pMsg += n;
-
-  *(int32_t*)pMsg = htonl(pTagData->dataLen);
-  pMsg += sizeof(int32_t);
-
-  memcpy(pMsg, pTagData->data, pTagData->dataLen);
-  pMsg += pTagData->dataLen;
-
-  return pMsg;
-}
-
 int32_t copyTagData(STagData* dst, const STagData* src) {
   dst->dataLen = src->dataLen;
   tstrncpy(dst->name, src->name, tListLen(dst->name));
diff --git a/source/libs/parser/test/CMakeLists.txt b/source/libs/parser/test/CMakeLists.txt
index f7d7113243..4b9e586be3 100644
--- a/source/libs/parser/test/CMakeLists.txt
+++ b/source/libs/parser/test/CMakeLists.txt
@@ -8,7 +8,7 @@ AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SOURCE_LIST)
 ADD_EXECUTABLE(parserTest ${SOURCE_LIST})
 TARGET_LINK_LIBRARIES(
         parserTest
-        PUBLIC os util common parser catalog transport gtest function planner
+        PUBLIC os util common parser catalog transport gtest function planner query
 )
 
 TARGET_INCLUDE_DIRECTORIES(
diff --git a/source/libs/parser/test/mockCatalog.cpp b/source/libs/parser/test/mockCatalog.cpp
index 1f6fd71030..f2b34971ef 100644
--- a/source/libs/parser/test/mockCatalog.cpp
+++ b/source/libs/parser/test/mockCatalog.cpp
@@ -48,6 +48,6 @@ struct SCatalog* getCatalogHandle(const SEpSet* pMgmtEps) {
   return mockCatalogService->getCatalogHandle(pMgmtEps);
 }
 
-int32_t catalogGetMetaData(struct SCatalog* pCatalog, const SMetaReq* pMetaReq, SMetaData* pMetaData) {
+int32_t catalogGetMetaData(struct SCatalog* pCatalog, const SCatalogReq* pMetaReq, SMetaData* pMetaData) {
   return mockCatalogService->catalogGetMetaData(pCatalog, pMetaReq, pMetaData);
 }
diff --git a/source/libs/parser/test/mockCatalog.h b/source/libs/parser/test/mockCatalog.h
index 32001d19fd..e60f7727e6 100644
--- a/source/libs/parser/test/mockCatalog.h
+++ b/source/libs/parser/test/mockCatalog.h
@@ -22,6 +22,6 @@ void generateMetaData(MockCatalogService* mcs);
 
 // mock
 struct SCatalog* getCatalogHandle(const SEpSet* pMgmtEps);
-int32_t catalogGetMetaData(struct SCatalog* pCatalog, const SMetaReq* pMetaReq, SMetaData* pMetaData);
+int32_t catalogGetMetaData(struct SCatalog* pCatalog, const SCatalogReq* pMetaReq, SMetaData* pMetaData);
 
 #endif  // MOCK_CATALOG_H
diff --git a/source/libs/parser/test/mockCatalogService.cpp b/source/libs/parser/test/mockCatalogService.cpp
index 46e82566d6..457f8d88bd 100644
--- a/source/libs/parser/test/mockCatalogService.cpp
+++ b/source/libs/parser/test/mockCatalogService.cpp
@@ -87,7 +87,7 @@ public:
     return (struct SCatalog*)0x01;
   }
 
-  int32_t catalogGetMetaData(struct SCatalog* pCatalog, const SMetaReq* pMetaReq, SMetaData* pMetaData) const {
+  int32_t catalogGetMetaData(struct SCatalog* pCatalog, const SCatalogReq* pMetaReq, SMetaData* pMetaData) const {
     assert(nullptr != pMetaReq && 1 == taosArrayGetSize(pMetaReq->pTableName));
     SName* fullName = (SName*)taosArrayGet(pMetaReq->pTableName, 0);
     std::unique_ptr<STableMeta> table;
@@ -248,7 +248,7 @@ struct SCatalog* MockCatalogService::getCatalogHandle(const SEpSet* pMgmtEps) co
   return impl_->getCatalogHandle(pMgmtEps);
 }
 
-int32_t MockCatalogService::catalogGetMetaData(struct SCatalog* pCatalog, const SMetaReq* pMetaReq, SMetaData* pMetaData) const {
+int32_t MockCatalogService::catalogGetMetaData(struct SCatalog* pCatalog, const SCatalogReq* pMetaReq, SMetaData* pMetaData) const {
   return impl_->catalogGetMetaData(pCatalog, pMetaReq, pMetaData);
 }
 
diff --git a/source/libs/parser/test/mockCatalogService.h b/source/libs/parser/test/mockCatalogService.h
index 79572086a1..66b439b3e9 100644
--- a/source/libs/parser/test/mockCatalogService.h
+++ b/source/libs/parser/test/mockCatalogService.h
@@ -50,7 +50,7 @@ public:
   MockCatalogService();
   ~MockCatalogService();
   struct SCatalog* getCatalogHandle(const SEpSet* pMgmtEps) const;
-  int32_t catalogGetMetaData(struct SCatalog* pCatalog, const SMetaReq* pMetaReq, SMetaData* pMetaData) const;
+  int32_t catalogGetMetaData(struct SCatalog* pCatalog, const SCatalogReq* pMetaReq, SMetaData* pMetaData) const;
   ITableBuilder& createTableBuilder(const std::string& db, const std::string& tbname, int8_t tableType, int32_t numOfColumns, int32_t numOfTags = 0);
   void createSubTable(const std::string& db, const std::string& stbname, const std::string& tbname, int16_t vgid);
   void showTables() const;
diff --git a/source/libs/parser/test/parserTests.cpp b/source/libs/parser/test/parserTests.cpp
index 2193a44604..6a402cd620 100644
--- a/source/libs/parser/test/parserTests.cpp
+++ b/source/libs/parser/test/parserTests.cpp
@@ -38,7 +38,7 @@ void setSchema(SSchema* p, int32_t type, int32_t bytes, const char* name, int32_
   strcpy(p->name, name);
 }
 
-void setTableMetaInfo(SQueryStmtInfo* pQueryInfo, SMetaReq* req) {
+void setTableMetaInfo(SQueryStmtInfo* pQueryInfo, SCatalogReq* req) {
   pQueryInfo->numOfTables = 1;
 
   pQueryInfo->pTableMetaInfo = (STableMetaInfo**)calloc(1, POINTER_BYTES);
@@ -80,7 +80,7 @@ void sqlCheck(const char* sql, bool valid) {
   int32_t   code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
   ASSERT_EQ(code, 0);
 
-  SMetaReq req = {0};
+  SCatalogReq req = {0};
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
@@ -117,7 +117,7 @@ TEST(testCase, validateAST_test) {
   int32_t   code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
   ASSERT_EQ(code, 0);
 
-  SMetaReq req = {0};
+  SCatalogReq req = {0};
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
@@ -175,7 +175,7 @@ TEST(testCase, function_Test) {
   int32_t   code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
   ASSERT_EQ(code, 0);
 
-  SMetaReq req = {0};
+  SCatalogReq req = {0};
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
@@ -221,7 +221,7 @@ TEST(testCase, function_Test2) {
   int32_t   code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
   ASSERT_EQ(code, 0);
 
-  SMetaReq req = {0};
+  SCatalogReq req = {0};
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
@@ -267,7 +267,7 @@ TEST(testCase, function_Test3) {
   int32_t   code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
   ASSERT_EQ(code, 0);
 
-  SMetaReq req = {0};
+  SCatalogReq req = {0};
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
@@ -312,7 +312,7 @@ TEST(testCase, function_Test4) {
   int32_t   code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
   ASSERT_EQ(code, 0);
 
-  SMetaReq req = {0};
+  SCatalogReq req = {0};
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
@@ -360,7 +360,7 @@ TEST(testCase, function_Test5) {
   int32_t   code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
   ASSERT_EQ(code, 0);
 
-  SMetaReq req = {0};
+  SCatalogReq req = {0};
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
@@ -445,7 +445,7 @@ TEST(testCase, function_Test6) {
   int32_t   code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
   ASSERT_EQ(code, 0);
 
-  SMetaReq req = {0};
+  SCatalogReq req = {0};
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
@@ -523,7 +523,7 @@ TEST(testCase, function_Test6) {
   int32_t code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
   ASSERT_EQ(code, 0);
 
-  SMetaReq req = {0};
+  SCatalogReq req = {0};
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
@@ -585,7 +585,7 @@ TEST(testCase, function_Test6) {
   int32_t code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
   ASSERT_EQ(code, 0);
 
-  SMetaReq req = {0};
+  SCatalogReq req = {0};
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
@@ -664,7 +664,7 @@ TEST(testCase, function_Test6) {
   int32_t code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
   ASSERT_EQ(code, 0);
 
-  SMetaReq req = {0};
+  SCatalogReq req = {0};
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
diff --git a/source/libs/parser/test/plannerTest.cpp b/source/libs/parser/test/plannerTest.cpp
index c86e687664..a2078defda 100644
--- a/source/libs/parser/test/plannerTest.cpp
+++ b/source/libs/parser/test/plannerTest.cpp
@@ -30,6 +30,7 @@
 #include "tdef.h"
 #include "tvariant.h"
 #include "planner.h"
+#include "../../planner/inc/plannerInt.h"
 
 namespace {
 void setSchema(SSchema* p, int32_t type, int32_t bytes, const char* name, int32_t colId) {
@@ -39,7 +40,7 @@ void setSchema(SSchema* p, int32_t type, int32_t bytes, const char* name, int32_
   strcpy(p->name, name);
 }
 
-void setTableMetaInfo(SQueryStmtInfo* pQueryInfo, SMetaReq *req) {
+void setTableMetaInfo(SQueryStmtInfo* pQueryInfo, SCatalogReq *req) {
   pQueryInfo->numOfTables = 1;
 
   pQueryInfo->pTableMetaInfo = (STableMetaInfo**)calloc(1, POINTER_BYTES);
@@ -79,7 +80,7 @@ void generateLogicplan(const char* sql) {
   int32_t code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
   ASSERT_EQ(code, 0);
 
-  SMetaReq req = {0};
+  SCatalogReq req = {0};
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
@@ -92,10 +93,10 @@ void generateLogicplan(const char* sql) {
   ASSERT_EQ(ret, 0);
 
   struct SQueryPlanNode* n = nullptr;
-  code = qCreateQueryPlan(pQueryInfo, &n);
+  code = createQueryPlan(pQueryInfo, &n);
 
   char* str = NULL;
-  qQueryPlanToString(n, &str);
+  queryPlanToString(n, &str);
 
   printf("--------SQL:%s\n", sql);
   printf("%s\n", str);
@@ -119,7 +120,7 @@ TEST(testCase, planner_test) {
   int32_t code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
   ASSERT_EQ(code, 0);
 
-  SMetaReq req = {0};
+  SCatalogReq req = {0};
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
@@ -155,10 +156,10 @@ TEST(testCase, planner_test) {
   ASSERT_EQ(pQueryInfo->fieldsInfo.numOfOutput, 2);
 
   struct SQueryPlanNode* n = nullptr;
-  code = qCreateQueryPlan(pQueryInfo, &n);
+  code = createQueryPlan(pQueryInfo, &n);
 
   char* str = NULL;
-  qQueryPlanToString(n, &str);
+  queryPlanToString(n, &str);
   printf("%s\n", str);
 
   destroyQueryInfo(pQueryInfo);
diff --git a/source/libs/parser/test/tokenizerTest.cpp b/source/libs/parser/test/tokenizerTest.cpp
index 032a93cd32..23c0aae15f 100644
--- a/source/libs/parser/test/tokenizerTest.cpp
+++ b/source/libs/parser/test/tokenizerTest.cpp
@@ -709,7 +709,7 @@ TEST(testCase, extractMeta_test) {
   ASSERT_EQ(info1.valid, true);
 
   char msg[128] = {0};
-  SMetaReq req  = {0};
+  SCatalogReq req  = {0};
   int32_t ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
diff --git a/source/libs/planner/CMakeLists.txt b/source/libs/planner/CMakeLists.txt
index 23efce38f4..4e0d03d07a 100644
--- a/source/libs/planner/CMakeLists.txt
+++ b/source/libs/planner/CMakeLists.txt
@@ -8,7 +8,7 @@ target_include_directories(
 
 target_link_libraries(
     planner
-    PRIVATE os util common catalog parser transport function
+    PRIVATE os util common catalog parser transport function query
 )
 
-ADD_SUBDIRECTORY(test)
\ No newline at end of file
+ADD_SUBDIRECTORY(test)
diff --git a/source/libs/planner/inc/plannerInt.h b/source/libs/planner/inc/plannerInt.h
index 6bd89905b1..2231c93362 100644
--- a/source/libs/planner/inc/plannerInt.h
+++ b/source/libs/planner/inc/plannerInt.h
@@ -25,6 +25,19 @@ extern "C" {
 #include "planner.h"
 #include "taosmsg.h"
 
+enum LOGIC_PLAN_E {
+  LP_SCAN     = 1,
+  LP_SESSION  = 2,
+  LP_STATE    = 3,
+  LP_INTERVAL = 4,
+  LP_FILL     = 5,
+  LP_AGG      = 6,
+  LP_JOIN     = 7,
+  LP_PROJECT  = 8,
+  LP_DISTINCT = 9,
+  LP_ORDER    = 10
+};
+
 typedef struct SQueryNodeBasicInfo {
   int32_t   type;          // operator type
   char     *name;          // operator name
@@ -57,50 +70,94 @@ typedef struct SQueryPlanNode {
   struct SQueryPlanNode  *nextNode;
 } SQueryPlanNode;
 
-typedef struct SQueryDistPlanNode {
+typedef SSchema SSlotSchema;
+
+typedef struct SDataBlockSchema {
+  int32_t             index;
+  SSlotSchema        *pSchema;
+  int32_t             numOfCols;    // number of columns
+} SDataBlockSchema;
+
+typedef struct SPhyNode {
   SQueryNodeBasicInfo info;
-  SSchema            *pSchema;      // the schema of the input SSDatablock
-  int32_t             numOfCols;    // number of input columns
-  SArray             *pExpr;        // the query functions or sql aggregations
-  int32_t             numOfExpr;    // number of result columns, which is also the number of pExprs
-  void               *pExtInfo;     // additional information
+  SArray             *pTargets;      // target list to be computed or scanned at this node
+  SArray             *pConditions;         // implicitly-ANDed qual conditions
+  SDataBlockSchema    targetSchema;
+  // children plan to generated result for current node to process
+  // in case of join, multiple plan nodes exist.
+  SArray             *pChildren;
+} SPhyNode;
 
-  // previous operator to generated result for current node to process
-  // in case of join, multiple prev nodes exist.
-  SArray             *pPrevNodes;   // upstream nodes, or exchange operator to load data from multiple sources.
-} SQueryDistPlanNode;
+typedef struct SScanPhyNode {
+  SPhyNode node;
+  uint64_t     uid;  // unique id of the table
+} SScanPhyNode;
 
-typedef struct SQueryCostSummary {
-  int64_t startTs;      // Object created and added into the message queue
-  int64_t endTs;        // the timestamp when the task is completed
-  int64_t cputime;      // total cpu cost, not execute elapsed time
+typedef SScanPhyNode STagScanPhyNode;
 
-  int64_t loadRemoteDataDuration;       // remote io time
-  int64_t loadNativeDataDuration;       // native disk io time
+typedef SScanPhyNode SSystemTableScanPhyNode;
 
-  uint64_t loadNativeData; // blocks + SMA + header files
-  uint64_t loadRemoteData; // remote data acquired by exchange operator.
+typedef struct SMultiTableScanPhyNode {
+  SScanPhyNode scan;
+  SArray      *pTagsConditions; // implicitly-ANDed tag qual conditions
+} SMultiTableScanPhyNode;
 
-  uint64_t waitDuration; // the time to waiting to be scheduled in queue does matter, so we need to record it
-  int64_t  addQTs;       // the time to be added into the message queue, used to calculate the waiting duration in queue.
+typedef SMultiTableScanPhyNode SMultiTableSeqScanPhyNode;
 
-  uint64_t totalRows;
-  uint64_t loadRows;
-  uint32_t totalBlocks;
-  uint32_t loadBlocks;
-  uint32_t loadBlockAgg;
-  uint32_t skipBlocks;
-  uint64_t resultSize;   // generated result size in Kb.
-} SQueryCostSummary;
+typedef struct SProjectPhyNode {
+  SPhyNode node;
+} SProjectPhyNode;
 
-typedef struct SQueryTask {
-  uint64_t            queryId; // query id
-  uint64_t            taskId;  // task id
-  SQueryDistPlanNode *pNode;   // operator tree
-  uint64_t            status;  // task status
-  SQueryCostSummary   summary; // task execution summary
-  void               *pOutputHandle; // result buffer handle, to temporarily keep the output result for next stage
-} SQueryTask;
+/**
+ * Optimize the query execution plan, currently not implement yet.
+ * @param pQueryNode
+ * @return
+ */
+int32_t optimizeQueryPlan(struct SQueryPlanNode* pQueryNode);
+
+/**
+ * Create the query plan according to the bound AST, which is in the form of pQueryInfo
+ * @param pQueryInfo
+ * @param pQueryNode
+ * @return
+ */
+int32_t createQueryPlan(const struct SQueryStmtInfo* pQueryInfo, struct SQueryPlanNode** pQueryNode);
+
+/**
+ * Convert the query plan to string, in order to display it in the shell.
+ * @param pQueryNode
+ * @return
+ */
+int32_t queryPlanToString(struct SQueryPlanNode* pQueryNode, char** str);
+
+/**
+ * Restore the SQL statement according to the logic query plan.
+ * @param pQueryNode
+ * @param sql
+ * @return
+ */
+int32_t queryPlanToSql(struct SQueryPlanNode* pQueryNode, char** sql);
+
+/**
+ * Convert to physical plan to string to enable to print it out in the shell.
+ * @param pPhyNode
+ * @param str
+ * @return
+ */
+int32_t phyPlanToString(struct SPhyNode *pPhyNode, char** str);
+
+/**
+ * Destroy the query plan object.
+ * @return
+ */
+void* destroyQueryPlan(struct SQueryPlanNode* pQueryNode);
+
+/**
+ * Destroy the physical plan.
+ * @param pQueryPhyNode
+ * @return
+ */
+void* destroyQueryPhyPlan(struct SPhyNode* pQueryPhyNode);
 
 #ifdef __cplusplus
 }
diff --git a/source/libs/planner/src/physicalPlan.c b/source/libs/planner/src/physicalPlan.c
new file mode 100644
index 0000000000..2bdc159af8
--- /dev/null
+++ b/source/libs/planner/src/physicalPlan.c
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "plannerInt.h"
+
+SPhyNode* createScanNode(SQueryPlanNode* pPlanNode) {
+  return NULL;
+}
+
+SPhyNode* createPhyNode(SQueryPlanNode* node) {
+  switch (node->info.type) {
+    case LP_SCAN:
+      return createScanNode(node);
+  }
+  return NULL;
+}
+
+SPhyNode* createSubplan(SQueryPlanNode* pSubquery) {
+  return NULL;
+}
+
+int32_t createDag(struct SQueryPlanNode* pQueryNode, struct SEpSet* pQnode, struct SQueryDag** pDag) {
+  return 0;
+}
diff --git a/source/libs/planner/src/planner.c b/source/libs/planner/src/planner.c
index 79c7691698..e54b847230 100644
--- a/source/libs/planner/src/planner.c
+++ b/source/libs/planner/src/planner.c
@@ -48,11 +48,11 @@ static SArray* createQueryPlanImpl(SQueryStmtInfo* pQueryInfo);
 static void doDestroyQueryNode(SQueryPlanNode* pQueryNode);
 
 int32_t printExprInfo(const char* buf, const SQueryPlanNode* pQueryNode, int32_t len);
-int32_t qOptimizeQueryPlan(struct SQueryPlanNode* pQueryNode) {
+int32_t optimizeQueryPlan(struct SQueryPlanNode* pQueryNode) {
   return 0;
 }
 
-int32_t qCreateQueryPlan(const struct SQueryStmtInfo* pQueryInfo, struct SQueryPlanNode** pQueryNode) {
+int32_t createQueryPlan(const struct SQueryStmtInfo* pQueryInfo, struct SQueryPlanNode** pQueryNode) {
   SArray* upstream = createQueryPlanImpl((struct SQueryStmtInfo*) pQueryInfo);
   assert(taosArrayGetSize(upstream) == 1);
 
@@ -62,19 +62,20 @@ int32_t qCreateQueryPlan(const struct SQueryStmtInfo* pQueryInfo, struct SQueryP
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t qQueryPlanToSql(struct SQueryPlanNode* pQueryNode, char** sql) {
+int32_t queryPlanToSql(struct SQueryPlanNode* pQueryNode, char** sql) {
   return 0;
 }
 
-int32_t qCreatePhysicalPlan(struct SQueryPlanNode* pQueryNode, struct SEpSet* pQnode, struct SQueryDistPlanNode *pPhyNode) {
+int32_t qCreatePhysicalPlan(struct SQueryPlanNode* pQueryNode, struct SEpSet* pQnode, struct SQueryDag** pDag) {
+
   return 0;
 }
 
-int32_t qPhyPlanToString(struct SQueryDistPlanNode *pPhyNode, char** str) {
+int32_t phyPlanToString(struct SPhyNode *pPhyNode, char** str) {
   return 0;
 }
 
-void* qDestroyQueryPlan(SQueryPlanNode* pQueryNode) {
+void* destroyQueryPlan(SQueryPlanNode* pQueryNode) {
   if (pQueryNode == NULL) {
     return NULL;
   }
@@ -83,14 +84,10 @@ void* qDestroyQueryPlan(SQueryPlanNode* pQueryNode) {
   return NULL;
 }
 
-void* qDestroyQueryPhyPlan(struct SQueryDistPlanNode* pQueryPhyNode) {
+void* destroyQueryPhyPlan(struct SPhyNode* pQueryPhyNode) {
   return NULL;
 }
 
-int32_t qCreateQueryJob(const struct SQueryDistPlanNode* pPhyNode, struct SQueryJob** pJob) {
-  return 0;
-}
-
 //======================================================================================================================
 
 static SQueryPlanNode* createQueryNode(int32_t type, const char* name, SQueryPlanNode** prev, int32_t numOfPrev,
@@ -619,7 +616,7 @@ int32_t queryPlanToStringImpl(char* buf, SQueryPlanNode* pQueryNode, int32_t lev
   return len;
 }
 
-int32_t qQueryPlanToString(struct SQueryPlanNode* pQueryNode, char** str) {
+int32_t queryPlanToString(struct SQueryPlanNode* pQueryNode, char** str) {
   assert(pQueryNode);
 
   *str = calloc(1, 4096);
diff --git a/source/libs/planner/test/CMakeLists.txt b/source/libs/planner/test/CMakeLists.txt
index a83d7a39d9..f00adfaeb2 100644
--- a/source/libs/planner/test/CMakeLists.txt
+++ b/source/libs/planner/test/CMakeLists.txt
@@ -8,7 +8,7 @@ AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SOURCE_LIST)
 ADD_EXECUTABLE(plannerTest ${SOURCE_LIST})
 TARGET_LINK_LIBRARIES(
         plannerTest
-        PUBLIC os util common planner parser catalog transport gtest function
+        PUBLIC os util common planner parser catalog transport gtest function query
 )
 
 TARGET_INCLUDE_DIRECTORIES(
diff --git a/source/libs/query/CMakeLists.txt b/source/libs/query/CMakeLists.txt
new file mode 100644
index 0000000000..579a4b279c
--- /dev/null
+++ b/source/libs/query/CMakeLists.txt
@@ -0,0 +1,12 @@
+aux_source_directory(src QUERY_SRC)
+add_library(query ${QUERY_SRC})
+target_include_directories(
+    query
+    PUBLIC "${CMAKE_SOURCE_DIR}/include/libs/query"
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+)
+
+target_link_libraries(
+   query
+   PRIVATE os util common transport
+)
diff --git a/source/libs/query/inc/queryInt.h b/source/libs/query/inc/queryInt.h
new file mode 100644
index 0000000000..f3204b3785
--- /dev/null
+++ b/source/libs/query/inc/queryInt.h
@@ -0,0 +1,40 @@
+/*
+ * 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_QUERY_INT_H_
+#define _TD_QUERY_INT_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#include "tlog.h"
+
+extern int32_t qDebugFlag;
+
+#define qFatal(...)  do { if (qDebugFlag & DEBUG_FATAL) { taosPrintLog("QRY FATAL ", qDebugFlag, __VA_ARGS__); }} while(0)
+#define qError(...)  do { if (qDebugFlag & DEBUG_ERROR) { taosPrintLog("QRY ERROR ", qDebugFlag, __VA_ARGS__); }} while(0)
+#define qWarn(...)   do { if (qDebugFlag & DEBUG_WARN)  { taosPrintLog("QRY WARN ", qDebugFlag, __VA_ARGS__); }}  while(0)
+#define qInfo(...)   do { if (qDebugFlag & DEBUG_INFO)  { taosPrintLog("QRY ", qDebugFlag, __VA_ARGS__); }} while(0)
+#define qDebug(...)  do { if (qDebugFlag & DEBUG_DEBUG) { taosPrintLog("QRY ", qDebugFlag, __VA_ARGS__); }} while(0)
+#define qTrace(...)  do { if (qDebugFlag & DEBUG_TRACE) { taosPrintLog("QRY ", qDebugFlag, __VA_ARGS__); }} while(0)
+#define qDebugL(...) do { if (qDebugFlag & DEBUG_DEBUG) { taosPrintLongString("QRY ", qDebugFlag, __VA_ARGS__); }} while(0)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_QUERY_INT_H_*/
diff --git a/source/libs/query/src/querymsg.c b/source/libs/query/src/querymsg.c
new file mode 100644
index 0000000000..8f35fd9c3e
--- /dev/null
+++ b/source/libs/query/src/querymsg.c
@@ -0,0 +1,336 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "taosmsg.h"
+#include "queryInt.h"
+#include "query.h"
+
+int32_t (*queryBuildMsg[TSDB_MSG_TYPE_MAX])(void* input, char **msg, int32_t msgSize, int32_t *msgLen) = {0};
+
+int32_t (*queryProcessMsgRsp[TSDB_MSG_TYPE_MAX])(void* output, char *msg, int32_t msgSize) = {0};
+
+
+int32_t queryBuildVgroupListReqMsg(void* input, char **msg, int32_t msgSize, int32_t *msgLen) {
+  if (NULL == msg || NULL == msgLen) {
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
+
+  *msgLen = 0;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t queryBuildTableMetaReqMsg(void* input, char **msg, int32_t msgSize, int32_t *msgLen) {
+  if (NULL == input || NULL == msg || NULL == msgLen) {
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
+
+  SBuildTableMetaInput* bInput = (SBuildTableMetaInput *)input;
+
+  int32_t estimateSize = sizeof(STableInfoMsg);
+  if (NULL == *msg || msgSize < estimateSize) {
+    tfree(*msg);
+    *msg = calloc(1, estimateSize);
+    if (NULL == *msg) {
+      return TSDB_CODE_TSC_OUT_OF_MEMORY;
+    }
+  }
+
+  STableInfoMsg *bMsg = (STableInfoMsg *)*msg;
+
+  bMsg->msgHead.vgId = bInput->vgId;
+
+  strncpy(bMsg->tableFname, bInput->tableFullName, sizeof(bMsg->tableFname));
+  bMsg->tableFname[sizeof(bMsg->tableFname) - 1] = 0;
+
+  *msgLen = (int32_t)sizeof(*bMsg);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t queryBuildUseDbMsg(void* input, char **msg, int32_t msgSize, int32_t *msgLen) {
+  if (NULL == input || NULL == msg || NULL == msgLen) {
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
+
+  SBuildUseDBInput* bInput = (SBuildUseDBInput *)input;
+
+  int32_t estimateSize = sizeof(SUseDbMsg);
+  if (NULL == *msg || msgSize < estimateSize) {
+    tfree(*msg);
+    *msg = calloc(1, estimateSize);
+    if (NULL == *msg) {
+      return TSDB_CODE_TSC_OUT_OF_MEMORY;
+    }
+  }
+
+  SUseDbMsg *bMsg = (SUseDbMsg *)*msg;
+
+  strncpy(bMsg->db, bInput->db, sizeof(bMsg->db));
+  bMsg->db[sizeof(bMsg->db) - 1] = 0;
+
+  bMsg->vgroupVersion = bInput->vgroupVersion;
+  bMsg->dbGroupVersion = bInput->dbGroupVersion;
+
+  *msgLen = (int32_t)sizeof(*bMsg);
+
+  return TSDB_CODE_SUCCESS;  
+}
+
+
+
+int32_t queryProcessVgroupListRsp(void* output, char *msg, int32_t msgSize) {
+  if (NULL == output || NULL == msg || msgSize <= 0) {
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
+
+  SVgroupListRspMsg *pRsp = (SVgroupListRspMsg *)msg;
+
+  pRsp->vgroupNum = htonl(pRsp->vgroupNum);
+  pRsp->vgroupVersion = htonl(pRsp->vgroupVersion);
+
+  if (pRsp->vgroupNum < 0) {
+    qError("vgroup number[%d] in rsp is invalid", pRsp->vgroupNum);
+    return TSDB_CODE_TSC_VALUE_OUT_OF_RANGE;
+  }
+
+  if (pRsp->vgroupVersion < 0) {
+    qError("vgroup vgroupVersion[%d] in rsp is invalid", pRsp->vgroupVersion);
+    return TSDB_CODE_TSC_VALUE_OUT_OF_RANGE;
+  }
+
+  if (msgSize != (pRsp->vgroupNum * sizeof(pRsp->vgroupInfo[0]) + sizeof(*pRsp))) {
+    qError("vgroup list msg size mis-match, msgSize:%d, vgroup number:%d", msgSize, pRsp->vgroupNum);
+    return TSDB_CODE_TSC_VALUE_OUT_OF_RANGE;
+  }
+
+  // keep SVgroupListInfo/SVgroupListRspMsg the same
+  *(SVgroupListInfo **)output = (SVgroupListInfo *)msg;
+
+  if (pRsp->vgroupNum == 0) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  for (int32_t i = 0; i < pRsp->vgroupNum; ++i) {
+    pRsp->vgroupInfo[i].vgId = htonl(pRsp->vgroupInfo[i].vgId);
+    for (int32_t n = 0; n < pRsp->vgroupInfo[i].numOfEps; ++n) {
+      pRsp->vgroupInfo[i].epAddr[n].port = htonl(pRsp->vgroupInfo[i].epAddr[n].port);
+    }
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
+
+
+int32_t queryProcessUseDBRsp(void* output, char *msg, int32_t msgSize) {
+  if (NULL == output || NULL == msg || msgSize <= 0) {
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
+
+  SUseDbRspMsg *pRsp = (SUseDbRspMsg *)msg;
+  SUseDbOutput *pOut = (SUseDbOutput *)output;
+  int32_t code = 0;
+
+  if (msgSize <= sizeof(*pRsp)) {
+    qError("invalid use db rsp msg size, msgSize:%d", msgSize);
+    return TSDB_CODE_TSC_VALUE_OUT_OF_RANGE;
+  }
+  
+  pRsp->vgroupVersion = htonl(pRsp->vgroupVersion);
+  pRsp->dbVgroupVersion = htonl(pRsp->dbVgroupVersion);
+
+  pRsp->vgroupNum = htonl(pRsp->vgroupNum);
+  pRsp->dbVgroupNum = htonl(pRsp->dbVgroupNum);
+
+  if (pRsp->vgroupNum < 0) {
+    qError("invalid vgroup number[%d]", pRsp->vgroupNum);
+    return TSDB_CODE_TSC_INVALID_VALUE;
+  }
+
+  if (pRsp->dbVgroupNum < 0) {
+    qError("invalid db vgroup number[%d]", pRsp->dbVgroupNum);
+    return TSDB_CODE_TSC_INVALID_VALUE;
+  }
+
+  int32_t expectSize = pRsp->vgroupNum * sizeof(pRsp->vgroupInfo[0]) + pRsp->dbVgroupNum * sizeof(int32_t) + sizeof(*pRsp);
+  if (msgSize != expectSize) {
+    qError("vgroup list msg size mis-match, msgSize:%d, expected:%d, vgroup number:%d, db vgroup number:%d", msgSize, expectSize, pRsp->vgroupNum, pRsp->dbVgroupNum);
+    return TSDB_CODE_TSC_VALUE_OUT_OF_RANGE;
+  }
+
+  if (pRsp->vgroupVersion < 0) {
+    qInfo("no new vgroup list info");
+    if (pRsp->vgroupNum != 0) {
+      qError("invalid vgroup number[%d] for no new vgroup list case", pRsp->vgroupNum);
+      return TSDB_CODE_TSC_INVALID_VALUE;
+    }
+  } else {
+    int32_t s = sizeof(*pOut->vgroupList) + sizeof(pOut->vgroupList->vgroupInfo[0]) * pRsp->vgroupNum;
+    pOut->vgroupList = calloc(1, s);
+    if (NULL == pOut->vgroupList) {
+      qError("calloc size[%d] failed", s);
+      return TSDB_CODE_TSC_OUT_OF_MEMORY;
+    }
+
+    pOut->vgroupList->vgroupNum = pRsp->vgroupNum;
+    pOut->vgroupList->vgroupVersion = pRsp->vgroupVersion;
+
+    for (int32_t i = 0; i < pRsp->vgroupNum; ++i) {
+      pRsp->vgroupInfo[i].vgId = htonl(pRsp->vgroupInfo[i].vgId);
+      for (int32_t n = 0; n < pRsp->vgroupInfo[i].numOfEps; ++n) {
+        pRsp->vgroupInfo[i].epAddr[n].port = htonl(pRsp->vgroupInfo[i].epAddr[n].port);
+      }
+
+      memcpy(&pOut->vgroupList->vgroupInfo[i], &pRsp->vgroupInfo[i], sizeof(pRsp->vgroupInfo[i]));
+    }
+  }
+
+  int32_t *vgIdList = (int32_t *)((char *)pRsp->vgroupInfo + sizeof(pRsp->vgroupInfo[0]) * pRsp->vgroupNum);
+
+  memcpy(pOut->db, pRsp->db, sizeof(pOut->db));
+  
+  if (pRsp->dbVgroupVersion < 0) {
+    qInfo("no new vgroup info for db[%s]", pRsp->db);
+  } else {
+    pOut->dbVgroup = calloc(1, sizeof(*pOut->dbVgroup));
+    if (NULL == pOut->dbVgroup) {
+      qError("calloc size[%d] failed", (int32_t)sizeof(*pOut->dbVgroup));
+      code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+      goto _exit;
+    }
+
+    pOut->dbVgroup->vgId = taosArrayInit(pRsp->dbVgroupNum, sizeof(int32_t));
+    if (NULL == pOut->dbVgroup->vgId) {
+      qError("taosArrayInit size[%d] failed", pRsp->dbVgroupNum);
+      code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+      goto _exit;
+    }
+    
+    pOut->dbVgroup->vgroupVersion = pRsp->dbVgroupVersion;
+    pOut->dbVgroup->hashRange = htonl(pRsp->dbHashRange);
+
+    for (int32_t i = 0; i < pRsp->dbVgroupNum; ++i) {
+      *(vgIdList + i) = htonl(*(vgIdList + i));
+      
+      taosArrayPush(pOut->dbVgroup->vgId, vgIdList + i) ;
+    }
+  }
+
+  return code;
+
+_exit:
+  if (pOut->dbVgroup && pOut->dbVgroup->vgId) {
+    taosArrayDestroy(pOut->dbVgroup->vgId);
+    pOut->dbVgroup->vgId = NULL;
+  }
+  
+  tfree(pOut->dbVgroup);
+  tfree(pOut->vgroupList);
+
+  return code;
+}
+
+
+void msgInit() {
+  queryBuildMsg[TSDB_MSG_TYPE_TABLE_META] = queryBuildTableMetaReqMsg;
+  queryBuildMsg[TSDB_MSG_TYPE_VGROUP_LIST] = queryBuildVgroupListReqMsg;
+  queryBuildMsg[TSDB_MSG_TYPE_USE_DB] = queryBuildUseDbMsg;
+
+  //tscProcessMsgRsp[TSDB_MSG_TYPE_TABLE_META] = tscProcessTableMetaRsp;
+  queryProcessMsgRsp[TSDB_MSG_TYPE_VGROUP_LIST] = queryProcessVgroupListRsp;
+  queryProcessMsgRsp[TSDB_MSG_TYPE_USE_DB] = queryProcessUseDBRsp;
+
+/*
+  tscBuildMsg[TSDB_SQL_SELECT] = tscBuildQueryMsg;
+  tscBuildMsg[TSDB_SQL_INSERT] = tscBuildSubmitMsg;
+  tscBuildMsg[TSDB_SQL_FETCH] = tscBuildFetchMsg;
+
+  tscBuildMsg[TSDB_SQL_CREATE_DB] = tscBuildCreateDbMsg;
+  tscBuildMsg[TSDB_SQL_CREATE_USER] = tscBuildUserMsg;
+  tscBuildMsg[TSDB_SQL_CREATE_FUNCTION] = tscBuildCreateFuncMsg;
+
+  tscBuildMsg[TSDB_SQL_CREATE_ACCT] = tscBuildAcctMsg;
+  tscBuildMsg[TSDB_SQL_ALTER_ACCT] = tscBuildAcctMsg;
+
+  tscBuildMsg[TSDB_SQL_CREATE_TABLE] = tscBuildCreateTableMsg;
+  tscBuildMsg[TSDB_SQL_DROP_USER] = tscBuildDropUserAcctMsg;
+  tscBuildMsg[TSDB_SQL_DROP_ACCT] = tscBuildDropUserAcctMsg;
+  tscBuildMsg[TSDB_SQL_DROP_DB] = tscBuildDropDbMsg;
+  tscBuildMsg[TSDB_SQL_DROP_FUNCTION] = tscBuildDropFuncMsg;
+  tscBuildMsg[TSDB_SQL_SYNC_DB_REPLICA] = tscBuildSyncDbReplicaMsg;
+  tscBuildMsg[TSDB_SQL_DROP_TABLE] = tscBuildDropTableMsg;
+  tscBuildMsg[TSDB_SQL_ALTER_USER] = tscBuildUserMsg;
+  tscBuildMsg[TSDB_SQL_CREATE_DNODE] = tscBuildCreateDnodeMsg;
+  tscBuildMsg[TSDB_SQL_DROP_DNODE] = tscBuildDropDnodeMsg;
+  tscBuildMsg[TSDB_SQL_CFG_DNODE] = tscBuildCfgDnodeMsg;
+  tscBuildMsg[TSDB_SQL_ALTER_TABLE] = tscBuildAlterTableMsg;
+  tscBuildMsg[TSDB_SQL_UPDATE_TAGS_VAL] = tscBuildUpdateTagMsg;
+  tscBuildMsg[TSDB_SQL_ALTER_DB] = tscAlterDbMsg;
+  tscBuildMsg[TSDB_SQL_COMPACT_VNODE] = tscBuildCompactMsg;  
+
+  tscBuildMsg[TSDB_SQL_CONNECT] = tscBuildConnectMsg;
+  tscBuildMsg[TSDB_SQL_USE_DB] = tscBuildUseDbMsg;
+  tscBuildMsg[TSDB_SQL_STABLEVGROUP] = tscBuildSTableVgroupMsg;
+  tscBuildMsg[TSDB_SQL_RETRIEVE_FUNC] = tscBuildRetrieveFuncMsg;
+
+  tscBuildMsg[TSDB_SQL_HB] = tscBuildHeartBeatMsg;
+  tscBuildMsg[TSDB_SQL_SHOW] = tscBuildShowMsg;
+  tscBuildMsg[TSDB_SQL_RETRIEVE] = tscBuildRetrieveFromMgmtMsg;
+  tscBuildMsg[TSDB_SQL_KILL_QUERY] = tscBuildKillMsg;
+  tscBuildMsg[TSDB_SQL_KILL_STREAM] = tscBuildKillMsg;
+  tscBuildMsg[TSDB_SQL_KILL_CONNECTION] = tscBuildKillMsg;
+
+  tscProcessMsgRsp[TSDB_SQL_SELECT] = tscProcessQueryRsp;
+  tscProcessMsgRsp[TSDB_SQL_FETCH] = tscProcessRetrieveRspFromNode;
+
+  tscProcessMsgRsp[TSDB_SQL_DROP_DB] = tscProcessDropDbRsp;
+  tscProcessMsgRsp[TSDB_SQL_DROP_TABLE] = tscProcessDropTableRsp;
+  tscProcessMsgRsp[TSDB_SQL_CONNECT] = tscProcessConnectRsp;
+  tscProcessMsgRsp[TSDB_SQL_USE_DB] = tscProcessUseDbRsp;
+  tscProcessMsgRsp[TSDB_SQL_META] = tscProcessTableMetaRsp;
+  tscProcessMsgRsp[TSDB_SQL_STABLEVGROUP] = tscProcessSTableVgroupRsp;
+  tscProcessMsgRsp[TSDB_SQL_MULTI_META] = tscProcessMultiTableMetaRsp;
+  tscProcessMsgRsp[TSDB_SQL_RETRIEVE_FUNC] = tscProcessRetrieveFuncRsp;
+
+  tscProcessMsgRsp[TSDB_SQL_SHOW] = tscProcessShowRsp;
+  tscProcessMsgRsp[TSDB_SQL_RETRIEVE] = tscProcessRetrieveRspFromNode;  // rsp handled by same function.
+  tscProcessMsgRsp[TSDB_SQL_DESCRIBE_TABLE] = tscProcessDescribeTableRsp;
+
+  tscProcessMsgRsp[TSDB_SQL_CURRENT_DB]   = tscProcessLocalRetrieveRsp;
+  tscProcessMsgRsp[TSDB_SQL_CURRENT_USER] = tscProcessLocalRetrieveRsp;
+  tscProcessMsgRsp[TSDB_SQL_SERV_VERSION] = tscProcessLocalRetrieveRsp;
+  tscProcessMsgRsp[TSDB_SQL_CLI_VERSION]  = tscProcessLocalRetrieveRsp;
+  tscProcessMsgRsp[TSDB_SQL_SERV_STATUS]  = tscProcessLocalRetrieveRsp;
+
+  tscProcessMsgRsp[TSDB_SQL_RETRIEVE_EMPTY_RESULT] = tscProcessEmptyResultRsp;
+
+  tscProcessMsgRsp[TSDB_SQL_RETRIEVE_GLOBALMERGE] = tscProcessRetrieveGlobalMergeRsp;
+
+  tscProcessMsgRsp[TSDB_SQL_ALTER_TABLE] = tscProcessAlterTableMsgRsp;
+  tscProcessMsgRsp[TSDB_SQL_ALTER_DB] = tscProcessAlterDbMsgRsp;
+  tscProcessMsgRsp[TSDB_SQL_COMPACT_VNODE] = tscProcessCompactRsp; 
+
+  tscProcessMsgRsp[TSDB_SQL_SHOW_CREATE_TABLE] = tscProcessShowCreateRsp;
+  tscProcessMsgRsp[TSDB_SQL_SHOW_CREATE_STABLE] = tscProcessShowCreateRsp;
+  tscProcessMsgRsp[TSDB_SQL_SHOW_CREATE_DATABASE] = tscProcessShowCreateRsp;
+*/
+}
+
+
+
+
+
diff --git a/source/libs/sync/src/sync.c b/source/libs/sync/src/sync.c
index 06af8ff6c2..e49b1d7983 100644
--- a/source/libs/sync/src/sync.c
+++ b/source/libs/sync/src/sync.c
@@ -228,7 +228,7 @@ static int syncInitRpcServer(SSyncManager* syncManager, const SSyncCluster* pSyn
 }
 
 static int syncInitRpcClient(SSyncManager* syncManager) {
-  char secret[TSDB_KEY_LEN] = "secret";
+  char secret[TSDB_PASSWORD_LEN] = "secret";
   SRpcInit rpcInit;
   memset(&rpcInit, 0, sizeof(rpcInit));
   rpcInit.label        = "sync-client";
diff --git a/source/libs/transport/inc/rpcLog.h b/source/libs/transport/inc/rpcLog.h
index 6c4a281d2c..904680bbe6 100644
--- a/source/libs/transport/inc/rpcLog.h
+++ b/source/libs/transport/inc/rpcLog.h
@@ -23,11 +23,10 @@ extern "C" {
 #include "tlog.h"
 
 extern int32_t rpcDebugFlag;
-extern int8_t  tscEmbedded;
 
-#define tFatal(...) { if (rpcDebugFlag & DEBUG_FATAL) { taosPrintLog("RPC FATAL ", tscEmbedded ? 255 : rpcDebugFlag, __VA_ARGS__); }}
-#define tError(...) { if (rpcDebugFlag & DEBUG_ERROR) { taosPrintLog("RPC ERROR ", tscEmbedded ? 255 : rpcDebugFlag, __VA_ARGS__); }}
-#define tWarn(...)  { if (rpcDebugFlag & DEBUG_WARN)  { taosPrintLog("RPC WARN ", tscEmbedded ? 255 : rpcDebugFlag, __VA_ARGS__); }}
+#define tFatal(...) { if (rpcDebugFlag & DEBUG_FATAL) { taosPrintLog("RPC FATAL ", rpcDebugFlag, __VA_ARGS__); }}
+#define tError(...) { if (rpcDebugFlag & DEBUG_ERROR) { taosPrintLog("RPC ERROR ", rpcDebugFlag, __VA_ARGS__); }}
+#define tWarn(...)  { if (rpcDebugFlag & DEBUG_WARN)  { taosPrintLog("RPC WARN ", rpcDebugFlag, __VA_ARGS__); }}
 #define tInfo(...)  { if (rpcDebugFlag & DEBUG_INFO)  { taosPrintLog("RPC ", tscEmbedded ? 255 : rpcDebugFlag, __VA_ARGS__); }}
 #define tDebug(...) { if (rpcDebugFlag & DEBUG_DEBUG) { taosPrintLog("RPC ", rpcDebugFlag, __VA_ARGS__); }}
 #define tTrace(...) { if (rpcDebugFlag & DEBUG_TRACE) { taosPrintLog("RPC ", rpcDebugFlag, __VA_ARGS__); }}
diff --git a/source/libs/transport/src/rpcMain.c b/source/libs/transport/src/rpcMain.c
index fb69a74876..2f710f3efd 100644
--- a/source/libs/transport/src/rpcMain.c
+++ b/source/libs/transport/src/rpcMain.c
@@ -51,8 +51,8 @@ typedef struct {
   char     user[TSDB_UNI_LEN];   // meter ID
   char     spi;                  // security parameter index
   char     encrypt;              // encrypt algorithm
-  char     secret[TSDB_KEY_LEN]; // secret for the link
-  char     ckey[TSDB_KEY_LEN];   // ciphering key 
+  char     secret[TSDB_PASSWORD_LEN]; // secret for the link
+  char     ckey[TSDB_PASSWORD_LEN];   // ciphering key
 
   void   (*cfp)(void *parent, SRpcMsg *, SEpSet *);
   int    (*afp)(void *parent, char *user, char *spi, char *encrypt, char *secret, char *ckey); 
@@ -97,8 +97,8 @@ typedef struct SRpcConn {
   char      user[TSDB_UNI_LEN]; // user ID for the link
   char      spi;     // security parameter index
   char      encrypt; // encryption, 0:1 
-  char      secret[TSDB_KEY_LEN]; // secret for the link
-  char      ckey[TSDB_KEY_LEN];   // ciphering key 
+  char      secret[TSDB_PASSWORD_LEN]; // secret for the link
+  char      ckey[TSDB_PASSWORD_LEN];   // ciphering key
   char      secured;              // if set to 1, no authentication
   uint16_t  localPort;      // for UDP only
   uint32_t  linkUid;        // connection unique ID assigned by client
@@ -229,8 +229,6 @@ static void rpcInitImp(void) {
   tsRpcOverhead = sizeof(SRpcReqContext);
 
   tsRpcRefId = taosOpenRef(200, rpcFree);
-
-  return 0;
 }
 
 int32_t rpcInit(void) {
@@ -413,7 +411,7 @@ void rpcSendRequest(void *shandle, const SEpSet *pEpSet, SRpcMsg *pMsg, int64_t
   // for TDengine, all the query, show commands shall have TCP connection
   char type = pMsg->msgType;
   if (type == TSDB_MSG_TYPE_QUERY || type == TSDB_MSG_TYPE_SHOW_RETRIEVE
-    || type == TSDB_MSG_TYPE_FETCH || type == TSDB_MSG_TYPE_STB_VGROUP
+    || type == TSDB_MSG_TYPE_FETCH || type == TSDB_MSG_TYPE_VGROUP_LIST
     || type == TSDB_MSG_TYPE_TABLES_META || type == TSDB_MSG_TYPE_TABLE_META
     || type == TSDB_MSG_TYPE_SHOW || type == TSDB_MSG_TYPE_STATUS || type == TSDB_MSG_TYPE_ALTER_TABLE)
     pContext->connType = RPC_CONN_TCPC;
@@ -705,7 +703,7 @@ static SRpcConn *rpcAllocateClientConn(SRpcInfo *pRpc) {
     pConn->linkUid = (uint32_t)((int64_t)pConn + taosGetPid() + (int64_t)pConn->tranId);
     pConn->spi = pRpc->spi;
     pConn->encrypt = pRpc->encrypt;
-    if (pConn->spi) memcpy(pConn->secret, pRpc->secret, TSDB_KEY_LEN);
+    if (pConn->spi) memcpy(pConn->secret, pRpc->secret, TSDB_PASSWORD_LEN);
     tDebug("%s %p client connection is allocated, uid:0x%x", pRpc->label, pConn, pConn->linkUid);
   }
 
@@ -1534,9 +1532,9 @@ static int rpcAuthenticateMsg(void *pMsg, int msgLen, void *pAuth, void *pKey) {
   int     ret = -1;
 
   tMD5Init(&context);
-  tMD5Update(&context, (uint8_t *)pKey, TSDB_KEY_LEN);
+  tMD5Update(&context, (uint8_t *)pKey, TSDB_PASSWORD_LEN);
   tMD5Update(&context, (uint8_t *)pMsg, msgLen);
-  tMD5Update(&context, (uint8_t *)pKey, TSDB_KEY_LEN);
+  tMD5Update(&context, (uint8_t *)pKey, TSDB_PASSWORD_LEN);
   tMD5Final(&context);
 
   if (memcmp(context.digest, pAuth, sizeof(context.digest)) == 0) ret = 0;
@@ -1548,9 +1546,9 @@ static void rpcBuildAuthHead(void *pMsg, int msgLen, void *pAuth, void *pKey) {
   T_MD5_CTX context;
 
   tMD5Init(&context);
-  tMD5Update(&context, (uint8_t *)pKey, TSDB_KEY_LEN);
+  tMD5Update(&context, (uint8_t *)pKey, TSDB_PASSWORD_LEN);
   tMD5Update(&context, (uint8_t *)pMsg, msgLen);
-  tMD5Update(&context, (uint8_t *)pKey, TSDB_KEY_LEN);
+  tMD5Update(&context, (uint8_t *)pKey, TSDB_PASSWORD_LEN);
   tMD5Final(&context);
 
   memcpy(pAuth, context.digest, sizeof(context.digest));
diff --git a/source/os/src/osSemaphore.c b/source/os/src/osSemaphore.c
index 2385d10285..0d7066b5c8 100644
--- a/source/os/src/osSemaphore.c
+++ b/source/os/src/osSemaphore.c
@@ -42,7 +42,7 @@ bool taosComparePthread(pthread_t first, pthread_t second) { return first.p == s
 
 int32_t taosGetPId() { return GetCurrentProcessId(); }
 
-int32_t taosGetCurrentAPPName(char* name, int32_t* len) {
+int32_t taosGetAppName(char* name, int32_t* len) {
   char filepath[1024] = {0};
 
   GetModuleFileName(NULL, filepath, MAX_PATH);
@@ -358,7 +358,7 @@ bool taosComparePthread(pthread_t first, pthread_t second) { return pthread_equa
 
 int32_t taosGetPId() { return (int32_t)getpid(); }
 
-int32_t taosGetCurrentAPPName(char *name, int32_t *len) {
+int32_t taosGetAppName(char *name, int32_t *len) {
   char buf[PATH_MAX + 1];
   buf[0] = '\0';
   proc_name(getpid(), buf, sizeof(buf) - 1);
@@ -392,7 +392,7 @@ void    taosResetPthread(pthread_t* thread) { *thread = 0; }
 bool    taosComparePthread(pthread_t first, pthread_t second) { return first == second; }
 int32_t taosGetPId() { return getpid(); }
 
-int32_t taosGetCurrentAPPName(char* name, int32_t* len) {
+int32_t taosGetAppName(char* name, int32_t* len) {
   const char* self = "/proc/self/exe";
   char        path[PATH_MAX] = {0};
 
diff --git a/source/os/src/osString.c b/source/os/src/osString.c
index 6063f81682..f714fd0dc4 100644
--- a/source/os/src/osString.c
+++ b/source/os/src/osString.c
@@ -275,13 +275,13 @@ char *strsep(char **stringp, const char *delim) {
 }
 
 char *getpass(const char *prefix) {
-  static char passwd[TSDB_KEY_LEN] = {0};
-  memset(passwd, 0, TSDB_KEY_LEN);
+  static char passwd[TSDB_PASSWORD_LEN] = {0};
+  memset(passwd, 0, TSDB_PASSWORD_LEN);
   //printf("%s", prefix);
 
   int32_t index = 0;
   char    ch;
-  while (index < TSDB_KEY_LEN) {
+  while (index < TSDB_PASSWORD_LEN) {
     ch = getch();
     if (ch == '\n' || ch == '\r') {
       break;
diff --git a/source/os/src/osSysinfo.c b/source/os/src/osSysinfo.c
index ca817c4c1e..f892b4d8c0 100644
--- a/source/os/src/osSysinfo.c
+++ b/source/os/src/osSysinfo.c
@@ -714,7 +714,7 @@ static void taosGetSystemLocale() {  // get and set default locale
     //printf("locale not configured, set to system default:%s", tsLocale);
   }
 
-  /* if user does not specify the charset, extract it from locale */
+  // if user does not specify the charset, extract it from locale
   char *str = strrchr(tsLocale, sep);
   if (str != NULL) {
     str++;
@@ -1118,13 +1118,13 @@ char *taosGetCmdlineByPID(int pid) {
 SysNameInfo taosGetSysNameInfo() {
   SysNameInfo info = {0};
 
-  struct utsname buf;
-  if (!uname(&buf)) {
-    info.sysname = buf.sysname;
-    info.sysname == buf.nodename;
-    info.sysname = buf.release;
-    info.sysname = buf.version;
-    info.sysname = buf.machine;
+  struct utsname uts;
+  if (!uname(&uts)) {
+    info.sysname = strdup(uts.sysname);
+    info.nodename = strdup(uts.nodename);
+    info.release = strdup(uts.release);
+    info.version = strdup(uts.version);
+    info.machine = strdup(uts.machine);
   }
 
   return info;
diff --git a/source/util/src/tconfig.c b/source/util/src/tconfig.c
index 8a6f389366..726247d450 100644
--- a/source/util/src/tconfig.c
+++ b/source/util/src/tconfig.c
@@ -282,7 +282,7 @@ static void taosReadConfigOption(const char *option, char *value, char *value2,
   }
 }
 
-void taosInitConfigOption(SGlobalCfg cfg) {
+void taosAddConfigOption(SGlobalCfg cfg) {
   tsGlobalConfig[tsGlobalConfigNum++] = cfg;
 }
 
@@ -335,7 +335,7 @@ void taosReadGlobalLogCfg() {
   fclose(fp);
 }
 
-int32_t taosReadGlobalCfg() {
+int32_t taosReadCfgFromFile() {
   char * line, *option, *value, *value2, *value3;
   int    olen, vlen, vlen2, vlen3;
   char   fileName[PATH_MAX] = {0};
@@ -396,7 +396,7 @@ int32_t taosReadGlobalCfg() {
   return 0;
 }
 
-void taosPrintGlobalCfg() {
+void taosPrintCfg() {
   uInfo("   taos config & system info:");
   uInfo("==================================");
 
@@ -443,7 +443,6 @@ void taosPrintGlobalCfg() {
   }
 
   taosPrintOsInfo();
-  // taosPrintDataDirCfg();
   uInfo("==================================");
 }
 
diff --git a/source/util/src/terror.c b/source/util/src/terror.c
index ceb344ffe8..70a3dc622f 100644
--- a/source/util/src/terror.c
+++ b/source/util/src/terror.c
@@ -127,8 +127,10 @@ TAOS_DEFINE_ERROR(TSDB_CODE_TSC_DUP_TAG_NAMES,            "duplicated tag names"
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_JSON,             "Invalid JSON format")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_JSON_TYPE,        "Invalid JSON data type")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_VALUE_OUT_OF_RANGE,       "Value out of range")
+TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_INPUT,            "Invalid tsc input")
 
-// mnode
+// mnode-common
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_NOT_READY,                "Cluster not ready")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_MSG_NOT_PROCESSED,        "Message not processed")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_ACTION_IN_PROGRESS,       "Message is progressing")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_ACTION_NEED_REPROCESSED,  "Message need to be reprocessed")
@@ -139,7 +141,11 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_MSG_VERSION,      "Incompatible protocol
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_MSG_LEN,          "Invalid message length")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_MSG_TYPE,         "Invalid message type")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_SHELL_CONNS,     "Too many connections")
+
+// mnode-show
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_SHOWOBJ,          "Data expired")
+
+// mnode-profile
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_QUERY_ID,         "Invalid query id")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_STREAM_ID,        "Invalid stream id")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_CONN_ID,          "Invalid connection id")
@@ -149,6 +155,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_FAILED_TO_START_SYNC,     "failed to start sync"
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_FAILED_TO_CREATE_DIR,     "failed to create mnode dir")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_FAILED_TO_INIT_STEP,      "failed to init components")
 
+// mnode-sdb
 TAOS_DEFINE_ERROR(TSDB_CODE_SDB_APP_ERROR,                "Unexpected generic error in sdb")
 TAOS_DEFINE_ERROR(TSDB_CODE_SDB_OBJ_ALREADY_THERE,        "Object already there")
 TAOS_DEFINE_ERROR(TSDB_CODE_SDB_OBJ_NOT_THERE,            "Object not there")
@@ -163,36 +170,50 @@ TAOS_DEFINE_ERROR(TSDB_CODE_SDB_INVALID_DATA_LEN,         "Invalid raw data len"
 TAOS_DEFINE_ERROR(TSDB_CODE_SDB_INVALID_DATA_CONTENT,     "Invalid raw data content")
 
 // mnode-dnode
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_DNODE_ALREADY_EXIST,      "DNode already exists")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_DNODE_NOT_EXIST,          "DNode does not exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_NO_ENOUGH_DNODES,         "Out of DNodes")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_DNODE_ALREADY_EXIST,      "Dnode already exists")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_DNODE_NOT_EXIST,          "Dnode does not exist")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_DNODES,          "Too many dnodes")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_NO_ENOUGH_DNODES,         "Out of dnodes")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_CLUSTER_CFG,      "Cluster cfg inconsistent")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_CLUSTER_ID,       "Cluster id not match")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DNODE_CFG,        "Invalid dnode cfg")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DNODE_EP,         "Invalid dnode end point")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DNODE_ID,         "Invalid dnode id")
 
-// mnode-vgroup
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_VGROUP_NOT_EXIST,         "VGroup does not exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_VGROUP_NOT_IN_DNODE,      "Vgroup not in dnode")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_VGROUP_ALREADY_IN_DNODE,  "Vgroup already in dnode")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_NOT_READY,                "Cluster not ready")
+// mnode-mnode
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_MNODE_ALREADY_EXIST,      "Mnode already exists")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_MNODE_NOT_EXIST,          "Mnode not there")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_MNODES,          "Too many mnodes")
 
 // mnode-acct
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_ACCT_ALREADY_EXIST,       "Account already exists")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_ACCT_NOT_EXIST,           "Invalid account")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_ACCTS,           "Too many accounts")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_ACCT_OPTION,      "Invalid account options")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_ACCT_EXPIRED,             "Account authorization has expired")
 
+// mnode-user
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_USER_ALREADY_EXIST,       "User already exists")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_USER_NOT_EXIST,           "Invalid user")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_USERS,           "Too many users")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_USER_FORMAT,      "Invalid user format")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_PASS_FORMAT,      "Invalid password format")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_NO_USER_FROM_CONN,        "Can not get user from conn")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_USERS,           "Too many users")
 
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_MNODE_ALREADY_EXIST,       "Mnode already exists")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_MNODE_NOT_EXIST,           "Mnode not there")
+// mnode-db
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_ALREADY_EXIST,         "Database already exists")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_NOT_EXIST,             "Database not exist")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_DATABASES,       "Too many databases for account")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_NOT_SELECTED,          "Database not specified or available")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB,               "Invalid database name")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_OPTION,        "Invalid database options")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_ACCT,          "Invalid database account")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_OPTION_UNCHANGED,      "Database options not changed")
+
+// mnode-vgroup
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_VGROUP_ALREADY_IN_DNODE,  "Vgroup already in dnode")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_VGROUP_NOT_IN_DNODE,      "Vgroup not in dnode")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_VGROUP_NOT_EXIST,         "VGroup does not exist")
 
 // mnode-stable
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_STB_ALREADY_EXIST,        "Stable already exists")
@@ -202,7 +223,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TABLE_TYPE,       "Invalid table type in
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_TAGS,            "Too many tags")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_COLUMNS,         "Too many columns")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_TIMESERIES,      "Too many time series")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_NOT_SUPER_TABLE,          "Not super table")           // operation only available for super table
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_NOT_SUPER_TABLE,          "Not super table")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_COL_NAME_TOO_LONG,        "Tag name too long")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_TAG_ALREAY_EXIST,         "Tag already exists")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_TAG_NOT_EXIST,            "Tag does not exist")
@@ -223,31 +244,6 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC_BUFSIZE,     "Invalid func bufSize"
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TAG_LENGTH,        "invalid tag length")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_COLUMN_LENGTH,     "invalid column length")
 
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_NOT_SELECTED,          "Database not specified or available")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_NOT_EXIST,             "Database not exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_ALREADY_EXIST,         "Database already exists")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB,               "Invalid database name")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_OPTION,        "Invalid database options")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_CACHE_SIZE,    "Invalid database cache block size option")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_TOTAL_BLOCKS,  "Invalid database total blocks option")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_DAYS,          "Invalid database days option")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_KEEP0,         "Invalid database keep0 option")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_KEEP1,         "Invalid database keep1 option")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_KEEP2,         "Invalid database keep2 option")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_MIN_ROWS,      "Invalid database min rows option")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_MAX_ROWS,      "Invalid database max rows option")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_COMMIT_TIME,   "Invalid database commit time option")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_FSYNC_PERIOD,  "Invalid database fsync periodoptions")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_WAL_LEVEL,     "Invalid database wal level option")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_PRECISION,     "Invalid database precisin option")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_COMP,          "Invalid database compression option")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_REPLICA,       "Invalid database replication option")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_QUORUM,        "Invalid database quorum option")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_UPDATE,        "Invalid database update option")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_CACHE_LAST,    "Invalid database cache last option")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_OPTION_UNCHANGED,      "Database options not changed")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_DATABASES,       "Too many databases for account")
-
 // dnode
 TAOS_DEFINE_ERROR(TSDB_CODE_DND_ACTION_IN_PROGRESS,       "Action in progress")
 TAOS_DEFINE_ERROR(TSDB_CODE_DND_EXITING,                  "Dnode is exiting")
@@ -497,6 +493,15 @@ TAOS_DEFINE_ERROR(TSDB_CODE_FS_FILE_ALREADY_EXISTS,       "tfs file already exis
 TAOS_DEFINE_ERROR(TSDB_CODE_FS_INVLD_LEVEL,               "tfs invalid level")
 TAOS_DEFINE_ERROR(TSDB_CODE_FS_NO_VALID_DISK,             "tfs no valid disk")
 
+// catalog
+TAOS_DEFINE_ERROR(TSDB_CODE_CTG_INTERNAL_ERROR,           "catalog interval error")
+TAOS_DEFINE_ERROR(TSDB_CODE_CTG_INVALID_INPUT,            "invalid catalog input parameters")
+TAOS_DEFINE_ERROR(TSDB_CODE_CTG_NOT_READY,                "catalog is not ready")
+TAOS_DEFINE_ERROR(TSDB_CODE_CTG_MEM_ERROR,                "catalog memory error")
+TAOS_DEFINE_ERROR(TSDB_CODE_CTG_SYS_ERROR,                "catalog system error")
+
+
+
 #ifdef TAOS_ERROR_C
 };
 #endif
@@ -545,4 +550,4 @@ const char* tstrerror(int32_t err) {
   return "";
 }
 
-const char* terrstr() { return tstrerror(terrno); }
\ No newline at end of file
+const char* terrstr() { return tstrerror(terrno); }
diff --git a/source/util/src/tlog.c b/source/util/src/tlog.c
index e6cc3a53af..2d7179c0d3 100644
--- a/source/util/src/tlog.c
+++ b/source/util/src/tlog.c
@@ -99,6 +99,8 @@ int32_t wDebugFlag = 135;
 int32_t tsdbDebugFlag = 131;
 int32_t cqDebugFlag = 131;
 int32_t fsDebugFlag = 135;
+int32_t ctgDebugFlag = 131;
+
 
 int64_t dbgEmptyW = 0;
 int64_t dbgWN = 0;
@@ -112,7 +114,7 @@ static int32_t   taosPushLogBuffer(SLogBuff *tLogBuff, char *msg, int32_t msgLen
 static SLogBuff *taosLogBuffNew(int32_t bufSize);
 static void      taosCloseLogByFd(int32_t oldFd);
 static int32_t   taosOpenLogFile(char *fn, int32_t maxLines, int32_t maxFileNum);
-extern void      taosPrintGlobalCfg();
+extern void      taosPrintCfg();
 static int32_t   taosCompressFile(char *srcFileName, char *destFileName);
 
 static int32_t taosStartLog() {
@@ -222,7 +224,7 @@ static void *taosThreadToOpenNewFile(void *param) {
   
   uInfo("   new log file:%d is opened", tsLogObj.flag);
   uInfo("==================================");
-  taosPrintGlobalCfg();
+  taosPrintCfg();
   taosKeepOldLog(keepName);
 
   return NULL;
diff --git a/source/util/src/tnote.c b/source/util/src/tnote.c
index 5606ab248d..d9356b7e40 100644
--- a/source/util/src/tnote.c
+++ b/source/util/src/tnote.c
@@ -49,15 +49,6 @@ int32_t taosInitNotes() {
     taosInitNote(tsNumOfLogLines, 1, &tsTscNote, name);
   }
 
-  if (tsHttpEnableRecordSql) {
-    snprintf(name, TSDB_FILENAME_LEN * 2, "%s/httpsql", tsLogDir);
-    taosInitNote(tsNumOfLogLines, 1, &tsHttpNote, name);
-  }
-
-  if (tscEmbedded == 1) {
-    snprintf(name, TSDB_FILENAME_LEN * 2, "%s/taosinfo", tsLogDir);
-    taosInitNote(tsNumOfLogLines, 1, &tsInfoNote, name);
-  }
 #endif
   return 0;
 }
diff --git a/source/util/src/ttimer.c b/source/util/src/ttimer.c
index 56186d9b24..1fdc2257d7 100644
--- a/source/util/src/ttimer.c
+++ b/source/util/src/ttimer.c
@@ -20,12 +20,10 @@
 #include "tutil.h"
 #include "taoserror.h"
 
-extern int8_t tscEmbedded;
-
-#define tmrFatal(...) { if (tmrDebugFlag & DEBUG_FATAL) { taosPrintLog("TMR FATAL ", tscEmbedded ? 255 : tmrDebugFlag, __VA_ARGS__); }}
-#define tmrError(...) { if (tmrDebugFlag & DEBUG_ERROR) { taosPrintLog("TMR ERROR ", tscEmbedded ? 255 : tmrDebugFlag, __VA_ARGS__); }}
-#define tmrWarn(...)  { if (tmrDebugFlag & DEBUG_WARN)  { taosPrintLog("TMR WARN ", tscEmbedded ? 255 : tmrDebugFlag, __VA_ARGS__); }}
-#define tmrInfo(...)  { if (tmrDebugFlag & DEBUG_INFO)  { taosPrintLog("TMR ", tscEmbedded ? 255 : tmrDebugFlag, __VA_ARGS__); }}
+#define tmrFatal(...) { if (tmrDebugFlag & DEBUG_FATAL) { taosPrintLog("TMR FATAL ", tmrDebugFlag, __VA_ARGS__); }}
+#define tmrError(...) { if (tmrDebugFlag & DEBUG_ERROR) { taosPrintLog("TMR ERROR ", tmrDebugFlag, __VA_ARGS__); }}
+#define tmrWarn(...)  { if (tmrDebugFlag & DEBUG_WARN)  { taosPrintLog("TMR WARN ", tmrDebugFlag, __VA_ARGS__); }}
+#define tmrInfo(...)  { if (tmrDebugFlag & DEBUG_INFO)  { taosPrintLog("TMR ", tmrDebugFlag, __VA_ARGS__); }}
 #define tmrDebug(...) { if (tmrDebugFlag & DEBUG_DEBUG) { taosPrintLog("TMR ", tmrDebugFlag, __VA_ARGS__); }}
 #define tmrTrace(...) { if (tmrDebugFlag & DEBUG_TRACE) { taosPrintLog("TMR ", tmrDebugFlag, __VA_ARGS__); }}
 
diff --git a/source/util/src/tutil.c b/source/util/src/tutil.c
index e8a5cdd301..58a2e57f7c 100644
--- a/source/util/src/tutil.c
+++ b/source/util/src/tutil.c
@@ -417,16 +417,3 @@ void taosIp2String(uint32_t ip, char *str) {
 void taosIpPort2String(uint32_t ip, uint16_t port, char *str) {
   sprintf(str, "%u.%u.%u.%u:%u", ip & 0xFF, (ip >> 8) & 0xFF, (ip >> 16) & 0xFF, (uint8_t)(ip >> 24), port);
 }
-
-int32_t taosGetFqdnPortFromEp(const char *ep, char *fqdn, uint16_t *port) {
-  *port = 0;
-  strcpy(fqdn, ep);
-
-  char *temp = strchr(fqdn, ':');
-  if (temp) {
-    *temp = 0;
-    *port = atoi(temp + 1);
-  }
-
-  return 0;
-}
\ No newline at end of file
diff --git a/src/inc/tcq.h b/src/inc/tcq.h
index 7338cccfee..71efe33011 100644
--- a/src/inc/tcq.h
+++ b/src/inc/tcq.h
@@ -26,7 +26,7 @@ typedef int32_t (*FCqWrite)(int32_t vgId, void *pHead, int32_t qtype, void *pMsg
 typedef struct {
   int32_t  vgId;
   char     user[TSDB_USER_LEN];
-  char     pass[TSDB_KEY_LEN];
+  char     pass[TSDB_PASSWORD_LEN];
   char     db[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN]; // size must same with SVnodeObj.db[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN]
   FCqWrite cqWrite;
 } SCqCfg;
@@ -37,7 +37,7 @@ typedef struct {
   int32_t  master;
   int32_t  num;      // number of continuous streams
   char     user[TSDB_USER_LEN];
-  char     pass[TSDB_KEY_LEN];
+  char     pass[TSDB_PASSWORD_LEN];
   char     db[TSDB_DB_NAME_LEN];
   FCqWrite cqWrite;
   struct SCqObj *pHead;
diff --git a/src/tsdb/inc/tsdbMemTable.h b/src/tsdb/inc/tsdbMemTable.h
deleted file mode 100644
index 67e9976c70..0000000000
--- a/src/tsdb/inc/tsdbMemTable.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _TD_TSDB_MEMTABLE_H_
-#define _TD_TSDB_MEMTABLE_H_
-
-typedef struct {
-  int   rowsInserted;
-  int   rowsUpdated;
-  int   rowsDeleteSucceed;
-  int   rowsDeleteFailed;
-  int   nOperations;
-  TSKEY keyFirst;
-  TSKEY keyLast;
-} SMergeInfo;
-
-typedef struct {
-  STable *           pTable;
-  SSkipListIterator *pIter;
-} SCommitIter;
-
-struct STableData {
-  uint64_t   uid;
-  TSKEY      keyFirst;
-  TSKEY      keyLast;
-  int64_t    numOfRows;
-  SSkipList* pData;
-  T_REF_DECLARE()
-};
-
-enum { TSDB_UPDATE_META, TSDB_DROP_META };
-
-#ifdef WINDOWS
-#pragma pack(push ,1) 
-typedef struct {
-#else
-typedef struct __attribute__((packed)){
-#endif
-  char     act;
-  uint64_t uid;
-} SActObj;
-#ifdef WINDOWS
-#pragma pack(pop) 
-#endif
-
-typedef struct {
-  int  len;
-  char cont[];
-} SActCont;
-
-int   tsdbRefMemTable(STsdbRepo* pRepo, SMemTable* pMemTable);
-int   tsdbUnRefMemTable(STsdbRepo* pRepo, SMemTable* pMemTable);
-int   tsdbTakeMemSnapshot(STsdbRepo* pRepo, SMemSnapshot* pSnapshot, SArray* pATable);
-void  tsdbUnTakeMemSnapShot(STsdbRepo* pRepo, SMemSnapshot* pSnapshot);
-void* tsdbAllocBytes(STsdbRepo* pRepo, int bytes);
-int   tsdbAsyncCommit(STsdbRepo* pRepo);
-int   tsdbSyncCommitConfig(STsdbRepo* pRepo);
-int   tsdbLoadDataFromCache(STable* pTable, SSkipListIterator* pIter, TSKEY maxKey, int maxRowsToRead, SDataCols* pCols,
-                            TKEY* filterKeys, int nFilterKeys, bool keepDup, SMergeInfo* pMergeInfo);
-void* tsdbCommitData(STsdbRepo* pRepo);
-
-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);
-}
-
-static FORCE_INLINE TKEY tsdbNextIterTKey(SSkipListIterator* pIter) {
-  SMemRow row = tsdbNextIterRow(pIter);
-  if (row == NULL) return TKEY_NULL;
-
-  return memRowTKey(row);
-}
-
-#endif /* _TD_TSDB_MEMTABLE_H_ */
\ No newline at end of file
diff --git a/src/tsdb/src/tsdbBuffer.c b/src/tsdb/src/tsdbBuffer.c
deleted file mode 100644
index 70589031f6..0000000000
--- a/src/tsdb/src/tsdbBuffer.c
+++ /dev/null
@@ -1,214 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "tsdbint.h"
-#include "tsdbHealth.h"
-
-#define POOL_IS_EMPTY(b) (listNEles((b)->bufBlockList) == 0)
-
-// ---------------- INTERNAL FUNCTIONS ----------------
-STsdbBufPool *tsdbNewBufPool() {
-  STsdbBufPool *pBufPool = (STsdbBufPool *)calloc(1, sizeof(*pBufPool));
-  if (pBufPool == NULL) {
-    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-    goto _err;
-  }
-
-  int code = pthread_cond_init(&(pBufPool->poolNotEmpty), NULL);
-  if (code != 0) {
-    terrno = TAOS_SYSTEM_ERROR(code);
-    goto _err;
-  }
-
-  pBufPool->bufBlockList = tdListNew(sizeof(STsdbBufBlock *));
-  if (pBufPool->bufBlockList == NULL) {
-    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-    goto _err;
-  }
-
-  return pBufPool;
-
-_err:
-  tsdbFreeBufPool(pBufPool);
-  return NULL;
-}
-
-void tsdbFreeBufPool(STsdbBufPool *pBufPool) {
-  if (pBufPool) {
-    if (pBufPool->bufBlockList) {
-      ASSERT(listNEles(pBufPool->bufBlockList) == 0);
-      tdListFree(pBufPool->bufBlockList);
-    }
-
-    pthread_cond_destroy(&pBufPool->poolNotEmpty);
-
-    free(pBufPool);
-  }
-}
-
-int tsdbOpenBufPool(STsdbRepo *pRepo) {
-  STsdbCfg *    pCfg = &(pRepo->config);
-  STsdbBufPool *pPool = pRepo->pPool;
-
-  ASSERT(pPool != NULL);
-  pPool->bufBlockSize = pCfg->cacheBlockSize * 1024 * 1024; // MB
-  pPool->tBufBlocks = pCfg->totalBlocks;
-  pPool->nBufBlocks = 0;
-  pPool->nElasticBlocks = 0;
-  pPool->index = 0;
-  pPool->nRecycleBlocks = 0;
-
-  for (int i = 0; i < pCfg->totalBlocks; i++) {
-    STsdbBufBlock *pBufBlock = tsdbNewBufBlock(pPool->bufBlockSize);
-    if (pBufBlock == NULL) goto _err;
-
-    if (tdListAppend(pPool->bufBlockList, (void *)(&pBufBlock)) < 0) {
-      tsdbFreeBufBlock(pBufBlock);
-      terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-      goto _err;
-    }
-
-    pPool->nBufBlocks++;
-  }
-
-  tsdbDebug("vgId:%d buffer pool is opened! bufBlockSize:%d tBufBlocks:%d nBufBlocks:%d", REPO_ID(pRepo),
-            pPool->bufBlockSize, pPool->tBufBlocks, pPool->nBufBlocks);
-
-  return 0;
-
-_err:
-  tsdbCloseBufPool(pRepo);
-  return -1;
-}
-
-void tsdbCloseBufPool(STsdbRepo *pRepo) {
-  if (pRepo == NULL) return;
-
-  STsdbBufPool * pBufPool = pRepo->pPool;
-  STsdbBufBlock *pBufBlock = NULL;
-
-  if (pBufPool) {
-    SListNode *pNode = NULL;
-    while ((pNode = tdListPopHead(pBufPool->bufBlockList)) != NULL) {
-      tdListNodeGetData(pBufPool->bufBlockList, pNode, (void *)(&pBufBlock));
-      tsdbFreeBufBlock(pBufBlock);
-      free(pNode);
-    }
-  }
-
-  tsdbDebug("vgId:%d, buffer pool is closed", REPO_ID(pRepo));
-}
-
-SListNode *tsdbAllocBufBlockFromPool(STsdbRepo *pRepo) {
-  ASSERT(pRepo != NULL && pRepo->pPool != NULL);
-  ASSERT(IS_REPO_LOCKED(pRepo));
-
-  STsdbBufPool *pBufPool = pRepo->pPool;
-
-  while (POOL_IS_EMPTY(pBufPool)) {
-    if(tsDeadLockKillQuery) {
-      // supply new Block 
-      if(tsdbInsertNewBlock(pRepo) > 0) {
-        tsdbWarn("vgId:%d add new elastic block . elasticBlocks=%d cur free Blocks=%d", REPO_ID(pRepo), pBufPool->nElasticBlocks, pBufPool->bufBlockList->numOfEles);
-        break;
-      } else {
-        // no newBlock, kill query free
-        if(!tsdbUrgeQueryFree(pRepo))
-          tsdbWarn("vgId:%d Urge query free thread start failed.", REPO_ID(pRepo));
-      }
-    }
-
-    pRepo->repoLocked = false;
-    pthread_cond_wait(&(pBufPool->poolNotEmpty), &(pRepo->mutex));
-    pRepo->repoLocked = true;
-  }
-
-  SListNode *    pNode = tdListPopHead(pBufPool->bufBlockList);
-  ASSERT(pNode != NULL);
-  STsdbBufBlock *pBufBlock = NULL;
-  tdListNodeGetData(pBufPool->bufBlockList, pNode, (void *)(&pBufBlock));
-
-  pBufBlock->blockId = pBufPool->index++;
-  pBufBlock->offset = 0;
-  pBufBlock->remain = pBufPool->bufBlockSize;
-
-  tsdbDebug("vgId:%d, buffer block is allocated, blockId:%" PRId64, REPO_ID(pRepo), pBufBlock->blockId);
-  return pNode;
-}
-
-// ---------------- LOCAL FUNCTIONS ----------------
-STsdbBufBlock *tsdbNewBufBlock(int bufBlockSize) {
-  STsdbBufBlock *pBufBlock = (STsdbBufBlock *)malloc(sizeof(*pBufBlock) + bufBlockSize);
-  if (pBufBlock == NULL) {
-    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-    return NULL;
-  }
-
-  pBufBlock->blockId = 0;
-  pBufBlock->offset = 0;
-  pBufBlock->remain = bufBlockSize;
-
-  return pBufBlock;
-}
-
- void tsdbFreeBufBlock(STsdbBufBlock *pBufBlock) { tfree(pBufBlock); }
-
-int tsdbExpandPool(STsdbRepo* pRepo, int32_t oldTotalBlocks) {
-  if (oldTotalBlocks == pRepo->config.totalBlocks) {
-    return TSDB_CODE_SUCCESS;
-  }
-
-  int err = TSDB_CODE_SUCCESS;
-
-  if (tsdbLockRepo(pRepo) < 0) return terrno;
-  STsdbBufPool* pPool = pRepo->pPool;
-
-  if (pRepo->config.totalBlocks > oldTotalBlocks) {
-    for (int i = 0; i < pRepo->config.totalBlocks - oldTotalBlocks; i++) {
-      STsdbBufBlock *pBufBlock = tsdbNewBufBlock(pPool->bufBlockSize);
-      if (pBufBlock == NULL) goto err;
-
-      if (tdListAppend(pPool->bufBlockList, (void *)(&pBufBlock)) < 0) {
-        tsdbFreeBufBlock(pBufBlock);
-        terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-        err = TSDB_CODE_TDB_OUT_OF_MEMORY;
-        goto err;
-      }
-
-      pPool->nBufBlocks++;      
-    }
-    pthread_cond_signal(&pPool->poolNotEmpty);
-  } else {
-    pPool->nRecycleBlocks = oldTotalBlocks - pRepo->config.totalBlocks;
-  } 
-
-err:
-  tsdbUnlockRepo(pRepo);
-  return err;
-}
-
-void tsdbRecycleBufferBlock(STsdbBufPool* pPool, SListNode *pNode, bool bELastic) {
-  STsdbBufBlock *pBufBlock = NULL;
-  tdListNodeGetData(pPool->bufBlockList, pNode, (void *)(&pBufBlock));
-  tsdbFreeBufBlock(pBufBlock);
-  free(pNode);
-  if(bELastic)
-  {
-    pPool->nElasticBlocks--;
-    tsdbWarn("pPool=%p elastic block reduce one . nElasticBlocks=%d cur free Blocks=%d", pPool, pPool->nElasticBlocks, pPool->bufBlockList->numOfEles);
-  }
-  else
-    pPool->nBufBlocks--;
-}
\ No newline at end of file
diff --git a/src/tsdb/src/tsdbCommitQueue.c b/src/tsdb/src/tsdbCommitQueue.c
deleted file mode 100644
index 59fb4f334d..0000000000
--- a/src/tsdb/src/tsdbCommitQueue.c
+++ /dev/null
@@ -1,213 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "tsdbint.h"
-
-typedef struct {
-  bool            stop;
-  pthread_mutex_t lock;
-  pthread_cond_t  queueNotEmpty;
-  int             nthreads;
-  int             refCount;
-  SList *         queue;
-  pthread_t *     threads;
-} SCommitQueue;
-
-typedef struct {
-  TSDB_REQ_T req;
-  STsdbRepo *pRepo;
-} SReq;
-
-static void *tsdbLoopCommit(void *arg);
-
-static SCommitQueue tsCommitQueue = {0};
-
-int tsdbInitCommitQueue() {
-  int nthreads = tsNumOfCommitThreads;
-  SCommitQueue *pQueue = &tsCommitQueue;
-
-  if (nthreads < 1) nthreads = 1;
-
-  pQueue->stop = false;
-  pQueue->nthreads = nthreads;
-
-  pQueue->queue = tdListNew(0);
-  if (pQueue->queue == NULL) {
-    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  pQueue->threads = (pthread_t *)calloc(nthreads, sizeof(pthread_t));
-  if (pQueue->threads == NULL) {
-    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-    tdListFree(pQueue->queue);
-    return -1;
-  }
-
-  pthread_mutex_init(&(pQueue->lock), NULL);
-  pthread_cond_init(&(pQueue->queueNotEmpty), NULL);
-
-  for (int i = 0; i < nthreads; i++) {
-    pthread_create(pQueue->threads + i, NULL, tsdbLoopCommit, NULL);
-  }
-
-  return 0;
-}
-
-void tsdbDestroyCommitQueue() {
-  SCommitQueue *pQueue = &tsCommitQueue;
-
-  pthread_mutex_lock(&(pQueue->lock));
-
-  if (pQueue->stop) {
-    pthread_mutex_unlock(&(pQueue->lock));
-    return;
-  }
-
-  pQueue->stop = true;
-  pthread_cond_broadcast(&(pQueue->queueNotEmpty));
-
-  pthread_mutex_unlock(&(pQueue->lock));
-
-  for (size_t i = 0; i < pQueue->nthreads; i++) {
-    pthread_join(pQueue->threads[i], NULL);
-  }
-
-  free(pQueue->threads);
-  tdListFree(pQueue->queue);
-  pthread_cond_destroy(&(pQueue->queueNotEmpty));
-  pthread_mutex_destroy(&(pQueue->lock));
-}
-
-int tsdbScheduleCommit(STsdbRepo *pRepo, TSDB_REQ_T req) {
-  SCommitQueue *pQueue = &tsCommitQueue;
-
-  SListNode *pNode = (SListNode *)calloc(1, sizeof(SListNode) + sizeof(SReq));
-  if (pNode == NULL) {
-    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  ((SReq *)pNode->data)->req = req;
-  ((SReq *)pNode->data)->pRepo = pRepo;
-
-  pthread_mutex_lock(&(pQueue->lock));
-
-  // ASSERT(pQueue->stop);
-
-  tdListAppendNode(pQueue->queue, pNode);
-  pthread_cond_signal(&(pQueue->queueNotEmpty));
-
-  pthread_mutex_unlock(&(pQueue->lock));
-  return 0;
-}
-
-static void tsdbApplyRepoConfig(STsdbRepo *pRepo) {
-  pthread_mutex_lock(&pRepo->save_mutex);
-
-  pRepo->config_changed = false;
-  STsdbCfg * pSaveCfg = &pRepo->save_config;
-  STsdbCfg oldCfg;
-  int32_t oldTotalBlocks = pRepo->config.totalBlocks;
-
-  memcpy(&oldCfg, &(pRepo->config), sizeof(STsdbCfg));
-
-  pRepo->config.compression = pRepo->save_config.compression;
-  pRepo->config.keep = pRepo->save_config.keep;
-  pRepo->config.keep1 = pRepo->save_config.keep1;
-  pRepo->config.keep2 = pRepo->save_config.keep2;
-  pRepo->config.cacheLastRow = pRepo->save_config.cacheLastRow;
-  pRepo->config.totalBlocks = pRepo->save_config.totalBlocks;
-
-  pthread_mutex_unlock(&pRepo->save_mutex);
-
-  tsdbInfo("vgId:%d apply new config: compression(%d), keep(%d,%d,%d), totalBlocks(%d), cacheLastRow(%d->%d),totalBlocks(%d->%d)",
-    REPO_ID(pRepo),
-    pSaveCfg->compression, pSaveCfg->keep,pSaveCfg->keep1, pSaveCfg->keep2,
-    pSaveCfg->totalBlocks, oldCfg.cacheLastRow, pSaveCfg->cacheLastRow, oldTotalBlocks, pSaveCfg->totalBlocks);
-
-  int err = tsdbExpandPool(pRepo, oldTotalBlocks);
-  if (!TAOS_SUCCEEDED(err)) {
-    tsdbError("vgId:%d expand pool from %d to %d fail,reason:%s",
-      REPO_ID(pRepo), oldTotalBlocks, pSaveCfg->totalBlocks, tstrerror(err));
-  }
-
-  if (oldCfg.cacheLastRow != pRepo->config.cacheLastRow) {
-    if (tsdbLockRepo(pRepo) < 0) return;
-    tsdbCacheLastData(pRepo, &oldCfg);
-    tsdbUnlockRepo(pRepo);
-  }
-
-}
-
-static void *tsdbLoopCommit(void *arg) {
-  SCommitQueue *pQueue = &tsCommitQueue;
-  SListNode *   pNode = NULL;
-  STsdbRepo *   pRepo = NULL;
-  TSDB_REQ_T    req;
-
-  setThreadName("tsdbCommit");
-
-  while (true) {
-    pthread_mutex_lock(&(pQueue->lock));
-
-    while (true) {
-      pNode = tdListPopHead(pQueue->queue);
-      if (pNode == NULL) {
-        if (pQueue->stop && pQueue->refCount <= 0) {
-          pthread_mutex_unlock(&(pQueue->lock));
-          goto _exit;
-        } else {
-          pthread_cond_wait(&(pQueue->queueNotEmpty), &(pQueue->lock));
-        }
-      } else {
-        break;
-      }
-    }
-
-    pthread_mutex_unlock(&(pQueue->lock));
-
-    req = ((SReq *)pNode->data)->req;
-    pRepo = ((SReq *)pNode->data)->pRepo;
-
-    if (req == COMMIT_REQ) {
-      tsdbCommitData(pRepo);
-    } else if (req == COMPACT_REQ) {
-      tsdbCompactImpl(pRepo);
-    } else if (req == COMMIT_CONFIG_REQ) {        
-      ASSERT(pRepo->config_changed);
-      tsdbApplyRepoConfig(pRepo);
-      tsem_post(&(pRepo->readyToCommit));
-    } else {
-      ASSERT(0);
-    }
-
-    listNodeFree(pNode);
-  }
-
-_exit:
-  return NULL;
-}
-
-void tsdbIncCommitRef(int vgId) {
-  int refCount = atomic_add_fetch_32(&tsCommitQueue.refCount, 1);
-  tsdbDebug("vgId:%d, inc commit queue ref to %d", vgId, refCount);
-}
-
-void tsdbDecCommitRef(int vgId) {
-  int refCount = atomic_sub_fetch_32(&tsCommitQueue.refCount, 1);
-  pthread_cond_broadcast(&(tsCommitQueue.queueNotEmpty));
-  tsdbDebug("vgId:%d, dec commit queue ref to %d", vgId, refCount);
-}
diff --git a/src/tsdb/src/tsdbMemTable.c b/src/tsdb/src/tsdbMemTable.c
deleted file mode 100644
index 3890dca5b9..0000000000
--- a/src/tsdb/src/tsdbMemTable.c
+++ /dev/null
@@ -1,1067 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "tdataformat.h"
-#include "tfunctional.h"
-#include "tsdbint.h"
-#include "tskiplist.h"
-#include "tsdbRowMergeBuf.h"
-
-#define TSDB_DATA_SKIPLIST_LEVEL 5
-#define TSDB_MAX_INSERT_BATCH 512
-
-typedef struct {
-  int32_t  totalLen;
-  int32_t  len;
-  SMemRow  row;
-} SSubmitBlkIter;
-
-typedef struct {
-  int32_t totalLen;
-  int32_t len;
-  void *  pMsg;
-} SSubmitMsgIter;
-
-static SMemTable *  tsdbNewMemTable(STsdbRepo *pRepo);
-static void         tsdbFreeMemTable(SMemTable *pMemTable);
-static STableData*  tsdbNewTableData(STsdbCfg *pCfg, STable *pTable);
-static void         tsdbFreeTableData(STableData *pTableData);
-static char *       tsdbGetTsTupleKey(const void *data);
-static int          tsdbAdjustMemMaxTables(SMemTable *pMemTable, int maxTables);
-static int          tsdbAppendTableRowToCols(STable *pTable, SDataCols *pCols, STSchema **ppSchema, SMemRow row);
-static int          tsdbInitSubmitBlkIter(SSubmitBlk *pBlock, SSubmitBlkIter *pIter);
-static SMemRow      tsdbGetSubmitBlkNext(SSubmitBlkIter *pIter);
-static int          tsdbScanAndConvertSubmitMsg(STsdbRepo *pRepo, SSubmitMsg *pMsg);
-static int          tsdbInsertDataToTable(STsdbRepo *pRepo, SSubmitBlk *pBlock, int32_t *affectedrows);
-static int          tsdbInitSubmitMsgIter(SSubmitMsg *pMsg, SSubmitMsgIter *pIter);
-static int          tsdbGetSubmitMsgNext(SSubmitMsgIter *pIter, SSubmitBlk **pPBlock);
-static int          tsdbCheckTableSchema(STsdbRepo *pRepo, SSubmitBlk *pBlock, STable *pTable);
-static int          tsdbUpdateTableLatestInfo(STsdbRepo *pRepo, STable *pTable, SMemRow row);
-
-static FORCE_INLINE int tsdbCheckRowRange(STsdbRepo *pRepo, STable *pTable, SMemRow row, TSKEY minKey, TSKEY maxKey,
-                                          TSKEY now);
-
-int32_t tsdbInsertData(STsdbRepo *repo, SSubmitMsg *pMsg, SShellSubmitRspMsg *pRsp) {
-  STsdbRepo *    pRepo = repo;
-  SSubmitMsgIter msgIter = {0};
-  SSubmitBlk *   pBlock = NULL;
-  int32_t        affectedrows = 0;
-
-  if (tsdbScanAndConvertSubmitMsg(pRepo, pMsg) < 0) {
-    if (terrno != TSDB_CODE_TDB_TABLE_RECONFIGURE) {
-      tsdbError("vgId:%d failed to insert data since %s", REPO_ID(pRepo), tstrerror(terrno));
-    }
-    return -1;
-  }
-
-  tsdbInitSubmitMsgIter(pMsg, &msgIter);
-  while (true) {
-    tsdbGetSubmitMsgNext(&msgIter, &pBlock);
-    if (pBlock == NULL) break;
-    if (tsdbInsertDataToTable(pRepo, pBlock, &affectedrows) < 0) {
-      return -1;
-    }
-  }
-
-  if (pRsp != NULL) pRsp->affectedRows = htonl(affectedrows);
-
-  if (tsdbCheckCommit(pRepo) < 0) return -1;
-  return 0;
-}
-
-// ---------------- INTERNAL FUNCTIONS ----------------
-int tsdbRefMemTable(STsdbRepo *pRepo, SMemTable *pMemTable) {
-  if (pMemTable == NULL) return 0;
-  int ref = T_REF_INC(pMemTable);
-	tsdbDebug("vgId:%d ref memtable %p ref %d", REPO_ID(pRepo), pMemTable, ref);
-  return 0;
-}
-
-// Need to lock the repository
-int tsdbUnRefMemTable(STsdbRepo *pRepo, SMemTable *pMemTable) {
-  if (pMemTable == NULL) return 0;
-
-	int ref = T_REF_DEC(pMemTable);
-	tsdbDebug("vgId:%d unref memtable %p ref %d", REPO_ID(pRepo), pMemTable, ref);
-  if (ref == 0) {
-    STsdbBufPool *pBufPool = pRepo->pPool;
-
-    SListNode *pNode = NULL;
-    bool addNew = false;
-    if (tsdbLockRepo(pRepo) < 0) return -1;
-    while ((pNode = tdListPopHead(pMemTable->bufBlockList)) != NULL) {
-      if (pBufPool->nRecycleBlocks > 0) {
-        tsdbRecycleBufferBlock(pBufPool, pNode, false);
-        pBufPool->nRecycleBlocks -= 1;
-      } else {
-        if(pBufPool->nElasticBlocks > 0 && listNEles(pBufPool->bufBlockList) > 2) {
-          tsdbRecycleBufferBlock(pBufPool, pNode, true);
-        } else {
-          tdListAppendNode(pBufPool->bufBlockList, pNode);
-          addNew = true;
-        }
-      }      
-    }
-    if (addNew) {
-      int code = pthread_cond_signal(&pBufPool->poolNotEmpty);
-      if (code != 0) {
-        if (tsdbUnlockRepo(pRepo) < 0) return -1;
-        tsdbError("vgId:%d failed to signal pool not empty since %s", REPO_ID(pRepo), strerror(code));
-        terrno = TAOS_SYSTEM_ERROR(code);
-        return -1;
-      }
-    }
-
-    if (tsdbUnlockRepo(pRepo) < 0) return -1;
-
-    for (int i = 0; i < pMemTable->maxTables; i++) {
-      if (pMemTable->tData[i] != NULL) {
-        tsdbFreeTableData(pMemTable->tData[i]);
-      }
-    }
-
-    tdListDiscard(pMemTable->actList);
-    tdListDiscard(pMemTable->bufBlockList);
-    tsdbFreeMemTable(pMemTable);
-  }
-  return 0;
-}
-
-int tsdbTakeMemSnapshot(STsdbRepo *pRepo, SMemSnapshot *pSnapshot, SArray *pATable) {
-  memset(pSnapshot, 0, sizeof(*pSnapshot));
-
-  if (tsdbLockRepo(pRepo) < 0) return -1;
-
-  pSnapshot->omem = pRepo->mem;
-  pSnapshot->imem = pRepo->imem;
-  tsdbRefMemTable(pRepo, pRepo->mem);
-  tsdbRefMemTable(pRepo, pRepo->imem);
-
-  if (tsdbUnlockRepo(pRepo) < 0) return -1;
-
-  if (pSnapshot->omem) {
-    taosRLockLatch(&(pSnapshot->omem->latch));
-
-    pSnapshot->mem = &(pSnapshot->mtable);
-
-    pSnapshot->mem->tData = (STableData **)calloc(pSnapshot->omem->maxTables, sizeof(STableData *));
-    if (pSnapshot->mem->tData == NULL) {
-      terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-      taosRUnLockLatch(&(pSnapshot->omem->latch));
-      tsdbUnRefMemTable(pRepo, pSnapshot->omem);
-      tsdbUnRefMemTable(pRepo, pSnapshot->imem);
-      pSnapshot->mem = NULL;
-      pSnapshot->imem = NULL;
-      pSnapshot->omem = NULL;
-      return -1;
-    }
-
-    pSnapshot->mem->keyFirst = pSnapshot->omem->keyFirst;
-    pSnapshot->mem->keyLast = pSnapshot->omem->keyLast;
-    pSnapshot->mem->numOfRows = pSnapshot->omem->numOfRows;
-    pSnapshot->mem->maxTables = pSnapshot->omem->maxTables;
-
-    for (size_t i = 0; i < taosArrayGetSize(pATable); i++) {
-      STable *    pTable = *(STable **)taosArrayGet(pATable, i);
-      int32_t     tid = TABLE_TID(pTable);
-      STableData *pTableData = (tid < pSnapshot->omem->maxTables) ? pSnapshot->omem->tData[tid] : NULL;
-
-      if ((pTableData == NULL) || (TABLE_UID(pTable) != pTableData->uid)) continue;
-
-      pSnapshot->mem->tData[tid] = pTableData;
-      T_REF_INC(pTableData);
-    }
-
-    taosRUnLockLatch(&(pSnapshot->omem->latch));
-  }
-
-  tsdbDebug("vgId:%d take memory snapshot, pMem %p pIMem %p", REPO_ID(pRepo), pSnapshot->omem, pSnapshot->imem);
-  return 0;
-}
-
-void tsdbUnTakeMemSnapShot(STsdbRepo *pRepo, SMemSnapshot *pSnapshot) {
-  tsdbDebug("vgId:%d untake memory snapshot, pMem %p pIMem %p", REPO_ID(pRepo), pSnapshot->omem, pSnapshot->imem);
-
-  if (pSnapshot->mem) {
-    ASSERT(pSnapshot->omem != NULL);
-
-    for (size_t i = 0; i < pSnapshot->mem->maxTables; i++) {
-      STableData *pTableData = pSnapshot->mem->tData[i];
-      if (pTableData) {
-        tsdbFreeTableData(pTableData);
-      }
-    }
-    tfree(pSnapshot->mem->tData);
-
-    tsdbUnRefMemTable(pRepo, pSnapshot->omem);
-  }
-
-  tsdbUnRefMemTable(pRepo, pSnapshot->imem);
-
-  pSnapshot->mem = NULL;
-  pSnapshot->imem = NULL;
-  pSnapshot->omem = NULL;
-}
-
-void *tsdbAllocBytes(STsdbRepo *pRepo, int bytes) {
-  STsdbCfg *     pCfg = &pRepo->config;
-  STsdbBufBlock *pBufBlock = NULL;
-  void *         ptr = NULL;
-
-  // Either allocate from buffer blocks or from SYSTEM memory pool
-  if (pRepo->mem == NULL) {
-    SMemTable *pMemTable = tsdbNewMemTable(pRepo);
-    if (pMemTable == NULL) return NULL;
-    pRepo->mem = pMemTable;
-  }
-
-  ASSERT(pRepo->mem != NULL);
-
-  pBufBlock = tsdbGetCurrBufBlock(pRepo);
-  if ((pRepo->mem->extraBuffList != NULL) ||
-      ((listNEles(pRepo->mem->bufBlockList) >= pCfg->totalBlocks / 3) && (pBufBlock->remain < bytes))) {
-    // allocate from SYSTEM buffer pool
-    if (pRepo->mem->extraBuffList == NULL) {
-      pRepo->mem->extraBuffList = tdListNew(0);
-      if (pRepo->mem->extraBuffList == NULL) {
-        terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-        return NULL;
-      }
-    }
-
-    ASSERT(pRepo->mem->extraBuffList != NULL);
-    SListNode *pNode = (SListNode *)malloc(sizeof(SListNode) + bytes);
-    if (pNode == NULL) {
-      if (listNEles(pRepo->mem->extraBuffList) == 0) {
-        tdListFree(pRepo->mem->extraBuffList);
-        pRepo->mem->extraBuffList = NULL;
-      }
-      terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-      return NULL;
-    }
-
-    pNode->next = pNode->prev = NULL;
-    tdListAppendNode(pRepo->mem->extraBuffList, pNode);
-    ptr = (void *)(pNode->data);
-    tsdbTrace("vgId:%d allocate %d bytes from SYSTEM buffer block", REPO_ID(pRepo), bytes);
-  } else {  // allocate from TSDB buffer pool
-    if (pBufBlock == NULL || pBufBlock->remain < bytes) {
-      ASSERT(listNEles(pRepo->mem->bufBlockList) < pCfg->totalBlocks / 3);
-      if (tsdbLockRepo(pRepo) < 0) return NULL;
-      SListNode *pNode = tsdbAllocBufBlockFromPool(pRepo);
-      tdListAppendNode(pRepo->mem->bufBlockList, pNode);
-      if (tsdbUnlockRepo(pRepo) < 0) return NULL;
-      pBufBlock = tsdbGetCurrBufBlock(pRepo);
-    }
-
-    ASSERT(pBufBlock->remain >= bytes);
-    ptr = POINTER_SHIFT(pBufBlock->data, pBufBlock->offset);
-    pBufBlock->offset += bytes;
-    pBufBlock->remain -= bytes;
-    tsdbTrace("vgId:%d allocate %d bytes from TSDB buffer block, nBlocks %d offset %d remain %d", REPO_ID(pRepo), bytes,
-              listNEles(pRepo->mem->bufBlockList), pBufBlock->offset, pBufBlock->remain);
-  }
-
-  return ptr;
-}
-
-int tsdbSyncCommitConfig(STsdbRepo* pRepo) {
-  ASSERT(pRepo->config_changed == true);
-  tsem_wait(&(pRepo->readyToCommit));
-
-  if (pRepo->code != TSDB_CODE_SUCCESS) {
-    tsdbWarn("vgId:%d try to commit config when TSDB not in good state: %s", REPO_ID(pRepo), tstrerror(terrno));
-  }
-
-  if (tsdbLockRepo(pRepo) < 0) return -1;
-  tsdbScheduleCommit(pRepo, COMMIT_CONFIG_REQ);
-  if (tsdbUnlockRepo(pRepo) < 0) return -1;
-
-  tsem_wait(&(pRepo->readyToCommit));
-  tsem_post(&(pRepo->readyToCommit));
-
-  if (pRepo->code != TSDB_CODE_SUCCESS) {
-    terrno = pRepo->code;
-    return -1;
-  }
-
-  terrno = TSDB_CODE_SUCCESS;
-  return 0;
-}
-
-int tsdbAsyncCommit(STsdbRepo *pRepo) {
-  tsem_wait(&(pRepo->readyToCommit));
-
-  ASSERT(pRepo->imem == NULL);
-  if (pRepo->mem == NULL) {
-    tsem_post(&(pRepo->readyToCommit));
-    return 0;
-  }
-
-  if (pRepo->code != TSDB_CODE_SUCCESS) {
-    tsdbWarn("vgId:%d try to commit when TSDB not in good state: %s", REPO_ID(pRepo), tstrerror(terrno));
-  }
-
-  if (pRepo->appH.notifyStatus) pRepo->appH.notifyStatus(pRepo->appH.appH, TSDB_STATUS_COMMIT_START, TSDB_CODE_SUCCESS);
-  if (tsdbLockRepo(pRepo) < 0) return -1;
-  pRepo->imem = pRepo->mem;
-  pRepo->mem = NULL;
-  tsdbScheduleCommit(pRepo, COMMIT_REQ);
-  if (tsdbUnlockRepo(pRepo) < 0) return -1;
-
-  return 0;
-}
-
-int tsdbSyncCommit(STsdbRepo *repo) {
-  STsdbRepo *pRepo = repo;
-
-  tsdbAsyncCommit(pRepo);
-  tsem_wait(&(pRepo->readyToCommit));
-  tsem_post(&(pRepo->readyToCommit));
-
-  if (pRepo->code != TSDB_CODE_SUCCESS) {
-    terrno = pRepo->code;
-    return -1;
-  } else {
-    terrno = TSDB_CODE_SUCCESS;
-    return 0;
-  }
-}
-
-/**
- * This is an important function to load data or try to load data from memory skiplist iterator.
- * 
- * This function load memory data until:
- * 1. iterator ends
- * 2. data key exceeds maxKey
- * 3. rowsIncreased = rowsInserted - rowsDeleteSucceed >= maxRowsToRead
- * 4. operations in pCols not exceeds its max capacity if pCols is given
- * 
- * The function tries to procceed AS MUCH AS POSSIBLE.
- */
-int tsdbLoadDataFromCache(STable *pTable, SSkipListIterator *pIter, TSKEY maxKey, int maxRowsToRead, SDataCols *pCols,
-                          TKEY *filterKeys, int nFilterKeys, bool keepDup, SMergeInfo *pMergeInfo) {
-  ASSERT(maxRowsToRead > 0 && nFilterKeys >= 0);
-  if (pIter == NULL) return 0;
-  STSchema * pSchema = NULL;
-  TSKEY      rowKey = 0;
-  TSKEY      fKey = 0;
-  bool       isRowDel = false;
-  int        filterIter = 0;
-  SMemRow    row = NULL;
-  SMergeInfo mInfo;
-
-  if (pMergeInfo == NULL) pMergeInfo = &mInfo;
-
-  memset(pMergeInfo, 0, sizeof(*pMergeInfo));
-  pMergeInfo->keyFirst = INT64_MAX;
-  pMergeInfo->keyLast = INT64_MIN;
-  if (pCols) tdResetDataCols(pCols);
-
-  row = tsdbNextIterRow(pIter);
-  if (row == NULL || memRowKey(row) > maxKey) {
-    rowKey = INT64_MAX;
-    isRowDel = false;
-  } else {
-    rowKey = memRowKey(row);
-    isRowDel = memRowDeleted(row);
-  }
-
-  if (filterIter >= nFilterKeys) {
-    fKey = INT64_MAX;
-  } else {
-    fKey = tdGetKey(filterKeys[filterIter]);
-  }
-
-  while (true) {
-    if (fKey == INT64_MAX && rowKey == INT64_MAX) break;
-
-    if (fKey < rowKey) {
-      pMergeInfo->keyFirst = MIN(pMergeInfo->keyFirst, fKey);
-      pMergeInfo->keyLast = MAX(pMergeInfo->keyLast, fKey);
-
-      filterIter++;
-      if (filterIter >= nFilterKeys) {
-        fKey = INT64_MAX;
-      } else {
-        fKey = tdGetKey(filterKeys[filterIter]);
-      }
-    } else if (fKey > rowKey) {
-      if (isRowDel) {
-        pMergeInfo->rowsDeleteFailed++;
-      } else {
-        if (pMergeInfo->rowsInserted - pMergeInfo->rowsDeleteSucceed >= maxRowsToRead) break;
-        if (pCols && pMergeInfo->nOperations >= pCols->maxPoints) break;
-        pMergeInfo->rowsInserted++;
-        pMergeInfo->nOperations++;
-        pMergeInfo->keyFirst = MIN(pMergeInfo->keyFirst, rowKey);
-        pMergeInfo->keyLast = MAX(pMergeInfo->keyLast, rowKey);
-        tsdbAppendTableRowToCols(pTable, pCols, &pSchema, row);
-      }
-
-      tSkipListIterNext(pIter);
-      row = tsdbNextIterRow(pIter);
-      if (row == NULL || memRowKey(row) > maxKey) {
-        rowKey = INT64_MAX;
-        isRowDel = false;
-      } else {
-        rowKey = memRowKey(row);
-        isRowDel = memRowDeleted(row);
-      }
-    } else {
-      if (isRowDel) {
-        ASSERT(!keepDup);
-        if (pCols && pMergeInfo->nOperations >= pCols->maxPoints) break;
-        pMergeInfo->rowsDeleteSucceed++;
-        pMergeInfo->nOperations++;
-        tsdbAppendTableRowToCols(pTable, pCols, &pSchema, row);
-      } else {
-        if (keepDup) {
-          if (pCols && pMergeInfo->nOperations >= pCols->maxPoints) break;
-          pMergeInfo->rowsUpdated++;
-          pMergeInfo->nOperations++;
-          pMergeInfo->keyFirst = MIN(pMergeInfo->keyFirst, rowKey);
-          pMergeInfo->keyLast = MAX(pMergeInfo->keyLast, rowKey);
-          tsdbAppendTableRowToCols(pTable, pCols, &pSchema, row);
-        } else {
-          pMergeInfo->keyFirst = MIN(pMergeInfo->keyFirst, fKey);
-          pMergeInfo->keyLast = MAX(pMergeInfo->keyLast, fKey);
-        }
-      }
-
-      tSkipListIterNext(pIter);
-      row = tsdbNextIterRow(pIter);
-      if (row == NULL || memRowKey(row) > maxKey) {
-        rowKey = INT64_MAX;
-        isRowDel = false;
-      } else {
-        rowKey = memRowKey(row);
-        isRowDel = memRowDeleted(row);
-      }
-
-      filterIter++;
-      if (filterIter >= nFilterKeys) {
-        fKey = INT64_MAX;
-      } else {
-        fKey = tdGetKey(filterKeys[filterIter]);
-      }
-    }
-  }
-
-  return 0;
-}
-
-// ---------------- LOCAL FUNCTIONS ----------------
-static SMemTable* tsdbNewMemTable(STsdbRepo *pRepo) {
-  STsdbMeta *pMeta = pRepo->tsdbMeta;
-
-  SMemTable *pMemTable = (SMemTable *)calloc(1, sizeof(*pMemTable));
-  if (pMemTable == NULL) {
-    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-    goto _err;
-  }
-
-  pMemTable->keyFirst = INT64_MAX;
-  pMemTable->keyLast = 0;
-  pMemTable->numOfRows = 0;
-
-  pMemTable->maxTables = pMeta->maxTables;
-  pMemTable->tData = (STableData **)calloc(pMemTable->maxTables, sizeof(STableData *));
-  if (pMemTable->tData == NULL) {
-    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-    goto _err;
-  }
-
-  pMemTable->actList = tdListNew(0);
-  if (pMemTable->actList == NULL) {
-    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-    goto _err;
-  }
-
-  pMemTable->bufBlockList = tdListNew(sizeof(STsdbBufBlock*));
-  if (pMemTable->bufBlockList == NULL) {
-    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-    goto _err;
-  }
-
-  T_REF_INC(pMemTable);
-
-  return pMemTable;
-
-_err:
-  tsdbFreeMemTable(pMemTable);
-  return NULL;
-}
-
-static void tsdbFreeMemTable(SMemTable* pMemTable) {
-  if (pMemTable) {
-    ASSERT((pMemTable->bufBlockList == NULL) ? true : (listNEles(pMemTable->bufBlockList) == 0));
-    ASSERT((pMemTable->actList == NULL) ? true : (listNEles(pMemTable->actList) == 0));
-
-    tdListFree(pMemTable->extraBuffList);
-    tdListFree(pMemTable->bufBlockList);
-    tdListFree(pMemTable->actList);
-    tfree(pMemTable->tData);
-    free(pMemTable);
-  }
-}
-
-static STableData *tsdbNewTableData(STsdbCfg *pCfg, STable *pTable) {
-  STableData *pTableData = (STableData *)calloc(1, sizeof(*pTableData));
-  if (pTableData == NULL) {
-    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-    return NULL;
-  }
-
-  pTableData->uid = TABLE_UID(pTable);
-  pTableData->keyFirst = INT64_MAX;
-  pTableData->keyLast = 0;
-  pTableData->numOfRows = 0;
-
-  uint8_t skipListCreateFlags;
-  if(pCfg->update == TD_ROW_DISCARD_UPDATE)
-    skipListCreateFlags = SL_DISCARD_DUP_KEY;
-  else
-    skipListCreateFlags = SL_UPDATE_DUP_KEY;
-
-  pTableData->pData =
-      tSkipListCreate(TSDB_DATA_SKIPLIST_LEVEL, TSDB_DATA_TYPE_TIMESTAMP, TYPE_BYTES[TSDB_DATA_TYPE_TIMESTAMP],
-                      tkeyComparFn, skipListCreateFlags, tsdbGetTsTupleKey);
-  if (pTableData->pData == NULL) {
-    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-    free(pTableData);
-    return NULL;
-  }
-
-  T_REF_INC(pTableData);
-
-  return pTableData;
-}
-
-static void tsdbFreeTableData(STableData *pTableData) {
-  if (pTableData) {
-    int32_t ref = T_REF_DEC(pTableData);
-    if (ref == 0) {
-      tSkipListDestroy(pTableData->pData);
-      free(pTableData);
-    }
-  }
-}
-
-static char *tsdbGetTsTupleKey(const void *data) { return memRowTuple((SMemRow)data); }
-
-static int tsdbAdjustMemMaxTables(SMemTable *pMemTable, int maxTables) {
-  ASSERT(pMemTable->maxTables < maxTables);
-
-  STableData **pTableData = (STableData **)calloc(maxTables, sizeof(STableData *));
-  if (pTableData == NULL) {
-    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-    return -1;
-  }
-  memcpy((void *)pTableData, (void *)pMemTable->tData, sizeof(STableData *) * pMemTable->maxTables);
-
-  STableData **tData = pMemTable->tData;
-
-  taosWLockLatch(&(pMemTable->latch));
-  pMemTable->maxTables = maxTables;
-  pMemTable->tData = pTableData;
-  taosWUnLockLatch(&(pMemTable->latch));
-
-  tfree(tData);
-
-  return 0;
-}
-
-static int tsdbAppendTableRowToCols(STable *pTable, SDataCols *pCols, STSchema **ppSchema, SMemRow row) {
-  if (pCols) {
-    if (*ppSchema == NULL || schemaVersion(*ppSchema) != memRowVersion(row)) {
-      *ppSchema = tsdbGetTableSchemaImpl(pTable, false, false, memRowVersion(row));
-      if (*ppSchema == NULL) {
-        ASSERT(false);
-        return -1;
-      }
-    }
-
-    tdAppendMemRowToDataCol(row, *ppSchema, pCols, true);
-  }
-
-  return 0;
-}
-
-static int tsdbInitSubmitBlkIter(SSubmitBlk *pBlock, SSubmitBlkIter *pIter) {
-  if (pBlock->dataLen <= 0) return -1;
-  pIter->totalLen = pBlock->dataLen;
-  pIter->len = 0;
-  pIter->row = (SMemRow)(pBlock->data + pBlock->schemaLen);
-  return 0;
-}
-
-static SMemRow tsdbGetSubmitBlkNext(SSubmitBlkIter *pIter) {
-  SMemRow row = pIter->row;  // firstly, get current row
-  if (row == NULL) return NULL;
-
-  pIter->len += memRowTLen(row);
-  if (pIter->len >= pIter->totalLen) {  // reach the end
-    pIter->row = NULL;
-  } else {
-    pIter->row = (char *)row + memRowTLen(row);  // secondly, move to next row
-  }
-
-  return row;
-}
-
-static FORCE_INLINE int tsdbCheckRowRange(STsdbRepo *pRepo, STable *pTable, SMemRow row, TSKEY minKey, TSKEY maxKey,
-                                          TSKEY now) {
-  TSKEY rowKey = memRowKey(row);
-  if (rowKey < minKey || rowKey > maxKey) {
-    tsdbError("vgId:%d table %s tid %d uid %" PRIu64 " timestamp is out of range! now %" PRId64 " minKey %" PRId64
-              " maxKey %" PRId64 " row key %" PRId64,
-              REPO_ID(pRepo), TABLE_CHAR_NAME(pTable), TABLE_TID(pTable), TABLE_UID(pTable), now, minKey, maxKey,
-              rowKey);
-    terrno = TSDB_CODE_TDB_TIMESTAMP_OUT_OF_RANGE;
-    return -1;
-  }
-
-  return 0;
-}
-
-static int tsdbScanAndConvertSubmitMsg(STsdbRepo *pRepo, SSubmitMsg *pMsg) {
-  ASSERT(pMsg != NULL);
-  STsdbMeta *    pMeta = pRepo->tsdbMeta;
-  SSubmitMsgIter msgIter = {0};
-  SSubmitBlk *   pBlock = NULL;
-  SSubmitBlkIter blkIter = {0};
-  SMemRow        row = NULL;
-  TSKEY          now = taosGetTimestamp(pRepo->config.precision);
-  TSKEY          minKey = now - tsTickPerDay[pRepo->config.precision] * pRepo->config.keep;
-  TSKEY          maxKey = now + tsTickPerDay[pRepo->config.precision] * pRepo->config.daysPerFile;
-
-  terrno = TSDB_CODE_SUCCESS;
-  pMsg->length = htonl(pMsg->length);
-  pMsg->numOfBlocks = htonl(pMsg->numOfBlocks);
-
-  if (tsdbInitSubmitMsgIter(pMsg, &msgIter) < 0) return -1;
-  while (true) {
-    if (tsdbGetSubmitMsgNext(&msgIter, &pBlock) < 0) return -1;
-    if (pBlock == NULL) break;
-
-    pBlock->uid = htobe64(pBlock->uid);
-    pBlock->tid = htonl(pBlock->tid);
-    pBlock->sversion = htonl(pBlock->sversion);
-    pBlock->dataLen = htonl(pBlock->dataLen);
-    pBlock->schemaLen = htonl(pBlock->schemaLen);
-    pBlock->numOfRows = htons(pBlock->numOfRows);
-
-    if (pBlock->tid <= 0 || pBlock->tid >= pMeta->maxTables) {
-      tsdbError("vgId:%d failed to get table to insert data, uid %" PRIu64 " tid %d", REPO_ID(pRepo), pBlock->uid,
-                pBlock->tid);
-      terrno = TSDB_CODE_TDB_INVALID_TABLE_ID;
-      return -1;
-    }
-
-    STable *pTable = pMeta->tables[pBlock->tid];
-    if (pTable == NULL || TABLE_UID(pTable) != pBlock->uid) {
-      tsdbError("vgId:%d failed to get table to insert data, uid %" PRIu64 " tid %d", REPO_ID(pRepo), pBlock->uid,
-                pBlock->tid);
-      terrno = TSDB_CODE_TDB_INVALID_TABLE_ID;
-      return -1;
-    }
-
-    if (TABLE_TYPE(pTable) == TSDB_SUPER_TABLE) {
-      tsdbError("vgId:%d invalid action trying to insert a super table %s", REPO_ID(pRepo), TABLE_CHAR_NAME(pTable));
-      terrno = TSDB_CODE_TDB_INVALID_ACTION;
-      return -1;
-    }
-
-    // Check schema version and update schema if needed
-    if (tsdbCheckTableSchema(pRepo, pBlock, pTable) < 0) {
-      if (terrno == TSDB_CODE_TDB_TABLE_RECONFIGURE) {
-        continue;
-      } else {
-        return -1;
-      }
-    }
-
-    tsdbInitSubmitBlkIter(pBlock, &blkIter);
-    while ((row = tsdbGetSubmitBlkNext(&blkIter)) != NULL) {
-      if (tsdbCheckRowRange(pRepo, pTable, row, minKey, maxKey, now) < 0) {
-        return -1;
-      }
-    }
-  }
-
-  if (terrno != TSDB_CODE_SUCCESS) return -1;
-  return 0;
-}
-
-//row1 has higher priority
-static SMemRow tsdbInsertDupKeyMerge(SMemRow row1, SMemRow row2, STsdbRepo* pRepo,
-                                     STSchema **ppSchema1, STSchema **ppSchema2,
-                                     STable* pTable, int32_t* pPoints, SMemRow* pLastRow) {
-  
-  //for compatiblity, duplicate key inserted when update=0 should be also calculated as affected rows!
-  if(row1 == NULL && row2 == NULL && pRepo->config.update == TD_ROW_DISCARD_UPDATE) {
-    (*pPoints)++;
-    return NULL;
-  }
-
-  if(row2 == NULL || pRepo->config.update != TD_ROW_PARTIAL_UPDATE) {
-    void* pMem = tsdbAllocBytes(pRepo, memRowTLen(row1));
-    if(pMem == NULL) return NULL;
-    memRowCpy(pMem, row1);
-    (*pPoints)++;
-    *pLastRow = pMem;
-    return pMem;
-  }
-
-  STSchema *pSchema1 = *ppSchema1;
-  STSchema *pSchema2 = *ppSchema2;
-  SMergeBuf * pBuf = &pRepo->mergeBuf;
-  int dv1 = memRowVersion(row1);
-  int dv2 = memRowVersion(row2);
-  if(pSchema1 == NULL || schemaVersion(pSchema1) != dv1) {
-    if(pSchema2 != NULL && schemaVersion(pSchema2) == dv1) {
-      *ppSchema1 = pSchema2;
-    } else {
-      *ppSchema1 = tsdbGetTableSchemaImpl(pTable, false, false, memRowVersion(row1));
-    }
-    pSchema1 = *ppSchema1;
-  }
-
-  if(pSchema2 == NULL || schemaVersion(pSchema2) != dv2) {
-    if(schemaVersion(pSchema1) == dv2) {
-      pSchema2 = pSchema1;
-    } else {
-      *ppSchema2 = tsdbGetTableSchemaImpl(pTable, false, false, memRowVersion(row2));
-      pSchema2 = *ppSchema2;
-    }
-  }
-
-  SMemRow tmp = tsdbMergeTwoRows(pBuf, row1, row2, pSchema1, pSchema2);
-
-  void* pMem = tsdbAllocBytes(pRepo, memRowTLen(tmp));
-  if(pMem == NULL) return NULL;
-  memRowCpy(pMem, tmp);
-
-  (*pPoints)++;
-  *pLastRow = pMem;
-  return pMem;
-}
-
-static void* tsdbInsertDupKeyMergePacked(void** args) {
-  return tsdbInsertDupKeyMerge(args[0], args[1], args[2], (STSchema**)&args[3], (STSchema**)&args[4], args[5], args[6], args[7]);
-}
-
-static void tsdbSetupSkipListHookFns(SSkipList* pSkipList, STsdbRepo *pRepo, STable *pTable, int32_t* pPoints, SMemRow* pLastRow) {
-
-  if(pSkipList->insertHandleFn == NULL) {
-    tGenericSavedFunc *dupHandleSavedFunc = genericSavedFuncInit((GenericVaFunc)&tsdbInsertDupKeyMergePacked, 9);
-    dupHandleSavedFunc->args[2] = pRepo;
-    dupHandleSavedFunc->args[3] = NULL;
-    dupHandleSavedFunc->args[4] = NULL;
-    dupHandleSavedFunc->args[5] = pTable;
-    pSkipList->insertHandleFn = dupHandleSavedFunc;
-  }
-  pSkipList->insertHandleFn->args[6] = pPoints;
-  pSkipList->insertHandleFn->args[7] = pLastRow;
-}
-
-static int tsdbInsertDataToTable(STsdbRepo* pRepo, SSubmitBlk* pBlock, int32_t *pAffectedRows) {
-
-  STsdbMeta       *pMeta = pRepo->tsdbMeta;
-  int32_t          points = 0;
-  STable          *pTable = NULL;
-  SSubmitBlkIter   blkIter = {0};
-  SMemTable       *pMemTable = NULL;
-  STableData      *pTableData = NULL;
-  STsdbCfg        *pCfg = &(pRepo->config);
-
-  tsdbInitSubmitBlkIter(pBlock, &blkIter);
-  if(blkIter.row == NULL) return 0;
-  TSKEY firstRowKey = memRowKey(blkIter.row);
-
-  tsdbAllocBytes(pRepo, 0);
-  pMemTable = pRepo->mem;
-
-  ASSERT(pMemTable != NULL);
-  ASSERT(pBlock->tid < pMeta->maxTables);
-
-  pTable = pMeta->tables[pBlock->tid];
-
-  ASSERT(pTable != NULL && TABLE_UID(pTable) == pBlock->uid);
-
-
-  if (TABLE_TID(pTable) >= pMemTable->maxTables) {
-    if (tsdbAdjustMemMaxTables(pMemTable, pMeta->maxTables) < 0) {
-      return -1;
-    }
-  }
-  pTableData = pMemTable->tData[TABLE_TID(pTable)];
-
-  if (pTableData == NULL || pTableData->uid != TABLE_UID(pTable)) {
-    if (pTableData != NULL) {
-      taosWLockLatch(&(pMemTable->latch));
-      pMemTable->tData[TABLE_TID(pTable)] = NULL;
-      tsdbFreeTableData(pTableData);
-      taosWUnLockLatch(&(pMemTable->latch));
-    }
-
-    pTableData = tsdbNewTableData(pCfg, pTable);
-    if (pTableData == NULL) {
-      tsdbError("vgId:%d failed to insert data to table %s uid %" PRId64 " tid %d since %s", REPO_ID(pRepo),
-                TABLE_CHAR_NAME(pTable), TABLE_UID(pTable), TABLE_TID(pTable), tstrerror(terrno));
-      return -1;
-    }
-
-    pRepo->mem->tData[TABLE_TID(pTable)] = pTableData;
-  }
-
-  ASSERT((pTableData != NULL) && pTableData->uid == TABLE_UID(pTable));
-
-  SMemRow lastRow = NULL;
-  int64_t osize = SL_SIZE(pTableData->pData);
-  tsdbSetupSkipListHookFns(pTableData->pData, pRepo, pTable, &points, &lastRow);
-  tSkipListPutBatchByIter(pTableData->pData, &blkIter, (iter_next_fn_t)tsdbGetSubmitBlkNext);
-  int64_t dsize = SL_SIZE(pTableData->pData) - osize;
-  (*pAffectedRows) += points;
-
-
-  if(lastRow != NULL) {
-    TSKEY lastRowKey = memRowKey(lastRow);
-    if (pMemTable->keyFirst > firstRowKey) pMemTable->keyFirst = firstRowKey;
-    pMemTable->numOfRows += dsize;
-
-    if (pTableData->keyFirst > firstRowKey) pTableData->keyFirst = firstRowKey;
-    pTableData->numOfRows += dsize;
-    if (pMemTable->keyLast < lastRowKey) pMemTable->keyLast = lastRowKey;
-    if (pTableData->keyLast < lastRowKey) pTableData->keyLast = lastRowKey;
-    if (tsdbUpdateTableLatestInfo(pRepo, pTable, lastRow) < 0) {
-      return -1;
-    }
-  }
-
-  STSchema *pSchema = tsdbGetTableSchemaByVersion(pTable, pBlock->sversion);
-  pRepo->stat.pointsWritten += points * schemaNCols(pSchema);
-  pRepo->stat.totalStorage += points * schemaVLen(pSchema);
-
-  return 0;
-}
-
-
-static int tsdbInitSubmitMsgIter(SSubmitMsg *pMsg, SSubmitMsgIter *pIter) {
-  if (pMsg == NULL) {
-    terrno = TSDB_CODE_TDB_SUBMIT_MSG_MSSED_UP;
-    return -1;
-  }
-
-  pIter->totalLen = pMsg->length;
-  pIter->len = 0;
-  pIter->pMsg = pMsg;
-  if (pMsg->length <= TSDB_SUBMIT_MSG_HEAD_SIZE) {
-    terrno = TSDB_CODE_TDB_SUBMIT_MSG_MSSED_UP;
-    return -1;
-  }
-
-  return 0;
-}
-
-static int tsdbGetSubmitMsgNext(SSubmitMsgIter *pIter, SSubmitBlk **pPBlock) {
-  if (pIter->len == 0) {
-    pIter->len += TSDB_SUBMIT_MSG_HEAD_SIZE;
-  } else {
-    SSubmitBlk *pSubmitBlk = (SSubmitBlk *)POINTER_SHIFT(pIter->pMsg, pIter->len);
-    pIter->len += (sizeof(SSubmitBlk) + pSubmitBlk->dataLen + pSubmitBlk->schemaLen);
-  }
-
-  if (pIter->len > pIter->totalLen) {
-    terrno = TSDB_CODE_TDB_SUBMIT_MSG_MSSED_UP;
-    *pPBlock = NULL;
-    return -1;
-  }
-
-  *pPBlock = (pIter->len == pIter->totalLen) ? NULL : (SSubmitBlk *)POINTER_SHIFT(pIter->pMsg, pIter->len);
-
-  return 0;
-}
-
-static int tsdbCheckTableSchema(STsdbRepo *pRepo, SSubmitBlk *pBlock, STable *pTable) {
-  ASSERT(pTable != NULL);
-
-  STSchema *pSchema = tsdbGetTableSchemaImpl(pTable, false, false, -1);
-  int       sversion = schemaVersion(pSchema);
-
-  if (pBlock->sversion == sversion) {
-    return 0;
-  } else {
-    if (TABLE_TYPE(pTable) == TSDB_STREAM_TABLE) {  // stream table is not allowed to change schema
-      terrno = TSDB_CODE_TDB_IVD_TB_SCHEMA_VERSION;
-      return -1;
-    }
-  }
-
-  if (pBlock->sversion > sversion) {  // may need to update table schema
-    if (pBlock->schemaLen > 0) {
-      tsdbDebug(
-          "vgId:%d table %s tid %d uid %" PRIu64 " schema version %d is out of data, client version %d, update...",
-          REPO_ID(pRepo), TABLE_CHAR_NAME(pTable), TABLE_TID(pTable), TABLE_UID(pTable), sversion, pBlock->sversion);
-      ASSERT(pBlock->schemaLen % sizeof(STColumn) == 0);
-      int       numOfCols = pBlock->schemaLen / sizeof(STColumn);
-      STColumn *pTCol = (STColumn *)pBlock->data;
-
-      STSchemaBuilder schemaBuilder = {0};
-      if (tdInitTSchemaBuilder(&schemaBuilder, pBlock->sversion) < 0) {
-        terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-        tsdbError("vgId:%d failed to update schema of table %s since %s", REPO_ID(pRepo), TABLE_CHAR_NAME(pTable),
-                  tstrerror(terrno));
-        return -1;
-      }
-
-      for (int i = 0; i < numOfCols; i++) {
-        if (tdAddColToSchema(&schemaBuilder, pTCol[i].type, htons(pTCol[i].colId), htons(pTCol[i].bytes)) < 0) {
-          terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-          tsdbError("vgId:%d failed to update schema of table %s since %s", REPO_ID(pRepo), TABLE_CHAR_NAME(pTable),
-                    tstrerror(terrno));
-          tdDestroyTSchemaBuilder(&schemaBuilder);
-          return -1;
-        }
-      }
-
-      STSchema *pNSchema = tdGetSchemaFromBuilder(&schemaBuilder);
-      if (pNSchema == NULL) {
-        terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-        tdDestroyTSchemaBuilder(&schemaBuilder);
-        return -1;
-      }
-
-      tdDestroyTSchemaBuilder(&schemaBuilder);
-      tsdbUpdateTableSchema(pRepo, pTable, pNSchema, true);
-    } else {
-      tsdbDebug(
-          "vgId:%d table %s tid %d uid %" PRIu64 " schema version %d is out of data, client version %d, reconfigure...",
-          REPO_ID(pRepo), TABLE_CHAR_NAME(pTable), TABLE_TID(pTable), TABLE_UID(pTable), sversion, pBlock->sversion);
-      terrno = TSDB_CODE_TDB_TABLE_RECONFIGURE;
-      return -1;
-    }
-  } else {
-    ASSERT(pBlock->sversion >= 0);
-    if (tsdbGetTableSchemaImpl(pTable, false, false, pBlock->sversion) == NULL) {
-      tsdbError("vgId:%d invalid submit schema version %d to table %s tid %d from client", REPO_ID(pRepo),
-                pBlock->sversion, TABLE_CHAR_NAME(pTable), TABLE_TID(pTable));
-      terrno = TSDB_CODE_TDB_IVD_TB_SCHEMA_VERSION;
-      return -1;
-    }
-  }
-
-  return 0;
-}
-
-
-static void updateTableLatestColumn(STsdbRepo *pRepo, STable *pTable, SMemRow row) {
-  tsdbDebug("vgId:%d updateTableLatestColumn, %s row version:%d", REPO_ID(pRepo), pTable->name->data,
-            memRowVersion(row));
-
-  STSchema* pSchema = tsdbGetTableLatestSchema(pTable);
-  if (tsdbUpdateLastColSchema(pTable, pSchema) < 0) {
-    return;
-  }
-
-  pSchema = tsdbGetTableSchemaByVersion(pTable, memRowVersion(row));
-  if (pSchema == NULL) {
-    return;
-  }
-
-  SDataCol *pLatestCols = pTable->lastCols;
-  int32_t kvIdx = 0;
-
-  for (int16_t j = 0; j < schemaNCols(pSchema); j++) {
-    STColumn *pTCol = schemaColAt(pSchema, j);
-    // ignore not exist colId
-    int16_t idx = tsdbGetLastColumnsIndexByColId(pTable, pTCol->colId);
-    if (idx == -1) {
-      continue;
-    }
-
-    void *value = NULL;
-
-    value = tdGetMemRowDataOfColEx(row, pTCol->colId, (int8_t)pTCol->type,
-                                   TD_DATA_ROW_HEAD_SIZE + pSchema->columns[j].offset, &kvIdx);
-
-    if ((value == NULL) || isNull(value, pTCol->type)) {
-      continue;
-    }
-
-    SDataCol *pDataCol = &(pLatestCols[idx]);
-    if (pDataCol->pData == NULL) {
-      pDataCol->pData = malloc(pTCol->bytes);
-      pDataCol->bytes = pTCol->bytes;
-    } else if (pDataCol->bytes < pTCol->bytes) {
-      pDataCol->pData = realloc(pDataCol->pData, pTCol->bytes);
-      pDataCol->bytes = pTCol->bytes;
-    }
-    // the actual value size
-    uint16_t bytes = IS_VAR_DATA_TYPE(pTCol->type) ? varDataTLen(value) : pTCol->bytes;
-    // the actual data size CANNOT larger than column size
-    assert(pTCol->bytes >= bytes);
-    memcpy(pDataCol->pData, value, bytes);
-    //tsdbInfo("updateTableLatestColumn vgId:%d cache column %d for %d,%s", REPO_ID(pRepo), j, pDataCol->bytes, (char*)pDataCol->pData);
-    pDataCol->ts = memRowKey(row);
-  }
-}
-
-static int tsdbUpdateTableLatestInfo(STsdbRepo *pRepo, STable *pTable, SMemRow row) {
-  STsdbCfg *pCfg = &pRepo->config;
-
-  // if cacheLastRow config has been reset, free the lastRow
-  if (!pCfg->cacheLastRow && pTable->lastRow != NULL) {
-    SMemRow cachedLastRow = pTable->lastRow;
-    TSDB_WLOCK_TABLE(pTable);
-    pTable->lastRow = NULL;
-    TSDB_WUNLOCK_TABLE(pTable);
-    taosTZfree(cachedLastRow);
-  }
-
-  if (tsdbGetTableLastKeyImpl(pTable) <= memRowKey(row)) {
-    if (CACHE_LAST_ROW(pCfg) || pTable->lastRow != NULL) {
-      SMemRow nrow = pTable->lastRow;
-      if (taosTSizeof(nrow) < memRowTLen(row)) {
-        SMemRow orow = nrow;
-        nrow = taosTMalloc(memRowTLen(row));
-        if (nrow == NULL) {
-          terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-          return -1;
-        }
-
-        memRowCpy(nrow, row);
-        TSDB_WLOCK_TABLE(pTable);
-        pTable->lastKey = memRowKey(row);
-        pTable->lastRow = nrow;
-        TSDB_WUNLOCK_TABLE(pTable);
-        taosTZfree(orow);
-      } else {
-        TSDB_WLOCK_TABLE(pTable);
-        pTable->lastKey = memRowKey(row);
-        memRowCpy(nrow, row);
-        TSDB_WUNLOCK_TABLE(pTable);
-      }
-    } else {
-      pTable->lastKey = memRowKey(row);
-    }
-
-    if (CACHE_LAST_NULL_COLUMN(pCfg)) {
-      updateTableLatestColumn(pRepo, pTable, row);
-    }
-  }
-  return 0;
-}
diff --git a/tests/pytest/crash_gen/valgrind_taos.supp b/tests/pytest/crash_gen/valgrind_taos.supp
index ec44a85d5b..974103052e 100644
--- a/tests/pytest/crash_gen/valgrind_taos.supp
+++ b/tests/pytest/crash_gen/valgrind_taos.supp
@@ -17515,7 +17515,7 @@
    fun:gaih_inet.constprop.0
    fun:getaddrinfo
    fun:taosGetFqdn
-   fun:taosCheckGlobalCfg
+   fun:taosCheckAndPrintCfg
    fun:taos_init_imp
 }
 {
@@ -17740,7 +17740,7 @@
    fun:gaih_inet.constprop.7
    fun:getaddrinfo
    fun:taosGetFqdn
-   fun:taosCheckGlobalCfg
+   fun:taosCheckAndPrintCfg
    fun:taos_init_imp
 }
 {