Merge branch '3.0' into enh/TD-30933-3.0

2024-11-27 16:44:43 +08:00 · 2024-11-27 16:44:43 +08:00 · 3da2d3d78d
parent 2028db3623 7f9a3bf9de
commit 3da2d3d78d
210 changed files with 5773 additions and 1705 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/10
+++ b/10
@ -5,7 +5,7 @@ node {
 }
 file_zh_changed = ''
 file_en_changed = ''
-file_no_doc_changed = ''
+file_no_doc_changed = '1'
 def abortPreviousBuilds() {
    def currentJobName = env.JOB_NAME
    def currentBuildNumber = env.BUILD_NUMBER.toInteger()
@ -355,7 +355,7 @@ def pre_test_build_win() {
    bat '''
        cd %WIN_COMMUNITY_ROOT%/tests/ci
        pip3 install taospy==2.7.16 
-        pip3 install taos-ws-py==0.3.3
+        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
@ -451,8 +451,8 @@ pipeline {
        stage('run test') {
            when {
-                allOf {
+                expression {
-                    not { expression { file_no_doc_changed == '' }}
+                    file_no_doc_changed != '' && env.CHANGE_TARGET != 'docs-cloud'
                }
            }
            parallel {
@ -656,4 +656,4 @@ pipeline {
            )
        }
    } 
-}
+}
--- 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/contrib/test/CMakeLists.txt
+++ b/contrib/test/CMakeLists.txt
@ -28,6 +28,9 @@ if(${BUILD_WITH_TRAFT})
    # add_subdirectory(traft)
 endif(${BUILD_WITH_TRAFT})
-add_subdirectory(azure)
+if(${BUILD_S3})
  add_subdirectory(azure)
 endif()
 add_subdirectory(tdev)
 add_subdirectory(lz4)
--- a/docs/en/08-develop/01-connect/index.md
+++ b/docs/en/08-develop/01-connect/index.md
@ -90,7 +90,7 @@ If `maven` is used to manage the projects, what needs to be done is only adding
 <dependency>
  <groupId>com.taosdata.jdbc</groupId>
  <artifactId>taos-jdbcdriver</artifactId>
-  <version>3.3.3</version>
+  <version>3.4.0</version>
 </dependency>
 ```
--- 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
--- 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|
+|binary/nchar| disabled| disabled|lz4/zlib/zstd/xz| lz4| zstd|
-|bool| bit-packing| bit-packing| lz4/zlib/zstd/xz| lz4| medium|
+|bool| bit-packing| bit-packing| lz4/zlib/zstd/xz| lz4| zstd|
 ## SQL
--- a/docs/en/14-reference/05-connectors/14-java.mdx
+++ b/docs/en/14-reference/05-connectors/14-java.mdx
@ -42,6 +42,9 @@ REST connection supports all platforms that can run Java.
 | taos-jdbcdriver version |                                                                   major changes                                                                    | TDengine version |
 | :---------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------: | :--------------: |
 |          3.4.0         | 1. Replace the fastjson library with the Jackson library; 2. WebSocket connection protocal uses independent identification; 3. Optimize the use of backend pull threads to avoid user misuse leading to timeouts.|    -       |
 |          3.3.4         | 1. Fixed getInt error when data type is float|    -       |
 |          3.3.3         | 1. Fixed the memory leak caused by WebSocket statement|    -       |
 |          3.3.2         | 1. Optimized websocket prepareStatement performance; 2. Improved mybatis support|    -       |
 |          3.3.0         | 1. Optimized data transmission performance under Websocket connection; 2. SSL validation skipping is supported but disabled by default|     3.3.2.0 or later          |
 |          3.2.11         | Fixed the result set closing bug when using a native connection.|        -         |
--- 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/examples/JDBC/mybatisplus-demo/pom.xml
+++ b/docs/examples/JDBC/mybatisplus-demo/pom.xml
@ -47,7 +47,7 @@
        <dependency>
            <groupId>com.taosdata.jdbc</groupId>
            <artifactId>taos-jdbcdriver</artifactId>
-            <version>3.2.4</version>
+            <version>3.4.0</version>
        </dependency>
        <dependency>
--- a/docs/examples/JDBC/mybatisplus-demo/src/main/java/com/taosdata/example/mybatisplusdemo/domain/Meters.java
+++ b/docs/examples/JDBC/mybatisplus-demo/src/main/java/com/taosdata/example/mybatisplusdemo/domain/Meters.java
@ -0,0 +1,16 @@
 package com.taosdata.example.mybatisplusdemo.domain;
 import lombok.Data;
 import java.sql.Timestamp;
@Data
 public class Meters {
    private String tbname;
    private Timestamp ts;
    private float current;
    private int voltage;
    private float phase;
    private int groupid;
    private byte[] location;
 }
--- a/docs/examples/JDBC/mybatisplus-demo/src/main/java/com/taosdata/example/mybatisplusdemo/mapper/MetersMapper.java
+++ b/docs/examples/JDBC/mybatisplus-demo/src/main/java/com/taosdata/example/mybatisplusdemo/mapper/MetersMapper.java
@ -0,0 +1,31 @@
 package com.taosdata.example.mybatisplusdemo.mapper;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.taosdata.example.mybatisplusdemo.domain.Meters;
 import org.apache.ibatis.annotations.Insert;
 import org.apache.ibatis.annotations.Param;
 import org.apache.ibatis.annotations.Update;
 import java.util.List;
 public interface MetersMapper extends BaseMapper<Meters> {
    @Update("CREATE STABLE IF NOT EXISTS meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (groupId INT, location BINARY(24))")
    int createTable();
    @Insert("insert into meters (tbname, ts, groupid, location, current, voltage, phase) values(#{tbname}, #{ts}, #{groupid}, #{location}, #{current}, #{voltage}, #{phase})")
    int insertOne(Meters one);
    @Insert({
            "<script>",
            "insert into meters (tbname, ts, groupid, location, current, voltage, phase) values ",
            "<foreach collection='list' item='item' index='index' separator=','>",
            "(#{item.tbname}, #{item.ts}, #{item.groupid}, #{item.location}, #{item.current}, #{item.voltage}, #{item.phase})",
            "</foreach>",
            "</script>"
    })
    int insertBatch(@Param("list") List<Meters> metersList);
    @Update("drop stable if exists meters")
    void dropTable();
 }
--- a/docs/examples/JDBC/mybatisplus-demo/src/main/resources/application.yml
+++ b/docs/examples/JDBC/mybatisplus-demo/src/main/resources/application.yml
@ -1,7 +1,7 @@
 spring:
  datasource:
-    driver-class-name: com.taosdata.jdbc.TSDBDriver
+    driver-class-name: com.taosdata.jdbc.ws.WebSocketDriver
-    url: jdbc:TAOS://localhost:6030/mp_test?charset=UTF-8&locale=en_US.UTF-8&timezone=UTC-8
+    url: jdbc:TAOS-WS://localhost:6041/mp_test?charset=UTF-8&locale=en_US.UTF-8&timezone=UTC-8
    username: root
    password: taosdata
--- a/docs/examples/JDBC/mybatisplus-demo/src/test/java/com/taosdata/example/mybatisplusdemo/mapper/MetersMapperTest.java
+++ b/docs/examples/JDBC/mybatisplus-demo/src/test/java/com/taosdata/example/mybatisplusdemo/mapper/MetersMapperTest.java
@ -0,0 +1,112 @@
 package com.taosdata.example.mybatisplusdemo.mapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.taosdata.example.mybatisplusdemo.domain.Meters;
 import com.taosdata.example.mybatisplusdemo.domain.Weather;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 import java.sql.Timestamp;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Random;
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
 public class MetersMapperTest {
    private static Random random = new Random(System.currentTimeMillis());
    @Autowired
    private MetersMapper mapper;
    @Before 
    public void createTable(){
        mapper.dropTable();
        mapper.createTable();
        Meters one = new Meters();
        one.setTbname("test_10001");
        one.setGroupid(10001);
        one.setCurrent(random.nextFloat());
        one.setPhase(random.nextFloat());
        one.setCurrent(12345);
        one.setTs(new Timestamp(1605024000000l));
        one.setLocation("望京".getBytes());
        mapper.insertOne(one);
    }
    @Test
    public void testSelectList() {
        List<Meters> meters = mapper.selectList(null);
        meters.forEach(System.out::println);
    }
    @Test
    public void testInsertBatch() {
        List<Meters> metersList = new LinkedList<>();
        for (int i  = 0; i < 100; i++){
            Meters one = new Meters();
            one.setTbname("tb_" + i);
            one.setGroupid(i);
            one.setCurrent(random.nextFloat());
            one.setPhase(random.nextFloat());
            one.setCurrent(random.nextInt());
            one.setTs(new Timestamp(1605024000000l + i));
            one.setLocation(("望京" + i).getBytes());
            metersList.add(one);
        }
        int affectRows = mapper.insertBatch(metersList);
        Assert.assertEquals(100, affectRows);
    }
    @Test
    public void testSelectOne() {
        QueryWrapper<Meters> wrapper = new QueryWrapper<>();
        wrapper.eq("location", "望京".getBytes());
        Meters one = mapper.selectOne(wrapper);
        System.out.println(one);
        Assert.assertEquals(12345, one.getCurrent(), 0.00f);
        Assert.assertArrayEquals("望京".getBytes(), one.getLocation());
    }
    // @Test
    // public void testSelectByMap() {
    //     Map<String, Object> map = new HashMap<>();
    //     map.put("location", "beijing");
    //     List<Weather> weathers = mapper.selectByMap(map);
    //     Assert.assertEquals(1, weathers.size());
    // }
    @Test
    public void testSelectObjs() {
        List<Object> ts = mapper.selectObjs(null);
        System.out.println(ts);
    }
    @Test
    public void testSelectCount() {
        int count = mapper.selectCount(null);
 //        Assert.assertEquals(5, count);
        System.out.println(count);
    }
    @Test
    public void testSelectPage() {
        IPage page = new Page(1, 2);
        IPage<Meters> metersIPage = mapper.selectPage(page, null);
        System.out.println("total : " + metersIPage.getTotal());
        System.out.println("pages : " + metersIPage.getPages());
        for (Meters meters : metersIPage.getRecords()) {
            System.out.println(meters);
        }
    }
 }
--- a/docs/examples/JDBC/springbootdemo/pom.xml
+++ b/docs/examples/JDBC/springbootdemo/pom.xml
@ -70,7 +70,7 @@
        <dependency>
            <groupId>com.taosdata.jdbc</groupId>
            <artifactId>taos-jdbcdriver</artifactId>
-            <version>3.0.0</version>
+            <version>3.4.0</version>
        </dependency>
        <dependency>
--- 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: 数据缓存
+sidebar_label: 读缓存
-title: 数据缓存
+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 内存的数据库。
+TDengine 采用时间驱动的缓存管理策略，将最新数据优先存储在缓存中，查询时无需访问硬盘即可快速返回结果。当缓存容量达到设定上限时，系统会批量将最早的数据写入硬盘，既提升了查询效率，也有效减少了硬盘的写入负担，延长硬件使用寿命。
 ```sql
 CREATE DATABASE POWER VGROUPS 10 BUFFER 256 CACHEMODEL 'NONE' PAGES 128 PAGESIZE 16;
 ```
-缓存越大越好，但超过一定阈值后再增加缓存对写入性能提升并无帮助。
+用户可通过设置 cachemodel 参数，自定义缓存模式，包括缓存最新一行数据、每列最近的非 NULL 值，或同时缓存行和列的数据。这种灵活设计在物联网场景中尤为重要，使设备状态的实时查询更加高效精准。
-## 读缓存
+这种读缓存机制的内置化设计显著降低了查询延迟，避免了引入 Redis 等外部系统的复杂性和运维成本。同时，减少了频繁查询对存储系统的压力，大幅提升系统的整体吞吐能力，确保在高并发场景下依然稳定高效运行。通过读缓存，TDengine 为用户提供了一种更轻量化的实时数据处理方案，不仅优化了查询性能，还降低了整体运维成本，为物联网和工业互联网用户提供强有力的技术支持。
-在创建数据库时，用户可以选择是否启用缓存机制以存储该数据库中每张子表的最新数据。这一缓存机制由数据库创建参数 cachemodel 进行控制。参数 cachemodel 具有如
+## TDengine 的读缓存配置
-下 4 种情况：
+
- none: 不缓存
+在创建数据库时，用户可以选择是否启用缓存机制以存储该数据库中每张子表的最新数据。这一缓存机制由数据库创建参数 cachemodel 进行控制。参数 cachemodel 具有如 下 4 种情况：
- last_row: 缓存子表最近一行数据，这将显著改善 last_row 函数的性能
+- none：不缓存
- last_value: 缓存子表每一列最近的非 NULL 值，这将显著改善无特殊影响（比如 WHERE， ORDER BY， GROUP BY， INTERVAL）时的 last 函数的性能
+- last_row：缓存子表最近一行数据，这将显著改善 last_row 函数的性能
- both: 同时缓存最近的行和列，即等同于上述 cachemodel 值为 last_row 和 last_value 的行为同时生效
+- 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。需要根据机器内存合理配置。
-## 元数据缓存
+关于数据库的具体创建，相关参数和操作说明请参考[创建数据库](../../reference/taos-sql/database/)
 为了提升查询和写入操作的效率，每个 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 的数据被立即同步到磁盘上，可靠性更高
 ## 实时数据查询的缓存实践
--- 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 指定的时间，则立即触发计算。
 ### 流计算的窗口关闭
@ -259,4 +259,4 @@ flush database test1;
 5.修改 taos.cfg，去掉 disableStream 1，或将 disableStream 改为 0
-6.启动 taosd
+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/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
@ -4,10 +4,12 @@ sidebar_label: "安装部署"
 ---
 ### 环境准备
-为了使用 TDgpt 的高级时序数据分析功能功能，需要在 TDengine 集群中安装部署 AI node（Anode）。Anode 可以运行在 Linux/Windows/Mac 等操作系统之上。请确保安装部署 Anode之前，系统中已经具备 3.10 及以上版本的Python环境，以及相应的 Python 包自动安装组件 Pip，否则无法正常安装 Anode。
+使用 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 的安装部署工作，使用如下命令：
+不同操作系统上安装及部署 Anode 有一些差异，主要是卸载操作、安装路径、服务启停等方面。本文以 Linux 系统为例，说明安装部署的流程。
 使用 Linux 环境下的安装包 TDengine-enterprise-anode-1.x.x.tar.gz 可进行 Anode 的安装部署工作，命令如下：
 ```bash
 tar -xzvf TDengine-enterprise-anode-1.0.0.tar.gz
@ -15,11 +17,11 @@ cd TDengine-enterprise-anode-1.0.0
 sudo ./install.sh
 ```
-在安装完成 Anode 之后，执行命令 `rmtaosanode` 即可已经安装的 Anode。
+对于已经安装的 Anode，执行命令 `rmtaosanode` 即可完成卸载。
-Anode 使用 Python 虚拟环境运行，避免影响安装环境中现有的 Python 库。安装后的默认 Python 虚拟环境目录位于 `/var/lib/taos/taosanode/venv/`。为了避免反复安装虚拟环境带来的开销，卸载 Anode 执行的命令 `rmtaosanode` 并不会自动删除该虚拟环境，如果您确认不需要 Python 的虚拟环境，手动删除即可。
+为了避免影响系统已有的 Python 环境，Anode 使用虚拟环境运行。安装 Anode 会在目录 `/var/lib/taos/taosanode/venv/` 中创建默认的 Python 虚拟环境，Anode 运行所需要的库均安装在该目录下。为了避免反复安装虚拟环境带来的开销，卸载命令 `rmtaosanode` 并不会自动删除该虚拟环境，如果您确认不再需要 Python 的虚拟环境，手动删除该目录即可。
 ### 启停服务
-在 Linux 系统中，安装 Anode 以后可以使用 `systemd` 来管理 Anode 服务。使用如下命令可以启动/停止/检查状态。
+在 Linux 系统中，安装 Anode 以后会自动创建 `taosanoded` 服务。可以使用 `systemd` 来管理 Anode 服务，使用如下命令启动/停止/检查 Anode。
 ```bash
 systemctl start  taosanoded
@ -28,6 +30,8 @@ systemctl status taosanoded
 ```
 ### 目录及配置说明
 安装完成后，Anode 主体目录结构如下：
 |目录/文件|说明|
 |---------------|------|
 |/usr/local/taos/taosanode/bin|可执行文件目录|
@ -39,13 +43,14 @@ systemctl status taosanoded
 #### 配置说明
-Anode 提供的服务使用 uWSGI 驱动，因此 Anode 和 uWSGI 的配置信息共同存放在相同的配置文件 `taosanode.ini`，该配置文件默认位于 `/etc/taos/`目录下，其具体内容及说明如下：
+Anode 的服务需要使用 uWSGI 驱动驱动运行，因此 Anode 和 uWSGI 的配置信息共同存放在相同的配置文件 `taosanode.ini` 中，该配置文件默认位于 `/etc/taos/` 目录下。
 具体内容及配置项说明如下：
 ```ini
 [uwsgi]
-# Anode HTTP service ip:port
+# Anode RESTful service ip:port
-http = 127.0.0.1:6050
+http = 127.0.0.1:6090
 # base directory for Anode python files， do NOT modified this
 chdir = /usr/local/taos/taosanode/lib
@ -81,8 +86,8 @@ log-level = DEBUG
 ```
 **提示**
-请勿设置 `daemonize` 参数，该参数会导致 uWSGI 与 systemctl 冲突，从而无法正常启动。
+请勿设置 `daemonize` 参数，该参数会导致 uWSGI 与 systemctl 冲突，从而导致 Anode 无法正常启动。
-上面的示例配置文件 `taosanode.ini` 只包含了使用 Anode 提供服务的基础配置参数，对于 uWSGI 的其他配置参数设置及其含义和说明请参考 [uWSGIS官方文档](https://uwsgi-docs-zh.readthedocs.io/zh-cn/latest/Options.html)。
+上面的示例配置文件 `taosanode.ini` 只包含了使用 Anode 提供服务的基础配置参数，对于 uWSGI 的其他配置参数的设置及其说明请参考 [uWSGIS官方文档](https://uwsgi-docs-zh.readthedocs.io/zh-cn/latest/Options.html)。
 Anode 运行配置主要是以下：
 - app-log: Anode 服务运行产生的日志，用户可以调整其到需要的位置
@ -91,14 +96,15 @@ Anode 运行配置主要是以下：
 ### Anode 基本操作
 对于 Anode 的管理，用户需要通过 TDengine 的命令行接口 taos 进行。因此下述介绍的管理命令都需要先打开 taos, 连接到 TDengine 运行实例。 
 #### 创建 Anode
 ```sql 
 CREATE ANODE {node_url}
 ```
-node_url 是提供服务的 Anode 的 IP 和 PORT, 例如：`create anode 'http://localhost:6050'`。启动 Anode 以后如果不注册到 TDengine 集群中，则无法提供正常的服务。不建议 Anode 注册到两个或多个集群中。
+node_url 是提供服务的 Anode 的 IP 和 PORT组成的字符串, 例如：`create anode '127.0.0.1:6090'`。Anode 启动后还需要注册到 TDengine 集群中才能提供服务。不建议将 Anode 同时注册到两个集群中。
 #### 查看 Anode
-列出集群中所有的数据分析节点，包括其 `FQDN`, `PORT`, `STATUS`。
+列出集群中所有的数据分析节点，包括其 `FQDN`, `PORT`, `STATUS`等属性。
 ```sql
 SHOW ANODES;
 ```
@ -111,7 +117,7 @@ SHOW ANODES FULL;
 #### 刷新集群中的分析算法缓存
 ```SQL
-UPDATE ANODE {node_id}
+UPDATE ANODE {anode_id}
 UPDATE ALL ANODES
 ```
@ -119,4 +125,4 @@ UPDATE ALL ANODES
 ```sql
 DROP ANODE {anode_id}
 ```
-删除 Anode 只是将 Anode 从 TDengine 集群中删除，管理 Anode 的启停仍然需要使用`systemctl`命令。
+删除 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
@ -7,27 +7,43 @@ import activity from './pic/activity.png';
 import wndata from './pic/white-noise-data.png'
 ### 分析流程
-在针对时序数据进行高级分析之前，首先进行数据的白噪声检查（White Noise Data check, WND）。整体的流程如下图所示。
+时序数据分析之前需要有预处理的过程，为减轻分析算法的负担，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` 要求分析平台忽略白噪声输入时间序列检查，从而节省计算资源。
+白噪声时序数据可以简单地认为是随机数构成的时间数据序列（如上图所示的正态分布随机数序列），随机数构成的时间序列没有分析的价值，因此会直接返回。白噪声检查采用经典的 `Ljung-Box` 统计量检验，计算 `Ljung-Box` 统计量需遍历整个输入时间序列。如果用户能够明确输入序列一定不是白噪声序列，那么可以在参数列表中增加参数 `wncheck=0` 强制要求分析平台忽略白噪声检查，从而节省计算资源。
 TDgpt 暂不提供独立的时间序列白噪声检测功能。
-### 数据重采样和时间戳对齐
+### 重采样和时间戳对齐
-对于输入的时间序列数据，在对齐进行预测分析之前需要进行必要的预处理流程。预处理解决以下两个方面的问题：
+对于进行预测分析的时间序列数据，在进行预测分析前需要进行必要的预处理。预处理主要解决以下两个问题：
- 真实时间序列数据时间戳未对齐。由于数据生成的原因或者网关给时间序列数据赋值时间戳并不能保证按照严格的时间间隔赋值，此时 分析平台会自动将输入数据按照用户指定的采样频率对时间戳进行对齐处理。例如输入时间序列 [11,  22,  29,  41]，用户指定时间间隔为 10，该时间序列的时间戳将被自动重整为以下时间戳序列 [10, 20, 30, 40]。
+- 真实时间序列数据时间戳未对齐。由于数据生成设备的原因或网关赋值时间戳的时候并不能保证按照严格的时间间隔赋值，时间序列数据并不能保证是严格按照采样频率对齐。例如采样频率为 1Hz 的一个时间序列数据序列，其时间戳序列如下：
 - 数据时间重采样。用户输入时间序列的采样频率超过了输出结果的频率，例如输入时间序列的采样频率是 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] 那么该序列进行预测分析将返回错误。
+  > ['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,  // 返回结果的行数
--- 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
@ -3,9 +3,30 @@ title: 预测算法
 description: 预测算法
 ---
-时序数据预测处理以持续一个时间段的时序数据作为输入，预测接下来一个连续时间区间内时间序列数据分布及运行的趋势。用户可以指定输出的（预测）时间序列数据点的数量，因此其输出的结果行数不确定。为此，我们引入了 `FORECAST` 函数提供预测服务。基础数据（用于预测的历史时间序列数据）是该函数的输入，预测结果是该函数的输出。用户可以通过 `FORECAST` 函数调用 Anode 提供的预测算法提供的服务。
+时序数据预测处理以持续一个时间段的时序数据作为输入，预测接下来一个连续时间区间内时间序列数据趋势。用户可以指定输出的（预测）时间序列数据点的数量，因此其输出的结果行数不确定。为此，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)
@ -23,7 +44,7 @@ algo=expr1
 1. `column_expr`：预测的时序数据列。与异常检测相同，只支持数值类型列输入。
 2. `options`：异常检测函数的参数，使用规则与 anomaly_window 相同。预测支持 `conf`, `every`, `rows`, `start`, `rows` 几个控制参数，其含义如下：
-**参数说明**
+### 参数说明
 |参数|含义|默认值|
 |---|---|---|
@ -31,7 +52,7 @@ algo=expr1
 |wncheck|白噪声（white noise data）检查|默认值为 1，0 表示不进行检查|
 |conf|预测数据的置信区间范围 ，取值范围 [0, 100]|95|
 |every|预测数据的采样间隔|输入数据的采样间隔|
-|start|预测结果的开始时间戳|输入数据最后一个时间戳加上一个采样时间段|
+|start|预测结果的开始时间戳|输入数据最后一个时间戳加上一个采样间隔时间区间|
 |rows|预测结果的记录数|10|
 1. 预测查询结果新增三个伪列，具体如下：`_FROWTS`：预测结果的时间戳、`_FLOW`：置信区间下界、`_FHIGH`：置信区间上界, 对于没有置信区间的预测算法，其置信区间同预测结果
@ -39,34 +60,34 @@ algo=expr1
 3. `EVERY`：可以与输入数据的采样频率不同。采样频率只能低于或等于输入数据采样频率，不能**高于**输入数据的采样频率。
 4. 对于某些不需要计算置信区间的算法，即使指定了置信区间，返回的结果中其上下界退化成为一个点。
-**示例**
+### 示例
 ```SQL
 --- 使用 arima 算法进行预测，预测结果是 10 条记录（默认值），数据进行白噪声检查，默认置信区间 95%. 
 SELECT  _flow, _fhigh, _frowts, FORECAST(i32, "algo=arima")
 FROM foo;
--- 使用 arima 算法进行预测，输入数据的是周期数据，每 10 个采样点是一个周期。返回置信区间是 95%.
+--- 使用 arima 算法进行预测，输入数据的是周期数据，每 10 个采样点是一个周期，返回置信区间是95%的上下边界，同时忽略白噪声检查
-SELECT  _flow, _fhigh, _frowts, FORECAST(i32, "algo=arima,alpha=95,period=10")
+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.001 |            26 |
+           10.5286684 |           41.8038254 | 2020-01-01 00:01:35.000 |            26 |
-          -21.9861946 |           83.3938904 | 2020-01-01 00:01:36.001 |            30 |
+          -21.9861946 |           83.3938904 | 2020-01-01 00:01:36.000 |            30 |
-          -78.5686035 |          144.6729126 | 2020-01-01 00:01:37.001 |            33 |
+          -78.5686035 |          144.6729126 | 2020-01-01 00:01:37.000 |            33 |
-         -154.9797363 |          230.3057709 | 2020-01-01 00:01:38.001 |            37 |
+         -154.9797363 |          230.3057709 | 2020-01-01 00:01:38.000 |            37 |
-         -253.9852905 |          337.6083984 | 2020-01-01 00:01:39.001 |            41 |
+         -253.9852905 |          337.6083984 | 2020-01-01 00:01:39.000 |            41 |
-         -375.7857971 |          466.4594727 | 2020-01-01 00:01:40.001 |            45 |
+         -375.7857971 |          466.4594727 | 2020-01-01 00:01:40.000 |            45 |
-         -514.8043823 |          622.4426270 | 2020-01-01 00:01:41.001 |            53 |
+         -514.8043823 |          622.4426270 | 2020-01-01 00:01:41.000 |            53 |
-         -680.6343994 |          796.2861328 | 2020-01-01 00:01:42.001 |            57 |
+         -680.6343994 |          796.2861328 | 2020-01-01 00:01:42.000 |            57 |
-         -868.4956665 |          992.8603516 | 2020-01-01 00:01:43.001 |            62 |
+         -868.4956665 |          992.8603516 | 2020-01-01 00:01:43.000 |            62 |
-        -1076.1566162 |         1214.4498291 | 2020-01-01 00:01:44.001 |            69 |
+        -1076.1566162 |         1214.4498291 | 2020-01-01 00:01:44.000 |            69 |
 ```
-**可用预测算法**
+## 内置预测算法
- arima
+- [arima](./02-arima.md)
- holtwinters
+- [holtwinters](./03-holtwinters.md)
--- a/docs/zh/06-advanced/06-TDgpt/05-anomaly-detection/02-anomaly-detection.md
+++ b/docs/zh/06-advanced/06-TDgpt/05-anomaly-detection/02-anomaly-detection.md
@ -1,46 +0,0 @@
 ---
 title: "异常检测算法"
 sidebar_label: "异常检测算法"
 ---
 本节讲述异常检测算法模型的使用方法。
 ## 概述
 分析平台提供了 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–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).
 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-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
@ -5,12 +5,13 @@ description: 异常检测算法
 import ad from '../pic/anomaly-detection.png';
-时序数据异常检测，在TDengine 查询处理中以异常窗口的形式服务。因此，可以将异常检测获得的窗口视为一种特殊的**事件窗口**，区别在于异常窗口的触发条件和结束条件不是用户指定，而是检测算法自动识别。因此，可以应用在事件窗口上的函数均可应用在异常窗口中。由于异常检测结果是一个时间窗口，因此调用异常检测的方式也与使用事件窗口的方式相同，在 `WHERE` 子句中使用 `ANOMALY_WINDOW` 关键词即可调用时序数据异常检测服务，同时窗口伪列（`_WSTART`, `_WEND`, `_WDURATION`）也能够像其他窗口函数一样使用。例如：
+TDengine 中定义了异常（状态）窗口来提供异常检测服务。异常窗口可以视为一种特殊的**事件窗口（Event Window）**，即异常检测算法确定的连续异常时间序列数据所在的时间窗口。与普通事件窗口区别在于——时间窗口的起始时间和结束时间均是分析算法识别确定，不是用户给定的表达式进行判定。因此，在 `WHERE` 子句中使用 `ANOMALY_WINDOW` 关键词即可调用时序数据异常检测服务，同时窗口伪列（`_WSTART`, `_WEND`, `_WDURATION`）也能够像其他时间窗口一样用于描述异常窗口的起始时间(`_WSTART`)、结束时间(`_WEND`)、持续时间(`_WDURATION`)。例如：
 ```SQL
-SELECT _wstart, _wend, SUM(i32) 
+--- 使用异常检测算法 IQR 对输入列 col_val 进行异常检测。同时输出异常窗口的起始时间、结束时间、以及异常窗口内 col 列的和。
 SELECT _wstart, _wend, SUM(col) 
 FROM foo
-ANOMALY_WINDOW(i32, "algo=iqr");
+ANOMALY_WINDOW(col_val, "algo=iqr");
 ```
 如下图所示，Anode 将返回时序数据异常窗口 $[10:51:30, 10:53:40]$ 
@ -36,18 +37,14 @@ algo=expr1
 3. 异常检测的结果可以作为外层查询的子查询输入，在 `SELECT` 子句中使用的聚合函数或标量函数与其他类型的窗口查询相同。
 4. 输入数据默认进行白噪声检查，如果输入数据是白噪声，将不会有任何（异常）窗口信息返回。
-**参数说明**
+### 参数说明
 |参数|含义|默认值|
 |---|---|---|
 |algo|异常检测调用的算法|iqr|
-|wncheck|对输入数据列是否进行白噪声检查|取值为 0 或者 1，默认值为 1，表示进行白噪声检查|
+|wncheck|对输入数据列是否进行白噪声检查，取值为0或1|1|
 异常检测的返回结果以窗口形式呈现，因此窗口查询相关的伪列在这种场景下仍然可用。可用的伪列如下：
 1. `_WSTART`： 异常窗口开始时间戳
 2. `_WEND`：异常窗口结束时间戳
 3. `_WDURATION`：异常窗口持续时间
-**示例**
+### 示例
 ```SQL
 --- 使用 iqr 算法进行异常检测，检测列 i32 列。
 SELECT _wstart, _wend, SUM(i32) 
@ -58,10 +55,8 @@ ANOMALY_WINDOW(i32, "algo=iqr");
 SELECT _wstart, _wend, SUM(i32) 
 FROM foo
 ANOMALY_WINDOW(i32, "algo=ksigma,k=2");
 ```
-```
+taos> SELECT _wstart, _wend, count(*) FROM foo ANOMAYL_WINDOW(i32);
 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:17.000 |             2 |
@ -69,10 +64,6 @@ Query OK, 1 row(s) in set (0.028946s)
 ```
-**可用异常检测算法**
+### 内置异常检测算法
- iqr
+分析平台内置了6个异常检查模型，分为3个类别，分别是[基于统计学的算法](./02-statistics-approach.md)、[基于数据密度的算法](./03-data-density.md)、以及[基于机器学习的算法](./04-machine-learning.md)。在不指定异常检测使用的方法的情况下，默认调用 IQR 进行异常检测。
- ksigma
+
 - grubbs
 - lof
 - shesd
 - tac
--- a/docs/zh/06-advanced/06-TDgpt/06-dev/02-forecast.md
+++ b/docs/zh/06-advanced/06-TDgpt/06-dev/02-forecast.md
@ -10,8 +10,8 @@ sidebar_label: "预测算法"
 `execute` 方法执行完成后的返回一个如下字典对象， 预测返回结果如下：
 ```python
 return {
-    "mse": mse,		    # 预测算法的拟合数据最小均方误差(minimum squared error)
+    "mse": mse, # 预测算法的拟合数据最小均方误差(minimum squared error)
-    "res": res              # 结果数组 [时间戳数组, 预测结果数组, 预测结果执行区间下界数组，预测结果执行区间上界数组]
+    "res": res  # 结果数组 [时间戳数组, 预测结果数组, 预测结果执行区间下界数组，预测结果执行区间上界数组]
 }
 ```
@ -77,14 +77,8 @@ class _MyForecastService(AbstractForecastService):
 	"""该算法无需任何输入参数，直接重载父类该函数，不处理算法参数设置逻辑"""
        pass
 ```
 将该文件保存在 `./taosanalytics/algo/ad/` 目录下，然后重启 taosanode 服务。然后就可以通过 SQL 语句调用该检测算法。
-```SQL
+将该文件保存在 `./taosanalytics/algo/fc/` 目录下，然后重启 taosanode 服务。在 TDengine 命令行接口中执行 `SHOW ANODES FULL` 能够看到新加入的算法。应用就可以通过 SQL 语句调用该预测算法。
 --- 对 col 列进行异常检测，通过指定 algo 参数为 myad 来调用新添加的异常检测类
 SELECT COUNT(*) FROM foo ANOMALY_DETECTION(col, 'algo=myad')
 ```
 将该文件保存在 `./taosanalytics/algo/fc/` 目录下，然后重启 taosanode 服务。通过执行 `SHOW ANODES FULL` 能够看到新加入的算法，通过 SQL 语句调用该预测算法。
 ```SQL
 --- 对 col 列进行异常检测，通过指定 algo 参数为 myfc 来调用新添加的预测类
@ -92,6 +86,7 @@ SELECT  _flow, _fhigh, _frowts, FORECAST(col_name, "algo=myfc")
 FROM foo;
 ```
 如果是第一次启动该 Anode, 请按照 [TDgpt 安装部署](../../management/) 里的步骤先将该 Anode 添加到 TDengine 系统中。
 ### 单元测试
--- a/docs/zh/06-advanced/06-TDgpt/06-dev/03-ad.md
+++ b/docs/zh/06-advanced/06-TDgpt/06-dev/03-ad.md
@ -48,13 +48,13 @@ class _MyAnomalyDetectionService(AbstractAnomalyDetectionService):
        pass
 ```
-将该文件保存在 `./taosanalytics/algo/ad/` 目录下，然后重启 taosanode 服务。然后就可以通过 SQL 语句调用该检测算法。
+将该文件保存在 `./taosanalytics/algo/ad/` 目录下，然后重启 taosanode 服务。在 TDengine 命令行接口 taos 中执行 `SHOW ANODES FULL` 就能够看到新加入的算法，然后应用就可以通过 SQL 语句调用该检测算法。
 ```SQL
 --- 对 col 列进行异常检测，通过指定 algo 参数为 myad 来调用新添加的异常检测类
 SELECT COUNT(*) FROM foo ANOMALY_DETECTION(col, 'algo=myad')
 ```
-
+如果是第一次启动该 Anode, 请按照 [TDgpt 安装部署](../../management/) 里的步骤先将该 Anode 添加到 TDengine 系统中。
 ### 单元测试
--- a/docs/zh/06-advanced/06-TDgpt/06-dev/index.md
+++ b/docs/zh/06-advanced/06-TDgpt/06-dev/index.md
@ -2,14 +2,20 @@
 title: "算法开发者指南"
 sidebar_label: "算法开发者指南"
 ---
-TDgpt 是一个可扩展的时序数据高级分析平台，用户仅按照简易的步骤就能将新分析算法添加到分析平台中。将开发完成的算法代码文件放入对应的目录文件夹，然后重启 Anode 即可完成扩展升级。Anode 启动后会自动加载特定目录的分析算法。用户可以直接使用 SQL 语句调用添加到 TDgpt 系统中的分析算法。得益于 TDgpt 与 taosd 的松散耦合关系，分析平台升级对 taosd 完全没有影响。应用系统也不需要做任何更改就能够完成分析功能和分析算法的升级。
+TDgpt 是一个可扩展的时序数据高级分析平台，用户遵循简易的步骤就能将自己开发的分析算法添加到分析平台, 各种应用就可以通过SQL语句直接调用, 让高级分析算法的使用门槛降到几乎为零。目前 TDpgt 平台只支持使用 Python 语言开发的分析算法。
 Anode 采用类动态加载模式，在启动的时候扫描特定目录内满足约定条件的所有代码文件，并将其加载到系统中。因此，开发者只需要遵循以下几步就能完成新算法的添加工作：
 1. 开发完成符合要求的分析算法类
 2. 将代码文件放入对应目录，然后重启 Anode
 3. 使用SQL命令"CREATE ANODE"，将 Anode 添加到 TDengine
 此时就完成了新算法的添加工作，之后应用就可以直接使用SQL语句调用新算法。得益于 TDgpt 与 TDengine主进程 `taosd` 的松散耦合，Anode算法升级对 `taosd` 完全没有影响。应用系统只需要调整对应的SQL语句调用新（升级的）算法，就能够快速完成分析功能和分析算法的升级。
-这种方式能够按需扩展新分析算法，极大地拓展了 TDgpt 适应的范围，用户可以将契合业务场景开发的（预测、异常检测）分析算法嵌入到 TDgpt，并通过 SQL 语句进行调用。在不更改或更改非常少的应用系统代码的前提下，就能够快速完成分析功能的平滑升级。
+这种方式能够按需扩展分析算法，极大地拓展 TDgpt 的适应范围，用户可以按需将更契合业务场景的、更准确的（预测、异常检测）分析算法动态嵌入到 TDgpt，并通过 SQL 语句进行调用。在基本不用更改应用系统代码的前提下，就能够快速完成分析功能的平滑升级。
-本节说明如何将预测算法和异常检测算法添加到 TDengine 分析平台。
+以下内容将说明如何将分析算法添加到 Anode 中并能够通过SQL语句进行调用。
 ## 目录结构
-首先需要了解TDgpt的目录结构。其主体目录结构如下图：
+Anode的主要目录结构如下图所示
 ```bash
 .
@ -42,7 +48,7 @@ TDgpt 是一个可扩展的时序数据高级分析平台，用户仅按照简
 ### 类命名规范
-由于算法采用自动加载，因此其只识别按照特定命名方式的类。算法类的名称需要以下划线开始，以 Service 结尾。例如：`_KsigmaService` 是  KSigma 异常检测算法类。
+Anode采用算法自动加载模式，因此只识别符合命名约定的 Python 类。需要加载的算法类名称需要以下划线 `_` 开始并以 `Service` 结尾。例如：`_KsigmaService` 是  KSigma 异常检测算法类。
 ### 类继承约定
@ -50,33 +56,27 @@ TDgpt 是一个可扩展的时序数据高级分析平台，用户仅按照简
 - 预测算法需要从 `AbstractForecastService` 继承，同样需要实现其核心抽象方法 `execute`
 ### 类属性初始化
-每个算法实现的类需要静态初始化两个类属性，分别是：
+实现的类需要初始化以下两个类属性：
- `name`：触发调用的关键词，全小写英文字母。该名称也是通过 `SHOW` 命令查看可用分析算法是显示的名称。
+- `name`：识别该算法的关键词，全小写英文字母。通过 `SHOW` 命令查看可用算法显示的名称即为该名称。
- `desc`：算法的描述信息
+- `desc`：算法的基础描述信息
 ```SQL
--- algo 后面的参数 algo_name 即为类名称 `name`
+--- algo 后面的参数 name 即为类属性 `name`
-SELECT COUNT(*) FROM foo ANOMALY_DETECTION(col_name, 'algo=algo_name')
+SELECT COUNT(*) FROM foo ANOMALY_DETECTION(col_name, 'algo=name')
 ```
 ## 添加具有训练模型的分析算法
 某些深度学习的分析算法需要使用输入时间序列数据进行训练，然后生成针对训练数据集的分析模型。这种情况下，同一个分析算法对应不同的输入数据集有不同的分析模型。
 这种类型的分析算法要添加到 TDgpt 中，首先需要在 `model` 目录中建立目录，将采用该算法针对不同的输入时间序列数据生成的训练模型均保存在该目录下。如下图所示，针对不同的数据集，采用自编码器训练的数据异常检测算法生成的模型均保存在该目录下。为了确保模型能够正常读取加载，要求存储的模型使用`joblib`库进行序列化保存。
 采用训练-保存模型的方式可以一次训练，多次调用的优势。避免动态训练调用所带来的反复训练开销。
 调用已经保存的模型，需要首先调用`set_params`方法，并在参数中指定调用模型的名称 `{"model": "ad_encoder_keras"}` 即可调用该模型进行计算。调用方式如下：
 ```python
 def test_autoencoder_ad(self):
    # 获取特定的算法对象
    # ...
    # 指定调用的模型，该模型是之前针对该数据集进行训练获得
    s.set_params({"model": "ad_encoder_keras"})
    # 执行检查动作，并返回结果
    r = s.execute()
 ```
 ## 添加具有模型的分析算法
 基于统计学的分析算法可以直接针对输入时间序列数据进行分析，但是某些深度学习算法对于输入数据需要较长的时间训练，并且生成相应的模型。这种情况下，同一个分析算法对应不同的输入数据集有不同的分析模型。
 将具有模型的分析算法添加到 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
@ -6,17 +6,20 @@ title: TDgpt
 import TDgpt from './pic/data-analysis.png';
-TDgpt 是 TDengine Enterprise 中针对时序数据提供高级分析功能的企业级组件，能够独立于 TDengine 主进程部署和运行，不消耗和占用 TDengine 主进程的资源，通过内置接口向 TDengine 提供运行时动态扩展的高级时序数据分析功能。TDgpt 具有服务无状态、功能易扩展、快速弹性部署、应用轻量化、高安全性等特点。
+TDgpt 是 TDengine Enterprise 中针对时序数据提供高级分析功能的企业级组件，通过内置接口向 TDengine 提供运行时动态扩展的时序数据分析服务。TDgpt 能够独立于 TDengine 主进程部署和运行，因此可避免消耗占用 TDengine 集群的主进程资源。
-TDgpt 运行在部署于 TDengine 集群中的 AI Node (Anode)中。每个 TDengine 集群中可以部署一个或若干个 Anode 节点，不同的 Anode 节点之间不相关，无同步或协同的要求。Anode 注册到 TDengine 集群以后，就可以通过内部接口提供服务。TDgpt 提供的高级时序数据分析服务可分为时序数据异常检测和时序数据预测分析两个类别。
+TDgpt 具有服务无状态、功能易扩展、快速弹性部署、应用轻量化、高安全性等优势。
 TDgpt 运行在集群中的 AI Node (Anode)中，集群中可以部署若干个 Anode 节点，不同的 Anode 节点之间无同步依赖或协同的要求。Anode 注册到 TDengine 集群以后，立即就可以提供服务。TDgpt 提供的高级时序数据分析服务可分为时序数据异常检测和时序数据预测分析两大类。
 下图是部署 TDgpt 的 TDengine 集群示意图。
 <img src={TDgpt} width="560" alt="TDgpt架构图" />
-通过注册指令将 Anode 注册到 Mnode 中以后，就加入到 TDengine 集群，并可被查询引擎动态调用执行。在查询处理过程中，查询引擎根据生成的物理执行计划，**按需**向 Anode 请求高级时序数据分析服务。用户可通过SQL语句与 Anode 节点交互，并使用其提供的全部分析服务。需要注意的是 Anode 不直接接受用户的数据分析请求。同时 Anode 提供高效的动态注册机制，其注册和卸载过程完全不影响 TDengine 集群的服务，只影响提供对应的查询服务能力。
+在查询处理过程中，Vnode中运行的查询引擎会根据查询处理物理执行计划，按需向 Anode 请求高级时序数据分析服务。因此用户可通过 SQL 语句与 Anode 节点交互并使用其提供的全部分析服务。需要注意的是 Anode 不直接接受用户的数据分析请求。同时 Anode 具备分析算法动态注册机制，其算法扩展过程完全不影响 TDengine 集群的服务，仅在非常小的（秒级）时间窗口内影响涉及高级分析的查询服务。
-TDgpt 提供的高级数据分析功能分为时序数据异常检测和时序数据预测。
+目前 TDgpt 提供如下的高级分析服务：
- 时序数据异常检测的结果采用异常窗口的形式提供，即分析系统自动将算法检测到的连续异常数据以时间窗口的形式返回，其使用方式与 TDengine 中其他类型的时间窗口（例如状态窗口、事件窗口）类似。特别地，可以将异常数据窗口视作为一种特殊的**事件窗口（Event Window）**，因此状态窗口可使用的所有查询操作均可应用在异常窗口上。
+- 时序数据异常检测。TDengine 中定义了新的时间窗口——异常（状态）窗口——来提供异常检测服务。异常窗口可以视为一种特殊的**事件窗口（Event Window）**，即异常检测算法确定的连续异常时间序列数据所在的时间窗口。与普通事件窗口区别在于——时间窗口的起始时间和结束时间均是分析算法确定，不是用户指定的表达式判定。异常窗口使用方式与其他类型的时间窗口（例如状态窗口、会话窗口等）类似。因此时间窗口内可使用的查询操作均可应用在异常窗口上。
- 时序数据预测是基于输入的时间序列数据，使用指定（或默认）预测算法给出输入时序数据后续时间序列的**预测**观测值数据。因此，不同于异常检测是以窗口的形式存在，时序数据预测在 TDengine 中是一个（不确定输出）函数。
+- 时序数据预测。定义了一个新函数`FORECAST`，基于输入的（历史）时间序列数据调用指定（或默认）预测算法给出输入时序数据后续时间序列的**预测**数据。
 TDgpt 还为算法开发者提供了一 SDK。任何开发者只需要按照[算法开发者指南](./dev)的步骤，就可以将自己独有的时序数据预测或时序数据异常检测算法无缝集成到 TDgpt, 这样 TDengine 用户就可以通过一条 SQL 获得时序数据预测结果或是异常窗口了, 大幅降低了用户使用新的时序数据分析算法的门槛，而且让 TDengine 成为一开放的系统。
--- a/docs/zh/07-develop/01-connect/index.md
+++ b/docs/zh/07-develop/01-connect/index.md
@ -89,7 +89,7 @@ TDengine 提供了丰富的应用程序开发接口，为了便于用户快速
 <dependency>
  <groupId>com.taosdata.jdbc</groupId>
  <artifactId>taos-jdbcdriver</artifactId>
-  <version>3.3.3</version>
+  <version>3.4.0</version>
 </dependency>
 ```
--- 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/14-reference/01-components/01-taosd.md
+++ b/docs/zh/14-reference/01-components/01-taosd.md
@ -27,65 +27,65 @@ taosd 命令行参数如下
 ### 连接相关
 |参数名称|支持版本|参数含义|
-|-----------------------|-----------|-|
+|-----------------------|----------|-|
-|firstEp                |           |taosd 启动时，主动连接的集群中首个 dnode 的 end point，默认值 localhost:6030|
+|firstEp                |          |taosd 启动时，主动连接的集群中首个 dnode 的 end point，默认值 localhost:6030|
-|secondEp               |           |taosd 启动时，如果 firstEp 连接不上，尝试连接集群中第二个 dnode 的 endpoint，无默认值|
+|secondEp               |          |taosd 启动时，如果 firstEp 连接不上，尝试连接集群中第二个 dnode 的 endpoint，无默认值|
-|fqdn                   |           |taosd 监听的服务地址，默认为所在服务器上配置的第一个 hostname|
+|fqdn                   |          |taosd 监听的服务地址，默认为所在服务器上配置的第一个 hostname|
-|serverPort             |           |taosd 监听的端口，默认值 6030|
+|serverPort             |          |taosd 监听的端口，默认值 6030|
-|compressMsgSize        |           |是否对 RPC 消息进行压缩；-1：所有消息都不压缩；0：所有消息都压缩；N (N>0)：只有大于 N 个字节的消息才压缩；默认值 -1|
+|compressMsgSize        |          |是否对 RPC 消息进行压缩；-1：所有消息都不压缩；0：所有消息都压缩；N (N>0)：只有大于 N 个字节的消息才压缩；默认值 -1|
-|shellActivityTimer     |           |客户端向 mnode 发送心跳的时长，单位为秒，取值范围 1-120，默认值 3|
+|shellActivityTimer     |          |客户端向 mnode 发送心跳的时长，单位为秒，取值范围 1-120，默认值 3|
-|numOfRpcSessions       |           |RPC 支持的最大连接数，取值范围 100-100000，默认值 30000|
+|numOfRpcSessions       |          |RPC 支持的最大连接数，取值范围 100-100000，默认值 30000|
-|numOfRpcThreads        |           |RPC 线程数目，默认值为 CPU 核数的一半|
+|numOfRpcThreads        |          |RPC 线程数目，默认值为 CPU 核数的一半|
-|numOfTaskQueueThreads  |           |dnode 处理 RPC 消息的线程数|
+|numOfTaskQueueThreads  |          |dnode 处理 RPC 消息的线程数|
-|statusInterval         |           |dnode 与 mnode 之间的心跳间隔|
+|statusInterval         |          |dnode 与 mnode 之间的心跳间隔|
-|rpcQueueMemoryAllowed  |           |dnode 允许的 rpc 消息占用的内存最大值，单位 bytes，取值范围 104857600-INT64_MAX，默认值 服务器内存的 1/10 |
+|rpcQueueMemoryAllowed  |          |dnode 允许的 rpc 消息占用的内存最大值，单位 bytes，取值范围 104857600-INT64_MAX，默认值 服务器内存的 1/10 |
-|resolveFQDNRetryTime   |           |FQDN 解析失败时的重试次数|
+|resolveFQDNRetryTime   |          |FQDN 解析失败时的重试次数|
-|timeToGetAvailableConn |           |获得可用连接的最长等待时间，取值范围 10-50000000，单位为毫秒，默认值 500000|
+|timeToGetAvailableConn |          |获得可用连接的最长等待时间，取值范围 10-50000000，单位为毫秒，默认值 500000|
-|maxShellConns          |           |允许创建的最大链接数|
+|maxShellConns          |          |允许创建的最大链接数|
-|maxRetryWaitTime       |           |重连最大超时时间|
+|maxRetryWaitTime       |          |重连最大超时时间|
-|shareConnLimit         |3.3.4.3 之后|内部参数，一个链接可以共享的查询数目，取值范围 1-256，默认值 10|
+|shareConnLimit         |3.3.4.3 后|内部参数，一个链接可以共享的查询数目，取值范围 1-256，默认值 10|
-|readTimeout            |3.3.4.3 之后|内部参数，最小超时时间，取值范围 64-604800，单位为秒，默认值 900|
+|readTimeout            |3.3.4.3 后|内部参数，最小超时时间，取值范围 64-604800，单位为秒，默认值 900|
 ### 监控相关
 |参数名称|支持版本|参数含义|
-|-----------------------|-----------|-|
+|-----------------------|----------|-|
-|monitor                |           |是否收集监控数据并上报，0：关闭；1:打开；默认值 0|
+|monitor                |          |是否收集监控数据并上报，0：关闭；1:打开；默认值 0|
-|monitorFqdn            |           |taosKeeper 服务所在服务器的 FQDN，默认值 无|
+|monitorFqdn            |          |taosKeeper 服务所在服务器的 FQDN，默认值 无|
-|monitorPort            |           |taosKeeper 服务所监听的端口号，默认值 6043|
+|monitorPort            |          |taosKeeper 服务所监听的端口号，默认值 6043|
-|monitorInterval        |           |监控数据库记录系统参数（CPU/内存）的时间间隔，单位是秒，取值范围 1-200000 ，默认值 30|
+|monitorInterval        |          |监控数据库记录系统参数（CPU/内存）的时间间隔，单位是秒，取值范围 1-200000 ，默认值 30|
-|monitorMaxLogs         |           |缓存的待上报日志条数|
+|monitorMaxLogs         |          |缓存的待上报日志条数|
-|monitorComp            |           |是否采用压缩方式上报监控日志时|
+|monitorComp            |          |是否采用压缩方式上报监控日志时|
-|monitorLogProtocol     |           |是否打印监控日志|
+|monitorLogProtocol     |          |是否打印监控日志|
-|monitorForceV2         |           |是否使用 V2 版本协议上报|
+|monitorForceV2         |          |是否使用 V2 版本协议上报|
-|telemetryReporting     |           |是否上传 telemetry，0：不上传，1：上传，默认值 1|
+|telemetryReporting     |          |是否上传 telemetry，0：不上传，1：上传，默认值 1|
-|telemetryServer        |           |telemetry 服务器地址|
+|telemetryServer        |          |telemetry 服务器地址|
-|telemetryPort          |           |telemetry 服务器端口编号|
+|telemetryPort          |          |telemetry 服务器端口编号|
-|telemetryInterval      |           |telemetry 上传时间间隔，单位为秒，默认 43200|
+|telemetryInterval      |          |telemetry 上传时间间隔，单位为秒，默认 43200|
-|crashReporting         |           |是否上传 crash 信息；0：不上传，1：上传；默认值  1|
+|crashReporting         |          |是否上传 crash 信息；0：不上传，1：上传；默认值  1|
 ### 查询相关
 |参数名称|支持版本|参数含义|
-|------------------------|-----------|-|
+|------------------------|----------|-|
-|countAlwaysReturnValue  |           |count/hyperloglog 函数在输入数据为空或者 NULL 的情况下是否返回值；0：返回空行，1：返回；默认值 1；该参数设置为 1 时，如果查询中含有 INTERVAL 子句或者该查询使用了 TSMA 时，且相应的组或窗口内数据为空或者 NULL，对应的组或窗口将不返回查询结果；注意此参数客户端和服务端值应保持一致|
+|countAlwaysReturnValue  |          |count/hyperloglog 函数在输入数据为空或者 NULL 的情况下是否返回值；0：返回空行，1：返回；默认值 1；该参数设置为 1 时，如果查询中含有 INTERVAL 子句或者该查询使用了 TSMA 时，且相应的组或窗口内数据为空或者 NULL，对应的组或窗口将不返回查询结果；注意此参数客户端和服务端值应保持一致|
-|tagFilterCache          |           |是否缓存标签过滤结果|
+|tagFilterCache          |          |是否缓存标签过滤结果|
-|maxNumOfDistinctRes     |           |允许返回的 distinct 结果最大行数，默认值 10 万，最大允许值 1 亿|
+|maxNumOfDistinctRes     |          |允许返回的 distinct 结果最大行数，默认值 10 万，最大允许值 1 亿|
-|queryBufferSize         |           |暂不生效|
+|queryBufferSize         |          |暂不生效|
-|queryRspPolicy          |           |查询响应策略|
+|queryRspPolicy          |          |查询响应策略|
-|filterScalarMode        |           |强制使用标量过滤模式，0：关闭；1：开启，默认值 0|
+|filterScalarMode        |          |强制使用标量过滤模式，0：关闭；1：开启，默认值 0|
-|queryPlannerTrace       |           |内部参数，查询计划是否输出详细日志|
+|queryPlannerTrace       |          |内部参数，查询计划是否输出详细日志|
-|queryNodeChunkSize      |           |内部参数，查询计划的块大小|
+|queryNodeChunkSize      |          |内部参数，查询计划的块大小|
-|queryUseNodeAllocator   |           |内部参数，查询计划的分配方法|
+|queryUseNodeAllocator   |          |内部参数，查询计划的分配方法|
-|queryMaxConcurrentTables|           |内部参数，查询计划的并发数目|
+|queryMaxConcurrentTables|          |内部参数，查询计划的并发数目|
-|queryRsmaTolerance      |           |内部参数，用于判定查询哪一级 rsma 数据时的容忍时间，单位为毫秒|
+|queryRsmaTolerance      |          |内部参数，用于判定查询哪一级 rsma 数据时的容忍时间，单位为毫秒|
-|enableQueryHb           |           |内部参数，是否发送查询心跳消息|
+|enableQueryHb           |          |内部参数，是否发送查询心跳消息|
-|pqSortMemThreshold      |           |内部参数，排序使用的内存阈值|
+|pqSortMemThreshold      |          |内部参数，排序使用的内存阈值|
 ### 区域相关
 |参数名称|支持版本|参数含义|
-|-----------------|-----------|-|
+|-----------------|----------|-|
-|timezone         |           |时区；缺省从系统中动态获取当前的时区设置|
+|timezone         |          |时区；缺省从系统中动态获取当前的时区设置|
-|locale           |           |系统区位信息及编码格式，缺省从系统中获取|
+|locale           |          |系统区位信息及编码格式，缺省从系统中获取|
-|charset          |           |字符集编码，缺省从系统中获取|
+|charset          |          |字符集编码，缺省从系统中获取|
 :::info
 1. 为应对多时区的数据写入和查询问题，TDengine 采用 Unix 时间戳(Unix Timestamp)来记录和存储时间戳。Unix 时间戳的特点决定了任一时刻不论在任何时区，产生的时间戳均一致。需要注意的是，Unix 时间戳是在客户端完成转换和记录。为了确保客户端其他形式的时间转换为正确的 Unix 时间戳，需要设置正确的时区。
@ -164,147 +164,148 @@ charset 的有效值是 UTF-8。
 ### 存储相关
 |参数名称|支持版本|参数含义|
-|--------------------|-----------|-|
+|--------------------|----------|-|
-|dataDir             |           |数据文件目录，所有的数据文件都将写入该目录，默认值 /var/lib/taos|
+|dataDir             |          |数据文件目录，所有的数据文件都将写入该目录，默认值 /var/lib/taos|
-|tempDir             |           |指定所有系统运行过程中的临时文件生成的目录，默认值 /tmp|
+|tempDir             |          |指定所有系统运行过程中的临时文件生成的目录，默认值 /tmp|
-|minimalDataDirGB    |           |dataDir 指定的时序数据存储目录所需要保留的最小空间，单位 GB，默认值 2|
+|minimalDataDirGB    |          |dataDir 指定的时序数据存储目录所需要保留的最小空间，单位 GB，默认值 2|
-|minimalTmpDirGB     |           |tempDir 所指定的临时文件目录所需要保留的最小空间，单位 GB，默认值 1|
+|minimalTmpDirGB     |          |tempDir 所指定的临时文件目录所需要保留的最小空间，单位 GB，默认值 1|
-|minDiskFreeSize     |3.1.1.0 之后|当某块磁盘上的可用空间小于等于这个阈值时，该磁盘将不再被选择用于生成新的数据文件，单位为字节，取值范围 52428800-1073741824，默认值为 52428800；企业版参数|
+|minDiskFreeSize     |3.1.1.0 后|当某块磁盘上的可用空间小于等于这个阈值时，该磁盘将不再被选择用于生成新的数据文件，单位为字节，取值范围 52428800-1073741824，默认值为 52428800；企业版参数|
-|s3MigrateIntervalSec|3.3.4.3 之后|本地数据文件自动上传 S3 的触发周期，单位为秒。最小值：600；最大值：100000。默认值 3600；企业版参数|
+|s3MigrateIntervalSec|3.3.4.3 后|本地数据文件自动上传 S3 的触发周期，单位为秒。最小值：600；最大值：100000。默认值 3600；企业版参数|
-|s3MigrateEnabled    |3.3.4.3 之后|是否自动进行 S3 迁移，默认值为 0，表示关闭自动 S3 迁移，可配置为 1；企业版参数|
+|s3MigrateEnabled    |3.3.4.3 后|是否自动进行 S3 迁移，默认值为 0，表示关闭自动 S3 迁移，可配置为 1；企业版参数|
-|s3Accesskey         |3.3.4.3 之后|冒号分隔的用户 SecretId:SecretKey，例如 AKIDsQmwsfKxTo2A6nGVXZN0UlofKn6JRRSJ:lIdoy99ygEacU7iHfogaN2Xq0yumSm1E；企业版参数|
+|s3Accesskey         |3.3.4.3 后|冒号分隔的用户 SecretId:SecretKey，例如 AKIDsQmwsfKxTo2A6nGVXZN0UlofKn6JRRSJ:lIdoy99ygEacU7iHfogaN2Xq0yumSm1E；企业版参数|
-|s3Endpoint          |3.3.4.3 之后|用户所在地域的 COS 服务域名，支持 http 和 https，bucket 的区域需要与 endpoint 保持一致，否则无法访问；企业版参数|
+|s3Endpoint          |3.3.4.3 后|用户所在地域的 COS 服务域名，支持 http 和 https，bucket 的区域需要与 endpoint 保持一致，否则无法访问；企业版参数|
-|s3BucketName        |3.3.4.3 之后|存储桶名称，减号后面是用户注册 COS 服务的 AppId，其中 AppId 是 COS 特有，AWS 和阿里云都没有，配置时需要作为 bucket name 的一部分，使用减号分隔；参数值均为字符串类型，但不需要引号；例如 test0711-1309024725；企业版参数|
+|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；企业版参数|
+|s3PageCacheSize     |3.3.4.3 后|S3 page cache 缓存页数目，取值范围 4-1048576，单位为页，默认值 4096；企业版参数|
-|s3UploadDelaySec    |3.3.4.3 之后|data 文件持续多长时间不再变动后上传至 S3，取值范围 1-2592000 (30天），单位为秒，默认值 60；企业版参数|
+|s3UploadDelaySec    |3.3.4.3 后|data 文件持续多长时间不再变动后上传至 S3，取值范围 1-2592000 (30天），单位为秒，默认值 60；企业版参数|
-|cacheLazyLoadThreshold  |       |内部参数，缓存的装载策略|
+|cacheLazyLoadThreshold|        |内部参数，缓存的装载策略|
 ### 集群相关
 |参数名称|支持版本|参数含义|
-|--------------------------|-----------|-|
+|--------------------------|----------|-|
-|supportVnodes             |           |dnode 支持的最大 vnode 数目，取值范围 0-4096，默认值 CPU 核数的 2 倍 + 5|
+|supportVnodes             |          |dnode 支持的最大 vnode 数目，取值范围 0-4096，默认值 CPU 核数的 2 倍 + 5|
-|numOfCommitThreads        |           |落盘线程的最大数量，取值范围 0-1024，默认值为 4|
+|numOfCommitThreads        |          |落盘线程的最大数量，取值范围 0-1024，默认值为 4|
-|numOfMnodeReadThreads     |           |mnode 的 Read 线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不超过 4）|
+|numOfMnodeReadThreads     |          |mnode 的 Read 线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不超过 4）|
-|numOfVnodeQueryThreads    |           |vnode 的 Query 线程数目，取值范围 0-1024，默认值为 CPU 核数的两倍（不超过 16）|
+|numOfVnodeQueryThreads    |          |vnode 的 Query 线程数目，取值范围 0-1024，默认值为 CPU 核数的两倍（不超过 16）|
-|numOfVnodeFetchThreads    |           |vnode 的 Fetch 线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不超过 4）|
+|numOfVnodeFetchThreads    |          |vnode 的 Fetch 线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不超过 4）|
-|numOfVnodeRsmaThreads     |           |vnode 的 Rsma 线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不超过 4）|
+|numOfVnodeRsmaThreads     |          |vnode 的 Rsma 线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不超过 4）|
-|numOfQnodeQueryThreads    |           |qnode 的 Query 线程数目，取值范围 0-1024，默认值为 CPU 核数的两倍（不超过 16）|
+|numOfQnodeQueryThreads    |          |qnode 的 Query 线程数目，取值范围 0-1024，默认值为 CPU 核数的两倍（不超过 16）|
-|numOfSnodeSharedThreads   |           |snode 的共享线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不小于 2，不超过 4）|
+|numOfSnodeSharedThreads   |          |snode 的共享线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不小于 2，不超过 4）|
-|numOfSnodeUniqueThreads   |           |snode 的独占线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不小于 2，不超过 4）|
+|numOfSnodeUniqueThreads   |          |snode 的独占线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不小于 2，不超过 4）|
-|ratioOfVnodeStreamThreads |           |流计算使用 vnode 线程的比例，取值范围 0.01-4，默认值 4|
+|ratioOfVnodeStreamThreads |          |流计算使用 vnode 线程的比例，取值范围 0.01-4，默认值 4|
-|ttlUnit                   |           |ttl 参数的单位，取值范围 1-31572500，单位为秒，默认值 86400|
+|ttlUnit                   |          |ttl 参数的单位，取值范围 1-31572500，单位为秒，默认值 86400|
-|ttlPushInterval           |           |ttl 检测超时频率，取值范围 1-100000，单位为秒，默认值 10|
+|ttlPushInterval           |          |ttl 检测超时频率，取值范围 1-100000，单位为秒，默认值 10|
-|ttlChangeOnWrite          |           |ttl 到期时间是否伴随表的修改操作改变；0：不改变，1：改变；默认值为 0|
+|ttlChangeOnWrite          |          |ttl 到期时间是否伴随表的修改操作改变；0：不改变，1：改变；默认值为 0|
-|ttlBatchDropNum           |           |ttl 一批删除子表的数目，最小值为 0，默认值 10000|
+|ttlBatchDropNum           |          |ttl 一批删除子表的数目，最小值为 0，默认值 10000|
-|retentionSpeedLimitMB     |           |数据在不同级别硬盘上迁移时的速度限制，取值范围 0-1024，单位 MB，默认值 0，表示不限制|
+|retentionSpeedLimitMB     |          |数据在不同级别硬盘上迁移时的速度限制，取值范围 0-1024，单位 MB，默认值 0，表示不限制|
-|maxTsmaNum                |           |集群内可创建的TSMA个数；取值范围 0-3；默认值 3|
+|maxTsmaNum                |          |集群内可创建的TSMA个数；取值范围 0-3；默认值 3|
-|tmqMaxTopicNum            |           |订阅最多可建立的 topic 数量；取值范围 1-10000；默认值为 20|
+|tmqMaxTopicNum            |          |订阅最多可建立的 topic 数量；取值范围 1-10000；默认值为 20|
-|tmqRowSize                |           |订阅数据块的最大记录条数，取值范围 1-1000000，默认值 4096|
+|tmqRowSize                |          |订阅数据块的最大记录条数，取值范围 1-1000000，默认值 4096|
-|audit                     |           |审计功能开关；企业版参数|
+|audit                     |          |审计功能开关；企业版参数|
-|auditInterval             |           |审计数据上报的时间间隔；企业版参数|
+|auditInterval             |          |审计数据上报的时间间隔；企业版参数|
-|auditCreateTable          |           |是否针对创建子表开启申计功能；企业版参数|
+|auditCreateTable          |          |是否针对创建子表开启申计功能；企业版参数|
-|encryptAlgorithm          |           |数据加密算法；企业版参数|
+|encryptAlgorithm          |          |数据加密算法；企业版参数|
-|encryptScope              |           |加密范围；企业版参数|
+|encryptScope              |          |加密范围；企业版参数|
-|enableWhiteList           |           |白名单功能开关；企业版参数|
+|enableWhiteList           |          |白名单功能开关；企业版参数|
-|syncLogBufferMemoryAllowed|           |一个 dnode 允许的 sync 日志缓存消息占用的内存最大值，单位 bytes，取值范围 104857600-INT64_MAX，默认值 服务器内存的 1/10，3.1.3.2/3.3.2.13 版本开始生效 |
+|syncLogBufferMemoryAllowed|          |一个 dnode 允许的 sync 日志缓存消息占用的内存最大值，单位 bytes，取值范围 104857600-INT64_MAX，默认值 服务器内存的 1/10，3.1.3.2/3.3.2.13 版本开始生效 |
-|syncElectInterval         |           |内部参数，用于同步模块调试|
+|syncElectInterval         |          |内部参数，用于同步模块调试|
-|syncHeartbeatInterval     |           |内部参数，用于同步模块调试|
+|syncHeartbeatInterval     |          |内部参数，用于同步模块调试|
-|syncHeartbeatTimeout      |           |内部参数，用于同步模块调试|
+|syncHeartbeatTimeout      |          |内部参数，用于同步模块调试|
-|syncSnapReplMaxWaitN      |           |内部参数，用于同步模块调试|
+|syncSnapReplMaxWaitN      |          |内部参数，用于同步模块调试|
-|syncSnapReplMaxWaitN      |           |内部参数，用于同步模块调试|
+|syncSnapReplMaxWaitN      |          |内部参数，用于同步模块调试|
-|arbHeartBeatIntervalSec   |           |内部参数，用于同步模块调试|
+|arbHeartBeatIntervalSec   |          |内部参数，用于同步模块调试|
-|arbCheckSyncIntervalSec   |           |内部参数，用于同步模块调试|
+|arbCheckSyncIntervalSec   |          |内部参数，用于同步模块调试|
-|arbSetAssignedTimeoutSec  |           |内部参数，用于同步模块调试|
+|arbSetAssignedTimeoutSec  |          |内部参数，用于同步模块调试|
-|mndSdbWriteDelta          |           |内部参数，用于 mnode 模块调试|
+|mndSdbWriteDelta          |          |内部参数，用于 mnode 模块调试|
-|mndLogRetention           |           |内部参数，用于 mnode 模块调试|
+|mndLogRetention           |          |内部参数，用于 mnode 模块调试|
-|skipGrant                 |           |内部参数，用于授权检查|
+|skipGrant                 |          |内部参数，用于授权检查|
-|trimVDbIntervalSec        |           |内部参数，用于删除过期数据|
+|trimVDbIntervalSec        |          |内部参数，用于删除过期数据|
-|ttlFlushThreshold         |           |内部参数，ttl 定时器的频率|
+|ttlFlushThreshold         |          |内部参数，ttl 定时器的频率|
-|compactPullupInterval     |           |内部参数，数据重整定时器的频率|
+|compactPullupInterval     |          |内部参数，数据重整定时器的频率|
-|walFsyncDataSizeLimit     |           |内部参数，WAL 进行 FSYNC 的阈值|
+|walFsyncDataSizeLimit     |          |内部参数，WAL 进行 FSYNC 的阈值|
-|transPullupInterval       |           |内部参数，mnode 执行事务的重试间隔|
+|transPullupInterval       |          |内部参数，mnode 执行事务的重试间隔|
-|mqRebalanceInterval       |           |内部参数，消费者再平衡的时间间隔|
+|mqRebalanceInterval       |          |内部参数，消费者再平衡的时间间隔|
-|uptimeInterval            |           |内部参数，用于记录系统启动时间|
+|uptimeInterval            |          |内部参数，用于记录系统启动时间|
-|timeseriesThreshold       |           |内部参数，用于统计用量|
+|timeseriesThreshold       |          |内部参数，用于统计用量|
-|udf                       |           |是否启动 UDF 服务；0：不启动，1：启动；默认值为 0 |
+|udf                       |          |是否启动 UDF 服务；0：不启动，1：启动；默认值为 0 |
-|udfdResFuncs              |           |内部参数，用于 UDF 结果集设置|
+|udfdResFuncs              |          |内部参数，用于 UDF 结果集设置|
-|udfdLdLibPath             |           |内部参数，表示 UDF 装载的库路径|
+|udfdLdLibPath             |          |内部参数，表示 UDF 装载的库路径|
 ### 流计算参数
 |参数名称|支持版本|参数含义|
-|-----------------------|-----------|-|
+|-----------------------|----------|-|
-|disableStream          |           |流计算的启动开关|
+|disableStream          |          |流计算的启动开关|
-|streamBufferSize       |           |控制内存中窗口状态缓存的大小，默认值为 128MB|
+|streamBufferSize       |          |控制内存中窗口状态缓存的大小，默认值为 128MB|
-|streamAggCnt           |           |内部参数，并发进行聚合计算的数目|
+|streamAggCnt           |          |内部参数，并发进行聚合计算的数目|
-|checkpointInterval     |           |内部参数，checkponit 同步间隔|
+|checkpointInterval     |          |内部参数，checkponit 同步间隔|
-|concurrentCheckpoint   |           |内部参数，是否并发检查 checkpoint|
+|concurrentCheckpoint   |          |内部参数，是否并发检查 checkpoint|
-|maxStreamBackendCache  |           |内部参数，流计算使用的最大缓存|
+|maxStreamBackendCache  |          |内部参数，流计算使用的最大缓存|
-|streamSinkDataRate     |           |内部参数，用于控制流计算结果的写入速度|
+|streamSinkDataRate     |          |内部参数，用于控制流计算结果的写入速度|
 ### 日志相关
 |参数名称|支持版本|参数含义|
-|----------------|-----------|-|
+|----------------|----------|-|
-|logDir          |           |日志文件目录，运行日志将写入该目录，默认值 /var/log/taos|
+|logDir          |          |日志文件目录，运行日志将写入该目录，默认值 /var/log/taos|
-|minimalLogDirGB |           |日志文件夹所在磁盘可用空间大小小于该值时，停止写日志，单位 GB，默认值 1|
+|minimalLogDirGB |          |日志文件夹所在磁盘可用空间大小小于该值时，停止写日志，单位 GB，默认值 1|
-|numOfLogLines   |           |单个日志文件允许的最大行数，默认值 10,000,000|
+|numOfLogLines   |          |单个日志文件允许的最大行数，默认值 10,000,000|
-|asyncLog        |           |日志写入模式，0：同步，1：异步，默认值 1|
+|asyncLog        |          |日志写入模式，0：同步，1：异步，默认值 1|
-|logKeepDays     |           |日志文件的最长保存时间，单位：天，默认值 0，意味着无限保存，日志文件不会被重命名，也不会有新的日志文件滚动产生，但日志文件的内容有可能会不断滚动，取决于日志文件大小的设置；当设置为大于 0 的值时，当日志文件大小达到设置的上限时会被重命名为 taosdlog.yyy，其中 yyy 为日志文件最后修改的时间戳，并滚动产生新的日志文件|
+|logKeepDays     |          |日志文件的最长保存时间，单位：天，默认值 0，意味着无限保存，日志文件不会被重命名，也不会有新的日志文件滚动产生，但日志文件的内容有可能会不断滚动，取决于日志文件大小的设置；当设置为大于 0 的值时，当日志文件大小达到设置的上限时会被重命名为 taosdlog.yyy，其中 yyy 为日志文件最后修改的时间戳，并滚动产生新的日志文件|
-|slowLogThreshold|3.3.3.0 之后|慢查询门限值，大于等于门限值认为是慢查询，单位秒，默认值 3 |
+|slowLogThreshold|3.3.3.0 后|慢查询门限值，大于等于门限值认为是慢查询，单位秒，默认值 3 |
-|slowLogMaxLen   |3.3.3.0 之后|慢查询日志最大长度，取值范围 1-16384，默认值 4096|
+|slowLogMaxLen   |3.3.3.0 后|慢查询日志最大长度，取值范围 1-16384，默认值 4096|
-|slowLogScope    |3.3.3.0 之后|慢查询记录类型，取值范围 ALL/QUERY/INSERT/OTHERS/NONE，默认值 QUERY|
+|slowLogScope    |3.3.3.0 后|慢查询记录类型，取值范围 ALL/QUERY/INSERT/OTHERS/NONE，默认值 QUERY|
-|slowLogExceptDb |3.3.3.0 之后|指定的数据库不上报慢查询，仅支持配置换一个数据库|
+|slowLogExceptDb |3.3.3.0 后|指定的数据库不上报慢查询，仅支持配置换一个数据库|
-|debugFlag       |           |运行日志开关，131（输出错误和警告日志），135（输出错误、警告和调试日志），143（输出错误、警告、调试和跟踪日志）；默认值 131 或 135 （取决于不同模块）|
+|debugFlag       |          |运行日志开关，131（输出错误和警告日志），135（输出错误、警告和调试日志），143（输出错误、警告、调试和跟踪日志）；默认值 131 或 135 （取决于不同模块）|
-|tmrDebugFlag    |           |定时器模块的日志开关，取值范围同上|
+|tmrDebugFlag    |          |定时器模块的日志开关，取值范围同上|
-|uDebugFlag      |           |共用功能模块的日志开关，取值范围同上|
+|uDebugFlag      |          |共用功能模块的日志开关，取值范围同上|
-|rpcDebugFlag    |           |rpc 模块的日志开关，取值范围同上|
+|rpcDebugFlag    |          |rpc 模块的日志开关，取值范围同上|
-|qDebugFlag      |           |query 模块的日志开关，取值范围同上|
+|qDebugFlag      |          |query 模块的日志开关，取值范围同上|
-|dDebugFlag      |           |dnode 模块的日志开关，取值范围同上|
+|dDebugFlag      |          |dnode 模块的日志开关，取值范围同上|
-|vDebugFlag      |           |vnode 模块的日志开关，取值范围同上|
+|vDebugFlag      |          |vnode 模块的日志开关，取值范围同上|
-|mDebugFlag      |           |mnode 模块的日志开关，取值范围同上|
+|mDebugFlag      |          |mnode 模块的日志开关，取值范围同上|
-|azDebugFlag     |3.3.4.3 之后|S3 模块的日志开关，取值范围同上|
+|azDebugFlag     |3.3.4.3 后|S3 模块的日志开关，取值范围同上|
-|sDebugFlag      |           |sync 模块的日志开关，取值范围同上|
+|sDebugFlag      |          |sync 模块的日志开关，取值范围同上|
-|tsdbDebugFlag   |           |tsdb 模块的日志开关，取值范围同上|
+|tsdbDebugFlag   |          |tsdb 模块的日志开关，取值范围同上|
-|tqDebugFlag     |           |tq 模块的日志开关，取值范围同上|
+|tqDebugFlag     |          |tq 模块的日志开关，取值范围同上|
-|fsDebugFlag     |           |fs 模块的日志开关，取值范围同上|
+|fsDebugFlag     |          |fs 模块的日志开关，取值范围同上|
-|udfDebugFlag    |           |udf 模块的日志开关，取值范围同上|
+|udfDebugFlag    |          |udf 模块的日志开关，取值范围同上|
-|smaDebugFlag    |           |sma 模块的日志开关，取值范围同上|
+|smaDebugFlag    |          |sma 模块的日志开关，取值范围同上|
-|idxDebugFlag    |           |index 模块的日志开关，取值范围同上|
+|idxDebugFlag    |          |index 模块的日志开关，取值范围同上|
-|tdbDebugFlag    |           |tdb 模块的日志开关，取值范围同上|
+|tdbDebugFlag    |          |tdb 模块的日志开关，取值范围同上|
-|metaDebugFlag   |           |meta 模块的日志开关，取值范围同上|
+|metaDebugFlag   |          |meta 模块的日志开关，取值范围同上|
-|stDebugFlag     |           |stream 模块的日志开关，取值范围同上|
+|stDebugFlag     |          |stream 模块的日志开关，取值范围同上|
-|sndDebugFlag    |           |snode 模块的日志开关，取值范围同上|
+|sndDebugFlag    |          |snode 模块的日志开关，取值范围同上|
 ### 调试相关
 |参数名称|支持版本|参数含义|
-|--------------------|-----------|-|
+|--------------------|----------|-|
-|enableCoreFile      |           |crash 时是否生成 core 文件，0：不生成，1：生成；默认值 1|
+|enableCoreFile      |          |crash 时是否生成 core 文件，0：不生成，1：生成；默认值 1|
-|configDir           |           |配置文件所在目录|
+|configDir           |          |配置文件所在目录|
-|scriptDir           |           |内部测试工具的脚本目录|
+|scriptDir           |          |内部测试工具的脚本目录|
-|assert              |           |断言控制开关，默认值 0|
+|assert              |          |断言控制开关，默认值 0|
-|randErrorChance     |           |内部参数，用于随机失败测试|
+|randErrorChance     |          |内部参数，用于随机失败测试|
-|randErrorDivisor    |           |内部参数，用于随机失败测试|
+|randErrorDivisor    |          |内部参数，用于随机失败测试|
-|randErrorScope      |           |内部参数，用于随机失败测试|
+|randErrorScope      |          |内部参数，用于随机失败测试|
-|safetyCheckLevel    |           |内部参数，用于随机失败测试|
+|safetyCheckLevel    |          |内部参数，用于随机失败测试|
-|experimental        |           |内部参数，用于一些实验特性|
+|experimental        |          |内部参数，用于一些实验特性|
-|simdEnable          |3.3.4.3 之后|内部参数，用于测试 SIMD 加速|
+|simdEnable          |3.3.4.3 后|内部参数，用于测试 SIMD 加速|
-|AVX512Enable        |3.3.4.3 之后|内部参数，用于测试 AVX512 加速|
+|AVX512Enable        |3.3.4.3 后|内部参数，用于测试 AVX512 加速|
-|rsyncPort           |           |内部参数，用于调试流计算|
+|rsyncPort           |          |内部参数，用于调试流计算|
-|snodeAddress        |           |内部参数，用于调试流计算|
+|snodeAddress        |          |内部参数，用于调试流计算|
-|checkpointBackupDir |           |内部参数，用于恢复 snode 数据|
+|checkpointBackupDir |          |内部参数，用于恢复 snode 数据|
-|enableAuditDelete   |           |内部参数，用于测试审计功能|
+|enableAuditDelete   |          |内部参数，用于测试审计功能|
-|slowLogThresholdTest|           |内部参数，用于测试慢日志|
+|slowLogThresholdTest|          |内部参数，用于测试慢日志|
 |bypassFlag          |3.3.4.5 后|内部参数，用于短路测试，0：正常写入，1：写入消息在 taos 客户端发送 RPC 消息前返回，2：写入消息在 taosd 服务端收到 RPC 消息后返回，4：写入消息在 taosd 服务端写入内存缓存前返回，8：写入消息在 taosd 服务端数据落盘前返回；默认值 0|
 ### 压缩参数
 |参数名称|支持版本|参数含义|
-|------------|-----------|-|
+|------------|----------|-|
-|fPrecision  |           |设置 float 类型浮点数压缩精度 ，取值范围 0.1 ~ 0.00000001  ，默认值  0.00000001  , 小于此值的浮点数尾数部分将被截断|
+|fPrecision  |          |设置 float 类型浮点数压缩精度 ，取值范围 0.1 ~ 0.00000001  ，默认值  0.00000001  , 小于此值的浮点数尾数部分将被截断|
-|dPrecision  |           |设置 double 类型浮点数压缩精度 , 取值范围 0.1 ~ 0.0000000000000001 ， 默认值 0.0000000000000001 ， 小于此值的浮点数尾数部分将被截取|
+|dPrecision  |          |设置 double 类型浮点数压缩精度 , 取值范围 0.1 ~ 0.0000000000000001 ， 默认值 0.0000000000000001 ， 小于此值的浮点数尾数部分将被截取|
-|lossyColumn |3.3.0.0 之前|对 float 和/或 double 类型启用 TSZ 有损压缩；取值范围 float/double/none；默认值 none，表示关闭无损压缩|
+|lossyColumn |3.3.0.0 前|对 float 和/或 double 类型启用 TSZ 有损压缩；取值范围 float/double/none；默认值 none，表示关闭无损压缩|
-|ifAdtFse    |           |在启用 TSZ 有损压缩时，使用 FSE 算法替换 HUFFMAN 算法，FSE 算法压缩速度更快，但解压稍慢，追求压缩速度可选用此算法；0：关闭，1：打开；默认值为 0|
+|ifAdtFse    |          |在启用 TSZ 有损压缩时，使用 FSE 算法替换 HUFFMAN 算法，FSE 算法压缩速度更快，但解压稍慢，追求压缩速度可选用此算法；0：关闭，1：打开；默认值为 0|
-|maxRange    |           |内部参数，用于有损压缩设置|
+|maxRange    |          |内部参数，用于有损压缩设置|
-|curRange    |           |内部参数，用于有损压缩设置|
+|curRange    |          |内部参数，用于有损压缩设置|
-|compressor  |           |内部参数，用于有损压缩设置|
+|compressor  |          |内部参数，用于有损压缩设置|
 **补充说明**
 1. 在 3.2.0.0 ~ 3.3.0.0（不包含）版本生效，启用该参数后不能回退到升级前的版本
--- a/docs/zh/14-reference/01-components/02-taosc.md
+++ b/docs/zh/14-reference/01-components/02-taosc.md
@ -10,99 +10,99 @@ TDengine 客户端驱动提供了应用编程所需要的全部 API，并且在
 ### 连接相关
 |参数名称|支持版本|参数含义|
-|----------------------|-----------|-|
+|----------------------|----------|-|
-|firstEp               |           |启动时，主动连接的集群中首个 dnode 的 endpoint，缺省值：hostname:6030，若无法获取该服务器的 hostname，则赋值为 localhost|
+|firstEp               |          |启动时，主动连接的集群中首个 dnode 的 endpoint，缺省值：hostname:6030，若无法获取该服务器的 hostname，则赋值为 localhost|
-|secondEp              |           |启动时，如果 firstEp 连接不上，尝试连接集群中第二个 dnode 的 endpoint，没有缺省值|
+|secondEp              |          |启动时，如果 firstEp 连接不上，尝试连接集群中第二个 dnode 的 endpoint，没有缺省值|
-|compressMsgSize       |           |是否对 RPC 消息进行压缩；-1：所有消息都不压缩；0：所有消息都压缩；N (N>0)：只有大于 N 个字节的消息才压缩；缺省值 -1|
+|compressMsgSize       |          |是否对 RPC 消息进行压缩；-1：所有消息都不压缩；0：所有消息都压缩；N (N>0)：只有大于 N 个字节的消息才压缩；缺省值 -1|
-|shellActivityTimer    |           |客户端向 mnode 发送心跳的时长，单位为秒，取值范围 1-120，默认值 3|
+|shellActivityTimer    |          |客户端向 mnode 发送心跳的时长，单位为秒，取值范围 1-120，默认值 3|
-|numOfRpcSessions      |           |RPC 支持的最大连接数，取值范围 100-100000，缺省值 30000|
+|numOfRpcSessions      |          |RPC 支持的最大连接数，取值范围 100-100000，缺省值 30000|
-|numOfRpcThreads       |           |RPC 线程数目，默认值为 CPU 核数的一半|
+|numOfRpcThreads       |          |RPC 线程数目，默认值为 CPU 核数的一半|
-|timeToGetAvailableConn|           |获得可用连接的最长等待时间，取值范围 10-50000000，单位为毫秒，缺省值 500000|
+|timeToGetAvailableConn|          |获得可用连接的最长等待时间，取值范围 10-50000000，单位为毫秒，缺省值 500000|
-|useAdapter            |           |内部参数，是否使用 taosadapter，影响 CSV 文件导入|
+|useAdapter            |          |内部参数，是否使用 taosadapter，影响 CSV 文件导入|
-|shareConnLimit        |3.3.4.3 之后|内部参数，一个链接可以共享的查询数目，取值范围 1-256，默认值 10|
+|shareConnLimit        |3.3.4.3 后|内部参数，一个链接可以共享的查询数目，取值范围 1-256，默认值 10|
-|readTimeout           |3.3.4.3 之后|内部参数，最小超时时间，取值范围 64-604800，单位为秒，默认值 900|
+|readTimeout           |3.3.4.3 后|内部参数，最小超时时间，取值范围 64-604800，单位为秒，默认值 900|
 ### 查询相关
 |参数名称|支持版本|参数含义|
-|---------------------------------|-----------|-|
+|---------------------------------|---------|-|
-|countAlwaysReturnValue           |           |count/hyperloglog 函数在输入数据为空或者 NULL 的情况下是否返回值；0：返回空行，1：返回；默认值 1；该参数设置为 1 时，如果查询中含有 INTERVAL 子句或者该查询使用了 TSMA 时，且相应的组或窗口内数据为空或者 NULL，对应的组或窗口将不返回查询结果；注意此参数客户端和服务端值应保持一致|
+|countAlwaysReturnValue           |         |count/hyperloglog 函数在输入数据为空或者 NULL 的情况下是否返回值；0：返回空行，1：返回；默认值 1；该参数设置为 1 时，如果查询中含有 INTERVAL 子句或者该查询使用了 TSMA 时，且相应的组或窗口内数据为空或者 NULL，对应的组或窗口将不返回查询结果；注意此参数客户端和服务端值应保持一致|
-|keepColumnName                   |           |Last、First、LastRow 函数查询且未指定别名时，自动设置别名为列名（不含函数名），因此 order by 子句如果引用了该列名将自动引用该列对应的函数；1：表示自动设置别名为列名(不包含函数名)，0：表示不自动设置别名；缺省值：0|
+|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 时，返回超级表的普通列和标签列|
+|multiResultFunctionStarReturnTags|3.3.3.0 后|查询超级表时，last(\*)/last_row(\*)/first(\*) 是否返回标签列；查询普通表、子表时，不受该参数影响；0：不返回标签列，1：返回标签列；缺省值：0；该参数设置为 0 时，last(\*)/last_row(\*)/first(\*) 只返回超级表的普通列；为 1 时，返回超级表的普通列和标签列|
-|
+|metaCacheMaxSize                 |         |指定单个客户端元数据缓存大小的最大值，单位 MB；缺省值 -1，表示无限制|
-                 |           |指定单个客户端元数据缓存大小的最大值，单位 MB；缺省值 -1，表示无限制|
+|maxTsmaCalcDelay                 |         |查询时客户端可允许的 tsma 计算延迟，若 tsma 的计算延迟大于配置值，则该 TSMA 将不会被使用；取值范围 600s - 86400s，即 10 分钟 - 1 小时；缺省值：600 秒|
-|maxTsmaCalcDelay                 |           |查询时客户端可允许的 tsma 计算延迟，若 tsma 的计算延迟大于配置值，则该 TSMA 将不会被使用；取值范围 600s - 86400s，即 10 分钟 - 1 小时；缺省值：600 秒|
+|tsmaDataDeleteMark               |         |TSMA 计算的历史数据中间结果保存时间，单位为毫秒；取值范围 >= 3600000，即大于等于1h；缺省值：86400000，即 1d |
-|tsmaDataDeleteMark               |           |TSMA 计算的历史数据中间结果保存时间，单位为毫秒；取值范围 >= 3600000，即大于等于1h；缺省值：86400000，即 1d |
+|queryPolicy                      |         |查询语句的执行策略，1：只使用 vnode，不使用 qnode；2：没有扫描算子的子任务在 qnode 执行，带扫描算子的子任务在 vnode 执行；3：vnode 只运行扫描算子，其余算子均在 qnode 执行；缺省值：1|
-|queryPolicy                      |           |查询语句的执行策略，1：只使用 vnode，不使用 qnode；2：没有扫描算子的子任务在 qnode 执行，带扫描算子的子任务在 vnode 执行；3：vnode 只运行扫描算子，其余算子均在 qnode 执行；缺省值：1|
+|queryTableNotExistAsEmpty        |         |查询表不存在时是否返回空结果集；false：返回错误；true：返回空结果集；缺省值 false|
-|queryTableNotExistAsEmpty        |           |查询表不存在时是否返回空结果集；false：返回错误；true：返回空结果集；缺省值 false|
+|querySmaOptimize                 |         |sma index 的优化策略，0：表示不使用 sma index，永远从原始数据进行查询；1：表示使用 sma index，对符合的语句，直接从预计算的结果进行查询；缺省值：0|
-|querySmaOptimize                 |           |sma index 的优化策略，0：表示不使用 sma index，永远从原始数据进行查询；1：表示使用 sma index，对符合的语句，直接从预计算的结果进行查询；缺省值：0|
+|queryPlannerTrace                |         |内部参数，查询计划是否输出详细日志|
-|queryPlannerTrace                |           |内部参数，查询计划是否输出详细日志|
+|queryNodeChunkSize               |         |内部参数，查询计划的块大小|
-|queryNodeChunkSize               |           |内部参数，查询计划的块大小|
+|queryUseNodeAllocator            |         |内部参数，查询计划的分配方法|
-|queryUseNodeAllocator            |           |内部参数，查询计划的分配方法|
+|queryMaxConcurrentTables         |         |内部参数，查询计划的并发数目|
-|queryMaxConcurrentTables         |           |内部参数，查询计划的并发数目|
+|enableQueryHb                    |         |内部参数，是否发送查询心跳消息|
-|enableQueryHb                    |           |内部参数，是否发送查询心跳消息|
+|minSlidingTime                   |         |内部参数，sliding 的最小允许值|
-|minSlidingTime                   |           |内部参数，sliding 的最小允许值|
+|minIntervalTime                  |         |内部参数，interval 的最小允许值|
 |minIntervalTime                  |           |内部参数，interval 的最小允许值|
 ### 写入相关
 |参数名称|支持版本|参数含义|
-|------------------------------|-----------|-|
+|------------------------------|----------|-|
-|smlChildTableName             |           |schemaless 自定义的子表名的 key，无缺省值|
+|smlChildTableName             |          |schemaless 自定义的子表名的 key，无缺省值|
-|smlAutoChildTableNameDelimiter|           |schemaless tag 之间的连接符，连起来作为子表名，无缺省值|
+|smlAutoChildTableNameDelimiter|          |schemaless tag 之间的连接符，连起来作为子表名，无缺省值|
-|smlTagName                    |           |schemaless tag 为空时默认的 tag 名字，缺省值 "_tag_null"|
+|smlTagName                    |          |schemaless tag 为空时默认的 tag 名字，缺省值 "_tag_null"|
-|smlTsDefaultName              |           |schemaless 自动建表的时间列名字通过该配置设置，缺省值 "_ts"|
+|smlTsDefaultName              |          |schemaless 自动建表的时间列名字通过该配置设置，缺省值 "_ts"|
-|smlDot2Underline              |           |schemaless 把超级表名中的 dot 转成下划线|
+|smlDot2Underline              |          |schemaless 把超级表名中的 dot 转成下划线|
-|maxInsertBatchRows            |           |内部参数，一批写入的最大条数|
+|maxInsertBatchRows            |          |内部参数，一批写入的最大条数|
 ### 区域相关
 |参数名称|支持版本|参数含义|
-|-----------------|-----------|-|
+|-----------------|----------|-|
-|timezone         |           |时区；缺省从系统中动态获取当前的时区设置|
+|timezone         |          |时区；缺省从系统中动态获取当前的时区设置|
-|locale           |           |系统区位信息及编码格式，缺省从系统中获取|
+|locale           |          |系统区位信息及编码格式，缺省从系统中获取|
-|charset          |           |字符集编码，缺省从系统中获取|
+|charset          |          |字符集编码，缺省从系统中获取|
 ### 存储相关
 |参数名称|支持版本|参数含义|
-|-----------------|-----------|-|
+|-----------------|----------|-|
-|tempDir          |           |指定所有运行过程中的临时文件生成的目录，Linux 平台默认值为 /tmp|
+|tempDir          |          |指定所有运行过程中的临时文件生成的目录，Linux 平台默认值为 /tmp|
-|minimalTmpDirGB  |           |tempDir 所指定的临时文件目录所需要保留的最小空间，单位 GB，缺省值：1|
+|minimalTmpDirGB  |          |tempDir 所指定的临时文件目录所需要保留的最小空间，单位 GB，缺省值：1|
 ### 日志相关
 |参数名称|支持版本|参数含义|
-|-----------------|-----------|-|
+|-----------------|----------|-|
-|logDir           |           |日志文件目录，运行日志将写入该目录，缺省值：/var/log/taos|
+|logDir           |          |日志文件目录，运行日志将写入该目录，缺省值：/var/log/taos|
-|minimalLogDirGB  |           |日志文件夹所在磁盘可用空间大小小于该值时，停止写日志，单位 GB，缺省值：1|
+|minimalLogDirGB  |          |日志文件夹所在磁盘可用空间大小小于该值时，停止写日志，单位 GB，缺省值：1|
-|numOfLogLines    |           |单个日志文件允许的最大行数，缺省值：10,000,000|
+|numOfLogLines    |          |单个日志文件允许的最大行数，缺省值：10,000,000|
-|asyncLog         |           |日志写入模式，0：同步，1：异步，缺省值：1|
+|asyncLog         |          |日志写入模式，0：同步，1：异步，缺省值：1|
-|logKeepDays      |           |日志文件的最长保存时间，单位：天，缺省值：0，意味着无限保存，日志文件不会被重命名，也不会有新的日志文件滚动产生，但日志文件的内容有可能会不断滚动，取决于日志文件大小的设置；当设置为大于 0 的值时，当日志文件大小达到设置的上限时会被重命名为 taoslogx.yyy，其中 yyy 为日志文件最后修改的时间戳，并滚动产生新的日志文件|
+|logKeepDays      |          |日志文件的最长保存时间，单位：天，缺省值：0，意味着无限保存，日志文件不会被重命名，也不会有新的日志文件滚动产生，但日志文件的内容有可能会不断滚动，取决于日志文件大小的设置；当设置为大于 0 的值时，当日志文件大小达到设置的上限时会被重命名为 taoslogx.yyy，其中 yyy 为日志文件最后修改的时间戳，并滚动产生新的日志文件|
-|debugFlag        |           |运行日志开关，131（输出错误和警告日志），135（输出错误、警告和调试日志），143（输出错误、警告、调试和跟踪日志）；默认值 131 或 135 （取决于不同模块）|
+|debugFlag        |          |运行日志开关，131（输出错误和警告日志），135（输出错误、警告和调试日志），143（输出错误、警告、调试和跟踪日志）；默认值 131 或 135 （取决于不同模块）|
-|tmrDebugFlag     |           |定时器模块的日志开关，取值范围同上|
+|tmrDebugFlag     |          |定时器模块的日志开关，取值范围同上|
-|uDebugFlag       |           |共用功能模块的日志开关，取值范围同上|
+|uDebugFlag       |          |共用功能模块的日志开关，取值范围同上|
-|rpcDebugFlag     |           |rpc 模块的日志开关，取值范围同上|
+|rpcDebugFlag     |          |rpc 模块的日志开关，取值范围同上|
-|jniDebugFlag     |           |jni 模块的日志开关，取值范围同上|
+|jniDebugFlag     |          |jni 模块的日志开关，取值范围同上|
-|qDebugFlag       |           |query 模块的日志开关，取值范围同上|
+|qDebugFlag       |          |query 模块的日志开关，取值范围同上|
-|cDebugFlag       |           |客户端模块的日志开关，取值范围同上|
+|cDebugFlag       |          |客户端模块的日志开关，取值范围同上|
-|simDebugFlag     |           |内部参数，测试工具的日志开关，取值范围同上|
+|simDebugFlag     |          |内部参数，测试工具的日志开关，取值范围同上|
-|tqClientDebugFlag|3.3.4.3 之后|客户端模块的日志开关，取值范围同上|
+|tqClientDebugFlag|3.3.4.3 后|客户端模块的日志开关，取值范围同上|
 ### 调试相关
 |参数名称|支持版本|参数含义|
 |-----------------|-----------|-|
-|crashReporting   |           |是否上传 crash 到 telemetry，0：不上传，1：上传；缺省值：1|
+|crashReporting   |          |是否上传 crash 到 telemetry，0：不上传，1：上传；缺省值：1|
-|enableCoreFile   |           |crash 时是否生成 core 文件，0：不生成，1：生成；缺省值：1|
+|enableCoreFile   |          |crash 时是否生成 core 文件，0：不生成，1：生成；缺省值：1|
-|assert           |           |断言控制开关，缺省值：0|
+|assert           |          |断言控制开关，缺省值：0|
-|configDir        |           |配置文件所在目录|
+|configDir        |          |配置文件所在目录|
-|scriptDir        |           |内部参数，测试用例的目录|
+|scriptDir        |          |内部参数，测试用例的目录|
-|randErrorChance  |3.3.3.0 之后|内部参数，用于随机失败测试|
+|randErrorChance  |3.3.3.0 后|内部参数，用于随机失败测试|
-|randErrorDivisor |3.3.3.0 之后|内部参数，用于随机失败测试|
+|randErrorDivisor |3.3.3.0 后|内部参数，用于随机失败测试|
-|randErrorScope   |3.3.3.0 之后|内部参数，用于随机失败测试|
+|randErrorScope   |3.3.3.0 后|内部参数，用于随机失败测试|
-|safetyCheckLevel |3.3.3.0 之后|内部参数，用于随机失败测试|
+|safetyCheckLevel |3.3.3.0 后|内部参数，用于随机失败测试|
-|simdEnable       |3.3.4.3 之后|内部参数，用于测试 SIMD 加速|
+|simdEnable       |3.3.4.3 后|内部参数，用于测试 SIMD 加速|
-|AVX512Enable     |3.3.4.3 之后|内部参数，用于测试 AVX512 加速|
+|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|
+|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
 ```
@ -126,7 +129,7 @@ alter_database_option: {
 }
 ```
-###  修改 CACHESIZE
+### 修改 CACHESIZE
 修改数据库参数的命令使用简单，难的是如何确定是否需要修改以及如何修改。本小节描述如何判断数据库的 cachesize 是否够用。
@ -155,13 +158,13 @@ alter_database_option: {
 ### 查看系统中的所有数据库
-```
+```sql
 SHOW DATABASES;
 ```
 ### 显示一个数据库的创建语句
-```
+```sql
 SHOW CREATE DATABASE db_name \G;
 ```
--- 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 标记也就会被替换为完全相同的时间戳取值。
+2. 一次插入多行数据时，不要把首列的时间戳的值都写 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。
-**语法说明**
+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 类型。
+- `expr1`：表示时间戳的 BIGINT, TIMESTAMP 类型，或符合 ISO8601/RFC3339 标准的日期时间格式的 VARCHAR, NCHAR 类型。
- `expr2`：表示 UNIX 时间戳的 BIGINT, TIMESTAMP 类型，或符合日期时间格式的 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 类型。
 **嵌套子查询支持**：适用于内层查询和外层查询。
--- 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|
+|  int/uint | simple8b| simple8b | lz4/zlib/zstd/xz| lz4 | medium|
-|   bigint/ubigint/timestamp   |  simple8b/delta-i    | delta-i |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|
+|binary/nchar| disabled| disabled|lz4/zlib/zstd/xz| zstd| medium|
-|bool| bit-packing| bit-packing| lz4/zlib/zstd/xz| lz4| 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/14-java.mdx
+++ b/docs/zh/14-reference/05-connector/14-java.mdx
@ -34,6 +34,7 @@ REST 连接支持所有能运行 Java 的平台。
 | taos-jdbcdriver 版本 |                                                                        主要变化                                                                        |   TDengine 版本    |
 | :------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------: | :----------------: |
 |        3.4.0        | 1. 使用 jackson 库替换 fastjson 库；2. WebSocket 采用独立协议标识；3. 优化后台拉取线程使用，避免用户误用导致超时。     |       -        |
 |        3.3.4        | 1. 解决了 getInt 在数据类型为 float 报错     |       -        |
 |        3.3.3        | 1. 解决了 WebSocket statement 关闭导致的内存泄漏      |       -        |
 |        3.3.2        | 1. 优化 WebSocket 连接下的参数绑定性能；2. 优化了对 mybatis 的支持      |       -        |
 |        3.3.0        | 1. 优化 WebSocket 连接下的数据传输性能；2. 支持跳过 SSL 验证，默认关闭      |        3.3.2.0 及更高版本         |
--- 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/03-notes/3.3.4.3.md
+++ b/docs/zh/28-releases/03-notes/3.3.4.3.md
@ -3,6 +3,12 @@ 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 函数支持时间驱动的结果推送模式 
--- a/docs/zh/28-releases/03-notes/index.md
+++ b/docs/zh/28-releases/03-notes/index.md
@ -3,6 +3,7 @@ title: 版本说明
 sidebar_label: 版本说明
 description: 各版本版本说明
 ---
-[3.3.4.3](./3.3.4.3) 
+
 [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)
+IF(TD_LINUX)
-  INCLUDE_DIRECTORIES(. ${TD_SOURCE_DIR}/src/inc ${TD_SOURCE_DIR}/src/client/inc  ${TD_SOURCE_DIR}/inc)
+  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
+    PRIVATE
-      "tmq.c"
+    "tmq.c"
-      )
+  )
  target_sources(stream_demo
-      PRIVATE
+    PRIVATE
-      "stream_demo.c"
+    "stream_demo.c"
-      )
+  )
  target_sources(schemaless
-      PRIVATE
+    PRIVATE
-      "schemaless.c"
+    "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 ()
+ENDIF()
-IF (TD_DARWIN)
+
-  INCLUDE_DIRECTORIES(. ${TD_SOURCE_DIR}/src/inc ${TD_SOURCE_DIR}/src/client/inc  ${TD_SOURCE_DIR}/inc)
+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 tEncodeStreamHbMsg(SEncoder* pEncoder, const SStreamHbMsg* pReq);
-int32_t tDecodeStreamHbMsg(SDecoder* pDecoder, SStreamHbMsg* pRsp);
+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 {
+int32_t tEncodeStreamTaskRunReq(SEncoder* pEncoder, const SStreamTaskRunReq* pReq);
-  SRestoreCheckpointInfo req;
+int32_t tDecodeStreamTaskRunReq(SDecoder* pDecoder, SStreamTaskRunReq* pReq);
  int64_t                ts;
 } SCheckpointConsensusEntry;
 #ifdef __cplusplus
 }
--- a/include/common/tanalytics.h
+++ b/include/common/tanalytics.h
@ -39,14 +39,14 @@ typedef struct {
 } SAnalyticsUrl;
 typedef enum {
-  ANAL_BUF_TYPE_JSON = 0,
+  ANALYTICS_BUF_TYPE_JSON = 0,
-  ANAL_BUF_TYPE_JSON_COL = 1,
+  ANALYTICS_BUF_TYPE_JSON_COL = 1,
-  ANAL_BUF_TYPE_OTHERS,
+  ANALYTICS_BUF_TYPE_OTHERS,
 } EAnalBufType;
 typedef enum {
-  ANAL_HTTP_TYPE_GET = 0,
+  ANALYTICS_HTTP_TYPE_GET = 0,
-  ANAL_HTTP_TYPE_POST,
+  ANALYTICS_HTTP_TYPE_POST,
 } EAnalHttpType;
 typedef struct {
@ -61,11 +61,11 @@ typedef struct {
  char         fileName[TSDB_FILENAME_LEN];
  int32_t      numOfCols;
  SAnalyticsColBuf *pCols;
-} SAnalBuf;
+} SAnalyticBuf;
 int32_t taosAnalyticsInit();
 void    taosAnalyticsCleanup();
-SJson  *taosAnalSendReqRetJson(const char *url, EAnalHttpType type, SAnalBuf *pBuf);
+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 tsosAnalBufOpen(SAnalyticBuf *pBuf, int32_t numOfCols);
-int32_t taosAnalBufWriteOptStr(SAnalBuf *pBuf, const char *optName, const char *optVal);
+int32_t taosAnalBufWriteOptStr(SAnalyticBuf *pBuf, const char *optName, const char *optVal);
-int32_t taosAnalBufWriteOptInt(SAnalBuf *pBuf, const char *optName, int64_t optVal);
+int32_t taosAnalBufWriteOptInt(SAnalyticBuf *pBuf, const char *optName, int64_t optVal);
-int32_t taosAnalBufWriteOptFloat(SAnalBuf *pBuf, const char *optName, float optVal);
+int32_t taosAnalBufWriteOptFloat(SAnalyticBuf *pBuf, const char *optName, float optVal);
-int32_t taosAnalBufWriteColMeta(SAnalBuf *pBuf, int32_t colIndex, int32_t colType, const char *colName);
+int32_t taosAnalBufWriteColMeta(SAnalyticBuf *pBuf, int32_t colIndex, int32_t colType, const char *colName);
-int32_t taosAnalBufWriteDataBegin(SAnalBuf *pBuf);
+int32_t taosAnalBufWriteDataBegin(SAnalyticBuf *pBuf);
-int32_t taosAnalBufWriteColBegin(SAnalBuf *pBuf, int32_t colIndex);
+int32_t taosAnalBufWriteColBegin(SAnalyticBuf *pBuf, int32_t colIndex);
-int32_t taosAnalBufWriteColData(SAnalBuf *pBuf, int32_t colIndex, int32_t colType, void *colValue);
+int32_t taosAnalBufWriteColData(SAnalyticBuf *pBuf, int32_t colIndex, int32_t colType, void *colValue);
-int32_t taosAnalBufWriteColEnd(SAnalBuf *pBuf, int32_t colIndex);
+int32_t taosAnalBufWriteColEnd(SAnalyticBuf *pBuf, int32_t colIndex);
-int32_t taosAnalBufWriteDataEnd(SAnalBuf *pBuf);
+int32_t taosAnalBufWriteDataEnd(SAnalyticBuf *pBuf);
-int32_t taosAnalBufClose(SAnalBuf *pBuf);
+int32_t taosAnalBufClose(SAnalyticBuf *pBuf);
-void    taosAnalBufDestroy(SAnalBuf *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
@ -251,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
--- 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
@ -67,6 +67,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;
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@ -2187,8 +2187,9 @@ int32_t tSerializeSShowVariablesReq(void* buf, int32_t bufLen, SShowVariablesReq
 typedef struct {
  char name[TSDB_CONFIG_OPTION_LEN + 1];
-  char value[TSDB_CONFIG_VALUE_LEN + 1];
+  char value[TSDB_CONFIG_PATH_LEN + 1];
  char scope[TSDB_CONFIG_SCOPE_LEN + 1];
  char info[TSDB_CONFIG_INFO_LEN + 1];
 } SVariablesInfo;
 typedef struct {
@ -3797,7 +3798,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];
--- a/include/libs/catalog/catalog.h
+++ b/include/libs/catalog/catalog.h
@ -102,6 +102,7 @@ typedef struct SCatalogReq {
  bool    svrVerRequired;
  bool    forceUpdate;
  bool    cloned;
  bool    forceFetchViewMeta;
 } SCatalogReq;
 typedef struct SMetaRes {
--- a/include/libs/geometry/geosWrapper.h
+++ b/include/libs/geometry/geosWrapper.h
@ -35,6 +35,7 @@ int32_t doGeomFromText(const char *inputWKT, unsigned char **outputGeom, size_t
 int32_t initCtxAsText();
 int32_t doAsText(const unsigned char *inputGeom, size_t size, char **outputWKT);
 int32_t checkWKB(const unsigned char *wkb, size_t size);
 int32_t initCtxRelationFunc();
 int32_t doIntersects(const GEOSGeometry *geom1, const GEOSPreparedGeometry *preparedGeom1, const GEOSGeometry *geom2,
@ -47,11 +48,12 @@ int32_t doCovers(const GEOSGeometry *geom1, const GEOSPreparedGeometry *prepared
                 bool swapped, char *res);
 int32_t doContains(const GEOSGeometry *geom1, const GEOSPreparedGeometry *preparedGeom1, const GEOSGeometry *geom2,
                   bool swapped, char *res);
-int32_t doContainsProperly(const GEOSGeometry *geom1, const GEOSPreparedGeometry *preparedGeom1, const GEOSGeometry *geom2,
+int32_t doContainsProperly(const GEOSGeometry *geom1, const GEOSPreparedGeometry *preparedGeom1,
-                           bool swapped, char *res);
+                           const GEOSGeometry *geom2, bool swapped, char *res);
-int32_t readGeometry(const unsigned char *input, GEOSGeometry **outputGeom, const GEOSPreparedGeometry **outputPreparedGeom);
+int32_t readGeometry(const unsigned char *input, GEOSGeometry **outputGeom,
-void destroyGeometry(GEOSGeometry **geom, const GEOSPreparedGeometry **preparedGeom);
+                     const GEOSPreparedGeometry **outputPreparedGeom);
 void    destroyGeometry(GEOSGeometry **geom, const GEOSPreparedGeometry **preparedGeom);
 #ifdef __cplusplus
 }
--- a/include/libs/nodes/cmdnodes.h
+++ b/include/libs/nodes/cmdnodes.h
@ -42,10 +42,11 @@ extern "C" {
 #define SHOW_CREATE_VIEW_RESULT_FIELD1_LEN (TSDB_VIEW_FNAME_LEN + 4 + VARSTR_HEADER_SIZE)
 #define SHOW_CREATE_VIEW_RESULT_FIELD2_LEN (TSDB_MAX_ALLOWED_SQL_LEN + VARSTR_HEADER_SIZE)
-#define SHOW_LOCAL_VARIABLES_RESULT_COLS       3
+#define SHOW_LOCAL_VARIABLES_RESULT_COLS       4
 #define SHOW_LOCAL_VARIABLES_RESULT_FIELD1_LEN (TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE)
-#define SHOW_LOCAL_VARIABLES_RESULT_FIELD2_LEN (TSDB_CONFIG_VALUE_LEN + VARSTR_HEADER_SIZE)
+#define SHOW_LOCAL_VARIABLES_RESULT_FIELD2_LEN (TSDB_CONFIG_PATH_LEN + VARSTR_HEADER_SIZE)
 #define SHOW_LOCAL_VARIABLES_RESULT_FIELD3_LEN (TSDB_CONFIG_SCOPE_LEN + VARSTR_HEADER_SIZE)
 #define SHOW_LOCAL_VARIABLES_RESULT_FIELD4_LEN (TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE)
 #define COMPACT_DB_RESULT_COLS       3
 #define COMPACT_DB_RESULT_FIELD1_LEN 32
@ -321,7 +322,7 @@ typedef struct SAlterDnodeStmt {
 typedef struct {
  ENodeType type;
-  char      url[TSDB_ANAL_ANODE_URL_LEN + 3];
+  char      url[TSDB_ANALYTIC_ANODE_URL_LEN + 3];
 } SCreateAnodeStmt;
 typedef struct {
--- a/include/libs/nodes/nodes.h
+++ b/include/libs/nodes/nodes.h
@ -174,6 +174,7 @@ char*   nodesGetNameFromColumnNode(SNode* pNode);
 int32_t nodesGetOutputNumFromSlotList(SNodeList* pSlots);
 void    nodesSortList(SNodeList** pList, int32_t (*)(SNode* pNode1, SNode* pNode2));
 void    destroyFuncParam(void* pFuncStruct);
 int32_t nodesListDeduplicate(SNodeList** pList);
 #ifdef __cplusplus
 }
--- a/include/libs/nodes/plannodes.h
+++ b/include/libs/nodes/plannodes.h
@ -334,7 +334,7 @@ typedef struct SWindowLogicNode {
  int64_t          windowSliding;
  SNodeList*       pTsmaSubplans;
  SNode*           pAnomalyExpr;
-  char             anomalyOpt[TSDB_ANAL_ALGO_OPTION_LEN];
+  char             anomalyOpt[TSDB_ANALYTIC_ALGO_OPTION_LEN];
 } SWindowLogicNode;
 typedef struct SFillLogicNode {
@ -740,7 +740,7 @@ typedef SCountWinodwPhysiNode SStreamCountWinodwPhysiNode;
 typedef struct SAnomalyWindowPhysiNode {
  SWindowPhysiNode window;
  SNode*           pAnomalyKey;
-  char             anomalyOpt[TSDB_ANAL_ALGO_OPTION_LEN];
+  char             anomalyOpt[TSDB_ANALYTIC_ALGO_OPTION_LEN];
 } SAnomalyWindowPhysiNode;
 typedef struct SSortPhysiNode {
--- a/include/libs/nodes/querynodes.h
+++ b/include/libs/nodes/querynodes.h
@ -351,7 +351,7 @@ typedef struct SAnomalyWindowNode {
  ENodeType type;  // QUERY_NODE_ANOMALY_WINDOW
  SNode*    pCol;  // timestamp primary key
  SNode*    pExpr;
-  char      anomalyOpt[TSDB_ANAL_ALGO_OPTION_LEN];
+  char      anomalyOpt[TSDB_ANALYTIC_ALGO_OPTION_LEN];
 } SAnomalyWindowNode;
 typedef enum EFillMode {
--- a/include/libs/stream/tstream.h
+++ b/include/libs/stream/tstream.h
@ -319,11 +319,6 @@ typedef struct SSTaskBasicInfo {
  SInterval interval;
 } SSTaskBasicInfo;
 typedef struct SStreamRetrieveReq SStreamRetrieveReq;
 typedef struct SStreamDispatchReq SStreamDispatchReq;
 typedef struct STokenBucket       STokenBucket;
 typedef struct SMetaHbInfo        SMetaHbInfo;
 typedef struct SDispatchMsgInfo {
  SStreamDispatchReq* pData;  // current dispatch data
@ -626,11 +621,11 @@ typedef struct STaskStatusEntry {
  STaskCkptInfo checkpointInfo;
 } STaskStatusEntry;
-typedef struct SNodeUpdateInfo {
+//typedef struct SNodeUpdateInfo {
-  int32_t nodeId;
+//  int32_t nodeId;
-  SEpSet  prevEp;
+//  SEpSet  prevEp;
-  SEpSet  newEp;
+//  SEpSet  newEp;
-} SNodeUpdateInfo;
+//} SNodeUpdateInfo;
 typedef struct SStreamTaskState {
  ETaskStatus state;
@ -643,6 +638,11 @@ typedef struct SCheckpointConsensusInfo {
  int64_t streamId;
 } SCheckpointConsensusInfo;
 typedef struct SCheckpointConsensusEntry {
  SRestoreCheckpointInfo req;
  int64_t                ts;
 } SCheckpointConsensusEntry;
 void    streamSetupScheduleTrigger(SStreamTask* pTask);
 // dispatch related
@ -718,6 +718,7 @@ int32_t streamTaskInitTriggerDispatchInfo(SStreamTask* pTask);
 void    streamTaskSetTriggerDispatchConfirmed(SStreamTask* pTask, int32_t vgId);
 int32_t streamTaskSendCheckpointTriggerMsg(SStreamTask* pTask, int32_t dstTaskId, int32_t downstreamNodeId,
                                           SRpcHandleInfo* pInfo, int32_t code);
 void    streamTaskSetFailedCheckpointId(SStreamTask* pTask, int64_t failedId);
 int32_t streamQueueGetNumOfItems(const SStreamQueue* pQueue);
 int32_t streamQueueGetNumOfUnAccessedItems(const SStreamQueue* pQueue);
--- a/include/util/taoserror.h
+++ b/include/util/taoserror.h
@ -491,13 +491,14 @@ int32_t  taosGetErrSize();
 #define TSDB_CODE_MND_ANODE_TOO_MANY_ALGO_TYPE  TAOS_DEF_ERROR_CODE(0, 0x0438)
 // analysis
-#define TSDB_CODE_ANAL_URL_RSP_IS_NULL          TAOS_DEF_ERROR_CODE(0, 0x0440)
+#define TSDB_CODE_ANA_URL_RSP_IS_NULL          TAOS_DEF_ERROR_CODE(0, 0x0440)
-#define TSDB_CODE_ANAL_URL_CANT_ACCESS          TAOS_DEF_ERROR_CODE(0, 0x0441)
+#define TSDB_CODE_ANA_URL_CANT_ACCESS          TAOS_DEF_ERROR_CODE(0, 0x0441)
-#define TSDB_CODE_ANAL_ALGO_NOT_FOUND           TAOS_DEF_ERROR_CODE(0, 0x0442)
+#define TSDB_CODE_ANA_ALGO_NOT_FOUND           TAOS_DEF_ERROR_CODE(0, 0x0442)
-#define TSDB_CODE_ANAL_ALGO_NOT_LOAD            TAOS_DEF_ERROR_CODE(0, 0x0443)
+#define TSDB_CODE_ANA_ALGO_NOT_LOAD            TAOS_DEF_ERROR_CODE(0, 0x0443)
-#define TSDB_CODE_ANAL_BUF_INVALID_TYPE         TAOS_DEF_ERROR_CODE(0, 0x0444)
+#define TSDB_CODE_ANA_BUF_INVALID_TYPE         TAOS_DEF_ERROR_CODE(0, 0x0444)
-#define TSDB_CODE_ANAL_ANODE_RETURN_ERROR       TAOS_DEF_ERROR_CODE(0, 0x0445)
+#define TSDB_CODE_ANA_ANODE_RETURN_ERROR       TAOS_DEF_ERROR_CODE(0, 0x0445)
-#define TSDB_CODE_ANAL_ANODE_TOO_MANY_ROWS      TAOS_DEF_ERROR_CODE(0, 0x0446)
+#define TSDB_CODE_ANA_ANODE_TOO_MANY_ROWS      TAOS_DEF_ERROR_CODE(0, 0x0446)
 #define TSDB_CODE_ANA_WN_DATA                  TAOS_DEF_ERROR_CODE(0, 0x0447)
 // mnode-sma
 #define TSDB_CODE_MND_SMA_ALREADY_EXIST         TAOS_DEF_ERROR_CODE(0, 0x0480)
@ -1011,6 +1012,7 @@ int32_t  taosGetErrSize();
 #define TSDB_CODE_STREAM_CONFLICT_EVENT          TAOS_DEF_ERROR_CODE(0, 0x4106)
 #define TSDB_CODE_STREAM_INTERNAL_ERROR          TAOS_DEF_ERROR_CODE(0, 0x4107)
 #define TSDB_CODE_STREAM_INPUTQ_FULL             TAOS_DEF_ERROR_CODE(0, 0x4108)
 #define TSDB_CODE_STREAM_INVLD_CHKPT             TAOS_DEF_ERROR_CODE(0, 0x4109)
 // TDLite
 #define TSDB_CODE_TDLITE_IVLD_OPEN_FLAGS         TAOS_DEF_ERROR_CODE(0, 0x5100)
--- a/include/util/tbuffer.inc
+++ b/include/util/tbuffer.inc
@ -186,11 +186,25 @@ static int32_t tBufferGetI16(SBufferReader *reader, int16_t *value) {
 }
 static int32_t tBufferGetI32(SBufferReader *reader, int32_t *value) {
-  return tBufferGet(reader, sizeof(*value), value);
+  if (reader->offset + sizeof(int32_t) > reader->buffer->size) {
    return TSDB_CODE_OUT_OF_RANGE;
  }
  if (value) {
    *value = *(int32_t*)BR_PTR(reader);
  }
  reader->offset += sizeof(int32_t);
  return 0;
 }
 static int32_t tBufferGetI64(SBufferReader *reader, int64_t *value) {
-  return tBufferGet(reader, sizeof(*value), value);
+  if (reader->offset + sizeof(int64_t) > reader->buffer->size) {
    return TSDB_CODE_OUT_OF_RANGE;
  }
  if (value) {
    *value = *(int64_t*)BR_PTR(reader);
  }
  reader->offset += sizeof(int64_t);
  return 0;
 }
 static int32_t tBufferGetU8(SBufferReader *reader, uint8_t *value) { return tBufferGet(reader, sizeof(*value), value); }
--- a/include/util/tdef.h
+++ b/include/util/tdef.h
@ -195,9 +195,9 @@ static const EOperatorType OPERATOR_ARRAY[] = {
  OP_TYPE_MULTI,
  OP_TYPE_DIV,
  OP_TYPE_REM,
-  
+
  OP_TYPE_MINUS,
-  
+
  OP_TYPE_BIT_AND,
  OP_TYPE_BIT_OR,
@ -213,7 +213,7 @@ static const EOperatorType OPERATOR_ARRAY[] = {
  OP_TYPE_NOT_LIKE,
  OP_TYPE_MATCH,
  OP_TYPE_NMATCH,
-  
+
  OP_TYPE_IS_NULL,
  OP_TYPE_IS_NOT_NULL,
  OP_TYPE_IS_TRUE,
@ -222,7 +222,7 @@ static const EOperatorType OPERATOR_ARRAY[] = {
  OP_TYPE_IS_NOT_TRUE,
  OP_TYPE_IS_NOT_FALSE,
  OP_TYPE_IS_NOT_UNKNOWN,
-  //OP_TYPE_COMPARE_MAX_VALUE, 
+  //OP_TYPE_COMPARE_MAX_VALUE,
  OP_TYPE_JSON_GET_VALUE,
  OP_TYPE_JSON_CONTAINS,
@ -335,12 +335,13 @@ typedef enum ELogicConditionType {
 #define TSDB_SLOW_QUERY_SQL_LEN   512
 #define TSDB_SHOW_SUBQUERY_LEN    1000
 #define TSDB_LOG_VAR_LEN          32
-#define TSDB_ANAL_ANODE_URL_LEN   128
+
-#define TSDB_ANAL_ALGO_NAME_LEN   64
+#define TSDB_ANALYTIC_ANODE_URL_LEN   128
-#define TSDB_ANAL_ALGO_TYPE_LEN   24
+#define TSDB_ANALYTIC_ALGO_NAME_LEN   64
-#define TSDB_ANAL_ALGO_KEY_LEN    (TSDB_ANAL_ALGO_NAME_LEN + 9)
+#define TSDB_ANALYTIC_ALGO_TYPE_LEN   24
-#define TSDB_ANAL_ALGO_URL_LEN    (TSDB_ANAL_ANODE_URL_LEN + TSDB_ANAL_ALGO_TYPE_LEN + 1)
+#define TSDB_ANALYTIC_ALGO_KEY_LEN    (TSDB_ANALYTIC_ALGO_NAME_LEN + 9)
-#define TSDB_ANAL_ALGO_OPTION_LEN 256
+#define TSDB_ANALYTIC_ALGO_URL_LEN    (TSDB_ANALYTIC_ANODE_URL_LEN + TSDB_ANALYTIC_ALGO_TYPE_LEN + 1)
 #define TSDB_ANALYTIC_ALGO_OPTION_LEN 256
 #define TSDB_MAX_EP_NUM 10
@ -620,6 +621,16 @@ enum {
 enum { RAND_ERR_MEMORY = 1, RAND_ERR_FILE = 2, RAND_ERR_NETWORK = 4 };
 /**
 * RB: return before
 * RA: return after
 * NR: not return, skip and go on following steps
 */
 #define TSDB_BYPASS_RB_RPC_SEND_SUBMIT 0x01u
 #define TSDB_BYPASS_RA_RPC_RECV_SUBMIT 0x02u
 #define TSDB_BYPASS_RB_TSDB_WRITE_MEM  0x04u
 #define TSDB_BYPASS_RB_TSDB_COMMIT     0x08u
 #define DEFAULT_HANDLE 0
 #define MNODE_HANDLE   1
 #define QNODE_HANDLE   -1
@ -631,6 +642,8 @@ enum { RAND_ERR_MEMORY = 1, RAND_ERR_FILE = 2, RAND_ERR_NETWORK = 4 };
 #define TSDB_CONFIG_VALUE_LEN  64
 #define TSDB_CONFIG_SCOPE_LEN  8
 #define TSDB_CONFIG_NUMBER     16
 #define TSDB_CONFIG_PATH_LEN   4096
 #define TSDB_CONFIG_INFO_LEN   64
 #define QUERY_ID_SIZE      20
 #define QUERY_OBJ_ID_SIZE  18
--- a/source/client/CMakeLists.txt
+++ b/source/client/CMakeLists.txt
@ -5,24 +5,24 @@ if(TD_ENTERPRISE)
 endif()
 if(TD_WINDOWS)
-    add_library(taos SHARED ${CLIENT_SRC} ${CMAKE_CURRENT_SOURCE_DIR}/src/taos.rc.in)
+    add_library(${TAOS_LIB} SHARED ${CLIENT_SRC} ${CMAKE_CURRENT_SOURCE_DIR}/src/taos.rc.in)
 else()
-    add_library(taos SHARED ${CLIENT_SRC})
+    add_library(${TAOS_LIB} SHARED ${CLIENT_SRC})
 endif()
 if(${TD_DARWIN})
-    target_compile_options(taos PRIVATE -Wno-error=deprecated-non-prototype)
+    target_compile_options(${TAOS_LIB} PRIVATE -Wno-error=deprecated-non-prototype)
 endif()
 INCLUDE_DIRECTORIES(jni)
 target_include_directories(
-    taos
+    ${TAOS_LIB}
    PUBLIC "${TD_SOURCE_DIR}/include/client"
    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
 target_link_libraries(
-    taos
+    ${TAOS_LIB}
    INTERFACE api
    PRIVATE os util common transport monitor nodes parser command planner catalog scheduler function qcom geometry
 )
@ -36,32 +36,32 @@ else()
 endif()
 set_target_properties(
-    taos
+    ${TAOS_LIB}
    PROPERTIES
    CLEAN_DIRECT_OUTPUT
    1
 )
 set_target_properties(
-    taos
+    ${TAOS_LIB}
    PROPERTIES
    VERSION ${TD_VER_NUMBER}
    SOVERSION 1
 )
-add_library(taos_static STATIC ${CLIENT_SRC})
+add_library(${TAOS_LIB_STATIC} STATIC ${CLIENT_SRC})
 if(${TD_DARWIN})
-    target_compile_options(taos_static PRIVATE -Wno-error=deprecated-non-prototype)
+    target_compile_options(${TAOS_LIB_STATIC} PRIVATE -Wno-error=deprecated-non-prototype)
 endif()
 target_include_directories(
-    taos_static
+    ${TAOS_LIB_STATIC}
    PUBLIC "${TD_SOURCE_DIR}/include/client"
    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
 target_link_libraries(
-    taos_static
+    ${TAOS_LIB_STATIC}
    INTERFACE api
    PRIVATE os util common transport monitor nodes parser command planner catalog scheduler function qcom geometry
 )
--- a/source/client/inc/clientInt.h
+++ b/source/client/inc/clientInt.h
@ -47,10 +47,11 @@ enum {
  RES_TYPE__TMQ_BATCH_META,
 };
-#define SHOW_VARIABLES_RESULT_COLS       3
+#define SHOW_VARIABLES_RESULT_COLS       4
 #define SHOW_VARIABLES_RESULT_FIELD1_LEN (TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE)
 #define SHOW_VARIABLES_RESULT_FIELD2_LEN (TSDB_CONFIG_VALUE_LEN + VARSTR_HEADER_SIZE)
 #define SHOW_VARIABLES_RESULT_FIELD3_LEN (TSDB_CONFIG_SCOPE_LEN + VARSTR_HEADER_SIZE)
 #define SHOW_VARIABLES_RESULT_FIELD4_LEN (TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE)
 #define TD_RES_QUERY(res)          (*(int8_t*)(res) == RES_TYPE__QUERY)
 #define TD_RES_TMQ(res)            (*(int8_t*)(res) == RES_TYPE__TMQ)
--- a/source/client/src/clientImpl.c
+++ b/source/client/src/clientImpl.c
@ -1816,7 +1816,7 @@ int32_t doProcessMsgFromServerImpl(SRpcMsg* pMsg, SEpSet* pEpSet) {
                  .handleRefId = pMsg->info.refId,
                  .pEpSet = pEpSet};
-  if (pMsg->contLen > 0) {
+  if (pMsg->code != TSDB_CODE_OUT_OF_MEMORY && pMsg->contLen > 0) {
    buf.pData = taosMemoryCalloc(1, pMsg->contLen);
    if (buf.pData == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
@ -2211,7 +2211,7 @@ static int32_t estimateJsonLen(SReqResultInfo* pResultInfo) {
 static int32_t doConvertJson(SReqResultInfo* pResultInfo) {
  int32_t numOfRows = pResultInfo->numOfRows;
  int32_t numOfCols = pResultInfo->numOfCols;
-  bool needConvert = false;
+  bool    needConvert = false;
  for (int32_t i = 0; i < numOfCols; ++i) {
    if (pResultInfo->fields[i].type == TSDB_DATA_TYPE_JSON) {
      needConvert = true;
@ -2400,8 +2400,8 @@ int32_t setResultDataPtr(SReqResultInfo* pResultInfo, bool convertUcs4) {
  p += sizeof(int32_t);
  if (rows != pResultInfo->numOfRows || cols != pResultInfo->numOfCols) {
-    tscError("setResultDataPtr paras error:rows;%d numOfRows:%" PRId64 " cols:%d numOfCols:%d", rows, pResultInfo->numOfRows, cols,
+    tscError("setResultDataPtr paras error:rows;%d numOfRows:%" PRId64 " cols:%d numOfCols:%d", rows,
-             pResultInfo->numOfCols);
+             pResultInfo->numOfRows, cols, pResultInfo->numOfCols);
    return TSDB_CODE_TSC_INTERNAL_ERROR;
  }
@ -2577,8 +2577,7 @@ int32_t setQueryResultFromRsp(SReqResultInfo* pResultInfo, const SRetrieveTableR
  // TODO handle the compressed case
  pResultInfo->totalRows += pResultInfo->numOfRows;
-  int32_t code =
+  int32_t code = setResultDataPtr(pResultInfo, convertUcs4);
      setResultDataPtr(pResultInfo, convertUcs4);
  return code;
 }
@ -3032,13 +3031,13 @@ static void fetchCallback(void* pResult, void* param, int32_t code) {
  if (code != TSDB_CODE_SUCCESS) {
    pRequest->code = code;
    taosMemoryFreeClear(pResultInfo->pData);
-    pRequest->body.fetchFp(((SSyncQueryParam*)pRequest->body.interParam)->userParam, pRequest, 0);
+    pRequest->body.fetchFp(((SSyncQueryParam*)pRequest->body.interParam)->userParam, pRequest, code);
    return;
  }
  if (pRequest->code != TSDB_CODE_SUCCESS) {
    taosMemoryFreeClear(pResultInfo->pData);
-    pRequest->body.fetchFp(((SSyncQueryParam*)pRequest->body.interParam)->userParam, pRequest, 0);
+    pRequest->body.fetchFp(((SSyncQueryParam*)pRequest->body.interParam)->userParam, pRequest, pRequest->code);
    return;
  }
--- a/source/client/src/clientMsgHandler.c
+++ b/source/client/src/clientMsgHandler.c
@ -541,6 +541,10 @@ static int32_t buildShowVariablesBlock(SArray* pVars, SSDataBlock** block) {
  infoData.info.bytes = SHOW_VARIABLES_RESULT_FIELD3_LEN;
  TSDB_CHECK_NULL(taosArrayPush(pBlock->pDataBlock, &infoData), code, line, END, terrno);
  infoData.info.type = TSDB_DATA_TYPE_VARCHAR;
  infoData.info.bytes = SHOW_VARIABLES_RESULT_FIELD4_LEN;
  TSDB_CHECK_NULL(taosArrayPush(pBlock->pDataBlock, &infoData), code, line, END, terrno);
  int32_t numOfCfg = taosArrayGetSize(pVars);
  code = blockDataEnsureCapacity(pBlock, numOfCfg);
  TSDB_CHECK_CODE(code, line, END);
@ -569,6 +573,13 @@ static int32_t buildShowVariablesBlock(SArray* pVars, SSDataBlock** block) {
    TSDB_CHECK_NULL(pColInfo, code, line, END, terrno);
    code = colDataSetVal(pColInfo, i, scope, false);
    TSDB_CHECK_CODE(code, line, END);
    char info[TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE] = {0};
    STR_WITH_MAXSIZE_TO_VARSTR(info, pInfo->info, TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE);
    pColInfo = taosArrayGet(pBlock->pDataBlock, c++);
    TSDB_CHECK_NULL(pColInfo, code, line, END, terrno);
    code = colDataSetVal(pColInfo, i, info, false);
    TSDB_CHECK_CODE(code, line, END);
  }
  pBlock->info.rows = numOfCfg;
@ -825,7 +836,7 @@ int32_t processCompactDbRsp(void* param, SDataBuf* pMsg, int32_t code) {
      tscError("failed to post semaphore");
    }
  }
-  return code;  
+  return code;
 }
 __async_send_cb_fn_t getMsgRspHandle(int32_t msgType) {
@ -845,7 +856,7 @@ __async_send_cb_fn_t getMsgRspHandle(int32_t msgType) {
    case TDMT_MND_SHOW_VARIABLES:
      return processShowVariablesRsp;
    case TDMT_MND_COMPACT_DB:
-      return processCompactDbRsp;  
+      return processCompactDbRsp;
    default:
      return genericRspCallback;
  }
--- a/source/client/src/clientTmq.c
+++ b/source/client/src/clientTmq.c
@ -1872,13 +1872,17 @@ int32_t tmq_subscribe(tmq_t* tmq, const tmq_list_t* topic_list) {
  if (tmq->epTimer == NULL){
    tmq->epTimer = taosTmrStart(tmqAssignAskEpTask, DEFAULT_ASKEP_INTERVAL, (void*)(tmq->refId), tmqMgmt.timer);
    if (tmq->epTimer == NULL) {
      code = TSDB_CODE_TSC_INTERNAL_ERROR;
      goto END;
    }
  }
-  if (tmq->commitTimer == NULL){
+  if (tmq->autoCommit && tmq->commitTimer == NULL){
    tmq->commitTimer = taosTmrStart(tmqAssignDelayedCommitTask, tmq->autoCommitInterval, (void*)(tmq->refId), tmqMgmt.timer);
-  }
+    if (tmq->commitTimer == NULL) {
-  if (tmq->epTimer == NULL || tmq->commitTimer == NULL) {
+      code = TSDB_CODE_TSC_INTERNAL_ERROR;
-    code = TSDB_CODE_TSC_INTERNAL_ERROR;
+      goto END;
-    goto END;
+    }
  }
 END:
--- a/source/client/test/CMakeLists.txt
+++ b/source/client/test/CMakeLists.txt
@ -8,31 +8,31 @@ AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SOURCE_LIST)
 ADD_EXECUTABLE(clientTest clientTests.cpp)
 TARGET_LINK_LIBRARIES(
        clientTest
-        os util common transport parser catalog scheduler gtest taos_static qcom executor function
+        os util common transport parser catalog scheduler gtest ${TAOS_LIB_STATIC} qcom executor function
 )
 ADD_EXECUTABLE(tmqTest tmqTest.cpp)
 TARGET_LINK_LIBRARIES(
        tmqTest
-        PUBLIC os util common transport parser catalog scheduler function gtest taos_static qcom
+        PUBLIC os util common transport parser catalog scheduler function gtest ${TAOS_LIB_STATIC} qcom
 )
 ADD_EXECUTABLE(smlTest smlTest.cpp)
 TARGET_LINK_LIBRARIES(
        smlTest
-        PUBLIC os util common transport parser catalog scheduler function gtest taos_static qcom geometry
+        PUBLIC os util common transport parser catalog scheduler function gtest ${TAOS_LIB_STATIC} qcom geometry
 )
 #ADD_EXECUTABLE(clientMonitorTest clientMonitorTests.cpp)
 #TARGET_LINK_LIBRARIES(
 #        clientMonitorTest
-#        PUBLIC os util common transport monitor parser catalog scheduler function gtest taos_static qcom executor
+#        PUBLIC os util common transport monitor parser catalog scheduler function gtest ${TAOS_LIB_STATIC} qcom executor
 #)
 ADD_EXECUTABLE(userOperTest ../../../tests/script/api/passwdTest.c)
 TARGET_LINK_LIBRARIES(
        userOperTest
-        PUBLIC taos
+        PUBLIC ${TAOS_LIB}
 )
 TARGET_INCLUDE_DIRECTORIES(
--- a/source/common/CMakeLists.txt
+++ b/source/common/CMakeLists.txt
@ -1,4 +1,7 @@
 aux_source_directory(src COMMON_SRC)
 aux_source_directory(src/msg COMMON_MSG_SRC)
 LIST(APPEND COMMON_SRC ${COMMON_MSG_SRC})
 if(TD_ENTERPRISE)
  LIST(APPEND COMMON_SRC ${TD_ENTERPRISE_DIR}/src/plugins/common/src/tglobal.c)
--- a/source/libs/stream/src/streamMsg.c
+++ b/source/libs/stream/src/streamMsg.c
@ -15,8 +15,48 @@
 #include "streamMsg.h"
 #include "os.h"
-#include "tstream.h"
+#include "tcommon.h"
-#include "streamInt.h"
+
 typedef struct STaskId {
  int64_t streamId;
  int64_t taskId;
 } STaskId;
 typedef struct STaskCkptInfo {
  int64_t latestId;          // saved checkpoint id
  int64_t latestVer;         // saved checkpoint ver
  int64_t latestTime;        // latest checkpoint time
  int64_t latestSize;        // latest checkpoint size
  int8_t  remoteBackup;      // latest checkpoint backup done
  int64_t activeId;          // current active checkpoint id
  int32_t activeTransId;     // checkpoint trans id
  int8_t  failed;            // denote if the checkpoint is failed or not
  int8_t  consensusChkptId;  // required the consensus-checkpointId
  int64_t consensusTs;       //
 } STaskCkptInfo;
 typedef struct STaskStatusEntry {
  STaskId       id;
  int32_t       status;
  int32_t       statusLastDuration;  // to record the last duration of current status
  int64_t       stage;
  int32_t       nodeId;
  SVersionRange verRange;      // start/end version in WAL, only valid for source task
  int64_t       processedVer;  // only valid for source task
  double        inputQUsed;    // in MiB
  double        inputRate;
  double        procsThroughput;   // duration between one element put into input queue and being processed.
  double        procsTotal;        // duration between one element put into input queue and being processed.
  double        outputThroughput;  // the size of dispatched result blocks in bytes
  double        outputTotal;       // the size of dispatched result blocks in bytes
  double        sinkQuota;         // existed quota size for sink task
  double        sinkDataSize;      // sink to dst data size
  int64_t       startTime;
  int64_t       startCheckpointId;
  int64_t       startCheckpointVer;
  int64_t       hTaskId;
  STaskCkptInfo checkpointInfo;
 } STaskStatusEntry;
 int32_t tEncodeStreamEpInfo(SEncoder* pEncoder, const SStreamUpstreamEpInfo* pInfo) {
  TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pInfo->taskId));
@ -289,7 +329,7 @@ int32_t tEncodeStreamDispatchReq(SEncoder* pEncoder, const SStreamDispatchReq* p
  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pReq->totalLen));
  if (taosArrayGetSize(pReq->data) != pReq->blockNum || taosArrayGetSize(pReq->dataLen) != pReq->blockNum) {
-    stError("invalid dispatch req msg");
+    uError("invalid dispatch req msg");
    TAOS_CHECK_EXIT(TSDB_CODE_INVALID_MSG);
  }
@ -605,173 +645,92 @@ void tCleanupStreamHbMsg(SStreamHbMsg* pMsg) {
  pMsg->numOfTasks = -1;
 }
-int32_t tEncodeStreamTask(SEncoder* pEncoder, const SStreamTask* pTask) {
+int32_t tEncodeStreamHbRsp(SEncoder* pEncoder, const SMStreamHbRspMsg* pRsp) {
  int32_t code = 0;
  int32_t lino;
  TAOS_CHECK_EXIT(tStartEncode(pEncoder));
-  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pTask->ver));
+  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pRsp->msgId));
  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pTask->id.streamId));
  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->id.taskId));
  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->info.trigger));
  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pTask->info.taskLevel));
  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pTask->outputInfo.type));
  TAOS_CHECK_EXIT(tEncodeI16(pEncoder, pTask->msgInfo.msgType));
  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pTask->status.taskStatus));
  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pTask->status.schedStatus));
  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->info.selfChildId));
  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->info.nodeId));
  TAOS_CHECK_EXIT(tEncodeSEpSet(pEncoder, &pTask->info.epSet));
  TAOS_CHECK_EXIT(tEncodeSEpSet(pEncoder, &pTask->info.mnodeEpset));
  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pTask->chkInfo.checkpointId));
  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pTask->chkInfo.checkpointVer));
  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pTask->info.fillHistory));
  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pTask->hTaskInfo.id.streamId));
  int32_t taskId = pTask->hTaskInfo.id.taskId;
  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, taskId));
  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pTask->streamTaskId.streamId));
  taskId = pTask->streamTaskId.taskId;
  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, taskId));
  TAOS_CHECK_EXIT(tEncodeU64(pEncoder, pTask->dataRange.range.minVer));
  TAOS_CHECK_EXIT(tEncodeU64(pEncoder, pTask->dataRange.range.maxVer));
  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pTask->dataRange.window.skey));
  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pTask->dataRange.window.ekey));
  int32_t epSz = taosArrayGetSize(pTask->upstreamInfo.pList);
  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, epSz));
  for (int32_t i = 0; i < epSz; i++) {
    SStreamUpstreamEpInfo* pInfo = taosArrayGetP(pTask->upstreamInfo.pList, i);
    TAOS_CHECK_EXIT(tEncodeStreamEpInfo(pEncoder, pInfo));
  }
  if (pTask->info.taskLevel != TASK_LEVEL__SINK) {
    TAOS_CHECK_EXIT(tEncodeCStr(pEncoder, pTask->exec.qmsg));
  }
  if (pTask->outputInfo.type == TASK_OUTPUT__TABLE) {
    TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pTask->outputInfo.tbSink.stbUid));
    TAOS_CHECK_EXIT(tEncodeCStr(pEncoder, pTask->outputInfo.tbSink.stbFullName));
    TAOS_CHECK_EXIT(tEncodeSSchemaWrapper(pEncoder, pTask->outputInfo.tbSink.pSchemaWrapper));
  } else if (pTask->outputInfo.type == TASK_OUTPUT__SMA) {
    TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pTask->outputInfo.smaSink.smaId));
  } else if (pTask->outputInfo.type == TASK_OUTPUT__FETCH) {
    TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pTask->outputInfo.fetchSink.reserved));
  } else if (pTask->outputInfo.type == TASK_OUTPUT__FIXED_DISPATCH) {
    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->outputInfo.fixedDispatcher.taskId));
    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->outputInfo.fixedDispatcher.nodeId));
    TAOS_CHECK_EXIT(tEncodeSEpSet(pEncoder, &pTask->outputInfo.fixedDispatcher.epSet));
  } else if (pTask->outputInfo.type == TASK_OUTPUT__SHUFFLE_DISPATCH) {
    TAOS_CHECK_EXIT(tSerializeSUseDbRspImp(pEncoder, &pTask->outputInfo.shuffleDispatcher.dbInfo));
    TAOS_CHECK_EXIT(tEncodeCStr(pEncoder, pTask->outputInfo.shuffleDispatcher.stbFullName));
  }
  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pTask->info.delaySchedParam));
  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pTask->subtableWithoutMd5));
  TAOS_CHECK_EXIT(tEncodeCStrWithLen(pEncoder, pTask->reserve, sizeof(pTask->reserve) - 1));
  tEndEncode(pEncoder);
 _exit:
  return code;
 }
-int32_t tDecodeStreamTask(SDecoder* pDecoder, SStreamTask* pTask) {
+int32_t tDecodeStreamHbRsp(SDecoder* pDecoder, SMStreamHbRspMsg* pRsp) {
  int32_t taskId = 0;
  int32_t code = 0;
  int32_t lino;
  TAOS_CHECK_EXIT(tStartDecode(pDecoder));
-  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pTask->ver));
+  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pRsp->msgId));
-  if (pTask->ver <= SSTREAM_TASK_INCOMPATIBLE_VER || pTask->ver > SSTREAM_TASK_VER) {
+  tEndDecode(pDecoder);
    TAOS_CHECK_EXIT(TSDB_CODE_INVALID_MSG);
  }
-  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pTask->id.streamId));
+_exit:
-  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pTask->id.taskId));
+  return code;
-  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pTask->info.trigger));
+}
  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pTask->info.taskLevel));
  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pTask->outputInfo.type));
  TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pTask->msgInfo.msgType));
-  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pTask->status.taskStatus));
+int32_t tEncodeRetrieveChkptTriggerReq(SEncoder* pEncoder, const SRetrieveChkptTriggerReq* pReq) {
-  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pTask->status.schedStatus));
+  int32_t code = 0;
  int32_t lino;
-  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pTask->info.selfChildId));
+  TAOS_CHECK_EXIT(tStartEncode(pEncoder));
-  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pTask->info.nodeId));
+  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pReq->streamId));
-  TAOS_CHECK_EXIT(tDecodeSEpSet(pDecoder, &pTask->info.epSet));
+  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pReq->checkpointId));
-  TAOS_CHECK_EXIT(tDecodeSEpSet(pDecoder, &pTask->info.mnodeEpset));
+  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->upstreamNodeId));
  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->upstreamTaskId));
  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->downstreamNodeId));
  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pReq->downstreamTaskId));
  tEndEncode(pEncoder);
-  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pTask->chkInfo.checkpointId));
+_exit:
-  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pTask->chkInfo.checkpointVer));
+  return code;
-  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pTask->info.fillHistory));
+}
-  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pTask->hTaskInfo.id.streamId));
+int32_t tDecodeRetrieveChkptTriggerReq(SDecoder* pDecoder, SRetrieveChkptTriggerReq* pReq) {
-  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &taskId));
+  int32_t code = 0;
-  pTask->hTaskInfo.id.taskId = taskId;
+  int32_t lino;
-  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pTask->streamTaskId.streamId));
+  TAOS_CHECK_EXIT(tStartDecode(pDecoder));
-  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &taskId));
+  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->streamId));
-  pTask->streamTaskId.taskId = taskId;
+  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->checkpointId));
  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->upstreamNodeId));
  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->upstreamTaskId));
  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->downstreamNodeId));
  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->downstreamTaskId));
  tEndDecode(pDecoder);
-  TAOS_CHECK_EXIT(tDecodeU64(pDecoder, (uint64_t*)&pTask->dataRange.range.minVer));
+_exit:
-  TAOS_CHECK_EXIT(tDecodeU64(pDecoder, (uint64_t*)&pTask->dataRange.range.maxVer));
+  return code;
-  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pTask->dataRange.window.skey));
+}
  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pTask->dataRange.window.ekey));
-  int32_t epSz = -1;
+int32_t tEncodeCheckpointTriggerRsp(SEncoder* pEncoder, const SCheckpointTriggerRsp* pRsp) {
-  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &epSz) < 0);
+  int32_t code = 0;
  int32_t lino;
-  if ((pTask->upstreamInfo.pList = taosArrayInit(epSz, POINTER_BYTES)) == NULL) {
+  TAOS_CHECK_EXIT(tStartEncode(pEncoder));
-    TAOS_CHECK_EXIT(terrno);
+  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pRsp->streamId));
-  }
+  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pRsp->checkpointId));
-  for (int32_t i = 0; i < epSz; i++) {
+  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pRsp->upstreamTaskId));
-    SStreamUpstreamEpInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamUpstreamEpInfo));
+  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pRsp->taskId));
-    if (pInfo == NULL) {
+  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pRsp->transId));
-      TAOS_CHECK_EXIT(terrno);
+  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pRsp->rspCode));
-    }
+  tEndEncode(pEncoder);
    if ((code = tDecodeStreamEpInfo(pDecoder, pInfo)) < 0) {
      taosMemoryFreeClear(pInfo);
      goto _exit;
    }
    if (taosArrayPush(pTask->upstreamInfo.pList, &pInfo) == NULL) {
      TAOS_CHECK_EXIT(terrno);
    }
  }
-  if (pTask->info.taskLevel != TASK_LEVEL__SINK) {
+_exit:
-    TAOS_CHECK_EXIT(tDecodeCStrAlloc(pDecoder, &pTask->exec.qmsg));
+  return code;
-  }
+}
-  if (pTask->outputInfo.type == TASK_OUTPUT__TABLE) {
+int32_t tDecodeCheckpointTriggerRsp(SDecoder* pDecoder, SCheckpointTriggerRsp* pRsp) {
-    TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pTask->outputInfo.tbSink.stbUid));
+  int32_t code = 0;
-    TAOS_CHECK_EXIT(tDecodeCStrTo(pDecoder, pTask->outputInfo.tbSink.stbFullName));
+  int32_t lino;
    pTask->outputInfo.tbSink.pSchemaWrapper = taosMemoryCalloc(1, sizeof(SSchemaWrapper));
    if (pTask->outputInfo.tbSink.pSchemaWrapper == NULL) {
      TAOS_CHECK_EXIT(terrno);
    }
    TAOS_CHECK_EXIT(tDecodeSSchemaWrapper(pDecoder, pTask->outputInfo.tbSink.pSchemaWrapper));
  } else if (pTask->outputInfo.type == TASK_OUTPUT__SMA) {
    TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pTask->outputInfo.smaSink.smaId));
  } else if (pTask->outputInfo.type == TASK_OUTPUT__FETCH) {
    TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pTask->outputInfo.fetchSink.reserved));
  } else if (pTask->outputInfo.type == TASK_OUTPUT__FIXED_DISPATCH) {
    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pTask->outputInfo.fixedDispatcher.taskId));
    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pTask->outputInfo.fixedDispatcher.nodeId));
    TAOS_CHECK_EXIT(tDecodeSEpSet(pDecoder, &pTask->outputInfo.fixedDispatcher.epSet));
  } else if (pTask->outputInfo.type == TASK_OUTPUT__SHUFFLE_DISPATCH) {
    TAOS_CHECK_EXIT(tDeserializeSUseDbRspImp(pDecoder, &pTask->outputInfo.shuffleDispatcher.dbInfo));
    TAOS_CHECK_EXIT(tDecodeCStrTo(pDecoder, pTask->outputInfo.shuffleDispatcher.stbFullName));
  }
  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pTask->info.delaySchedParam));
  if (pTask->ver >= SSTREAM_TASK_SUBTABLE_CHANGED_VER) {
    TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pTask->subtableWithoutMd5));
  }
  TAOS_CHECK_EXIT(tDecodeCStrTo(pDecoder, pTask->reserve));
  TAOS_CHECK_EXIT(tStartDecode(pDecoder));
  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pRsp->streamId));
  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pRsp->checkpointId));
  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pRsp->upstreamTaskId));
  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pRsp->taskId));
  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pRsp->transId));
  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pRsp->rspCode));
  tEndDecode(pDecoder);
 _exit:
@ -830,11 +789,7 @@ int32_t tEncodeRestoreCheckpointInfo(SEncoder* pEncoder, const SRestoreCheckpoin
  tEndEncode(pEncoder);
 _exit:
-  if (code) {
+  return code;
    return code;
  } else {
    return pEncoder->pos;
  }
 }
 int32_t tDecodeRestoreCheckpointInfo(SDecoder* pDecoder, SRestoreCheckpointInfo* pReq) {
@ -853,3 +808,31 @@ int32_t tDecodeRestoreCheckpointInfo(SDecoder* pDecoder, SRestoreCheckpointInfo*
 _exit:
  return code;
 }
 int32_t tEncodeStreamTaskRunReq (SEncoder* pEncoder, const SStreamTaskRunReq* pReq) {
  int32_t code = 0;
  int32_t lino;
  TAOS_CHECK_EXIT(tStartEncode(pEncoder));
  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pReq->streamId));
  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->taskId));
  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->reqType));
  tEndEncode(pEncoder);
 _exit:
  return code;
 }
 int32_t tDecodeStreamTaskRunReq(SDecoder* pDecoder, SStreamTaskRunReq* pReq) {
  int32_t code = 0;
  int32_t lino;
  TAOS_CHECK_EXIT(tStartDecode(pDecoder));
  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->streamId));
  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->taskId));
  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->reqType));
  tEndDecode(pDecoder);
 _exit:
  return code;
 }
--- a/source/common/src/msg/tmsg.c
+++ b/source/common/src/msg/tmsg.c
@ -2169,7 +2169,7 @@ int32_t tSerializeRetrieveAnalAlgoRsp(void *buf, int32_t bufLen, SRetrieveAnalAl
    SAnalyticsUrl   *pUrl = pIter;
    size_t      nameLen = 0;
    const char *name = taosHashGetKey(pIter, &nameLen);
-    if (nameLen > 0 && nameLen <= TSDB_ANAL_ALGO_KEY_LEN && pUrl->urlLen > 0) {
+    if (nameLen > 0 && nameLen <= TSDB_ANALYTIC_ALGO_KEY_LEN && pUrl->urlLen > 0) {
      numOfAlgos++;
    }
    pIter = taosHashIterate(pRsp->hash, pIter);
@ -2224,7 +2224,7 @@ int32_t tDeserializeRetrieveAnalAlgoRsp(void *buf, int32_t bufLen, SRetrieveAnal
  int32_t      numOfAlgos = 0;
  int32_t      nameLen;
  int32_t      type;
-  char         name[TSDB_ANAL_ALGO_KEY_LEN];
+  char         name[TSDB_ANALYTIC_ALGO_KEY_LEN];
  SAnalyticsUrl url = {0};
  TAOS_CHECK_EXIT(tStartDecode(&decoder));
@ -2233,7 +2233,7 @@ int32_t tDeserializeRetrieveAnalAlgoRsp(void *buf, int32_t bufLen, SRetrieveAnal
  for (int32_t f = 0; f < numOfAlgos; ++f) {
    TAOS_CHECK_EXIT(tDecodeI32(&decoder, &nameLen));
-    if (nameLen > 0 && nameLen <= TSDB_ANAL_ALGO_NAME_LEN) {
+    if (nameLen > 0 && nameLen <= TSDB_ANALYTIC_ALGO_NAME_LEN) {
      TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, name));
    }
@ -5642,6 +5642,12 @@ int32_t tSerializeSShowVariablesRsp(void *buf, int32_t bufLen, SShowVariablesRsp
    SVariablesInfo *pInfo = taosArrayGet(pRsp->variables, i);
    TAOS_CHECK_EXIT(tEncodeSVariablesInfo(&encoder, pInfo));
  }
  for (int32_t i = 0; i < varNum; ++i) {
    SVariablesInfo *pInfo = taosArrayGet(pRsp->variables, i);
    TAOS_CHECK_RETURN(tEncodeCStr(&encoder, pInfo->info));
  }
  tEndEncode(&encoder);
 _exit:
@ -5675,6 +5681,13 @@ int32_t tDeserializeSShowVariablesRsp(void *buf, int32_t bufLen, SShowVariablesR
        TAOS_CHECK_EXIT(terrno);
      }
    }
    if (!tDecodeIsEnd(&decoder)) {
      for (int32_t i = 0; i < varNum; ++i) {
        SVariablesInfo *pInfo = taosArrayGet(pRsp->variables, i);
        TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pInfo->info));
      }
    }
  }
  tEndDecode(&decoder);
--- a/source/common/src/systable.c
+++ b/source/common/src/systable.c
@ -327,8 +327,9 @@ static const SSysDbTableSchema configSchema[] = {
 static const SSysDbTableSchema variablesSchema[] = {
    {.name = "dnode_id", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = true},
    {.name = "name", .bytes = TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
-    {.name = "value", .bytes = TSDB_CONFIG_VALUE_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
+    {.name = "value", .bytes = TSDB_CONFIG_PATH_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
    {.name = "scope", .bytes = TSDB_CONFIG_SCOPE_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
    {.name = "info", .bytes = TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
 };
 static const SSysDbTableSchema topicSchema[] = {
@ -401,7 +402,7 @@ static const SSysDbTableSchema userCompactsDetailSchema[] = {
 static const SSysDbTableSchema anodesSchema[] = {
    {.name = "id", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = false},
-    {.name = "url", .bytes = TSDB_ANAL_ANODE_URL_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
+    {.name = "url", .bytes = TSDB_ANALYTIC_ANODE_URL_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
    {.name = "status", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
    {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP, .sysInfo = true},
    {.name = "update_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP, .sysInfo = true},
@ -409,8 +410,8 @@ static const SSysDbTableSchema anodesSchema[] = {
 static const SSysDbTableSchema anodesFullSchema[] = {
    {.name = "id", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = false},
-    {.name = "type", .bytes = TSDB_ANAL_ALGO_TYPE_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
+    {.name = "type", .bytes = TSDB_ANALYTIC_ALGO_TYPE_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
-    {.name = "algo", .bytes = TSDB_ANAL_ALGO_NAME_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
+    {.name = "algo", .bytes = TSDB_ANALYTIC_ALGO_NAME_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
 };
 static const SSysDbTableSchema tsmaSchema[] = {
--- a/source/common/src/tcol.c
+++ b/source/common/src/tcol.c
@ -81,26 +81,42 @@ const char* getDefaultEncodeStr(uint8_t type) { return columnEncodeStr(getDefaul
 uint16_t getDefaultCompress(uint8_t type) {
  switch (type) {
    case TSDB_DATA_TYPE_NULL:
      return TSDB_COLVAL_COMPRESS_LZ4;
    case TSDB_DATA_TYPE_BOOL:
      return TSDB_COLVAL_COMPRESS_ZSTD;
    case TSDB_DATA_TYPE_TINYINT:
    case TSDB_DATA_TYPE_SMALLINT:
      return TSDB_COLVAL_COMPRESS_ZLIB;
    case TSDB_DATA_TYPE_INT:
    case TSDB_DATA_TYPE_BIGINT:
      return TSDB_COLVAL_COMPRESS_LZ4;
    case TSDB_DATA_TYPE_FLOAT:
    case TSDB_DATA_TYPE_DOUBLE:
      return TSDB_COLVAL_COMPRESS_LZ4;
    case TSDB_DATA_TYPE_VARCHAR:  // TSDB_DATA_TYPE_BINARY
      return TSDB_COLVAL_COMPRESS_ZSTD;
    case TSDB_DATA_TYPE_TIMESTAMP:
      return TSDB_COLVAL_COMPRESS_LZ4;
    case TSDB_DATA_TYPE_NCHAR:
      return TSDB_COLVAL_COMPRESS_ZSTD;
    case TSDB_DATA_TYPE_UTINYINT:
    case TSDB_DATA_TYPE_USMALLINT:
      return TSDB_COLVAL_COMPRESS_ZLIB;
    case TSDB_DATA_TYPE_UINT:
    case TSDB_DATA_TYPE_UBIGINT:
      return TSDB_COLVAL_COMPRESS_LZ4;
    case TSDB_DATA_TYPE_JSON:
      return TSDB_COLVAL_COMPRESS_LZ4;
    case TSDB_DATA_TYPE_VARBINARY:
      return TSDB_COLVAL_COMPRESS_ZSTD;
    case TSDB_DATA_TYPE_DECIMAL:
      return TSDB_COLVAL_COMPRESS_LZ4;
    case TSDB_DATA_TYPE_BLOB:
      return TSDB_COLVAL_COMPRESS_LZ4;
    case TSDB_DATA_TYPE_MEDIUMBLOB:
      return TSDB_COLVAL_COMPRESS_LZ4;
    case TSDB_DATA_TYPE_GEOMETRY:
      return TSDB_COLVAL_COMPRESS_LZ4;
    case TSDB_DATA_TYPE_MAX:
      return TSDB_COLVAL_COMPRESS_LZ4;
    default:
--- a/source/common/src/tdataformat.c
+++ b/source/common/src/tdataformat.c
@ -3036,7 +3036,8 @@ _exit:
  return code;
 }
-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 code = 0;
  if (!(pBind->num == 1 && pBind->is_null && *pBind->is_null)) {
@ -3046,6 +3047,12 @@ int32_t tColDataAddValueByBind(SColData *pColData, TAOS_MULTI_BIND *pBind, int32
  }
  if (IS_VAR_DATA_TYPE(pColData->type)) {  // var-length data type
    if (pColData->type == TSDB_DATA_TYPE_GEOMETRY) {
      code = igeos();
      if (code) {
        return code;
      }
    }
    for (int32_t i = 0; i < pBind->num; ++i) {
      if (pBind->is_null && pBind->is_null[i]) {
        if (pColData->cflag & COL_IS_KEY) {
@ -3055,9 +3062,12 @@ int32_t tColDataAddValueByBind(SColData *pColData, TAOS_MULTI_BIND *pBind, int32
        code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NULL](pColData, NULL, 0);
        if (code) goto _exit;
      } else if (pBind->length[i] > buffMaxLen) {
-        uError("var data length too big, len:%d, max:%d", pBind->length[i], buffMaxLen);
+        return TSDB_CODE_PAR_VALUE_TOO_LONG;
        return TSDB_CODE_INVALID_PARA;
      } else {
        if (pColData->type == TSDB_DATA_TYPE_GEOMETRY) {
          code = cgeos((char *)pBind->buffer + pBind->buffer_length * i, (size_t)pBind->length[i]);
          if (code) goto _exit;
        }
        code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_VALUE](
            pColData, (uint8_t *)pBind->buffer + pBind->buffer_length * i, pBind->length[i]);
      }
@ -3108,7 +3118,8 @@ _exit:
  return code;
 }
-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) {
  int32_t code = 0;
  if (!(pBind->num == 1 && pBind->is_null && *pBind->is_null)) {
@ -3118,6 +3129,13 @@ int32_t tColDataAddValueByBind2(SColData *pColData, TAOS_STMT2_BIND *pBind, int3
  }
  if (IS_VAR_DATA_TYPE(pColData->type)) {  // var-length data type
    if (pColData->type == TSDB_DATA_TYPE_GEOMETRY) {
      code = igeos();
      if (code) {
        return code;
      }
    }
    uint8_t *buf = pBind->buffer;
    for (int32_t i = 0; i < pBind->num; ++i) {
      if (pBind->is_null && pBind->is_null[i]) {
@ -3133,9 +3151,12 @@ int32_t tColDataAddValueByBind2(SColData *pColData, TAOS_STMT2_BIND *pBind, int3
          if (code) goto _exit;
        }
      } else if (pBind->length[i] > buffMaxLen) {
-        uError("var data length too big, len:%d, max:%d", pBind->length[i], buffMaxLen);
+        return TSDB_CODE_PAR_VALUE_TOO_LONG;
        return TSDB_CODE_INVALID_PARA;
      } else {
        if (pColData->type == TSDB_DATA_TYPE_GEOMETRY) {
          code = cgeos(buf, pBind->length[i]);
          if (code) goto _exit;
        }
        code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_VALUE](pColData, buf, pBind->length[i]);
        buf += pBind->length[i];
      }
--- a/source/common/src/tglobal.c
+++ b/source/common/src/tglobal.c
@ -217,6 +217,8 @@ float   tsSelectivityRatio = 1.0;
 int32_t tsTagFilterResCacheSize = 1024 * 10;
 char    tsTagFilterCache = 0;
 int32_t tsBypassFlag = 0;
 // the maximum allowed query buffer size during query processing for each data node.
 // -1 no limit (default)
 // 0  no query allowed, queries are disabled
@ -612,6 +614,7 @@ static int32_t taosAddClientCfg(SConfig *pCfg) {
      cfgAddInt64(pCfg, "randErrorDivisor", tsRandErrDivisor, 1, INT64_MAX, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
  TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "randErrorScope", tsRandErrScope, 0, INT64_MAX, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "safetyCheckLevel", tsSafetyCheckLevel, 0, 5, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "bypassFlag", tsBypassFlag, 0, INT32_MAX, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
  tsNumOfRpcThreads = tsNumOfCores / 2;
  tsNumOfRpcThreads = TRANGE(tsNumOfRpcThreads, 1, TSDB_MAX_RPC_THREADS);
@ -1303,6 +1306,10 @@ static int32_t taosSetClientCfg(SConfig *pCfg) {
  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "safetyCheckLevel");
  tsSafetyCheckLevel = pItem->i32;
  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "bypassFlag");
  tsBypassFlag = pItem->i32;
  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
@ -2046,7 +2053,8 @@ static int32_t taosCfgDynamicOptionsForServer(SConfig *pCfg, const char *name) {
                                         {"supportVnodes", &tsNumOfSupportVnodes},
                                         {"experimental", &tsExperimental},
                                         {"maxTsmaNum", &tsMaxTsmaNum},
-                                         {"safetyCheckLevel", &tsSafetyCheckLevel}};
+                                         {"safetyCheckLevel", &tsSafetyCheckLevel},
                                         {"bypassFlag", &tsBypassFlag}};
    if ((code = taosCfgSetOption(debugOptions, tListLen(debugOptions), pItem, true)) != TSDB_CODE_SUCCESS) {
      code = taosCfgSetOption(options, tListLen(options), pItem, false);
@ -2302,7 +2310,8 @@ static int32_t taosCfgDynamicOptionsForClient(SConfig *pCfg, const char *name) {
                                         {"multiResultFunctionStarReturnTags", &tsMultiResultFunctionStarReturnTags},
                                         {"maxTsmaCalcDelay", &tsMaxTsmaCalcDelay},
                                         {"tsmaDataDeleteMark", &tsmaDataDeleteMark},
-                                         {"safetyCheckLevel", &tsSafetyCheckLevel}};
+                                         {"safetyCheckLevel", &tsSafetyCheckLevel},
                                         {"bypassFlag", &tsBypassFlag}};
    if ((code = taosCfgSetOption(debugOptions, tListLen(debugOptions), pItem, true)) != TSDB_CODE_SUCCESS) {
      code = taosCfgSetOption(options, tListLen(options), pItem, false);
--- a/source/common/src/tmisce.c
+++ b/source/common/src/tmisce.c
@ -267,7 +267,14 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
  int8_t locked = 0;
-  TAOS_CHECK_GOTO(blockDataEnsureCapacity(pBlock, cfgGetSize(pConf)), NULL, _exit);
+  size_t       exSize = 0;
  size_t       index = 0;
  SConfigItem* pDataDirItem = cfgGetItem(pConf, "dataDir");
  if (pDataDirItem) {
    exSize = TMAX(taosArrayGetSize(pDataDirItem->array), 1) - 1;
  }
  TAOS_CHECK_GOTO(blockDataEnsureCapacity(pBlock, cfgGetSize(pConf) + exSize), NULL, _exit);
  TAOS_CHECK_GOTO(cfgCreateIter(pConf, &pIter), NULL, _exit);
@ -275,6 +282,7 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
  locked = 1;
  while ((pItem = cfgNextIter(pIter)) != NULL) {
 _start:
    col = startCol;
    // GRANT_CFG_SKIP;
@ -289,9 +297,18 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, name, false), NULL, _exit);
-    char    value[TSDB_CONFIG_VALUE_LEN + VARSTR_HEADER_SIZE] = {0};
+    char    value[TSDB_CONFIG_PATH_LEN + VARSTR_HEADER_SIZE] = {0};
    int32_t valueLen = 0;
-    TAOS_CHECK_GOTO(cfgDumpItemValue(pItem, &value[VARSTR_HEADER_SIZE], TSDB_CONFIG_VALUE_LEN, &valueLen), NULL, _exit);
+    SDiskCfg* pDiskCfg = NULL;
    if (strcasecmp(pItem->name, "dataDir") == 0 && exSize > 0) {
      char*     buf = &value[VARSTR_HEADER_SIZE];
      pDiskCfg = taosArrayGet(pItem->array, index);
      valueLen = tsnprintf(buf, TSDB_CONFIG_PATH_LEN, "%s", pDiskCfg->dir);
      index++;
    } else {
      TAOS_CHECK_GOTO(cfgDumpItemValue(pItem, &value[VARSTR_HEADER_SIZE], TSDB_CONFIG_PATH_LEN, &valueLen), NULL,
                      _exit);
    }
    varDataSetLen(value, valueLen);
    pColInfo = taosArrayGet(pBlock->pDataBlock, col++);
@ -313,8 +330,28 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
    }
    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, scope, false), NULL, _exit);
    char info[TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE] = {0};
    if (strcasecmp(pItem->name, "dataDir") == 0 && pDiskCfg) {
      char* buf = &info[VARSTR_HEADER_SIZE];
      valueLen = tsnprintf(buf, TSDB_CONFIG_INFO_LEN, "level %d primary %d disabled %" PRIi8, pDiskCfg->level,
                              pDiskCfg->primary, pDiskCfg->disable);
    } else {
      valueLen = 0;
    }
    varDataSetLen(info, valueLen);
    pColInfo = taosArrayGet(pBlock->pDataBlock, col++);
    if (pColInfo == NULL) {
      code = terrno;
      TAOS_CHECK_GOTO(code, NULL, _exit);
    }
    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, info, false), NULL, _exit);
    numOfRows++;
-  }
+    if (index > 0 && index <= exSize) {
      goto _start;
    }
 }
  pBlock->info.rows = numOfRows;
 _exit:
  if (locked) cfgUnLock(pConf);
--- a/source/common/test/CMakeLists.txt
+++ b/source/common/test/CMakeLists.txt
@ -46,7 +46,7 @@ if (${TD_LINUX})
    target_sources(tmsgTest 
        PRIVATE
        "tmsgTest.cpp"
-        "../src/tmsg.c"
+        "../src/msg/tmsg.c"
    )
    target_include_directories(tmsgTest PUBLIC "${TD_SOURCE_DIR}/include/common/")
    target_link_libraries(tmsgTest PUBLIC os util gtest gtest_main)
--- a/source/dnode/mgmt/mgmt_snode/src/smWorker.c
+++ b/source/dnode/mgmt/mgmt_snode/src/smWorker.c
@ -36,14 +36,15 @@ static void smProcessWriteQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numO
    dTrace("msg:%p, get from snode-write queue", pMsg);
    int32_t code = sndProcessWriteMsg(pMgmt->pSnode, pMsg, NULL);
-    if (code < 0) {
+    // if (code < 0) {
-      dGError("snd, msg:%p failed to process write since %s", pMsg, tstrerror(code));
+    //   dGError("snd, msg:%p failed to process write since %s", pMsg, tstrerror(code));
-      if (pMsg->info.handle != NULL) {
+    //   if (pMsg->info.handle != NULL) {
-        tmsgSendRsp(pMsg);
+    //     tmsgSendRsp(pMsg);
-      }
+    //   }
-    } else {
+    // } else {
-      smSendRsp(pMsg, 0);
+    //   smSendRsp(pMsg, 0);
-    }
+    // }
    smSendRsp(pMsg, code);
    dTrace("msg:%p, is freed", pMsg);
    rpcFreeCont(pMsg->pCont);
--- a/source/dnode/mgmt/mgmt_vnode/inc/vmInt.h
+++ b/source/dnode/mgmt/mgmt_vnode/inc/vmInt.h
@ -37,7 +37,9 @@ typedef struct SVnodeMgmt {
  SSingleWorker         mgmtMultiWorker;
  SHashObj             *hash;
  SHashObj             *closedHash;
  SHashObj             *creatingHash;
  TdThreadRwlock        lock;
  TdThreadMutex         mutex;
  SVnodesStat           state;
  STfs                 *pTfs;
  TdThread              thread;
@ -96,6 +98,7 @@ SVnodeObj *vmAcquireVnodeImpl(SVnodeMgmt *pMgmt, int32_t vgId, bool strict);
 void       vmReleaseVnode(SVnodeMgmt *pMgmt, SVnodeObj *pVnode);
 int32_t    vmOpenVnode(SVnodeMgmt *pMgmt, SWrapperCfg *pCfg, SVnode *pImpl);
 void       vmCloseVnode(SVnodeMgmt *pMgmt, SVnodeObj *pVnode, bool commitAndRemoveWal, bool keepClosed);
 void vmRemoveFromCreatingHash(SVnodeMgmt *pMgmt, int32_t vgId);
 // vmHandle.c
 SArray *vmGetMsgHandles();
@ -113,6 +116,7 @@ int32_t vmGetVnodeListFromFile(SVnodeMgmt *pMgmt, SWrapperCfg **ppCfgs, int32_t
 int32_t vmWriteVnodeListToFile(SVnodeMgmt *pMgmt);
 int32_t vmGetVnodeListFromHash(SVnodeMgmt *pMgmt, int32_t *numOfVnodes, SVnodeObj ***ppVnodes);
 int32_t vmGetAllVnodeListFromHash(SVnodeMgmt *pMgmt, int32_t *numOfVnodes, SVnodeObj ***ppVnodes);
 int32_t vmGetAllVnodeListFromHashWithCreating(SVnodeMgmt *pMgmt, int32_t *numOfVnodes, SVnodeObj ***ppVnodes);
 // vmWorker.c
 int32_t vmStartWorker(SVnodeMgmt *pMgmt);
--- a/source/dnode/mgmt/mgmt_vnode/src/vmFile.c
+++ b/source/dnode/mgmt/mgmt_vnode/src/vmFile.c
@ -67,6 +67,54 @@ int32_t vmGetAllVnodeListFromHash(SVnodeMgmt *pMgmt, int32_t *numOfVnodes, SVnod
  return 0;
 }
 int32_t vmGetAllVnodeListFromHashWithCreating(SVnodeMgmt *pMgmt, int32_t *numOfVnodes, SVnodeObj ***ppVnodes) {
  (void)taosThreadRwlockRdlock(&pMgmt->lock);
  int32_t num = 0;
  int32_t size = taosHashGetSize(pMgmt->hash);
  int32_t creatingSize = taosHashGetSize(pMgmt->creatingHash);
  size += creatingSize;
  SVnodeObj **pVnodes = taosMemoryCalloc(size, sizeof(SVnodeObj *));
  if (pVnodes == NULL) {
    (void)taosThreadRwlockUnlock(&pMgmt->lock);
    return terrno;
  }
  void *pIter = taosHashIterate(pMgmt->hash, NULL);
  while (pIter) {
    SVnodeObj **ppVnode = pIter;
    SVnodeObj  *pVnode = *ppVnode;
    if (pVnode && num < size) {
      int32_t refCount = atomic_add_fetch_32(&pVnode->refCount, 1);
      dTrace("vgId:%d,acquire vnode, vnode:%p, ref:%d", pVnode->vgId, pVnode, refCount);
      pVnodes[num++] = (*ppVnode);
      pIter = taosHashIterate(pMgmt->hash, pIter);
    } else {
      taosHashCancelIterate(pMgmt->hash, pIter);
    }
  }
  pIter = taosHashIterate(pMgmt->creatingHash, NULL);
  while (pIter) {
    SVnodeObj **ppVnode = pIter;
    SVnodeObj  *pVnode = *ppVnode;
    if (pVnode && num < size) {
      int32_t refCount = atomic_add_fetch_32(&pVnode->refCount, 1);
      dTrace("vgId:%d, acquire vnode, vnode:%p, ref:%d", pVnode->vgId, pVnode, refCount);
      pVnodes[num++] = (*ppVnode);
      pIter = taosHashIterate(pMgmt->creatingHash, pIter);
    } else {
      taosHashCancelIterate(pMgmt->creatingHash, pIter);
    }
  }
  (void)taosThreadRwlockUnlock(&pMgmt->lock);
  *numOfVnodes = num;
  *ppVnodes = pVnodes;
  return 0;
 }
 int32_t vmGetVnodeListFromHash(SVnodeMgmt *pMgmt, int32_t *numOfVnodes, SVnodeObj ***ppVnodes) {
  (void)taosThreadRwlockRdlock(&pMgmt->lock);
--- a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
+++ b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
@ -381,6 +381,7 @@ int32_t vmProcessCreateVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
  if (vnodeCreate(path, &vnodeCfg, diskPrimary, pMgmt->pTfs) < 0) {
    dError("vgId:%d, failed to create vnode since %s", req.vgId, terrstr());
    vmReleaseVnode(pMgmt, pVnode);
    vmRemoveFromCreatingHash(pMgmt, req.vgId);
    (void)tFreeSCreateVnodeReq(&req);
    code = terrno != 0 ? terrno : -1;
    return code;
@ -422,6 +423,8 @@ int32_t vmProcessCreateVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
  }
 _OVER:
  vmRemoveFromCreatingHash(pMgmt, req.vgId);
  if (code != 0) {
    int32_t r = 0;
    r = taosThreadRwlockWrlock(&pMgmt->lock);
--- a/source/dnode/mgmt/mgmt_vnode/src/vmInt.c
+++ b/source/dnode/mgmt/mgmt_vnode/src/vmInt.c
@ -16,6 +16,7 @@
 #define _DEFAULT_SOURCE
 #include "vmInt.h"
 #include "libs/function/tudf.h"
 #include "osMemory.h"
 #include "tfs.h"
 #include "vnd.h"
@ -62,10 +63,20 @@ int32_t vmAllocPrimaryDisk(SVnodeMgmt *pMgmt, int32_t vgId) {
  int32_t     numOfVnodes = 0;
  SVnodeObj **ppVnodes = NULL;
-  code = vmGetVnodeListFromHash(pMgmt, &numOfVnodes, &ppVnodes);
+  code = taosThreadMutexLock(&pMgmt->mutex);
  if (code != 0) {
    return code;
  }
  code = vmGetAllVnodeListFromHashWithCreating(pMgmt, &numOfVnodes, &ppVnodes);
  if (code != 0) {
    int32_t r = taosThreadMutexUnlock(&pMgmt->mutex);
    if (r != 0) {
      dError("vgId:%d, failed to unlock mutex since %s", vgId, tstrerror(r));
    }
    return code;
  }
  for (int32_t v = 0; v < numOfVnodes; v++) {
    SVnodeObj *pVnode = ppVnodes[v];
    disks[pVnode->diskPrimary] += 1;
@ -81,6 +92,51 @@ int32_t vmAllocPrimaryDisk(SVnodeMgmt *pMgmt, int32_t vgId) {
    }
  }
  SVnodeObj *pCreatingVnode = taosMemoryCalloc(1, sizeof(SVnodeObj));
  if (pCreatingVnode == NULL) {
    code = -1;
    if (terrno != 0) code = terrno;
    dError("failed to alloc vnode since %s", tstrerror(code));
    int32_t r = taosThreadMutexUnlock(&pMgmt->mutex);
    if (r != 0) {
      dError("vgId:%d, failed to unlock mutex since %s", vgId, tstrerror(r));
    }
    goto _OVER;
  }
  (void)memset(pCreatingVnode, 0, sizeof(SVnodeObj));
  pCreatingVnode->vgId = vgId;
  pCreatingVnode->diskPrimary = diskId;
  code = taosThreadRwlockWrlock(&pMgmt->lock);
  if (code != 0) {
    int32_t r = taosThreadMutexUnlock(&pMgmt->mutex);
    if (r != 0) {
      dError("vgId:%d, failed to unlock mutex since %s", vgId, tstrerror(r));
    }
    taosMemoryFree(pCreatingVnode);
    goto _OVER;
  }
  dTrace("vgId:%d, put vnode into creating hash, pCreatingVnode:%p", vgId, pCreatingVnode);
  code = taosHashPut(pMgmt->creatingHash, &vgId, sizeof(int32_t), &pCreatingVnode, sizeof(SVnodeObj *));
  if (code != 0) {
    dError("vgId:%d, failed to put vnode to creatingHash", vgId);
    taosMemoryFree(pCreatingVnode);
  }
  int32_t r = taosThreadRwlockUnlock(&pMgmt->lock);
  if (r != 0) {
    dError("vgId:%d, failed to unlock since %s", vgId, tstrerror(r));
  }
  code = taosThreadMutexUnlock(&pMgmt->mutex);
  if (code != 0) {
    goto _OVER;
  }
 _OVER:
  for (int32_t i = 0; i < numOfVnodes; ++i) {
    if (ppVnodes == NULL || ppVnodes[i] == NULL) continue;
    vmReleaseVnode(pMgmt, ppVnodes[i]);
@ -89,8 +145,13 @@ int32_t vmAllocPrimaryDisk(SVnodeMgmt *pMgmt, int32_t vgId) {
    taosMemoryFree(ppVnodes);
  }
-  dInfo("vgId:%d, alloc disk:%d of level 0. ndisk:%d, vnodes: %d", vgId, diskId, ndisk, numOfVnodes);
+  if (code != 0) {
-  return diskId;
+    dError("vgId:%d, failed to alloc disk since %s", vgId, tstrerror(code));
    return code;
  } else {
    dInfo("vgId:%d, alloc disk:%d of level 0. ndisk:%d, vnodes: %d", vgId, diskId, ndisk, numOfVnodes);
    return diskId;
  }
 }
 SVnodeObj *vmAcquireVnodeImpl(SVnodeMgmt *pMgmt, int32_t vgId, bool strict) {
@ -172,7 +233,9 @@ int32_t vmOpenVnode(SVnodeMgmt *pMgmt, SWrapperCfg *pCfg, SVnode *pImpl) {
  }
  (void)taosThreadRwlockWrlock(&pMgmt->lock);
  SVnodeObj *pOld = NULL;
  int32_t    r = taosHashGetDup(pMgmt->hash, &pVnode->vgId, sizeof(int32_t), (void *)&pOld);
  if (r != 0) {
    dError("vgId:%d, failed to get vnode from hash", pVnode->vgId);
@ -187,15 +250,15 @@ int32_t vmOpenVnode(SVnodeMgmt *pMgmt, SWrapperCfg *pCfg, SVnode *pImpl) {
  if (r != 0) {
    dError("vgId:%d, failed to get vnode from closedHash", pVnode->vgId);
  }
-  if (pOld) {
+  if (pOld != NULL) {
    vmFreeVnodeObj(&pOld);
    dInfo("vgId:%d, remove from closedHash", pVnode->vgId);
    r = taosHashRemove(pMgmt->closedHash, &pVnode->vgId, sizeof(int32_t));
    if (r != 0) {
      dError("vgId:%d, failed to remove vnode from hash", pVnode->vgId);
    }
  }
  dInfo("vgId:%d, remove from closedHash", pVnode->vgId);
  r = taosHashRemove(pMgmt->closedHash, &pVnode->vgId, sizeof(int32_t));
  if (r != 0) {
    dError("vgId:%d, failed to remove vnode from hash", pVnode->vgId);
  }
  (void)taosThreadRwlockUnlock(&pMgmt->lock);
  return code;
@ -216,12 +279,12 @@ void vmCloseVnode(SVnodeMgmt *pMgmt, SVnodeObj *pVnode, bool commitAndRemoveWal,
  }
  if (keepClosed) {
    SVnodeObj *pClosedVnode = taosMemoryCalloc(1, sizeof(SVnodeObj));
-    (void)memset(pClosedVnode, 0, sizeof(SVnodeObj));
+    if (pClosedVnode == NULL) {
-    if (pVnode == NULL) {
+      dError("failed to alloc vnode since %s", terrstr());
      dError("vgId:%d, failed to alloc vnode since %s", pVnode->vgId, terrstr());
      (void)taosThreadRwlockUnlock(&pMgmt->lock);
      return;
    }
    (void)memset(pClosedVnode, 0, sizeof(SVnodeObj));
    pClosedVnode->vgId = pVnode->vgId;
    pClosedVnode->dropped = pVnode->dropped;
@ -427,11 +490,18 @@ static int32_t vmOpenVnodes(SVnodeMgmt *pMgmt) {
  pMgmt->closedHash =
      taosHashInit(TSDB_MIN_VNODES, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_ENTRY_LOCK);
-  if (pMgmt->hash == NULL) {
+  if (pMgmt->closedHash == NULL) {
    dError("failed to init vnode closed hash since %s", terrstr());
    return TSDB_CODE_OUT_OF_MEMORY;
  }
  pMgmt->creatingHash =
      taosHashInit(TSDB_MIN_VNODES, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_ENTRY_LOCK);
  if (pMgmt->creatingHash == NULL) {
    dError("failed to init vnode creatingHash hash since %s", terrstr());
    return TSDB_CODE_OUT_OF_MEMORY;
  }
  SWrapperCfg *pCfgs = NULL;
  int32_t      numOfVnodes = 0;
  if (vmGetVnodeListFromFile(pMgmt, &pCfgs, &numOfVnodes) != 0) {
@ -509,6 +579,32 @@ static int32_t vmOpenVnodes(SVnodeMgmt *pMgmt) {
  return 0;
 }
 void vmRemoveFromCreatingHash(SVnodeMgmt *pMgmt, int32_t vgId) {
  SVnodeObj *pOld = NULL;
  (void)taosThreadRwlockWrlock(&pMgmt->lock);
  int32_t    r = taosHashGetDup(pMgmt->creatingHash, &vgId, sizeof(int32_t), (void *)&pOld);
  if (r != 0) {
    dError("vgId:%d, failed to get vnode from creating Hash", vgId);
  }
  dTrace("vgId:%d, remove from creating Hash", vgId);
  r = taosHashRemove(pMgmt->creatingHash, &vgId, sizeof(int32_t));
  if (r != 0) {
    dError("vgId:%d, failed to remove vnode from hash", vgId);
  }
  (void)taosThreadRwlockUnlock(&pMgmt->lock);
  if (pOld) {
    dTrace("vgId:%d, free vnode pOld:%p", vgId, &pOld);
    vmFreeVnodeObj(&pOld);
  }
 _OVER:
  if (r != 0) {
    dError("vgId:%d, failed to remove vnode from creatingHash since %s", vgId, tstrerror(r));
  }
 }
 static void *vmCloseVnodeInThread(void *param) {
  SVnodeThread *pThread = param;
  SVnodeMgmt   *pMgmt = pThread->pMgmt;
@ -614,6 +710,18 @@ static void vmCloseVnodes(SVnodeMgmt *pMgmt) {
    pMgmt->closedHash = NULL;
  }
  pIter = taosHashIterate(pMgmt->creatingHash, NULL);
  while (pIter) {
    SVnodeObj **ppVnode = pIter;
    vmFreeVnodeObj(ppVnode);
    pIter = taosHashIterate(pMgmt->creatingHash, pIter);
  }
  if (pMgmt->creatingHash != NULL) {
    taosHashCleanup(pMgmt->creatingHash);
    pMgmt->creatingHash = NULL;
  }
  dInfo("total vnodes:%d are all closed", numOfVnodes);
 }
@ -622,6 +730,7 @@ static void vmCleanup(SVnodeMgmt *pMgmt) {
  vmStopWorker(pMgmt);
  vnodeCleanup();
  (void)taosThreadRwlockDestroy(&pMgmt->lock);
  (void)taosThreadMutexDestroy(&pMgmt->mutex);
  (void)taosThreadMutexDestroy(&pMgmt->fileLock);
  taosMemoryFree(pMgmt);
 }
@ -714,6 +823,12 @@ static int32_t vmInit(SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
    goto _OVER;
  }
  code = taosThreadMutexInit(&pMgmt->mutex, NULL);
  if (code != 0) {
    code = TAOS_SYSTEM_ERROR(errno);
    goto _OVER;
  }
  code = taosThreadMutexInit(&pMgmt->fileLock, NULL);
  if (code != 0) {
    code = TAOS_SYSTEM_ERROR(errno);
--- a/source/dnode/mgmt/node_mgmt/src/dmTransport.c
+++ b/source/dnode/mgmt/node_mgmt/src/dmTransport.c
@ -214,8 +214,6 @@ static void dmProcessRpcMsg(SDnode *pDnode, SRpcMsg *pRpc, SEpSet *pEpSet) {
  } else if ((pRpc->code == TSDB_CODE_RPC_NETWORK_UNAVAIL || pRpc->code == TSDB_CODE_RPC_BROKEN_LINK) &&
             (!IsReq(pRpc)) && (pRpc->pCont == NULL)) {
    dGError("msg:%p, type:%s pCont is NULL, err: %s", pRpc, TMSG_INFO(pRpc->msgType), tstrerror(pRpc->code));
    code = pRpc->code;
    goto _OVER;
  }
  if (pHandle->defaultNtype == NODE_END) {
--- a/source/dnode/mgmt/node_util/CMakeLists.txt
+++ b/source/dnode/mgmt/node_util/CMakeLists.txt
@ -6,5 +6,5 @@ target_include_directories(
    PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
 target_link_libraries(
-    node_util cjson mnode vnode qnode snode wal sync taos_static tfs monitor monitorfw
+    node_util cjson mnode vnode qnode snode wal sync ${TAOS_LIB_STATIC} tfs monitor monitorfw
 )
--- a/source/dnode/mnode/impl/inc/mndStream.h
+++ b/source/dnode/mnode/impl/inc/mndStream.h
@ -56,6 +56,7 @@ typedef struct SStreamTransMgmt {
 typedef struct SStreamTaskResetMsg {
  int64_t streamId;
  int32_t transId;
  int64_t checkpointId;
 } SStreamTaskResetMsg;
 typedef struct SChkptReportInfo {
@ -142,9 +143,9 @@ int32_t mndStreamSetResumeAction(STrans *pTrans, SMnode *pMnode, SStreamObj *pSt
 int32_t mndStreamSetPauseAction(SMnode *pMnode, STrans *pTrans, SStreamObj *pStream);
 int32_t mndStreamSetDropAction(SMnode *pMnode, STrans *pTrans, SStreamObj *pStream);
 int32_t mndStreamSetDropActionFromList(SMnode *pMnode, STrans *pTrans, SArray *pList);
-int32_t mndStreamSetResetTaskAction(SMnode *pMnode, STrans *pTrans, SStreamObj *pStream);
+int32_t mndStreamSetResetTaskAction(SMnode *pMnode, STrans *pTrans, SStreamObj *pStream, int64_t chkptId);
 int32_t mndStreamSetUpdateChkptAction(SMnode *pMnode, STrans *pTrans, SStreamObj *pStream);
-int32_t mndCreateStreamResetStatusTrans(SMnode *pMnode, SStreamObj *pStream);
+int32_t mndCreateStreamResetStatusTrans(SMnode *pMnode, SStreamObj *pStream, int64_t chkptId);
 int32_t mndStreamSetChkptIdAction(SMnode *pMnode, STrans *pTrans, SStreamTask* pTask, int64_t checkpointId, int64_t ts);
 int32_t mndStreamSetRestartAction(SMnode* pMnode, STrans *pTrans, SStreamObj* pStream);
 int32_t mndStreamSetCheckpointAction(SMnode *pMnode, STrans *pTrans, SStreamTask *pTask, int64_t checkpointId,
--- a/source/dnode/mnode/impl/src/mndAnode.c
+++ b/source/dnode/mnode/impl/src/mndAnode.c
@ -309,7 +309,7 @@ static int32_t mndCreateAnode(SMnode *pMnode, SRpcMsg *pReq, SMCreateAnodeReq *p
  anodeObj.updateTime = anodeObj.createdTime;
  anodeObj.version = 0;
  anodeObj.urlLen = pCreate->urlLen;
-  if (anodeObj.urlLen > TSDB_ANAL_ANODE_URL_LEN) {
+  if (anodeObj.urlLen > TSDB_ANALYTIC_ANODE_URL_LEN) {
    code = TSDB_CODE_MND_ANODE_TOO_LONG_URL;
    goto _OVER;
  }
@ -491,23 +491,24 @@ static int32_t mndSetDropAnodeRedoLogs(STrans *pTrans, SAnodeObj *pObj) {
  int32_t  code = 0;
  SSdbRaw *pRedoRaw = mndAnodeActionEncode(pObj);
  if (pRedoRaw == NULL) {
-    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    code = terrno;
-    if (terrno != 0) code = terrno;
+    return code;
    TAOS_RETURN(code);
  }
  TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pRedoRaw));
  TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING));
-  TAOS_RETURN(code);
+
  return code;
 }
 static int32_t mndSetDropAnodeCommitLogs(STrans *pTrans, SAnodeObj *pObj) {
  int32_t  code = 0;
  SSdbRaw *pCommitRaw = mndAnodeActionEncode(pObj);
  if (pCommitRaw == NULL) {
-    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    code = terrno;
-    if (terrno != 0) code = terrno;
+    return code;
    TAOS_RETURN(code);
  }
  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pCommitRaw));
  TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED));
  TAOS_RETURN(code);
@ -521,25 +522,25 @@ static int32_t mndSetDropAnodeInfoToTrans(SMnode *pMnode, STrans *pTrans, SAnode
 }
 static int32_t mndDropAnode(SMnode *pMnode, SRpcMsg *pReq, SAnodeObj *pObj) {
-  int32_t code = -1;
+  int32_t code = 0;
  int32_t lino = 0;
  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_NOTHING, pReq, "drop-anode");
-  if (pTrans == NULL) {
+  TSDB_CHECK_NULL(pTrans, code, lino, _OVER, terrno);
-    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+
    if (terrno != 0) code = terrno;
    goto _OVER;
  }
  mndTransSetSerial(pTrans);
  mInfo("trans:%d, to drop anode:%d", pTrans->id, pObj->id);
-  mInfo("trans:%d, used to drop anode:%d", pTrans->id, pObj->id);
+  code = mndSetDropAnodeInfoToTrans(pMnode, pTrans, pObj, false);
-  TAOS_CHECK_GOTO(mndSetDropAnodeInfoToTrans(pMnode, pTrans, pObj, false), NULL, _OVER);
+  mndReleaseAnode(pMnode, pObj);
  TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);
-  code = 0;
+  TSDB_CHECK_CODE(code, lino, _OVER);
  code = mndTransPrepare(pMnode, pTrans);
 _OVER:
  mndTransDrop(pTrans);
-  TAOS_RETURN(code);
+  return code;
 }
 static int32_t mndProcessDropAnodeReq(SRpcMsg *pReq) {
@ -560,20 +561,20 @@ static int32_t mndProcessDropAnodeReq(SRpcMsg *pReq) {
  pObj = mndAcquireAnode(pMnode, dropReq.anodeId);
  if (pObj == NULL) {
-    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    code = terrno;
    if (terrno != 0) code = terrno;
    goto _OVER;
  }
  code = mndDropAnode(pMnode, pReq, pObj);
-  if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;
+  if (code == 0) {
    code = TSDB_CODE_ACTION_IN_PROGRESS;
  }
 _OVER:
  if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {
    mError("anode:%d, failed to drop since %s", dropReq.anodeId, tstrerror(code));
  }
  mndReleaseAnode(pMnode, pObj);
  tFreeSMDropAnodeReq(&dropReq);
  TAOS_RETURN(code);
 }
@ -584,7 +585,7 @@ static int32_t mndRetrieveAnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB
  int32_t    numOfRows = 0;
  int32_t    cols = 0;
  SAnodeObj *pObj = NULL;
-  char       buf[TSDB_ANAL_ANODE_URL_LEN + VARSTR_HEADER_SIZE];
+  char       buf[TSDB_ANALYTIC_ANODE_URL_LEN + VARSTR_HEADER_SIZE];
  char       status[64];
  int32_t    code = 0;
@ -642,7 +643,7 @@ static int32_t mndRetrieveAnodesFull(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock
  int32_t    numOfRows = 0;
  int32_t    cols = 0;
  SAnodeObj *pObj = NULL;
-  char       buf[TSDB_ANAL_ALGO_NAME_LEN + VARSTR_HEADER_SIZE];
+  char       buf[TSDB_ANALYTIC_ALGO_NAME_LEN + VARSTR_HEADER_SIZE];
  int32_t    code = 0;
  while (numOfRows < rows) {
@ -693,7 +694,7 @@ static int32_t mndDecodeAlgoList(SJson *pJson, SAnodeObj *pObj) {
  int32_t code = 0;
  int32_t protocol = 0;
  double  tmp = 0;
-  char    buf[TSDB_ANAL_ALGO_NAME_LEN + 1] = {0};
+  char    buf[TSDB_ANALYTIC_ALGO_NAME_LEN + 1] = {0};
  code = tjsonGetDoubleValue(pJson, "protocol", &tmp);
  if (code < 0) return TSDB_CODE_INVALID_JSON_FORMAT;
@ -753,10 +754,10 @@ static int32_t mndDecodeAlgoList(SJson *pJson, SAnodeObj *pObj) {
 }
 static int32_t mndGetAnodeAlgoList(const char *url, SAnodeObj *pObj) {
-  char anodeUrl[TSDB_ANAL_ANODE_URL_LEN + 1] = {0};
+  char anodeUrl[TSDB_ANALYTIC_ANODE_URL_LEN + 1] = {0};
-  snprintf(anodeUrl, TSDB_ANAL_ANODE_URL_LEN, "%s/%s", url, "list");
+  snprintf(anodeUrl, TSDB_ANALYTIC_ANODE_URL_LEN, "%s/%s", url, "list");
-  SJson *pJson = taosAnalSendReqRetJson(anodeUrl, ANAL_HTTP_TYPE_GET, NULL);
+  SJson *pJson = taosAnalSendReqRetJson(anodeUrl, ANALYTICS_HTTP_TYPE_GET, NULL);
  if (pJson == NULL) return terrno;
  int32_t code = mndDecodeAlgoList(pJson, pObj);
@ -769,10 +770,10 @@ static int32_t mndGetAnodeStatus(SAnodeObj *pObj, char *status, int32_t statusLe
  int32_t code = 0;
  int32_t protocol = 0;
  double  tmp = 0;
-  char    anodeUrl[TSDB_ANAL_ANODE_URL_LEN + 1] = {0};
+  char    anodeUrl[TSDB_ANALYTIC_ANODE_URL_LEN + 1] = {0};
-  snprintf(anodeUrl, TSDB_ANAL_ANODE_URL_LEN, "%s/%s", pObj->url, "status");
+  snprintf(anodeUrl, TSDB_ANALYTIC_ANODE_URL_LEN, "%s/%s", pObj->url, "status");
-  SJson *pJson = taosAnalSendReqRetJson(anodeUrl, ANAL_HTTP_TYPE_GET, NULL);
+  SJson *pJson = taosAnalSendReqRetJson(anodeUrl, ANALYTICS_HTTP_TYPE_GET, NULL);
  if (pJson == NULL) return terrno;
  code = tjsonGetDoubleValue(pJson, "protocol", &tmp);
@ -808,7 +809,7 @@ static int32_t mndProcessAnalAlgoReq(SRpcMsg *pReq) {
  SAnodeObj           *pObj = NULL;
  SAnalyticsUrl             url;
  int32_t              nameLen;
-  char                 name[TSDB_ANAL_ALGO_KEY_LEN];
+  char                 name[TSDB_ANALYTIC_ALGO_KEY_LEN];
  SRetrieveAnalAlgoReq req = {0};
  SRetrieveAnalAlgoRsp rsp = {0};
@ -847,13 +848,13 @@ static int32_t mndProcessAnalAlgoReq(SRpcMsg *pReq) {
                goto _OVER;
              }
            }
-            url.url = taosMemoryMalloc(TSDB_ANAL_ANODE_URL_LEN + TSDB_ANAL_ALGO_TYPE_LEN + 1);
+            url.url = taosMemoryMalloc(TSDB_ANALYTIC_ANODE_URL_LEN + TSDB_ANALYTIC_ALGO_TYPE_LEN + 1);
            if (url.url == NULL) {
              sdbRelease(pSdb, pAnode);
              goto _OVER;
            }
-            url.urlLen = 1 + tsnprintf(url.url, TSDB_ANAL_ANODE_URL_LEN + TSDB_ANAL_ALGO_TYPE_LEN, "%s/%s", pAnode->url,
+            url.urlLen = 1 + tsnprintf(url.url, TSDB_ANALYTIC_ANODE_URL_LEN + TSDB_ANALYTIC_ALGO_TYPE_LEN, "%s/%s", pAnode->url,
                                      taosAnalAlgoUrlStr(url.type));
            if (taosHashPut(rsp.hash, name, nameLen, &url, sizeof(SAnalyticsUrl)) != 0) {
              taosMemoryFree(url.url);
--- a/source/dnode/mnode/impl/src/mndDnode.c
+++ b/source/dnode/mnode/impl/src/mndDnode.c
@ -1103,6 +1103,7 @@ static int32_t mndProcessShowVariablesReq(SRpcMsg *pReq) {
  (void)strcpy(info.name, "statusInterval");
  (void)snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsStatusInterval);
  (void)strcpy(info.scope, "server");
  // fill info.info
  if (taosArrayPush(rsp.variables, &info) == NULL) {
    code = terrno;
    goto _OVER;
--- a/source/dnode/mnode/impl/src/mndMain.c
+++ b/source/dnode/mnode/impl/src/mndMain.c
@ -53,7 +53,7 @@ static inline int32_t mndAcquireRpc(SMnode *pMnode) {
  if (pMnode->stopped) {
    code = TSDB_CODE_APP_IS_STOPPING;
  } else if (!mndIsLeader(pMnode)) {
-    code = -1;
+    code = 1;
  } else {
 #if 1
    (void)atomic_add_fetch_32(&pMnode->rpcRef, 1);
@ -1002,8 +1002,12 @@ int64_t mndGenerateUid(const char *name, int32_t len) {
 int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pClusterInfo, SMonVgroupInfo *pVgroupInfo,
                          SMonStbInfo *pStbInfo, SMonGrantInfo *pGrantInfo) {
-  int32_t code = 0;
+  int32_t code = mndAcquireRpc(pMnode);
-  TAOS_CHECK_RETURN(mndAcquireRpc(pMnode));
+  if (code < 0) {
    TAOS_RETURN(code);
  } else if (code == 1) {
    TAOS_RETURN(TSDB_CODE_SUCCESS);
  }
  SSdb   *pSdb = pMnode->pSdb;
  int64_t ms = taosGetTimestampMs();
--- a/Show More
+++ b/Show More