Merge branch '3.0' into enh/3.0/TS-5007

2024-11-25 14:47:38 +08:00 · 2024-11-25 14:47:38 +08:00 · cf8cea4c2d
parent a63c132fba a7f655a784
commit cf8cea4c2d
361 changed files with 15528 additions and 5303 deletions
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@ -0,0 +1,5 @@
+# Pull Request Checklist
+
+- [ ] Is the user manual updated?
+- [ ] Are the test cases passed and automated?
+- [ ] Is there no significant decrease in test coverage?
--- a/.gitignore
+++ b/.gitignore
@ -161,4 +161,4 @@ version.h
 geos_c.h
 source/libs/parser/src/sql.c
 include/common/ttokenauto.h
-
+!packaging/smokeTest/pytest_require.txt
--- a/190
+++ b/190
@ -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 = '1'
 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.5
        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 }
+                expression {
+                    file_no_doc_changed != '' && env.CHANGE_TARGET != 'docs-cloud'
                }
            }
            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
--- a/cmake/cmake.define
+++ b/cmake/cmake.define
@ -97,10 +97,13 @@ ELSE()
    SET(TD_TAOS_TOOLS TRUE)
 ENDIF()

+SET(TAOS_LIB taos)
+SET(TAOS_LIB_STATIC taos_static)
+
 IF(${TD_WINDOWS})
-    SET(TAOS_LIB taos_static)
+    SET(TAOS_LIB_PLATFORM_SPEC taos_static)
 ELSE()
-    SET(TAOS_LIB taos)
+    SET(TAOS_LIB_PLATFORM_SPEC taos)
 ENDIF()

 # build TSZ by default
--- a/cmake/cmake.version
+++ b/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)
--- a/docs/en/14-reference/03-taos-sql/10-function.md
+++ b/docs/en/14-reference/03-taos-sql/10-function.md
@ -422,7 +422,7 @@ CAST(expr AS type_name)
 TO_ISO8601(expr [, timezone])
 ```

-**Description**: The ISO8601 date/time format converted from a UNIX timestamp, plus the timezone. You can specify any time zone with the timezone parameter. If you do not enter this parameter, the time zone on the client is used.
+**Description**: The ISO8601 date/time format converted from a timestamp, plus the timezone. You can specify any time zone with the timezone parameter. If you do not enter this parameter, the time zone on the client is used.

 **Return value type**: VARCHAR

@ -466,7 +466,7 @@ return_timestamp: {
 }
 ```

-**Description**: UNIX timestamp converted from a string of date/time format
+**Description**: timestamp converted from a string of date/time format

 **Return value type**: BIGINT, TIMESTAMP

@ -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

--- a/docs/en/14-reference/03-taos-sql/31-compress.md
+++ b/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

--- a/docs/en/14-reference/05-connectors/30-python.mdx
+++ b/docs/en/14-reference/05-connectors/30-python.mdx
@ -41,12 +41,18 @@ We recommend using the latest version of `taospy`, regardless of the version of

 |Python Client Library Version|major changes|
 |:-------------------:|:----:|
+|2.7.16|add subscription configuration (session.timeout.ms, max.poll.interval.ms)|
+|2.7.15|added support for VARBINARY and GEOMETRY types|
+|2.7.14|fix known issues|
+|2.7.13|add TMQ synchronous submission offset interface|
 |2.7.12|1. added support for `varbinary` type (STMT does not yet support)<br/> 2. improved query performance (thanks to contributor [hadrianl](https://github.com/taosdata/taos-connector-python/pull/209))|
 |2.7.9|support for getting assignment and seek function on subscription|
 |2.7.8|add `execute_many` method|

 |Python Websocket Connection Version|major changes|
 |:----------------------------:|:-----:|
+|0.3.5|1. added support for VARBINARY and GEOMETRY types <br/> 2. Fix known issues|
+|0.3.2|1. optimize WebSocket SQL query and insertion performance <br/> 2. Fix known issues <br/> 3. Modify the readme and document|
 |0.2.9|bugs fixes|
 |0.2.5|1. support for getting assignment and seek function on subscription <br/> 2. support schemaless <br/> 3. support STMT|
 |0.2.4|support `unsubscribe` on subscription|
--- a/docs/en/14-reference/05-connectors/35-node.mdx
+++ b/docs/en/14-reference/05-connectors/35-node.mdx
@ -27,6 +27,8 @@ Node.js client library needs to be run with Node.js 14 or higher version.

 | Node.js connector version |    major changes     |   TDengine 版本    |
 | :-----------------------: | :------------------: | :----------------:|
+|        3.1.2              |  Optimized the data protocol and parsing, resulting in a significant improvement in performance |  3.2.0.0 or later |
+|        3.1.1              |  Optimized data transmission performance |  3.2.0.0 or later |
 |        3.1.0              |  new version, supports websocket |  3.2.0.0 or later |

 ## Supported features
--- a/docs/en/14-reference/12-config/index.md
+++ b/docs/en/14-reference/12-config/index.md
@ -773,7 +773,7 @@ lossyColumns     float|double
   02/22 10:49:27.607990 00002933 UTL  lossyColumns     float|double
 ```

-### ifAdtFse 
+### ifAdtFse

 | Attribute     | Description                         |
 | -------- | -------------------------------- |
@ -898,4 +898,4 @@ lossyColumns     float|double
 | 53  |          udf           | Yes                    | Yes                          |                         |
 | 54  |     enableCoreFile     | Yes                    | Yes                          |                         |
 | 55  |    ttlChangeOnWrite    | No                     | Yes                          |                         |
-| 56  |     keepTimeOffset     | Yes                    | Yes(discarded since 3.2.0.0) |                         |
+| 56  |     keepTimeOffset     | Yes                    | Yes(discarded since 3.2.0.0) | see "KEEP_TIME_OFFSET"  |
--- a/docs/en/28-releases/01-tdengine.md
+++ b/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" />
--- a/docs/examples/JDBC/SpringJdbcTemplate/pom.xml
+++ b/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>
--- a/docs/examples/JDBC/springbootdemo/pom.xml
+++ b/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>
--- a/docs/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/SpringbootdemoApplication.java
+++ b/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) {
--- a/docs/examples/JDBC/springbootdemo/src/main/resources/application.properties
+++ b/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
--- a/docs/examples/JDBC/taosdemo/pom.xml
+++ b/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>
--- a/docs/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/QueryService.java
+++ b/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);
--- a/docs/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/DatabaseServiceTest.java
+++ b/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);
+    }
+
 }
--- a/docs/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/QueryServiceTest.java
+++ b/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
--- a/docs/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/SuperTableServiceTest.java
+++ b/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);
+    }
+
 }
--- a/docs/examples/java/src/main/java/com/taos/example/DruidDemo.java
+++ b/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");
--- a/docs/examples/java/src/main/java/com/taos/example/GeometryDemo.java
+++ b/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));

--- a/docs/examples/java/src/main/java/com/taos/example/HikariDemo.java
+++ b/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
--- a/docs/examples/java/src/main/java/com/taos/example/TelnetLineProtocolExample.java
+++ b/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();
        }
    }

--- a/docs/examples/node/package.json
+++ b/docs/examples/node/package.json
@ -4,6 +4,12 @@
  "main": "index.js",
  "license": "MIT",
  "dependencies": {
-    "@tdengine/websocket": "^3.1.1"
-  }
+    "@tdengine/websocket": "^3.1.2"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "description": ""
 }
--- a/docs/examples/node/websocketexample/all_type_stmt.js
+++ b/docs/examples/node/websocketexample/all_type_stmt.js
@ -95,8 +95,8 @@ async function all_type_example() {
        tagParams.setBoolean([true]);
        tagParams.setVarchar(["hello"]);
        tagParams.setNchar(["stmt"]);
-        tagParams.setGeometry([geometryData]);
        tagParams.setVarBinary([vbData]);
+        tagParams.setGeometry([geometryData]);
        await stmt.setTags(tagParams);


@ -108,8 +108,8 @@ async function all_type_example() {
        bindParams.setBoolean([true]);
        bindParams.setVarchar(["hello"]);
        bindParams.setNchar(["stmt"]);
-        bindParams.setGeometry([geometryData]);
        bindParams.setVarBinary([vbData]);
+        bindParams.setGeometry([geometryData]);

        await stmt.bind(bindParams);
        await stmt.batch();
--- a/docs/zh/06-advanced/02-cache.md
+++ b/docs/zh/06-advanced/02-cache.md
@ -1,68 +1,44 @@
 ---
-sidebar_label: 数据缓存
-title: 数据缓存
+sidebar_label: 读缓存
+title: 读缓存
 toc_max_heading_level: 4
 ---

-在工业互联网和物联网大数据应用场景中，时序数据库的性能表现尤为关键。这类应用程序不仅要求数据的实时写入能力，还需求能够迅速获取设备的最新状态或对最新数据进行实时计算。通常，大数据平台会通过部署 Redis 或类似的缓存技术来满足这些需求。然而，这种做法会增加系统的复杂性和运营成本。
+在物联网（IoT）和工业互联网（IIoT）大数据应用场景中，实时数据的价值往往远超历史数据。企业不仅需要数据处理系统具备高效的实时写入能力，更需要能快速获取设备的最新状态，或者对最新数据进行实时计算和分析。无论是工业设备的状态监控、车联网中的车辆位置追踪，还是智能仪表的实时读数，当前值都是业务运行中不可或缺的核心数据。这些数据直接关系到生产安全、运营效率以及用户体验。

-为了解决这一问题，TDengine 采用了针对性的缓存优化策略。通过精心设计的缓存机制，TDengine 实现了数据的实时高效写入和快速查询，从而有效降低整个集群的复杂性和运营成本。这种优化不仅提升了性能，还为用户带来了更简洁、易用的解决方案，使他们能够更专注于核心业务的发展。
+例如，在工业生产中，生产线设备的当前运行状态至关重要。操作员需要实时监控温度、压力、转速等关键指标，一旦设备出现异常，这些数据必须即时呈现，以便迅速调整工艺参数，避免停产或更大的损失。在车联网领域，以滴滴为例，车辆的实时位置数据是滴滴平台优化派单策略、提升运营效率的关键，确保每位乘客快速上车并享受更高质量的出行体验。

-## 写缓存
+同时，看板系统和智能仪表作为现场操作和用户端的窗口，也需要实时数据支撑。无论是工厂管理者通过看板获取的实时生产指标，还是家庭用户随时查询智能水表、电表的用量，实时性不仅影响到运营和决策效率，更直接关系到用户对服务的满意程度。

-TDengine 采用了一种创新的时间驱动缓存管理策略，亦称为写驱动的缓存管理机制。这一策略与传统的读驱动的缓存模式有所不同，其核心思想是将最新写入的数据优先保存在缓存中。当缓存容量达到预设的临界值时，系统会将最早存储的数据批量写入硬盘，从而实现缓存与硬盘之间的动态平衡。
+## 传统缓存方案的局限性

-在物联网数据应用中，用户往往最关注最近产生的数据，即设备的当前状态。TDengine 充分利用了这一业务特性，将最近到达的当前状态数据优先存储在缓存中，以便用户能够快速获取所需信息。
+为了满足这些高频实时查询需求，许多企业选择将 Redis 等缓存技术集成到大数据平台中，通过在数据库和应用之间添加一层缓存来提升查询性能。然而，这种方法也带来了不少问题：
+- 系统复杂性增加：需要额外部署和维护缓存集群，对系统架构提出了更高的要求。
+- 运营成本上升：需要额外的硬件资源来支撑缓存，增加了维护和管理的开销。
+- 一致性问题：缓存和数据库之间的数据同步需要额外的机制来保障，否则可能出现数据不一致的情况。

-为了实现数据的分布式存储和高可用性，TDengine 引入了虚拟节点（vnode）的概念。每个 vnode 可以拥有多达 3 个副本，这些副本共同组成一个 vnode group，简称 vgroup。在创建数据库时，用户需要确定每个 vnode 的写入缓存大小，以确保数据的合理分配和高效存储。
+## TDengine 的解决方案：内置读缓存

-创建数据库时的两个关键参数 `vgroups` 和 `buffer` 分别决定了数据库中的数据由多少个 vgroup 进行处理，以及为每个 vnode 分配多少写入缓存。通过合理配置这两个
-参数，用户可以根据实际需求调整数据库的性能和存储容量，从而实现最佳的性能和成本效益。
+为了解决这些问题，TDengine 针对物联网和工业互联网的高频实时查询场景，设计并实现了读缓存机制。这一机制能够自动将每张表的最后一条记录缓存到内存中，从而在不引入第三方缓存技术的情况下，直接满足用户对当前值的实时查询需求。

-例 如， 下面的 SQL 创建了包含 10 个 vgroup，每个 vnode 占 用 256MB 内存的数据库。
-```sql
-CREATE DATABASE POWER VGROUPS 10 BUFFER 256 CACHEMODEL 'NONE' PAGES 128 PAGESIZE 16;
-```
+TDengine 采用时间驱动的缓存管理策略，将最新数据优先存储在缓存中，查询时无需访问硬盘即可快速返回结果。当缓存容量达到设定上限时，系统会批量将最早的数据写入硬盘，既提升了查询效率，也有效减少了硬盘的写入负担，延长硬件使用寿命。

-缓存越大越好，但超过一定阈值后再增加缓存对写入性能提升并无帮助。
+用户可通过设置 cachemodel 参数，自定义缓存模式，包括缓存最新一行数据、每列最近的非 NULL 值，或同时缓存行和列的数据。这种灵活设计在物联网场景中尤为重要，使设备状态的实时查询更加高效精准。

-## 读缓存
+这种读缓存机制的内置化设计显著降低了查询延迟，避免了引入 Redis 等外部系统的复杂性和运维成本。同时，减少了频繁查询对存储系统的压力，大幅提升系统的整体吞吐能力，确保在高并发场景下依然稳定高效运行。通过读缓存，TDengine 为用户提供了一种更轻量化的实时数据处理方案，不仅优化了查询性能，还降低了整体运维成本，为物联网和工业互联网用户提供强有力的技术支持。

-在创建数据库时，用户可以选择是否启用缓存机制以存储该数据库中每张子表的最新数据。这一缓存机制由数据库创建参数 cachemodel 进行控制。参数 cachemodel 具有如
-下 4 种情况：
- none: 不缓存
- last_row: 缓存子表最近一行数据，这将显著改善 last_row 函数的性能
- last_value: 缓存子表每一列最近的非 NULL 值，这将显著改善无特殊影响（比如 WHERE， ORDER BY， GROUP BY， INTERVAL）时的 last 函数的性能
- both: 同时缓存最近的行和列，即等同于上述 cachemodel 值为 last_row 和 last_value 的行为同时生效
+## TDengine 的读缓存配置
+
+在创建数据库时，用户可以选择是否启用缓存机制以存储该数据库中每张子表的最新数据。这一缓存机制由数据库创建参数 cachemodel 进行控制。参数 cachemodel 具有如 下 4 种情况：
+- none：不缓存
+- last_row：缓存子表最近一行数据，这将显著改善 last_row 函数的性能
+- last_value：缓存子表每一列最近的非 NULL 值，这将显著改善无特殊影响（比如 WHERE,ORDER BY,GROUP BY, INTERVAL）时的 last 函数的性能
+- both：同时缓存最近的行和列，即等同于上述 cachemodel 值为 last_row 和 last_value 的行为同时生效

 当使用数据库读缓存时，可以使用参数 cachesize 来配置每个 vnode 的内存大小。
- cachesize：表示每个 vnode 中用于缓存子表最近数据的内存大小。默认为 1 ，范围是[1， 65536]，单位是 MB。需要根据机器内存合理配置。
+- cachesize：表示每个 vnode 中用于缓存子表最近数据的内存大小。默认为 1 ，范围是[1，65536]，单位是 MB。需要根据机器内存合理配置。

-## 元数据缓存
-
-为了提升查询和写入操作的效率，每个 vnode 都配备了缓存机制，用于存储其曾经获取过的元数据。这一元数据缓存的大小由创建数据库时的两个参数 pages 和 pagesize 共同决定。其中，pagesize 参数的单位是 KB，用于指定每个缓存页的大小。如下 SQL 会为数据库 power 的每个 vnode 创建 128 个 page、每个 page 16KB 的元数据缓存
-
-```sql
-CREATE DATABASE POWER PAGES 128 PAGESIZE 16;
-```
-
-## 文件系统缓存
-
-TDengine 采用 WAL 技术作为基本的数据可靠性保障手段。WAL 是一种先进的数据保护机制，旨在确保在发生故障时能够迅速恢复数据。其核心原理在于，在数据实际写入数据存储层之前，先将其变更记录到一个日志文件中。这样一来，即便集群遭遇崩溃或其他故障，也能确保数据安全无损。
-
-TDengine 利用这些日志文件实现故障前的状态恢复。在写入 WAL 的过程中，数据是以顺序追加的方式写入硬盘文件的。因此，文件系统缓存在此过程中发挥着关键作用，对写入性能产生显著影响。为了确保数据真正落盘，系统会调用 fsync 函数，该函数负责将文件系统缓存中的数据强制写入硬盘。
-
-数据库参数 wal_level 和 wal_fsync_period 共同决定了 WAL 的保存行为。。
- wal_level：此参数控制 WAL 的保存级别。级别 1 表示仅将数据写入 WAL，但不立即执行 fsync 函数；级别 2 则表示在写入 WAL 的同时执行 fsync 函数。默认情况下，wal_level 设为 1。虽然执行 fsync 函数可以提高数据的持久性，但相应地也会降低写入性能。
- wal_fsync_period：当 wal_level 设置为 2 时，这个参数控制执行 fsync 的频率。设置为 0 表示每次写入后立即执行 fsync，这可以确保数据的安全性，但可能会牺牲一些性能。当设置为大于 0 的数值时，表示 fsync 周期，默认为 3000，范围是[1， 180000]，单位毫秒。
-
-```sql
-CREATE DATABASE POWER WAL_LEVEL 2 WAL_FSYNC_PERIOD 3000;
-```
-
-在创建数据库时可以选择不同的参数类型，来选择性能优先或者可靠性优先。
- 1: 写 WAL 但不执行 fsync ，新写入 WAL 的数据保存在文件系统缓存中但并未写入磁盘，这种方式性能优先
- 2: 写 WAL 且执行 fsync，新写入 WAL 的数据被立即同步到磁盘上，可靠性更高
+关于数据库的具体创建，相关参数和操作说明请参考[创建数据库](../../reference/taos-sql/database/)

 ## 实时数据查询的缓存实践

--- a/docs/zh/06-advanced/03-stream.md
+++ b/docs/zh/06-advanced/03-stream.md
@ -124,7 +124,7 @@ create stream if not exists count_history_s fill_history 1 into count_history as

 窗口关闭是由事件时间决定的，如事件流中断、或持续延迟，此时事件时间无法更新，可能导致无法得到最新的计算结果。

-因此，流计算提供了以事件时间结合处理时间计算的 MAX_DELAY 触发模式。MAX_DELAY 模式在窗口关闭时会立即触发计算。此外，当数据写入后，计算触发的时间超过 max delay 指定的时间，则立即触发计算。
+因此，流计算提供了以事件时间结合处理时间计算的 MAX_DELAY 触发模式：MAX_DELAY 模式在窗口关闭时会立即触发计算，它的单位可以自行指定，具体单位：a（毫秒）、s（秒）、m（分）、h（小时）、d（天）、w（周）。此外，当数据写入后，计算触发的时间超过 MAX_DELAY 指定的时间，则立即触发计算。

 ### 流计算的窗口关闭

@ -228,4 +228,35 @@ PAUSE STREAM [IF EXISTS] stream_name;
 RESUME STREAM [IF EXISTS] [IGNORE UNTREATED] stream_name; 
 ```

-没有指定 IF EXISTS，如果该 stream 不存在，则报错。如果存在，则恢复流计算。指定了 IF EXISTS，如果 stream 不存在，则返回成功。如果存在，则恢复流计算。如果指定 IGNORE UNTREATED，则恢复流计算时，忽略流计算暂停期间写入的数据。
+没有指定 IF EXISTS，如果该 stream 不存在，则报错。如果存在，则恢复流计算。指定了 IF EXISTS，如果 stream 不存在，则返回成功。如果存在，则恢复流计算。如果指定 IGNORE UNTREATED，则恢复流计算时，忽略流计算暂停期间写入的数据。
+
+### 流计算升级故障恢复
+
+升级 TDengine 后，如果流计算不兼容，需要删除流计算，然后重新创建流计算。步骤如下：
+
+1.修改 taos.cfg，添加 disableStream 1
+
+2.重启 taosd。如果启动失败，修改 stream 目录的名称，避免 taosd 启动的时候尝试加载 stream 目录下的流计算数据信息。不使用删除操作避免误操作导致的风险。需要修改的文件夹：$dataDir/vnode/vnode*/tq/stream，$dataDir 指 TDengine 存储数据的目录，在 $dataDir/vnode/ 目录下会有多个类似 vnode1 、vnode2...vnode* 的目录，全部需要修改里面的 tq/stream 目录的名字，改为 tq/stream.bk
+
+3.启动 taos
+
+```sql
+drop stream xxxx;                ---- xxx 指stream name
+flush database stream_source_db; ---- 流计算读取数据的超级表所在的 database
+flush database stream_dest_db;   ---- 流计算写入数据的超级表所在的 database
+```
+
+举例：
+
+```sql
+create stream streams1 into test1.streamst as select  _wstart, count(a) c1  from test.st interval(1s) ;
+drop database streams1;
+flush database test;
+flush database test1;
+```
+
+4.关闭 taosd
+
+5.修改 taos.cfg，去掉 disableStream 1，或将 disableStream 改为 0
+
+6.启动 taosd
--- a/docs/zh/06-advanced/05-data-in/05-opcua.md
+++ b/docs/zh/06-advanced/05-data-in/05-opcua.md
@ -150,7 +150,7 @@ CSV 文件中的每个 Row 配置一个 OPC 数据点位。Row 的规则如下

 #### 5.2. 选择数据点位

-可以通过配置 **根节点ID**、**命名空间**、**正则匹配** 等条件，对点位进行筛选。
+可以通过配置 **根节点ID**、**命名空间**、**节点ID**、**节点名称** 等条件，对点位进行筛选。

 通过配置 **超级表名**、**表名称**，指定数据要写入的超级表、子表。

--- a/docs/zh/06-advanced/05-data-in/06-opcda.md
+++ b/docs/zh/06-advanced/05-data-in/06-opcda.md
@ -126,7 +126,7 @@ CSV 文件中的每个 Row 配置一个 OPC 数据点位。Row 的规则如下

 #### 4.2. 选择数据点位

-可以通过配置 **根节点ID** 和 **正则匹配** 作为过滤条件，对点位进行筛选。
+可以通过配置 **根节点ID**、**节点ID**、**节点名称** 作为过滤条件，对点位进行筛选。

 通过配置 **超级表名**、**表名称**，指定数据要写入的超级表、子表。

--- a/docs/zh/06-advanced/05-data-in/07-mqtt.md
+++ b/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个参数配置生效。

--- a/docs/zh/06-advanced/05-data-in/11-csv.md
+++ b/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)
--- a/docs/zh/06-advanced/05-data-in/csv-01.png
+++ b/docs/zh/06-advanced/05-data-in/csv-01.png
--- a/docs/zh/06-advanced/05-data-in/csv-02.png
+++ b/docs/zh/06-advanced/05-data-in/csv-02.png
--- a/docs/zh/06-advanced/05-data-in/csv-03.png
+++ b/docs/zh/06-advanced/05-data-in/csv-03.png
--- a/docs/zh/06-advanced/05-data-in/csv-04.png
+++ b/docs/zh/06-advanced/05-data-in/csv-04.png
--- a/docs/zh/06-advanced/05-data-in/csv-05.png
+++ b/docs/zh/06-advanced/05-data-in/csv-05.png
--- a/docs/zh/06-advanced/05-data-in/csv-06.png
+++ b/docs/zh/06-advanced/05-data-in/csv-06.png
--- a/docs/zh/06-advanced/05-data-in/csv-07.png
+++ b/docs/zh/06-advanced/05-data-in/csv-07.png
--- a/docs/zh/06-advanced/05-data-in/csv-08.png
+++ b/docs/zh/06-advanced/05-data-in/csv-08.png
--- a/docs/zh/06-advanced/05-data-in/csv-09.png
+++ b/docs/zh/06-advanced/05-data-in/csv-09.png
--- a/docs/zh/06-advanced/05-data-in/csv-10.png
+++ b/docs/zh/06-advanced/05-data-in/csv-10.png
--- a/docs/zh/06-advanced/05-data-in/csv-11.png
+++ b/docs/zh/06-advanced/05-data-in/csv-11.png
--- a/docs/zh/06-advanced/05-data-in/csv-12.png
+++ b/docs/zh/06-advanced/05-data-in/csv-12.png
--- a/docs/zh/06-advanced/05-data-in/csv-13.png
+++ b/docs/zh/06-advanced/05-data-in/csv-13.png
--- a/docs/zh/06-advanced/05-data-in/csv-14.png
+++ b/docs/zh/06-advanced/05-data-in/csv-14.png
--- a/docs/zh/06-advanced/05-data-in/mqtt-14.png
+++ b/docs/zh/06-advanced/05-data-in/mqtt-14.png
--- a/docs/zh/06-advanced/05-data-in/pic/opcda-06-point.png
+++ b/docs/zh/06-advanced/05-data-in/pic/opcda-06-point.png
--- a/docs/zh/06-advanced/05-data-in/pic/opcua-06-point.png
+++ b/docs/zh/06-advanced/05-data-in/pic/opcua-06-point.png
--- a/docs/zh/06-advanced/06-TDgpt/02-management.md
+++ b/docs/zh/06-advanced/06-TDgpt/02-management.md
@ -0,0 +1,128 @@
+---
+title: "安装部署"
+sidebar_label: "安装部署"
+---
+
+### 环境准备
+使用 TDgpt 的高级时序数据分析功能需要在 TDengine 集群中安装部署 AI node（Anode）。Anode 可以运行在 Linux/Windows/MacOS 等平台上，同时需要 3.10 或以上版本的 Python 环境支持。
+> 部署 Anode 需要 TDengine Enterprise 3.3.4.3 及以后版本，请首先确认搭配 Anode 使用的 TDengine 能够支持 Anode。
+
+### 安装及卸载
+不同操作系统上安装及部署 Anode 有一些差异，主要是卸载操作、安装路径、服务启停等方面。本文以 Linux 系统为例，说明安装部署的流程。
+使用 Linux 环境下的安装包 TDengine-enterprise-anode-1.x.x.tar.gz 可进行 Anode 的安装部署工作，命令如下：
+
+```bash
+tar -xzvf TDengine-enterprise-anode-1.0.0.tar.gz
+cd TDengine-enterprise-anode-1.0.0
+sudo ./install.sh
+```
+
+对于已经安装的 Anode，执行命令 `rmtaosanode` 即可完成卸载。
+为了避免影响系统已有的 Python 环境，Anode 使用虚拟环境运行。安装 Anode 会在目录 `/var/lib/taos/taosanode/venv/` 中创建默认的 Python 虚拟环境，Anode 运行所需要的库均安装在该目录下。为了避免反复安装虚拟环境带来的开销，卸载命令 `rmtaosanode` 并不会自动删除该虚拟环境，如果您确认不再需要 Python 的虚拟环境，手动删除该目录即可。
+
+### 启停服务
+在 Linux 系统中，安装 Anode 以后会自动创建 `taosanoded` 服务。可以使用 `systemd` 来管理 Anode 服务，使用如下命令启动/停止/检查 Anode。
+
+```bash
+systemctl start  taosanoded
+systemctl stop   taosanoded
+systemctl status taosanoded
+```
+
+### 目录及配置说明
+安装完成后，Anode 主体目录结构如下：
+
+|目录/文件|说明|
+|---------------|------|
+|/usr/local/taos/taosanode/bin|可执行文件目录|
+|/usr/local/taos/taosanode/resource|资源文件目录，链接到文件夹 /var/lib/taos/taosanode/resource/|
+|/usr/local/taos/taosanode/lib|库文件目录|
+|/var/lib/taos/taosanode/model/|模型文件目录，链接到文件夹 /var/lib/taos/taosanode/model|
+|/var/log/taos/taosanode/|日志文件目录|
+|/etc/taos/taosanode.ini|配置文件|
+
+#### 配置说明
+
+Anode 的服务需要使用 uWSGI 驱动驱动运行，因此 Anode 和 uWSGI 的配置信息共同存放在相同的配置文件 `taosanode.ini` 中，该配置文件默认位于 `/etc/taos/` 目录下。
+具体内容及配置项说明如下：
+
+```ini
+[uwsgi]
+
+# Anode RESTful service ip:port
+http = 127.0.0.1:6090
+
+# base directory for Anode python files， do NOT modified this
+chdir = /usr/local/taos/taosanode/lib
+
+# initialize Anode python file
+wsgi-file = /usr/local/taos/taosanode/lib/taos/app.py
+
+# pid file
+pidfile = /usr/local/taos/taosanode/taosanode.pid
+
+# conflict with systemctl, so do NOT uncomment this
+# daemonize = /var/log/taos/taosanode/taosanode.log
+
+# log directory
+logto = /var/log/taos/taosanode/taosanode.log
+
+# wWSGI monitor port
+stats = 127.0.0.1:8387
+
+# python virtual environment directory, used by Anode
+virtualenv = /usr/local/taos/taosanode/venv/
+
+[taosanode]
+# default app log file
+app-log = /var/log/taos/taosanode/taosanode.app.log
+
+# model storage directory
+model-dir = /usr/local/taos/taosanode/model/
+
+# default log level
+log-level = DEBUG
+
+```
+
+**提示**
+请勿设置 `daemonize` 参数，该参数会导致 uWSGI 与 systemctl 冲突，从而导致 Anode 无法正常启动。
+上面的示例配置文件 `taosanode.ini` 只包含了使用 Anode 提供服务的基础配置参数，对于 uWSGI 的其他配置参数的设置及其说明请参考 [uWSGIS官方文档](https://uwsgi-docs-zh.readthedocs.io/zh-cn/latest/Options.html)。
+
+Anode 运行配置主要是以下：
+- app-log: Anode 服务运行产生的日志，用户可以调整其到需要的位置
+- model-dir: 采用算法针对已经存在的数据集的运行完成生成的模型存储位置
+- log-level: app-log文件的日志级别
+
+
+### Anode 基本操作
+对于 Anode 的管理，用户需要通过 TDengine 的命令行接口 taos 进行。因此下述介绍的管理命令都需要先打开 taos, 连接到 TDengine 运行实例。 
+#### 创建 Anode
+```sql 
+CREATE ANODE {node_url}
+```
+node_url 是提供服务的 Anode 的 IP 和 PORT组成的字符串, 例如：`create anode '127.0.0.1:6090'`。Anode 启动后还需要注册到 TDengine 集群中才能提供服务。不建议将 Anode 同时注册到两个集群中。
+
+#### 查看 Anode
+列出集群中所有的数据分析节点，包括其 `FQDN`, `PORT`, `STATUS`等属性。
+```sql
+SHOW ANODES;
+```
+
+#### 查看提供的时序数据分析服务
+
+```SQL
+SHOW ANODES FULL;
+```
+
+#### 刷新集群中的分析算法缓存
+```SQL
+UPDATE ANODE {anode_id}
+UPDATE ALL ANODES
+```
+
+#### 删除 Anode
+```sql
+DROP ANODE {anode_id}
+```
+删除 Anode 只是将 Anode 从 TDengine 集群中删除，管理 Anode 的启停仍然需要使用 `systemctl` 命令。卸载 Anode 则需要使用上面提到的 `rmtaosanode` 命令。
--- a/docs/zh/06-advanced/06-TDgpt/03-preprocess.md
+++ b/docs/zh/06-advanced/06-TDgpt/03-preprocess.md
@ -0,0 +1,49 @@
+---
+title: "数据分析预处理"
+sidebar_label: "数据分析预处理"
+---
+
+import activity from './pic/activity.png';
+import wndata from './pic/white-noise-data.png'
+
+### 分析流程
+时序数据分析之前需要有预处理的过程，为减轻分析算法的负担，TDgpt 在将时序数据发给具体分析算法进行分析时，已经对数据做了预处理，整体的流程如下图所示。
+
+<img src={activity} width="560" alt="预处理流程" />
+
+TDgpt 首先对输入数据进行白噪声检查（White Noise Data check）, 检查通过以后针对预测分析，还要进行输入（历史）数据的重采样和时间戳对齐处理（异常检测跳过数据重采样和时间戳对齐步骤）。
+预处理完成以后，再进行预测或异常检测操作。预处理过程部署于预测或异常检测处理逻辑的一部分。
+
+### 白噪声检查
+
+<img src={wndata} width="430" alt="white-noise-data"/>
+
+白噪声时序数据可以简单地认为是随机数构成的时间数据序列（如上图所示的正态分布随机数序列），随机数构成的时间序列没有分析的价值，因此会直接返回。白噪声检查采用经典的 `Ljung-Box` 统计量检验，计算 `Ljung-Box` 统计量需遍历整个输入时间序列。如果用户能够明确输入序列一定不是白噪声序列，那么可以在参数列表中增加参数 `wncheck=0` 强制要求分析平台忽略白噪声检查，从而节省计算资源。
+TDgpt 暂不提供独立的时间序列白噪声检测功能。
+
+
+### 重采样和时间戳对齐
+
+对于进行预测分析的时间序列数据，在进行预测分析前需要进行必要的预处理。预处理主要解决以下两个问题：
+
+- 真实时间序列数据时间戳未对齐。由于数据生成设备的原因或网关赋值时间戳的时候并不能保证按照严格的时间间隔赋值，时间序列数据并不能保证是严格按照采样频率对齐。例如采样频率为 1Hz 的一个时间序列数据序列，其时间戳序列如下：
+
+  > ['20:12:21.143', '20:12:22.187', '20:12:23.032', '20:12:24.384', '20:12:25.033']
+  
+  预测返回的时间序列时间戳会严格对齐，例如返回后续的两个预测结果的时间戳，其时间一定如下：['20:12:26.000', '20:12:27.000']。因此上述的输入时间戳序列要进行时间戳对齐，变换成为如下时间戳序列
+
+  > ['20:12:21.000', '20:12:22.000', '20:12:23.000', '20:12:24.000', '20:12:25.000']
+  
+  
+- 数据时间重采样。用户输入时间序列的采样频率超过了输出结果的频率，例如输入时间序列的采样时间间隔是 5 sec，但是要求输出预测结果的采样时间间隔是 10sec
+
+  > ['20:12:20.000', '20:12:25.000', '20:12:30.000', '20:12:35.000', '20:12:40.000'] 
+
+  重采样为采样间隔为 10sec 的时间戳序列
+
+  > ['20:12:20.000', '20:12:30.000', '20:12:40.000']
+
+  然后将其作为预测分析的输入， ['20:12:25.000', '20:12:35.000'] 数据被丢弃。
+
+需要注意的是，预处理过程不支持缺失数据补齐操作，如果输入时间序列数据 ['20:12:10.113', '20:12:21.393', '20:12:29.143', '20:12:51.330']，并且要求的采样时间间隔为 10sec，重整对齐后的时间戳序列是 ['20:12:10.000', '20:12:20.000', '20:12:30.000', '20:12:50.000'] 那么对该序列进行预测分析将返回错误。
+
--- a/docs/zh/06-advanced/06-TDgpt/04-forecast/02-arima.md
+++ b/docs/zh/06-advanced/06-TDgpt/04-forecast/02-arima.md
@ -3,14 +3,14 @@ title: "ARIMA"
 sidebar_label: "ARIMA"
 ---

-本节讲述 ARIMA 算法模型的使用方法。
+本节说明 ARIMA 算法模型的使用方法。

 ## 功能概述

-ARIMA 即自回归移动平均模型（Autoregressive Integrated Moving Average, ARIMA），也记作 ARIMA(p,d,q)，是统计模型中最常见的一种用来进行时间序列预测的模型。
+ARIMA：Autoregressive Integrated Moving Average，即自回归移动平均模型，记作 ARIMA(p,d,q)，是统计模型中最常见的一种用来进行时间序列预测的模型。
 ARIMA 模型是一种自回归模型，只需要自变量即可预测后续的值。ARIMA 模型要求时间序列**平稳**，或经过差分处理后平稳，如果是不平稳的数据，**无法**获得正确的结果。

->平稳的时间序列：其性质不随观测时间的变化而变化。具有趋势或季节性的时间序列不是平稳时间序列——趋势和季节性使得时间序列在不同时段呈现不同性质。
+> 平稳的时间序列：其性质不随观测时间的变化而变化。具有趋势或季节性的时间序列不是平稳时间序列——趋势和季节性使得时间序列在不同时段呈现不同性质。

 以下参数可以动态输入，控制预测过程中生成合适的 ARIMA 模型。

@ -38,6 +38,11 @@ ARIMA 模型是一种自回归模型，只需要自变量即可预测后续的
 FORECAST(i32, "algo=arima,alpha=95,period=10,start_p=1,max_p=5,start_q=1,max_q=5")
 ```

+完整的调用SQL语句如下：
+```SQL
+SELECT _frowts, FORECAST(i32, "algo=arima,alpha=95,period=10,start_p=1,max_p=5,start_q=1,max_q=5") from foo
+```
+
 ```json5
 {
 "rows": fc_rows,  // 返回结果的行数
@ -51,4 +56,4 @@ FORECAST(i32, "algo=arima,alpha=95,period=10,start_p=1,max_p=5,start_q=1,max_q=5

 ### 参考文献
 - https://en.wikipedia.org/wiki/Autoregressive_moving-average_model
- https://baike.baidu.com/item/%E8%87%AA%E5%9B%9E%E5%BD%92%E6%BB%91%E5%8A%A8%E5%B9%B3%E5%9D%87%E6%A8%A1%E5%9E%8B/5023931?fromtitle=ARMA%E6%A8%A1%E5%9E%8B&fromid=8048415
+- [https://baike.baidu.com/item/自回归滑动平均模型/5023931](https://baike.baidu.com/item/%E8%87%AA%E5%9B%9E%E5%BD%92%E6%BB%91%E5%8A%A8%E5%B9%B3%E5%9D%87%E6%A8%A1%E5%9E%8B/5023931)
--- a/docs/zh/06-advanced/06-TDgpt/04-forecast/03-holtwinters.md
+++ b/docs/zh/06-advanced/06-TDgpt/04-forecast/03-holtwinters.md
@ -23,11 +23,16 @@ HoltWinters 有两种不同的季节性组成部分，当季节变化在该时
 参数 `trend` 和 `seasonal`的均可以选择 `add` （加法模型）或 `mul`（乘法模型）。

 ### 示例及结果
-针对 i32 列进行数据预测，输入列 i32 每 10 个点是一个周期，趋势采用乘法模型，季节采用乘法模型
+针对 i32 列进行数据预测，输入列 i32 每 10 个点是一个周期，趋势参数采用乘法模型，季节参数采用乘法模型
 ```
 FORECAST(i32, "algo=holtwinters,period=10,trend=mul,seasonal=mul")
 ```

+完整的调用SQL语句如下：
+```SQL
+SELECT _frowts, FORECAST(i32, "algo=holtwinters, peroid=10,trend=mul,seasonal=mul") from foo
+```
+
 ```json5
 {
 "rows": rows,         // 返回结果的行数
--- a/docs/zh/06-advanced/06-TDgpt/04-forecast/index.md
+++ b/docs/zh/06-advanced/06-TDgpt/04-forecast/index.md
@ -0,0 +1,93 @@
+---
+title: 预测算法
+description: 预测算法
+---
+
+时序数据预测处理以持续一个时间段的时序数据作为输入，预测接下来一个连续时间区间内时间序列数据趋势。用户可以指定输出的（预测）时间序列数据点的数量，因此其输出的结果行数不确定。为此，TDengine 使用新 SQL 函数 `FORECAST` 提供时序数据预测服务。基础数据（用于预测的历史时间序列数据）是该函数的输入，预测结果是该函数的输出。用户可以通过 `FORECAST` 函数调用 Anode 提供的预测算法提供的服务。
+
+在后续章节中，使用时序数据表`foo`作为示例，介绍预测和异常检测算法的使用方式，`foo` 表的模式如下：
+
+|列名称|类型|说明|
+|---|---|---|
+|ts| timestamp| 主时间戳列|
+|i32| int32| 4字节整数，设备测量值 metric|
+
+```bash
+taos> select * from foo;
+           ts            |      k      |
+========================================
+ 2020-01-01 00:00:12.681 |          13 |
+ 2020-01-01 00:00:13.727 |          14 |
+ 2020-01-01 00:00:14.378 |           8 |
+ 2020-01-01 00:00:15.774 |          10 |
+ 2020-01-01 00:00:16.170 |          16 |
+ 2020-01-01 00:00:17.558 |          26 |
+ 2020-01-01 00:00:18.938 |          32 |
+ 2020-01-01 00:00:19.308 |          27 |
+```
+
+### 语法
+```SQL
+FORECAST(column_expr, option_expr)
+
+option_expr: {"
+algo=expr1
+[,wncheck=1|0]
+[,conf=conf_val]
+[,every=every_val]
+[,rows=rows_val]
+[,start=start_ts_val]
+[,expr2]
+"}
+
+```
+1. `column_expr`：预测的时序数据列。与异常检测相同，只支持数值类型列输入。
+2. `options`：异常检测函数的参数，使用规则与 anomaly_window 相同。预测支持 `conf`, `every`, `rows`, `start`, `rows` 几个控制参数，其含义如下：
+
+### 参数说明
+
+|参数|含义|默认值|
+|---|---|---|
+|algo|预测分析使用的算法|holtwinters|
+|wncheck|白噪声（white noise data）检查|默认值为 1，0 表示不进行检查|
+|conf|预测数据的置信区间范围 ，取值范围 [0, 100]|95|
+|every|预测数据的采样间隔|输入数据的采样间隔|
+|start|预测结果的开始时间戳|输入数据最后一个时间戳加上一个采样间隔时间区间|
+|rows|预测结果的记录数|10|
+
+1. 预测查询结果新增三个伪列，具体如下：`_FROWTS`：预测结果的时间戳、`_FLOW`：置信区间下界、`_FHIGH`：置信区间上界, 对于没有置信区间的预测算法，其置信区间同预测结果
+2. 更改参数 `START`：返回预测结果的起始时间，改变起始时间不会影响返回的预测数值，只影响起始时间。
+3. `EVERY`：可以与输入数据的采样频率不同。采样频率只能低于或等于输入数据采样频率，不能**高于**输入数据的采样频率。
+4. 对于某些不需要计算置信区间的算法，即使指定了置信区间，返回的结果中其上下界退化成为一个点。
+
+### 示例
+
+```SQL
+--- 使用 arima 算法进行预测，预测结果是 10 条记录（默认值），数据进行白噪声检查，默认置信区间 95%. 
+SELECT  _flow, _fhigh, _frowts, FORECAST(i32, "algo=arima")
+FROM foo;
+
+--- 使用 arima 算法进行预测，输入数据的是周期数据，每 10 个采样点是一个周期，返回置信区间是95%的上下边界，同时忽略白噪声检查
+SELECT  _flow, _fhigh, _frowts, FORECAST(i32, "algo=arima,alpha=95,period=10,wncheck=0")
+FROM foo;
+```
+```
+taos> select _flow, _fhigh, _frowts, forecast(i32) from foo;
+        _flow         |        _fhigh        |       _frowts           | forecast(i32) |
+========================================================================================
+           10.5286684 |           41.8038254 | 2020-01-01 00:01:35.000 |            26 |
+          -21.9861946 |           83.3938904 | 2020-01-01 00:01:36.000 |            30 |
+          -78.5686035 |          144.6729126 | 2020-01-01 00:01:37.000 |            33 |
+         -154.9797363 |          230.3057709 | 2020-01-01 00:01:38.000 |            37 |
+         -253.9852905 |          337.6083984 | 2020-01-01 00:01:39.000 |            41 |
+         -375.7857971 |          466.4594727 | 2020-01-01 00:01:40.000 |            45 |
+         -514.8043823 |          622.4426270 | 2020-01-01 00:01:41.000 |            53 |
+         -680.6343994 |          796.2861328 | 2020-01-01 00:01:42.000 |            57 |
+         -868.4956665 |          992.8603516 | 2020-01-01 00:01:43.000 |            62 |
+        -1076.1566162 |         1214.4498291 | 2020-01-01 00:01:44.000 |            69 |
+```
+
+
+## 内置预测算法
+- [arima](./02-arima.md)
+- [holtwinters](./03-holtwinters.md)
--- a/docs/zh/06-advanced/06-TDgpt/05-anomaly-detection/02-statistics-approach.md
+++ b/docs/zh/06-advanced/06-TDgpt/05-anomaly-detection/02-statistics-approach.md
@ -0,0 +1,57 @@
+---
+title: "统计学算法"
+sidebar_label: "统计学算法"
+---
+
+- k-sigma<sup>[1]</sup>: 即 ***68–95–99.7 rule*** 。***k***值默认为 3，即序列均值的 3 倍标准差范围为边界，超过边界的是异常值。KSigma 要求数据整体上服从正态分布，如果一个点偏离均值 K 倍标准差，则该点被视为异常点.
+
+|参数|说明|是否必选|默认值|
+|---|---|---|---|
+|k|标准差倍数|选填|3|
+
+```SQL
+--- 指定调用的算法为ksigma, 参数 k 为 2
+SELECT _WSTART, COUNT(*)
+FROM foo
+ANOMALY_WINDOW(foo.i32, "algo=ksigma,k=2")
+```
+
+- IQR<sup>[2]</sup>：Interquartile range(IQR)，四分位距是一种衡量变异性的方法。四分位数将一个按等级排序的数据集划分为四个相等的部分。即 Q1（第 1 个四分位数）、Q2（第 2 个四分位数）和 Q3（第 3 个四分位数）。 $IQR=Q3-Q1$，对于 $v$, $Q1-(1.5 \times IQR) \le v \le Q3+(1.5 \times IQR)$ 是正常值，范围之外的是异常值。无输入参数。
+
+```SQL
+--- 指定调用的算法为 iqr, 无参数
+SELECT _WSTART, COUNT(*)
+FROM foo
+ANOMALY_WINDOW(foo.i32, "algo=iqr")
+```
+
+- Grubbs<sup>[3]</sup>: Grubbs' test，即最大标准残差测试。Grubbs 通常用作检验最大值、最小值偏离均值的程度是否为异常，要求单变量数据集遵循近似标准正态分布。非正态分布数据集不能使用该方法。无输入参数。
+
+```SQL
+--- 指定调用的算法为 grubbs, 无参数
+SELECT _WSTART, COUNT(*)
+FROM foo
+ANOMALY_WINDOW(foo.i32, "algo=grubbs")
+```
+
+- SHESD<sup>[4]</sup>： 带有季节性的 ESD 检测算法。ESD 可以检测时间序列数据的多异常点。需要指定异常检测方向（'pos' / 'neg' / 'both'），异常值比例的上界***max_anoms***，最差的情况是至多 49.9%。数据集的异常比例一般不超过 5%
+
+|参数|说明|是否必选|默认值|
+|---|---|---|---|
+|direction|异常检测方向类型('pos' / 'neg' / 'both')|否|"both"|
+|max_anoms|异常值比例 $0 < K \le 49.9$|否|0.05|
+|period|一个周期包含的数据点|否|0|
+
+
+```SQL
+--- 指定调用的算法为 shesd, 参数 direction 为 both，异常值比例 5%
+SELECT _WSTART, COUNT(*)
+FROM foo
+ANOMALY_WINDOW(foo.i32, "algo=shesd,direction=both,anoms=0.05")
+```
+
+### 参考文献
+1. [https://en.wikipedia.org/wiki/68–95–99.7 rule](https://en.wikipedia.org/wiki/68%E2%80%9395%E2%80%9399.7_rule)
+2. https://en.wikipedia.org/wiki/Interquartile_range
+3. Adikaram, K. K. L. B.; Hussein, M. A.; Effenberger, M.; Becker, T. (2015-01-14). "Data Transformation Technique to Improve the Outlier Detection Power of Grubbs's Test for Data Expected to Follow Linear Relation". Journal of Applied Mathematics. 2015: 1–9. doi:10.1155/2015/708948.
+4. Hochenbaum, O. S. Vallis, and A. Kejariwal. 2017. Automatic Anomaly Detection in the Cloud Via Statistical Learning. arXiv preprint arXiv:1704.07706 (2017).
--- a/docs/zh/06-advanced/06-TDgpt/05-anomaly-detection/03-data-density.md
+++ b/docs/zh/06-advanced/06-TDgpt/05-anomaly-detection/03-data-density.md
@ -0,0 +1,20 @@
+---
+title: "数据密度算法"
+sidebar_label: "数据密度算法"
+---
+
+### 基于数据密度的检测方法
+LOF<sup>[1]</sup>: Local Outlier Factor(LOF)，局部离群因子/局部异常因子，
+是 Breunig 在 2000 年提出的一种基于密度的局部离群点检测算法，该方法适用于不同类簇密度分散情况迥异的数据。根据数据点周围的数据密集情况，首先计算每个数据点的一个局部可达密度，然后通过局部可达密度进一步计算得到每个数据点的一个离群因子，
+该离群因子即标识了一个数据点的离群程度，因子值越大，表示离群程度越高，因子值越小，表示离群程度越低。最后，输出离群程度最大的 $topK$ 个点。
+
+```SQL
+--- 指定调用的算法为LOF，即可调用该算法
+SELECT count(*)
+FROM foo
+ANOMALY_WINDOW(foo.i32, "algo=lof")
+```
+
+### 参考文献
+
+1. Breunig, M. M.; Kriegel, H.-P.; Ng, R. T.; Sander, J. (2000). LOF: Identifying Density-based Local Outliers (PDF). Proceedings of the 2000 ACM SIGMOD International Conference on Management of Data. SIGMOD. pp. 93–104. doi:10.1145/335191.335388. ISBN 1-58113-217-4.
--- a/docs/zh/06-advanced/06-TDgpt/05-anomaly-detection/04-machine-learning.md
+++ b/docs/zh/06-advanced/06-TDgpt/05-anomaly-detection/04-machine-learning.md
@ -0,0 +1,17 @@
+---
+title: "机器学习算法"
+sidebar_label: "机器学习算法"
+---
+
+Autoencoder<sup>[1]</sup>: TDgpt 内置使用自编码器（Autoencoder）的异常检测算法，对周期性的时间序列数据具有较好的检测结果。使用该模型需要针对输入时序数据进行预训练，同时将训练完成的模型保存在到服务目录 `ad_autoencoder` 中，然后在 SQL 语句中指定调用该算法模型即可使用。
+
+```SQL
+--- 在 options 中增加 model 的名称，ad_autoencoder_foo， 针对 foo 数据集（表）训练的采用自编码器的异常检测模型进行异常检测
+SELECT COUNT(*), _WSTART
+FROM foo
+ANOMALY_DETECTION(col1, 'algo=encoder, model=ad_autoencoder_foo');
+```
+
+### 参考文献
+
+1. https://en.wikipedia.org/wiki/Autoencoder
--- a/docs/zh/06-advanced/06-TDgpt/05-anomaly-detection/index.md
+++ b/docs/zh/06-advanced/06-TDgpt/05-anomaly-detection/index.md
@ -0,0 +1,69 @@
+---
+title: 异常检测算法
+description: 异常检测算法
+---
+
+import ad from '../pic/anomaly-detection.png';
+
+TDengine 中定义了异常（状态）窗口来提供异常检测服务。异常窗口可以视为一种特殊的**事件窗口（Event Window）**，即异常检测算法确定的连续异常时间序列数据所在的时间窗口。与普通事件窗口区别在于——时间窗口的起始时间和结束时间均是分析算法识别确定，不是用户给定的表达式进行判定。因此，在 `WHERE` 子句中使用 `ANOMALY_WINDOW` 关键词即可调用时序数据异常检测服务，同时窗口伪列（`_WSTART`, `_WEND`, `_WDURATION`）也能够像其他时间窗口一样用于描述异常窗口的起始时间(`_WSTART`)、结束时间(`_WEND`)、持续时间(`_WDURATION`)。例如：
+
+```SQL
+--- 使用异常检测算法 IQR 对输入列 col_val 进行异常检测。同时输出异常窗口的起始时间、结束时间、以及异常窗口内 col 列的和。
+SELECT _wstart, _wend, SUM(col) 
+FROM foo
+ANOMALY_WINDOW(col_val, "algo=iqr");
+```
+
+如下图所示，Anode 将返回时序数据异常窗口 $[10:51:30, 10:53:40]$ 
+
+<img src={ad} width="760" alt="异常检测" />
+
+在此基础上，用户可以针对异常窗口内的时序数据进行查询聚合、变换处理等操作。
+
+### 语法
+
+```SQL
+ANOMALY_WINDOW(column_name, option_expr)
+
+option_expr: {"
+algo=expr1
+[,wncheck=1|0]
+[,expr2]
+"}
+```
+
+1. `column_name`：进行时序数据异常检测的输入数据列，当前只支持单列，且只能是数值类型，不能是字符类型（例如：`NCHAR` `VARCHAR` `VARBINARY`等类型），**不支持函数表达式**。
+2. `options`：字符串。其中使用 K=V 调用异常检测算法及与算法相关的参数。采用逗号分隔的 K=V 字符串表示，其中的字符串不需要使用单引号、双引号、或转义号等符号，不能使用中文及其他宽字符。例如：`algo=ksigma,k=2` 表示进行异常检测的算法是 ksigma，该算法接受的输入参数是 2。
+3. 异常检测的结果可以作为外层查询的子查询输入，在 `SELECT` 子句中使用的聚合函数或标量函数与其他类型的窗口查询相同。
+4. 输入数据默认进行白噪声检查，如果输入数据是白噪声，将不会有任何（异常）窗口信息返回。
+
+### 参数说明
+|参数|含义|默认值|
+|---|---|---|
+|algo|异常检测调用的算法|iqr|
+|wncheck|对输入数据列是否进行白噪声检查，取值为0或1|1|
+
+
+### 示例
+```SQL
+--- 使用 iqr 算法进行异常检测，检测列 i32 列。
+SELECT _wstart, _wend, SUM(i32) 
+FROM foo
+ANOMALY_WINDOW(i32, "algo=iqr");
+
+--- 使用 ksigma 算法进行异常检测，输入参数 k 值为 2，检测列 i32 列
+SELECT _wstart, _wend, SUM(i32) 
+FROM foo
+ANOMALY_WINDOW(i32, "algo=ksigma,k=2");
+
+taos> SELECT _wstart, _wend, count(*) FROM foo ANOMAYL_WINDOW(i32);
+         _wstart         |          _wend          |   count(*)    |
+====================================================================
+ 2020-01-01 00:00:16.000 | 2020-01-01 00:00:17.000 |             2 |
+Query OK, 1 row(s) in set (0.028946s)
+```
+
+
+### 内置异常检测算法
+分析平台内置了6个异常检查模型，分为3个类别，分别是[基于统计学的算法](./02-statistics-approach.md)、[基于数据密度的算法](./03-data-density.md)、以及[基于机器学习的算法](./04-machine-learning.md)。在不指定异常检测使用的方法的情况下，默认调用 IQR 进行异常检测。
+
--- a/docs/zh/06-advanced/06-TDgpt/06-dev/02-forecast.md
+++ b/docs/zh/06-advanced/06-TDgpt/06-dev/02-forecast.md
@ -0,0 +1,110 @@
+---
+title: "预测算法"
+sidebar_label: "预测算法"
+---
+
+### 输入约定
+`execute` 是预测算法处理的核心方法。框架调用该方法之前，在对象属性参数 `self.list` 中已经设置完毕用于预测的历史时间序列数据。
+
+### 输出约定及父类属性说明
+`execute` 方法执行完成后的返回一个如下字典对象， 预测返回结果如下：
+```python
+return {
+    "mse": mse, # 预测算法的拟合数据最小均方误差(minimum squared error)
+    "res": res  # 结果数组 [时间戳数组, 预测结果数组, 预测结果执行区间下界数组，预测结果执行区间上界数组]
+}
+```
+
+
+预测算法的父类 `AbstractForecastService` 包含的对象属性如下：
+
+|属性名称|说明|默认值|
+|---|---|---|
+|period|输入时间序列的周期性，多少个数据点表示一个完整的周期。如果没有周期性，设置为 0 即可|	0|
+|start_ts|预测结果的开始时间|	0|
+|time_step|预测结果的两个数据点之间时间间隔|0	|
+|fc_rows|预测结果的数量|	0	|
+|return_conf|预测结果中是否包含置信区间范围，如果不包含置信区间，那么上界和下界与自身相同|	1|	
+|conf|置信区间分位数|95|
+
+
+
+### 示例代码
+下面我们开发一个示例预测算法，对于任何输入的时间序列数据，固定返回值 1 作为预测结果。
+
+```python
+import numpy as np
+from service import AbstractForecastService
+
+# 算法实现类名称 需要以下划线 "_" 开始，并以 Service 结束
+class _MyForecastService(AbstractForecastService):
+    """ 定义类，从 AbstractForecastService 继承并实现其定义的抽象方法 execute  """
+
+    # 定义算法调用关键词，全小写ASCII码
+    name = 'myfc'
+
+    # 该算法的描述信息(建议添加)
+    desc = """return the forecast time series data"""
+
+    def __init__(self):
+        """类初始化方法"""
+        super().__init__()
+
+    def execute(self):
+	""" 算法逻辑的核心实现"""
+        res = []
+
+        """这个预测算法固定返回 1 作为预测值，预测值的数量是用户通过 self.fc_rows 指定"""
+        ts_list = [self.start_ts + i * self.time_step for i in range(self.fc_rows)]
+        res.app(ts_list)  #  设置预测结果时间戳列
+
+        """生成全部为 1 的预测结果 """
+        res_list = [1] * self.fc_rows
+        res.append(res_list)
+
+        """检查用户输入，是否要求返回预测置信区间上下界"""
+        if self.return_conf:
+           """对于没有计算预测置信区间上下界的算法，直接返回预测值作为上下界即可"""
+           bound_list = [1] * self.fc_rows
+           res.append(bound_list) #  预测结果置信区间下界
+           res.append(bound_list) #  预测结果执行区间上界	 
+
+        """返回结果"""
+        return { "res": res, "mse": 0}
+
+	
+    def set_params(self, params):
+	"""该算法无需任何输入参数，直接重载父类该函数，不处理算法参数设置逻辑"""
+        pass
+```
+
+将该文件保存在 `./taosanalytics/algo/fc/` 目录下，然后重启 taosanode 服务。在 TDengine 命令行接口中执行 `SHOW ANODES FULL` 能够看到新加入的算法。应用就可以通过 SQL 语句调用该预测算法。
+
+```SQL
+--- 对 col 列进行异常检测，通过指定 algo 参数为 myfc 来调用新添加的预测类
+SELECT  _flow, _fhigh, _frowts, FORECAST(col_name, "algo=myfc")
+FROM foo;
+```
+
+如果是第一次启动该 Anode, 请按照 [TDgpt 安装部署](../../management/) 里的步骤先将该 Anode 添加到 TDengine 系统中。
+
+### 单元测试
+
+在测试目录`taosanalytics/test`中的 forecast_test.py 中增加单元测试用例或添加新的测试文件。单元测试依赖 Python Unit test 包。
+
+```python
+def test_myfc(self):
+    """ 测试 myfc 类 """
+    s = loader.get_service("myfc")
+
+    # 设置用于预测分析的数据
+    s.set_input_list(self.get_input_list())
+    # 检查预测结果应该全部为 1
+    r = s.set_params(
+        {"fc_rows": 10, "start_ts": 171000000, "time_step": 86400 * 30, "start_p": 0}
+    )
+    r = s.execute()
+
+    expected_list = [1] * 10
+    self.assertEqlist(r["res"][0], expected_list)
+```
--- a/docs/zh/06-advanced/06-TDgpt/06-dev/03-ad.md
+++ b/docs/zh/06-advanced/06-TDgpt/06-dev/03-ad.md
@ -0,0 +1,76 @@
+---
+title: "异常检测"
+sidebar_label: "异常检测"
+---
+
+### 输入约定
+`execute` 是算法处理的核心方法。框架调用该方法之前，在对象属性参数 `self.list` 中已经设置完毕用于异常检测的时间序列数据。
+
+### 输出约定
+`execute` 方法执行完成后的返回值是长度与 `self.list` 相同的数组，数组位置 -1 的标识异常值点。
+> 例如：对于输入测量值序列 $[2, 2, 2, 2, 100]$， 假设 100 是异常点，那么方法返回的结果数组则为 $[1, 1, 1, 1, -1]$。
+
+
+### 示例代码
+下面我们开发一个示例异常检测算法，在异常检测中，将输入时间序列值的最后一个值设置为异常值，并返回结果。
+
+```python
+import numpy as np
+from service import AbstractAnomalyDetectionService
+
+# 算法实现类名称 需要以下划线 "_" 开始，并以 Service 结束
+class _MyAnomalyDetectionService(AbstractAnomalyDetectionService):
+    """ 定义类，从 AbstractAnomalyDetectionService 继承，并实现 AbstractAnomalyDetectionService 类的抽象方法  """
+
+    # 定义算法调用关键词，全小写ASCII码
+    name = 'myad'
+
+    # 该算法的描述信息(建议添加)
+    desc = """return the last value as the anomaly data"""
+
+    def __init__(self):
+        """类初始化方法"""
+        super().__init__()
+
+    def execute(self):
+	""" 算法逻辑的核心实现"""
+
+        """创建一个长度为 len(self.list)，全部值为 1 的结果数组，然后将最后一个值设置为 -1，表示最后一个值是异常值"""
+        res = [1] * len(self.list)
+        res[-1] = -1
+
+        """返回结果数组"""
+        return res
+
+	
+    def set_params(self, params):
+	"""该算法无需任何输入参数，直接重载父类该函数，不处理算法参数设置逻辑"""
+        pass
+```
+
+将该文件保存在 `./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 系统中。
+
+### 单元测试
+
+在测试目录`taosanalytics/test`中的 anomaly_test.py 中增加单元测试用例或添加新的测试文件。框架中使用了 Python Unit test 包。
+
+```python
+def test_myad(self):
+    """ 测试 _IqrService 类 """
+    s = loader.get_service("myad")
+
+    # 设置需要进行检测的输入数据
+    s.set_input_list(AnomalyDetectionTest.input_list)
+
+    r = s.execute()
+
+    # 最后一个点是异常点
+    self.assertEqual(r[-1], -1)
+    self.assertEqual(len(r), len(AnomalyDetectionTest.input_list))
+```
--- a/docs/zh/06-advanced/06-TDgpt/06-dev/index.md
+++ b/docs/zh/06-advanced/06-TDgpt/06-dev/index.md
@ -0,0 +1,82 @@
+---
+title: "算法开发者指南"
+sidebar_label: "算法开发者指南"
+---
+TDgpt 是一个可扩展的时序数据高级分析平台，用户遵循简易的步骤就能将自己开发的分析算法添加到分析平台, 各种应用就可以通过SQL语句直接调用, 让高级分析算法的使用门槛降到几乎为零。目前 TDpgt 平台只支持使用 Python 语言开发的分析算法。
+Anode 采用类动态加载模式，在启动的时候扫描特定目录内满足约定条件的所有代码文件，并将其加载到系统中。因此，开发者只需要遵循以下几步就能完成新算法的添加工作：
+1. 开发完成符合要求的分析算法类
+2. 将代码文件放入对应目录，然后重启 Anode
+3. 使用SQL命令"CREATE ANODE"，将 Anode 添加到 TDengine
+   
+此时就完成了新算法的添加工作，之后应用就可以直接使用SQL语句调用新算法。得益于 TDgpt 与 TDengine主进程 `taosd` 的松散耦合，Anode算法升级对 `taosd` 完全没有影响。应用系统只需要调整对应的SQL语句调用新（升级的）算法，就能够快速完成分析功能和分析算法的升级。
+
+这种方式能够按需扩展分析算法，极大地拓展 TDgpt 的适应范围，用户可以按需将更契合业务场景的、更准确的（预测、异常检测）分析算法动态嵌入到 TDgpt，并通过 SQL 语句进行调用。在基本不用更改应用系统代码的前提下，就能够快速完成分析功能的平滑升级。
+
+以下内容将说明如何将分析算法添加到 Anode 中并能够通过SQL语句进行调用。
+
+## 目录结构
+Anode的主要目录结构如下图所示
+
+```bash
+.
+├── cfg
+├── model
+│   └── ac_detection
+├── release
+├── script
+└── taosanalytics
+    ├── algo
+    │   ├── ad
+    │   └── fc
+    ├── misc
+    └── test
+
+```
+
+|目录|说明|
+|---|---|
+|taosanalytics| 源代码目录，其下包含了算法具体保存目录 algo，放置杂项目录 misc，单元测试和集成测试目录 test。 algo 目录下 ad 保存异常检测算法代码，fc 目录保存预测算法代码|
+|script|是安装脚本和发布脚本放置目录|
+|model|放置针对数据集完成的训练模型|
+|cfg|配置文件目录|
+
+## 约定与限制
+
+- 异常检测算法的 Python 代码文件需放在 `./taos/algo/ad` 目录中
+- 预测算法 Python 代码文件需要放在 `./taos/algo/fc` 目录中
+
+
+### 类命名规范
+
+Anode采用算法自动加载模式，因此只识别符合命名约定的 Python 类。需要加载的算法类名称需要以下划线 `_` 开始并以 `Service` 结尾。例如：`_KsigmaService` 是  KSigma 异常检测算法类。
+
+### 类继承约定
+
+- 异常检测算法需要从 `AbstractAnomalyDetectionService` 继承，并实现其核心抽象方法 `execute`
+- 预测算法需要从 `AbstractForecastService` 继承，同样需要实现其核心抽象方法 `execute`
+
+### 类属性初始化
+实现的类需要初始化以下两个类属性：
+
+- `name`：识别该算法的关键词，全小写英文字母。通过 `SHOW` 命令查看可用算法显示的名称即为该名称。
+- `desc`：算法的基础描述信息
+
+```SQL
+--- algo 后面的参数 name 即为类属性 `name`
+SELECT COUNT(*) FROM foo ANOMALY_DETECTION(col_name, 'algo=name')
+```
+
+## 添加具有模型的分析算法
+
+基于统计学的分析算法可以直接针对输入时间序列数据进行分析，但是某些深度学习算法对于输入数据需要较长的时间训练，并且生成相应的模型。这种情况下，同一个分析算法对应不同的输入数据集有不同的分析模型。
+将具有模型的分析算法添加到 Anode 中，首先需要在 `model` 目录中建立该算法对应的目录（目录名称可自拟），将采用该算法针对不同的输入时间序列数据生成的训练模型均需要保存在该目录下，同时目录名称要在分析算法中确定，以便能够固定加载该目录下的分析模型。为了确保模型能够正常读取加载，存储的模型使用`joblib`库进行序列化保存。
+
+下面以自编码器（Autoencoder）为例，说明如何添加要预先训练的模型进行异常检测。
+首先我们在`model`目录中创建一个目录 -- `ad_detection`，该目录将用来保存所有使用自编码器训练的模型。然后，我们使用自编码器对 foo 表的时间序列数据进行训练，得到模型 ad_autoencoder_foo，使用 `joblib`序列化以后保存在`ad_detection` 目录中。
+
+使用 SQL 调用已经保存的模型，需要在调用参数中指定模型名称``model=ad_autoencoder_foo`，而 `algo=encoder` 是确定调用的自编码器生成的模型（这里的`encoder`说明调用的是自编码器算法模型，该名称是添加算法的时候在代码中定义）以便能够调用该模型。
+
+```SQL
+--- 在 options 中增加 model 的名称，ad_autoencoder_foo， 针对 foo 数据集（表）训练的采用自编码器的异常检测模型进行异常检测
+SELECT COUNT(*), _WSTART FROM foo ANOMALY_DETECTION(col1, 'algo=encoder, model=ad_autoencoder_foo');
+```
--- a/docs/zh/06-advanced/06-TDgpt/index.md
+++ b/docs/zh/06-advanced/06-TDgpt/index.md
@ -0,0 +1,25 @@
+---
+sidebar_label: TDgpt
+title: TDgpt
+---
+
+import TDgpt from './pic/data-analysis.png';
+
+
+TDgpt 是 TDengine Enterprise 中针对时序数据提供高级分析功能的企业级组件，通过内置接口向 TDengine 提供运行时动态扩展的时序数据分析服务。TDgpt 能够独立于 TDengine 主进程部署和运行，因此可避免消耗占用 TDengine 集群的主进程资源。
+TDgpt 具有服务无状态、功能易扩展、快速弹性部署、应用轻量化、高安全性等优势。
+TDgpt 运行在集群中的 AI Node (Anode)中，集群中可以部署若干个 Anode 节点，不同的 Anode 节点之间无同步依赖或协同的要求。Anode 注册到 TDengine 集群以后，立即就可以提供服务。TDgpt 提供的高级时序数据分析服务可分为时序数据异常检测和时序数据预测分析两大类。
+
+下图是部署 TDgpt 的 TDengine 集群示意图。
+<img src={TDgpt} width="560" alt="TDgpt架构图" />
+
+在查询处理过程中，Vnode中运行的查询引擎会根据查询处理物理执行计划，按需向 Anode 请求高级时序数据分析服务。因此用户可通过 SQL 语句与 Anode 节点交互并使用其提供的全部分析服务。需要注意的是 Anode 不直接接受用户的数据分析请求。同时 Anode 具备分析算法动态注册机制，其算法扩展过程完全不影响 TDengine 集群的服务，仅在非常小的（秒级）时间窗口内影响涉及高级分析的查询服务。
+
+目前 TDgpt 提供如下的高级分析服务：
+- 时序数据异常检测。TDengine 中定义了新的时间窗口——异常（状态）窗口——来提供异常检测服务。异常窗口可以视为一种特殊的**事件窗口（Event Window）**，即异常检测算法确定的连续异常时间序列数据所在的时间窗口。与普通事件窗口区别在于——时间窗口的起始时间和结束时间均是分析算法确定，不是用户指定的表达式判定。异常窗口使用方式与其他类型的时间窗口（例如状态窗口、会话窗口等）类似。因此时间窗口内可使用的查询操作均可应用在异常窗口上。
+- 时序数据预测。定义了一个新函数`FORECAST`，基于输入的（历史）时间序列数据调用指定（或默认）预测算法给出输入时序数据后续时间序列的**预测**数据。
+
+TDgpt 还为算法开发者提供了一 SDK。任何开发者只需要按照[算法开发者指南](./dev)的步骤，就可以将自己独有的时序数据预测或时序数据异常检测算法无缝集成到 TDgpt, 这样 TDengine 用户就可以通过一条 SQL 获得时序数据预测结果或是异常窗口了, 大幅降低了用户使用新的时序数据分析算法的门槛，而且让 TDengine 成为一开放的系统。
+
+
+
--- a/docs/zh/06-advanced/06-TDgpt/pic/activity.png
+++ b/docs/zh/06-advanced/06-TDgpt/pic/activity.png
--- a/docs/zh/06-advanced/06-TDgpt/pic/anomaly-detection.png
+++ b/docs/zh/06-advanced/06-TDgpt/pic/anomaly-detection.png
--- a/docs/zh/06-advanced/06-TDgpt/pic/data-analysis.png
+++ b/docs/zh/06-advanced/06-TDgpt/pic/data-analysis.png
--- a/docs/zh/06-advanced/06-TDgpt/pic/white-noise-data.png
+++ b/docs/zh/06-advanced/06-TDgpt/pic/white-noise-data.png
--- a/docs/zh/06-advanced/06-data-analysis/03-anomaly-detection.md
+++ b/docs/zh/06-advanced/06-data-analysis/03-anomaly-detection.md
@ -1,46 +0,0 @@
---
-title: "Anomaly-detection"
-sidebar_label: "Anomaly-detection"
---
-
-本节讲述异常检测算法模型的使用方法。
-
-## 概述
-分析平台提供了 6 种异常检查模型，6 种异常检查模型分为 3 个类别，分别属于基于统计的异常检测模型、基于数据密度的检测模型、基于深度学习的异常检测模型。在不指定异常检测使用的方法的情况下，默认调用 iqr 的方法进行计算。
-
-
-### 统计学异常检测方法
-
- k-sigma<sup>[1]</sup>: 即 ***68–95–99.7 rule*** 。***k***值默认为 3，即序列均值的 3 倍标准差范围为边界，超过边界的是异常值。KSigma 要求数据整体上服从正态分布，如果一个点偏离均值 K 倍标准差，则该点被视为异常点.
-  
-|参数|说明|是否必选|默认值|
-|---|---|---|---|
-|k|标准差倍数|选填|3|
-
-
- IQR<sup>[2]</sup>：四分位距 (Interquartile range, IQR) 是一种衡量变异性的方法. 四分位数将一个按等级排序的数据集划分为四个相等的部分。即 Q1（第 1 个四分位数）、Q2（第 2 个四分位数）和 Q3（第 3 个四分位数）。IQR 定义为 Q3–Q1，位于 Q3+1.5。无输入参数。
-
- Grubbs<sup>[3]</sup>: 又称为 Grubbs' test，即最大标准残差测试。Grubbs 通常用作检验最大值、最小值偏离均值的程度是否为异常，该单变量数据集遵循近似标准正态分布。非正态分布数据集不能使用该方法。无输入参数。
-
- SHESD<sup>[4]</sup>： 带有季节性的 ESD 检测算法。ESD 可以检测时间序列数据的多异常点。需要指定异常点比例的上界***k***，最差的情况是至多 49.9%。数据集的异常比例一般不超过 5%
-  
-|参数|说明|是否必选|默认值|
-|---|---|---|---|
-|k|异常点在输入数据集中占比，范围是$`1\le K \le 49.9`$ |选填|5|
-
-
-### 基于数据密度的检测方法
-LOF<sup>[5]</sup>: 局部离群因子（LOF，又叫局部异常因子）算法是 Breunig 于 2000 年提出的一种基于密度的局部离群点检测算法，该方法适用于不同类簇密度分散情况迥异的数据。根据数据点周围的数据密集情况，首先计算每个数据点的一个局部可达密度，然后通过局部可达密度进一步计算得到每个数据点的一个离群因子，该离群因子即标识了一个数据点的离群程度，因子值越大，表示离群程度越高，因子值越小，表示离群程度越低。最后，输出离群程度最大的 top(n) 个点。
-
-
-### 基于深度学习的检测方法
-使用自动编码器的异常检测模型。可以对具有周期性的数据具有较好的检测结果。但是使用该模型需要针对输入的时序数据进行训练，同时将训练完成的模型部署到服务目录中，才能够运行与使用。
-
-
-### 参考文献
-1. https://en.wikipedia.org/wiki/68%E2%80%9395%E2%80%9399.7_rule
-2. https://en.wikipedia.org/wiki/Interquartile_range
-3. Adikaram, K. K. L. B.; Hussein, M. A.; Effenberger, M.; Becker, T. (2015-01-14). "Data Transformation Technique to Improve the Outlier Detection Power of Grubbs's Test for Data Expected to Follow Linear Relation". Journal of Applied Mathematics. 2015: 1–9. doi:10.1155/2015/708948.
-4. Hochenbaum, O. S. Vallis, and A. Kejariwal. 2017. Automatic Anomaly Detection in the Cloud Via Statistical Learning. arXiv preprint arXiv:1704.07706 (2017).
-5. Breunig, M. M.; Kriegel, H.-P.; Ng, R. T.; Sander, J. (2000). LOF: Identifying Density-based Local Outliers (PDF). Proceedings of the 2000 ACM SIGMOD International Conference on Management of Data. SIGMOD. pp. 93–104. doi:10.1145/335191.335388. ISBN 1-58113-217-4.
-
--- a/docs/zh/06-advanced/06-data-analysis/addins.md
+++ b/docs/zh/06-advanced/06-data-analysis/addins.md
@ -1,170 +0,0 @@
---
-title: "addins"
-sidebar_label: "addins"
---
-
-本节说明如何将自己开发的预测算法和异常检测算法整合到 TDengine 分析平台，并能够通过 SQL 语句进行调用。
-
-## 目录结构
-
-![数据分析功能架构图](./pic/dir.png)
-
-|目录|说明|
-|---|---|
-|taos|Python 源代码目录，其下包含了算法具体保存目录 algo，放置杂项目录 misc，单元测试和集成测试目录 test。 algo 目录下 ad 放置异常检测算法代码，fc 放置预测算法代码|
-|script|是安装脚本和发布脚本放置目录|
-|model|放置针对数据集完成的训练模型|
-|cfg|配置文件目录|
-
-## 约定与限制
-
-定义异常检测算法的 Python 代码文件需放在 /taos/algo/ad 目录中，预测算法 Python 代码文件需要放在 /taos/algo/fc 目录中，以确保系统启动的时候能够正常加载对应目录下的 Python 文件。
-
-
-### 类命名规范
-
-算法类的名称需要以下划线开始，以 Service 结尾。例如：_KsigmaService 是  KSigma 异常检测算法的实现类。
-
-### 类继承约定
-
- 异常检测算法需要从 `AbstractAnomalyDetectionService` 继承，并实现其核心抽象方法 `execute`
- 预测算法需要从 `AbstractForecastService` 继承，同样需要实现其核心抽象方法 `execute`
-
-### 类属性初始化
-每个算法实现的类需要静态初始化两个类属性，分别是：
-
- `name`：触发调用的关键词，全小写英文字母
- `desc`：算法的描述信息
-
-### 核心方法输入与输出约定
-
-`execute` 是算法处理的核心方法。调用该方法的时候，`self.list` 已经设置好输入数组。
-
-异常检测输出结果
-
-`execute` 的返回值是长度与 `self.list` 相同的数组，数组位置为 -1 的即为异常值点。例如：输入数组是 [2, 2, 2, 2, 100]， 如果 100 是异常点，那么返回值是 [1, 1, 1, 1, -1]。
-
-预测输出结果
-
-对于预测算法，`AbstractForecastService` 的对象属性说明如下：
-
-|属性名称|说明|默认值|
-|---|---|---|
-|period|输入时间序列的周期性，多少个数据点表示一个完整的周期。如果没有周期性，那么设置为 0 即可|	0|
-|start_ts|预测结果的开始时间|	0|
-|time_step|预测结果的两个数据点之间时间间隔|0	|
-|fc_rows|预测结果的数量|	0	|
-|return_conf|预测结果中是否包含置信区间范围，如果不包含置信区间，那么上界和下界与自身相同|	1|	
-|conf|置信区间分位数 0.05|
-
-
-预测返回结果如下：
-```python
-return {
-    "rows": self.fc_rows,   # 预测数据行数
-    "period": self.period,  # 数据周期性，同输入
-    "algo": "holtwinters",  # 预测使用的算法
-    "mse": mse,				# 预测算法的 mse
-    "res": res              # 结果数组 [时间戳数组, 预测结果数组, 预测结果执行区间下界数组，预测结果执行区间上界数组]
-}
-```
-
-
-## 示例代码
-
-```python
-import numpy as np
-from service import AbstractAnomalyDetectionService
-
-# 算法实现类名称 需要以下划线 "_" 开始，并以 Service 结束，如下 _IqrService 是 IQR 异常检测算法的实现类。
-class _IqrService(AbstractAnomalyDetectionService):
-    """ IQR algorithm 定义类，从 AbstractAnomalyDetectionService 继承，并实现 AbstractAnomalyDetectionService 类的抽象函数  """
-
-	# 定义算法调用关键词，全小写ASCII码(必须添加)
-    name = 'iqr'
-
-	# 该算法的描述信息(建议添加)
-    desc = """found the anomaly data according to the inter-quartile range"""
-
-    def __init__(self):
-        super().__init__()
-
-    def execute(self):
-		""" execute 是算法实现逻辑的核心实现，直接修改该实现即可 """
-
-		# self.list 是输入数值列，list 类型，例如：[1,2,3,4,5]。设置 self.list 的方法在父类中已经进行了定义。实现自己的算法，修改该文件即可，以下代码使用自己的实现替换即可。
-        #lower = np.quantile(self.list, 0.25)
-        #upper = np.quantile(self.list, 0.75)
-
-        #min_val = lower - 1.5 * (upper - lower)
-        #max_val = upper + 1.5 * (upper - lower)
-        #threshold = [min_val, max_val]
-
-		# 返回值是与输入数值列长度相同的数据列，异常值对应位置是 -1。例如上述输入数据列，返回数值列是 [1, 1, 1, 1, -1],表示 [5] 是异常值。
-        return [-1 if k < threshold[0] or k > threshold[1] else 1 for k in self.list]
-
-	
-    def set_params(self, params):
-		"""该算法无需任何输入参数，直接重载父类该函数，不处理算法参数设置逻辑"""
-        pass
-```
-
-
-## 单元测试
-
-在测试文件目录中的 anomaly_test.py 中增加单元测试用例。
-
-```python
-def test_iqr(self):
-	""" 测试 _IqrService 类 """
-    s = loader.get_service("iqr")
-
-    # 设置需要进行检测的输入数据
-    s.set_input_list(AnomalyDetectionTest.input_list)
-
-	#  测试 set_params 的处理逻辑
-    try:
-        s.set_params({"k": 2})
-    except ValueError as e:
-        self.assertEqual(1, 0)
-
-    r = s.execute()
-	
-	# 绘制异常检测结果
-    draw_ad_results(AnomalyDetectionTest.input_list, r, "iqr")
-	
-	# 检查结果
-    self.assertEqual(r[-1], -1)
-    self.assertEqual(len(r), len(AnomalyDetectionTest.input_list))
-```
-
-## 需要模型的算法
-
-针对特定数据集，进行模型训练的算法，在训练完成后。需要将训练得到的模型保存在 model 目录中。需要注意的是，针对每个算法，需要建立独立的文件夹。例如 auto_encoder 的训练算法在 model 目录下建立 autoencoder 的目录，使用该算法针对不同数据集训练得到的模型，均需要放置在该目录下。
-
-训练完成后的模型，使用 joblib 进行保存。
-
-并在 model 目录下建立对应的文件夹存放该模型。
-
-保存模型的调用，可参考  encoder.py 的方式，用户通过调用  set_params 方法，并指定参数 `{"model": "ad_encoder_keras"}` 的方式，可以调用该模型进行计算。
-
-具体的调用方式如下：
-
-```python
-def test_autoencoder_ad(self):
-    # 获取特定的算法服务
-    s = loader.get_service("ac")
-    data = self.__load_remote_data_for_ad()
-	
-    # 设置异常检查的输入数据
-    s.set_input_list(data)
-    
-    # 指定调用的模型，该模型是之前针对该数据集进行训练获得
-    s.set_params({"model": "ad_encoder_keras"})
-    # 执行检查动作，并返回结果
-    r = s.execute()
-
-    num_of_error = -(sum(filter(lambda x: x == -1, r)))
-    self.assertEqual(num_of_error, 109)
-```
-
--- a/docs/zh/06-advanced/06-data-analysis/index.md
+++ b/docs/zh/06-advanced/06-data-analysis/index.md
@ -1,322 +0,0 @@
---
-sidebar_label: 数据分析
-title: 数据分析功能
---
-
-## 概述
-
-ANode（Analysis Node）是 TDengine 提供数据分析功能的扩展组件，通过 Restful 接口提供分析服务，拓展 TDengine 的功能，支持时间序列高级分析。
-ANode 是无状态的数据分析节点，集群中可以存在多个 ANode 节点，相互之间没有关联。将 ANode 注册到 TDengine 集群以后，通过 SQL 语句即可调用并完成时序分析任务。
-下图是数据分析的技术架构示意图。
-
-![数据分析功能架构图](./pic/data-analysis.png)
-
-## 安装部署
-### 环境准备
-ANode 要求节点上准备有 Python 3.10 及以上版本，以及相应的 Python 包自动安装组件 Pip，同时请确保能够正常连接互联网。
-
-### 安装及卸载
-使用专门的 ANode 安装包 TDengine-enterprise-anode-1.x.x.tar.gz 进行 ANode 的安装部署工作，安装过程与 TDengine 的安装流程一致。
-
-```bash
-tar -xzvf TDengine-enterprise-anode-1.0.0.tar.gz
-cd TDengine-enterprise-anode-1.0.0
-sudo ./install.sh
-```
-
-卸载 ANode，执行命令 `rmtaosanode` 即可。
-
-### 其他
-为了避免 ANode 安装后影响目标节点现有的 Python 库。 ANode 使用 Python 虚拟环境运行，安装后的默认 Python 目录处于 `/var/lib/taos/taosanode/venv/`。为了避免反复安装虚拟环境带来的开销，卸载 ANode 并不会自动删除该虚拟环境，如果您确认不需要 Python 的虚拟环境，可以手动删除。
-
-## 启动及停止服务
-安装 ANode 以后，可以使用 `systemctl` 来管理 ANode 的服务。使用如下命令可以启动/停止/检查状态。
-
-```bash
-systemctl start  taosanoded
-systemctl stop   taosanoded
-systemctl status taosanoded
-```
-
-## 目录及配置说明
-|目录/文件|说明|
-|---------------|------|
-|/usr/local/taos/taosanode/bin|可执行文件目录|
-|/usr/local/taos/taosanode/resource|资源文件目录，链接到文件夹 /var/lib/taos/taosanode/resource/|
-|/usr/local/taos/taosanode/lib|库文件目录|
-|/var/lib/taos/taosanode/model/|模型文件目录，链接到文件夹 /var/lib/taos/taosanode/model|
-|/var/log/taos/taosanode/|日志文件目录|
-|/etc/taos/taosanode.ini|配置文件|
-
-### 配置说明
-
-Anode 提供的 RestFul 服务使用 uWSGI 驱动，因此 ANode 和 uWSGI 的配置信息存放在同一个配置文件中，具体如下：
-
-```ini
-[uwsgi]
-# charset
-env = LC_ALL = en_US.UTF-8
-
-# ip:port
-http = 127.0.0.1:6050
-
-# the local unix socket file than communicate to Nginx
-#socket = 127.0.0.1:8001
-#socket-timeout = 10
-
-# base directory
-chdir = /usr/local/taos/taosanode/lib
-
-# initialize python file
-wsgi-file = /usr/local/taos/taosanode/lib/taos/app.py
-
-# call module of uWSGI
-callable = app
-
-# auto remove unix Socket and pid file when stopping
-vacuum = true
-
-# socket exec model
-#chmod-socket = 664
-
-# uWSGI pid
-uid = root
-
-# uWSGI gid
-gid = root
-
-# main process
-master = true
-
-# the number of worker processes
-processes = 2
-
-# pid file
-pidfile = /usr/local/taos/taosanode/taosanode.pid
-
-# enable threads
-enable-threads = true
-
-# the number of threads for each process
-threads = 4
-
-# memory useage report
-memory-report = true
-
-# smooth restart
-reload-mercy = 10
-
-# conflict with systemctl, so do NOT uncomment this
-# daemonize = /var/log/taos/taosanode/taosanode.log
-
-# log directory
-logto = /var/log/taos/taosanode/taosanode.log
-
-# wWSGI monitor port
-stats = 127.0.0.1:8387
-
-# python virtual environment directory
-virtualenv = /usr/local/taos/taosanode/venv/
-
-[taosanode]
-# default app log file
-app-log = /var/log/taos/taosanode/taosanode.app.log
-
-# model storage directory
-model-dir = /usr/local/taos/taosanode/model/
-
-# default log level
-log-level = DEBUG
-
-# draw the query results
-draw-result = 0
-```
-
-**提示**
-请勿设置 `daemonize` 参数，该参数会导致 uWSGI 与 systemctl 冲突，从而无法正常启动。
-
-
-## ANode 基本操作
-### 管理 ANode
-#### 创建 ANode 
-```sql 
-CREATE ANODE {node_url}
-```
-node_url 是提供服务的 ANode 的 IP 和 PORT, 例如：`create anode 'http://localhost:6050'`。启动 ANode 以后如果不注册到 TDengine 集群中，则无法提供正常的服务。不建议 ANode 注册到两个或多个集群中。
-
-#### 查看 ANode
-列出集群中所有的数据分析节点，包括其 `FQDN`, `PORT`, `STATUS`。
-```sql
-SHOW ANODES;
-```
-
-#### 查看提供的时序数据分析服务
-
-```SQL
-SHOW ANODES FULL;
-```
-
-#### 强制刷新集群中的分析算法缓存
-```SQL
-UPDATE ANODE {node_id}
-UPDATE ALL ANODES
-```
-
-#### 删除 ANode 
-```sql
-DROP ANODE {anode_id}
-```
-删除 ANode 只是将 ANode 从 TDengine 集群中删除，管理 ANode 的启停仍然需要使用`systemctl`命令。
-
-### 时序数据分析功能
-
-#### 白噪声检查
-
-分析平台提供的 Restful 服务要求输入的时间序列不能是白噪声时间序列（White Noise Data, WND）和随机数序列 , 因此针对所有数据均默认进行白噪声检查。当前白噪声检查采用通行的 `Ljung-Box` 检验，`Ljung-Box` 统计量检查过程需要遍历整个输入序列并进行计算。
-如果用户能够明确输入序列一定不是白噪声序列，那么可以通过输入参数，指定预测之前忽略该检查，从而节省分析过程的 CPU 计算资源。
-同时支持独立地针对输入序列进行白噪声检测（该检测功能暂不独立对外开放）。
-
-
-#### 数据重采样和时间戳对齐
-
-分析平台支持将输入数据进行重采样预处理，从而确保输出结果按照用户指定的等间隔进行处理。处理过程分为两种类别：
-
- 数据时间戳对齐。由于真实数据可能并非严格按照查询指定的时间戳输入。此时分析平台会自动将数据的时间间隔按照指定的时间间隔进行对齐。例如输入时间序列 [11,  22,  29,  41]，用户指定时间间隔为 10，该序列将被对齐重整为以下序列 [10, 20, 30, 40]。
- 数据时间重采样。用户输入时间序列的采样频率超过了输出结果的频率，例如输入时间序列的采样频率是 5，输出结果的频率是 10，输入时间序列 [0， 5， 10， 15， 20， 25， 30] 将被重采用为间隔 为 10 的序列 [0, 10, 20，30]，[5, 15, 25] 处的数据将被丢弃。
-
-需要注意的是，数据输入平台不支持缺失数据补齐后进行的预测分析，如果输入时间序列数据 [11, 22, 29, 49]，并且用户要求的时间间隔为 10，重整对齐后的序列是 [10, 20, 30, 50] 那么该序列进行预测分析将返回错误。
-
-
-#### 时序数据异常检测
-异常检测是针对输入的时序数据，使用预设或用户指定的算法确定时间序列中**可能**出现异常的时间序列点，对于时间序列中若干个连续的异常点，将自动合并成为一个连续的（闭区间）异常窗口。对于只有单个点的场景，异常窗口窗口退化成为一个起始时间和结束时间相同的点。
-异常检测生成的异常窗口受检测算法和算法参数的共同影响，对于异常窗口范围内的数据，可以应用 TDengine 提供的聚合和标量函数进行查询或变换处理。
-对于输入时间序列 (1, 20), (2, 22), (3, 91), (4, 120), (5, 18), (6, 19)。系统检测到 (3, 91), (4, 120) 为异常点，那么返回的异常窗口是闭区间 [3, 4]。
-
-
-##### 语法
-
-```SQL
-ANOMALY_WINDOW(column_name, option_expr)
-
-option_expr: {"
-algo=expr1
-[,wncheck=1|0]
-[,expr2]
-"}
-```
-
-1. `column`：进行时序数据异常检测的输入数据列，当前只支持单列，且只能是数值类型，不能是字符类型（例如：`NCHAR` `VARCHAR` `VARBINARY`等类型），**不支持函数表达式**。
-2. `options`：字符串。其中使用 K=V 调用异常检测算法及与算法相关的参数。采用逗号分隔的 K=V 字符串表示，其中的字符串不需要使用单引号、双引号、或转义号等符号，不能使用中文及其他宽字符。例如：`algo=ksigma,k=2` 表示进行异常检测的算法是 ksigma，该算法接受的输入参数是 2。
-3. 异常检测的结果可以作为外层查询的子查询输入，在 `SELECT` 子句中使用的聚合函数或标量函数与其他类型的窗口查询相同。
-4. 输入数据默认进行白噪声检查，如果输入数据是白噪声，将不会有任何（异常）窗口信息返回。
-
-**参数说明**
-|参数|含义|默认值|
-|---|---|---|
-|algo|异常检测调用的算法|iqr|
-|wncheck|对输入数据列是否进行白噪声检查|取值为 0 或者 1，默认值为 1，表示进行白噪声检查|
-
-异常检测的返回结果以窗口形式呈现，因此窗口查询相关的伪列在这种场景下仍然可用。可以使用的伪列如下：
-1. `_WSTART`： 异常窗口开始时间戳
-2. `_WEND`：异常窗口结束时间戳
-3. `_WDURATION`：异常窗口持续时间
-
-**示例**
-```SQL
--- 使用 iqr 算法进行异常检测，检测列 i32 列。
-SELECT _wstart, _wend, SUM(i32) 
-FROM ai.atb
-ANOMALY_WINDOW(i32, "algo=iqr");
-
--- 使用 ksigma 算法进行异常检测，输入参数 k 值为 2，检测列 i32 列
-SELECT _wstart, _wend, SUM(i32) 
-FROM ai.atb
-ANOMALY_WINDOW(i32, "algo=ksigma,k=2");
-```
-
-```
-taos> SELECT _wstart, _wend, count(*) FROM ai.atb ANOMAYL_WINDOW(i32);
-         _wstart         |          _wend          |   count(*)    |
-====================================================================
- 2020-01-01 00:00:16.000 | 2020-01-01 00:00:16.001 |             1 |
-Query OK, 1 row(s) in set (0.028946s)
-```
-
-
-**可用异常检测算法**
- iqr
- ksigma
- grubbs
- lof
- shesd
- tac
-
-
-#### 时序数据预测
-数据预测以一段训练数据作为输入，预测接下来一个连续时间区间内，时序数据的趋势。
-
-##### 语法
-```SQL
-FORECAST(column_expr, option_expr)
-
-option_expr: {"
-algo=expr1
-[,wncheck=1|0]
-[,conf=conf_val]
-[,every=every_val]
-[,rows=rows_val]
-[,start=start_ts_val]
-[,expr2]
-"}
-
-```
-1. `column_expr`：预测的时序数据列。与异常检测相同，只支持数值类型输入。
-2. `options`：异常检测函数的参数，使用规则与 anomaly_window 相同。预测还支持 `conf`, `every`, `rows`, `start`, `rows` 几个参数，其含义如下：
-
-**参数说明**
-
-|参数|含义|默认值|
-|---|---|---|
-|algo|预测分析使用的算法|holtwinters|
-|wncheck|白噪声（white noise data）检查|默认值为 1，0 表示不进行检查|
-|conf|预测数据的置信区间范围 ，取值范围 [0, 100]|95|
-|every|预测数据的采样间隔|输入数据的采样间隔|
-|start|预测结果的开始时间戳|输入数据最后一个时间戳加上一个采样时间段|
-|rows|预测结果的记录数|10|
-
-1. 预测查询结果新增了三个伪列，具体如下：`_FROWTS`：预测结果的时间戳、`_FLOW`：置信区间下界、`_FHIGH`：置信区间上界, 对于没有置信区间的预测算法，其置信区间同预测结果
-2. 更改参数 `START`：返回预测结果的起始时间，改变起始时间不会影响返回的预测数值，只影响起始时间。
-3. `EVERY`：可以与输入数据的采样频率不同。采样频率只能低于或等于输入数据采样频率，不能**高于**输入数据的采样频率。
-4. 对于某些不需要计算置信区间的算法，即使指定了置信区间，返回的结果中其上下界退化成为一个点。
-
-**示例**
-
-```SQL
--- 使用 arima 算法进行预测，预测结果是 10 条记录（默认值），数据进行白噪声检查，默认置信区间 95%. 
-SELECT  _flow, _fhigh, _frowts, FORECAST(i32, "algo=arima")
-FROM ai.ftb;
-
--- 使用 arima 算法进行预测，输入数据的是周期数据，每 10 个采样点是一个周期。返回置信区间是 95%.
-SELECT  _flow, _fhigh, _frowts, FORECAST(i32, "algo=arima,alpha=95,period=10")
-FROM ai.ftb;
-```
-```
-taos> select _flow, _fhigh, _frowts, forecast(i32) from ai.ftb;
-        _flow         |        _fhigh        |       _frowts           | forecast(i32) |
-========================================================================================
-           10.5286684 |           41.8038254 | 2020-01-01 00:01:35.001 |            26 |
-          -21.9861946 |           83.3938904 | 2020-01-01 00:01:36.001 |            30 |
-          -78.5686035 |          144.6729126 | 2020-01-01 00:01:37.001 |            33 |
-         -154.9797363 |          230.3057709 | 2020-01-01 00:01:38.001 |            37 |
-         -253.9852905 |          337.6083984 | 2020-01-01 00:01:39.001 |            41 |
-         -375.7857971 |          466.4594727 | 2020-01-01 00:01:40.001 |            45 |
-         -514.8043823 |          622.4426270 | 2020-01-01 00:01:41.001 |            53 |
-         -680.6343994 |          796.2861328 | 2020-01-01 00:01:42.001 |            57 |
-         -868.4956665 |          992.8603516 | 2020-01-01 00:01:43.001 |            62 |
-        -1076.1566162 |         1214.4498291 | 2020-01-01 00:01:44.001 |            69 |
-```
-
-
-**可用预测算法**
- arima
- holtwinters
--- a/docs/zh/06-advanced/06-data-analysis/pic/data-analysis.png
+++ b/docs/zh/06-advanced/06-data-analysis/pic/data-analysis.png
--- a/docs/zh/06-advanced/06-data-analysis/pic/dir.png
+++ b/docs/zh/06-advanced/06-data-analysis/pic/dir.png
--- a/docs/zh/07-develop/07-tmq.md
+++ b/docs/zh/07-develop/07-tmq.md
@ -16,7 +16,7 @@ TDengine 提供了类似于消息队列产品的数据订阅和消费接口。

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

--- a/docs/zh/08-operation/06-gui.md
+++ b/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 "查看已创建的流计算")

--- a/docs/zh/08-operation/16-security.md
+++ b/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

 ## 审计日志

--- a/docs/zh/08-operation/19-debug.md
+++ b/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 性能分析工具。它提供了对系统和应用程序的详细性能分析，帮助开发者和系统管理员识别和解决性能瓶颈。
--- a/docs/zh/08-operation/pic/topic-03-addTopicWizard.jpeg
+++ b/docs/zh/08-operation/pic/topic-03-addTopicWizard.jpeg
--- a/docs/zh/14-reference/01-components/01-taosd.md
+++ b/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,149 @@ 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|          |内部参数，用于测试慢日志|
+|bypassFlag          |3.3.4.5 后|内部参数，用于短路测试，0：正常写入，1：写入消息在 taos 客户端发送 RPC 消息前返回，2：写入消息在 taosd 服务端收到 RPC 消息后返回，4：写入消息在 taosd 服务端写入内存缓存前返回，8：写入消息在 taosd 服务端数据落盘前返回；默认值 0|

 ### 压缩参数
-
-| 参数名称       |  参数说明                                                         |
-|:-------------:|:----------------------------------------------------------------:|
-| 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 +320,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 +372,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 +401,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 +420,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 +463,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 +475,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 +489,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 +505,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 +518,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                                            |

 ## 日志相关
--- a/docs/zh/14-reference/01-components/02-taosc.md
+++ b/docs/zh/14-reference/01-components/02-taosc.md
@ -8,38 +8,101 @@ 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 加速|
+|bypassFlag       |3.3.4.5 后|内部参数，用于短路测试，0：正常写入，1：写入消息在 taos 客户端发送 RPC 消息前返回，2：写入消息在 taosd 服务端收到 RPC 消息后返回，4：写入消息在 taosd 服务端写入内存缓存前返回，8：写入消息在 taosd 服务端数据落盘前返回；缺省值：0|
+
+### SHELL 相关
+|参数名称|支持版本|参数含义|
+|-----------------|----------|-|
+|enableScience    |          |是否开启科学计数法显示浮点数；0：不开始，1：开启；缺省值：1|

 ## API

--- a/docs/zh/14-reference/03-taos-sql/02-database.md
+++ b/docs/zh/14-reference/03-taos-sql/02-database.md
@ -8,10 +8,10 @@ description: "创建、删除数据库，查看、修改数据库参数"

 ```sql
 CREATE DATABASE [IF NOT EXISTS] db_name [database_options]
- 
+
 database_options:
    database_option ...
- 
+
 database_option: {
    VGROUPS value
  | PRECISION {'ms' | 'us' | 'ns'}
@ -26,6 +26,7 @@ database_option: {
  | MAXROWS value
  | MINROWS value
  | KEEP value
+  | KEEP_TIME_OFFSET value
  | STT_TRIGGER value
  | SINGLE_STABLE {0 | 1}
  | TABLE_PREFIX value
@ -43,7 +44,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 +64,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/)
+- KEEP_TIME_OFFSET：自 3.2.0.0 版本生效。删除或迁移保存时间超过 KEEP 值的数据的延迟执行时间，默认值为 0 (小时)。在数据文件保存时间超过 KEEP 后，删除或迁移操作不会立即执行，而会额外等待本参数指定的时间间隔，以实现与业务高峰期错开的目的。
 - STT_TRIGGER：表示落盘文件触发文件合并的个数。开源版本固定为 1，企业版本可设置范围为 1 到 16。对于少表高频写入场景，此参数建议使用默认配置；而对于多表低频写入场景，此参数建议配置较大的值。
 - SINGLE_STABLE：表示此数据库中是否只可以创建一个超级表，用于超级表列非常多的情况。
  - 0：表示可以创建多张超级表。
@ -78,6 +80,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 +91,7 @@ create database if not exists db vgroups 10 buffer 10

 ### 使用数据库

-```
+```sql
 USE db_name;
 ```

@ -96,7 +99,7 @@ USE db_name;

 ## 删除数据库

-```
+```sql
 DROP DATABASE [IF EXISTS] db_name
 ```

@ -122,10 +125,11 @@ alter_database_option: {
  | KEEP value
  | WAL_RETENTION_PERIOD value
  | WAL_RETENTION_SIZE value
+  | MINROWS value
 }
 ```

-###  修改 CACHESIZE
+### 修改 CACHESIZE

 修改数据库参数的命令使用简单，难的是如何确定是否需要修改以及如何修改。本小节描述如何判断数据库的 cachesize 是否够用。

@ -154,13 +158,13 @@ alter_database_option: {

 ### 查看系统中的所有数据库

-```
+```sql
 SHOW DATABASES;
 ```

 ### 显示一个数据库的创建语句

-```
+```sql
 SHOW CREATE DATABASE db_name \G;
 ```

@ -188,23 +192,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 重新选主，对集群各节点进行负载再均衡操作。

 ## 查看数据库工作状态

--- a/docs/zh/14-reference/03-taos-sql/03-table.md
+++ b/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];
 ```

 ### 显示表创建语句
--- a/docs/zh/14-reference/03-taos-sql/05-insert.md
+++ b/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
--- a/docs/zh/14-reference/03-taos-sql/10-function.md
+++ b/docs/zh/14-reference/03-taos-sql/10-function.md
@ -1065,7 +1065,7 @@ CAST(expr AS type_name)
 TO_ISO8601(expr [, timezone])
 ```

-**功能说明**：将 UNIX 时间戳转换成为 ISO8601 标准的日期时间格式，并附加时区信息。timezone 参数允许用户为输出结果指定附带任意时区信息。如果 timezone 参数省略，输出结果则附带当前客户端的系统时区信息。
+**功能说明**：将时间戳转换成为 ISO8601 标准的日期时间格式，并附加时区信息。timezone 参数允许用户为输出结果指定附带任意时区信息。如果 timezone 参数省略，输出结果则附带当前客户端的系统时区信息。

 **返回结果数据类型**：VARCHAR 类型。

@ -1109,7 +1109,7 @@ return_timestamp: {
 }
 ```

-**功能说明**：将日期时间格式的字符串转换成为 UNIX 时间戳。
+**功能说明**：将日期时间格式的字符串转换成为时间戳。

 **返回结果数据类型**：BIGINT, TIMESTAMP。

@ -1257,8 +1257,8 @@ TIMEDIFF(expr1, expr2 [, time_unit])
 **返回结果类型**：BIGINT。

 **适用数据类型**：
- `expr1`：表示 UNIX 时间戳的 BIGINT, TIMESTAMP 类型，或符合日期时间格式的 VARCHAR, NCHAR 类型。
- `expr2`：表示 UNIX 时间戳的 BIGINT, TIMESTAMP 类型，或符合日期时间格式的 VARCHAR, NCHAR 类型。
+- `expr1`：表示时间戳的 BIGINT, TIMESTAMP 类型，或符合 ISO8601/RFC3339 标准的日期时间格式的 VARCHAR, NCHAR 类型。
+- `expr2`：表示时间戳的 BIGINT, TIMESTAMP 类型，或符合 ISO8601/RFC3339 标准的日期时间格式的 VARCHAR, NCHAR 类型。
 - `time_unit`：见使用说明。

 **嵌套子查询支持**：适用于内层查询和外层查询。
@ -1301,7 +1301,7 @@ use_current_timezone: {

 **返回结果数据类型**：TIMESTAMP。

-**应用字段**：表示 UNIX 时间戳的 BIGINT, TIMESTAMP 类型，或符合日期时间格式的 VARCHAR, NCHAR 类型。
+**应用字段**：表示时间戳的 BIGINT, TIMESTAMP 类型，或符合 ISO8601/RFC3339 标准的日期时间格式的 VARCHAR, NCHAR 类型。

 **适用于**：表和超级表。

@ -1364,7 +1364,7 @@ WEEK(expr [, mode])
 **返回结果类型**：BIGINT。

 **适用数据类型**：
- `expr`：表示 UNIX 时间戳的 BIGINT, TIMESTAMP 类型，或符合日期时间格式的 VARCHAR, NCHAR 类型。
+- `expr`：表示时间戳的 BIGINT, TIMESTAMP 类型，或符合 ISO8601/RFC3339 标准的日期时间格式的 VARCHAR, NCHAR 类型。
 - `mode`：0 - 7 之间的整数。

 **嵌套子查询支持**：适用于内层查询和外层查询。
@ -1424,7 +1424,7 @@ WEEKOFYEAR(expr)

 **返回结果类型**：BIGINT。

-**适用数据类型**：表示 UNIX 时间戳的 BIGINT, TIMESTAMP 类型，或符合日期时间格式的 VARCHAR, NCHAR 类型。
+**适用数据类型**：表示时间戳的 BIGINT, TIMESTAMP 类型，或符合 ISO8601/RFC3339 标准的日期时间格式的 VARCHAR, NCHAR 类型。

 **嵌套子查询支持**：适用于内层查询和外层查询。

@ -1451,7 +1451,7 @@ WEEKDAY(expr)

 **返回结果类型**：BIGINT。

-**适用数据类型**：表示 UNIX 时间戳的 BIGINT, TIMESTAMP 类型，或符合日期时间格式的 VARCHAR, NCHAR 类型。
+**适用数据类型**：表示 表示时间戳的 BIGINT, TIMESTAMP 类型，或符合 ISO8601/RFC3339 标准的日期时间格式的 VARCHAR, NCHAR 类型。

 **嵌套子查询支持**：适用于内层查询和外层查询。

@ -1478,7 +1478,7 @@ DAYOFWEEK(expr)

 **返回结果类型**：BIGINT。

-**适用数据类型**：表示 UNIX 时间戳的 BIGINT, TIMESTAMP 类型，或符合日期时间格式的 VARCHAR, NCHAR 类型。
+**适用数据类型**：表示时间戳的 BIGINT, TIMESTAMP 类型，或符合 ISO8601/RFC3339 标准的日期时间格式的 VARCHAR, NCHAR 类型。

 **嵌套子查询支持**：适用于内层查询和外层查询。

@ -1988,7 +1988,7 @@ TOP(expr, k)
 UNIQUE(expr)
 ```

-**功能说明**：返回该列数据首次出现的值。该函数功能与 distinct 相似。对于存在复合主键的表的查询，若最小时间戳的数据有多条，则只有对应的复合主键最小的数据被返回。
+**功能说明**：返回该列数据去重后的值。该函数功能与 distinct 相似。对于相同的数据，返回时间戳最小的一条，对于存在复合主键的表的查询，若最小时间戳的数据有多条，则只有对应的复合主键最小的数据被返回。

 **返回数据类型**：同应用的字段。

--- a/docs/zh/14-reference/03-taos-sql/20-keywords.md
+++ b/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              | |

 ### \_

--- a/docs/zh/14-reference/03-taos-sql/28-index.md
+++ b/docs/zh/14-reference/03-taos-sql/28-index.md
--- a/docs/zh/14-reference/03-taos-sql/32-compress.md
+++ b/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 语法

--- a/docs/zh/14-reference/03-taos-sql/pic/database-keep.jpg
+++ b/docs/zh/14-reference/03-taos-sql/pic/database-keep.jpg
--- a/docs/zh/14-reference/05-connector/30-python.mdx
+++ b/docs/zh/14-reference/05-connector/30-python.mdx
@ -41,6 +41,7 @@ Python 连接器的源码托管在 [GitHub](https://github.com/taosdata/taos-con

 |Python Connector 版本|主要变化|
 |:-------------------:|:----:|
+|2.7.16|新增订阅配置 (session.timeout.ms, max.poll.interval.ms)|
 |2.7.15|新增 VARBINARY 和 GEOMETRY 类型支持|
 |2.7.14|修复已知问题|
 |2.7.13|新增 tmq 同步提交 offset 接口|
@ -50,6 +51,7 @@ Python 连接器的源码托管在 [GitHub](https://github.com/taosdata/taos-con

 |Python WebSocket Connector 版本|主要变化|
 |:----------------------------:|:-----:|
+|0.3.5|新增 VARBINARY 和 GEOMETRY 类型支持，修复已知问题|
 |0.3.2|优化 WebSocket sql 查询和插入性能，修改 readme 和 文档，修复已知问题|
 |0.2.9|已知问题修复|
 |0.2.5|1. 数据订阅支持获取消费进度和重置消费进度 <br/> 2. 支持 schemaless <br/> 3. 支持 STMT|
--- a/docs/zh/14-reference/05-connector/35-node.mdx
+++ b/docs/zh/14-reference/05-connector/35-node.mdx
@ -26,6 +26,7 @@ Node.js 连接器目前仅支持 WebSocket 连接器， 其通过 taosAdapter

 | Node.js 连接器 版本 |          主要变化         |   TDengine 版本    |
 | :------------------:  | :----------------------: | :----------------: |
+|        3.1.2          | 对数据协议和解析进行了优化，性能得到大幅提升|  3.3.2.0 及更高版本 |
 |        3.1.1          | 优化了数据传输性能          |  3.3.2.0 及更高版本 |
 |        3.1.0          | 新版本发布，支持 WebSocket 连接 |  3.2.0.0 及更高版本 |

--- a/docs/zh/26-tdinternal/01-arch.md
+++ b/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 会创建新的数据库日志文件用于数据落盘，并在落盘成功后删除旧的日志文件，以防止日志文件无限制增长。
--- a/docs/zh/26-tdinternal/10-cache.md
+++ b/docs/zh/26-tdinternal/10-cache.md
@ -0,0 +1,62 @@
+---
+sidebar_label: 数据缓存
+title: 数据缓存
+toc_max_heading_level: 4
+---
+在现代物联网（IoT）和工业互联网（IIoT）应用中，数据的高效管理对系统性能和用户体验至关重要。为了应对高并发环境下的实时读写需求，TDengine 设计了一套完整的缓存机制，包括写缓存、读缓存、元数据缓存和文件系统缓存。这些缓存机制紧密结合，既能优化数据查询的响应速度，又能提高数据写入的效率，同时保障数据的可靠性和系统的高可用性。通过灵活配置缓存参数，TDengine 为用户提供了性能与成本之间的最佳平衡。
+
+## 写缓存
+
+TDengine 采用了一种创新的时间驱动缓存管理策略，亦称为写驱动的缓存管理机制。这一策略与传统的读驱动的缓存模式有所不同，其核心思想是将最新写入的数据优先保存在缓存中。当缓存容量达到预设的临界值时，系统会将最早存储的数据批量写入硬盘，从而实现缓存与硬盘之间的动态平衡。
+
+在物联网数据应用中，用户往往最关注最近产生的数据，即设备的当前状态。TDengine 充分利用了这一业务特性，将最近到达的当前状态数据优先存储在缓存中，以便用户能够快速获取所需信息。
+
+为了实现数据的分布式存储和高可用性，TDengine 引入了虚拟节点（vnode）的概念。每个 vnode 可以拥有多达 3 个副本，这些副本共同组成一个 vnode group，简称 vgroup。在创建数据库时，用户需要确定每个 vnode 的写入缓存大小，以确保数据的合理分配和高效存储。
+
+创建数据库时的两个关键参数 `vgroups` 和 `buffer` 分别决定了数据库中的数据由多少个 vgroup 进行处理，以及为每个 vnode 分配多少写入缓存。通过合理配置这两个
+参数，用户可以根据实际需求调整数据库的性能和存储容量，从而实现最佳的性能和成本效益。
+
+例 如， 下面的 SQL 创建了包含 10 个 vgroup，每个 vnode 占 用 256MB 内存的数据库。
+```sql
+CREATE DATABASE POWER VGROUPS 10 BUFFER 256 CACHEMODEL 'NONE' PAGES 128 PAGESIZE 16;
+```
+
+缓存越大越好，但超过一定阈值后再增加缓存对写入性能提升并无帮助。
+
+## 读缓存
+
+TDengine 的读缓存机制专为高频实时查询场景设计，尤其适用于物联网和工业互联网等需要实时掌握设备状态的业务场景。在这些场景中，用户往往最关心最新的数据，如设备的当前读数或状态。
+
+通过设置 cachemodel 参数，TDengine 用户可以灵活选择适合的缓存模式，包括缓存最新一行数据、每列最近的非 NULL 值，或同时缓存行和列的数据。这种灵活性使 TDengine 能根据具体业务需求提供精准优化，在物联网场景下尤为突出，助力用户快速访问设备的最新状态。
+
+这种设计不仅降低了查询的响应延迟，还能有效缓解存储系统的 I/O 压力。在高并发场景下，读缓存能够帮助系统维持更高的吞吐量，确保查询性能的稳定性。借助 TDengine 读缓存，用户无需再集成如 Redis 一类的外部缓存系统，避免了系统架构的复杂化，显著降低运维和部署成本。
+
+此外，TDengine 的读缓存机制还能够根据实际业务场景灵活调整。在数据访问热点集中在最新记录的场景中，这种内置缓存能够显著提高用户体验，让关键数据的获取更加快速高效。相比传统缓存方案，这种无缝集成的缓存策略不仅简化了开发流程，还为用户提供了更高的性能保障。
+
+关于 TDengine 读缓存的更多详细内容请看[读缓存](../../advanced/cache/)
+
+## 元数据缓存
+
+为了提升查询和写入操作的效率，每个 vnode 都配备了缓存机制，用于存储其曾经获取过的元数据。这一元数据缓存的大小由创建数据库时的两个参数 pages 和 pagesize 共同决定。其中，pagesize 参数的单位是 KB，用于指定每个缓存页的大小。如下 SQL 会为数据库 power 的每个 vnode 创建 128 个 page、每个 page 16KB 的元数据缓存
+
+```sql
+CREATE DATABASE POWER PAGES 128 PAGESIZE 16;
+```
+
+## 文件系统缓存
+
+TDengine 采用 WAL 技术作为基本的数据可靠性保障手段。WAL 是一种先进的数据保护机制，旨在确保在发生故障时能够迅速恢复数据。其核心原理在于，在数据实际写入数据存储层之前，先将其变更记录到一个日志文件中。这样一来，即便集群遭遇崩溃或其他故障，也能确保数据安全无损。
+
+TDengine 利用这些日志文件实现故障前的状态恢复。在写入 WAL 的过程中，数据是以顺序追加的方式写入硬盘文件的。因此，文件系统缓存在此过程中发挥着关键作用，对写入性能产生显著影响。为了确保数据真正落盘，系统会调用 fsync 函数，该函数负责将文件系统缓存中的数据强制写入硬盘。
+
+数据库参数 wal_level 和 wal_fsync_period 共同决定了 WAL 的保存行为。。
+- wal_level：此参数控制 WAL 的保存级别。级别 1 表示仅将数据写入 WAL，但不立即执行 fsync 函数；级别 2 则表示在写入 WAL 的同时执行 fsync 函数。默认情况下，wal_level 设为 1。虽然执行 fsync 函数可以提高数据的持久性，但相应地也会降低写入性能。
+- wal_fsync_period：当 wal_level 设置为 2 时，这个参数控制执行 fsync 的频率。设置为 0 则表示每次写入后立即执行 fsync，这可以确保数据的安全性，但可能会牺牲一些性能。当设置为大于 0 的数值时，则表示 fsync 周期，默认为 3000，范围是[1， 180000]，单位毫秒。
+
+```sql
+CREATE DATABASE POWER WAL_LEVEL 2 WAL_FSYNC_PERIOD 3000;
+```
+
+在创建数据库时，用户可以根据需求选择不同的参数设置，以在性能和可靠性之间找到最佳平衡：
+- 性能优先：将数据写入 WAL，但不立即执行 fsync 操作，此时新写入的数据仅保存在文件系统缓存中，尚未同步到磁盘。这种配置能够显著提高写入性能。
+- 可靠性优先：将数据写入 WAL 的同时执行 fsync 操作，将数据立即同步到磁盘，确保数据持久化，可靠性更高。
--- a/docs/zh/28-releases/01-tdengine.md
+++ b/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" />
--- a/docs/zh/28-releases/03-notes/3.3.4.3.md
+++ b/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 错误码 
--- a/docs/zh/28-releases/03-notes/index.md
+++ b/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)
--- a/examples/c/CMakeLists.txt
+++ b/examples/c/CMakeLists.txt
@ -1,7 +1,7 @@
 PROJECT(TDengine)

-IF (TD_LINUX)
-  INCLUDE_DIRECTORIES(. ${TD_SOURCE_DIR}/src/inc ${TD_SOURCE_DIR}/src/client/inc  ${TD_SOURCE_DIR}/inc)
+IF(TD_LINUX)
+  INCLUDE_DIRECTORIES(. ${TD_SOURCE_DIR}/src/inc ${TD_SOURCE_DIR}/src/client/inc ${TD_SOURCE_DIR}/inc)
  AUX_SOURCE_DIRECTORY(. SRC)

  add_executable(tmq "")
@ -12,58 +12,58 @@ IF (TD_LINUX)
  add_executable(asyncdemo "")

  target_sources(tmq
-      PRIVATE
-      "tmq.c"
-      )
+    PRIVATE
+    "tmq.c"
+  )

  target_sources(stream_demo
-      PRIVATE
-      "stream_demo.c"
-      )
+    PRIVATE
+    "stream_demo.c"
+  )

  target_sources(schemaless
-      PRIVATE
-      "schemaless.c"
-      )
+    PRIVATE
+    "schemaless.c"
+  )

  target_sources(prepare
-    PRIVATE 
+    PRIVATE
    "prepare.c"
-    )
-    
+  )
+
  target_sources(demo
-    PRIVATE 
+    PRIVATE
    "demo.c"
-    )
+  )

  target_sources(asyncdemo
-    PRIVATE 
+    PRIVATE
    "asyncdemo.c"
-    )
+  )

  target_link_libraries(tmq
-      taos
-      )
+    ${TAOS_LIB}
+  )

  target_link_libraries(stream_demo
-      taos
-      )
+    ${TAOS_LIB}
+  )

  target_link_libraries(schemaless
-      taos
-      )
+    ${TAOS_LIB}
+  )

  target_link_libraries(prepare
-      taos
-      )
-  
+    ${TAOS_LIB}
+  )
+
  target_link_libraries(demo
-      taos
-      )
+    ${TAOS_LIB}
+  )

  target_link_libraries(asyncdemo
-      taos
-      )
+    ${TAOS_LIB}
+  )

  SET_TARGET_PROPERTIES(tmq PROPERTIES OUTPUT_NAME tmq)
  SET_TARGET_PROPERTIES(stream_demo PROPERTIES OUTPUT_NAME stream_demo)
@ -71,8 +71,9 @@ IF (TD_LINUX)
  SET_TARGET_PROPERTIES(prepare PROPERTIES OUTPUT_NAME prepare)
  SET_TARGET_PROPERTIES(demo PROPERTIES OUTPUT_NAME demo)
  SET_TARGET_PROPERTIES(asyncdemo PROPERTIES OUTPUT_NAME asyncdemo)
-ENDIF ()
-IF (TD_DARWIN)
-  INCLUDE_DIRECTORIES(. ${TD_SOURCE_DIR}/src/inc ${TD_SOURCE_DIR}/src/client/inc  ${TD_SOURCE_DIR}/inc)
+ENDIF()
+
+IF(TD_DARWIN)
+  INCLUDE_DIRECTORIES(. ${TD_SOURCE_DIR}/src/inc ${TD_SOURCE_DIR}/src/client/inc ${TD_SOURCE_DIR}/inc)
  AUX_SOURCE_DIRECTORY(. SRC)
-ENDIF ()
+ENDIF()
--- a/include/libs/stream/streamMsg.h
+++ b/include/libs/stream/streamMsg.h
@ -17,12 +17,23 @@
 #define TDENGINE_STREAMMSG_H

 #include "tmsg.h"
-#include "trpc.h"
+//#include "trpc.h"

 #ifdef __cplusplus
 extern "C" {
 #endif

+typedef struct SStreamRetrieveReq SStreamRetrieveReq;
+typedef struct SStreamDispatchReq SStreamDispatchReq;
+typedef struct STokenBucket       STokenBucket;
+typedef struct SMetaHbInfo        SMetaHbInfo;
+
+typedef struct SNodeUpdateInfo {
+  int32_t nodeId;
+  SEpSet  prevEp;
+  SEpSet  newEp;
+} SNodeUpdateInfo;
+
 typedef struct SStreamUpstreamEpInfo {
  int32_t nodeId;
  int32_t childId;
@ -170,8 +181,8 @@ typedef struct SStreamHbMsg {
  SArray* pUpdateNodes;  // SArray<int32_t>, needs update the epsets in stream tasks for those nodes.
 } SStreamHbMsg;

-int32_t tEncodeStreamHbMsg(SEncoder* pEncoder, const SStreamHbMsg* pRsp);
-int32_t tDecodeStreamHbMsg(SDecoder* pDecoder, SStreamHbMsg* pRsp);
+int32_t tEncodeStreamHbMsg(SEncoder* pEncoder, const SStreamHbMsg* pReq);
+int32_t tDecodeStreamHbMsg(SDecoder* pDecoder, SStreamHbMsg* pReq);
 void    tCleanupStreamHbMsg(SStreamHbMsg* pMsg);

 typedef struct {
@ -179,6 +190,9 @@ typedef struct {
  int32_t  msgId;
 } SMStreamHbRspMsg;

+int32_t tEncodeStreamHbRsp(SEncoder* pEncoder, const SMStreamHbRspMsg* pRsp);
+int32_t tDecodeStreamHbRsp(SDecoder* pDecoder, SMStreamHbRspMsg* pRsp);
+
 typedef struct SRetrieveChkptTriggerReq {
  SMsgHead head;
  int64_t  streamId;
@ -189,6 +203,9 @@ typedef struct SRetrieveChkptTriggerReq {
  int64_t  downstreamTaskId;
 } SRetrieveChkptTriggerReq;

+int32_t tEncodeRetrieveChkptTriggerReq(SEncoder* pEncoder, const SRetrieveChkptTriggerReq* pReq);
+int32_t tDecodeRetrieveChkptTriggerReq(SDecoder* pDecoder, SRetrieveChkptTriggerReq* pReq);
+
 typedef struct SCheckpointTriggerRsp {
  int64_t streamId;
  int64_t checkpointId;
@ -198,6 +215,9 @@ typedef struct SCheckpointTriggerRsp {
  int32_t rspCode;
 } SCheckpointTriggerRsp;

+int32_t tEncodeCheckpointTriggerRsp(SEncoder* pEncoder, const SCheckpointTriggerRsp* pRsp);
+int32_t tDecodeCheckpointTriggerRsp(SDecoder* pDecoder, SCheckpointTriggerRsp* pRsp);
+
 typedef struct SCheckpointReport {
  int64_t streamId;
  int32_t taskId;
@ -222,7 +242,7 @@ typedef struct SRestoreCheckpointInfo {
  int32_t  nodeId;
 } SRestoreCheckpointInfo;

-int32_t tEncodeRestoreCheckpointInfo (SEncoder* pEncoder, const SRestoreCheckpointInfo* pReq);
+int32_t tEncodeRestoreCheckpointInfo(SEncoder* pEncoder, const SRestoreCheckpointInfo* pReq);
 int32_t tDecodeRestoreCheckpointInfo(SDecoder* pDecoder, SRestoreCheckpointInfo* pReq);

 typedef struct {
@ -232,10 +252,8 @@ typedef struct {
  int32_t  reqType;
 } SStreamTaskRunReq;

-typedef struct SCheckpointConsensusEntry {
-  SRestoreCheckpointInfo req;
-  int64_t                ts;
-} SCheckpointConsensusEntry;
+int32_t tEncodeStreamTaskRunReq(SEncoder* pEncoder, const SStreamTaskRunReq* pReq);
+int32_t tDecodeStreamTaskRunReq(SDecoder* pDecoder, SStreamTaskRunReq* pReq);

 #ifdef __cplusplus
 }
--- a/include/common/tanalytics.h
+++ b/include/common/tanalytics.h
@ -36,36 +36,36 @@ typedef struct {
  int32_t       anode;
  int32_t       urlLen;
  char         *url;
-} SAnalUrl;
+} SAnalyticsUrl;

 typedef enum {
-  ANAL_BUF_TYPE_JSON = 0,
-  ANAL_BUF_TYPE_JSON_COL = 1,
-  ANAL_BUF_TYPE_OTHERS,
+  ANALYTICS_BUF_TYPE_JSON = 0,
+  ANALYTICS_BUF_TYPE_JSON_COL = 1,
+  ANALYTICS_BUF_TYPE_OTHERS,
 } EAnalBufType;

 typedef enum {
-  ANAL_HTTP_TYPE_GET = 0,
-  ANAL_HTTP_TYPE_POST,
+  ANALYTICS_HTTP_TYPE_GET = 0,
+  ANALYTICS_HTTP_TYPE_POST,
 } EAnalHttpType;

 typedef struct {
  TdFilePtr filePtr;
  char      fileName[TSDB_FILENAME_LEN + 10];
  int64_t   numOfRows;
-} SAnalColBuf;
+} SAnalyticsColBuf;

 typedef struct {
  EAnalBufType bufType;
  TdFilePtr    filePtr;
  char         fileName[TSDB_FILENAME_LEN];
  int32_t      numOfCols;
-  SAnalColBuf *pCols;
-} SAnalBuf;
+  SAnalyticsColBuf *pCols;
+} SAnalyticBuf;

-int32_t taosAnalInit();
-void    taosAnalCleanup();
-SJson  *taosAnalSendReqRetJson(const char *url, EAnalHttpType type, SAnalBuf *pBuf);
+int32_t taosAnalyticsInit();
+void    taosAnalyticsCleanup();
+SJson  *taosAnalSendReqRetJson(const char *url, EAnalHttpType type, SAnalyticBuf *pBuf);

 int32_t taosAnalGetAlgoUrl(const char *algoName, EAnalAlgoType type, char *url, int32_t urlLen);
 bool    taosAnalGetOptStr(const char *option, const char *optName, char *optValue, int32_t optMaxLen);
@ -73,18 +73,18 @@ bool    taosAnalGetOptInt(const char *option, const char *optName, int64_t *optV
 int64_t taosAnalGetVersion();
 void    taosAnalUpdate(int64_t newVer, SHashObj *pHash);

-int32_t tsosAnalBufOpen(SAnalBuf *pBuf, int32_t numOfCols);
-int32_t taosAnalBufWriteOptStr(SAnalBuf *pBuf, const char *optName, const char *optVal);
-int32_t taosAnalBufWriteOptInt(SAnalBuf *pBuf, const char *optName, int64_t optVal);
-int32_t taosAnalBufWriteOptFloat(SAnalBuf *pBuf, const char *optName, float optVal);
-int32_t taosAnalBufWriteColMeta(SAnalBuf *pBuf, int32_t colIndex, int32_t colType, const char *colName);
-int32_t taosAnalBufWriteDataBegin(SAnalBuf *pBuf);
-int32_t taosAnalBufWriteColBegin(SAnalBuf *pBuf, int32_t colIndex);
-int32_t taosAnalBufWriteColData(SAnalBuf *pBuf, int32_t colIndex, int32_t colType, void *colValue);
-int32_t taosAnalBufWriteColEnd(SAnalBuf *pBuf, int32_t colIndex);
-int32_t taosAnalBufWriteDataEnd(SAnalBuf *pBuf);
-int32_t taosAnalBufClose(SAnalBuf *pBuf);
-void    taosAnalBufDestroy(SAnalBuf *pBuf);
+int32_t tsosAnalBufOpen(SAnalyticBuf *pBuf, int32_t numOfCols);
+int32_t taosAnalBufWriteOptStr(SAnalyticBuf *pBuf, const char *optName, const char *optVal);
+int32_t taosAnalBufWriteOptInt(SAnalyticBuf *pBuf, const char *optName, int64_t optVal);
+int32_t taosAnalBufWriteOptFloat(SAnalyticBuf *pBuf, const char *optName, float optVal);
+int32_t taosAnalBufWriteColMeta(SAnalyticBuf *pBuf, int32_t colIndex, int32_t colType, const char *colName);
+int32_t taosAnalBufWriteDataBegin(SAnalyticBuf *pBuf);
+int32_t taosAnalBufWriteColBegin(SAnalyticBuf *pBuf, int32_t colIndex);
+int32_t taosAnalBufWriteColData(SAnalyticBuf *pBuf, int32_t colIndex, int32_t colType, void *colValue);
+int32_t taosAnalBufWriteColEnd(SAnalyticBuf *pBuf, int32_t colIndex);
+int32_t taosAnalBufWriteDataEnd(SAnalyticBuf *pBuf);
+int32_t taosAnalBufClose(SAnalyticBuf *pBuf);
+void    taosAnalBufDestroy(SAnalyticBuf *pBuf);

 const char   *taosAnalAlgoStr(EAnalAlgoType algoType);
 EAnalAlgoType taosAnalAlgoInt(const char *algoName);
--- a/include/common/tcommon.h
+++ b/include/common/tcommon.h
@ -155,6 +155,7 @@ typedef enum EStreamType {
  STREAM_MID_RETRIEVE,
  STREAM_PARTITION_DELETE_DATA,
  STREAM_GET_RESULT,
+  STREAM_DROP_CHILD_TABLE,
 } EStreamType;

 #pragma pack(push, 1)
@ -250,6 +251,7 @@ typedef struct SQueryTableDataCond {
  int32_t      type;       // data block load type:
  bool         skipRollup;
  STimeWindow  twindows;
+  STimeWindow  extTwindows[2];
  int64_t      startVersion;
  int64_t      endVersion;
  bool         notLoadData;  // response the actual data, not only the rows in the attribute of info.row of ssdatablock
@ -401,6 +403,8 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol);
 #define TSMA_RES_STB_EXTRA_COLUMN_NUM 4 // 3 columns: _wstart, _wend, _wduration, 1 tag: tbname

 static inline bool isTsmaResSTb(const char* stbName) {
+  static bool showTsmaTables = false;
+  if (showTsmaTables) return false;
  const char* pos = strstr(stbName, TSMA_RES_STB_POSTFIX);
  if (pos && strlen(stbName) == (pos - stbName) + strlen(TSMA_RES_STB_POSTFIX)) {
    return true;
--- a/include/common/tdataformat.h
+++ b/include/common/tdataformat.h
@ -57,9 +57,9 @@ const static uint8_t BIT2_MAP[4] = {0b11111100, 0b11110011, 0b11001111, 0b001111
 #define ONE               ((uint8_t)1)
 #define THREE             ((uint8_t)3)
 #define DIV_8(i)          ((i) >> 3)
-#define MOD_8(i)          ((i)&7)
+#define MOD_8(i)          ((i) & 7)
 #define DIV_4(i)          ((i) >> 2)
-#define MOD_4(i)          ((i)&3)
+#define MOD_4(i)          ((i) & 3)
 #define MOD_4_TIME_2(i)   (MOD_4(i) << 1)
 #define BIT1_SIZE(n)      (DIV_8((n)-1) + 1)
 #define BIT2_SIZE(n)      (DIV_4((n)-1) + 1)
@ -173,6 +173,8 @@ typedef struct {
 } SColDataCompressInfo;

 typedef void *(*xMallocFn)(void *, int32_t);
+typedef int32_t (*checkWKBGeometryFn)(const unsigned char *geoWKB, size_t nGeom);
+typedef int32_t (*initGeosFn)();

 void    tColDataDestroy(void *ph);
 void    tColDataInit(SColData *pColData, int16_t cid, int8_t type, int8_t cflag);
@ -191,7 +193,8 @@ int32_t tColDataCompress(SColData *colData, SColDataCompressInfo *info, SBuffer
 int32_t tColDataDecompress(void *input, SColDataCompressInfo *info, SColData *colData, SBuffer *assist);

 // for stmt bind
-int32_t tColDataAddValueByBind(SColData *pColData, TAOS_MULTI_BIND *pBind, int32_t buffMaxLen);
+int32_t tColDataAddValueByBind(SColData *pColData, TAOS_MULTI_BIND *pBind, int32_t buffMaxLen, initGeosFn igeos,
+                               checkWKBGeometryFn cgeos);
 int32_t tColDataSortMerge(SArray **arr);

 // for raw block
@ -378,7 +381,8 @@ int32_t tRowBuildFromBind(SBindInfo *infos, int32_t numOfInfos, bool infoSorted,
                          SArray *rowArray);

 // stmt2 binding
-int32_t tColDataAddValueByBind2(SColData *pColData, TAOS_STMT2_BIND *pBind, int32_t buffMaxLen);
+int32_t tColDataAddValueByBind2(SColData *pColData, TAOS_STMT2_BIND *pBind, int32_t buffMaxLen, initGeosFn igeos,
+                                checkWKBGeometryFn cgeos);

 typedef struct {
  int32_t          columnId;
--- a/include/common/tglobal.h
+++ b/include/common/tglobal.h
@ -74,6 +74,7 @@ extern int64_t tsTickPerHour[3];
 extern int32_t tsCountAlwaysReturnValue;
 extern float   tsSelectivityRatio;
 extern int32_t tsTagFilterResCacheSize;
+extern int32_t tsBypassFlag;

 // queue & threads
 extern int32_t tsNumOfRpcThreads;
@ -195,7 +196,6 @@ extern int32_t tsMaxRetryWaitTime;
 extern bool    tsUseAdapter;
 extern int32_t tsMetaCacheMaxSize;
 extern int32_t tsSlowLogThreshold;
-extern int32_t tsSlowLogThresholdTest;
 extern char    tsSlowLogExceptDb[];
 extern int32_t tsSlowLogScope;
 extern int32_t tsSlowLogMaxLen;
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@ -676,7 +676,7 @@ typedef struct {
  int32_t tsSlowLogThreshold;
  int32_t tsSlowLogMaxLen;
  int32_t tsSlowLogScope;
-  int32_t tsSlowLogThresholdTest;
+  int32_t tsSlowLogThresholdTest;   //Obsolete
  char    tsSlowLogExceptDb[TSDB_DB_NAME_LEN];
 } SMonitorParas;

@ -2208,8 +2208,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 {
@ -2328,6 +2329,7 @@ typedef struct {
 typedef struct {
  SExplainRsp rsp;
  uint64_t    qId;
+  uint64_t    cId;
  uint64_t    tId;
  int64_t     rId;
  int32_t     eId;
@ -2682,6 +2684,7 @@ typedef struct SSubQueryMsg {
  SMsgHead header;
  uint64_t sId;
  uint64_t queryId;
+  uint64_t clientId;
  uint64_t taskId;
  int64_t  refId;
  int32_t  execId;
@ -2711,6 +2714,7 @@ typedef struct {
  SMsgHead header;
  uint64_t sId;
  uint64_t queryId;
+  uint64_t clientId;
  uint64_t taskId;
  int32_t  execId;
 } SQueryContinueReq;
@ -2745,6 +2749,7 @@ typedef struct {
  SMsgHead        header;
  uint64_t        sId;
  uint64_t        queryId;
+  uint64_t        clientId;
  uint64_t        taskId;
  int32_t         execId;
  SOperatorParam* pOpParam;
@ -2760,6 +2765,7 @@ typedef struct {

 typedef struct {
  uint64_t queryId;
+  uint64_t clientId;
  uint64_t taskId;
  int64_t  refId;
  int32_t  execId;
@ -2806,6 +2812,7 @@ typedef struct {
  SMsgHead header;
  uint64_t sId;
  uint64_t queryId;
+  uint64_t clientId;
  uint64_t taskId;
  int64_t  refId;
  int32_t  execId;
@ -2819,6 +2826,7 @@ typedef struct {
  SMsgHead header;
  uint64_t sId;
  uint64_t queryId;
+  uint64_t clientId;
  uint64_t taskId;
  int64_t  refId;
  int32_t  execId;
@ -2835,6 +2843,7 @@ typedef struct {
  SMsgHead        header;
  uint64_t        sId;
  uint64_t        queryId;
+  uint64_t        clientId;
  uint64_t        taskId;
  int64_t         refId;
  int32_t         execId;
@ -3242,6 +3251,7 @@ int tDecodeSVCreateTbBatchRsp(SDecoder* pCoder, SVCreateTbBatchRsp* pRsp);
 typedef struct {
  char*    name;
  uint64_t suid;  // for tmq in wal format
+  int64_t  uid;
  int8_t   igNotExists;
 } SVDropTbReq;

@ -3810,7 +3820,14 @@ typedef struct {
  SMsgHead head;
  int64_t  streamId;
  int32_t  taskId;
-} SVPauseStreamTaskReq, SVResetStreamTaskReq;
+} SVPauseStreamTaskReq;
+
+typedef struct {
+  SMsgHead head;
+  int64_t  streamId;
+  int32_t  taskId;
+  int64_t  chkptId;
+} SVResetStreamTaskReq;

 typedef struct {
  char   name[TSDB_STREAM_FNAME_LEN];
@ -4283,6 +4300,7 @@ typedef struct {
  SMsgHead header;
  uint64_t sId;
  uint64_t queryId;
+  uint64_t clientId;
  uint64_t taskId;
  uint32_t sqlLen;
  uint32_t phyLen;
--- a/Show More
+++ b/Show More