Merge remote-tracking branch 'origin/3.0' into feature/qnode

960f885a · dapan1121 · 65a7d0f1 · e15d78e2 · 960f885a · 960f885a
102 changed 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,8 +17,8 @@
 #include <stdio.h>
 #include <string.h>
 #include <time.h>
-#include <unistd.h>
 #include "taos.h"
+#include "osSleep.h"
 static int  running = 1;
 static void msg_process(TAOS_RES* msg) {
@@ -48,7 +48,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,7 +85,11 @@ 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);
@@ -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/tmsg.h
+++ b/include/common/tmsg.h
@@ -230,12 +230,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;
@@ -249,10 +249,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
@@ -292,7 +292,6 @@ typedef struct {
  char    name[TSDB_TABLE_FNAME_LEN];
  int8_t  igExists;
  float   xFilesFactor;
-  int32_t aggregationMethod;
  int32_t delay;
  int32_t ttl;
  int32_t numOfColumns;
@@ -1512,10 +1511,8 @@ typedef struct {
  int32_t    delay;
  int32_t    qmsg1Len;
  int32_t    qmsg2Len;
-  func_id_t* pFuncIds;
  char*      qmsg1;  // pAst1:qmsg1:SRetention1 => trigger aggr task1
  char*      qmsg2;  // pAst2:qmsg2:SRetention2 => trigger aggr task2
-  int8_t     nFuncIds;
 } SRSmaParam;
 typedef struct SVCreateTbReq {

--- a/include/libs/function/functionMgt.h
+++ b/include/libs/function/functionMgt.h
@@ -125,15 +125,15 @@ typedef struct SFmGetFuncInfoParam {
  struct SCatalog* pCtg;
  void *pRpc;
  const SEpSet* pMgmtEps;
+  char* pErrBuf;
+  int32_t errBufLen;
 } SFmGetFuncInfoParam;
 int32_t fmFuncMgtInit();
 void fmFuncMgtDestroy();
-int32_t fmGetFuncInfo(SFmGetFuncInfoParam* pParam, const char* pFuncName, int32_t* pFuncId, int32_t* pFuncType);
+int32_t fmGetFuncInfo(SFmGetFuncInfoParam* pParam, SFunctionNode* pFunc);
-int32_t fmGetFuncResultType(SFunctionNode* pFunc, char* pErrBuf, int32_t len);
 bool fmIsAggFunc(int32_t funcId);
 bool fmIsScalarFunc(int32_t funcId);

--- a/include/libs/nodes/querynodes.h
+++ b/include/libs/nodes/querynodes.h
@@ -25,14 +25,16 @@ extern "C" {
 #include "tvariant.h"
 #define TABLE_TOTAL_COL_NUM(pMeta) ((pMeta)->tableInfo.numOfColumns + (pMeta)->tableInfo.numOfTags)
-#define TABLE_META_SIZE(pMeta) (NULL == (pMeta) ? 0 : (sizeof(STableMeta) + TABLE_TOTAL_COL_NUM((pMeta)) * sizeof(SSchema)))
+#define TABLE_META_SIZE(pMeta) \
-#define VGROUPS_INFO_SIZE(pInfo) (NULL == (pInfo) ? 0 : (sizeof(SVgroupsInfo) + (pInfo)->numOfVgroups * sizeof(SVgroupInfo)))
+  (NULL == (pMeta) ? 0 : (sizeof(STableMeta) + TABLE_TOTAL_COL_NUM((pMeta)) * sizeof(SSchema)))
+#define VGROUPS_INFO_SIZE(pInfo) \
+  (NULL == (pInfo) ? 0 : (sizeof(SVgroupsInfo) + (pInfo)->numOfVgroups * sizeof(SVgroupInfo)))
 typedef struct SRawExprNode {
  ENodeType nodeType;
-  char* p;
+  char*     p;
-  uint32_t n;
+  uint32_t  n;
-  SNode* pNode;
+  SNode*    pNode;
 } SRawExprNode;
 typedef struct SDataType {
@@ -45,170 +47,155 @@ typedef struct SDataType {
 typedef struct SExprNode {
  ENodeType type;
  SDataType resType;
-  char aliasName[TSDB_COL_NAME_LEN];
+  char      aliasName[TSDB_COL_NAME_LEN];
-  SNodeList* pAssociationList;
+  SArray*   pAssociation;
 } SExprNode;
-typedef enum EColumnType {
+typedef enum EColumnType { COLUMN_TYPE_COLUMN = 1, COLUMN_TYPE_TAG } EColumnType;
-  COLUMN_TYPE_COLUMN = 1,
-  COLUMN_TYPE_TAG
-} EColumnType;
 typedef struct SColumnNode {
-  SExprNode node; // QUERY_NODE_COLUMN
+  SExprNode   node;  // QUERY_NODE_COLUMN
-  uint64_t tableId;
+  uint64_t    tableId;
-  int8_t tableType;
+  int8_t      tableType;
-  col_id_t colId;
+  col_id_t    colId;
-  EColumnType colType; // column or tag
+  EColumnType colType;  // column or tag
-  char dbName[TSDB_DB_NAME_LEN];
+  char        dbName[TSDB_DB_NAME_LEN];
-  char tableName[TSDB_TABLE_NAME_LEN];
+  char        tableName[TSDB_TABLE_NAME_LEN];
-  char tableAlias[TSDB_TABLE_NAME_LEN];
+  char        tableAlias[TSDB_TABLE_NAME_LEN];
-  char colName[TSDB_COL_NAME_LEN];
+  char        colName[TSDB_COL_NAME_LEN];
-  SNode* pProjectRef;
+  SNode*      pProjectRef;
-  int16_t dataBlockId;
+  int16_t     dataBlockId;
-  int16_t slotId;
+  int16_t     slotId;
 } SColumnNode;
 typedef struct STargetNode {
  ENodeType type;
-  int16_t dataBlockId;
+  int16_t   dataBlockId;
-  int16_t slotId;
+  int16_t   slotId;
-  SNode* pExpr;
+  SNode*    pExpr;
 } STargetNode;
 typedef struct SValueNode {
-  SExprNode node; // QUERY_NODE_VALUE
+  SExprNode node;  // QUERY_NODE_VALUE
-  char* literal;
+  char*     literal;
-  bool isDuration;
+  bool      isDuration;
-  bool translate;
+  bool      translate;
-  bool genByCalc;
+  int16_t   placeholderNo;
-  int16_t placeholderNo;
  union {
-    bool b;
+    bool     b;
-    int64_t i;
+    int64_t  i;
    uint64_t u;
-    double d;
+    double   d;
-    char* p;
+    char*    p;
  } datum;
  char unit;
 } SValueNode;
 typedef struct SOperatorNode {
-  SExprNode node; // QUERY_NODE_OPERATOR
+  SExprNode     node;  // QUERY_NODE_OPERATOR
  EOperatorType opType;
-  SNode* pLeft;
+  SNode*        pLeft;
-  SNode* pRight;
+  SNode*        pRight;
 } SOperatorNode;
 typedef struct SLogicConditionNode {
-  SExprNode node; // QUERY_NODE_LOGIC_CONDITION
+  SExprNode           node;  // QUERY_NODE_LOGIC_CONDITION
  ELogicConditionType condType;
-  SNodeList* pParameterList;
+  SNodeList*          pParameterList;
 } SLogicConditionNode;
 typedef struct SNodeListNode {
-  ENodeType type; // QUERY_NODE_NODE_LIST
+  ENodeType  type;  // QUERY_NODE_NODE_LIST
-  SDataType dataType;
+  SDataType  dataType;
  SNodeList* pNodeList;
 } SNodeListNode;
 typedef struct SFunctionNode {
-  SExprNode node; // QUERY_NODE_FUNCTION
+  SExprNode  node;  // QUERY_NODE_FUNCTION
-  char functionName[TSDB_FUNC_NAME_LEN];
+  char       functionName[TSDB_FUNC_NAME_LEN];
-  int32_t funcId;
+  int32_t    funcId;
-  int32_t funcType;
+  int32_t    funcType;
  SNodeList* pParameterList;
+  int32_t    udfBufSize;
 } SFunctionNode;
 typedef struct STableNode {
  SExprNode node;
-  char dbName[TSDB_DB_NAME_LEN];
+  char      dbName[TSDB_DB_NAME_LEN];
-  char tableName[TSDB_TABLE_NAME_LEN];
+  char      tableName[TSDB_TABLE_NAME_LEN];
-  char tableAlias[TSDB_TABLE_NAME_LEN];
+  char      tableAlias[TSDB_TABLE_NAME_LEN];
-  uint8_t precision;
+  uint8_t   precision;
 } STableNode;
 struct STableMeta;
 typedef struct SRealTableNode {
-  STableNode table; // QUERY_NODE_REAL_TABLE
+  STableNode         table;  // QUERY_NODE_REAL_TABLE
  struct STableMeta* pMeta;
-  SVgroupsInfo* pVgroupList;
+  SVgroupsInfo*      pVgroupList;
-  char useDbName[TSDB_DB_NAME_LEN];
+  char               qualDbName[TSDB_DB_NAME_LEN];  // SHOW qualDbName.TABLES
-  double ratio;
+  double             ratio;
 } SRealTableNode;
 typedef struct STempTableNode {
-  STableNode table; // QUERY_NODE_TEMP_TABLE
+  STableNode table;  // QUERY_NODE_TEMP_TABLE
-  SNode* pSubquery;
+  SNode*     pSubquery;
 } STempTableNode;
-typedef enum EJoinType {
+typedef enum EJoinType { JOIN_TYPE_INNER = 1 } EJoinType;
-  JOIN_TYPE_INNER = 1
-} EJoinType;
 typedef struct SJoinTableNode {
-  STableNode table; // QUERY_NODE_JOIN_TABLE
+  STableNode table;  // QUERY_NODE_JOIN_TABLE
-  EJoinType joinType;
+  EJoinType  joinType;
-  SNode* pLeft;
+  SNode*     pLeft;
-  SNode* pRight;
+  SNode*     pRight;
-  SNode* pOnCond;
+  SNode*     pOnCond;
 } SJoinTableNode;
-typedef enum EGroupingSetType {
+typedef enum EGroupingSetType { GP_TYPE_NORMAL = 1 } EGroupingSetType;
-  GP_TYPE_NORMAL = 1
-} EGroupingSetType;
 typedef struct SGroupingSetNode {
-  ENodeType type; // QUERY_NODE_GROUPING_SET
+  ENodeType        type;  // QUERY_NODE_GROUPING_SET
  EGroupingSetType groupingSetType;
-  SNodeList* pParameterList; 
+  SNodeList*       pParameterList;
 } SGroupingSetNode;
-typedef enum EOrder {
+typedef enum EOrder { ORDER_ASC = 1, ORDER_DESC } EOrder;
-  ORDER_ASC = 1,
-  ORDER_DESC
-} EOrder;
-typedef enum ENullOrder {
+typedef enum ENullOrder { NULL_ORDER_DEFAULT = 1, NULL_ORDER_FIRST, NULL_ORDER_LAST } ENullOrder;
-  NULL_ORDER_DEFAULT = 1,
-  NULL_ORDER_FIRST,
-  NULL_ORDER_LAST
-} ENullOrder;
 typedef struct SOrderByExprNode {
-  ENodeType type; // QUERY_NODE_ORDER_BY_EXPR
+  ENodeType  type;  // QUERY_NODE_ORDER_BY_EXPR
-  SNode* pExpr;
+  SNode*     pExpr;
-  EOrder order;
+  EOrder     order;
  ENullOrder nullOrder;
 } SOrderByExprNode;
 typedef struct SLimitNode {
-  ENodeType type; // QUERY_NODE_LIMIT
+  ENodeType type;  // QUERY_NODE_LIMIT
-  int64_t limit;
+  int64_t   limit;
-  int64_t offset;
+  int64_t   offset;
 } SLimitNode;
 typedef struct SStateWindowNode {
-  ENodeType type; // QUERY_NODE_STATE_WINDOW
+  ENodeType type;  // QUERY_NODE_STATE_WINDOW
-  SNode* pCol; // timestamp primary key
+  SNode*    pCol;  // timestamp primary key
-  SNode* pExpr;
+  SNode*    pExpr;
 } SStateWindowNode;
 typedef struct SSessionWindowNode {
-  ENodeType type; // QUERY_NODE_SESSION_WINDOW
+  ENodeType    type;  // QUERY_NODE_SESSION_WINDOW
-  SColumnNode* pCol; // timestamp primary key
+  SColumnNode* pCol;  // timestamp primary key
-  SValueNode* pGap; // gap between two session window(in microseconds)
+  SValueNode*  pGap;  // gap between two session window(in microseconds)
 } SSessionWindowNode;
 typedef struct SIntervalWindowNode {
-  ENodeType type; // QUERY_NODE_INTERVAL_WINDOW
+  ENodeType type;       // QUERY_NODE_INTERVAL_WINDOW
-  SNode* pCol; // timestamp primary key
+  SNode*    pCol;       // timestamp primary key
-  SNode* pInterval; // SValueNode
+  SNode*    pInterval;  // SValueNode
-  SNode* pOffset;   // SValueNode
+  SNode*    pOffset;    // SValueNode
-  SNode* pSliding;  // SValueNode
+  SNode*    pSliding;   // SValueNode
-  SNode* pFill;
+  SNode*    pFill;
 } SIntervalWindowNode;
 typedef enum EFillMode {
@@ -221,42 +208,40 @@ typedef enum EFillMode {
 } EFillMode;
 typedef struct SFillNode {
-  ENodeType type; // QUERY_NODE_FILL
+  ENodeType type;  // QUERY_NODE_FILL
  EFillMode mode;
-  SNode* pValues; // SNodeListNode
+  SNode*    pValues;  // SNodeListNode
 } SFillNode;
 typedef struct SSelectStmt {
-  ENodeType type; // QUERY_NODE_SELECT_STMT
+  ENodeType   type;  // QUERY_NODE_SELECT_STMT
-  bool isDistinct;
+  bool        isDistinct;
-  SNodeList* pProjectionList;
+  SNodeList*  pProjectionList;
-  SNode* pFromTable;
+  SNode*      pFromTable;
-  SNode* pWhere;
+  SNode*      pWhere;
-  SNodeList* pPartitionByList;
+  SNodeList*  pPartitionByList;
-  SNode* pWindow;
+  SNode*      pWindow;
-  SNodeList* pGroupByList; // SGroupingSetNode
+  SNodeList*  pGroupByList;  // SGroupingSetNode
-  SNode* pHaving;
+  SNode*      pHaving;
-  SNodeList* pOrderByList; // SOrderByExprNode
+  SNodeList*  pOrderByList;  // SOrderByExprNode
  SLimitNode* pLimit;
  SLimitNode* pSlimit;
-  char stmtName[TSDB_TABLE_NAME_LEN];
+  char        stmtName[TSDB_TABLE_NAME_LEN];
-  uint8_t precision;
+  uint8_t     precision;
-  bool isEmptyResult;
+  bool        isEmptyResult;
+  bool        hasAggFuncs;
 } SSelectStmt;
-typedef enum ESetOperatorType {
+typedef enum ESetOperatorType { SET_OP_TYPE_UNION_ALL = 1, SET_OP_TYPE_UNION } ESetOperatorType;
-  SET_OP_TYPE_UNION_ALL = 1,
-  SET_OP_TYPE_UNION
-} ESetOperatorType;
 typedef struct SSetOperator {
-  ENodeType type; // QUERY_NODE_SET_OPERATOR
+  ENodeType        type;  // QUERY_NODE_SET_OPERATOR
  ESetOperatorType opType;
-  SNodeList* pProjectionList;
+  SNodeList*       pProjectionList;
-  SNode* pLeft;
+  SNode*           pLeft;
-  SNode* pRight;
+  SNode*           pRight;
-  SNodeList* pOrderByList; // SOrderByExprNode
+  SNodeList*       pOrderByList;  // SOrderByExprNode
-  SNode* pLimit;
+  SNode*           pLimit;
 } SSetOperator;
 typedef enum ESqlClause {
@@ -271,7 +256,6 @@ typedef enum ESqlClause {
  SQL_CLAUSE_ORDER_BY
 } ESqlClause;
 typedef enum {
  PAYLOAD_TYPE_KV = 0,
  PAYLOAD_TYPE_RAW = 1,
@@ -281,29 +265,29 @@ typedef struct SVgDataBlocks {
  SVgroupInfo vg;
  int32_t     numOfTables;  // number of tables in current submit block
  uint32_t    size;
-  char       *pData;        // SMsgDesc + SSubmitReq + SSubmitBlk + ...
+  char*       pData;  // SMsgDesc + SSubmitReq + SSubmitBlk + ...
 } SVgDataBlocks;
 typedef struct SVnodeModifOpStmt {
-  ENodeType    nodeType;
+  ENodeType   nodeType;
-  ENodeType    sqlNodeType;
+  ENodeType   sqlNodeType;
-  SArray*      pDataBlocks;         // data block for each vgroup, SArray<SVgDataBlocks*>.
+  SArray*     pDataBlocks;  // data block for each vgroup, SArray<SVgDataBlocks*>.
-  uint8_t      payloadType;         // EPayloadType. 0: K-V payload for non-prepare insert, 1: rawPayload for prepare insert
+  uint8_t     payloadType;  // EPayloadType. 0: K-V payload for non-prepare insert, 1: rawPayload for prepare insert
-  uint32_t     insertType;          // insert data from [file|sql statement| bound statement]
+  uint32_t    insertType;   // insert data from [file|sql statement| bound statement]
-  const char*  sql;                 // current sql statement position
+  const char* sql;          // current sql statement position
 } SVnodeModifOpStmt;
 typedef struct SExplainOptions {
  ENodeType type;
-  bool verbose;
+  bool      verbose;
-  double ratio;
+  double    ratio;
 } SExplainOptions;
 typedef struct SExplainStmt {
-  ENodeType type;
+  ENodeType        type;
-  bool analyze;
+  bool             analyze;
  SExplainOptions* pOptions;
-  SNode* pQuery;
+  SNode*           pQuery;
 } SExplainStmt;
 void nodesWalkSelectStmt(SSelectStmt* pSelect, ESqlClause clause, FNodeWalker walker, void* pContext);
@@ -324,10 +308,10 @@ bool nodesIsJsonOp(const SOperatorNode* pOp);
 bool nodesIsTimeorderQuery(const SNode* pQuery);
 bool nodesIsTimelineQuery(const SNode* pQuery);
-void* nodesGetValueFromNode(SValueNode *pNode);
+void* nodesGetValueFromNode(SValueNode* pNode);
-char* nodesGetStrValueFromNode(SValueNode *pNode);
+char* nodesGetStrValueFromNode(SValueNode* pNode);
-char *getFillModeString(EFillMode mode);
+char* getFillModeString(EFillMode mode);
-void valueNodeToVariant(const SValueNode* pNode, SVariant* pVal);
+void  valueNodeToVariant(const SValueNode* pNode, SVariant* pVal);
 #ifdef __cplusplus
 }

--- a/include/util/taoserror.h
+++ b/include/util/taoserror.h
@@ -573,7 +573,6 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_TABLE_NOT_EXIST           TAOS_DEF_ERROR_CODE(0, 0x2602)
 #define TSDB_CODE_PAR_AMBIGUOUS_COLUMN          TAOS_DEF_ERROR_CODE(0, 0x2603)
 #define TSDB_CODE_PAR_WRONG_VALUE_TYPE          TAOS_DEF_ERROR_CODE(0, 0x2604)
-#define TSDB_CODE_PAR_INVALID_FUNTION           TAOS_DEF_ERROR_CODE(0, 0x2605)
 #define TSDB_CODE_PAR_ILLEGAL_USE_AGG_FUNCTION  TAOS_DEF_ERROR_CODE(0, 0x2608)
 #define TSDB_CODE_PAR_WRONG_NUMBER_OF_SELECT    TAOS_DEF_ERROR_CODE(0, 0x2609)
 #define TSDB_CODE_PAR_GROUPBY_LACK_EXPRESSION   TAOS_DEF_ERROR_CODE(0, 0x260A)
@@ -633,6 +632,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_FUNC_FUNTION_PARA_NUM         TAOS_DEF_ERROR_CODE(0, 0x2801)
 #define TSDB_CODE_FUNC_FUNTION_PARA_TYPE        TAOS_DEF_ERROR_CODE(0, 0x2802)
 #define TSDB_CODE_FUNC_FUNTION_PARA_VALUE       TAOS_DEF_ERROR_CODE(0, 0x2803)
+#define TSDB_CODE_FUNC_INVALID_FUNTION          TAOS_DEF_ERROR_CODE(0, 0x2604)
 #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/src/clientMain.c
+++ b/source/client/src/clientMain.c
@@ -120,7 +120,7 @@ const char *taos_errstr(TAOS_RES *res) {
    return (const char *)tstrerror(terrno);
  }
-  if (strlen(pRequest->msgBuf) > 0 || pRequest->code == TSDB_CODE_RPC_FQDN_ERROR) {
+  if (NULL != pRequest->msgBuf && (strlen(pRequest->msgBuf) > 0 || pRequest->code == TSDB_CODE_RPC_FQDN_ERROR)) {
    return pRequest->msgBuf;
  } else {
    return (const char *)tstrerror(pRequest->code);

--- 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
@@ -56,7 +56,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;
@@ -76,17 +76,25 @@ struct tmq_t {
  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;
@@ -280,6 +294,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, false);
+      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 +466,15 @@ 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->autoCommit = conf->autoCommit;*/
+  pTmq->autoCommit = 0;
+  pTmq->autoCommitInterval = conf->autoCommitInterval;
  pTmq->commit_cb = conf->commit_cb;
  pTmq->resetOffsetCfg = conf->resetOffset;
@@ -607,6 +667,14 @@ tmq_resp_err_t tmq_subscribe(tmq_t* tmq, const tmq_list_t* topic_list) {
    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);
@@ -909,7 +977,7 @@ 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) {
    tsem_post(&pParam->rspSem);
  }
@@ -918,6 +986,7 @@ END:
 int32_t tmqAskEp(tmq_t* tmq, bool sync) {
  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);
+#endif
  int32_t           tlen = sizeof(SMqCMGetSubEpReq);
  SMqCMGetSubEpReq* 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,7 +1010,7 @@ 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;
@@ -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;
  }
@@ -1216,7 +1286,7 @@ TAOS_RES* tmq_consumer_poll(tmq_t* tmq, int64_t blocking_time) {
  }
  while (1) {
-    tmqAskEp(tmq, false);
+    tmqHandleAllDelayedTask(tmq);
    tmqPollImpl(tmq, blocking_time);
    /*tsem_wait(&tmq->rspSem);*/

--- 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;
@@ -522,10 +522,6 @@ int32_t tSerializeSVCreateTbReq(void **buf, SVCreateTbReq *pReq) {
        SRSmaParam *param = pReq->stbCfg.pRSmaParam;
        tlen += taosEncodeBinary(buf, (const void *)&param->xFilesFactor, sizeof(param->xFilesFactor));
        tlen += taosEncodeFixedI32(buf, param->delay);
-        tlen += taosEncodeFixedI8(buf, param->nFuncIds);
-        for (int8_t i = 0; i < param->nFuncIds; ++i) {
-          tlen += taosEncodeFixedI32(buf, param->pFuncIds[i]);
-        }
        tlen += taosEncodeFixedI32(buf, param->qmsg1Len);
        if (param->qmsg1Len > 0) {
          tlen += taosEncodeString(buf, param->qmsg1);
@@ -555,10 +551,6 @@ int32_t tSerializeSVCreateTbReq(void **buf, SVCreateTbReq *pReq) {
        SRSmaParam *param = pReq->ntbCfg.pRSmaParam;
        tlen += taosEncodeBinary(buf, (const void *)&param->xFilesFactor, sizeof(param->xFilesFactor));
        tlen += taosEncodeFixedI32(buf, param->delay);
-        tlen += taosEncodeFixedI8(buf, param->nFuncIds);
-        for (int8_t i = 0; i < param->nFuncIds; ++i) {
-          tlen += taosEncodeFixedI32(buf, param->pFuncIds[i]);
-        }
      }
      break;
    default:
@@ -601,13 +593,6 @@ void *tDeserializeSVCreateTbReq(void *buf, SVCreateTbReq *pReq) {
        SRSmaParam *param = pReq->stbCfg.pRSmaParam;
        buf = taosDecodeBinaryTo(buf, (void *)&param->xFilesFactor, sizeof(param->xFilesFactor));
        buf = taosDecodeFixedI32(buf, &param->delay);
-        buf = taosDecodeFixedI8(buf, &param->nFuncIds);
-        if (param->nFuncIds > 0) {
-          param->pFuncIds = (func_id_t *)taosMemoryCalloc(param->nFuncIds, sizeof(func_id_t));
-          for (int8_t i = 0; i < param->nFuncIds; ++i) {
-            buf = taosDecodeFixedI32(buf, param->pFuncIds + i);
-          }
-        }
        buf = taosDecodeFixedI32(buf, &param->qmsg1Len);
        if (param->qmsg1Len > 0) {
          buf = taosDecodeString(buf, &param->qmsg1);
@@ -641,15 +626,6 @@ void *tDeserializeSVCreateTbReq(void *buf, SVCreateTbReq *pReq) {
        SRSmaParam *param = pReq->ntbCfg.pRSmaParam;
        buf = taosDecodeBinaryTo(buf, (void *)&param->xFilesFactor, sizeof(param->xFilesFactor));
        buf = taosDecodeFixedI32(buf, &param->delay);
-        buf = taosDecodeFixedI8(buf, &param->nFuncIds);
-        if (param->nFuncIds > 0) {
-          param->pFuncIds = (func_id_t *)taosMemoryMalloc(param->nFuncIds * sizeof(func_id_t));
-          for (int8_t i = 0; i < param->nFuncIds; ++i) {
-            buf = taosDecodeFixedI32(buf, param->pFuncIds + i);
-          }
-        } else {
-          param->pFuncIds = NULL;
-        }
      } else {
        pReq->ntbCfg.pRSmaParam = NULL;
      }
@@ -712,7 +688,6 @@ int32_t tSerializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pReq
  if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->igExists) < 0) return -1;
  if (tEncodeFloat(&encoder, pReq->xFilesFactor) < 0) return -1;
-  if (tEncodeI32(&encoder, pReq->aggregationMethod) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->delay) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->ttl) < 0) return -1;
  if (tEncodeI32(&encoder, pReq->numOfColumns) < 0) return -1;
@@ -767,7 +742,6 @@ int32_t tDeserializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pR
  if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->igExists) < 0) return -1;
  if (tDecodeFloat(&decoder, &pReq->xFilesFactor) < 0) return -1;
-  if (tDecodeI32(&decoder, &pReq->aggregationMethod) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->delay) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->ttl) < 0) return -1;
  if (tDecodeI32(&decoder, &pReq->numOfColumns) < 0) return -1;

--- 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;
@@ -91,6 +101,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 +123,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 +224,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/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 {
@@ -350,7 +354,6 @@ typedef struct {
  int32_t  version;
  int32_t  nextColId;
  float    xFilesFactor;
-  int32_t  aggregationMethod;
  int32_t  delay;
  int32_t  ttl;
  int32_t  numOfColumns;

--- 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/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/mndStb.c
+++ b/source/dnode/mnode/impl/src/mndStb.c
@@ -87,7 +87,6 @@ SSdbRaw *mndStbActionEncode(SStbObj *pStb) {
  SDB_SET_INT32(pRaw, dataPos, pStb->version, _OVER)
  SDB_SET_INT32(pRaw, dataPos, pStb->nextColId, _OVER)
  SDB_SET_INT32(pRaw, dataPos, (int32_t)(pStb->xFilesFactor * 10000), _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pStb->aggregationMethod, _OVER)
  SDB_SET_INT32(pRaw, dataPos, pStb->delay, _OVER)
  SDB_SET_INT32(pRaw, dataPos, pStb->ttl, _OVER)
  SDB_SET_INT32(pRaw, dataPos, pStb->numOfColumns, _OVER)
@@ -175,7 +174,6 @@ static SSdbRow *mndStbActionDecode(SSdbRaw *pRaw) {
  int32_t xFilesFactor = 0;
  SDB_GET_INT32(pRaw, dataPos, &xFilesFactor, _OVER)
  pStb->xFilesFactor = xFilesFactor / 10000.0f;
-  SDB_GET_INT32(pRaw, dataPos, &pStb->aggregationMethod, _OVER)
  SDB_GET_INT32(pRaw, dataPos, &pStb->delay, _OVER)
  SDB_GET_INT32(pRaw, dataPos, &pStb->ttl, _OVER)
  SDB_GET_INT32(pRaw, dataPos, &pStb->numOfColumns, _OVER)
@@ -404,7 +402,7 @@ static void *mndBuildVCreateStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pSt
  req.name = (char *)tNameGetTableName(&name);
  req.ttl = 0;
  req.keep = 0;
-  req.rollup = pStb->aggregationMethod > -1 ? 1 : 0;
+  req.rollup = pStb->pAst1 > 0 ? 1 : 0;
  req.type = TD_SUPER_TABLE;
  req.stbCfg.suid = pStb->uid;
  req.stbCfg.nCols = pStb->numOfColumns;
@@ -433,20 +431,8 @@ static void *mndBuildVCreateStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pSt
    pRSmaParam->xFilesFactor = pStb->xFilesFactor;
    pRSmaParam->delay = pStb->delay;
-    pRSmaParam->nFuncIds = 1;  // only 1 aggregation method supported currently
-    pRSmaParam->pFuncIds = (func_id_t *)taosMemoryCalloc(pRSmaParam->nFuncIds, sizeof(func_id_t));
-    if (pRSmaParam->pFuncIds == NULL) {
-      taosMemoryFreeClear(req.stbCfg.pRSmaParam);
-      taosMemoryFreeClear(req.stbCfg.pSchema);
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      return NULL;
-    }
-    for (int32_t f = 0; f < pRSmaParam->nFuncIds; ++f) {
-      *(pRSmaParam->pFuncIds + f) = pStb->aggregationMethod;
-    }
    if (pStb->ast1Len > 0) {
      if (mndConvertRSmaTask(pStb->pAst1, 0, 0, &pRSmaParam->qmsg1, &pRSmaParam->qmsg1Len) != TSDB_CODE_SUCCESS) {
-        taosMemoryFreeClear(pRSmaParam->pFuncIds);
        taosMemoryFreeClear(req.stbCfg.pRSmaParam);
        taosMemoryFreeClear(req.stbCfg.pSchema);
        return NULL;
@@ -454,7 +440,6 @@ static void *mndBuildVCreateStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pSt
    }
    if (pStb->ast2Len > 0) {
      if (mndConvertRSmaTask(pStb->pAst2, 0, 0, &pRSmaParam->qmsg2, &pRSmaParam->qmsg2Len) != TSDB_CODE_SUCCESS) {
-        taosMemoryFreeClear(pRSmaParam->pFuncIds);
        taosMemoryFreeClear(pRSmaParam->qmsg1);
        taosMemoryFreeClear(req.stbCfg.pRSmaParam);
        taosMemoryFreeClear(req.stbCfg.pSchema);
@@ -469,7 +454,6 @@ static void *mndBuildVCreateStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pSt
  SMsgHead *pHead = taosMemoryMalloc(contLen);
  if (pHead == NULL) {
    if (pRSmaParam) {
-      taosMemoryFreeClear(pRSmaParam->pFuncIds);
      taosMemoryFreeClear(pRSmaParam->qmsg1);
      taosMemoryFreeClear(pRSmaParam->qmsg2);
      taosMemoryFreeClear(pRSmaParam);
@@ -487,7 +471,6 @@ static void *mndBuildVCreateStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pSt
  *pContLen = contLen;
  if (pRSmaParam) {
-    taosMemoryFreeClear(pRSmaParam->pFuncIds);
    taosMemoryFreeClear(pRSmaParam->qmsg1);
    taosMemoryFreeClear(pRSmaParam->qmsg2);
    taosMemoryFreeClear(pRSmaParam);
@@ -705,7 +688,6 @@ static int32_t mndCreateStb(SMnode *pMnode, SNodeMsg *pReq, SMCreateStbReq *pCre
  stbObj.version = 1;
  stbObj.nextColId = 1;
  stbObj.xFilesFactor = pCreate->xFilesFactor;
-  stbObj.aggregationMethod = pCreate->aggregationMethod;
  stbObj.delay = pCreate->delay;
  stbObj.ttl = pCreate->ttl;
  stbObj.numOfColumns = pCreate->numOfColumns;

--- 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,7 +837,7 @@ 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;
@@ -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/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
@@ -258,7 +258,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/vnode/src/inc/tsdb.h
+++ b/source/dnode/vnode/src/inc/tsdb.h
@@ -56,7 +56,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

--- 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
@@ -33,24 +33,24 @@ STqReadHandle* tqInitSubmitMsgScanner(SMeta* pMeta) {
 int32_t tqReadHandleSetMsg(STqReadHandle* pReadHandle, SSubmitReq* pMsg, int64_t ver) {
  pReadHandle->pMsg = pMsg;
-  pMsg->length = htonl(pMsg->length);
+  // pMsg->length = htonl(pMsg->length);
-  pMsg->numOfBlocks = htonl(pMsg->numOfBlocks);
+  // pMsg->numOfBlocks = htonl(pMsg->numOfBlocks);
  // iterate and convert
-  if (tInitSubmitMsgIter(pMsg, &pReadHandle->msgIter) < 0) return -1;
+  if (tInitSubmitMsgIterEx(pMsg, &pReadHandle->msgIter) < 0) return -1;
  while (true) {
-    if (tGetSubmitMsgNext(&pReadHandle->msgIter, &pReadHandle->pBlock) < 0) return -1;
+    if (tGetSubmitMsgNextEx(&pReadHandle->msgIter, &pReadHandle->pBlock) < 0) return -1;
    if (pReadHandle->pBlock == NULL) break;
-    pReadHandle->pBlock->uid = htobe64(pReadHandle->pBlock->uid);
+    // pReadHandle->pBlock->uid = htobe64(pReadHandle->pBlock->uid);
-    pReadHandle->pBlock->suid = htobe64(pReadHandle->pBlock->suid);
+    // pReadHandle->pBlock->suid = htobe64(pReadHandle->pBlock->suid);
-    pReadHandle->pBlock->sversion = htonl(pReadHandle->pBlock->sversion);
+    // pReadHandle->pBlock->sversion = htonl(pReadHandle->pBlock->sversion);
-    pReadHandle->pBlock->dataLen = htonl(pReadHandle->pBlock->dataLen);
+    // pReadHandle->pBlock->dataLen = htonl(pReadHandle->pBlock->dataLen);
-    pReadHandle->pBlock->schemaLen = htonl(pReadHandle->pBlock->schemaLen);
+    // pReadHandle->pBlock->schemaLen = htonl(pReadHandle->pBlock->schemaLen);
-    pReadHandle->pBlock->numOfRows = htons(pReadHandle->pBlock->numOfRows);
+    // pReadHandle->pBlock->numOfRows = htons(pReadHandle->pBlock->numOfRows);
  }
-  if (tInitSubmitMsgIter(pMsg, &pReadHandle->msgIter) < 0) return -1;
+  if (tInitSubmitMsgIterEx(pMsg, &pReadHandle->msgIter) < 0) return -1;
  pReadHandle->ver = ver;
  memset(&pReadHandle->blkIter, 0, sizeof(SSubmitBlkIter));
  return 0;
@@ -58,7 +58,7 @@ int32_t tqReadHandleSetMsg(STqReadHandle* pReadHandle, SSubmitReq* pMsg, int64_t
 bool tqNextDataBlock(STqReadHandle* pHandle) {
  while (1) {
-    if (tGetSubmitMsgNext(&pHandle->msgIter, &pHandle->pBlock) < 0) {
+    if (tGetSubmitMsgNextEx(&pHandle->msgIter, &pHandle->pBlock) < 0) {
      return false;
    }
    if (pHandle->pBlock == NULL) return false;
@@ -68,7 +68,7 @@ bool tqNextDataBlock(STqReadHandle* pHandle) {
    if (pHandle->tbIdHash == NULL) {
      return true;
    }
-    void* ret = taosHashGet(pHandle->tbIdHash, &pHandle->pBlock->uid, sizeof(int64_t));
+    void* ret = taosHashGet(pHandle->tbIdHash, &pHandle->msgIter.uid, sizeof(int64_t));
    if (ret != NULL) {
      /*printf("retrieve one tb %ld\n", pHandle->pBlock->uid);*/
      /*pHandle->pBlock->tid = htonl(pHandle->pBlock->tid);*/
@@ -90,23 +90,25 @@ int32_t tqRetrieveDataBlock(SArray** ppCols, STqReadHandle* pHandle, uint64_t* p
  // TODO set to real sversion
  int32_t sversion = 0;
  if (pHandle->sver != sversion) {
-    pHandle->pSchema = metaGetTbTSchema(pHandle->pVnodeMeta, pHandle->pBlock->uid, sversion);
+    pHandle->pSchema = metaGetTbTSchema(pHandle->pVnodeMeta, pHandle->msgIter.uid, sversion);
+#if 0
    tb_uid_t quid;
-    STbCfg*  pTbCfg = metaGetTbInfoByUid(pHandle->pVnodeMeta, pHandle->pBlock->uid);
+    STbCfg*  pTbCfg = metaGetTbInfoByUid(pHandle->pVnodeMeta, pHandle->msgIter.uid);
    if (pTbCfg->type == META_CHILD_TABLE) {
      quid = pTbCfg->ctbCfg.suid;
    } else {
-      quid = pHandle->pBlock->uid;
+      quid = pHandle->msgIter.uid;
    }
    pHandle->pSchemaWrapper = metaGetTableSchema(pHandle->pVnodeMeta, quid, sversion, true);
+#endif
+    pHandle->pSchemaWrapper = metaGetTableSchema(pHandle->pVnodeMeta, pHandle->msgIter.suid, sversion, true);
    pHandle->sver = sversion;
  }
  STSchema*       pTschema = pHandle->pSchema;
  SSchemaWrapper* pSchemaWrapper = pHandle->pSchemaWrapper;
-  *pNumOfRows = pHandle->pBlock->numOfRows;
+  *pNumOfRows = pHandle->msgIter.numOfRows;
  int32_t colNumNeed = taosArrayGetSize(pHandle->pColIdList);
  if (colNumNeed == 0) {
@@ -175,8 +177,8 @@ int32_t tqRetrieveDataBlock(SArray** ppCols, STqReadHandle* pHandle, uint64_t* p
  tdSTSRowIterInit(&iter, pTschema);
  STSRow* row;
  int32_t curRow = 0;
-  tInitSubmitBlkIter(pHandle->pBlock, &pHandle->blkIter);
+  tInitSubmitBlkIterEx(&pHandle->msgIter, pHandle->pBlock, &pHandle->blkIter);
-  while ((row = tGetSubmitBlkNext(&pHandle->blkIter)) != NULL) {
+  while ((row = tGetSubmitBlkNextEx(&pHandle->blkIter)) != NULL) {
    tdSTSRowIterReset(&iter, row);
    // get all wanted col of that block
    for (int32_t i = 0; i < colActual; i++) {

--- a/source/dnode/vnode/src/tsdb/tsdbSma.c
+++ b/source/dnode/vnode/src/tsdb/tsdbSma.c
@@ -678,9 +678,6 @@ int32_t tsdbUpdateExpiredWindowImpl(STsdb *pTsdb, SSubmitReq *pMsg, int64_t vers
    return TSDB_CODE_FAILED;
  }
-  if (tdScanAndConvertSubmitMsg(pMsg) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_FAILED;
-  }
  if (tsdbCheckAndInitSmaEnv(pTsdb, TSDB_SMA_TYPE_TIME_RANGE) != TSDB_CODE_SUCCESS) {
    terrno = TSDB_CODE_TDB_INIT_FAILED;
@@ -705,25 +702,25 @@ int32_t tsdbUpdateExpiredWindowImpl(STsdb *pTsdb, SSubmitReq *pMsg, int64_t vers
  SInterval      interval = {0};
  TSKEY          lastWinSKey = INT64_MIN;
-  if (tInitSubmitMsgIter(pMsg, &msgIter) != TSDB_CODE_SUCCESS) {
+  if (tInitSubmitMsgIterEx(pMsg, &msgIter) != TSDB_CODE_SUCCESS) {
    return TSDB_CODE_FAILED;
  }
  while (true) {
-    tGetSubmitMsgNext(&msgIter, &pBlock);
+    tGetSubmitMsgNextEx(&msgIter, &pBlock);
    if (!pBlock) break;
    STSmaWrapper *pSW = NULL;
    STSma        *pTSma = NULL;
    SSubmitBlkIter blkIter = {0};
-    if (tInitSubmitBlkIter(pBlock, &blkIter) != TSDB_CODE_SUCCESS) {
+    if (tInitSubmitBlkIterEx(&msgIter, pBlock, &blkIter) != TSDB_CODE_SUCCESS) {
      pSW = tdFreeTSmaWrapper(pSW);
      break;
    }
    while (true) {
-      STSRow *row = tGetSubmitBlkNext(&blkIter);
+      STSRow *row = tGetSubmitBlkNextEx(&blkIter);
      if (!row) {
        tdFreeTSmaWrapper(pSW);
        break;
@@ -1764,7 +1761,7 @@ int32_t tsdbRegisterRSma(STsdb *pTsdb, SMeta *pMeta, SVCreateTbReq *pReq) {
      TSDB_CODE_SUCCESS) {
    return TSDB_CODE_FAILED;
  } else {
-    tsdbDebug("vgId:%d register rsma info succeed for suid:%" PRIi64, REPO_ID(pTsdb), pReq->stbCfg.suid);
+   tsdbDebug("vgId:%d register rsma info succeed for suid:%" PRIi64, REPO_ID(pTsdb), pReq->stbCfg.suid);
  }
  return TSDB_CODE_SUCCESS;
@@ -1791,7 +1788,7 @@ int32_t tsdbUidStorePut(STbUidStore *pStore, tb_uid_t suid, tb_uid_t *uid) {
          return TSDB_CODE_FAILED;
        }
      }
-      if (!taosArrayPush(pStore->tbUids, &uid)) {
+      if (!taosArrayPush(pStore->tbUids, uid)) {
        return TSDB_CODE_FAILED;
      }
    }
@@ -1806,14 +1803,14 @@ int32_t tsdbUidStorePut(STbUidStore *pStore, tb_uid_t suid, tb_uid_t *uid) {
    if (uid) {
      SArray *uidArray = taosHashGet(pStore->uidHash, &suid, sizeof(tb_uid_t));
      if (uidArray && ((uidArray = *(SArray **)uidArray))) {
-        taosArrayPush(uidArray, &uid);
+        taosArrayPush(uidArray, uid);
      } else {
        SArray *pUidArray = taosArrayInit(1, sizeof(tb_uid_t));
        if (!pUidArray) {
          terrno = TSDB_CODE_OUT_OF_MEMORY;
          return TSDB_CODE_FAILED;
        }
-        if (!taosArrayPush(pUidArray, &uid)) {
+        if (!taosArrayPush(pUidArray, uid)) {
          terrno = TSDB_CODE_OUT_OF_MEMORY;
          return TSDB_CODE_FAILED;
        }
@@ -1975,12 +1972,12 @@ static int32_t tsdbFetchSubmitReqSuids(SSubmitReq *pMsg, STbUidStore *pStore) {
  // pMsg->length = htonl(pMsg->length);
  // pMsg->numOfBlocks = htonl(pMsg->numOfBlocks);
-  if (tInitSubmitMsgIter(pMsg, &msgIter) < 0) return -1;
+  if (tInitSubmitMsgIterEx(pMsg, &msgIter) < 0) return -1;
  while (true) {
-    if (tGetSubmitMsgNext(&msgIter, &pBlock) < 0) return -1;
+    if (tGetSubmitMsgNextEx(&msgIter, &pBlock) < 0) return -1;
    if (!pBlock) break;
-    tsdbUidStorePut(pStore, pBlock->suid, NULL);
+    tsdbUidStorePut(pStore, msgIter.suid, NULL);
  }
  if (terrno != TSDB_CODE_SUCCESS) return -1;
@@ -2014,6 +2011,8 @@ int32_t tsdbExecuteRSma(STsdb *pTsdb, SMeta *pMeta, const void *pMsg, int32_t in
  if (inputType == STREAM_DATA_TYPE_SUBMIT_BLOCK) {
    if (pRSmaInfo->taskInfo[0]) {
+      tsdbDebug("vgId:%d execute rsma task for qTaskInfo:%p suid:%" PRIu64, REPO_ID(pTsdb), pRSmaInfo->taskInfo[0],
+                *suid);
      qSetStreamInput(pRSmaInfo->taskInfo[0], pMsg, inputType);
      while (1) {
        SSDataBlock *output;
@@ -2026,7 +2025,11 @@ int32_t tsdbExecuteRSma(STsdb *pTsdb, SMeta *pMeta, const void *pMsg, int32_t in
        }
        taosArrayPush(pResult, output);
      }
-      blockDebugShowData(pResult);
+      if (taosArrayGetSize(pResult) > 0) {
+        blockDebugShowData(pResult);
+      } else {
+        tsdbWarn("vgId:%d no sma data generated since %s", REPO_ID(pTsdb), tstrerror(terrno));
+      }
    }
    // if (pRSmaInfo->taskInfo[1]) {

--- a/source/dnode/vnode/src/vnd/vnodeSvr.c
+++ b/source/dnode/vnode/src/vnd/vnodeSvr.c
@@ -81,9 +81,9 @@ int vnodeProcessWriteReq(SVnode *pVnode, SRpcMsg *pMsg, int64_t version, SRpcMsg
    case TDMT_VND_DROP_TABLE:
      break;
    case TDMT_VND_SUBMIT:
+      tsdbTriggerRSma(pVnode->pTsdb, pVnode->pMeta, ptr, STREAM_DATA_TYPE_SUBMIT_BLOCK);
      pRsp->msgType = TDMT_VND_SUBMIT_RSP;
      vnodeProcessSubmitReq(pVnode, ptr, pRsp);
-      tsdbTriggerRSma(pVnode->pTsdb, pVnode->pMeta, ptr, STREAM_DATA_TYPE_SUBMIT_BLOCK);
      break;
    case TDMT_VND_MQ_VG_CHANGE:
      if (tqProcessVgChangeReq(pVnode->pTq, POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead)),
@@ -287,7 +287,6 @@ static int vnodeProcessCreateStbReq(SVnode *pVnode, void *pReq) {
  taosMemoryFree(vCreateTbReq.stbCfg.pSchema);
  taosMemoryFree(vCreateTbReq.stbCfg.pTagSchema);
  if (vCreateTbReq.stbCfg.pRSmaParam) {
-    taosMemoryFree(vCreateTbReq.stbCfg.pRSmaParam->pFuncIds);
    taosMemoryFree(vCreateTbReq.stbCfg.pRSmaParam->qmsg1);
    taosMemoryFree(vCreateTbReq.stbCfg.pRSmaParam->qmsg2);
    taosMemoryFree(vCreateTbReq.stbCfg.pRSmaParam);
@@ -334,7 +333,6 @@ static int vnodeProcessCreateTbReq(SVnode *pVnode, SRpcMsg *pMsg, void *pReq, SR
      taosMemoryFree(pCreateTbReq->stbCfg.pSchema);
      taosMemoryFree(pCreateTbReq->stbCfg.pTagSchema);
      if (pCreateTbReq->stbCfg.pRSmaParam) {
-        taosMemoryFree(pCreateTbReq->stbCfg.pRSmaParam->pFuncIds);
        taosMemoryFree(pCreateTbReq->stbCfg.pRSmaParam);
      }
    } else if (pCreateTbReq->type == TD_CHILD_TABLE) {
@@ -342,7 +340,6 @@ static int vnodeProcessCreateTbReq(SVnode *pVnode, SRpcMsg *pMsg, void *pReq, SR
    } else {
      taosMemoryFree(pCreateTbReq->ntbCfg.pSchema);
      if (pCreateTbReq->ntbCfg.pRSmaParam) {
-        taosMemoryFree(pCreateTbReq->ntbCfg.pRSmaParam->pFuncIds);
        taosMemoryFree(pCreateTbReq->ntbCfg.pRSmaParam);
      }
    }
@@ -373,7 +370,6 @@ static int vnodeProcessAlterStbReq(SVnode *pVnode, void *pReq) {
  taosMemoryFree(vAlterTbReq.stbCfg.pSchema);
  taosMemoryFree(vAlterTbReq.stbCfg.pTagSchema);
  if (vAlterTbReq.stbCfg.pRSmaParam) {
-    taosMemoryFree(vAlterTbReq.stbCfg.pRSmaParam->pFuncIds);
    taosMemoryFree(vAlterTbReq.stbCfg.pRSmaParam);
  }
  taosMemoryFree(vAlterTbReq.name);

--- 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/function/inc/functionMgtInt.h
+++ b/source/libs/function/inc/functionMgtInt.h
@@ -41,7 +41,9 @@ extern "C" {
 #define FUNC_MGT_TEST_MASK(val, mask) (((val) & (mask)) != 0)
-#define FUNC_UDF_ID_START_OFFSET_VAL 5000
+#define FUNC_UDF_ID_START     5000
+#define FUNC_AGGREGATE_UDF_ID 5001
+#define FUNC_SCALAR_UDF_ID    5002
 extern const int funcMgtUdfNum;

--- a/source/libs/function/src/builtins.c
+++ b/source/libs/function/src/builtins.c
--- a/source/libs/function/src/functionMgt.c
+++ b/source/libs/function/src/functionMgt.c
@@ -24,7 +24,6 @@
 typedef struct SFuncMgtService {
  SHashObj* pFuncNameHashTable;
-  SArray* pUdfTable; // SUdfInfo
 } SFuncMgtService;
 typedef struct SUdfInfo {
@@ -49,18 +48,12 @@ static void doInitFunctionTable() {
      return;
    }
  }
-  gFunMgtService.pUdfTable = NULL;
-}
-static int8_t getUdfType(int32_t funcId) {
-  SUdfInfo* pUdf = taosArrayGet(gFunMgtService.pUdfTable, funcId - FUNC_UDF_ID_START_OFFSET_VAL - 1);
-  return pUdf->funcType;
 }
 static bool isSpecificClassifyFunc(int32_t funcId, uint64_t classification) {
  if (fmIsUserDefinedFunc(funcId)) {
-    return getUdfType(funcId);
+    return FUNC_MGT_AGG_FUNC == classification ? FUNC_AGGREGATE_UDF_ID == funcId :
+        (FUNC_MGT_SCALAR_FUNC == classification ? FUNC_SCALAR_UDF_ID == funcId : false);
  }
  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {
    return false;
@@ -68,33 +61,23 @@ static bool isSpecificClassifyFunc(int32_t funcId, uint64_t classification) {
  return FUNC_MGT_TEST_MASK(funcMgtBuiltins[funcId].classification, classification);
 }
-static int32_t getUdfId(SFmGetFuncInfoParam* pParam, const char* pFuncName) {
+static int32_t getUdfInfo(SFmGetFuncInfoParam* pParam, SFunctionNode* pFunc) {
  SFuncInfo* pInfo = NULL;
-  int32_t code = catalogGetUdfInfo(pParam->pCtg, pParam->pRpc, pParam->pMgmtEps, pFuncName, &pInfo);
+  int32_t code = catalogGetUdfInfo(pParam->pCtg, pParam->pRpc, pParam->pMgmtEps, pFunc->functionName, &pInfo);
-  if (TSDB_CODE_SUCCESS != code || NULL == pInfo) {
+  if (TSDB_CODE_SUCCESS != code) {
-    return -1;
+    return code;
  }
-  if (NULL == gFunMgtService.pUdfTable) {
+  if (NULL == pInfo) {
-    gFunMgtService.pUdfTable = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SUdfInfo));
+    snprintf(pParam->pErrBuf, pParam->errBufLen, "Invalid function name: %s", pFunc->functionName);
-  }
+    return TSDB_CODE_FUNC_INVALID_FUNTION;
-  SUdfInfo info = { .outputDt.type = pInfo->outputType, .outputDt.bytes = pInfo->outputLen, .funcType = pInfo->funcType };
+  }
-  taosArrayPush(gFunMgtService.pUdfTable, &info);
+  pFunc->funcType = FUNCTION_TYPE_UDF;
+  pFunc->funcId = TSDB_FUNC_TYPE_AGGREGATE == pInfo->funcType ? FUNC_AGGREGATE_UDF_ID : FUNC_SCALAR_UDF_ID;
+  pFunc->node.resType.type = pInfo->outputType;
+  pFunc->node.resType.bytes = pInfo->outputLen;
+  pFunc->udfBufSize = pInfo->bufSize;
  tFreeSFuncInfo(pInfo);
  taosMemoryFree(pInfo);
-  return taosArrayGetSize(gFunMgtService.pUdfTable) + FUNC_UDF_ID_START_OFFSET_VAL;
-}
-static int32_t getFuncId(SFmGetFuncInfoParam* pParam, const char* pFuncName) {
-  void* pVal = taosHashGet(gFunMgtService.pFuncNameHashTable, pFuncName, strlen(pFuncName));
-  if (NULL == pVal) {
-    return getUdfId(pParam, pFuncName);
-  }
-  return *(int32_t*)pVal;
-}
-static int32_t getUdfResultType(SFunctionNode* pFunc) {
-  SUdfInfo* pUdf = taosArrayGet(gFunMgtService.pUdfTable, pFunc->funcId - FUNC_UDF_ID_START_OFFSET_VAL - 1);
-  pFunc->node.resType = pUdf->outputDt;
  return TSDB_CODE_SUCCESS;
 }
@@ -103,28 +86,14 @@ int32_t fmFuncMgtInit() {
  return initFunctionCode;
 }
-int32_t fmGetFuncInfo(SFmGetFuncInfoParam* pParam, const char* pFuncName, int32_t* pFuncId, int32_t* pFuncType) {
+int32_t fmGetFuncInfo(SFmGetFuncInfoParam* pParam, SFunctionNode* pFunc) {
-  *pFuncId = getFuncId(pParam, pFuncName);
+  void* pVal = taosHashGet(gFunMgtService.pFuncNameHashTable, pFunc->functionName, strlen(pFunc->functionName));
-  if (*pFuncId < 0) {
+  if (NULL != pVal) {
-    return TSDB_CODE_FAILED;
+    pFunc->funcId = *(int32_t*)pVal;
-  }
+    pFunc->funcType = funcMgtBuiltins[pFunc->funcId].type;
-  if (fmIsUserDefinedFunc(*pFuncId)) {
+    return funcMgtBuiltins[pFunc->funcId].translateFunc(pFunc, pParam->pErrBuf, pParam->errBufLen);
-    *pFuncType = FUNCTION_TYPE_UDF;
-  } else {
-    *pFuncType = funcMgtBuiltins[*pFuncId].type;
-  }
-  return TSDB_CODE_SUCCESS;
-}
-int32_t fmGetFuncResultType(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
-  if (fmIsUserDefinedFunc(pFunc->funcId)) {
-    return getUdfResultType(pFunc);
-  }
-  if (pFunc->funcId < 0 || pFunc->funcId >= funcMgtBuiltinsNum) {
-    return TSDB_CODE_FAILED;
  }
-  return funcMgtBuiltins[pFunc->funcId].translateFunc(pFunc, pErrBuf, len);
+  return getUdfInfo(pParam, pFunc);
 }
 EFuncDataRequired fmFuncDataRequired(SFunctionNode* pFunc, STimeWindow* pTimeWindow) {
@@ -194,7 +163,7 @@ bool fmIsMultiResFunc(int32_t funcId) {
 }
 bool fmIsUserDefinedFunc(int32_t funcId) {
-  return funcId > FUNC_UDF_ID_START_OFFSET_VAL;
+  return funcId > FUNC_UDF_ID_START;
 }
 void fmFuncMgtDestroy() {

--- a/source/libs/nodes/inc/nodesUtil.h
+++ b/source/libs/nodes/inc/nodesUtil.h
@@ -20,17 +20,39 @@
 extern "C" {
 #endif
-#define nodesFatal(...)  qFatal("NODES: " __VA_ARGS__)
+#define nodesFatal(...) qFatal("NODES: " __VA_ARGS__)
-#define nodesError(...)  qError("NODES: " __VA_ARGS__)
+#define nodesError(...) qError("NODES: " __VA_ARGS__)
-#define nodesWarn(...)   qWarn("NODES: " __VA_ARGS__)
+#define nodesWarn(...)  qWarn("NODES: " __VA_ARGS__)
-#define nodesInfo(...)   qInfo("NODES: " __VA_ARGS__)
+#define nodesInfo(...)  qInfo("NODES: " __VA_ARGS__)
-#define nodesDebug(...)  qDebug("NODES: " __VA_ARGS__)
+#define nodesDebug(...) qDebug("NODES: " __VA_ARGS__)
-#define nodesTrace(...)  qTrace("NODES: " __VA_ARGS__)
+#define nodesTrace(...) qTrace("NODES: " __VA_ARGS__)
-#define NODES_ERR_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { terrno = _code; return _code; } } while (0)
+#define NODES_ERR_RET(c)              \
-#define NODES_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { terrno = _code; } return _code; } while (0)
+  do {                                \
-#define NODES_ERR_JRET(c) do { code = c; if (code != TSDB_CODE_SUCCESS) { terrno = code; goto _return; } } while (0)
+    int32_t _code = c;                \
+    if (_code != TSDB_CODE_SUCCESS) { \
+      terrno = _code;                 \
+      return _code;                   \
+    }                                 \
+  } while (0)
+#define NODES_RET(c)                  \
+  do {                                \
+    int32_t _code = c;                \
+    if (_code != TSDB_CODE_SUCCESS) { \
+      terrno = _code;                 \
+    }                                 \
+    return _code;                     \
+  } while (0)
+#define NODES_ERR_JRET(c)            \
+  do {                               \
+    code = c;                        \
+    if (code != TSDB_CODE_SUCCESS) { \
+      terrno = code;                 \
+      goto _return;                  \
+    }                                \
+  } while (0)
 #ifdef __cplusplus
 }

--- a/source/libs/nodes/src/nodesCloneFuncs.c
+++ b/source/libs/nodes/src/nodesCloneFuncs.c
@@ -19,71 +19,71 @@
 #include "taos.h"
 #include "taoserror.h"
-#define COPY_ALL_SCALAR_FIELDS \
+#define COPY_ALL_SCALAR_FIELDS             \
-	do { \
+  do {                                     \
    memcpy((pDst), (pSrc), sizeof(*pSrc)); \
-	} while (0)
+  } while (0)
-#define COPY_SCALAR_FIELD(fldname) \
+#define COPY_SCALAR_FIELD(fldname)     \
-	do { \
+  do {                                 \
    (pDst)->fldname = (pSrc)->fldname; \
-	} while (0)
+  } while (0)
-#define COPY_CHAR_ARRAY_FIELD(fldname) \
+#define COPY_CHAR_ARRAY_FIELD(fldname)        \
-	do { \
+  do {                                        \
    strcpy((pDst)->fldname, (pSrc)->fldname); \
-	} while (0)
+  } while (0)
-#define COPY_CHAR_POINT_FIELD(fldname) \
+#define COPY_CHAR_POINT_FIELD(fldname)         \
-	do { \
+  do {                                         \
-    if (NULL == (pSrc)->fldname) { \
+    if (NULL == (pSrc)->fldname) {             \
-      break; \
+      break;                                   \
-    } \
+    }                                          \
    (pDst)->fldname = strdup((pSrc)->fldname); \
-	} while (0)
+  } while (0)
-#define CLONE_NODE_FIELD(fldname) \
+#define CLONE_NODE_FIELD(fldname)                      \
-	do { \
+  do {                                                 \
-    if (NULL == (pSrc)->fldname) { \
+    if (NULL == (pSrc)->fldname) {                     \
-      break; \
+      break;                                           \
-    } \
+    }                                                  \
    (pDst)->fldname = nodesCloneNode((pSrc)->fldname); \
-    if (NULL == (pDst)->fldname) { \
+    if (NULL == (pDst)->fldname) {                     \
-      nodesDestroyNode((SNode*)(pDst)); \
+      nodesDestroyNode((SNode*)(pDst));                \
-      return NULL; \
+      return NULL;                                     \
-    } \
+    }                                                  \
-	} while (0)
+  } while (0)
-#define CLONE_NODE_LIST_FIELD(fldname) \
+#define CLONE_NODE_LIST_FIELD(fldname)                 \
-	do { \
+  do {                                                 \
-    if (NULL == (pSrc)->fldname) { \
+    if (NULL == (pSrc)->fldname) {                     \
-      break; \
+      break;                                           \
-    } \
+    }                                                  \
    (pDst)->fldname = nodesCloneList((pSrc)->fldname); \
-    if (NULL == (pDst)->fldname) { \
+    if (NULL == (pDst)->fldname) {                     \
-      nodesDestroyNode((SNode*)(pDst)); \
+      nodesDestroyNode((SNode*)(pDst));                \
-      return NULL; \
+      return NULL;                                     \
-    } \
+    }                                                  \
-	} while (0)
+  } while (0)
-#define CLONE_OBJECT_FIELD(fldname, cloneFunc) \
+#define CLONE_OBJECT_FIELD(fldname, cloneFunc)    \
-	do { \
+  do {                                            \
-    if (NULL == (pSrc)->fldname) { \
+    if (NULL == (pSrc)->fldname) {                \
-      break; \
+      break;                                      \
-    } \
+    }                                             \
    (pDst)->fldname = cloneFunc((pSrc)->fldname); \
-    if (NULL == (pDst)->fldname) { \
+    if (NULL == (pDst)->fldname) {                \
-      nodesDestroyNode((SNode*)(pDst)); \
+      nodesDestroyNode((SNode*)(pDst));           \
-      return NULL; \
+      return NULL;                                \
-    } \
+    }                                             \
-	} while (0)
+  } while (0)
-#define COPY_BASE_OBJECT_FIELD(fldname, copyFunc) \
+#define COPY_BASE_OBJECT_FIELD(fldname, copyFunc)                   \
-	do { \
+  do {                                                              \
    if (NULL == copyFunc(&((pSrc)->fldname), &((pDst)->fldname))) { \
-      return NULL; \
+      return NULL;                                                  \
-    } \
+    }                                                               \
-	} while (0)
+  } while (0)
 static void dataTypeCopy(const SDataType* pSrc, SDataType* pDst) {
  COPY_SCALAR_FIELD(type);
@@ -201,7 +201,7 @@ static SNode* logicNodeCopy(const SLogicNode* pSrc, SLogicNode* pDst) {
 }
 static STableMeta* tableMetaClone(const STableMeta* pSrc) {
-  int32_t len = TABLE_META_SIZE(pSrc);
+  int32_t     len = TABLE_META_SIZE(pSrc);
  STableMeta* pDst = taosMemoryMalloc(len);
  if (NULL == pDst) {
    return NULL;
@@ -211,7 +211,7 @@ static STableMeta* tableMetaClone(const STableMeta* pSrc) {
 }
 static SVgroupsInfo* vgroupsInfoClone(const SVgroupsInfo* pSrc) {
-  int32_t len = VGROUPS_INFO_SIZE(pSrc);
+  int32_t       len = VGROUPS_INFO_SIZE(pSrc);
  SVgroupsInfo* pDst = taosMemoryMalloc(len);
  if (NULL == pDst) {
    return NULL;

--- a/source/libs/nodes/src/nodesCodeFuncs.c
+++ b/source/libs/nodes/src/nodesCodeFuncs.c
@@ -16,8 +16,8 @@
 #include "cmdnodes.h"
 #include "nodesUtil.h"
 #include "plannodes.h"
-#include "querynodes.h"
 #include "query.h"
+#include "querynodes.h"
 #include "taoserror.h"
 #include "tjson.h"
@@ -29,7 +29,7 @@ static int32_t makeNodeByJson(const SJson* pJson, SNode** pNode);
 const char* nodesNodeName(ENodeType type) {
  switch (type) {
    case QUERY_NODE_COLUMN:
-      return "Column";    
+      return "Column";
    case QUERY_NODE_VALUE:
      return "Value";
    case QUERY_NODE_OPERATOR:
@@ -306,7 +306,7 @@ static int32_t tableComInfoToJson(const void* pObj, SJson* pJson) {
  if (TSDB_CODE_SUCCESS == code) {
    code = tjsonAddIntegerToObject(pJson, jkTableComInfoRowSize, pNode->rowSize);
  }
  return code;
 }
@@ -323,7 +323,7 @@ static int32_t jsonToTableComInfo(const SJson* pJson, void* pObj) {
  if (TSDB_CODE_SUCCESS == code) {
    code = tjsonGetNumberValue(pJson, jkTableComInfoRowSize, pNode->rowSize);
  }
  return code;
 }
@@ -345,7 +345,7 @@ static int32_t schemaToJson(const void* pObj, SJson* pJson) {
  if (TSDB_CODE_SUCCESS == code) {
    code = tjsonAddStringToObject(pJson, jkSchemaName, pNode->name);
  }
  return code;
 }
@@ -362,7 +362,7 @@ static int32_t jsonToSchema(const SJson* pJson, void* pObj) {
  if (TSDB_CODE_SUCCESS == code) {
    code = tjsonGetStringValue(pJson, jkSchemaName, pNode->name);
  }
  return code;
 }
@@ -398,7 +398,8 @@ static int32_t tableMetaToJson(const void* pObj, SJson* pJson) {
    code = tjsonAddObject(pJson, jkTableMetaComInfo, tableComInfoToJson, &pNode->tableInfo);
  }
  if (TSDB_CODE_SUCCESS == code) {
-    code = tjsonAddArray(pJson, jkTableMetaColSchemas, schemaToJson, pNode->schema, sizeof(SSchema), TABLE_TOTAL_COL_NUM(pNode));
+    code = tjsonAddArray(pJson, jkTableMetaColSchemas, schemaToJson, pNode->schema, sizeof(SSchema),
+                         TABLE_TOTAL_COL_NUM(pNode));
  }
  return code;
@@ -713,13 +714,9 @@ static int32_t jsonToPhysiScanNode(const SJson* pJson, void* pObj) {
  return code;
 }
-static int32_t physiTagScanNodeToJson(const void* pObj, SJson* pJson) {
+static int32_t physiTagScanNodeToJson(const void* pObj, SJson* pJson) { return physiScanNodeToJson(pObj, pJson); }
-  return physiScanNodeToJson(pObj, pJson);
-}
-static int32_t jsonToPhysiTagScanNode(const SJson* pJson, void* pObj) {
+static int32_t jsonToPhysiTagScanNode(const SJson* pJson, void* pObj) { return jsonToPhysiScanNode(pJson, pObj); }
-  return jsonToPhysiScanNode(pJson, pObj);
-}
 static const char* jkTableScanPhysiPlanScanCount = "ScanCount";
 static const char* jkTableScanPhysiPlanReverseScanCount = "ReverseScanCount";
@@ -732,7 +729,7 @@ static const char* jkTableScanPhysiPlanInterval = "Interval";
 static const char* jkTableScanPhysiPlanOffset = "Offset";
 static const char* jkTableScanPhysiPlanSliding = "Sliding";
 static const char* jkTableScanPhysiPlanIntervalUnit = "intervalUnit";
-static const char* jkTableScanPhysiPlanSlidingUnit  = "slidingUnit";
+static const char* jkTableScanPhysiPlanSlidingUnit = "slidingUnit";
 static int32_t physiTableScanNodeToJson(const void* pObj, SJson* pJson) {
  const STableScanPhysiNode* pNode = (const STableScanPhysiNode*)pObj;
@@ -822,13 +819,9 @@ static int32_t jsonToPhysiTableScanNode(const SJson* pJson, void* pObj) {
  return code;
 }
-static int32_t physiStreamScanNodeToJson(const void* pObj, SJson* pJson) {
+static int32_t physiStreamScanNodeToJson(const void* pObj, SJson* pJson) { return physiScanNodeToJson(pObj, pJson); }
-  return physiScanNodeToJson(pObj, pJson);
-}
-static int32_t jsonToPhysiStreamScanNode(const SJson* pJson, void* pObj) {
+static int32_t jsonToPhysiStreamScanNode(const SJson* pJson, void* pObj) { return jsonToPhysiScanNode(pJson, pObj); }
-  return jsonToPhysiScanNode(pJson, pObj);
-}
 static const char* jkEndPointFqdn = "Fqdn";
 static const char* jkEndPointPort = "Port";
@@ -1178,7 +1171,7 @@ static const char* jkIntervalPhysiPlanInterval = "Interval";
 static const char* jkIntervalPhysiPlanOffset = "Offset";
 static const char* jkIntervalPhysiPlanSliding = "Sliding";
 static const char* jkIntervalPhysiPlanIntervalUnit = "intervalUnit";
-static const char* jkIntervalPhysiPlanSlidingUnit  = "slidingUnit";
+static const char* jkIntervalPhysiPlanSlidingUnit = "slidingUnit";
 static const char* jkIntervalPhysiPlanFill = "Fill";
 static int32_t physiIntervalNodeToJson(const void* pObj, SJson* pJson) {
@@ -1331,13 +1324,9 @@ static int32_t jsonToPhysicDataSinkNode(const SJson* pJson, void* pObj) {
  return jsonToNodeObject(pJson, jkDataSinkInputDataBlockDesc, (SNode**)&pNode->pInputDataBlockDesc);
 }
-static int32_t physiDispatchNodeToJson(const void* pObj, SJson* pJson) {
+static int32_t physiDispatchNodeToJson(const void* pObj, SJson* pJson) { return physicDataSinkNodeToJson(pObj, pJson); }
-  return physicDataSinkNodeToJson(pObj, pJson);
-}
-static int32_t jsonToPhysiDispatchNode(const SJson* pJson, void* pObj) {
+static int32_t jsonToPhysiDispatchNode(const SJson* pJson, void* pObj) { return jsonToPhysicDataSinkNode(pJson, pObj); }
-  return jsonToPhysicDataSinkNode(pJson, pObj);
-}
 static const char* jkSubplanIdQueryId = "QueryId";
 static const char* jkSubplanIdGroupId = "GroupId";
@@ -1663,7 +1652,7 @@ static int32_t jsonToColumnNode(const SJson* pJson, void* pObj) {
  return code;
 }
-static const char* jkValueGenByCalc = "GenByCalc";
+static const char* jkValueLiteralSize = "LiteralSize";
 static const char* jkValueLiteral = "Literal";
 static const char* jkValueDuration = "Duration";
 static const char* jkValueTranslate = "Translate";
@@ -1709,7 +1698,7 @@ static int32_t datumToJson(const void* pObj, SJson* pJson) {
      break;
  }
-  return code ;
+  return code;
 }
 static int32_t valueNodeToJson(const void* pObj, SJson* pJson) {
@@ -1717,9 +1706,9 @@ static int32_t valueNodeToJson(const void* pObj, SJson* pJson) {
  int32_t code = exprNodeToJson(pObj, pJson);
  if (TSDB_CODE_SUCCESS == code) {
-    code = tjsonAddBoolToObject(pJson, jkValueGenByCalc, pNode->genByCalc);
+    code = tjsonAddIntegerToObject(pJson, jkValueLiteralSize, NULL != pNode->literal ? strlen(pNode->literal) : 0);
  }
-  if (TSDB_CODE_SUCCESS == code && !pNode->genByCalc) {
+  if (TSDB_CODE_SUCCESS == code && NULL != pNode->literal) {
    code = tjsonAddStringToObject(pJson, jkValueLiteral, pNode->literal);
  }
  if (TSDB_CODE_SUCCESS == code) {
@@ -1789,10 +1778,11 @@ static int32_t jsonToValueNode(const SJson* pJson, void* pObj) {
  SValueNode* pNode = (SValueNode*)pObj;
  int32_t code = jsonToExprNode(pJson, pObj);
+  int32_t literalSize = 0;
  if (TSDB_CODE_SUCCESS == code) {
-    code = tjsonGetBoolValue(pJson, jkValueGenByCalc, &pNode->genByCalc);
+    code = tjsonGetIntValue(pJson, jkValueLiteralSize, &literalSize);
  }
-  if (TSDB_CODE_SUCCESS == code && !pNode->genByCalc) {
+  if (TSDB_CODE_SUCCESS == code && literalSize > 0) {
    code = tjsonDupStringValue(pJson, jkValueLiteral, &pNode->literal);
  }
  if (TSDB_CODE_SUCCESS == code) {
@@ -2014,7 +2004,8 @@ static int32_t vgroupsInfoToJson(const void* pObj, SJson* pJson) {
  int32_t code = tjsonAddIntegerToObject(pJson, jkVgroupsInfoNum, pNode->numOfVgroups);
  if (TSDB_CODE_SUCCESS == code) {
-    code = tjsonAddArray(pJson, jkVgroupsInfoVgroups, vgroupInfoToJson, pNode->vgroups, sizeof(SVgroupInfo), pNode->numOfVgroups);
+    code = tjsonAddArray(pJson, jkVgroupsInfoVgroups, vgroupInfoToJson, pNode->vgroups, sizeof(SVgroupInfo),
+                         pNode->numOfVgroups);
  }
  return code;
@@ -2380,6 +2371,7 @@ static const char* jkSelectStmtOrderBy = "OrderBy";
 static const char* jkSelectStmtLimit = "Limit";
 static const char* jkSelectStmtSlimit = "Slimit";
 static const char* jkSelectStmtStmtName = "StmtName";
+static const char* jkSelectStmtHasAggFuncs = "HasAggFuncs";
 static int32_t selectStmtTojson(const void* pObj, SJson* pJson) {
  const SSelectStmt* pNode = (const SSelectStmt*)pObj;
@@ -2418,6 +2410,9 @@ static int32_t selectStmtTojson(const void* pObj, SJson* pJson) {
  if (TSDB_CODE_SUCCESS == code) {
    code = tjsonAddStringToObject(pJson, jkSelectStmtStmtName, pNode->stmtName);
  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonAddBoolToObject(pJson, jkSelectStmtHasAggFuncs, pNode->hasAggFuncs);
+  }
  return code;
 }
@@ -2459,6 +2454,9 @@ static int32_t jsonToSelectStmt(const SJson* pJson, void* pObj) {
  if (TSDB_CODE_SUCCESS == code) {
    code = tjsonGetStringValue(pJson, jkSelectStmtStmtName, pNode->stmtName);
  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonGetBoolValue(pJson, jkSelectStmtHasAggFuncs, &pNode->hasAggFuncs);
+  }
  return code;
 }
@@ -2659,10 +2657,10 @@ static int32_t jsonToSpecificNode(const SJson* pJson, void* pObj) {
      return jsonToPhysiTagScanNode(pJson, pObj);
    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN:
      return jsonToPhysiTableScanNode(pJson, pObj);
-   case QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN:
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN:
      return jsonToPhysiStreamScanNode(pJson, pObj);
    case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN:
-      return jsonToPhysiSysTableScanNode(pJson, pObj);  
+      return jsonToPhysiSysTableScanNode(pJson, pObj);
    case QUERY_NODE_PHYSICAL_PLAN_PROJECT:
      return jsonToPhysiProjectNode(pJson, pObj);
    case QUERY_NODE_PHYSICAL_PLAN_JOIN:

--- a/source/libs/nodes/src/nodesEqualFuncs.c
+++ b/source/libs/nodes/src/nodesEqualFuncs.c
@@ -15,32 +15,27 @@
 #include "querynodes.h"
-#define COMPARE_SCALAR_FIELD(fldname) \
+#define COMPARE_SCALAR_FIELD(fldname)           \
-	do { \
+  do {                                          \
-		if (a->fldname != b->fldname) \
+    if (a->fldname != b->fldname) return false; \
-			return false; \
+  } while (0)
-	} while (0)
+#define COMPARE_STRING(a, b) (((a) != NULL && (b) != NULL) ? (strcmp(a, b) == 0) : (a) == (b))
-#define COMPARE_STRING(a, b)	\
-	(((a) != NULL && (b) != NULL) ? (strcmp(a, b) == 0) : (a) == (b))
+#define COMPARE_STRING_FIELD(fldname)                          \
+  do {                                                         \
-#define COMPARE_STRING_FIELD(fldname) \
+    if (!COMPARE_STRING(a->fldname, b->fldname)) return false; \
-	do { \
+  } while (0)
-		if (!COMPARE_STRING(a->fldname, b->fldname)) \
-			return false; \
+#define COMPARE_NODE_FIELD(fldname)                            \
-	} while (0)
+  do {                                                         \
+    if (!nodesEqualNode(a->fldname, b->fldname)) return false; \
-#define COMPARE_NODE_FIELD(fldname) \
+  } while (0)
-	do { \
-		if (!nodesEqualNode(a->fldname, b->fldname)) \
+#define COMPARE_NODE_LIST_FIELD(fldname)                          \
-			return false; \
+  do {                                                            \
-	} while (0)
+    if (!nodeNodeListEqual(a->fldname, b->fldname)) return false; \
+  } while (0)
-#define COMPARE_NODE_LIST_FIELD(fldname) \
-	do { \
-		if (!nodeNodeListEqual(a->fldname, b->fldname)) \
-			return false; \
-	} while (0)
 static bool nodeNodeListEqual(const SNodeList* a, const SNodeList* b) {
  if (a == b) {
@@ -55,7 +50,7 @@ static bool nodeNodeListEqual(const SNodeList* a, const SNodeList* b) {
    return false;
  }
-  SNode* na, *nb;
+  SNode *na, *nb;
  FORBOTH(na, a, nb, b) {
    if (!nodesEqualNode(na, nb)) {
      return false;
@@ -125,7 +120,7 @@ bool nodesEqualNode(const SNodeptr a, const SNodeptr b) {
    case QUERY_NODE_GROUPING_SET:
    case QUERY_NODE_ORDER_BY_EXPR:
    case QUERY_NODE_LIMIT:
-      return false; // todo
+      return false;  // todo
    default:
      break;
  }

--- a/source/libs/nodes/src/nodesToSQLFuncs.c
+++ b/source/libs/nodes/src/nodesToSQLFuncs.c
@@ -21,9 +21,35 @@
 #include "taoserror.h"
 #include "thash.h"
-char *gOperatorStr[] = {NULL, "+", "-", "*", "/", "%", "-", "&", "|", ">", ">=", "<", "<=", "=", "<>", 
+char *gOperatorStr[] = {NULL,
-                        "IN", "NOT IN", "LIKE", "NOT LIKE", "MATCH", "NMATCH", "IS NULL", "IS NOT NULL",
+                        "+",
-                        "IS TRUE", "IS FALSE", "IS UNKNOWN", "IS NOT TRUE", "IS NOT FALSE", "IS NOT UNKNOWN"};
+                        "-",
+                        "*",
+                        "/",
+                        "%",
+                        "-",
+                        "&",
+                        "|",
+                        ">",
+                        ">=",
+                        "<",
+                        "<=",
+                        "=",
+                        "<>",
+                        "IN",
+                        "NOT IN",
+                        "LIKE",
+                        "NOT LIKE",
+                        "MATCH",
+                        "NMATCH",
+                        "IS NULL",
+                        "IS NOT NULL",
+                        "IS TRUE",
+                        "IS FALSE",
+                        "IS UNKNOWN",
+                        "IS NOT TRUE",
+                        "IS NOT FALSE",
+                        "IS NOT UNKNOWN"};
 char *gLogicConditionStr[] = {"AND", "OR", "NOT"};
 int32_t nodesNodeToSQL(SNode *pNode, char *buf, int32_t bufSize, int32_t *len) {
@@ -33,36 +59,36 @@ int32_t nodesNodeToSQL(SNode *pNode, char *buf, int32_t bufSize, int32_t *len) {
      if (colNode->dbName[0]) {
        *len += snprintf(buf + *len, bufSize - *len, "`%s`.", colNode->dbName);
      }
      if (colNode->tableAlias[0]) {
        *len += snprintf(buf + *len, bufSize - *len, "`%s`.", colNode->tableAlias);
      } else if (colNode->tableName[0]) {
        *len += snprintf(buf + *len, bufSize - *len, "`%s`.", colNode->tableName);
      }
      if (colNode->tableAlias[0]) {
        *len += snprintf(buf + *len, bufSize - *len, "`%s`", colNode->colName);
      } else {
        *len += snprintf(buf + *len, bufSize - *len, "%s", colNode->colName);
      }
      return TSDB_CODE_SUCCESS;
    }
-    case QUERY_NODE_VALUE:{
+    case QUERY_NODE_VALUE: {
      SValueNode *colNode = (SValueNode *)pNode;
-      char *t = nodesGetStrValueFromNode(colNode);
+      char       *t = nodesGetStrValueFromNode(colNode);
      if (NULL == t) {
        nodesError("fail to get str value from valueNode");
        NODES_ERR_RET(TSDB_CODE_QRY_APP_ERROR);
      }
      *len += snprintf(buf + *len, bufSize - *len, "%s", t);
      taosMemoryFree(t);
      return TSDB_CODE_SUCCESS;
    }
    case QUERY_NODE_OPERATOR: {
-      SOperatorNode* pOpNode = (SOperatorNode*)pNode;
+      SOperatorNode *pOpNode = (SOperatorNode *)pNode;
      *len += snprintf(buf + *len, bufSize - *len, "(");
      if (pOpNode->pLeft) {
        NODES_ERR_RET(nodesNodeToSQL(pOpNode->pLeft, buf, bufSize, len));
@@ -72,24 +98,24 @@ int32_t nodesNodeToSQL(SNode *pNode, char *buf, int32_t bufSize, int32_t *len) {
        nodesError("unknown operation type:%d", pOpNode->opType);
        NODES_ERR_RET(TSDB_CODE_QRY_APP_ERROR);
      }
      *len += snprintf(buf + *len, bufSize - *len, " %s ", gOperatorStr[pOpNode->opType]);
      if (pOpNode->pRight) {
        NODES_ERR_RET(nodesNodeToSQL(pOpNode->pRight, buf, bufSize, len));
-      }    
+      }
      *len += snprintf(buf + *len, bufSize - *len, ")");
      return TSDB_CODE_SUCCESS;
    }
-    case QUERY_NODE_LOGIC_CONDITION:{
+    case QUERY_NODE_LOGIC_CONDITION: {
-      SLogicConditionNode* pLogicNode = (SLogicConditionNode*)pNode;
+      SLogicConditionNode *pLogicNode = (SLogicConditionNode *)pNode;
-      SNode* node = NULL;
+      SNode               *node = NULL;
-      bool first = true;
+      bool                 first = true;
      *len += snprintf(buf + *len, bufSize - *len, "(");
      FOREACH(node, pLogicNode->pParameterList) {
        if (!first) {
          *len += snprintf(buf + *len, bufSize - *len, " %s ", gLogicConditionStr[pLogicNode->condType]);
@@ -102,13 +128,13 @@ int32_t nodesNodeToSQL(SNode *pNode, char *buf, int32_t bufSize, int32_t *len) {
      return TSDB_CODE_SUCCESS;
    }
-    case QUERY_NODE_FUNCTION:{
+    case QUERY_NODE_FUNCTION: {
-      SFunctionNode* pFuncNode = (SFunctionNode*)pNode;
+      SFunctionNode *pFuncNode = (SFunctionNode *)pNode;
-      SNode* node = NULL;
+      SNode         *node = NULL;
-      bool first = true;
+      bool           first = true;
      *len += snprintf(buf + *len, bufSize - *len, "%s(", pFuncNode->functionName);
      FOREACH(node, pFuncNode->pParameterList) {
        if (!first) {
          *len += snprintf(buf + *len, bufSize - *len, ", ");
@@ -121,13 +147,13 @@ int32_t nodesNodeToSQL(SNode *pNode, char *buf, int32_t bufSize, int32_t *len) {
      return TSDB_CODE_SUCCESS;
    }
-    case QUERY_NODE_NODE_LIST:{
+    case QUERY_NODE_NODE_LIST: {
-      SNodeListNode* pListNode = (SNodeListNode *)pNode;
+      SNodeListNode *pListNode = (SNodeListNode *)pNode;
-      SNode* node = NULL;
+      SNode         *node = NULL;
-      bool first = true;
+      bool           first = true;
      *len += snprintf(buf + *len, bufSize - *len, "(");
      FOREACH(node, pListNode->pNodeList) {
        if (!first) {
          *len += snprintf(buf + *len, bufSize - *len, ", ");
@@ -135,7 +161,7 @@ int32_t nodesNodeToSQL(SNode *pNode, char *buf, int32_t bufSize, int32_t *len) {
        NODES_ERR_RET(nodesNodeToSQL(node, buf, bufSize, len));
        first = false;
      }
      *len += snprintf(buf + *len, bufSize - *len, ")");
      return TSDB_CODE_SUCCESS;
@@ -143,7 +169,7 @@ int32_t nodesNodeToSQL(SNode *pNode, char *buf, int32_t bufSize, int32_t *len) {
    default:
      break;
  }
  nodesError("nodesNodeToSQL unknown node = %s", nodesNodeName(pNode->type));
  NODES_RET(TSDB_CODE_QRY_APP_ERROR);
 }
--- a/source/libs/nodes/src/nodesTraverseFuncs.c
+++ b/source/libs/nodes/src/nodesTraverseFuncs.c
@@ -13,8 +13,8 @@
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
-#include "querynodes.h"
 #include "plannodes.h"
+#include "querynodes.h"
 typedef enum ETraversalOrder {
  TRAVERSAL_PREORDER = 1,
@@ -29,7 +29,8 @@ static EDealRes walkExprs(SNodeList* pNodeList, ETraversalOrder order, FNodeWalk
 static EDealRes walkPhysiPlan(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext);
 static EDealRes walkPhysiPlans(SNodeList* pNodeList, ETraversalOrder order, FNodeWalker walker, void* pContext);
-static EDealRes walkNode(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext, FNodeDispatcher dispatcher) {
+static EDealRes walkNode(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext,
+                         FNodeDispatcher dispatcher) {
  if (NULL == pNode) {
    return DEAL_RES_CONTINUE;
  }
@@ -77,7 +78,7 @@ static EDealRes dispatchExpr(SNode* pNode, ETraversalOrder order, FNodeWalker wa
      break;
    case QUERY_NODE_REAL_TABLE:
    case QUERY_NODE_TEMP_TABLE:
-      break; // todo
+      break;  // todo
    case QUERY_NODE_JOIN_TABLE: {
      SJoinTableNode* pJoinTableNode = (SJoinTableNode*)pNode;
      res = walkExpr(pJoinTableNode->pLeft, order, walker, pContext);
@@ -217,7 +218,7 @@ static EDealRes rewriteExpr(SNode** pRawNode, ETraversalOrder order, FNodeRewrit
      break;
    case QUERY_NODE_REAL_TABLE:
    case QUERY_NODE_TEMP_TABLE:
-      break; // todo
+      break;  // todo
    case QUERY_NODE_JOIN_TABLE: {
      SJoinTableNode* pJoinTableNode = (SJoinTableNode*)pNode;
      res = rewriteExpr(&(pJoinTableNode->pLeft), order, rewriter, pContext);
@@ -339,7 +340,7 @@ void nodesWalkSelectStmt(SSelectStmt* pSelect, ESqlClause clause, FNodeWalker wa
    case SQL_CLAUSE_DISTINCT:
      nodesWalkExprs(pSelect->pOrderByList, walker, pContext);
    case SQL_CLAUSE_ORDER_BY:
-      nodesWalkExprs(pSelect->pProjectionList, walker, pContext);      
+      nodesWalkExprs(pSelect->pProjectionList, walker, pContext);
    default:
      break;
  }
@@ -368,7 +369,7 @@ void nodesRewriteSelectStmt(SSelectStmt* pSelect, ESqlClause clause, FNodeRewrit
    case SQL_CLAUSE_DISTINCT:
      nodesRewriteExprs(pSelect->pOrderByList, rewriter, pContext);
    case SQL_CLAUSE_ORDER_BY:
-      nodesRewriteExprs(pSelect->pProjectionList, rewriter, pContext);      
+      nodesRewriteExprs(pSelect->pProjectionList, rewriter, pContext);
    default:
      break;
  }
@@ -395,7 +396,8 @@ static EDealRes walkScanPhysi(SScanPhysiNode* pScan, ETraversalOrder order, FNod
  return res;
 }
-static EDealRes walkTableScanPhysi(STableScanPhysiNode* pScan, ETraversalOrder order, FNodeWalker walker, void* pContext) {
+static EDealRes walkTableScanPhysi(STableScanPhysiNode* pScan, ETraversalOrder order, FNodeWalker walker,
+                                   void* pContext) {
  EDealRes res = walkScanPhysi((SScanPhysiNode*)pScan, order, walker, pContext);
  if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
    res = walkPhysiPlans(pScan->pDynamicScanFuncs, order, walker, pContext);

--- a/source/libs/nodes/src/nodesUtilFuncs.c
+++ b/source/libs/nodes/src/nodesUtilFuncs.c
@@ -97,7 +97,7 @@ SNodeptr nodesMakeNode(ENodeType type) {
    case QUERY_NODE_CREATE_DATABASE_STMT:
      return makeNode(type, sizeof(SCreateDatabaseStmt));
    case QUERY_NODE_DROP_DATABASE_STMT:
-      return makeNode(type, sizeof(SDropDatabaseStmt));    
+      return makeNode(type, sizeof(SDropDatabaseStmt));
    case QUERY_NODE_ALTER_DATABASE_STMT:
      return makeNode(type, sizeof(SAlterDatabaseStmt));
    case QUERY_NODE_CREATE_TABLE_STMT:
@@ -298,9 +298,7 @@ static void destroyScanPhysiNode(SScanPhysiNode* pNode) {
  nodesDestroyList(pNode->pScanCols);
 }
-static void destroyDataSinkNode(SDataSinkNode* pNode) {
+static void destroyDataSinkNode(SDataSinkNode* pNode) { nodesDestroyNode(pNode->pInputDataBlockDesc); }
-  nodesDestroyNode(pNode->pInputDataBlockDesc);
-}
 void nodesDestroyNode(SNodeptr pNode) {
  if (NULL == pNode) {
@@ -308,7 +306,7 @@ void nodesDestroyNode(SNodeptr pNode) {
  }
  switch (nodeType(pNode)) {
-    case QUERY_NODE_COLUMN: // pProjectRef is weak reference, no need to release
+    case QUERY_NODE_COLUMN:  // pProjectRef is weak reference, no need to release
      break;
    case QUERY_NODE_VALUE: {
      SValueNode* pValue = (SValueNode*)pNode;
@@ -352,7 +350,7 @@ void nodesDestroyNode(SNodeptr pNode) {
    case QUERY_NODE_ORDER_BY_EXPR:
      nodesDestroyNode(((SOrderByExprNode*)pNode)->pExpr);
      break;
-    case QUERY_NODE_LIMIT: // no pointer field
+    case QUERY_NODE_LIMIT:  // no pointer field
      break;
    case QUERY_NODE_STATE_WINDOW:
      nodesDestroyNode(((SStateWindowNode*)pNode)->pExpr);
@@ -387,9 +385,9 @@ void nodesDestroyNode(SNodeptr pNode) {
    case QUERY_NODE_DATABLOCK_DESC:
      nodesDestroyList(((SDataBlockDescNode*)pNode)->pSlots);
      break;
-    case QUERY_NODE_SLOT_DESC:         // no pointer field
+    case QUERY_NODE_SLOT_DESC:          // no pointer field
-    case QUERY_NODE_COLUMN_DEF:        // no pointer field
+    case QUERY_NODE_COLUMN_DEF:         // no pointer field
-    case QUERY_NODE_DOWNSTREAM_SOURCE: // no pointer field
+    case QUERY_NODE_DOWNSTREAM_SOURCE:  // no pointer field
      break;
    case QUERY_NODE_DATABASE_OPTIONS:
      nodesDestroyList(((SDatabaseOptions*)pNode)->pRetentions);
@@ -436,7 +434,7 @@ void nodesDestroyNode(SNodeptr pNode) {
    case QUERY_NODE_CREATE_DATABASE_STMT:
      nodesDestroyNode(((SCreateDatabaseStmt*)pNode)->pOptions);
      break;
-    case QUERY_NODE_DROP_DATABASE_STMT: // no pointer field
+    case QUERY_NODE_DROP_DATABASE_STMT:  // no pointer field
      break;
    case QUERY_NODE_ALTER_DATABASE_STMT:
      nodesDestroyNode(((SAlterDatabaseStmt*)pNode)->pOptions);
@@ -457,12 +455,12 @@ void nodesDestroyNode(SNodeptr pNode) {
    case QUERY_NODE_CREATE_MULTI_TABLE_STMT:
      nodesDestroyList(((SCreateMultiTableStmt*)pNode)->pSubTables);
      break;
-    case QUERY_NODE_DROP_TABLE_CLAUSE: // no pointer field
+    case QUERY_NODE_DROP_TABLE_CLAUSE:  // no pointer field
      break;
    case QUERY_NODE_DROP_TABLE_STMT:
      nodesDestroyNode(((SDropTableStmt*)pNode)->pTables);
      break;
-    case QUERY_NODE_DROP_SUPER_TABLE_STMT: // no pointer field
+    case QUERY_NODE_DROP_SUPER_TABLE_STMT:  // no pointer field
      break;
    case QUERY_NODE_ALTER_TABLE_STMT: {
      SAlterTableStmt* pStmt = (SAlterTableStmt*)pNode;
@@ -470,13 +468,13 @@ void nodesDestroyNode(SNodeptr pNode) {
      nodesDestroyNode(pStmt->pVal);
      break;
    }
-    case QUERY_NODE_CREATE_USER_STMT:  // no pointer field
+    case QUERY_NODE_CREATE_USER_STMT:   // no pointer field
-    case QUERY_NODE_ALTER_USER_STMT:   // no pointer field
+    case QUERY_NODE_ALTER_USER_STMT:    // no pointer field
-    case QUERY_NODE_DROP_USER_STMT:    // no pointer field
+    case QUERY_NODE_DROP_USER_STMT:     // no pointer field
-    case QUERY_NODE_USE_DATABASE_STMT: // no pointer field
+    case QUERY_NODE_USE_DATABASE_STMT:  // no pointer field
-    case QUERY_NODE_CREATE_DNODE_STMT: // no pointer field
+    case QUERY_NODE_CREATE_DNODE_STMT:  // no pointer field
-    case QUERY_NODE_DROP_DNODE_STMT:   // no pointer field
+    case QUERY_NODE_DROP_DNODE_STMT:    // no pointer field
-    case QUERY_NODE_ALTER_DNODE_STMT:  // no pointer field
+    case QUERY_NODE_ALTER_DNODE_STMT:   // no pointer field
      break;
    case QUERY_NODE_CREATE_INDEX_STMT: {
      SCreateIndexStmt* pStmt = (SCreateIndexStmt*)pNode;
@@ -484,15 +482,15 @@ void nodesDestroyNode(SNodeptr pNode) {
      nodesDestroyList(pStmt->pCols);
      break;
    }
-    case QUERY_NODE_DROP_INDEX_STMT:   // no pointer field
+    case QUERY_NODE_DROP_INDEX_STMT:    // no pointer field
-    case QUERY_NODE_CREATE_QNODE_STMT: // no pointer field
+    case QUERY_NODE_CREATE_QNODE_STMT:  // no pointer field
-    case QUERY_NODE_DROP_QNODE_STMT:   // no pointer field
+    case QUERY_NODE_DROP_QNODE_STMT:    // no pointer field
      break;
    case QUERY_NODE_CREATE_TOPIC_STMT:
      nodesDestroyNode(((SCreateTopicStmt*)pNode)->pQuery);
      break;
-    case QUERY_NODE_DROP_TOPIC_STMT:  // no pointer field
+    case QUERY_NODE_DROP_TOPIC_STMT:   // no pointer field
-    case QUERY_NODE_ALTER_LOCAL_STMT: // no pointer field
+    case QUERY_NODE_ALTER_LOCAL_STMT:  // no pointer field
      break;
    case QUERY_NODE_SHOW_DATABASES_STMT:
    case QUERY_NODE_SHOW_TABLES_STMT:
@@ -658,7 +656,7 @@ void nodesDestroyNode(SNodeptr pNode) {
      SQueryPlan* pPlan = (SQueryPlan*)pNode;
      if (NULL != pPlan->pSubplans) {
        // only need to destroy the top-level subplans, because they will recurse to all the subplans below
-        bool first = true;
+        bool   first = true;
        SNode* pElement = NULL;
        FOREACH(pElement, pPlan->pSubplans) {
          if (first) {
@@ -866,7 +864,7 @@ void nodesClearList(SNodeList* pList) {
  taosMemoryFreeClear(pList);
 }
-void* nodesGetValueFromNode(SValueNode *pNode) {
+void* nodesGetValueFromNode(SValueNode* pNode) {
  switch (pNode->node.resType.type) {
    case TSDB_DATA_TYPE_BOOL:
      return (void*)&pNode->datum.b;
@@ -895,10 +893,10 @@ void* nodesGetValueFromNode(SValueNode *pNode) {
  return NULL;
 }
-char* nodesGetStrValueFromNode(SValueNode *pNode) {
+char* nodesGetStrValueFromNode(SValueNode* pNode) {
  switch (pNode->node.resType.type) {
    case TSDB_DATA_TYPE_BOOL: {
-      void *buf = taosMemoryMalloc(MAX_NUM_STR_SIZE);
+      void* buf = taosMemoryMalloc(MAX_NUM_STR_SIZE);
      if (NULL == buf) {
        return NULL;
      }
@@ -911,7 +909,7 @@ char* nodesGetStrValueFromNode(SValueNode *pNode) {
    case TSDB_DATA_TYPE_INT:
    case TSDB_DATA_TYPE_BIGINT:
    case TSDB_DATA_TYPE_TIMESTAMP: {
-      void *buf = taosMemoryMalloc(MAX_NUM_STR_SIZE);
+      void* buf = taosMemoryMalloc(MAX_NUM_STR_SIZE);
      if (NULL == buf) {
        return NULL;
      }
@@ -923,7 +921,7 @@ char* nodesGetStrValueFromNode(SValueNode *pNode) {
    case TSDB_DATA_TYPE_USMALLINT:
    case TSDB_DATA_TYPE_UINT:
    case TSDB_DATA_TYPE_UBIGINT: {
-      void *buf = taosMemoryMalloc(MAX_NUM_STR_SIZE);
+      void* buf = taosMemoryMalloc(MAX_NUM_STR_SIZE);
      if (NULL == buf) {
        return NULL;
      }
@@ -933,7 +931,7 @@ char* nodesGetStrValueFromNode(SValueNode *pNode) {
    }
    case TSDB_DATA_TYPE_FLOAT:
    case TSDB_DATA_TYPE_DOUBLE: {
-      void *buf = taosMemoryMalloc(MAX_NUM_STR_SIZE);
+      void* buf = taosMemoryMalloc(MAX_NUM_STR_SIZE);
      if (NULL == buf) {
        return NULL;
      }
@@ -945,7 +943,7 @@ char* nodesGetStrValueFromNode(SValueNode *pNode) {
    case TSDB_DATA_TYPE_VARCHAR:
    case TSDB_DATA_TYPE_VARBINARY: {
      int32_t bufSize = varDataLen(pNode->datum.p) + 2 + 1;
-      void *buf = taosMemoryMalloc(bufSize);
+      void*   buf = taosMemoryMalloc(bufSize);
      if (NULL == buf) {
        return NULL;
      }
@@ -962,7 +960,8 @@ char* nodesGetStrValueFromNode(SValueNode *pNode) {
 bool nodesIsExprNode(const SNode* pNode) {
  ENodeType type = nodeType(pNode);
-  return (QUERY_NODE_COLUMN == type || QUERY_NODE_VALUE == type || QUERY_NODE_OPERATOR == type || QUERY_NODE_FUNCTION == type);
+  return (QUERY_NODE_COLUMN == type || QUERY_NODE_VALUE == type || QUERY_NODE_OPERATOR == type ||
+          QUERY_NODE_FUNCTION == type);
 }
 bool nodesIsUnaryOp(const SOperatorNode* pOp) {
@@ -1037,23 +1036,19 @@ bool nodesIsJsonOp(const SOperatorNode* pOp) {
  return false;
 }
-bool nodesIsTimeorderQuery(const SNode* pQuery) {
+bool nodesIsTimeorderQuery(const SNode* pQuery) { return false; }
-  return false;
-}
-bool nodesIsTimelineQuery(const SNode* pQuery) {
+bool nodesIsTimelineQuery(const SNode* pQuery) { return false; }
-  return false;
-}
 typedef struct SCollectColumnsCxt {
-  int32_t errCode;
+  int32_t     errCode;
  const char* pTableAlias;
-  SNodeList* pCols;
+  SNodeList*  pCols;
-  SHashObj* pColHash;
+  SHashObj*   pColHash;
 } SCollectColumnsCxt;
 static EDealRes doCollect(SCollectColumnsCxt* pCxt, SColumnNode* pCol, SNode* pNode) {
-  char name[TSDB_TABLE_NAME_LEN + TSDB_COL_NAME_LEN];
+  char    name[TSDB_TABLE_NAME_LEN + TSDB_COL_NAME_LEN];
  int32_t len = 0;
  if ('\0' == pCol->tableAlias[0]) {
    len = sprintf(name, "%s", pCol->colName);
@@ -1086,11 +1081,10 @@ int32_t nodesCollectColumns(SSelectStmt* pSelect, ESqlClause clause, const char*
  }
  SCollectColumnsCxt cxt = {
-    .errCode = TSDB_CODE_SUCCESS,
+      .errCode = TSDB_CODE_SUCCESS,
-    .pTableAlias = pTableAlias,
+      .pTableAlias = pTableAlias,
-    .pCols = nodesMakeList(),
+      .pCols = nodesMakeList(),
-    .pColHash = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK)
+      .pColHash = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK)};
-  };
  if (NULL == cxt.pCols || NULL == cxt.pColHash) {
    return TSDB_CODE_OUT_OF_MEMORY;
  }
@@ -1110,9 +1104,9 @@ int32_t nodesCollectColumns(SSelectStmt* pSelect, ESqlClause clause, const char*
 }
 typedef struct SCollectFuncsCxt {
-  int32_t errCode;
+  int32_t         errCode;
  FFuncClassifier classifier;
-  SNodeList* pFuncs;
+  SNodeList*      pFuncs;
 } SCollectFuncsCxt;
 static EDealRes collectFuncs(SNode* pNode, void* pContext) {
@@ -1129,11 +1123,7 @@ int32_t nodesCollectFuncs(SSelectStmt* pSelect, FFuncClassifier classifier, SNod
    return TSDB_CODE_SUCCESS;
  }
-  SCollectFuncsCxt cxt = {
+  SCollectFuncsCxt cxt = {.errCode = TSDB_CODE_SUCCESS, .classifier = classifier, .pFuncs = nodesMakeList()};
-    .errCode = TSDB_CODE_SUCCESS,
-    .classifier = classifier,
-    .pFuncs = nodesMakeList()
-  };
  if (NULL == cxt.pFuncs) {
    return TSDB_CODE_OUT_OF_MEMORY;
  }
@@ -1148,12 +1138,11 @@ int32_t nodesCollectFuncs(SSelectStmt* pSelect, FFuncClassifier classifier, SNod
    nodesDestroyList(cxt.pFuncs);
    *pFuncs = NULL;
  }
  return TSDB_CODE_SUCCESS;
 }
+char* getFillModeString(EFillMode mode) {
-char *getFillModeString(EFillMode mode) {
  switch (mode) {
    case FILL_MODE_NONE:
      return "none";
@@ -1172,12 +1161,12 @@ char *getFillModeString(EFillMode mode) {
  }
 }
-char *nodesGetNameFromColumnNode(SNode *pNode) {
+char* nodesGetNameFromColumnNode(SNode* pNode) {
  if (NULL == pNode || QUERY_NODE_COLUMN != pNode->type) {
    return "NULL";
  }
-  return ((SColumnNode *)pNode)->colName;
+  return ((SColumnNode*)pNode)->colName;
 }
 int32_t nodesGetOutputNumFromSlotList(SNodeList* pSlots) {
@@ -1185,14 +1174,14 @@ int32_t nodesGetOutputNumFromSlotList(SNodeList* pSlots) {
    return 0;
  }
-  SNode* pNode = NULL;
+  SNode*  pNode = NULL;
  int32_t num = 0;
  FOREACH(pNode, pSlots) {
    if (QUERY_NODE_SLOT_DESC != pNode->type) {
      continue;
    }
-    SSlotDescNode *descNode = (SSlotDescNode *)pNode;
+    SSlotDescNode* descNode = (SSlotDescNode*)pNode;
    if (descNode->output) {
      ++num;
    }
@@ -1201,13 +1190,12 @@ int32_t nodesGetOutputNumFromSlotList(SNodeList* pSlots) {
  return num;
 }
 void valueNodeToVariant(const SValueNode* pNode, SVariant* pVal) {
  pVal->nType = pNode->node.resType.type;
  pVal->nLen = pNode->node.resType.bytes;
  switch (pNode->node.resType.type) {
    case TSDB_DATA_TYPE_NULL:
-        break;
+      break;
    case TSDB_DATA_TYPE_BOOL:
      pVal->i = pNode->datum.b;
      break;
@@ -1241,6 +1229,3 @@ void valueNodeToVariant(const SValueNode* pNode, SVariant* pVal) {
      break;
  }
 }
--- a/source/libs/nodes/test/nodesTest.cpp
+++ b/source/libs/nodes/test/nodesTest.cpp
@@ -20,42 +20,42 @@
 using namespace std;
 static EDealRes rewriterTest(SNode** pNode, void* pContext) {
-	EDealRes* pRes = (EDealRes*)pContext;
+  EDealRes* pRes = (EDealRes*)pContext;
-	if (QUERY_NODE_OPERATOR == nodeType(*pNode)) {
+  if (QUERY_NODE_OPERATOR == nodeType(*pNode)) {
-		SOperatorNode* pOp = (SOperatorNode*)(*pNode);
+    SOperatorNode* pOp = (SOperatorNode*)(*pNode);
-		if (QUERY_NODE_VALUE != nodeType(pOp->pLeft) || QUERY_NODE_VALUE != nodeType(pOp->pRight)) {
+    if (QUERY_NODE_VALUE != nodeType(pOp->pLeft) || QUERY_NODE_VALUE != nodeType(pOp->pRight)) {
-			*pRes = DEAL_RES_ERROR;
+      *pRes = DEAL_RES_ERROR;
-		}
+    }
-		SValueNode* pVal = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
+    SValueNode* pVal = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
-		string tmp = to_string(stoi(((SValueNode*)(pOp->pLeft))->literal) + stoi(((SValueNode*)(pOp->pRight))->literal));
+    string tmp = to_string(stoi(((SValueNode*)(pOp->pLeft))->literal) + stoi(((SValueNode*)(pOp->pRight))->literal));
-		pVal->literal = strdup(tmp.c_str());
+    pVal->literal = strdup(tmp.c_str());
-		nodesDestroyNode(*pNode);
+    nodesDestroyNode(*pNode);
-		*pNode = (SNode*)pVal;
+    *pNode = (SNode*)pVal;
-	}
+  }
-	return DEAL_RES_CONTINUE;
+  return DEAL_RES_CONTINUE;
 }
 TEST(NodesTest, traverseTest) {
-	SNode* pRoot = (SNode*)nodesMakeNode(QUERY_NODE_OPERATOR);
+  SNode*         pRoot = (SNode*)nodesMakeNode(QUERY_NODE_OPERATOR);
-	SOperatorNode* pOp = (SOperatorNode*)pRoot;
+  SOperatorNode* pOp = (SOperatorNode*)pRoot;
-	SOperatorNode* pLeft = (SOperatorNode*)nodesMakeNode(QUERY_NODE_OPERATOR);
+  SOperatorNode* pLeft = (SOperatorNode*)nodesMakeNode(QUERY_NODE_OPERATOR);
-	pLeft->pLeft = (SNode*)nodesMakeNode(QUERY_NODE_VALUE);
+  pLeft->pLeft = (SNode*)nodesMakeNode(QUERY_NODE_VALUE);
-	((SValueNode*)(pLeft->pLeft))->literal = strdup("10");
+  ((SValueNode*)(pLeft->pLeft))->literal = strdup("10");
-	pLeft->pRight = (SNode*)nodesMakeNode(QUERY_NODE_VALUE);
+  pLeft->pRight = (SNode*)nodesMakeNode(QUERY_NODE_VALUE);
-	((SValueNode*)(pLeft->pRight))->literal = strdup("5");
+  ((SValueNode*)(pLeft->pRight))->literal = strdup("5");
-	pOp->pLeft = (SNode*)pLeft;
+  pOp->pLeft = (SNode*)pLeft;
-	pOp->pRight = (SNode*)nodesMakeNode(QUERY_NODE_VALUE);
+  pOp->pRight = (SNode*)nodesMakeNode(QUERY_NODE_VALUE);
-	((SValueNode*)(pOp->pRight))->literal = strdup("3");
+  ((SValueNode*)(pOp->pRight))->literal = strdup("3");
-	EXPECT_EQ(nodeType(pRoot), QUERY_NODE_OPERATOR);
+  EXPECT_EQ(nodeType(pRoot), QUERY_NODE_OPERATOR);
-	EDealRes res = DEAL_RES_CONTINUE;
+  EDealRes res = DEAL_RES_CONTINUE;
-	nodesRewriteExprPostOrder(&pRoot, rewriterTest, &res);
+  nodesRewriteExprPostOrder(&pRoot, rewriterTest, &res);
-	EXPECT_EQ(res, DEAL_RES_CONTINUE);
+  EXPECT_EQ(res, DEAL_RES_CONTINUE);
-	EXPECT_EQ(nodeType(pRoot), QUERY_NODE_VALUE);
+  EXPECT_EQ(nodeType(pRoot), QUERY_NODE_VALUE);
-	EXPECT_EQ(string(((SValueNode*)pRoot)->literal), "18");
+  EXPECT_EQ(string(((SValueNode*)pRoot)->literal), "18");
 }
 int main(int argc, char* argv[]) {
-	testing::InitGoogleTest(&argc, argv);
+  testing::InitGoogleTest(&argc, argv);
-	return RUN_ALL_TESTS();
+  return RUN_ALL_TESTS();
 }
--- a/source/libs/parser/inc/parAst.h
+++ b/source/libs/parser/inc/parAst.h
@@ -21,18 +21,18 @@ extern "C" {
 #endif
 #include "cmdnodes.h"
-#include "parser.h"
 #include "parToken.h"
 #include "parUtil.h"
+#include "parser.h"
 #include "querynodes.h"
 typedef struct SAstCreateContext {
  SParseContext* pQueryCxt;
-  SMsgBuf msgBuf;
+  SMsgBuf        msgBuf;
-  bool notSupport;
+  bool           notSupport;
-  bool valid;
+  bool           valid;
-  SNode* pRootNode;
+  SNode*         pRootNode;
-  int16_t placeholderNo;
+  int16_t        placeholderNo;
 } SAstCreateContext;
 typedef enum EDatabaseOptionType {
@@ -67,9 +67,9 @@ typedef enum ETableOptionType {
 } ETableOptionType;
 typedef struct SAlterOption {
-  int32_t type;
+  int32_t     type;
  SValueNode* pVal;
-  SNodeList* pList;
+  SNodeList*  pList;
 } SAlterOption;
 extern SToken nil_token;
@@ -95,7 +95,6 @@ SNode* createOperatorNode(SAstCreateContext* pCxt, EOperatorType type, SNode* pL
 SNode* createBetweenAnd(SAstCreateContext* pCxt, SNode* pExpr, SNode* pLeft, SNode* pRight);
 SNode* createNotBetweenAnd(SAstCreateContext* pCxt, SNode* pExpr, SNode* pLeft, SNode* pRight);
 SNode* createFunctionNode(SAstCreateContext* pCxt, const SToken* pFuncName, SNodeList* pParameterList);
-SNode* createFunctionNodeNoArg(SAstCreateContext* pCxt, const SToken* pFuncName);
 SNode* createCastFunctionNode(SAstCreateContext* pCxt, SNode* pExpr, SDataType dt);
 SNode* createNodeListNode(SAstCreateContext* pCxt, SNodeList* pList);
 SNode* createNodeListNodeEx(SAstCreateContext* pCxt, SNode* p1, SNode* p2);
@@ -106,7 +105,8 @@ SNode* createLimitNode(SAstCreateContext* pCxt, const SToken* pLimit, const STok
 SNode* createOrderByExprNode(SAstCreateContext* pCxt, SNode* pExpr, EOrder order, ENullOrder nullOrder);
 SNode* createSessionWindowNode(SAstCreateContext* pCxt, SNode* pCol, SNode* pGap);
 SNode* createStateWindowNode(SAstCreateContext* pCxt, SNode* pExpr);
-SNode* createIntervalWindowNode(SAstCreateContext* pCxt, SNode* pInterval, SNode* pOffset, SNode* pSliding, SNode* pFill);
+SNode* createIntervalWindowNode(SAstCreateContext* pCxt, SNode* pInterval, SNode* pOffset, SNode* pSliding,
+                                SNode* pFill);
 SNode* createFillNode(SAstCreateContext* pCxt, EFillMode mode, SNode* pValues);
 SNode* createGroupingSetNode(SAstCreateContext* pCxt, SNode* pNode);
@@ -121,26 +121,30 @@ SNode* addLimitClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pLimit);
 SNode* createSelectStmt(SAstCreateContext* pCxt, bool isDistinct, SNodeList* pProjectionList, SNode* pTable);
 SNode* createSetOperator(SAstCreateContext* pCxt, ESetOperatorType type, SNode* pLeft, SNode* pRight);
-SNode* createDatabaseOptions(SAstCreateContext* pCxt);
+SNode*    createDatabaseOptions(SAstCreateContext* pCxt);
-SNode* setDatabaseAlterOption(SAstCreateContext* pCxt, SNode* pOptions, SAlterOption* pAlterOption);
+SNode*    setDatabaseAlterOption(SAstCreateContext* pCxt, SNode* pOptions, SAlterOption* pAlterOption);
-SNode* createCreateDatabaseStmt(SAstCreateContext* pCxt, bool ignoreExists, SToken* pDbName, SNode* pOptions);
+SNode*    createCreateDatabaseStmt(SAstCreateContext* pCxt, bool ignoreExists, SToken* pDbName, SNode* pOptions);
-SNode* createDropDatabaseStmt(SAstCreateContext* pCxt, bool ignoreNotExists, SToken* pDbName);
+SNode*    createDropDatabaseStmt(SAstCreateContext* pCxt, bool ignoreNotExists, SToken* pDbName);
-SNode* createAlterDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName, SNode* pOptions);
+SNode*    createAlterDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName, SNode* pOptions);
-SNode* createTableOptions(SAstCreateContext* pCxt);
+SNode*    createTableOptions(SAstCreateContext* pCxt);
-SNode* setTableAlterOption(SAstCreateContext* pCxt, SNode* pOptions, SAlterOption* pAlterOption);
+SNode*    setTableAlterOption(SAstCreateContext* pCxt, SNode* pOptions, SAlterOption* pAlterOption);
-SNode* createColumnDefNode(SAstCreateContext* pCxt, SToken* pColName, SDataType dataType, const SToken* pComment);
+SNode*    createColumnDefNode(SAstCreateContext* pCxt, SToken* pColName, SDataType dataType, const SToken* pComment);
 SDataType createDataType(uint8_t type);
 SDataType createVarLenDataType(uint8_t type, const SToken* pLen);
-SNode* createCreateTableStmt(SAstCreateContext* pCxt, bool ignoreExists, SNode* pRealTable, SNodeList* pCols, SNodeList* pTags, SNode* pOptions);
+SNode*    createCreateTableStmt(SAstCreateContext* pCxt, bool ignoreExists, SNode* pRealTable, SNodeList* pCols,
-SNode* createCreateSubTableClause(SAstCreateContext* pCxt, bool ignoreExists, SNode* pRealTable, SNode* pUseRealTable, SNodeList* pSpecificTags, SNodeList* pValsOfTags);
+                                SNodeList* pTags, SNode* pOptions);
+SNode* createCreateSubTableClause(SAstCreateContext* pCxt, bool ignoreExists, SNode* pRealTable, SNode* pUseRealTable,
+                                  SNodeList* pSpecificTags, SNodeList* pValsOfTags);
 SNode* createCreateMultiTableStmt(SAstCreateContext* pCxt, SNodeList* pSubTables);
 SNode* createDropTableClause(SAstCreateContext* pCxt, bool ignoreNotExists, SNode* pRealTable);
 SNode* createDropTableStmt(SAstCreateContext* pCxt, SNodeList* pTables);
 SNode* createDropSuperTableStmt(SAstCreateContext* pCxt, bool ignoreNotExists, SNode* pRealTable);
 SNode* createAlterTableOption(SAstCreateContext* pCxt, SNode* pRealTable, SNode* pOptions);
-SNode* createAlterTableAddModifyCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType, const SToken* pColName, SDataType dataType);
+SNode* createAlterTableAddModifyCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType,
+                                    const SToken* pColName, SDataType dataType);
 SNode* createAlterTableDropCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType, const SToken* pColName);
-SNode* createAlterTableRenameCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType, const SToken* pOldColName, const SToken* pNewColName);
+SNode* createAlterTableRenameCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType,
+                                 const SToken* pOldColName, const SToken* pNewColName);
 SNode* createAlterTableSetTag(SAstCreateContext* pCxt, SNode* pRealTable, const SToken* pTagName, SNode* pVal);
 SNode* createUseDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName);
 SNode* createShowStmt(SAstCreateContext* pCxt, ENodeType type, SNode* pDbName, SNode* pTbNamePattern);
@@ -152,13 +156,15 @@ SNode* createDropUserStmt(SAstCreateContext* pCxt, SToken* pUserName);
 SNode* createCreateDnodeStmt(SAstCreateContext* pCxt, const SToken* pFqdn, const SToken* pPort);
 SNode* createDropDnodeStmt(SAstCreateContext* pCxt, const SToken* pDnode);
 SNode* createAlterDnodeStmt(SAstCreateContext* pCxt, const SToken* pDnode, const SToken* pConfig, const SToken* pValue);
-SNode* createCreateIndexStmt(SAstCreateContext* pCxt, EIndexType type, bool ignoreExists, SToken* pIndexName, SToken* pTableName, SNodeList* pCols, SNode* pOptions);
+SNode* createCreateIndexStmt(SAstCreateContext* pCxt, EIndexType type, bool ignoreExists, SToken* pIndexName,
+                             SToken* pTableName, SNodeList* pCols, SNode* pOptions);
 SNode* createIndexOption(SAstCreateContext* pCxt, SNodeList* pFuncs, SNode* pInterval, SNode* pOffset, SNode* pSliding);
 SNode* createDropIndexStmt(SAstCreateContext* pCxt, bool ignoreNotExists, SToken* pIndexName, SToken* pTableName);
 SNode* createCreateComponentNodeStmt(SAstCreateContext* pCxt, ENodeType type, const SToken* pDnodeId);
 SNode* createDropComponentNodeStmt(SAstCreateContext* pCxt, ENodeType type, const SToken* pDnodeId);
 SNode* createTopicOptions(SAstCreateContext* pCxt);
-SNode* createCreateTopicStmt(SAstCreateContext* pCxt, bool ignoreExists, const SToken* pTopicName, SNode* pQuery, const SToken* pSubscribeDbName, SNode* pOptions);
+SNode* createCreateTopicStmt(SAstCreateContext* pCxt, bool ignoreExists, const SToken* pTopicName, SNode* pQuery,
+                             const SToken* pSubscribeDbName, SNode* pOptions);
 SNode* createDropTopicStmt(SAstCreateContext* pCxt, bool ignoreNotExists, const SToken* pTopicName);
 SNode* createAlterLocalStmt(SAstCreateContext* pCxt, const SToken* pConfig, const SToken* pValue);
 SNode* createDefaultExplainOptions(SAstCreateContext* pCxt);
@@ -168,10 +174,12 @@ SNode* createExplainStmt(SAstCreateContext* pCxt, bool analyze, SNode* pOptions,
 SNode* createDescribeStmt(SAstCreateContext* pCxt, SNode* pRealTable);
 SNode* createResetQueryCacheStmt(SAstCreateContext* pCxt);
 SNode* createCompactStmt(SAstCreateContext* pCxt, SNodeList* pVgroups);
-SNode* createCreateFunctionStmt(SAstCreateContext* pCxt, bool ignoreExists, bool aggFunc, const SToken* pFuncName, const SToken* pLibPath, SDataType dataType, int32_t bufSize);
+SNode* createCreateFunctionStmt(SAstCreateContext* pCxt, bool ignoreExists, bool aggFunc, const SToken* pFuncName,
+                                const SToken* pLibPath, SDataType dataType, int32_t bufSize);
 SNode* createDropFunctionStmt(SAstCreateContext* pCxt, const SToken* pFuncName);
 SNode* createStreamOptions(SAstCreateContext* pCxt);
-SNode* createCreateStreamStmt(SAstCreateContext* pCxt, bool ignoreExists, const SToken* pStreamName, SNode* pRealTable, SNode* pOptions, SNode* pQuery);
+SNode* createCreateStreamStmt(SAstCreateContext* pCxt, bool ignoreExists, const SToken* pStreamName, SNode* pRealTable,
+                              SNode* pOptions, SNode* pQuery);
 SNode* createDropStreamStmt(SAstCreateContext* pCxt, bool ignoreNotExists, const SToken* pStreamName);
 SNode* createKillStmt(SAstCreateContext* pCxt, ENodeType type, const SToken* pId);
 SNode* createMergeVgroupStmt(SAstCreateContext* pCxt, const SToken* pVgId1, const SToken* pVgId2);

--- a/source/libs/parser/inc/parInsertData.h
+++ b/source/libs/parser/inc/parInsertData.h
@@ -18,8 +18,8 @@
 #include "catalog.h"
 #include "os.h"
-#include "ttypes.h"
 #include "tname.h"
+#include "ttypes.h"
 #define IS_DATA_COL_ORDERED(spd) ((spd->orderStatus) == (int8_t)ORDER_STATUS_ORDERED)
@@ -52,8 +52,8 @@ typedef struct SParsedDataColInfo {
  uint16_t       flen;        // TODO: get from STSchema
  uint16_t       allNullLen;  // TODO: get from STSchema(base on SDataRow)
  uint16_t       extendedVarLen;
-  uint16_t       boundNullLen;    // bound column len with all NULL value(without VarDataOffsetT/SColIdx part)
+  uint16_t       boundNullLen;  // bound column len with all NULL value(without VarDataOffsetT/SColIdx part)
-  col_id_t      *boundColumns;    // bound column idx according to schema
+  col_id_t      *boundColumns;  // bound column idx according to schema
  SBoundColumn  *cols;
  SBoundIdxInfo *colIdxInfo;
  int8_t         orderStatus;  // bound columns
@@ -72,12 +72,13 @@ typedef struct STableDataBlocks {
  int32_t     numOfTables;  // number of tables in current submit block
  int32_t     rowSize;      // row size for current table
  uint32_t    nAllocSize;
-  uint32_t    headerSize;   // header for table info (uid, tid, submit metadata)
+  uint32_t    headerSize;  // header for table info (uid, tid, submit metadata)
  uint32_t    size;
-  STableMeta *pTableMeta;   // the tableMeta of current table, the table meta will be used during submit, keep a ref to avoid to be removed from cache
+  STableMeta *pTableMeta;  // the tableMeta of current table, the table meta will be used during submit, keep a ref to
-  char       *pData;
+                           // avoid to be removed from cache
-  bool        cloned;
+  char              *pData;
-  int32_t     createTbReqLen;
+  bool               cloned;
+  int32_t            createTbReqLen;
  SParsedDataColInfo boundColumnInfo;
  SRowBuilder        rowBuilder;
 } STableDataBlocks;
@@ -89,8 +90,8 @@ static FORCE_INLINE int32_t getExtendedRowSize(STableDataBlocks *pBlock) {
         (int32_t)TD_BITMAP_BYTES(pTableInfo->numOfColumns - 1);
 }
-static FORCE_INLINE void getSTSRowAppendInfo(uint8_t rowType, SParsedDataColInfo *spd, col_id_t idx,
+static FORCE_INLINE void getSTSRowAppendInfo(uint8_t rowType, SParsedDataColInfo *spd, col_id_t idx, int32_t *toffset,
-                                             int32_t *toffset, col_id_t *colIdx) {
+                                             col_id_t *colIdx) {
  col_id_t schemaIdx = 0;
  if (IS_DATA_COL_ORDERED(spd)) {
    schemaIdx = spd->boundColumns[idx] - PRIMARYKEY_TIMESTAMP_COL_ID;
@@ -114,8 +115,9 @@ static FORCE_INLINE void getSTSRowAppendInfo(uint8_t rowType, SParsedDataColInfo
  }
 }
-static FORCE_INLINE int32_t setBlockInfo(SSubmitBlk *pBlocks, STableDataBlocks* dataBuf, int32_t numOfRows) {
+static FORCE_INLINE int32_t setBlockInfo(SSubmitBlk *pBlocks, STableDataBlocks *dataBuf, int32_t numOfRows) {
-  pBlocks->suid = (TSDB_NORMAL_TABLE == dataBuf->pTableMeta->tableType ? dataBuf->pTableMeta->uid : dataBuf->pTableMeta->suid);
+  pBlocks->suid =
+      (TSDB_NORMAL_TABLE == dataBuf->pTableMeta->tableType ? dataBuf->pTableMeta->uid : dataBuf->pTableMeta->suid);
  pBlocks->uid = dataBuf->pTableMeta->uid;
  pBlocks->sversion = dataBuf->pTableMeta->sversion;
  pBlocks->schemaLen = dataBuf->createTbReqLen;
@@ -131,14 +133,15 @@ static FORCE_INLINE int32_t setBlockInfo(SSubmitBlk *pBlocks, STableDataBlocks*
 int32_t schemaIdxCompar(const void *lhs, const void *rhs);
 int32_t boundIdxCompar(const void *lhs, const void *rhs);
 void    setBoundColumnInfo(SParsedDataColInfo *pColList, SSchema *pSchema, col_id_t numOfCols);
-void destroyBlockArrayList(SArray* pDataBlockList);
+void    destroyBlockArrayList(SArray *pDataBlockList);
-void destroyBlockHashmap(SHashObj* pDataBlockHash);
+void    destroyBlockHashmap(SHashObj *pDataBlockHash);
-int  initRowBuilder(SRowBuilder *pBuilder, int16_t schemaVer, SParsedDataColInfo *pColInfo);
+int     initRowBuilder(SRowBuilder *pBuilder, int16_t schemaVer, SParsedDataColInfo *pColInfo);
-int32_t allocateMemIfNeed(STableDataBlocks *pDataBlock, int32_t rowSize, int32_t * numOfRows);
+int32_t allocateMemIfNeed(STableDataBlocks *pDataBlock, int32_t rowSize, int32_t *numOfRows);
-int32_t getDataBlockFromList(SHashObj* pHashList, int64_t id, int32_t size, int32_t startOffset, int32_t rowSize,
+int32_t getDataBlockFromList(SHashObj *pHashList, int64_t id, int32_t size, int32_t startOffset, int32_t rowSize,
-    const STableMeta* pTableMeta, STableDataBlocks** dataBlocks, SArray* pBlockList, SVCreateTbReq* pCreateTbReq);
+                             const STableMeta *pTableMeta, STableDataBlocks **dataBlocks, SArray *pBlockList,
-int32_t mergeTableDataBlocks(SHashObj* pHashObj, uint8_t payloadType, SArray** pVgDataBlocks);
+                             SVCreateTbReq *pCreateTbReq);
-int32_t buildCreateTbMsg(STableDataBlocks* pBlocks, SVCreateTbReq* pCreateTbReq);
+int32_t mergeTableDataBlocks(SHashObj *pHashObj, uint8_t payloadType, SArray **pVgDataBlocks);
+int32_t buildCreateTbMsg(STableDataBlocks *pBlocks, SVCreateTbReq *pCreateTbReq);
 int32_t allocateMemForSize(STableDataBlocks *pDataBlock, int32_t allSize);
 #endif  // TDENGINE_DATABLOCKMGT_H
--- a/source/libs/parser/inc/parInt.h
+++ b/source/libs/parser/inc/parInt.h
@@ -20,9 +20,9 @@
 extern "C" {
 #endif
-#include "parser.h"
 #include "parToken.h"
 #include "parUtil.h"
+#include "parser.h"
 int32_t parseInsertSql(SParseContext* pContext, SQuery** pQuery);
 int32_t parse(SParseContext* pParseCxt, SQuery** pQuery);

--- a/source/libs/parser/inc/parToken.h
+++ b/source/libs/parser/inc/parToken.h
@@ -20,6 +20,8 @@
 extern "C" {
 #endif
+#include "os.h"
 #include "ttokendef.h"
 // used to denote the minimum unite in sql parsing
@@ -35,7 +37,7 @@ typedef struct SToken {
 * @return
 */
 #define isNumber(tk) \
-((tk)->type == TK_NK_INTEGER || (tk)->type == TK_NK_FLOAT || (tk)->type == TK_NK_HEX || (tk)->type == TK_NK_BIN)
+  ((tk)->type == TK_NK_INTEGER || (tk)->type == TK_NK_FLOAT || (tk)->type == TK_NK_HEX || (tk)->type == TK_NK_BIN)
 /**
 * tokenizer for sql string
@@ -68,12 +70,12 @@ bool taosIsKeyWordToken(const char *z, int32_t len);
 * @param   pToken
 * @return  token type, if it is not a number, TK_NK_ILLEGAL will return
 */
-static FORCE_INLINE int32_t tGetNumericStringType(const SToken* pToken) {
+static FORCE_INLINE int32_t tGetNumericStringType(const SToken *pToken) {
-  const char* z = pToken->z;
+  const char *z = pToken->z;
-  int32_t type = TK_NK_ILLEGAL;
+  int32_t     type = TK_NK_ILLEGAL;
  uint32_t i = 0;
-  for(; i < pToken->n; ++i) {
+  for (; i < pToken->n; ++i) {
    switch (z[i]) {
      case '+':
      case '-': {
@@ -86,7 +88,7 @@ static FORCE_INLINE int32_t tGetNumericStringType(const SToken* pToken) {
         * .123
         * .123e4
         */
-        if (!isdigit(z[i+1])) {
+        if (!isdigit(z[i + 1])) {
          return TK_NK_ILLEGAL;
        }
@@ -107,13 +109,13 @@ static FORCE_INLINE int32_t tGetNumericStringType(const SToken* pToken) {
      case '0': {
        char next = z[i + 1];
-        if (next == 'b') { // bin number
+        if (next == 'b') {  // bin number
          type = TK_NK_BIN;
          for (i += 2; (z[i] == '0' || z[i] == '1'); ++i) {
          }
          goto _end;
-        } else if (next == 'x') {  //hex number
+        } else if (next == 'x') {  // hex number
          type = TK_NK_HEX;
          for (i += 2; isdigit(z[i]) || (z[i] >= 'a' && z[i] <= 'f') || (z[i] >= 'A' && z[i] <= 'F'); ++i) {
          }
@@ -167,15 +169,15 @@ static FORCE_INLINE int32_t tGetNumericStringType(const SToken* pToken) {
    }
  }
-  _end:
+_end:
-  return (i < pToken->n)? TK_NK_ILLEGAL:type;
+  return (i < pToken->n) ? TK_NK_ILLEGAL : type;
 }
 void taosCleanupKeywordsTable();
-SToken tscReplaceStrToken(char **str, SToken *token, const char* newToken);
+SToken tscReplaceStrToken(char **str, SToken *token, const char *newToken);
-SToken taosTokenDup(SToken* pToken, char* buf, int32_t len);
+SToken taosTokenDup(SToken *pToken, char *buf, int32_t len);
 #ifdef __cplusplus
 }

--- a/source/libs/parser/inc/parUtil.h
+++ b/source/libs/parser/inc/parUtil.h
@@ -23,31 +23,31 @@ extern "C" {
 #include "os.h"
 #include "query.h"
-#define parserFatal(param, ...)  qFatal("PARSER: " param, __VA_ARGS__)
+#define parserFatal(param, ...) qFatal("PARSER: " param, __VA_ARGS__)
-#define parserError(param, ...)  qError("PARSER: " param, __VA_ARGS__)
+#define parserError(param, ...) qError("PARSER: " param, __VA_ARGS__)
-#define parserWarn(param, ...)   qWarn("PARSER: " param, __VA_ARGS__)
+#define parserWarn(param, ...)  qWarn("PARSER: " param, __VA_ARGS__)
-#define parserInfo(param, ...)   qInfo("PARSER: " param, __VA_ARGS__)
+#define parserInfo(param, ...)  qInfo("PARSER: " param, __VA_ARGS__)
-#define parserDebug(param, ...)  qDebug("PARSER: " param, __VA_ARGS__)
+#define parserDebug(param, ...) qDebug("PARSER: " param, __VA_ARGS__)
-#define parserTrace(param, ...)  qTrace("PARSER: " param, __VA_ARGS__)
+#define parserTrace(param, ...) qTrace("PARSER: " param, __VA_ARGS__)
 #define PK_TS_COL_INTERNAL_NAME "_rowts"
 typedef struct SMsgBuf {
  int32_t len;
-  char   *buf;
+  char*   buf;
 } SMsgBuf;
 int32_t generateSyntaxErrMsg(SMsgBuf* pBuf, int32_t errCode, ...);
 int32_t buildInvalidOperationMsg(SMsgBuf* pMsgBuf, const char* msg);
-int32_t buildSyntaxErrMsg(SMsgBuf* pBuf, const char* additionalInfo,  const char* sourceStr);
+int32_t buildSyntaxErrMsg(SMsgBuf* pBuf, const char* additionalInfo, const char* sourceStr);
-STableMeta* tableMetaDup(const STableMeta* pTableMeta);
+STableMeta*   tableMetaDup(const STableMeta* pTableMeta);
-SSchema *getTableColumnSchema(const STableMeta *pTableMeta);
+SSchema*      getTableColumnSchema(const STableMeta* pTableMeta);
-SSchema *getTableTagSchema(const STableMeta* pTableMeta);
+SSchema*      getTableTagSchema(const STableMeta* pTableMeta);
-int32_t  getNumOfColumns(const STableMeta* pTableMeta);
+int32_t       getNumOfColumns(const STableMeta* pTableMeta);
-int32_t  getNumOfTags(const STableMeta* pTableMeta);
+int32_t       getNumOfTags(const STableMeta* pTableMeta);
 STableComInfo getTableInfo(const STableMeta* pTableMeta);
-int parseJsontoTagData(const char* json, SKVRowBuilder* kvRowBuilder, SMsgBuf* errMsg, int16_t startColId);
+int           parseJsontoTagData(const char* json, SKVRowBuilder* kvRowBuilder, SMsgBuf* errMsg, int16_t startColId);
 int32_t trimString(const char* src, int32_t len, char* dst, int32_t dlen);

--- a/source/libs/parser/inc/sql.y
+++ b/source/libs/parser/inc/sql.y
@@ -498,6 +498,7 @@ signed_literal(A) ::= NK_BOOL(B).
 signed_literal(A) ::= TIMESTAMP NK_STRING(B).                                     { A = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &B); }
 signed_literal(A) ::= duration_literal(B).                                        { A = releaseRawExprNode(pCxt, B); }
 signed_literal(A) ::= NULL.                                                       { A = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, NULL); }
+signed_literal(A) ::= literal_func(B).                                            { A = releaseRawExprNode(pCxt, B); }
 %type literal_list                                                                { SNodeList* }
 %destructor literal_list                                                          { nodesDestroyList($$); }
@@ -610,8 +611,10 @@ pseudo_column(A) ::= WDURATION(B).
 function_expression(A) ::= function_name(B) NK_LP expression_list(C) NK_RP(D).    { A = createRawExprNodeExt(pCxt, &B, &D, createFunctionNode(pCxt, &B, C)); }
 function_expression(A) ::= star_func(B) NK_LP star_func_para_list(C) NK_RP(D).    { A = createRawExprNodeExt(pCxt, &B, &D, createFunctionNode(pCxt, &B, C)); }
 function_expression(A) ::= CAST(B) NK_LP expression(C) AS type_name(D) NK_RP(E).  { A = createRawExprNodeExt(pCxt, &B, &E, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, C), D)); }
-function_expression(A) ::= noarg_func(B) NK_LP NK_RP(C).                          { A = createRawExprNodeExt(pCxt, &B, &C, createFunctionNodeNoArg(pCxt, &B)); }
+function_expression(A) ::= literal_func(B).                                       { A = B; }
-//function_expression(A) ::= NOW(B).                                                { A = createRawExprNode(pCxt, &B, createFunctionNode(pCxt, &B, NULL)); }
+literal_func(A) ::= noarg_func(B) NK_LP NK_RP(C).                                 { A = createRawExprNodeExt(pCxt, &B, &C, createFunctionNode(pCxt, &B, NULL)); }
+literal_func(A) ::= NOW(B).                                                       { A = createRawExprNode(pCxt, &B, createFunctionNode(pCxt, &B, NULL)); }
 %type noarg_func                                                                  { SToken }
 %destructor noarg_func                                                            { }

--- a/source/libs/parser/src/parAstCreater.c
+++ b/source/libs/parser/src/parAstCreater.c
@@ -18,24 +18,24 @@
 #include "parUtil.h"
 #include "ttime.h"
-#define CHECK_OUT_OF_MEM(p) \
+#define CHECK_OUT_OF_MEM(p)                                                      \
-  do { \
+  do {                                                                           \
-    if (NULL == (p)) { \
+    if (NULL == (p)) {                                                           \
-      pCxt->valid = false; \
+      pCxt->valid = false;                                                       \
      snprintf(pCxt->pQueryCxt->pMsg, pCxt->pQueryCxt->msgLen, "Out of memory"); \
-      return NULL; \
+      return NULL;                                                               \
-    } \
+    }                                                                            \
  } while (0)
-#define CHECK_RAW_EXPR_NODE(node) \
+#define CHECK_RAW_EXPR_NODE(node)                                  \
-  do { \
+  do {                                                             \
    if (NULL == (node) || QUERY_NODE_RAW_EXPR != nodeType(node)) { \
-      pCxt->valid = false; \
+      pCxt->valid = false;                                         \
-      return NULL; \
+      return NULL;                                                 \
-    } \
+    }                                                              \
  } while (0)
-SToken nil_token = { .type = TK_NK_NIL, .n = 0, .z = NULL };
+SToken nil_token = {.type = TK_NK_NIL, .n = 0, .z = NULL};
 void initAstCreateContext(SParseContext* pParseCxt, SAstCreateContext* pCxt) {
  pCxt->pQueryCxt = pParseCxt;
@@ -90,7 +90,7 @@ static bool checkPassword(SAstCreateContext* pCxt, const SToken* pPasswordToken,
 static bool checkAndSplitEndpoint(SAstCreateContext* pCxt, const SToken* pEp, char* pFqdn, int32_t* pPort) {
  if (NULL == pEp) {
    pCxt->valid = false;
-  } else if (pEp->n >= TSDB_FQDN_LEN + 2 + 6) { // format 'fqdn:port'
+  } else if (pEp->n >= TSDB_FQDN_LEN + 2 + 6) {  // format 'fqdn:port'
    generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_NAME_OR_PASSWD_TOO_LONG);
    pCxt->valid = false;
  } else {
@@ -206,7 +206,7 @@ SNode* createRawExprNodeExt(SAstCreateContext* pCxt, const SToken* pStart, const
 SNode* releaseRawExprNode(SAstCreateContext* pCxt, SNode* pNode) {
  CHECK_RAW_EXPR_NODE(pNode);
  SRawExprNode* pRawExpr = (SRawExprNode*)pNode;
-  SNode* pExpr = pRawExpr->pNode;
+  SNode*        pExpr = pRawExpr->pNode;
  if (nodesIsExprNode(pExpr)) {
    int32_t len = TMIN(sizeof(((SExprNode*)pExpr)->aliasName) - 1, pRawExpr->n);
    strncpy(((SExprNode*)pExpr)->aliasName, pRawExpr->p, len);
@@ -222,7 +222,7 @@ SToken getTokenFromRawExprNode(SAstCreateContext* pCxt, SNode* pNode) {
    return nil_token;
  }
  SRawExprNode* target = (SRawExprNode*)pNode;
-  SToken t = { .type = 0, .z = target->p, .n = target->n};
+  SToken        t = {.type = 0, .z = target->p, .n = target->n};
  return t;
 }
@@ -352,12 +352,13 @@ SNode* createOperatorNode(SAstCreateContext* pCxt, EOperatorType type, SNode* pL
 SNode* createBetweenAnd(SAstCreateContext* pCxt, SNode* pExpr, SNode* pLeft, SNode* pRight) {
  return createLogicConditionNode(pCxt, LOGIC_COND_TYPE_AND,
-      createOperatorNode(pCxt, OP_TYPE_GREATER_EQUAL, pExpr, pLeft), createOperatorNode(pCxt, OP_TYPE_LOWER_EQUAL, nodesCloneNode(pExpr), pRight));
+                                  createOperatorNode(pCxt, OP_TYPE_GREATER_EQUAL, pExpr, pLeft),
+                                  createOperatorNode(pCxt, OP_TYPE_LOWER_EQUAL, nodesCloneNode(pExpr), pRight));
 }
 SNode* createNotBetweenAnd(SAstCreateContext* pCxt, SNode* pExpr, SNode* pLeft, SNode* pRight) {
-  return createLogicConditionNode(pCxt, LOGIC_COND_TYPE_OR,
+  return createLogicConditionNode(pCxt, LOGIC_COND_TYPE_OR, createOperatorNode(pCxt, OP_TYPE_LOWER_THAN, pExpr, pLeft),
-      createOperatorNode(pCxt, OP_TYPE_LOWER_THAN, pExpr, pLeft), createOperatorNode(pCxt, OP_TYPE_GREATER_THAN, nodesCloneNode(pExpr), pRight));
+                                  createOperatorNode(pCxt, OP_TYPE_GREATER_THAN, nodesCloneNode(pExpr), pRight));
 }
 SNode* createFunctionNode(SAstCreateContext* pCxt, const SToken* pFuncName, SNodeList* pParameterList) {
@@ -368,39 +369,6 @@ SNode* createFunctionNode(SAstCreateContext* pCxt, const SToken* pFuncName, SNod
  return (SNode*)func;
 }
-SNode* createFunctionNodeNoArg(SAstCreateContext* pCxt, const SToken* pFuncName) {
-  SFunctionNode* func = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION);
-  CHECK_OUT_OF_MEM(func);
-  char buf[64] = {0};
-  int32_t dataType;
-  switch (pFuncName->type) {
-    case TK_NOW: {
-      int64_t ts = taosGetTimestamp(TSDB_TIME_PRECISION_MILLI);
-      snprintf(buf, sizeof(buf), "%"PRId64, ts);
-      dataType = TSDB_DATA_TYPE_BIGINT;
-      break;
-    }
-    case TK_TODAY: {
-      int64_t ts = taosGetTimestampToday(TSDB_TIME_PRECISION_MILLI);
-      snprintf(buf, sizeof(buf), "%"PRId64, ts);
-      dataType = TSDB_DATA_TYPE_BIGINT;
-      break;
-    }
-    case TK_TIMEZONE: {
-      strncpy(buf, tsTimezoneStr, strlen(tsTimezoneStr));
-      dataType = TSDB_DATA_TYPE_BINARY;
-      break;
-    }
-  }
-  SToken token = {.type = pFuncName->type, .n = strlen(buf), .z = buf};
-  SNodeList *pParameterList = createNodeList(pCxt, createValueNode(pCxt, dataType, &token));
-  strncpy(func->functionName, pFuncName->z, pFuncName->n);
-  func->pParameterList = pParameterList;
-  return (SNode*)func;
-}
 SNode* createCastFunctionNode(SAstCreateContext* pCxt, SNode* pExpr, SDataType dt) {
  SFunctionNode* func = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION);
  CHECK_OUT_OF_MEM(func);
@@ -444,9 +412,6 @@ SNode* createRealTableNode(SAstCreateContext* pCxt, SToken* pDbName, SToken* pTa
    strncpy(realTable->table.tableAlias, pTableName->z, pTableName->n);
  }
  strncpy(realTable->table.tableName, pTableName->z, pTableName->n);
-  if (NULL != pCxt->pQueryCxt->db) {
-    strcpy(realTable->useDbName, pCxt->pQueryCxt->db);
-  }  
  return (SNode*)realTable;
 }
@@ -519,7 +484,8 @@ SNode* createStateWindowNode(SAstCreateContext* pCxt, SNode* pExpr) {
  return (SNode*)state;
 }
-SNode* createIntervalWindowNode(SAstCreateContext* pCxt, SNode* pInterval, SNode* pOffset, SNode* pSliding, SNode* pFill) {
+SNode* createIntervalWindowNode(SAstCreateContext* pCxt, SNode* pInterval, SNode* pOffset, SNode* pSliding,
+                                SNode* pFill) {
  SIntervalWindowNode* interval = (SIntervalWindowNode*)nodesMakeNode(QUERY_NODE_INTERVAL_WINDOW);
  CHECK_OUT_OF_MEM(interval);
  interval->pCol = nodesMakeNode(QUERY_NODE_COLUMN);
@@ -785,17 +751,17 @@ SNode* createColumnDefNode(SAstCreateContext* pCxt, SToken* pColName, SDataType
 }
 SDataType createDataType(uint8_t type) {
-  SDataType dt = { .type = type, .precision = 0, .scale = 0, .bytes = tDataTypes[type].bytes };
+  SDataType dt = {.type = type, .precision = 0, .scale = 0, .bytes = tDataTypes[type].bytes};
  return dt;
 }
 SDataType createVarLenDataType(uint8_t type, const SToken* pLen) {
-  SDataType dt = { .type = type, .precision = 0, .scale = 0, .bytes = strtol(pLen->z, NULL, 10) };
+  SDataType dt = {.type = type, .precision = 0, .scale = 0, .bytes = strtol(pLen->z, NULL, 10)};
  return dt;
 }
-SNode* createCreateTableStmt(SAstCreateContext* pCxt,
+SNode* createCreateTableStmt(SAstCreateContext* pCxt, bool ignoreExists, SNode* pRealTable, SNodeList* pCols,
-    bool ignoreExists, SNode* pRealTable, SNodeList* pCols, SNodeList* pTags, SNode* pOptions) {
+                             SNodeList* pTags, SNode* pOptions) {
  if (NULL == pRealTable) {
    return NULL;
  }
@@ -811,8 +777,8 @@ SNode* createCreateTableStmt(SAstCreateContext* pCxt,
  return (SNode*)pStmt;
 }
-SNode* createCreateSubTableClause(SAstCreateContext* pCxt,
+SNode* createCreateSubTableClause(SAstCreateContext* pCxt, bool ignoreExists, SNode* pRealTable, SNode* pUseRealTable,
-    bool ignoreExists, SNode* pRealTable, SNode* pUseRealTable, SNodeList* pSpecificTags, SNodeList* pValsOfTags) {
+                                  SNodeList* pSpecificTags, SNodeList* pValsOfTags) {
  if (NULL == pRealTable) {
    return NULL;
  }
@@ -878,7 +844,8 @@ SNode* createAlterTableOption(SAstCreateContext* pCxt, SNode* pRealTable, SNode*
  return (SNode*)pStmt;
 }
-SNode* createAlterTableAddModifyCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType, const SToken* pColName, SDataType dataType) {
+SNode* createAlterTableAddModifyCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType,
+                                    const SToken* pColName, SDataType dataType) {
  if (NULL == pRealTable) {
    return NULL;
  }
@@ -901,7 +868,8 @@ SNode* createAlterTableDropCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_
  return (SNode*)pStmt;
 }
-SNode* createAlterTableRenameCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType, const SToken* pOldColName, const SToken* pNewColName) {
+SNode* createAlterTableRenameCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType,
+                                 const SToken* pOldColName, const SToken* pNewColName) {
  if (NULL == pRealTable) {
    return NULL;
  }
@@ -936,7 +904,8 @@ SNode* createUseDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName) {
 }
 static bool needDbShowStmt(ENodeType type) {
-  return QUERY_NODE_SHOW_TABLES_STMT == type || QUERY_NODE_SHOW_STABLES_STMT == type || QUERY_NODE_SHOW_VGROUPS_STMT == type;
+  return QUERY_NODE_SHOW_TABLES_STMT == type || QUERY_NODE_SHOW_STABLES_STMT == type ||
+         QUERY_NODE_SHOW_VGROUPS_STMT == type;
 }
 SNode* createShowStmt(SAstCreateContext* pCxt, ENodeType type, SNode* pDbName, SNode* pTbNamePattern) {
@@ -945,7 +914,8 @@ SNode* createShowStmt(SAstCreateContext* pCxt, ENodeType type, SNode* pDbName, S
    pCxt->valid = false;
    return NULL;
  }
-  SShowStmt* pStmt = nodesMakeNode(type);;
+  SShowStmt* pStmt = nodesMakeNode(type);
+  ;
  CHECK_OUT_OF_MEM(pStmt);
  pStmt->pDbName = pDbName;
  pStmt->pTbNamePattern = pTbNamePattern;
@@ -1007,7 +977,7 @@ SNode* createDropUserStmt(SAstCreateContext* pCxt, SToken* pUserName) {
 SNode* createCreateDnodeStmt(SAstCreateContext* pCxt, const SToken* pFqdn, const SToken* pPort) {
  int32_t port = 0;
-  char fqdn[TSDB_FQDN_LEN] = {0};
+  char    fqdn[TSDB_FQDN_LEN] = {0};
  if (NULL == pPort) {
    if (!checkAndSplitEndpoint(pCxt, pFqdn, fqdn, &port)) {
      return NULL;
@@ -1040,7 +1010,8 @@ SNode* createDropDnodeStmt(SAstCreateContext* pCxt, const SToken* pDnode) {
  return (SNode*)pStmt;
 }
-SNode* createAlterDnodeStmt(SAstCreateContext* pCxt, const SToken* pDnode, const SToken* pConfig, const SToken* pValue) {
+SNode* createAlterDnodeStmt(SAstCreateContext* pCxt, const SToken* pDnode, const SToken* pConfig,
+                            const SToken* pValue) {
  SAlterDnodeStmt* pStmt = nodesMakeNode(QUERY_NODE_ALTER_DNODE_STMT);
  CHECK_OUT_OF_MEM(pStmt);
  pStmt->dnodeId = strtol(pDnode->z, NULL, 10);
@@ -1051,7 +1022,8 @@ SNode* createAlterDnodeStmt(SAstCreateContext* pCxt, const SToken* pDnode, const
  return (SNode*)pStmt;
 }
-SNode* createCreateIndexStmt(SAstCreateContext* pCxt, EIndexType type, bool ignoreExists, SToken* pIndexName, SToken* pTableName, SNodeList* pCols, SNode* pOptions) {
+SNode* createCreateIndexStmt(SAstCreateContext* pCxt, EIndexType type, bool ignoreExists, SToken* pIndexName,
+                             SToken* pTableName, SNodeList* pCols, SNode* pOptions) {
  if (!checkIndexName(pCxt, pIndexName) || !checkTableName(pCxt, pTableName)) {
    return NULL;
  }
@@ -1066,7 +1038,8 @@ SNode* createCreateIndexStmt(SAstCreateContext* pCxt, EIndexType type, bool igno
  return (SNode*)pStmt;
 }
-SNode* createIndexOption(SAstCreateContext* pCxt, SNodeList* pFuncs, SNode* pInterval, SNode* pOffset, SNode* pSliding) {
+SNode* createIndexOption(SAstCreateContext* pCxt, SNodeList* pFuncs, SNode* pInterval, SNode* pOffset,
+                         SNode* pSliding) {
  SIndexOptions* pOptions = nodesMakeNode(QUERY_NODE_INDEX_OPTIONS);
  CHECK_OUT_OF_MEM(pOptions);
  pOptions->pFuncs = pFuncs;
@@ -1091,14 +1064,16 @@ SNode* createDropIndexStmt(SAstCreateContext* pCxt, bool ignoreNotExists, SToken
 SNode* createCreateComponentNodeStmt(SAstCreateContext* pCxt, ENodeType type, const SToken* pDnodeId) {
  SCreateComponentNodeStmt* pStmt = nodesMakeNode(type);
  CHECK_OUT_OF_MEM(pStmt);
-  pStmt->dnodeId = strtol(pDnodeId->z, NULL, 10);;
+  pStmt->dnodeId = strtol(pDnodeId->z, NULL, 10);
+  ;
  return (SNode*)pStmt;
 }
 SNode* createDropComponentNodeStmt(SAstCreateContext* pCxt, ENodeType type, const SToken* pDnodeId) {
  SDropComponentNodeStmt* pStmt = nodesMakeNode(type);
  CHECK_OUT_OF_MEM(pStmt);
-  pStmt->dnodeId = strtol(pDnodeId->z, NULL, 10);;
+  pStmt->dnodeId = strtol(pDnodeId->z, NULL, 10);
+  ;
  return (SNode*)pStmt;
 }
@@ -1111,8 +1086,8 @@ SNode* createTopicOptions(SAstCreateContext* pCxt) {
  return (SNode*)pOptions;
 }
-SNode* createCreateTopicStmt(SAstCreateContext* pCxt,
+SNode* createCreateTopicStmt(SAstCreateContext* pCxt, bool ignoreExists, const SToken* pTopicName, SNode* pQuery,
-    bool ignoreExists, const SToken* pTopicName, SNode* pQuery, const SToken* pSubscribeDbName, SNode* pOptions) {
+                             const SToken* pSubscribeDbName, SNode* pOptions) {
  SCreateTopicStmt* pStmt = nodesMakeNode(QUERY_NODE_CREATE_TOPIC_STMT);
  CHECK_OUT_OF_MEM(pStmt);
  strncpy(pStmt->topicName, pTopicName->z, pTopicName->n);
@@ -1194,8 +1169,8 @@ SNode* createCompactStmt(SAstCreateContext* pCxt, SNodeList* pVgroups) {
  return pStmt;
 }
-SNode* createCreateFunctionStmt(SAstCreateContext* pCxt,
+SNode* createCreateFunctionStmt(SAstCreateContext* pCxt, bool ignoreExists, bool aggFunc, const SToken* pFuncName,
-    bool ignoreExists, bool aggFunc, const SToken* pFuncName, const SToken* pLibPath, SDataType dataType, int32_t bufSize) {
+                                const SToken* pLibPath, SDataType dataType, int32_t bufSize) {
  if (pLibPath->n <= 2) {
    pCxt->valid = false;
    return NULL;
@@ -1224,7 +1199,8 @@ SNode* createStreamOptions(SAstCreateContext* pCxt) {
  return (SNode*)pOptions;
 }
-SNode* createCreateStreamStmt(SAstCreateContext* pCxt, bool ignoreExists, const SToken* pStreamName, SNode* pRealTable, SNode* pOptions, SNode* pQuery) {
+SNode* createCreateStreamStmt(SAstCreateContext* pCxt, bool ignoreExists, const SToken* pStreamName, SNode* pRealTable,
+                              SNode* pOptions, SNode* pQuery) {
  SCreateStreamStmt* pStmt = nodesMakeNode(QUERY_NODE_CREATE_STREAM_STMT);
  CHECK_OUT_OF_MEM(pStmt);
  strncpy(pStmt->streamName, pStreamName->z, pStreamName->n);

--- a/source/libs/parser/src/parAstParser.c
+++ b/source/libs/parser/src/parAstParser.c
@@ -23,14 +23,14 @@ typedef void* (*FMalloc)(size_t);
 typedef void (*FFree)(void*);
 extern void* ParseAlloc(FMalloc);
-extern void Parse(void*, int, SToken, void*);
+extern void  Parse(void*, int, SToken, void*);
-extern void ParseFree(void*, FFree);
+extern void  ParseFree(void*, FFree);
-extern void ParseTrace(FILE*, char*);
+extern void  ParseTrace(FILE*, char*);
 int32_t parse(SParseContext* pParseCxt, SQuery** pQuery) {
  SAstCreateContext cxt;
  initAstCreateContext(pParseCxt, &cxt);
-  void *pParser = ParseAlloc((FMalloc)taosMemoryMalloc);
+  void*   pParser = ParseAlloc((FMalloc)taosMemoryMalloc);
  int32_t i = 0;
  while (1) {
    SToken t0 = {0};
@@ -38,8 +38,8 @@ int32_t parse(SParseContext* pParseCxt, SQuery** pQuery) {
      Parse(pParser, 0, t0, &cxt);
      goto abort_parse;
    }
-    t0.n = tGetToken((char *)&cxt.pQueryCxt->pSql[i], &t0.type);
+    t0.n = tGetToken((char*)&cxt.pQueryCxt->pSql[i], &t0.type);
-    t0.z = (char *)(cxt.pQueryCxt->pSql + i);
+    t0.z = (char*)(cxt.pQueryCxt->pSql + i);
    i += t0.n;
    switch (t0.type) {

--- a/source/libs/parser/src/parCalcConst.c
+++ b/source/libs/parser/src/parCalcConst.c
--- 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/parTokenizer.c
+++ b/source/libs/parser/src/parTokenizer.c
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
--- a/source/libs/parser/src/parUtil.c
+++ b/source/libs/parser/src/parUtil.c
--- a/source/libs/parser/src/parser.c
+++ b/source/libs/parser/src/parser.c
@@ -13,8 +13,8 @@
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
-#include "os.h"
 #include "parser.h"
+#include "os.h"
 #include "parInt.h"
 #include "parToken.h"
@@ -23,11 +23,11 @@ bool isInsertSql(const char* pStr, size_t length) {
  if (NULL == pStr) {
    return false;
  }
  int32_t index = 0;
  do {
-    SToken t0 = tStrGetToken((char*) pStr, &index, false);
+    SToken t0 = tStrGetToken((char*)pStr, &index, false);
    if (t0.type != TK_NK_LP) {
      return t0.type == TK_INSERT || t0.type == TK_IMPORT;
    }

--- a/source/libs/parser/src/sql.c
+++ b/source/libs/parser/src/sql.c
--- a/source/libs/parser/test/mockCatalog.cpp
+++ b/source/libs/parser/test/mockCatalog.cpp
--- a/source/libs/parser/test/mockCatalogService.cpp
+++ b/source/libs/parser/test/mockCatalogService.cpp
--- a/source/libs/parser/test/mockCatalogService.h
+++ b/source/libs/parser/test/mockCatalogService.h
@@ -20,17 +20,15 @@
 #include <string>
 #include <vector>
+#define ALLOW_FORBID_FUNC
 #include "catalog.h"
 class ITableBuilder {
-public:
+ public:
-  ITableBuilder& addTag(const std::string& name, int8_t type) {
+  ITableBuilder& addTag(const std::string& name, int8_t type) { return addColumn(name, type, tDataTypes[type].bytes); }
-    return addColumn(name, type, tDataTypes[type].bytes);
-  }
-  ITableBuilder& addTag(const std::string& name, int8_t type, int32_t bytes) {
+  ITableBuilder& addTag(const std::string& name, int8_t type, int32_t bytes) { return addColumn(name, type, bytes); }
-    return addColumn(name, type, bytes);
-  }
  ITableBuilder& addColumn(const std::string& name, int8_t type) {
    return addColumn(name, type, tDataTypes[type].bytes);
@@ -39,24 +37,23 @@ public:
  virtual ITableBuilder& addColumn(const std::string& name, int8_t type, int32_t bytes) = 0;
  virtual ITableBuilder& setVgid(int16_t vgid) = 0;
  virtual ITableBuilder& setPrecision(uint8_t precision) = 0;
-  virtual void done() = 0;
+  virtual void           done() = 0;
 };
 struct MockTableMeta {
-  ~MockTableMeta() {
+  ~MockTableMeta() { taosMemoryFree(schema); }
-    taosMemoryFree(schema);
-  }
-  STableMeta* schema;
+  STableMeta*              schema;
  std::vector<SVgroupInfo> vgs;
 };
 class MockCatalogServiceImpl;
 class MockCatalogService {
-public:
+ public:
  MockCatalogService();
  ~MockCatalogService();
-  ITableBuilder& createTableBuilder(const std::string& db, const std::string& tbname, int8_t tableType, int32_t numOfColumns, int32_t numOfTags = 0);
+  ITableBuilder& createTableBuilder(const std::string& db, const std::string& tbname, int8_t tableType,
+                                    int32_t numOfColumns, int32_t numOfTags = 0);
  void createSubTable(const std::string& db, const std::string& stbname, const std::string& tbname, int16_t vgid);
  void showTables() const;
  std::shared_ptr<MockTableMeta> getTableMeta(const std::string& db, const std::string& tbname) const;
@@ -65,7 +62,7 @@ public:
  int32_t catalogGetTableHashVgroup(const SName* pTableName, SVgroupInfo* vgInfo) const;
  int32_t catalogGetTableDistVgInfo(const SName* pTableName, SArray** pVgList) const;
-private:
+ private:
  std::unique_ptr<MockCatalogServiceImpl> impl_;
 };

--- a/source/libs/parser/test/parserAstTest.cpp
+++ b/source/libs/parser/test/parserAstTest.cpp
--- a/source/libs/parser/test/parserInsertTest.cpp
+++ b/source/libs/parser/test/parserInsertTest.cpp
--- a/source/libs/parser/test/parserTestMain.cpp
+++ b/source/libs/parser/test/parserTestMain.cpp
--- a/source/libs/planner/inc/planInt.h
+++ b/source/libs/planner/inc/planInt.h
@@ -26,12 +26,12 @@ extern "C" {
 #define QUERY_POLICY_HYBRID 2
 #define QUERY_POLICY_QNODE  3
-#define planFatal(param, ...)  qFatal("PLAN: " param, __VA_ARGS__)
+#define planFatal(param, ...) qFatal("PLAN: " param, __VA_ARGS__)
-#define planError(param, ...)  qError("PLAN: " param, __VA_ARGS__)
+#define planError(param, ...) qError("PLAN: " param, __VA_ARGS__)
-#define planWarn(param, ...)   qWarn("PLAN: " param, __VA_ARGS__)
+#define planWarn(param, ...)  qWarn("PLAN: " param, __VA_ARGS__)
-#define planInfo(param, ...)   qInfo("PLAN: " param, __VA_ARGS__)
+#define planInfo(param, ...)  qInfo("PLAN: " param, __VA_ARGS__)
-#define planDebug(param, ...)  qDebug("PLAN: " param, __VA_ARGS__)
+#define planDebug(param, ...) qDebug("PLAN: " param, __VA_ARGS__)
-#define planTrace(param, ...)  qTrace("PLAN: " param, __VA_ARGS__)
+#define planTrace(param, ...) qTrace("PLAN: " param, __VA_ARGS__)
 int32_t createLogicPlan(SPlanContext* pCxt, SLogicNode** pLogicNode);
 int32_t optimizeLogicPlan(SPlanContext* pCxt, SLogicNode* pLogicNode);

--- a/source/libs/planner/src/planLogicCreater.c
+++ b/source/libs/planner/src/planLogicCreater.c
--- a/source/libs/planner/src/planOptimizer.c
+++ b/source/libs/planner/src/planOptimizer.c
--- a/source/libs/planner/src/planPhysiCreater.c
+++ b/source/libs/planner/src/planPhysiCreater.c
--- a/source/libs/planner/src/planScaleOut.c
+++ b/source/libs/planner/src/planScaleOut.c
--- a/source/libs/planner/src/planSpliter.c
+++ b/source/libs/planner/src/planSpliter.c
--- a/source/libs/planner/src/planner.c
+++ b/source/libs/planner/src/planner.c
--- a/source/libs/planner/test/planOptTest.cpp
+++ b/source/libs/planner/test/planOptTest.cpp
@@ -18,9 +18,7 @@
 using namespace std;
-class PlanOptimizeTest : public PlannerTestBase {
+class PlanOptimizeTest : public PlannerTestBase {};
-};
 TEST_F(PlanOptimizeTest, orderByPrimaryKey) {
  useDb("root", "test");

--- a/source/libs/planner/test/planSTableTest.cpp
+++ b/source/libs/planner/test/planSTableTest.cpp
--- a/source/libs/planner/test/planSetOpTest.cpp
+++ b/source/libs/planner/test/planSetOpTest.cpp
@@ -18,9 +18,7 @@
 using namespace std;
-class PlanSetOpTest : public PlannerTestBase {
+class PlanSetOpTest : public PlannerTestBase {};
-};
 TEST_F(PlanSetOpTest, unionAll) {
  useDb("root", "test");

--- a/source/libs/planner/test/planStmtTest.cpp
+++ b/source/libs/planner/test/planStmtTest.cpp
@@ -19,7 +19,7 @@
 using namespace std;
 class PlanStmtTest : public PlannerTestBase {
-public:
+ public:
  void prepare(const string& sql) {
    run(sql);
    // todo calloc pBindParams_

--- a/source/libs/planner/test/planTestMain.cpp
+++ b/source/libs/planner/test/planTestMain.cpp
--- a/source/libs/planner/test/planTestUtil.cpp
+++ b/source/libs/planner/test/planTestUtil.cpp
--- a/source/libs/planner/test/planTestUtil.h
+++ b/source/libs/planner/test/planTestUtil.h
--- a/source/libs/planner/test/plannerTest.cpp
+++ b/source/libs/planner/test/plannerTest.cpp
--- a/source/libs/scalar/inc/sclvector.h
+++ b/source/libs/scalar/inc/sclvector.h
--- 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/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/tconfig.c
+++ b/source/util/src/tconfig.c
--- a/tests/script/sh/deploy.sh
+++ b/tests/script/sh/deploy.sh
--- 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/2-query/Now.py
+++ b/tests/system-test/2-query/Now.py
--- a/tests/system-test/2-query/To_iso8061.py
+++ b/tests/system-test/2-query/To_iso8061.py
--- a/tests/system-test/2-query/Today.py
+++ b/tests/system-test/2-query/Today.py
--- a/tests/system-test/2-query/timezone.py
+++ b/tests/system-test/2-query/timezone.py
--- 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