refactor: merge from 3.0

.gitignore

@@ -5,6 +5,7 @@ compile_commands.json
 .tasks
 .vimspector.json
 .vscode/
+.vscode
 .idea/
 cmake-build-debug/
 cmake-build-release/

2.0/src/query/inc/qExecutor.h

@@ -179,7 +179,7 @@ typedef struct SQueryCostInfo {
   uint32_t totalBlocks;
   uint32_t loadBlocks;
   uint32_t loadBlockStatis;
-  uint32_t discardBlocks;
+  uint32_t skipBlocks;
   uint64_t elapsedTime;
   uint64_t firstStageMergeTime;
   uint64_t winInfoSize;

2.0/src/query/src/qExecutor.c

@@ -3144,7 +3144,7 @@ int32_t loadDataBlockOnDemand(SQueryRuntimeEnv* pRuntimeEnv, STableScanInfo* pTa
   if ((*status) == BLK_DATA_NO_NEEDED || (*status) == BLK_DATA_DISCARD) {
     qDebug("QInfo:0x%"PRIx64" data block discard, brange:%" PRId64 "-%" PRId64 ", rows:%d", pQInfo->qId, pBlockInfo->window.skey,
            pBlockInfo->window.ekey, pBlockInfo->rows);
-    pCost->discardBlocks += 1;
+    pCost->skipBlocks += 1;
   } else if ((*status) == BLK_DATA_STATIS_NEEDED) {
     // this function never returns error?
     pCost->loadBlockStatis += 1;
@@ -3184,7 +3184,7 @@ int32_t loadDataBlockOnDemand(SQueryRuntimeEnv* pRuntimeEnv, STableScanInfo* pTa
           load = topbot_datablock_filter(&pTableScanInfo->pCtx[i], (char*)&(pBlock->pBlockStatis[i].min),
                                          (char*)&(pBlock->pBlockStatis[i].max));
           if (!load) { // current block has been discard due to filter applied
-            pCost->discardBlocks += 1;
+            pCost->skipBlocks += 1;
             qDebug("QInfo:0x%"PRIx64" data block discard, brange:%" PRId64 "-%" PRId64 ", rows:%d", pQInfo->qId,
                    pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows);
             (*status) = BLK_DATA_DISCARD;
@@ -3196,7 +3196,7 @@ int32_t loadDataBlockOnDemand(SQueryRuntimeEnv* pRuntimeEnv, STableScanInfo* pTa
 
     // current block has been discard due to filter applied
     if (!doFilterByBlockStatistics(pRuntimeEnv, pBlock->pBlockStatis, pTableScanInfo->pCtx, pBlockInfo->rows)) {
-      pCost->discardBlocks += 1;
+      pCost->skipBlocks += 1;
       qDebug("QInfo:0x%"PRIx64" data block discard, brange:%" PRId64 "-%" PRId64 ", rows:%d", pQInfo->qId, pBlockInfo->window.skey,
              pBlockInfo->window.ekey, pBlockInfo->rows);
       (*status) = BLK_DATA_DISCARD;

CMakeLists.txt

@@ -17,6 +17,7 @@ include(${TD_SUPPORT_DIR}/cmake.platform)
 include(${TD_SUPPORT_DIR}/cmake.define)
 include(${TD_SUPPORT_DIR}/cmake.options)
 include(${TD_SUPPORT_DIR}/cmake.version)
+include(${TD_SUPPORT_DIR}/cmake.install)
 
 # contrib
 add_subdirectory(contrib)

cmake/cmake.define

 cmake_minimum_required(VERSION 3.16)
 
+#set output directory
+SET(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/build/lib)
+SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/build/bin)
+SET(TD_TESTS_OUTPUT_DIR ${PROJECT_BINARY_DIR}/test)
+
+MESSAGE(STATUS "Project source directory: " ${PROJECT_SOURCE_DIR})
+MESSAGE(STATUS "Project binary files output path: " ${PROJECT_BINARY_DIR})
+MESSAGE(STATUS "Project executable files output path: " ${EXECUTABLE_OUTPUT_PATH})
+MESSAGE(STATUS "Project library files output path: " ${LIBRARY_OUTPUT_PATH})
+
 if (NOT DEFINED TD_GRANT)
   SET(TD_GRANT FALSE)
 endif()

cmake/cmake.install

+IF (TD_LINUX)
+  SET(TD_MAKE_INSTALL_SH "${TD_SOURCE_DIR}/packaging/make_install.sh")
+  INSTALL(CODE "MESSAGE(\"make install script: ${TD_MAKE_INSTALL_SH}\")")
+  INSTALL(CODE "execute_process(COMMAND bash ${TD_MAKE_INSTALL_SH} ${TD_SOURCE_DIR} ${PROJECT_BINARY_DIR} Linux ${TD_VER_NUMBER})")
+ELSEIF (TD_WINDOWS)
+  SET(CMAKE_INSTALL_PREFIX C:/TDengine)
+
+  INSTALL(DIRECTORY ${TD_SOURCE_DIR}/src/connector/go     DESTINATION connector)
+  INSTALL(DIRECTORY ${TD_SOURCE_DIR}/src/connector/nodejs DESTINATION connector)
+  INSTALL(DIRECTORY ${TD_SOURCE_DIR}/src/connector/python DESTINATION connector)
+  INSTALL(DIRECTORY ${TD_SOURCE_DIR}/src/connector/C\# DESTINATION connector)
+  INSTALL(DIRECTORY ${TD_SOURCE_DIR}/examples DESTINATION .)
+  INSTALL(FILES ${TD_SOURCE_DIR}/packaging/cfg/taos.cfg DESTINATION cfg)
+  INSTALL(FILES ${TD_SOURCE_DIR}/src/inc/taos.h DESTINATION include)
+  INSTALL(FILES ${TD_SOURCE_DIR}/src/inc/taoserror.h DESTINATION include)
+  INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos.lib DESTINATION driver)
+  INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos_static.lib DESTINATION driver)
+  INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos.exp DESTINATION driver)
+  INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos.dll DESTINATION driver)
+
+  IF (TD_MVN_INSTALLED)
+    INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.38-dist.jar DESTINATION connector/jdbc)
+  ENDIF ()
+ELSEIF (TD_DARWIN)
+  SET(TD_MAKE_INSTALL_SH "${TD_SOURCE_DIR}/packaging/tools/make_install.sh")
+  INSTALL(CODE "MESSAGE(\"make install script: ${TD_MAKE_INSTALL_SH}\")")
+  INSTALL(CODE "execute_process(COMMAND bash ${TD_MAKE_INSTALL_SH} ${TD_SOURCE_DIR} ${PROJECT_BINARY_DIR} Darwin ${TD_VER_NUMBER})")
+ENDIF ()

example/CMakeLists.txt

@@ -18,15 +18,15 @@ target_sources(demoapi
 )
 
 target_link_libraries(tmq
-    taos
+    taos_static
 )
 
 target_link_libraries(tstream
-    taos
+    taos_static
 )
 
 target_link_libraries(demoapi
-    taos
+    taos_static
 )
 
 target_include_directories(tmq

example/src/demoapi.c

@@ -30,7 +30,7 @@
         fprintf(stderr, "\033[0m"); } while(0)
 
 int64_t g_num_of_tb = 2;
-int64_t g_num_of_rec = 2;
+int64_t g_num_of_rec = 3;
 
 static struct argp_option options[] = {
     {"tables", 't', "NUMBER", 0, "Number of child tables, default is 10000."},
@@ -42,10 +42,18 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
     switch (key) {
         case 't':
             g_num_of_tb = atoll(arg);
+            if (g_num_of_tb < 1) {
+                warnPrint("minimal g_num_of_tb is %d\n", 1);
+                g_num_of_tb = 1;
+            }
             break;
 
         case 'n':
             g_num_of_rec = atoll(arg);
+            if (g_num_of_rec < 2) {
+                warnPrint("minimal g_num_of_rec is %d\n", 2);
+                g_num_of_rec = 2;
+            }
             break;
     }
 
@@ -65,15 +73,32 @@ static void prepare_data(TAOS* taos) {
     usleep(100000);
     taos_select_db(taos, "test");
 
-    res = taos_query(taos, "create table meters(ts timestamp, f float, n int, b binary(20), c nchar(20)) tags(area int, city binary(20), dist nchar(20));");
+    char command[1024] = {0};
+    sprintf(command, "%s", "create table meters(ts timestamp, f float, n int, bin1 binary(20), c nchar(20), bin2 binary(20)) tags(area int, city binary(20), dist nchar(20), street binary(20));");
+    res = taos_query(taos, command);
+    if ((res) && (0 == taos_errno(res))) {
+        okPrint("%s created\n", "meters");
+    } else {
+        errorPrint("%s() LN%d: %s\n",
+                __func__, __LINE__, taos_errstr(res));
+        taos_free_result(res);
+        exit(1);
+    }
     taos_free_result(res);
 
-    char command[1024] = {0};
     for (int64_t i = 0; i < g_num_of_tb; i ++) {
-//        sprintf(command, "create table t%"PRId64" using meters tags(%"PRId64", '%s', '%s');",
-//                i, i, (i%2)?"beijing":"shanghai", (i%2)?"朝阳区":"黄浦区");
-        sprintf(command, "create table t%"PRId64" using meters tags(%"PRId64", '%s', '%s');",
-                i, i, (i%2)?"beijing":"shanghai", (i%2)?"chaoyang":"huangpu");
+        sprintf(command, "create table t%"PRId64" using meters "
+                "tags(%"PRId64", '%s', '%s', '%s');",
+                i, i, (i%2)?"beijing":"shanghai",
+                (i%2)?"朝阳区":"黄浦区",
+                (i%2)?"长安街":"中山路");
+/*        sprintf(command, "create table t%"PRId64" using meters "
+                "tags(%"PRId64", '%s', '%s', '%s');",
+                i, i,
+                (i%2)?"beijing":"shanghai",
+                (i%2)?"chaoyang":"huangpu",
+                (i%2?"changan street":"jianguo rd"));
+                */
         res = taos_query(taos,  command);
         if ((res) && (0 == taos_errno(res))) {
             okPrint("t%" PRId64 " created\n", i);
@@ -86,11 +111,15 @@ static void prepare_data(TAOS* taos) {
         int64_t j = 0;
         int64_t total = 0;
         int64_t affected;
-        for (; j < g_num_of_rec -1; j ++) {
+        for (; j < g_num_of_rec -2; j ++) {
             sprintf(command, "insert into t%"PRId64" "
-                    "values(%" PRId64 ", %f, %"PRId64", '%c%d', '%c%d')",
-                    i, 1650000000000+j, (float)j, j, 'a'+(int)j%25, rand(),
-                    'z' - (int)j%25, rand());
+                    "values(%" PRId64 ", %f, %"PRId64", "
+                    "'%c%d', '%s%c%d', '%c%d')",
+                    i, 1650000000000+j, (float)j, j,
+                    'a'+(int)j%25, rand(),
+                    "涛思", 'z' - (int)j%25, rand(),
+                    'b' - (int)j%25, rand()
+                    );
             res = taos_query(taos,  command);
             if ((res) && (0 == taos_errno(res))) {
                 affected = taos_affected_rows(res);
@@ -101,8 +130,25 @@ static void prepare_data(TAOS* taos) {
             }
             taos_free_result(res);
         }
-        sprintf(command, "insert into t%"PRId64" values(%" PRId64 ", NULL, NULL, NULL, NULL)",
-                i, 1650000000000+j+1);
+        sprintf(command, "insert into t%"PRId64" values(%" PRId64 ", "
+                "NULL, NULL, NULL, NULL, NULL)",
+                i, 1650000000000+j);
+        res = taos_query(taos,  command);
+        if ((res) && (0 == taos_errno(res))) {
+            affected = taos_affected_rows(res);
+            total += affected;
+        } else {
+            errorPrint("%s() LN%d: %s\n",
+                    __func__, __LINE__, taos_errstr(res));
+        }
+        sprintf(command, "insert into t%"PRId64" "
+                "values(%" PRId64 ", %f, %"PRId64", "
+                "'%c%d', '%s%c%d', '%c%d')",
+                i, 1650000000000+j+1, (float)j, j,
+                'a'+(int)j%25, rand(),
+                "数据", 'z' - (int)j%25, rand(),
+                'b' - (int)j%25, rand()
+               );
         res = taos_query(taos,  command);
         if ((res) && (0 == taos_errno(res))) {
             affected = taos_affected_rows(res);
@@ -113,7 +159,8 @@ static void prepare_data(TAOS* taos) {
         }
         taos_free_result(res);
 
-        printf("insert %"PRId64" records into t%"PRId64", total affected rows: %"PRId64"\n", j, i, total);
+        okPrint("insert %"PRId64" records into t%"PRId64", "
+                "total affected rows: %"PRId64"\n", j, i, total);
     }
 }
 
@@ -127,29 +174,107 @@ static int print_result(char *tbname, TAOS_RES* res, int block) {
         printf("fields[%d].name=%s, fields[%d].type=%d, fields[%d].bytes=%d\n",
                 f, fields[f].name, f, fields[f].type, f, fields[f].bytes);
     }
+
     if (block) {
-        warnPrint("%s() LN%d, call taos_fetch_block()\n", __func__, __LINE__);
+        warnPrint("%s", "call taos_fetch_block()\n");
         int rows = 0;
         while ((rows = taos_fetch_block(res, &row))) {
+            int *lengths = taos_fetch_lengths(res);
+            for (int f = 0; f < num_fields; f++) {
+                if ((fields[f].type != TSDB_DATA_TYPE_VARCHAR)
+                        && (fields[f].type != TSDB_DATA_TYPE_NCHAR)
+                        && (fields[f].type != TSDB_DATA_TYPE_JSON)) {
+                    printf("col%d type is %d, no need get offset\n",
+                            f, fields[f].type);
+                    for (int64_t c = 0; c < rows; c++) {
+                        switch(fields[f].type) {
+                            case TSDB_DATA_TYPE_TIMESTAMP:
+                                if (taos_is_null(res, c, f)) {
+                                    printf("col%d, row: %"PRId64" "
+                                            "value: NULL\n", f, c);
+                                } else {
+                                    printf("col%d, row: %"PRId64", "
+                                            "value: %"PRId64"\n",
+                                            f, c,
+                                            *(int64_t*)(row[f]+c*sizeof(int64_t)));
+                                }
+                                break;
+
+                            case TSDB_DATA_TYPE_INT:
+                                if (taos_is_null(res, c, f)) {
+                                    printf("col%d, row: %"PRId64" "
+                                            "value: NULL\n", f, c);
+                                } else {
+                                    printf("col%d, row: %"PRId64", "
+                                            "value: %d\n",
+                                            f, c,
+                                            *(int32_t*)(row[f]+c*sizeof(int32_t)));
+                                }
+                                break;
+
+                            case TSDB_DATA_TYPE_FLOAT:
+                                if (taos_is_null(res, c, f)) {
+                                    printf("col%d, row: %"PRId64" "
+                                            "value: NULL\n", f, c);
+                                } else {
+                                    printf("col%d, row: %"PRId64", "
+                                            "value: %f\n",
+                                            f, c,
+                                            *(float*)(row[f]+c*sizeof(float)));
+                                }
+                                break;
+
+                            default:
+                                printf("type: %d is not processed\n",
+                                        fields[f].type);
+                                break;
+                        }
+                    }
+                } else {
+                    int *offsets = taos_get_column_data_offset(res, f);
+                    if (offsets) {
+                        for (int c = 0; c < rows; c++) {
+                            if (offsets[c] != -1) {
+                                int length = *(int16_t*)(row[f] + offsets[c]);
+                                char *buf = calloc(1, length + 1);
+                                strncpy(buf, (char *)(row[f] + offsets[c] + 2), length);
+                                printf("row: %d, col: %d, offset: %d, length: %d, content: %s\n",
+                                        c, f, offsets[c], length, buf);
+                                free(buf);
+                            } else {
+                                printf("row: %d, col: %d, offset: -1, means content is NULL\n",
+                                        c, f);
+                            }
+                        }
+                    } else {
+                        errorPrint("%s() LN%d: col%d's offsets is NULL\n",
+                                __func__, __LINE__, f);
+                    }
+                }
+            }
             num_rows += rows;
         }
     } else {
-        warnPrint("%s() LN%d, call taos_fetch_rows()\n", __func__, __LINE__);
+        warnPrint("%s", "call taos_fetch_rows()\n");
         while ((row = taos_fetch_row(res))) {
             char temp[256] = {0};
             taos_print_row(temp, row, fields, num_fields);
             puts(temp);
-            num_rows ++;
 
             int* lengths = taos_fetch_lengths(res);
             if (lengths) {
                 for (int c = 0; c < num_fields; c++) {
-                    printf("length of column %d is %d\n", c, lengths[c]);
+                    printf("row: %"PRId64", col: %d, is_null: %s, length of column %d is %d\n",
+                            num_rows, c,
+                            taos_is_null(res, num_rows, c)?"True":"False",
+                            c, lengths[c]);
                 }
             } else {
                 errorPrint("%s() LN%d: %s's lengths is NULL\n",
                         __func__, __LINE__, tbname);
             }
+
+            num_rows ++;
         }
     }
 
@@ -172,8 +297,8 @@ static void verify_query(TAOS* taos) {
                 int field_count = taos_field_count(res);
                 printf("field_count: %d\n", field_count);
                 int64_t rows = print_result(tbname, res, i % 2);
-                printf("rows is: %"PRId64"\n", rows);
-
+                okPrint("total query %s result rows is: %"PRId64"\n",
+                        tbname, rows);
             } else {
                 errorPrint("%s() LN%d: %s\n",
                         __func__, __LINE__, taos_errstr(res));
@@ -207,7 +332,7 @@ int main(int argc, char *argv[]) {
     verify_query(taos);
 
     taos_close(taos);
-    printf("done\n");
+    okPrint("%s", "done\n");
 
     return 0;
 }

include/common/tmsg.h

@@ -70,11 +70,7 @@ typedef uint16_t tmsg_t;
 #define TSDB_IE_TYPE_DNODE_EXT   6
 #define TSDB_IE_TYPE_DNODE_STATE 7
 
-enum {
-  CONN_TYPE__QUERY = 1,
-  CONN_TYPE__TMQ,
-  CONN_TYPE__MAX
-};
+enum { CONN_TYPE__QUERY = 1, CONN_TYPE__TMQ, CONN_TYPE__MAX };
 
 enum {
   HEARTBEAT_KEY_DBINFO = 1,
@@ -342,13 +338,13 @@ int32_t tSerializeSConnectReq(void* buf, int32_t bufLen, SConnectReq* pReq);
 int32_t tDeserializeSConnectReq(void* buf, int32_t bufLen, SConnectReq* pReq);
 
 typedef struct {
-  int32_t acctId;
-  int64_t clusterId;
+  int32_t  acctId;
+  int64_t  clusterId;
   uint32_t connId;
-  int8_t  superUser;
-  int8_t  connType;
-  SEpSet  epSet;
-  char    sVersion[128];
+  int8_t   superUser;
+  int8_t   connType;
+  SEpSet   epSet;
+  char     sVersion[128];
 } SConnectRsp;
 
 int32_t tSerializeSConnectRsp(void* buf, int32_t bufLen, SConnectRsp* pRsp);
@@ -663,14 +659,13 @@ typedef struct {
   int32_t outputLen;
   int32_t bufSize;
   int64_t signature;
-  int32_t commentSize;
-  int32_t codeSize;
-  char    pComment[TSDB_FUNC_COMMENT_LEN];
-  char    pCode[TSDB_FUNC_CODE_LEN];
+  char*   pComment;
+  char*   pCode;
 } SCreateFuncReq;
 
 int32_t tSerializeSCreateFuncReq(void* buf, int32_t bufLen, SCreateFuncReq* pReq);
 int32_t tDeserializeSCreateFuncReq(void* buf, int32_t bufLen, SCreateFuncReq* pReq);
+void    tFreeSCreateFuncReq(SCreateFuncReq* pReq);
 
 typedef struct {
   char   name[TSDB_FUNC_NAME_LEN];
@@ -687,6 +682,7 @@ typedef struct {
 
 int32_t tSerializeSRetrieveFuncReq(void* buf, int32_t bufLen, SRetrieveFuncReq* pReq);
 int32_t tDeserializeSRetrieveFuncReq(void* buf, int32_t bufLen, SRetrieveFuncReq* pReq);
+void    tFreeSRetrieveFuncReq(SRetrieveFuncReq* pReq);
 
 typedef struct {
   char    name[TSDB_FUNC_NAME_LEN];
@@ -698,8 +694,8 @@ typedef struct {
   int64_t signature;
   int32_t commentSize;
   int32_t codeSize;
-  char    pComment[TSDB_FUNC_COMMENT_LEN];
-  char    pCode[TSDB_FUNC_CODE_LEN];
+  char*   pComment;
+  char*   pCode;
 } SFuncInfo;
 
 typedef struct {
@@ -709,6 +705,7 @@ typedef struct {
 
 int32_t tSerializeSRetrieveFuncRsp(void* buf, int32_t bufLen, SRetrieveFuncRsp* pRsp);
 int32_t tDeserializeSRetrieveFuncRsp(void* buf, int32_t bufLen, SRetrieveFuncRsp* pRsp);
+void    tFreeSRetrieveFuncRsp(SRetrieveFuncRsp* pRsp);
 
 typedef struct {
   int32_t statusInterval;
@@ -1209,12 +1206,17 @@ typedef struct {
   int32_t code;
 } STaskDropRsp;
 
+#define STREAM_TRIGGER_AT_ONCE      1
+#define STREAM_TRIGGER_WINDOW_CLOSE 2
+
 typedef struct {
-  char   name[TSDB_TOPIC_FNAME_LEN];
-  char   outputSTbName[TSDB_TABLE_FNAME_LEN];
-  int8_t igExists;
-  char*  sql;
-  char*  ast;
+  char    name[TSDB_TOPIC_FNAME_LEN];
+  char    outputSTbName[TSDB_TABLE_FNAME_LEN];
+  int8_t  igExists;
+  char*   sql;
+  char*   ast;
+  int8_t  triggerType;
+  int64_t watermark;
 } SCMCreateStreamReq;
 
 typedef struct {
@@ -1666,14 +1668,14 @@ typedef struct {
   int32_t  pid;
   char     fqdn[TSDB_FQDN_LEN];
   int32_t  subPlanNum;
-  SArray*  subDesc;    // SArray<SQuerySubDesc>
+  SArray*  subDesc;  // SArray<SQuerySubDesc>
 } SQueryDesc;
 
 typedef struct {
-  uint32_t   connId;
-  int32_t    pid;
-  char       app[TSDB_APP_NAME_LEN];
-  SArray*    queryDesc;   // SArray<SQueryDesc>
+  uint32_t connId;
+  int32_t  pid;
+  char     app[TSDB_APP_NAME_LEN];
+  SArray*  queryDesc;  // SArray<SQueryDesc>
 } SQueryHbReqBasic;
 
 typedef struct {
@@ -1737,7 +1739,7 @@ static FORCE_INLINE void tFreeClientHbReq(void* pReq) {
     }
     taosMemoryFreeClear(req->query);
   }
-  
+
   if (req->info) {
     tFreeReqKvHash(req->info);
     taosHashCleanup(req->info);

include/common/trow.h

@@ -48,9 +48,12 @@ extern "C" {
 #define TD_VTYPE_NONE 0x02U  // none or unknown/undefined
 #define TD_VTYPE_MAX  0x03U  //
 
-#define TD_VTYPE_NORM_BYTE 0x0U
-#define TD_VTYPE_NULL_BYTE 0x55U
-#define TD_VTYPE_NONE_BYTE 0xAAU
+#define TD_VTYPE_NORM_BYTE_I 0x0U
+#define TD_VTYPE_NULL_BYTE_I 0xFFU
+
+#define TD_VTYPE_NORM_BYTE_II 0x0U
+#define TD_VTYPE_NULL_BYTE_II 0x55U
+#define TD_VTYPE_NONE_BYTE_II 0xAAU
 
 #define TD_ROWS_ALL_NORM  0x00U
 #define TD_ROWS_NULL_NORM 0x01U
@@ -162,38 +165,39 @@ typedef struct {
   int32_t  extendedRowSize;
 } SRowBuilder;
 
-#define TD_ROW_HEAD_LEN (sizeof(STSRow))
+#define TD_ROW_HEAD_LEN  (sizeof(STSRow))
 #define TD_ROW_NCOLS_LEN (sizeof(col_id_t))
 
-#define TD_ROW_INFO(r) ((r)->info)
-#define TD_ROW_TYPE(r) ((r)->type)
-#define TD_ROW_DELETE(r) ((r)->del)
-#define TD_ROW_ENDIAN(r) ((r)->endian)
-#define TD_ROW_SVER(r) ((r)->sver)
-#define TD_ROW_NCOLS(r) ((r)->data)  // only valid for SKvRow
-#define TD_ROW_DATA(r) ((r)->data)
-#define TD_ROW_LEN(r) ((r)->len)
-#define TD_ROW_KEY(r) ((r)->ts)
+#define TD_ROW_INFO(r)     ((r)->info)
+#define TD_ROW_TYPE(r)     ((r)->type)
+#define TD_ROW_DELETE(r)   ((r)->del)
+#define TD_ROW_ENDIAN(r)   ((r)->endian)
+#define TD_ROW_SVER(r)     ((r)->sver)
+#define TD_ROW_NCOLS(r)    ((r)->data)  // only valid for SKvRow
+#define TD_ROW_DATA(r)     ((r)->data)
+#define TD_ROW_LEN(r)      ((r)->len)
+#define TD_ROW_KEY(r)      ((r)->ts)
+#define TD_ROW_VER(r)      ((r)->ver)
 #define TD_ROW_KEY_ADDR(r) (r)
 
 // N.B. If without STSchema, getExtendedRowSize() is used to get the rowMaxBytes and
 // (int32_t)ceil((double)nCols/TD_VTYPE_PARTS) should be added if TD_SUPPORT_BITMAP defined.
 #define TD_ROW_MAX_BYTES_FROM_SCHEMA(s) (schemaTLen(s) + TD_ROW_HEAD_LEN)
 
-#define TD_ROW_SET_INFO(r, i) (TD_ROW_INFO(r) = (i))
-#define TD_ROW_SET_TYPE(r, t) (TD_ROW_TYPE(r) = (t))
-#define TD_ROW_SET_DELETE(r) (TD_ROW_DELETE(r) = 1)
-#define TD_ROW_SET_SVER(r, v) (TD_ROW_SVER(r) = (v))
-#define TD_ROW_SET_LEN(r, l) (TD_ROW_LEN(r) = (l))
+#define TD_ROW_SET_INFO(r, i)  (TD_ROW_INFO(r) = (i))
+#define TD_ROW_SET_TYPE(r, t)  (TD_ROW_TYPE(r) = (t))
+#define TD_ROW_SET_DELETE(r)   (TD_ROW_DELETE(r) = 1)
+#define TD_ROW_SET_SVER(r, v)  (TD_ROW_SVER(r) = (v))
+#define TD_ROW_SET_LEN(r, l)   (TD_ROW_LEN(r) = (l))
 #define TD_ROW_SET_NCOLS(r, n) (*(col_id_t *)TD_ROW_NCOLS(r) = (n))
 
 #define TD_ROW_IS_DELETED(r) (TD_ROW_DELETE(r) == 1)
-#define TD_IS_TP_ROW(r) (TD_ROW_TYPE(r) == TD_ROW_TP)
-#define TD_IS_KV_ROW(r) (TD_ROW_TYPE(r) == TD_ROW_KV)
-#define TD_IS_TP_ROW_T(t) ((t) == TD_ROW_TP)
-#define TD_IS_KV_ROW_T(t) ((t) == TD_ROW_KV)
+#define TD_IS_TP_ROW(r)      (TD_ROW_TYPE(r) == TD_ROW_TP)
+#define TD_IS_KV_ROW(r)      (TD_ROW_TYPE(r) == TD_ROW_KV)
+#define TD_IS_TP_ROW_T(t)    ((t) == TD_ROW_TP)
+#define TD_IS_KV_ROW_T(t)    ((t) == TD_ROW_KV)
 
-#define TD_BOOL_STR(b) ((b) ? "true" : "false")
+#define TD_BOOL_STR(b)       ((b) ? "true" : "false")
 #define isUtilizeKVRow(k, d) ((k) < ((d)*KVRatioConvert))
 
 #define TD_ROW_COL_IDX(r) POINTER_SHIFT(TD_ROW_DATA(r), sizeof(col_id_t))
@@ -221,8 +225,12 @@ static FORCE_INLINE int32_t tdSetBitmapValTypeI(void *pBitmap, int16_t colIdx, T
 static FORCE_INLINE int32_t tdSetBitmapValTypeII(void *pBitmap, int16_t colIdx, TDRowValT valType);
 static FORCE_INLINE int32_t tdSetBitmapValType(void *pBitmap, int16_t colIdx, TDRowValT valType, int8_t bitmapMode);
 int32_t                     tdSetBitmapValTypeN(void *pBitmap, int16_t nEle, TDRowValT valType, int8_t bitmapMode);
-static FORCE_INLINE int32_t tdGetBitmapValTypeI(void *pBitmap, int16_t colIdx, TDRowValT *pValType);
-static FORCE_INLINE int32_t tdGetBitmapValTypeII(void *pBitmap, int16_t colIdx, TDRowValT *pValType);
+static FORCE_INLINE int32_t tdGetBitmapValTypeI(const void *pBitmap, int16_t colIdx, TDRowValT *pValType);
+static FORCE_INLINE int32_t tdGetBitmapValTypeII(const void *pBitmap, int16_t colIdx, TDRowValT *pValType);
+static FORCE_INLINE int32_t tdGetBitmapValType(const void *pBitmap, int16_t colIdx, TDRowValT *pValType,
+                                               int8_t bitmapMode);
+static FORCE_INLINE bool    tdIsBitmapValTypeNorm(const void *pBitmap, int16_t idx, int8_t bitmapMode);
+bool                        tdIsBitmapBlkNorm(const void *pBitmap, int32_t numOfBits, int8_t bitmapMode);
 int32_t tdAppendValToDataCol(SDataCol *pCol, TDRowValT valType, const void *val, int32_t numOfRows, int32_t maxPoints,
                              int8_t bitmapMode);
 static FORCE_INLINE int32_t tdAppendColValToTpRow(SRowBuilder *pBuilder, TDRowValT valType, const void *val,
@@ -230,7 +238,7 @@ static FORCE_INLINE int32_t tdAppendColValToTpRow(SRowBuilder *pBuilder, TDRowVa
 static FORCE_INLINE int32_t tdAppendColValToKvRow(SRowBuilder *pBuilder, TDRowValT valType, const void *val,
                                                   bool isCopyVarData, int8_t colType, int16_t colIdx, int32_t offset,
                                                   col_id_t colId);
-int32_t tdAppendSTSRowToDataCol(STSRow *pRow, STSchema *pSchema, SDataCols *pCols);
+int32_t                     tdAppendSTSRowToDataCol(STSRow *pRow, STSchema *pSchema, SDataCols *pCols);
 
 /**
  * @brief
@@ -324,7 +332,16 @@ static FORCE_INLINE int32_t tdSetBitmapValTypeII(void *pBitmap, int16_t colIdx,
   return TSDB_CODE_SUCCESS;
 }
 
-static FORCE_INLINE int32_t tdGetBitmapValType(void *pBitmap, int16_t colIdx, TDRowValT *pValType, int8_t bitmapMode) {
+static FORCE_INLINE bool tdIsBitmapValTypeNorm(const void *pBitmap, int16_t idx, int8_t bitmapMode) {
+  TDRowValT valType = 0;
+  tdGetBitmapValType(pBitmap, idx, &valType, bitmapMode);
+  if (tdValTypeIsNorm(valType)) {
+    return true;
+  }
+  return false;
+}
+
+static FORCE_INLINE int32_t tdGetBitmapValType(const void *pBitmap, int16_t colIdx, TDRowValT *pValType, int8_t bitmapMode) {
   switch (bitmapMode) {
     case 0:
       tdGetBitmapValTypeII(pBitmap, colIdx, pValType);
@@ -349,7 +366,7 @@ static FORCE_INLINE int32_t tdGetBitmapValType(void *pBitmap, int16_t colIdx, TD
  * @param pValType
  * @return FORCE_INLINE
  */
-static FORCE_INLINE int32_t tdGetBitmapValTypeII(void *pBitmap, int16_t colIdx, TDRowValT *pValType) {
+static FORCE_INLINE int32_t tdGetBitmapValTypeII(const void *pBitmap, int16_t colIdx, TDRowValT *pValType) {
   if (!pBitmap || colIdx < 0) {
     TASSERT(0);
     terrno = TSDB_CODE_INVALID_PARA;
@@ -448,7 +465,7 @@ static FORCE_INLINE int32_t tdSetBitmapValTypeI(void *pBitmap, int16_t colIdx, T
  * @param pValType
  * @return FORCE_INLINE
  */
-static FORCE_INLINE int32_t tdGetBitmapValTypeI(void *pBitmap, int16_t colIdx, TDRowValT *pValType) {
+static FORCE_INLINE int32_t tdGetBitmapValTypeI(const void *pBitmap, int16_t colIdx, TDRowValT *pValType) {
   if (!pBitmap || colIdx < 0) {
     TASSERT(0);
     terrno = TSDB_CODE_INVALID_PARA;

include/common/ttokendef.h

@@ -195,45 +195,46 @@
 #define TK_CAST                           177
 #define TK_NOW                            178
 #define TK_TODAY                          179
-#define TK_COUNT                          180
-#define TK_FIRST                          181
-#define TK_LAST                           182
-#define TK_LAST_ROW                       183
-#define TK_BETWEEN                        184
-#define TK_IS                             185
-#define TK_NK_LT                          186
-#define TK_NK_GT                          187
-#define TK_NK_LE                          188
-#define TK_NK_GE                          189
-#define TK_NK_NE                          190
-#define TK_MATCH                          191
-#define TK_NMATCH                         192
-#define TK_CONTAINS                       193
-#define TK_JOIN                           194
-#define TK_INNER                          195
-#define TK_SELECT                         196
-#define TK_DISTINCT                       197
-#define TK_WHERE                          198
-#define TK_PARTITION                      199
-#define TK_BY                             200
-#define TK_SESSION                        201
-#define TK_STATE_WINDOW                   202
-#define TK_SLIDING                        203
-#define TK_FILL                           204
-#define TK_VALUE                          205
-#define TK_NONE                           206
-#define TK_PREV                           207
-#define TK_LINEAR                         208
-#define TK_NEXT                           209
-#define TK_GROUP                          210
-#define TK_HAVING                         211
-#define TK_ORDER                          212
-#define TK_SLIMIT                         213
-#define TK_SOFFSET                        214
-#define TK_LIMIT                          215
-#define TK_OFFSET                         216
-#define TK_ASC                            217
-#define TK_NULLS                          218
+#define TK_TIMEZONE                       180
+#define TK_COUNT                          181
+#define TK_FIRST                          182
+#define TK_LAST                           183
+#define TK_LAST_ROW                       184
+#define TK_BETWEEN                        185
+#define TK_IS                             186
+#define TK_NK_LT                          187
+#define TK_NK_GT                          188
+#define TK_NK_LE                          189
+#define TK_NK_GE                          190
+#define TK_NK_NE                          191
+#define TK_MATCH                          192
+#define TK_NMATCH                         193
+#define TK_CONTAINS                       194
+#define TK_JOIN                           195
+#define TK_INNER                          196
+#define TK_SELECT                         197
+#define TK_DISTINCT                       198
+#define TK_WHERE                          199
+#define TK_PARTITION                      200
+#define TK_BY                             201
+#define TK_SESSION                        202
+#define TK_STATE_WINDOW                   203
+#define TK_SLIDING                        204
+#define TK_FILL                           205
+#define TK_VALUE                          206
+#define TK_NONE                           207
+#define TK_PREV                           208
+#define TK_LINEAR                         209
+#define TK_NEXT                           210
+#define TK_GROUP                          211
+#define TK_HAVING                         212
+#define TK_ORDER                          213
+#define TK_SLIMIT                         214
+#define TK_SOFFSET                        215
+#define TK_LIMIT                          216
+#define TK_OFFSET                         217
+#define TK_ASC                            218
+#define TK_NULLS                          219
 
 #define TK_NK_SPACE                       300
 #define TK_NK_COMMENT                     301

include/common/ttypes.h

@@ -248,8 +248,8 @@ typedef struct tDataTypeDescriptor {
                       int32_t outputSize, char algorithm, char *const buffer, int32_t bufferSize);
   int32_t (*decompFunc)(const char *const input, int32_t compressedSize, const int32_t nelements, char *const output,
                         int32_t outputSize, char algorithm, char *const buffer, int32_t bufferSize);
-  void (*statisFunc)(const void *pData, int32_t numofrow, int64_t *min, int64_t *max, int64_t *sum, int16_t *minindex,
-                     int16_t *maxindex, int16_t *numofnull);
+  void (*statisFunc)(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numofrow, int64_t *min,
+                     int64_t *max, int64_t *sum, int16_t *minindex, int16_t *maxindex, int16_t *numofnull);
 } tDataTypeDescriptor;
 
 extern tDataTypeDescriptor tDataTypes[TSDB_DATA_TYPE_MAX];

include/libs/nodes/cmdnodes.h

@@ -272,14 +272,9 @@ typedef struct SKillStmt {
   int32_t targetId;
 } SKillStmt;
 
-typedef enum EStreamTriggerType {
-  STREAM_TRIGGER_AT_ONCE = 1,
-  STREAM_TRIGGER_WINDOW_CLOSE
-} EStreamTriggerType;
-
 typedef struct SStreamOptions {
   ENodeType type;
-  EStreamTriggerType triggerType;
+  int8_t triggerType;
   SNode* pWatermark;
 } SStreamOptions;
 

include/libs/nodes/plannodes.h

@@ -53,6 +53,11 @@ typedef struct SScanLogicNode {
   double ratio;
   SNodeList* pDynamicScanFuncs;
   int32_t dataRequired;
+  int64_t interval;
+  int64_t offset;
+  int64_t sliding;
+  int8_t intervalUnit;
+  int8_t slidingUnit;
 } SScanLogicNode;
 
 typedef struct SJoinLogicNode {
@@ -109,6 +114,8 @@ typedef struct SWindowLogicNode {
   int64_t sessionGap;
   SNode* pTspk;
   SNode* pStateExpr;
+  int8_t triggerType;
+  int64_t watermark;
 } SWindowLogicNode;
 
 typedef struct SSortLogicNode {
@@ -206,6 +213,11 @@ typedef struct STableScanPhysiNode {
   double ratio;
   int32_t dataRequired;
   SNodeList* pDynamicScanFuncs;
+  int64_t interval;
+  int64_t offset;
+  int64_t sliding;
+  int8_t intervalUnit;
+  int8_t slidingUnit;
 } STableScanPhysiNode;
 
 typedef STableScanPhysiNode STableSeqScanPhysiNode;
@@ -251,6 +263,8 @@ typedef struct SWinodwPhysiNode {
   SNodeList* pExprs;   // these are expression list of parameter expression of function
   SNodeList* pFuncs;
   SNode* pTspk; // timestamp primary key
+  int8_t triggerType;
+  int64_t watermark;
 } SWinodwPhysiNode;
 
 typedef struct SIntervalPhysiNode {
@@ -260,7 +274,6 @@ typedef struct SIntervalPhysiNode {
   int64_t    sliding;
   int8_t     intervalUnit;
   int8_t     slidingUnit;
-  uint8_t    precision;
   SFillNode* pFill;
 } SIntervalPhysiNode;
 
@@ -342,8 +355,11 @@ typedef struct SQueryPlan {
   int32_t numOfSubplans;
   SNodeList* pSubplans; // Element is SNodeListNode. The execution level of subplan, starting from 0.
   SExplainInfo explainInfo;
+  SNodeList* pPlaceholderValues;
 } SQueryPlan;
 
+void nodesWalkPhysiPlan(SNode* pNode, FNodeWalker walker, void* pContext);
+
 #ifdef __cplusplus
 }
 #endif

include/libs/nodes/querynodes.h

@@ -57,6 +57,7 @@ typedef enum EColumnType {
 typedef struct SColumnNode {
   SExprNode node; // QUERY_NODE_COLUMN
   uint64_t tableId;
+  int8_t tableType;
   col_id_t colId;
   EColumnType colType; // column or tag
   char dbName[TSDB_DB_NAME_LEN];
@@ -81,6 +82,7 @@ typedef struct SValueNode {
   bool isDuration;
   bool translate;
   bool genByCalc;
+  int16_t placeholderNo;
   union {
     bool b;
     int64_t i;
@@ -196,8 +198,8 @@ typedef struct SStateWindowNode {
 
 typedef struct SSessionWindowNode {
   ENodeType type; // QUERY_NODE_SESSION_WINDOW
-  SNode* pCol; // timestamp primary key
-  SNode* pGap; // gap between two session window(in microseconds)
+  SColumnNode* pCol; // timestamp primary key
+  SValueNode* pGap; // gap between two session window(in microseconds)
 } SSessionWindowNode;
 
 typedef struct SIntervalWindowNode {

include/libs/planner/planner.h

@@ -21,6 +21,7 @@ extern "C" {
 #endif
 
 #include "plannodes.h"
+#include "taos.h"
 
 typedef struct SPlanContext {
   uint64_t queryId;
@@ -30,6 +31,9 @@ typedef struct SPlanContext {
   bool topicQuery;
   bool streamQuery;
   bool showRewrite;
+  int8_t triggerType;
+  int64_t watermark;
+  bool isStmtQuery;
 } SPlanContext;
 
 // Create the physical plan for the query, according to the AST.
@@ -41,6 +45,9 @@ int32_t qCreateQueryPlan(SPlanContext* pCxt, SQueryPlan** pPlan, SArray* pExecNo
 // @pSource one execution location of this group of datasource subplans 
 int32_t qSetSubplanExecutionNode(SSubplan* pSubplan, int32_t groupId, SDownstreamSourceNode* pSource);
 
+typedef TAOS_MULTI_BIND TAOS_BIND_v2; // todo remove
+int32_t qStmtBindParam(SQueryPlan* pPlan, TAOS_BIND_v2* pParams);
+
 // Convert to subplan to string for the scheduler to send to the executor
 int32_t qSubPlanToString(const SSubplan* pSubplan, char** pStr, int32_t* pLen);
 int32_t qStringToSubplan(const char* pStr, SSubplan** pSubplan);

include/libs/scalar/scalar.h

@@ -81,6 +81,7 @@ int32_t timeTruncateFunction(SScalarParam *pInput, int32_t inputNum, SScalarPara
 int32_t timeDiffFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 int32_t nowFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 int32_t todayFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t timezoneFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 
 bool getTimePseudoFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
 

include/libs/wal/wal.h

@@ -61,16 +61,16 @@ extern "C" {
     }                                                             \
   }
 
-#define WAL_HEAD_VER 0
+#define WAL_HEAD_VER     0
 #define WAL_NOSUFFIX_LEN 20
-#define WAL_SUFFIX_AT (WAL_NOSUFFIX_LEN + 1)
-#define WAL_LOG_SUFFIX "log"
+#define WAL_SUFFIX_AT    (WAL_NOSUFFIX_LEN + 1)
+#define WAL_LOG_SUFFIX   "log"
 #define WAL_INDEX_SUFFIX "idx"
-#define WAL_REFRESH_MS 1000
-#define WAL_MAX_SIZE (TSDB_MAX_WAL_SIZE + sizeof(SWalHead))
-#define WAL_PATH_LEN (TSDB_FILENAME_LEN + 12)
-#define WAL_FILE_LEN (WAL_PATH_LEN + 32)
-#define WAL_MAGIC 0xFAFBFCFDULL
+#define WAL_REFRESH_MS   1000
+#define WAL_MAX_SIZE     (TSDB_MAX_WAL_SIZE + sizeof(SWalHead))
+#define WAL_PATH_LEN     (TSDB_FILENAME_LEN + 12)
+#define WAL_FILE_LEN     (WAL_PATH_LEN + 32)
+#define WAL_MAGIC        0xFAFBFCFDULL
 
 #define WAL_CUR_FAILED 1
 

include/os/osMemory.h

@@ -36,12 +36,12 @@ void *taosMemoryStrDup(void *ptr);
 void taosMemoryFree(void *ptr);
 int32_t taosMemorySize(void *ptr);
 
-#define taosMemoryFreeClear(ptr) \
-  do {                           \
-    if (ptr) {                   \
-      taosMemoryFree((void*)ptr);       \
-      (ptr) = NULL;              \
-    }                            \
+#define taosMemoryFreeClear(ptr)   \
+  do {                             \
+    if (ptr) {                     \
+      taosMemoryFree((void *)ptr); \
+      (ptr) = NULL;                \
+    }                              \
   } while (0)
 
 #ifdef __cplusplus

include/util/taoserror.h

@@ -579,7 +579,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_INVALID_PORT              TAOS_DEF_ERROR_CODE(0, 0x2612)
 #define TSDB_CODE_PAR_INVALID_ENDPOINT          TAOS_DEF_ERROR_CODE(0, 0x2613)
 #define TSDB_CODE_PAR_EXPRIE_STATEMENT          TAOS_DEF_ERROR_CODE(0, 0x2614)
-#define TSDB_CODE_PAR_INTERVAL_VALUE_TOO_SMALL  TAOS_DEF_ERROR_CODE(0, 0x2615)
+#define TSDB_CODE_PAR_INTER_VALUE_TOO_SMALL     TAOS_DEF_ERROR_CODE(0, 0x2615)
 #define TSDB_CODE_PAR_DB_NOT_SPECIFIED          TAOS_DEF_ERROR_CODE(0, 0x2616)
 #define TSDB_CODE_PAR_INVALID_IDENTIFIER_NAME   TAOS_DEF_ERROR_CODE(0, 0x2617)
 #define TSDB_CODE_PAR_CORRESPONDING_STABLE_ERR  TAOS_DEF_ERROR_CODE(0, 0x2618)
@@ -597,7 +597,19 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_GROUPBY_WINDOW_COEXIST    TAOS_DEF_ERROR_CODE(0, 0x2624)
 #define TSDB_CODE_PAR_INVALID_OPTION_UNIT       TAOS_DEF_ERROR_CODE(0, 0x2625)
 #define TSDB_CODE_PAR_INVALID_KEEP_UNIT         TAOS_DEF_ERROR_CODE(0, 0x2626)
-#define TSDB_CODE_PAR_ONLY_ONE_JSON_TAG         TAOS_DEF_ERROR_CODE(0, 0x2627)
+#define TSDB_CODE_PAR_AGG_FUNC_NESTING          TAOS_DEF_ERROR_CODE(0, 0x2627)
+#define TSDB_CODE_PAR_INVALID_STATE_WIN_TYPE    TAOS_DEF_ERROR_CODE(0, 0x2628)
+#define TSDB_CODE_PAR_INVALID_STATE_WIN_COL     TAOS_DEF_ERROR_CODE(0, 0x2629)
+#define TSDB_CODE_PAR_INVALID_STATE_WIN_TABLE   TAOS_DEF_ERROR_CODE(0, 0x262A)
+#define TSDB_CODE_PAR_INTER_SESSION_GAP         TAOS_DEF_ERROR_CODE(0, 0x262B)
+#define TSDB_CODE_PAR_INTER_SESSION_COL         TAOS_DEF_ERROR_CODE(0, 0x262C)
+#define TSDB_CODE_PAR_INTER_OFFSET_NEGATIVE     TAOS_DEF_ERROR_CODE(0, 0x262D)
+#define TSDB_CODE_PAR_INTER_OFFSET_UNIT         TAOS_DEF_ERROR_CODE(0, 0x262E)
+#define TSDB_CODE_PAR_INTER_OFFSET_TOO_BIG      TAOS_DEF_ERROR_CODE(0, 0x262F)
+#define TSDB_CODE_PAR_INTER_SLIDING_UNIT        TAOS_DEF_ERROR_CODE(0, 0x2630)
+#define TSDB_CODE_PAR_INTER_SLIDING_TOO_BIG     TAOS_DEF_ERROR_CODE(0, 0x2631)
+#define TSDB_CODE_PAR_INTER_SLIDING_TOO_SMALL   TAOS_DEF_ERROR_CODE(0, 0x2632)
+#define TSDB_CODE_PAR_ONLY_ONE_JSON_TAG         TAOS_DEF_ERROR_CODE(0, 0x2633)
 
 //planner
 #define TSDB_CODE_PLAN_INTERNAL_ERROR           TAOS_DEF_ERROR_CODE(0, 0x2700)

include/util/tdef.h

@@ -128,17 +128,17 @@ extern const int32_t TYPE_BYTES[15];
 #define TSDB_INS_TABLE_QUERIES                "queries"
 #define TSDB_INS_TABLE_VNODES                 "vnodes"
 
-#define TSDB_PERFORMANCE_SCHEMA_DB            "performance_schema"
-#define TSDB_PERFS_TABLE_CONNECTIONS          "connections"
-#define TSDB_PERFS_TABLE_QUERIES              "queries"
-#define TSDB_PERFS_TABLE_TOPICS               "topics"
-#define TSDB_PERFS_TABLE_CONSUMERS            "consumers"
-#define TSDB_PERFS_TABLE_SUBSCRIBES           "subscribes"
+#define TSDB_PERFORMANCE_SCHEMA_DB   "performance_schema"
+#define TSDB_PERFS_TABLE_CONNECTIONS "connections"
+#define TSDB_PERFS_TABLE_QUERIES     "queries"
+#define TSDB_PERFS_TABLE_TOPICS      "topics"
+#define TSDB_PERFS_TABLE_CONSUMERS   "consumers"
+#define TSDB_PERFS_TABLE_SUBSCRIBES  "subscribes"
 
 #define TSDB_INDEX_TYPE_SMA      "SMA"
 #define TSDB_INDEX_TYPE_FULLTEXT "FULLTEXT"
 
-#define TSDB_INS_USER_STABLES_DBNAME_COLID    2
+#define TSDB_INS_USER_STABLES_DBNAME_COLID 2
 
 #define TSDB_TICK_PER_SECOND(precision)                      \
   ((int64_t)((precision) == TSDB_TIME_PRECISION_MILLI ? 1e3L \
@@ -234,8 +234,8 @@ typedef enum ELogicConditionType {
 #define TSDB_DB_FNAME_LEN   (TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN + TSDB_NAME_DELIMITER_LEN)
 
 #define TSDB_FUNC_NAME_LEN       65
-#define TSDB_FUNC_COMMENT_LEN    4096
-#define TSDB_FUNC_CODE_LEN       (65535 - 512)
+#define TSDB_FUNC_COMMENT_LEN    1024 * 1024
+#define TSDB_FUNC_CODE_LEN       10 * 1024 * 1024
 #define TSDB_FUNC_BUF_SIZE       512
 #define TSDB_FUNC_TYPE_SCALAR    1
 #define TSDB_FUNC_TYPE_AGGREGATE 2
@@ -346,12 +346,12 @@ typedef enum ELogicConditionType {
 #define TSDB_MAX_TOTAL_BLOCKS     10000
 #define TSDB_DEFAULT_TOTAL_BLOCKS 6
 
-#define TSDB_MIN_DAYS_PER_FILE     60    // unit minute
+#define TSDB_MIN_DAYS_PER_FILE     60  // unit minute
 #define TSDB_MAX_DAYS_PER_FILE     (3650 * 1440)
 #define TSDB_DEFAULT_DAYS_PER_FILE (10 * 1440)
 
 #define TSDB_MIN_KEEP     (1 * 1440)       // data in db to be reserved. unit minute
-#define TSDB_MAX_KEEP     (365000 * 1440) // data in db to be reserved.
+#define TSDB_MAX_KEEP     (365000 * 1440)  // data in db to be reserved.
 #define TSDB_DEFAULT_KEEP (3650 * 1440)    // ten years
 
 #define TSDB_MIN_MIN_ROW_FBLOCK     10
@@ -426,11 +426,11 @@ typedef enum ELogicConditionType {
 
 #define TSDB_DEFAULT_EXPLAIN_VERBOSE false
 
-#define TSDB_MIN_EXPLAIN_RATIO       0
-#define TSDB_MAX_EXPLAIN_RATIO       1
-#define TSDB_DEFAULT_EXPLAIN_RATIO   0.001
+#define TSDB_MIN_EXPLAIN_RATIO     0
+#define TSDB_MAX_EXPLAIN_RATIO     1
+#define TSDB_DEFAULT_EXPLAIN_RATIO 0.001
 
-#define TSDB_EXPLAIN_RESULT_ROW_SIZE 1024
+#define TSDB_EXPLAIN_RESULT_ROW_SIZE    1024
 #define TSDB_EXPLAIN_RESULT_COLUMN_NAME "QUERY PLAN"
 
 #define TSDB_MAX_JOIN_TABLE_NUM 10
@@ -516,13 +516,13 @@ enum {
   SND_WORKER_TYPE__UNIQUE,
 };
 
-#define MNODE_HANDLE -1
-#define QNODE_HANDLE 1
+#define MNODE_HANDLE   -1
+#define QNODE_HANDLE   1
 #define DEFAULT_HANDLE 0
 
-#define TSDB_CONFIG_OPTION_LEN  16
-#define TSDB_CONIIG_VALUE_LEN   48
-#define TSDB_CONFIG_NUMBER      8
+#define TSDB_CONFIG_OPTION_LEN 16
+#define TSDB_CONIIG_VALUE_LEN  48
+#define TSDB_CONFIG_NUMBER     8
 
 #define QUERY_ID_SIZE      20
 #define QUERY_OBJ_ID_SIZE  18
@@ -531,7 +531,6 @@ enum {
 
 #define MAX_NUM_STR_SIZE 40
 
-
 #ifdef __cplusplus
 }
 #endif

packaging/release.sh

@@ -64,11 +64,11 @@ cp ${install_files} ${install_dir}
 header_files="${top_dir}/include/client/taos.h ${top_dir}/include/util/taoserror.h"
 cp ${header_files} ${install_dir}/inc
  
-bin_files="${compile_dir}/source/dnode/mgmt/taosd ${compile_dir}/tools/shell/taos  ${compile_dir}/tests/test/c/create_table ${compile_dir}/tests/test/c/tmq_sim ${script_dir}/remove.sh"
+bin_files="${compile_dir}/build/bin/taosd ${compile_dir}/build/bin/taos  ${compile_dir}/build/bin/create_table ${compile_dir}/build/bin/tmq_sim ${script_dir}/remove.sh"
 cp ${bin_files} ${install_dir}/bin && chmod a+x ${install_dir}/bin/* || :
 
-cp ${compile_dir}/source/client/libtaos.so  ${install_dir}/lib/
-cp ${compile_dir}/source/libs/tdb/libtdb.so ${install_dir}/lib/
+cp ${compile_dir}/build/lib/libtaos.so  ${install_dir}/lib/
+cp ${compile_dir}/build/lib/libtdb.so ${install_dir}/lib/
 taostoolfile="${top_dir}/tools/taosTools-1.4.1-Linux-x64.tar.gz"
 cp ${taostoolfile} ${install_dir}/taos-tools 
 

source/client/CMakeLists.txt

 aux_source_directory(src CLIENT_SRC)
-add_library(taos ${CLIENT_SRC})
+add_library(taos SHARED ${CLIENT_SRC})
 target_include_directories(
     taos
     PUBLIC "${TD_SOURCE_DIR}/include/client"
@@ -11,6 +11,25 @@ target_link_libraries(
     PRIVATE os util common transport nodes parser command planner catalog scheduler function qcom
 )
 
+set_target_properties(
+    taos
+    PROPERTIES
+    VERSION ${TD_VER_NUMBER}
+    SOVERSION ${TD_VER_NUMBER}
+)
+
+add_library(taos_static STATIC ${CLIENT_SRC})
+target_include_directories(
+    taos_static
+    PUBLIC "${TD_SOURCE_DIR}/include/client"
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+)
+target_link_libraries(
+    taos_static
+    INTERFACE api
+    PRIVATE os util common transport nodes parser command planner catalog scheduler function qcom
+)
+
 if(${BUILD_TEST})
     ADD_SUBDIRECTORY(test)
 endif(${BUILD_TEST})
\ No newline at end of file

source/client/src/clientMain.c

@@ -69,9 +69,9 @@ void taos_cleanup(void) {
   rpcCleanup();
   catalogDestroy();
   schedulerDestroy();
-  taosCloseLog();
 
   tscInfo("all local resources released");
+  taosCloseLog();
 }
 
 setConfRet taos_set_config(const char *config) {

source/client/test/CMakeLists.txt

@@ -8,13 +8,13 @@ AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SOURCE_LIST)
 ADD_EXECUTABLE(clientTest clientTests.cpp)
 TARGET_LINK_LIBRARIES(
         clientTest
-        PUBLIC os util common transport parser catalog scheduler function gtest taos qcom
+        PUBLIC os util common transport parser catalog scheduler function gtest taos_static qcom
 )
 
 ADD_EXECUTABLE(tmqTest tmqTest.cpp)
 TARGET_LINK_LIBRARIES(
         tmqTest
-        PUBLIC os util common transport parser catalog scheduler function gtest taos qcom
+        PUBLIC os util common transport parser catalog scheduler function gtest taos_static qcom
 )
 
 TARGET_INCLUDE_DIRECTORIES(

source/client/test/clientTests.cpp

@@ -662,7 +662,7 @@ TEST(testCase, agg_query_tables) {
   TAOS_RES* pRes = taos_query(pConn, "use abc1");
   taos_free_result(pRes);
 
-  pRes = taos_query(pConn, "select * from test_block_raw.all_type");
+  pRes = taos_query(pConn, "select count(*) from tu");
   if (taos_errno(pRes) != 0) {
     printf("failed to select from table, reason:%s\n", taos_errstr(pRes));
     taos_free_result(pRes);
@@ -674,9 +674,6 @@ TEST(testCase, agg_query_tables) {
   int32_t     numOfFields = taos_num_fields(pRes);
 
   int32_t n = 0;
-  void* data = NULL;
-  int32_t code = taos_fetch_raw_block(pRes, &n, &data);
-
   char str[512] = {0};
   while ((pRow = taos_fetch_row(pRes)) != NULL) {
     int32_t* length = taos_fetch_lengths(pRes);

source/common/src/tdatablock.c

@@ -1100,6 +1100,11 @@ int32_t colInfoDataEnsureCapacity(SColumnInfoData* pColumn, uint32_t numOfRows)
 
     pColumn->nullbitmap = tmp;
     memset(pColumn->nullbitmap, 0, BitmapLen(numOfRows));
+
+    if (pColumn->info.type == TSDB_DATA_TYPE_NULL) {
+      return TSDB_CODE_SUCCESS;
+    }
+
     assert(pColumn->info.bytes);
     tmp = taosMemoryRealloc(pColumn->pData, numOfRows * pColumn->info.bytes);
     if (tmp == NULL) {

source/common/src/tglobal.c

@@ -238,7 +238,7 @@ static int32_t taosLoadCfg(SConfig *pCfg, const char *inputCfgDir, const char *e
 
   if (cfgLoad(pCfg, CFG_STYPE_CFG_FILE, cfgDir) != 0) {
     if (cfgLoad(pCfg, CFG_STYPE_CFG_FILE, cfgFile) != 0) {
-      uError("failed to load from config file:%s since %s", cfgFile, terrstr());
+      uInfo("cfg file:%s not read since %s", cfgFile, terrstr());
       return 0;
     }
   }

source/common/src/tmsg.c

@@ -142,10 +142,10 @@ static int32_t tSerializeSClientHbReq(SCoder *pEncoder, const SClientHbReq *pReq
       if (tEncodeU32(pEncoder, pReq->query->connId) < 0) return -1;
       if (tEncodeI32(pEncoder, pReq->query->pid) < 0) return -1;
       if (tEncodeCStr(pEncoder, pReq->query->app) < 0) return -1;
-      
+
       int32_t num = taosArrayGetSize(pReq->query->queryDesc);
       if (tEncodeI32(pEncoder, num) < 0) return -1;
-      
+
       for (int32_t i = 0; i < num; ++i) {
         SQueryDesc *desc = taosArrayGet(pReq->query->queryDesc, i);
         if (tEncodeCStr(pEncoder, desc->sql) < 0) return -1;
@@ -169,7 +169,7 @@ static int32_t tSerializeSClientHbReq(SCoder *pEncoder, const SClientHbReq *pReq
       if (tEncodeI32(pEncoder, queryNum) < 0) return -1;
     }
   }
-  
+
   int32_t kvNum = taosHashGetSize(pReq->info);
   if (tEncodeI32(pEncoder, kvNum) < 0) return -1;
   void *pIter = taosHashIterate(pReq->info, NULL);
@@ -200,7 +200,7 @@ static int32_t tDeserializeSClientHbReq(SCoder *pDecoder, SClientHbReq *pReq) {
       if (num > 0) {
         pReq->query->queryDesc = taosArrayInit(num, sizeof(SQueryDesc));
         if (NULL == pReq->query->queryDesc) return -1;
-        
+
         for (int32_t i = 0; i < num; ++i) {
           SQueryDesc desc = {0};
           if (tDecodeCStrTo(pDecoder, desc.sql) < 0) return -1;
@@ -217,7 +217,7 @@ static int32_t tDeserializeSClientHbReq(SCoder *pDecoder, SClientHbReq *pReq) {
           if (snum > 0) {
             desc.subDesc = taosArrayInit(snum, sizeof(SQuerySubDesc));
             if (NULL == desc.subDesc) return -1;
-            
+
             for (int32_t m = 0; m < snum; ++m) {
               SQuerySubDesc sDesc = {0};
               if (tDecodeI64(pDecoder, &sDesc.tid) < 0) return -1;
@@ -254,7 +254,7 @@ static int32_t tSerializeSClientHbRsp(SCoder *pEncoder, const SClientHbRsp *pRsp
   int32_t queryNum = 0;
   if (pRsp->query) {
     queryNum = 1;
-    if (tEncodeI32(pEncoder, queryNum) < 0) return -1;  
+    if (tEncodeI32(pEncoder, queryNum) < 0) return -1;
     if (tEncodeU32(pEncoder, pRsp->query->connId) < 0) return -1;
     if (tEncodeU64(pEncoder, pRsp->query->killRid) < 0) return -1;
     if (tEncodeI32(pEncoder, pRsp->query->totalDnodes) < 0) return -1;
@@ -262,9 +262,9 @@ static int32_t tSerializeSClientHbRsp(SCoder *pEncoder, const SClientHbRsp *pRsp
     if (tEncodeI8(pEncoder, pRsp->query->killConnection) < 0) return -1;
     if (tEncodeSEpSet(pEncoder, &pRsp->query->epSet) < 0) return -1;
   } else {
-    if (tEncodeI32(pEncoder, queryNum) < 0) return -1;  
+    if (tEncodeI32(pEncoder, queryNum) < 0) return -1;
   }
-  
+
   int32_t kvNum = taosArrayGetSize(pRsp->info);
   if (tEncodeI32(pEncoder, kvNum) < 0) return -1;
   for (int32_t i = 0; i < kvNum; i++) {
@@ -1492,10 +1492,25 @@ int32_t tSerializeSCreateFuncReq(void *buf, int32_t bufLen, SCreateFuncReq *pReq
   if (tEncodeI32(&encoder, pReq->outputLen) < 0) return -1;
   if (tEncodeI32(&encoder, pReq->bufSize) < 0) return -1;
   if (tEncodeI64(&encoder, pReq->signature) < 0) return -1;
-  if (tEncodeI32(&encoder, pReq->commentSize) < 0) return -1;
-  if (tEncodeI32(&encoder, pReq->codeSize) < 0) return -1;
-  if (tEncodeCStr(&encoder, pReq->pComment) < 0) return -1;
-  if (tEncodeCStr(&encoder, pReq->pCode) < 0) return -1;
+
+  int32_t codeSize = 0;
+  if (pReq->pCode != NULL) {
+    codeSize = strlen(pReq->pCode) + 1;
+  }
+  if (tEncodeI32(&encoder, codeSize) < 0) return -1;
+  if (pReq->pCode != NULL) {
+    if (tEncodeCStr(&encoder, pReq->pCode) < 0) return -1;
+  }
+
+  int32_t commentSize = 0;
+  if (pReq->pComment != NULL) {
+    commentSize = strlen(pReq->pComment) + 1;
+  }
+  if (tEncodeI32(&encoder, commentSize) < 0) return -1;
+  if (pReq->pComment != NULL) {
+    if (tEncodeCStr(&encoder, pReq->pComment) < 0) return -1;
+  }
+
   tEndEncode(&encoder);
 
   int32_t tlen = encoder.pos;
@@ -1516,16 +1531,40 @@ int32_t tDeserializeSCreateFuncReq(void *buf, int32_t bufLen, SCreateFuncReq *pR
   if (tDecodeI32(&decoder, &pReq->outputLen) < 0) return -1;
   if (tDecodeI32(&decoder, &pReq->bufSize) < 0) return -1;
   if (tDecodeI64(&decoder, &pReq->signature) < 0) return -1;
-  if (tDecodeI32(&decoder, &pReq->commentSize) < 0) return -1;
-  if (tDecodeI32(&decoder, &pReq->codeSize) < 0) return -1;
-  if (tDecodeCStrTo(&decoder, pReq->pComment) < 0) return -1;
-  if (tDecodeCStrTo(&decoder, pReq->pCode) < 0) return -1;
+
+  int32_t codeSize = 0;
+  if (tDecodeI32(&decoder, &codeSize) < 0) return -1;
+  if (codeSize > 0) {
+    pReq->pCode = taosMemoryCalloc(1, codeSize);
+    if (pReq->pCode == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      return -1;
+    }
+    if (tDecodeCStrTo(&decoder, pReq->pCode) < 0) return -1;
+  }
+
+  int32_t commentSize = 0;
+  if (tDecodeI32(&decoder, &commentSize) < 0) return -1;
+  if (commentSize > 0) {
+    pReq->pComment = taosMemoryCalloc(1, commentSize);
+    if (pReq->pComment == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      return -1;
+    }
+    if (tDecodeCStrTo(&decoder, pReq->pComment) < 0) return -1;
+  }
+
   tEndDecode(&decoder);
 
   tCoderClear(&decoder);
   return 0;
 }
 
+void tFreeSCreateFuncReq(SCreateFuncReq *pReq) {
+  taosMemoryFree(pReq->pCode);
+  taosMemoryFree(pReq->pComment);
+}
+
 int32_t tSerializeSDropFuncReq(void *buf, int32_t bufLen, SDropFuncReq *pReq) {
   SCoder encoder = {0};
   tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
@@ -1594,6 +1633,8 @@ int32_t tDeserializeSRetrieveFuncReq(void *buf, int32_t bufLen, SRetrieveFuncReq
   return 0;
 }
 
+void tFreeSRetrieveFuncReq(SRetrieveFuncReq *pReq) { taosArrayDestroy(pReq->pFuncNames); }
+
 int32_t tSerializeSRetrieveFuncRsp(void *buf, int32_t bufLen, SRetrieveFuncRsp *pRsp) {
   SCoder encoder = {0};
   tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
@@ -1612,10 +1653,10 @@ int32_t tSerializeSRetrieveFuncRsp(void *buf, int32_t bufLen, SRetrieveFuncRsp *
     if (tEncodeI32(&encoder, pInfo->outputLen) < 0) return -1;
     if (tEncodeI32(&encoder, pInfo->bufSize) < 0) return -1;
     if (tEncodeI64(&encoder, pInfo->signature) < 0) return -1;
-    if (tEncodeI32(&encoder, pInfo->commentSize) < 0) return -1;
     if (tEncodeI32(&encoder, pInfo->codeSize) < 0) return -1;
-    if (tEncodeCStr(&encoder, pInfo->pComment) < 0) return -1;
+    if (tEncodeI32(&encoder, pInfo->commentSize) < 0) return -1;
     if (tEncodeCStr(&encoder, pInfo->pCode) < 0) return -1;
+    if (tEncodeCStr(&encoder, pInfo->pComment) < 0) return -1;
   }
 
   tEndEncode(&encoder);
@@ -1644,10 +1685,17 @@ int32_t tDeserializeSRetrieveFuncRsp(void *buf, int32_t bufLen, SRetrieveFuncRsp
     if (tDecodeI32(&decoder, &fInfo.outputLen) < 0) return -1;
     if (tDecodeI32(&decoder, &fInfo.bufSize) < 0) return -1;
     if (tDecodeI64(&decoder, &fInfo.signature) < 0) return -1;
-    if (tDecodeI32(&decoder, &fInfo.commentSize) < 0) return -1;
     if (tDecodeI32(&decoder, &fInfo.codeSize) < 0) return -1;
-    if (tDecodeCStrTo(&decoder, fInfo.pComment) < 0) return -1;
+    if (tDecodeI32(&decoder, &fInfo.commentSize) < 0) return -1;
+    fInfo.pCode = taosMemoryCalloc(1, fInfo.codeSize);
+    fInfo.pComment = taosMemoryCalloc(1, fInfo.commentSize);
+    if (fInfo.pCode == NULL || fInfo.pComment == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      return -1;
+    }
+
     if (tDecodeCStrTo(&decoder, fInfo.pCode) < 0) return -1;
+    if (tDecodeCStrTo(&decoder, fInfo.pComment) < 0) return -1;
     taosArrayPush(pRsp->pFuncInfos, &fInfo);
   }
   tEndDecode(&decoder);
@@ -1656,6 +1704,16 @@ int32_t tDeserializeSRetrieveFuncRsp(void *buf, int32_t bufLen, SRetrieveFuncRsp
   return 0;
 }
 
+void tFreeSRetrieveFuncRsp(SRetrieveFuncRsp *pRsp) {
+  int32_t size = taosArrayGetSize(pRsp->pFuncInfos);
+  for (int32_t i = 0; i < size; ++i) {
+    SFuncInfo *pInfo = taosArrayGet(pRsp->pFuncInfos, i);
+    taosMemoryFree(pInfo->pCode);
+    taosMemoryFree(pInfo->pComment);
+  }
+  taosArrayDestroy(pRsp->pFuncInfos);
+}
+
 int32_t tSerializeSCreateDbReq(void *buf, int32_t bufLen, SCreateDbReq *pReq) {
   SCoder encoder = {0};
   tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
@@ -3381,6 +3439,8 @@ int32_t tSerializeSCMCreateStreamReq(void *buf, int32_t bufLen, const SCMCreateS
   if (tEncodeI8(&encoder, pReq->igExists) < 0) return -1;
   if (tEncodeI32(&encoder, sqlLen) < 0) return -1;
   if (tEncodeI32(&encoder, astLen) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->triggerType) < 0) return -1;
+  if (tEncodeI64(&encoder, pReq->watermark) < 0) return -1;
   if (sqlLen > 0 && tEncodeCStr(&encoder, pReq->sql) < 0) return -1;
   if (astLen > 0 && tEncodeCStr(&encoder, pReq->ast) < 0) return -1;
 
@@ -3404,6 +3464,8 @@ int32_t tDeserializeSCMCreateStreamReq(void *buf, int32_t bufLen, SCMCreateStrea
   if (tDecodeI8(&decoder, &pReq->igExists) < 0) return -1;
   if (tDecodeI32(&decoder, &sqlLen) < 0) return -1;
   if (tDecodeI32(&decoder, &astLen) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->triggerType) < 0) return -1;
+  if (tDecodeI64(&decoder, &pReq->watermark) < 0) return -1;
 
   if (sqlLen > 0) {
     pReq->sql = taosMemoryCalloc(1, sqlLen + 1);

source/common/src/trow.c

@@ -16,10 +16,19 @@
 #define _DEFAULT_SOURCE
 #include "trow.h"
 
-const uint8_t tdVTypeByte[3] = {
-    TD_VTYPE_NORM_BYTE,  // TD_VTYPE_NORM
-    TD_VTYPE_NONE_BYTE,  // TD_VTYPE_NONE
-    TD_VTYPE_NULL_BYTE,  // TD_VTYPE_NULL
+const uint8_t tdVTypeByte[2][3] = {{
+                                       // 2 bits
+                                       TD_VTYPE_NORM_BYTE_II,
+                                       TD_VTYPE_NONE_BYTE_II,
+                                       TD_VTYPE_NULL_BYTE_II,
+                                   },
+                                   {
+                                       // 1 bit
+                                       TD_VTYPE_NORM_BYTE_I,
+                                       TD_VTYPE_NULL_BYTE_I,
+                                       TD_VTYPE_NULL_BYTE_I, // padding
+                                   }
+
 };
 
 // declaration
@@ -266,21 +275,53 @@ static FORCE_INLINE void dataColSetNullAt(SDataCol *pCol, int index, bool setBit
 //   }
 // }
 
+/**
+ * @brief Set bitmap area by byte preferentially and then by bit.
+ *
+ * @param pBitmap
+ * @param nEle
+ * @param valType
+ * @param bitmapMode 0 for 2 bits, 1 for 1 bit
+ * @return int32_t
+ */
 int32_t tdSetBitmapValTypeN(void *pBitmap, int16_t nEle, TDRowValT valType, int8_t bitmapMode) {
   TASSERT(valType < TD_VTYPE_MAX);
-  int16_t nBytes = nEle / TD_VTYPE_PARTS;
+  int32_t nBytes = (bitmapMode == 0 ? nEle / TD_VTYPE_PARTS : nEle / TD_VTYPE_PARTS_I);
+  uint8_t vTypeByte = tdVTypeByte[bitmapMode][valType];
   for (int i = 0; i < nBytes; ++i) {
-    *(uint8_t *)pBitmap = tdVTypeByte[valType];
+    *(uint8_t *)pBitmap = vTypeByte;
     pBitmap = POINTER_SHIFT(pBitmap, 1);
   }
-  int16_t nLeft = nEle - nBytes * TD_VTYPE_BITS;
 
+  int32_t nLeft = nEle - nBytes * (bitmapMode == 0 ? TD_VTYPE_BITS : TD_VTYPE_BITS_I);
   for (int j = 0; j < nLeft; ++j) {
     tdSetBitmapValType(pBitmap, j, valType, bitmapMode);
   }
   return TSDB_CODE_SUCCESS;
 }
 
+bool tdIsBitmapBlkNorm(const void *pBitmap, int32_t numOfBits, int8_t bitmapMode) {
+  int32_t nBytes = (bitmapMode == 0 ? numOfBits / TD_VTYPE_PARTS : numOfBits / TD_VTYPE_PARTS_I);
+  uint8_t vTypeByte = tdVTypeByte[bitmapMode][TD_VTYPE_NORM];
+  for (int i = 0; i < nBytes; ++i) {
+    if (*((uint8_t *)pBitmap) != vTypeByte) {
+      return false;
+    }
+    pBitmap = POINTER_SHIFT(pBitmap, 1);
+  }
+
+  int32_t nLeft = numOfBits - nBytes * (bitmapMode == 0 ? TD_VTYPE_BITS : TD_VTYPE_BITS_I);
+
+  for (int j = 0; j < nLeft; ++j) {
+    uint8_t vType;
+    tdGetBitmapValType(pBitmap, j, &vType, bitmapMode);
+    if (vType != TD_VTYPE_NORM) {
+      return false;
+    }
+  }
+  return true;
+}
+
 static FORCE_INLINE void dataColSetNoneAt(SDataCol *pCol, int index, bool setBitmap, int8_t bitmapMode) {
   if (IS_VAR_DATA_TYPE(pCol->type)) {
     pCol->dataOff[index] = pCol->len;

source/common/src/ttime.c

@@ -415,7 +415,11 @@ int32_t convertStringToTimestamp(int16_t type, char *inputData, int64_t timePrec
   if (type == TSDB_DATA_TYPE_BINARY) {
     newColData = taosMemoryCalloc(1,  charLen + 1);
     memcpy(newColData, varDataVal(inputData), charLen);
-    taosParseTime(newColData, timeVal, charLen, (int32_t)timePrec, 0);
+    bool ret = taosParseTime(newColData, timeVal, charLen, (int32_t)timePrec, 0);
+    if (ret != TSDB_CODE_SUCCESS) {
+      taosMemoryFree(newColData);
+      return ret;
+    }
     taosMemoryFree(newColData);
   } else if (type == TSDB_DATA_TYPE_NCHAR) {
     newColData = taosMemoryCalloc(1,  charLen / TSDB_NCHAR_SIZE + 1);
@@ -425,7 +429,11 @@ int32_t convertStringToTimestamp(int16_t type, char *inputData, int64_t timePrec
       return TSDB_CODE_FAILED;
     }
     newColData[len] = 0;
-    taosParseTime(newColData, timeVal, len + 1, (int32_t)timePrec, 0);
+    bool ret = taosParseTime(newColData, timeVal, len + 1, (int32_t)timePrec, 0);
+    if (ret != TSDB_CODE_SUCCESS) {
+      taosMemoryFree(newColData);
+      return ret;
+    }
     taosMemoryFree(newColData);
   } else {
     return TSDB_CODE_FAILED;

source/common/src/ttypes.c

@@ -16,6 +16,7 @@
 #define _DEFAULT_SOURCE
 #include "ttypes.h"
 #include "tcompression.h"
+#include "trow.h"
 
 const int32_t TYPE_BYTES[15] = {
     -1,                      // TSDB_DATA_TYPE_NULL
@@ -49,8 +50,8 @@ const int32_t TYPE_BYTES[15] = {
     }                                                                          \
   } while (0)
 
-static void getStatics_bool(const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
-                            int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+static void getStatics_bool(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
+                            int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   int8_t *data = (int8_t *)pData;
   *min = INT64_MAX;
   *max = INT64_MIN;
@@ -60,7 +61,8 @@ static void getStatics_bool(const void *pData, int32_t numOfRow, int64_t *min, i
   assert(numOfRow <= INT16_MAX);
 
   for (int32_t i = 0; i < numOfRow; ++i) {
-    if (data[i] == TSDB_DATA_BOOL_NULL) {
+    // if (data[i] == TSDB_DATA_BOOL_NULL) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
       continue;
     }
@@ -69,8 +71,8 @@ static void getStatics_bool(const void *pData, int32_t numOfRow, int64_t *min, i
   }
 }
 
-static void getStatics_i8(const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
-                          int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+static void getStatics_i8(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
+                          int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   int8_t *data = (int8_t *)pData;
   *min = INT64_MAX;
   *max = INT64_MIN;
@@ -80,7 +82,8 @@ static void getStatics_i8(const void *pData, int32_t numOfRow, int64_t *min, int
   assert(numOfRow <= INT16_MAX);
 
   for (int32_t i = 0; i < numOfRow; ++i) {
-    if (((uint8_t)data[i]) == TSDB_DATA_TINYINT_NULL) {
+    // if (((uint8_t)data[i]) == TSDB_DATA_TINYINT_NULL) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
       continue;
     }
@@ -89,8 +92,8 @@ static void getStatics_i8(const void *pData, int32_t numOfRow, int64_t *min, int
   }
 }
 
-static void getStatics_u8(const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
-                          int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+static void getStatics_u8(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
+                          int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   uint8_t *data = (uint8_t *)pData;
   uint64_t _min = UINT64_MAX;
   uint64_t _max = 0;
@@ -102,7 +105,8 @@ static void getStatics_u8(const void *pData, int32_t numOfRow, int64_t *min, int
   assert(numOfRow <= INT16_MAX);
 
   for (int32_t i = 0; i < numOfRow; ++i) {
-    if (((uint8_t)data[i]) == TSDB_DATA_UTINYINT_NULL) {
+    // if (((uint8_t)data[i]) == TSDB_DATA_UTINYINT_NULL) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
       continue;
     }
@@ -115,8 +119,8 @@ static void getStatics_u8(const void *pData, int32_t numOfRow, int64_t *min, int
   *sum = _sum;
 }
 
-static void getStatics_i16(const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
-                           int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+static void getStatics_i16(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
+                           int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   int16_t *data = (int16_t *)pData;
   *min = INT64_MAX;
   *max = INT64_MIN;
@@ -126,7 +130,8 @@ static void getStatics_i16(const void *pData, int32_t numOfRow, int64_t *min, in
   assert(numOfRow <= INT16_MAX);
 
   for (int32_t i = 0; i < numOfRow; ++i) {
-    if (((uint16_t)data[i]) == TSDB_DATA_SMALLINT_NULL) {
+    // if (((uint16_t)data[i]) == TSDB_DATA_SMALLINT_NULL) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
       continue;
     }
@@ -135,8 +140,8 @@ static void getStatics_i16(const void *pData, int32_t numOfRow, int64_t *min, in
   }
 }
 
-static void getStatics_u16(const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
-                           int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+static void getStatics_u16(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
+                           int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   uint16_t *data = (uint16_t *)pData;
   uint64_t  _min = UINT64_MAX;
   uint64_t  _max = 0;
@@ -148,7 +153,8 @@ static void getStatics_u16(const void *pData, int32_t numOfRow, int64_t *min, in
   assert(numOfRow <= INT16_MAX);
 
   for (int32_t i = 0; i < numOfRow; ++i) {
-    if (((uint16_t)data[i]) == TSDB_DATA_USMALLINT_NULL) {
+    // if (((uint16_t)data[i]) == TSDB_DATA_USMALLINT_NULL) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
       continue;
     }
@@ -161,8 +167,8 @@ static void getStatics_u16(const void *pData, int32_t numOfRow, int64_t *min, in
   *sum = _sum;
 }
 
-static void getStatics_i32(const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
-                           int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+static void getStatics_i32(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
+                           int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   int32_t *data = (int32_t *)pData;
   *min = INT64_MAX;
   *max = INT64_MIN;
@@ -172,7 +178,8 @@ static void getStatics_i32(const void *pData, int32_t numOfRow, int64_t *min, in
   assert(numOfRow <= INT16_MAX);
 
   for (int32_t i = 0; i < numOfRow; ++i) {
-    if (((uint32_t)data[i]) == TSDB_DATA_INT_NULL) {
+    // if (((uint32_t)data[i]) == TSDB_DATA_INT_NULL) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
       continue;
     }
@@ -181,8 +188,8 @@ static void getStatics_i32(const void *pData, int32_t numOfRow, int64_t *min, in
   }
 }
 
-static void getStatics_u32(const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
-                           int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+static void getStatics_u32(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
+                           int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   uint32_t *data = (uint32_t *)pData;
   uint64_t  _min = UINT64_MAX;
   uint64_t  _max = 0;
@@ -194,7 +201,8 @@ static void getStatics_u32(const void *pData, int32_t numOfRow, int64_t *min, in
   assert(numOfRow <= INT16_MAX);
 
   for (int32_t i = 0; i < numOfRow; ++i) {
-    if (((uint32_t)data[i]) == TSDB_DATA_UINT_NULL) {
+    // if (((uint32_t)data[i]) == TSDB_DATA_UINT_NULL) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
       continue;
     }
@@ -207,8 +215,8 @@ static void getStatics_u32(const void *pData, int32_t numOfRow, int64_t *min, in
   *sum = _sum;
 }
 
-static void getStatics_i64(const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
-                           int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+static void getStatics_i64(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
+                           int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   int64_t *data = (int64_t *)pData;
   *min = INT64_MAX;
   *max = INT64_MIN;
@@ -218,7 +226,8 @@ static void getStatics_i64(const void *pData, int32_t numOfRow, int64_t *min, in
   assert(numOfRow <= INT16_MAX);
 
   for (int32_t i = 0; i < numOfRow; ++i) {
-    if (((uint64_t)data[i]) == TSDB_DATA_BIGINT_NULL) {
+    // if (((uint64_t)data[i]) == TSDB_DATA_BIGINT_NULL) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
       continue;
     }
@@ -227,8 +236,8 @@ static void getStatics_i64(const void *pData, int32_t numOfRow, int64_t *min, in
   }
 }
 
-static void getStatics_u64(const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
-                           int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+static void getStatics_u64(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
+                           int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   uint64_t *data = (uint64_t *)pData;
   uint64_t  _min = UINT64_MAX;
   uint64_t  _max = 0;
@@ -240,7 +249,8 @@ static void getStatics_u64(const void *pData, int32_t numOfRow, int64_t *min, in
   assert(numOfRow <= INT16_MAX);
 
   for (int32_t i = 0; i < numOfRow; ++i) {
-    if (((uint64_t)data[i]) == TSDB_DATA_UBIGINT_NULL) {
+    // if (((uint64_t)data[i]) == TSDB_DATA_UBIGINT_NULL) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
       continue;
     }
@@ -253,8 +263,8 @@ static void getStatics_u64(const void *pData, int32_t numOfRow, int64_t *min, in
   *sum = _sum;
 }
 
-static void getStatics_f(const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
-                         int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+static void getStatics_f(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
+                         int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   float *data = (float *)pData;
   float  fmin = FLT_MAX;
   float  fmax = -FLT_MAX;
@@ -265,7 +275,8 @@ static void getStatics_f(const void *pData, int32_t numOfRow, int64_t *min, int6
   assert(numOfRow <= INT16_MAX);
 
   for (int32_t i = 0; i < numOfRow; ++i) {
-    if ((*(uint32_t *)&(data[i])) == TSDB_DATA_FLOAT_NULL) {
+    // if ((*(uint32_t *)&(data[i])) == TSDB_DATA_FLOAT_NULL) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
       continue;
     }
@@ -289,8 +300,8 @@ static void getStatics_f(const void *pData, int32_t numOfRow, int64_t *min, int6
   SET_DOUBLE_VAL(min, fmin);
 }
 
-static void getStatics_d(const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
-                         int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+static void getStatics_d(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
+                         int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   double *data = (double *)pData;
   double  dmin = DBL_MAX;
   double  dmax = -DBL_MAX;
@@ -301,7 +312,8 @@ static void getStatics_d(const void *pData, int32_t numOfRow, int64_t *min, int6
   assert(numOfRow <= INT16_MAX);
 
   for (int32_t i = 0; i < numOfRow; ++i) {
-    if ((*(uint64_t *)&(data[i])) == TSDB_DATA_DOUBLE_NULL) {
+    // if ((*(uint64_t *)&(data[i])) == TSDB_DATA_DOUBLE_NULL) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
       continue;
     }
@@ -325,13 +337,14 @@ static void getStatics_d(const void *pData, int32_t numOfRow, int64_t *min, int6
   SET_DOUBLE_PTR(min, &dmin);
 }
 
-static void getStatics_bin(const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
-                           int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+static void getStatics_bin(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
+                           int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   const char *data = pData;
   assert(numOfRow <= INT16_MAX);
 
   for (int32_t i = 0; i < numOfRow; ++i) {
-    if (isNull(data, TSDB_DATA_TYPE_BINARY)) {
+    // if (isNull(data, TSDB_DATA_TYPE_BINARY)) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
     }
 
@@ -345,13 +358,14 @@ static void getStatics_bin(const void *pData, int32_t numOfRow, int64_t *min, in
   *maxIndex = 0;
 }
 
-static void getStatics_nchr(const void *pData, int32_t numOfRow, int64_t *min, int64_t *max, int64_t *sum,
-                            int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
+static void getStatics_nchr(int8_t bitmapMode, const void *pBitmap, const void *pData, int32_t numOfRow, int64_t *min,
+                            int64_t *max, int64_t *sum, int16_t *minIndex, int16_t *maxIndex, int16_t *numOfNull) {
   const char *data = pData;
   assert(numOfRow <= INT16_MAX);
 
   for (int32_t i = 0; i < numOfRow; ++i) {
-    if (isNull(data, TSDB_DATA_TYPE_NCHAR)) {
+    // if (isNull(data, TSDB_DATA_TYPE_NCHAR)) {
+    if (!tdIsBitmapValTypeNorm(pBitmap, i, bitmapMode)) {
       (*numOfNull) += 1;
     }
 
@@ -392,19 +406,19 @@ tDataTypeDescriptor tDataTypes[TSDB_DATA_TYPE_MAX] = {
 };
 
 char tTokenTypeSwitcher[13] = {
-    TSDB_DATA_TYPE_NULL,    // no type
-    TSDB_DATA_TYPE_BINARY,  // TK_ID
-    TSDB_DATA_TYPE_BOOL,    // TK_BOOL
-    TSDB_DATA_TYPE_BIGINT,  // TK_TINYINT
-    TSDB_DATA_TYPE_BIGINT,  // TK_SMALLINT
-    TSDB_DATA_TYPE_BIGINT,  // TK_INTEGER
-    TSDB_DATA_TYPE_BIGINT,  // TK_BIGINT
-    TSDB_DATA_TYPE_DOUBLE,  // TK_FLOAT
-    TSDB_DATA_TYPE_DOUBLE,  // TK_DOUBLE
-    TSDB_DATA_TYPE_BINARY,  // TK_STRING
-    TSDB_DATA_TYPE_BIGINT,  // TK_TIMESTAMP
+    TSDB_DATA_TYPE_NULL,     // no type
+    TSDB_DATA_TYPE_BINARY,   // TK_ID
+    TSDB_DATA_TYPE_BOOL,     // TK_BOOL
+    TSDB_DATA_TYPE_BIGINT,   // TK_TINYINT
+    TSDB_DATA_TYPE_BIGINT,   // TK_SMALLINT
+    TSDB_DATA_TYPE_BIGINT,   // TK_INTEGER
+    TSDB_DATA_TYPE_BIGINT,   // TK_BIGINT
+    TSDB_DATA_TYPE_DOUBLE,   // TK_FLOAT
+    TSDB_DATA_TYPE_DOUBLE,   // TK_DOUBLE
+    TSDB_DATA_TYPE_BINARY,   // TK_STRING
+    TSDB_DATA_TYPE_BIGINT,   // TK_TIMESTAMP
     TSDB_DATA_TYPE_VARCHAR,  // TK_BINARY
-    TSDB_DATA_TYPE_NCHAR,   // TK_NCHAR
+    TSDB_DATA_TYPE_NCHAR,    // TK_NCHAR
 };
 
 float  floatMin = -FLT_MAX, floatMax = FLT_MAX;

source/dnode/mgmt/interface/CMakeLists.txt

@@ -6,5 +6,5 @@ target_include_directories(
     PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
 target_link_libraries(
-    dnode_interface cjson mnode vnode qnode snode bnode wal sync taos tfs monitor
+    dnode_interface cjson mnode vnode qnode snode bnode wal sync taos_static tfs monitor
 )
\ No newline at end of file

source/dnode/mgmt/mgmt_mnode/src/mmFile.c

@@ -121,7 +121,7 @@ int32_t mmWriteFile(SMgmtWrapper *pWrapper, SDCreateMnodeReq *pReq, bool deploye
   int32_t len = 0;
   int32_t maxLen = 4096;
   char   *content = taosMemoryCalloc(1, maxLen + 1);
-  
+
   len += snprintf(content + len, maxLen - len, "{\n");
   len += snprintf(content + len, maxLen - len, "  \"mnodes\": [{\n");
 

source/dnode/mgmt/mgmt_vnode/src/vmHandle.c

@@ -83,9 +83,9 @@ int32_t vmProcessGetVnodeLoadsReq(SMgmtWrapper *pWrapper, SNodeMsg *pReq) {
 
 static void vmGenerateVnodeCfg(SCreateVnodeReq *pCreate, SVnodeCfg *pCfg) {
   pCfg->vgId = pCreate->vgId;
-  pCfg->wsize = pCreate->cacheBlockSize;
-  pCfg->ssize = pCreate->cacheBlockSize;
-  pCfg->lsize = pCreate->cacheBlockSize;
+  pCfg->wsize = pCreate->cacheBlockSize * 1024 * 1024;
+  pCfg->ssize = 1024;
+  pCfg->lsize = 1024 * 1024;
   pCfg->isHeapAllocator = true;
   pCfg->ttl = 4;
   pCfg->keep = pCreate->daysToKeep0;
@@ -96,13 +96,12 @@ static void vmGenerateVnodeCfg(SCreateVnodeReq *pCreate, SVnodeCfg *pCfg) {
   pCfg->tsdbCfg.keep1 = pCreate->daysToKeep0;
   pCfg->tsdbCfg.lruCacheSize = pCreate->cacheBlockSize;
   pCfg->tsdbCfg.retentions = pCreate->pRetensions;
-  pCfg->metaCfg.lruSize = pCreate->cacheBlockSize;
-  pCfg->walCfg.fsyncPeriod = pCreate->fsyncPeriod;
-  pCfg->walCfg.level = pCreate->walLevel;
-  pCfg->walCfg.retentionPeriod = 10;
-  pCfg->walCfg.retentionSize = 128;
-  pCfg->walCfg.rollPeriod = 128;
-  pCfg->walCfg.segSize = 128;
+  pCfg->walCfg.level = TAOS_WAL_WRITE;
+  pCfg->walCfg.fsyncPeriod = 0;
+  pCfg->walCfg.retentionPeriod = 0;
+  pCfg->walCfg.retentionSize = 0;
+  pCfg->walCfg.rollPeriod = 0;
+  pCfg->walCfg.segSize = 0;
   pCfg->walCfg.vgId = pCreate->vgId;
   pCfg->hashBegin = pCreate->hashBegin;
   pCfg->hashEnd = pCreate->hashEnd;
@@ -160,13 +159,10 @@ int32_t vmProcessCreateVnodeReq(SVnodesMgmt *pMgmt, SNodeMsg *pMsg) {
   msgCb.queueFps[APPLY_QUEUE] = vmPutMsgToApplyQueue;
   msgCb.qsizeFp = vmGetQueueSize;
 
-  vnodeCfg.msgCb = msgCb;
-  vnodeCfg.pTfs = pMgmt->pTfs;
-  vnodeCfg.dbId = wrapperCfg.dbUid;
-  SVnode *pImpl = vnodeOpen(wrapperCfg.path, &vnodeCfg);
+  SVnode *pImpl = vnodeOpen(path, pMgmt->pTfs, msgCb);
   if (pImpl == NULL) {
-    tFreeSCreateVnodeReq(&createReq);
     dError("vgId:%d, failed to create vnode since %s", createReq.vgId, terrstr());
+    tFreeSCreateVnodeReq(&createReq);
     return -1;
   }
 
@@ -175,7 +171,7 @@ int32_t vmProcessCreateVnodeReq(SVnodesMgmt *pMgmt, SNodeMsg *pMsg) {
     tFreeSCreateVnodeReq(&createReq);
     dError("vgId:%d, failed to open vnode since %s", createReq.vgId, terrstr());
     vnodeClose(pImpl);
-    vnodeDestroy(wrapperCfg.path);
+    vnodeDestroy(path, pMgmt->pTfs);
     terrno = code;
     return code;
   }
@@ -184,7 +180,7 @@ int32_t vmProcessCreateVnodeReq(SVnodesMgmt *pMgmt, SNodeMsg *pMsg) {
   if (code != 0) {
     tFreeSCreateVnodeReq(&createReq);
     vnodeClose(pImpl);
-    vnodeDestroy(wrapperCfg.path);
+    vnodeDestroy(path, pMgmt->pTfs);
     terrno = code;
     return code;
   }

source/dnode/mgmt/mgmt_vnode/src/vmInt.c

@@ -84,6 +84,8 @@ int32_t vmOpenVnode(SVnodesMgmt *pMgmt, SWrapperCfg *pCfg, SVnode *pImpl) {
 }
 
 void vmCloseVnode(SVnodesMgmt *pMgmt, SVnodeObj *pVnode) {
+  char path[TSDB_FILENAME_LEN];
+
   taosWLockLatch(&pMgmt->latch);
   taosHashRemove(pMgmt->hash, &pVnode->vgId, sizeof(int32_t));
   taosWUnLockLatch(&pMgmt->latch);
@@ -104,7 +106,8 @@ void vmCloseVnode(SVnodesMgmt *pMgmt, SVnodeObj *pVnode) {
 
   if (pVnode->dropped) {
     dDebug("vgId:%d, vnode is destroyed for dropped:%d", pVnode->vgId, pVnode->dropped);
-    vnodeDestroy(pVnode->path);
+    snprintf(path, TSDB_FILENAME_LEN, "vnode%svnode%d", TD_DIRSEP, pVnode->vgId);
+    vnodeDestroy(path, pMgmt->pTfs);
   }
 
   taosMemoryFree(pVnode->path);
@@ -116,6 +119,7 @@ static void *vmOpenVnodeFunc(void *param) {
   SVnodeThread *pThread = param;
   SVnodesMgmt  *pMgmt = pThread->pMgmt;
   SDnode       *pDnode = pMgmt->pDnode;
+  char          path[TSDB_FILENAME_LEN];
 
   dDebug("thread:%d, start to open %d vnodes", pThread->threadIndex, pThread->vnodeNum);
   setThreadName("open-vnodes");
@@ -134,8 +138,8 @@ static void *vmOpenVnodeFunc(void *param) {
     msgCb.queueFps[FETCH_QUEUE] = vmPutMsgToFetchQueue;
     msgCb.queueFps[APPLY_QUEUE] = vmPutMsgToApplyQueue;
     msgCb.qsizeFp = vmGetQueueSize;
-    SVnodeCfg cfg = {.msgCb = msgCb, .pTfs = pMgmt->pTfs, .vgId = pCfg->vgId, .dbId = pCfg->dbUid};
-    SVnode   *pImpl = vnodeOpen(pCfg->path, &cfg);
+    snprintf(path, TSDB_FILENAME_LEN, "vnode%svnode%d", TD_DIRSEP, pCfg->vgId);
+    SVnode *pImpl = vnodeOpen(path, pMgmt->pTfs, msgCb);
     if (pImpl == NULL) {
       dError("vgId:%d, failed to open vnode by thread:%d", pCfg->vgId, pThread->threadIndex);
       pThread->failed++;
@@ -258,6 +262,7 @@ static void vmCleanup(SMgmtWrapper *pWrapper) {
   vmCloseVnodes(pMgmt);
   vmStopWorker(pMgmt);
   vnodeCleanup();
+  tfsClose(pMgmt->pTfs);
   // walCleanUp();
   taosMemoryFree(pMgmt);
   pWrapper->pMgmt = NULL;

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

@@ -275,16 +275,17 @@ typedef struct {
 } SDbCfg;
 
 typedef struct {
-  char    name[TSDB_DB_FNAME_LEN];
-  char    acct[TSDB_USER_LEN];
-  char    createUser[TSDB_USER_LEN];
-  int64_t createdTime;
-  int64_t updateTime;
-  int64_t uid;
-  int32_t cfgVersion;
-  int32_t vgVersion;
-  int8_t  hashMethod;  // default is 1
-  SDbCfg  cfg;
+  char     name[TSDB_DB_FNAME_LEN];
+  char     acct[TSDB_USER_LEN];
+  char     createUser[TSDB_USER_LEN];
+  int64_t  createdTime;
+  int64_t  updateTime;
+  int64_t  uid;
+  int32_t  cfgVersion;
+  int32_t  vgVersion;
+  int8_t   hashMethod;  // default is 1
+  SDbCfg   cfg;
+  SRWLatch lock;
 } SDbObj;
 
 typedef struct {

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

@@ -31,7 +31,7 @@ void        mndReleaseStream(SMnode *pMnode, SStreamObj *pStream);
 SSdbRaw *mndStreamActionEncode(SStreamObj *pStream);
 SSdbRow *mndStreamActionDecode(SSdbRaw *pRaw);
 
-int32_t mndAddStreamToTrans(SMnode *pMnode, SStreamObj *pStream, const char *ast, STrans *pTrans);
+int32_t mndAddStreamToTrans(SMnode *pMnode, SStreamObj *pStream, const char *ast, int8_t triggerType, int64_t watermark, STrans *pTrans);
 
 #ifdef __cplusplus
 }

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

@@ -33,7 +33,7 @@ static int32_t  mndProcessCreateBnodeReq(SNodeMsg *pReq);
 static int32_t  mndProcessCreateBnodeRsp(SNodeMsg *pRsp);
 static int32_t  mndProcessDropBnodeReq(SNodeMsg *pReq);
 static int32_t  mndProcessDropBnodeRsp(SNodeMsg *pRsp);
-static int32_t  mndRetrieveBnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows);
+static int32_t  mndRetrieveBnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
 static void     mndCancelGetNextBnode(SMnode *pMnode, void *pIter);
 
 int32_t mndInitBnode(SMnode *pMnode) {
@@ -437,7 +437,7 @@ static int32_t mndProcessDropBnodeRsp(SNodeMsg *pRsp) {
   return 0;
 }
 
-static int32_t mndRetrieveBnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows) {
+static int32_t mndRetrieveBnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
   SMnode    *pMnode = pReq->pNode;
   SSdb      *pSdb = pMnode->pSdb;
   int32_t    numOfRows = 0;
@@ -449,8 +449,8 @@ static int32_t mndRetrieveBnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* p
     if (pShow->pIter == NULL) break;
 
     cols = 0;
-    SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, numOfRows, (const char*) &pObj->id, false);
+    SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, numOfRows, (const char *)&pObj->id, false);
 
     char buf[TSDB_EP_LEN + VARSTR_HEADER_SIZE] = {0};
     STR_WITH_MAXSIZE_TO_VARSTR(buf, pObj->pDnode->ep, pShow->bytes[cols]);
@@ -459,7 +459,7 @@ static int32_t mndRetrieveBnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* p
     colDataAppend(pColInfo, numOfRows, buf, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, numOfRows, (const char*) &pObj->createdTime, false);
+    colDataAppend(pColInfo, numOfRows, (const char *)&pObj->createdTime, false);
 
     numOfRows++;
     sdbRelease(pSdb, pObj);

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

@@ -106,6 +106,7 @@ static SSdbRaw *mndDbActionEncode(SDbObj *pDb) {
   SDB_SET_INT8(pRaw, dataPos, pDb->cfg.cacheLastRow, DB_ENCODE_OVER)
   SDB_SET_INT32(pRaw, dataPos, pDb->cfg.numOfRetensions, DB_ENCODE_OVER)
   for (int32_t i = 0; i < pDb->cfg.numOfRetensions; ++i) {
+    TASSERT(taosArrayGetSize(pDb->cfg.pRetensions) == pDb->cfg.numOfRetensions);
     SRetention *pRetension = taosArrayGet(pDb->cfg.pRetensions, i);
     SDB_SET_INT32(pRaw, dataPos, pRetension->freq, DB_ENCODE_OVER)
     SDB_SET_INT32(pRaw, dataPos, pRetension->keep, DB_ENCODE_OVER)
@@ -218,10 +219,14 @@ static int32_t mndDbActionDelete(SSdb *pSdb, SDbObj *pDb) {
 
 static int32_t mndDbActionUpdate(SSdb *pSdb, SDbObj *pOld, SDbObj *pNew) {
   mTrace("db:%s, perform update action, old row:%p new row:%p", pOld->name, pOld, pNew);
+  taosWLockLatch(&pOld->lock);
+  SArray *pOldRetensions = pOld->cfg.pRetensions;
   pOld->updateTime = pNew->updateTime;
   pOld->cfgVersion = pNew->cfgVersion;
   pOld->vgVersion = pNew->vgVersion;
   memcpy(&pOld->cfg, &pNew->cfg, sizeof(SDbCfg));
+  pNew->cfg.pRetensions = pOldRetensions;
+  taosWUnLockLatch(&pOld->lock);
   return 0;
 }
 
@@ -1353,7 +1358,7 @@ char *mndGetDbStr(char *src) {
   return pos;
 }
 
-static void dumpDbInfoData(SSDataBlock* pBlock, SDbObj *pDb, SShowObj *pShow, int32_t rows, int64_t numOfTables) {
+static void dumpDbInfoData(SSDataBlock* pBlock, SDbObj *pDb, SShowObj *pShow, int32_t rows, int64_t numOfTables, bool sysDb) {
   int32_t cols = 0;
 
   char* buf = taosMemoryMalloc(pShow->bytes[cols]);
@@ -1365,100 +1370,117 @@ static void dumpDbInfoData(SSDataBlock* pBlock, SDbObj *pDb, SShowObj *pShow, in
     ASSERT(0);
   }
 
-  SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-  colDataAppend(pColInfo, rows, buf, false);
-  taosMemoryFree(buf);
+  char *status = "ready";
+  char  b[24] = {0};
+  STR_WITH_SIZE_TO_VARSTR(b, status, strlen(status));
 
-  pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-  colDataAppend(pColInfo, rows, (const char *)&pDb->createdTime, false);
+  if (sysDb) {
+    for(int32_t i = 0; i < pShow->numOfColumns; ++i) {
+      SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, i);
+      if (i == 0) {
+        colDataAppend(pColInfo, rows, buf, false);
+      } else if (i == 3) {
+        colDataAppend(pColInfo, rows, (const char *)&numOfTables, false);
+      } else if (i == 20) {
+        colDataAppend(pColInfo, rows, b, false);
+      } else {
+        colDataAppendNULL(pColInfo, rows);
+      }
+    }
+  } else {
+    SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, rows, buf, false);
+    taosMemoryFree(buf);
 
-  pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-  colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.numOfVgroups, false);
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, rows, (const char *)&pDb->createdTime, false);
 
-  pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-  colDataAppend(pColInfo, rows, (const char *)&numOfTables, false);
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.numOfVgroups, false);
 
-  pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-  colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.replications, false);
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, rows, (const char *)&numOfTables, false);
 
-  pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-  colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.quorum, false);
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.replications, false);
 
-  pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-  colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.daysPerFile, false);
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.quorum, false);
 
-  char tmp[128] = {0};
-  int32_t len = 0;
-  if (pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep1 || pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep2) {
-    len = sprintf(&tmp[VARSTR_HEADER_SIZE], "%d,%d,%d", pDb->cfg.daysToKeep1, pDb->cfg.daysToKeep2, pDb->cfg.daysToKeep0);
-  } else {
-    len = sprintf(&tmp[VARSTR_HEADER_SIZE], "%d,%d,%d", pDb->cfg.daysToKeep0, pDb->cfg.daysToKeep1, pDb->cfg.daysToKeep2);
-  }
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.daysPerFile, false);
 
-  varDataSetLen(tmp, len);
-  pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-  colDataAppend(pColInfo, rows, (const char *)tmp, false);
+    char    tmp[128] = {0};
+    int32_t len = 0;
+    if (pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep1 || pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep2) {
+      len = sprintf(&tmp[VARSTR_HEADER_SIZE], "%d,%d,%d", pDb->cfg.daysToKeep1, pDb->cfg.daysToKeep2,
+                    pDb->cfg.daysToKeep0);
+    } else {
+      len = sprintf(&tmp[VARSTR_HEADER_SIZE], "%d,%d,%d", pDb->cfg.daysToKeep0, pDb->cfg.daysToKeep1,
+                    pDb->cfg.daysToKeep2);
+    }
 
-  pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-  colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.cacheBlockSize, false);
+    varDataSetLen(tmp, len);
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, rows, (const char *)tmp, false);
 
-  pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-  colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.totalBlocks, false);
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.cacheBlockSize, false);
 
-  pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-  colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.minRows, false);
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.totalBlocks, false);
 
-  pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-  colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.maxRows, false);
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.minRows, false);
 
-  pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-  colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.walLevel, false);
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.maxRows, false);
 
-  pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-  colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.fsyncPeriod, false);
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.walLevel, false);
 
-  pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-  colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.compression, false);
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.fsyncPeriod, false);
 
-  pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-  colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.cacheLastRow, false);
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.compression, false);
 
-  char *prec = NULL;
-  switch (pDb->cfg.precision) {
-    case TSDB_TIME_PRECISION_MILLI:
-      prec = TSDB_TIME_PRECISION_MILLI_STR;
-      break;
-    case TSDB_TIME_PRECISION_MICRO:
-      prec = TSDB_TIME_PRECISION_MICRO_STR;
-      break;
-    case TSDB_TIME_PRECISION_NANO:
-      prec = TSDB_TIME_PRECISION_NANO_STR;
-      break;
-    default:
-      prec = "none";
-      break;
-  }
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.cacheLastRow, false);
 
-  char t[10] = {0};
-  STR_WITH_SIZE_TO_VARSTR(t, prec, 2);
-  pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-  colDataAppend(pColInfo, rows, (const char *)t, false);
+    char *prec = NULL;
+    switch (pDb->cfg.precision) {
+      case TSDB_TIME_PRECISION_MILLI:
+        prec = TSDB_TIME_PRECISION_MILLI_STR;
+        break;
+      case TSDB_TIME_PRECISION_MICRO:
+        prec = TSDB_TIME_PRECISION_MICRO_STR;
+        break;
+      case TSDB_TIME_PRECISION_NANO:
+        prec = TSDB_TIME_PRECISION_NANO_STR;
+        break;
+      default:
+        prec = "none";
+        break;
+    }
 
-  pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-  colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.ttl, false);
+    char t[10] = {0};
+    STR_WITH_SIZE_TO_VARSTR(t, prec, 2);
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, rows, (const char *)t, false);
 
-  pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-  colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.singleSTable, false);
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.ttl, false);
 
-  pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-  colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.streamMode, false);
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.singleSTable, false);
 
-  char *status = "ready";
-  char b[24] = {0};
-  STR_WITH_SIZE_TO_VARSTR(b, status, strlen(status));
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.streamMode, false);
 
-  pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-  colDataAppend(pColInfo, rows, (const char *)b, false);
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols);
+    colDataAppend(pColInfo, rows, (const char *)b, false);
+  }
 
   //  pWrite = getDataPosition(data, pShow, cols, rows, rowCapacity);
   //  *(int8_t *)pWrite = pDb->cfg.update;
@@ -1507,13 +1529,13 @@ static int32_t mndRetrieveDbs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlo
   if (!pShow->sysDbRsp) {
     SDbObj infoschemaDb = {0};
     setInformationSchemaDbCfg(&infoschemaDb);
-    dumpDbInfoData(pBlock, &infoschemaDb, pShow, numOfRows, 14);
+    dumpDbInfoData(pBlock, &infoschemaDb, pShow, numOfRows, 14, true);
 
     numOfRows += 1;
 
     SDbObj perfschemaDb = {0};
     setPerfSchemaDbCfg(&perfschemaDb);
-    dumpDbInfoData(pBlock, &perfschemaDb, pShow, numOfRows, 3);
+    dumpDbInfoData(pBlock, &perfschemaDb, pShow, numOfRows, 3, true);
 
     numOfRows += 1;
     pShow->sysDbRsp = true;
@@ -1528,7 +1550,7 @@ static int32_t mndRetrieveDbs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlo
     int32_t numOfTables = 0;
     sdbTraverse(pSdb, SDB_VGROUP, mndGetTablesOfDbFp, &numOfTables, NULL, NULL);
 
-    dumpDbInfoData(pBlock, pDb, pShow, numOfRows, numOfTables);
+    dumpDbInfoData(pBlock, pDb, pShow, numOfRows, numOfTables, false);
     numOfRows++;
     sdbRelease(pSdb, pDb);
   }

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

@@ -34,7 +34,7 @@ static int32_t  mndDropFunc(SMnode *pMnode, SNodeMsg *pReq, SFuncObj *pFunc);
 static int32_t  mndProcessCreateFuncReq(SNodeMsg *pReq);
 static int32_t  mndProcessDropFuncReq(SNodeMsg *pReq);
 static int32_t  mndProcessRetrieveFuncReq(SNodeMsg *pReq);
-static int32_t  mndRetrieveFuncs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows);
+static int32_t  mndRetrieveFuncs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
 static void     mndCancelGetNextFunc(SMnode *pMnode, void *pIter);
 
 int32_t mndInitFunc(SMnode *pMnode) {
@@ -63,28 +63,28 @@ static SSdbRaw *mndFuncActionEncode(SFuncObj *pFunc) {
 
   int32_t  size = pFunc->commentSize + pFunc->codeSize + sizeof(SFuncObj) + SDB_FUNC_RESERVE_SIZE;
   SSdbRaw *pRaw = sdbAllocRaw(SDB_FUNC, SDB_FUNC_VER, size);
-  if (pRaw == NULL) goto FUNC_ENCODE_OVER;
+  if (pRaw == NULL) goto _OVER;
 
   int32_t dataPos = 0;
-  SDB_SET_BINARY(pRaw, dataPos, pFunc->name, TSDB_FUNC_NAME_LEN, FUNC_ENCODE_OVER)
-  SDB_SET_INT64(pRaw, dataPos, pFunc->createdTime, FUNC_ENCODE_OVER)
-  SDB_SET_INT8(pRaw, dataPos, pFunc->funcType, FUNC_ENCODE_OVER)
-  SDB_SET_INT8(pRaw, dataPos, pFunc->scriptType, FUNC_ENCODE_OVER)
-  SDB_SET_INT8(pRaw, dataPos, pFunc->align, FUNC_ENCODE_OVER)
-  SDB_SET_INT8(pRaw, dataPos, pFunc->outputType, FUNC_ENCODE_OVER)
-  SDB_SET_INT32(pRaw, dataPos, pFunc->outputLen, FUNC_ENCODE_OVER)
-  SDB_SET_INT32(pRaw, dataPos, pFunc->bufSize, FUNC_ENCODE_OVER)
-  SDB_SET_INT64(pRaw, dataPos, pFunc->signature, FUNC_ENCODE_OVER)
-  SDB_SET_INT32(pRaw, dataPos, pFunc->commentSize, FUNC_ENCODE_OVER)
-  SDB_SET_INT32(pRaw, dataPos, pFunc->codeSize, FUNC_ENCODE_OVER)
-  SDB_SET_BINARY(pRaw, dataPos, pFunc->pComment, pFunc->commentSize, FUNC_ENCODE_OVER)
-  SDB_SET_BINARY(pRaw, dataPos, pFunc->pCode, pFunc->codeSize, FUNC_ENCODE_OVER)
-  SDB_SET_RESERVE(pRaw, dataPos, SDB_FUNC_RESERVE_SIZE, FUNC_ENCODE_OVER)
-  SDB_SET_DATALEN(pRaw, dataPos, FUNC_ENCODE_OVER);
+  SDB_SET_BINARY(pRaw, dataPos, pFunc->name, TSDB_FUNC_NAME_LEN, _OVER)
+  SDB_SET_INT64(pRaw, dataPos, pFunc->createdTime, _OVER)
+  SDB_SET_INT8(pRaw, dataPos, pFunc->funcType, _OVER)
+  SDB_SET_INT8(pRaw, dataPos, pFunc->scriptType, _OVER)
+  SDB_SET_INT8(pRaw, dataPos, pFunc->align, _OVER)
+  SDB_SET_INT8(pRaw, dataPos, pFunc->outputType, _OVER)
+  SDB_SET_INT32(pRaw, dataPos, pFunc->outputLen, _OVER)
+  SDB_SET_INT32(pRaw, dataPos, pFunc->bufSize, _OVER)
+  SDB_SET_INT64(pRaw, dataPos, pFunc->signature, _OVER)
+  SDB_SET_INT32(pRaw, dataPos, pFunc->commentSize, _OVER)
+  SDB_SET_INT32(pRaw, dataPos, pFunc->codeSize, _OVER)
+  SDB_SET_BINARY(pRaw, dataPos, pFunc->pComment, pFunc->commentSize, _OVER)
+  SDB_SET_BINARY(pRaw, dataPos, pFunc->pCode, pFunc->codeSize, _OVER)
+  SDB_SET_RESERVE(pRaw, dataPos, SDB_FUNC_RESERVE_SIZE, _OVER)
+  SDB_SET_DATALEN(pRaw, dataPos, _OVER);
 
   terrno = 0;
 
-FUNC_ENCODE_OVER:
+_OVER:
   if (terrno != 0) {
     mError("func:%s, failed to encode to raw:%p since %s", pFunc->name, pRaw, terrstr());
     sdbFreeRaw(pRaw);
@@ -99,45 +99,45 @@ static SSdbRow *mndFuncActionDecode(SSdbRaw *pRaw) {
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
   int8_t sver = 0;
-  if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto FUNC_DECODE_OVER;
+  if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto _OVER;
 
   if (sver != SDB_FUNC_VER) {
     terrno = TSDB_CODE_SDB_INVALID_DATA_VER;
-    goto FUNC_DECODE_OVER;
+    goto _OVER;
   }
 
   SSdbRow *pRow = sdbAllocRow(sizeof(SFuncObj));
-  if (pRow == NULL) goto FUNC_DECODE_OVER;
+  if (pRow == NULL) goto _OVER;
 
   SFuncObj *pFunc = sdbGetRowObj(pRow);
-  if (pFunc == NULL) goto FUNC_DECODE_OVER;
+  if (pFunc == NULL) goto _OVER;
 
   int32_t dataPos = 0;
-  SDB_GET_BINARY(pRaw, dataPos, pFunc->name, TSDB_FUNC_NAME_LEN, FUNC_DECODE_OVER)
-  SDB_GET_INT64(pRaw, dataPos, &pFunc->createdTime, FUNC_DECODE_OVER)
-  SDB_GET_INT8(pRaw, dataPos, &pFunc->funcType, FUNC_DECODE_OVER)
-  SDB_GET_INT8(pRaw, dataPos, &pFunc->scriptType, FUNC_DECODE_OVER)
-  SDB_GET_INT8(pRaw, dataPos, &pFunc->align, FUNC_DECODE_OVER)
-  SDB_GET_INT8(pRaw, dataPos, &pFunc->outputType, FUNC_DECODE_OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pFunc->outputLen, FUNC_DECODE_OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pFunc->bufSize, FUNC_DECODE_OVER)
-  SDB_GET_INT64(pRaw, dataPos, &pFunc->signature, FUNC_DECODE_OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pFunc->commentSize, FUNC_DECODE_OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pFunc->codeSize, FUNC_DECODE_OVER)
+  SDB_GET_BINARY(pRaw, dataPos, pFunc->name, TSDB_FUNC_NAME_LEN, _OVER)
+  SDB_GET_INT64(pRaw, dataPos, &pFunc->createdTime, _OVER)
+  SDB_GET_INT8(pRaw, dataPos, &pFunc->funcType, _OVER)
+  SDB_GET_INT8(pRaw, dataPos, &pFunc->scriptType, _OVER)
+  SDB_GET_INT8(pRaw, dataPos, &pFunc->align, _OVER)
+  SDB_GET_INT8(pRaw, dataPos, &pFunc->outputType, _OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pFunc->outputLen, _OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pFunc->bufSize, _OVER)
+  SDB_GET_INT64(pRaw, dataPos, &pFunc->signature, _OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pFunc->commentSize, _OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pFunc->codeSize, _OVER)
 
   pFunc->pComment = taosMemoryCalloc(1, pFunc->commentSize);
   pFunc->pCode = taosMemoryCalloc(1, pFunc->codeSize);
   if (pFunc->pComment == NULL || pFunc->pCode == NULL) {
-    goto FUNC_DECODE_OVER;
+    goto _OVER;
   }
 
-  SDB_GET_BINARY(pRaw, dataPos, pFunc->pComment, pFunc->commentSize, FUNC_DECODE_OVER)
-  SDB_GET_BINARY(pRaw, dataPos, pFunc->pCode, pFunc->codeSize, FUNC_DECODE_OVER)
-  SDB_GET_RESERVE(pRaw, dataPos, SDB_FUNC_RESERVE_SIZE, FUNC_DECODE_OVER)
+  SDB_GET_BINARY(pRaw, dataPos, pFunc->pComment, pFunc->commentSize, _OVER)
+  SDB_GET_BINARY(pRaw, dataPos, pFunc->pCode, pFunc->codeSize, _OVER)
+  SDB_GET_RESERVE(pRaw, dataPos, SDB_FUNC_RESERVE_SIZE, _OVER)
 
   terrno = 0;
 
-FUNC_DECODE_OVER:
+_OVER:
   if (terrno != 0) {
     mError("func:%s, failed to decode from raw:%p since %s", pFunc->name, pRaw, terrstr());
     taosMemoryFreeClear(pRow);
@@ -192,40 +192,40 @@ static int32_t mndCreateFunc(SMnode *pMnode, SNodeMsg *pReq, SCreateFuncReq *pCr
   func.outputLen = pCreate->outputLen;
   func.bufSize = pCreate->bufSize;
   func.signature = pCreate->signature;
-  func.commentSize = pCreate->commentSize;
-  func.codeSize = pCreate->codeSize;
+  func.commentSize = strlen(pCreate->pComment) + 1;
+  func.codeSize = strlen(pCreate->pCode) + 1;
   func.pComment = taosMemoryMalloc(func.commentSize);
   func.pCode = taosMemoryMalloc(func.codeSize);
   if (func.pCode == NULL || func.pCode == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
-    goto CREATE_FUNC_OVER;
+    goto _OVER;
   }
 
-  memcpy(func.pComment, pCreate->pComment, pCreate->commentSize);
+  memcpy(func.pComment, pCreate->pComment, func.commentSize);
   memcpy(func.pCode, pCreate->pCode, func.codeSize);
 
   pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_CREATE_FUNC, &pReq->rpcMsg);
-  if (pTrans == NULL) goto CREATE_FUNC_OVER;
+  if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to create func:%s", pTrans->id, pCreate->name);
 
   SSdbRaw *pRedoRaw = mndFuncActionEncode(&func);
-  if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) goto CREATE_FUNC_OVER;
-  if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING) != 0) goto CREATE_FUNC_OVER;
+  if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) goto _OVER;
+  if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING) != 0) goto _OVER;
 
   SSdbRaw *pUndoRaw = mndFuncActionEncode(&func);
-  if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) goto CREATE_FUNC_OVER;
-  if (sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED) != 0) goto CREATE_FUNC_OVER;
+  if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) goto _OVER;
+  if (sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED) != 0) goto _OVER;
 
   SSdbRaw *pCommitRaw = mndFuncActionEncode(&func);
-  if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto CREATE_FUNC_OVER;
-  if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY) != 0) goto CREATE_FUNC_OVER;
+  if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto _OVER;
+  if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY) != 0) goto _OVER;
 
-  if (mndTransPrepare(pMnode, pTrans) != 0) goto CREATE_FUNC_OVER;
+  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
 
   code = 0;
 
-CREATE_FUNC_OVER:
+_OVER:
   taosMemoryFree(func.pCode);
   taosMemoryFree(func.pComment);
   mndTransDrop(pTrans);
@@ -235,27 +235,27 @@ CREATE_FUNC_OVER:
 static int32_t mndDropFunc(SMnode *pMnode, SNodeMsg *pReq, SFuncObj *pFunc) {
   int32_t code = -1;
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_DROP_FUNC, &pReq->rpcMsg);
-  if (pTrans == NULL) goto DROP_FUNC_OVER;
+  if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to drop user:%s", pTrans->id, pFunc->name);
 
   SSdbRaw *pRedoRaw = mndFuncActionEncode(pFunc);
-  if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) goto DROP_FUNC_OVER;
+  if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) goto _OVER;
   sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING);
 
   SSdbRaw *pUndoRaw = mndFuncActionEncode(pFunc);
-  if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) goto DROP_FUNC_OVER;
+  if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) goto _OVER;
   sdbSetRawStatus(pUndoRaw, SDB_STATUS_READY);
 
   SSdbRaw *pCommitRaw = mndFuncActionEncode(pFunc);
-  if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto DROP_FUNC_OVER;
+  if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto _OVER;
   sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED);
 
-  if (mndTransPrepare(pMnode, pTrans) != 0) goto DROP_FUNC_OVER;
+  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
 
   code = 0;
 
-DROP_FUNC_OVER:
+_OVER:
   mndTransDrop(pTrans);
   return code;
 }
@@ -269,7 +269,7 @@ static int32_t mndProcessCreateFuncReq(SNodeMsg *pReq) {
 
   if (tDeserializeSCreateFuncReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &createReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
-    goto CREATE_FUNC_OVER;
+    goto _OVER;
   }
 
   mDebug("func:%s, start to create", createReq.name);
@@ -279,60 +279,66 @@ static int32_t mndProcessCreateFuncReq(SNodeMsg *pReq) {
     if (createReq.igExists) {
       mDebug("func:%s, already exist, ignore exist is set", createReq.name);
       code = 0;
-      goto CREATE_FUNC_OVER;
+      goto _OVER;
     } else {
       terrno = TSDB_CODE_MND_FUNC_ALREADY_EXIST;
-      goto CREATE_FUNC_OVER;
+      goto _OVER;
     }
   } else if (terrno == TSDB_CODE_MND_FUNC_ALREADY_EXIST) {
-    goto CREATE_FUNC_OVER;
+    goto _OVER;
   }
 
   if (createReq.name[0] == 0) {
     terrno = TSDB_CODE_MND_INVALID_FUNC_NAME;
-    goto CREATE_FUNC_OVER;
+    goto _OVER;
   }
 
-  if (createReq.commentSize <= 0 || createReq.commentSize > TSDB_FUNC_COMMENT_LEN) {
+  if (createReq.pComment == NULL) {
     terrno = TSDB_CODE_MND_INVALID_FUNC_COMMENT;
-    goto CREATE_FUNC_OVER;
+    goto _OVER;
   }
 
-  if (createReq.codeSize <= 0 || createReq.codeSize > TSDB_FUNC_CODE_LEN) {
+  if (createReq.pComment[0] == 0) {
+    terrno = TSDB_CODE_MND_INVALID_FUNC_COMMENT;
+    goto _OVER;
+  }
+
+  if (createReq.pCode == NULL) {
     terrno = TSDB_CODE_MND_INVALID_FUNC_CODE;
-    goto CREATE_FUNC_OVER;
+    goto _OVER;
   }
 
   if (createReq.pCode[0] == 0) {
     terrno = TSDB_CODE_MND_INVALID_FUNC_CODE;
-    goto CREATE_FUNC_OVER;
+    goto _OVER;
   }
 
   if (createReq.bufSize <= 0 || createReq.bufSize > TSDB_FUNC_BUF_SIZE) {
     terrno = TSDB_CODE_MND_INVALID_FUNC_BUFSIZE;
-    goto CREATE_FUNC_OVER;
+    goto _OVER;
   }
 
   pUser = mndAcquireUser(pMnode, pReq->user);
   if (pUser == NULL) {
     terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
-    goto CREATE_FUNC_OVER;
+    goto _OVER;
   }
 
   if (mndCheckFuncAuth(pUser)) {
-    goto CREATE_FUNC_OVER;
+    goto _OVER;
   }
 
   code = mndCreateFunc(pMnode, pReq, &createReq);
   if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS;
 
-CREATE_FUNC_OVER:
+_OVER:
   if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
     mError("func:%s, failed to create since %s", createReq.name, terrstr());
   }
 
   mndReleaseFunc(pMnode, pFunc);
   mndReleaseUser(pMnode, pUser);
+  tFreeSCreateFuncReq(&createReq);
 
   return code;
 }
@@ -346,14 +352,14 @@ static int32_t mndProcessDropFuncReq(SNodeMsg *pReq) {
 
   if (tDeserializeSDropFuncReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
-    goto DROP_FUNC_OVER;
+    goto _OVER;
   }
 
   mDebug("func:%s, start to drop", dropReq.name);
 
   if (dropReq.name[0] == 0) {
     terrno = TSDB_CODE_MND_INVALID_FUNC_NAME;
-    goto DROP_FUNC_OVER;
+    goto _OVER;
   }
 
   pFunc = mndAcquireFunc(pMnode, dropReq.name);
@@ -361,27 +367,27 @@ static int32_t mndProcessDropFuncReq(SNodeMsg *pReq) {
     if (dropReq.igNotExists) {
       mDebug("func:%s, not exist, ignore not exist is set", dropReq.name);
       code = 0;
-      goto DROP_FUNC_OVER;
+      goto _OVER;
     } else {
       terrno = TSDB_CODE_MND_FUNC_NOT_EXIST;
-      goto DROP_FUNC_OVER;
+      goto _OVER;
     }
   }
 
   pUser = mndAcquireUser(pMnode, pReq->user);
   if (pUser == NULL) {
     terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
-    goto DROP_FUNC_OVER;
+    goto _OVER;
   }
 
   if (mndCheckFuncAuth(pUser)) {
-    goto DROP_FUNC_OVER;
+    goto _OVER;
   }
 
   code = mndDropFunc(pMnode, pReq, pFunc);
   if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS;
 
-DROP_FUNC_OVER:
+_OVER:
   if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
     mError("func:%s, failed to drop since %s", dropReq.name, terrstr());
   }
@@ -434,6 +440,12 @@ static int32_t mndProcessRetrieveFuncReq(SNodeMsg *pReq) {
     funcInfo.signature = pFunc->signature;
     funcInfo.commentSize = pFunc->commentSize;
     funcInfo.codeSize = pFunc->codeSize;
+    funcInfo.pCode = taosMemoryCalloc(1, sizeof(funcInfo.codeSize));
+    funcInfo.pComment = taosMemoryCalloc(1, sizeof(funcInfo.commentSize));
+    if (funcInfo.pCode == NULL || funcInfo.pComment == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      goto RETRIEVE_FUNC_OVER;
+    }
     memcpy(funcInfo.pComment, pFunc->pComment, pFunc->commentSize);
     memcpy(funcInfo.pCode, pFunc->pCode, pFunc->codeSize);
     taosArrayPush(retrieveRsp.pFuncInfos, &funcInfo);
@@ -455,8 +467,8 @@ static int32_t mndProcessRetrieveFuncReq(SNodeMsg *pReq) {
   code = 0;
 
 RETRIEVE_FUNC_OVER:
-  taosArrayDestroy(retrieveReq.pFuncNames);
-  taosArrayDestroy(retrieveRsp.pFuncInfos);
+  tFreeSRetrieveFuncReq(&retrieveReq);
+  tFreeSRetrieveFuncRsp(&retrieveRsp);
 
   return code;
 }
@@ -479,7 +491,7 @@ static void *mnodeGenTypeStr(char *buf, int32_t buflen, uint8_t type, int16_t le
   return tDataTypes[type].name;
 }
 
-static int32_t mndRetrieveFuncs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows) {
+static int32_t mndRetrieveFuncs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
   SMnode   *pMnode = pReq->pNode;
   SSdb     *pSdb = pMnode->pSdb;
   int32_t   numOfRows = 0;
@@ -496,34 +508,35 @@ static int32_t mndRetrieveFuncs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pB
     char b1[tListLen(pFunc->name) + VARSTR_HEADER_SIZE] = {0};
     STR_WITH_MAXSIZE_TO_VARSTR(b1, pFunc->name, pShow->bytes[cols]);
 
-    SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, numOfRows, (const char*) b1, false);
+    SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, numOfRows, (const char *)b1, false);
 
-    char* b2 = taosMemoryCalloc(1, pShow->bytes[cols]);
+    char *b2 = taosMemoryCalloc(1, pShow->bytes[cols]);
     STR_WITH_MAXSIZE_TO_VARSTR(b2, pFunc->pComment, pShow->bytes[cols]);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, numOfRows, (const char*) b2, false);
+    colDataAppend(pColInfo, numOfRows, (const char *)b2, false);
 
     int32_t isAgg = (pFunc->funcType == TSDB_FUNC_TYPE_AGGREGATE) ? 1 : 0;
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, numOfRows, (const char*) &isAgg, false);
+    colDataAppend(pColInfo, numOfRows, (const char *)&isAgg, false);
 
     char b3[TSDB_TYPE_STR_MAX_LEN] = {0};
-    STR_WITH_MAXSIZE_TO_VARSTR(b3, mnodeGenTypeStr(buf, TSDB_TYPE_STR_MAX_LEN, pFunc->outputType, pFunc->outputLen), pShow->bytes[cols]);
+    STR_WITH_MAXSIZE_TO_VARSTR(b3, mnodeGenTypeStr(buf, TSDB_TYPE_STR_MAX_LEN, pFunc->outputType, pFunc->outputLen),
+                               pShow->bytes[cols]);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, numOfRows, (const char*) b3, false);
+    colDataAppend(pColInfo, numOfRows, (const char *)b3, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, numOfRows, (const char*) &pFunc->createdTime, false);
+    colDataAppend(pColInfo, numOfRows, (const char *)&pFunc->createdTime, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, numOfRows, (const char*) &pFunc->codeSize, false);
+    colDataAppend(pColInfo, numOfRows, (const char *)&pFunc->codeSize, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, numOfRows, (const char*) &pFunc->bufSize, false);
+    colDataAppend(pColInfo, numOfRows, (const char *)&pFunc->bufSize, false);
 
     numOfRows++;
     sdbRelease(pSdb, pFunc);

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

@@ -78,13 +78,13 @@ void mndReleaseMnode(SMnode *pMnode, SMnodeObj *pObj) {
 const char *mndGetRoleStr(int32_t showType) {
   switch (showType) {
     case TAOS_SYNC_STATE_FOLLOWER:
-      return "unsynced";
+      return "FOLLOWER";
     case TAOS_SYNC_STATE_CANDIDATE:
-      return "slave";
+      return "CANDIDATE";
     case TAOS_SYNC_STATE_LEADER:
-      return "master";
+      return "LEADER";
     default:
-      return "undefined";
+      return "ERROR";
   }
 }
 
@@ -615,7 +615,7 @@ static int32_t mndProcessDropMnodeRsp(SNodeMsg *pRsp) {
   return 0;
 }
 
-static int32_t mndRetrieveMnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows) {
+static int32_t mndRetrieveMnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
   SMnode    *pMnode = pReq->pNode;
   SSdb      *pSdb = pMnode->pSdb;
   int32_t    numOfRows = 0;
@@ -628,8 +628,8 @@ static int32_t mndRetrieveMnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* p
     if (pShow->pIter == NULL) break;
 
     cols = 0;
-    SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, numOfRows, (const char*) &pObj->id, false);
+    SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, numOfRows, (const char *)&pObj->id, false);
 
     char b1[TSDB_EP_LEN + VARSTR_HEADER_SIZE] = {0};
     STR_WITH_MAXSIZE_TO_VARSTR(b1, pObj->pDnode->ep, pShow->bytes[cols]);
@@ -638,11 +638,11 @@ static int32_t mndRetrieveMnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* p
     colDataAppend(pColInfo, numOfRows, b1, false);
 
     const char *roles = mndGetRoleStr(pObj->role);
-    char* b2 = taosMemoryCalloc(1, strlen(roles) + VARSTR_HEADER_SIZE);
+    char       *b2 = taosMemoryCalloc(1, strlen(roles) + VARSTR_HEADER_SIZE);
     STR_WITH_MAXSIZE_TO_VARSTR(b2, roles, pShow->bytes[cols]);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, numOfRows, (const char*) b2, false);
+    colDataAppend(pColInfo, numOfRows, (const char *)b2, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     colDataAppend(pColInfo, numOfRows, (const char *)&pObj->roleTime, false);

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

@@ -34,7 +34,7 @@ static int32_t  mndProcessCreateQnodeRsp(SNodeMsg *pRsp);
 static int32_t  mndProcessDropQnodeReq(SNodeMsg *pReq);
 static int32_t  mndProcessDropQnodeRsp(SNodeMsg *pRsp);
 static int32_t  mndProcessQnodeListReq(SNodeMsg *pReq);
-static int32_t  mndRetrieveQnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows);
+static int32_t  mndRetrieveQnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
 static void     mndCancelGetNextQnode(SMnode *pMnode, void *pIter);
 
 int32_t mndInitQnode(SMnode *pMnode) {
@@ -497,7 +497,7 @@ static int32_t mndProcessDropQnodeRsp(SNodeMsg *pRsp) {
   return 0;
 }
 
-static int32_t mndRetrieveQnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows) {
+static int32_t mndRetrieveQnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
   SMnode    *pMnode = pReq->pNode;
   SSdb      *pSdb = pMnode->pSdb;
   int32_t    numOfRows = 0;
@@ -510,8 +510,8 @@ static int32_t mndRetrieveQnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* p
     if (pShow->pIter == NULL) break;
 
     cols = 0;
-    SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, numOfRows, (const char*)&pObj->id, false);
+    SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, numOfRows, (const char *)&pObj->id, false);
 
     char ep[TSDB_EP_LEN + VARSTR_HEADER_SIZE] = {0};
     STR_WITH_MAXSIZE_TO_VARSTR(ep, pObj->pDnode->ep, pShow->bytes[cols]);

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

@@ -429,7 +429,7 @@ static int32_t mndCreateSma(SMnode *pMnode, SNodeMsg *pReq, SMCreateSmaReq *pCre
   if (mndSetCreateSmaRedoLogs(pMnode, pTrans, &smaObj) != 0) goto _OVER;
   if (mndSetCreateSmaCommitLogs(pMnode, pTrans, &smaObj) != 0) goto _OVER;
   if (mndSetCreateSmaRedoActions(pMnode, pTrans, pDb, &smaObj) != 0) goto _OVER;
-  if (mndAddStreamToTrans(pMnode, &streamObj, pCreate->ast, pTrans) != 0) goto _OVER;
+  if (mndAddStreamToTrans(pMnode, &streamObj, pCreate->ast, STREAM_TRIGGER_AT_ONCE, 0, pTrans) != 0) goto _OVER;
   if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
 
   code = 0;

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

@@ -33,7 +33,7 @@ static int32_t  mndProcessCreateSnodeReq(SNodeMsg *pReq);
 static int32_t  mndProcessCreateSnodeRsp(SNodeMsg *pRsp);
 static int32_t  mndProcessDropSnodeReq(SNodeMsg *pReq);
 static int32_t  mndProcessDropSnodeRsp(SNodeMsg *pRsp);
-static int32_t  mndRetrieveSnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows);
+static int32_t  mndRetrieveSnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
 static void     mndCancelGetNextSnode(SMnode *pMnode, void *pIter);
 
 int32_t mndInitSnode(SMnode *pMnode) {
@@ -447,7 +447,7 @@ static int32_t mndProcessDropSnodeRsp(SNodeMsg *pRsp) {
   return 0;
 }
 
-static int32_t mndRetrieveSnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows) {
+static int32_t mndRetrieveSnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
   SMnode    *pMnode = pReq->pNode;
   SSdb      *pSdb = pMnode->pSdb;
   int32_t    numOfRows = 0;
@@ -459,8 +459,8 @@ static int32_t mndRetrieveSnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* p
     if (pShow->pIter == NULL) break;
 
     cols = 0;
-    SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, numOfRows, (const char*)&pObj->id, false);
+    SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataAppend(pColInfo, numOfRows, (const char *)&pObj->id, false);
 
     char ep[TSDB_EP_LEN + VARSTR_HEADER_SIZE] = {0};
     STR_WITH_MAXSIZE_TO_VARSTR(ep, pObj->pDnode->ep, pShow->bytes[cols]);

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

@@ -218,7 +218,7 @@ static int32_t mndCheckCreateStreamReq(SCMCreateStreamReq *pCreate) {
   return 0;
 }
 
-static int32_t mndStreamGetPlanString(const char *ast, char **pStr) {
+static int32_t mndStreamGetPlanString(const char *ast, int8_t triggerType, int64_t watermark, char **pStr) {
   if (NULL == ast) {
     return TSDB_CODE_SUCCESS;
   }
@@ -232,6 +232,8 @@ static int32_t mndStreamGetPlanString(const char *ast, char **pStr) {
         .pAstRoot = pAst,
         .topicQuery = false,
         .streamQuery = true,
+        .triggerType = triggerType,
+        .watermark = watermark,
     };
     code = qCreateQueryPlan(&cxt, &pPlan, NULL);
   }
@@ -245,7 +247,7 @@ static int32_t mndStreamGetPlanString(const char *ast, char **pStr) {
   return code;
 }
 
-int32_t mndAddStreamToTrans(SMnode *pMnode, SStreamObj *pStream, const char *ast, STrans *pTrans) {
+int32_t mndAddStreamToTrans(SMnode *pMnode, SStreamObj *pStream, const char *ast, int8_t triggerType, int64_t watermark, STrans *pTrans) {
   SNode *pAst = NULL;
 
   if (nodesStringToNode(ast, &pAst) < 0) {
@@ -265,7 +267,7 @@ int32_t mndAddStreamToTrans(SMnode *pMnode, SStreamObj *pStream, const char *ast
 
 #endif
 
-  if (TSDB_CODE_SUCCESS != mndStreamGetPlanString(ast, &pStream->physicalPlan)) {
+  if (TSDB_CODE_SUCCESS != mndStreamGetPlanString(ast, triggerType, watermark, &pStream->physicalPlan)) {
     mError("topic:%s, failed to get plan since %s", pStream->name, terrstr());
     return -1;
   }
@@ -313,7 +315,7 @@ static int32_t mndCreateStream(SMnode *pMnode, SNodeMsg *pReq, SCMCreateStreamRe
   }
   mDebug("trans:%d, used to create stream:%s", pTrans->id, pCreate->name);
 
-  if (mndAddStreamToTrans(pMnode, &streamObj, pCreate->ast, pTrans) != 0) {
+  if (mndAddStreamToTrans(pMnode, &streamObj, pCreate->ast, pCreate->triggerType, pCreate->watermark, pTrans) != 0) {
     mError("trans:%d, failed to add stream since %s", pTrans->id, terrstr());
     mndTransDrop(pTrans);
     return -1;

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

@@ -21,10 +21,25 @@ class MndTestFunc : public ::testing::Test {
  public:
   void SetUp() override {}
   void TearDown() override {}
+
+  void SetCode(SCreateFuncReq* pReq, const char* pCode);
+  void SetComment(SCreateFuncReq* pReq, const char* pComment);
 };
 
 Testbase MndTestFunc::test;
 
+void MndTestFunc::SetCode(SCreateFuncReq* pReq, const char* pCode) {
+  int32_t len = strlen(pCode);
+  pReq->pCode = (char*)taosMemoryCalloc(1, len + 1);
+  strcpy(pReq->pCode, pCode);
+}
+
+void MndTestFunc::SetComment(SCreateFuncReq* pReq, const char* pComment) {
+  int32_t len = strlen(pComment);
+  pReq->pComment = (char*)taosMemoryCalloc(1, len + 1);
+  strcpy(pReq->pComment, pComment);
+}
+
 TEST_F(MndTestFunc, 01_Show_Func) {
   test.SendShowReq(TSDB_MGMT_TABLE_FUNC, "user_functions", "");
   EXPECT_EQ(test.GetShowRows(), 0);
@@ -38,6 +53,7 @@ TEST_F(MndTestFunc, 02_Create_Func) {
     int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSCreateFuncReq(pReq, contLen, &createReq);
+    tFreeSCreateFuncReq(&createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -47,10 +63,12 @@ TEST_F(MndTestFunc, 02_Create_Func) {
   {
     SCreateFuncReq createReq = {0};
     strcpy(createReq.name, "f1");
+    SetCode(&createReq, "code1");
 
     int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSCreateFuncReq(pReq, contLen, &createReq);
+    tFreeSCreateFuncReq(&createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -60,25 +78,12 @@ TEST_F(MndTestFunc, 02_Create_Func) {
   {
     SCreateFuncReq createReq = {0};
     strcpy(createReq.name, "f1");
-    createReq.commentSize = TSDB_FUNC_COMMENT_LEN + 1;
-
-    int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq);
-    void*   pReq = rpcMallocCont(contLen);
-    tSerializeSCreateFuncReq(pReq, contLen, &createReq);
-
-    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
-    ASSERT_NE(pRsp, nullptr);
-    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_COMMENT);
-  }
-
-  {
-    SCreateFuncReq createReq = {0};
-    strcpy(createReq.name, "f1");
-    createReq.commentSize = TSDB_FUNC_COMMENT_LEN;
+    SetComment(&createReq, "comment1");
 
     int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSCreateFuncReq(pReq, contLen, &createReq);
+    tFreeSCreateFuncReq(&createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -88,27 +93,29 @@ TEST_F(MndTestFunc, 02_Create_Func) {
   {
     SCreateFuncReq createReq = {0};
     strcpy(createReq.name, "f1");
-    createReq.commentSize = TSDB_FUNC_COMMENT_LEN;
-    createReq.codeSize = TSDB_FUNC_CODE_LEN + 1;
+    SetCode(&createReq, "code1");
+    SetComment(&createReq, "");
 
     int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSCreateFuncReq(pReq, contLen, &createReq);
+    tFreeSCreateFuncReq(&createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
-    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_CODE);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_COMMENT);
   }
 
   {
     SCreateFuncReq createReq = {0};
     strcpy(createReq.name, "f1");
-    createReq.commentSize = TSDB_FUNC_COMMENT_LEN;
-    createReq.codeSize = TSDB_FUNC_CODE_LEN;
+    SetCode(&createReq, "");
+    SetComment(&createReq, "comment1");
 
     int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSCreateFuncReq(pReq, contLen, &createReq);
+    tFreeSCreateFuncReq(&createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -118,13 +125,13 @@ TEST_F(MndTestFunc, 02_Create_Func) {
   {
     SCreateFuncReq createReq = {0};
     strcpy(createReq.name, "f1");
-    createReq.commentSize = TSDB_FUNC_COMMENT_LEN;
-    createReq.codeSize = TSDB_FUNC_CODE_LEN;
-    createReq.pCode[0] = 'a';
+    SetCode(&createReq, "code1");
+    SetComment(&createReq, "comment1");
 
     int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSCreateFuncReq(pReq, contLen, &createReq);
+    tFreeSCreateFuncReq(&createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -134,14 +141,14 @@ TEST_F(MndTestFunc, 02_Create_Func) {
   {
     SCreateFuncReq createReq = {0};
     strcpy(createReq.name, "f1");
-    createReq.commentSize = TSDB_FUNC_COMMENT_LEN;
-    createReq.codeSize = TSDB_FUNC_CODE_LEN;
-    createReq.pCode[0] = 'a';
+    SetCode(&createReq, "code1");
+    SetComment(&createReq, "comment1");
     createReq.bufSize = TSDB_FUNC_BUF_SIZE + 1;
 
     int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSCreateFuncReq(pReq, contLen, &createReq);
+    tFreeSCreateFuncReq(&createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -151,9 +158,8 @@ TEST_F(MndTestFunc, 02_Create_Func) {
   for (int32_t i = 0; i < 3; ++i) {
     SCreateFuncReq createReq = {0};
     strcpy(createReq.name, "f1");
-    createReq.commentSize = TSDB_FUNC_COMMENT_LEN;
-    createReq.codeSize = TSDB_FUNC_CODE_LEN;
-    createReq.pCode[0] = 'a';
+    SetCode(&createReq, "code1");
+    SetComment(&createReq, "comment1");
     createReq.bufSize = TSDB_FUNC_BUF_SIZE + 1;
     createReq.igExists = 0;
     if (i == 2) createReq.igExists = 1;
@@ -163,16 +169,11 @@ TEST_F(MndTestFunc, 02_Create_Func) {
     createReq.outputLen = 12;
     createReq.bufSize = 4;
     createReq.signature = 5;
-    for (int32_t i = 0; i < createReq.commentSize - 1; ++i) {
-      createReq.pComment[i] = 'm';
-    }
-    for (int32_t i = 0; i < createReq.codeSize - 1; ++i) {
-      createReq.pCode[i] = 'd';
-    }
 
     int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSCreateFuncReq(pReq, contLen, &createReq);
+    tFreeSCreateFuncReq(&createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -197,7 +198,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
     int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq);
-    taosArrayDestroy(retrieveReq.pFuncNames);
+    tFreeSRetrieveFuncReq(&retrieveReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -217,20 +218,10 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
     EXPECT_EQ(pFuncInfo->outputLen, 12);
     EXPECT_EQ(pFuncInfo->bufSize, 4);
     EXPECT_EQ(pFuncInfo->signature, 5);
-    EXPECT_EQ(pFuncInfo->commentSize, TSDB_FUNC_COMMENT_LEN);
-    EXPECT_EQ(pFuncInfo->codeSize, TSDB_FUNC_CODE_LEN);
+    EXPECT_STREQ("comment1", pFuncInfo->pComment);
+    EXPECT_STREQ("code1", pFuncInfo->pCode);
 
-    char comments[TSDB_FUNC_COMMENT_LEN] = {0};
-    for (int32_t i = 0; i < TSDB_FUNC_COMMENT_LEN - 1; ++i) {
-      comments[i] = 'm';
-    }
-    char codes[TSDB_FUNC_CODE_LEN] = {0};
-    for (int32_t i = 0; i < TSDB_FUNC_CODE_LEN - 1; ++i) {
-      codes[i] = 'd';
-    }
-    EXPECT_STREQ(comments, pFuncInfo->pComment);
-    EXPECT_STREQ(codes, pFuncInfo->pCode);
-    taosArrayDestroy(retrieveRsp.pFuncInfos);
+    tFreeSRetrieveFuncRsp(&retrieveRsp);
   }
 
   {
@@ -241,7 +232,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
     int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq);
-    taosArrayDestroy(retrieveReq.pFuncNames);
+    tFreeSRetrieveFuncReq(&retrieveReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -259,7 +250,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
     int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq);
-    taosArrayDestroy(retrieveReq.pFuncNames);
+    tFreeSRetrieveFuncReq(&retrieveReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -275,7 +266,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
     int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq);
-    taosArrayDestroy(retrieveReq.pFuncNames);
+    tFreeSRetrieveFuncReq(&retrieveReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -285,8 +276,6 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
   {
     SCreateFuncReq createReq = {0};
     strcpy(createReq.name, "f2");
-    createReq.commentSize = 1024;
-    createReq.codeSize = 9527;
     createReq.igExists = 1;
     createReq.funcType = 2;
     createReq.scriptType = 3;
@@ -294,16 +283,13 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
     createReq.outputLen = 24;
     createReq.bufSize = 6;
     createReq.signature = 18;
-    for (int32_t i = 0; i < createReq.commentSize - 1; ++i) {
-      createReq.pComment[i] = 'p';
-    }
-    for (int32_t i = 0; i < createReq.codeSize - 1; ++i) {
-      createReq.pCode[i] = 'q';
-    }
+    SetCode(&createReq, "code2");
+    SetComment(&createReq, "comment2");
 
     int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSCreateFuncReq(pReq, contLen, &createReq);
+    tFreeSCreateFuncReq(&createReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -322,7 +308,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
     int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq);
-    taosArrayDestroy(retrieveReq.pFuncNames);
+    tFreeSRetrieveFuncReq(&retrieveReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -342,21 +328,13 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
     EXPECT_EQ(pFuncInfo->outputLen, 24);
     EXPECT_EQ(pFuncInfo->bufSize, 6);
     EXPECT_EQ(pFuncInfo->signature, 18);
-    EXPECT_EQ(pFuncInfo->commentSize, 1024);
-    EXPECT_EQ(pFuncInfo->codeSize, 9527);
+    EXPECT_EQ(pFuncInfo->commentSize, strlen("comment2") + 1);
+    EXPECT_EQ(pFuncInfo->codeSize, strlen("code2") + 1);
 
-    char comments[TSDB_FUNC_COMMENT_LEN] = {0};
-    for (int32_t i = 0; i < 1024 - 1; ++i) {
-      comments[i] = 'p';
-    }
-    char codes[TSDB_FUNC_CODE_LEN] = {0};
-    for (int32_t i = 0; i < 9527 - 1; ++i) {
-      codes[i] = 'q';
-    }
+    EXPECT_STREQ("comment2", pFuncInfo->pComment);
+    EXPECT_STREQ("code2", pFuncInfo->pCode);
 
-    EXPECT_STREQ(comments, pFuncInfo->pComment);
-    EXPECT_STREQ(codes, pFuncInfo->pCode);
-    taosArrayDestroy(retrieveRsp.pFuncInfos);
+    tFreeSRetrieveFuncRsp(&retrieveRsp);
   }
 
   {
@@ -369,7 +347,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
     int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq);
-    taosArrayDestroy(retrieveReq.pFuncNames);
+    tFreeSRetrieveFuncReq(&retrieveReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
@@ -389,20 +367,10 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
       EXPECT_EQ(pFuncInfo->outputLen, 24);
       EXPECT_EQ(pFuncInfo->bufSize, 6);
       EXPECT_EQ(pFuncInfo->signature, 18);
-      EXPECT_EQ(pFuncInfo->commentSize, 1024);
-      EXPECT_EQ(pFuncInfo->codeSize, 9527);
-
-      char comments[TSDB_FUNC_COMMENT_LEN] = {0};
-      for (int32_t i = 0; i < 1024 - 1; ++i) {
-        comments[i] = 'p';
-      }
-      char codes[TSDB_FUNC_CODE_LEN] = {0};
-      for (int32_t i = 0; i < 9527 - 1; ++i) {
-        codes[i] = 'q';
-      }
-
-      EXPECT_STREQ(comments, pFuncInfo->pComment);
-      EXPECT_STREQ(codes, pFuncInfo->pCode);
+      EXPECT_EQ(pFuncInfo->commentSize, strlen("comment2") + 1);
+      EXPECT_EQ(pFuncInfo->codeSize, strlen("code2") + 1);
+      EXPECT_STREQ("comment2", pFuncInfo->pComment);
+      EXPECT_STREQ("code2", pFuncInfo->pCode);
     }
 
     {
@@ -414,21 +382,11 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
       EXPECT_EQ(pFuncInfo->outputLen, 12);
       EXPECT_EQ(pFuncInfo->bufSize, 4);
       EXPECT_EQ(pFuncInfo->signature, 5);
-      EXPECT_EQ(pFuncInfo->commentSize, TSDB_FUNC_COMMENT_LEN);
-      EXPECT_EQ(pFuncInfo->codeSize, TSDB_FUNC_CODE_LEN);
-
-      char comments[TSDB_FUNC_COMMENT_LEN] = {0};
-      for (int32_t i = 0; i < TSDB_FUNC_COMMENT_LEN - 1; ++i) {
-        comments[i] = 'm';
-      }
-      char codes[TSDB_FUNC_CODE_LEN] = {0};
-      for (int32_t i = 0; i < TSDB_FUNC_CODE_LEN - 1; ++i) {
-        codes[i] = 'd';
-      }
-      EXPECT_STREQ(comments, pFuncInfo->pComment);
-      EXPECT_STREQ(codes, pFuncInfo->pCode);
+      EXPECT_STREQ("comment1", pFuncInfo->pComment);
+      EXPECT_STREQ("code1", pFuncInfo->pCode);
     }
-    taosArrayDestroy(retrieveRsp.pFuncInfos);
+
+    tFreeSRetrieveFuncRsp(&retrieveRsp);
   }
 
   {
@@ -441,7 +399,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
     int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq);
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq);
-    taosArrayDestroy(retrieveReq.pFuncNames);
+    tFreeSRetrieveFuncReq(&retrieveReq);
 
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);

source/dnode/vnode/CMakeLists.txt

@@ -18,12 +18,11 @@ target_sources(
     "src/vnd/vnodeSvr.c"
 
     # meta
-    # "src/meta/metaBDBImpl.c"
+    "src/meta/metaOpen.c"
     "src/meta/metaIdx.c"
-    "src/meta/metaMain.c"
     "src/meta/metaTable.c"
-    "src/meta/metaTbUid.c"
     "src/meta/metaTDBImpl.c"
+    # "src/meta/metaBDBImpl.c"
 
     # tsdb
     "src/tsdb/tsdbTDBImpl.c"

source/dnode/vnode/inc/vnode.h

@@ -37,16 +37,14 @@ extern "C" {
 
 // vnode
 typedef struct SVnode    SVnode;
-typedef struct SMetaCfg  SMetaCfg;  // todo: remove
 typedef struct STsdbCfg  STsdbCfg;  // todo: remove
-typedef struct STqCfg    STqCfg;    // todo: remove
 typedef struct SVnodeCfg SVnodeCfg;
 
 int     vnodeInit(int nthreads);
 void    vnodeCleanup();
 int     vnodeCreate(const char *path, SVnodeCfg *pCfg, STfs *pTfs);
-void    vnodeDestroy(const char *path);
-SVnode *vnodeOpen(const char *path, const SVnodeCfg *pVnodeCfg);
+void    vnodeDestroy(const char *path, STfs *pTfs);
+SVnode *vnodeOpen(const char *path, STfs *pTfs, SMsgCb msgCb);
 void    vnodeClose(SVnode *pVnode);
 void    vnodePreprocessWriteReqs(SVnode *pVnode, SArray *pMsgs);
 int     vnodeProcessWriteReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp);
@@ -73,7 +71,6 @@ char       *metaTbCursorNext(SMTbCursor *pTbCur);
 
 // tsdb
 typedef struct STsdb          STsdb;
-typedef struct SDataStatis    SDataStatis;
 typedef struct STsdbQueryCond STsdbQueryCond;
 typedef void                 *tsdbReaderT;
 
@@ -93,7 +90,7 @@ int32_t      tsdbQuerySTableByTagCond(void *pMeta, uint64_t uid, TSKEY skey, con
 int64_t      tsdbGetNumOfRowsInMemTable(tsdbReaderT *pHandle);
 bool         tsdbNextDataBlock(tsdbReaderT pTsdbReadHandle);
 void         tsdbRetrieveDataBlockInfo(tsdbReaderT *pTsdbReadHandle, SDataBlockInfo *pBlockInfo);
-int32_t      tsdbRetrieveDataBlockStatisInfo(tsdbReaderT *pTsdbReadHandle, SDataStatis **pBlockStatis);
+int32_t      tsdbRetrieveDataBlockStatisInfo(tsdbReaderT *pTsdbReadHandle, SColumnDataAgg **pBlockStatis);
 SArray      *tsdbRetrieveDataBlock(tsdbReaderT *pTsdbReadHandle, SArray *pColumnIdList);
 void         tsdbDestroyTableGroup(STableGroupInfo *pGroupList);
 int32_t      tsdbGetOneTableGroup(void *pMeta, uint64_t uid, TSKEY startKey, STableGroupInfo *pGroupInfo);
@@ -134,14 +131,9 @@ struct STsdbCfg {
   SArray  *retentions;
 };
 
-struct STqCfg {
-  int32_t reserved;
-};
-
 struct SVnodeCfg {
   int32_t  vgId;
   uint64_t dbId;
-  STfs    *pTfs;
   uint64_t wsize;
   uint64_t ssize;
   uint64_t lsize;
@@ -151,25 +143,12 @@ struct SVnodeCfg {
   int8_t   streamMode;
   bool     isWeak;
   STsdbCfg tsdbCfg;
-  SMetaCfg metaCfg;
-  STqCfg   tqCfg;
   SWalCfg  walCfg;
-  SMsgCb   msgCb;
   uint32_t hashBegin;
   uint32_t hashEnd;
   int8_t   hashMethod;
 };
 
-struct SDataStatis {
-  int16_t colId;
-  int16_t maxIndex;
-  int16_t minIndex;
-  int16_t numOfNull;
-  int64_t sum;
-  int64_t max;
-  int64_t min;
-};
-
 struct STsdbQueryCond {
   STimeWindow  twindow;
   int32_t      order;  // desc|asc order to iterate the data block

source/dnode/vnode/src/inc/meta.h

@@ -20,7 +20,6 @@
 extern "C" {
 #endif
 
-typedef struct SMetaCache  SMetaCache;
 typedef struct SMetaIdx    SMetaIdx;
 typedef struct SMetaDB     SMetaDB;
 typedef struct SMCtbCursor SMCtbCursor;
@@ -36,13 +35,22 @@ typedef struct SMSmaCursor SMSmaCursor;
 #define metaTrace(...) do { if (metaDebugFlag & DEBUG_TRACE) { taosPrintLog("META ", DEBUG_TRACE, metaDebugFlag, __VA_ARGS__); }} while(0)
 // clang-format on
 
+// metaOpen ==================
+int metaOpen(SVnode* pVnode, SMeta** ppMeta);
+int metaClose(SMeta* pMeta);
+
+// metaIdx ==================
+int  metaOpenIdx(SMeta* pMeta);
+void metaCloseIdx(SMeta* pMeta);
+int  metaSaveTableToIdx(SMeta* pMeta, const STbCfg* pTbOptions);
+int  metaRemoveTableFromIdx(SMeta* pMeta, tb_uid_t uid);
+
+static FORCE_INLINE tb_uid_t metaGenerateUid(SMeta* pMeta) { return tGenIdPI64(); }
+
 #define META_SUPER_TABLE  TD_SUPER_TABLE
 #define META_CHILD_TABLE  TD_CHILD_TABLE
 #define META_NORMAL_TABLE TD_NORMAL_TABLE
 
-SMeta*          metaOpen(const char* path, const SMetaCfg* pMetaCfg, SMemAllocatorFactory* pMAF);
-void            metaClose(SMeta* pMeta);
-void            metaRemove(const char* path);
 int             metaCreateTable(SMeta* pMeta, STbCfg* pTbCfg);
 int             metaDropTable(SMeta* pMeta, tb_uid_t uid);
 int             metaCommit(SMeta* pMeta);
@@ -71,38 +79,15 @@ int  metaRemoveTableFromDb(SMeta* pMeta, tb_uid_t uid);
 int  metaSaveSmaToDB(SMeta* pMeta, STSma* pTbCfg);
 int  metaRemoveSmaFromDb(SMeta* pMeta, int64_t indexUid);
 
-// SMetaCache
-int  metaOpenCache(SMeta* pMeta);
-void metaCloseCache(SMeta* pMeta);
-
 // SMetaIdx
-int  metaOpenIdx(SMeta* pMeta);
-void metaCloseIdx(SMeta* pMeta);
-int  metaSaveTableToIdx(SMeta* pMeta, const STbCfg* pTbOptions);
-int  metaRemoveTableFromIdx(SMeta* pMeta, tb_uid_t uid);
-
-// STbUidGnrt
-typedef struct STbUidGenerator {
-  tb_uid_t nextUid;
-} STbUidGenerator;
-
-// STableUidGenerator
-int  metaOpenUidGnrt(SMeta* pMeta);
-void metaCloseUidGnrt(SMeta* pMeta);
 
-// tb_uid_t
-#define IVLD_TB_UID 0
 tb_uid_t metaGenerateUid(SMeta* pMeta);
 
 struct SMeta {
-  char*                 path;
-  SVnode*               pVnode;
-  SMetaCfg              options;
-  SMetaDB*              pDB;
-  SMetaIdx*             pIdx;
-  SMetaCache*           pCache;
-  STbUidGenerator       uidGnrt;
-  SMemAllocatorFactory* pmaf;
+  char*     path;
+  SVnode*   pVnode;
+  SMetaDB*  pDB;
+  SMetaIdx* pIdx;
 };
 
 #ifdef __cplusplus

source/dnode/vnode/src/inc/tq.h

@@ -160,7 +160,6 @@ struct STQ {
   // the handle of meta kvstore
   bool          writeTrigger;
   char*         path;
-  STqCfg*       tqConfig;
   STqMemRef     tqMemRef;
   STqMetaStore* tqMeta;
   // STqPushMgr*   tqPushMgr;
@@ -251,8 +250,7 @@ int  tqInit();
 void tqCleanUp();
 
 // open in each vnode
-STQ* tqOpen(const char* path, SVnode* pVnode, SWal* pWal, SMeta* pMeta, STqCfg* tqConfig,
-            SMemAllocatorFactory* allocFac);
+STQ* tqOpen(const char* path, SVnode* pVnode, SWal* pWal, SMeta* pMeta, SMemAllocatorFactory* allocFac);
 void tqClose(STQ*);
 // required by vnode
 int tqPushMsg(STQ*, void* msg, int32_t msgLen, tmsg_t msgType, int64_t version);

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

@@ -43,10 +43,8 @@ typedef struct STable {
 #define TABLE_TID(t) (t)->tid
 #define TABLE_UID(t) (t)->uid
 
-STsdb  *tsdbOpen(const char *path, int32_t vgId, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF, SMeta *pMeta,
-                 STfs *pTfs);
+STsdb  *tsdbOpen(const char *path, SVnode *pVnode, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF);
 void    tsdbClose(STsdb *);
-void    tsdbRemove(const char *path);
 int     tsdbInsertData(STsdb *pTsdb, SSubmitReq *pMsg, SSubmitRsp *pRsp);
 int     tsdbPrepareCommit(STsdb *pTsdb);
 int     tsdbCommit(STsdb *pTsdb);
@@ -167,16 +165,14 @@ struct STsdb {
   SRtn                  rtn;
   SMemAllocatorFactory *pmaf;
   STsdbFS              *fs;
-  SMeta                *pMeta;
-  STfs                 *pTfs;
   SSmaEnvs              smaEnvs;
 };
 
 #define REPO_ID(r)        ((r)->vgId)
 #define REPO_CFG(r)       (&(r)->config)
 #define REPO_FS(r)        ((r)->fs)
-#define REPO_META(r)      ((r)->pMeta)
-#define REPO_TFS(r)       ((r)->pTfs)
+#define REPO_META(r)      ((r)->pVnode->pMeta)
+#define REPO_TFS(r)       ((r)->pVnode->pTfs)
 #define IS_REPO_LOCKED(r) ((r)->repoLocked)
 #define REPO_TSMA_NUM(r)  ((r)->smaEnvs.nTSma)
 #define REPO_RSMA_NUM(r)  ((r)->smaEnvs.nRSma)
@@ -438,7 +434,7 @@ int tsdbLoadBlockDataCols(SReadH *pReadh, SBlock *pBlock, SBlockInfo *pBlkInfo,
 int tsdbLoadBlockStatis(SReadH *pReadh, SBlock *pBlock);
 int tsdbEncodeSBlockIdx(void **buf, SBlockIdx *pIdx);
 void *tsdbDecodeSBlockIdx(void *buf, SBlockIdx *pIdx);
-void  tsdbGetBlockStatis(SReadH *pReadh, SDataStatis *pStatis, int numOfCols, SBlock *pBlock);
+void  tsdbGetBlockStatis(SReadH *pReadh, SColumnDataAgg *pStatis, int numOfCols, SBlock *pBlock);
 
 static FORCE_INLINE int tsdbMakeRoom(void **ppBuf, size_t size) {
   void  *pBuf = *ppBuf;

source/dnode/vnode/src/inc/vnd.h

@@ -44,6 +44,11 @@ int  vnodeGetTableMeta(SVnode* pVnode, SRpcMsg* pMsg);
 int vnodeSaveInfo(const char* dir, const SVnodeInfo* pCfg);
 int vnodeCommitInfo(const char* dir, const SVnodeInfo* pInfo);
 int vnodeLoadInfo(const char* dir, SVnodeInfo* pInfo);
+int vnodeBegin(SVnode* pVnode, int option);
+int vnodeSyncCommit(SVnode* pVnode);
+int vnodeAsyncCommit(SVnode* pVnode);
+
+#define vnodeShouldCommit vnodeBufPoolIsFull
 
 #if 1
 // SVBufPool
@@ -84,13 +89,8 @@ bool            vmaIsFull(SVMemAllocator* pVMA);
 // vnodeCfg.h
 extern const SVnodeCfg vnodeCfgDefault;
 
-int  vnodeCheckCfg(const SVnodeCfg*);
-void vnodeOptionsCopy(SVnodeCfg* pDest, const SVnodeCfg* pSrc);
+int vnodeCheckCfg(const SVnodeCfg*);
 
-// For commit
-#define vnodeShouldCommit vnodeBufPoolIsFull
-int vnodeSyncCommit(SVnode* pVnode);
-int vnodeAsyncCommit(SVnode* pVnode);
 #endif
 
 #ifdef __cplusplus

source/dnode/vnode/src/inc/vnodeInt.h

@@ -52,6 +52,11 @@ typedef struct SVState      SVState;
 typedef struct SVBufPool    SVBufPool;
 typedef struct SQWorkerMgmt SQHandle;
 
+#define VNODE_META_DIR "meta"
+#define VNODE_TSDB_DIR "tsdb"
+#define VNODE_TQ_DIR   "tq"
+#define VNODE_WAL_DIR  "wal"
+
 typedef struct {
   int8_t  streamType;  // sma or other
   int8_t  dstType;
@@ -80,10 +85,11 @@ struct SVnodeInfo {
 };
 
 struct SVnode {
-  int32_t    vgId;
   char*      path;
   SVnodeCfg  config;
   SVState    state;
+  STfs*      pTfs;
+  SMsgCb     msgCb;
   SVBufPool* pBufPool;
   SMeta*     pMeta;
   STsdb*     pTsdb;
@@ -92,10 +98,10 @@ struct SVnode {
   SSink*     pSink;
   tsem_t     canCommit;
   SQHandle*  pQuery;
-  SMsgCb     msgCb;
-  STfs*      pTfs;
 };
 
+#define TD_VID(PVNODE) (PVNODE)->config.vgId
+
 // sma
 void smaHandleRes(void* pVnode, int64_t smaId, const SArray* data);
 

source/dnode/vnode/src/meta/metaMain.c → source/dnode/vnode/src/meta/metaOpen.c

@@ -13,99 +13,54 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "tcoding.h"
-
 #include "vnodeInt.h"
 
-static SMeta *metaNew(const char *path, const SMetaCfg *pMetaCfg, SMemAllocatorFactory *pMAF);
-static void   metaFree(SMeta *pMeta);
-static int    metaOpenImpl(SMeta *pMeta);
-static void   metaCloseImpl(SMeta *pMeta);
-
-SMeta *metaOpen(const char *path, const SMetaCfg *pMetaCfg, SMemAllocatorFactory *pMAF) {
+int metaOpen(SVnode *pVnode, SMeta **ppMeta) {
   SMeta *pMeta = NULL;
+  int    slen;
 
-  // Allocate handle
-  pMeta = metaNew(path, pMetaCfg, pMAF);
-  if (pMeta == NULL) {
-    // TODO: handle error
-    return NULL;
-  }
-
-  // Create META path (TODO)
-  taosMkDir(path);
-
-  // Open meta
-  if (metaOpenImpl(pMeta) < 0) {
-    metaFree(pMeta);
-    return NULL;
-  }
-
-  return pMeta;
-}
+  *ppMeta = NULL;
 
-void metaClose(SMeta *pMeta) {
-  if (pMeta) {
-    metaCloseImpl(pMeta);
-    metaFree(pMeta);
+  // create handle
+  slen = strlen(tfsGetPrimaryPath(pVnode->pTfs)) + strlen(pVnode->path) + strlen(VNODE_META_DIR) + 3;
+  if ((pMeta = taosMemoryCalloc(1, sizeof(*pMeta) + slen)) == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
   }
-}
 
-void metaRemove(const char *path) { taosRemoveDir(path); }
+  pMeta->path = (char *)&pMeta[1];
+  sprintf(pMeta->path, "%s%s%s%s%s", tfsGetPrimaryPath(pVnode->pTfs), TD_DIRSEP, pVnode->path, TD_DIRSEP,
+          VNODE_META_DIR);
+  pMeta->pVnode = pVnode;
 
-/* ------------------------ STATIC METHODS ------------------------ */
-static SMeta *metaNew(const char *path, const SMetaCfg *pMetaCfg, SMemAllocatorFactory *pMAF) {
-  SMeta *pMeta;
-  size_t psize = strlen(path);
+  // create path if not created yet
+  taosMkDir(pMeta->path);
 
-  pMeta = (SMeta *)taosMemoryCalloc(1, sizeof(*pMeta));
-  if (pMeta == NULL) {
-    return NULL;
+  // open meta
+  if (metaOpenDB(pMeta) < 0) {
+    goto _err;
   }
 
-  pMeta->path = strdup(path);
-  if (pMeta->path == NULL) {
-    metaFree(pMeta);
-    return NULL;
+  if (metaOpenIdx(pMeta) < 0) {
+    goto _err;
   }
 
-  return pMeta;
-};
+  *ppMeta = pMeta;
+  return 0;
 
-static void metaFree(SMeta *pMeta) {
-  if (pMeta) {
-    taosMemoryFreeClear(pMeta->path);
-    taosMemoryFree(pMeta);
-  }
+_err:
+  if (pMeta->pIdx) metaCloseIdx(pMeta);
+  if (pMeta->pDB) metaCloseDB(pMeta);
+  taosMemoryFree(pMeta);
+  return -1;
 }
 
-static int metaOpenImpl(SMeta *pMeta) {
-  // Open meta db
-  if (metaOpenDB(pMeta) < 0) {
-    // TODO: handle error
-    metaCloseImpl(pMeta);
-    return -1;
-  }
-
-  // Open meta index
-  if (metaOpenIdx(pMeta) < 0) {
-    // TODO: handle error
-    metaCloseImpl(pMeta);
-    return -1;
-  }
-
-  // Open meta table uid generator
-  if (metaOpenUidGnrt(pMeta) < 0) {
-    // TODO: handle error
-    metaCloseImpl(pMeta);
-    return -1;
+int metaClose(SMeta *pMeta) {
+  if (pMeta) {
+    metaCloseIdx(pMeta);
+    metaCloseDB(pMeta);
+    taosMemoryFree(pMeta);
   }
 
   return 0;
-}
-
-static void metaCloseImpl(SMeta *pMeta) {
-  metaCloseUidGnrt(pMeta);
-  metaCloseIdx(pMeta);
-  metaCloseDB(pMeta);
 }
\ No newline at end of file

source/dnode/vnode/src/tq/tq.c

@@ -19,15 +19,13 @@ int32_t tqInit() { return tqPushMgrInit(); }
 
 void tqCleanUp() { tqPushMgrCleanUp(); }
 
-STQ* tqOpen(const char* path, SVnode* pVnode, SWal* pWal, SMeta* pVnodeMeta, STqCfg* tqConfig,
-            SMemAllocatorFactory* allocFac) {
+STQ* tqOpen(const char* path, SVnode* pVnode, SWal* pWal, SMeta* pVnodeMeta, SMemAllocatorFactory* allocFac) {
   STQ* pTq = taosMemoryMalloc(sizeof(STQ));
   if (pTq == NULL) {
     terrno = TSDB_CODE_TQ_OUT_OF_MEMORY;
     return NULL;
   }
   pTq->path = strdup(path);
-  pTq->tqConfig = tqConfig;
   pTq->pVnode = pVnode;
   pTq->pWal = pWal;
   pTq->pVnodeMeta = pVnodeMeta;
@@ -267,7 +265,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
   }
 
   vDebug("tmq poll: consumer %ld (epoch %d) recv poll req in vg %d, req %ld %ld", consumerId, pReq->epoch,
-         pTq->pVnode->vgId, pReq->currentOffset, fetchOffset);
+         TD_VID(pTq->pVnode), pReq->currentOffset, fetchOffset);
 
   SMqPollRsp rsp = {
       /*.consumerId = consumerId,*/
@@ -277,7 +275,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
 
   STqConsumer* pConsumer = tqHandleGet(pTq->tqMeta, consumerId);
   if (pConsumer == NULL) {
-    vWarn("tmq poll: consumer %ld (epoch %d) not found in vg %d", consumerId, pReq->epoch, pTq->pVnode->vgId);
+    vWarn("tmq poll: consumer %ld (epoch %d) not found in vg %d", consumerId, pReq->epoch, TD_VID(pTq->pVnode));
     pMsg->pCont = NULL;
     pMsg->contLen = 0;
     pMsg->code = -1;
@@ -303,7 +301,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
   }
   if (pTopic == NULL) {
     vWarn("tmq poll: consumer %ld (epoch %d) topic %s not found in vg %d", consumerId, pReq->epoch, pReq->topic,
-          pTq->pVnode->vgId);
+          TD_VID(pTq->pVnode));
     pMsg->pCont = NULL;
     pMsg->contLen = 0;
     pMsg->code = -1;
@@ -312,7 +310,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
   }
 
   vDebug("poll topic %s from consumer %ld (epoch %d) vg %d", pTopic->topicName, consumerId, pReq->epoch,
-         pTq->pVnode->vgId);
+         TD_VID(pTq->pVnode));
 
   rsp.reqOffset = pReq->currentOffset;
   rsp.skipLogNum = 0;
@@ -323,7 +321,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
     consumerEpoch = atomic_load_32(&pConsumer->epoch);
     if (consumerEpoch > reqEpoch) {
       vDebug("tmq poll: consumer %ld (epoch %d) vg %d offset %ld, found new consumer epoch %d discard req epoch %d",
-             consumerId, pReq->epoch, pTq->pVnode->vgId, fetchOffset, consumerEpoch, reqEpoch);
+             consumerId, pReq->epoch, TD_VID(pTq->pVnode), fetchOffset, consumerEpoch, reqEpoch);
       break;
     }
     SWalReadHead* pHead;
@@ -332,11 +330,11 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
       // if data inserted during waiting, launch query and
       // response to user
       vDebug("tmq poll: consumer %ld (epoch %d) vg %d offset %ld, no more log to return", consumerId, pReq->epoch,
-             pTq->pVnode->vgId, fetchOffset);
+             TD_VID(pTq->pVnode), fetchOffset);
       break;
     }
     vDebug("tmq poll: consumer %ld (epoch %d) iter log, vg %d offset %ld msgType %d", consumerId, pReq->epoch,
-           pTq->pVnode->vgId, fetchOffset, pHead->msgType);
+           TD_VID(pTq->pVnode), fetchOffset, pHead->msgType);
     /*int8_t pos = fetchOffset % TQ_BUFFER_SIZE;*/
     /*pHead = pTopic->pReadhandle->pHead;*/
     if (pHead->msgType == TDMT_VND_SUBMIT) {
@@ -361,7 +359,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
 
       if (taosArrayGetSize(pRes) == 0) {
         vDebug("tmq poll: consumer %ld (epoch %d) iter log, vg %d skip log %ld since not wanted", consumerId,
-               pReq->epoch, pTq->pVnode->vgId, fetchOffset);
+               pReq->epoch, TD_VID(pTq->pVnode), fetchOffset);
         fetchOffset++;
         rsp.skipLogNum++;
         taosArrayDestroy(pRes);
@@ -390,7 +388,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
       pMsg->pCont = buf;
       pMsg->contLen = tlen;
       pMsg->code = 0;
-      vDebug("vg %d offset %ld msgType %d from consumer %ld (epoch %d) actual rsp", pTq->pVnode->vgId, fetchOffset,
+      vDebug("vg %d offset %ld msgType %d from consumer %ld (epoch %d) actual rsp", TD_VID(pTq->pVnode), fetchOffset,
              pHead->msgType, consumerId, pReq->epoch);
       tmsgSendRsp(pMsg);
       taosMemoryFree(pHead);
@@ -422,7 +420,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
   pMsg->contLen = tlen;
   pMsg->code = 0;
   tmsgSendRsp(pMsg);
-  vDebug("vg %d offset %ld from consumer %ld (epoch %d) not rsp", pTq->pVnode->vgId, fetchOffset, consumerId,
+  vDebug("vg %d offset %ld from consumer %ld (epoch %d) not rsp", TD_VID(pTq->pVnode), fetchOffset, consumerId,
          pReq->epoch);
   /*}*/
 
@@ -446,14 +444,14 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
   }
 
   vDebug("tmq poll: consumer %ld (epoch %d) recv poll req in vg %d, req %ld %ld", consumerId, pReq->epoch,
-         pTq->pVnode->vgId, pReq->currentOffset, fetchOffset);
+         TD_VID(pTq->pVnode), pReq->currentOffset, fetchOffset);
 
   SMqPollRspV2 rspV2 = {0};
   rspV2.dataLen = 0;
 
   STqConsumer* pConsumer = tqHandleGet(pTq->tqMeta, consumerId);
   if (pConsumer == NULL) {
-    vWarn("tmq poll: consumer %ld (epoch %d) not found in vg %d", consumerId, pReq->epoch, pTq->pVnode->vgId);
+    vWarn("tmq poll: consumer %ld (epoch %d) not found in vg %d", consumerId, pReq->epoch, TD_VID(pTq->pVnode));
     pMsg->pCont = NULL;
     pMsg->contLen = 0;
     pMsg->code = -1;
@@ -479,7 +477,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
   }
   if (pTopic == NULL) {
     vWarn("tmq poll: consumer %ld (epoch %d) topic %s not found in vg %d", consumerId, pReq->epoch, pReq->topic,
-          pTq->pVnode->vgId);
+          TD_VID(pTq->pVnode));
     pMsg->pCont = NULL;
     pMsg->contLen = 0;
     pMsg->code = -1;
@@ -488,7 +486,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
   }
 
   vDebug("poll topic %s from consumer %ld (epoch %d) vg %d", pTopic->topicName, consumerId, pReq->epoch,
-         pTq->pVnode->vgId);
+         TD_VID(pTq->pVnode));
 
   rspV2.reqOffset = pReq->currentOffset;
   rspV2.skipLogNum = 0;
@@ -499,7 +497,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
     consumerEpoch = atomic_load_32(&pConsumer->epoch);
     if (consumerEpoch > reqEpoch) {
       vDebug("tmq poll: consumer %ld (epoch %d) vg %d offset %ld, found new consumer epoch %d discard req epoch %d",
-             consumerId, pReq->epoch, pTq->pVnode->vgId, fetchOffset, consumerEpoch, reqEpoch);
+             consumerId, pReq->epoch, TD_VID(pTq->pVnode), fetchOffset, consumerEpoch, reqEpoch);
       break;
     }
     SWalReadHead* pHead;
@@ -508,11 +506,11 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
       // if data inserted during waiting, launch query and
       // response to user
       vDebug("tmq poll: consumer %ld (epoch %d) vg %d offset %ld, no more log to return", consumerId, pReq->epoch,
-             pTq->pVnode->vgId, fetchOffset);
+             TD_VID(pTq->pVnode), fetchOffset);
       break;
     }
     vDebug("tmq poll: consumer %ld (epoch %d) iter log, vg %d offset %ld msgType %d", consumerId, pReq->epoch,
-           pTq->pVnode->vgId, fetchOffset, pHead->msgType);
+           TD_VID(pTq->pVnode), fetchOffset, pHead->msgType);
     /*int8_t pos = fetchOffset % TQ_BUFFER_SIZE;*/
     /*pHead = pTopic->pReadhandle->pHead;*/
     if (pHead->msgType == TDMT_VND_SUBMIT) {
@@ -537,7 +535,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
 
       if (taosArrayGetSize(pRes) == 0) {
         vDebug("tmq poll: consumer %ld (epoch %d) iter log, vg %d skip log %ld since not wanted", consumerId,
-               pReq->epoch, pTq->pVnode->vgId, fetchOffset);
+               pReq->epoch, TD_VID(pTq->pVnode), fetchOffset);
         fetchOffset++;
         rspV2.skipLogNum++;
         taosArrayDestroy(pRes);
@@ -597,7 +595,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
       pMsg->pCont = buf;
       pMsg->contLen = msgLen;
       pMsg->code = 0;
-      vDebug("vg %d offset %ld msgType %d from consumer %ld (epoch %d) actual rsp", pTq->pVnode->vgId, fetchOffset,
+      vDebug("vg %d offset %ld msgType %d from consumer %ld (epoch %d) actual rsp", TD_VID(pTq->pVnode), fetchOffset,
              pHead->msgType, consumerId, pReq->epoch);
       tmsgSendRsp(pMsg);
       taosMemoryFree(pHead);
@@ -631,7 +629,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
   pMsg->contLen = tlen;
   pMsg->code = 0;
   tmsgSendRsp(pMsg);
-  vDebug("vg %d offset %ld from consumer %ld (epoch %d) not rsp", pTq->pVnode->vgId, fetchOffset, consumerId,
+  vDebug("vg %d offset %ld from consumer %ld (epoch %d) not rsp", TD_VID(pTq->pVnode), fetchOffset, consumerId,
          pReq->epoch);
   /*}*/
 
@@ -742,7 +740,7 @@ int32_t tqProcessSetConnReq(STQ* pTq, char* msg) {
     pTopic->buffer.output[i].task = qCreateStreamExecTaskInfo(req.qmsg, &handle);
     ASSERT(pTopic->buffer.output[i].task);
   }
-  vDebug("set topic %s to consumer %ld on vg %d", pTopic->topicName, req.consumerId, pTq->pVnode->vgId);
+  vDebug("set topic %s to consumer %ld on vg %d", pTopic->topicName, req.consumerId, TD_VID(pTq->pVnode));
   taosArrayPush(pConsumer->topics, pTopic);
   if (create) {
     tqHandleMovePut(pTq->tqMeta, req.consumerId, pConsumer);

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

@@ -100,7 +100,7 @@ int tsdbApplyRtnOnFSet(STsdb *pRepo, SDFileSet *pSet, SRtn *pRtn) {
 
   level = tsdbGetFidLevel(pSet->fid, pRtn);
 
-  if (tfsAllocDisk(pRepo->pTfs, level, &did) < 0) {
+  if (tfsAllocDisk(pRepo->pVnode->pTfs, level, &did) < 0) {
     terrno = TSDB_CODE_TDB_NO_AVAIL_DISK;
     return -1;
   }
@@ -427,7 +427,7 @@ static int tsdbCreateCommitIters(SCommitH *pCommith) {
     pCommitIter->pTable = (STable *)taosMemoryMalloc(sizeof(STable));
     pCommitIter->pTable->uid = pTbData->uid;
     pCommitIter->pTable->tid = pTbData->uid;
-    pCommitIter->pTable->pSchema = metaGetTbTSchema(pRepo->pMeta, pTbData->uid, 0);
+    pCommitIter->pTable->pSchema = metaGetTbTSchema(REPO_META(pRepo), pTbData->uid, 0);
   }
 
   return 0;
@@ -459,7 +459,7 @@ static int tsdbSetAndOpenCommitFile(SCommitH *pCommith, SDFileSet *pSet, int fid
   STsdb     *pRepo = TSDB_COMMIT_REPO(pCommith);
   SDFileSet *pWSet = TSDB_COMMIT_WRITE_FSET(pCommith);
 
-  if (tfsAllocDisk(pRepo->pTfs, tsdbGetFidLevel(fid, &(pCommith->rtn)), &did) < 0) {
+  if (tfsAllocDisk(REPO_TFS(pRepo), tsdbGetFidLevel(fid, &(pCommith->rtn)), &did) < 0) {
     terrno = TSDB_CODE_TDB_NO_AVAIL_DISK;
     return -1;
   }
@@ -1201,6 +1201,23 @@ static int tsdbComparKeyBlock(const void *arg1, const void *arg2) {
   }
 }
 
+/**
+ * @brief Write SDataCols to data file.
+ *
+ * @param pRepo
+ * @param pTable
+ * @param pDFile
+ * @param pDFileAggr
+ * @param pDataCols The pDataCols would be generated from mem/imem directly with 2 bits bitmap or from tsdbRead
+ * interface with 1 bit bitmap.
+ * @param pBlock
+ * @param isLast
+ * @param isSuper
+ * @param ppBuf
+ * @param ppCBuf
+ * @param ppExBuf
+ * @return int
+ */
 int tsdbWriteBlockImpl(STsdb *pRepo, STable *pTable, SDFile *pDFile, SDFile *pDFileAggr, SDataCols *pDataCols,
                        SBlock *pBlock, bool isLast, bool isSuper, void **ppBuf, void **ppCBuf, void **ppExBuf) {
   STsdbCfg     *pCfg = REPO_CFG(pRepo);
@@ -1244,14 +1261,15 @@ int tsdbWriteBlockImpl(STsdb *pRepo, STable *pTable, SDFile *pDFile, SDFile *pDF
     pBlockCol->type = pDataCol->type;
     pAggrBlkCol->colId = pDataCol->colId;
 
-    if (tDataTypes[pDataCol->type].statisFunc) {
+    if (isSuper && pColumn->sma && tDataTypes[pDataCol->type].statisFunc) {
 #if 0
       (*tDataTypes[pDataCol->type].statisFunc)(pDataCol->pData, rowsToWrite, &(pBlockCol->min), &(pBlockCol->max),
                                                &(pBlockCol->sum), &(pBlockCol->minIndex), &(pBlockCol->maxIndex),
                                                &(pBlockCol->numOfNull));
 #endif
-      (*tDataTypes[pDataCol->type].statisFunc)(pDataCol->pData, rowsToWrite, &(pAggrBlkCol->min), &(pAggrBlkCol->max),
-                                               &(pAggrBlkCol->sum), &(pAggrBlkCol->minIndex), &(pAggrBlkCol->maxIndex),
+      (*tDataTypes[pDataCol->type].statisFunc)(pDataCols->bitmapMode, pDataCol->pBitmap, pDataCol->pData, rowsToWrite,
+                                               &(pAggrBlkCol->min), &(pAggrBlkCol->max), &(pAggrBlkCol->sum),
+                                               &(pAggrBlkCol->minIndex), &(pAggrBlkCol->maxIndex),
                                                &(pAggrBlkCol->numOfNull));
 
       if (pAggrBlkCol->numOfNull == 0) {
@@ -1259,13 +1277,16 @@ int tsdbWriteBlockImpl(STsdb *pRepo, STable *pTable, SDFile *pDFile, SDFile *pDF
       } else {
         TD_SET_COL_ROWS_MISC(pBlockCol);
       }
+    } else if (tdIsBitmapBlkNorm(pDataCol->pBitmap, rowsToWrite, pDataCols->bitmapMode)) {
+      // check if all rows normal
+      TD_SET_COL_ROWS_NORM(pBlockCol);
     } else {
       TD_SET_COL_ROWS_MISC(pBlockCol);
     }
 
     ++nColsNotAllNull;
 
-    if (pColumn->sma) {
+    if (isSuper && pColumn->sma) {
       ++nColsOfBlockSma;
     }
   }
@@ -1277,7 +1298,7 @@ int tsdbWriteBlockImpl(STsdb *pRepo, STable *pTable, SDFile *pDFile, SDFile *pDF
   uint32_t toffset = 0;
   int32_t  tsize = (int32_t)tsdbBlockStatisSize(nColsNotAllNull, SBlockVerLatest);
   int32_t  lsize = tsize;
-  uint32_t tsizeAggr = (uint32_t)tsdbBlockAggrSize(nColsNotAllNull, SBlockVerLatest);
+  uint32_t tsizeAggr = (uint32_t)tsdbBlockAggrSize(nColsOfBlockSma, SBlockVerLatest);
   int32_t  keyLen = 0;
   int32_t  nBitmaps = (int32_t)TD_BITMAP_BYTES(rowsToWrite);
   int32_t  sBitmaps = isSuper ? (int32_t)TD_BITMAP_BYTES_I(rowsToWrite) : nBitmaps;

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

@@ -644,7 +644,7 @@ static int tsdbComparFidFSet(const void *arg1, const void *arg2) {
 }
 
 static void tsdbGetTxnFname(STsdb *pRepo, TSDB_TXN_FILE_T ftype, char fname[]) {
-  snprintf(fname, TSDB_FILENAME_LEN, "%s/vnode/vnode%d/tsdb/%s", tfsGetPrimaryPath(pRepo->pTfs), pRepo->vgId,
+  snprintf(fname, TSDB_FILENAME_LEN, "%s/vnode/vnode%d/tsdb/%s", tfsGetPrimaryPath(REPO_TFS(pRepo)), pRepo->vgId,
            tsdbTxnFname[ftype]);
 }
 
@@ -912,7 +912,7 @@ static int tsdbScanRootDir(STsdb *pRepo) {
   const STfsFile *pf;
 
   tsdbGetRootDir(REPO_ID(pRepo), rootDir);
-  STfsDir *tdir = tfsOpendir(pRepo->pTfs, rootDir);
+  STfsDir *tdir = tfsOpendir(REPO_TFS(pRepo), rootDir);
   if (tdir == NULL) {
     tsdbError("vgId:%d failed to open directory %s since %s", REPO_ID(pRepo), rootDir, tstrerror(terrno));
     return -1;
@@ -946,7 +946,7 @@ static int tsdbScanDataDir(STsdb *pRepo) {
   const STfsFile *pf;
 
   tsdbGetDataDir(REPO_ID(pRepo), dataDir);
-  STfsDir *tdir = tfsOpendir(pRepo->pTfs, dataDir);
+  STfsDir *tdir = tfsOpendir(REPO_TFS(pRepo), dataDir);
   if (tdir == NULL) {
     tsdbError("vgId:%d failed to open directory %s since %s", REPO_ID(pRepo), dataDir, tstrerror(terrno));
     return -1;
@@ -1128,7 +1128,7 @@ static int tsdbRestoreDFileSet(STsdb *pRepo) {
     return -1;
   }
 
-  tdir = tfsOpendir(pRepo->pTfs, dataDir);
+  tdir = tfsOpendir(REPO_TFS(pRepo), dataDir);
   if (tdir == NULL) {
     tsdbError("vgId:%d failed to restore DFileSet while open directory %s since %s", REPO_ID(pRepo), dataDir,
               tstrerror(terrno));

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

@@ -311,7 +311,7 @@ void tsdbInitDFile(STsdb *pRepo, SDFile *pDFile, SDiskID did, int fid, uint32_t
   pDFile->info.fver = tsdbGetDFSVersion(ftype);
 
   tsdbGetFilename(pRepo->vgId, fid, ver, ftype, fname);
-  tfsInitFile(pRepo->pTfs, &(pDFile->f), did, fname);
+  tfsInitFile(REPO_TFS(pRepo), &(pDFile->f), did, fname);
 }
 
 void tsdbInitDFileEx(SDFile *pDFile, SDFile *pODFile) {
@@ -330,7 +330,7 @@ int tsdbEncodeSDFile(void **buf, SDFile *pDFile) {
 
 void *tsdbDecodeSDFile(STsdb *pRepo, void *buf, SDFile *pDFile) {
   buf = tsdbDecodeDFInfo(buf, &(pDFile->info));
-  buf = tfsDecodeFile(pRepo->pTfs, buf, &(pDFile->f));
+  buf = tfsDecodeFile(REPO_TFS(pRepo), buf, &(pDFile->f));
   TSDB_FILE_SET_CLOSED(pDFile);
 
   return buf;
@@ -365,7 +365,7 @@ int tsdbCreateDFile(STsdb *pRepo, SDFile *pDFile, bool updateHeader, TSDB_FILE_T
     if (errno == ENOENT) {
       // Try to create directory recursively
       char *s = strdup(TSDB_FILE_REL_NAME(pDFile));
-      if (tfsMkdirRecurAt(pRepo->pTfs, taosDirName(s), TSDB_FILE_DID(pDFile)) < 0) {
+      if (tfsMkdirRecurAt(REPO_TFS(pRepo), taosDirName(s), TSDB_FILE_DID(pDFile)) < 0) {
         taosMemoryFreeClear(s);
         return -1;
       }
@@ -443,7 +443,7 @@ int tsdbLoadDFileHeader(SDFile *pDFile, SDFInfo *pInfo) {
 }
 
 static int tsdbScanAndTryFixDFile(STsdb *pRepo, SDFile *pDFile) {
-  SDFile      df;
+  SDFile df;
 
   tsdbInitDFileEx(&df, pDFile);
 

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

@@ -15,14 +15,12 @@
 
 #include "vnodeInt.h"
 
-static STsdb *tsdbNew(const char *path, int32_t vgId, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF,
-                      SMeta *pMeta, STfs *pTfs);
+static STsdb *tsdbNew(const char *path, SVnode *pVnode, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF);
 static void   tsdbFree(STsdb *pTsdb);
 static int    tsdbOpenImpl(STsdb *pTsdb);
 static void   tsdbCloseImpl(STsdb *pTsdb);
 
-STsdb *tsdbOpen(const char *path, int32_t vgId, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF, SMeta *pMeta,
-                STfs *pTfs) {
+STsdb *tsdbOpen(const char *path, SVnode *pVnode, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF) {
   STsdb *pTsdb = NULL;
 
   // Set default TSDB Options
@@ -37,7 +35,7 @@ STsdb *tsdbOpen(const char *path, int32_t vgId, const STsdbCfg *pTsdbCfg, SMemAl
   }
 
   // Create the handle
-  pTsdb = tsdbNew(path, vgId, pTsdbCfg, pMAF, pMeta, pTfs);
+  pTsdb = tsdbNew(path, pVnode, pTsdbCfg, pMAF);
   if (pTsdb == NULL) {
     // TODO: handle error
     return NULL;
@@ -61,11 +59,8 @@ void tsdbClose(STsdb *pTsdb) {
   }
 }
 
-void tsdbRemove(const char *path) { taosRemoveDir(path); }
-
 /* ------------------------ STATIC METHODS ------------------------ */
-static STsdb *tsdbNew(const char *path, int32_t vgId, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF,
-                      SMeta *pMeta, STfs *pTfs) {
+static STsdb *tsdbNew(const char *path, SVnode *pVnode, const STsdbCfg *pTsdbCfg, SMemAllocatorFactory *pMAF) {
   STsdb *pTsdb = NULL;
 
   pTsdb = (STsdb *)taosMemoryCalloc(1, sizeof(STsdb));
@@ -75,11 +70,10 @@ static STsdb *tsdbNew(const char *path, int32_t vgId, const STsdbCfg *pTsdbCfg,
   }
 
   pTsdb->path = strdup(path);
-  pTsdb->vgId = vgId;
+  pTsdb->vgId = TD_VID(pVnode);
+  pTsdb->pVnode = pVnode;
   tsdbOptionsCopy(&(pTsdb->config), pTsdbCfg);
   pTsdb->pmaf = pMAF;
-  pTsdb->pMeta = pMeta;
-  pTsdb->pTfs = pTfs;
   pTsdb->fs = tsdbNewFS(pTsdbCfg);
 
   return pTsdb;
@@ -156,7 +150,7 @@ int tsdbUnlockRepo(STsdb *pTsdb) {
 
 #define IS_VALID_PRECISION(precision) \
   (((precision) >= TSDB_TIME_PRECISION_MILLI) && ((precision) <= TSDB_TIME_PRECISION_NANO))
-#define TSDB_DEFAULT_COMPRESSION TWO_STAGE_COMP
+#define TSDB_DEFAULT_COMPRESSION          TWO_STAGE_COMP
 #define IS_VALID_COMPRESSION(compression) (((compression) >= NO_COMPRESSION) && ((compression) <= TWO_STAGE_COMP))
 
 static int32_t    tsdbCheckAndSetDefaultCfg(STsdbCfg *pCfg);

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

@@ -97,8 +97,8 @@ int tsdbMemTableInsert(STsdb *pTsdb, STsdbMemTable *pMemTable, SSubmitReq *pMsg,
   }
 
   if (pRsp != NULL) {
-    pRsp->affectedRows = htonl(affectedrows);
-    pRsp->numOfRows = htonl(numOfRows);
+    pRsp->affectedRows = affectedrows;
+    pRsp->numOfRows = numOfRows;
   }
 
   return 0;

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

@@ -433,7 +433,7 @@ void *tsdbDecodeSBlockIdx(void *buf, SBlockIdx *pIdx) {
   return buf;
 }
 
-void tsdbGetBlockStatis(SReadH *pReadh, SDataStatis *pStatis, int numOfCols, SBlock *pBlock) {
+void tsdbGetBlockStatis(SReadH *pReadh, SColumnDataAgg *pStatis, int numOfCols, SBlock *pBlock) {
 #ifdef TD_REFACTOR_3
   SBlockData *pBlockData = pReadh->pBlkData;
 

source/dnode/vnode/src/vnd/vnodeCfg.c

@@ -23,11 +23,6 @@ int vnodeCheckCfg(const SVnodeCfg *pCfg) {
   return 0;
 }
 
-#if 1  //======================================================================
-void vnodeOptionsCopy(SVnodeCfg *pDest, const SVnodeCfg *pSrc) {
-  memcpy((void *)pDest, (void *)pSrc, sizeof(SVnodeCfg));
-}
-
 int vnodeValidateTableHash(SVnodeCfg *pVnodeOptions, char *tableFName) {
   uint32_t hashValue = 0;
 
@@ -47,5 +42,3 @@ int vnodeValidateTableHash(SVnodeCfg *pVnodeOptions, char *tableFName) {
 
   return TSDB_CODE_SUCCESS;
 }
-
-#endif
\ No newline at end of file

source/libs/catalog/test/CMakeLists.txt

@@ -8,7 +8,7 @@ AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SOURCE_LIST)
 ADD_EXECUTABLE(catalogTest ${SOURCE_LIST})
 TARGET_LINK_LIBRARIES(
         catalogTest
-        PUBLIC os util common catalog transport gtest qcom taos
+        PUBLIC os util common catalog transport gtest qcom taos_static
 )
 
 TARGET_INCLUDE_DIRECTORIES(