Merge branch '3.0' into doc/analysis

Jenkinsfile2

@@ -1,9 +1,11 @@
 import hudson.model.Result
 import hudson.model.*;
 import jenkins.model.CauseOfInterruption
-docs_only=0
 node {
 }
+file_zh_changed = ''
+file_en_changed = ''
+file_no_doc_changed = ''
 def abortPreviousBuilds() {
     def currentJobName = env.JOB_NAME
     def currentBuildNumber = env.BUILD_NUMBER.toInteger()
@@ -29,7 +31,7 @@ def abort_previous(){
     if (buildNumber > 1) milestone(buildNumber - 1)
     milestone(buildNumber)
 }
-def check_docs() {
+def check_docs(){
     if (env.CHANGE_URL =~ /\/TDengine\//) {
         sh '''
             hostname
@@ -40,39 +42,94 @@ def check_docs() {
             cd ${WKC}
             git reset --hard
             git clean -f
-            rm -rf examples/rust/
             git remote prune origin
             git fetch
-        '''
-        script {
-            sh '''
-                cd ${WKC}
-                git checkout ''' + env.CHANGE_TARGET + '''
-            '''
-        }
-        sh '''
-            cd ${WKC}
-            git remote prune origin
+            git checkout ''' + env.CHANGE_TARGET + '''
             git pull >/dev/null
             git fetch origin +refs/pull/${CHANGE_ID}/merge
-            git checkout -qf FETCH_HEAD
+            git checkout -qf FETCH_HEAD 
         '''
-        def file_changed = sh (
+
+        file_zh_changed = sh (
             script: '''
                 cd ${WKC}
-                git --no-pager diff --name-only FETCH_HEAD `git merge-base FETCH_HEAD ${CHANGE_TARGET}`|grep -v "^docs/en/"|grep -v "^docs/zh/" || :
+                git --no-pager diff --name-only FETCH_HEAD `git merge-base FETCH_HEAD ${CHANGE_TARGET}`|grep  "^docs/zh/" || :
+            ''',
+            returnStdout: true
+        )
+
+        file_en_changed = sh (
+            script: '''
+                cd ${WKC}
+                git --no-pager diff --name-only FETCH_HEAD `git merge-base FETCH_HEAD ${CHANGE_TARGET}`|grep  "^docs/en/" || :
+            ''',
+            returnStdout: true
+        )
+        
+        file_no_doc_changed = sh (
+            script: '''
+                cd ${WKC}
+                git --no-pager diff --name-only FETCH_HEAD `git merge-base FETCH_HEAD ${CHANGE_TARGET}`|grep -v "^docs/en/"|grep -v "^docs/zh/"|grep -v "*.md" || :
             ''',
             returnStdout: true
         ).trim()
-        if (file_changed == '') {
-            echo "docs PR"
-            docs_only=1
-        } else {
-            echo file_changed
-        }
-        env.FILE_CHANGED = file_changed
+        echo "file_zh_changed: ${file_zh_changed}"
+        echo "file_en_changed: ${file_en_changed}"
+        echo "file_no_doc_changed: ${file_no_doc_changed}"
     }
 }
+
+def build_pre_docs(){
+    if (env.CHANGE_URL =~ /\/TDengine\//) {
+        sh '''
+            hostname
+            date
+            env
+        '''
+        
+        sh '''
+            cd ${DOC_WKC}/${td_repo}
+            git reset --hard
+            git clean -f
+            git remote prune origin
+            git fetch
+            git checkout ''' + env.CHANGE_TARGET + '''
+            git pull >/dev/null
+            git fetch origin +refs/pull/${CHANGE_ID}/merge
+            git checkout -qf FETCH_HEAD 
+        '''
+
+        sh '''
+             cd ${DOC_WKC}/${tools_repo}
+            git reset --hard
+            git clean -f
+            git fetch
+            git remote prune origin
+            git checkout ''' + env.CHANGE_TARGET + '''
+            git pull >/dev/null
+        '''
+    }
+}
+
+def build_zh_docs(){
+    sh '''
+        cd ${DOC_WKC}/${zh_doc_repo}
+        # git pull 
+        yarn ass local
+        yarn build
+    '''
+}
+
+def build_en_docs(){
+    sh '''
+        cd ${DOC_WKC}/${en_doc_repo}
+        # git pull 
+        yarn ass local
+        yarn build
+    '''
+}
+
+
 def pre_test(){
     sh '''
         hostname
@@ -153,6 +210,7 @@ def pre_test(){
     '''
     return 1
 }
+
 def pre_test_build_mac() {
     sh '''
         hostname
@@ -173,6 +231,7 @@ def pre_test_build_mac() {
         date
     '''
 }
+
 def pre_test_win(){
     bat '''
         hostname
@@ -273,17 +332,8 @@ def pre_test_win(){
         cd %WIN_COMMUNITY_ROOT%
         git submodule update --init --recursive
     '''
-    bat '''
-        cd %WIN_CONNECTOR_ROOT%
-        git branch
-        git reset --hard
-        git pull
-    '''
-    bat '''
-        cd %WIN_CONNECTOR_ROOT%
-        git log -5
-    '''
 }
+
 def pre_test_build_win() {
     bat '''
         echo "building ..."
@@ -303,16 +353,14 @@ def pre_test_build_win() {
         time /t
     '''
     bat '''
-        cd %WIN_CONNECTOR_ROOT%
-        python.exe -m pip install --upgrade pip
-        python -m pip uninstall taospy -y 
-        python -m pip install taospy==2.7.16
-        python -m pip uninstall taos-ws-py -y 
-        python -m pip install taos-ws-py==0.3.3
+        cd %WIN_COMMUNITY_ROOT%/tests/ci
+        pip3 install taospy==2.7.16 
+        pip3 install taos-ws-py==0.3.3
         xcopy /e/y/i/f %WIN_INTERNAL_ROOT%\\debug\\build\\lib\\taos.dll C:\\Windows\\System32
     '''
     return 1
 }
+
 def run_win_ctest() {
     bat '''
         echo "windows ctest ..."
@@ -322,10 +370,10 @@ def run_win_ctest() {
         time /t
     '''
 }
+
 def run_win_test() {
     bat '''
         echo "windows test ..."
-        cd %WIN_CONNECTOR_ROOT%
         xcopy /e/y/i/f %WIN_INTERNAL_ROOT%\\debug\\build\\lib\\taos.dll C:\\Windows\\System32
         ls -l C:\\Windows\\System32\\taos.dll
         time /t
@@ -344,28 +392,67 @@ pipeline {
         WK = '/var/lib/jenkins/workspace/TDinternal'
         WKC = '/var/lib/jenkins/workspace/TDinternal/community'
         WKPY = '/var/lib/jenkins/workspace/taos-connector-python'
+        DOC_WKC = '/root/doc_ci_work'
+        td_repo = 'TDengine'
+        zh_doc_repo = 'docs.taosdata.com'
+        en_doc_repo = 'docs.tdengine.com'
+        tools_repo = 'taos-tools'
     }
     stages {
-        stage('check') {
+        stage ('check doc file changed') {
+            agent{label " slave1_47 || slave1_48 || slave1_49 || slave1_50 || slave1_52  || slave1_59 || slave1_63 ||  worker03 || slave215 || slave217 || slave219 || Mac_catalina "}            
+            steps {
+                check_docs()
+            }
+        }
+        
+        stage ('pre for build docs') {
             when {
-                allOf {
-                    not { expression { env.CHANGE_BRANCH =~ /docs\// }}
-                }
+                beforeAgent true
+                expression { env.CHANGE_BRANCH =~ /(?i)doc.*/ || file_zh_changed != '' || file_en_changed != '' }
+            }
+            agent{label "doc_build_0_30"}
+            steps {
+                build_pre_docs()
+            }
+        }
+
+        stage('build Docs') {
+            when {
+                beforeAgent true
+                expression { env.CHANGE_BRANCH =~ /(?i)doc.*/ || file_zh_changed != '' || file_en_changed != '' }
             }
             parallel {
-                stage('check docs') {
-                    agent{label " slave1_47 || slave1_48 || slave1_49 || slave1_50 || slave1_52  || slave1_59 || slave1_63 ||  worker03 || slave215 || slave217 || slave219 || Mac_catalina "}
+                stage('build zh docs') {
+                    agent{label "doc_build_0_30"}
+                    when {
+                        expression { file_zh_changed != '' }
+                    }
                     steps {
-                        check_docs()
+                        build_zh_docs()
+                    }
+                }
+                stage('build en docs') {
+                    agent{label "doc_build_0_30"}
+                    when {
+                        expression { file_en_changed != '' }
+                    }
+                    steps {
+                        build_en_docs()
                     }
                 }
             }
+            post {
+                unsuccessful {
+                    error('build docs stage failed, terminating pipeline.')
+                }
+            }
         }
+
         stage('run test') {
             when {
                 allOf {
-                    not { expression { env.CHANGE_BRANCH =~ /docs\// }}
-                    expression { docs_only == 0 }
+                    not { expression { file_no_doc_changed == '' }}
                 }
             }
             parallel {
@@ -375,7 +462,6 @@ pipeline {
                         WIN_INTERNAL_ROOT="C:\\workspace\\${env.EXECUTOR_NUMBER}\\TDinternal"
                         WIN_COMMUNITY_ROOT="C:\\workspace\\${env.EXECUTOR_NUMBER}\\TDinternal\\community"
                         WIN_SYSTEM_TEST_ROOT="C:\\workspace\\${env.EXECUTOR_NUMBER}\\TDinternal\\community\\tests\\system-test"
-                        WIN_CONNECTOR_ROOT="C:\\workspace\\${env.EXECUTOR_NUMBER}\\taos-connector-python"
                     }
                     steps {
                         catchError(buildResult: 'FAILURE', stageResult: 'FAILURE') {
@@ -420,7 +506,7 @@ pipeline {
                                 script {
                                     sh '''
                                     mkdir -p ${WKDIR}/tmp/${BRANCH_NAME}_${BUILD_ID}
-                                    echo "''' + env.FILE_CHANGED + '''" > ${WKDIR}/tmp/${BRANCH_NAME}_${BUILD_ID}/docs_changed.txt
+                                    echo "''' + file_no_doc_changed + '''" > ${WKDIR}/tmp/${BRANCH_NAME}_${BUILD_ID}/docs_changed.txt
                                     '''
                                     sh '''
                                        cd ${WKC}/tests/parallel_test
@@ -570,4 +656,4 @@ pipeline {
             )
         }
     } 
-}
+}

cmake/cmake.version

@@ -2,7 +2,7 @@
 IF (DEFINED VERNUMBER)
   SET(TD_VER_NUMBER ${VERNUMBER})
 ELSE ()
-  SET(TD_VER_NUMBER "3.3.4.0.alpha")
+  SET(TD_VER_NUMBER "3.3.4.3.alpha")
 ENDIF ()
 
 IF (DEFINED VERCOMPATIBLE)

docs/en/14-reference/03-taos-sql/10-function.md

@@ -1149,7 +1149,7 @@ TOP(expr, k)
 UNIQUE(expr)
 ```
 
-**Description**: The values that occur the first time in the specified column. The effect is similar to `distinct` keyword. For a table with composite primary key, only the data with the smallest primary key value is returned.
+**Description**: Return the unique values of this column. The effect is similar to `distinct` keyword. Return the row with the earliest timestamp for duplicate data. For a table with composite primary key, only the data with the smallest primary key value is returned.
 
 **Return value type**:Same as the data type of the column being operated upon
 

docs/en/14-reference/03-taos-sql/31-compress.md

@@ -30,11 +30,12 @@ In this article, it specifically refers to the level within the secondary compre
 
 | Data Type |   Optional Encoding Algorithm      |  Default Encoding Algorithm  | Optional Compression Algorithm|Default Compression Algorithm| Default Compression Level|
 | :-----------:|:----------:|:-------:|:-------:|:----------:|:----:|
-|  tinyint/untinyint/smallint/usmallint/int/uint | simple8b| simple8b | lz4/zlib/zstd/xz| lz4 | medium|
+|  int/uint | simple8b| simple8b | lz4/zlib/zstd/xz| lz4 | medium|
+|  tinyint/untinyint/smallint/usmallint | simple8b| simple8b | lz4/zlib/zstd/xz| zlib| medium|
 |   bigint/ubigint/timestamp   |  simple8b/delta-i    | delta-i |lz4/zlib/zstd/xz | lz4| medium|
 |float/double | delta-d|delta-d |lz4/zlib/zstd/xz/tsz|lz4| medium|
-|binary/nchar| disabled| disabled|lz4/zlib/zstd/xz| lz4| medium|
-|bool| bit-packing| bit-packing| lz4/zlib/zstd/xz| lz4| medium|
+|binary/nchar| disabled| disabled|lz4/zlib/zstd/xz| lz4| zstd|
+|bool| bit-packing| bit-packing| lz4/zlib/zstd/xz| lz4| zstd|
 
 ## SQL
 

docs/en/28-releases/01-tdengine.md

@@ -20,6 +20,10 @@ For TDengine 2.x installation packages by version, please visit [here](https://t
 
 import Release from "/components/ReleaseV3";
 
+## 3.3.4.3
+
+<Release type="tdengine" version="3.3.4.3" />
+
 ## 3.3.3.0
 
 <Release type="tdengine" version="3.3.3.0" />

docs/examples/JDBC/SpringJdbcTemplate/pom.xml

@@ -22,19 +22,19 @@
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-context</artifactId>
-            <version>5.2.8.RELEASE</version>
+            <version>5.3.39</version>
         </dependency>
 
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-jdbc</artifactId>
-            <version>5.1.9.RELEASE</version>
+            <version>5.3.39</version>
         </dependency>
 
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-test</artifactId>
-            <version>5.1.9.RELEASE</version>
+            <version>5.3.39</version>
         </dependency>
 
         <dependency>
@@ -47,7 +47,7 @@
         <dependency>
             <groupId>com.taosdata.jdbc</groupId>
             <artifactId>taos-jdbcdriver</artifactId>
-            <version>3.0.0</version>
+            <version>3.4.0</version>
         </dependency>
 
     </dependencies>

docs/examples/JDBC/springbootdemo/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-parent</artifactId>
-        <version>2.2.1.RELEASE</version>
+        <version>2.6.15</version>
         <relativePath/> <!-- lookup parent from repository -->
     </parent>
     <groupId>com.taosdata.example</groupId>
@@ -65,6 +65,8 @@
             <artifactId>spring-boot-starter-aop</artifactId>
         </dependency>
 
+
+
         <dependency>
             <groupId>com.taosdata.jdbc</groupId>
             <artifactId>taos-jdbcdriver</artifactId>

docs/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/SpringbootdemoApplication.java

@@ -3,9 +3,10 @@ package com.taosdata.example.springbootdemo;
 import org.mybatis.spring.annotation.MapperScan;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.autoconfigure.data.jdbc.JdbcRepositoriesAutoConfiguration;
 
 @MapperScan(basePackages = {"com.taosdata.example.springbootdemo"})
-@SpringBootApplication
+@SpringBootApplication(exclude = {JdbcRepositoriesAutoConfiguration.class})
 public class SpringbootdemoApplication {
 
     public static void main(String[] args) {

docs/examples/JDBC/springbootdemo/src/main/resources/application.properties

@@ -15,6 +15,8 @@ spring.datasource.druid.max-wait=30000
 spring.datasource.druid.validation-query=select SERVER_VERSION();
 spring.aop.auto=true
 spring.aop.proxy-target-class=true
+
+spring.jooq.sql-dialect=
 #mybatis
 mybatis.mapper-locations=classpath:mapper/*.xml
 logging.level.com.taosdata.jdbc.springbootdemo.dao=debug

docs/examples/JDBC/taosdemo/pom.xml

@@ -10,7 +10,7 @@
     <description>Demo project for TDengine</description>
 
     <properties>
-        <spring.version>5.3.27</spring.version>
+        <spring.version>5.3.39</spring.version>
     </properties>
 
     <dependencies>
@@ -130,6 +130,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.13.0</version>
                 <configuration>
                     <source>8</source>
                     <target>8</target>

docs/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/QueryService.java

@@ -37,7 +37,7 @@ public class QueryService {
             stmt.execute("use " + dbName);
             ResultSet rs = stmt.executeQuery("show stables");
             while (rs.next()) {
-                String name = rs.getString("name");
+                String name = rs.getString("stable_name");
                 sqls.add("select count(*) from " + dbName + "." + name);
                 sqls.add("select first(*) from " + dbName + "." + name);
                 sqls.add("select last(*) from " + dbName + "." + name);

docs/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/DatabaseServiceTest.java

@@ -1,10 +1,14 @@
 package com.taosdata.taosdemo.service;
 
+import com.zaxxer.hikari.HikariConfig;
+import com.zaxxer.hikari.HikariDataSource;
+import org.junit.BeforeClass;
 import org.junit.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 
 public class DatabaseServiceTest {
-    private DatabaseService service;
+
+    private static DatabaseService service;
 
     @Test
     public void testCreateDatabase1() {
@@ -20,4 +24,16 @@ public class DatabaseServiceTest {
     public void useDatabase() {
         service.useDatabase("test");
     }
+
+    @BeforeClass
+    public static void beforeClass() throws ClassNotFoundException {
+        Class.forName("com.taosdata.jdbc.TSDBDriver");
+        HikariConfig config = new HikariConfig();
+        config.setJdbcUrl("jdbc:TAOS://127.0.0.1:6030/?charset=UTF-8&locale=en_US.UTF-8&timezone=UTC-8");
+        config.setUsername("root");
+        config.setPassword("taosdata");
+        HikariDataSource dataSource = new HikariDataSource(config);
+        service = new DatabaseService(dataSource);
+    }
+
 }

docs/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/QueryServiceTest.java

@@ -15,7 +15,7 @@ public class QueryServiceTest {
 
     @Test
     public void generateSuperTableQueries() {
-        String[] sqls = queryService.generateSuperTableQueries("restful_test");
+        String[] sqls = queryService.generateSuperTableQueries("test");
         for (String sql : sqls) {
             System.out.println(sql);
         }
@@ -23,8 +23,8 @@ public class QueryServiceTest {
 
     @Test
     public void querySuperTable() {
-        String[] sqls = queryService.generateSuperTableQueries("restful_test");
-        queryService.querySuperTable(sqls, 1000, 10, 10);
+        String[] sqls = queryService.generateSuperTableQueries("test");
+        queryService.querySuperTable(sqls, 100, 3, 3);
     }
 
     @BeforeClass

docs/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/SuperTableServiceTest.java

@@ -3,6 +3,9 @@ package com.taosdata.taosdemo.service;
 import com.taosdata.taosdemo.domain.FieldMeta;
 import com.taosdata.taosdemo.domain.SuperTableMeta;
 import com.taosdata.taosdemo.domain.TagMeta;
+import com.zaxxer.hikari.HikariConfig;
+import com.zaxxer.hikari.HikariDataSource;
+import org.junit.BeforeClass;
 import org.junit.Test;
 
 import java.util.ArrayList;
@@ -10,7 +13,7 @@ import java.util.List;
 
 public class SuperTableServiceTest {
 
-    private SuperTableService service;
+    private static SuperTableService service;
 
     @Test
     public void testCreate() {
@@ -29,4 +32,15 @@ public class SuperTableServiceTest {
         service.create(superTableMeta);
     }
 
+    @BeforeClass
+    public static void beforeClass() throws ClassNotFoundException {
+        Class.forName("com.taosdata.jdbc.TSDBDriver");
+        HikariConfig config = new HikariConfig();
+        config.setJdbcUrl("jdbc:TAOS://127.0.0.1:6030/?charset=UTF-8&locale=en_US.UTF-8&timezone=UTC-8");
+        config.setUsername("root");
+        config.setPassword("taosdata");
+        HikariDataSource dataSource = new HikariDataSource(config);
+        service = new SuperTableService(dataSource);
+    }
+
 }

docs/examples/java/src/main/java/com/taos/example/DruidDemo.java

@@ -1,4 +1,4 @@
-package com.taosdata.example;
+package com.taos.example;
 
 import com.alibaba.druid.pool.DruidDataSource;
 
@@ -8,11 +8,11 @@ import java.sql.Statement;
 public class DruidDemo {
     // ANCHOR: connection_pool
     public static void main(String[] args) throws Exception {
-        String url = "jdbc:TAOS://127.0.0.1:6030/log";
+        String url = "jdbc:TAOS-WS://127.0.0.1:6041/log";
 
         DruidDataSource dataSource = new DruidDataSource();
         // jdbc properties
-        dataSource.setDriverClassName("com.taosdata.jdbc.TSDBDriver");
+        dataSource.setDriverClassName("com.taosdata.jdbc.ws.WebSocketDriver");
         dataSource.setUrl(url);
         dataSource.setUsername("root");
         dataSource.setPassword("taosdata");

docs/examples/java/src/main/java/com/taos/example/GeometryDemo.java

@@ -144,8 +144,9 @@ public class GeometryDemo {
 
     private void executeQuery(String sql) {
         long start = System.currentTimeMillis();
-        try (Statement statement = connection.createStatement()) {
-            ResultSet resultSet = statement.executeQuery(sql);
+        try (Statement statement = connection.createStatement();
+             ResultSet resultSet = statement.executeQuery(sql)) {
+
             long end = System.currentTimeMillis();
             printSql(sql, true, (end - start));
 

docs/examples/java/src/main/java/com/taos/example/HikariDemo.java

@@ -1,4 +1,4 @@
-package com.taosdata.example;
+package com.taos.example;
 
 import com.zaxxer.hikari.HikariConfig;
 import com.zaxxer.hikari.HikariDataSource;
@@ -11,7 +11,7 @@ public class HikariDemo {
     public static void main(String[] args) throws Exception {
         HikariConfig config = new HikariConfig();
         // jdbc properties
-        config.setJdbcUrl("jdbc:TAOS://127.0.0.1:6030/log");
+        config.setJdbcUrl("jdbc:TAOS-WS://127.0.0.1:6041/log");
         config.setUsername("root");
         config.setPassword("taosdata");
         // connection pool configurations

docs/examples/java/src/main/java/com/taos/example/TelnetLineProtocolExample.java

@@ -39,6 +39,7 @@ public class TelnetLineProtocolExample {
             createDatabase(conn);
             SchemalessWriter writer = new SchemalessWriter(conn);
             writer.write(lines, SchemalessProtocolType.TELNET, SchemalessTimestampType.NOT_CONFIGURED);
+            writer.close();
         }
     }
 

docs/zh/06-advanced/05-data-in/05-opcua.md

@@ -150,7 +150,7 @@ CSV 文件中的每个 Row 配置一个 OPC 数据点位。Row 的规则如下
 
 #### 5.2. 选择数据点位
 
-可以通过配置 **根节点ID**、**命名空间**、**正则匹配** 等条件，对点位进行筛选。
+可以通过配置 **根节点ID**、**命名空间**、**节点ID**、**节点名称** 等条件，对点位进行筛选。
 
 通过配置 **超级表名**、**表名称**，指定数据要写入的超级表、子表。
 

docs/zh/06-advanced/05-data-in/06-opcda.md

@@ -126,7 +126,7 @@ CSV 文件中的每个 Row 配置一个 OPC 数据点位。Row 的规则如下
 
 #### 4.2. 选择数据点位
 
-可以通过配置 **根节点ID** 和 **正则匹配** 作为过滤条件，对点位进行筛选。
+可以通过配置 **根节点ID**、**节点ID**、**节点名称** 作为过滤条件，对点位进行筛选。
 
 通过配置 **超级表名**、**表名称**，指定数据要写入的超级表、子表。
 

docs/zh/06-advanced/05-data-in/07-mqtt.md

@@ -63,7 +63,7 @@ TDengine 可以通过 MQTT 连接器从 MQTT 代理订阅数据并将其写入 T
 
 在 **Clean Session** 中，选择是否清除会话。默认值为 true。
 
-在 **订阅主题及 QoS 配置** 中填写要消费的 Topic 名称。使用如下格式设置： `topic1::0,topic2::1`。
+在 **订阅主题及 QoS 配置** 中填写要消费的 Topic 名称和 QoS。使用如下格式设置： `{topic_name}::{qos}`（如：`my_topic::0`）。MQTT 协议 5.0 支持共享订阅，可以通过多个客户端订阅同一个 Topic 实现负载均衡，使用如下格式： `$share/{group_name}/{topic_name}::{qos}`，其中，`$share` 是固定前缀，表示启用共享订阅，`group_name` 是分组名称，类似 kafka 的消费者组。
 
 点击 **检查连通性** 按钮，检查数据源是否可用。
 
@@ -146,7 +146,13 @@ json 数据支持 JSONObject 或者 JSONArray，使用 json 解析器可以解
 
 ### 7. 高级选项
 
-在 **日志级别** 下拉列表中选择日志级别。有五个选项：`TRACE`、`DEBUG`、`INFO`、`WARN`、`ERROR`。 默认值为 INFO。
+在 **消息等待队列大小** 中填写接收 MQTT 消息的缓存队列大小，当队列满时，新到达的数据会直接丢弃。可设置为 0，即不缓存。
+
+在 **处理批次上限** 中填写可以同时进行数据处理流程的批次数量，当到达此上限后，不再从消息缓存队列中获取消息，会导致缓存队列的消息积压，最小值为 1。
+
+在 **批次大小** 中填写每次发送给数据处理流程的消息数量，和 **批次延时** 配合使用，当读取的 MQTT 消息数量达到批次大小时，就算 **批次延时** 没有到达也立即向数据处理流程发送数据，最小值为 1。
+
+在 **批次延时** 中填写每次生成批次消息的超时时间（单位：毫秒），从每批次接收到的第一个消息开始算起，和 **批次大小** 配合使用，当读取消息到达超时时间时，就算 **批次大小** 不满足数量也立即向数据处理流程发送数据，最小值为 1。
 
 当 **保存原始数据时**，以下2个参数配置生效。
 

docs/zh/06-advanced/05-data-in/11-csv.md

@@ -2,86 +2,123 @@
 title: "CSV"
 sidebar_label: "CSV"
 ---
-本节讲述如何通过 Explorer 界面创建数据迁移任务, 从 CSV 迁移数据到当前 TDengine 集群。
+本节讲述如何通过 Explorer 界面创建数据迁移任务，从 CSV 迁移数据到当前 TDengine 集群。
 
 ## 功能概述
 导入一个或多个 CSV 文件数据到 TDengine。
 
 ## 创建任务
 ### 1. 新增数据源
-在数据写入页面中，点击 **+新增数据源** 按钮，进入新增数据源页面。
+在数据写入任务列表页面中，点击 **+新建任务** 按钮，进入新建任务页面。
 
 ![csv-01.png](./csv-01.png)
 
 ### 2. 配置基本信息
-在 **名称** 中输入任务名称，如：“test_csv”；
+在 **名称** 中输入任务名称，如：“test_csv”。
 
 在 **类型** 下拉列表中选择 **CSV**。
 
-在 **目标数据库** 下拉列表中选择一个目标数据库，也可以先点击右侧的 **+创建数据库** 按钮
+在 **目标数据库** 下拉列表中选择一个目标数据库，也可以先点击右侧的 **+创建数据库** 按钮。
 
 ![csv-02.png](./csv-02.png)
 
 ### 3. 配置 CSV 选项
-在 **包含表头** 区域点击开启或关闭，如果包含表头，则第一行将被视为列信息。
+在 **包含表头** 区域点击开启或关闭，如果包含表头，则 CSV 文件内容第一行将被视为列信息。
 
-在 **忽略前 N 行** 区域填写 N，表示忽略 CSV 文件的前 N 行。
+在 **忽略前 N 行** 区域填写数字 N，表示忽略 CSV 文件的前 N 行。
 
-在 **字段分隔符** 区域进行选择，CSV 字段之间的分隔符，默认是 “,” 。
+在 **字段分隔符** 区域选择 CSV 字段分隔符，用于分隔行内容为多个字段，默认是 `,`。
 
-在 **字段引用符** 区域进行选择,当 CSV 字段中包含分隔符或换行符时，用于包围字段内容，以确保整个字段被正确识别,默认是 "“"。
+在 **字段引用符** 区域选择 CSV 字段引用符，当 CSV 字段中包含分隔符或换行符时，用于包围字段内容，以确保整个字段被正确识别，默认是 `"`。
 
-在 **注释前缀符** 区域进行选择,当 CSV 文件中某行以此处指定的字符开头，则忽略该行默认是 “#”。
+在 **注释前缀符** 区域选择 CSV 行注释前缀符，当 CSV 文件中某行以此处指定的字符开头，则忽略该行，默认是 `#`。
 
 ![csv-03.png](./csv-03.png)
 
 ### 4. 配置解析 CSV 文件
-在本地上传 CSV 文件，例如：test-json.csv，之后会使用这条示例 csv 文件来配置提取和过滤条件。
 
-#### 4.1 解析
+#### 4.1 配置数据源
 
-点击 **选取文件** 后，选择 test-json.csv，点击 **解析** 预览识别的列。
+包含“上传 CSV 文件”与“监听文件目录”两种方式，“上传 CSV 文件”是指将本地文件通过浏览器上传到 taosx 所在服务器作为数据源，“监听文件目录”是指配置一个 taosx 所在服务器的绝对路径作为数据源，以下将分别进行介绍：
+
+##### 4.1.1 上传 CSV 文件
+
+在“上传 CSV 文件”标签页中：
+
+点击 **选取文件** 按钮，选取一个或多个本地文件，上传到服务器作为数据源。
+
+在 **保留已处理文件** 区域点击开启或关闭，如果开启，则文件被处理完成后仍会保留在服务器中，如果关闭，则将被删除。
 
 ![csv-04.png](./csv-04.png)
 
-**预览解析结果**
+##### 4.1.2 监听文件目录
+
+在“监听文件目录”标签页中：
+
+在 **文件监听目录** 中输入一个 taosx 所在服务器的绝对路径，路径中包含的文件及子目录文件将作为数据源。
+
+在 **匹配模式** 中输入一个正则表达式，用于筛选过滤目录中的文件。
+
+在 **监听新文件** 区域点击开启或关闭，如果开启，则任务永不停止，且持续处理目录中新增的文件，如果关闭，则不处理新增文件，且初始文件处理结束后任务变为完成状态。
+
+在 **监听间隔** 中输入一个数字，用于配置监听新文件的时间间隔。
+
+在 **文件处理顺序** 区域选择“正序”或“倒序”，用于指定文件列表的处理先后顺序，“正序”将按照文件名的字典序正序处理，“倒序”将按照文件名的字典序倒序处理，与此同时，程序总是保持先处理文件后处理同级子目录的顺序。
 
 ![csv-05.png](./csv-05.png)
 
-#### 4.2 字段拆分
+#### 4.2 解析
 
-在 **从列中提取或拆分** 中填写从消息体中提取或拆分的字段，例如：将 message 字段拆分成 `text_0` 和 `text_1` 这2个字段，选择 split 提取器，seperator 填写 -, number 填写2。
-点击 **删除**，可以删除当前提取规则。
-点击 **新增**，可以添加更多提取规则。
+上传文件或配置监听目录后，点击解析按钮，页面将获取文件中的示例数据，同时得到识别的列与示例数据解析结果：
 
-![csv-06.png](./csv-06.png)
+![csv-05.png](./csv-06.png)
 
-点击 **放大镜图标** 可预览提取或拆分结果。
+#### 4.2 从列中提取或拆分
+
+在 **从列中提取或拆分** 中填写从消息体中提取或拆分规则，例如：将 `desc` 字段拆分为 `desc_0` 与 `desc_1` 两个字段，可以选择 split 规则，separator 填写 `,`，number 填写 2 即可。
+
+点击 **删除** 可以删除当前提取规则。
+
+点击 **预览** 可以预览提取或拆分结果。
+
+点击 **新增提取/拆分** 可以添加更多提取规则。
 
 ![csv-07.png](./csv-07.png)
 
-<!-- 在 **过滤** 中，填写过滤条件，例如：填写 `id != 1`，则只有 id 不为 1 的数据才会被写入 TDengine。
-点击 **删除**，可以删除当前过滤规则。
+#### 4.3 过滤
+
+在 **过滤** 中填写过滤条件，例如：填写 `id != "1"`，则只有 id 不为 1 的数据才会被处理。
+
+点击 **删除** 可以删除当前过滤规则。
+
+点击 **预览** 可以预览过滤结果。
+
+点击 **新增过滤** 可以添加更多过滤规则。
 
 ![csv-08.png](./csv-08.png)
 
-点击 **放大镜图标** 可查看预览过滤结果。
-
-![csv-09.png](./csv-09.png) -->
-
-#### 4.3 表映射
+#### 4.4 映射
 
 在 **目标超级表** 的下拉列表中选择一个目标超级表，也可以先点击右侧的 **创建超级表** 按钮
 
-在 **映射** 中，填写目标超级表中的子表名称，例如：`t_${groupid}`。
+在映射规则中，填写目标超级表中的子表名称，例如：`csv_meter_${id}`，同时配置映射到超级表的列。
 
-![csv-10.png](./csv-10.png)
-
-点击 **预览**，可以预览映射的结果。
-
-![csv-11.png](./csv-11.png)
+点击 **预览** 可以预览映射的结果。
 
+![csv-09.png](./csv-09.png)
 
 ### 5. 创建完成
 
-点击 **提交** 按钮，完成创建 CSV 到 TDengine 的数据同步任务，回到**数据源列表**页面可查看任务执行情况。
+点击 **提交** 按钮，完成创建 CSV 到 TDengine 的数据同步任务，回到数据写入任务列表页面，可查看任务执行情况，也可以进行任务的“启动/停止”操作与“查看/编辑/删除/复制”操作。
+
+![csv-10.png](./csv-10.png)
+
+### 6. 查看运行指标
+
+点击 **查看** 按钮，查看任务的运行指标，同时也可以查看任务中所有文件的处理情况。
+
+![csv-11.png](./csv-11.png)
+
+![csv-12.png](./csv-12.png)
+
+![csv-13.png](./csv-13.png)

docs/zh/06-advanced/06-TDgpt/02-management.md

@@ -4,7 +4,7 @@ sidebar_label: "安装部署"
 ---
 
 ### 环境准备
-使用 TDgpt 的高级时序数据分析功能需要在 TDengine 集群中安装部署 AI node（Anode）。Anode 可以运行在 Linux/Windows/MacOS 等平台上，同时需要 3.10 或以上版本的 Python 环境支持。
+使用 TDgpt 的高级时序数据分析功能需要在 TDengine 集群中安装部署 AI node（Anode）。Anode 可以运行在 Linux/Windows/MacOS 等平台上，同时需要 Python 3.10 或以上版本的环境支持。
 
 ### 安装及卸载
 不同操作系统上安装及部署 Anode 有一些差异，主要是卸载操作、安装路径、服务启停等方面。本文以 Linux 系统为例，说明安装部署的流程。
@@ -48,7 +48,7 @@ Anode 的服务需要使用 uWSGI 驱动驱动运行，因此 Anode 和 uWSGI
 ```ini
 [uwsgi]
 
-# Anode HTTP service ip:port
+# Anode RESTful service ip:port
 http = 127.0.0.1:6050
 
 # base directory for Anode python files， do NOT modified this
@@ -95,6 +95,7 @@ Anode 运行配置主要是以下：
 
 
 ### Anode 基本操作
+对于 Anode 的管理，用户需要通过 TDengine 的命令行接口 taos 进行。因此下述介绍的管理命令都需要先打开 taos, 链接到 TDengine 运行实例。 
 #### 创建 Anode
 ```sql 
 CREATE ANODE {node_url}

docs/zh/06-advanced/06-TDgpt/03-preprocess.md

@@ -7,11 +7,11 @@ import activity from './pic/activity.png';
 import wndata from './pic/white-noise-data.png'
 
 ### 分析流程
-时序数据分析之前需要有预处理的过程，整体的流程如下图所示。
+时序数据分析之前需要有预处理的过程，为减轻分析算法的负担，TDgpt 在将时序数据发给具体分析算法进行分析时，已经对数据做了预处理，整体的流程如下图所示。
 
 <img src={activity} width="560" alt="预处理流程" />
 
-首先对输入数据进行白噪声检查（White Noise Data check）, 检查通过以后针对预测分析，还需要进行输入（历史）数据的重采样和时间戳对齐处理操作，如果是异常检测则跳过数据重采样和时间戳对齐的预处理。
+TDgpt 首先对输入数据进行白噪声检查（White Noise Data check）, 检查通过以后针对预测分析，还需要进行输入（历史）数据的重采样和时间戳对齐处理操作，如果是异常检测则跳过数据重采样和时间戳对齐的预处理。
 预处理完成以后，在进行后续的预测或异常检测操作。
 
 ### 白噪声检查

docs/zh/06-advanced/06-TDgpt/04-forecast/index.md

@@ -3,7 +3,7 @@ title: 预测算法
 description: 预测算法
 ---
 
-时序数据预测处理以持续一个时间段的时序数据作为输入，预测接下来一个连续时间区间内时间序列数据趋势。用户可以指定输出的（预测）时间序列数据点的数量，因此其输出的结果行数不确定。为此，TDengine 使用新函数 `FORECAST` 提供时序数据预测服务。基础数据（用于预测的历史时间序列数据）是该函数的输入，预测结果是该函数的输出。用户可以通过 `FORECAST` 函数调用 Anode 提供的预测算法提供的服务。
+时序数据预测处理以持续一个时间段的时序数据作为输入，预测接下来一个连续时间区间内时间序列数据趋势。用户可以指定输出的（预测）时间序列数据点的数量，因此其输出的结果行数不确定。为此，TDengine 使用新 SQL 函数 `FORECAST` 提供时序数据预测服务。基础数据（用于预测的历史时间序列数据）是该函数的输入，预测结果是该函数的输出。用户可以通过 `FORECAST` 函数调用 Anode 提供的预测算法提供的服务。
 
 ### 语法
 ```SQL

docs/zh/06-advanced/06-TDgpt/06-dev/02-forecast.md

@@ -77,14 +77,8 @@ class _MyForecastService(AbstractForecastService):
 	"""该算法无需任何输入参数，直接重载父类该函数，不处理算法参数设置逻辑"""
         pass
 ```
-将该文件保存在 `./taosanalytics/algo/ad/` 目录下，然后重启 taosanode 服务。然后就可以通过 SQL 语句调用该检测算法。
 
-```SQL
---- 对 col 列进行异常检测，通过指定 algo 参数为 myad 来调用新添加的异常检测类
-SELECT COUNT(*) FROM foo ANOMALY_DETECTION(col, 'algo=myad')
-```
-
-将该文件保存在 `./taosanalytics/algo/fc/` 目录下，然后重启 taosanode 服务。通过执行 `SHOW ANODES FULL` 能够看到新加入的算法，通过 SQL 语句调用该预测算法。
+将该文件保存在 `./taosanalytics/algo/fc/` 目录下，然后重启 taosanode 服务。在 TDengine 命令行接口中执行 `SHOW ANODES FULL` 能够看到新加入的算法。应用就可以通过 SQL 语句调用该预测算法。
 
 ```SQL
 --- 对 col 列进行异常检测，通过指定 algo 参数为 myfc 来调用新添加的预测类
@@ -92,6 +86,7 @@ SELECT  _flow, _fhigh, _frowts, FORECAST(col_name, "algo=myfc")
 FROM foo;
 ```
 
+如果是第一次启动该 Anode, 请按照 [TDgpt 安装部署](../../management/) 里的步骤先将该 Anode 添加到 TDengine 系统中。
 
 ### 单元测试
 

docs/zh/06-advanced/06-TDgpt/06-dev/03-ad.md

@@ -48,13 +48,13 @@ class _MyAnomalyDetectionService(AbstractAnomalyDetectionService):
         pass
 ```
 
-将该文件保存在 `./taosanalytics/algo/ad/` 目录下，然后重启 taosanode 服务。然后就可以通过 SQL 语句调用该检测算法。
+将该文件保存在 `./taosanalytics/algo/ad/` 目录下，然后重启 taosanode 服务。在 TDengine 命令行接口 taos 中执行 `SHOW ANODES FULL` 就能够看到新加入的算法，然后应用就可以通过 SQL 语句调用该检测算法。
 
 ```SQL
 --- 对 col 列进行异常检测，通过指定 algo 参数为 myad 来调用新添加的异常检测类
 SELECT COUNT(*) FROM foo ANOMALY_DETECTION(col, 'algo=myad')
 ```
-
+如果是第一次启动该 Anode, 请按照 [TDgpt 安装部署](../../management/) 里的步骤先将该 Anode 添加到 TDengine 系统中。
 
 ### 单元测试
 

docs/zh/06-advanced/06-TDgpt/06-dev/index.md

@@ -2,13 +2,13 @@
 title: "算法开发者指南"
 sidebar_label: "算法开发者指南"
 ---
-TDgpt 是一个可扩展的时序数据高级分析平台，用户遵循简易的步骤就能将自己开发的分析算法添加到分析平台并通过SQL语句直接调用。目前 TDpgt 平台只支持使用 Python 语言开发的分析算法。
+TDgpt 是一个可扩展的时序数据高级分析平台，用户遵循简易的步骤就能将自己开发的分析算法添加到分析平台, 各种应用就可以通过SQL语句直接调用, 让高级分析算法的使用门槛降到几乎为零。目前 TDpgt 平台只支持使用 Python 语言开发的分析算法。
 Anode 采用类动态加载模式，在启动的时候扫描特定目录内满足约定条件的所有代码文件，并将其加载到系统中。因此，开发者只需要遵循以下几步就能完成新算法的添加工作：
 1. 开发完成符合要求的分析算法类
 2. 将代码文件放入对应目录，然后重启 Anode
-3. 使用SQL命令，向 Mnode 同步新的算法列表
+3. 使用SQL命令"CREATE ANODE"，将 Anode 添加到 TDengine
    
-此时就完成了新算法的添加工作，之后就可以直接使用SQL语句调用新算法。得益于 TDgpt 与 TDengine主进程 `taosd` 的松散耦合，Anode算法升级对 `taosd` 完全没有影响。应用系统只需要调整对应的SQL语句调用新（升级的）算法，就能够快速完成分析功能和分析算法的升级。
+此时就完成了新算法的添加工作，之后应用就可以直接使用SQL语句调用新算法。得益于 TDgpt 与 TDengine主进程 `taosd` 的松散耦合，Anode算法升级对 `taosd` 完全没有影响。应用系统只需要调整对应的SQL语句调用新（升级的）算法，就能够快速完成分析功能和分析算法的升级。
 
 这种方式能够按需扩展分析算法，极大地拓展 TDgpt 的适应范围，用户可以按需将更契合业务场景的、更准确的（预测、异常检测）分析算法动态嵌入到 TDgpt，并通过 SQL 语句进行调用。在基本不用更改应用系统代码的前提下，就能够快速完成分析功能的平滑升级。
 

docs/zh/06-advanced/06-TDgpt/index.md

@@ -15,6 +15,7 @@ TDgpt 运行在集群中的 AI Node (Anode)中，集群中可以部署若干个
 
 在查询处理过程中，Vnode中运行的查询引擎会根据查询处理物理执行计划，按需向 Anode 请求高级时序数据分析服务。因此用户可通过 SQL 语句与 Anode 节点交互并使用其提供的全部分析服务。需要注意的是 Anode 不直接接受用户的数据分析请求。同时 Anode 具备分析算法动态注册机制，其算法扩展过程完全不影响 TDengine 集群的服务，仅在非常小的（秒级）时间窗口内影响涉及高级分析的查询服务。
 
+目前 TDgpt 提供如下的高级分析服务：
 - 时序数据异常检测。TDengine 中定义了新的时间窗口——异常（状态）窗口——来提供异常检测服务。异常窗口可以视为一种特殊的**事件窗口（Event Window）**，即异常检测算法确定的连续异常时间序列数据所在的时间窗口。与普通事件窗口区别在于——时间窗口的起始时间和结束时间均是分析算法确定，不是用户指定的表达式判定。异常窗口使用方式与其他类型的时间窗口（例如状态窗口、会话窗口等）类似。因此时间窗口内可使用的查询操作均可应用在异常窗口上。
 - 时序数据预测。定义了一个新函数`FORECAST`，基于输入的（历史）时间序列数据调用指定（或默认）预测算法给出输入时序数据后续时间序列的**预测**数据。
 

docs/zh/07-develop/07-tmq.md

@@ -16,7 +16,7 @@ TDengine 提供了类似于消息队列产品的数据订阅和消费接口。
 
 **注意**
 在 TDengine 连接器实现中，对于订阅查询，有以下限制。
-- 查询语句限制：订阅查询只能使用 select 语句，不支持其他类型的SQL，如 insert、update 或 delete 等。
+- 查询语句限制：订阅查询只能使用 select 语句，并不支持其他类型的SQL，如订阅库，订阅超级表（非 select 方式），insert、update 或 delete 等。
 - 原始始数据查询：订阅查询只能查询原始数据，而不能查询聚合或计算结果。
 - 时间顺序限制：订阅查询只能按照时间正序查询数据。
 

docs/zh/08-operation/06-gui.md

@@ -165,6 +165,10 @@ toc_max_heading_level: 4
 第一步 填写添加新主题需要的信息，点击“创建”按钮；
 ![topic-03-addTopicWizard.jpeg](./pic/topic-03-addTopicWizard.jpeg "添加新主题 Wizard 页面")
 
+如上图，您可以选择是否 “同步 meta”。如果同步 meta 信息，则可以订阅到 meta 信息，比如增加或者删除超级表。
+
+您需要根据使用场景来选择是否开启，如果您引用 taos 连接器编写业务代码订阅 topic，则不能开启“同步 meta”，只能订阅数据；如果您创建 topic 在 explorer 配置同步任务使用，则可以开启“同步 meta”。
+
 第二步 页面出现以下记录，则证明创建成功。
 ![topic-05-addTopicSucc1.jpeg](./pic/topic-05-addTopicSucc1.jpeg "查看已创建的流计算")
 

docs/zh/08-operation/16-security.md

@@ -26,6 +26,22 @@ SHOW USERS;
 ```sql
 ALTER USER TEST DROP HOST HOST_NAME1
 ```
+说明 
+- 开源版和企业版本都能添加成功，且可以查询到，但是开源版本不会对 IP 做任何限制。
+- create user u_write pass 'taosdata1' host 'iprange1','iprange2', 可以一次添加多个 iprange,  服务端会做去重，去重的逻辑是需要 iprange 完全一样
+- 默认会把 127.0.0.1 添加到白名单列表，且在白名单列表可以查询
+- 集群的节点 IP 集合会自动添加到白名单列表，但是查询不到。 
+- taosadaper 和 taosd 不在一个机器的时候，需要把 taosadaper IP 手动添加到 taosd 白名单列表中
+- 集群情况下，各个节点 enableWhiteList 成一样，或者全为 false,或者全为 true, 要不然集群无法启动
+- 白名单变更生效时间 1s，不超过 2s, 每次变更对收发性能有些微影响（多一次判断，可以忽略），变更完之后、影响忽略不计, 变更过程中对集群没有影响，对正在访问客户端也没有影响（假设这些客户端的 IP 包含在 white list 内）
+- 如果添加两个 ip range,  192.168.1.1/16(假设为 A), 192.168.1.1/24(假设为 B), 严格来说，A 包含了 B，但是考虑情况太复杂，并不会对 A 和 B 做合并
+- 要删除的时候，必须严格匹配。 也就是如果添加的是 192.168.1.1/24, 要删除也是 192.168.1.1/24 
+- 只有 root 才有权限对其他用户增删 ip white list
+- 兼容之前的版本，但是不支持从当前版本回退到之前版本
+- x.x.x.x/32 和 x.x.x.x 属于同一个 iprange, 显示为 x.x.x.x
+- 如果客户端拿到的 0.0.0.0/0, 说明没有开启白名单
+- 如果白名单发生了改变， 客户端会在 heartbeat 里检测到。
+- 针对一个 user, 添加的 IP 个数上限是 2048
 
 ## 审计日志
 

docs/zh/08-operation/19-debug.md

@@ -0,0 +1,14 @@
+---
+sidebar_label: 分析调试
+title: 分析调试
+toc_max_heading_level: 4
+---
+为了更好的分析调试 TDengine ，推荐开发者在操作系统中安装以下分析调试工具：
+## gdb
+GDB（GNU Debugger）是一个功能强大的命令行调试器，广泛用于调试 C、C++ 和其他编程语言的程序。
+## valgrind 
+valgrind 是一个用于内存调试、内存泄漏检测和性能分析的工具框架。Valgrind 提供了一组工具，帮助开发者检测和修复程序中的内存错误、线程错误和性能问题。
+## bpftrace  
+bpftrace 是一个高级的动态跟踪工具，基于 eBPF（Extended Berkeley Packet Filter）技术，用于在 Linux 系统上进行性能分析和故障排除。
+## perf
+perf 是一个强大的 Linux 性能分析工具。它提供了对系统和应用程序的详细性能分析，帮助开发者和系统管理员识别和解决性能瓶颈。

docs/zh/14-reference/01-components/01-taosd.md

@@ -26,42 +26,66 @@ taosd 命令行参数如下
 :::
 
 ### 连接相关
-
-|        参数名称        |                                        参数说明                                         |
-| :--------------------: | :-------------------------------------------------------------------------------------: |
-|        firstEp         |      taosd 启动时，主动连接的集群中首个 dnode 的 end point，缺省值：localhost:6030      |
-|        secondEp        | taosd 启动时，如果 firstEp 连接不上，尝试连接集群中第二个 dnode 的 endpoint，缺省值：无 |
-|          fqdn          |        启动 taosd 后所监听的服务地址，缺省值：所在服务器上配置的第一个 hostname         |
-|       serverPort       |                         启动 taosd 后所监听的端口，缺省值：6030                         |
-|    numOfRpcSessions    |          允许一个 dnode 能发起的最大连接数，取值范围 100-100000，缺省值：30000           |
-| timeToGetAvailableConn |      获得可用连接的最长等待时间，取值范围 10-50000000，单位为毫秒，缺省值：500000       |
+|参数名称|支持版本|参数含义|
+|-----------------------|----------|-|
+|firstEp                |          |taosd 启动时，主动连接的集群中首个 dnode 的 end point，默认值 localhost:6030|
+|secondEp               |          |taosd 启动时，如果 firstEp 连接不上，尝试连接集群中第二个 dnode 的 endpoint，无默认值|
+|fqdn                   |          |taosd 监听的服务地址，默认为所在服务器上配置的第一个 hostname|
+|serverPort             |          |taosd 监听的端口，默认值 6030|
+|compressMsgSize        |          |是否对 RPC 消息进行压缩；-1：所有消息都不压缩；0：所有消息都压缩；N (N>0)：只有大于 N 个字节的消息才压缩；默认值 -1|
+|shellActivityTimer     |          |客户端向 mnode 发送心跳的时长，单位为秒，取值范围 1-120，默认值 3|
+|numOfRpcSessions       |          |RPC 支持的最大连接数，取值范围 100-100000，默认值 30000|
+|numOfRpcThreads        |          |RPC 线程数目，默认值为 CPU 核数的一半|
+|numOfTaskQueueThreads  |          |dnode 处理 RPC 消息的线程数|
+|statusInterval         |          |dnode 与 mnode 之间的心跳间隔|
+|rpcQueueMemoryAllowed  |          |dnode 允许的 rpc 消息占用的内存最大值，单位 bytes，取值范围 104857600-INT64_MAX，默认值 服务器内存的 1/10 |
+|resolveFQDNRetryTime   |          |FQDN 解析失败时的重试次数|
+|timeToGetAvailableConn |          |获得可用连接的最长等待时间，取值范围 10-50000000，单位为毫秒，默认值 500000|
+|maxShellConns          |          |允许创建的最大链接数|
+|maxRetryWaitTime       |          |重连最大超时时间|
+|shareConnLimit         |3.3.4.3 后|内部参数，一个链接可以共享的查询数目，取值范围 1-256，默认值 10|
+|readTimeout            |3.3.4.3 后|内部参数，最小超时时间，取值范围 64-604800，单位为秒，默认值 900|
 
 ### 监控相关
-|      参数名称      |                                        参数说明                                        |
-| :----------------: | :------------------------------------------------------------------------------------: |
-|      monitor       |                   是否收集监控数据并上报，0: 关闭；1:打开；缺省值：0                   |
-|    monitorFqdn     |                      taosKeeper 服务所在服务器的 FQDN，缺省值：无                      |
-|    monitorPort     |                      taosKeeper 服务所监听的端口号，缺省值：6043                       |
-|  monitorInternal   | 监控数据库记录系统参数（CPU/内存）的时间间隔，单位是秒，取值范围 1-200000 ，缺省值：30 |
-| telemetryReporting |                   是否上传 telemetry，0: 不上传，1：上传，缺省值：1                    |
-|   crashReporting   |                  是否上传 crash 信息；0: 不上传，1: 上传；缺省值： 1                   |
+|参数名称|支持版本|参数含义|
+|-----------------------|----------|-|
+|monitor                |          |是否收集监控数据并上报，0：关闭；1:打开；默认值 0|
+|monitorFqdn            |          |taosKeeper 服务所在服务器的 FQDN，默认值 无|
+|monitorPort            |          |taosKeeper 服务所监听的端口号，默认值 6043|
+|monitorInterval        |          |监控数据库记录系统参数（CPU/内存）的时间间隔，单位是秒，取值范围 1-200000 ，默认值 30|
+|monitorMaxLogs         |          |缓存的待上报日志条数|
+|monitorComp            |          |是否采用压缩方式上报监控日志时|
+|monitorLogProtocol     |          |是否打印监控日志|
+|monitorForceV2         |          |是否使用 V2 版本协议上报|
+|telemetryReporting     |          |是否上传 telemetry，0：不上传，1：上传，默认值 1|
+|telemetryServer        |          |telemetry 服务器地址|
+|telemetryPort          |          |telemetry 服务器端口编号|
+|telemetryInterval      |          |telemetry 上传时间间隔，单位为秒，默认 43200|
+|crashReporting         |          |是否上传 crash 信息；0：不上传，1：上传；默认值  1|
 
 ### 查询相关
-
-|        参数名称        |                                                                                                                               参数说明                                                                                                                                |
-| :--------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
-|      queryPolicy       |                                             查询策略，1: 只使用 vnode，不使用 qnode; 2: 没有扫描算子的子任务在 qnode 执行，带扫描算子的子任务在 vnode 执行; 3: vnode 只运行扫描算子，其余算子均在 qnode 执行 ；4: 使用客户端聚合模式；缺省值：1                                              |
-|  maxNumOfDistinctRes   |                                                                                                    允许返回的 distinct 结果最大行数，默认值 10 万，最大允许值 1 亿                                                                                                    |
-| countAlwaysReturnValue | count/hyperloglog函数在输入数据为空或者NULL的情况下是否返回值，0: 返回空行，1: 返回；该参数设置为 1 时，如果查询中含有 INTERVAL 子句或者该查询使用了TSMA时, 且相应的组或窗口内数据为空或者NULL， 对应的组或窗口将不返回查询结果. 注意此参数客户端和服务端值应保持一致. |
-
+|参数名称|支持版本|参数含义|
+|------------------------|----------|-|
+|countAlwaysReturnValue  |          |count/hyperloglog 函数在输入数据为空或者 NULL 的情况下是否返回值；0：返回空行，1：返回；默认值 1；该参数设置为 1 时，如果查询中含有 INTERVAL 子句或者该查询使用了 TSMA 时，且相应的组或窗口内数据为空或者 NULL，对应的组或窗口将不返回查询结果；注意此参数客户端和服务端值应保持一致|
+|tagFilterCache          |          |是否缓存标签过滤结果|
+|maxNumOfDistinctRes     |          |允许返回的 distinct 结果最大行数，默认值 10 万，最大允许值 1 亿|
+|queryBufferSize         |          |暂不生效|
+|queryRspPolicy          |          |查询响应策略|
+|filterScalarMode        |          |强制使用标量过滤模式，0：关闭；1：开启，默认值 0|
+|queryPlannerTrace       |          |内部参数，查询计划是否输出详细日志|
+|queryNodeChunkSize      |          |内部参数，查询计划的块大小|
+|queryUseNodeAllocator   |          |内部参数，查询计划的分配方法|
+|queryMaxConcurrentTables|          |内部参数，查询计划的并发数目|
+|queryRsmaTolerance      |          |内部参数，用于判定查询哪一级 rsma 数据时的容忍时间，单位为毫秒|
+|enableQueryHb           |          |内部参数，是否发送查询心跳消息|
+|pqSortMemThreshold      |          |内部参数，排序使用的内存阈值|
 
 ### 区域相关
-
-| 参数名称 |                                                 参数说明                                                 |
-| :------: | :------------------------------------------------------------------------------------------------------: |
-| timezone |                                   时区，缺省值：当前服务器所配置的时区                                   |
-|  locale  | 系统区位信息及编码格式 ，缺省值：系统中动态获取，如果自动获取失败，需要用户在配置文件设置或通过 API 设置 |
-| charset  |                                     字符集编码，缺省值：系统自动获取                                     |
+|参数名称|支持版本|参数含义|
+|-----------------|----------|-|
+|timezone         |          |时区；缺省从系统中动态获取当前的时区设置|
+|locale           |          |系统区位信息及编码格式，缺省从系统中获取|
+|charset          |          |字符集编码，缺省从系统中获取|
 
 :::info
 1. 为应对多时区的数据写入和查询问题，TDengine 采用 Unix 时间戳(Unix Timestamp)来记录和存储时间戳。Unix 时间戳的特点决定了任一时刻不论在任何时区，产生的时间戳均一致。需要注意的是，Unix 时间戳是在客户端完成转换和记录。为了确保客户端其他形式的时间转换为正确的 Unix 时间戳，需要设置正确的时区。
@@ -101,7 +125,7 @@ SELECT count(*) FROM table_name WHERE TS<1554984068000;
 
 客户端的输入的字符均采用操作系统当前默认的编码格式，在 Linux/macOS 系统上多为 UTF-8，部分中文系统编码则可能是 GB18030 或 GBK 等。在 docker 环境中默认的编码是 POSIX。在中文版 Windows 系统中，编码则是 CP936。客户端需要确保正确设置自己所使用的字符集，即客户端运行的操作系统当前编码字符集，才能保证 nchar 中的数据正确转换为 UCS4-LE 编码格式。
 
-在 Linux/macOS 中 locale 的命名规则为: \<语言>_\<地区>.\<字符集编码> 如：zh_CN.UTF-8，zh 代表中文，CN 代表大陆地区，UTF-8 表示字符集。字符集编码为客户端正确解析本地字符串提供编码转换的说明。Linux/macOS 可以通过设置 locale 来确定系统的字符编码，由于 Windows 使用的 locale 中不是 POSIX 标准的 locale 格式，因此在 Windows 下需要采用另一个配置参数 charset 来指定字符编码。在 Linux/macOS 中也可以使用 charset 来指定字符编码。
+在 Linux/macOS 中 locale 的命名规则为：\<语言>_\<地区>.\<字符集编码> 如：zh_CN.UTF-8，zh 代表中文，CN 代表大陆地区，UTF-8 表示字符集。字符集编码为客户端正确解析本地字符串提供编码转换的说明。Linux/macOS 可以通过设置 locale 来确定系统的字符编码，由于 Windows 使用的 locale 中不是 POSIX 标准的 locale 格式，因此在 Windows 下需要采用另一个配置参数 charset 来指定字符编码。在 Linux/macOS 中也可以使用 charset 来指定字符编码。
 
 
 3. 如果配置文件中不设置 charset，在 Linux/macOS 中，taos 在启动时候，自动读取系统当前的 locale 信息，并从 locale 信息中解析提取 charset 编码格式。如果自动读取 locale 信息失败，则尝试读取 charset 配置，如果读取 charset 配置也失败，则中断启动过程。
@@ -139,73 +163,148 @@ charset 的有效值是 UTF-8。
 :::
 
 ### 存储相关
-
-|     参数名称     |                                参数说明                                |
-| :--------------: | :--------------------------------------------------------------------: |
-|     dataDir      |      数据文件目录，所有的数据文件都将写入该目录，缺省值：/var/lib/taos    |
-|     tempDir      |        指定所有系统运行过程中的临时文件生成的目录，缺省值：/tmp        |
-| minimalTmpDirGB  |  tempDir 所指定的临时文件目录所需要保留的最小空间，单位 GB，缺省值: 1  |
-| minimalDataDirGB | dataDir 指定的时序数据存储目录所需要保留的最小空间，单位 GB，缺省值: 2 |
+|参数名称|支持版本|参数含义|
+|--------------------|----------|-|
+|dataDir             |          |数据文件目录，所有的数据文件都将写入该目录，默认值 /var/lib/taos|
+|tempDir             |          |指定所有系统运行过程中的临时文件生成的目录，默认值 /tmp|
+|minimalDataDirGB    |          |dataDir 指定的时序数据存储目录所需要保留的最小空间，单位 GB，默认值 2|
+|minimalTmpDirGB     |          |tempDir 所指定的临时文件目录所需要保留的最小空间，单位 GB，默认值 1|
+|minDiskFreeSize     |3.1.1.0 后|当某块磁盘上的可用空间小于等于这个阈值时，该磁盘将不再被选择用于生成新的数据文件，单位为字节，取值范围 52428800-1073741824，默认值为 52428800；企业版参数|
+|s3MigrateIntervalSec|3.3.4.3 后|本地数据文件自动上传 S3 的触发周期，单位为秒。最小值：600；最大值：100000。默认值 3600；企业版参数|
+|s3MigrateEnabled    |3.3.4.3 后|是否自动进行 S3 迁移，默认值为 0，表示关闭自动 S3 迁移，可配置为 1；企业版参数|
+|s3Accesskey         |3.3.4.3 后|冒号分隔的用户 SecretId:SecretKey，例如 AKIDsQmwsfKxTo2A6nGVXZN0UlofKn6JRRSJ:lIdoy99ygEacU7iHfogaN2Xq0yumSm1E；企业版参数|
+|s3Endpoint          |3.3.4.3 后|用户所在地域的 COS 服务域名，支持 http 和 https，bucket 的区域需要与 endpoint 保持一致，否则无法访问；企业版参数|
+|s3BucketName        |3.3.4.3 后|存储桶名称，减号后面是用户注册 COS 服务的 AppId，其中 AppId 是 COS 特有，AWS 和阿里云都没有，配置时需要作为 bucket name 的一部分，使用减号分隔；参数值均为字符串类型，但不需要引号；例如 test0711-1309024725；企业版参数|
+|s3PageCacheSize     |3.3.4.3 后|S3 page cache 缓存页数目，取值范围 4-1048576，单位为页，默认值 4096；企业版参数|
+|s3UploadDelaySec    |3.3.4.3 后|data 文件持续多长时间不再变动后上传至 S3，取值范围 1-2592000 (30天），单位为秒，默认值 60；企业版参数|
+|cacheLazyLoadThreshold|        |内部参数，缓存的装载策略|
 
 ### 集群相关
+|参数名称|支持版本|参数含义|
+|--------------------------|----------|-|
+|supportVnodes             |          |dnode 支持的最大 vnode 数目，取值范围 0-4096，默认值 CPU 核数的 2 倍 + 5|
+|numOfCommitThreads        |          |落盘线程的最大数量，取值范围 0-1024，默认值为 4|
+|numOfMnodeReadThreads     |          |mnode 的 Read 线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不超过 4）|
+|numOfVnodeQueryThreads    |          |vnode 的 Query 线程数目，取值范围 0-1024，默认值为 CPU 核数的两倍（不超过 16）|
+|numOfVnodeFetchThreads    |          |vnode 的 Fetch 线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不超过 4）|
+|numOfVnodeRsmaThreads     |          |vnode 的 Rsma 线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不超过 4）|
+|numOfQnodeQueryThreads    |          |qnode 的 Query 线程数目，取值范围 0-1024，默认值为 CPU 核数的两倍（不超过 16）|
+|numOfSnodeSharedThreads   |          |snode 的共享线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不小于 2，不超过 4）|
+|numOfSnodeUniqueThreads   |          |snode 的独占线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不小于 2，不超过 4）|
+|ratioOfVnodeStreamThreads |          |流计算使用 vnode 线程的比例，取值范围 0.01-4，默认值 4|
+|ttlUnit                   |          |ttl 参数的单位，取值范围 1-31572500，单位为秒，默认值 86400|
+|ttlPushInterval           |          |ttl 检测超时频率，取值范围 1-100000，单位为秒，默认值 10|
+|ttlChangeOnWrite          |          |ttl 到期时间是否伴随表的修改操作改变；0：不改变，1：改变；默认值为 0|
+|ttlBatchDropNum           |          |ttl 一批删除子表的数目，最小值为 0，默认值 10000|
+|retentionSpeedLimitMB     |          |数据在不同级别硬盘上迁移时的速度限制，取值范围 0-1024，单位 MB，默认值 0，表示不限制|
+|maxTsmaNum                |          |集群内可创建的TSMA个数；取值范围 0-3；默认值 3|
+|tmqMaxTopicNum            |          |订阅最多可建立的 topic 数量；取值范围 1-10000；默认值为 20|
+|tmqRowSize                |          |订阅数据块的最大记录条数，取值范围 1-1000000，默认值 4096|
+|audit                     |          |审计功能开关；企业版参数|
+|auditInterval             |          |审计数据上报的时间间隔；企业版参数|
+|auditCreateTable          |          |是否针对创建子表开启申计功能；企业版参数|
+|encryptAlgorithm          |          |数据加密算法；企业版参数|
+|encryptScope              |          |加密范围；企业版参数|
+|enableWhiteList           |          |白名单功能开关；企业版参数|
+|syncLogBufferMemoryAllowed|          |一个 dnode 允许的 sync 日志缓存消息占用的内存最大值，单位 bytes，取值范围 104857600-INT64_MAX，默认值 服务器内存的 1/10，3.1.3.2/3.3.2.13 版本开始生效 |
+|syncElectInterval         |          |内部参数，用于同步模块调试|
+|syncHeartbeatInterval     |          |内部参数，用于同步模块调试|
+|syncHeartbeatTimeout      |          |内部参数，用于同步模块调试|
+|syncSnapReplMaxWaitN      |          |内部参数，用于同步模块调试|
+|syncSnapReplMaxWaitN      |          |内部参数，用于同步模块调试|
+|arbHeartBeatIntervalSec   |          |内部参数，用于同步模块调试|
+|arbCheckSyncIntervalSec   |          |内部参数，用于同步模块调试|
+|arbSetAssignedTimeoutSec  |          |内部参数，用于同步模块调试|
+|mndSdbWriteDelta          |          |内部参数，用于 mnode 模块调试|
+|mndLogRetention           |          |内部参数，用于 mnode 模块调试|
+|skipGrant                 |          |内部参数，用于授权检查|
+|trimVDbIntervalSec        |          |内部参数，用于删除过期数据|
+|ttlFlushThreshold         |          |内部参数，ttl 定时器的频率|
+|compactPullupInterval     |          |内部参数，数据重整定时器的频率|
+|walFsyncDataSizeLimit     |          |内部参数，WAL 进行 FSYNC 的阈值|
+|transPullupInterval       |          |内部参数，mnode 执行事务的重试间隔|
+|mqRebalanceInterval       |          |内部参数，消费者再平衡的时间间隔|
+|uptimeInterval            |          |内部参数，用于记录系统启动时间|
+|timeseriesThreshold       |          |内部参数，用于统计用量|
+|udf                       |          |是否启动 UDF 服务；0：不启动，1：启动；默认值为 0 |
+|udfdResFuncs              |          |内部参数，用于 UDF 结果集设置|
+|udfdLdLibPath             |          |内部参数，表示 UDF 装载的库路径|
 
-|   参数名称    |                                  参数说明                                   |
-| :-----------: | :-------------------------------------------------------------------------: |
-| supportVnodes | dnode 支持的最大 vnode 数目，取值范围：0-4096，缺省值： CPU 核数的 2 倍 + 5 |
 
-### 内存相关
-|      参数名称       |                    参数说明                     |
-| :----------------: | :---------------------------------------------: |
-| rpcQueueMemoryAllowed       | 一个 dnode 允许的 rpc 消息占用的内存最大值，单位 bytes，取值范围：104857600-INT64_MAX，缺省值：服务器内存的 1/10 |
-| syncLogBufferMemoryAllowed  | 一个 dnode 允许的 sync 日志缓存消息占用的内存最大值，单位 bytes，取值范围：104857600-INT64_MAX，缺省值：服务器内存的 1/10，3.1.3.2/3.3.2.13 版本开始生效 |
-
-### 性能调优
-
-|      参数名称      |                    参数说明                     |
-| :----------------: | :---------------------------------------------: |
-| numOfCommitThreads | 落盘线程的最大数量，取值范围 0-1024，缺省值为 4 |
+### 流计算参数
+|参数名称|支持版本|参数含义|
+|-----------------------|----------|-|
+|disableStream          |          |流计算的启动开关|
+|streamBufferSize       |          |控制内存中窗口状态缓存的大小，默认值为 128MB|
+|streamAggCnt           |          |内部参数，并发进行聚合计算的数目|
+|checkpointInterval     |          |内部参数，checkponit 同步间隔|
+|concurrentCheckpoint   |          |内部参数，是否并发检查 checkpoint|
+|maxStreamBackendCache  |          |内部参数，流计算使用的最大缓存|
+|streamSinkDataRate     |          |内部参数，用于控制流计算结果的写入速度|
 
 ### 日志相关
+|参数名称|支持版本|参数含义|
+|----------------|----------|-|
+|logDir          |          |日志文件目录，运行日志将写入该目录，默认值 /var/log/taos|
+|minimalLogDirGB |          |日志文件夹所在磁盘可用空间大小小于该值时，停止写日志，单位 GB，默认值 1|
+|numOfLogLines   |          |单个日志文件允许的最大行数，默认值 10,000,000|
+|asyncLog        |          |日志写入模式，0：同步，1：异步，默认值 1|
+|logKeepDays     |          |日志文件的最长保存时间，单位：天，默认值 0，意味着无限保存，日志文件不会被重命名，也不会有新的日志文件滚动产生，但日志文件的内容有可能会不断滚动，取决于日志文件大小的设置；当设置为大于 0 的值时，当日志文件大小达到设置的上限时会被重命名为 taosdlog.yyy，其中 yyy 为日志文件最后修改的时间戳，并滚动产生新的日志文件|
+|slowLogThreshold|3.3.3.0 后|慢查询门限值，大于等于门限值认为是慢查询，单位秒，默认值 3 |
+|slowLogMaxLen   |3.3.3.0 后|慢查询日志最大长度，取值范围 1-16384，默认值 4096|
+|slowLogScope    |3.3.3.0 后|慢查询记录类型，取值范围 ALL/QUERY/INSERT/OTHERS/NONE，默认值 QUERY|
+|slowLogExceptDb |3.3.3.0 后|指定的数据库不上报慢查询，仅支持配置换一个数据库|
+|debugFlag       |          |运行日志开关，131（输出错误和警告日志），135（输出错误、警告和调试日志），143（输出错误、警告、调试和跟踪日志）；默认值 131 或 135 （取决于不同模块）|
+|tmrDebugFlag    |          |定时器模块的日志开关，取值范围同上|
+|uDebugFlag      |          |共用功能模块的日志开关，取值范围同上|
+|rpcDebugFlag    |          |rpc 模块的日志开关，取值范围同上|
+|qDebugFlag      |          |query 模块的日志开关，取值范围同上|
+|dDebugFlag      |          |dnode 模块的日志开关，取值范围同上|
+|vDebugFlag      |          |vnode 模块的日志开关，取值范围同上|
+|mDebugFlag      |          |mnode 模块的日志开关，取值范围同上|
+|azDebugFlag     |3.3.4.3 后|S3 模块的日志开关，取值范围同上|
+|sDebugFlag      |          |sync 模块的日志开关，取值范围同上|
+|tsdbDebugFlag   |          |tsdb 模块的日志开关，取值范围同上|
+|tqDebugFlag     |          |tq 模块的日志开关，取值范围同上|
+|fsDebugFlag     |          |fs 模块的日志开关，取值范围同上|
+|udfDebugFlag    |          |udf 模块的日志开关，取值范围同上|
+|smaDebugFlag    |          |sma 模块的日志开关，取值范围同上|
+|idxDebugFlag    |          |index 模块的日志开关，取值范围同上|
+|tdbDebugFlag    |          |tdb 模块的日志开关，取值范围同上|
+|metaDebugFlag   |          |meta 模块的日志开关，取值范围同上|
+|stDebugFlag     |          |stream 模块的日志开关，取值范围同上|
+|sndDebugFlag    |          |snode 模块的日志开关，取值范围同上|
 
-|     参数名称     |                                                                           参数说明                                                                           |
-| :--------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------: |
-|      logDir      |                                                  日志文件目录，运行日志将写入该目录，缺省值：/var/log/taos                                                   |
-| minimalLogDirGB  |                                          当日志文件夹所在磁盘可用空间大小小于该值时，停止写日志，单位GB，缺省值：1                                           |
-|  numOfLogLines   |                                                        单个日志文件允许的最大行数，缺省值：10,000,000                                                        |
-|     asyncLog     |                                                          日志写入模式，0: 同步，1: 异步，缺省值: 1                                                           |
-|   logKeepDays    | 日志文件的最长保存时间 ，单位：天，缺省值：0，意味着无限保存，日志文件不会被重命名，也不会有新的日志文件滚动产生，但日志文件的内容有可能会不断滚动，取决于日志文件大小的设置；当设置为大于0 的值时，当日志文件大小达到设置的上限时会被重命名为 taosdlog.xxx，其中 xxx 为日志文件最后修改的时间戳，并滚动产生新的日志文件 |
-| slowLogThreshold |                                                 慢查询门限值，大于等于门限值认为是慢查询，单位秒，默认值: 3                                                  |
-|   slowLogScope   |                                      定启动记录哪些类型的慢查询，可选值：ALL, QUERY, INSERT, OHTERS, NONE; 默认值：ALL                                       |
-|    debugFlag     |    运行日志开关，131（输出错误和警告日志），135（输出错误、警告和调试日志），143（输出错误、警告、调试和跟踪日志）; 默认值：131 或 135 （取决于不同模块）    |
-|   tmrDebugFlag   |                                                              定时器模块的日志开关，取值范围同上                                                              |
-|    uDebugFlag    |                                                             共用功能模块的日志开关，取值范围同上                                                             |
-|   rpcDebugFlag   |                                                               rpc 模块的日志开关，取值范围同上                                                               |
-|   cDebugFlag   |                                                               客户端模块的日志开关，取值范围同上                                                               |
-|   jniDebugFlag   |                                                               jni 模块的日志开关，取值范围同上                                                               |
-|    qDebugFlag    |                                                              query 模块的日志开关，取值范围同上                                                              |
-|    dDebugFlag    |                                                        dnode 模块的日志开关，取值范围同上，缺省值 135                                                        |
-|    vDebugFlag    |                                                              vnode 模块的日志开关，取值范围同上                                                              |
-|    mDebugFlag    |                                                              mnode 模块的日志开关，取值范围同上                                                              |
-|    wDebugFlag    |                                                               wal 模块的日志开关，取值范围同上                                                               |
-|    sDebugFlag    |                                                              sync 模块的日志开关，取值范围同上                                                               |
-|  tsdbDebugFlag   |                                                              tsdb 模块的日志开关，取值范围同上                                                               |
-|   tqDebugFlag    |                                                               tq 模块的日志开关，取值范围同上                                                                |
-|   fsDebugFlag    |                                                               fs 模块的日志开关，取值范围同上                                                                |
-|   udfDebugFlag   |                                                               udf 模块的日志开关，取值范围同上                                                               |
-|   smaDebugFlag   |                                                               sma 模块的日志开关，取值范围同上                                                               |
-|   idxDebugFlag   |                                                              index 模块的日志开关，取值范围同上                                                              |
-|   tdbDebugFlag   |                                                               tdb 模块的日志开关，取值范围同上                                                               |
+### 调试相关
+|参数名称|支持版本|参数含义|
+|--------------------|----------|-|
+|enableCoreFile      |          |crash 时是否生成 core 文件，0：不生成，1：生成；默认值 1|
+|configDir           |          |配置文件所在目录|
+|scriptDir           |          |内部测试工具的脚本目录|
+|assert              |          |断言控制开关，默认值 0|
+|randErrorChance     |          |内部参数，用于随机失败测试|
+|randErrorDivisor    |          |内部参数，用于随机失败测试|
+|randErrorScope      |          |内部参数，用于随机失败测试|
+|safetyCheckLevel    |          |内部参数，用于随机失败测试|
+|experimental        |          |内部参数，用于一些实验特性|
+|simdEnable          |3.3.4.3 后|内部参数，用于测试 SIMD 加速|
+|AVX512Enable        |3.3.4.3 后|内部参数，用于测试 AVX512 加速|
+|rsyncPort           |          |内部参数，用于调试流计算|
+|snodeAddress        |          |内部参数，用于调试流计算|
+|checkpointBackupDir |          |内部参数，用于恢复 snode 数据|
+|enableAuditDelete   |          |内部参数，用于测试审计功能|
+|slowLogThresholdTest|          |内部参数，用于测试慢日志|
 
 ### 压缩参数
-
-| 参数名称       |  参数说明                                                         |
-|:-------------:|:----------------------------------------------------------------:|
-| compressMsgSize | 是否对 RPC 消息进行压缩；-1: 所有消息都不压缩; 0: 所有消息都压缩; N (N>0): 只有大于 N 个字节的消息才压缩；缺省值  -1 |
-| fPrecision | 设置 float 类型浮点数压缩精度 ，取值范围：0.1 ~ 0.00000001  ，默认值  0.00000001  , 小于此值的浮点数尾数部分将被截断 |
-|dPrecision | 设置 double 类型浮点数压缩精度 , 取值范围：0.1 ~ 0.0000000000000001 ， 缺省值 0.0000000000000001 ， 小于此值的浮点数尾数部分将被截取  |
-|lossyColumn | 对 float 和/或 double 类型启用 TSZ 有损压缩；取值范围： float, double, none；缺省值: none，表示关闭无损压缩。**注意：此参数在 3.3.0.0 及更高版本中不再使用** |
-|ifAdtFse | 在启用 TSZ 有损压缩时，使用 FSE 算法替换 HUFFMAN 算法， FSE 算法压缩速度更快，但解压稍慢，追求压缩速度可选用此算法; 0: 关闭，1：打开；默认值为 0 |
-
+|参数名称|支持版本|参数含义|
+|------------|----------|-|
+|fPrecision  |          |设置 float 类型浮点数压缩精度 ，取值范围 0.1 ~ 0.00000001  ，默认值  0.00000001  , 小于此值的浮点数尾数部分将被截断|
+|dPrecision  |          |设置 double 类型浮点数压缩精度 , 取值范围 0.1 ~ 0.0000000000000001 ， 默认值 0.0000000000000001 ， 小于此值的浮点数尾数部分将被截取|
+|lossyColumn |3.3.0.0 前|对 float 和/或 double 类型启用 TSZ 有损压缩；取值范围 float/double/none；默认值 none，表示关闭无损压缩|
+|ifAdtFse    |          |在启用 TSZ 有损压缩时，使用 FSE 算法替换 HUFFMAN 算法，FSE 算法压缩速度更快，但解压稍慢，追求压缩速度可选用此算法；0：关闭，1：打开；默认值为 0|
+|maxRange    |          |内部参数，用于有损压缩设置|
+|curRange    |          |内部参数，用于有损压缩设置|
+|compressor  |          |内部参数，用于有损压缩设置|
 
 **补充说明**
 1. 在 3.2.0.0 ~ 3.3.0.0（不包含）版本生效，启用该参数后不能回退到升级前的版本
@@ -220,16 +319,6 @@ lossyColumns     float|double
    02/22 10:49:27.607990 00002933 UTL  lossyColumns     float|double
 ```
 
-### 其他参数
-
-|     参数名称     |                                                                                                 参数说明                                                                                                 |
-| :--------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
-|  enableCoreFile  | crash 时是否生成 core 文件；0: 不生成，1：生成；默认值为 1; 不同的启动方式，生成 core 文件的目录如下：1、systemctl start taosd 启动：生成的 core 在根目录下  <br/> 2、手动启动，就在 taosd 执行目录下。  |
-|       udf        |                                                                            是否启动 UDF 服务；0: 不启动，1：启动；默认值为 0                                                                             |
-| ttlChangeOnWrite |                                                                   ttl 到期时间是否伴随表的修改操作改变; 0: 不改变，1：改变；默认值为 0                                                                   |
-|  tmqMaxTopicNum  |                                                                        订阅最多可建立的 topic 数量; 取值范围 1-10000；缺省值为20                                                                         |
-|    maxTsmaNum    |                                                                             集群内可创建的TSMA个数；取值范围：0-3；缺省值为 3                                                                            |
-
 
 ## taosd 监控指标
 
@@ -282,7 +371,7 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
 | :------------- | :-------- | :------ | :--------------------------------------------- |
 | \_ts           | TIMESTAMP |         | timestamp                                      |
 | tables\_num    | DOUBLE    |         | vgroup 中 table 数量                           |
-| status         | DOUBLE    |         | vgroup 状态, 取值范围：unsynced = 0, ready = 1 |
+| status         | DOUBLE    |         | vgroup 状态, 取值范围 unsynced = 0, ready = 1 |
 | vgroup\_id     | VARCHAR   | TAG     | vgroup id                                      |
 | database\_name | VARCHAR   | TAG     | vgroup 所属的 database 名字                    |
 | cluster\_id    | VARCHAR   | TAG     | cluster id                                     |
@@ -311,10 +400,10 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
 | io\_write\_disk   | DOUBLE    |         | 磁盘 io 吞吐率，从 `/proc/<taosd_pid>/io` 中读取的 write_bytes。单位 byte/s                       |
 | vnodes\_num       | DOUBLE    |         | dnode 上 vnodes 数量                                                                              |
 | masters           | DOUBLE    |         | dnode 上 master node 数量                                                                         |
-| has\_mnode        | DOUBLE    |         | dnode 是否包含 mnode，取值范围：包含=1,不包含=0                                                   |
-| has\_qnode        | DOUBLE    |         | dnode 是否包含 qnode，取值范围：包含=1,不包含=0                                                   |
-| has\_snode        | DOUBLE    |         | dnode 是否包含 snode，取值范围：包含=1,不包含=0                                                   |
-| has\_bnode        | DOUBLE    |         | dnode 是否包含 bnode，取值范围：包含=1,不包含=0                                                   |
+| has\_mnode        | DOUBLE    |         | dnode 是否包含 mnode，取值范围 包含=1,不包含=0                                                   |
+| has\_qnode        | DOUBLE    |         | dnode 是否包含 qnode，取值范围 包含=1,不包含=0                                                   |
+| has\_snode        | DOUBLE    |         | dnode 是否包含 snode，取值范围 包含=1,不包含=0                                                   |
+| has\_bnode        | DOUBLE    |         | dnode 是否包含 bnode，取值范围 包含=1,不包含=0                                                   |
 | error\_log\_count | DOUBLE    |         | error 总数                                                                                        |
 | info\_log\_count  | DOUBLE    |         | info 总数                                                                                         |
 | debug\_log\_count | DOUBLE    |         | debug 总数                                                                                        |
@@ -330,7 +419,7 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
 | field       | type      | is\_tag | comment                                  |
 | :---------- | :-------- | :------ | :--------------------------------------- |
 | \_ts        | TIMESTAMP |         | timestamp                                |
-| status      | DOUBLE    |         | dnode 状态,取值范围：ready=1，offline =0 |
+| status      | DOUBLE    |         | dnode 状态,取值范围 ready=1，offline =0 |
 | dnode\_id   | VARCHAR   | TAG     | dnode id                                 |
 | dnode\_ep   | VARCHAR   | TAG     | dnode endpoint                           |
 | cluster\_id | VARCHAR   | TAG     | cluster id                               |
@@ -373,7 +462,7 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
 | field       | type      | is\_tag | comment                                                                                                  |
 | :---------- | :-------- | :------ | :------------------------------------------------------------------------------------------------------- |
 | \_ts        | TIMESTAMP |         | timestamp                                                                                                |
-| role        | DOUBLE    |         | mnode 角色， 取值范围：offline = 0,follower = 100,candidate = 101,leader = 102,error = 103,learner = 104 |
+| role        | DOUBLE    |         | mnode 角色， 取值范围 offline = 0,follower = 100,candidate = 101,leader = 102,error = 103,learner = 104 |
 | mnode\_id   | VARCHAR   | TAG     | master node id                                                                                           |
 | mnode\_ep   | VARCHAR   | TAG     | master node endpoint                                                                                     |
 | cluster\_id | VARCHAR   | TAG     | cluster id                                                                                               |
@@ -385,7 +474,7 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
 | field          | type      | is\_tag | comment                                                                                                 |
 | :------------- | :-------- | :------ | :------------------------------------------------------------------------------------------------------ |
 | \_ts           | TIMESTAMP |         | timestamp                                                                                               |
-| vnode\_role    | DOUBLE    |         | vnode 角色，取值范围：offline = 0,follower = 100,candidate = 101,leader = 102,error = 103,learner = 104 |
+| vnode\_role    | DOUBLE    |         | vnode 角色，取值范围 offline = 0,follower = 100,candidate = 101,leader = 102,error = 103,learner = 104 |
 | vgroup\_id     | VARCHAR   | TAG     | dnode id                                                                                                |
 | dnode\_id      | VARCHAR   | TAG     | dnode id                                                                                                |
 | database\_name | VARCHAR   | TAG     | vgroup 所属的 database 名字                                                                             |
@@ -399,9 +488,9 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
 | :---------- | :-------- | :------ | :--------------------------------------- |
 | \_ts        | TIMESTAMP |         | timestamp                                |
 | count       | DOUBLE    |         | sql 数量                                 |
-| result      | VARCHAR   | TAG     | sql的执行结果，取值范围：Success, Failed |
+| result      | VARCHAR   | TAG     | sql的执行结果，取值范围 Success, Failed |
 | username    | VARCHAR   | TAG     | 执行sql的user name                       |
-| sql\_type   | VARCHAR   | TAG     | sql类型，取值范围：inserted_rows         |
+| sql\_type   | VARCHAR   | TAG     | sql类型，取值范围 inserted_rows         |
 | dnode\_id   | VARCHAR   | TAG     | dnode id                                 |
 | dnode\_ep   | VARCHAR   | TAG     | dnode endpoint                           |
 | vgroup\_id  | VARCHAR   | TAG     | dnode id                                 |
@@ -415,9 +504,9 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
 | :---------- | :-------- | :------ | :---------------------------------------- |
 | \_ts        | TIMESTAMP |         | timestamp                                 |
 | count       | DOUBLE    |         | sql 数量                                  |
-| result      | VARCHAR   | TAG     | sql的执行结果，取值范围：Success, Failed  |
+| result      | VARCHAR   | TAG     | sql的执行结果，取值范围 Success, Failed  |
 | username    | VARCHAR   | TAG     | 执行sql的user name                        |
-| sql\_type   | VARCHAR   | TAG     | sql类型，取值范围：select, insert，delete |
+| sql\_type   | VARCHAR   | TAG     | sql类型，取值范围 select, insert，delete |
 | cluster\_id | VARCHAR   | TAG     | cluster id                                |
 
 ### taos\_slow\_sql 表
@@ -428,9 +517,9 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
 | :---------- | :-------- | :------ | :---------------------------------------------------- |
 | \_ts        | TIMESTAMP |         | timestamp                                             |
 | count       | DOUBLE    |         | sql 数量                                              |
-| result      | VARCHAR   | TAG     | sql的执行结果，取值范围：Success, Failed              |
+| result      | VARCHAR   | TAG     | sql的执行结果，取值范围 Success, Failed              |
 | username    | VARCHAR   | TAG     | 执行sql的user name                                    |
-| duration    | VARCHAR   | TAG     | sql执行耗时，取值范围：3-10s,10-100s,100-1000s,1000s- |
+| duration    | VARCHAR   | TAG     | sql执行耗时，取值范围 3-10s,10-100s,100-1000s,1000s- |
 | cluster\_id | VARCHAR   | TAG     | cluster id                                            |
 
 ## 日志相关

docs/zh/14-reference/01-components/02-taosc.md

@@ -8,38 +8,100 @@ TDengine 客户端驱动提供了应用编程所需要的全部 API，并且在
 
 ## 配置参数
 
-| 参数名称     | 参数含义                                                    |
-|:-----------:|:----------------------------------------------------------:|
-|firstEp | taos 启动时，主动连接的集群中首个 dnode 的 endpoint，缺省值：hostname:6030，若无法获取该服务器的 hostname，则赋值为 localhost  |
-|secondEp | 启动时，如果 firstEp 连接不上，尝试连接集群中第二个 dnode 的 endpoint，没有缺省值 |
-|numOfRpcSessions | 一个客户端能创建的最大连接数，取值范围：10-50000000(单位为毫秒)；缺省值：500000 |
-|telemetryReporting | 是否上传 telemetry，0: 不上传，1： 上传；缺省值：1 |
-|crashReporting | 是否上传 telemetry，0: 不上传，1： 上传；缺省值：1  |
-|queryPolicy | 查询语句的执行策略，1: 只使用 vnode，不使用 qnode; 2: 没有扫描算子的子任务在 qnode 执行，带扫描算子的子任务在 vnode 执行; 3: vnode 只运行扫描算子，其余算子均在 qnode 执行 ；缺省值：1 |
-|querySmaOptimize | sma index 的优化策略，0: 表示不使用 sma index，永远从原始数据进行查询; 1: 表示使用 sma index，对符合的语句，直接从预计算的结果进行查询；缺省值：0 |
-|keepColumnName | Last、First、LastRow 函数查询且未指定别名时，自动设置别名为列名（不含函数名），因此 order by 子句如果引用了该列名将自动引用该列对应的函数; 1: 表示自动设置别名为列名(不包含函数名), 0: 表示不自动设置别名; 缺省值: 0 |
-|countAlwaysReturnValue | count/hyperloglog函数在输入数据为空或者NULL的情况下是否返回值; 0：返回空行，1：返回; 缺省值 1; 该参数设置为 1 时，如果查询中含有 INTERVAL 子句或者该查询使用了TSMA时, 且相应的组或窗口内数据为空或者NULL， 对应的组或窗口将不返回查询结果. 注意此参数客户端和服务端值应保持一致. |
-|multiResultFunctionStarReturnTags | 查询超级表时，last(\*)/last_row(\*)/first(\*) 是否返回标签列；查询普通表、子表时，不受该参数影响; 0：不返回标签列，1：返回标签列 ; 缺省值: 0; 该参数设置为 0 时，last(\*)/last_row(\*)/first(\*) 只返回超级表的普通列；为 1 时，返回超级表的普通列和标签列 |
-|maxTsmaCalcDelay| 查询时客户端可允许的tsma计算延迟, 若tsma的计算延迟大于配置值, 则该TSMA将不会被使用.; 取值范围: 600s - 86400s, 即10分钟-1小时 ; 缺省值：600 秒|
-|tsmaDataDeleteMark |TSMA计算的历史数据中间结果保存时间, 单位为毫秒; 取值范围：>= 3600000, 即大于等于1h; 缺省值: 86400000, 即1d  |
-|timezone | 时区; 缺省从系统中动态获取当前的时区设置 |
-|locale | 系统区位信息及编码格式, 缺省从系统中获取 |
-|charset | 字符集编码，缺省从系统中获取 |
-|metaCacheMaxSize | 指定单个客户端元数据缓存大小的最大值, 单位 MB; 缺省值 -1，表示无限制 |
-|logDir | 日志文件目录，客户端运行日志将写入该目录, 缺省值: /var/log/taos |
-|minimalLogDirGB | 当日志文件夹所在磁盘可用空间大小小于该值时，停止写日志; 缺省值  1 |
-|numOfLogLines | 单个日志文件允许的最大行数; 缺省值 10,000,000 |
-|asyncLog | 是否异步写入日志，0：同步；1：异步；缺省值：1 |
-|logKeepDays | 日志文件的最长保存时间; 缺省值: 0，表示无限保存; 大于 0 时，日志文件会被重命名为 taosdlog.xxx，其中 xxx 为日志文件最后修改的时间戳|
-|smlChildTableName | schemaless 自定义的子表名的 key, 无缺省值 |
-|smlAutoChildTableNameDelimiter | schemaless tag之间的连接符，连起来作为子表名，无缺省值 |
-|smlTagName | schemaless tag 为空时默认的 tag 名字, 缺省值 "_tag_null" |
-|smlTsDefaultName | schemaless自动建表的时间列名字通过该配置设置, 缺省值 "_ts" |
-|smlDot2Underline | schemaless 把超级表名中的 dot 转成下划线 |
-|enableCoreFile | crash 时是否生成 core 文件，0: 不生成， 1： 生成；缺省值：1 |
-|enableScience | 是否开启科学计数法显示浮点数; 0: 不开始, 1: 开启；缺省值：1 |
-|compressMsgSize | 是否对 RPC 消息进行压缩; -1: 所有消息都不压缩; 0: 所有消息都压缩; N (N>0): 只有大于 N 个字节的消息才压缩; 缺省值 -1|
-|queryTableNotExistAsEmpty | 查询表不存在时是否返回空结果集; false: 返回错误; true: 返回空结果集; 缺省值 false|
+### 连接相关
+|参数名称|支持版本|参数含义|
+|----------------------|----------|-|
+|firstEp               |          |启动时，主动连接的集群中首个 dnode 的 endpoint，缺省值：hostname:6030，若无法获取该服务器的 hostname，则赋值为 localhost|
+|secondEp              |          |启动时，如果 firstEp 连接不上，尝试连接集群中第二个 dnode 的 endpoint，没有缺省值|
+|compressMsgSize       |          |是否对 RPC 消息进行压缩；-1：所有消息都不压缩；0：所有消息都压缩；N (N>0)：只有大于 N 个字节的消息才压缩；缺省值 -1|
+|shellActivityTimer    |          |客户端向 mnode 发送心跳的时长，单位为秒，取值范围 1-120，默认值 3|
+|numOfRpcSessions      |          |RPC 支持的最大连接数，取值范围 100-100000，缺省值 30000|
+|numOfRpcThreads       |          |RPC 线程数目，默认值为 CPU 核数的一半|
+|timeToGetAvailableConn|          |获得可用连接的最长等待时间，取值范围 10-50000000，单位为毫秒，缺省值 500000|
+|useAdapter            |          |内部参数，是否使用 taosadapter，影响 CSV 文件导入|
+|shareConnLimit        |3.3.4.3 后|内部参数，一个链接可以共享的查询数目，取值范围 1-256，默认值 10|
+|readTimeout           |3.3.4.3 后|内部参数，最小超时时间，取值范围 64-604800，单位为秒，默认值 900|
+
+### 查询相关
+|参数名称|支持版本|参数含义|
+|---------------------------------|---------|-|
+|countAlwaysReturnValue           |         |count/hyperloglog 函数在输入数据为空或者 NULL 的情况下是否返回值；0：返回空行，1：返回；默认值 1；该参数设置为 1 时，如果查询中含有 INTERVAL 子句或者该查询使用了 TSMA 时，且相应的组或窗口内数据为空或者 NULL，对应的组或窗口将不返回查询结果；注意此参数客户端和服务端值应保持一致|
+|keepColumnName                   |         |Last、First、LastRow 函数查询且未指定别名时，自动设置别名为列名（不含函数名），因此 order by 子句如果引用了该列名将自动引用该列对应的函数；1：表示自动设置别名为列名(不包含函数名)，0：表示不自动设置别名；缺省值：0|
+|multiResultFunctionStarReturnTags|3.3.3.0 后|查询超级表时，last(\*)/last_row(\*)/first(\*) 是否返回标签列；查询普通表、子表时，不受该参数影响；0：不返回标签列，1：返回标签列；缺省值：0；该参数设置为 0 时，last(\*)/last_row(\*)/first(\*) 只返回超级表的普通列；为 1 时，返回超级表的普通列和标签列|
+|metaCacheMaxSize                 |         |指定单个客户端元数据缓存大小的最大值，单位 MB；缺省值 -1，表示无限制|
+|maxTsmaCalcDelay                 |         |查询时客户端可允许的 tsma 计算延迟，若 tsma 的计算延迟大于配置值，则该 TSMA 将不会被使用；取值范围 600s - 86400s，即 10 分钟 - 1 小时；缺省值：600 秒|
+|tsmaDataDeleteMark               |         |TSMA 计算的历史数据中间结果保存时间，单位为毫秒；取值范围 >= 3600000，即大于等于1h；缺省值：86400000，即 1d |
+|queryPolicy                      |         |查询语句的执行策略，1：只使用 vnode，不使用 qnode；2：没有扫描算子的子任务在 qnode 执行，带扫描算子的子任务在 vnode 执行；3：vnode 只运行扫描算子，其余算子均在 qnode 执行；缺省值：1|
+|queryTableNotExistAsEmpty        |         |查询表不存在时是否返回空结果集；false：返回错误；true：返回空结果集；缺省值 false|
+|querySmaOptimize                 |         |sma index 的优化策略，0：表示不使用 sma index，永远从原始数据进行查询；1：表示使用 sma index，对符合的语句，直接从预计算的结果进行查询；缺省值：0|
+|queryPlannerTrace                |         |内部参数，查询计划是否输出详细日志|
+|queryNodeChunkSize               |         |内部参数，查询计划的块大小|
+|queryUseNodeAllocator            |         |内部参数，查询计划的分配方法|
+|queryMaxConcurrentTables         |         |内部参数，查询计划的并发数目|
+|enableQueryHb                    |         |内部参数，是否发送查询心跳消息|
+|minSlidingTime                   |         |内部参数，sliding 的最小允许值|
+|minIntervalTime                  |         |内部参数，interval 的最小允许值|
+
+### 写入相关
+|参数名称|支持版本|参数含义|
+|------------------------------|----------|-|
+|smlChildTableName             |          |schemaless 自定义的子表名的 key，无缺省值|
+|smlAutoChildTableNameDelimiter|          |schemaless tag 之间的连接符，连起来作为子表名，无缺省值|
+|smlTagName                    |          |schemaless tag 为空时默认的 tag 名字，缺省值 "_tag_null"|
+|smlTsDefaultName              |          |schemaless 自动建表的时间列名字通过该配置设置，缺省值 "_ts"|
+|smlDot2Underline              |          |schemaless 把超级表名中的 dot 转成下划线|
+|maxInsertBatchRows            |          |内部参数，一批写入的最大条数|
+
+### 区域相关
+|参数名称|支持版本|参数含义|
+|-----------------|----------|-|
+|timezone         |          |时区；缺省从系统中动态获取当前的时区设置|
+|locale           |          |系统区位信息及编码格式，缺省从系统中获取|
+|charset          |          |字符集编码，缺省从系统中获取|
+
+### 存储相关
+|参数名称|支持版本|参数含义|
+|-----------------|----------|-|
+|tempDir          |          |指定所有运行过程中的临时文件生成的目录，Linux 平台默认值为 /tmp|
+|minimalTmpDirGB  |          |tempDir 所指定的临时文件目录所需要保留的最小空间，单位 GB，缺省值：1|
+
+### 日志相关
+|参数名称|支持版本|参数含义|
+|-----------------|----------|-|
+|logDir           |          |日志文件目录，运行日志将写入该目录，缺省值：/var/log/taos|
+|minimalLogDirGB  |          |日志文件夹所在磁盘可用空间大小小于该值时，停止写日志，单位 GB，缺省值：1|
+|numOfLogLines    |          |单个日志文件允许的最大行数，缺省值：10,000,000|
+|asyncLog         |          |日志写入模式，0：同步，1：异步，缺省值：1|
+|logKeepDays      |          |日志文件的最长保存时间，单位：天，缺省值：0，意味着无限保存，日志文件不会被重命名，也不会有新的日志文件滚动产生，但日志文件的内容有可能会不断滚动，取决于日志文件大小的设置；当设置为大于 0 的值时，当日志文件大小达到设置的上限时会被重命名为 taoslogx.yyy，其中 yyy 为日志文件最后修改的时间戳，并滚动产生新的日志文件|
+|debugFlag        |          |运行日志开关，131（输出错误和警告日志），135（输出错误、警告和调试日志），143（输出错误、警告、调试和跟踪日志）；默认值 131 或 135 （取决于不同模块）|
+|tmrDebugFlag     |          |定时器模块的日志开关，取值范围同上|
+|uDebugFlag       |          |共用功能模块的日志开关，取值范围同上|
+|rpcDebugFlag     |          |rpc 模块的日志开关，取值范围同上|
+|jniDebugFlag     |          |jni 模块的日志开关，取值范围同上|
+|qDebugFlag       |          |query 模块的日志开关，取值范围同上|
+|cDebugFlag       |          |客户端模块的日志开关，取值范围同上|
+|simDebugFlag     |          |内部参数，测试工具的日志开关，取值范围同上|
+|tqClientDebugFlag|3.3.4.3 后|客户端模块的日志开关，取值范围同上|
+
+### 调试相关
+|参数名称|支持版本|参数含义|
+|-----------------|-----------|-|
+|crashReporting   |          |是否上传 crash 到 telemetry，0：不上传，1：上传；缺省值：1|
+|enableCoreFile   |          |crash 时是否生成 core 文件，0：不生成，1：生成；缺省值：1|
+|assert           |          |断言控制开关，缺省值：0|
+|configDir        |          |配置文件所在目录|
+|scriptDir        |          |内部参数，测试用例的目录|
+|randErrorChance  |3.3.3.0 后|内部参数，用于随机失败测试|
+|randErrorDivisor |3.3.3.0 后|内部参数，用于随机失败测试|
+|randErrorScope   |3.3.3.0 后|内部参数，用于随机失败测试|
+|safetyCheckLevel |3.3.3.0 后|内部参数，用于随机失败测试|
+|simdEnable       |3.3.4.3 后|内部参数，用于测试 SIMD 加速|
+|AVX512Enable     |3.3.4.3 后|内部参数，用于测试 AVX512 加速|
+
+### SHELL 相关
+|参数名称|支持版本|参数含义|
+|-----------------|----------|-|
+|enableScience    |          |是否开启科学计数法显示浮点数；0：不开始，1：开启；缺省值：1|
 
 ## API
 

docs/zh/14-reference/03-taos-sql/02-database.md

@@ -43,7 +43,7 @@ database_option: {
 
 - VGROUPS：数据库中初始 vgroup 的数目。
 - PRECISION：数据库的时间戳精度。ms 表示毫秒，us 表示微秒，ns 表示纳秒，默认 ms 毫秒。
-- REPLICA：表示数据库副本数，取值为 1、2 或 3，默认为 1; 2 仅在企业版 3.3.0.0 及以后版本中可用。在集群中使用，副本数必须小于或等于 DNODE 的数目。且使用时存在以下限制： 
+- REPLICA：表示数据库副本数，取值为 1、2 或 3，默认为 1; 2 仅在企业版 3.3.0.0 及以后版本中可用。在集群中使用，副本数必须小于或等于 DNODE 的数目。且使用时存在以下限制：
   - 暂不支持对双副本数据库相关 Vgroup 进行 SPLITE VGROUP 或 REDISTRIBUTE VGROUP 操作
   - 单副本数据库可变更为双副本数据库，但不支持从双副本变更为其它副本数，也不支持从三副本变更为双副本
 - BUFFER: 一个 VNODE 写入内存池大小，单位为 MB，默认为 256，最小为 3，最大为 16384。
@@ -63,7 +63,8 @@ database_option: {
 - DURATION：数据文件存储数据的时间跨度。可以使用加单位的表示形式，如 DURATION 100h、DURATION 10d 等，支持 m（分钟）、h（小时）和 d（天）三个单位。不加时间单位时默认单位为天，如 DURATION 50 表示 50 天。
 - MAXROWS：文件块中记录的最大条数，默认为 4096 条。
 - MINROWS：文件块中记录的最小条数，默认为 100 条。
-- KEEP：表示数据文件保存的天数，缺省值为 3650，取值范围 [1, 365000]，且必须大于或等于3倍的 DURATION 参数值。数据库会自动删除保存时间超过 KEEP 值的数据。KEEP 可以使用加单位的表示形式，如 KEEP 100h、KEEP 10d 等，支持 m（分钟）、h（小时）和 d（天）三个单位。也可以不写单位，如 KEEP 50，此时默认单位为天。企业版支持[多级存储](https://docs.taosdata.com/tdinternal/arch/#%E5%A4%9A%E7%BA%A7%E5%AD%98%E5%82%A8)功能, 因此, 可以设置多个保存时间（多个以英文逗号分隔，最多 3 个，满足 keep 0 \<= keep 1 \<= keep 2，如 KEEP 100h,100d,3650d）; 社区版不支持多级存储功能（即使配置了多个保存时间, 也不会生效, KEEP 会取最大的保存时间）。
+- KEEP：表示数据文件保存的天数，缺省值为 3650，取值范围 [1, 365000]，且必须大于或等于3倍的 DURATION 参数值。数据库会自动删除保存时间超过 KEEP 值的数据。KEEP 可以使用加单位的表示形式，如 KEEP 100h、KEEP 10d 等，支持 m（分钟）、h（小时）和 d（天）三个单位。也可以不写单位，如 KEEP 50，此时默认单位为天。企业版支持[多级存储](https://docs.taosdata.com/tdinternal/arch/#%E5%A4%9A%E7%BA%A7%E5%AD%98%E5%82%A8)功能, 因此, 可以设置多个保存时间（多个以英文逗号分隔，最多 3 个，满足 keep 0 \<= keep 1 \<= keep 2，如 KEEP 100h,100d,3650d）; 社区版不支持多级存储功能（即使配置了多个保存时间, 也不会生效, KEEP 会取最大的保存时间）。了解更多，请点击 [关于主键时间戳](https://docs.taosdata.com/reference/taos-sql/insert/#%E5%85%B3%E4%BA%8E%E4%B8%BB%E9%94%AE%E6%97%B6%E9%97%B4%E6%88%B3)。
+
 - STT_TRIGGER：表示落盘文件触发文件合并的个数。开源版本固定为 1，企业版本可设置范围为 1 到 16。对于少表高频写入场景，此参数建议使用默认配置；而对于多表低频写入场景，此参数建议配置较大的值。
 - SINGLE_STABLE：表示此数据库中是否只可以创建一个超级表，用于超级表列非常多的情况。
   - 0：表示可以创建多张超级表。
@@ -78,6 +79,7 @@ database_option: {
 - WAL_FSYNC_PERIOD：当 WAL_LEVEL 参数设置为 2 时，用于设置落盘的周期。默认为 3000，单位毫秒。最小为 0，表示每次写入立即落盘；最大为 180000，即三分钟。
 - WAL_RETENTION_PERIOD: 为了数据订阅消费，需要 WAL 日志文件额外保留的最大时长策略。WAL 日志清理，不受订阅客户端消费状态影响。单位为 s。默认为 3600，表示在 WAL 保留最近 3600 秒的数据，请根据数据订阅的需要修改这个参数为适当值。
 - WAL_RETENTION_SIZE：为了数据订阅消费，需要 WAL 日志文件额外保留的最大累计大小策略。单位为 KB。默认为 0，表示累计大小无上限。
+
 ### 创建数据库示例
 
 ```sql
@@ -88,7 +90,7 @@ create database if not exists db vgroups 10 buffer 10
 
 ### 使用数据库
 
-```
+```sql
 USE db_name;
 ```
 
@@ -96,7 +98,7 @@ USE db_name;
 
 ## 删除数据库
 
-```
+```sql
 DROP DATABASE [IF EXISTS] db_name
 ```
 
@@ -126,7 +128,7 @@ alter_database_option: {
 }
 ```
 
-###  修改 CACHESIZE
+### 修改 CACHESIZE
 
 修改数据库参数的命令使用简单，难的是如何确定是否需要修改以及如何修改。本小节描述如何判断数据库的 cachesize 是否够用。
 
@@ -155,13 +157,13 @@ alter_database_option: {
 
 ### 查看系统中的所有数据库
 
-```
+```sql
 SHOW DATABASES;
 ```
 
 ### 显示一个数据库的创建语句
 
-```
+```sql
 SHOW CREATE DATABASE db_name \G;
 ```
 
@@ -189,23 +191,23 @@ TRIM DATABASE db_name;
 FLUSH DATABASE db_name;
 ```
 
-落盘内存中的数据。在关闭节点之前，执行这条命令可以避免重启后的数据回放，加速启动过程。
+落盘内存中的数据。在关闭节点之前，执行这条命令可以避免重启后的预写数据日志回放，加速启动过程。
 
-## 调整VGROUP中VNODE的分布
+## 调整 VGROUP 中 VNODE 的分布
 
 ```sql
 REDISTRIBUTE VGROUP vgroup_no DNODE dnode_id1 [DNODE dnode_id2] [DNODE dnode_id3]
 ```
 
-按照给定的dnode列表，调整vgroup中的vnode分布。因为副本数目最大为3，所以最多输入3个dnode。
+按照给定的 dnode 列表，调整 vgroup 中的 vnode 分布。因为副本数目最大为 3，所以最多输入 3 个 dnode。
 
-## 自动调整VGROUP中VNODE的分布
+## 自动调整 VGROUP 中 LEADER 的分布
 
 ```sql
-BALANCE VGROUP
+BALANCE VGROUP LEADER
 ```
 
-自动调整集群所有vgroup中的vnode分布，相当于在vnode级别对集群进行数据的负载均衡操作。
+触发集群所有 vgroup 中的 leader 重新选主，对集群各节点进行负载再均衡操作。
 
 ## 查看数据库工作状态
 

docs/zh/14-reference/03-taos-sql/03-table.md

@@ -227,7 +227,7 @@ DROP TABLE [IF EXISTS] [db_name.]tb_name [, [IF EXISTS] [db_name.]tb_name] ...
 如下 SQL 语句可以列出当前数据库中的所有表名。
 
 ```sql
-SHOW TABLES [LIKE tb_name_wildchar];
+SHOW TABLES [LIKE tb_name_wildcard];
 ```
 
 ### 显示表创建语句

docs/zh/14-reference/03-taos-sql/05-insert.md

@@ -5,9 +5,11 @@ description: 写入数据的详细语法
 ---
 
 ## 写入语法
+
 写入记录支持两种语法, 正常语法和超级表语法. 正常语法下, 紧跟INSERT INTO后名的表名是子表名或者普通表名. 超级表语法下, 紧跟INSERT INTO后名的表名是超级表名
 
 ### 正常语法
+
 ```sql
 INSERT INTO
     tb_name
@@ -22,7 +24,9 @@ INSERT INTO
 
 INSERT INTO tb_name [(field1_name, ...)] subquery
 ```
+
 ### 超级表语法
+
 ```sql
 INSERT INTO
     stb1_name [(field1_name, ...)]
@@ -32,16 +36,18 @@ INSERT INTO
     ...];
 ```
 
-**关于时间戳**
+#### 关于主键时间戳
 
-1. TDengine 要求插入的数据必须要有时间戳，插入数据的时间戳要注意以下几点：
+TDengine 要求插入的数据必须要有时间戳，插入数据的时间戳要注意以下几点：
 
-2. 时间戳不同的格式语法会有不同的精度影响。字符串格式的时间戳写法不受所在 DATABASE 的时间精度设置影响；而长整形格式的时间戳写法会受到所在 DATABASE 的时间精度设置影响。例如，时间戳"2021-07-13 16:16:48"的 UNIX 秒数为 1626164208。则其在毫秒精度下需要写作 1626164208000，在微秒精度设置下就需要写为 1626164208000000，纳秒精度设置下需要写为 1626164208000000000。
+1. 时间戳不同的格式语法会有不同的精度影响。字符串格式的时间戳写法不受所在 DATABASE 的时间精度设置影响；而长整形格式的时间戳写法会受到所在 DATABASE 的时间精度设置影响。例如，时间戳"2021-07-13 16:16:48"的 UNIX 秒数为 1626164208。则其在毫秒精度下需要写作 1626164208000，在微秒精度设置下就需要写为 1626164208000000，纳秒精度设置下需要写为 1626164208000000000。
 
-3. 一次插入多行数据时，不要把首列的时间戳的值都写 NOW。否则会导致语句中的多条记录使用相同的时间戳，于是就可能出现相互覆盖以致这些数据行无法全部被正确保存。其原因在于，NOW 函数在执行中会被解析为所在 SQL 语句的客户端执行时间，出现在同一语句中的多个 NOW 标记也就会被替换为完全相同的时间戳取值。
-   允许插入的最老记录的时间戳，是相对于当前服务器时间，减去配置的 KEEP 值（数据保留的天数, 可以在创建数据库时指定，缺省值是 3650 天）。允许插入的最新记录的时间戳，取决于数据库的 PRECISION 值（时间戳精度, 可以在创建数据库时指定, ms 表示毫秒，us 表示微秒，ns 表示纳秒，默认毫秒）：如果是毫秒或微秒, 取值为 1970 年 1 月 1 日 00:00:00.000 UTC 加上 1000 年, 即 2970 年 1 月 1 日 00:00:00.000 UTC; 如果是纳秒, 取值为 1970 年 1 月 1 日 00:00:00.000000000 UTC 加上 292 年, 即 2262 年 1 月 1 日 00:00:00.000000000 UTC。
+2. 一次插入多行数据时，不要把首列的时间戳的值都写 NOW。否则会导致语句中的多条记录使用相同的时间戳，于是就可能出现相互覆盖以致这些数据行无法全部被正确保存。其原因在于，NOW 函数在执行中会被解析为所在 SQL 语句的客户端执行时间，出现在同一语句中的多个 NOW 标记也就会被替换为完全相同的时间戳取值。
 
-**语法说明**
+3. 允许插入的最大时间戳为当前时间加上 100 年, 比如当前时间为`2024-11-11 12:00:00`，则允许插入的最大时间戳为`2124-11-11 12:00:00`。允许插入的最小时间戳取决于数据库的 KEEP 设置。企业版支持三级存储，可以设置多个 KEEP 时间，如下图所示，如果数据库的 KEEP 配置为`100h,100d,3650d`，则允许的最小时间戳为当前时间减去 3650 天。那么时间戳在`[Now - 100h, Now + 100y)`内的会保存在一级存储，时间戳在`[Now - 100d, Now - 100h)`内的会保存在二级存储，时间戳在`[Now - 3650d, Now - 100d)`内的会保存在三级存储。社区版不支持多级存储功能，只能配置一个 KEEP 值，如果配置多个，则取其最大者。如果时间戳不在有效时间范围内，TDengine 将返回错误“Timestamp out of range"。
+![Keep timerange 示意图](./pic/database-keep.jpg)
+
+#### 语法说明
 
 1. 可以指定要插入值的列，对于未指定的列数据库将自动填充为 NULL。
 
@@ -56,22 +62,24 @@ INSERT INTO
    ```sql
    INSERT INTO d1001 USING meters TAGS('Beijing.Chaoyang', 2) VALUES('a');
    ```
+
 6. 对于向多个子表插入数据的情况，依然会有部分数据写入失败，部分数据写入成功的情况。这是因为多个子表可能分布在不同的 VNODE 上，客户端将 INSERT 语句完整解析后，将数据发往各个涉及的 VNODE 上，每个 VNODE 独立进行写入操作。如果某个 VNODE 因为某些原因（比如网络问题或磁盘故障）导致写入失败，并不会影响其他 VNODE 节点的写入。
 7. 主键列值必须指定且不能为 NULL。
 
-**正常语法说明**
+#### 正常语法说明
 
 1. USING 子句是自动建表语法。如果用户在写数据时并不确定某个表是否存在，此时可以在写入数据时使用自动建表语法来创建不存在的表，若该表已存在则不会建立新表。自动建表时，要求必须以超级表为模板，并写明数据表的 TAGS 取值。可以只是指定部分 TAGS 列的取值，未被指定的 TAGS 列将置为 NULL。
 
 2. 可以使用 `INSERT ... subquery` 语句将 TDengine 中的数据插入到指定表中。subquery 可以是任意的查询语句。此语法只能用于子表和普通表，且不支持自动建表。
 
-**超级表语法说明**
+#### 超级表语法说明
 
 1. 在 field_name 列表中必须指定 tbname 列，否则报错. tbname列是子表名, 类型是字符串. 其中字符不用转义, 不能包含点‘.‘
 
 2. 在 field_name 列表中支持标签列，当子表已经存在时，指定标签值并不会触发标签值的修改；当子表不存在时会使用所指定的标签值建立子表. 如果没有指定任何标签列，则把所有标签列的值设置为NULL
 
 3. 不支持参数绑定写入
+
 ## 插入一条记录
 
 指定已经创建好的数据子表的表名，并通过 VALUES 关键字提供一行或多行数据，即可向数据库写入这些数据。例如，执行如下语句可以写入一行记录：
@@ -154,15 +162,18 @@ INSERT INTO d21001 USING meters TAGS ('California.SanFrancisco', 2) FILE '/tmp/c
 INSERT INTO d21001 USING meters TAGS ('California.SanFrancisco', 2) FILE '/tmp/csvfile_21001.csv'
             d21002 USING meters (groupId) TAGS (2) FILE '/tmp/csvfile_21002.csv';
 ```
+
 ## 向超级表插入数据并自动创建子表
 
 自动建表, 表名通过 tbname 列指定
+
 ```sql
 INSERT INTO meters(tbname, location, groupId, ts, current, voltage, phase)
                 VALUES ('d31001', 'California.SanFrancisco', 2, '2021-07-13 14:06:34.630', 10.2, 219, 0.32)
                 ('d31001', 'California.SanFrancisco', 2, '2021-07-13 14:06:35.779', 10.15, 217, 0.33)
                 ('d31002', NULL, 2, '2021-07-13 14:06:34.255', 10.15, 217, 0.33)
 ```
+
 ## 通过 CSV 文件向超级表插入数据并自动创建子表
 
 根据 csv 文件内容，为 超级表创建子表，并填充相应 column 与 tag

docs/zh/14-reference/03-taos-sql/10-function.md

@@ -1988,7 +1988,7 @@ TOP(expr, k)
 UNIQUE(expr)
 ```
 
-**功能说明**：返回该列数据首次出现的值。该函数功能与 distinct 相似。对于存在复合主键的表的查询，若最小时间戳的数据有多条，则只有对应的复合主键最小的数据被返回。
+**功能说明**：返回该列数据去重后的值。该函数功能与 distinct 相似。对于相同的数据，返回时间戳最小的一条，对于存在复合主键的表的查询，若最小时间戳的数据有多条，则只有对应的复合主键最小的数据被返回。
 
 **返回数据类型**：同应用的字段。
 

docs/zh/14-reference/03-taos-sql/20-keywords.md

@@ -11,337 +11,470 @@ description: TDengine 保留关键字的详细列表
 关键字列表如下：
 
 ### A
-
-- ABORT
-- ACCOUNT
-- ACCOUNTS
-- ADD
-- AFTER
-- AGGREGATE
-- ALIVE
-- ALL
-- ALTER
-- ANALYZE
-- AND
-- APPS
-- AS
-- ASC
-- AT_ONCE
-- ATTACH
+|关键字|说明|
+|----------------------|-|
+| ABORT                | |
+| ACCOUNT              | |
+| ACCOUNTS             | |
+| ADD                  | |
+| AFTER                | |
+| AGGREGATE            | |
+| ALIAS                | |
+| ALIVE                | |
+| ALL                  | |
+| ALTER                | |
+| ANALYZE              | 3.3.4.3 及后续版本 |
+| AND                  | |
+| ANODE                | 3.3.4.3 及后续版本 |
+| ANODES               | 3.3.4.3 及后续版本 |
+| ANOMALY_WINDOW       | 3.3.4.3 及后续版本 |
+| ANTI                 | |
+| APPS                 | |
+| ARBGROUPS            | |
+| ARROW                | |
+| AS                   | |
+| ASC                  | |
+| ASOF                 | |
+| AT_ONCE              | |
+| ATTACH               | |
 
 ### B
-
-- BALANCE
-- BEFORE
-- BEGIN
-- BETWEEN
-- BIGINT
-- BINARY
-- BITAND
-- BITNOT
-- BITOR
-- BLOCKS
-- BNODE
-- BNODES
-- BOOL
-- BUFFER
-- BUFSIZE
-- BY
+|关键字|说明|
+|----------------------|-|
+| BALANCE              | |
+| BEFORE               | |
+| BEGIN                | |
+| BETWEEN              | |
+| BIGINT               | |
+| BIN                  | |
+| BINARY               | |
+| BITAND               | |
+| BITAND               | |
+| BITNOT               | |
+| BITOR                | |
+| BLOB                 | |
+| BLOCKS               | |
+| BNODE                | |
+| BNODES               | |
+| BOOL                 | |
+| BOTH                 | |
+| BUFFER               | |
+| BUFSIZE              | |
+| BWLIMIT              | |
+| BY                   | |
 
 ### C
-
-- CACHE
-- CACHEMODEL
-- CACHESIZE
-- CASCADE
-- CAST
-- CHANGE
-- CLIENT_VERSION
-- CLUSTER
-- COLON
-- COLUMN
-- COMMA
-- COMMENT
-- COMP
-- COMPACT
-- CONCAT
-- CONFLICT
-- CONNECTION
-- CONNECTIONS
-- CONNS
-- CONSUMER
-- CONSUMERS
-- CONTAINS
-- COPY
-- COUNT
-- CREATE
-- CURRENT_USER
+|关键字|说明|
+|----------------------|-|
+| CACHE                | |
+| CACHEMODEL           | |
+| CACHESIZE            | |
+| CASE                 | |
+| CAST                 | |
+| CHANGE               | |
+| CHILD                | |
+| CLIENT_VERSION       | |
+| CLUSTER              | |
+| COLON                | |
+| COLUMN               | |
+| COMMA                | |
+| COMMENT              | |
+| COMP                 | |
+| COMPACT              | |
+| COMPACTS             | |
+| CONCAT               | |
+| CONFLICT             | |
+| CONNECTION           | |
+| CONNECTIONS          | |
+| CONNS                | |
+| CONSUMER             | |
+| CONSUMERS            | |
+| CONTAINS             | |
+| COPY                 | |
+| COUNT                | |
+| COUNT_WINDOW         | |
+| CREATE               | |
+| CREATEDB             | |
+| CURRENT_USER         | |
 
 ### D
-
-- DATABASE
-- DATABASES
-- DBS
-- DEFERRED
-- DELETE
-- DELIMITERS
-- DESC
-- DESCRIBE
-- DETACH
-- DISTINCT
-- DISTRIBUTED
-- DIVIDE
-- DNODE
-- DNODES
-- DOT
-- DOUBLE
-- DROP
-- DURATION
+|关键字|说明|
+|----------------------|-|
+| DATABASE             | |
+| DATABASES            | |
+| DBS                  | |
+| DECIMAL              | |
+| DEFERRED             | |
+| DELETE               | |
+| DELETE_MARK          | |
+| DELIMITERS           | |
+| DESC                 | |
+| DESCRIBE             | |
+| DETACH               | |
+| DISTINCT             | |
+| DISTRIBUTED          | |
+| DIVIDE               | |
+| DNODE                | |
+| DNODES               | |
+| DOT                  | |
+| DOUBLE               | |
+| DROP                 | |
+| DURATION             | |
 
 ### E
-
-- EACH
-- ENABLE
-- END
-- EVERY
-- EXISTS
-- EXPIRED
-- EXPLAIN
+|关键字|说明|
+|----------------------|-|
+| EACH                 | |
+| ELSE                 | |
+| ENABLE               | |
+| ENCRYPT_ALGORITHM    | |
+| ENCRYPT_KEY          | |
+| ENCRYPTIONS          | |
+| END                  | |
+| EQ                   | |
+| EVENT_WINDOW         | |
+| EVERY                | |
+| EXCEPT               | |
+| EXISTS               | |
+| EXPIRED              | |
+| EXPLAIN              | |
 
 ### F
-
-- FAIL
-- FILE
-- FILL
-- FIRST
-- FLOAT
-- FLUSH
-- FOR
-- FROM
-- FUNCTION
-- FUNCTIONS
+|关键字|说明|
+|----------------------|-|
+| FAIL                 | |
+| FHIGH                | 3.3.4.3 及后续版本 |
+| FILE                 | |
+| FILL                 | |
+| FILL_HISTORY         | |
+| FIRST                | |
+| FLOAT                | |
+| FLOW                 | 3.3.4.3 及后续版本 |
+| FLUSH                | |
+| FOR                  | |
+| FORCE                | |
+| FORCE_WINDOW_CLOSE   | 3.3.4.3 及后续版本 |
+| FROM                 | |
+| FROWTS               | 3.3.4.3 及后续版本 |
+| FULL                 | |
+| FUNCTION             | |
+| FUNCTIONS            | |
 
 ### G
-
-- GLOB
-- GRANT
-- GRANTS
-- GROUP
+|关键字|说明|
+|----------------------|-|
+| GE                   | |
+| GEOMETRY             | |
+| GLOB                 | |
+| GRANT                | |
+| GRANTS               | |
+| GROUP                | |
+| GT                   | |
 
 ### H
-
-- HAVING
-- HOST
+|关键字|说明|
+|----------------------|-|
+| HAVING               | |
+| HEX                  | |
+| HOST                 | |
 
 ### I
-
-- ID
-- IF
-- IGNORE
-- IMMEDIATE
-- IMPORT
-- IN
-- INDEX
-- INDEXES
-- INITIALLY
-- INNER
-- INSERT
-- INSTEAD
-- INT
-- INTEGER
-- INTERVAL
-- INTO
-- IS
-- IS NULL
+|关键字|说明|
+|----------------------|-|
+| ID                   | |
+| IF                   | |
+| IGNORE               | |
+| ILLEGAL              | |
+| IMMEDIATE            | |
+| IMPORT               | |
+| IN                   | |
+| INDEX                | |
+| INDEXES              | |
+| INITIALLY            | |
+| INNER                | |
+| INSERT               | |
+| INSTEAD              | |
+| INT                  | |
+| INTEGER              | |
+| INTERSECT            | |
+| INTERVAL             | |
+| INTO                 | |
+| IPTOKEN              | |
+| IROWTS               | |
+| IS                   | |
+| IS_IMPORT            | |
+| ISFILLED             | |
+| ISNULL               | |
 
 ### J
-
-- JOIN
-- JSON
+|关键字|说明|
+|----------------------|-|
+| JLIMIT               | |
+| JOIN                 | |
+| JSON                 | |
 
 ### K
-
-- KEEP
-- KEY
-- KILL
+|关键字|说明|
+|----------------------|-|
+| KEEP                 | |
+| KEEP_TIME_OFFSET     | |
+| KEY                  | |
+| KILL                 | |
 
 ### L
-
-- LAST
-- LAST_ROW
-- LICENCES
-- LIKE
-- LIMIT
-- LINEAR
-- LOCAL
+|关键字|说明|
+|----------------------|-|
+| LANGUAGE             | |
+| LAST                 | |
+| LAST_ROW             | |
+| LE                   | |
+| LEADER               | |
+| LEADING              | |
+| LEFT                 | |
+| LICENCES             | |
+| LIKE                 | |
+| LIMIT                | |
+| LINEAR               | |
+| LOCAL                | |
+| LOGS                 | |
+| LP                   | |
+| LSHIFT               | |
+| LT                   | |
 
 ### M
-
-- MATCH
-- MAX_DELAY
-- BWLIMIT
-- MAXROWS
-- MAX_SPEED
-- MERGE
-- META
-- MINROWS
-- MINUS
-- MNODE
-- MNODES
-- MODIFY
-- MODULES
+|关键字|说明|
+|----------------------|-|
+| MACHINES             | |
+| MATCH                | |
+| MAX_DELAY            | |
+| MAXROWS              | |
+| MEDIUMBLOB           | |
+| MERGE                | |
+| META                 | |
+| MINROWS              | |
+| MINUS                | |
+| MNODE                | |
+| MNODES               | |
+| MODIFY               | |
+| MODULES              | |
 
 ### N
-
-- NCHAR
-- NEXT
-- NMATCH
-- NONE
-- NOT
-- NOT NULL
-- NOW
-- NULL
-- NULLS
+|关键字|说明|
+|----------------------|-|
+| NCHAR                | |
+| NE                   | |
+| NEXT                 | |
+| NMATCH               | |
+| NONE                 | |
+| NORMAL               | |
+| NOT                  | |
+| NOTNULL              | |
+| NOW                  | |
+| NULL                 | |
+| NULL_F               | |
+| NULLS                | |
 
 ### O
-
-- OF
-- OFFSET
-- ON
-- OR
-- ORDER
-- OUTPUTTYPE
+|关键字|说明|
+|----------------------|-|
+| OF                   | |
+| OFFSET               | |
+| ON                   | |
+| ONLY                 | |
+| OR                   | |
+| ORDER                | |
+| OUTER                | |
+| OUTPUTTYPE           | |
 
 ### P
-
-- PAGES
-- PAGESIZE
-- PARTITIONS
-- PASS
-- PLUS
-- PORT
-- PPS
-- PRECISION
-- PREV
-- PRIVILEGE
+|关键字|说明|
+|----------------------|-|
+| PAGES                | |
+| PAGESIZE             | |
+| PARTITION            | |
+| PASS                 | |
+| PAUSE                | |
+| PI                   | |
+| PLUS                 | |
+| PORT                 | |
+| POSITION             | |
+| PPS                  | |
+| PRECISION            | |
+| PREV                 | |
+| PRIMARY              | |
+| PRIVILEGE            | |
+| PRIVILEGES           | |
 
 ### Q
-
-- QNODE
-- QNODES
-- QTIME
-- QUERIES
-- QUERY
+|关键字|说明|
+|----------------------|-|
+| QDURATION            | |
+| QEND                 | |
+| QNODE                | |
+| QNODES               | |
+| QSTART               | |
+| QTAGS                | |
+| QTIME                | |
+| QUERIES              | |
+| QUERY                | |
+| QUESTION             | |
 
 ### R
-
-- RAISE
-- RANGE
-- RATIO
-- READ
-- REDISTRIBUTE
-- RENAME
-- REPLACE
-- REPLICA
-- RESET
-- RESTRICT
-- RETENTIONS
-- REVOKE
-- ROLLUP
-- ROW
+|关键字|说明|
+|----------------------|-|
+| RAISE                | |
+| RAND                 | |
+| RANGE                | |
+| RATIO                | |
+| READ                 | |
+| RECURSIVE            | |
+| REDISTRIBUTE         | |
+| REM                  | |
+| REPLACE              | |
+| REPLICA              | |
+| RESET                | |
+| RESTORE              | |
+| RESTRICT             | |
+| RESUME               | |
+| RETENTIONS           | |
+| REVOKE               | |
+| RIGHT                | |
+| ROLLUP               | |
+| ROW                  | |
+| ROWTS                | |
+| RP                   | |
+| RSHIFT               | |
 
 ### S
-
-- SCHEMALESS
-- SCORES
-- SELECT
-- SEMI
-- SERVER_STATUS
-- SERVER_VERSION
-- SESSION
-- SET
-- SHOW
-- SINGLE_STABLE
-- SLIDING
-- SLIMIT
-- SMA
-- SMALLINT
-- SNODE
-- SNODES
-- SOFFSET
-- SPLIT
-- STABLE
-- STABLES
-- START
-- STATE
-- STATE_WINDOW
-- STATEMENT
-- STORAGE
-- STREAM
-- STREAMS
-- STRICT
-- STRING
-- SUBSCRIPTIONS
-- SYNCDB
-- SYSINFO
+|关键字|说明|
+|----------------------|-|
+| S3_CHUNKPAGES        | |
+| S3_COMPACT           | |
+| S3_KEEPLOCAL         | |
+| SCHEMALESS           | |
+| SCORES               | |
+| SELECT               | |
+| SEMI                 | |
+| SERVER_STATUS        | |
+| SERVER_VERSION       | |
+| SESSION              | |
+| SET                  | |
+| SHOW                 | |
+| SINGLE_STABLE        | |
+| SLASH                | |
+| SLIDING              | |
+| SLIMIT               | |
+| SMA                  | |
+| SMALLINT             | |
+| SMIGRATE             | |
+| SNODE                | |
+| SNODES               | |
+| SOFFSET              | |
+| SPLIT                | |
+| STABLE               | |
+| STABLES              | |
+| STAR                 | |
+| START                | |
+| STATE                | |
+| STATE_WINDOW         | |
+| STATEMENT            | |
+| STORAGE              | |
+| STREAM               | |
+| STREAMS              | |
+| STRICT               | |
+| STRING               | |
+| STT_TRIGGER          | |
+| SUBSCRIBE            | |
+| SUBSCRIPTIONS        | |
+| SUBSTR               | |
+| SUBSTRING            | |
+| SUBTABLE             | |
+| SYSINFO              | |
+| SYSTEM               | |
 
 ### T
-
-- TABLE
-- TABLES
-- TAG
-- TAGS
-- TBNAME
-- TIMES
-- TIMESTAMP
-- TIMEZONE
-- TINYINT
-- TO
-- TODAY
-- TOPIC
-- TOPICS
-- TRANSACTION
-- TRANSACTIONS
-- TRIGGER
-- TRIM
-- TSERIES
-- TTL
+|关键字|说明|
+|----------------------|-|
+| TABLE                | |
+| TABLE_PREFIX         | |
+| TABLE_SUFFIX         | |
+| TABLES               | |
+| TAG                  | |
+| TAGS                 | |
+| TBNAME               | |
+| THEN                 | |
+| TIMES                | |
+| TIMESTAMP            | |
+| TIMEZONE             | |
+| TINYINT              | |
+| TO                   | |
+| TODAY                | |
+| TOPIC                | |
+| TOPICS               | |
+| TRAILING             | |
+| TRANSACTION          | |
+| TRANSACTIONS         | |
+| TRIGGER              | |
+| TRIM                 | |
+| TSDB_PAGESIZE        | |
+| TSERIES              | |
+| TSMA                 | |
+| TSMAS                | |
+| TTL                  | |
 
 ### U
-
-- UNION
-- UNSIGNED
-- UPDATE
-- USE
-- USER
-- USERS
-- USING
+|关键字|说明|
+|----------------------|-|
+| UNION                | |
+| UNSAFE               | |
+| UNSIGNED             | |
+| UNTREATED            | |
+| UPDATE               | |
+| USE                  | |
+| USER                 | |
+| USERS                | |
+| USING                | |
 
 ### V
+|关键字|说明|
+|----------------------|-|
+| VALUE                | |
+| VALUE_F              | |
+| VALUES               | |
+| VARBINARY            | |
+| VARCHAR              | |
+| VARIABLE             | |
+| VARIABLES            | |
+| VERBOSE              | |
+| VGROUP               | |
+| VGROUPS              | |
+| VIEW                 | |
+| VIEWS                | |
+| VNODE                | |
+| VNODES               | |
 
-- VALUE
-- VALUES
-- VARCHAR
-- VARIABLE
-- VARIABLES
-- VERBOSE
-- VGROUP
-- VGROUPS
-- VIEW
-- VNODES
 
 ### W
-
-- WAL
-- WAL_FSYNC_PERIOD
-- WAL_LEVEL
-- WAL_RETENTION_PERIOD
-- WAL_RETENTION_SIZE
-- WATERMARK
-- WHERE
-- WINDOW_CLOSE
-- WITH
-- WRITE
+|关键字|说明|
+|----------------------|-|
+| WAL                  | |
+| WAL_FSYNC_PERIOD     | |
+| WAL_LEVEL            | |
+| WAL_RETENTION_PERIOD | |
+| WAL_RETENTION_SIZE   | |
+| WAL_ROLL_PERIOD      | |
+| WAL_SEGMENT_SIZE     | |
+| WATERMARK            | |
+| WDURATION            | |
+| WEND                 | |
+| WHEN                 | |
+| WHERE                | |
+| WINDOW               | |
+| WINDOW_CLOSE         | |
+| WINDOW_OFFSET        | |
+| WITH                 | |
+| WRITE                | |
+| WSTART              | |
 
 ### \_
 

docs/zh/14-reference/03-taos-sql/32-compress.md

@@ -31,11 +31,12 @@ description: 可配置压缩算法
 
 | 数据类型 |   可选编码算法      |  编码算法默认值 | 可选压缩算法|压缩算法默认值| 压缩等级默认值|
 | :-----------:|:----------:|:-------:|:-------:|:----------:|:----:|
-|  tinyint/untinyint/smallint/usmallint/int/uint | simple8b| simple8b | lz4/zlib/zstd/xz| lz4 | medium|
-|   bigint/ubigint/timestamp   |  simple8b/delta-i    | delta-i |lz4/zlib/zstd/xz | lz4| medium|
+|  int/uint | simple8b| simple8b | lz4/zlib/zstd/xz| lz4 | medium|
+|  tinyint/untinyint/smallint/usmallint | simple8b| simple8b | lz4/zlib/zstd/xz| zlib | medium|
+|  bigint/ubigint/timestamp   |  simple8b/delta-i    | delta-i |lz4/zlib/zstd/xz | lz4| medium|
 |float/double | delta-d|delta-d |lz4/zlib/zstd/xz/tsz|lz4| medium|
-|binary/nchar| disabled| disabled|lz4/zlib/zstd/xz| lz4| medium|
-|bool| bit-packing| bit-packing| lz4/zlib/zstd/xz| lz4| medium|
+|binary/nchar| disabled| disabled|lz4/zlib/zstd/xz| zstd| medium|
+|bool| bit-packing| bit-packing| lz4/zlib/zstd/xz| zstd| medium|
 
 ## SQL 语法
 

docs/zh/26-tdinternal/01-arch.md

@@ -293,6 +293,14 @@ TDengine 采纳了一种独特的时间驱动缓存管理策略，亦称为写
 
 此外，考虑到物联网数据的特点，用户通常最关注的是数据的实时性，即最新产生的数据。TDengine 很好地利用了这一特点，优先将最新到达的（即当前状态）数据存储在缓存中。具体而言，TDengine 会将最新到达的数据直接存入缓存，以便快速响应用户对最新一条或多条数据的查询和分析需求，从而在整体上提高数据库查询的响应速度。从这个角度来看，通过合理设置数据库参数，TDengine 完全可以作为数据缓存来使用，这样就无须再部署 Redis 或其他额外的缓存系统。这种做法不仅有效简化了系统架构，还有助于降低运维成本。需要注意的是，一旦 TDengine 重启，缓存中的数据将被清除，所有先前缓存的数据都会被批量写入硬盘，而不会像专业的 Key-Value 缓存系统那样自动将之前缓存的数据重新加载回缓存。
 
+### last/last_row 缓存
+
+在时序数据的场景中，查询表的最后一条记录（last_row）或最后一条非 NULL 记录（last）是一个常见的需求。为了提高 TDengine 对这种查询的响应速度，TSDB 为每张表的 last 和 last_row 数据提供了 LRU 缓存。LRU 缓存采用延迟加载策略，当首次查询某张表的 last 或 last_row 时，缓存模块会去内存池和磁盘文件加载数据，处理后放入LRU 缓存，并返回给查询模块继续处理；当有新的数据插入或删除时，如果缓存需要更新，会进行相应的更新操作；如果缓存中没有当前被写入表的数据，则直接跳过，无需其它操作。
+
+此外在缓存配置更新的时候，也会更新缓存数据。比如，缓存功能默认是关闭的，用户使用命令开启缓存功能之后，就会在首次查询时加载数据；当关闭缓存开关时，会释放之前的缓存区。当查询某一个子表的 last 或 last_row 数据时，如果缓存中没有，则从内存池和磁盘文件加载对应的 last 或 last_row 数据到缓存中；当查询某一个超级表的 last 或 last_row 数据时，这个超级表对应的所有子表都需要加载到缓存中。
+
+通过数据库参数 cachemodel 可以配置某一个数据库的缓存参数，默认值为 "none"，表示不开启缓存，另外三个值为 "last_row"，"last_value"，"both"；分别是开启 last_row 缓存，开启 last 缓存，和两个同时开启。缓存当前所使用的内存数量，可在通过 show vgroups; 命令，在 cacheload 列中进行查看，单位为字节。
+
 ### 持久化存储
 
 TDengine 采用了一种数据驱动的策略来实现缓存数据的持久化存储。当 vnode 中的缓存数据积累到一定量时，为了避免阻塞后续数据的写入，TDengine 会启动落盘线程，将这些缓存数据写入持久化存储设备。在此过程中，TDengine 会创建新的数据库日志文件用于数据落盘，并在落盘成功后删除旧的日志文件，以防止日志文件无限制增长。

docs/zh/28-releases/01-tdengine.md

@@ -24,6 +24,10 @@ TDengine 3.x 各版本安装包下载链接如下：
 
 import Release from "/components/ReleaseV3";
 
+## 3.3.4.3
+
+<Release type="tdengine" version="3.3.4.3" />
+
 ## 3.3.3.0
 
 <Release type="tdengine" version="3.3.3.0" />

docs/zh/28-releases/03-notes/3.3.4.3.md

@@ -0,0 +1,69 @@
+---
+title: 3.3.4.3 版本说明
+sidebar_label: 3.3.4.3
+description: 3.3.4.3 版本说明
+---
+
+### 行为变更及兼容性
+1. 多副本流计算中必须使用 snode
+1. 增加了流计算的兼容性保证机制，避免后续函数变更产生新的兼容性问题，但之前版本的流计算必须重建，具体参见 https://docs.taosdata.com/advanced/stream/#流计算升级故障恢复
+1. 调整 case when 语句结果类型的判断方法
+   
+### 新特性
+1. 新功能：流计算的 TWA 函数支持时间驱动的结果推送模式 
+1. 新功能：流计算的 Interp 函数支持时间驱动的结果推送模式 
+1. 新功能：支持微软对象存储 
+
+### 优化
+1.  优化：提升并发大查询时节点之间互相拉数据的效率 
+1.  优化：支持使用 AVX2 和 AVX512 对 double 、timestamp 和 bigint 类型进行解码优化 
+1.  优化：调整 case when 语句的结果类型判断方法 
+1.  优化：顺序执行 compact 和 split vgroup操作时的日志错误提示 
+1.  优化：提升查询 “select ... from ... where ts in (...)” 的数据扫描速度 
+1.  优化：增加了流计算的兼容性保证机制，避免后续函数变更产生新的兼容性问题，之前版本的流计算必须重建 
+1.  优化：提升 taosX 在交叉写入场景下的数据同步性能 
+1.  优化：支持关闭整数/浮点数类型的编码 
+1.  优化：多副本流计算中必须使用 snode 
+1.  优化：客户端生成唯一 ID 标识每一个查询任务，避免重复 ID 导致的内存损坏 
+1.  优化：加快数据库的创建时间 
+1.  优化：修改 s3MigrateEnabled 默认值为0 
+1.  优化：支持在审计数据库中记录删除操作 
+1.  优化：支持在指定的 dnode 中创建数据库 [企业版] 
+1.  优化：调整删除超级表数据列时的报错信息 
+
+### 修复
+1. 修复：last_row 查询性能在 3.3.3.0 中大幅下降的问题 
+1. 修复：WAL 条目不完整时 taosd 无法启动的问题 
+1. 修复: partition by 常量时查询结果错误的问题 
+1. 修复：标量函数包含 _wstart 且填充方式为 prev 时计算结果错误 
+1. 修复：Windows 平台下的时区设置问题 
+1. 修复：空数据库进行 compact 操作时，事务无法结束【企业版】 
+1. 修复：事务冲突的逻辑错误 
+1. 修复：管理节点某些错误会导致事务无法停止 
+1. 修复：管理节点某些错误会导致事务无法停止 
+1. 修复：dnode 数据清空后 taosc 重试错误的问题 
+1. 修复：Data Compact 被异常终止后，中间文件未被清理 
+1. 修复：新增列后，Kafka 连接器的 earliest 模式消费不到新列数据 
+1. 修复：interp 函数在 fill(prev) 时行为不正确 
+1. 修复：TSMA 在高频元数据操作时异常停止的问题 
+1. 修复：show create stable 语句执行结果的标签显示错误 
+1. 修复：Percentile 函数在大数据量查询时会崩溃。 
+1. 修复：partition by 和 having 联合使用时的语法错误问题 
+1. 修复：interp 在 partition by tbname,c1 时 tbname 为空的问题 
+1. 修复：通过 stmt 写入非法布尔数值时 taosd 可能 crash 
+1. 修复：库符号 version 与使用相同符号的库冲突的问题 
+1. 修复：在 windows 平台下 JDBC 驱动的句柄数持续升高问题 
+1. 修复：3.3.3.1 升级至 3.3.4.0 偶现的启动失败问题 
+1. 修复：Windows 平台重复增删表的内存泄漏 
+1. 修复：无法限制并发拉起 checkpoint 数量导致流计算消耗资源过多 
+1. 修复：并发查询时的 too many session 问题 
+1. 修复：Windows 平台下 taos shell 在慢查询场景中崩溃的问题 
+1. 修复：当打开 dnode日志时，加密数据库无法恢复的问题 
+1. 修复：由于 mnode 同步超时，进而导致 taosd 无法启动的问题 
+1. 修复：由于在快照同步过程中整理文件组数据的速度过慢，从而导致 Vnode（虚拟节点）无法恢复的问题 
+1. 修复：通过行协议向字符串类型的字段中写入带转义符的数据时，taosd 会崩溃 
+1. 修复：Error Code 逻辑处理错误导致的元数据文件损坏 
+1. 修复：查询语句中包含多个 “not” 条件语句嵌套时，未设置标量模式导致查询错误 
+1. 修复：vnode 统计信息上报超时导致的 dnode offline 问题 
+1. 修复：在不支持 avx 指令集的服务器上，taosd 启动失败问题 
+1. 修复：taosX 数据迁移容错处理 0x09xx 错误码 

docs/zh/28-releases/03-notes/index.md

@@ -3,5 +3,7 @@ title: 版本说明
 sidebar_label: 版本说明
 description: 各版本版本说明
 ---
+
+[3.3.4.3](./3.3.4.3)  
 [3.3.3.0](./3.3.3.0)  
 [3.3.2.0](./3.3.2.0)

include/common/tmsg.h

@@ -2187,8 +2187,9 @@ int32_t tSerializeSShowVariablesReq(void* buf, int32_t bufLen, SShowVariablesReq
 
 typedef struct {
   char name[TSDB_CONFIG_OPTION_LEN + 1];
-  char value[TSDB_CONFIG_VALUE_LEN + 1];
+  char value[TSDB_CONFIG_PATH_LEN + 1];
   char scope[TSDB_CONFIG_SCOPE_LEN + 1];
+  char info[TSDB_CONFIG_INFO_LEN + 1];
 } SVariablesInfo;
 
 typedef struct {
@@ -2307,6 +2308,7 @@ typedef struct {
 typedef struct {
   SExplainRsp rsp;
   uint64_t    qId;
+  uint64_t    cId;
   uint64_t    tId;
   int64_t     rId;
   int32_t     eId;
@@ -2660,6 +2662,7 @@ typedef struct SSubQueryMsg {
   SMsgHead header;
   uint64_t sId;
   uint64_t queryId;
+  uint64_t clientId;
   uint64_t taskId;
   int64_t  refId;
   int32_t  execId;
@@ -2689,6 +2692,7 @@ typedef struct {
   SMsgHead header;
   uint64_t sId;
   uint64_t queryId;
+  uint64_t clientId;
   uint64_t taskId;
   int32_t  execId;
 } SQueryContinueReq;
@@ -2723,6 +2727,7 @@ typedef struct {
   SMsgHead        header;
   uint64_t        sId;
   uint64_t        queryId;
+  uint64_t        clientId;
   uint64_t        taskId;
   int32_t         execId;
   SOperatorParam* pOpParam;
@@ -2738,6 +2743,7 @@ typedef struct {
 
 typedef struct {
   uint64_t queryId;
+  uint64_t clientId;
   uint64_t taskId;
   int64_t  refId;
   int32_t  execId;
@@ -2784,6 +2790,7 @@ typedef struct {
   SMsgHead header;
   uint64_t sId;
   uint64_t queryId;
+  uint64_t clientId;
   uint64_t taskId;
   int64_t  refId;
   int32_t  execId;
@@ -2797,6 +2804,7 @@ typedef struct {
   SMsgHead header;
   uint64_t sId;
   uint64_t queryId;
+  uint64_t clientId;
   uint64_t taskId;
   int64_t  refId;
   int32_t  execId;
@@ -2813,6 +2821,7 @@ typedef struct {
   SMsgHead        header;
   uint64_t        sId;
   uint64_t        queryId;
+  uint64_t        clientId;
   uint64_t        taskId;
   int64_t         refId;
   int32_t         execId;
@@ -4262,6 +4271,7 @@ typedef struct {
   SMsgHead header;
   uint64_t sId;
   uint64_t queryId;
+  uint64_t clientId;
   uint64_t taskId;
   uint32_t sqlLen;
   uint32_t phyLen;

include/common/ttime.h

@@ -62,7 +62,8 @@ static FORCE_INLINE int64_t taosGetTimestampToday(int32_t precision) {
   int64_t   factor = (precision == TSDB_TIME_PRECISION_MILLI)   ? 1000
                      : (precision == TSDB_TIME_PRECISION_MICRO) ? 1000000
                                                                 : 1000000000;
-  time_t    t = taosTime(NULL);
+  time_t    t;
+  (void) taosTime(&t);
   struct tm tm;
   (void) taosLocalTime(&t, &tm, NULL, 0);
   tm.tm_hour = 0;

include/libs/executor/executor.h

@@ -31,7 +31,7 @@ typedef void* DataSinkHandle;
 struct SRpcMsg;
 struct SSubplan;
 
-typedef int32_t (*localFetchFp)(void*, uint64_t, uint64_t, uint64_t, int64_t, int32_t, void**, SArray*);
+typedef int32_t (*localFetchFp)(void*, uint64_t, uint64_t, uint64_t, uint64_t, int64_t, int32_t, void**, SArray*);
 
 typedef struct {
   void*        handle;

include/libs/function/tudf.h

@@ -61,6 +61,35 @@ extern "C" {
     }                                               \
   } while (0)
 
+#define TAOS_UDF_CHECK_PTR_RCODE(...)                                          \
+  do {                                                                         \
+    const void *ptrs[] = {__VA_ARGS__};                                        \
+    for (int i = 0; i < sizeof(ptrs) / sizeof(ptrs[0]); ++i) {                 \
+      if (ptrs[i] == NULL) {                                                   \
+        fnError("udfd %dth parameter invalid, NULL PTR.line:%d", i, __LINE__); \
+        return TSDB_CODE_INVALID_PARA;                                         \
+      }                                                                        \
+    }                                                                          \
+  } while (0)
+
+#define TAOS_UDF_CHECK_PTR_RVOID(...)                                          \
+  do {                                                                         \
+    const void *ptrs[] = {__VA_ARGS__};                                        \
+    for (int i = 0; i < sizeof(ptrs) / sizeof(ptrs[0]); ++i) {                 \
+      if (ptrs[i] == NULL) {                                                   \
+        fnError("udfd %dth parameter invalid, NULL PTR.line:%d", i, __LINE__); \
+        return;                                                                \
+      }                                                                        \
+    }                                                                          \
+  } while (0)
+
+#define TAOS_UDF_CHECK_CONDITION(o, code)             \
+  do {                                                \
+    if ((o) == false) {                               \
+      fnError("Condition not met.line:%d", __LINE__); \
+      return code;                                    \
+    }                                                 \
+  } while (0)
 
 // low level APIs
 /**

include/libs/nodes/cmdnodes.h

@@ -42,10 +42,11 @@ extern "C" {
 #define SHOW_CREATE_VIEW_RESULT_FIELD1_LEN (TSDB_VIEW_FNAME_LEN + 4 + VARSTR_HEADER_SIZE)
 #define SHOW_CREATE_VIEW_RESULT_FIELD2_LEN (TSDB_MAX_ALLOWED_SQL_LEN + VARSTR_HEADER_SIZE)
 
-#define SHOW_LOCAL_VARIABLES_RESULT_COLS       3
+#define SHOW_LOCAL_VARIABLES_RESULT_COLS       4
 #define SHOW_LOCAL_VARIABLES_RESULT_FIELD1_LEN (TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE)
-#define SHOW_LOCAL_VARIABLES_RESULT_FIELD2_LEN (TSDB_CONFIG_VALUE_LEN + VARSTR_HEADER_SIZE)
+#define SHOW_LOCAL_VARIABLES_RESULT_FIELD2_LEN (TSDB_CONFIG_PATH_LEN + VARSTR_HEADER_SIZE)
 #define SHOW_LOCAL_VARIABLES_RESULT_FIELD3_LEN (TSDB_CONFIG_SCOPE_LEN + VARSTR_HEADER_SIZE)
+#define SHOW_LOCAL_VARIABLES_RESULT_FIELD4_LEN (TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE)
 
 #define COMPACT_DB_RESULT_COLS       3
 #define COMPACT_DB_RESULT_FIELD1_LEN 32

include/libs/nodes/plannodes.h

@@ -624,6 +624,7 @@ typedef struct SAggPhysiNode {
 typedef struct SDownstreamSourceNode {
   ENodeType      type;
   SQueryNodeAddr addr;
+  uint64_t       clientId;
   uint64_t       taskId;
   uint64_t       schedId;
   int32_t        execId;

include/libs/qworker/qworker.h

@@ -105,11 +105,11 @@ void qWorkerDestroy(void **qWorkerMgmt);
 
 int32_t qWorkerGetStat(SReadHandle *handle, void *qWorkerMgmt, SQWorkerStat *pStat);
 
-int32_t qWorkerProcessLocalQuery(void *pMgmt, uint64_t sId, uint64_t qId, uint64_t tId, int64_t rId, int32_t eId,
-                                 SQWMsg *qwMsg, SArray *explainRes);
+int32_t qWorkerProcessLocalQuery(void *pMgmt, uint64_t sId, uint64_t qId, uint64_t cId, uint64_t tId, int64_t rId,
+                                 int32_t eId, SQWMsg *qwMsg, SArray *explainRes);
 
-int32_t qWorkerProcessLocalFetch(void *pMgmt, uint64_t sId, uint64_t qId, uint64_t tId, int64_t rId, int32_t eId,
-                                 void **pRsp, SArray *explainRes);
+int32_t qWorkerProcessLocalFetch(void *pMgmt, uint64_t sId, uint64_t qId, uint64_t cId, uint64_t tId, int64_t rId,
+                                 int32_t eId, void **pRsp, SArray *explainRes);
 
 int32_t qWorkerDbgEnableDebug(char *option);
 

include/libs/scheduler/scheduler.h

@@ -83,6 +83,9 @@ void schedulerStopQueryHb(void* pTrans);
 int32_t schedulerUpdatePolicy(int32_t policy);
 int32_t schedulerEnableReSchedule(bool enableResche);
 
+int32_t initClientId(void);
+uint64_t getClientId(void);
+
 /**
  * Cancel query job
  * @param pJob

include/os/os.h

@@ -137,6 +137,14 @@ extern threadlocal bool tsEnableRandErr;
     terrno = _code;           \
   }
 
+#define OS_PARAM_CHECK(_o)             \
+  do {                                 \
+    if ((_o) == NULL) {                \
+      terrno = TSDB_CODE_INVALID_PARA; \
+      return terrno;                   \
+    }                                  \
+  } while (0)
+
 #ifdef __cplusplus
 }
 #endif

include/os/osSemaphore.h

@@ -104,6 +104,7 @@ int64_t taosGetPthreadId(TdThread thread);
 void    taosResetPthread(TdThread *thread);
 bool    taosComparePthread(TdThread first, TdThread second);
 int32_t taosGetPId();
+int32_t taosGetPIdByName(const char* name, int32_t* pPId);
 int32_t taosGetAppName(char *name, int32_t *len);
 
 #ifdef __cplusplus

include/os/osSystem.h

@@ -48,8 +48,6 @@ void    taosCloseCmd(TdCmdPtr *ppCmd);
 
 void *taosLoadDll(const char *filename);
 
-void *taosLoadSym(void *handle, char *name);
-
 void taosCloseDll(void *handle);
 
 int32_t taosSetConsoleEcho(bool on);

include/os/osTime.h

@@ -93,7 +93,7 @@ static FORCE_INLINE int64_t taosGetMonoTimestampMs() {
 char      *taosStrpTime(const char *buf, const char *fmt, struct tm *tm);
 struct tm *taosLocalTime(const time_t *timep, struct tm *result, char *buf, int32_t bufSize);
 struct tm *taosLocalTimeNolock(struct tm *result, const time_t *timep, int dst);
-time_t     taosTime(time_t *t);
+int32_t    taosTime(time_t *t);
 time_t     taosMktime(struct tm *timep);
 int64_t    user_mktime64(const uint32_t year, const uint32_t mon, const uint32_t day, const uint32_t hour,
                          const uint32_t min, const uint32_t sec, int64_t time_zone);

include/util/tdef.h

@@ -195,9 +195,9 @@ static const EOperatorType OPERATOR_ARRAY[] = {
   OP_TYPE_MULTI,
   OP_TYPE_DIV,
   OP_TYPE_REM,
-  
+
   OP_TYPE_MINUS,
-  
+
   OP_TYPE_BIT_AND,
   OP_TYPE_BIT_OR,
 
@@ -213,7 +213,7 @@ static const EOperatorType OPERATOR_ARRAY[] = {
   OP_TYPE_NOT_LIKE,
   OP_TYPE_MATCH,
   OP_TYPE_NMATCH,
-  
+
   OP_TYPE_IS_NULL,
   OP_TYPE_IS_NOT_NULL,
   OP_TYPE_IS_TRUE,
@@ -222,7 +222,7 @@ static const EOperatorType OPERATOR_ARRAY[] = {
   OP_TYPE_IS_NOT_TRUE,
   OP_TYPE_IS_NOT_FALSE,
   OP_TYPE_IS_NOT_UNKNOWN,
-  //OP_TYPE_COMPARE_MAX_VALUE, 
+  //OP_TYPE_COMPARE_MAX_VALUE,
 
   OP_TYPE_JSON_GET_VALUE,
   OP_TYPE_JSON_CONTAINS,
@@ -631,6 +631,8 @@ enum { RAND_ERR_MEMORY = 1, RAND_ERR_FILE = 2, RAND_ERR_NETWORK = 4 };
 #define TSDB_CONFIG_VALUE_LEN  64
 #define TSDB_CONFIG_SCOPE_LEN  8
 #define TSDB_CONFIG_NUMBER     16
+#define TSDB_CONFIG_PATH_LEN   4096
+#define TSDB_CONFIG_INFO_LEN   64
 
 #define QUERY_ID_SIZE      20
 #define QUERY_OBJ_ID_SIZE  18

include/util/tjson.h

@@ -25,7 +25,7 @@ extern "C" {
 
 #define tjsonGetNumberValue(pJson, pName, val, code) \
   do {                                               \
-    uint64_t _tmp = 0;                               \
+    int64_t _tmp = 0;                                \
     code = tjsonGetBigIntValue(pJson, pName, &_tmp); \
     val = _tmp;                                      \
   } while (0)

include/util/tutil.h

@@ -120,6 +120,18 @@ static FORCE_INLINE int32_t taosGetTbHashVal(const char *tbname, int32_t tblen,
   }
 }
 
+/*
+ * LIKELY and UNLIKELY macros for branch predication hints. Use them judiciously
+ * only in very hot code paths. Misuse or abuse can lead to performance degradation.
+ */
+#if __GNUC__ >= 3
+#define LIKELY(x)	__builtin_expect((x) != 0, 1)
+#define UNLIKELY(x) __builtin_expect((x) != 0, 0)
+#else
+#define LIKELY(x)	((x) != 0)
+#define UNLIKELY(x) ((x) != 0)
+#endif
+
 #define TAOS_CHECK_ERRNO(CODE)         \
   do {                                 \
     terrno = (CODE);                   \
@@ -129,25 +141,27 @@ static FORCE_INLINE int32_t taosGetTbHashVal(const char *tbname, int32_t tblen,
     }                                  \
   } while (0)
 
-#define TSDB_CHECK_CODE(CODE, LINO, LABEL) \
-  do {                                     \
-    if (TSDB_CODE_SUCCESS != (CODE)) {     \
-      LINO = __LINE__;                     \
-      goto LABEL;                          \
-    }                                      \
+#define TSDB_CHECK_CODE(CODE, LINO, LABEL)       \
+  do {                                           \
+    if (UNLIKELY(TSDB_CODE_SUCCESS != (CODE))) { \
+      LINO = __LINE__;                           \
+      goto LABEL;                                \
+    }                                            \
   } while (0)
 
 #define QUERY_CHECK_CODE TSDB_CHECK_CODE
 
-#define QUERY_CHECK_CONDITION(condition, CODE, LINO, LABEL, ERRNO) \
-  if (!condition) {                                                \
-    (CODE) = (ERRNO);                                              \
-    (LINO) = __LINE__;                                             \
-    goto LABEL;                                                    \
+#define TSDB_CHECK_CONDITION(condition, CODE, LINO, LABEL, ERRNO) \
+  if (UNLIKELY(!(condition))) {                                   \
+    (CODE) = (ERRNO);                                             \
+    (LINO) = __LINE__;                                            \
+    goto LABEL;                                                   \
   }
 
+#define QUERY_CHECK_CONDITION TSDB_CHECK_CONDITION
+
 #define TSDB_CHECK_NULL(ptr, CODE, LINO, LABEL, ERRNO) \
-  if ((ptr) == NULL) {                                 \
+  if (UNLIKELY((ptr) == NULL)) {                       \
     (CODE) = (ERRNO);                                  \
     (LINO) = __LINE__;                                 \
     goto LABEL;                                        \

packaging/smokeTest/test_server.py

@@ -61,7 +61,7 @@ def setup_module(get_config):
     else:
         cmd = "mkdir -p ../../debug/build/bin/"
     subprocess.getoutput(cmd)
-    if config["system"] == "Linux":  # add tmq_sim
+    if config["system"] == "Linux" or config["system"] == "Darwin" :  # add tmq_sim
         cmd = "cp -rf ../../../debug/build/bin/tmq_sim ../../debug/build/bin/."
         subprocess.getoutput(cmd)
     if config["system"] == "Darwin":
@@ -140,9 +140,11 @@ class TestServer:
             if line:
                 print(line.strip())
             if "succeed to write dnode" in line:
-                time.sleep(15)
+                time.sleep(5)
                 # 发送终止信号
-                os.kill(process.pid, signal.SIGTERM)
+                os.kill(process.pid, signal.SIGKILL)
+                # Waiting for the process to be completely killed
+                time.sleep(5)
                 break
 
     @pytest.mark.all

source/client/inc/clientInt.h

@@ -47,10 +47,11 @@ enum {
   RES_TYPE__TMQ_BATCH_META,
 };
 
-#define SHOW_VARIABLES_RESULT_COLS       3
+#define SHOW_VARIABLES_RESULT_COLS       4
 #define SHOW_VARIABLES_RESULT_FIELD1_LEN (TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE)
 #define SHOW_VARIABLES_RESULT_FIELD2_LEN (TSDB_CONFIG_VALUE_LEN + VARSTR_HEADER_SIZE)
 #define SHOW_VARIABLES_RESULT_FIELD3_LEN (TSDB_CONFIG_SCOPE_LEN + VARSTR_HEADER_SIZE)
+#define SHOW_VARIABLES_RESULT_FIELD4_LEN (TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE)
 
 #define TD_RES_QUERY(res)          (*(int8_t*)(res) == RES_TYPE__QUERY)
 #define TD_RES_TMQ(res)            (*(int8_t*)(res) == RES_TYPE__TMQ)

source/client/src/clientEnv.c

@@ -982,6 +982,7 @@ void taos_init_imp(void) {
   SCatalogCfg cfg = {.maxDBCacheNum = 100, .maxTblCacheNum = 100};
   ENV_ERR_RET(catalogInit(&cfg), "failed to init catalog");
   ENV_ERR_RET(schedulerInit(), "failed to init scheduler");
+  ENV_ERR_RET(initClientId(), "failed to init clientId");
 
   tscDebug("starting to initialize TAOS driver");
 

source/client/src/clientMsgHandler.c

@@ -541,6 +541,10 @@ static int32_t buildShowVariablesBlock(SArray* pVars, SSDataBlock** block) {
   infoData.info.bytes = SHOW_VARIABLES_RESULT_FIELD3_LEN;
   TSDB_CHECK_NULL(taosArrayPush(pBlock->pDataBlock, &infoData), code, line, END, terrno);
 
+  infoData.info.type = TSDB_DATA_TYPE_VARCHAR;
+  infoData.info.bytes = SHOW_VARIABLES_RESULT_FIELD4_LEN;
+  TSDB_CHECK_NULL(taosArrayPush(pBlock->pDataBlock, &infoData), code, line, END, terrno);
+
   int32_t numOfCfg = taosArrayGetSize(pVars);
   code = blockDataEnsureCapacity(pBlock, numOfCfg);
   TSDB_CHECK_CODE(code, line, END);
@@ -569,6 +573,13 @@ static int32_t buildShowVariablesBlock(SArray* pVars, SSDataBlock** block) {
     TSDB_CHECK_NULL(pColInfo, code, line, END, terrno);
     code = colDataSetVal(pColInfo, i, scope, false);
     TSDB_CHECK_CODE(code, line, END);
+
+    char info[TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE] = {0};
+    STR_WITH_MAXSIZE_TO_VARSTR(info, pInfo->info, TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE);
+    pColInfo = taosArrayGet(pBlock->pDataBlock, c++);
+    TSDB_CHECK_NULL(pColInfo, code, line, END, terrno);
+    code = colDataSetVal(pColInfo, i, info, false);
+    TSDB_CHECK_CODE(code, line, END);
   }
 
   pBlock->info.rows = numOfCfg;
@@ -825,7 +836,7 @@ int32_t processCompactDbRsp(void* param, SDataBuf* pMsg, int32_t code) {
       tscError("failed to post semaphore");
     }
   }
-  return code;  
+  return code;
 }
 
 __async_send_cb_fn_t getMsgRspHandle(int32_t msgType) {
@@ -845,7 +856,7 @@ __async_send_cb_fn_t getMsgRspHandle(int32_t msgType) {
     case TDMT_MND_SHOW_VARIABLES:
       return processShowVariablesRsp;
     case TDMT_MND_COMPACT_DB:
-      return processCompactDbRsp;  
+      return processCompactDbRsp;
     default:
       return genericRspCallback;
   }

source/common/src/rsync.c

@@ -119,11 +119,21 @@ static int32_t execCommand(char* command) {
 }
 
 void stopRsync() {
-  int32_t code =
+  int32_t pid = 0;
+  int32_t code = 0;
+  char    buf[128] = {0};
+
 #ifdef WINDOWS
-      system("taskkill /f /im rsync.exe");
+  code = system("taskkill /f /im rsync.exe");
 #else
-      system("pkill rsync");
+  code = taosGetPIdByName("rsync", &pid);
+  if (code == 0) {
+    int32_t ret = tsnprintf(buf, tListLen(buf), "kill -9 %d", pid);
+    if (ret > 0) {
+      uInfo("kill rsync program pid:%d", pid);
+      code = system(buf);
+    }
+  }
 #endif
 
   if (code != 0) {

source/common/src/systable.c

@@ -327,8 +327,9 @@ static const SSysDbTableSchema configSchema[] = {
 static const SSysDbTableSchema variablesSchema[] = {
     {.name = "dnode_id", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = true},
     {.name = "name", .bytes = TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
-    {.name = "value", .bytes = TSDB_CONFIG_VALUE_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
+    {.name = "value", .bytes = TSDB_CONFIG_PATH_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
     {.name = "scope", .bytes = TSDB_CONFIG_SCOPE_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
+    {.name = "info", .bytes = TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
 };
 
 static const SSysDbTableSchema topicSchema[] = {

source/common/src/tcol.c

@@ -81,26 +81,42 @@ const char* getDefaultEncodeStr(uint8_t type) { return columnEncodeStr(getDefaul
 uint16_t getDefaultCompress(uint8_t type) {
   switch (type) {
     case TSDB_DATA_TYPE_NULL:
+      return TSDB_COLVAL_COMPRESS_LZ4;
     case TSDB_DATA_TYPE_BOOL:
+      return TSDB_COLVAL_COMPRESS_ZSTD;
     case TSDB_DATA_TYPE_TINYINT:
     case TSDB_DATA_TYPE_SMALLINT:
+      return TSDB_COLVAL_COMPRESS_ZLIB;
     case TSDB_DATA_TYPE_INT:
     case TSDB_DATA_TYPE_BIGINT:
+      return TSDB_COLVAL_COMPRESS_LZ4;
     case TSDB_DATA_TYPE_FLOAT:
     case TSDB_DATA_TYPE_DOUBLE:
+      return TSDB_COLVAL_COMPRESS_LZ4;
     case TSDB_DATA_TYPE_VARCHAR:  // TSDB_DATA_TYPE_BINARY
+      return TSDB_COLVAL_COMPRESS_ZSTD;
     case TSDB_DATA_TYPE_TIMESTAMP:
+      return TSDB_COLVAL_COMPRESS_LZ4;
     case TSDB_DATA_TYPE_NCHAR:
+      return TSDB_COLVAL_COMPRESS_ZSTD;
     case TSDB_DATA_TYPE_UTINYINT:
     case TSDB_DATA_TYPE_USMALLINT:
+      return TSDB_COLVAL_COMPRESS_ZLIB;
     case TSDB_DATA_TYPE_UINT:
     case TSDB_DATA_TYPE_UBIGINT:
+      return TSDB_COLVAL_COMPRESS_LZ4;
     case TSDB_DATA_TYPE_JSON:
+      return TSDB_COLVAL_COMPRESS_LZ4;
     case TSDB_DATA_TYPE_VARBINARY:
+      return TSDB_COLVAL_COMPRESS_ZSTD;
     case TSDB_DATA_TYPE_DECIMAL:
+      return TSDB_COLVAL_COMPRESS_LZ4;
     case TSDB_DATA_TYPE_BLOB:
+      return TSDB_COLVAL_COMPRESS_LZ4;
     case TSDB_DATA_TYPE_MEDIUMBLOB:
+      return TSDB_COLVAL_COMPRESS_LZ4;
     case TSDB_DATA_TYPE_GEOMETRY:
+      return TSDB_COLVAL_COMPRESS_LZ4;
     case TSDB_DATA_TYPE_MAX:
       return TSDB_COLVAL_COMPRESS_LZ4;
     default:
@@ -166,6 +182,7 @@ const char* columnCompressStr(uint16_t type) {
 }
 
 uint8_t columnLevelVal(const char* level) {
+  if (level == NULL) return TSDB_COLVAL_LEVEL_NOCHANGE;
   uint8_t l = TSDB_COLVAL_LEVEL_MEDIUM;
   if (0 == strcmp(level, "h") || 0 == strcmp(level, TSDB_COLUMN_LEVEL_HIGH)) {
     l = TSDB_COLVAL_LEVEL_HIGH;
@@ -180,6 +197,7 @@ uint8_t columnLevelVal(const char* level) {
 }
 
 uint16_t columnCompressVal(const char* compress) {
+  if (compress == NULL) return TSDB_COLVAL_COMPRESS_NOCHANGE;
   uint16_t c = TSDB_COLVAL_COMPRESS_LZ4;
   if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_LZ4)) {
     c = TSDB_COLVAL_COMPRESS_LZ4;
@@ -200,6 +218,7 @@ uint16_t columnCompressVal(const char* compress) {
 }
 
 uint8_t columnEncodeVal(const char* encode) {
+  if (encode == NULL) return TSDB_COLVAL_ENCODE_NOCHANGE;
   uint8_t e = TSDB_COLVAL_ENCODE_SIMPLE8B;
   if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_SIMPLE8B)) {
     e = TSDB_COLVAL_ENCODE_SIMPLE8B;
@@ -311,6 +330,7 @@ void setColLevel(uint32_t* compress, uint8_t level) {
 
 int32_t setColCompressByOption(uint8_t type, uint8_t encode, uint16_t compressType, uint8_t level, bool check,
                                uint32_t* compress) {
+  if(compress == NULL) return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;
   if (check && !validColEncode(type, encode)) return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;
   setColEncode(compress, encode);
 

source/common/src/tglobal.c

@@ -59,7 +59,6 @@ int32_t tsNumOfRpcSessions = 30000;
 int32_t tsShareConnLimit = 10;
 int32_t tsReadTimeout = 900;
 int32_t tsTimeToGetAvailableConn = 500000;
-int32_t tsKeepAliveIdle = 60;
 
 int32_t tsNumOfCommitThreads = 2;
 int32_t tsNumOfTaskQueueThreads = 16;
@@ -522,7 +521,7 @@ static int32_t taosLoadCfg(SConfig *pCfg, const char **envCmd, const char *input
 
 int32_t taosAddClientLogCfg(SConfig *pCfg) {
   TAOS_CHECK_RETURN(cfgAddDir(pCfg, "configDir", configDir, CFG_SCOPE_BOTH, CFG_DYN_NONE));
-  TAOS_CHECK_RETURN(cfgAddDir(pCfg, "scriptDir", configDir, CFG_SCOPE_BOTH, CFG_DYN_NONE));
+  TAOS_CHECK_RETURN(cfgAddDir(pCfg, "scriptDir", configDir, CFG_SCOPE_CLIENT, CFG_DYN_NONE));
   TAOS_CHECK_RETURN(cfgAddDir(pCfg, "logDir", tsLogDir, CFG_SCOPE_BOTH, CFG_DYN_NONE));
   TAOS_CHECK_RETURN(cfgAddFloat(pCfg, "minimalLogDirGB", 1.0f, 0.001f, 10000000, CFG_SCOPE_BOTH, CFG_DYN_CLIENT));
   TAOS_CHECK_RETURN(
@@ -530,13 +529,14 @@ int32_t taosAddClientLogCfg(SConfig *pCfg) {
   TAOS_CHECK_RETURN(cfgAddBool(pCfg, "asyncLog", tsAsyncLog, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "logKeepDays", 0, -365000, 365000, CFG_SCOPE_BOTH, CFG_DYN_ENT_BOTH));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "debugFlag", 0, 0, 255, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
-  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "simDebugFlag", simDebugFlag, 0, 255, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
+  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "simDebugFlag", simDebugFlag, 0, 255, CFG_SCOPE_CLIENT, CFG_DYN_BOTH));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "tmrDebugFlag", tmrDebugFlag, 0, 255, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "uDebugFlag", uDebugFlag, 0, 255, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "rpcDebugFlag", rpcDebugFlag, 0, 255, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "jniDebugFlag", jniDebugFlag, 0, 255, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "qDebugFlag", qDebugFlag, 0, 255, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "cDebugFlag", cDebugFlag, 0, 255, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
+  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "tqClientDebugFlag", tqClientDebugFlag, 0, 255, CFG_SCOPE_CLIENT, CFG_DYN_SERVER));
   TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
@@ -549,7 +549,6 @@ static int32_t taosAddServerLogCfg(SConfig *pCfg) {
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "sDebugFlag", sDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "tsdbDebugFlag", tsdbDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "tqDebugFlag", tqDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
-  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "tqClientDebugFlag", tqClientDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "fsDebugFlag", fsDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "udfDebugFlag", udfDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "smaDebugFlag", smaDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
@@ -590,17 +589,18 @@ static int32_t taosAddClientCfg(SConfig *pCfg) {
   TAOS_CHECK_RETURN(
       cfgAddBool(pCfg, "queryUseNodeAllocator", tsQueryUseNodeAllocator, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
   TAOS_CHECK_RETURN(cfgAddBool(pCfg, "keepColumnName", tsKeepColumnName, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
+  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "minSlidingTime", tsMinSlidingTime, 1, 1000000, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
+  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "minIntervalTime", tsMinIntervalTime, 1, 1000000, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
   TAOS_CHECK_RETURN(cfgAddString(pCfg, "smlChildTableName", tsSmlChildTableName, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
   TAOS_CHECK_RETURN(cfgAddString(pCfg, "smlAutoChildTableNameDelimiter", tsSmlAutoChildTableNameDelimiter,
                                  CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
   TAOS_CHECK_RETURN(cfgAddString(pCfg, "smlTagName", tsSmlTagName, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
   TAOS_CHECK_RETURN(cfgAddString(pCfg, "smlTsDefaultName", tsSmlTsDefaultName, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
   TAOS_CHECK_RETURN(cfgAddBool(pCfg, "smlDot2Underline", tsSmlDot2Underline, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
-  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "maxShellConns", tsMaxShellConns, 10, 50000000, CFG_SCOPE_CLIENT, CFG_DYN_NONE));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "maxInsertBatchRows", tsMaxInsertBatchRows, 1, INT32_MAX, CFG_SCOPE_CLIENT,
                                 CFG_DYN_CLIENT) != 0);
   TAOS_CHECK_RETURN(
-      cfgAddInt32(pCfg, "maxRetryWaitTime", tsMaxRetryWaitTime, 0, 86400000, CFG_SCOPE_BOTH, CFG_DYN_CLIENT));
+      cfgAddInt32(pCfg, "maxRetryWaitTime", tsMaxRetryWaitTime, 0, 86400000, CFG_SCOPE_SERVER, CFG_DYN_CLIENT));
   TAOS_CHECK_RETURN(cfgAddBool(pCfg, "useAdapter", tsUseAdapter, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
   TAOS_CHECK_RETURN(cfgAddBool(pCfg, "crashReporting", tsEnableCrashReport, CFG_SCOPE_BOTH, CFG_DYN_CLIENT));
   TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "queryMaxConcurrentTables", tsQueryMaxConcurrentTables, INT64_MIN, INT64_MAX,
@@ -630,15 +630,12 @@ static int32_t taosAddClientCfg(SConfig *pCfg) {
   TAOS_CHECK_RETURN(
       cfgAddInt32(pCfg, "timeToGetAvailableConn", tsTimeToGetAvailableConn, 20, 1000000, CFG_SCOPE_BOTH, CFG_DYN_NONE));
 
-  tsKeepAliveIdle = TRANGE(tsKeepAliveIdle, 1, 72000);
-  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "keepAliveIdle", tsKeepAliveIdle, 1, 7200000, CFG_SCOPE_BOTH, CFG_DYN_NONE));
-
   tsNumOfTaskQueueThreads = tsNumOfCores * 2;
   tsNumOfTaskQueueThreads = TMAX(tsNumOfTaskQueueThreads, 16);
 
   TAOS_CHECK_RETURN(
       cfgAddInt32(pCfg, "numOfTaskQueueThreads", tsNumOfTaskQueueThreads, 4, 1024, CFG_SCOPE_CLIENT, CFG_DYN_NONE));
-  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "experimental", tsExperimental, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
+  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "experimental", tsExperimental, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
 
   TAOS_CHECK_RETURN(cfgAddBool(pCfg, "multiResultFunctionStarReturnTags", tsMultiResultFunctionStarReturnTags,
                                CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
@@ -727,8 +724,7 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
   TAOS_CHECK_RETURN(cfgAddString(pCfg, "encryptScope", tsEncryptScope, CFG_SCOPE_SERVER, CFG_DYN_NONE));
 
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "statusInterval", tsStatusInterval, 1, 30, CFG_SCOPE_SERVER, CFG_DYN_NONE));
-  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "minSlidingTime", tsMinSlidingTime, 1, 1000000, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
-  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "minIntervalTime", tsMinIntervalTime, 1, 1000000, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
+  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "maxShellConns", tsMaxShellConns, 10, 50000000, CFG_SCOPE_SERVER, CFG_DYN_NONE));
 
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "queryBufferSize", tsQueryBufferSize, -1, 500000000000, CFG_SCOPE_SERVER, CFG_DYN_NONE));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "queryRspPolicy", tsQueryRspPolicy, 0, 1, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER));
@@ -746,7 +742,7 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "numOfSnodeSharedThreads", tsNumOfSnodeStreamThreads, 2, 1024, CFG_SCOPE_SERVER, CFG_DYN_NONE));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "numOfSnodeUniqueThreads", tsNumOfSnodeWriteThreads, 2, 1024, CFG_SCOPE_SERVER, CFG_DYN_NONE));
 
-  TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "rpcQueueMemoryAllowed", tsQueueMemoryAllowed, TSDB_MAX_MSG_SIZE * 10L, INT64_MAX, CFG_SCOPE_BOTH, CFG_DYN_NONE));
+  TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "rpcQueueMemoryAllowed", tsQueueMemoryAllowed, TSDB_MAX_MSG_SIZE * 10L, INT64_MAX, CFG_SCOPE_SERVER, CFG_DYN_NONE));
 
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "syncElectInterval", tsElectInterval, 10, 1000 * 60 * 24 * 2, CFG_SCOPE_SERVER, CFG_DYN_NONE));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "syncHeartbeatInterval", tsHeartbeatInterval, 10, 1000 * 60 * 24 * 2, CFG_SCOPE_SERVER, CFG_DYN_NONE));
@@ -782,12 +778,12 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
   TAOS_CHECK_RETURN(cfgAddBool(pCfg, "auditCreateTable", tsEnableAuditCreateTable, CFG_SCOPE_SERVER, CFG_DYN_NONE));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "auditInterval", tsAuditInterval, 500, 200000, CFG_SCOPE_SERVER, CFG_DYN_NONE));
 
-  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "telemetryReporting", tsEnableTelem, CFG_SCOPE_BOTH, CFG_DYN_ENT_SERVER));
-  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "telemetryInterval", tsTelemInterval, 1, 200000, CFG_SCOPE_BOTH, CFG_DYN_NONE));
-  TAOS_CHECK_RETURN(cfgAddString(pCfg, "telemetryServer", tsTelemServer, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
-  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "telemetryPort", tsTelemPort, 1, 65056, CFG_SCOPE_BOTH, CFG_DYN_NONE));
+  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "telemetryReporting", tsEnableTelem, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER));
+  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "telemetryInterval", tsTelemInterval, 1, 200000, CFG_SCOPE_SERVER, CFG_DYN_NONE));
+  TAOS_CHECK_RETURN(cfgAddString(pCfg, "telemetryServer", tsTelemServer, CFG_SCOPE_SERVER, CFG_DYN_BOTH));
+  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "telemetryPort", tsTelemPort, 1, 65056, CFG_SCOPE_SERVER, CFG_DYN_NONE));
 
-  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "rsyncPort", tsRsyncPort, 1, 65535, CFG_SCOPE_BOTH, CFG_DYN_SERVER));
+  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "rsyncPort", tsRsyncPort, 1, 65535, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
   TAOS_CHECK_RETURN(cfgAddString(pCfg, "snodeAddress", tsSnodeAddress, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
   TAOS_CHECK_RETURN(cfgAddString(pCfg, "checkpointBackupDir", tsCheckpointBackupDir, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
 
@@ -1293,9 +1289,6 @@ static int32_t taosSetClientCfg(SConfig *pCfg) {
   TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "timeToGetAvailableConn");
   tsTimeToGetAvailableConn = pItem->i32;
 
-  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "keepAliveIdle");
-  tsKeepAliveIdle = pItem->i32;
-
   TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "experimental");
   tsExperimental = pItem->bval;
 
@@ -2030,7 +2023,6 @@ static int32_t taosCfgDynamicOptionsForServer(SConfig *pCfg, const char *name) {
 
                                          {"cacheLazyLoadThreshold", &tsCacheLazyLoadThreshold},
                                          {"checkpointInterval", &tsStreamCheckpointInterval},
-                                         {"keepAliveIdle", &tsKeepAliveIdle},
                                          {"logKeepDays", &tsLogKeepDays},
                                          {"maxStreamBackendCache", &tsMaxStreamBackendCache},
                                          {"mqRebalanceInterval", &tsMqRebalanceInterval},
@@ -2288,7 +2280,6 @@ static int32_t taosCfgDynamicOptionsForClient(SConfig *pCfg, const char *name) {
                                          {"crashReporting", &tsEnableCrashReport},
                                          {"enableQueryHb", &tsEnableQueryHb},
                                          {"keepColumnName", &tsKeepColumnName},
-                                         {"keepAliveIdle", &tsKeepAliveIdle},
                                          {"logKeepDays", &tsLogKeepDays},
                                          {"maxInsertBatchRows", &tsMaxInsertBatchRows},
                                          {"maxRetryWaitTime", &tsMaxRetryWaitTime},

source/common/src/tmisce.c

@@ -267,7 +267,14 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
 
   int8_t locked = 0;
 
-  TAOS_CHECK_GOTO(blockDataEnsureCapacity(pBlock, cfgGetSize(pConf)), NULL, _exit);
+  size_t       exSize = 0;
+  size_t       index = 0;
+  SConfigItem* pDataDirItem = cfgGetItem(pConf, "dataDir");
+  if (pDataDirItem) {
+    exSize = TMAX(taosArrayGetSize(pDataDirItem->array), 1) - 1;
+  }
+
+  TAOS_CHECK_GOTO(blockDataEnsureCapacity(pBlock, cfgGetSize(pConf) + exSize), NULL, _exit);
 
   TAOS_CHECK_GOTO(cfgCreateIter(pConf, &pIter), NULL, _exit);
 
@@ -275,6 +282,7 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
   locked = 1;
 
   while ((pItem = cfgNextIter(pIter)) != NULL) {
+_start:
     col = startCol;
 
     // GRANT_CFG_SKIP;
@@ -289,9 +297,18 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
 
     TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, name, false), NULL, _exit);
 
-    char    value[TSDB_CONFIG_VALUE_LEN + VARSTR_HEADER_SIZE] = {0};
+    char    value[TSDB_CONFIG_PATH_LEN + VARSTR_HEADER_SIZE] = {0};
     int32_t valueLen = 0;
-    TAOS_CHECK_GOTO(cfgDumpItemValue(pItem, &value[VARSTR_HEADER_SIZE], TSDB_CONFIG_VALUE_LEN, &valueLen), NULL, _exit);
+    SDiskCfg* pDiskCfg = NULL;
+    if (strcasecmp(pItem->name, "dataDir") == 0 && exSize > 0) {
+      char*     buf = &value[VARSTR_HEADER_SIZE];
+      pDiskCfg = taosArrayGet(pItem->array, index);
+      valueLen = tsnprintf(buf, TSDB_CONFIG_PATH_LEN, "%s", pDiskCfg->dir);
+      index++;
+    } else {
+      TAOS_CHECK_GOTO(cfgDumpItemValue(pItem, &value[VARSTR_HEADER_SIZE], TSDB_CONFIG_PATH_LEN, &valueLen), NULL,
+                      _exit);
+    }
     varDataSetLen(value, valueLen);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, col++);
@@ -313,8 +330,28 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
     }
     TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, scope, false), NULL, _exit);
 
+    char info[TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE] = {0};
+    if (strcasecmp(pItem->name, "dataDir") == 0 && pDiskCfg) {
+      char* buf = &info[VARSTR_HEADER_SIZE];
+      valueLen = tsnprintf(buf, TSDB_CONFIG_INFO_LEN, "level %d primary %d disabled %" PRIi8, pDiskCfg->level,
+                              pDiskCfg->primary, pDiskCfg->disable);
+    } else {
+      valueLen = 0;
+    }
+    varDataSetLen(info, valueLen);
+
+    pColInfo = taosArrayGet(pBlock->pDataBlock, col++);
+    if (pColInfo == NULL) {
+      code = terrno;
+      TAOS_CHECK_GOTO(code, NULL, _exit);
+    }
+    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, info, false), NULL, _exit);
+
     numOfRows++;
-  }
+    if (index > 0 && index <= exSize) {
+      goto _start;
+    }
+}
   pBlock->info.rows = numOfRows;
 _exit:
   if (locked) cfgUnLock(pConf);

source/common/src/tmsg.c

@@ -5642,6 +5642,12 @@ int32_t tSerializeSShowVariablesRsp(void *buf, int32_t bufLen, SShowVariablesRsp
     SVariablesInfo *pInfo = taosArrayGet(pRsp->variables, i);
     TAOS_CHECK_EXIT(tEncodeSVariablesInfo(&encoder, pInfo));
   }
+
+  for (int32_t i = 0; i < varNum; ++i) {
+    SVariablesInfo *pInfo = taosArrayGet(pRsp->variables, i);
+    TAOS_CHECK_RETURN(tEncodeCStr(&encoder, pInfo->info));
+  }
+
   tEndEncode(&encoder);
 
 _exit:
@@ -5675,6 +5681,13 @@ int32_t tDeserializeSShowVariablesRsp(void *buf, int32_t bufLen, SShowVariablesR
         TAOS_CHECK_EXIT(terrno);
       }
     }
+
+    if (!tDecodeIsEnd(&decoder)) {
+      for (int32_t i = 0; i < varNum; ++i) {
+        SVariablesInfo *pInfo = taosArrayGet(pRsp->variables, i);
+        TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pInfo->info));
+      }
+    }
   }
 
   tEndDecode(&decoder);
@@ -8717,6 +8730,7 @@ int32_t tSerializeSSubQueryMsg(void *buf, int32_t bufLen, SSubQueryMsg *pReq) {
   TAOS_CHECK_EXIT(tEncodeCStrWithLen(&encoder, pReq->sql, pReq->sqlLen));
   TAOS_CHECK_EXIT(tEncodeU32(&encoder, pReq->msgLen));
   TAOS_CHECK_EXIT(tEncodeBinary(&encoder, (uint8_t *)pReq->msg, pReq->msgLen));
+  TAOS_CHECK_EXIT(tEncodeU64(&encoder, pReq->clientId));
 
   tEndEncode(&encoder);
 
@@ -8765,6 +8779,11 @@ int32_t tDeserializeSSubQueryMsg(void *buf, int32_t bufLen, SSubQueryMsg *pReq)
   TAOS_CHECK_EXIT(tDecodeCStrAlloc(&decoder, &pReq->sql));
   TAOS_CHECK_EXIT(tDecodeU32(&decoder, &pReq->msgLen));
   TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void **)&pReq->msg, NULL));
+  if (!tDecodeIsEnd(&decoder)) {
+    TAOS_CHECK_EXIT(tDecodeU64(&decoder, &pReq->clientId));
+  } else {
+    pReq->clientId = 0;
+  }
 
   tEndDecode(&decoder);
 
@@ -8894,6 +8913,7 @@ int32_t tSerializeSResFetchReq(void *buf, int32_t bufLen, SResFetchReq *pReq) {
   } else {
     TAOS_CHECK_EXIT(tEncodeI32(&encoder, 0));
   }
+  TAOS_CHECK_EXIT(tEncodeU64(&encoder, pReq->clientId));
 
   tEndEncode(&encoder);
 
@@ -8943,6 +8963,11 @@ int32_t tDeserializeSResFetchReq(void *buf, int32_t bufLen, SResFetchReq *pReq)
     }
     TAOS_CHECK_EXIT(tDeserializeSOperatorParam(&decoder, pReq->pOpParam));
   }
+  if (!tDecodeIsEnd(&decoder)) {
+    TAOS_CHECK_EXIT(tDecodeU64(&decoder, &pReq->clientId));
+  } else {
+    pReq->clientId = 0;
+  }
 
   tEndDecode(&decoder);
 
@@ -9055,6 +9080,7 @@ int32_t tSerializeSTaskDropReq(void *buf, int32_t bufLen, STaskDropReq *pReq) {
   TAOS_CHECK_EXIT(tEncodeU64(&encoder, pReq->taskId));
   TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->refId));
   TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->execId));
+  TAOS_CHECK_EXIT(tEncodeU64(&encoder, pReq->clientId));
 
   tEndEncode(&encoder);
 
@@ -9095,6 +9121,11 @@ int32_t tDeserializeSTaskDropReq(void *buf, int32_t bufLen, STaskDropReq *pReq)
   TAOS_CHECK_EXIT(tDecodeU64(&decoder, &pReq->taskId));
   TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->refId));
   TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->execId));
+  if (!tDecodeIsEnd(&decoder)) {
+    TAOS_CHECK_EXIT(tDecodeU64(&decoder, &pReq->clientId));
+  } else {
+    pReq->clientId = 0;
+  }
 
   tEndDecode(&decoder);
 
@@ -9123,6 +9154,7 @@ int32_t tSerializeSTaskNotifyReq(void *buf, int32_t bufLen, STaskNotifyReq *pReq
   TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->refId));
   TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->execId));
   TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->type));
+  TAOS_CHECK_EXIT(tEncodeU64(&encoder, pReq->clientId));
 
   tEndEncode(&encoder);
 
@@ -9164,6 +9196,11 @@ int32_t tDeserializeSTaskNotifyReq(void *buf, int32_t bufLen, STaskNotifyReq *pR
   TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->refId));
   TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->execId));
   TAOS_CHECK_EXIT(tDecodeI32(&decoder, (int32_t *)&pReq->type));
+  if (!tDecodeIsEnd(&decoder)) {
+    TAOS_CHECK_EXIT(tDecodeU64(&decoder, &pReq->clientId));
+  } else {
+    pReq->clientId = 0;
+  }
 
   tEndDecode(&decoder);
 
@@ -9353,6 +9390,10 @@ int32_t tSerializeSSchedulerHbRsp(void *buf, int32_t bufLen, SSchedulerHbRsp *pR
       TAOS_CHECK_EXIT(tEncodeI32(&encoder, status->execId));
       TAOS_CHECK_EXIT(tEncodeI8(&encoder, status->status));
     }
+    for (int32_t i = 0; i < num; ++i) {
+      STaskStatus *status = taosArrayGet(pRsp->taskStatus, i);
+      TAOS_CHECK_EXIT(tEncodeU64(&encoder, status->clientId));
+    }
   } else {
     TAOS_CHECK_EXIT(tEncodeI32(&encoder, 0));
   }
@@ -9396,6 +9437,12 @@ int32_t tDeserializeSSchedulerHbRsp(void *buf, int32_t bufLen, SSchedulerHbRsp *
         TAOS_CHECK_EXIT(terrno);
       }
     }
+    if (!tDecodeIsEnd(&decoder)) {
+      for (int32_t i = 0; i < num; ++i) {
+        STaskStatus *status = taosArrayGet(pRsp->taskStatus, i);
+        TAOS_CHECK_EXIT(tDecodeU64(&decoder, &status->clientId));
+      }
+    }
   } else {
     pRsp->taskStatus = NULL;
   }
@@ -9560,6 +9607,7 @@ int32_t tSerializeSVDeleteReq(void *buf, int32_t bufLen, SVDeleteReq *pReq) {
   TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->sql));
   TAOS_CHECK_EXIT(tEncodeBinary(&encoder, pReq->msg, pReq->phyLen));
   TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->source));
+  TAOS_CHECK_EXIT(tEncodeU64(&encoder, pReq->clientId));
   tEndEncode(&encoder);
 
 _exit:
@@ -9608,6 +9656,11 @@ int32_t tDeserializeSVDeleteReq(void *buf, int32_t bufLen, SVDeleteReq *pReq) {
   if (!tDecodeIsEnd(&decoder)) {
     TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->source));
   }
+  if (!tDecodeIsEnd(&decoder)) {
+    TAOS_CHECK_EXIT(tDecodeU64(&decoder, &pReq->clientId));
+  } else {
+    pReq->clientId = 0;
+  }
   tEndDecode(&decoder);
 
 _exit:

source/common/src/ttime.c

@@ -30,7 +30,7 @@ static int64_t m_deltaUtc = 0;
 
 void deltaToUtcInitOnce() {
   struct tm tm = {0};
-  if (taosStrpTime("1970-01-01 00:00:00", (const char*)("%Y-%m-%d %H:%M:%S"), &tm) != 0) {
+  if (taosStrpTime("1970-01-01 00:00:00", (const char*)("%Y-%m-%d %H:%M:%S"), &tm) == NULL) {
     uError("failed to parse time string");
   }
   m_deltaUtc = (int64_t)taosMktime(&tm);

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

@@ -1103,6 +1103,7 @@ static int32_t mndProcessShowVariablesReq(SRpcMsg *pReq) {
   (void)strcpy(info.name, "statusInterval");
   (void)snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsStatusInterval);
   (void)strcpy(info.scope, "server");
+  // fill info.info
   if (taosArrayPush(rsp.variables, &info) == NULL) {
     code = terrno;
     goto _OVER;

source/dnode/vnode/inc/vnode.h

@@ -172,7 +172,7 @@ void         tsdbReleaseDataBlock2(STsdbReader *pReader);
 int32_t      tsdbRetrieveDataBlock2(STsdbReader *pReader, SSDataBlock **pBlock, SArray *pIdList);
 int32_t      tsdbReaderReset2(STsdbReader *pReader, SQueryTableDataCond *pCond);
 int32_t      tsdbGetFileBlocksDistInfo2(STsdbReader *pReader, STableBlockDistInfo *pTableBlockInfo);
-int64_t      tsdbGetNumOfRowsInMemTable2(STsdbReader *pHandle);
+int64_t      tsdbGetNumOfRowsInMemTable2(STsdbReader *pHandle, uint32_t *rows);
 void        *tsdbGetIdx2(SMeta *pMeta);
 void        *tsdbGetIvtIdx2(SMeta *pMeta);
 uint64_t     tsdbGetReaderMaxVersion2(STsdbReader *pReader);

source/dnode/vnode/src/tqCommon/tqCommon.c

@@ -1186,10 +1186,12 @@ int32_t tqStreamTaskProcessTaskResumeReq(void* handle, int64_t sversion, char* m
     streamMutexUnlock(&pHTask->lock);
 
     code = tqProcessTaskResumeImpl(handle, pHTask, sversion, pReq->igUntreated, fromVnode);
+    tqDebug("s-task:%s resume complete, code:%s", pHTask->id.idStr, tstrerror(code));
+
     streamMetaReleaseTask(pMeta, pHTask);
   }
 
-  return code;
+  return TSDB_CODE_SUCCESS;
 }
 
 int32_t tqStreamTasksGetTotalNum(SStreamMeta* pMeta) { return taosArrayGetSize(pMeta->pTaskList); }

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

@@ -25,82 +25,109 @@
 #define HASTYPE(_type, _t) (((_type) & (_t)) == (_t))
 
 static int32_t setFirstLastResColToNull(SColumnInfoData* pCol, int32_t row) {
-  char* buf = taosMemoryCalloc(1, pCol->info.bytes);
-  if (buf == NULL) {
-    return terrno;
-  }
+  int32_t        code = TSDB_CODE_SUCCESS;
+  int32_t        lino = 0;
+  char*          buf = NULL;
+  SFirstLastRes* pRes = NULL;
 
-  SFirstLastRes* pRes = (SFirstLastRes*)((char*)buf + VARSTR_HEADER_SIZE);
+  TSDB_CHECK_NULL(pCol, code, lino, _end, TSDB_CODE_INVALID_PARA);
+
+  buf = taosMemoryCalloc(1, pCol->info.bytes);
+  TSDB_CHECK_NULL(buf, code, lino, _end, terrno);
+
+  pRes = (SFirstLastRes*)((char*)buf + VARSTR_HEADER_SIZE);
   pRes->bytes = 0;
   pRes->hasResult = true;
   pRes->isNull = true;
   varDataSetLen(buf, pCol->info.bytes - VARSTR_HEADER_SIZE);
-  int32_t code = colDataSetVal(pCol, row, buf, false);
-  taosMemoryFree(buf);
+  code = colDataSetVal(pCol, row, buf, false);
+  TSDB_CHECK_CODE(code, lino, _end);
 
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
+  if (buf != NULL) {
+    taosMemoryFreeClear(buf);
+  }
   return code;
 }
 
 static int32_t saveOneRowForLastRaw(SLastCol* pColVal, SCacheRowsReader* pReader, const int32_t slotId,
-                                 SColumnInfoData* pColInfoData, int32_t numOfRows) {
-  SColVal* pVal = &pColVal->colVal;
-  int32_t code = 0;
+                                    SColumnInfoData* pColInfoData, int32_t numOfRows) {
+  int32_t  code = TSDB_CODE_SUCCESS;
+  int32_t  lino = 0;
+  SColVal* pVal = NULL;
+
+  TSDB_CHECK_NULL(pColVal, code, lino, _end, TSDB_CODE_INVALID_PARA);
+  TSDB_CHECK_NULL(pColInfoData, code, lino, _end, TSDB_CODE_INVALID_PARA);
+
+  pVal = &pColVal->colVal;
 
   // allNullRow = false;
   if (IS_VAR_DATA_TYPE(pColVal->colVal.value.type)) {
     if (!COL_VAL_IS_VALUE(&pColVal->colVal)) {
       colDataSetNULL(pColInfoData, numOfRows);
     } else {
+      TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);
       varDataSetLen(pReader->transferBuf[slotId], pVal->value.nData);
 
       memcpy(varDataVal(pReader->transferBuf[slotId]), pVal->value.pData, pVal->value.nData);
       code = colDataSetVal(pColInfoData, numOfRows, pReader->transferBuf[slotId], false);
+      TSDB_CHECK_CODE(code, lino, _end);
     }
   } else {
     code = colDataSetVal(pColInfoData, numOfRows, (const char*)&pVal->value.val, !COL_VAL_IS_VALUE(pVal));
+    TSDB_CHECK_CODE(code, lino, _end);
   }
 
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
   return code;
 }
 
 static int32_t saveOneRow(SArray* pRow, SSDataBlock* pBlock, SCacheRowsReader* pReader, const int32_t* slotIds,
                           const int32_t* dstSlotIds, void** pRes, const char* idStr) {
-  int32_t numOfRows = pBlock->info.rows;
-  int32_t code = 0;
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
+  int32_t numOfRows = 0;
+  SArray* funcTypeBlockArray = NULL;
+
+  TSDB_CHECK_NULL(pBlock, code, lino, _end, TSDB_CODE_INVALID_PARA);
+  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);
+  if (pReader->numOfCols > 0) {
+    TSDB_CHECK_NULL(slotIds, code, lino, _end, TSDB_CODE_INVALID_PARA);
+    TSDB_CHECK_NULL(dstSlotIds, code, lino, _end, TSDB_CODE_INVALID_PARA);
+    TSDB_CHECK_NULL(pRes, code, lino, _end, TSDB_CODE_INVALID_PARA);
+  }
+
+  numOfRows = pBlock->info.rows;
 
   if (HASTYPE(pReader->type, CACHESCAN_RETRIEVE_LAST)) {
     uint64_t       ts = TSKEY_MIN;
     SFirstLastRes* p = NULL;
     col_id_t       colId = -1;
 
-    SArray* funcTypeBlockArray = taosArrayInit(pReader->numOfCols, sizeof(int32_t));
-    if (funcTypeBlockArray == NULL) {
-      return terrno;
-    }
+    funcTypeBlockArray = taosArrayInit(pReader->numOfCols, sizeof(int32_t));
+    TSDB_CHECK_NULL(funcTypeBlockArray, code, lino, _end, terrno);
 
     for (int32_t i = 0; i < pReader->numOfCols; ++i) {
       SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, dstSlotIds[i]);
-      if (pColInfoData == NULL) {
-        return TSDB_CODE_INVALID_PARA;
-      }
+      TSDB_CHECK_NULL(pColInfoData, code, lino, _end, TSDB_CODE_INVALID_PARA);
 
       int32_t funcType = FUNCTION_TYPE_CACHE_LAST;
       if (pReader->pFuncTypeList != NULL && taosArrayGetSize(pReader->pFuncTypeList) > i) {
         void* pVal = taosArrayGet(pReader->pFuncTypeList, i);
-        if (pVal == NULL) {
-          return TSDB_CODE_INVALID_PARA;
-        }
+        TSDB_CHECK_NULL(pVal, code, lino, _end, TSDB_CODE_INVALID_PARA);
 
-        funcType = *(int32_t*) pVal;
+        funcType = *(int32_t*)pVal;
         pVal = taosArrayGet(pReader->pFuncTypeList, i);
-        if (pVal == NULL) {
-          return TSDB_CODE_INVALID_PARA;
-        }
+        TSDB_CHECK_NULL(pVal, code, lino, _end, TSDB_CODE_INVALID_PARA);
 
         void* px = taosArrayInsert(funcTypeBlockArray, dstSlotIds[i], pVal);
-        if (px == NULL) {
-          return terrno;
-        }
+        TSDB_CHECK_NULL(px, code, lino, _end, terrno);
       }
 
       if (slotIds[i] == -1) {
@@ -110,24 +137,18 @@ static int32_t saveOneRow(SArray* pRow, SSDataBlock* pBlock, SCacheRowsReader* p
         }
 
         code = setFirstLastResColToNull(pColInfoData, numOfRows);
-        if (code) {
-          return code;
-        }
+        TSDB_CHECK_CODE(code, lino, _end);
         continue;
       }
 
       int32_t   slotId = slotIds[i];
       SLastCol* pColVal = (SLastCol*)taosArrayGet(pRow, i);
-      if (pColVal == NULL) {
-        return TSDB_CODE_INVALID_PARA;
-      }
+      TSDB_CHECK_NULL(pColVal, code, lino, _end, TSDB_CODE_INVALID_PARA);
 
       colId = pColVal->colVal.cid;
       if (FUNCTION_TYPE_CACHE_LAST_ROW == funcType) {
         code = saveOneRowForLastRaw(pColVal, pReader, slotId, pColInfoData, numOfRows);
-        if (code) {
-          return code;
-        }
+        TSDB_CHECK_CODE(code, lino, _end);
 
         continue;
       }
@@ -154,22 +175,16 @@ static int32_t saveOneRow(SArray* pRow, SSDataBlock* pBlock, SCacheRowsReader* p
       p->hasResult = true;
       varDataSetLen(pRes[i], pColInfoData->info.bytes - VARSTR_HEADER_SIZE);
       code = colDataSetVal(pColInfoData, numOfRows, (const char*)pRes[i], false);
-      if (code) {
-        return code;
-      }
+      TSDB_CHECK_CODE(code, lino, _end);
     }
 
     for (int32_t idx = 0; idx < taosArrayGetSize(pBlock->pDataBlock); ++idx) {
       SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, idx);
-      if (pCol == NULL) {
-        return TSDB_CODE_INVALID_PARA;
-      }
+      TSDB_CHECK_NULL(pCol, code, lino, _end, TSDB_CODE_INVALID_PARA);
 
       if (idx < funcTypeBlockArray->size) {
         void* pVal = taosArrayGet(funcTypeBlockArray, idx);
-        if (pVal == NULL) {
-          return TSDB_CODE_INVALID_PARA;
-        }
+        TSDB_CHECK_NULL(pVal, code, lino, _end, TSDB_CODE_INVALID_PARA);
 
         int32_t funcType = *(int32_t*)pVal;
         if (FUNCTION_TYPE_CACHE_LAST_ROW == funcType) {
@@ -182,17 +197,13 @@ static int32_t saveOneRow(SArray* pRow, SSDataBlock* pBlock, SCacheRowsReader* p
           colDataSetNULL(pCol, numOfRows);
         } else {
           code = colDataSetVal(pCol, numOfRows, (const char*)&ts, false);
-          if (code) {
-            return code;
-          }
+          TSDB_CHECK_CODE(code, lino, _end);
         }
         continue;
       } else if (pReader->numOfCols == 1 && idx != dstSlotIds[0] && (pCol->info.colId == colId || colId == -1)) {
         if (p && !p->isNull) {
           code = colDataSetVal(pCol, numOfRows, p->buf, false);
-          if (code) {
-            return code;
-          }
+          TSDB_CHECK_CODE(code, lino, _end);
         } else {
           colDataSetNULL(pCol, numOfRows);
         }
@@ -201,13 +212,10 @@ static int32_t saveOneRow(SArray* pRow, SSDataBlock* pBlock, SCacheRowsReader* p
 
     // pBlock->info.rows += allNullRow ? 0 : 1;
     ++pBlock->info.rows;
-    taosArrayDestroy(funcTypeBlockArray);
   } else if (HASTYPE(pReader->type, CACHESCAN_RETRIEVE_LAST_ROW)) {
     for (int32_t i = 0; i < pReader->numOfCols; ++i) {
       SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, dstSlotIds[i]);
-      if (pColInfoData == NULL) {
-        return TSDB_CODE_INVALID_PARA;
-      }
+      TSDB_CHECK_NULL(pColInfoData, code, lino, _end, TSDB_CODE_INVALID_PARA);
 
       int32_t slotId = slotIds[i];
       if (slotId == -1) {
@@ -216,47 +224,53 @@ static int32_t saveOneRow(SArray* pRow, SSDataBlock* pBlock, SCacheRowsReader* p
       }
 
       SLastCol* pColVal = (SLastCol*)taosArrayGet(pRow, i);
-      if (pColVal == NULL) {
-        return TSDB_CODE_INVALID_PARA;
-      }
+      TSDB_CHECK_NULL(pColVal, code, lino, _end, TSDB_CODE_INVALID_PARA);
 
       code = saveOneRowForLastRaw(pColVal, pReader, slotId, pColInfoData, numOfRows);
-      if (code) {
-        return code;
-      }
+      TSDB_CHECK_CODE(code, lino, _end);
     }
 
     // pBlock->info.rows += allNullRow ? 0 : 1;
     ++pBlock->info.rows;
   } else {
     tsdbError("invalid retrieve type:%d, %s", pReader->type, idStr);
-    return TSDB_CODE_INVALID_PARA;
+    code = TSDB_CODE_INVALID_PARA;
+    TSDB_CHECK_CODE(code, lino, _end);
   }
 
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
+  if (funcTypeBlockArray != NULL) {
+    taosArrayDestroy(funcTypeBlockArray);
+  }
   return code;
 }
 
 static int32_t setTableSchema(SCacheRowsReader* p, uint64_t suid, const char* idstr) {
-  int32_t numOfTables = p->numOfTables;
-  int32_t  code = TSDB_CODE_SUCCESS;
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
+  int32_t numOfTables = 0;
+
+  TSDB_CHECK_NULL(p, code, lino, _end, TSDB_CODE_INVALID_PARA);
+
+  numOfTables = p->numOfTables;
 
   if (suid != 0) {
     code = metaGetTbTSchemaNotNull(p->pVnode->pMeta, suid, -1, 1, &p->pSchema);
     if (TSDB_CODE_SUCCESS != code) {
       tsdbWarn("stable:%" PRIu64 " has been dropped, failed to retrieve cached rows, %s", suid, idstr);
-      if(code == TSDB_CODE_NOT_FOUND) {
-        return TSDB_CODE_PAR_TABLE_NOT_EXIST;
-      }  else {
-        return code;
+      if (code == TSDB_CODE_NOT_FOUND) {
+        code = TSDB_CODE_PAR_TABLE_NOT_EXIST;
       }
+      TSDB_CHECK_CODE(code, lino, _end);
     }
   } else {
     for (int32_t i = 0; i < numOfTables; ++i) {
       uint64_t uid = p->pTableList[i].uid;
       code = metaGetTbTSchemaMaybeNull(p->pVnode->pMeta, uid, -1, 1, &p->pSchema);
-      if(code != TSDB_CODE_SUCCESS) {
-        return code;
-      }
+      TSDB_CHECK_CODE(code, lino, _end);
       if (p->pSchema != NULL) {
         break;
       }
@@ -267,33 +281,52 @@ static int32_t setTableSchema(SCacheRowsReader* p, uint64_t suid, const char* id
     // all queried tables have been dropped already, return immediately.
     if (p->pSchema == NULL) {
       tsdbWarn("all queried tables has been dropped, try next group, %s", idstr);
-      return TSDB_CODE_PAR_TABLE_NOT_EXIST;
+      code = TSDB_CODE_PAR_TABLE_NOT_EXIST;
+      TSDB_CHECK_CODE(code, lino, _end);
     }
   }
 
-  return TSDB_CODE_SUCCESS;
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
+  return code;
 }
 
 int32_t tsdbReuseCacherowsReader(void* reader, void* pTableIdList, int32_t numOfTables) {
+  int32_t           code = TSDB_CODE_SUCCESS;
+  int32_t           lino = 0;
   SCacheRowsReader* pReader = (SCacheRowsReader*)reader;
 
+  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);
+
   pReader->pTableList = pTableIdList;
   pReader->numOfTables = numOfTables;
   pReader->lastTs = INT64_MIN;
   destroySttBlockReader(pReader->pLDataIterArray, NULL);
   pReader->pLDataIterArray = taosArrayInit(4, POINTER_BYTES);
+  TSDB_CHECK_NULL(pReader->pLDataIterArray, code, lino, _end, terrno);
 
-  return (pReader->pLDataIterArray != NULL) ? TSDB_CODE_SUCCESS : terrno;
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
+  return code;
 }
 
 int32_t tsdbCacherowsReaderOpen(void* pVnode, int32_t type, void* pTableIdList, int32_t numOfTables, int32_t numOfCols,
                                 SArray* pCidList, int32_t* pSlotIds, uint64_t suid, void** pReader, const char* idstr,
                                 SArray* pFuncTypeList, SColumnInfo* pPkCol, int32_t numOfPks) {
+  int32_t           code = TSDB_CODE_SUCCESS;
+  int32_t           lino = 0;
+  SCacheRowsReader* p = NULL;
+
+  TSDB_CHECK_NULL(pVnode, code, lino, _end, TSDB_CODE_INVALID_PARA);
+  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);
+
   *pReader = NULL;
-  SCacheRowsReader* p = taosMemoryCalloc(1, sizeof(SCacheRowsReader));
-  if (p == NULL) {
-    return terrno;
-  }
+  p = taosMemoryCalloc(1, sizeof(SCacheRowsReader));
+  TSDB_CHECK_NULL(p, code, lino, _end, terrno);
 
   p->type = type;
   p->pVnode = pVnode;
@@ -307,12 +340,13 @@ int32_t tsdbCacherowsReaderOpen(void* pVnode, int32_t type, void* pTableIdList,
 
   p->rowKey.numOfPKs = numOfPks;
   if (numOfPks > 0) {
+    TSDB_CHECK_NULL(pPkCol, code, lino, _end, TSDB_CODE_INVALID_PARA);
     p->rowKey.pks[0].type = pPkCol->type;
     if (IS_VAR_DATA_TYPE(pPkCol->type)) {
       p->rowKey.pks[0].pData = taosMemoryCalloc(1, pPkCol->bytes);
       if (p->rowKey.pks[0].pData == NULL) {
-        taosMemoryFree(p);
-        return terrno;
+        taosMemoryFreeClear(p);
+        TSDB_CHECK_NULL(p->rowKey.pks[0].pData, code, lino, _end, terrno);
       }
     }
 
@@ -321,48 +355,46 @@ int32_t tsdbCacherowsReaderOpen(void* pVnode, int32_t type, void* pTableIdList,
 
   if (numOfTables == 0) {
     *pReader = p;
-    return TSDB_CODE_SUCCESS;
+    p = NULL;
+    goto _end;
   }
 
   p->pTableList = pTableIdList;
   p->numOfTables = numOfTables;
 
-  int32_t code = setTableSchema(p, suid, idstr);
-  if (code != TSDB_CODE_SUCCESS) {
-    tsdbCacherowsReaderClose(p);
-    return code;
-  }
+  code = setTableSchema(p, suid, idstr);
+  TSDB_CHECK_CODE(code, lino, _end);
 
   p->transferBuf = taosMemoryCalloc(p->pSchema->numOfCols, POINTER_BYTES);
-  if (p->transferBuf == NULL) {
-    tsdbCacherowsReaderClose(p);
-    return terrno;
-  }
+  TSDB_CHECK_NULL(p->transferBuf, code, lino, _end, terrno);
 
   for (int32_t i = 0; i < p->pSchema->numOfCols; ++i) {
     if (IS_VAR_DATA_TYPE(p->pSchema->columns[i].type)) {
       p->transferBuf[i] = taosMemoryMalloc(p->pSchema->columns[i].bytes);
-      if (p->transferBuf[i] == NULL) {
-        tsdbCacherowsReaderClose(p);
-        return terrno;
-      }
+      TSDB_CHECK_NULL(p->transferBuf[i], code, lino, _end, terrno);
     }
   }
 
-  p->idstr = taosStrdup(idstr);
-  if (idstr != NULL && p->idstr == NULL) {
-    tsdbCacherowsReaderClose(p);
-    return terrno;
+  if (idstr != NULL) {
+    p->idstr = taosStrdup(idstr);
+    TSDB_CHECK_NULL(p->idstr, code, lino, _end, terrno);
   }
   code = taosThreadMutexInit(&p->readerMutex, NULL);
-  if (code) {
-    tsdbCacherowsReaderClose(p);
-    return code;
-  }
+  TSDB_CHECK_CODE(code, lino, _end);
 
   p->lastTs = INT64_MIN;
 
   *pReader = p;
+  p = NULL;
+
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+    *pReader = NULL;
+  }
+  if (p != NULL) {
+    tsdbCacherowsReaderClose(p);
+  }
   return code;
 }
 
@@ -393,6 +425,7 @@ void tsdbCacherowsReaderClose(void* pReader) {
 
   if (p->pLDataIterArray) {
     destroySttBlockReader(p->pLDataIterArray, NULL);
+    p->pLDataIterArray = NULL;
   }
 
   if (p->pFileReader) {
@@ -401,7 +434,7 @@ void tsdbCacherowsReaderClose(void* pReader) {
   }
 
   taosMemoryFree((void*)p->idstr);
-  (void) taosThreadMutexDestroy(&p->readerMutex);
+  (void)taosThreadMutexDestroy(&p->readerMutex);
 
   if (p->pTableMap) {
     void*   pe = NULL;
@@ -443,39 +476,32 @@ static int32_t tsdbCacheQueryReseek(void* pQHandle) {
 
 int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32_t* slotIds, const int32_t* dstSlotIds,
                               SArray* pTableUidList, bool* pGotAll) {
-  if (pReader == NULL || pResBlock == NULL) {
-    return TSDB_CODE_INVALID_PARA;
-  }
-
   int32_t           code = TSDB_CODE_SUCCESS;
+  int32_t           lino = 0;
   bool              hasRes = false;
   SArray*           pRow = NULL;
   void**            pRes = NULL;
-  SCacheRowsReader* pr = pReader;
+  SCacheRowsReader* pr = NULL;
   int32_t           pkBufLen = 0;
 
+  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);
+  TSDB_CHECK_NULL(pResBlock, code, lino, _end, TSDB_CODE_INVALID_PARA);
+
+  pr = pReader;
+
   pr->pReadSnap = NULL;
   pRow = taosArrayInit(TARRAY_SIZE(pr->pCidList), sizeof(SLastCol));
-  if (pRow == NULL) {
-    code = terrno;
-    goto _end;
-  }
+  TSDB_CHECK_NULL(pRow, code, lino, _end, terrno);
 
   pRes = taosMemoryCalloc(pr->numOfCols, POINTER_BYTES);
-  if (pRes == NULL) {
-    code = terrno;
-    goto _end;
-  }
+  TSDB_CHECK_NULL(pRes, code, lino, _end, terrno);
 
   pkBufLen = (pr->rowKey.numOfPKs > 0) ? pr->pkColumn.bytes : 0;
   for (int32_t j = 0; j < pr->numOfCols; ++j) {
     int32_t bytes = (slotIds[j] == -1) ? 1 : pr->pSchema->columns[slotIds[j]].bytes;
 
     pRes[j] = taosMemoryCalloc(1, sizeof(SFirstLastRes) + bytes + pkBufLen + VARSTR_HEADER_SIZE);
-    if (pRes[j] == NULL) {
-      code = terrno;
-      goto _end;
-    }
+    TSDB_CHECK_NULL(pRes[j], code, lino, _end, terrno);
 
     SFirstLastRes* p = (SFirstLastRes*)varDataVal(pRes[j]);
     p->ts = INT64_MIN;
@@ -483,9 +509,7 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
 
   (void)taosThreadMutexLock(&pr->readerMutex);
   code = tsdbTakeReadSnap2((STsdbReader*)pr, tsdbCacheQueryReseek, &pr->pReadSnap, pr->idstr);
-  if (code != TSDB_CODE_SUCCESS) {
-    goto _end;
-  }
+  TSDB_CHECK_CODE(code, lino, _end);
 
   int8_t ltype = (pr->type & CACHESCAN_RETRIEVE_LAST) >> 3;
 
@@ -494,20 +518,14 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
   // retrieve the only one last row of all tables in the uid list.
   if (HASTYPE(pr->type, CACHESCAN_RETRIEVE_TYPE_SINGLE)) {
     SArray* pLastCols = taosArrayInit(pr->numOfCols, sizeof(SLastCol));
-    if (pLastCols == NULL) {
-      code = terrno;
-      goto _end;
-    }
+    TSDB_CHECK_NULL(pLastCols, code, lino, _end, terrno);
 
     for (int32_t i = 0; i < pr->numOfCols; ++i) {
       int32_t slotId = slotIds[i];
       if (slotId == -1) {
         SLastCol p = {.rowKey.ts = INT64_MIN, .colVal.value.type = TSDB_DATA_TYPE_BOOL, .colVal.flag = CV_FLAG_NULL};
         void*    px = taosArrayPush(pLastCols, &p);
-        if (px == NULL) {
-          code = terrno;
-          goto _end;
-        }
+        TSDB_CHECK_NULL(px, code, lino, _end, terrno);
         continue;
       }
       struct STColumn* pCol = &pr->pSchema->columns[slotId];
@@ -518,29 +536,19 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
         for (int32_t j = 0; j < pr->rowKey.numOfPKs; j++) {
           p.rowKey.pks[j].type = pr->pkColumn.type;
           if (IS_VAR_DATA_TYPE(pr->pkColumn.type)) {
-
             p.rowKey.pks[j].pData = taosMemoryCalloc(1, pr->pkColumn.bytes);
-            if (p.rowKey.pks[j].pData == NULL) {
-              code = terrno;
-              goto _end;
-            }
+            TSDB_CHECK_NULL(p.rowKey.pks[j].pData, code, lino, _end, terrno);
           }
         }
       }
 
       if (IS_VAR_DATA_TYPE(pCol->type)) {
         p.colVal.value.pData = taosMemoryCalloc(pCol->bytes, sizeof(char));
-        if (p.colVal.value.pData == NULL) {
-          code = terrno;
-          goto _end;
-        }
+        TSDB_CHECK_NULL(p.colVal.value.pData, code, lino, _end, terrno);
       }
 
       void* px = taosArrayPush(pLastCols, &p);
-      if (px == NULL) {
-        code = terrno;
-        goto _end;
-      }
+      TSDB_CHECK_NULL(px, code, lino, _end, terrno);
     }
 
     int64_t st = taosGetTimestampUs();
@@ -549,11 +557,10 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
       tb_uid_t uid = pTableList[i].uid;
 
       code = tsdbCacheGetBatch(pr->pTsdb, uid, pRow, pr, ltype);
-      if (code == -1) {// fix the invalid return code
+      if (code == -1) {  // fix the invalid return code
         code = 0;
-      } else if (code != 0) {
-        goto _end;
       }
+      TSDB_CHECK_CODE(code, lino, _end);
 
       if (TARRAY_SIZE(pRow) <= 0 || COL_VAL_IS_NONE(&((SLastCol*)TARRAY_DATA(pRow))[0].colVal)) {
         taosArrayClearEx(pRow, tsdbCacheFreeSLastColItem);
@@ -600,10 +607,7 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
             if (k == 0) {
               if (TARRAY_SIZE(pTableUidList) == 0) {
                 void* px = taosArrayPush(pTableUidList, &uid);
-                if (px == NULL) {
-                  code = terrno;
-                  goto _end;
-                }
+                TSDB_CHECK_NULL(px, code, lino, _end, terrno);
               } else {
                 taosArraySet(pTableUidList, 0, &uid);
               }
@@ -654,9 +658,7 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
 
     if (hasRes) {
       code = saveOneRow(pLastCols, pResBlock, pr, slotIds, dstSlotIds, pRes, pr->idstr);
-      if (code) {
-        goto _end;
-      }
+      TSDB_CHECK_CODE(code, lino, _end);
     }
 
     taosArrayDestroyEx(pLastCols, tsdbCacheFreeSLastColItem);
@@ -666,11 +668,10 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
       tb_uid_t uid = pTableList[i].uid;
 
       if ((code = tsdbCacheGetBatch(pr->pTsdb, uid, pRow, pr, ltype)) != 0) {
-        if (code == -1) {// fix the invalid return code
+        if (code == -1) {  // fix the invalid return code
           code = 0;
-        } else if (code != 0) {
-          goto _end;
         }
+        TSDB_CHECK_CODE(code, lino, _end);
       }
 
       if (TARRAY_SIZE(pRow) <= 0 || COL_VAL_IS_NONE(&((SLastCol*)TARRAY_DATA(pRow))[0].colVal)) {
@@ -679,17 +680,12 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
       }
 
       code = saveOneRow(pRow, pResBlock, pr, slotIds, dstSlotIds, pRes, pr->idstr);
-      if (code) {
-        goto _end;
-      }
+      TSDB_CHECK_CODE(code, lino, _end);
 
       taosArrayClearEx(pRow, tsdbCacheFreeSLastColItem);
 
       void* px = taosArrayPush(pTableUidList, &uid);
-      if (px == NULL) {
-        code = terrno;
-        goto _end;
-      }
+      TSDB_CHECK_NULL(px, code, lino, _end, terrno);
 
       ++pr->tableIndex;
       if (pResBlock->info.rows >= pResBlock->info.capacity) {
@@ -702,6 +698,7 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
     }
   } else {
     code = TSDB_CODE_INVALID_PARA;
+    TSDB_CHECK_CODE(code, lino, _end);
   }
 
 _end:
@@ -723,5 +720,8 @@ _end:
   taosMemoryFree(pRes);
   taosArrayDestroy(pRow);
 
+  if (code != TSDB_CODE_SUCCESS) {
+    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
   return code;
 }

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

@@ -30,13 +30,13 @@ extern "C" {
   do {                      \
     (_w)->skey = INT64_MAX; \
     (_w)->ekey = INT64_MIN; \
-  } while (0);
+  } while (0)
 
 #define INIT_KEYRANGE(_k)      \
   do {                         \
     (_k)->skey.ts = INT64_MAX; \
     (_k)->ekey.ts = INT64_MIN; \
-  } while (0);
+  } while (0)
 
 #define tRowGetKeyEx(_pRow, _pKey)                                         \
   {                                                                        \
@@ -72,7 +72,6 @@ typedef struct STsdbReaderInfo {
 } STsdbReaderInfo;
 
 typedef struct SBlockInfoBuf {
-  int32_t currentIndex;
   SArray* pData;
   int32_t numPerBucket;
   int32_t numOfTables;
@@ -241,7 +240,6 @@ typedef struct SDataBlockIter {
   int32_t    index;
   SArray*    blockList;  // SArray<SFileDataBlockInfo>
   int32_t    order;
-  SDataBlk   block;  // current SDataBlk data
 } SDataBlockIter;
 
 typedef struct SFileBlockDumpInfo {
@@ -321,7 +319,7 @@ int32_t createDataBlockScanInfo(STsdbReader* pTsdbReader, SBlockInfoBuf* pBuf, c
 int32_t initTableBlockScanInfo(STableBlockScanInfo* pScanInfo, uint64_t uid, SSHashObj* pTableMap,
                                STsdbReader* pReader);
 void    clearBlockScanInfo(STableBlockScanInfo* p);
-void    destroyAllBlockScanInfo(SSHashObj* pTableMap);
+void    destroyAllBlockScanInfo(SSHashObj** pTableMap);
 void    resetAllDataBlockScanInfo(SSHashObj* pTableMap, int64_t ts, int32_t step);
 void    cleanupInfoForNextFileset(SSHashObj* pTableMap);
 int32_t ensureBlockScanInfoBuf(SBlockInfoBuf* pBuf, int32_t numOfTables);
@@ -335,7 +333,7 @@ void    clearBrinBlockIter(SBrinRecordIter* pIter);
 
 // initialize block iterator API
 int32_t initBlockIterator(STsdbReader* pReader, SDataBlockIter* pBlockIter, int32_t numOfBlocks, SArray* pTableList);
-bool    blockIteratorNext(SDataBlockIter* pBlockIter, const char* idStr);
+bool    blockIteratorNext(SDataBlockIter* pBlockIter);
 
 // load tomb data API (stt/mem only for one table each, tomb data from data files are load for all tables at one time)
 int32_t loadMemTombData(SArray** ppMemDelData, STbData* pMemTbData, STbData* piMemTbData, int64_t ver);

source/libs/command/src/command.c

@@ -35,6 +35,9 @@
 extern SConfig* tsCfg;
 
 static int32_t buildRetrieveTableRsp(SSDataBlock* pBlock, int32_t numOfCols, SRetrieveTableRsp** pRsp) {
+  if (NULL == pBlock || NULL == pRsp) {
+    return TSDB_CODE_INVALID_PARA;
+  }
   size_t dataEncodeBufSize = blockGetEncodeSize(pBlock);
   size_t rspSize = sizeof(SRetrieveTableRsp) + dataEncodeBufSize + PAYLOAD_PREFIX_LEN;
   *pRsp = taosMemoryCalloc(1, rspSize);
@@ -53,6 +56,7 @@ static int32_t buildRetrieveTableRsp(SSDataBlock* pBlock, int32_t numOfCols, SRe
   int32_t len = blockEncode(pBlock, (*pRsp)->data + PAYLOAD_PREFIX_LEN, dataEncodeBufSize, numOfCols);
   if(len < 0) {
     taosMemoryFree(*pRsp);
+    *pRsp = NULL;
     return terrno;
   }
   SET_PAYLOAD_LEN((*pRsp)->data, len, len);
@@ -216,6 +220,9 @@ static int32_t setDescResultIntoDataBlock(bool sysInfoUser, SSDataBlock* pBlock,
 
 static int32_t execDescribe(bool sysInfoUser, SNode* pStmt, SRetrieveTableRsp** pRsp, int8_t biMode) {
   SDescribeStmt* pDesc = (SDescribeStmt*)pStmt;
+  if (NULL == pDesc || NULL == pDesc->pMeta) {
+    return TSDB_CODE_INVALID_PARA;
+  }
   int32_t        numOfRows = TABLE_TOTAL_COL_NUM(pDesc->pMeta);
 
   SSDataBlock* pBlock = NULL;
@@ -505,7 +512,7 @@ static int32_t buildCreateViewResultDataBlock(SSDataBlock** pOutput) {
   return code;
 }
 
-void appendColumnFields(char* buf, int32_t* len, STableCfg* pCfg) {
+static void appendColumnFields(char* buf, int32_t* len, STableCfg* pCfg) {
   for (int32_t i = 0; i < pCfg->numOfColumns; ++i) {
     SSchema* pSchema = pCfg->pSchemas + i;
 #define LTYPE_LEN (32 + 60)  // 60 byte for compress info
@@ -539,7 +546,7 @@ void appendColumnFields(char* buf, int32_t* len, STableCfg* pCfg) {
   }
 }
 
-void appendTagFields(char* buf, int32_t* len, STableCfg* pCfg) {
+static void appendTagFields(char* buf, int32_t* len, STableCfg* pCfg) {
   for (int32_t i = 0; i < pCfg->numOfTags; ++i) {
     SSchema* pSchema = pCfg->pSchemas + pCfg->numOfColumns + i;
     char     type[32];
@@ -558,7 +565,7 @@ void appendTagFields(char* buf, int32_t* len, STableCfg* pCfg) {
   }
 }
 
-void appendTagNameFields(char* buf, int32_t* len, STableCfg* pCfg) {
+static void appendTagNameFields(char* buf, int32_t* len, STableCfg* pCfg) {
   for (int32_t i = 0; i < pCfg->numOfTags; ++i) {
     SSchema* pSchema = pCfg->pSchemas + pCfg->numOfColumns + i;
     *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),
@@ -566,7 +573,7 @@ void appendTagNameFields(char* buf, int32_t* len, STableCfg* pCfg) {
   }
 }
 
-int32_t appendTagValues(char* buf, int32_t* len, STableCfg* pCfg) {
+static int32_t appendTagValues(char* buf, int32_t* len, STableCfg* pCfg) {
   int32_t code = TSDB_CODE_SUCCESS;
   SArray* pTagVals = NULL;
   STag*   pTag = (STag*)pCfg->pTags;
@@ -643,7 +650,7 @@ _exit:
   return code;
 }
 
-void appendTableOptions(char* buf, int32_t* len, SDbCfgInfo* pDbCfg, STableCfg* pCfg) {
+static void appendTableOptions(char* buf, int32_t* len, SDbCfgInfo* pDbCfg, STableCfg* pCfg) {
   if (pCfg->commentLen > 0) {
     *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),
                       " COMMENT '%s'", pCfg->pComment);
@@ -947,12 +954,18 @@ static int32_t buildLocalVariablesResultDataBlock(SSDataBlock** pOutput) {
     goto _exit;
   }
 
+  infoData.info.type = TSDB_DATA_TYPE_VARCHAR;
+  infoData.info.bytes = SHOW_LOCAL_VARIABLES_RESULT_FIELD4_LEN;
+  if (taosArrayPush(pBlock->pDataBlock, &infoData) == NULL) {
+    goto _exit;
+  }
+
   *pOutput = pBlock;
 
 _exit:
   if (terrno != TSDB_CODE_SUCCESS) {
-    taosMemoryFree(pBlock);
     taosArrayDestroy(pBlock->pDataBlock);
+    taosMemoryFree(pBlock);
   }
   return terrno;
 }
@@ -997,7 +1010,7 @@ static int32_t createSelectResultDataBlock(SNodeList* pProjects, SSDataBlock** p
   return code;
 }
 
-int32_t buildSelectResultDataBlock(SNodeList* pProjects, SSDataBlock* pBlock) {
+static int32_t buildSelectResultDataBlock(SNodeList* pProjects, SSDataBlock* pBlock) {
   QRY_ERR_RET(blockDataEnsureCapacity(pBlock, 1));
 
   int32_t index = 0;

source/libs/command/src/explain.c

@@ -30,8 +30,8 @@ char *gJoinTypeStr[JOIN_TYPE_MAX_VALUE][JOIN_STYPE_MAX_VALUE] = {
 /*FULL*/   {"Full Join",          "Full Join",           NULL,                 NULL,                  NULL,                  NULL},
 };
 
-int32_t qExplainGenerateResNode(SPhysiNode *pNode, SExplainGroup *group, SExplainResNode **pRes);
-int32_t qExplainAppendGroupResRows(void *pCtx, int32_t groupId, int32_t level, bool singleChannel);
+static int32_t qExplainGenerateResNode(SPhysiNode *pNode, SExplainGroup *group, SExplainResNode **pRes);
+static int32_t qExplainAppendGroupResRows(void *pCtx, int32_t groupId, int32_t level, bool singleChannel);
 
 char *qExplainGetDynQryCtrlType(EDynQueryType type) {
   switch (type) {
@@ -118,7 +118,7 @@ void qExplainFreeCtx(SExplainCtx *pCtx) {
   taosMemoryFree(pCtx);
 }
 
-int32_t qExplainInitCtx(SExplainCtx **pCtx, SHashObj *groupHash, bool verbose, double ratio, EExplainMode mode) {
+static int32_t qExplainInitCtx(SExplainCtx **pCtx, SHashObj *groupHash, bool verbose, double ratio, EExplainMode mode) {
   int32_t      code = 0;
   SExplainCtx *ctx = taosMemoryCalloc(1, sizeof(SExplainCtx));
   if (NULL == ctx) {
@@ -158,7 +158,7 @@ _return:
   QRY_RET(code);
 }
 
-int32_t qExplainGenerateResChildren(SPhysiNode *pNode, SExplainGroup *group, SNodeList **pChildren) {
+static int32_t qExplainGenerateResChildren(SPhysiNode *pNode, SExplainGroup *group, SNodeList **pChildren) {
   int32_t    tlen = 0;
   SNodeList *pPhysiChildren = pNode->pChildren;
 
@@ -180,7 +180,7 @@ int32_t qExplainGenerateResChildren(SPhysiNode *pNode, SExplainGroup *group, SNo
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t qExplainGenerateResNodeExecInfo(SPhysiNode *pNode, SArray **pExecInfo, SExplainGroup *group) {
+static int32_t qExplainGenerateResNodeExecInfo(SPhysiNode *pNode, SArray **pExecInfo, SExplainGroup *group) {
   *pExecInfo = taosArrayInit(group->nodeNum, sizeof(SExplainExecInfo));
   if (NULL == (*pExecInfo)) {
     qError("taosArrayInit %d explainExecInfo failed", group->nodeNum);
@@ -217,7 +217,7 @@ int32_t qExplainGenerateResNodeExecInfo(SPhysiNode *pNode, SArray **pExecInfo, S
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t qExplainGenerateResNode(SPhysiNode *pNode, SExplainGroup *group, SExplainResNode **pResNode) {
+static int32_t qExplainGenerateResNode(SPhysiNode *pNode, SExplainGroup *group, SExplainResNode **pResNode) {
   if (NULL == pNode) {
     *pResNode = NULL;
     qError("physical node is NULL");
@@ -250,7 +250,7 @@ _return:
   QRY_RET(code);
 }
 
-int32_t qExplainBufAppendExecInfo(SArray *pExecInfo, char *tbuf, int32_t *len) {
+static int32_t qExplainBufAppendExecInfo(SArray *pExecInfo, char *tbuf, int32_t *len) {
   int32_t          tlen = *len;
   int32_t          nodeNum = taosArrayGetSize(pExecInfo);
   SExplainExecInfo maxExecInfo = {0};
@@ -275,7 +275,7 @@ int32_t qExplainBufAppendExecInfo(SArray *pExecInfo, char *tbuf, int32_t *len) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t qExplainBufAppendVerboseExecInfo(SArray *pExecInfo, char *tbuf, int32_t *len) {
+static int32_t qExplainBufAppendVerboseExecInfo(SArray *pExecInfo, char *tbuf, int32_t *len) {
   int32_t          tlen = 0;
   bool             gotVerbose = false;
   int32_t          nodeNum = taosArrayGetSize(pExecInfo);
@@ -297,7 +297,7 @@ int32_t qExplainBufAppendVerboseExecInfo(SArray *pExecInfo, char *tbuf, int32_t
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t qExplainResAppendRow(SExplainCtx *ctx, char *tbuf, int32_t len, int32_t level) {
+static int32_t qExplainResAppendRow(SExplainCtx *ctx, char *tbuf, int32_t len, int32_t level) {
   SQueryExplainRowInfo row = {0};
   row.buf = taosMemoryMalloc(len);
   if (NULL == row.buf) {
@@ -362,7 +362,7 @@ static char* qExplainGetScanDataLoad(STableScanPhysiNode* pScan) {
   return "unknown";
 }
 
-int32_t qExplainResNodeToRowsImpl(SExplainResNode *pResNode, SExplainCtx *ctx, int32_t level) {
+static int32_t qExplainResNodeToRowsImpl(SExplainResNode *pResNode, SExplainCtx *ctx, int32_t level) {
   int32_t     tlen = 0;
   bool        isVerboseLine = false;
   char       *tbuf = ctx->tbuf;
@@ -1900,7 +1900,7 @@ int32_t qExplainResNodeToRowsImpl(SExplainResNode *pResNode, SExplainCtx *ctx, i
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t qExplainResNodeToRows(SExplainResNode *pResNode, SExplainCtx *ctx, int32_t level) {
+static int32_t qExplainResNodeToRows(SExplainResNode *pResNode, SExplainCtx *ctx, int32_t level) {
   if (NULL == pResNode) {
     qError("explain res node is NULL");
     QRY_ERR_RET(TSDB_CODE_APP_ERROR);
@@ -1915,7 +1915,7 @@ int32_t qExplainResNodeToRows(SExplainResNode *pResNode, SExplainCtx *ctx, int32
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t qExplainAppendGroupResRows(void *pCtx, int32_t groupId, int32_t level, bool singleChannel) {
+static int32_t qExplainAppendGroupResRows(void *pCtx, int32_t groupId, int32_t level, bool singleChannel) {
   SExplainResNode *node = NULL;
   int32_t          code = 0;
   SExplainCtx     *ctx = (SExplainCtx *)pCtx;
@@ -1940,7 +1940,7 @@ _return:
   QRY_RET(code);
 }
 
-int32_t qExplainGetRspFromCtx(void *ctx, SRetrieveTableRsp **pRsp) {
+static int32_t qExplainGetRspFromCtx(void *ctx, SRetrieveTableRsp **pRsp) {
   int32_t      code = 0;
   SSDataBlock *pBlock = NULL;
   SExplainCtx *pCtx = (SExplainCtx *)ctx;
@@ -1997,7 +1997,7 @@ _return:
   QRY_RET(code);
 }
 
-int32_t qExplainPrepareCtx(SQueryPlan *pDag, SExplainCtx **pCtx) {
+static int32_t qExplainPrepareCtx(SQueryPlan *pDag, SExplainCtx **pCtx) {
   int32_t        code = 0;
   SNodeListNode *plans = NULL;
   int32_t        taskNum = 0;
@@ -2080,7 +2080,7 @@ _return:
   QRY_RET(code);
 }
 
-int32_t qExplainAppendPlanRows(SExplainCtx *pCtx) {
+static int32_t qExplainAppendPlanRows(SExplainCtx *pCtx) {
   if (EXPLAIN_MODE_ANALYZE != pCtx->mode) {
     return TSDB_CODE_SUCCESS;
   }
@@ -2103,7 +2103,7 @@ int32_t qExplainAppendPlanRows(SExplainCtx *pCtx) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t qExplainGenerateRsp(SExplainCtx *pCtx, SRetrieveTableRsp **pRsp) {
+static int32_t qExplainGenerateRsp(SExplainCtx *pCtx, SRetrieveTableRsp **pRsp) {
   QRY_ERR_RET(qExplainAppendGroupResRows(pCtx, pCtx->rootGroupId, 0, false));
   QRY_ERR_RET(qExplainAppendPlanRows(pCtx));
   QRY_ERR_RET(qExplainGetRspFromCtx(pCtx, pRsp));
@@ -2112,6 +2112,7 @@ int32_t qExplainGenerateRsp(SExplainCtx *pCtx, SRetrieveTableRsp **pRsp) {
 }
 
 int32_t qExplainUpdateExecInfo(SExplainCtx *pCtx, SExplainRsp *pRspMsg, int32_t groupId, SRetrieveTableRsp **pRsp) {
+  if(!pCtx || !pRspMsg || !pRsp) return TSDB_CODE_INVALID_PARA;
   SExplainResNode *node = NULL;
   int32_t          code = 0;
   bool             groupDone = false;
@@ -2176,6 +2177,7 @@ _exit:
 }
 
 int32_t qExecStaticExplain(SQueryPlan *pDag, SRetrieveTableRsp **pRsp) {
+  if (!pDag || !pRsp) return TSDB_CODE_INVALID_PARA;
   int32_t      code = 0;
   SExplainCtx *pCtx = NULL;
 
@@ -2188,6 +2190,7 @@ _return:
 }
 
 int32_t qExecExplainBegin(SQueryPlan *pDag, SExplainCtx **pCtx, int64_t startTs) {
+  if(!pDag || !pCtx) return TSDB_CODE_INVALID_PARA;
   QRY_ERR_RET(qExplainPrepareCtx(pDag, pCtx));
 
   (*pCtx)->reqStartTs = startTs;
@@ -2197,6 +2200,7 @@ int32_t qExecExplainBegin(SQueryPlan *pDag, SExplainCtx **pCtx, int64_t startTs)
 }
 
 int32_t qExecExplainEnd(SExplainCtx *pCtx, SRetrieveTableRsp **pRsp) {
+  if(!pCtx || !pRsp) return TSDB_CODE_INVALID_PARA;
   int32_t code = 0;
   pCtx->jobDoneTs = taosGetTimestampUs();
 

source/libs/executor/src/exchangeoperator.c

@@ -121,10 +121,10 @@ static void concurrentlyLoadRemoteDataImpl(SOperatorInfo* pOperator, SExchangeIn
           }
         } else {
           pDataInfo->status = EX_SOURCE_DATA_EXHAUSTED;
-          qDebug("%s vgId:%d, taskId:0x%" PRIx64 " execId:%d index:%d completed, rowsOfSource:%" PRIu64
-                 ", totalRows:%" PRIu64 ", try next %d/%" PRIzu,
-                 GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pSource->execId, i, pDataInfo->totalRows,
-                 pExchangeInfo->loadInfo.totalRows, i + 1, totalSources);
+          qDebug("%s vgId:%d, clientId:0x%" PRIx64 " taskId:0x%" PRIx64
+                 " execId:%d index:%d completed, rowsOfSource:%" PRIu64 ", totalRows:%" PRIu64 ", try next %d/%" PRIzu,
+                 GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->clientId, pSource->taskId, pSource->execId, i,
+                 pDataInfo->totalRows, pExchangeInfo->loadInfo.totalRows, i + 1, totalSources);
           taosMemoryFreeClear(pDataInfo->pRsp);
         }
         break;
@@ -141,17 +141,17 @@ static void concurrentlyLoadRemoteDataImpl(SOperatorInfo* pOperator, SExchangeIn
 
       if (pRsp->completed == 1) {
         pDataInfo->status = EX_SOURCE_DATA_EXHAUSTED;
-        qDebug("%s fetch msg rsp from vgId:%d, taskId:0x%" PRIx64
+        qDebug("%s fetch msg rsp from vgId:%d, clientId:0x%" PRIx64 " taskId:0x%" PRIx64
                " execId:%d index:%d completed, blocks:%d, numOfRows:%" PRId64 ", rowsOfSource:%" PRIu64
                ", totalRows:%" PRIu64 ", total:%.2f Kb, try next %d/%" PRIzu,
-               GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pSource->execId, i, pRsp->numOfBlocks,
-               pRsp->numOfRows, pDataInfo->totalRows, pLoadInfo->totalRows, pLoadInfo->totalSize / 1024.0, i + 1,
-               totalSources);
+               GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->clientId, pSource->taskId, pSource->execId, i,
+               pRsp->numOfBlocks, pRsp->numOfRows, pDataInfo->totalRows, pLoadInfo->totalRows,
+               pLoadInfo->totalSize / 1024.0, i + 1, totalSources);
       } else {
-        qDebug("%s fetch msg rsp from vgId:%d, taskId:0x%" PRIx64 " execId:%d blocks:%d, numOfRows:%" PRId64
-               ", totalRows:%" PRIu64 ", total:%.2f Kb",
-               GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pSource->execId, pRsp->numOfBlocks,
-               pRsp->numOfRows, pLoadInfo->totalRows, pLoadInfo->totalSize / 1024.0);
+        qDebug("%s fetch msg rsp from vgId:%d, clientId:0x%" PRIx64 " taskId:0x%" PRIx64
+               " execId:%d blocks:%d, numOfRows:%" PRId64 ", totalRows:%" PRIu64 ", total:%.2f Kb",
+               GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->clientId, pSource->taskId, pSource->execId,
+               pRsp->numOfBlocks, pRsp->numOfRows, pLoadInfo->totalRows, pLoadInfo->totalSize / 1024.0);
       }
 
       taosMemoryFreeClear(pDataInfo->pRsp);
@@ -640,9 +640,9 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas
 
   if (pSource->localExec) {
     SDataBuf pBuf = {0};
-    int32_t  code =
-        (*pTaskInfo->localFetch.fp)(pTaskInfo->localFetch.handle, pSource->schedId, pTaskInfo->id.queryId,
-                                    pSource->taskId, 0, pSource->execId, &pBuf.pData, pTaskInfo->localFetch.explainRes);
+    int32_t  code = (*pTaskInfo->localFetch.fp)(pTaskInfo->localFetch.handle, pSource->schedId, pTaskInfo->id.queryId,
+                                               pSource->clientId, pSource->taskId, 0, pSource->execId, &pBuf.pData,
+                                               pTaskInfo->localFetch.explainRes);
     code = loadRemoteDataCallback(pWrapper, &pBuf, code);
     QUERY_CHECK_CODE(code, lino, _end);
     taosMemoryFree(pWrapper);
@@ -650,6 +650,7 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas
     SResFetchReq req = {0};
     req.header.vgId = pSource->addr.nodeId;
     req.sId = pSource->schedId;
+    req.clientId = pSource->clientId;
     req.taskId = pSource->taskId;
     req.queryId = pTaskInfo->id.queryId;
     req.execId = pSource->execId;
@@ -691,9 +692,10 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas
 
     freeOperatorParam(req.pOpParam, OP_GET_PARAM);
 
-    qDebug("%s build fetch msg and send to vgId:%d, ep:%s, taskId:0x%" PRIx64 ", execId:%d, %p, %d/%" PRIzu,
-           GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->addr.epSet.eps[0].fqdn, pSource->taskId,
-           pSource->execId, pExchangeInfo, sourceIndex, totalSources);
+    qDebug("%s build fetch msg and send to vgId:%d, ep:%s, clientId:0x%" PRIx64 " taskId:0x%" PRIx64
+           ", execId:%d, %p, %d/%" PRIzu,
+           GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->addr.epSet.eps[0].fqdn, pSource->clientId,
+           pSource->taskId, pSource->execId, pExchangeInfo, sourceIndex, totalSources);
 
     // send the fetch remote task result reques
     SMsgSendInfo* pMsgSendInfo = taosMemoryCalloc(1, sizeof(SMsgSendInfo));
@@ -974,8 +976,9 @@ int32_t seqLoadRemoteData(SOperatorInfo* pOperator) {
     }
 
     if (pDataInfo->code != TSDB_CODE_SUCCESS) {
-      qError("%s vgId:%d, taskID:0x%" PRIx64 " execId:%d error happens, code:%s", GET_TASKID(pTaskInfo),
-             pSource->addr.nodeId, pSource->taskId, pSource->execId, tstrerror(pDataInfo->code));
+      qError("%s vgId:%d, clientId:0x%" PRIx64 " taskID:0x%" PRIx64 " execId:%d error happens, code:%s",
+             GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->clientId, pSource->taskId, pSource->execId,
+             tstrerror(pDataInfo->code));
       pOperator->pTaskInfo->code = pDataInfo->code;
       return pOperator->pTaskInfo->code;
     }
@@ -984,10 +987,10 @@ int32_t seqLoadRemoteData(SOperatorInfo* pOperator) {
     SLoadRemoteDataInfo* pLoadInfo = &pExchangeInfo->loadInfo;
 
     if (pRsp->numOfRows == 0) {
-      qDebug("%s vgId:%d, taskID:0x%" PRIx64 " execId:%d %d of total completed, rowsOfSource:%" PRIu64
-             ", totalRows:%" PRIu64 " try next",
-             GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pSource->execId, pExchangeInfo->current + 1,
-             pDataInfo->totalRows, pLoadInfo->totalRows);
+      qDebug("%s vgId:%d, clientId:0x%" PRIx64 " taskID:0x%" PRIx64
+             " execId:%d %d of total completed, rowsOfSource:%" PRIu64 ", totalRows:%" PRIu64 " try next",
+             GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->clientId, pSource->taskId, pSource->execId,
+             pExchangeInfo->current + 1, pDataInfo->totalRows, pLoadInfo->totalRows);
 
       pDataInfo->status = EX_SOURCE_DATA_EXHAUSTED;
       pExchangeInfo->current += 1;
@@ -1002,19 +1005,19 @@ int32_t seqLoadRemoteData(SOperatorInfo* pOperator) {
 
     SRetrieveTableRsp* pRetrieveRsp = pDataInfo->pRsp;
     if (pRsp->completed == 1) {
-      qDebug("%s fetch msg rsp from vgId:%d, taskId:0x%" PRIx64 " execId:%d numOfRows:%" PRId64
+      qDebug("%s fetch msg rsp from vgId:%d, clientId:0x%" PRIx64 " taskId:0x%" PRIx64 " execId:%d numOfRows:%" PRId64
              ", rowsOfSource:%" PRIu64 ", totalRows:%" PRIu64 ", totalBytes:%" PRIu64 " try next %d/%" PRIzu,
-             GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pSource->execId, pRetrieveRsp->numOfRows,
-             pDataInfo->totalRows, pLoadInfo->totalRows, pLoadInfo->totalSize, pExchangeInfo->current + 1,
-             totalSources);
+             GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->clientId, pSource->taskId, pSource->execId,
+             pRetrieveRsp->numOfRows, pDataInfo->totalRows, pLoadInfo->totalRows, pLoadInfo->totalSize,
+             pExchangeInfo->current + 1, totalSources);
 
       pDataInfo->status = EX_SOURCE_DATA_EXHAUSTED;
       pExchangeInfo->current += 1;
     } else {
-      qDebug("%s fetch msg rsp from vgId:%d, taskId:0x%" PRIx64 " execId:%d numOfRows:%" PRId64 ", totalRows:%" PRIu64
-             ", totalBytes:%" PRIu64,
-             GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pSource->execId, pRetrieveRsp->numOfRows,
-             pLoadInfo->totalRows, pLoadInfo->totalSize);
+      qDebug("%s fetch msg rsp from vgId:%d, clientId:0x%" PRIx64 " taskId:0x%" PRIx64 " execId:%d numOfRows:%" PRId64
+             ", totalRows:%" PRIu64 ", totalBytes:%" PRIu64,
+             GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->clientId, pSource->taskId, pSource->execId,
+             pRetrieveRsp->numOfRows, pLoadInfo->totalRows, pLoadInfo->totalSize);
     }
 
     updateLoadRemoteInfo(pLoadInfo, pRetrieveRsp->numOfRows, pRetrieveRsp->compLen, startTs, pOperator);