merge 3.0

cdee4d8e · Xiaoyu Wang · ac754dce · 0bd5a15d · cdee4d8e · cdee4d8e
137 changed file
--- a/.gitignore
+++ b/.gitignore
@@ -40,6 +40,7 @@ taosdalipu/
 Target/
 *.failed
 *.sql
+sim
 sim/
 psim/
 pysim/
@@ -107,3 +108,4 @@ TAGS
 contrib/*
 !contrib/CMakeLists.txt
 !contrib/test
+sql
\ No newline at end of file
--- a/contrib/CMakeLists.txt
+++ b/contrib/CMakeLists.txt
@@ -14,9 +14,24 @@ if(${BUILD_PTHREAD})
    cat("${TD_SUPPORT_DIR}/pthread_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
 endif()
-# gnu regex
+# iconv
-if(${BUILD_GNUREGEX})
+if(${BUILD_WITH_ICONV})
-    cat("${TD_SUPPORT_DIR}/gnuregex_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
+    cat("${TD_SUPPORT_DIR}/iconv_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
+endif()
+# msvc regex
+if(${BUILD_MSVCREGEX})
+    cat("${TD_SUPPORT_DIR}/msvcregex_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
+endif()
+# wcwidth
+if(${BUILD_WCWIDTH})
+    cat("${TD_SUPPORT_DIR}/wcwidth_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
+endif()
+# wingetopt
+if(${BUILD_WINGETOPT})
+    cat("${TD_SUPPORT_DIR}/wingetopt_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
 endif()
 # googletest
@@ -99,8 +114,27 @@ if(${BUILD_TEST})
    target_include_directories(
        gtest
        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/cpp-stub/src>
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/cpp-stub/src_linux>
    )
+    if(${TD_WINDOWS})
+        target_include_directories(
+            gtest
+            PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/cpp-stub/src_win>
+        )
+    endif(${TD_WINDOWS})
+    if(${TD_LINUX})
+        target_include_directories(
+            gtest
+            PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/cpp-stub/src_linux>
+        )
+    endif(${TD_LINUX})
+    if(${TD_DARWIN})
+        target_include_directories(
+            gtest
+            PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/cpp-stub/src_darwin>
+        )
+    endif(${TD_DARWIN})
 endif(${BUILD_TEST})
 # cJson
@@ -182,6 +216,53 @@ if(${BUILD_WITH_NURAFT})
    add_subdirectory(nuraft)
 endif(${BUILD_WITH_NURAFT})
+# pthread
+if(${BUILD_PTHREAD})
+    set(CMAKE_BUILD_TYPE release)
+    add_definitions(-DPTW32_STATIC_LIB) 
+    add_subdirectory(pthread)
+    set_target_properties(libpthreadVC3 PROPERTIES OUTPUT_NAME pthread)
+    add_library(pthread STATIC IMPORTED GLOBAL)
+    SET_PROPERTY(TARGET pthread PROPERTY IMPORTED_LOCATION ${LIBRARY_OUTPUT_PATH}/pthread.lib)
+endif()
+# iconv
+if(${BUILD_WITH_ICONV})
+    add_subdirectory(iconv)
+endif(${BUILD_WITH_ICONV})
+# wingetopt
+if(${BUILD_WINGETOPT})
+    add_subdirectory(wingetopt)
+endif(${BUILD_WINGETOPT})
+# msvcregex
+if(${BUILD_MSVCREGEX})
+    add_library(msvcregex STATIC "")
+    target_sources(msvcregex
+        PRIVATE "msvcregex/regex.c"
+    )
+    target_include_directories(msvcregex
+        PRIVATE "msvcregex"
+    )
+    target_link_libraries(msvcregex 
+        INTERFACE Shell32
+    )
+    SET_TARGET_PROPERTIES(msvcregex PROPERTIES OUTPUT_NAME msvcregex)
+endif(${BUILD_MSVCREGEX})
+# msvcregex
+if(${BUILD_WCWIDTH})
+    add_library(wcwidth STATIC "")
+    target_sources(wcwidth
+        PRIVATE "wcwidth/wcwidth.c"
+    )
+    target_include_directories(wcwidth
+        PRIVATE "wcwidth"
+    )
+    SET_TARGET_PROPERTIES(wcwidth PROPERTIES OUTPUT_NAME wcwidth)
+endif(${BUILD_WCWIDTH})
 # CRAFT
 if(${BUILD_WITH_CRAFT})
    add_library(craft STATIC IMPORTED GLOBAL)
@@ -238,8 +319,12 @@ if(${BUILD_WITH_SQLITE})
    target_link_libraries(sqlite 
        INTERFACE m 
        INTERFACE pthread 
-        INTERFACE dl
    )
+    if(NOT TD_WINDOWS)
+        target_link_libraries(sqlite 
+            INTERFACE dl
+        )
+    endif(NOT TD_WINDOWS)
 endif(${BUILD_WITH_SQLITE})
 # pthread

--- a/contrib/test/craft/CMakeLists.txt
+++ b/contrib/test/craft/CMakeLists.txt
 add_executable(simulate_vnode "simulate_vnode.c")
 target_link_libraries(simulate_vnode PUBLIC craft lz4 uv_a)
\ No newline at end of file
+if(${BUILD_WINGETOPT})
+    target_link_libraries(simulate_vnode PUBLIC wingetopt)
+    target_include_directories(
+        simulate_vnode
+        PUBLIC "${TD_SOURCE_DIR}/contrib/wingetopt/src"
+    )
+endif()
\ No newline at end of file
--- a/contrib/test/tdev/src/main.c
+++ b/contrib/test/tdev/src/main.c
@@ -6,43 +6,39 @@
 #define POINTER_SHIFT(ptr, s) ((void *)(((char *)ptr) + (s)))
 #define POINTER_DISTANCE(pa, pb) ((char *)(pb) - (char *)(pa))
-#define tPutA(buf, val)              \
+static inline void tPutA(void **buf, uint64_t val) {
-  ({                                 \
+  memcpy(buf, &val, sizeof(val));
-    memcpy(buf, &val, sizeof(val));  \
+  *buf = POINTER_SHIFT(buf, sizeof(val));
-    POINTER_SHIFT(buf, sizeof(val)); \
+}
-  })
-#define tPutB(buf, val)                         \
+static inline void tPutB(void **buf, uint64_t val) {
-  ({                                            \
+  ((uint8_t *)buf)[7] = ((val) >> 56) & 0xff;
-    ((uint8_t *)buf)[7] = ((val) >> 56) & 0xff; \
+  ((uint8_t *)buf)[6] = ((val) >> 48) & 0xff;
-    ((uint8_t *)buf)[6] = ((val) >> 48) & 0xff; \
+  ((uint8_t *)buf)[5] = ((val) >> 40) & 0xff;
-    ((uint8_t *)buf)[5] = ((val) >> 40) & 0xff; \
+  ((uint8_t *)buf)[4] = ((val) >> 32) & 0xff;
-    ((uint8_t *)buf)[4] = ((val) >> 32) & 0xff; \
+  ((uint8_t *)buf)[3] = ((val) >> 24) & 0xff;
-    ((uint8_t *)buf)[3] = ((val) >> 24) & 0xff; \
+  ((uint8_t *)buf)[2] = ((val) >> 16) & 0xff;
-    ((uint8_t *)buf)[2] = ((val) >> 16) & 0xff; \
+  ((uint8_t *)buf)[1] = ((val) >> 8) & 0xff;
-    ((uint8_t *)buf)[1] = ((val) >> 8) & 0xff;  \
+  ((uint8_t *)buf)[0] = (val)&0xff;
-    ((uint8_t *)buf)[0] = (val)&0xff;           \
+  *buf = POINTER_SHIFT(buf, sizeof(val));
-    POINTER_SHIFT(buf, sizeof(val));            \
+}
-  })
-#define tPutC(buf, val)                \
+static inline void tPutC(void **buf, uint64_t val) {
-  ({                                   \
+  if (buf) {
-    if (buf) {                         \
+    ((uint64_t *)buf)[0] = (val);
-      ((uint64_t *)buf)[0] = (val);    \
+    POINTER_SHIFT(buf, sizeof(val));
-      POINTER_SHIFT(buf, sizeof(val)); \
+  }
-    }                                  \
+  *buf = NULL;
-    NULL;                                 \
+}
-  })
-#define tPutD(buf, val)                        \
+static inline void tPutD(void **buf, uint64_t val) {
-  ({                                           \
+  uint64_t tmp = val;
-    uint64_t tmp = val;                        \
+  for (size_t i = 0; i < sizeof(val); i++) {
-    for (size_t i = 0; i < sizeof(val); i++) { \
+    ((uint8_t *)buf)[i] = tmp & 0xff;
-      ((uint8_t *)buf)[i] = tmp & 0xff;        \
+    tmp >>= 8;
-      tmp >>= 8;                               \
+  }
-    }                                          \
+  *buf = POINTER_SHIFT(buf, sizeof(val));
-    POINTER_SHIFT(buf, sizeof(val));           \
+}
-  })
 static inline void tPutE(void **buf, uint64_t val) {
  if (buf) {
@@ -61,7 +57,7 @@ static void func(T t) {
  switch (t) {
    case A:
      for (size_t i = 0; i < 10 * 1024l * 1024l * 1024l; i++) {
-        pBuf = tPutA(pBuf, val);
+        tPutA(pBuf, val);
        if (POINTER_DISTANCE(buf, pBuf) == 1024) {
          pBuf = buf;
        }
@@ -69,7 +65,7 @@ static void func(T t) {
      break;
    case B:
      for (size_t i = 0; i < 10 * 1024l * 1024l * 1024l; i++) {
-        pBuf = tPutB(pBuf, val);
+        tPutB(pBuf, val);
        if (POINTER_DISTANCE(buf, pBuf) == 1024) {
          pBuf = buf;
        }
@@ -77,7 +73,7 @@ static void func(T t) {
      break;
    case C:
      for (size_t i = 0; i < 10 * 1024l * 1024l * 1024l; i++) {
-        pBuf = tPutC(pBuf, val);
+        tPutC(pBuf, val);
        if (POINTER_DISTANCE(buf, pBuf) == 1024) {
          pBuf = buf;
        }
@@ -85,7 +81,7 @@ static void func(T t) {
      break;
    case D:
      for (size_t i = 0; i < 10 * 1024l * 1024l * 1024l; i++) {
-        pBuf = tPutD(pBuf, val);
+        tPutD(pBuf, val);
        if (POINTER_DISTANCE(buf, pBuf) == 1024) {
          pBuf = buf;
        }

--- a/example/CMakeLists.txt
+++ b/example/CMakeLists.txt
@@ -30,6 +30,7 @@ target_link_libraries(demoapi
 )
 target_include_directories(tmq
+    PUBLIC "${TD_SOURCE_DIR}/include/os"
    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )

--- a/example/src/tmq.c
+++ b/example/src/tmq.c
@@ -17,7 +17,6 @@
 #include <stdio.h>
 #include <string.h>
 #include <time.h>
-#include <unistd.h>
 #include "taos.h"
 static int  running = 1;
@@ -48,7 +47,6 @@ int32_t init_env() {
    return -1;
  }
  taos_free_result(pRes);
-  sleep(1);
  pRes = taos_query(pConn, "use abc1");
  if (taos_errno(pRes) != 0) {

--- a/include/client/taos.h
+++ b/include/client/taos.h
@@ -27,10 +27,7 @@ typedef void   TAOS;
 typedef void   TAOS_STMT;
 typedef void   TAOS_RES;
 typedef void **TAOS_ROW;
-#if 0
+typedef void   TAOS_SUB;
-typedef void   TAOS_STREAM;
-#endif
-typedef void TAOS_SUB;
 // Data type definition
 #define TSDB_DATA_TYPE_NULL       0   // 1 bytes
@@ -88,18 +85,22 @@ typedef struct taosField {
  int32_t bytes;
 } TAOS_FIELD;
-#define DLL_EXPORT
+#ifdef WINDOWS
+  #define DLL_EXPORT    __declspec(dllexport)
+#else
+  #define DLL_EXPORT 
+#endif
 typedef void (*__taos_async_fn_t)(void *param, TAOS_RES *, int code);
-typedef struct TAOS_BIND_v2 {
+typedef struct TAOS_MULTI_BIND {
-  int      buffer_type;
+  int       buffer_type;
-  void    *buffer;
+  void     *buffer;
-  int32_t  buffer_length;
+  uintptr_t buffer_length;
-  int32_t *length;
+  int32_t  *length;
-  char    *is_null;
+  char     *is_null;
-  int      num;
+  int       num;
-} TAOS_BIND_v2;
+} TAOS_MULTI_BIND;
 typedef enum {
  SET_CONF_RET_SUCC = 0,
@@ -128,35 +129,35 @@ DLL_EXPORT void  taos_close(TAOS *taos);
 const char *taos_data_type(int type);
-DLL_EXPORT TAOS_STMT *taos_stmt_init(TAOS *taos);
+DLL_EXPORT TAOS_STMT  *taos_stmt_init(TAOS *taos);
-DLL_EXPORT int        taos_stmt_prepare(TAOS_STMT *stmt, const char *sql, unsigned long length);
+DLL_EXPORT int         taos_stmt_prepare(TAOS_STMT *stmt, const char *sql, unsigned long length);
-DLL_EXPORT int        taos_stmt_set_tbname_tags(TAOS_STMT *stmt, const char *name, TAOS_BIND_v2 *tags);
+DLL_EXPORT int         taos_stmt_set_tbname_tags(TAOS_STMT *stmt, const char *name, TAOS_MULTI_BIND *tags);
-DLL_EXPORT int        taos_stmt_set_tbname(TAOS_STMT *stmt, const char *name);
+DLL_EXPORT int         taos_stmt_set_tbname(TAOS_STMT *stmt, const char *name);
-DLL_EXPORT int        taos_stmt_set_sub_tbname(TAOS_STMT *stmt, const char *name);
+DLL_EXPORT int         taos_stmt_set_sub_tbname(TAOS_STMT *stmt, const char *name);
-DLL_EXPORT int       taos_stmt_is_insert(TAOS_STMT *stmt, int *insert);
+DLL_EXPORT int         taos_stmt_is_insert(TAOS_STMT *stmt, int *insert);
-DLL_EXPORT int       taos_stmt_num_params(TAOS_STMT *stmt, int *nums);
+DLL_EXPORT int         taos_stmt_num_params(TAOS_STMT *stmt, int *nums);
-DLL_EXPORT int       taos_stmt_get_param(TAOS_STMT *stmt, int idx, int *type, int *bytes);
+DLL_EXPORT int         taos_stmt_get_param(TAOS_STMT *stmt, int idx, int *type, int *bytes);
-DLL_EXPORT int       taos_stmt_bind_param(TAOS_STMT *stmt, TAOS_BIND_v2 *bind);
+DLL_EXPORT int         taos_stmt_bind_param(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind);
-DLL_EXPORT int       taos_stmt_bind_param_batch(TAOS_STMT *stmt, TAOS_BIND_v2 *bind);
+DLL_EXPORT int         taos_stmt_bind_param_batch(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind);
-DLL_EXPORT int       taos_stmt_bind_single_param_batch(TAOS_STMT *stmt, TAOS_BIND_v2 *bind, int colIdx);
+DLL_EXPORT int         taos_stmt_bind_single_param_batch(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind, int colIdx);
-DLL_EXPORT int       taos_stmt_add_batch(TAOS_STMT *stmt);
+DLL_EXPORT int         taos_stmt_add_batch(TAOS_STMT *stmt);
-DLL_EXPORT int       taos_stmt_execute(TAOS_STMT *stmt);
+DLL_EXPORT int         taos_stmt_execute(TAOS_STMT *stmt);
-DLL_EXPORT TAOS_RES *taos_stmt_use_result(TAOS_STMT *stmt);
+DLL_EXPORT TAOS_RES   *taos_stmt_use_result(TAOS_STMT *stmt);
-DLL_EXPORT int       taos_stmt_close(TAOS_STMT *stmt);
+DLL_EXPORT int         taos_stmt_close(TAOS_STMT *stmt);
-DLL_EXPORT char     *taos_stmt_errstr(TAOS_STMT *stmt);
+DLL_EXPORT char       *taos_stmt_errstr(TAOS_STMT *stmt);
-DLL_EXPORT int       taos_stmt_affected_rows(TAOS_STMT *stmt);
+DLL_EXPORT int         taos_stmt_affected_rows(TAOS_STMT *stmt);
-DLL_EXPORT int       taos_stmt_affected_rows_once(TAOS_STMT *stmt);
+DLL_EXPORT int         taos_stmt_affected_rows_once(TAOS_STMT *stmt);
-DLL_EXPORT TAOS_RES *taos_query(TAOS *taos, const char *sql);
+DLL_EXPORT TAOS_RES   *taos_query(TAOS *taos, const char *sql);
-DLL_EXPORT TAOS_RES *taos_query_l(TAOS *taos, const char *sql, int sqlLen);
+DLL_EXPORT TAOS_RES   *taos_query_l(TAOS *taos, const char *sql, int sqlLen);
-DLL_EXPORT TAOS_ROW taos_fetch_row(TAOS_RES *res);
+DLL_EXPORT TAOS_ROW    taos_fetch_row(TAOS_RES *res);
-DLL_EXPORT int      taos_result_precision(TAOS_RES *res);  // get the time precision of result
+DLL_EXPORT int         taos_result_precision(TAOS_RES *res);  // get the time precision of result
-DLL_EXPORT void     taos_free_result(TAOS_RES *res);
+DLL_EXPORT void        taos_free_result(TAOS_RES *res);
-DLL_EXPORT int      taos_field_count(TAOS_RES *res);
+DLL_EXPORT int         taos_field_count(TAOS_RES *res);
-DLL_EXPORT int      taos_num_fields(TAOS_RES *res);
+DLL_EXPORT int         taos_num_fields(TAOS_RES *res);
-DLL_EXPORT int      taos_affected_rows(TAOS_RES *res);
+DLL_EXPORT int         taos_affected_rows(TAOS_RES *res);
 DLL_EXPORT TAOS_FIELD *taos_fetch_fields(TAOS_RES *res);
 DLL_EXPORT int         taos_select_db(TAOS *taos, const char *db);
@@ -192,12 +193,6 @@ DLL_EXPORT TAOS_RES *taos_consume(TAOS_SUB *tsub);
 DLL_EXPORT void      taos_unsubscribe(TAOS_SUB *tsub, int keepProgress);
 #endif
-#if 0
-DLL_EXPORT TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sql, void (*fp)(void *param, TAOS_RES *, TAOS_ROW row),
-                                         int64_t stime, void *param, void (*callback)(void *));
-DLL_EXPORT void         taos_close_stream(TAOS_STREAM *tstr);
-#endif
 DLL_EXPORT int       taos_load_table_info(TAOS *taos, const char *tableNameList);
 DLL_EXPORT TAOS_RES *taos_schemaless_insert(TAOS *taos, char *lines[], int numLines, int protocol, int precision);
@@ -237,12 +232,8 @@ DLL_EXPORT const char *tmq_err2str(tmq_resp_err_t);
 DLL_EXPORT tmq_resp_err_t tmq_subscribe(tmq_t *tmq, const tmq_list_t *topic_list);
 DLL_EXPORT tmq_resp_err_t tmq_unsubscribe(tmq_t *tmq);
 DLL_EXPORT tmq_resp_err_t tmq_subscription(tmq_t *tmq, tmq_list_t **topics);
-DLL_EXPORT TAOS_RES      *tmq_consumer_poll(tmq_t *tmq, int64_t blocking_time);
+DLL_EXPORT TAOS_RES      *tmq_consumer_poll(tmq_t *tmq, int64_t wait_time);
 DLL_EXPORT tmq_resp_err_t tmq_consumer_close(tmq_t *tmq);
-#if 0
-DLL_EXPORT tmq_resp_err_t tmq_assign(tmq_t* tmq, const tmq_topic_vgroup_list_t* vgroups);
-DLL_EXPORT tmq_resp_err_t tmq_assignment(tmq_t* tmq, tmq_topic_vgroup_list_t** vgroups);
-#endif
 DLL_EXPORT tmq_resp_err_t tmq_commit(tmq_t *tmq, const tmq_topic_vgroup_list_t *offsets, int32_t async);
 #if 0
 DLL_EXPORT tmq_resp_err_t tmq_commit_message(tmq_t* tmq, const tmq_message_t* tmqmessage, int32_t async);
@@ -269,7 +260,7 @@ DLL_EXPORT char   *tmq_get_topic_name(TAOS_RES *res);
 DLL_EXPORT int32_t tmq_get_vgroup_id(TAOS_RES *res);
 // TODO
 #if 0
-DLL_EXPORT char   *tmq_get_block_table_name(TAOS_RES *res);
+DLL_EXPORT char   *tmq_get_table_name(TAOS_RES *res);
 #endif
 #if 0

--- a/include/common/tcommon.h
+++ b/include/common/tcommon.h
@@ -66,13 +66,13 @@ typedef struct SDataBlockInfo {
  int32_t     rows;
  int32_t     rowSize;
  union {
-    int64_t uid;        // from which table of uid, comes from this data block
+    int64_t uid;  // from which table of uid, comes from this data block
    int64_t blockId;
  };
-  uint64_t    groupId;  // no need to serialize
+  uint64_t groupId;  // no need to serialize
-  int16_t     numOfCols;
+  int16_t  numOfCols;
-  int16_t     hasVarCol;
+  int16_t  hasVarCol;
-  int16_t     capacity;
+  int16_t  capacity;
 } SDataBlockInfo;
 typedef struct SSDataBlock {
@@ -99,6 +99,15 @@ typedef struct SColumnInfoData {
  };
 } SColumnInfoData;
+typedef struct SQueryTableDataCond {
+  STimeWindow  twindow;
+  int32_t      order;  // desc|asc order to iterate the data block
+  int32_t      numOfCols;
+  SColumnInfo *colList;
+  bool         loadExternalRows;  // load external rows or not
+  int32_t      type;              // data block load type:
+} SQueryTableDataCond;
 void*   blockDataDestroy(SSDataBlock* pBlock);
 int32_t tEncodeDataBlock(void** buf, const SSDataBlock* pBlock);
 void*   tDecodeDataBlock(const void* buf, SSDataBlock* pBlock);
@@ -122,59 +131,6 @@ static FORCE_INLINE void blockDestroyInner(SSDataBlock* pBlock) {
 static FORCE_INLINE void tDeleteSSDataBlock(SSDataBlock* pBlock) { blockDestroyInner(pBlock); }
-static FORCE_INLINE int32_t tEncodeSMqPollRsp(void** buf, const SMqPollRsp* pRsp) {
-  int32_t tlen = 0;
-  int32_t sz = 0;
-  // tlen += taosEncodeFixedI64(buf, pRsp->consumerId);
-  tlen += taosEncodeFixedI64(buf, pRsp->reqOffset);
-  tlen += taosEncodeFixedI64(buf, pRsp->rspOffset);
-  tlen += taosEncodeFixedI32(buf, pRsp->skipLogNum);
-  tlen += taosEncodeFixedI32(buf, pRsp->numOfTopics);
-  if (pRsp->numOfTopics == 0) return tlen;
-  tlen += taosEncodeSSchemaWrapper(buf, pRsp->schema);
-  if (pRsp->pBlockData) {
-    sz = taosArrayGetSize(pRsp->pBlockData);
-  }
-  tlen += taosEncodeFixedI32(buf, sz);
-  for (int32_t i = 0; i < sz; i++) {
-    SSDataBlock* pBlock = (SSDataBlock*)taosArrayGet(pRsp->pBlockData, i);
-    tlen += tEncodeDataBlock(buf, pBlock);
-  }
-  return tlen;
-}
-static FORCE_INLINE void* tDecodeSMqPollRsp(void* buf, SMqPollRsp* pRsp) {
-  int32_t sz;
-  // buf = taosDecodeFixedI64(buf, &pRsp->consumerId);
-  buf = taosDecodeFixedI64(buf, &pRsp->reqOffset);
-  buf = taosDecodeFixedI64(buf, &pRsp->rspOffset);
-  buf = taosDecodeFixedI32(buf, &pRsp->skipLogNum);
-  buf = taosDecodeFixedI32(buf, &pRsp->numOfTopics);
-  if (pRsp->numOfTopics == 0) return buf;
-  pRsp->schema = (SSchemaWrapper*)taosMemoryCalloc(1, sizeof(SSchemaWrapper));
-  if (pRsp->schema == NULL) return NULL;
-  buf = taosDecodeSSchemaWrapper(buf, pRsp->schema);
-  buf = taosDecodeFixedI32(buf, &sz);
-  pRsp->pBlockData = taosArrayInit(sz, sizeof(SSDataBlock));
-  for (int32_t i = 0; i < sz; i++) {
-    SSDataBlock block = {0};
-    tDecodeDataBlock(buf, &block);
-    taosArrayPush(pRsp->pBlockData, &block);
-  }
-  return buf;
-}
-static FORCE_INLINE void tDeleteSMqConsumeRsp(SMqPollRsp* pRsp) {
-  if (pRsp->schema) {
-    if (pRsp->schema->nCols) {
-      taosMemoryFreeClear(pRsp->schema->pSchema);
-    }
-    taosMemoryFree(pRsp->schema);
-  }
-  taosArrayDestroyEx(pRsp->pBlockData, (void (*)(void*))blockDestroyInner);
-  pRsp->pBlockData = NULL;
-}
 //======================================================================================================================
 // the following structure shared by parser and executor
 typedef struct SColumn {
@@ -195,22 +151,22 @@ typedef struct SColumn {
 } SColumn;
 typedef struct STableBlockDistInfo {
-  uint16_t  rowSize;
+  uint16_t rowSize;
-  uint16_t  numOfFiles;
+  uint16_t numOfFiles;
-  uint32_t  numOfTables;
+  uint32_t numOfTables;
-  uint64_t  totalSize;
+  uint64_t totalSize;
-  uint64_t  totalRows;
+  uint64_t totalRows;
-  int32_t   maxRows;
+  int32_t  maxRows;
-  int32_t   minRows;
+  int32_t  minRows;
-  int32_t   firstSeekTimeUs;
+  int32_t  firstSeekTimeUs;
-  uint32_t  numOfRowsInMemTable;
+  uint32_t numOfRowsInMemTable;
-  uint32_t  numOfSmallBlocks;
+  uint32_t numOfSmallBlocks;
-  SArray   *dataBlockInfos;
+  SArray*  dataBlockInfos;
 } STableBlockDistInfo;
 enum {
  FUNC_PARAM_TYPE_VALUE = 0x1,
-  FUNC_PARAM_TYPE_COLUMN= 0x2,
+  FUNC_PARAM_TYPE_COLUMN = 0x2,
 };
 typedef struct SFunctParam {
@@ -229,7 +185,6 @@ typedef struct SResSchame {
  char    name[TSDB_COL_NAME_LEN];
 } SResSchema;
-// TODO move away to executor.h
 typedef struct SExprBasicInfo {
  SResSchema   resSchema;
  int16_t      numOfParams;  // argument value of each function
@@ -241,7 +196,7 @@ typedef struct SExprInfo {
  struct tExprNode*     pExpr;
 } SExprInfo;
-#define QUERY_ASC_FORWARD_STEP 1
+#define QUERY_ASC_FORWARD_STEP  1
 #define QUERY_DESC_FORWARD_STEP -1
 #define GET_FORWARD_DIRECTION_FACTOR(ord) (((ord) == TSDB_ORDER_ASC) ? QUERY_ASC_FORWARD_STEP : QUERY_DESC_FORWARD_STEP)

--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@@ -231,12 +231,12 @@ typedef struct {
  int32_t totalLen;
  int32_t len;
  // head of SSubmitBlk
-  // int64_t uid;        // table unique id
+  int64_t uid;        // table unique id
-  // int64_t suid;       // stable id
+  int64_t suid;       // stable id
-  // int32_t sversion;   // data schema version
+  int32_t sversion;   // data schema version
-  // int32_t dataLen;    // data part length, not including the SSubmitBlk head
+  int32_t dataLen;    // data part length, not including the SSubmitBlk head
-  // int32_t schemaLen;  // schema length, if length is 0, no schema exists
+  int32_t schemaLen;  // schema length, if length is 0, no schema exists
-  // int16_t numOfRows;  // total number of rows in current submit block
+  int16_t numOfRows;  // total number of rows in current submit block
  // head of SSubmitBlk
  const void* pMsg;
 } SSubmitMsgIter;
@@ -250,10 +250,10 @@ STSRow* tGetSubmitBlkNext(SSubmitBlkIter* pIter);
 // 1) use tInitSubmitMsgIterEx firstly as not decrease the merge conflicts
 // 2) replace tInitSubmitMsgIterEx with tInitSubmitMsgIter later
 // 3) finally, rename tInitSubmitMsgIterEx to tInitSubmitMsgIter
-// int32_t tInitSubmitMsgIterEx(const SSubmitReq* pMsg, SSubmitMsgIter* pIter);
+int32_t tInitSubmitMsgIterEx(const SSubmitReq* pMsg, SSubmitMsgIter* pIter);
-// int32_t tGetSubmitMsgNextEx(SSubmitMsgIter* pIter, SSubmitBlk** pPBlock);
+int32_t tGetSubmitMsgNextEx(SSubmitMsgIter* pIter, SSubmitBlk** pPBlock);
-// int32_t tInitSubmitBlkIterEx(SSubmitMsgIter* pMsgIter, SSubmitBlk* pBlock, SSubmitBlkIter* pIter);
+int32_t tInitSubmitBlkIterEx(SSubmitMsgIter* pMsgIter, SSubmitBlk* pBlock, SSubmitBlkIter* pIter);
-// STSRow* tGetSubmitBlkNextEx(SSubmitBlkIter* pIter);
+STSRow* tGetSubmitBlkNextEx(SSubmitBlkIter* pIter);
 typedef struct {
  int32_t index;  // index of failed block in submit blocks
@@ -287,6 +287,12 @@ typedef struct SSchema {
 #define SSCHMEA_BYTES(s) ((s)->bytes)
 #define SSCHMEA_NAME(s)  ((s)->name)
+typedef struct {
+  int32_t  nCols;
+  int32_t  sver;
+  SSchema* pSchema;
+} SSchemaWrapper;
 STSchema* tdGetSTSChemaFromSSChema(SSchema** pSchema, int32_t nCols);
 typedef struct {
@@ -1514,57 +1520,81 @@ typedef struct {
  char*   qmsg2;  // pAst2:qmsg2:SRetention2 => trigger aggr task2
 } SRSmaParam;
+int tEncodeSRSmaParam(SCoder* pCoder, const SRSmaParam* pRSmaParam);
+int tDecodeSRSmaParam(SCoder* pCoder, SRSmaParam* pRSmaParam);
+typedef struct SVCreateStbReq {
+  const char*    name;
+  tb_uid_t       suid;
+  int8_t         rollup;
+  SSchemaWrapper schema;
+  SSchemaWrapper schemaTag;
+  SRSmaParam     pRSmaParam;
+} SVCreateStbReq;
+int tEncodeSVCreateStbReq(SCoder* pCoder, const SVCreateStbReq* pReq);
+int tDecodeSVCreateStbReq(SCoder* pCoder, SVCreateStbReq* pReq);
+typedef struct SVDropStbReq {
+  // data
+} SVDropStbReq;
+typedef struct SVCreateStbRsp {
+  int code;
+} SVCreateStbRsp;
 typedef struct SVCreateTbReq {
-  char*    name;
+  tb_uid_t    uid;
-  uint32_t ttl;
+  int64_t     ctime;
-  uint32_t keep;
+  const char* name;
-  union {
+  int32_t     ttl;
-    uint8_t info;
+  int8_t      type;
-    struct {
-      uint8_t rollup : 1;  // 1 means rollup sma
-      uint8_t type : 7;
-    };
-  };
  union {
    struct {
      tb_uid_t    suid;
-      col_id_t    nCols;
+      const void* pTag;
-      SSchema*    pSchema;
+    } ctb;
-      col_id_t    nTagCols;
-      SSchema*    pTagSchema;
-      SRSmaParam* pRSmaParam;
-    } stbCfg;
    struct {
-      tb_uid_t suid;
+      SSchemaWrapper schema;
-      SKVRow   pTag;
+    } ntb;
-    } ctbCfg;
-    struct {
-      col_id_t    nCols;
-      SSchema*    pSchema;
-      SRSmaParam* pRSmaParam;
-    } ntbCfg;
  };
-} SVCreateTbReq, SVUpdateTbReq;
+} SVCreateTbReq;
+int tEncodeSVCreateTbReq(SCoder* pCoder, const SVCreateTbReq* pReq);
+int tDecodeSVCreateTbReq(SCoder* pCoder, SVCreateTbReq* pReq);
+typedef struct {
+  int32_t nReqs;
+  union {
+    SVCreateTbReq* pReqs;
+    SArray*        pArray;
+  };
+} SVCreateTbBatchReq;
+int tEncodeSVCreateTbBatchReq(SCoder* pCoder, const SVCreateTbBatchReq* pReq);
+int tDecodeSVCreateTbBatchReq(SCoder* pCoder, SVCreateTbBatchReq* pReq);
 typedef struct {
  int32_t code;
 } SVCreateTbRsp, SVUpdateTbRsp;
+int tEncodeSVCreateTbRsp(SCoder* pCoder, const SVCreateTbRsp* pRsp);
+int tDecodeSVCreateTbRsp(SCoder* pCoder, SVCreateTbRsp* pRsp);
 int32_t tSerializeSVCreateTbReq(void** buf, SVCreateTbReq* pReq);
 void*   tDeserializeSVCreateTbReq(void* buf, SVCreateTbReq* pReq);
 typedef struct {
-  int64_t ver;  // use a general definition
+  int32_t nRsps;
-  SArray* pArray;
+  union {
-} SVCreateTbBatchReq;
+    SVCreateTbRsp* pRsps;
+    SArray*        pArray;
-int32_t tSerializeSVCreateTbBatchReq(void** buf, SVCreateTbBatchReq* pReq);
+  };
-void*   tDeserializeSVCreateTbBatchReq(void* buf, SVCreateTbBatchReq* pReq);
-typedef struct {
-  SArray* rspList;  // SArray<SVCreateTbRsp>
 } SVCreateTbBatchRsp;
+int tEncodeSVCreateTbBatchRsp(SCoder* pCoder, const SVCreateTbBatchRsp* pRsp);
+int tDecodeSVCreateTbBatchRsp(SCoder* pCoder, SVCreateTbBatchRsp* pRsp);
 int32_t tSerializeSVCreateTbBatchRsp(void* buf, int32_t bufLen, SVCreateTbBatchRsp* pRsp);
 int32_t tDeserializeSVCreateTbBatchRsp(void* buf, int32_t bufLen, SVCreateTbBatchRsp* pRsp);
@@ -1619,103 +1649,11 @@ typedef struct {
  char    data[];
 } SVShowTablesFetchRsp;
-typedef struct SMqCMGetSubEpReq {
+typedef struct {
  int64_t consumerId;
  int32_t epoch;
  char    cgroup[TSDB_CGROUP_LEN];
-} SMqCMGetSubEpReq;
+} SMqAskEpReq;
-static FORCE_INLINE int32_t tEncodeSMsgHead(void** buf, const SMsgHead* pMsg) {
-  int32_t tlen = 0;
-  tlen += taosEncodeFixedI32(buf, pMsg->contLen);
-  tlen += taosEncodeFixedI32(buf, pMsg->vgId);
-  return tlen;
-}
-typedef struct SMqHbRsp {
-  int8_t status;  // idle or not
-  int8_t vnodeChanged;
-  int8_t epChanged;  // should use new epset
-  int8_t reserved;
-  SEpSet epSet;
-} SMqHbRsp;
-static FORCE_INLINE int32_t taosEncodeSMqHbRsp(void** buf, const SMqHbRsp* pRsp) {
-  int32_t tlen = 0;
-  tlen += taosEncodeFixedI8(buf, pRsp->status);
-  tlen += taosEncodeFixedI8(buf, pRsp->vnodeChanged);
-  tlen += taosEncodeFixedI8(buf, pRsp->epChanged);
-  tlen += taosEncodeSEpSet(buf, &pRsp->epSet);
-  return tlen;
-}
-static FORCE_INLINE void* taosDecodeSMqHbRsp(void* buf, SMqHbRsp* pRsp) {
-  buf = taosDecodeFixedI8(buf, &pRsp->status);
-  buf = taosDecodeFixedI8(buf, &pRsp->vnodeChanged);
-  buf = taosDecodeFixedI8(buf, &pRsp->epChanged);
-  buf = taosDecodeSEpSet(buf, &pRsp->epSet);
-  return buf;
-}
-typedef struct SMqHbOneTopicBatchRsp {
-  char    topicName[TSDB_TOPIC_FNAME_LEN];
-  SArray* rsps;  // SArray<SMqHbRsp>
-} SMqHbOneTopicBatchRsp;
-static FORCE_INLINE int32_t taosEncodeSMqHbOneTopicBatchRsp(void** buf, const SMqHbOneTopicBatchRsp* pBatchRsp) {
-  int32_t tlen = 0;
-  tlen += taosEncodeString(buf, pBatchRsp->topicName);
-  int32_t sz = taosArrayGetSize(pBatchRsp->rsps);
-  tlen += taosEncodeFixedI32(buf, sz);
-  for (int32_t i = 0; i < sz; i++) {
-    SMqHbRsp* pRsp = (SMqHbRsp*)taosArrayGet(pBatchRsp->rsps, i);
-    tlen += taosEncodeSMqHbRsp(buf, pRsp);
-  }
-  return tlen;
-}
-static FORCE_INLINE void* taosDecodeSMqHbOneTopicBatchRsp(void* buf, SMqHbOneTopicBatchRsp* pBatchRsp) {
-  int32_t sz;
-  buf = taosDecodeStringTo(buf, pBatchRsp->topicName);
-  buf = taosDecodeFixedI32(buf, &sz);
-  pBatchRsp->rsps = taosArrayInit(sz, sizeof(SMqHbRsp));
-  for (int32_t i = 0; i < sz; i++) {
-    SMqHbRsp rsp;
-    buf = taosDecodeSMqHbRsp(buf, &rsp);
-    buf = taosArrayPush(pBatchRsp->rsps, &rsp);
-  }
-  return buf;
-}
-typedef struct SMqHbBatchRsp {
-  int64_t consumerId;
-  SArray* batchRsps;  // SArray<SMqHbOneTopicBatchRsp>
-} SMqHbBatchRsp;
-static FORCE_INLINE int32_t taosEncodeSMqHbBatchRsp(void** buf, const SMqHbBatchRsp* pBatchRsp) {
-  int32_t tlen = 0;
-  tlen += taosEncodeFixedI64(buf, pBatchRsp->consumerId);
-  int32_t sz;
-  tlen += taosEncodeFixedI32(buf, sz);
-  for (int32_t i = 0; i < sz; i++) {
-    SMqHbOneTopicBatchRsp* pRsp = (SMqHbOneTopicBatchRsp*)taosArrayGet(pBatchRsp->batchRsps, i);
-    tlen += taosEncodeSMqHbOneTopicBatchRsp(buf, pRsp);
-  }
-  return tlen;
-}
-static FORCE_INLINE void* taosDecodeSMqHbBatchRsp(void* buf, SMqHbBatchRsp* pBatchRsp) {
-  buf = taosDecodeFixedI64(buf, &pBatchRsp->consumerId);
-  int32_t sz;
-  buf = taosDecodeFixedI32(buf, &sz);
-  pBatchRsp->batchRsps = taosArrayInit(sz, sizeof(SMqHbOneTopicBatchRsp));
-  for (int32_t i = 0; i < sz; i++) {
-    SMqHbOneTopicBatchRsp rsp;
-    buf = taosDecodeSMqHbOneTopicBatchRsp(buf, &rsp);
-    buf = taosArrayPush(pBatchRsp->batchRsps, &rsp);
-  }
-  return buf;
-}
 typedef struct {
  int32_t key;
@@ -2084,15 +2022,11 @@ int32_t tDecodeSMqOffset(SCoder* decoder, SMqOffset* pOffset);
 int32_t tEncodeSMqCMCommitOffsetReq(SCoder* encoder, const SMqCMCommitOffsetReq* pReq);
 int32_t tDecodeSMqCMCommitOffsetReq(SCoder* decoder, SMqCMCommitOffsetReq* pReq);
-typedef struct {
-  uint32_t nCols;
-  SSchema* pSchema;
-} SSchemaWrapper;
 static FORCE_INLINE SSchemaWrapper* tCloneSSchemaWrapper(const SSchemaWrapper* pSchemaWrapper) {
  SSchemaWrapper* pSW = (SSchemaWrapper*)taosMemoryMalloc(sizeof(SSchemaWrapper));
  if (pSW == NULL) return pSW;
  pSW->nCols = pSchemaWrapper->nCols;
+  pSW->sver = pSchemaWrapper->sver;
  pSW->pSchema = (SSchema*)taosMemoryCalloc(pSW->nCols, sizeof(SSchema));
  if (pSW->pSchema == NULL) {
    taosMemoryFree(pSW);
@@ -2129,8 +2063,8 @@ static FORCE_INLINE void* taosDecodeSSchema(const void* buf, SSchema* pSchema) {
 static FORCE_INLINE int32_t tEncodeSSchema(SCoder* pEncoder, const SSchema* pSchema) {
  if (tEncodeI8(pEncoder, pSchema->type) < 0) return -1;
  if (tEncodeI8(pEncoder, pSchema->flags) < 0) return -1;
-  if (tEncodeI32(pEncoder, pSchema->bytes) < 0) return -1;
+  if (tEncodeI32v(pEncoder, pSchema->bytes) < 0) return -1;
-  if (tEncodeI16(pEncoder, pSchema->colId) < 0) return -1;
+  if (tEncodeI16v(pEncoder, pSchema->colId) < 0) return -1;
  if (tEncodeCStr(pEncoder, pSchema->name) < 0) return -1;
  return 0;
 }
@@ -2138,15 +2072,16 @@ static FORCE_INLINE int32_t tEncodeSSchema(SCoder* pEncoder, const SSchema* pSch
 static FORCE_INLINE int32_t tDecodeSSchema(SCoder* pDecoder, SSchema* pSchema) {
  if (tDecodeI8(pDecoder, &pSchema->type) < 0) return -1;
  if (tDecodeI8(pDecoder, &pSchema->flags) < 0) return -1;
-  if (tDecodeI32(pDecoder, &pSchema->bytes) < 0) return -1;
+  if (tDecodeI32v(pDecoder, &pSchema->bytes) < 0) return -1;
-  if (tDecodeI16(pDecoder, &pSchema->colId) < 0) return -1;
+  if (tDecodeI16v(pDecoder, &pSchema->colId) < 0) return -1;
  if (tDecodeCStrTo(pDecoder, pSchema->name) < 0) return -1;
  return 0;
 }
 static FORCE_INLINE int32_t taosEncodeSSchemaWrapper(void** buf, const SSchemaWrapper* pSW) {
  int32_t tlen = 0;
-  tlen += taosEncodeFixedU32(buf, pSW->nCols);
+  tlen += taosEncodeVariantI32(buf, pSW->nCols);
+  tlen += taosEncodeVariantI32(buf, pSW->sver);
  for (int32_t i = 0; i < pSW->nCols; i++) {
    tlen += taosEncodeSSchema(buf, &pSW->pSchema[i]);
  }
@@ -2154,7 +2089,8 @@ static FORCE_INLINE int32_t taosEncodeSSchemaWrapper(void** buf, const SSchemaWr
 }
 static FORCE_INLINE void* taosDecodeSSchemaWrapper(const void* buf, SSchemaWrapper* pSW) {
-  buf = taosDecodeFixedU32(buf, &pSW->nCols);
+  buf = taosDecodeVariantI32(buf, &pSW->nCols);
+  buf = taosDecodeVariantI32(buf, &pSW->sver);
  pSW->pSchema = (SSchema*)taosMemoryCalloc(pSW->nCols, sizeof(SSchema));
  if (pSW->pSchema == NULL) {
    return NULL;
@@ -2167,23 +2103,25 @@ static FORCE_INLINE void* taosDecodeSSchemaWrapper(const void* buf, SSchemaWrapp
 }
 static FORCE_INLINE int32_t tEncodeSSchemaWrapper(SCoder* pEncoder, const SSchemaWrapper* pSW) {
-  if (tEncodeU32(pEncoder, pSW->nCols) < 0) return -1;
+  if (tEncodeI32v(pEncoder, pSW->nCols) < 0) return -1;
+  if (tEncodeI32v(pEncoder, pSW->sver) < 0) return -1;
  for (int32_t i = 0; i < pSW->nCols; i++) {
    if (tEncodeSSchema(pEncoder, &pSW->pSchema[i]) < 0) return -1;
  }
-  return pEncoder->pos;
+  return 0;
 }
 static FORCE_INLINE int32_t tDecodeSSchemaWrapper(SCoder* pDecoder, SSchemaWrapper* pSW) {
-  if (tDecodeU32(pDecoder, &pSW->nCols) < 0) return -1;
+  if (tDecodeI32v(pDecoder, &pSW->nCols) < 0) return -1;
-  void* ptr = taosMemoryRealloc(pSW->pSchema, pSW->nCols * sizeof(SSchema));
+  if (tDecodeI32v(pDecoder, &pSW->sver) < 0) return -1;
-  if (ptr == NULL) {
-    return -1;
+  pSW->pSchema = (SSchema*)TCODER_MALLOC(pDecoder, sizeof(SSchema) * pSW->nCols);
-  }
+  if (pSW->pSchema == NULL) return -1;
-  pSW->pSchema = (SSchema*)ptr;
  for (int32_t i = 0; i < pSW->nCols; i++) {
    if (tDecodeSSchema(pDecoder, &pSW->pSchema[i]) < 0) return -1;
  }
  return 0;
 }
@@ -2439,22 +2377,6 @@ typedef struct {
  int64_t consumerId;
 } SMqRspHead;
-#if 0
-typedef struct {
-  SMsgHead head;
-  int64_t consumerId;
-  int64_t blockingTime;
-  int32_t epoch;
-  int8_t  withSchema;
-  char    cgroup[TSDB_CGROUP_LEN];
-  int64_t  currentOffset;
-  uint64_t reqId;
-  char     topic[TSDB_TOPIC_FNAME_LEN];
-} SMqPollReq;
-#endif
 typedef struct {
  SMsgHead head;
  char     subKey[TSDB_SUBSCRIBE_KEY_LEN];
@@ -2478,18 +2400,6 @@ typedef struct {
  SSchemaWrapper schema;
 } SMqSubTopicEp;
-typedef struct {
-  SMqRspHead head;
-  int64_t    reqOffset;
-  int64_t    rspOffset;
-  int32_t    skipLogNum;
-  // TODO: replace with topic name
-  int32_t numOfTopics;
-  // TODO: remove from msg
-  SSchemaWrapper* schema;
-  SArray*         pBlockData;  // SArray<SSDataBlock>
-} SMqPollRsp;
 typedef struct {
  SMqRspHead head;
  int64_t    reqOffset;
@@ -2613,7 +2523,7 @@ typedef struct {
  SMqRspHead head;
  char       cgroup[TSDB_CGROUP_LEN];
  SArray*    topics;  // SArray<SMqSubTopicEp>
-} SMqCMGetSubEpRsp;
+} SMqAskEpRsp;
 static FORCE_INLINE void tDeleteSMqSubTopicEp(SMqSubTopicEp* pSubTopicEp) {
  // taosMemoryFree(pSubTopicEp->schema.pSchema);
@@ -2635,10 +2545,6 @@ static FORCE_INLINE void* tDecodeSMqSubVgEp(void* buf, SMqSubVgEp* pVgEp) {
  return buf;
 }
-static FORCE_INLINE void tDeleteSMqCMGetSubEpRsp(SMqCMGetSubEpRsp* pRsp) {
-  taosArrayDestroyEx(pRsp->topics, (void (*)(void*))tDeleteSMqSubTopicEp);
-}
 static FORCE_INLINE int32_t tEncodeSMqSubTopicEp(void** buf, const SMqSubTopicEp* pTopicEp) {
  int32_t tlen = 0;
  tlen += taosEncodeString(buf, pTopicEp->topic);
@@ -2671,7 +2577,7 @@ static FORCE_INLINE void* tDecodeSMqSubTopicEp(void* buf, SMqSubTopicEp* pTopicE
  return buf;
 }
-static FORCE_INLINE int32_t tEncodeSMqCMGetSubEpRsp(void** buf, const SMqCMGetSubEpRsp* pRsp) {
+static FORCE_INLINE int32_t tEncodeSMqAskEpRsp(void** buf, const SMqAskEpRsp* pRsp) {
  int32_t tlen = 0;
  // tlen += taosEncodeString(buf, pRsp->cgroup);
  int32_t sz = taosArrayGetSize(pRsp->topics);
@@ -2683,7 +2589,7 @@ static FORCE_INLINE int32_t tEncodeSMqCMGetSubEpRsp(void** buf, const SMqCMGetSu
  return tlen;
 }
-static FORCE_INLINE void* tDecodeSMqCMGetSubEpRsp(void* buf, SMqCMGetSubEpRsp* pRsp) {
+static FORCE_INLINE void* tDecodeSMqAskEpRsp(void* buf, SMqAskEpRsp* pRsp) {
  // buf = taosDecodeStringTo(buf, pRsp->cgroup);
  int32_t sz;
  buf = taosDecodeFixedI32(buf, &sz);
@@ -2699,6 +2605,10 @@ static FORCE_INLINE void* tDecodeSMqCMGetSubEpRsp(void* buf, SMqCMGetSubEpRsp* p
  return buf;
 }
+static FORCE_INLINE void tDeleteSMqAskEpRsp(SMqAskEpRsp* pRsp) {
+  taosArrayDestroyEx(pRsp->topics, (void (*)(void*))tDeleteSMqSubTopicEp);
+}
 #pragma pack(pop)
 #ifdef __cplusplus

--- a/include/common/tmsgdef.h
+++ b/include/common/tmsgdef.h
@@ -145,7 +145,7 @@ enum {
  TD_DEF_MSG_TYPE(TDMT_MND_ALTER_TOPIC, "mnode-alter-topic", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_MND_DROP_TOPIC, "mnode-drop-topic", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_MND_SUBSCRIBE, "mnode-subscribe", SCMSubscribeReq, SCMSubscribeRsp)
-  TD_DEF_MSG_TYPE(TDMT_MND_GET_SUB_EP, "mnode-mq-ask-ep", SMqCMGetSubEpReq, SMqCMGetSubEpRsp)
+  TD_DEF_MSG_TYPE(TDMT_MND_MQ_ASK_EP, "mnode-mq-ask-ep", SMqAskEpReq, SMqAskEpReq)
  TD_DEF_MSG_TYPE(TDMT_MND_MQ_TIMER, "mnode-mq-tmr", SMTimerReq, SMTimerReq)
  TD_DEF_MSG_TYPE(TDMT_MND_MQ_CONSUMER_LOST, "mnode-mq-consumer-lost", SMTimerReq, SMTimerReq)
  TD_DEF_MSG_TYPE(TDMT_MND_MQ_DO_REBALANCE, "mnode-mq-do-rebalance", SMqDoRebalanceMsg, SMqDoRebalanceMsg)

--- a/include/common/trow.h
+++ b/include/common/trow.h
@@ -23,7 +23,6 @@
 #include "tbuffer.h"
 #include "tdataformat.h"
 #include "tdef.h"
-#include "tschema.h"
 #include "ttypes.h"
 #include "tutil.h"
@@ -58,12 +57,12 @@ extern "C" {
 #define TD_ROWS_ALL_NORM  0x00U
 #define TD_ROWS_NULL_NORM 0x01U
-#define TD_COL_ROWS_NORM(c) ((c)->bitmap == TD_ROWS_ALL_NORM)  // all rows of SDataCol/SBlockCol is NORM
+#define TD_COL_ROWS_NORM(c)          ((c)->bitmap == TD_ROWS_ALL_NORM)  // all rows of SDataCol/SBlockCol is NORM
 #define TD_SET_COL_ROWS_BTIMAP(c, v) ((c)->bitmap = (v))
-#define TD_SET_COL_ROWS_NORM(c) TD_SET_COL_ROWS_BTIMAP((c), TD_ROWS_ALL_NORM)
+#define TD_SET_COL_ROWS_NORM(c)      TD_SET_COL_ROWS_BTIMAP((c), TD_ROWS_ALL_NORM)
-#define TD_SET_COL_ROWS_MISC(c) TD_SET_COL_ROWS_BTIMAP((c), TD_ROWS_NULL_NORM)
+#define TD_SET_COL_ROWS_MISC(c)      TD_SET_COL_ROWS_BTIMAP((c), TD_ROWS_NULL_NORM)
-#define KvConvertRatio (0.9f)
+#define KvConvertRatio            (0.9f)
 #define isSelectKVRow(klen, tlen) ((klen) < ((tlen)*KvConvertRatio))
 #ifdef TD_SUPPORT_BITMAP
@@ -341,7 +340,8 @@ static FORCE_INLINE bool tdIsBitmapValTypeNorm(const void *pBitmap, int16_t idx,
  return false;
 }
-static FORCE_INLINE int32_t tdGetBitmapValType(const void *pBitmap, int16_t colIdx, TDRowValT *pValType, int8_t bitmapMode) {
+static FORCE_INLINE int32_t tdGetBitmapValType(const void *pBitmap, int16_t colIdx, TDRowValT *pValType,
+                                               int8_t bitmapMode) {
  switch (bitmapMode) {
    case 0:
      tdGetBitmapValTypeII(pBitmap, colIdx, pValType);

--- a/include/dnode/mnode/sdb/sdb.h
+++ b/include/dnode/mnode/sdb/sdb.h
@@ -221,7 +221,7 @@ int32_t sdbWrite(SSdb *pSdb, SSdbRaw *pRaw);
 * @param pRaw The raw data.
 * @return int32_t 0 for success, -1 for failure.
 */
-int32_t sdbWriteNotFree(SSdb *pSdb, SSdbRaw *pRaw);
+int32_t sdbWriteWithoutFree(SSdb *pSdb, SSdbRaw *pRaw);
 /**
 * @brief Acquire a row from sdb

--- a/include/libs/function/function.h
+++ b/include/libs/function/function.h
@@ -202,7 +202,7 @@ typedef struct SqlFunctionCtx {
  SPoint1                end;
  SFuncExecFuncs         fpSet;
  SScalarFuncExecFuncs   sfp;
-  SExprInfo             *pExpr;
+  struct SExprInfo      *pExpr;
  struct SDiskbasedBuf  *pBuf;
  struct SSDataBlock    *pSrcBlock;
  int32_t                curBufPage;

--- a/include/libs/parser/parser.h
+++ b/include/libs/parser/parser.h
@@ -88,11 +88,11 @@ int32_t qCloneStmtDataBlock(void** pDst, void* pSrc);
 void    qFreeStmtDataBlock(void* pDataBlock);
 int32_t qRebuildStmtDataBlock(void** pDst, void* pSrc);
 void    qDestroyStmtDataBlock(void* pBlock);
-int32_t qBindStmtColsValue(void *pBlock, TAOS_BIND_v2 *bind, char *msgBuf, int32_t msgBufLen);
+int32_t qBindStmtColsValue(void *pBlock, TAOS_MULTI_BIND *bind, char *msgBuf, int32_t msgBufLen);
-int32_t qBindStmtSingleColValue(void *pBlock, TAOS_BIND_v2 *bind, char *msgBuf, int32_t msgBufLen, int32_t colIdx, int32_t rowNum);
+int32_t qBindStmtSingleColValue(void *pBlock, TAOS_MULTI_BIND *bind, char *msgBuf, int32_t msgBufLen, int32_t colIdx, int32_t rowNum);
 int32_t qBuildStmtColFields(void *pDataBlock, int32_t *fieldNum, TAOS_FIELD** fields);
 int32_t qBuildStmtTagFields(void *pBlock, void *boundTags, int32_t *fieldNum, TAOS_FIELD** fields);
-int32_t qBindStmtTagsValue(void *pBlock, void *boundTags, int64_t suid, SName *pName, TAOS_BIND_v2 *bind, char *msgBuf, int32_t msgBufLen);
+int32_t qBindStmtTagsValue(void *pBlock, void *boundTags, int64_t suid, SName *pName, TAOS_MULTI_BIND *bind, char *msgBuf, int32_t msgBufLen);
 void destroyBoundColumnInfo(void* pBoundInfo);
 int32_t qCreateSName(SName* pName, const char* pTableName, int32_t acctId, char* dbName, char *msgBuf, int32_t msgBufLen);

--- a/include/libs/planner/planner.h
+++ b/include/libs/planner/planner.h
@@ -50,7 +50,7 @@ int32_t qCreateQueryPlan(SPlanContext* pCxt, SQueryPlan** pPlan, SArray* pExecNo
 // @pSource one execution location of this group of datasource subplans 
 int32_t qSetSubplanExecutionNode(SSubplan* pSubplan, int32_t groupId, SDownstreamSourceNode* pSource);
-int32_t qStmtBindParam(SQueryPlan* pPlan, TAOS_BIND_v2* pParams);
+int32_t qStmtBindParam(SQueryPlan* pPlan, TAOS_MULTI_BIND* pParams, int32_t colIdx);
 // Convert to subplan to string for the scheduler to send to the executor
 int32_t qSubPlanToString(const SSubplan* pSubplan, char** pStr, int32_t* pLen);

--- a/include/libs/sync/sync.h
+++ b/include/libs/sync/sync.h
@@ -158,6 +158,8 @@ typedef enum {
 int32_t syncPropose(int64_t rid, const SRpcMsg* pMsg, bool isWeak);
+bool syncEnvIsStart();
 extern int32_t sDebugFlag;
 //-----------------------------------------

--- a/include/util/taoserror.h
+++ b/include/util/taoserror.h
@@ -139,16 +139,9 @@ int32_t* taosGetErrno();
 // mnode-common
 #define TSDB_CODE_MND_APP_ERROR                 TAOS_DEF_ERROR_CODE(0, 0x0300)
 #define TSDB_CODE_MND_NOT_READY                 TAOS_DEF_ERROR_CODE(0, 0x0301)
-#define TSDB_CODE_MND_MSG_NOT_PROCESSED         TAOS_DEF_ERROR_CODE(0, 0x0302)
+#define TSDB_CODE_MND_ACTION_IN_PROGRESS        TAOS_DEF_ERROR_CODE(0, 0x0302)
-#define TSDB_CODE_MND_ACTION_IN_PROGRESS        TAOS_DEF_ERROR_CODE(0, 0x0303)
+#define TSDB_CODE_MND_NO_RIGHTS                 TAOS_DEF_ERROR_CODE(0, 0x0303)
-#define TSDB_CODE_MND_ACTION_NEED_REPROCESSED   TAOS_DEF_ERROR_CODE(0, 0x0304)
+#define TSDB_CODE_MND_INVALID_CONNECTION        TAOS_DEF_ERROR_CODE(0, 0x0304)
-#define TSDB_CODE_MND_NO_RIGHTS                 TAOS_DEF_ERROR_CODE(0, 0x0305)
-#define TSDB_CODE_MND_INVALID_OPTIONS           TAOS_DEF_ERROR_CODE(0, 0x0306)
-#define TSDB_CODE_MND_INVALID_CONNECTION        TAOS_DEF_ERROR_CODE(0, 0x0307)
-#define TSDB_CODE_MND_INVALID_MSG_VERSION       TAOS_DEF_ERROR_CODE(0, 0x0308)
-#define TSDB_CODE_MND_INVALID_MSG_LEN           TAOS_DEF_ERROR_CODE(0, 0x0309)
-#define TSDB_CODE_MND_INVALID_MSG_TYPE          TAOS_DEF_ERROR_CODE(0, 0x030A)
-#define TSDB_CODE_MND_TOO_MANY_SHELL_CONNS      TAOS_DEF_ERROR_CODE(0, 0x030B)
 // mnode-show
 #define TSDB_CODE_MND_INVALID_SHOWOBJ           TAOS_DEF_ERROR_CODE(0, 0x0310)

--- a/include/util/tdef.h
+++ b/include/util/tdef.h
@@ -125,12 +125,12 @@ extern const int32_t TYPE_BYTES[15];
 #define TSDB_INS_TABLE_QUERIES                "queries"
 #define TSDB_INS_TABLE_VNODES                 "vnodes"
-#define TSDB_PERFORMANCE_SCHEMA_DB   "performance_schema"
+#define TSDB_PERFORMANCE_SCHEMA_DB     "performance_schema"
-#define TSDB_PERFS_TABLE_CONNECTIONS "connections"
+#define TSDB_PERFS_TABLE_CONNECTIONS   "connections"
-#define TSDB_PERFS_TABLE_QUERIES     "queries"
+#define TSDB_PERFS_TABLE_QUERIES       "queries"
-#define TSDB_PERFS_TABLE_TOPICS      "topics"
+#define TSDB_PERFS_TABLE_TOPICS        "topics"
-#define TSDB_PERFS_TABLE_CONSUMERS   "consumers"
+#define TSDB_PERFS_TABLE_CONSUMERS     "consumers"
-#define TSDB_PERFS_TABLE_SUBSCRIBES  "subscribes"
+#define TSDB_PERFS_TABLE_SUBSCRIPTIONS "subscriptions"
 #define TSDB_INDEX_TYPE_SMA      "SMA"
 #define TSDB_INDEX_TYPE_FULLTEXT "FULLTEXT"
@@ -195,6 +195,8 @@ typedef enum EOperatorType {
  OP_TYPE_JSON_CONTAINS
 } EOperatorType;
+#define OP_TYPE_CALC_MAX OP_TYPE_BIT_OR
 typedef enum ELogicConditionType {
  LOGIC_COND_TYPE_AND = 1,
  LOGIC_COND_TYPE_OR,
@@ -270,7 +272,7 @@ typedef enum ELogicConditionType {
 #define TSDB_MAX_TAGS           128
 #define TSDB_MAX_TAG_CONDITIONS 1024
-#define TSDB_MAX_JSON_TAG_LEN   16384
+#define TSDB_MAX_JSON_TAG_LEN 16384
 #define TSDB_AUTH_LEN          16
 #define TSDB_PASSWORD_LEN      32
@@ -284,8 +286,9 @@ typedef enum ELogicConditionType {
 #define TSDB_IPv4ADDR_LEN       16
 #define TSDB_FILENAME_LEN       128
 #define TSDB_SHOW_SQL_LEN       512
-#define TSDB_SHOW_SUBQUERY_LEN  1000
 #define TSDB_SLOW_QUERY_SQL_LEN 512
+#define TSDB_SHOW_SUBQUERY_LEN  1000
+#define TSDB_SHOW_LIST_LEN      1000
 #define TSDB_TRANS_STAGE_LEN 12
 #define TSDB_TRANS_TYPE_LEN  16
@@ -372,7 +375,7 @@ typedef enum ELogicConditionType {
 #define TSDB_DB_STREAM_MODE_OFF       0
 #define TSDB_DB_STREAM_MODE_ON        1
 #define TSDB_DEFAULT_DB_STREAM_MODE   0
-#define TSDB_DB_SINGLE_STABLE_ON     0
+#define TSDB_DB_SINGLE_STABLE_ON      0
 #define TSDB_DB_SINGLE_STABLE_OFF     1
 #define TSDB_DEFAULT_DB_SINGLE_STABLE 0

--- a/include/util/tencode.h
+++ b/include/util/tencode.h
@@ -17,7 +17,8 @@
 #define _TD_UTIL_ENCODE_H_
 #include "tcoding.h"
-#include "tfreelist.h"
+#include "tlist.h"
+// #include "tfreelist.h"
 #ifdef __cplusplus
 extern "C" {
@@ -62,10 +63,14 @@ struct SCoderNode {
  CODER_NODE_FIELDS
 };
+typedef struct SCoderMem {
+  struct SCoderMem* next;
+} SCoderMem;
 typedef struct {
  td_coder_t  type;
  td_endian_t endian;
-  SFreeList   fl;
+  SCoderMem*  mList;
  CODER_NODE_FIELDS
  TD_SLIST(SCoderNode) stack;
 } SCoder;
@@ -74,7 +79,31 @@ typedef struct {
 #define TD_CODER_CURRENT(CODER)                        ((CODER)->data + (CODER)->pos)
 #define TD_CODER_MOVE_POS(CODER, MOVE)                 ((CODER)->pos += (MOVE))
 #define TD_CODER_CHECK_CAPACITY_FAILED(CODER, EXPSIZE) (((CODER)->size - (CODER)->pos) < (EXPSIZE))
-#define TCODER_MALLOC(PTR, TYPE, SIZE, CODER)          TFL_MALLOC(PTR, TYPE, SIZE, &((CODER)->fl))
+#define TCODER_MALLOC(PCODER, SIZE)                                         \
+  ({                                                                        \
+    void*      ptr = NULL;                                                  \
+    SCoderMem* pMem = (SCoderMem*)taosMemoryMalloc(sizeof(*pMem) + (SIZE)); \
+    if (pMem) {                                                             \
+      pMem->next = (PCODER)->mList;                                         \
+      (PCODER)->mList = pMem;                                               \
+      ptr = (void*)&pMem[1];                                                \
+    }                                                                       \
+    ptr;                                                                    \
+  })
+#define tEncodeSize(E, S, SIZE)                                \
+  ({                                                           \
+    SCoder coder = {0};                                        \
+    int    ret = 0;                                            \
+    tCoderInit(&coder, TD_LITTLE_ENDIAN, NULL, 0, TD_ENCODER); \
+    if ((E)(&coder, S) == 0) {                                 \
+      SIZE = coder.pos;                                        \
+    } else {                                                   \
+      ret = -1;                                                \
+    }                                                          \
+    tCoderClear(&coder);                                       \
+    ret;                                                       \
+  })
 void tCoderInit(SCoder* pCoder, td_endian_t endian, uint8_t* data, int32_t size, td_coder_t type);
 void tCoderClear(SCoder* pCoder);
@@ -377,7 +406,9 @@ static FORCE_INLINE int32_t tDecodeBinary(SCoder* pDecoder, const void** val, ui
  if (tDecodeU64v(pDecoder, len) < 0) return -1;
  if (TD_CODER_CHECK_CAPACITY_FAILED(pDecoder, *len)) return -1;
-  *val = (void*)TD_CODER_CURRENT(pDecoder);
+  if (val) {
+    *val = (void*)TD_CODER_CURRENT(pDecoder);
+  }
  TD_CODER_MOVE_POS(pDecoder, *len);
  return 0;

--- a/include/util/tlog.h
+++ b/include/util/tlog.h
@@ -59,6 +59,7 @@ extern int32_t sDebugFlag;
 extern int32_t tsdbDebugFlag;
 extern int32_t tqDebugFlag;
 extern int32_t fsDebugFlag;
+extern int32_t metaDebugFlag;
 extern int32_t fnDebugFlag;
 int32_t taosInitLog(const char *logName, int32_t maxFiles);
@@ -79,6 +80,7 @@ void taosPrintLongString(const char *flags, ELogLevel level, int32_t dflag, cons
 #endif
    ;
+// clang-format off
 #define uFatal(...) { if (uDebugFlag & DEBUG_FATAL) { taosPrintLog("UTL FATAL", DEBUG_FATAL, tsLogEmbedded ? 255 : uDebugFlag, __VA_ARGS__); }}
 #define uError(...) { if (uDebugFlag & DEBUG_ERROR) { taosPrintLog("UTL ERROR ", DEBUG_ERROR, tsLogEmbedded ? 255 : uDebugFlag, __VA_ARGS__); }}
 #define uWarn(...)  { if (uDebugFlag & DEBUG_WARN)  { taosPrintLog("UTL WARN ", DEBUG_WARN, tsLogEmbedded ? 255 : uDebugFlag, __VA_ARGS__); }}
@@ -88,6 +90,7 @@ void taosPrintLongString(const char *flags, ELogLevel level, int32_t dflag, cons
 #define pError(...) { taosPrintLog("APP ERROR ", DEBUG_ERROR, 255, __VA_ARGS__); }
 #define pPrint(...) { taosPrintLog("APP ", DEBUG_INFO, 255, __VA_ARGS__); }
+// clang-format on
 #ifdef __cplusplus
 }

--- a/source/client/CMakeLists.txt
+++ b/source/client/CMakeLists.txt
 aux_source_directory(src CLIENT_SRC)
-add_library(taos SHARED ${CLIENT_SRC})
+if(TD_WINDOWS)
+    add_library(taos SHARED ${CLIENT_SRC} ${CMAKE_CURRENT_SOURCE_DIR}/src/taos.rc.in)
+else()
+    add_library(taos SHARED ${CLIENT_SRC})
+endif ()
 target_include_directories(
    taos
    PUBLIC "${TD_SOURCE_DIR}/include/client"
@@ -10,6 +14,13 @@ target_link_libraries(
    INTERFACE api
    PRIVATE os util common transport nodes parser command planner catalog scheduler function qcom
 )
+if(TD_WINDOWS)
+    set_target_properties(taos 
+        PROPERTIES 
+        LINK_FLAGS 
+        /DEF:${CMAKE_CURRENT_SOURCE_DIR}/src/taos.def
+    )
+endif ()
 set_target_properties(
    taos

--- a/source/client/inc/clientInt.h
+++ b/source/client/inc/clientInt.h
@@ -310,6 +310,9 @@ int hbAddConnInfo(SAppHbMgr* pAppHbMgr, SClientHbKey connKey, void* key, void* v
 void hbMgrInitMqHbRspHandle();
 SRequestObj* launchQueryImpl(SRequestObj* pRequest, SQuery* pQuery, int32_t code, bool keepQuery);
+int32_t getQueryPlan(SRequestObj* pRequest, SQuery* pQuery, SArray** pNodeList);
+int32_t scheduleQuery(SRequestObj* pRequest, SQueryPlan* pDag, SArray* pNodeList);
 #ifdef __cplusplus
 }

--- a/source/client/inc/clientStmt.h
+++ b/source/client/inc/clientStmt.h
@@ -34,8 +34,7 @@ typedef enum {
  STMT_PREPARE,
  STMT_SETTBNAME,
  STMT_SETTAGS,
-  STMT_FETCH_TAG_FIELDS,
+  STMT_FETCH_FIELDS,
-  STMT_FETCH_COL_FIELDS,
  STMT_BIND,
  STMT_BIND_COL,
  STMT_ADD_BATCH,
@@ -75,6 +74,8 @@ typedef struct SStmtSQLInfo {
  SQuery*      pQuery;
  char*        sqlStr;
  int32_t      sqlLen;
+  SArray*      nodeList;
+  SQueryPlan*  pQueryPlan;
 } SStmtSQLInfo;
 typedef struct STscStmt {
@@ -87,6 +88,8 @@ typedef struct STscStmt {
  SStmtBindInfo bInfo;
 } STscStmt;
+#define STMT_STATUS_NE(S) (pStmt->sql.status != STMT_##S)
+#define STMT_STATUS_EQ(S) (pStmt->sql.status == STMT_##S)
 #define STMT_ERR_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { terrno = _code; return _code; } } while (0)
 #define STMT_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { terrno = _code; } return _code; } while (0)
@@ -97,14 +100,15 @@ int stmtClose(TAOS_STMT *stmt);
 int stmtExec(TAOS_STMT *stmt);
 const char *stmtErrstr(TAOS_STMT *stmt);
 int stmtAffectedRows(TAOS_STMT *stmt);
+int stmtAffectedRowsOnce(TAOS_STMT *stmt);
 int stmtPrepare(TAOS_STMT *stmt, const char *sql, unsigned long length);
 int stmtSetTbName(TAOS_STMT *stmt, const char *tbName);
-int stmtSetTbTags(TAOS_STMT *stmt, TAOS_BIND_v2 *tags);
+int stmtSetTbTags(TAOS_STMT *stmt, TAOS_MULTI_BIND *tags);
 int stmtIsInsert(TAOS_STMT *stmt, int *insert);
 int stmtGetParamNum(TAOS_STMT *stmt, int *nums);
 int stmtAddBatch(TAOS_STMT *stmt);
 TAOS_RES *stmtUseResult(TAOS_STMT *stmt);
-int stmtBindBatch(TAOS_STMT *stmt, TAOS_BIND_v2 *bind, int32_t colIdx);
+int stmtBindBatch(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind, int32_t colIdx);
 #ifdef __cplusplus

--- a/source/client/src/clientImpl.c
+++ b/source/client/src/clientImpl.c
@@ -305,6 +305,11 @@ int32_t scheduleQuery(SRequestObj* pRequest, SQueryPlan* pDag, SArray* pNodeList
  return pRequest->code;
 }
+int32_t getQueryPlan(SRequestObj* pRequest, SQuery* pQuery, SArray** pNodeList) {
+  *pNodeList = taosArrayInit(4, sizeof(struct SQueryNodeAddr));
+  return getPlan(pRequest, pQuery, &pRequest->body.pDag, *pNodeList);
+}
 SRequestObj* launchQueryImpl(SRequestObj* pRequest, SQuery* pQuery, int32_t code, bool keepQuery) {
  if (TSDB_CODE_SUCCESS == code) {
    switch (pQuery->execMode) {

--- a/source/client/src/clientMain.c
+++ b/source/client/src/clientMain.c
@@ -603,7 +603,7 @@ int taos_stmt_prepare(TAOS_STMT *stmt, const char *sql, unsigned long length) {
  return stmtPrepare(stmt, sql, length);
 }
-int taos_stmt_set_tbname_tags(TAOS_STMT *stmt, const char *name, TAOS_BIND_v2 *tags) {
+int taos_stmt_set_tbname_tags(TAOS_STMT *stmt, const char *name, TAOS_MULTI_BIND *tags) {
  if (stmt == NULL || name == NULL) {
    tscError("NULL parameter for %s", __FUNCTION__);
    terrno = TSDB_CODE_INVALID_PARA;
@@ -636,7 +636,7 @@ int taos_stmt_set_sub_tbname(TAOS_STMT *stmt, const char *name) {
  return taos_stmt_set_tbname(stmt, name);
 }
-int taos_stmt_bind_param(TAOS_STMT *stmt, TAOS_BIND_v2 *bind) {
+int taos_stmt_bind_param(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind) {
  if (stmt == NULL || bind == NULL) {
    tscError("NULL parameter for %s", __FUNCTION__);
    terrno = TSDB_CODE_INVALID_PARA;
@@ -652,7 +652,7 @@ int taos_stmt_bind_param(TAOS_STMT *stmt, TAOS_BIND_v2 *bind) {
  return stmtBindBatch(stmt, bind, -1);
 }
-int taos_stmt_bind_param_batch(TAOS_STMT *stmt, TAOS_BIND_v2 *bind) {
+int taos_stmt_bind_param_batch(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind) {
  if (stmt == NULL || bind == NULL) {
    tscError("NULL parameter for %s", __FUNCTION__);
    terrno = TSDB_CODE_INVALID_PARA;
@@ -665,10 +665,18 @@ int taos_stmt_bind_param_batch(TAOS_STMT *stmt, TAOS_BIND_v2 *bind) {
    return terrno;
  }
+  int32_t insert = 0;
+  stmtIsInsert(stmt, &insert);
+  if (0 == insert && bind->num > 1) {
+    tscError("only one row data allowed for query");
+    terrno = TSDB_CODE_INVALID_PARA;
+    return terrno;
+  }
  return stmtBindBatch(stmt, bind, -1);
 }
-int taos_stmt_bind_single_param_batch(TAOS_STMT *stmt, TAOS_BIND_v2 *bind, int colIdx) {
+int taos_stmt_bind_single_param_batch(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind, int colIdx) {
  if (stmt == NULL || bind == NULL) {
    tscError("NULL parameter for %s", __FUNCTION__);
    terrno = TSDB_CODE_INVALID_PARA;
@@ -680,6 +688,14 @@ int taos_stmt_bind_single_param_batch(TAOS_STMT *stmt, TAOS_BIND_v2 *bind, int c
    terrno = TSDB_CODE_INVALID_PARA;
    return terrno;
  }
+  int32_t insert = 0;
+  stmtIsInsert(stmt, &insert);
+  if (0 == insert && bind->num > 1) {
+    tscError("only one row data allowed for query");
+    terrno = TSDB_CODE_INVALID_PARA;
+    return terrno;
+  }
  return stmtBindBatch(stmt, bind, colIdx);
 }
@@ -748,6 +764,16 @@ int taos_stmt_affected_rows(TAOS_STMT *stmt) {
  return stmtAffectedRows(stmt);
 }
+int taos_stmt_affected_rows_once(TAOS_STMT *stmt) {
+  if (stmt == NULL) {
+    tscError("NULL parameter for %s", __FUNCTION__);
+    terrno = TSDB_CODE_INVALID_PARA;
+    return 0;
+  }
+  return stmtAffectedRowsOnce(stmt);
+}
 int taos_stmt_close(TAOS_STMT *stmt) {
  if (stmt == NULL) {
    tscError("NULL parameter for %s", __FUNCTION__);

--- a/source/client/src/clientStmt.c
+++ b/source/client/src/clientStmt.c
@@ -5,14 +5,52 @@
 #include "tdef.h"
 int32_t stmtSwitchStatus(STscStmt* pStmt, STMT_STATUS newStatus) {
+  int32_t code = 0;
  switch (newStatus) {
+    case STMT_PREPARE:
+      break;
    case STMT_SETTBNAME:
+      if (STMT_STATUS_EQ(INIT) || STMT_STATUS_EQ(BIND) || STMT_STATUS_EQ(BIND_COL)) {
+        code = TSDB_CODE_TSC_STMT_API_ERROR;
+      }
+      break;
+    case STMT_SETTAGS:
+      if (STMT_STATUS_NE(SETTBNAME)) {
+        code = TSDB_CODE_TSC_STMT_API_ERROR;
+      }
+      break;
+    case STMT_FETCH_FIELDS:
+      if (STMT_STATUS_EQ(INIT)) {
+        code = TSDB_CODE_TSC_STMT_API_ERROR;
+      }
+      break;
+    case STMT_BIND:
+      if (STMT_STATUS_EQ(INIT) || STMT_STATUS_EQ(BIND_COL)) {
+        code = TSDB_CODE_TSC_STMT_API_ERROR;
+      }
+      break;
+    case STMT_BIND_COL:
+      if (STMT_STATUS_EQ(INIT) || STMT_STATUS_EQ(BIND)) {
+        code = TSDB_CODE_TSC_STMT_API_ERROR;
+      }
+      break;
+    case STMT_ADD_BATCH:
+      if (STMT_STATUS_NE(BIND) && STMT_STATUS_NE(BIND_COL) && STMT_STATUS_NE(FETCH_FIELDS)) {
+        code = TSDB_CODE_TSC_STMT_API_ERROR;
+      }
+      break;
+    case STMT_EXECUTE:
+      if (STMT_STATUS_NE(ADD_BATCH) && STMT_STATUS_NE(FETCH_FIELDS)) {
+        code = TSDB_CODE_TSC_STMT_API_ERROR;
+      }
      break;
    default:
+      code = TSDB_CODE_TSC_APP_ERROR;
      break;
  }
-  //STMT_ERR_RET(TSDB_CODE_TSC_STMT_API_ERROR);
+  STMT_ERR_RET(code);
  pStmt->sql.status = newStatus;
@@ -69,15 +107,10 @@ int32_t stmtCacheBlock(STscStmt *pStmt) {
    return TSDB_CODE_SUCCESS;
  }
-  uint64_t uid;
+  uint64_t uid = pStmt->bInfo.tbUid; 
-  if (TSDB_CHILD_TABLE == pStmt->bInfo.tbType) {
+  uint64_t tuid = (TSDB_CHILD_TABLE == pStmt->bInfo.tbType) ? pStmt->bInfo.tbSuid : uid;
-    uid = pStmt->bInfo.tbSuid;
-  } else {
-    ASSERT(TSDB_NORMAL_TABLE == pStmt->bInfo.tbType);
-    uid = pStmt->bInfo.tbUid;
-  }
-  if (taosHashGet(pStmt->sql.pTableCache, &uid, sizeof(uid))) {
+  if (taosHashGet(pStmt->sql.pTableCache, &tuid, sizeof(tuid))) {
    return TSDB_CODE_SUCCESS;
  }
@@ -91,7 +124,7 @@ int32_t stmtCacheBlock(STscStmt *pStmt) {
    .boundTags = pStmt->bInfo.boundTags,
  };
-  if (taosHashPut(pStmt->sql.pTableCache, &uid, sizeof(uid), &cache, sizeof(cache))) {
+  if (taosHashPut(pStmt->sql.pTableCache, &tuid, sizeof(tuid), &cache, sizeof(cache))) {
    return TSDB_CODE_OUT_OF_MEMORY;
  }
@@ -149,9 +182,11 @@ int32_t stmtCleanBindInfo(STscStmt* pStmt) {
  return TSDB_CODE_SUCCESS;
 }
-int32_t stmtCleanExecInfo(STscStmt* pStmt, bool keepTable) {
+int32_t stmtCleanExecInfo(STscStmt* pStmt, bool keepTable, bool freeRequest) {
-  taos_free_result(pStmt->exec.pRequest);
+  if (STMT_TYPE_QUERY != pStmt->sql.type || freeRequest) {
-  pStmt->exec.pRequest = NULL;
+    taos_free_result(pStmt->exec.pRequest);
+    pStmt->exec.pRequest = NULL;
+  }
  void *pIter = taosHashIterate(pStmt->exec.pBlockHash, NULL);
  while (pIter) {
@@ -186,7 +221,9 @@ int32_t stmtCleanExecInfo(STscStmt* pStmt, bool keepTable) {
 int32_t stmtCleanSQLInfo(STscStmt* pStmt) {
  taosMemoryFree(pStmt->sql.sqlStr);
  qDestroyQuery(pStmt->sql.pQuery);
+  qDestroyQueryPlan(pStmt->sql.pQueryPlan);
+  taosArrayDestroy(pStmt->sql.nodeList);
  void *pIter = taosHashIterate(pStmt->sql.pTableCache, NULL);
  while (pIter) {
    SStmtTableCache* pCache = (SStmtTableCache*)pIter;    
@@ -201,7 +238,7 @@ int32_t stmtCleanSQLInfo(STscStmt* pStmt) {
  memset(&pStmt->sql, 0, sizeof(pStmt->sql));
-  STMT_ERR_RET(stmtCleanExecInfo(pStmt, false));
+  STMT_ERR_RET(stmtCleanExecInfo(pStmt, false, true));
  STMT_ERR_RET(stmtCleanBindInfo(pStmt));
  return TSDB_CODE_SUCCESS;
@@ -333,6 +370,13 @@ int stmtSetTbName(TAOS_STMT *stmt, const char *tbName) {
  STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_SETTBNAME));
+  int32_t insert = 0;
+  stmtIsInsert(stmt, &insert);
+  if (0 == insert) {
+    tscError("set tb name not available for none insert statement");
+    STMT_ERR_RET(TSDB_CODE_TSC_STMT_API_ERROR);
+  }
  if (NULL == pStmt->exec.pRequest) {
    STMT_ERR_RET(buildRequest(pStmt->taos, pStmt->sql.sqlStr, pStmt->sql.sqlLen, &pStmt->exec.pRequest));
  }
@@ -349,7 +393,7 @@ int stmtSetTbName(TAOS_STMT *stmt, const char *tbName) {
  return TSDB_CODE_SUCCESS;
 }
-int stmtSetTbTags(TAOS_STMT *stmt, TAOS_BIND_v2 *tags) {
+int stmtSetTbTags(TAOS_STMT *stmt, TAOS_MULTI_BIND *tags) {
  STscStmt* pStmt = (STscStmt*)stmt;
  STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_SETTAGS));
@@ -370,15 +414,7 @@ int stmtSetTbTags(TAOS_STMT *stmt, TAOS_BIND_v2 *tags) {
 }
-int32_t stmtFetchTagFields(TAOS_STMT *stmt, int32_t *fieldNum, TAOS_FIELD** fields) {
+int32_t stmtFetchTagFields(STscStmt* pStmt, int32_t *fieldNum, TAOS_FIELD** fields) {
-  STscStmt* pStmt = (STscStmt*)stmt;
-  STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_FETCH_TAG_FIELDS));
-  if (pStmt->bInfo.needParse) {
-    STMT_ERR_RET(stmtParseSql(pStmt));
-  }
  if (STMT_TYPE_QUERY == pStmt->sql.type) {
    tscError("invalid operation to get query tag fileds");
    STMT_ERR_RET(TSDB_CODE_TSC_STMT_API_ERROR);
@@ -395,15 +431,7 @@ int32_t stmtFetchTagFields(TAOS_STMT *stmt, int32_t *fieldNum, TAOS_FIELD** fiel
  return TSDB_CODE_SUCCESS;
 }
-int32_t stmtFetchColFields(TAOS_STMT *stmt, int32_t *fieldNum, TAOS_FIELD** fields) {
+int32_t stmtFetchColFields(STscStmt* pStmt, int32_t *fieldNum, TAOS_FIELD** fields) {
-  STscStmt* pStmt = (STscStmt*)stmt;
-  STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_FETCH_COL_FIELDS));
-  if (pStmt->bInfo.needParse) {
-    STMT_ERR_RET(stmtParseSql(pStmt));
-  }
  if (STMT_TYPE_QUERY == pStmt->sql.type) {
    tscError("invalid operation to get query column fileds");
    STMT_ERR_RET(TSDB_CODE_TSC_STMT_API_ERROR);
@@ -420,7 +448,7 @@ int32_t stmtFetchColFields(TAOS_STMT *stmt, int32_t *fieldNum, TAOS_FIELD** fiel
  return TSDB_CODE_SUCCESS;  
 }
-int stmtBindBatch(TAOS_STMT *stmt, TAOS_BIND_v2 *bind, int32_t colIdx) {
+int stmtBindBatch(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind, int32_t colIdx) {
  STscStmt* pStmt = (STscStmt*)stmt;
  STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_BIND));
@@ -429,6 +457,11 @@ int stmtBindBatch(TAOS_STMT *stmt, TAOS_BIND_v2 *bind, int32_t colIdx) {
    pStmt->bInfo.needParse = false;
  }
+  if (pStmt->exec.pRequest && STMT_TYPE_QUERY == pStmt->sql.type && pStmt->sql.runTimes) {
+    taos_free_result(pStmt->exec.pRequest);
+    pStmt->exec.pRequest = NULL;
+  }
  if (NULL == pStmt->exec.pRequest) {
    STMT_ERR_RET(buildRequest(pStmt->taos, pStmt->sql.sqlStr, pStmt->sql.sqlLen, &pStmt->exec.pRequest));
  }
@@ -437,6 +470,16 @@ int stmtBindBatch(TAOS_STMT *stmt, TAOS_BIND_v2 *bind, int32_t colIdx) {
    STMT_ERR_RET(stmtParseSql(pStmt));
  }
+  if (STMT_TYPE_QUERY == pStmt->sql.type) {
+    if (NULL == pStmt->sql.pQueryPlan) {
+      STMT_ERR_RET(getQueryPlan(pStmt->exec.pRequest, pStmt->sql.pQuery, &pStmt->sql.nodeList));
+      pStmt->sql.pQueryPlan = pStmt->exec.pRequest->body.pDag;
+      pStmt->exec.pRequest->body.pDag = NULL;
+    }
+    STMT_RET(qStmtBindParam(pStmt->sql.pQueryPlan, bind, colIdx));
+  }
  STableDataBlocks **pDataBlock = (STableDataBlocks**)taosHashGet(pStmt->exec.pBlockHash, (const char*)&pStmt->bInfo.tbUid, sizeof(pStmt->bInfo.tbUid));
  if (NULL == pDataBlock) {
    tscError("table uid %" PRIx64 "not found in exec blockHash", pStmt->bInfo.tbUid);
@@ -480,10 +523,13 @@ int stmtExec(TAOS_STMT *stmt) {
  STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_EXECUTE));
-  STMT_ERR_RET(qBuildStmtOutput(pStmt->sql.pQuery, pStmt->exec.pVgHash, pStmt->exec.pBlockHash));
+  if (STMT_TYPE_QUERY == pStmt->sql.type) {
+    scheduleQuery(pStmt->exec.pRequest, pStmt->sql.pQueryPlan, pStmt->sql.nodeList);
-  launchQueryImpl(pStmt->exec.pRequest, pStmt->sql.pQuery, TSDB_CODE_SUCCESS, true);
+  } else {
+    STMT_ERR_RET(qBuildStmtOutput(pStmt->sql.pQuery, pStmt->exec.pVgHash, pStmt->exec.pBlockHash));
+    launchQueryImpl(pStmt->exec.pRequest, pStmt->sql.pQuery, TSDB_CODE_SUCCESS, true);
+  }
  STMT_ERR_JRET(pStmt->exec.pRequest->code);
  pStmt->exec.affectedRows = taos_affected_rows(pStmt->exec.pRequest);
@@ -491,7 +537,7 @@ int stmtExec(TAOS_STMT *stmt) {
 _return:
-  stmtCleanExecInfo(pStmt, (code ? false : true));
+  stmtCleanExecInfo(pStmt, (code ? false : true), false);
  ++pStmt->sql.runTimes;
@@ -523,6 +569,10 @@ int stmtAffectedRows(TAOS_STMT *stmt) {
  return ((STscStmt*)stmt)->affectedRows;
 }
+int stmtAffectedRowsOnce(TAOS_STMT *stmt) {
+  return ((STscStmt*)stmt)->exec.affectedRows;
+}
 int stmtIsInsert(TAOS_STMT *stmt, int *insert) {
  STscStmt* pStmt = (STscStmt*)stmt;
@@ -536,13 +586,38 @@ int stmtIsInsert(TAOS_STMT *stmt, int *insert) {
 }
 int stmtGetParamNum(TAOS_STMT *stmt, int *nums) {
-  STMT_ERR_RET(stmtFetchColFields(stmt, nums, NULL));
+  STscStmt* pStmt = (STscStmt*)stmt;
+  STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_FETCH_FIELDS));
+  if (pStmt->bInfo.needParse) {
+    STMT_ERR_RET(stmtParseSql(pStmt));
+  }
+  if (STMT_TYPE_QUERY == pStmt->sql.type) {
+    if (NULL == pStmt->sql.pQueryPlan) {
+      STMT_ERR_RET(getQueryPlan(pStmt->exec.pRequest, pStmt->sql.pQuery, &pStmt->sql.nodeList));
+      pStmt->sql.pQueryPlan = pStmt->exec.pRequest->body.pDag;
+      pStmt->exec.pRequest->body.pDag = NULL;
+    }
+    *nums = (pStmt->sql.pQueryPlan->pPlaceholderValues) ? pStmt->sql.pQueryPlan->pPlaceholderValues->length : 0;
+  } else {
+    STMT_ERR_RET(stmtFetchColFields(stmt, nums, NULL));
+  }
  return TSDB_CODE_SUCCESS;
 }
 TAOS_RES *stmtUseResult(TAOS_STMT *stmt) {
-  return NULL;
+  STscStmt* pStmt = (STscStmt*)stmt;
+  if (STMT_TYPE_QUERY != pStmt->sql.type) {
+    tscError("useResult only for query statement");
+    return NULL;
+  }
+  return pStmt->exec.pRequest;
 }

--- a/source/client/src/taos.def
+++ b/source/client/src/taos.def
+taos_cleanup
+taos_options
+taos_set_config
+taos_connect
+taos_connect_l
+taos_connect_auth
+taos_close
+taos_data_type
+taos_stmt_init
+taos_stmt_prepare
+taos_stmt_set_tbname_tags
+taos_stmt_set_tbname
+taos_stmt_set_sub_tbname
+taos_stmt_is_insert
+taos_stmt_num_params
+taos_stmt_get_param
+taos_stmt_bind_param
+taos_stmt_bind_param_batch
+taos_stmt_bind_single_param_batch
+taos_stmt_add_batch
+taos_stmt_execute
+taos_stmt_use_result
+taos_stmt_close
+taos_stmt_errstr
+taos_stmt_affected_rows
+taos_stmt_affected_rows_once
+taos_query
+taos_query_l
+taos_fetch_row
+taos_result_precision
+taos_free_result
+taos_field_count
+taos_num_fields
+taos_affected_rows
+taos_fetch_fields
+taos_select_db
+taos_print_row
+taos_stop_query
+taos_is_null
+taos_is_update_query
+taos_fetch_block
+taos_fetch_block_s
+taos_fetch_raw_block
+taos_get_column_data_offset
+taos_validate_sql
+taos_reset_current_db
+taos_fetch_lengths
+taos_result_block
+taos_get_server_info
+taos_get_client_info
+taos_errstr
+taos_errno
+taos_query_a
+taos_fetch_rows_a
+taos_subscribe
+taos_consume
+taos_unsubscribe
+taos_load_table_info
+taos_schemaless_insert
+tmq_list_new
+tmq_list_append
+tmq_list_destroy
+tmq_list_get_size
+tmq_list_to_c_array
+tmq_consumer_new
+tmq_err2str
+tmq_subscribe
+tmq_unsubscribe
+tmq_subscription
+tmq_consumer_poll
+tmq_consumer_close
+tmq_commit
+tmq_conf_new
+tmq_conf_set
+tmq_conf_destroy
+tmq_conf_set_offset_commit_cb
+tmq_get_topic_name
+tmq_get_vgroup_id
+tmq_create_stream
+taos_check_server_status
\ No newline at end of file
--- a/source/client/src/taos.rc.in
+++ b/source/client/src/taos.rc.in
+1 VERSIONINFO
+ FILEVERSION ${TD_VER_NUMBER}
+ PRODUCTVERSION ${TD_VER_NUMBER}
+ FILEFLAGSMASK 0x17L
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x4L
+ FILETYPE 0x0L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "FileDescription", "Native C Driver for TDengine"
+            VALUE "FileVersion", "${TD_VER_NUMBER}"
+            VALUE "InternalName", "taos.dll(${TD_VER_CPUTYPE})"
+            VALUE "LegalCopyright", "Copyright (C) 2020 TAOS Data"
+            VALUE "OriginalFilename", ""
+            VALUE "ProductName", "taos.dll(${TD_VER_CPUTYPE})"
+            VALUE "ProductVersion", "${TD_VER_NUMBER}"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
\ No newline at end of file
--- a/source/client/src/tmq.c
+++ b/source/client/src/tmq.c
@@ -25,7 +25,14 @@
 #include "tref.h"
 #include "ttimer.h"
-int32_t tmqAskEp(tmq_t* tmq, bool sync);
+int32_t tmqAskEp(tmq_t* tmq, bool async);
+typedef struct {
+  int8_t inited;
+  tmr_h  timer;
+} SMqMgmt;
+static SMqMgmt tmqMgmt = {0};
 typedef struct {
  int8_t  tmqRspType;
@@ -33,9 +40,9 @@ typedef struct {
 } SMqRspWrapper;
 typedef struct {
-  int8_t           tmqRspType;
+  int8_t      tmqRspType;
-  int32_t          epoch;
+  int32_t     epoch;
-  SMqCMGetSubEpRsp msg;
+  SMqAskEpRsp msg;
 } SMqAskEpRspWrapper;
 struct tmq_list_t {
@@ -56,7 +63,7 @@ struct tmq_conf_t {
  int8_t         autoCommit;
  int8_t         resetOffset;
  uint16_t       port;
-  uint16_t       autoCommitInterval;
+  int32_t        autoCommitInterval;
  char*          ip;
  char*          user;
  char*          pass;
@@ -64,29 +71,30 @@ struct tmq_conf_t {
  tmq_commit_cb* commit_cb;
 };
-typedef struct {
-  int8_t inited;
-  tmr_h  timer;
-} SMqMgmt;
-static SMqMgmt tmqMgmt = {0};
 struct tmq_t {
  // conf
  char           groupId[TSDB_CGROUP_LEN];
  char           clientId[256];
  int8_t         autoCommit;
-  int64_t        consumerId;
+  int32_t        autoCommitInterval;
  int32_t        resetOffsetCfg;
+  int64_t        consumerId;
  tmq_commit_cb* commit_cb;
  // status
  int8_t  status;
-  int8_t  epStatus;
  int32_t epoch;
+#if 0
+  int8_t  epStatus;
  int32_t epSkipCnt;
+#endif
  int64_t pollCnt;
+  // timer
+  tmr_h hbTimer;
+  tmr_h reportTimer;
+  tmr_h commitTimer;
  // connection
  STscObj* pTscObj;
@@ -111,6 +119,12 @@ enum {
  TMQ_CONSUMER_STATUS__READY,
 };
+enum {
+  TMQ_DELAYED_TASK__HB = 1,
+  TMQ_DELAYED_TASK__REPORT,
+  TMQ_DELAYED_TASK__COMMIT,
+};
 typedef struct {
  // statistics
  int64_t pollCnt;
@@ -150,7 +164,7 @@ typedef struct {
 typedef struct {
  tmq_t*  tmq;
  int32_t code;
-  int32_t sync;
+  int32_t async;
  tsem_t  rspSem;
 } SMqAskEpCbParam;
@@ -174,6 +188,7 @@ typedef struct {
 tmq_conf_t* tmq_conf_new() {
  tmq_conf_t* conf = taosMemoryCalloc(1, sizeof(tmq_conf_t));
  conf->autoCommit = false;
+  conf->autoCommitInterval = 5000;
  conf->resetOffset = TMQ_CONF__RESET_OFFSET__EARLIEAST;
  return conf;
 }
@@ -280,6 +295,50 @@ static int32_t tmqMakeTopicVgKey(char* dst, const char* topicName, int32_t vg) {
  return sprintf(dst, "%s:%d", topicName, vg);
 }
+void tmqAssignDelayedHbTask(void* param, void* tmrId) {
+  tmq_t*  tmq = (tmq_t*)param;
+  int8_t* pTaskType = taosAllocateQitem(sizeof(int8_t));
+  *pTaskType = TMQ_DELAYED_TASK__HB;
+  taosWriteQitem(tmq->delayedTask, pTaskType);
+}
+void tmqAssignDelayedCommitTask(void* param, void* tmrId) {
+  tmq_t*  tmq = (tmq_t*)param;
+  int8_t* pTaskType = taosAllocateQitem(sizeof(int8_t));
+  *pTaskType = TMQ_DELAYED_TASK__COMMIT;
+  taosWriteQitem(tmq->delayedTask, pTaskType);
+}
+void tmqAssignDelayedReportTask(void* param, void* tmrId) {
+  tmq_t*  tmq = (tmq_t*)param;
+  int8_t* pTaskType = taosAllocateQitem(sizeof(int8_t));
+  *pTaskType = TMQ_DELAYED_TASK__REPORT;
+  taosWriteQitem(tmq->delayedTask, pTaskType);
+}
+int32_t tmqHandleAllDelayedTask(tmq_t* tmq) {
+  STaosQall* qall = taosAllocateQall();
+  taosReadAllQitems(tmq->delayedTask, qall);
+  while (1) {
+    int8_t* pTaskType = NULL;
+    taosGetQitem(qall, (void**)&pTaskType);
+    if (pTaskType == NULL) break;
+    if (*pTaskType == TMQ_DELAYED_TASK__HB) {
+      tmqAskEp(tmq, true);
+      taosTmrReset(tmqAssignDelayedHbTask, 1000, tmq, tmqMgmt.timer, &tmq->hbTimer);
+    } else if (*pTaskType == TMQ_DELAYED_TASK__COMMIT) {
+      tmq_commit(tmq, NULL, true);
+      taosTmrReset(tmqAssignDelayedCommitTask, tmq->autoCommitInterval, tmq, tmqMgmt.timer, &tmq->commitTimer);
+    } else if (*pTaskType == TMQ_DELAYED_TASK__REPORT) {
+    } else {
+      ASSERT(0);
+    }
+  }
+  taosFreeQall(qall);
+  return 0;
+}
 void tmqClearUnhandleMsg(tmq_t* tmq) {
  SMqRspWrapper* msg = NULL;
  while (1) {
@@ -408,13 +467,14 @@ tmq_t* tmq_consumer_new(tmq_conf_t* conf, char* errstr, int32_t errstrLen) {
  pTmq->status = TMQ_CONSUMER_STATUS__INIT;
  pTmq->pollCnt = 0;
  pTmq->epoch = 0;
-  pTmq->epStatus = 0;
+  /*pTmq->epStatus = 0;*/
-  pTmq->epSkipCnt = 0;
+  /*pTmq->epSkipCnt = 0;*/
  // set conf
  strcpy(pTmq->clientId, conf->clientId);
  strcpy(pTmq->groupId, conf->groupId);
  pTmq->autoCommit = conf->autoCommit;
+  pTmq->autoCommitInterval = conf->autoCommitInterval;
  pTmq->commit_cb = conf->commit_cb;
  pTmq->resetOffsetCfg = conf->resetOffset;
@@ -602,11 +662,19 @@ tmq_resp_err_t tmq_subscribe(tmq_t* tmq, const tmq_list_t* topic_list) {
  if (code != 0) goto FAIL;
  // TODO: add max retry cnt
-  while (TSDB_CODE_MND_CONSUMER_NOT_READY == tmqAskEp(tmq, true)) {
+  while (TSDB_CODE_MND_CONSUMER_NOT_READY == tmqAskEp(tmq, false)) {
-    tscDebug("not ready, retry\n");
+    tscDebug("not ready, retry");
    taosMsleep(500);
  }
+  // init hb timer
+  tmq->hbTimer = taosTmrStart(tmqAssignDelayedHbTask, 1000, tmq, tmqMgmt.timer);
+  // init auto commit timer
+  if (tmq->autoCommit) {
+    tmq->commitTimer = taosTmrStart(tmqAssignDelayedCommitTask, tmq->autoCommitInterval, tmq, tmqMgmt.timer);
+  }
  code = 0;
 FAIL:
  if (req.topicNames != NULL) taosArrayDestroyP(req.topicNames, taosMemoryFree);
@@ -786,7 +854,7 @@ CREATE_MSG_FAIL:
  return -1;
 }
-bool tmqUpdateEp(tmq_t* tmq, int32_t epoch, SMqCMGetSubEpRsp* pRsp) {
+bool tmqUpdateEp(tmq_t* tmq, int32_t epoch, SMqAskEpRsp* pRsp) {
  /*printf("call update ep %d\n", epoch);*/
  bool    set = false;
  int32_t topicNumGet = taosArrayGetSize(pRsp->topics);
@@ -868,7 +936,7 @@ int32_t tmqAskEpCb(void* param, const SDataBuf* pMsg, int32_t code) {
  tmq_t*           tmq = pParam->tmq;
  pParam->code = code;
  if (code != 0) {
-    tscError("consumer %ld get topic endpoint error, not ready, wait:%d", tmq->consumerId, pParam->sync);
+    tscError("consumer %ld get topic endpoint error, not ready, wait:%d", tmq->consumerId, pParam->async);
    goto END;
  }
@@ -882,15 +950,15 @@ int32_t tmqAskEpCb(void* param, const SDataBuf* pMsg, int32_t code) {
    goto END;
  }
-  if (pParam->sync) {
+  if (!pParam->async) {
-    SMqCMGetSubEpRsp rsp;
+    SMqAskEpRsp rsp;
-    tDecodeSMqCMGetSubEpRsp(POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), &rsp);
+    tDecodeSMqAskEpRsp(POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), &rsp);
    /*printf("rsp epoch %ld sz %ld\n", rsp.epoch, rsp.topics->size);*/
    /*printf("tmq epoch %ld sz %ld\n", tmq->epoch, tmq->clientTopics->size);*/
    if (tmqUpdateEp(tmq, head->epoch, &rsp)) {
      atomic_store_8(&tmq->status, TMQ_CONSUMER_STATUS__READY);
    }
-    tDeleteSMqCMGetSubEpRsp(&rsp);
+    tDeleteSMqAskEpRsp(&rsp);
  } else {
    SMqAskEpRspWrapper* pWrapper = taosAllocateQitem(sizeof(SMqAskEpRspWrapper));
    if (pWrapper == NULL) {
@@ -901,7 +969,7 @@ int32_t tmqAskEpCb(void* param, const SDataBuf* pMsg, int32_t code) {
    pWrapper->tmqRspType = TMQ_MSG_TYPE__EP_RSP;
    pWrapper->epoch = head->epoch;
    memcpy(&pWrapper->msg, pMsg->pData, sizeof(SMqRspHead));
-    tDecodeSMqCMGetSubEpRsp(POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), &pWrapper->msg);
+    tDecodeSMqAskEpRsp(POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), &pWrapper->msg);
    taosWriteQitem(tmq->mqueue, pWrapper);
    /*tsem_post(&tmq->rspSem);*/
@@ -909,15 +977,16 @@ int32_t tmqAskEpCb(void* param, const SDataBuf* pMsg, int32_t code) {
  }
 END:
-  atomic_store_8(&tmq->epStatus, 0);
+  /*atomic_store_8(&tmq->epStatus, 0);*/
-  if (pParam->sync) {
+  if (!pParam->async) {
    tsem_post(&pParam->rspSem);
  }
  return code;
 }
-int32_t tmqAskEp(tmq_t* tmq, bool sync) {
+int32_t tmqAskEp(tmq_t* tmq, bool async) {
  int32_t code = 0;
+#if 0
  int8_t  epStatus = atomic_val_compare_exchange_8(&tmq->epStatus, 0, 1);
  if (epStatus == 1) {
    int32_t epSkipCnt = atomic_add_fetch_32(&tmq->epSkipCnt, 1);
@@ -925,11 +994,12 @@ int32_t tmqAskEp(tmq_t* tmq, bool sync) {
    if (epSkipCnt < 5000) return 0;
  }
  atomic_store_32(&tmq->epSkipCnt, 0);
-  int32_t           tlen = sizeof(SMqCMGetSubEpReq);
+#endif
-  SMqCMGetSubEpReq* req = taosMemoryMalloc(tlen);
+  int32_t      tlen = sizeof(SMqAskEpReq);
+  SMqAskEpReq* req = taosMemoryMalloc(tlen);
  if (req == NULL) {
    tscError("failed to malloc get subscribe ep buf");
-    atomic_store_8(&tmq->epStatus, 0);
+    /*atomic_store_8(&tmq->epStatus, 0);*/
    return -1;
  }
  req->consumerId = htobe64(tmq->consumerId);
@@ -940,11 +1010,11 @@ int32_t tmqAskEp(tmq_t* tmq, bool sync) {
  if (pParam == NULL) {
    tscError("failed to malloc subscribe param");
    taosMemoryFree(req);
-    atomic_store_8(&tmq->epStatus, 0);
+    /*atomic_store_8(&tmq->epStatus, 0);*/
    return -1;
  }
  pParam->tmq = tmq;
-  pParam->sync = sync;
+  pParam->async = async;
  tsem_init(&pParam->rspSem, 0, 0);
  SMsgSendInfo* sendInfo = taosMemoryMalloc(sizeof(SMsgSendInfo));
@@ -952,7 +1022,7 @@ int32_t tmqAskEp(tmq_t* tmq, bool sync) {
    tsem_destroy(&pParam->rspSem);
    taosMemoryFree(pParam);
    taosMemoryFree(req);
-    atomic_store_8(&tmq->epStatus, 0);
+    /*atomic_store_8(&tmq->epStatus, 0);*/
    return -1;
  }
@@ -966,7 +1036,7 @@ int32_t tmqAskEp(tmq_t* tmq, bool sync) {
  sendInfo->requestObjRefId = 0;
  sendInfo->param = pParam;
  sendInfo->fp = tmqAskEpCb;
-  sendInfo->msgType = TDMT_MND_GET_SUB_EP;
+  sendInfo->msgType = TDMT_MND_MQ_ASK_EP;
  SEpSet epSet = getEpSet_s(&tmq->pTscObj->pAppInfo->mgmtEp);
@@ -975,7 +1045,7 @@ int32_t tmqAskEp(tmq_t* tmq, bool sync) {
  int64_t transporterId = 0;
  asyncSendMsgToServer(tmq->pTscObj->pAppInfo->pTransporter, &epSet, &transporterId, sendInfo);
-  if (sync) {
+  if (!async) {
    tsem_wait(&pParam->rspSem);
    code = pParam->code;
    taosMemoryFree(pParam);
@@ -1139,7 +1209,7 @@ int32_t tmqHandleNoPollRsp(tmq_t* tmq, SMqRspWrapper* rspWrapper, bool* pReset)
    /*printf("ep %d %d\n", rspMsg->head.epoch, tmq->epoch);*/
    if (rspWrapper->epoch > atomic_load_32(&tmq->epoch)) {
      SMqAskEpRspWrapper* pEpRspWrapper = (SMqAskEpRspWrapper*)rspWrapper;
-      SMqCMGetSubEpRsp*   rspMsg = &pEpRspWrapper->msg;
+      SMqAskEpRsp*        rspMsg = &pEpRspWrapper->msg;
      tmqUpdateEp(tmq, rspWrapper->epoch, rspMsg);
      /*tmqClearUnhandleMsg(tmq);*/
      *pReset = true;
@@ -1201,22 +1271,13 @@ TAOS_RES* tmq_consumer_poll(tmq_t* tmq, int64_t blocking_time) {
  SMqRspObj* rspObj;
  int64_t    startTime = taosGetTimestampMs();
-  // TODO: put into delayed queue
-#if 0
-  int8_t status = atomic_load_8(&tmq->status);
-  while (0 != tmqAskEp(tmq, status != TMQ_CONSUMER_STATUS__READY)) {
-    tscDebug("not ready, retry\n");
-    taosSsleep(1);
-  }
-#endif
  rspObj = tmqHandleAllRsp(tmq, blocking_time, false);
  if (rspObj) {
    return (TAOS_RES*)rspObj;
  }
  while (1) {
-    tmqAskEp(tmq, false);
+    tmqHandleAllDelayedTask(tmq);
    tmqPollImpl(tmq, blocking_time);
    /*tsem_wait(&tmq->rspSem);*/

--- a/source/common/src/tdatablock.c
+++ b/source/common/src/tdatablock.c
@@ -79,7 +79,11 @@ int32_t colDataGetLength(const SColumnInfoData* pColumnInfoData, int32_t numOfRo
  if (IS_VAR_DATA_TYPE(pColumnInfoData->info.type)) {
    return pColumnInfoData->varmeta.length;
  } else {
-    return pColumnInfoData->info.bytes * numOfRows;
+    if (pColumnInfoData->info.type == TSDB_DATA_TYPE_NULL) {
+      return 0;
+    } else {
+      return pColumnInfoData->info.bytes * numOfRows;
+    }
  }
 }

--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@@ -93,7 +93,7 @@ STSRow *tGetSubmitBlkNext(SSubmitBlkIter *pIter) {
    return row;
  }
 }
-#if 0
 // TODO: KEEP one suite of iterator API finally.
 // 1) use tInitSubmitMsgIterEx firstly as not decrease the merge conflicts
 // 2) replace tInitSubmitMsgIterEx with tInitSubmitMsgIter later
@@ -173,7 +173,7 @@ STSRow *tGetSubmitBlkNextEx(SSubmitBlkIter *pIter) {
    return row;
  }
 }
-#endif
 int32_t tEncodeSEpSet(SCoder *pEncoder, const SEpSet *pEp) {
  if (tEncodeI8(pEncoder, pEp->inUse) < 0) return -1;
  if (tEncodeI8(pEncoder, pEp->numOfEps) < 0) return -1;
@@ -490,177 +490,6 @@ int32_t tDeserializeSClientHbBatchRsp(void *buf, int32_t bufLen, SClientHbBatchR
  return 0;
 }
-int32_t tSerializeSVCreateTbReq(void **buf, SVCreateTbReq *pReq) {
-  int32_t tlen = 0;
-  tlen += taosEncodeString(buf, pReq->name);
-  tlen += taosEncodeFixedU32(buf, pReq->ttl);
-  tlen += taosEncodeFixedU32(buf, pReq->keep);
-  tlen += taosEncodeFixedU8(buf, pReq->info);
-  switch (pReq->type) {
-    case TD_SUPER_TABLE:
-      tlen += taosEncodeFixedI64(buf, pReq->stbCfg.suid);
-      tlen += taosEncodeFixedI16(buf, pReq->stbCfg.nCols);
-      for (col_id_t i = 0; i < pReq->stbCfg.nCols; ++i) {
-        tlen += taosEncodeFixedI8(buf, pReq->stbCfg.pSchema[i].type);
-        tlen += taosEncodeFixedI8(buf, pReq->stbCfg.pSchema[i].flags);
-        tlen += taosEncodeFixedI16(buf, pReq->stbCfg.pSchema[i].colId);
-        tlen += taosEncodeFixedI32(buf, pReq->stbCfg.pSchema[i].bytes);
-        tlen += taosEncodeString(buf, pReq->stbCfg.pSchema[i].name);
-      }
-      tlen += taosEncodeFixedI16(buf, pReq->stbCfg.nTagCols);
-      for (col_id_t i = 0; i < pReq->stbCfg.nTagCols; ++i) {
-        tlen += taosEncodeFixedI8(buf, pReq->stbCfg.pTagSchema[i].type);
-        tlen += taosEncodeFixedI8(buf, pReq->stbCfg.pTagSchema[i].flags);
-        tlen += taosEncodeFixedI16(buf, pReq->stbCfg.pTagSchema[i].colId);
-        tlen += taosEncodeFixedI32(buf, pReq->stbCfg.pTagSchema[i].bytes);
-        tlen += taosEncodeString(buf, pReq->stbCfg.pTagSchema[i].name);
-      }
-      if (pReq->rollup && pReq->stbCfg.pRSmaParam) {
-        SRSmaParam *param = pReq->stbCfg.pRSmaParam;
-        tlen += taosEncodeBinary(buf, (const void *)&param->xFilesFactor, sizeof(param->xFilesFactor));
-        tlen += taosEncodeFixedI32(buf, param->delay);
-        tlen += taosEncodeFixedI32(buf, param->qmsg1Len);
-        if (param->qmsg1Len > 0) {
-          tlen += taosEncodeString(buf, param->qmsg1);
-        }
-        tlen += taosEncodeFixedI32(buf, param->qmsg2Len);
-        if (param->qmsg2Len > 0) {
-          tlen += taosEncodeString(buf, param->qmsg2);
-        }
-      }
-      break;
-    case TD_CHILD_TABLE:
-      tlen += taosEncodeFixedI64(buf, pReq->ctbCfg.suid);
-      tlen += tdEncodeKVRow(buf, pReq->ctbCfg.pTag);
-      break;
-    case TD_NORMAL_TABLE:
-      tlen += taosEncodeFixedI16(buf, pReq->ntbCfg.nCols);
-      for (col_id_t i = 0; i < pReq->ntbCfg.nCols; ++i) {
-        tlen += taosEncodeFixedI8(buf, pReq->ntbCfg.pSchema[i].type);
-        tlen += taosEncodeFixedI8(buf, pReq->ntbCfg.pSchema[i].flags);
-        tlen += taosEncodeFixedI16(buf, pReq->ntbCfg.pSchema[i].colId);
-        tlen += taosEncodeFixedI32(buf, pReq->ntbCfg.pSchema[i].bytes);
-        tlen += taosEncodeString(buf, pReq->ntbCfg.pSchema[i].name);
-      }
-      if (pReq->rollup && pReq->ntbCfg.pRSmaParam) {
-        SRSmaParam *param = pReq->ntbCfg.pRSmaParam;
-        tlen += taosEncodeBinary(buf, (const void *)&param->xFilesFactor, sizeof(param->xFilesFactor));
-        tlen += taosEncodeFixedI32(buf, param->delay);
-      }
-      break;
-    default:
-      ASSERT(0);
-  }
-  return tlen;
-}
-void *tDeserializeSVCreateTbReq(void *buf, SVCreateTbReq *pReq) {
-  buf = taosDecodeString(buf, &(pReq->name));
-  buf = taosDecodeFixedU32(buf, &(pReq->ttl));
-  buf = taosDecodeFixedU32(buf, &(pReq->keep));
-  buf = taosDecodeFixedU8(buf, &(pReq->info));
-  switch (pReq->type) {
-    case TD_SUPER_TABLE:
-      buf = taosDecodeFixedI64(buf, &(pReq->stbCfg.suid));
-      buf = taosDecodeFixedI16(buf, &(pReq->stbCfg.nCols));
-      pReq->stbCfg.pSchema = (SSchema *)taosMemoryMalloc(pReq->stbCfg.nCols * sizeof(SSchema));
-      for (col_id_t i = 0; i < pReq->stbCfg.nCols; ++i) {
-        buf = taosDecodeFixedI8(buf, &(pReq->stbCfg.pSchema[i].type));
-        buf = taosDecodeFixedI8(buf, &(pReq->stbCfg.pSchema[i].flags));
-        buf = taosDecodeFixedI16(buf, &(pReq->stbCfg.pSchema[i].colId));
-        buf = taosDecodeFixedI32(buf, &(pReq->stbCfg.pSchema[i].bytes));
-        buf = taosDecodeStringTo(buf, pReq->stbCfg.pSchema[i].name);
-      }
-      buf = taosDecodeFixedI16(buf, &pReq->stbCfg.nTagCols);
-      pReq->stbCfg.pTagSchema = (SSchema *)taosMemoryMalloc(pReq->stbCfg.nTagCols * sizeof(SSchema));
-      for (col_id_t i = 0; i < pReq->stbCfg.nTagCols; ++i) {
-        buf = taosDecodeFixedI8(buf, &(pReq->stbCfg.pTagSchema[i].type));
-        buf = taosDecodeFixedI8(buf, &(pReq->stbCfg.pTagSchema[i].flags));
-        buf = taosDecodeFixedI16(buf, &pReq->stbCfg.pTagSchema[i].colId);
-        buf = taosDecodeFixedI32(buf, &pReq->stbCfg.pTagSchema[i].bytes);
-        buf = taosDecodeStringTo(buf, pReq->stbCfg.pTagSchema[i].name);
-      }
-      if (pReq->rollup) {
-        pReq->stbCfg.pRSmaParam = (SRSmaParam *)taosMemoryCalloc(1, sizeof(SRSmaParam));
-        SRSmaParam *param = pReq->stbCfg.pRSmaParam;
-        buf = taosDecodeBinaryTo(buf, (void *)&param->xFilesFactor, sizeof(param->xFilesFactor));
-        buf = taosDecodeFixedI32(buf, &param->delay);
-        buf = taosDecodeFixedI32(buf, &param->qmsg1Len);
-        if (param->qmsg1Len > 0) {
-          buf = taosDecodeString(buf, &param->qmsg1);
-        }
-        buf = taosDecodeFixedI32(buf, &param->qmsg2Len);
-        if (param->qmsg2Len > 0) {
-          buf = taosDecodeString(buf, &param->qmsg2);
-        }
-      } else {
-        pReq->stbCfg.pRSmaParam = NULL;
-      }
-      break;
-    case TD_CHILD_TABLE:
-      buf = taosDecodeFixedI64(buf, &pReq->ctbCfg.suid);
-      buf = tdDecodeKVRow(buf, &pReq->ctbCfg.pTag);
-      break;
-    case TD_NORMAL_TABLE:
-      buf = taosDecodeFixedI16(buf, &pReq->ntbCfg.nCols);
-      pReq->ntbCfg.pSchema = (SSchema *)taosMemoryMalloc(pReq->ntbCfg.nCols * sizeof(SSchema));
-      for (col_id_t i = 0; i < pReq->ntbCfg.nCols; ++i) {
-        buf = taosDecodeFixedI8(buf, &pReq->ntbCfg.pSchema[i].type);
-        buf = taosDecodeFixedI8(buf, &pReq->ntbCfg.pSchema[i].flags);
-        buf = taosDecodeFixedI16(buf, &pReq->ntbCfg.pSchema[i].colId);
-        buf = taosDecodeFixedI32(buf, &pReq->ntbCfg.pSchema[i].bytes);
-        buf = taosDecodeStringTo(buf, pReq->ntbCfg.pSchema[i].name);
-      }
-      if (pReq->rollup) {
-        pReq->ntbCfg.pRSmaParam = (SRSmaParam *)taosMemoryMalloc(sizeof(SRSmaParam));
-        SRSmaParam *param = pReq->ntbCfg.pRSmaParam;
-        buf = taosDecodeBinaryTo(buf, (void *)&param->xFilesFactor, sizeof(param->xFilesFactor));
-        buf = taosDecodeFixedI32(buf, &param->delay);
-      } else {
-        pReq->ntbCfg.pRSmaParam = NULL;
-      }
-      break;
-    default:
-      ASSERT(0);
-  }
-  return buf;
-}
-int32_t tSerializeSVCreateTbBatchReq(void **buf, SVCreateTbBatchReq *pReq) {
-  int32_t tlen = 0;
-  tlen += taosEncodeFixedI64(buf, pReq->ver);
-  tlen += taosEncodeFixedU32(buf, taosArrayGetSize(pReq->pArray));
-  for (size_t i = 0; i < taosArrayGetSize(pReq->pArray); i++) {
-    SVCreateTbReq *pCreateTbReq = taosArrayGet(pReq->pArray, i);
-    tlen += tSerializeSVCreateTbReq(buf, pCreateTbReq);
-  }
-  return tlen;
-}
-void *tDeserializeSVCreateTbBatchReq(void *buf, SVCreateTbBatchReq *pReq) {
-  uint32_t nsize = 0;
-  buf = taosDecodeFixedI64(buf, &pReq->ver);
-  buf = taosDecodeFixedU32(buf, &nsize);
-  pReq->pArray = taosArrayInit(nsize, sizeof(SVCreateTbReq));
-  for (size_t i = 0; i < nsize; i++) {
-    SVCreateTbReq req = {0};
-    buf = tDeserializeSVCreateTbReq(buf, &req);
-    taosArrayPush(pReq->pArray, &req);
-  }
-  return buf;
-}
 int32_t tSerializeSVDropTbReq(void **buf, SVDropTbReq *pReq) {
  int32_t tlen = 0;
  tlen += taosEncodeFixedI64(buf, pReq->ver);
@@ -3397,7 +3226,7 @@ int32_t tEncodeSMqCMCommitOffsetReq(SCoder *encoder, const SMqCMCommitOffsetReq
 int32_t tDecodeSMqCMCommitOffsetReq(SCoder *decoder, SMqCMCommitOffsetReq *pReq) {
  if (tStartDecode(decoder) < 0) return -1;
  if (tDecodeI32(decoder, &pReq->num) < 0) return -1;
-  TCODER_MALLOC(pReq->offsets, SMqOffset *, pReq->num * sizeof(SMqOffset), decoder);
+  pReq->offsets = (SMqOffset *)TCODER_MALLOC(decoder, sizeof(SMqOffset) * pReq->num);
  if (pReq->offsets == NULL) return -1;
  for (int32_t i = 0; i < pReq->num; i++) {
    tDecodeSMqOffset(decoder, &pReq->offsets[i]);
@@ -3613,48 +3442,79 @@ int32_t tDeserializeSQueryTableRsp(void *buf, int32_t bufLen, SQueryTableRsp *pR
 }
 int32_t tSerializeSVCreateTbBatchRsp(void *buf, int32_t bufLen, SVCreateTbBatchRsp *pRsp) {
-  SCoder encoder = {0};
+  // SCoder encoder = {0};
-  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+  // tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
-  if (tStartEncode(&encoder) < 0) return -1;
+  // if (tStartEncode(&encoder) < 0) return -1;
-  if (pRsp->rspList) {
+  // if (pRsp->rspList) {
-    int32_t num = taosArrayGetSize(pRsp->rspList);
+  //   int32_t num = taosArrayGetSize(pRsp->rspList);
-    if (tEncodeI32(&encoder, num) < 0) return -1;
+  //   if (tEncodeI32(&encoder, num) < 0) return -1;
-    for (int32_t i = 0; i < num; ++i) {
+  //   for (int32_t i = 0; i < num; ++i) {
-      SVCreateTbRsp *rsp = taosArrayGet(pRsp->rspList, i);
+  //     SVCreateTbRsp *rsp = taosArrayGet(pRsp->rspList, i);
-      if (tEncodeI32(&encoder, rsp->code) < 0) return -1;
+  //     if (tEncodeI32(&encoder, rsp->code) < 0) return -1;
-    }
+  //   }
-  } else {
+  // } else {
-    if (tEncodeI32(&encoder, 0) < 0) return -1;
+  //   if (tEncodeI32(&encoder, 0) < 0) return -1;
-  }
+  // }
-  tEndEncode(&encoder);
+  // tEndEncode(&encoder);
-  int32_t tlen = encoder.pos;
+  // int32_t tlen = encoder.pos;
-  tCoderClear(&encoder);
+  // tCoderClear(&encoder);
-  return tlen;
+  // reture tlen;
+  return 0;
 }
 int32_t tDeserializeSVCreateTbBatchRsp(void *buf, int32_t bufLen, SVCreateTbBatchRsp *pRsp) {
-  SCoder  decoder = {0};
+  // SCoder  decoder = {0};
-  int32_t num = 0;
+  // int32_t num = 0;
-  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+  // tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
-  if (tStartDecode(&decoder) < 0) return -1;
+  // if (tStartDecode(&decoder) < 0) return -1;
-  if (tDecodeI32(&decoder, &num) < 0) return -1;
+  // if (tDecodeI32(&decoder, &num) < 0) return -1;
-  if (num > 0) {
+  // if (num > 0) {
-    pRsp->rspList = taosArrayInit(num, sizeof(SVCreateTbRsp));
+  //   pRsp->rspList = taosArrayInit(num, sizeof(SVCreateTbRsp));
-    if (NULL == pRsp->rspList) return -1;
+  //   if (NULL == pRsp->rspList) return -1;
-    for (int32_t i = 0; i < num; ++i) {
+  //   for (int32_t i = 0; i < num; ++i) {
-      SVCreateTbRsp rsp = {0};
+  //     SVCreateTbRsp rsp = {0};
-      if (tDecodeI32(&decoder, &rsp.code) < 0) return -1;
+  //     if (tDecodeI32(&decoder, &rsp.code) < 0) return -1;
-      if (NULL == taosArrayPush(pRsp->rspList, &rsp)) return -1;
+  //     if (NULL == taosArrayPush(pRsp->rspList, &rsp)) return -1;
-    }
+  //   }
-  } else {
+  // } else {
-    pRsp->rspList = NULL;
+  //   pRsp->rspList = NULL;
+  // }
+  // tEndDecode(&decoder);
+  // tCoderClear(&decoder);
+  return 0;
+}
+int tEncodeSVCreateTbBatchRsp(SCoder *pCoder, const SVCreateTbBatchRsp *pRsp) {
+  int32_t        nRsps = taosArrayGetSize(pRsp->pArray);
+  SVCreateTbRsp *pCreateRsp;
+  if (tStartEncode(pCoder) < 0) return -1;
+  if (tEncodeI32v(pCoder, nRsps) < 0) return -1;
+  for (int32_t i = 0; i < nRsps; i++) {
+    pCreateRsp = taosArrayGet(pRsp->pArray, i);
+    if (tEncodeSVCreateTbRsp(pCoder, pCreateRsp) < 0) return -1;
  }
-  tEndDecode(&decoder);
-  tCoderClear(&decoder);
+  tEndEncode(pCoder);
+  return 0;
+}
+int tDecodeSVCreateTbBatchRsp(SCoder *pCoder, SVCreateTbBatchRsp *pRsp) {
+  if (tStartDecode(pCoder) < 0) return -1;
+  if (tDecodeI32v(pCoder, &pRsp->nRsps) < 0) return -1;
+  pRsp->pRsps = (SVCreateTbRsp *)TCODER_MALLOC(pCoder, sizeof(*pRsp->pRsps) * pRsp->nRsps);
+  for (int32_t i = 0; i < pRsp->nRsps; i++) {
+    if (tDecodeSVCreateTbRsp(pCoder, pRsp->pRsps + i) < 0) return -1;
+  }
+  tEndDecode(pCoder);
  return 0;
 }
@@ -3756,6 +3616,38 @@ void tFreeSCMCreateStreamReq(SCMCreateStreamReq *pReq) {
  taosMemoryFreeClear(pReq->ast);
 }
+int tEncodeSVCreateStbReq(SCoder *pCoder, const SVCreateStbReq *pReq) {
+  if (tStartEncode(pCoder) < 0) return -1;
+  if (tEncodeCStr(pCoder, pReq->name) < 0) return -1;
+  if (tEncodeI64(pCoder, pReq->suid) < 0) return -1;
+  if (tEncodeI8(pCoder, pReq->rollup) < 0) return -1;
+  if (tEncodeSSchemaWrapper(pCoder, &pReq->schema) < 0) return -1;
+  if (tEncodeSSchemaWrapper(pCoder, &pReq->schemaTag) < 0) return -1;
+  // if (pReq->rollup) {
+  //   if (tEncodeSRSmaParam(pCoder, pReq->pRSmaParam) < 0) return -1;
+  // }
+  tEndEncode(pCoder);
+  return 0;
+}
+int tDecodeSVCreateStbReq(SCoder *pCoder, SVCreateStbReq *pReq) {
+  if (tStartDecode(pCoder) < 0) return -1;
+  if (tDecodeCStr(pCoder, &pReq->name) < 0) return -1;
+  if (tDecodeI64(pCoder, &pReq->suid) < 0) return -1;
+  if (tDecodeI8(pCoder, &pReq->rollup) < 0) return -1;
+  if (tDecodeSSchemaWrapper(pCoder, &pReq->schema) < 0) return -1;
+  if (tDecodeSSchemaWrapper(pCoder, &pReq->schemaTag) < 0) return -1;
+  // if (pReq->rollup) {
+  //   if (tDecodeSRSmaParam(pCoder, pReq->pRSmaParam) < 0) return -1;
+  // }
+  tEndDecode(pCoder);
+  return 0;
+}
 STSchema *tdGetSTSChemaFromSSChema(SSchema **pSchema, int32_t nCols) {
  STSchemaBuilder schemaBuilder = {0};
  if (tdInitTSchemaBuilder(&schemaBuilder, 0) < 0) {
@@ -3779,3 +3671,97 @@ STSchema *tdGetSTSChemaFromSSChema(SSchema **pSchema, int32_t nCols) {
  tdDestroyTSchemaBuilder(&schemaBuilder);
  return pNSchema;
 }
+int tEncodeSVCreateTbReq(SCoder *pCoder, const SVCreateTbReq *pReq) {
+  if (tStartEncode(pCoder) < 0) return -1;
+  if (tEncodeI64(pCoder, pReq->uid) < 0) return -1;
+  if (tEncodeI64(pCoder, pReq->ctime) < 0) return -1;
+  if (tEncodeCStr(pCoder, pReq->name) < 0) return -1;
+  if (tEncodeI32(pCoder, pReq->ttl) < 0) return -1;
+  if (tEncodeI8(pCoder, pReq->type) < 0) return -1;
+  if (pReq->type == TSDB_CHILD_TABLE) {
+    if (tEncodeI64(pCoder, pReq->ctb.suid) < 0) return -1;
+    if (tEncodeBinary(pCoder, pReq->ctb.pTag, kvRowLen(pReq->ctb.pTag)) < 0) return -1;
+  } else if (pReq->type == TSDB_NORMAL_TABLE) {
+    if (tEncodeSSchemaWrapper(pCoder, &pReq->ntb.schema) < 0) return -1;
+  } else {
+    ASSERT(0);
+  }
+  tEndEncode(pCoder);
+  return 0;
+}
+int tDecodeSVCreateTbReq(SCoder *pCoder, SVCreateTbReq *pReq) {
+  uint64_t len;
+  if (tStartDecode(pCoder) < 0) return -1;
+  if (tDecodeI64(pCoder, &pReq->uid) < 0) return -1;
+  if (tDecodeI64(pCoder, &pReq->ctime) < 0) return -1;
+  if (tDecodeCStr(pCoder, &pReq->name) < 0) return -1;
+  if (tDecodeI32(pCoder, &pReq->ttl) < 0) return -1;
+  if (tDecodeI8(pCoder, &pReq->type) < 0) return -1;
+  if (pReq->type == TSDB_CHILD_TABLE) {
+    if (tDecodeI64(pCoder, &pReq->ctb.suid) < 0) return -1;
+    if (tDecodeBinary(pCoder, &pReq->ctb.pTag, &len) < 0) return -1;
+  } else if (pReq->type == TSDB_NORMAL_TABLE) {
+    if (tDecodeSSchemaWrapper(pCoder, &pReq->ntb.schema) < 0) return -1;
+  } else {
+    ASSERT(0);
+  }
+  tEndDecode(pCoder);
+  return 0;
+}
+int tEncodeSVCreateTbBatchReq(SCoder *pCoder, const SVCreateTbBatchReq *pReq) {
+  int32_t nReq = taosArrayGetSize(pReq->pArray);
+  if (tStartEncode(pCoder) < 0) return -1;
+  if (tEncodeI32v(pCoder, nReq) < 0) return -1;
+  for (int iReq = 0; iReq < nReq; iReq++) {
+    if (tEncodeSVCreateTbReq(pCoder, (SVCreateTbReq *)taosArrayGet(pReq->pArray, iReq)) < 0) return -1;
+  }
+  tEndEncode(pCoder);
+  return 0;
+}
+int tDecodeSVCreateTbBatchReq(SCoder *pCoder, SVCreateTbBatchReq *pReq) {
+  if (tStartDecode(pCoder) < 0) return -1;
+  if (tDecodeI32v(pCoder, &pReq->nReqs) < 0) return -1;
+  pReq->pReqs = (SVCreateTbReq *)TCODER_MALLOC(pCoder, sizeof(SVCreateTbReq) * pReq->nReqs);
+  if (pReq->pReqs == NULL) return -1;
+  for (int iReq = 0; iReq < pReq->nReqs; iReq++) {
+    if (tDecodeSVCreateTbReq(pCoder, pReq->pReqs + iReq) < 0) return -1;
+  }
+  tEndDecode(pCoder);
+  return 0;
+}
+int tEncodeSVCreateTbRsp(SCoder *pCoder, const SVCreateTbRsp *pRsp) {
+  if (tStartEncode(pCoder) < 0) return -1;
+  if (tEncodeI32(pCoder, pRsp->code) < 0) return -1;
+  tEndEncode(pCoder);
+  return 0;
+}
+int tDecodeSVCreateTbRsp(SCoder *pCoder, SVCreateTbRsp *pRsp) {
+  if (tStartDecode(pCoder) < 0) return -1;
+  if (tDecodeI32(pCoder, &pRsp->code) < 0) return -1;
+  tEndDecode(pCoder);
+  return 0;
+}
\ No newline at end of file
--- a/source/common/test/tschemaTest.cpp
+++ b/source/common/test/tschemaTest.cpp
-#include <gtest/gtest.h>
-#include "tschema.h"
-TEST(td_schema_test, build_schema_test) {
-}
\ No newline at end of file
--- a/source/dnode/mgmt/exe/dmMain.c
+++ b/source/dnode/mgmt/exe/dmMain.c
@@ -17,11 +17,21 @@
 #include "dmImp.h"
 #include "tconfig.h"
+#define DM_APOLLO_URL    "The apollo string to use when configuring the server, such as: -a 'jsonFile:./tests/cfg.json', cfg.json text can be '{\"fqdn\":\"td1\"}'."
+#define DM_CFG_DIR       "Configuration directory."
+#define DM_DMP_CFG       "Dump configuration."
+#define DM_ENV_CMD       "The env cmd variable string to use when configuring the server, such as: -e 'TAOS_FQDN=td1'."
+#define DM_ENV_FILE      "The env variable file path to use when configuring the server, default is './.env', .env text can be 'TAOS_FQDN=td1'."
+#define DM_NODE_TYPE     "Startup type of the node, default is 0."
+#define DM_MACHINE_CODE  "Get machine code."
+#define DM_VERSION       "Print program version."
+#define DM_EMAIL         "<support@taosdata.com>"
 static struct {
  bool         dumpConfig;
  bool         generateGrant;
  bool         printAuth;
  bool         printVersion;
+  bool         printHelp;
  char         envFile[PATH_MAX];
  char         apolloUrl[PATH_MAX];
  const char **envCmd;
@@ -58,6 +68,7 @@ static void dmSetSignalHandle() {
 static int32_t dmParseArgs(int32_t argc, char const *argv[]) {
  int32_t cmdEnvIndex = 0;
+  if (argc < 2) return 0;
  global.envCmd = taosMemoryMalloc(argc-1);
  memset(global.envCmd, 0, argc-1);
  for (int32_t i = 1; i < argc; ++i) {
@@ -91,6 +102,8 @@ static int32_t dmParseArgs(int32_t argc, char const *argv[]) {
    } else if (strcmp(argv[i], "-e") == 0) {
      global.envCmd[cmdEnvIndex] = argv[++i];
      cmdEnvIndex++;
+    } else if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "--usage") == 0 || strcmp(argv[i], "-?")) {
+      global.printHelp = true;
    } else {
    }
  }
@@ -111,6 +124,21 @@ static void dmPrintVersion() {
  printf("buildInfo: %s\n", buildinfo);
 }
+static void dmPrintHelp() {
+  char indent[] = "  ";
+  printf("Usage: taosd [OPTION...] \n\n");
+  printf("%s%s%s%s\n", indent, "-a,", indent, DM_APOLLO_URL);
+  printf("%s%s%s%s\n", indent, "-c,", indent, DM_CFG_DIR);
+  printf("%s%s%s%s\n", indent, "-C,", indent, DM_DMP_CFG);
+  printf("%s%s%s%s\n", indent, "-e,", indent, DM_ENV_CMD);
+  printf("%s%s%s%s\n", indent, "-E,", indent, DM_ENV_FILE);
+  printf("%s%s%s%s\n", indent, "-n,", indent, DM_NODE_TYPE);
+  printf("%s%s%s%s\n", indent, "-k,", indent, DM_MACHINE_CODE);
+  printf("%s%s%s%s\n", indent, "-V,", indent, DM_VERSION);
+  printf("\n\nReport bugs to %s.\n", DM_EMAIL);
+}
 static void dmDumpCfg() {
  SConfig *pCfg = taosGetCfg();
  cfgDumpCfg(pCfg, 0, true);
@@ -197,6 +225,12 @@ int main(int argc, char const *argv[]) {
    return 0;
  }
+  if (global.printHelp) {
+    dmPrintHelp();
+    taosCleanupArgs();
+    return 0;
+  }
  if (global.printVersion) {
    dmPrintVersion();
    taosCleanupArgs();

--- a/source/dnode/mgmt/mgmt_mnode/src/mmHandle.c
+++ b/source/dnode/mgmt/mgmt_mnode/src/mmHandle.c
@@ -211,7 +211,7 @@ void mmInitMsgHandle(SMgmtWrapper *pWrapper) {
  dmSetMsgHandle(pWrapper, TDMT_MND_DROP_TOPIC, mmProcessWriteMsg, DEFAULT_HANDLE);
  dmSetMsgHandle(pWrapper, TDMT_MND_SUBSCRIBE, mmProcessWriteMsg, DEFAULT_HANDLE);
  dmSetMsgHandle(pWrapper, TDMT_MND_MQ_COMMIT_OFFSET, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_GET_SUB_EP, mmProcessReadMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_MND_MQ_ASK_EP, mmProcessReadMsg, DEFAULT_HANDLE);
  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_VG_CHANGE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
  dmSetMsgHandle(pWrapper, TDMT_MND_CREATE_STREAM, mmProcessWriteMsg, DEFAULT_HANDLE);
  dmSetMsgHandle(pWrapper, TDMT_VND_TASK_DEPLOY_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);

--- a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
+++ b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
@@ -107,14 +107,13 @@ static void vmGenerateVnodeCfg(SCreateVnodeReq *pCreate, SVnodeCfg *pCfg) {
  pCfg->vgId = pCreate->vgId;
  strcpy(pCfg->dbname, pCreate->db);
-  pCfg->wsize = pCreate->cacheBlockSize * 1024 * 1024;
+  pCfg->szBuf = pCreate->cacheBlockSize * 1024 * 1024;
-  pCfg->ssize = 1024;
-  pCfg->lsize = 1024 * 1024;
  pCfg->streamMode = pCreate->streamMode;
  pCfg->isWeak = true;
-  pCfg->tsdbCfg.keep2 = pCreate->daysToKeep0;
+  pCfg->tsdbCfg.days = 10;
-  pCfg->tsdbCfg.keep0 = pCreate->daysToKeep2;
+  pCfg->tsdbCfg.keep2 = 3650;  // pCreate->daysToKeep0;
-  pCfg->tsdbCfg.keep1 = pCreate->daysToKeep0;
+  pCfg->tsdbCfg.keep0 = 3650;  // pCreate->daysToKeep2;
+  pCfg->tsdbCfg.keep1 = 3650;  // pCreate->daysToKeep0;
  pCfg->tsdbCfg.lruCacheSize = pCreate->cacheBlockSize;
  pCfg->tsdbCfg.retentions = pCreate->pRetensions;
  pCfg->walCfg.vgId = pCreate->vgId;
@@ -212,7 +211,6 @@ int32_t vmProcessCreateVnodeReq(SVnodesMgmt *pMgmt, SNodeMsg *pMsg) {
    return code;
  }
  code = vmWriteVnodesToFile(pMgmt);
  if (code != 0) {
    tFreeSCreateVnodeReq(&createReq);

--- a/source/dnode/mnode/impl/inc/mndDef.h
+++ b/source/dnode/mnode/impl/inc/mndDef.h
@@ -126,6 +126,8 @@ typedef enum {
  DND_REASON_OTHERS
 } EDndReason;
+typedef void (*TransCbFp)(SMnode* pMnode, void* param);
 typedef struct {
  int32_t    id;
  ETrnStage  stage;
@@ -148,6 +150,8 @@ typedef struct {
  int64_t    dbUid;
  char       dbname[TSDB_DB_FNAME_LEN];
  char       lastError[TSDB_TRANS_ERROR_LEN];
+  TransCbFp  transCbFp;
+  void*      transCbParam;
 } STrans;
 typedef struct {
@@ -434,14 +438,12 @@ static FORCE_INLINE void* tDecodeSMqOffsetObj(void* buf, SMqOffsetObj* pOffset)
 }
 typedef struct {
-  char    name[TSDB_TOPIC_FNAME_LEN];
+  char           name[TSDB_TOPIC_FNAME_LEN];
-  char    db[TSDB_DB_FNAME_LEN];
+  char           db[TSDB_DB_FNAME_LEN];
-  int64_t createTime;
+  int64_t        createTime;
-  int64_t updateTime;
+  int64_t        updateTime;
-  int64_t uid;
+  int64_t        uid;
-  // TODO: use subDbUid
  int64_t        dbUid;
-  int64_t        subDbUid;
  int32_t        version;
  int8_t         subType;  // db or table
  int8_t         withTbName;

--- a/source/dnode/mnode/impl/inc/mndTrans.h
+++ b/source/dnode/mnode/impl/inc/mndTrans.h
@@ -44,6 +44,7 @@ int32_t mndTransAppendCommitlog(STrans *pTrans, SSdbRaw *pRaw);
 int32_t mndTransAppendRedoAction(STrans *pTrans, STransAction *pAction);
 int32_t mndTransAppendUndoAction(STrans *pTrans, STransAction *pAction);
 void    mndTransSetRpcRsp(STrans *pTrans, void *pCont, int32_t contLen);
+void    mndTransSetCb(STrans *pTrans, TransCbFp fp, void *param);
 void    mndTransSetDbInfo(STrans *pTrans, SDbObj *pDb);
 int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans);

--- a/source/dnode/mnode/impl/inc/mndVgroup.h
+++ b/source/dnode/mnode/impl/inc/mndVgroup.h
@@ -30,7 +30,6 @@ SSdbRaw *mndVgroupActionEncode(SVgObj *pVgroup);
 int32_t  mndAllocVgroup(SMnode *pMnode, SDbObj *pDb, SVgObj **ppVgroups);
 SEpSet   mndGetVgroupEpset(SMnode *pMnode, const SVgObj *pVgroup);
 int32_t  mndGetVnodesNum(SMnode *pMnode, int32_t dnodeId);
-int32_t  mndGetGlobalVgroupVersion(int32_t *vgId);
 void *mndBuildCreateVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen);
 void *mndBuildDropVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen);

--- a/source/dnode/mnode/impl/src/mndAcct.c
+++ b/source/dnode/mnode/impl/src/mndAcct.c
@@ -17,8 +17,8 @@
 #include "mndAcct.h"
 #include "mndShow.h"
-#define TSDB_ACCT_VER_NUMBER   1
+#define ACCT_VER_NUMBER   1
-#define TSDB_ACCT_RESERVE_SIZE 128
+#define ACCT_RESERVE_SIZE 128
 static int32_t  mndCreateDefaultAcct(SMnode *pMnode);
 static SSdbRaw *mndAcctActionEncode(SAcctObj *pAcct);
@@ -55,6 +55,7 @@ static int32_t mndCreateDefaultAcct(SMnode *pMnode) {
  acctObj.createdTime = taosGetTimestampMs();
  acctObj.updateTime = acctObj.createdTime;
  acctObj.acctId = 1;
+  acctObj.status = 0;
  acctObj.cfg = (SAcctCfg){.maxUsers = INT32_MAX,
                           .maxDbs = INT32_MAX,
                           .maxStbs = INT32_MAX,
@@ -79,7 +80,7 @@ static int32_t mndCreateDefaultAcct(SMnode *pMnode) {
 static SSdbRaw *mndAcctActionEncode(SAcctObj *pAcct) {
  terrno = TSDB_CODE_OUT_OF_MEMORY;
-  SSdbRaw *pRaw = sdbAllocRaw(SDB_ACCT, TSDB_ACCT_VER_NUMBER, sizeof(SAcctObj) + TSDB_ACCT_RESERVE_SIZE);
+  SSdbRaw *pRaw = sdbAllocRaw(SDB_ACCT, ACCT_VER_NUMBER, sizeof(SAcctObj) + ACCT_RESERVE_SIZE);
  if (pRaw == NULL) goto _OVER;
  int32_t dataPos = 0;
@@ -100,7 +101,7 @@ static SSdbRaw *mndAcctActionEncode(SAcctObj *pAcct) {
  SDB_SET_INT32(pRaw, dataPos, pAcct->cfg.maxTopics, _OVER)
  SDB_SET_INT64(pRaw, dataPos, pAcct->cfg.maxStorage, _OVER)
  SDB_SET_INT32(pRaw, dataPos, pAcct->cfg.accessState, _OVER)
-  SDB_SET_RESERVE(pRaw, dataPos, TSDB_ACCT_RESERVE_SIZE, _OVER)
+  SDB_SET_RESERVE(pRaw, dataPos, ACCT_RESERVE_SIZE, _OVER)
  SDB_SET_DATALEN(pRaw, dataPos, _OVER)
  terrno = 0;
@@ -122,7 +123,7 @@ static SSdbRow *mndAcctActionDecode(SSdbRaw *pRaw) {
  int8_t sver = 0;
  if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto _OVER;
-  if (sver != TSDB_ACCT_VER_NUMBER) {
+  if (sver != ACCT_VER_NUMBER) {
    terrno = TSDB_CODE_SDB_INVALID_DATA_VER;
    goto _OVER;
  }
@@ -151,7 +152,7 @@ static SSdbRow *mndAcctActionDecode(SSdbRaw *pRaw) {
  SDB_GET_INT32(pRaw, dataPos, &pAcct->cfg.maxTopics, _OVER)
  SDB_GET_INT64(pRaw, dataPos, &pAcct->cfg.maxStorage, _OVER)
  SDB_GET_INT32(pRaw, dataPos, &pAcct->cfg.accessState, _OVER)
-  SDB_GET_RESERVE(pRaw, dataPos, TSDB_ACCT_RESERVE_SIZE, _OVER)
+  SDB_GET_RESERVE(pRaw, dataPos, ACCT_RESERVE_SIZE, _OVER)
  terrno = 0;
@@ -178,7 +179,6 @@ static int32_t mndAcctActionDelete(SSdb *pSdb, SAcctObj *pAcct) {
 static int32_t mndAcctActionUpdate(SSdb *pSdb, SAcctObj *pOld, SAcctObj *pNew) {
  mTrace("acct:%s, perform update action, old row:%p new row:%p", pOld->acct, pOld, pNew);
  pOld->updateTime = pNew->updateTime;
  pOld->status = pNew->status;
  memcpy(&pOld->cfg, &pNew->cfg, sizeof(SAcctCfg));
@@ -186,19 +186,19 @@ static int32_t mndAcctActionUpdate(SSdb *pSdb, SAcctObj *pOld, SAcctObj *pNew) {
 }
 static int32_t mndProcessCreateAcctReq(SNodeMsg *pReq) {
-  terrno = TSDB_CODE_MND_MSG_NOT_PROCESSED;
+  terrno = TSDB_CODE_MSG_NOT_PROCESSED;
  mError("failed to process create acct request since %s", terrstr());
  return -1;
 }
 static int32_t mndProcessAlterAcctReq(SNodeMsg *pReq) {
-  terrno = TSDB_CODE_MND_MSG_NOT_PROCESSED;
+  terrno = TSDB_CODE_MSG_NOT_PROCESSED;
  mError("failed to process create acct request since %s", terrstr());
  return -1;
 }
 static int32_t mndProcessDropAcctReq(SNodeMsg *pReq) {
-  terrno = TSDB_CODE_MND_MSG_NOT_PROCESSED;
+  terrno = TSDB_CODE_MSG_NOT_PROCESSED;
  mError("failed to process create acct request since %s", terrstr());
  return -1;
 }
\ No newline at end of file
--- a/source/dnode/mnode/impl/src/mndConsumer.c
+++ b/source/dnode/mnode/impl/src/mndConsumer.c
@@ -59,7 +59,7 @@ int32_t mndInitConsumer(SMnode *pMnode) {
                     .deleteFp = (SdbDeleteFp)mndConsumerActionDelete};
  mndSetMsgHandle(pMnode, TDMT_MND_SUBSCRIBE, mndProcessSubscribeReq);
-  mndSetMsgHandle(pMnode, TDMT_MND_GET_SUB_EP, mndProcessAskEpReq);
+  mndSetMsgHandle(pMnode, TDMT_MND_MQ_ASK_EP, mndProcessAskEpReq);
  mndSetMsgHandle(pMnode, TDMT_MND_MQ_TIMER, mndProcessMqTimerMsg);
  mndSetMsgHandle(pMnode, TDMT_MND_MQ_CONSUMER_LOST, mndProcessConsumerLostMsg);
  return sdbSetTable(pMnode->pSdb, table);
@@ -86,7 +86,7 @@ static int32_t mndProcessConsumerLostMsg(SNodeMsg *pMsg) {
  mndTransDrop(pTrans);
  return 0;
 FAIL:
-  // TODO delete consumer
+  tDeleteSMqConsumerObj(pConsumerNew);
  mndTransDrop(pTrans);
  return -1;
 }
@@ -197,11 +197,11 @@ static int32_t mndProcessMqTimerMsg(SNodeMsg *pMsg) {
 }
 static int32_t mndProcessAskEpReq(SNodeMsg *pMsg) {
-  SMnode           *pMnode = pMsg->pNode;
+  SMnode      *pMnode = pMsg->pNode;
-  SMqCMGetSubEpReq *pReq = (SMqCMGetSubEpReq *)pMsg->rpcMsg.pCont;
+  SMqAskEpReq *pReq = (SMqAskEpReq *)pMsg->rpcMsg.pCont;
-  SMqCMGetSubEpRsp  rsp = {0};
+  SMqAskEpRsp  rsp = {0};
-  int64_t           consumerId = be64toh(pReq->consumerId);
+  int64_t      consumerId = be64toh(pReq->consumerId);
-  int32_t           epoch = ntohl(pReq->epoch);
+  int32_t      epoch = ntohl(pReq->epoch);
  SMqConsumerObj *pConsumer = mndAcquireConsumer(pMsg->pNode, consumerId);
  if (pConsumer == NULL) {
@@ -300,7 +300,7 @@ static int32_t mndProcessAskEpReq(SNodeMsg *pMsg) {
    taosRUnLockLatch(&pConsumer->lock);
  }
  // encode rsp
-  int32_t tlen = sizeof(SMqRspHead) + tEncodeSMqCMGetSubEpRsp(NULL, &rsp);
+  int32_t tlen = sizeof(SMqRspHead) + tEncodeSMqAskEpRsp(NULL, &rsp);
  void   *buf = rpcMallocCont(tlen);
  if (buf == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -311,10 +311,10 @@ static int32_t mndProcessAskEpReq(SNodeMsg *pMsg) {
  ((SMqRspHead *)buf)->consumerId = pConsumer->consumerId;
  void *abuf = POINTER_SHIFT(buf, sizeof(SMqRspHead));
-  tEncodeSMqCMGetSubEpRsp(&abuf, &rsp);
+  tEncodeSMqAskEpRsp(&abuf, &rsp);
  // release consumer and free memory
-  tDeleteSMqCMGetSubEpRsp(&rsp);
+  tDeleteSMqAskEpRsp(&rsp);
  mndReleaseConsumer(pMnode, pConsumer);
  // send rsp
@@ -322,7 +322,7 @@ static int32_t mndProcessAskEpReq(SNodeMsg *pMsg) {
  pMsg->rspLen = tlen;
  return 0;
 FAIL:
-  tDeleteSMqCMGetSubEpRsp(&rsp);
+  tDeleteSMqAskEpRsp(&rsp);
  mndReleaseConsumer(pMnode, pConsumer);
  return -1;
 }

--- a/source/dnode/mnode/impl/src/mndDb.c
+++ b/source/dnode/mnode/impl/src/mndDb.c
@@ -234,6 +234,8 @@ static int32_t mndDbActionUpdate(SSdb *pSdb, SDbObj *pOld, SDbObj *pNew) {
  return 0;
 }
+static int32_t mndGetGlobalVgroupVersion(SMnode *pMnode) { return sdbGetTableVer(pMnode->pSdb, SDB_VGROUP); }
 SDbObj *mndAcquireDb(SMnode *pMnode, const char *db) {
  SSdb   *pSdb = pMnode->pSdb;
  SDbObj *pDb = sdbAcquire(pSdb, SDB_DB, db);
@@ -618,7 +620,7 @@ static int32_t mndSetAlterDbRedoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pOl
  SSdbRaw *pRedoRaw = mndDbActionEncode(pOld);
  if (pRedoRaw == NULL) return -1;
  if (mndTransAppendRedolog(pTrans, pRedoRaw) != 0) return -1;
-  if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_UPDATING) != 0) return -1;
+  if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_READY) != 0) return -1;
  return 0;
 }
@@ -1191,8 +1193,7 @@ static int32_t mndProcessUseDbReq(SNodeMsg *pReq) {
  char *p = strchr(usedbReq.db, '.');
  if (p && 0 == strcmp(p + 1, TSDB_INFORMATION_SCHEMA_DB)) {
    memcpy(usedbRsp.db, usedbReq.db, TSDB_DB_FNAME_LEN);
-    //mndGetGlobalVgroupVersion(); TODO
+    int32_t vgVersion = mndGetGlobalVgroupVersion(pMnode);
-    static int32_t vgVersion = 1;
    if (usedbReq.vgVersion < vgVersion) {
      usedbRsp.pVgroupInfos = taosArrayInit(10, sizeof(SVgroupInfo));
      if (usedbRsp.pVgroupInfos == NULL) {

--- a/source/dnode/mnode/impl/src/mndDef.c
+++ b/source/dnode/mnode/impl/src/mndDef.c
@@ -215,7 +215,7 @@ SMqSubscribeObj *tNewSubscribeObj(const char key[TSDB_SUBSCRIBE_KEY_LEN]) {
  if (pSubNew == NULL) return NULL;
  memcpy(pSubNew->key, key, TSDB_SUBSCRIBE_KEY_LEN);
  taosInitRWLatch(&pSubNew->lock);
-  pSubNew->vgNum = -1;
+  pSubNew->vgNum = 0;
  pSubNew->consumerHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
  // TODO set free fp
  SMqConsumerEpInSub epInSub = {

--- a/source/dnode/mnode/impl/src/mndDnode.c
+++ b/source/dnode/mnode/impl/src/mndDnode.c
@@ -363,7 +363,7 @@ static int32_t mndProcessStatusReq(SNodeMsg *pReq) {
        pDnode->offlineReason = DND_REASON_VERSION_NOT_MATCH;
      }
      mError("dnode:%d, status msg version:%d not match cluster:%d", statusReq.dnodeId, statusReq.sver, tsVersion);
-      terrno = TSDB_CODE_MND_INVALID_MSG_VERSION;
+      terrno = TSDB_CODE_VERSION_NOT_COMPATIBLE;
      goto PROCESS_STATUS_MSG_OVER;
    }

--- a/source/dnode/mnode/impl/src/mndPerfSchema.c
+++ b/source/dnode/mnode/impl/src/mndPerfSchema.c
@@ -41,29 +41,31 @@ static const SPerfsTableSchema queriesSchema[] = {
 static const SPerfsTableSchema topicSchema[] = {
    {.name = "topic_name", .bytes = SYSTABLE_SCH_TABLE_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY},
-    /*{.name = "db_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY},*/
+    {.name = "db_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY},
    {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP},
    {.name = "sql", .bytes = TSDB_SHOW_SQL_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY},
-    /*{.name = "row_len", .bytes = 4, .type = TSDB_DATA_TYPE_INT},*/
+    // TODO config
 };
 static const SPerfsTableSchema consumerSchema[] = {
-    {.name = "client_id", .bytes = SYSTABLE_SCH_TABLE_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY},
+    {.name = "consumer_id", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT},
    {.name = "app_id", .bytes = SYSTABLE_SCH_TABLE_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY},
    {.name = "group_id", .bytes = SYSTABLE_SCH_TABLE_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY},
-    {.name = "pid", .bytes = 4, .type = TSDB_DATA_TYPE_INT},
    {.name = "status", .bytes = 4, .type = TSDB_DATA_TYPE_INT},
-    // ep
+    {.name = "topics", .bytes = TSDB_SHOW_LIST_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY},
-    // up time
+    {.name = "pid", .bytes = 4, .type = TSDB_DATA_TYPE_INT},
-    // topics
+    {.name = "end_point", .bytes = TSDB_EP_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY},
+    {.name = "up_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP},
 };
-static const SPerfsTableSchema subscribeSchema[] = {
+static const SPerfsTableSchema subscriptionSchema[] = {
    {.name = "topic_name", .bytes = SYSTABLE_SCH_TABLE_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY},
    {.name = "group_id", .bytes = SYSTABLE_SCH_TABLE_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY},
    {.name = "vgroup_id", .bytes = 4, .type = TSDB_DATA_TYPE_INT},
-    {.name = "offset", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT},
+    {.name = "consumer_id", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT},
-    {.name = "client_id", .bytes = SYSTABLE_SCH_TABLE_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY},
+    {.name = "committed_offset", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT},
+    {.name = "current_offset", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT},
+    {.name = "skip_log_cnt", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT},
 };
 static const SPerfsTableMeta perfsMeta[] = {
@@ -71,7 +73,7 @@ static const SPerfsTableMeta perfsMeta[] = {
    {TSDB_PERFS_TABLE_QUERIES, queriesSchema, tListLen(queriesSchema)},
    {TSDB_PERFS_TABLE_TOPICS, topicSchema, tListLen(topicSchema)},
    {TSDB_PERFS_TABLE_CONSUMERS, consumerSchema, tListLen(consumerSchema)},
-    {TSDB_PERFS_TABLE_SUBSCRIBES, subscribeSchema, tListLen(subscribeSchema)},
+    {TSDB_PERFS_TABLE_SUBSCRIPTIONS, subscriptionSchema, tListLen(subscriptionSchema)},
 };
 // connection/application/

--- a/source/dnode/mnode/impl/src/mndScheduler.c
+++ b/source/dnode/mnode/impl/src/mndScheduler.c
@@ -478,6 +478,7 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib
  SVgObj*     pVgroup = NULL;
  SQueryPlan* pPlan = NULL;
  SSubplan*   plan = NULL;
  if (pTopic->subType == TOPIC_SUB_TYPE__TABLE) {
    pPlan = qStringToQueryPlan(pTopic->physicalPlan);
    if (pPlan == NULL) {
@@ -485,10 +486,6 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib
      return -1;
    }
-    ASSERT(pSub->vgNum == -1);
-    pSub->vgNum = 0;
    int32_t levelNum = LIST_LENGTH(pPlan->pSubplans);
    if (levelNum != 1) {
      qDestroyQueryPlan(pPlan);
@@ -529,7 +526,7 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib
    pVgEp->vgId = pVgroup->vgId;
    taosArrayPush(pEpInSub->vgs, &pVgEp);
-    mDebug("init subscribption %s, assign vg: %d", pSub->key, pVgEp->vgId);
+    mDebug("init subscription %s, assign vg: %d", pSub->key, pVgEp->vgId);
    if (pTopic->subType == TOPIC_SUB_TYPE__TABLE) {
      int32_t msgLen;

--- a/source/dnode/mnode/impl/src/mndStb.c
+++ b/source/dnode/mnode/impl/src/mndStb.c
@@ -362,68 +362,49 @@ static FORCE_INLINE int schemaExColIdCompare(const void *colId, const void *pSch
 }
 static void *mndBuildVCreateStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pStb, int32_t *pContLen) {
-  SName name = {0};
+  SCoder         coder = {0};
+  int32_t        contLen;
+  SName          name = {0};
+  SVCreateStbReq req = {0};
  tNameFromString(&name, pStb->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
  char dbFName[TSDB_DB_FNAME_LEN] = {0};
  tNameGetFullDbName(&name, dbFName);
-  SVCreateTbReq req = {0};
  req.name = (char *)tNameGetTableName(&name);
-  req.ttl = 0;
+  req.suid = pStb->uid;
-  req.keep = 0;
+  req.rollup = pStb->ast1Len > 0 ? 1 : 0;
-  req.rollup = pStb->pAst1 > 0 ? 1 : 0;
+  req.schema.nCols = pStb->numOfColumns;
-  req.type = TD_SUPER_TABLE;
+  req.schema.sver = 0;
-  req.stbCfg.suid = pStb->uid;
+  req.schema.pSchema = pStb->pColumns;
-  req.stbCfg.nCols = pStb->numOfColumns;
+  req.schemaTag.nCols = pStb->numOfTags;
-  req.stbCfg.nTagCols = pStb->numOfTags;
+  req.schemaTag.pSchema = pStb->pTags;
-  req.stbCfg.pTagSchema = pStb->pTags;
-  req.stbCfg.pSchema = (SSchema *)taosMemoryCalloc(pStb->numOfColumns, sizeof(SSchema));
-  if (req.stbCfg.pSchema == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
-  }
-  memcpy(req.stbCfg.pSchema, pStb->pColumns, sizeof(SSchema) * pStb->numOfColumns);
-  SRSmaParam *pRSmaParam = NULL;
  if (req.rollup) {
-    pRSmaParam = (SRSmaParam *)taosMemoryCalloc(1, sizeof(SRSmaParam));
+    req.pRSmaParam.xFilesFactor = pStb->xFilesFactor;
-    if (pRSmaParam == NULL) {
+    req.pRSmaParam.delay = pStb->delay;
-      taosMemoryFreeClear(req.stbCfg.pSchema);
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      return NULL;
-    }
-    pRSmaParam->xFilesFactor = pStb->xFilesFactor;
-    pRSmaParam->delay = pStb->delay;
    if (pStb->ast1Len > 0) {
-      if (mndConvertRSmaTask(pStb->pAst1, 0, 0, &pRSmaParam->qmsg1, &pRSmaParam->qmsg1Len) != TSDB_CODE_SUCCESS) {
+      if (mndConvertRSmaTask(pStb->pAst1, 0, 0, &req.pRSmaParam.qmsg1, &req.pRSmaParam.qmsg1Len) != TSDB_CODE_SUCCESS) {
-        taosMemoryFreeClear(req.stbCfg.pRSmaParam);
-        taosMemoryFreeClear(req.stbCfg.pSchema);
        return NULL;
      }
    }
    if (pStb->ast2Len > 0) {
-      if (mndConvertRSmaTask(pStb->pAst2, 0, 0, &pRSmaParam->qmsg2, &pRSmaParam->qmsg2Len) != TSDB_CODE_SUCCESS) {
+      if (mndConvertRSmaTask(pStb->pAst2, 0, 0, &req.pRSmaParam.qmsg2, &req.pRSmaParam.qmsg2Len) != TSDB_CODE_SUCCESS) {
-        taosMemoryFreeClear(pRSmaParam->qmsg1);
-        taosMemoryFreeClear(req.stbCfg.pRSmaParam);
-        taosMemoryFreeClear(req.stbCfg.pSchema);
        return NULL;
      }
    }
-    req.stbCfg.pRSmaParam = pRSmaParam;
  }
+  // get length
+  if (tEncodeSize(tEncodeSVCreateStbReq, &req, contLen) < 0) {
+    return NULL;
+  }
+  contLen += sizeof(SMsgHead);
-  int32_t   contLen = tSerializeSVCreateTbReq(NULL, &req) + sizeof(SMsgHead);
  SMsgHead *pHead = taosMemoryMalloc(contLen);
  if (pHead == NULL) {
-    if (pRSmaParam) {
+    taosMemoryFreeClear(req.pRSmaParam.qmsg1);
-      taosMemoryFreeClear(pRSmaParam->qmsg1);
+    taosMemoryFreeClear(req.pRSmaParam.qmsg2);
-      taosMemoryFreeClear(pRSmaParam->qmsg2);
-      taosMemoryFreeClear(pRSmaParam);
-    }
-    taosMemoryFreeClear(req.stbCfg.pSchema);
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    return NULL;
  }
@@ -432,15 +413,15 @@ static void *mndBuildVCreateStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pSt
  pHead->vgId = htonl(pVgroup->vgId);
  void *pBuf = POINTER_SHIFT(pHead, sizeof(SMsgHead));
-  tSerializeSVCreateTbReq(&pBuf, &req);
+  tCoderInit(&coder, TD_LITTLE_ENDIAN, pBuf, contLen - sizeof(SMsgHead), TD_ENCODER);
+  if (tEncodeSVCreateStbReq(&coder, &req) < 0) {
+    return NULL;
+  }
+  tCoderClear(&coder);
  *pContLen = contLen;
-  if (pRSmaParam) {
+  taosMemoryFreeClear(req.pRSmaParam.qmsg1);
-    taosMemoryFreeClear(pRSmaParam->qmsg1);
+  taosMemoryFreeClear(req.pRSmaParam.qmsg2);
-    taosMemoryFreeClear(pRSmaParam->qmsg2);
-    taosMemoryFreeClear(pRSmaParam);
-  }
-  taosMemoryFreeClear(req.stbCfg.pSchema);
  return pHead;
 }

--- a/source/dnode/mnode/impl/src/mndSync.c
+++ b/source/dnode/mnode/impl/src/mndSync.c
@@ -72,7 +72,7 @@ static int32_t mndRestoreWal(SMnode *pMnode) {
    }
    mTrace("wal:%" PRId64 ", will be restored, content:%p", ver, pHead->head.body);
-    if (sdbWriteNotFree(pSdb, (void *)pHead->head.body) < 0) {
+    if (sdbWriteWithoutFree(pSdb, (void *)pHead->head.body) < 0) {
      mError("failed to read wal from sdb since %s, ver:%" PRId64, terrstr(), ver);
      goto WAL_RESTORE_OVER;
    }

--- a/source/dnode/mnode/impl/src/mndTopic.c
+++ b/source/dnode/mnode/impl/src/mndTopic.c
@@ -76,7 +76,6 @@ SSdbRaw *mndTopicActionEncode(SMqTopicObj *pTopic) {
  SDB_SET_INT64(pRaw, dataPos, pTopic->updateTime, TOPIC_ENCODE_OVER);
  SDB_SET_INT64(pRaw, dataPos, pTopic->uid, TOPIC_ENCODE_OVER);
  SDB_SET_INT64(pRaw, dataPos, pTopic->dbUid, TOPIC_ENCODE_OVER);
-  SDB_SET_INT64(pRaw, dataPos, pTopic->subDbUid, TOPIC_ENCODE_OVER);
  SDB_SET_INT32(pRaw, dataPos, pTopic->version, TOPIC_ENCODE_OVER);
  SDB_SET_INT8(pRaw, dataPos, pTopic->subType, TOPIC_ENCODE_OVER);
  SDB_SET_INT8(pRaw, dataPos, pTopic->withTbName, TOPIC_ENCODE_OVER);
@@ -139,7 +138,6 @@ SSdbRow *mndTopicActionDecode(SSdbRaw *pRaw) {
  SDB_GET_INT64(pRaw, dataPos, &pTopic->updateTime, TOPIC_DECODE_OVER);
  SDB_GET_INT64(pRaw, dataPos, &pTopic->uid, TOPIC_DECODE_OVER);
  SDB_GET_INT64(pRaw, dataPos, &pTopic->dbUid, TOPIC_DECODE_OVER);
-  SDB_GET_INT64(pRaw, dataPos, &pTopic->subDbUid, TOPIC_DECODE_OVER);
  SDB_GET_INT32(pRaw, dataPos, &pTopic->version, TOPIC_DECODE_OVER);
  SDB_GET_INT8(pRaw, dataPos, &pTopic->subType, TOPIC_DECODE_OVER);
  SDB_GET_INT8(pRaw, dataPos, &pTopic->withTbName, TOPIC_DECODE_OVER);
@@ -520,29 +518,33 @@ static int32_t mndRetrieveTopic(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pB
    pShow->pIter = sdbFetch(pSdb, SDB_TOPIC, pShow->pIter, (void **)&pTopic);
    if (pShow->pIter == NULL) break;
-    int32_t cols = 0;
+    SColumnInfoData *pColInfo;
+    SName            n;
+    int32_t          cols = 0;
    char topicName[TSDB_TOPIC_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
+    tNameFromString(&n, pTopic->name, T_NAME_ACCT | T_NAME_DB);
-    SName n;
-    tNameFromString(&n, pTopic->name, T_NAME_ACCT|T_NAME_DB);
    tNameGetDbName(&n, varDataVal(topicName));
    varDataSetLen(topicName, strlen(varDataVal(topicName)));
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
    colDataAppend(pColInfo, numOfRows, (const char *)topicName, false);
+    char dbName[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
+    tNameFromString(&n, pTopic->db, T_NAME_ACCT | T_NAME_DB);
+    tNameGetDbName(&n, varDataVal(dbName));
+    varDataSetLen(dbName, strlen(varDataVal(dbName)));
    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, numOfRows, (const char *)&pTopic->createTime, false);
+    colDataAppend(pColInfo, numOfRows, (const char *)dbName, false);
    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, numOfRows, (const char *)&pTopic->createTime, false);
    char sql[TSDB_SHOW_SQL_LEN + VARSTR_HEADER_SIZE] = {0};
    tstrncpy(&sql[VARSTR_HEADER_SIZE], pTopic->sql, TSDB_SHOW_SQL_LEN);
    varDataSetLen(sql, strlen(&sql[VARSTR_HEADER_SIZE]));
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
    colDataAppend(pColInfo, numOfRows, (const char *)sql, false);
-//    taosMemoryFree(sql);
    numOfRows++;
    sdbRelease(pSdb, pTopic);
  }

--- a/source/dnode/mnode/impl/src/mndTrans.c
+++ b/source/dnode/mnode/impl/src/mndTrans.c
@@ -193,9 +193,9 @@ TRANS_ENCODE_OVER:
 static SSdbRow *mndTransActionDecode(SSdbRaw *pRaw) {
  terrno = TSDB_CODE_OUT_OF_MEMORY;
-  SSdbRow *    pRow = NULL;
+  SSdbRow     *pRow = NULL;
-  STrans *     pTrans = NULL;
+  STrans      *pTrans = NULL;
-  char *       pData = NULL;
+  char        *pData = NULL;
  int32_t      dataLen = 0;
  int8_t       sver = 0;
  int32_t      redoLogNum = 0;
@@ -456,7 +456,7 @@ static int32_t mndTransActionUpdate(SSdb *pSdb, STrans *pOld, STrans *pNew) {
 }
 static STrans *mndAcquireTrans(SMnode *pMnode, int32_t transId) {
-  SSdb *  pSdb = pMnode->pSdb;
+  SSdb   *pSdb = pMnode->pSdb;
  STrans *pTrans = sdbAcquire(pSdb, SDB_TRANS, &transId);
  if (pTrans == NULL) {
    terrno = TSDB_CODE_MND_TRANS_NOT_EXIST;
@@ -574,6 +574,11 @@ void mndTransSetRpcRsp(STrans *pTrans, void *pCont, int32_t contLen) {
  pTrans->rpcRspLen = contLen;
 }
+void mndTransSetCb(STrans *pTrans, TransCbFp fp, void *param) {
+  pTrans->transCbFp = fp;
+  pTrans->transCbParam = param;
+}
 void mndTransSetDbInfo(STrans *pTrans, SDbObj *pDb) {
  pTrans->dbUid = pDb->uid;
  memcpy(pTrans->dbname, pDb->name, TSDB_DB_FNAME_LEN);
@@ -626,7 +631,7 @@ static int32_t mndCheckTransCanBeStartedInParallel(SMnode *pMnode, STrans *pNewT
  if (mndIsBasicTrans(pNewTrans)) return 0;
  STrans *pTrans = NULL;
-  void *  pIter = NULL;
+  void   *pIter = NULL;
  int32_t code = 0;
  while (1) {
@@ -707,6 +712,8 @@ int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans) {
  pNew->rpcRefId = pTrans->rpcRefId;
  pNew->rpcRsp = pTrans->rpcRsp;
  pNew->rpcRspLen = pTrans->rpcRspLen;
+  pNew->transCbFp = pTrans->transCbFp;
+  pNew->transCbParam = pTrans->transCbParam;
  pTrans->rpcRsp = NULL;
  pTrans->rpcRspLen = 0;
@@ -830,14 +837,14 @@ HANDLE_ACTION_RSP_OVER:
 }
 static int32_t mndTransExecuteLogs(SMnode *pMnode, SArray *pArray) {
-  SSdb *  pSdb = pMnode->pSdb;
+  SSdb   *pSdb = pMnode->pSdb;
  int32_t arraySize = taosArrayGetSize(pArray);
  if (arraySize == 0) return 0;
  for (int32_t i = 0; i < arraySize; ++i) {
    SSdbRaw *pRaw = taosArrayGetP(pArray, i);
-    int32_t  code = sdbWriteNotFree(pSdb, pRaw);
+    int32_t  code = sdbWriteWithoutFree(pSdb, pRaw);
    if (code != 0) {
      return code;
    }
@@ -1117,6 +1124,11 @@ static bool mndTransPerfromFinishedStage(SMnode *pMnode, STrans *pTrans) {
  }
  mDebug("trans:%d, finished, code:0x%04x, failedTimes:%d", pTrans->id, pTrans->code, pTrans->failedTimes);
+  if (pTrans->transCbFp != NULL) {
+    (*pTrans->transCbFp)(pMnode, pTrans->transCbParam);
+  }
  return continueExec;
 }
@@ -1205,11 +1217,11 @@ static int32_t mndKillTrans(SMnode *pMnode, STrans *pTrans) {
 }
 static int32_t mndProcessKillTransReq(SNodeMsg *pReq) {
-  SMnode *      pMnode = pReq->pNode;
+  SMnode       *pMnode = pReq->pNode;
  SKillTransReq killReq = {0};
  int32_t       code = -1;
-  SUserObj *    pUser = NULL;
+  SUserObj     *pUser = NULL;
-  STrans *      pTrans = NULL;
+  STrans       *pTrans = NULL;
  if (tDeserializeSKillTransReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &killReq) != 0) {
    terrno = TSDB_CODE_INVALID_MSG;
@@ -1249,7 +1261,7 @@ KILL_OVER:
 void mndTransPullup(SMnode *pMnode) {
  STrans *pTrans = NULL;
-  void *  pIter = NULL;
+  void   *pIter = NULL;
  while (1) {
    pIter = sdbFetch(pMnode->pSdb, SDB_TRANS, pIter, (void **)&pTrans);
@@ -1264,11 +1276,11 @@ void mndTransPullup(SMnode *pMnode) {
 static int32_t mndRetrieveTrans(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
  SMnode *pMnode = pReq->pNode;
-  SSdb *  pSdb = pMnode->pSdb;
+  SSdb   *pSdb = pMnode->pSdb;
  int32_t numOfRows = 0;
  STrans *pTrans = NULL;
  int32_t cols = 0;
-  char *  pWrite;
+  char   *pWrite;
  while (numOfRows < rows) {
    pShow->pIter = sdbFetch(pSdb, SDB_TRANS, pShow->pIter, (void **)&pTrans);

--- a/source/dnode/mnode/impl/src/mnode.c
+++ b/source/dnode/mnode/impl/src/mnode.c
@@ -368,7 +368,7 @@ int32_t mndProcessMsg(SNodeMsg *pMsg) {
  }
  if (isReq && (pRpc->contLen == 0 || pRpc->pCont == NULL)) {
-    terrno = TSDB_CODE_MND_INVALID_MSG_LEN;
+    terrno = TSDB_CODE_INVALID_MSG_LEN;
    mError("msg:%p, failed to process since %s, app:%p", pMsg, terrstr(), ahandle);
    return -1;
  }

--- a/source/dnode/mnode/impl/test/acct/acct.cpp
+++ b/source/dnode/mnode/impl/test/acct/acct.cpp
@@ -32,7 +32,7 @@ TEST_F(MndTestAcct, 01_Create_Acct) {
  SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_ACCT, pReq, contLen);
  ASSERT_NE(pRsp, nullptr);
-  ASSERT_EQ(pRsp->code, TSDB_CODE_MND_MSG_NOT_PROCESSED);
+  ASSERT_EQ(pRsp->code, TSDB_CODE_MSG_NOT_PROCESSED);
 }
 TEST_F(MndTestAcct, 02_Alter_Acct) {
@@ -42,7 +42,7 @@ TEST_F(MndTestAcct, 02_Alter_Acct) {
  SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_ACCT, pReq, contLen);
  ASSERT_NE(pRsp, nullptr);
-  ASSERT_EQ(pRsp->code, TSDB_CODE_MND_MSG_NOT_PROCESSED);
+  ASSERT_EQ(pRsp->code, TSDB_CODE_MSG_NOT_PROCESSED);
 }
 TEST_F(MndTestAcct, 03_Drop_Acct) {
@@ -52,5 +52,5 @@ TEST_F(MndTestAcct, 03_Drop_Acct) {
  SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_ACCT, pReq, contLen);
  ASSERT_NE(pRsp, nullptr);
-  ASSERT_EQ(pRsp->code, TSDB_CODE_MND_MSG_NOT_PROCESSED);
+  ASSERT_EQ(pRsp->code, TSDB_CODE_MSG_NOT_PROCESSED);
 }
--- a/source/dnode/mnode/impl/test/db/db.cpp
+++ b/source/dnode/mnode/impl/test/db/db.cpp
@@ -89,7 +89,6 @@ TEST_F(MndTestDb, 02_Create_Alter_Drop_Db) {
    void*   pReq = rpcMallocCont(contLen);
    tSerializeSAlterDbReq(pReq, contLen, &alterdbReq);
-    taosMsleep(1000); // Wait for the vnode to become the leader
    SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_DB, pReq, contLen);
    ASSERT_NE(pRsp, nullptr);
    ASSERT_EQ(pRsp->code, 0);

--- a/source/dnode/mnode/impl/test/sma/sma.cpp
+++ b/source/dnode/mnode/impl/test/sma/sma.cpp
@@ -255,7 +255,6 @@ TEST_F(MndTestSma, 02_Create_Show_Meta_Drop_Restart_BSma) {
    pReq = BuildCreateDbReq(dbname, &contLen);
    pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
    ASSERT_EQ(pRsp->code, 0);
-    taosMsleep(1000);  // Wait for the vnode to become the leader
  }
  {

--- a/source/dnode/mnode/impl/test/stb/stb.cpp
+++ b/source/dnode/mnode/impl/test/stb/stb.cpp
@@ -304,7 +304,6 @@ TEST_F(MndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) {
    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
    ASSERT_NE(pRsp, nullptr);
    ASSERT_EQ(pRsp->code, 0);
-    taosMsleep(2000); // Wait for the vnode to become the leader
  }
  {
@@ -439,7 +438,6 @@ TEST_F(MndTestStb, 02_Alter_Stb_AddTag) {
    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
    ASSERT_NE(pRsp, nullptr);
    ASSERT_EQ(pRsp->code, 0);
-    taosMsleep(2000); // Wait for the vnode to become the leader
  }
  {
@@ -499,7 +497,6 @@ TEST_F(MndTestStb, 03_Alter_Stb_DropTag) {
    void*    pReq = BuildCreateDbReq(dbname, &contLen);
    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
    ASSERT_EQ(pRsp->code, 0);
-    taosMsleep(2000); // Wait for the vnode to become the leader
  }
  {
@@ -541,7 +538,6 @@ TEST_F(MndTestStb, 04_Alter_Stb_AlterTagName) {
    void*    pReq = BuildCreateDbReq(dbname, &contLen);
    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
    ASSERT_EQ(pRsp->code, 0);
-    taosMsleep(2000); // Wait for the vnode to become the leader
  }
  {
@@ -606,7 +602,6 @@ TEST_F(MndTestStb, 05_Alter_Stb_AlterTagBytes) {
    void*    pReq = BuildCreateDbReq(dbname, &contLen);
    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
    ASSERT_EQ(pRsp->code, 0);
-    taosMsleep(2000); // Wait for the vnode to become the leader
  }
  {
@@ -660,7 +655,6 @@ TEST_F(MndTestStb, 06_Alter_Stb_AddColumn) {
    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
    ASSERT_NE(pRsp, nullptr);
    ASSERT_EQ(pRsp->code, 0);
-    taosMsleep(2000); // Wait for the vnode to become the leader
  }
  {
@@ -721,7 +715,6 @@ TEST_F(MndTestStb, 07_Alter_Stb_DropColumn) {
    void*    pReq = BuildCreateDbReq(dbname, &contLen);
    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
    ASSERT_EQ(pRsp->code, 0);
-    taosMsleep(2000); // Wait for the vnode to become the leader
  }
  {
@@ -782,7 +775,6 @@ TEST_F(MndTestStb, 08_Alter_Stb_AlterTagBytes) {
    void*    pReq = BuildCreateDbReq(dbname, &contLen);
    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
    ASSERT_EQ(pRsp->code, 0);
-    taosMsleep(2000); // Wait for the vnode to become the leader
  }
  {

--- a/source/dnode/mnode/sdb/src/sdbFile.c
+++ b/source/dnode/mnode/sdb/src/sdbFile.c
@@ -202,7 +202,7 @@ int32_t sdbReadFile(SSdb *pSdb) {
      break;
    }
-    code = sdbWriteNotFree(pSdb, pRaw);
+    code = sdbWriteWithoutFree(pSdb, pRaw);
    if (code != 0) {
      mError("failed to read file:%s since %s", file, terrstr());
      goto PARSE_SDB_DATA_ERROR;
@@ -263,7 +263,7 @@ static int32_t sdbWriteFileImp(SSdb *pSdb) {
        continue;
      }
-      sdbPrintOper(pSdb, pRow, "writeFile");
+      sdbPrintOper(pSdb, pRow, "write");
      SSdbRaw *pRaw = (*encodeFp)(pRow->pObj);
      if (pRaw != NULL) {

--- a/source/dnode/mnode/sdb/src/sdbHash.c
+++ b/source/dnode/mnode/sdb/src/sdbHash.c
@@ -51,7 +51,9 @@ const char *sdbTableName(ESdbType type) {
    case SDB_TOPIC:
      return "topic";
    case SDB_VGROUP:
-      return "vgId";
+      return "vgroup";
+    case SDB_SMA:
+      return "sma";
    case SDB_STB:
      return "stb";
    case SDB_DB:
@@ -86,13 +88,13 @@ void sdbPrintOper(SSdb *pSdb, SSdbRow *pRow, const char *oper) {
  EKeyType keyType = pSdb->keyTypes[pRow->type];
  if (keyType == SDB_KEY_BINARY) {
-    mTrace("%s:%s, refCount:%d oper:%s row:%p status:%s", sdbTableName(pRow->type), (char *)pRow->pObj, pRow->refCount,
+    mTrace("%s:%s, ref:%d oper:%s row:%p status:%s", sdbTableName(pRow->type), (char *)pRow->pObj, pRow->refCount, oper,
-           oper, pRow->pObj, sdbStatusStr(pRow->status));
+           pRow->pObj, sdbStatusStr(pRow->status));
  } else if (keyType == SDB_KEY_INT32) {
-    mTrace("%s:%d, refCount:%d oper:%s row:%p status:%s", sdbTableName(pRow->type), *(int32_t *)pRow->pObj,
+    mTrace("%s:%d, ref:%d oper:%s row:%p status:%s", sdbTableName(pRow->type), *(int32_t *)pRow->pObj, pRow->refCount,
-           pRow->refCount, oper, pRow->pObj, sdbStatusStr(pRow->status));
+           oper, pRow->pObj, sdbStatusStr(pRow->status));
  } else if (keyType == SDB_KEY_INT64) {
-    mTrace("%s:%" PRId64 ", refCount:%d oper:%s row:%p status:%s", sdbTableName(pRow->type), *(int64_t *)pRow->pObj,
+    mTrace("%s:%" PRId64 ", ref:%d oper:%s row:%p status:%s", sdbTableName(pRow->type), *(int64_t *)pRow->pObj,
           pRow->refCount, oper, pRow->pObj, sdbStatusStr(pRow->status));
  } else {
  }
@@ -142,7 +144,7 @@ static int32_t sdbInsertRow(SSdb *pSdb, SHashObj *hash, SSdbRaw *pRaw, SSdbRow *
  pRow->refCount = 0;
  pRow->status = pRaw->status;
-  sdbPrintOper(pSdb, pRow, "insertRow");
+  sdbPrintOper(pSdb, pRow, "insert");
  if (taosHashPut(hash, pRow->pObj, keySize, &pRow, sizeof(void *)) != 0) {
    taosWUnLockLatch(pLock);
@@ -191,7 +193,7 @@ static int32_t sdbUpdateRow(SSdb *pSdb, SHashObj *hash, SSdbRaw *pRaw, SSdbRow *
  SSdbRow *pOldRow = *ppOldRow;
  pOldRow->status = pRaw->status;
-  sdbPrintOper(pSdb, pOldRow, "updateRow");
+  sdbPrintOper(pSdb, pOldRow, "update");
  taosRUnLockLatch(pLock);
  int32_t     code = 0;
@@ -220,7 +222,7 @@ static int32_t sdbDeleteRow(SSdb *pSdb, SHashObj *hash, SSdbRaw *pRaw, SSdbRow *
  SSdbRow *pOldRow = *ppOldRow;
  pOldRow->status = pRaw->status;
-  sdbPrintOper(pSdb, pOldRow, "deleteRow");
+  sdbPrintOper(pSdb, pOldRow, "delete");
  taosHashRemove(hash, pOldRow->pObj, keySize);
  taosWUnLockLatch(pLock);
@@ -233,7 +235,7 @@ static int32_t sdbDeleteRow(SSdb *pSdb, SHashObj *hash, SSdbRaw *pRaw, SSdbRow *
  return 0;
 }
-int32_t sdbWriteNotFree(SSdb *pSdb, SSdbRaw *pRaw) {
+int32_t sdbWriteWithoutFree(SSdb *pSdb, SSdbRaw *pRaw) {
  SHashObj *hash = sdbGetHash(pSdb, pRaw->type);
  if (hash == NULL) return terrno;
@@ -266,7 +268,7 @@ int32_t sdbWriteNotFree(SSdb *pSdb, SSdbRaw *pRaw) {
 }
 int32_t sdbWrite(SSdb *pSdb, SSdbRaw *pRaw) {
-  int32_t code = sdbWriteNotFree(pSdb, pRaw);
+  int32_t code = sdbWriteWithoutFree(pSdb, pRaw);
  sdbFreeRaw(pRaw);
  return code;
 }
@@ -296,7 +298,7 @@ void *sdbAcquire(SSdb *pSdb, ESdbType type, const void *pKey) {
    case SDB_STATUS_UPDATING:
      atomic_add_fetch_32(&pRow->refCount, 1);
      pRet = pRow->pObj;
-      sdbPrintOper(pSdb, pRow, "acquireRow");
+      sdbPrintOper(pSdb, pRow, "acquire");
      break;
    case SDB_STATUS_CREATING:
      terrno = TSDB_CODE_SDB_OBJ_CREATING;
@@ -318,7 +320,7 @@ static void sdbCheck(SSdb *pSdb, SSdbRow *pRow) {
  taosRLockLatch(pLock);
  int32_t ref = atomic_load_32(&pRow->refCount);
-  sdbPrintOper(pSdb, pRow, "checkRow");
+  sdbPrintOper(pSdb, pRow, "check");
  if (ref <= 0 && pRow->status == SDB_STATUS_DROPPED) {
    sdbFreeRow(pSdb, pRow);
  }
@@ -330,13 +332,13 @@ void sdbRelease(SSdb *pSdb, void *pObj) {
  if (pObj == NULL) return;
  SSdbRow *pRow = (SSdbRow *)((char *)pObj - sizeof(SSdbRow));
-  if (pRow->type >= SDB_MAX ) return;
+  if (pRow->type >= SDB_MAX) return;
  SRWLatch *pLock = &pSdb->locks[pRow->type];
  taosRLockLatch(pLock);
  int32_t ref = atomic_sub_fetch_32(&pRow->refCount, 1);
-  sdbPrintOper(pSdb, pRow, "releaseRow");
+  sdbPrintOper(pSdb, pRow, "release");
  if (ref <= 0 && pRow->status == SDB_STATUS_DROPPED) {
    sdbFreeRow(pSdb, pRow);
  }
@@ -372,7 +374,7 @@ void *sdbFetch(SSdb *pSdb, ESdbType type, void *pIter, void **ppObj) {
    }
    atomic_add_fetch_32(&pRow->refCount, 1);
-    sdbPrintOper(pSdb, pRow, "fetchRow");
+    sdbPrintOper(pSdb, pRow, "fetch");
    *ppObj = pRow->pObj;
    break;
  }

--- a/source/dnode/mnode/sdb/src/sdbRaw.c
+++ b/source/dnode/mnode/sdb/src/sdbRaw.c
@@ -27,7 +27,7 @@ SSdbRaw *sdbAllocRaw(ESdbType type, int8_t sver, int32_t dataLen) {
  pRaw->sver = sver;
  pRaw->dataLen = dataLen;
-  mTrace("raw:%p, is created, len:%d", pRaw, dataLen);
+  mTrace("raw:%p, is created, len:%d table:%s", pRaw, dataLen, sdbTableName(type));
  return pRaw;
 }

--- a/source/dnode/mnode/sdb/src/sdbRow.c
+++ b/source/dnode/mnode/sdb/src/sdbRow.c
@@ -43,7 +43,7 @@ void sdbFreeRow(SSdb *pSdb, SSdbRow *pRow) {
    (*deleteFp)(pSdb, pRow->pObj);
  }
-  sdbPrintOper(pSdb, pRow, "freeRow");
+  sdbPrintOper(pSdb, pRow, "free");
  mTrace("row:%p, is freed", pRow->pObj);
  taosMemoryFreeClear(pRow);

--- a/source/dnode/vnode/CMakeLists.txt
+++ b/source/dnode/vnode/CMakeLists.txt
@@ -5,9 +5,7 @@ target_sources(
    PRIVATE
    # vnode
    "src/vnd/vnodeOpen.c"
-    "src/vnd/vnodeArenaMAImpl.c"
+    "src/vnd/vnodeBufPool.c"
-    "src/vnd/vnodeBufferPool.c"
-    # "src/vnd/vnodeBufferPool2.c"
    "src/vnd/vnodeCfg.c"
    "src/vnd/vnodeCommit.c"
    "src/vnd/vnodeInt.c"
@@ -22,11 +20,14 @@ target_sources(
    "src/meta/metaIdx.c"
    "src/meta/metaTable.c"
    "src/meta/metaTDBImpl.c"
-    # "src/meta/metaBDBImpl.c"
+    "src/meta/metaQuery.c"
+    "src/meta/metaCommit.c"
+    "src/meta/metaEntry.c"
    # tsdb
    "src/tsdb/tsdbTDBImpl.c"
    "src/tsdb/tsdbCommit.c"
+    "src/tsdb/tsdbCommit2.c"
    "src/tsdb/tsdbCompact.c"
    "src/tsdb/tsdbFile.c"
    "src/tsdb/tsdbFS.c"
@@ -71,6 +72,7 @@ target_link_libraries(
    PUBLIC transport
    PUBLIC stream
 )
+target_compile_definitions(vnode PUBLIC -DMETA_REFACT)
 if(${BUILD_TEST})
    add_subdirectory(test)

--- a/source/dnode/vnode/inc/vnode.h
+++ b/source/dnode/vnode/inc/vnode.h
@@ -32,6 +32,8 @@
 #include "tmsg.h"
 #include "trow.h"
+#include "tdbInt.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -59,7 +61,7 @@ int32_t vnodeAlter(SVnode *pVnode, const SVnodeCfg *pCfg);
 int32_t vnodeCompact(SVnode *pVnode);
 int32_t vnodeSync(SVnode *pVnode);
 int32_t vnodeGetLoad(SVnode *pVnode, SVnodeLoad *pLoad);
-int     vnodeValidateTableHash(SVnodeCfg *pVnodeOptions, char *tableFName);
+int     vnodeValidateTableHash(SVnode *pVnode, char *tableFName);
 int32_t vnodeStart(SVnode *pVnode);
 void    vnodeStop(SVnode *pVnode);
@@ -68,28 +70,36 @@ int64_t vnodeGetSyncHandle(SVnode *pVnode);
 void    vnodeGetSnapshot(SVnode *pVnode, SSnapshot *pSnapshot);
 // meta
-typedef struct SMeta      SMeta;  // todo: remove
+typedef struct SMeta       SMeta;  // todo: remove
-typedef struct SMTbCursor SMTbCursor;
+typedef struct SMetaReader SMetaReader;
+typedef struct SMetaEntry  SMetaEntry;
+void metaReaderInit(SMetaReader *pReader, SVnode *pVnode, int32_t flags);
+void metaReaderClear(SMetaReader *pReader);
+int  metaReadNext(SMetaReader *pReader);
+#if 1  // refact APIs below (TODO)
 typedef SVCreateTbReq   STbCfg;
 typedef SVCreateTSmaReq SSmaCfg;
+typedef struct SMTbCursor SMTbCursor;
 SMTbCursor *metaOpenTbCursor(SMeta *pMeta);
 void        metaCloseTbCursor(SMTbCursor *pTbCur);
-char       *metaTbCursorNext(SMTbCursor *pTbCur);
+int         metaTbCursorNext(SMTbCursor *pTbCur);
+#endif
 // tsdb
 typedef struct STsdb          STsdb;
-typedef struct STsdbQueryCond STsdbQueryCond;
 typedef void                 *tsdbReaderT;
 #define BLOCK_LOAD_OFFSET_SEQ_ORDER 1
 #define BLOCK_LOAD_TABLE_SEQ_ORDER  2
 #define BLOCK_LOAD_TABLE_RR_ORDER   3
-tsdbReaderT *tsdbQueryTables(STsdb *tsdb, STsdbQueryCond *pCond, STableGroupInfo *tableInfoGroup, uint64_t qId,
+tsdbReaderT *tsdbQueryTables(STsdb *tsdb, SQueryTableDataCond *pCond, STableGroupInfo *tableInfoGroup, uint64_t qId,
                             uint64_t taskId);
-tsdbReaderT  tsdbQueryCacheLast(STsdb *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList, uint64_t qId,
+tsdbReaderT  tsdbQueryCacheLast(STsdb *tsdb, SQueryTableDataCond *pCond, STableGroupInfo *groupList, uint64_t qId,
                                void *pMemRef);
 int32_t      tsdbGetFileBlocksDistInfo(tsdbReaderT *pReader, STableBlockDistInfo *pTableBlockInfo);
 bool         isTsdbCacheLastRow(tsdbReaderT *pReader);
@@ -101,6 +111,7 @@ bool         tsdbNextDataBlock(tsdbReaderT pTsdbReadHandle);
 void         tsdbRetrieveDataBlockInfo(tsdbReaderT *pTsdbReadHandle, SDataBlockInfo *pBlockInfo);
 int32_t      tsdbRetrieveDataBlockStatisInfo(tsdbReaderT *pTsdbReadHandle, SColumnDataAgg **pBlockStatis);
 SArray      *tsdbRetrieveDataBlock(tsdbReaderT *pTsdbReadHandle, SArray *pColumnIdList);
+void         tsdbResetReadHandle(tsdbReaderT queryHandle, SQueryTableDataCond* pCond);
 void         tsdbDestroyTableGroup(STableGroupInfo *pGroupList);
 int32_t      tsdbGetOneTableGroup(void *pMeta, uint64_t uid, TSKEY startKey, STableGroupInfo *pGroupInfo);
 int32_t      tsdbGetTableGroupFromIdList(STsdb *tsdb, SArray *pTableIdList, STableGroupInfo *pGroupInfo);
@@ -130,6 +141,7 @@ struct STsdbCfg {
  int8_t   precision;
  int8_t   update;
  int8_t   compression;
+  int8_t   slLevel;
  int32_t  days;
  int32_t  minRows;
  int32_t  maxRows;
@@ -144,10 +156,10 @@ struct SVnodeCfg {
  int32_t  vgId;
  char     dbname[TSDB_DB_NAME_LEN];
  uint64_t dbId;
-  uint64_t wsize;
+  int32_t  szPage;
-  uint64_t ssize;
+  int32_t  szCache;
-  uint64_t lsize;
+  uint64_t szBuf;
-  bool     isHeapAllocator;
+  bool     isHeap;
  uint32_t ttl;
  uint32_t keep;
  int8_t   streamMode;
@@ -160,20 +172,53 @@ struct SVnodeCfg {
  int8_t   hashMethod;
 };
-struct STsdbQueryCond {
-  STimeWindow  twindow;
-  int32_t      order;  // desc|asc order to iterate the data block
-  int32_t      numOfCols;
-  SColumnInfo *colList;
-  bool         loadExternalRows;  // load external rows or not
-  int32_t      type;              // data block load type:
-};
 typedef struct {
  TSKEY    lastKey;
  uint64_t uid;
 } STableKeyInfo;
+struct SMetaEntry {
+  int64_t     version;
+  int8_t      type;
+  tb_uid_t    uid;
+  const char *name;
+  union {
+    struct {
+      SSchemaWrapper schema;
+      SSchemaWrapper schemaTag;
+    } stbEntry;
+    struct {
+      int64_t     ctime;
+      int32_t     ttlDays;
+      tb_uid_t    suid;
+      const void *pTags;
+    } ctbEntry;
+    struct {
+      int64_t        ctime;
+      int32_t        ttlDays;
+      SSchemaWrapper schema;
+    } ntbEntry;
+  };
+};
+struct SMetaReader {
+  int32_t    flags;
+  SMeta     *pMeta;
+  SCoder     coder;
+  SMetaEntry me;
+  void      *pBuf;
+  int        szBuf;
+};
+struct SMTbCursor {
+  TDBC       *pDbc;
+  void       *pKey;
+  void       *pVal;
+  int         kLen;
+  int         vLen;
+  SMetaReader mr;
+};
 #ifdef __cplusplus
 }
 #endif

--- a/source/dnode/vnode/src/inc/meta.h
+++ b/source/dnode/vnode/src/inc/meta.h
@@ -39,25 +39,82 @@ typedef struct SMSmaCursor SMSmaCursor;
 int metaOpen(SVnode* pVnode, SMeta** ppMeta);
 int metaClose(SMeta* pMeta);
+// metaEntry ==================
+int metaEncodeEntry(SCoder* pCoder, const SMetaEntry* pME);
+int metaDecodeEntry(SCoder* pCoder, SMetaEntry* pME);
+// metaTable ==================
+int metaCreateSTable(SMeta* pMeta, int64_t version, SVCreateStbReq* pReq);
+int metaDropSTable(SMeta* pMeta, int64_t verison, SVDropStbReq* pReq);
+int metaCreateTable(SMeta* pMeta, int64_t version, SVCreateTbReq* pReq);
+// metaQuery ==================
+int metaGetTableEntryByVersion(SMetaReader* pReader, int64_t version, tb_uid_t uid);
+int metaGetTableEntryByUid(SMetaReader* pReader, tb_uid_t uid);
+int metaGetTableEntryByName(SMetaReader* pReader, const char* name);
 // metaIdx ==================
 int  metaOpenIdx(SMeta* pMeta);
 void metaCloseIdx(SMeta* pMeta);
 int  metaSaveTableToIdx(SMeta* pMeta, const STbCfg* pTbOptions);
 int  metaRemoveTableFromIdx(SMeta* pMeta, tb_uid_t uid);
+// metaCommit ==================
+int metaBegin(SMeta* pMeta);
 static FORCE_INLINE tb_uid_t metaGenerateUid(SMeta* pMeta) { return tGenIdPI64(); }
+struct SMeta {
+  char*     path;
+  SVnode*   pVnode;
+  TENV*     pEnv;
+  TXN       txn;
+  TDB*      pTbDb;
+  TDB*      pSkmDb;
+  TDB*      pUidIdx;
+  TDB*      pNameIdx;
+  TDB*      pCtbIdx;
+  TDB*      pTagIdx;
+  TDB*      pTtlIdx;
+  SMetaIdx* pIdx;
+};
+typedef struct {
+  int64_t  version;
+  tb_uid_t uid;
+} STbDbKey;
+typedef struct __attribute__((__packed__)) {
+  tb_uid_t uid;
+  int32_t  sver;
+} SSkmDbKey;
+typedef struct {
+  tb_uid_t suid;
+  tb_uid_t uid;
+} SCtbIdxKey;
+typedef struct __attribute__((__packed__)) {
+  tb_uid_t suid;
+  int16_t  cid;
+  char     data[];
+} STagIdxKey;
+typedef struct {
+  int64_t  dtime;
+  tb_uid_t uid;
+} STtlIdxKey;
+#if 1
 #define META_SUPER_TABLE  TD_SUPER_TABLE
 #define META_CHILD_TABLE  TD_CHILD_TABLE
 #define META_NORMAL_TABLE TD_NORMAL_TABLE
-int             metaCreateTable(SMeta* pMeta, STbCfg* pTbCfg, STbDdlH* pHandle);
+// int             metaCreateTable(SMeta* pMeta, STbCfg* pTbCfg, STbDdlH* pHandle);
 int             metaDropTable(SMeta* pMeta, tb_uid_t uid);
 int             metaCommit(SMeta* pMeta);
 int32_t         metaCreateTSma(SMeta* pMeta, SSmaCfg* pCfg);
 int32_t         metaDropTSma(SMeta* pMeta, int64_t indexUid);
-STbCfg*         metaGetTbInfoByUid(SMeta* pMeta, tb_uid_t uid);
-STbCfg*         metaGetTbInfoByName(SMeta* pMeta, char* tbname, tb_uid_t* uid);
 SSchemaWrapper* metaGetTableSchema(SMeta* pMeta, tb_uid_t uid, int32_t sver, bool isinline);
 STSchema*       metaGetTbTSchema(SMeta* pMeta, tb_uid_t uid, int32_t sver);
 void*           metaGetSmaInfoByIndex(SMeta* pMeta, int64_t indexUid, bool isDecode);
@@ -71,6 +128,7 @@ SMCtbCursor*    metaOpenCtbCursor(SMeta* pMeta, tb_uid_t uid);
 void            metaCloseCtbCurosr(SMCtbCursor* pCtbCur);
 tb_uid_t        metaCtbCursorNext(SMCtbCursor* pCtbCur);
+#ifndef META_REFACT
 // SMetaDB
 int  metaOpenDB(SMeta* pMeta);
 void metaCloseDB(SMeta* pMeta);
@@ -78,17 +136,9 @@ int  metaSaveTableToDB(SMeta* pMeta, STbCfg* pTbCfg, STbDdlH* pHandle);
 int  metaRemoveTableFromDb(SMeta* pMeta, tb_uid_t uid);
 int  metaSaveSmaToDB(SMeta* pMeta, STSma* pTbCfg);
 int  metaRemoveSmaFromDb(SMeta* pMeta, int64_t indexUid);
+#endif
-// SMetaIdx
+#endif
-tb_uid_t metaGenerateUid(SMeta* pMeta);
-struct SMeta {
-  char*     path;
-  SVnode*   pVnode;
-  SMetaDB*  pDB;
-  SMetaIdx* pIdx;
-};
 #ifdef __cplusplus
 }

--- a/source/dnode/vnode/src/inc/tsdb.h
+++ b/source/dnode/vnode/src/inc/tsdb.h
@@ -30,22 +30,39 @@ extern "C" {
 #define tsdbTrace(...) do { if (tsdbDebugFlag & DEBUG_TRACE) { taosPrintLog("TSDB ", DEBUG_TRACE, tsdbDebugFlag, __VA_ARGS__); }} while(0)
 // clang-format on
+// tsdbMemTable ================
+typedef struct STbData       STbData;
+typedef struct STsdbMemTable STsdbMemTable;
+typedef struct SMergeInfo    SMergeInfo;
+typedef struct STable        STable;
+int  tsdbMemTableCreate(STsdb *pTsdb, STsdbMemTable **ppMemTable);
+void tsdbMemTableDestroy(STsdb *pTsdb, STsdbMemTable *pMemTable);
+int  tsdbInsertTableData(STsdb *pTsdb, SSubmitBlk *pBlock, int32_t *pAffectedRows);
+int  tsdbLoadDataFromCache(STable *pTable, SSkipListIterator *pIter, TSKEY maxKey, int maxRowsToRead, SDataCols *pCols,
+                           TKEY *filterKeys, int nFilterKeys, bool keepDup, SMergeInfo *pMergeInfo);
+// tsdbCommit ================
+int tsdbBegin(STsdb *pTsdb);
+#if 1
 typedef struct SSmaStat SSmaStat;
 typedef struct SSmaEnv  SSmaEnv;
 typedef struct SSmaEnvs SSmaEnvs;
-typedef struct STable {
+struct STable {
  uint64_t  tid;
  uint64_t  uid;
  STSchema *pSchema;
-} STable;
+};
 #define TABLE_TID(t) (t)->tid
 #define TABLE_UID(t) (t)->uid
-STsdb  *tsdbOpen(const char *path, SVnode *pVnode, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF);
+int     tsdbOpen(SVnode *pVnode, STsdb **ppTsdb);
-void    tsdbClose(STsdb *);
+int     tsdbClose(STsdb *pTsdb);
-int     tsdbInsertData(STsdb *pTsdb, SSubmitReq *pMsg, SSubmitRsp *pRsp);
+int     tsdbInsertData(STsdb *pTsdb, int64_t version, SSubmitReq *pMsg, SSubmitRsp *pRsp);
 int     tsdbPrepareCommit(STsdb *pTsdb);
 int     tsdbCommit(STsdb *pTsdb);
 int32_t tsdbInitSma(STsdb *pTsdb);
@@ -56,7 +73,6 @@ int32_t tsdbInsertTSmaData(STsdb *pTsdb, int64_t indexUid, const char *msg);
 int32_t tsdbDropTSmaData(STsdb *pTsdb, int64_t indexUid);
 int32_t tsdbInsertRSmaData(STsdb *pTsdb, char *msg);
 void    tsdbCleanupReadHandle(tsdbReaderT queryHandle);
-int32_t tdScanAndConvertSubmitMsg(SSubmitReq *pMsg);
 typedef enum {
  TSDB_FILE_HEAD = 0,  // .head
  TSDB_FILE_DATA,      // .data
@@ -109,25 +125,28 @@ typedef struct {
  TSKEY minKey;
 } SRtn;
-typedef struct STbData {
+struct STbData {
  tb_uid_t   uid;
  TSKEY      keyMin;
  TSKEY      keyMax;
+  int64_t    minVer;
+  int64_t    maxVer;
  int64_t    nrows;
  SSkipList *pData;
-} STbData;
+};
-typedef struct STsdbMemTable {
+struct STsdbMemTable {
+  SVBufPool *pPool;
  T_REF_DECLARE()
-  SRWLatch       latch;
+  SRWLatch   latch;
-  TSKEY          keyMin;
+  TSKEY      keyMin;
-  TSKEY          keyMax;
+  TSKEY      keyMax;
-  uint64_t       nRow;
+  int64_t    minVer;
-  SMemAllocator *pMA;
+  int64_t    maxVer;
-  // Container
+  int64_t    nRow;
  SSkipList *pSlIdx;  // SSkiplist<STbData>
  SHashObj  *pHashIdx;
-} STsdbMemTable;
+};
 typedef struct {
  uint32_t version;       // Commit version from 0 to increase
@@ -153,18 +172,17 @@ typedef struct {
 } STsdbFS;
 struct STsdb {
-  int32_t               vgId;
+  char          *path;
-  SVnode               *pVnode;
+  SVnode        *pVnode;
-  bool                  repoLocked;
+  int32_t        vgId;
-  TdThreadMutex         mutex;
+  bool           repoLocked;
-  char                 *path;
+  TdThreadMutex  mutex;
-  STsdbCfg              config;
+  STsdbCfg       config;
-  STsdbMemTable        *mem;
+  STsdbMemTable *mem;
-  STsdbMemTable        *imem;
+  STsdbMemTable *imem;
-  SRtn                  rtn;
+  SRtn           rtn;
-  SMemAllocatorFactory *pmaf;
+  STsdbFS       *fs;
-  STsdbFS              *fs;
+  SSmaEnvs       smaEnvs;
-  SSmaEnvs              smaEnvs;
 };
 #define REPO_ID(r)        ((r)->vgId)
@@ -186,7 +204,7 @@ static FORCE_INLINE STSchema *tsdbGetTableSchemaImpl(STable *pTable, bool lock,
 }
 // tsdbMemTable.h
-typedef struct {
+struct SMergeInfo {
  int   rowsInserted;
  int   rowsUpdated;
  int   rowsDeleteSucceed;
@@ -194,7 +212,7 @@ typedef struct {
  int   nOperations;
  TSKEY keyFirst;
  TSKEY keyLast;
-} SMergeInfo;
+};
 static void  *taosTMalloc(size_t size);
 static void  *taosTCalloc(size_t nmemb, size_t size);
@@ -203,12 +221,6 @@ static void  *taosTZfree(void *ptr);
 static size_t taosTSizeof(void *ptr);
 static void   taosTMemset(void *ptr, int c);
-STsdbMemTable *tsdbNewMemTable(STsdb *pTsdb);
-void           tsdbFreeMemTable(STsdb *pTsdb, STsdbMemTable *pMemTable);
-int            tsdbMemTableInsert(STsdb *pTsdb, STsdbMemTable *pMemTable, SSubmitReq *pMsg, SSubmitRsp *pRsp);
-int tsdbLoadDataFromCache(STable *pTable, SSkipListIterator *pIter, TSKEY maxKey, int maxRowsToRead, SDataCols *pCols,
-                          TKEY *filterKeys, int nFilterKeys, bool keepDup, SMergeInfo *pMergeInfo);
 static FORCE_INLINE STSRow *tsdbNextIterRow(SSkipListIterator *pIter) {
  if (pIter == NULL) return NULL;
@@ -988,6 +1000,8 @@ static FORCE_INLINE int32_t tsdbEncodeTSmaKey(int64_t groupId, TSKEY tsKey, void
  return len;
 }
+#endif
 #ifdef __cplusplus
 }
 #endif

--- a/source/dnode/vnode/src/inc/vnd.h
+++ b/source/dnode/vnode/src/inc/vnd.h
@@ -31,70 +31,54 @@ extern "C" {
 // clang-format on
 // vnodeCfg ====================
+extern const SVnodeCfg vnodeCfgDefault;
+int vnodeCheckCfg(const SVnodeCfg*);
 int vnodeEncodeConfig(const void* pObj, SJson* pJson);
 int vnodeDecodeConfig(const SJson* pJson, void* pObj);
 // vnodeModule ====================
 int vnodeScheduleTask(int (*execute)(void*), void* arg);
+// vnodeBufPool ====================
+typedef struct SVBufPoolNode SVBufPoolNode;
+struct SVBufPoolNode {
+  SVBufPoolNode*  prev;
+  SVBufPoolNode** pnext;
+  int64_t         size;
+  uint8_t         data[];
+};
+struct SVBufPool {
+  SVBufPool*     next;
+  int64_t        nRef;
+  int64_t        size;
+  uint8_t*       ptr;
+  SVBufPoolNode* pTail;
+  SVBufPoolNode  node;
+};
+int   vnodeOpenBufPool(SVnode* pVnode, int64_t size);
+int   vnodeCloseBufPool(SVnode* pVnode);
+void  vnodeBufPoolReset(SVBufPool* pPool);
+void* vnodeBufPoolMalloc(SVBufPool* pPool, int size);
+void  vnodeBufPoolFree(SVBufPool* pPool, void* p);
 // vnodeQuery ====================
 int  vnodeQueryOpen(SVnode* pVnode);
 void vnodeQueryClose(SVnode* pVnode);
 int  vnodeGetTableMeta(SVnode* pVnode, SRpcMsg* pMsg);
 // vnodeCommit ====================
+int vnodeBegin(SVnode* pVnode);
+int vnodeShouldCommit(SVnode* pVnode);
+int vnodeCommit(SVnode* pVnode);
 int vnodeSaveInfo(const char* dir, const SVnodeInfo* pCfg);
 int vnodeCommitInfo(const char* dir, const SVnodeInfo* pInfo);
 int vnodeLoadInfo(const char* dir, SVnodeInfo* pInfo);
-int vnodeBegin(SVnode* pVnode, int option);
 int vnodeSyncCommit(SVnode* pVnode);
 int vnodeAsyncCommit(SVnode* pVnode);
-#define vnodeShouldCommit vnodeBufPoolIsFull
-#if 1
-// 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);
-SMemAllocatorFactory* vBufPoolGetMAF(SVnode* pVnode);
-// SVMemAllocator
-typedef struct SVArenaNode {
-  TD_SLIST_NODE(SVArenaNode);
-  uint64_t size;  // current node size
-  void*    ptr;
-  char     data[];
-} SVArenaNode;
-typedef struct SVMemAllocator {
-  T_REF_DECLARE()
-  TD_DLIST_NODE(SVMemAllocator);
-  uint64_t     capacity;
-  uint64_t     ssize;
-  uint64_t     lsize;
-  SVArenaNode* pNode;
-  TD_SLIST(SVArenaNode) nlist;
-} SVMemAllocator;
-SVMemAllocator* vmaCreate(uint64_t capacity, uint64_t ssize, uint64_t lsize);
-void            vmaDestroy(SVMemAllocator* pVMA);
-void            vmaReset(SVMemAllocator* pVMA);
-void*           vmaMalloc(SVMemAllocator* pVMA, uint64_t size);
-void            vmaFree(SVMemAllocator* pVMA, void* ptr);
-bool            vmaIsFull(SVMemAllocator* pVMA);
-// vnodeCfg.h
-extern const SVnodeCfg vnodeCfgDefault;
-int vnodeCheckCfg(const SVnodeCfg*);
-#endif
 #ifdef __cplusplus
 }
 #endif

--- a/source/dnode/vnode/src/inc/vnodeInt.h
+++ b/source/dnode/vnode/src/inc/vnodeInt.h
@@ -22,9 +22,11 @@
 #include "sync.h"
 #include "tchecksum.h"
 #include "tcoding.h"
+#include "tcompare.h"
 #include "tcompression.h"
 #include "tdatablock.h"
 #include "tdbInt.h"
+#include "tencode.h"
 #include "tfs.h"
 #include "tglobal.h"
 #include "tjson.h"
@@ -68,8 +70,8 @@ typedef struct {
 } SStreamSinkInfo;
 typedef struct {
-  SVnode   *pVnode;
+  SVnode*   pVnode;
-  SHashObj *pHash;  // streamId -> SStreamSinkInfo
+  SHashObj* pHash;  // streamId -> SStreamSinkInfo
 } SSink;
 // SVState
@@ -85,20 +87,23 @@ struct SVnodeInfo {
 };
 struct SVnode {
-  char      *path;
+  char*      path;
  SVnodeCfg  config;
  SVState    state;
-  STfs      *pTfs;
+  STfs*      pTfs;
  SMsgCb     msgCb;
-  SVBufPool *pBufPool;
+  SVBufPool* pPool;
-  SMeta     *pMeta;
+  SVBufPool* inUse;
-  STsdb     *pTsdb;
+  SVBufPool* onCommit;
-  SWal      *pWal;
+  SVBufPool* onRecycle;
-  STQ       *pTq;
+  SMeta*     pMeta;
-  SSink     *pSink;
+  STsdb*     pTsdb;
-  int64_t    sync;  // sync integration
+  SWal*      pWal;
+  STQ*       pTq;
+  SSink*     pSink;
+  int64_t    sync;
  tsem_t     canCommit;
-  SQHandle  *pQuery;
+  SQHandle*  pQuery;
 };
 #define TD_VID(PVNODE) (PVNODE)->config.vgId
@@ -106,7 +111,7 @@ struct SVnode {
 typedef struct STbDdlH STbDdlH;
 // sma
-void smaHandleRes(void *pVnode, int64_t smaId, const SArray *data);
+void smaHandleRes(void* pVnode, int64_t smaId, const SArray* data);
 #include "vnd.h"

--- a/source/dnode/vnode/src/meta/metaBDBImpl.c
+++ b/source/dnode/vnode/src/meta/metaBDBImpl.c
--- a/include/common/tschema.h
+++ b/include/common/tschema.h
@@ -13,69 +13,19 @@
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
-#ifndef _TD_COMMON_SCHEMA_H_
+#include "vnodeInt.h"
-#define _TD_COMMON_SCHEMA_H_
-#include "os.h"
+static FORCE_INLINE void *metaMalloc(void *pPool, size_t size) { return vnodeBufPoolMalloc((SVBufPool *)pPool, size); }
-#include "tarray.h"
+static FORCE_INLINE void  metaFree(void *pPool, void *p) { vnodeBufPoolFree((SVBufPool *)pPool, p); }
-#include "ttypes.h"
-#ifdef __cplusplus
+int metaBegin(SMeta *pMeta) {
-extern "C" {
+  tdbTxnOpen(&pMeta->txn, 0, metaMalloc, metaFree, pMeta->pVnode->inUse, TDB_TXN_WRITE | TDB_TXN_READ_UNCOMMITTED);
-#endif
-#if 0
+  if (tdbBegin(pMeta->pEnv, &pMeta->txn) < 0) {
-typedef struct STColumn {
+    return -1;
-  /// column name
+  }
-  char *cname;
-  union {
-    /// for encode purpose
-    uint64_t info;
-    struct {
-      uint64_t sma : 1;
-      /// column data type
-      uint64_t type : 7;
-      /// column id
-      uint64_t cid : 16;
-      /// max bytes of the column
-      uint64_t bytes : 32;
-      /// reserved
-      uint64_t reserve : 8;
-    };
-  };
-  /// comment about the column
-  char *comment;
-} STColumn;
-typedef struct STSchema {
+  return 0;
-  /// schema version
-  uint16_t sver;
-  /// number of columns
-  uint16_t ncols;
-  /// sma attributes
-  struct {
-    bool    sma;
-    SArray *smaArray;
-  };
-  /// column info
-  STColumn cols[];
-} STSchema;
-typedef struct {
-  uint64_t  size;
-  STSchema *pSchema;
-} STShemaBuilder;
-#define tSchemaBuilderInit(target, capacity) \
-  { .size = (capacity), .pSchema = (target) }
-void tSchemaBuilderSetSver(STShemaBuilder *pSchemaBuilder, uint16_t sver);
-void tSchemaBuilderSetSMA(bool sma, SArray *smaArray);
-int32_t  tSchemaBuilderPutColumn(char *cname, bool sma, uint8_t type, col_id_t cid, uint32_t bytes, char *comment);
-#endif
-#ifdef __cplusplus
 }
-#endif
-#endif /*_TD_COMMON_SCHEMA_H_*/
+int metaCommit(SMeta *pMeta) { return tdbCommit(pMeta->pEnv, &pMeta->txn); }
\ No newline at end of file
--- a/source/dnode/vnode/src/meta/metaEntry.c
+++ b/source/dnode/vnode/src/meta/metaEntry.c
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "vnodeInt.h"
+int metaEncodeEntry(SCoder *pCoder, const SMetaEntry *pME) {
+  if (tStartEncode(pCoder) < 0) return -1;
+  if (tEncodeI64(pCoder, pME->version) < 0) return -1;
+  if (tEncodeI8(pCoder, pME->type) < 0) return -1;
+  if (tEncodeI64(pCoder, pME->uid) < 0) return -1;
+  if (tEncodeCStr(pCoder, pME->name) < 0) return -1;
+  if (pME->type == TSDB_SUPER_TABLE) {
+    if (tEncodeSSchemaWrapper(pCoder, &pME->stbEntry.schema) < 0) return -1;
+    if (tEncodeSSchemaWrapper(pCoder, &pME->stbEntry.schemaTag) < 0) return -1;
+  } else if (pME->type == TSDB_CHILD_TABLE) {
+    if (tEncodeI64(pCoder, pME->ctbEntry.ctime) < 0) return -1;
+    if (tEncodeI32(pCoder, pME->ctbEntry.ttlDays) < 0) return -1;
+    if (tEncodeI64(pCoder, pME->ctbEntry.suid) < 0) return -1;
+    if (tEncodeBinary(pCoder, pME->ctbEntry.pTags, kvRowLen(pME->ctbEntry.pTags)) < 0) return -1;
+  } else if (pME->type == TSDB_NORMAL_TABLE) {
+    if (tEncodeI64(pCoder, pME->ntbEntry.ctime) < 0) return -1;
+    if (tEncodeI32(pCoder, pME->ntbEntry.ttlDays) < 0) return -1;
+    if (tEncodeSSchemaWrapper(pCoder, &pME->ntbEntry.schema) < 0) return -1;
+  } else {
+    ASSERT(0);
+  }
+  tEndEncode(pCoder);
+  return 0;
+}
+int metaDecodeEntry(SCoder *pCoder, SMetaEntry *pME) {
+  uint64_t len;
+  if (tStartDecode(pCoder) < 0) return -1;
+  if (tDecodeI64(pCoder, &pME->version) < 0) return -1;
+  if (tDecodeI8(pCoder, &pME->type) < 0) return -1;
+  if (tDecodeI64(pCoder, &pME->uid) < 0) return -1;
+  if (tDecodeCStr(pCoder, &pME->name) < 0) return -1;
+  if (pME->type == TSDB_SUPER_TABLE) {
+    if (tDecodeSSchemaWrapper(pCoder, &pME->stbEntry.schema) < 0) return -1;
+    if (tDecodeSSchemaWrapper(pCoder, &pME->stbEntry.schemaTag) < 0) return -1;
+  } else if (pME->type == TSDB_CHILD_TABLE) {
+    if (tDecodeI64(pCoder, &pME->ctbEntry.ctime) < 0) return -1;
+    if (tDecodeI32(pCoder, &pME->ctbEntry.ttlDays) < 0) return -1;
+    if (tDecodeI64(pCoder, &pME->ctbEntry.suid) < 0) return -1;
+    if (tDecodeBinary(pCoder, &pME->ctbEntry.pTags, &len) < 0) return -1;  // (TODO)
+  } else if (pME->type == TSDB_NORMAL_TABLE) {
+    if (tDecodeI64(pCoder, &pME->ntbEntry.ctime) < 0) return -1;
+    if (tDecodeI32(pCoder, &pME->ntbEntry.ttlDays) < 0) return -1;
+    if (tDecodeSSchemaWrapper(pCoder, &pME->ntbEntry.schema) < 0) return -1;
+  } else {
+    ASSERT(0);
+  }
+  tEndDecode(pCoder);
+  return 0;
+}
--- a/source/dnode/vnode/src/meta/metaIdx.c
+++ b/source/dnode/vnode/src/meta/metaIdx.c
@@ -54,7 +54,9 @@ int metaOpenIdx(SMeta *pMeta) {
 #ifdef USE_INVERTED_INDEX
  SIndexOpts opts;
-  if (indexOpen(&opts, pMeta->path, &pMeta->pIdx->pIdx) != 0) { return -1; }
+  if (indexOpen(&opts, pMeta->path, &pMeta->pIdx->pIdx) != 0) {
+    return -1;
+  }
 #endif
  return 0;
@@ -70,7 +72,9 @@ void metaCloseIdx(SMeta *pMeta) { /* TODO */
 #ifdef USE_INVERTED_INDEX
  SIndexOpts opts;
-  if (indexClose(pMeta->pIdx->pIdx) != 0) { return -1; }
+  if (indexClose(pMeta->pIdx->pIdx) != 0) {
+    return -1;
+  }
 #endif
 }
@@ -87,7 +91,7 @@ int metaSaveTableToIdx(SMeta *pMeta, const STbCfg *pTbCfg) {
    tb_uid_t         suid = pTbCfg->ctbCfg.suid;  // super id
    tb_uid_t         tuid = 0;                    // child table uid
    SIndexMultiTerm *terms = indexMultiTermCreate();
-    SIndexTerm *     term =
+    SIndexTerm      *term =
        indexTermCreate(suid, ADD_VALUE, TSDB_DATA_TYPE_BINARY, buf, strlen(buf), pTagVal, strlen(pTagVal), tuid);
    indexMultiTermAdd(terms, term);
@@ -117,10 +121,13 @@ int32_t metaCreateTSma(SMeta *pMeta, SSmaCfg *pCfg) {
  // TODO: add atomicity
+#ifdef META_REFACT
+#else
  if (metaSaveSmaToDB(pMeta, &pCfg->tSma) < 0) {
    // TODO: handle error
    return -1;
  }
+#endif
  return TSDB_CODE_SUCCESS;
 }
@@ -128,9 +135,12 @@ int32_t metaDropTSma(SMeta *pMeta, int64_t indexUid) {
  // TODO: Validate the cfg
  // TODO: add atomicity
+#ifdef META_REFACT
+#else
  if (metaRemoveSmaFromDb(pMeta, indexUid) < 0) {
    // TODO: handle error
    return -1;
  }
+#endif
  return TSDB_CODE_SUCCESS;
 }
\ No newline at end of file
--- a/source/dnode/vnode/src/meta/metaOpen.c
+++ b/source/dnode/vnode/src/meta/metaOpen.c
@@ -15,8 +15,16 @@
 #include "vnodeInt.h"
+static int tbDbKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2);
+static int skmDbKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2);
+static int ctbIdxKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2);
+static int tagIdxKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2);
+static int ttlIdxKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2);
+static int uidIdxKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2);
 int metaOpen(SVnode *pVnode, SMeta **ppMeta) {
  SMeta *pMeta = NULL;
+  int    ret;
  int    slen;
  *ppMeta = NULL;
@@ -36,31 +44,240 @@ int metaOpen(SVnode *pVnode, SMeta **ppMeta) {
  // create path if not created yet
  taosMkDir(pMeta->path);
-  // open meta
+  // open env
-  if (metaOpenDB(pMeta) < 0) {
+  ret = tdbEnvOpen(pMeta->path, pVnode->config.szPage, pVnode->config.szCache, &pMeta->pEnv);
+  if (ret < 0) {
+    metaError("vgId: %d failed to open meta env since %s", TD_VID(pVnode), tstrerror(terrno));
+    goto _err;
+  }
+  // open pTbDb
+  ret = tdbDbOpen("table.db", sizeof(STbDbKey), -1, tbDbKeyCmpr, pMeta->pEnv, &pMeta->pTbDb);
+  if (ret < 0) {
+    metaError("vgId: %d failed to open meta table db since %s", TD_VID(pVnode), tstrerror(terrno));
+    goto _err;
+  }
+  // open pSkmDb
+  ret = tdbDbOpen("schema.db", sizeof(SSkmDbKey), -1, skmDbKeyCmpr, pMeta->pEnv, &pMeta->pSkmDb);
+  if (ret < 0) {
+    metaError("vgId: %d failed to open meta schema db since %s", TD_VID(pVnode), tstrerror(terrno));
+    goto _err;
+  }
+  // open pUidIdx
+  ret = tdbDbOpen("uid.idx", sizeof(tb_uid_t), sizeof(int64_t), uidIdxKeyCmpr, pMeta->pEnv, &pMeta->pUidIdx);
+  if (ret < 0) {
+    metaError("vgId: %d failed to open meta uid idx since %s", TD_VID(pVnode), tstrerror(terrno));
    goto _err;
  }
+  // open pNameIdx
+  ret = tdbDbOpen("name.idx", -1, sizeof(tb_uid_t), NULL, pMeta->pEnv, &pMeta->pNameIdx);
+  if (ret < 0) {
+    metaError("vgId: %d failed to open meta name index since %s", TD_VID(pVnode), tstrerror(terrno));
+    goto _err;
+  }
+  // open pCtbIdx
+  ret = tdbDbOpen("ctb.idx", sizeof(SCtbIdxKey), 0, ctbIdxKeyCmpr, pMeta->pEnv, &pMeta->pCtbIdx);
+  if (ret < 0) {
+    metaError("vgId: %d failed to open meta child table index since %s", TD_VID(pVnode), tstrerror(terrno));
+    goto _err;
+  }
+  // open pTagIdx
+  ret = tdbDbOpen("tag.idx", -1, 0, tagIdxKeyCmpr, pMeta->pEnv, &pMeta->pTagIdx);
+  if (ret < 0) {
+    metaError("vgId: %d failed to open meta tag index since %s", TD_VID(pVnode), tstrerror(terrno));
+    goto _err;
+  }
+  // open pTtlIdx
+  ret = tdbDbOpen("ttl.idx", sizeof(STtlIdxKey), 0, ttlIdxKeyCmpr, pMeta->pEnv, &pMeta->pTtlIdx);
+  if (ret < 0) {
+    metaError("vgId: %d failed to open meta ttl index since %s", TD_VID(pVnode), tstrerror(terrno));
+    goto _err;
+  }
+  // open index
  if (metaOpenIdx(pMeta) < 0) {
+    metaError("vgId: %d failed to open meta index since %s", TD_VID(pVnode), tstrerror(terrno));
    goto _err;
  }
+  metaDebug("vgId: %d meta is opened", TD_VID(pVnode));
  *ppMeta = pMeta;
  return 0;
 _err:
  if (pMeta->pIdx) metaCloseIdx(pMeta);
-  if (pMeta->pDB) metaCloseDB(pMeta);
+  if (pMeta->pTtlIdx) tdbDbClose(pMeta->pTtlIdx);
+  if (pMeta->pTagIdx) tdbDbClose(pMeta->pTagIdx);
+  if (pMeta->pCtbIdx) tdbDbClose(pMeta->pCtbIdx);
+  if (pMeta->pNameIdx) tdbDbClose(pMeta->pNameIdx);
+  if (pMeta->pNameIdx) tdbDbClose(pMeta->pUidIdx);
+  if (pMeta->pSkmDb) tdbDbClose(pMeta->pSkmDb);
+  if (pMeta->pTbDb) tdbDbClose(pMeta->pTbDb);
+  if (pMeta->pEnv) tdbEnvClose(pMeta->pEnv);
  taosMemoryFree(pMeta);
  return -1;
 }
 int metaClose(SMeta *pMeta) {
  if (pMeta) {
-    metaCloseIdx(pMeta);
+    if (pMeta->pIdx) metaCloseIdx(pMeta);
-    metaCloseDB(pMeta);
+    if (pMeta->pTtlIdx) tdbDbClose(pMeta->pTtlIdx);
+    if (pMeta->pTagIdx) tdbDbClose(pMeta->pTagIdx);
+    if (pMeta->pCtbIdx) tdbDbClose(pMeta->pCtbIdx);
+    if (pMeta->pNameIdx) tdbDbClose(pMeta->pNameIdx);
+    if (pMeta->pNameIdx) tdbDbClose(pMeta->pUidIdx);
+    if (pMeta->pSkmDb) tdbDbClose(pMeta->pSkmDb);
+    if (pMeta->pTbDb) tdbDbClose(pMeta->pTbDb);
+    if (pMeta->pEnv) tdbEnvClose(pMeta->pEnv);
    taosMemoryFree(pMeta);
  }
  return 0;
 }
\ No newline at end of file
+static int tbDbKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2) {
+  STbDbKey *pTbDbKey1 = (STbDbKey *)pKey1;
+  STbDbKey *pTbDbKey2 = (STbDbKey *)pKey2;
+  if (pTbDbKey1->version > pTbDbKey2->version) {
+    return 1;
+  } else if (pTbDbKey1->version < pTbDbKey2->version) {
+    return -1;
+  }
+  if (pTbDbKey1->uid > pTbDbKey2->uid) {
+    return 1;
+  } else if (pTbDbKey1->uid < pTbDbKey2->uid) {
+    return -1;
+  }
+  return 0;
+}
+static int skmDbKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2) {
+  SSkmDbKey *pSkmDbKey1 = (SSkmDbKey *)pKey1;
+  SSkmDbKey *pSkmDbKey2 = (SSkmDbKey *)pKey2;
+  if (pSkmDbKey1->uid > pSkmDbKey2->uid) {
+    return 1;
+  } else if (pSkmDbKey1->uid < pSkmDbKey2->uid) {
+    return -1;
+  }
+  if (pSkmDbKey1->sver > pSkmDbKey2->sver) {
+    return 1;
+  } else if (pSkmDbKey1->sver < pSkmDbKey2->sver) {
+    return -1;
+  }
+  return 0;
+}
+static int uidIdxKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2) {
+  tb_uid_t uid1 = *(tb_uid_t *)pKey1;
+  tb_uid_t uid2 = *(tb_uid_t *)pKey2;
+  if (uid1 > uid2) {
+    return 1;
+  } else if (uid1 < uid2) {
+    return -1;
+  }
+  return 0;
+}
+static int ctbIdxKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2) {
+  SCtbIdxKey *pCtbIdxKey1 = (SCtbIdxKey *)pKey1;
+  SCtbIdxKey *pCtbIdxKey2 = (SCtbIdxKey *)pKey2;
+  if (pCtbIdxKey1->suid > pCtbIdxKey2->suid) {
+    return 1;
+  } else if (pCtbIdxKey1->suid < pCtbIdxKey2->suid) {
+    return -1;
+  }
+  if (pCtbIdxKey1->uid > pCtbIdxKey2->uid) {
+    return 1;
+  } else if (pCtbIdxKey1->uid < pCtbIdxKey2->uid) {
+    return -1;
+  }
+  return 0;
+}
+static int tagIdxKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2) {
+  STagIdxKey *pTagIdxKey1 = (STagIdxKey *)pKey1;
+  STagIdxKey *pTagIdxKey2 = (STagIdxKey *)pKey2;
+  int8_t     *p1, *p2;
+  int8_t      type;
+  int         c;
+  // compare suid
+  if (pTagIdxKey1->suid > pTagIdxKey2->suid) {
+    return 1;
+  } else if (pTagIdxKey1->suid < pTagIdxKey2->suid) {
+    return -1;
+  }
+  // compare column id
+  if (pTagIdxKey1->cid > pTagIdxKey2->cid) {
+    return 1;
+  } else if (pTagIdxKey1->cid < pTagIdxKey2->cid) {
+    return -1;
+  }
+  // compare value
+  p1 = pTagIdxKey1->data;
+  p2 = pTagIdxKey2->data;
+  ASSERT(p1[0] == p2[0]);
+  type = p1[0];
+  p1++;
+  p2++;
+  c = doCompare(p1, p2, type, 0);
+  if (c) return c;
+  if (IS_VAR_DATA_TYPE(type)) {
+    p1 = p1 + varDataTLen(p1);
+    p2 = p2 + varDataTLen(p2);
+  } else {
+    p1 = p1 + tDataTypes[type].bytes;
+    p2 = p2 + tDataTypes[type].bytes;
+  }
+  // compare suid
+  if (*(tb_uid_t *)p1 > *(tb_uid_t *)p2) {
+    return 1;
+  } else if (*(tb_uid_t *)p1 < *(tb_uid_t *)p2) {
+    return -1;
+  }
+  return 0;
+}
+static int ttlIdxKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2) {
+  STtlIdxKey *pTtlIdxKey1 = (STtlIdxKey *)pKey1;
+  STtlIdxKey *pTtlIdxKey2 = (STtlIdxKey *)pKey2;
+  if (pTtlIdxKey1->dtime > pTtlIdxKey2->dtime) {
+    return 1;
+  } else if (pTtlIdxKey1->dtime < pTtlIdxKey2->dtime) {
+    return -1;
+  }
+  if (pTtlIdxKey1->uid > pTtlIdxKey2->uid) {
+    return 1;
+  } else if (pTtlIdxKey1->uid < pTtlIdxKey2->uid) {
+    return -1;
+  }
+  return 0;
+}
--- a/source/dnode/vnode/src/meta/metaQuery.c
+++ b/source/dnode/vnode/src/meta/metaQuery.c
--- a/source/dnode/vnode/src/meta/metaTDBImpl.c
+++ b/source/dnode/vnode/src/meta/metaTDBImpl.c
@@ -15,6 +15,8 @@
 #include "vnodeInt.h"
+#ifndef META_REFACT
 typedef struct SPoolMem {
  int64_t          size;
  struct SPoolMem *prev;
@@ -45,7 +47,7 @@ struct SMetaDB {
 #endif
 };
-#pragma pack(push,1)
+#pragma pack(push, 1)
 typedef struct {
  tb_uid_t uid;
  int32_t  sver;
@@ -379,64 +381,6 @@ int metaRemoveTableFromDb(SMeta *pMeta, tb_uid_t uid) {
  return 0;
 }
-STbCfg *metaGetTbInfoByUid(SMeta *pMeta, tb_uid_t uid) {
-  int      ret;
-  SMetaDB *pMetaDb = pMeta->pDB;
-  void    *pKey;
-  void    *pVal;
-  int      kLen;
-  int      vLen;
-  STbCfg  *pTbCfg;
-  // Fetch
-  pKey = &uid;
-  kLen = sizeof(uid);
-  pVal = NULL;
-  ret = tdbDbGet(pMetaDb->pTbDB, pKey, kLen, &pVal, &vLen);
-  if (ret < 0) {
-    return NULL;
-  }
-  // Decode
-  pTbCfg = taosMemoryMalloc(sizeof(*pTbCfg));
-  metaDecodeTbInfo(pVal, pTbCfg);
-  TDB_FREE(pVal);
-  return pTbCfg;
-}
-STbCfg *metaGetTbInfoByName(SMeta *pMeta, char *tbname, tb_uid_t *uid) {
-  void *pKey;
-  void *pVal;
-  void *ppKey;
-  int   pkLen;
-  int   kLen;
-  int   vLen;
-  int   ret;
-  pKey = tbname;
-  kLen = strlen(tbname) + 1;
-  pVal = NULL;
-  ppKey = NULL;
-  ret = tdbDbPGet(pMeta->pDB->pNameIdx, pKey, kLen, &ppKey, &pkLen, &pVal, &vLen);
-  if (ret < 0) {
-    return NULL;
-  }
-  ASSERT(pkLen == kLen + sizeof(uid));
-  *uid = *(tb_uid_t *)POINTER_SHIFT(ppKey, kLen);
-  TDB_FREE(ppKey);
-  TDB_FREE(pVal);
-  return metaGetTbInfoByUid(pMeta, *uid);
-}
-SSchemaWrapper *metaGetTableSchema(SMeta *pMeta, tb_uid_t uid, int32_t sver, bool isinline) {
-  return metaGetTableSchemaImpl(pMeta, uid, sver, isinline, false);
-}
 static SSchemaWrapper *metaGetTableSchemaImpl(SMeta *pMeta, tb_uid_t uid, int32_t sver, bool isinline, bool isGetEx) {
  void           *pKey;
  void           *pVal;
@@ -468,156 +412,6 @@ static SSchemaWrapper *metaGetTableSchemaImpl(SMeta *pMeta, tb_uid_t uid, int32_
  return pSchemaWrapper;
 }
-STSchema *metaGetTbTSchema(SMeta *pMeta, tb_uid_t uid, int32_t sver) {
-  tb_uid_t        quid;
-  SSchemaWrapper *pSW;
-  STSchemaBuilder sb;
-  SSchema        *pSchema;
-  STSchema       *pTSchema;
-  STbCfg         *pTbCfg;
-  pTbCfg = metaGetTbInfoByUid(pMeta, uid);
-  if (pTbCfg->type == META_CHILD_TABLE) {
-    quid = pTbCfg->ctbCfg.suid;
-  } else {
-    quid = uid;
-  }
-  pSW = metaGetTableSchemaImpl(pMeta, quid, sver, true, true);
-  if (pSW == NULL) {
-    return NULL;
-  }
-  tdInitTSchemaBuilder(&sb, 0);
-  for (int i = 0; i < pSW->nCols; i++) {
-    pSchema = pSW->pSchema + i;
-    tdAddColToSchema(&sb, pSchema->type, pSchema->flags, pSchema->colId, pSchema->bytes);
-  }
-  pTSchema = tdGetSchemaFromBuilder(&sb);
-  tdDestroyTSchemaBuilder(&sb);
-  return pTSchema;
-}
-struct SMTbCursor {
-  TDBC *pDbc;
-};
-SMTbCursor *metaOpenTbCursor(SMeta *pMeta) {
-  SMTbCursor *pTbCur = NULL;
-  SMetaDB    *pDB = pMeta->pDB;
-  pTbCur = (SMTbCursor *)taosMemoryCalloc(1, sizeof(*pTbCur));
-  if (pTbCur == NULL) {
-    return NULL;
-  }
-  tdbDbcOpen(pDB->pTbDB, &pTbCur->pDbc);
-  return pTbCur;
-}
-void metaCloseTbCursor(SMTbCursor *pTbCur) {
-  if (pTbCur) {
-    if (pTbCur->pDbc) {
-      tdbDbcClose(pTbCur->pDbc);
-    }
-    taosMemoryFree(pTbCur);
-  }
-}
-char *metaTbCursorNext(SMTbCursor *pTbCur) {
-  void  *pKey = NULL;
-  void  *pVal = NULL;
-  int    kLen;
-  int    vLen;
-  int    ret;
-  void  *pBuf;
-  STbCfg tbCfg;
-  for (;;) {
-    ret = tdbDbNext(pTbCur->pDbc, &pKey, &kLen, &pVal, &vLen);
-    if (ret < 0) break;
-    pBuf = pVal;
-    metaDecodeTbInfo(pBuf, &tbCfg);
-    if (tbCfg.type == META_SUPER_TABLE) {
-      taosMemoryFree(tbCfg.name);
-      taosMemoryFree(tbCfg.stbCfg.pTagSchema);
-      continue;
-    } else if (tbCfg.type == META_CHILD_TABLE) {
-      kvRowFree(tbCfg.ctbCfg.pTag);
-    }
-    return tbCfg.name;
-  }
-  return NULL;
-}
-struct SMCtbCursor {
-  TDBC    *pCur;
-  tb_uid_t suid;
-  void    *pKey;
-  void    *pVal;
-  int      kLen;
-  int      vLen;
-};
-SMCtbCursor *metaOpenCtbCursor(SMeta *pMeta, tb_uid_t uid) {
-  SMCtbCursor *pCtbCur = NULL;
-  SMetaDB     *pDB = pMeta->pDB;
-  int          ret;
-  pCtbCur = (SMCtbCursor *)taosMemoryCalloc(1, sizeof(*pCtbCur));
-  if (pCtbCur == NULL) {
-    return NULL;
-  }
-  pCtbCur->suid = uid;
-  ret = tdbDbcOpen(pDB->pCtbIdx, &pCtbCur->pCur);
-  if (ret < 0) {
-    taosMemoryFree(pCtbCur);
-    return NULL;
-  }
-  // TODO: move the cursor to the suid there
-  return pCtbCur;
-}
-void metaCloseCtbCurosr(SMCtbCursor *pCtbCur) {
-  if (pCtbCur) {
-    if (pCtbCur->pCur) {
-      tdbDbcClose(pCtbCur->pCur);
-      TDB_FREE(pCtbCur->pKey);
-      TDB_FREE(pCtbCur->pVal);
-    }
-    taosMemoryFree(pCtbCur);
-  }
-}
-tb_uid_t metaCtbCursorNext(SMCtbCursor *pCtbCur) {
-  int         ret;
-  SCtbIdxKey *pCtbIdxKey;
-  ret = tdbDbNext(pCtbCur->pCur, &pCtbCur->pKey, &pCtbCur->kLen, &pCtbCur->pVal, &pCtbCur->vLen);
-  if (ret < 0) {
-    return 0;
-  }
-  pCtbIdxKey = pCtbCur->pKey;
-  return pCtbIdxKey->uid;
-}
-int metaGetTbNum(SMeta *pMeta) {
-  // TODO
-  // ASSERT(0);
-  return 0;
-}
 struct SMSmaCursor {
  TDBC    *pCur;
  tb_uid_t uid;
@@ -768,53 +562,6 @@ int metaSaveSmaToDB(SMeta *pMeta, STSma *pSmaCfg) {
  return 0;
 }
-void *metaGetSmaInfoByIndex(SMeta *pMeta, int64_t indexUid, bool isDecode) {
-  // TODO
-  // ASSERT(0);
-  // return NULL;
-#ifdef META_TDB_SMA_TEST
-  SMetaDB *pDB = pMeta->pDB;
-  void    *pKey = NULL;
-  void    *pVal = NULL;
-  int      kLen = 0;
-  int      vLen = 0;
-  int      ret = -1;
-  // Set key
-  pKey = (void *)&indexUid;
-  kLen = sizeof(indexUid);
-  // Query
-  ret = tdbDbGet(pDB->pSmaDB, pKey, kLen, &pVal, &vLen);
-  if (ret != 0 || !pVal) {
-    return NULL;
-  }
-  if (!isDecode) {
-    // return raw value
-    return pVal;
-  }
-  // Decode
-  STSma *pCfg = (STSma *)taosMemoryCalloc(1, sizeof(STSma));
-  if (pCfg == NULL) {
-    taosMemoryFree(pVal);
-    return NULL;
-  }
-  void *pBuf = pVal;
-  if (tDecodeTSma(pBuf, pCfg) == NULL) {
-    tdDestroyTSma(pCfg);
-    taosMemoryFree(pCfg);
-    TDB_FREE(pVal);
-    return NULL;
-  }
-  TDB_FREE(pVal);
-  return pCfg;
-#endif
-}
 /**
 * @brief
 *
@@ -889,56 +636,6 @@ void metaCloseSmaCursor(SMSmaCursor *pCur) {
 #endif
 }
-SArray *metaGetSmaTbUids(SMeta *pMeta, bool isDup) {
-  // TODO
-  // ASSERT(0); // comment this line to pass CI
-  // return NULL:
-#ifdef META_TDB_SMA_TEST
-  SArray  *pUids = NULL;
-  SMetaDB *pDB = pMeta->pDB;
-  void    *pKey;
-  // TODO: lock?
-  SMSmaCursor *pCur = metaOpenSmaCursor(pMeta, 0);
-  if (pCur == NULL) {
-    return NULL;
-  }
-  // TODO: lock?
-  SSmaIdxKey *pSmaIdxKey = NULL;
-  tb_uid_t    uid = 0;
-  while (true) {
-    // TODO: lock during iterate?
-    if (tdbDbNext(pCur->pCur, &pCur->pKey, &pCur->kLen, NULL, &pCur->vLen) == 0) {
-      ASSERT(pSmaIdxKey != NULL);
-      pSmaIdxKey = pCur->pKey;
-      if (pSmaIdxKey->uid == 0 || pSmaIdxKey->uid == uid) {
-        continue;
-      }
-      uid = pSmaIdxKey->uid;
-      if (!pUids) {
-        pUids = taosArrayInit(16, sizeof(tb_uid_t));
-        if (!pUids) {
-          metaCloseSmaCursor(pCur);
-          return NULL;
-        }
-      }
-      taosArrayPush(pUids, &uid);
-      continue;
-    }
-    break;
-  }
-  metaCloseSmaCursor(pCur);
-  return pUids;
-#endif
-}
 static int metaEncodeSchema(void **buf, SSchemaWrapper *pSW) {
  int      tlen = 0;
  SSchema *pSchema;
@@ -1142,3 +839,5 @@ static void poolFree(void *arg, void *ptr) {
  tdbOsFree(pMem);
 }
+#endif
\ No newline at end of file
--- a/source/dnode/vnode/src/meta/metaTable.c
+++ b/source/dnode/vnode/src/meta/metaTable.c
--- a/source/dnode/vnode/src/tq/tq.c
+++ b/source/dnode/vnode/src/tq/tq.c
@@ -197,10 +197,9 @@ int tqPushMsg(STQ* pTq, void* msg, int32_t msgLen, tmsg_t msgType, int64_t ver)
  }
  memcpy(data, msg, msgLen);
-  if (msgType == TDMT_VND_SUBMIT) {
+  // make sure msgType == TDMT_VND_SUBMIT
-    if (tsdbUpdateSmaWindow(pTq->pVnode->pTsdb, msg, ver) != 0) {
+  if (tsdbUpdateSmaWindow(pTq->pVnode->pTsdb, msg, ver) != 0) {
-      return -1;
+    return -1;
-    }
  }
  SRpcMsg req = {

--- a/source/dnode/vnode/src/tq/tqRead.c
+++ b/source/dnode/vnode/src/tq/tqRead.c
--- a/source/dnode/vnode/src/tsdb/tsdbCommit.c
+++ b/source/dnode/vnode/src/tsdb/tsdbCommit.c
@@ -142,12 +142,13 @@ int tsdbPrepareCommit(STsdb *pTsdb) {
 }
 int tsdbCommit(STsdb *pRepo) {
-  STsdbMemTable *pMem = pRepo->imem;
+  SCommitH   commith = {0};
-  SCommitH       commith = {0};
+  SDFileSet *pSet = NULL;
-  SDFileSet     *pSet = NULL;
+  int        fid;
-  int            fid;
-  if (pRepo->imem == NULL) return 0;
+  // if (pRepo->imem == NULL) return 0;
+  pRepo->imem = pRepo->mem;
+  pRepo->mem = NULL;
  tsdbStartCommit(pRepo);
  // Resource initialization
@@ -239,7 +240,7 @@ static void tsdbStartCommit(STsdb *pRepo) {
 static void tsdbEndCommit(STsdb *pTsdb, int eno) {
  tsdbEndFSTxn(pTsdb);
-  tsdbFreeMemTable(pTsdb, pTsdb->imem);
+  tsdbMemTableDestroy(pTsdb, pTsdb->imem);
  pTsdb->imem = NULL;
  tsdbInfo("vgId:%d commit over, %s", REPO_ID(pTsdb), (eno == TSDB_CODE_SUCCESS) ? "succeed" : "failed");
 }

--- a/source/dnode/vnode/src/tsdb/tsdbCommit2.c
+++ b/source/dnode/vnode/src/tsdb/tsdbCommit2.c
--- a/source/dnode/vnode/src/tsdb/tsdbMain.c
+++ b/source/dnode/vnode/src/tsdb/tsdbMain.c
--- a/source/dnode/vnode/src/tsdb/tsdbMemTable.c
+++ b/source/dnode/vnode/src/tsdb/tsdbMemTable.c
--- a/source/dnode/vnode/src/tsdb/tsdbRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbRead.c
--- a/source/dnode/vnode/src/tsdb/tsdbSma.c
+++ b/source/dnode/vnode/src/tsdb/tsdbSma.c
--- a/source/dnode/vnode/src/tsdb/tsdbWrite.c
+++ b/source/dnode/vnode/src/tsdb/tsdbWrite.c
--- a/source/dnode/vnode/src/vnd/vnodeArenaMAImpl.c
+++ b/source/dnode/vnode/src/vnd/vnodeArenaMAImpl.c
--- a/source/dnode/vnode/src/vnd/vnodeBufferPool2.c
+++ b/source/dnode/vnode/src/vnd/vnodeBufferPool2.c
--- a/source/dnode/vnode/src/vnd/vnodeBufferPool.c
+++ b/source/dnode/vnode/src/vnd/vnodeBufferPool.c
--- a/source/dnode/vnode/src/vnd/vnodeCfg.c
+++ b/source/dnode/vnode/src/vnd/vnodeCfg.c
--- a/source/dnode/vnode/src/vnd/vnodeCommit.c
+++ b/source/dnode/vnode/src/vnd/vnodeCommit.c
--- a/source/dnode/vnode/src/vnd/vnodeOpen.c
+++ b/source/dnode/vnode/src/vnd/vnodeOpen.c
--- a/source/dnode/vnode/src/vnd/vnodeQuery.c
+++ b/source/dnode/vnode/src/vnd/vnodeQuery.c
--- a/source/dnode/vnode/src/vnd/vnodeSvr.c
+++ b/source/dnode/vnode/src/vnd/vnodeSvr.c
--- a/source/libs/executor/inc/executorimpl.h
+++ b/source/libs/executor/inc/executorimpl.h
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@@ -221,7 +221,7 @@ void initGroupedResultInfo(SGroupResInfo* pGroupResInfo, SHashObj* pHashmap, boo
    p->groupId = *(uint64_t*) key;
    p->pos = *(SResultRowPosition*) pData;
-    memcpy(p->key, key + sizeof(uint64_t), keyLen - sizeof(uint64_t));
+    memcpy(p->key, (char*)key + sizeof(uint64_t), keyLen - sizeof(uint64_t));
    taosArrayPush(pGroupResInfo->pRows, &p);
  }

--- a/source/libs/executor/src/executorimpl.c
+++ b/source/libs/executor/src/executorimpl.c
--- a/source/libs/executor/src/scanoperator.c
+++ b/source/libs/executor/src/scanoperator.c
--- a/source/libs/executor/test/CMakeLists.txt
+++ b/source/libs/executor/test/CMakeLists.txt
@@ -8,7 +8,7 @@ AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SOURCE_LIST)
 ADD_EXECUTABLE(executorTest ${SOURCE_LIST})
 TARGET_LINK_LIBRARIES(
        executorTest
-        PRIVATE os util common transport gtest taos_static qcom executor function planner scalar nodes
+        PRIVATE os util common transport gtest taos_static qcom executor function planner scalar nodes vnode
 )
 TARGET_INCLUDE_DIRECTORIES(

--- a/source/libs/parser/src/parInsert.c
+++ b/source/libs/parser/src/parInsert.c
--- a/source/libs/parser/src/parInsertData.c
+++ b/source/libs/parser/src/parInsertData.c
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
--- a/source/libs/planner/src/planner.c
+++ b/source/libs/planner/src/planner.c
--- a/source/libs/planner/test/planStmtTest.cpp
+++ b/source/libs/planner/test/planStmtTest.cpp
--- a/source/libs/scalar/inc/sclInt.h
+++ b/source/libs/scalar/inc/sclInt.h
@@ -34,6 +34,7 @@ typedef struct SScalarCtx {
 #define SCL_IS_CONST_NODE(_node) ((NULL == (_node)) || (QUERY_NODE_VALUE == (_node)->type) || (QUERY_NODE_NODE_LIST == (_node)->type))
 #define SCL_IS_CONST_CALC(_ctx) (NULL == (_ctx)->pBlockList)
+#define SCL_IS_NULL_VALUE_NODE(_node) ((QUERY_NODE_VALUE == nodeType(_node)) && (TSDB_DATA_TYPE_NULL == ((SValueNode *)_node)->node.resType.type))
 #define sclFatal(...)  qFatal(__VA_ARGS__)
 #define sclError(...)  qError(__VA_ARGS__)

--- a/source/libs/scalar/inc/sclvector.h
+++ b/source/libs/scalar/inc/sclvector.h
--- a/source/libs/scalar/src/filter.c
+++ b/source/libs/scalar/src/filter.c
--- a/source/libs/scalar/src/scalar.c
+++ b/source/libs/scalar/src/scalar.c
--- a/source/libs/scalar/src/sclvector.c
+++ b/source/libs/scalar/src/sclvector.c
--- a/source/libs/scheduler/src/scheduler.c
+++ b/source/libs/scheduler/src/scheduler.c
--- a/source/libs/sync/inc/syncEnv.h
+++ b/source/libs/sync/inc/syncEnv.h
--- a/source/libs/sync/src/syncEnv.c
+++ b/source/libs/sync/src/syncEnv.c
--- a/source/libs/tdb/src/db/tdbBtree.c
+++ b/source/libs/tdb/src/db/tdbBtree.c
--- a/source/libs/tdb/src/db/tdbPCache.c
+++ b/source/libs/tdb/src/db/tdbPCache.c
--- a/source/libs/tdb/src/db/tdbPage.c
+++ b/source/libs/tdb/src/db/tdbPage.c
--- a/source/libs/tdb/src/db/tdbPager.c
+++ b/source/libs/tdb/src/db/tdbPager.c
--- a/source/libs/tdb/src/inc/tdbBtree.h
+++ b/source/libs/tdb/src/inc/tdbBtree.h
--- a/source/libs/tdb/src/inc/tdbPager.h
+++ b/source/libs/tdb/src/inc/tdbPager.h
--- a/source/libs/tdb/test/tdbTest.cpp
+++ b/source/libs/tdb/test/tdbTest.cpp
--- a/source/libs/transport/src/transSrv.c
+++ b/source/libs/transport/src/transSrv.c
--- a/source/libs/wal/src/walWrite.c
+++ b/source/libs/wal/src/walWrite.c
--- a/source/os/src/osSystem.c
+++ b/source/os/src/osSystem.c
--- a/source/util/src/tcompare.c
+++ b/source/util/src/tcompare.c
--- a/source/util/src/tconfig.c
+++ b/source/util/src/tconfig.c
--- a/source/util/src/tencode.c
+++ b/source/util/src/tencode.c
--- a/source/util/src/terror.c
+++ b/source/util/src/terror.c
--- a/source/util/src/tlog.c
+++ b/source/util/src/tlog.c
--- a/source/util/test/encodeTest.cpp
+++ b/source/util/test/encodeTest.cpp
--- a/tests/script/api/batchprepare.c
+++ b/tests/script/api/batchprepare.c
--- a/tests/script/jenkins/basic.txt
+++ b/tests/script/jenkins/basic.txt
--- a/tests/script/sh/deploy.sh
+++ b/tests/script/sh/deploy.sh
--- a/tests/script/tsim/query/scalarNull.sim
+++ b/tests/script/tsim/query/scalarNull.sim
--- a/tests/script/tsim/snode/basic1.sim
+++ b/tests/script/tsim/snode/basic1.sim
--- a/tests/script/tsim/tmq/basic1.sim
+++ b/tests/script/tsim/tmq/basic1.sim
--- a/tests/script/tsim/tmq/basic2.sim
+++ b/tests/script/tsim/tmq/basic2.sim
--- a/tests/script/tsim/tmq/basic3.sim
+++ b/tests/script/tsim/tmq/basic3.sim
--- a/tests/script/tsim/tmq/basic4.sim
+++ b/tests/script/tsim/tmq/basic4.sim
--- a/tests/system-test/fulltest.sh
+++ b/tests/system-test/fulltest.sh
--- a/tests/test/c/tmqSim.c
+++ b/tests/test/c/tmqSim.c
--- a/tools/shell/src/shellArguments.c
+++ b/tools/shell/src/shellArguments.c
--- a/tools/shell/src/shellCommand.c
+++ b/tools/shell/src/shellCommand.c
--- a/tools/shell/src/shellMain.c
+++ b/tools/shell/src/shellMain.c