Merge branch '3.0' into test/cluster_case

.gitignore

@@ -48,6 +48,8 @@ pysim/
 *.out
 *DS_Store
 tests/script/api/batchprepare
+taosadapter
+taosadapter-debug
 
 # Doxygen Generated files
 html/

.gitmodules

@@ -4,21 +4,9 @@
 [submodule "src/connector/hivemq-tdengine-extension"]
 	path = src/connector/hivemq-tdengine-extension
 	url = git@github.com:taosdata/hivemq-tdengine-extension.git
-[submodule "deps/jemalloc"]
-	path = deps/jemalloc
-	url = https://github.com/jemalloc/jemalloc
 [submodule "deps/TSZ"]
 	path = deps/TSZ
 	url = https://github.com/taosdata/TSZ.git
 [submodule "examples/rust"]
 	path = examples/rust
 	url = https://github.com/songtianyi/tdengine-rust-bindings.git
-[submodule "tools/taos-tools"]
-	path = tools/taos-tools
-	url = https://github.com/taosdata/taos-tools
-[submodule "tools/taosadapter"]
-	path = tools/taosadapter
-	url = https://github.com/taosdata/taosadapter.git
-[submodule "tools/taosws-rs"]
-	path = tools/taosws-rs
-	url = https://github.com/taosdata/taosws-rs

Jenkinsfile2

@@ -113,6 +113,12 @@ def pre_test(){
             echo "unmatched reposiotry ${CHANGE_URL}"
         '''
     }
+    sh '''
+        cd ${WKC}
+        git rm --cached tools/taos-tools 2>/dev/null || :
+        git rm --cached tools/taosadapter 2>/dev/null || :
+        git rm --cached tools/taosws-rs 2>/dev/null || :
+    '''
     sh '''
         cd ${WKC}
         git submodule update --init --recursive
@@ -258,6 +264,13 @@ def pre_test_win(){
         git branch
         git log -5
     '''
+    bat '''
+        cd %WIN_COMMUNITY_ROOT%
+        git rm --cached tools/taos-tools 2>nul
+        git rm --cached tools/taosadapter 2>nul
+        git rm --cached tools/taosws-rs 2>nul
+        exit 0
+    '''
     bat '''
         cd %WIN_COMMUNITY_ROOT%
         git submodule update --init --recursive

cmake/cmake.options

@@ -84,6 +84,12 @@ ELSE ()
     ENDIF ()
 ENDIF ()
 
+option(
+    JEMALLOC_ENABLED
+    "If build with jemalloc"
+    OFF
+    )
+
 option(
     BUILD_SANITIZER
     "If build sanitizer"

cmake/jemalloc_CMakeLists.txt.in

+
+# jemalloc
+ExternalProject_Add(jemalloc
+        GIT_REPOSITORY https://github.com/jemalloc/jemalloc.git
+        GIT_TAG 5.3.0
+        SOURCE_DIR "${TD_CONTRIB_DIR}/jemalloc"
+        BINARY_DIR ""
+        CONFIGURE_COMMAND ""
+        BUILD_COMMAND ""
+        INSTALL_COMMAND ""
+        TEST_COMMAND ""
+        GIT_SHALLOW true
+        GIT_PROGRESS true
+        )

cmake/taosadapter_CMakeLists.txt.in

+
+# zlib
+ExternalProject_Add(taosadapter
+        GIT_REPOSITORY https://github.com/taosdata/taosadapter.git
+        GIT_TAG df8678f
+        SOURCE_DIR "${TD_SOURCE_DIR}/tools/taosadapter"
+        BINARY_DIR ""
+        #BUILD_IN_SOURCE TRUE
+        CONFIGURE_COMMAND ""
+        BUILD_COMMAND ""
+        INSTALL_COMMAND ""
+        TEST_COMMAND ""
+)

cmake/taostools_CMakeLists.txt.in

+
+# zlib
+ExternalProject_Add(taos-tools
+        GIT_REPOSITORY https://github.com/taosdata/taos-tools.git
+        GIT_TAG 817cb6a
+        SOURCE_DIR "${TD_SOURCE_DIR}/tools/taos-tools"
+        BINARY_DIR ""
+        #BUILD_IN_SOURCE TRUE
+        CONFIGURE_COMMAND ""
+        BUILD_COMMAND ""
+        INSTALL_COMMAND ""
+        TEST_COMMAND ""
+)

cmake/taosws_CMakeLists.txt.in

+
+# zlib
+ExternalProject_Add(taosws-rs
+        GIT_REPOSITORY https://github.com/taosdata/taosws-rs.git
+        GIT_TAG 9de599d
+        SOURCE_DIR "${TD_SOURCE_DIR}/tools/taosws-rs"
+        BINARY_DIR ""
+        #BUILD_IN_SOURCE TRUE
+        CONFIGURE_COMMAND ""
+        BUILD_COMMAND ""
+        INSTALL_COMMAND ""
+        TEST_COMMAND ""
+)

contrib/CMakeLists.txt

@@ -9,6 +9,28 @@ endfunction(cat IN_FILE OUT_FILE)
 set(CONTRIB_TMP_FILE "${CMAKE_BINARY_DIR}/deps_tmp_CMakeLists.txt.in")
 configure_file("${TD_SUPPORT_DIR}/deps_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
 
+# taos-tools
+if(${BUILD_TOOLS})
+    cat("${TD_SUPPORT_DIR}/taostools_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
+endif()
+
+# taosws-rs
+if(${WEBSOCKET})
+    cat("${TD_SUPPORT_DIR}/taosws_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
+endif()
+
+# taosadapter
+if(${BUILD_HTTP})
+    MESSAGE("BUILD_HTTP is on")
+else ()
+    MESSAGE("BUILD_HTTP is off, use taosAdapter")
+    cat("${TD_SUPPORT_DIR}/taosadapter_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
+endif()
+
+if(TD_LINUX_64 AND JEMALLOC_ENABLED)
+    cat("${TD_SUPPORT_DIR}/jemalloc_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
+endif()
+
 # pthread
 if(${BUILD_PTHREAD})
     cat("${TD_SUPPORT_DIR}/pthread_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
@@ -381,6 +403,18 @@ if(${BUILD_ADDR2LINE})
     endif(NOT ${TD_WINDOWS})
 endif(${BUILD_ADDR2LINE})
 
+# jemalloc
+IF (TD_LINUX_64 AND JEMALLOC_ENABLED)
+    include(ExternalProject)
+    ExternalProject_Add(jemalloc
+        PREFIX        "jemalloc"
+        SOURCE_DIR    ${CMAKE_CURRENT_SOURCE_DIR}/jemalloc
+        BUILD_IN_SOURCE     1
+        CONFIGURE_COMMAND   ./autogen.sh COMMAND ./configure --prefix=${CMAKE_BINARY_DIR}/build/
+        BUILD_COMMAND       ${MAKE}
+        )
+    INCLUDE_DIRECTORIES(${CMAKE_BINARY_DIR}/build/include)
+ENDIF ()
 
 # ================================================================================================
 # Build test

docs/zh/05-get-started/03-package.md

@@ -245,7 +245,7 @@ select * from t;
 Query OK, 2 row(s) in set (0.003128s)
 ```
 
-除执行 SQL 语句外，系统管理员还可以从 TDengine CLI 进行检查系统运行状态、添加删除用户账号等操作。TDengine CLI 连同应用驱动也可以独立安装在 Linux 或 Windows 机器上运行，更多细节请参考 [这里](../reference/taos-shell/)
+除执行 SQL 语句外，系统管理员还可以从 TDengine CLI 进行检查系统运行状态、添加删除用户账号等操作。TDengine CLI 连同应用驱动也可以独立安装在 Linux 或 Windows 机器上运行，更多细节请参考 [这里](../../reference/taos-shell/)
 
 ## 使用 taosBenchmark 体验写入速度
 

docs/zh/05-get-started/index.md

@@ -3,6 +3,7 @@ title: 立即开始
 description: '快速设置 TDengine 环境并体验其高效写入和查询'
 ---
 
+TDengine 完整的软件包包括服务端（taosd）、用于与第三方系统对接并提供 RESTful 接口的 taosAdapter、应用驱动（taosc）、命令行程序 (CLI，taos) 和一些工具软件。TDengine 除了提供多种语言的连接器之外，还通过 [taosAdapter](/reference/taosadapter) 提供 [RESTful 接口](/reference/rest-api)。
 
 本章主要介绍如何利用 Docker 或者安装包快速设置 TDengine 环境并体验其高效写入和查询。
 

docs/zh/12-taos-sql/02-database.md

@@ -6,53 +6,86 @@ description: "创建、删除数据库，查看、修改数据库参数"
 
 ## 创建数据库
 
-```
-CREATE DATABASE [IF NOT EXISTS] db_name [KEEP keep] [DAYS days] [UPDATE 1];
-```
-
-:::info
-1. KEEP 是该数据库的数据保留多长天数，缺省是 3650 天(10 年)，数据库会自动删除超过时限的数据；<!-- REPLACE_OPEN_TO_ENTERPRISE__KEEP_PARAM_DESCRIPTION -->
-2. UPDATE 标志数据库支持更新相同时间戳数据；（从 2.1.7.0 版本开始此参数支持设为 2，表示允许部分列更新，也即更新数据行时未被设置的列会保留原值。）（从 2.0.8.0 版本开始支持此参数。注意此参数不能通过 `ALTER DATABASE` 指令进行修改。）
-   1. UPDATE 设为 0 时，表示不允许更新数据，后发送的相同时间戳的数据会被直接丢弃；
-   2. UPDATE 设为 1 时，表示更新全部列数据，即如果更新一个数据行，其中某些列没有提供取值，那么这些列会被设为 NULL；
-   3. UPDATE 设为 2 时，表示支持更新部分列数据，即如果更新一个数据行，其中某些列没有提供取值，那么这些列会保持原有数据行中的对应值；
-   4. 更多关于 UPDATE 参数的用法，请参考[FAQ](/train-faq/faq)。
-3. 数据库名最大长度为 33；
-4. 一条 SQL 语句的最大长度为 65480 个字符；
-5. 创建数据库时可用的参数有：
-   - cache: [详细说明](/reference/config/#cache)
-   - blocks: [详细说明](/reference/config/#blocks)
-   - days: [详细说明](/reference/config/#days)
-   - keep: [详细说明](/reference/config/#keep)
-   - minRows: [详细说明](/reference/config/#minrows)
-   - maxRows: [详细说明](/reference/config/#maxrows)
-   - wal: [详细说明](/reference/config/#wallevel)
-   - fsync: [详细说明](/reference/config/#fsync)
-   - update: [详细说明](/reference/config/#update)
-   - cacheLast: [详细说明](/reference/config/#cachelast)
-   - replica: [详细说明](/reference/config/#replica)
-   - quorum: [详细说明](/reference/config/#quorum)
-   - comp: [详细说明](/reference/config/#comp)
-   - precision: [详细说明](/reference/config/#precision)
-6. 请注意上面列出的所有参数都可以配置在配置文件 `taosd.cfg` 中作为创建数据库时使用的默认配置， `create database` 的参数中明确指定的会覆盖配置文件中的设置。
-
-:::
+```sql
+CREATE DATABASE [IF NOT EXISTS] db_name [database_options]
+ 
+database_options:
+    database_option ...
+ 
+database_option: {
+    BUFFER value
+  | CACHEMODEL {'none' | 'last_row' | 'last_value' | 'both'}
+  | CACHESIZE value
+  | COMP {0 | 1 | 2}
+  | DURATION value
+  | WAL_FSYNC_PERIOD value
+  | MAXROWS value
+  | MINROWS value
+  | KEEP value
+  | PAGES value
+  | PAGESIZE  value
+  | PRECISION {'ms' | 'us' | 'ns'}
+  | REPLICA value
+  | RETENTIONS ingestion_duration:keep_duration ...
+  | STRICT {'off' | 'on'}
+  | WAL_LEVEL {1 | 2}
+  | VGROUPS value
+  | SINGLE_STABLE {0 | 1}
+  | WAL_RETENTION_PERIOD value
+  | WAL_ROLL_PERIOD value
+  | WAL_RETENTION_SIZE value
+  | WAL_SEGMENT_SIZE value
+}
+```
+
+### 参数说明
+
+- BUFFER: 一个 VNODE 写入内存池大小，单位为 MB，默认为 96，最小为 3，最大为 16384。
+- CACHEMODEL：表示是否在内存中缓存子表的最近数据。默认为 none。
+  - none：表示不缓存。
+  - last_row：表示缓存子表最近一行数据。这将显著改善 LAST_ROW 函数的性能表现。
+  - last_value：表示缓存子表每一列的最近的非 NULL 值。这将显著改善无特殊影响（WHERE、ORDER BY、GROUP BY、INTERVAL）下的 LAST 函数的性能表现。
+  - both：表示同时打开缓存最近行和列功能。
+- CACHESIZE：表示每个 vnode 中用于缓存子表最近数据的内存大小。默认为 1 ，范围是[1, 65536]，单位是 MB。
+- COMP：表示数据库文件压缩标志位，缺省值为 2，取值范围为 [0, 2]。
+  - 0：表示不压缩。
+  - 1：表示一阶段压缩。
+  - 2：表示两阶段压缩。
+- DURATION：数据文件存储数据的时间跨度。可以使用加单位的表示形式，如 DURATION 100h、DURATION 10d 等，支持 m（分钟）、h（小时）和 d（天）三个单位。不加时间单位时默认单位为天，如 DURATION 50 表示 50 天。
+- WAL_FSYNC_PERIOD：当 WAL 参数设置为 2 时，落盘的周期。默认为 3000，单位毫秒。最小为 0，表示每次写入立即落盘；最大为 180000，即三分钟。
+- MAXROWS：文件块中记录的最大条数，默认为 4096 条。
+- MINROWS：文件块中记录的最小条数，默认为 100 条。
+- KEEP：表示数据文件保存的天数，缺省值为 3650，取值范围 [1, 365000]，且必须大于或等于 DURATION 参数值。数据库会自动删除保存时间超过 KEEP 值的数据。KEEP 可以使用加单位的表示形式，如 KEEP 100h、KEEP 10d 等，支持 m（分钟）、h（小时）和 d（天）三个单位。也可以不写单位，如 KEEP 50，此时默认单位为天。
+- PAGES：一个 VNODE 中元数据存储引擎的缓存页个数，默认为 256，最小 64。一个 VNODE 元数据存储占用 PAGESIZE \* PAGES，默认情况下为 1MB 内存。
+- PAGESIZE：一个 VNODE 中元数据存储引擎的页大小，单位为 KB，默认为 4 KB。范围为 1 到 16384，即 1 KB 到 16 MB。
+- PRECISION：数据库的时间戳精度。ms 表示毫秒，us 表示微秒，ns 表示纳秒，默认 ms 毫秒。
+- REPLICA：表示数据库副本数，取值为 1 或 3，默认为 1。在集群中使用，副本数必须小于或等于 DNODE 的数目。
+- RETENTIONS：表示数据的聚合周期和保存时长，如 RETENTIONS 15s:7d,1m:21d,15m:50d 表示数据原始采集周期为 15 秒，原始数据保存 7 天；按 1 分钟聚合的数据保存 21 天；按 15 分钟聚合的数据保存 50 天。目前支持且只支持三级存储周期。
+- STRICT：表示数据同步的一致性要求，默认为 off。
+  - on 表示强一致，即运行标准的 raft 协议，半数提交返回成功。
+  - off 表示弱一致，本地提交即返回成功。
+- WAL_LEVEL：WAL 级别，默认为 1。
+  - 1：写 WAL，但不执行 fsync。
+  - 2：写 WAL，而且执行 fsync。
+- VGROUPS：数据库中初始 vgroup 的数目。
+- SINGLE_STABLE：表示此数据库中是否只可以创建一个超级表，用于超级表列非常多的情况。
+  - 0：表示可以创建多张超级表。
+  - 1：表示只可以创建一张超级表。
+- WAL_RETENTION_PERIOD：wal 文件的额外保留策略，用于数据订阅。wal 的保存时长，单位为 s。默认为 0，即落盘后立即删除。-1 表示不删除。
+- WAL_RETENTION_SIZE：wal 文件的额外保留策略，用于数据订阅。wal 的保存的最大上限，单位为 KB。默认为 0，即落盘后立即删除。-1 表示不删除。
+- WAL_ROLL_PERIOD：wal 文件切换时长，单位为 s。当 wal 文件创建并写入后，经过该时间，会自动创建一个新的 wal 文件。默认为 0，即仅在落盘时创建新文件。
+- WAL_SEGMENT_SIZE：wal 单个文件大小，单位为 KB。当前写入文件大小超过上限后会自动创建一个新的 wal 文件。默认为 0，即仅在落盘时创建新文件。
 
 ### 创建数据库示例
 
-创建时间精度为纳秒的数据库, 保留 1 年数据：
-
 ```sql
-CREATE DATABASE test PRECISION 'ns' KEEP 365;
-```
-
-## 显示系统当前参数
+create database if not exists db vgroups 10 buffer 10
 
 ```
-SHOW VARIABLES;
-```
 
-## 使用数据库
+以上示例创建了一个有 10 个 vgroup 名为 db 的数据库， 其中每个 vnode 分配也 10MB 的写入缓存
+
+### 使用数据库
 
 ```
 USE db_name;
@@ -63,65 +96,61 @@ USE db_name;
 ## 删除数据库
 
 ```
-DROP DATABASE [IF EXISTS] db_name;
+DROP DATABASE [IF EXISTS] db_name
 ```
 
-删除数据库。指定 Database 所包含的全部数据表将被删除，谨慎使用！
+删除数据库。指定 Database 所包含的全部数据表将被删除，该数据库的所有 vgroups 也会被全部销毁，请谨慎使用！
 
 ## 修改数据库参数
 
-```
-ALTER DATABASE db_name COMP 2;
-```
+```sql
+ALTER DATABASE db_name [alter_database_options]
 
-COMP 参数是指修改数据库文件压缩标志位，缺省值为 2，取值范围为 [0, 2]。0 表示不压缩，1 表示一阶段压缩，2 表示两阶段压缩。
+alter_database_options:
+    alter_database_option ...
 
+alter_database_option: {
+    CACHEMODEL {'none' | 'last_row' | 'last_value' | 'both'}
+  | CACHESIZE value
+  | FSYNC value
+  | KEEP value
+  | WAL value
+}
 ```
-ALTER DATABASE db_name REPLICA 2;
-```
-
-REPLICA 参数是指修改数据库副本数，取值范围 [1, 3]。在集群中使用，副本数必须小于或等于 DNODE 的数目。
 
-```
-ALTER DATABASE db_name KEEP 365;
-```
+:::note
+其它参数在 3.0.0.0 中暂不支持修改
 
-KEEP 参数是指修改数据文件保存的天数，缺省值为 3650，取值范围 [days, 365000]，必须大于或等于 days 参数值。
+:::
 
-```
-ALTER DATABASE db_name QUORUM 2;
-```
+## 查看数据库
 
-QUORUM 参数是指数据写入成功所需要的确认数，取值范围 [1, 2]。对于异步复制，quorum 设为 1，具有 master 角色的虚拟节点自己确认即可。对于同步复制，quorum 设为 2。原则上，Quorum >= 1 并且 Quorum <= replica(副本数)，这个参数在启动一个同步模块实例时需要提供。
+### 查看系统中的所有数据库
 
 ```
-ALTER DATABASE db_name BLOCKS 100;
+SHOW DATABASES;
 ```
 
-BLOCKS 参数是每个 VNODE (TSDB) 中有多少 cache 大小的内存块，因此一个 VNODE 的用的内存大小粗略为（cache \* blocks）。取值范围 [3, 1000]。
+### 显示一个数据库的创建语句
 
 ```
-ALTER DATABASE db_name CACHELAST 0;
+SHOW CREATE DATABASE db_name;
 ```
 
-CACHELAST 参数控制是否在内存中缓存子表的最近数据。缺省值为 0，取值范围 [0, 1, 2, 3]。其中 0 表示不缓存，1 表示缓存子表最近一行数据，2 表示缓存子表每一列的最近的非 NULL 值，3 表示同时打开缓存最近行和列功能。（从 2.0.11.0 版本开始支持参数值 [0, 1]，从 2.1.2.0 版本开始支持参数值 [0, 1, 2, 3]。）  
-说明：缓存最近行，将显著改善 LAST_ROW 函数的性能表现；缓存每列的最近非 NULL 值，将显著改善无特殊影响（WHERE、ORDER BY、GROUP BY、INTERVAL）下的 LAST 函数的性能表现。
-
-:::tip
-以上所有参数修改后都可以用 show databases 来确认是否修改成功。另外，从 2.1.3.0 版本开始，修改这些参数后无需重启服务器即可生效。
-:::
+常用于数据库迁移。对一个已经存在的数据库，返回其创建语句；在另一个集群中执行该语句，就能得到一个设置完全相同的 Database。
 
-## 显示系统所有数据库
+### 查看数据库参数
 
-```
-SHOW DATABASES;
+```sql
+SHOW DATABASES \G;
 ```
 
-## 显示一个数据库的创建语句
+会列出系统中所有数据库的配置参数，并且每行只显示一个参数。
 
-```
-SHOW CREATE DATABASE db_name;
-```
+## 删除过期数据
 
-常用于数据库迁移。对一个已经存在的数据库，返回其创建语句；在另一个集群中执行该语句，就能得到一个设置完全相同的 Database。
+```sql
+TRIM DATABASE db_name;
+```
 
+删除过期数据，并根据多级存储的配置归整数据。

docs/zh/12-taos-sql/03-table.md

@@ -2,13 +2,45 @@
 title: 表管理
 ---
 
-## 创建数据表
-
-```
-CREATE TABLE [IF NOT EXISTS] tb_name (timestamp_field_name TIMESTAMP, field1_name data_type1 [, field2_name data_type2 ...]);
-```
-
-:::info 说明
+## 创建表
+
+`CREATE TABLE` 语句用于创建普通表和以超级表为模板创建子表。
+
+```sql
+CREATE TABLE [IF NOT EXISTS] [db_name.]tb_name (create_definition [, create_definitionn] ...) [table_options]
+ 
+CREATE TABLE create_subtable_clause
+ 
+CREATE TABLE [IF NOT EXISTS] [db_name.]tb_name (create_definition [, create_definitionn] ...)
+    [TAGS (create_definition [, create_definitionn] ...)]
+    [table_options]
+ 
+create_subtable_clause: {
+    create_subtable_clause [create_subtable_clause] ...
+  | [IF NOT EXISTS] [db_name.]tb_name USING [db_name.]stb_name [(tag_name [, tag_name] ...)] TAGS (tag_value [, tag_value] ...)
+}
+ 
+create_definition:
+    col_name column_definition
+ 
+column_definition:
+    type_name [comment 'string_value']
+ 
+table_options:
+    table_option ...
+ 
+table_option: {
+    COMMENT 'string_value'
+  | WATERMARK duration[,duration]
+  | MAX_DELAY duration[,duration]
+  | ROLLUP(func_name [, func_name] ...)
+  | SMA(col_name [, col_name] ...)
+  | TTL value
+}
+
+```
+
+**使用说明**
 
 1. 表的第一个字段必须是 TIMESTAMP，并且系统自动将其设为主键；
 2. 表名最大长度为 192；
@@ -18,106 +50,149 @@ CREATE TABLE [IF NOT EXISTS] tb_name (timestamp_field_name TIMESTAMP, field1_nam
 6. 为了兼容支持更多形式的表名，TDengine 引入新的转义符 "\`"，可以让表名与关键词不冲突，同时不受限于上述表名称合法性约束检查。但是同样具有长度限制要求。使用转义字符以后，不再对转义字符中的内容进行大小写统一。
    例如：\`aBc\` 和 \`abc\` 是不同的表名，但是 abc 和 aBc 是相同的表名。
    需要注意的是转义字符中的内容必须是可打印字符。
-   上述的操作逻辑和约束要求与 MySQL 数据的操作一致。
-   从 2.3.0.0 版本开始支持这种方式。
 
-:::
+**参数说明**
+1. COMMENT：表注释。可用于超级表、子表和普通表。
+2. WATERMARK：指定窗口的关闭时间，默认值为 5 秒，最小单位毫秒，范围为0到15分钟，多个以逗号分隔。只可用于超级表，且只有当数据库使用了RETENTIONS参数时，才可以使用此表参数。
+3. MAX_DELAY：用于控制推送计算结果的最大延迟，默认值为 interval 的值(但不能超过最大值)，最小单位毫秒，范围为1毫秒到15分钟，多个以逗号分隔。注：不建议 MAX_DELAY 设置太小，否则会过于频繁的推送结果，影响存储和查询性能，如无特殊需求，取默认值即可。只可用于超级表，且只有当数据库使用了RETENTIONS参数时，才可以使用此表参数。
+4. ROLLUP：Rollup 指定的聚合函数，提供基于多层级的降采样聚合结果。只可用于超级表。只有当数据库使用了RETENTIONS参数时，才可以使用此表参数。作用于超级表除TS列外的其它所有列，但是只能定义一个聚合函数。 聚合函数支持 avg, sum, min, max, last, first。
+5. SMA：Small Materialized Aggregates，提供基于数据块的自定义预计算功能。预计算类型包括MAX、MIN和SUM。可用于超级表/普通表。
+6. TTL：Time to Live，是用户用来指定表的生命周期的参数。如果在持续的TTL时间内，都没有数据写入该表，则TDengine系统会自动删除该表。这个TTL的时间只是一个大概时间，我们系统不保证到了时间一定会将其删除，而只保证存在这样一个机制。TTL单位是天，默认为0，表示不限制。用户需要注意，TTL优先级高于KEEP，即TTL时间满足删除机制时，即使当前数据的存在时间小于KEEP，此表也会被删除。只可用于子表和普通表。
 
-### 以超级表为模板创建数据表
+## 创建子表
 
-```
+### 创建子表
+
+```sql
 CREATE TABLE [IF NOT EXISTS] tb_name USING stb_name TAGS (tag_value1, ...);
 ```
 
-以指定的超级表为模板，指定 TAGS 的值来创建数据表。
-
-### 以超级表为模板创建数据表，并指定具体的 TAGS 列
+### 创建子表并指定标签的值
 
-```
+```sql
 CREATE TABLE [IF NOT EXISTS] tb_name USING stb_name (tag_name1, ...) TAGS (tag_value1, ...);
 ```
 
-以指定的超级表为模板，指定一部分 TAGS 列的值来创建数据表（没被指定的 TAGS 列会设为空值）。
-说明：从 2.0.17.0 版本开始支持这种方式。在之前的版本中，不允许指定 TAGS 列，而必须显式给出所有 TAGS 列的取值。
+以指定的超级表为模板，也可以指定一部分 TAGS 列的值来创建数据表（没被指定的 TAGS 列会设为空值）。
 
-### 批量创建数据表
+### 批量创建子表
 
-```
+```sql
 CREATE TABLE [IF NOT EXISTS] tb_name1 USING stb_name TAGS (tag_value1, ...) [IF NOT EXISTS] tb_name2 USING stb_name TAGS (tag_value2, ...) ...;
 ```
 
-以更快的速度批量创建大量数据表（服务器端 2.0.14 及以上版本）。
+批量建表方式要求数据表必须以超级表为模板。 在不超出 SQL 语句长度限制的前提下，单条语句中的建表数量建议控制在 1000 ～ 3000 之间，将会获得比较理想的建表速度。
+
+## 修改普通表
 
-:::info
+```sql
+ALTER TABLE [db_name.]tb_name alter_table_clause
+ 
+alter_table_clause: {
+    alter_table_options
+  | ADD COLUMN col_name column_type
+  | DROP COLUMN col_name
+  | MODIFY COLUMN col_name column_type
+  | RENAME COLUMN old_col_name new_col_name
+}
+ 
+alter_table_options:
+    alter_table_option ...
+ 
+alter_table_option: {
+    TTL value
+  | COMMENT 'string_value'
+}
 
-1.批量建表方式要求数据表必须以超级表为模板。 2.在不超出 SQL 语句长度限制的前提下，单条语句中的建表数量建议控制在 1000 ～ 3000 之间，将会获得比较理想的建表速度。
+```
 
-:::
+**使用说明**
+对普通表可以进行如下修改操作
+1. ADD COLUMN：添加列。
+2. DROP COLUMN：删除列。
+3. ODIFY COLUMN：修改列定义，如果数据列的类型是可变长类型，那么可以使用此指令修改其宽度，只能改大，不能改小。
+4. RENAME COLUMN：修改列名称。
 
-## 删除数据表
+### 增加列
 
-```
-DROP TABLE [IF EXISTS] tb_name;
+```sql
+ALTER TABLE tb_name ADD COLUMN field_name data_type;
 ```
 
-## 显示当前数据库下的所有数据表信息
+### 删除列
 
-```
-SHOW TABLES [LIKE tb_name_wildchar];
+```sql
+ALTER TABLE tb_name DROP COLUMN field_name;
 ```
 
-显示当前数据库下的所有数据表信息。
+### 修改列宽
 
-## 显示一个数据表的创建语句
+```sql
+ALTER TABLE tb_name MODIFY COLUMN field_name data_type(length);
+```
 
+### 修改列名
+
+```sql
+ALTER TABLE tb_name RENAME COLUMN old_col_name new_col_name
 ```
-SHOW CREATE TABLE tb_name;
+
+## 修改子表
+
+```sql
+ALTER TABLE [db_name.]tb_name alter_table_clause
+ 
+alter_table_clause: {
+    alter_table_options
+  | SET TAG tag_name = new_tag_value
+}
+ 
+alter_table_options:
+    alter_table_option ...
+ 
+alter_table_option: {
+    TTL value
+  | COMMENT 'string_value'
+}
 ```
 
-常用于数据库迁移。对一个已经存在的数据表，返回其创建语句；在另一个集群中执行该语句，就能得到一个结构完全相同的数据表。
+**使用说明**
+1. 对子表的列和标签的修改，除了更改标签值以外，都要通过超级表才能进行。
 
-## 获取表的结构信息
+### 修改子表标签值
 
 ```
-DESCRIBE tb_name;
+ALTER TABLE tb_name SET TAG tag_name=new_tag_value;
 ```
 
-## 修改表定义
+## 删除表
 
-### 表增加列
+可以在一条SQL语句中删除一个或多个普通表或子表。
 
+```sql
+DROP TABLE [IF EXISTS] [db_name.]tb_name [, [IF EXISTS] [db_name.]tb_name] ...
 ```
-ALTER TABLE tb_name ADD COLUMN field_name data_type;
-```
-
-:::info
 
-1. 列的最大个数为 1024，最小个数为 2；（从 2.1.7.0 版本开始，改为最多允许 4096 列）
-2. 列名最大长度为 64。
+## 查看表的信息
 
-:::
+### 显示所有表
 
-### 表删除列
+如下SQL语句可以列出当前数据库中的所有表名。
 
+```sql
+SHOW TABLES [LIKE tb_name_wildchar];
 ```
-ALTER TABLE tb_name DROP COLUMN field_name;
-```
-
-如果表是通过超级表创建，更改表结构的操作只能对超级表进行。同时针对超级表的结构更改对所有通过该结构创建的表生效。对于不是通过超级表创建的表，可以直接修改表结构。
 
-### 表修改列宽
+### 显示表创建语句
 
 ```
-ALTER TABLE tb_name MODIFY COLUMN field_name data_type(length);
+SHOW CREATE TABLE tb_name;
 ```
 
-如果数据列的类型是可变长格式（BINARY 或 NCHAR），那么可以使用此指令修改其宽度（只能改大，不能改小）。（2.1.3.0 版本新增）
-如果表是通过超级表创建，更改表结构的操作只能对超级表进行。同时针对超级表的结构更改对所有通过该结构创建的表生效。对于不是通过超级表创建的表，可以直接修改表结构。
+常用于数据库迁移。对一个已经存在的数据表，返回其创建语句；在另一个集群中执行该语句，就能得到一个结构完全相同的数据表。
 
-### 修改子表标签值
+### 获取表结构信息
 
 ```
-ALTER TABLE tb_name SET TAG tag_name=new_tag_value;
-```
-
+DESCRIBE [db_name.]tb_name;
+```
\ No newline at end of file
-如果表是通过超级表创建，可以使用此指令修改其标签值

docs/zh/12-taos-sql/04-stable.md

@@ -3,87 +3,121 @@ sidebar_label: 超级表管理
 title: 超级表 STable 管理
 ---
 
-:::note
-
-在 2.0.15.0 及以后的版本中开始支持 STABLE 保留字。也即，在本节后文的指令说明中，CREATE、DROP、ALTER 三个指令在 2.0.15.0 之前的版本中 STABLE 保留字需写作 TABLE。
-
-:::
-
 ## 创建超级表
 
-```
-CREATE STABLE [IF NOT EXISTS] stb_name (timestamp_field_name TIMESTAMP, field1_name data_type1 [, field2_name data_type2 ...]) TAGS (tag1_name tag_type1, tag2_name tag_type2 [, tag3_name tag_type3]);
+```sql
+CREATE STABLE [IF NOT EXISTS] stb_name (create_definition [, create_definitionn] ...) TAGS (create_definition [, create_definition] ...) [table_options]
+ 
+create_definition:
+    col_name column_definition
+ 
+column_definition:
+    type_name [COMMENT 'string_value']
 ```
 
-创建 STable，与创建表的 SQL 语法相似，但需要指定 TAGS 字段的名称和类型。
+**使用说明**
+- 超级表中列的最大个数为 4096，需要注意，这里的 4096 是包含 TAG 列在内的，最小个数为 3，包含一个时间戳主键、一个 TAG 列和一个数据列。
+- 建表时可以给列或标签附加注释。
+- TAGS语法指定超级表的标签列，标签列需要遵循以下约定：
+    - TAGS 中的 TIMESTAMP 列写入数据时需要提供给定值，而暂不支持四则运算，例如 NOW + 10s 这类表达式。
+    - TAGS 列名不能与其他列名相同。
+    - TAGS 列名不能为预留关键字。
+    - TAGS 最多允许 128 个，至少 1 个，总长度不超过 16 KB。
+- 关于表参数的详细说明，参见 CREATE TABLE 中的介绍。
 
-:::info
+## 查看超级表
 
-1. TAGS 列的数据类型不能是 timestamp 类型；（从 2.1.3.0 版本开始，TAGS 列中支持使用 timestamp 类型，但需注意在 TAGS 中的 timestamp 列写入数据时需要提供给定值，而暂不支持四则运算，例如 `NOW + 10s` 这类表达式）
-2. TAGS 列名不能与其他列名相同；
-3. TAGS 列名不能为预留关键字（参见：[参数限制与保留关键字](/taos-sql/keywords/) 章节）；
-4. TAGS 最多允许 128 个，至少 1 个，总长度不超过 16 KB。
+### 显示当前数据库下的所有超级表信息
 
-:::
+```
+SHOW STABLES [LIKE tb_name_wildcard];
+```
 
-## 删除超级表
+查看数据库内全部 STable，及其相关信息，包括 STable 的名称、创建时间、列数量、标签（TAG）数量、通过该 STable 建表的数量。
+
+### 显示一个超级表的创建语句
 
 ```
-DROP STABLE [IF EXISTS] stb_name;
+SHOW CREATE STABLE stb_name;
 ```
 
-删除 STable 会自动删除通过 STable 创建的子表。
+常用于数据库迁移。对一个已经存在的超级表，返回其创建语句；在另一个集群中执行该语句，就能得到一个结构完全相同的超级表。
 
-## 显示当前数据库下的所有超级表信息
+### 获取超级表的结构信息
 
 ```
-SHOW STABLES [LIKE tb_name_wildcard];
+DESCRIBE [db_name.]stb_name;
 ```
 
-查看数据库内全部 STable，及其相关信息，包括 STable 的名称、创建时间、列数量、标签（TAG）数量、通过该 STable 建表的数量。
-
-## 显示一个超级表的创建语句
+## 删除超级表
 
 ```
-SHOW CREATE STABLE stb_name;
+DROP STABLE [IF EXISTS] [db_name.]stb_name
 ```
 
-常用于数据库迁移。对一个已经存在的超级表，返回其创建语句；在另一个集群中执行该语句，就能得到一个结构完全相同的超级表。
+删除 STable 会自动删除通过 STable 创建的子表以及子表中的所有数据。
 
-## 获取超级表的结构信息
+## 修改超级表
+
+```sql
+ALTER STABLE [db_name.]tb_name alter_table_clause
+ 
+alter_table_clause: {
+    alter_table_options
+  | ADD COLUMN col_name column_type
+  | DROP COLUMN col_name
+  | MODIFY COLUMN col_name column_type
+  | ADD TAG tag_name tag_type
+  | DROP TAG tag_name
+  | MODIFY TAG tag_name tag_type
+  | RENAME TAG old_tag_name new_tag_name
+}
+ 
+alter_table_options:
+    alter_table_option ...
+ 
+alter_table_option: {
+    COMMENT 'string_value'
+}
 
-```
-DESCRIBE stb_name;
 ```
 
-## 修改超级表普通列
+**使用说明**
 
-### 超级表增加列
+修改超级表的结构会对其下的所有子表生效。无法针对某个特定子表修改表结构。标签结构的修改需要对超级表下发，TDengine 会自动作用于此超级表的所有子表。
+
+- ADD COLUMN：添加列。
+- DROP COLUMN：删除列。
+- MODIFY COLUMN：修改列定义，如果数据列的类型是可变长类型，那么可以使用此指令修改其宽度，只能改大，不能改小。
+- ADD TAG：给超级表添加一个标签。
+- DROP TAG：删除超级表的一个标签。从超级表删除某个标签后，该超级表下的所有子表也会自动删除该标签。
+- MODIFY TAG：修改超级表的一个标签的定义。如果标签的类型是可变长类型，那么可以使用此指令修改其宽度，只能改大，不能改小。
+- RENAME TAG：修改超级表的一个标签的名称。从超级表修改某个标签名后，该超级表下的所有子表也会自动更新该标签名。
+
+### 增加列
 
 ```
-ALTER STABLE stb_name ADD COLUMN field_name data_type;
+ALTER STABLE stb_name ADD COLUMN col_name column_type;
 ```
 
-### 超级表删除列
+### 删除列
 
 ```
-ALTER STABLE stb_name DROP COLUMN field_name;
+ALTER STABLE stb_name DROP COLUMN col_name;
 ```
 
-### 超级表修改列宽
+### 修改列宽
 
 ```
-ALTER STABLE stb_name MODIFY COLUMN field_name data_type(length);
+ALTER STABLE stb_name MODIFY COLUMN col_name data_type(length);
 ```
 
-如果数据列的类型是可变长格式（BINARY 或 NCHAR），那么可以使用此指令修改其宽度（只能改大，不能改小）。（2.1.3.0 版本新增）
-
-## 修改超级表标签列
+如果数据列的类型是可变长格式（BINARY 或 NCHAR），那么可以使用此指令修改其宽度（只能改大，不能改小）。
 
 ### 添加标签
 
 ```
-ALTER STABLE stb_name ADD TAG new_tag_name tag_type;
+ALTER STABLE stb_name ADD TAG tag_name tag_type;
 ```
 
 为 STable 增加一个新的标签，并指定新标签的类型。标签总数不能超过 128 个，总长度不超过 16KB 。
@@ -99,7 +133,7 @@ ALTER STABLE stb_name DROP TAG tag_name;
 ### 修改标签名
 
 ```
-ALTER STABLE stb_name CHANGE TAG old_tag_name new_tag_name;
+ALTER STABLE stb_name RENAME TAG old_tag_name new_tag_name;
 ```
 
 修改超级表的标签名，从超级表修改某个标签名后，该超级表下的所有子表也会自动更新该标签名。

docs/zh/12-taos-sql/05-insert.md

@@ -5,7 +5,7 @@ title: 数据写入
 
 ## 写入语法
 
-```
+```sql
 INSERT INTO
     tb_name
         [USING stb_name [(tag1_name, ...)] TAGS (tag1_value, ...)]
@@ -18,46 +18,64 @@ INSERT INTO
     ...];
 ```
 
-## 插入一条或多条记录
+**关于时间戳**
+
+1. TDengine 要求插入的数据必须要有时间戳，插入数据的时间戳要注意以下几点：
+
+2. 时间戳不同的格式语法会有不同的精度影响。字符串格式的时间戳写法不受所在 DATABASE 的时间精度设置影响；而长整形格式的时间戳写法会受到所在 DATABASE 的时间精度设置影响。例如，时间戳"2021-07-13 16:16:48"的 UNIX 秒数为 1626164208。则其在毫秒精度下需要写作 1626164208000，在微秒精度设置下就需要写为 1626164208000000，纳秒精度设置下需要写为 1626164208000000000。
+
+3. 一次插入多行数据时，不要把首列的时间戳的值都写 NOW。否则会导致语句中的多条记录使用相同的时间戳，于是就可能出现相互覆盖以致这些数据行无法全部被正确保存。其原因在于，NOW 函数在执行中会被解析为所在 SQL 语句的客户端执行时间，出现在同一语句中的多个 NOW 标记也就会被替换为完全相同的时间戳取值。
+   允许插入的最老记录的时间戳，是相对于当前服务器时间，减去配置的 KEEP 值（数据保留的天数）。允许插入的最新记录的时间戳，是相对于当前服务器时间，加上配置的 DURATION 值（数据文件存储数据的时间跨度，单位为天）。KEEP 和 DURATION 都是可以在创建数据库时指定的，缺省值分别是 3650 天和 10 天。
+
+**语法说明**
+
+1. USING 子句是自动建表语法。如果用户在写数据时并不确定某个表是否存在，此时可以在写入数据时使用自动建表语法来创建不存在的表，若该表已存在则不会建立新表。自动建表时，要求必须以超级表为模板，并写明数据表的 TAGS 取值。可以只是指定部分 TAGS 列的取值，未被指定的 TAGS 列将置为 NULL。
+
+2. 可以指定要插入值的列，对于为指定的列数据库将自动填充为 NULL。
+
+3. VALUES 语法表示了要插入的一行或多行数据。
+
+4. FILE 语法表示数据来自于 CSV 文件（英文逗号分隔、英文单引号括住每个值），CSV 文件无需表头。
+
+5. 无论使用哪种语法，均可以在一条 INSERT 语句中同时向多个表插入数据。
+
+6. INSERT 语句是完整解析后再执行的，对如下语句，不会再出现数据错误但建表成功的情况：
+
+   ```sql
+   INSERT INTO d1001 USING meters TAGS('Beijing.Chaoyang', 2) VALUES('a');
+   ```
+
+7. 对于向多个子表插入数据的情况，依然会有部分数据写入失败，部分数据写入成功的情况。这是因为多个子表可能分布在不同的 VNODE 上，客户端将 INSERT 语句完整解析后，将数据发往各个涉及的 VNODE 上，每个 VNODE 独立进行写入操作。如果某个 VNODE 因为某些原因（比如网络问题或磁盘故障）导致写入失败，并不会影响其他 VNODE 节点的写入。
+
+## 插入一条记录
 
 指定已经创建好的数据子表的表名，并通过 VALUES 关键字提供一行或多行数据，即可向数据库写入这些数据。例如，执行如下语句可以写入一行记录：
 
-```
+```sql
 INSERT INTO d1001 VALUES (NOW, 10.2, 219, 0.32);
 ```
 
+## 插入多条记录
+
 或者，可以通过如下语句写入两行记录：
 
-```
+```sql
 INSERT INTO d1001 VALUES ('2021-07-13 14:06:32.272', 10.2, 219, 0.32) (1626164208000, 10.15, 217, 0.33);
 ```
 
-:::note
-
-1. 在第二个例子中，两行记录的首列时间戳使用了不同格式的写法。其中字符串格式的时间戳写法不受所在 DATABASE 的时间精度设置影响；而长整形格式的时间戳写法会受到所在 DATABASE 的时间精度设置影响——例子中的时间戳在毫秒精度下可以写作 1626164208000，而如果是在微秒精度设置下就需要写为 1626164208000000，纳秒精度设置下需要写为 1626164208000000000。
-2. 在使用“插入多条记录”方式写入数据时，不能把第一列的时间戳取值都设为 NOW，否则会导致语句中的多条记录使用相同的时间戳，于是就可能出现相互覆盖以致这些数据行无法全部被正确保存。其原因在于，NOW 函数在执行中会被解析为所在 SQL 语句的实际执行时间，出现在同一语句中的多个 NOW 标记也就会被替换为完全相同的时间戳取值。
-3. 允许插入的最老记录的时间戳，是相对于当前服务器时间，减去配置的 keep 值（数据保留的天数）；允许插入的最新记录的时间戳，是相对于当前服务器时间，加上配置的 days 值（数据文件存储数据的时间跨度，单位为天）。keep 和 days 都是可以在创建数据库时指定的，缺省值分别是 3650 天和 10 天。
-
-:::
-
-## 插入记录，数据对应到指定的列
+## 指定列插入
 
 向数据子表中插入记录时，无论插入一行还是多行，都可以让数据对应到指定的列。对于 SQL 语句中没有出现的列，数据库将自动填充为 NULL。主键（时间戳）不能为 NULL。例如：
 
-```
+```sql
 INSERT INTO d1001 (ts, current, phase) VALUES ('2021-07-13 14:06:33.196', 10.27, 0.31);
 ```
 
-:::info
-如果不指定列，也即使用全列模式——那么在 VALUES 部分提供的数据，必须为数据表的每个列都显式地提供数据。全列模式写入速度会远快于指定列，因此建议尽可能采用全列写入方式，此时空列可以填入 NULL。
-
-:::
-
 ## 向多个表插入记录
 
 可以在一条语句中，分别向多个表插入一条或多条记录，并且也可以在插入过程中指定列。例如：
 
-```
+```sql
 INSERT INTO d1001 VALUES ('2021-07-13 14:06:34.630', 10.2, 219, 0.32) ('2021-07-13 14:06:35.779', 10.15, 217, 0.33)
             d1002 (ts, current, phase) VALUES ('2021-07-13 14:06:34.255', 10.27, 0.31）;
 ```
@@ -66,28 +84,24 @@ INSERT INTO d1001 VALUES ('2021-07-13 14:06:34.630', 10.2, 219, 0.32) ('2021-07-
 
 如果用户在写数据时并不确定某个表是否存在，此时可以在写入数据时使用自动建表语法来创建不存在的表，若该表已存在则不会建立新表。自动建表时，要求必须以超级表为模板，并写明数据表的 TAGS 取值。例如：
 
-```
+```sql
 INSERT INTO d21001 USING meters TAGS ('California.SanFrancisco', 2) VALUES ('2021-07-13 14:06:32.272', 10.2, 219, 0.32);
 ```
 
 也可以在自动建表时，只是指定部分 TAGS 列的取值，未被指定的 TAGS 列将置为 NULL。例如：
 
-```
+```sql
 INSERT INTO d21001 USING meters (groupId) TAGS (2) VALUES ('2021-07-13 14:06:33.196', 10.15, 217, 0.33);
 ```
 
 自动建表语法也支持在一条语句中向多个表插入记录。例如：
 
-```
+```sql
 INSERT INTO d21001 USING meters TAGS ('California.SanFrancisco', 2) VALUES ('2021-07-13 14:06:34.630', 10.2, 219, 0.32) ('2021-07-13 14:06:35.779', 10.15, 217, 0.33)
             d21002 USING meters (groupId) TAGS (2) VALUES ('2021-07-13 14:06:34.255', 10.15, 217, 0.33)
             d21003 USING meters (groupId) TAGS (2) (ts, current, phase) VALUES ('2021-07-13 14:06:34.255', 10.27, 0.31);
 ```
 
-:::info
-在 2.0.20.5 版本之前，在使用自动建表语法并指定列时，子表的列名必须紧跟在子表名称后面，而不能如例子里那样放在 TAGS 和 VALUES 之间。从 2.0.20.5 版本开始，两种写法都可以，但不能在一条 SQL 语句中混用，否则会报语法错误。
-:::
-
 ## 插入来自文件的数据记录
 
 除了使用 VALUES 关键字插入一行或多行数据外，也可以把要写入的数据放在 CSV 文件中（英文逗号分隔、英文单引号括住每个值）供 SQL 指令读取。其中 CSV 文件无需表头。例如，如果 /tmp/csvfile.csv 文件的内容为：
@@ -99,51 +113,19 @@ INSERT INTO d21001 USING meters TAGS ('California.SanFrancisco', 2) VALUES ('202
 
 那么通过如下指令可以把这个文件中的数据写入子表中：
 
-```
+```sql
 INSERT INTO d1001 FILE '/tmp/csvfile.csv';
 ```
 
 ## 插入来自文件的数据记录，并自动建表
 
-从 2.1.5.0 版本开始，支持在插入来自 CSV 文件的数据时，以超级表为模板来自动创建不存在的数据表。例如：
-
-```
+```sql
 INSERT INTO d21001 USING meters TAGS ('California.SanFrancisco', 2) FILE '/tmp/csvfile.csv';
 ```
 
 也可以在一条语句中向多个表以自动建表的方式插入记录。例如：
 
-```
+```sql
 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';
 ```
-
-## 历史记录写入
-
-可使用 IMPORT 或者 INSERT 命令，IMPORT 的语法，功能与 INSERT 完全一样。
-
-针对 insert 类型的 SQL 语句，我们采用的流式解析策略，在发现后面的错误之前，前面正确的部分 SQL 仍会执行。下面的 SQL 中，INSERT 语句是无效的，但是 d1001 仍会被创建。
-
-```
-taos> CREATE TABLE meters(ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS(location BINARY(30), groupId INT);
-Query OK, 0 row(s) affected (0.008245s)
-
-taos> SHOW STABLES;
-              name              |      created_time       | columns |  tags  |   tables    |
-============================================================================================
- meters                         | 2020-08-06 17:50:27.831 |       4 |      2 |           0 |
-Query OK, 1 row(s) in set (0.001029s)
-
-taos> SHOW TABLES;
-Query OK, 0 row(s) in set (0.000946s)
-
-taos> INSERT INTO d1001 USING meters TAGS('California.SanFrancisco', 2) VALUES('a');
-
-DB error: invalid SQL: 'a' (invalid timestamp) (0.039494s)
-
-taos> SHOW TABLES;
-           table_name           |      created_time       | columns |          stable_name           |
-======================================================================================================
- d1001                          | 2020-08-06 17:52:02.097 |       4 | meters                         |
-Query OK, 1 row(s) in set (0.001091s)
-```

docs/zh/12-taos-sql/08-delete-data.mdx

@@ -5,8 +5,6 @@ title: "删除数据"
 ---
 
 删除数据是 TDengine 提供的根据指定时间段删除指定表或超级表中数据记录的功能，方便用户清理由于设备故障等原因产生的异常数据。
-注意：本功能只在企业版 2.6.0.0 及以后的版本中提供，如需此功能请点击下面的链接访问[企业版产品](https://www.taosdata.com/products#enterprise-edition-link)
-
 
 **语法：**
 
@@ -17,21 +15,21 @@ DELETE FROM [ db_name. ] tb_name [WHERE condition];
 **功能：** 删除指定表或超级表中的数据记录
 
 **参数：**
-   
-- `db_name` ：  可选参数，指定要删除表所在的数据库名，不填写则在当前数据库中
-- `tb_name` ：  必填参数，指定要删除数据的表名，可以是普通表、子表，也可以是超级表。
-- `condition`： 可选参数，指定删除数据的过滤条件，不指定过滤条件则为表中所有数据，请慎重使用。特别说明，这里的where 条件中只支持对第一列时间列的过滤，如果是超级表，支持对 tag 列过滤。
+
+- `db_name` ： 可选参数，指定要删除表所在的数据库名，不填写则在当前数据库中
+- `tb_name` ： 必填参数，指定要删除数据的表名，可以是普通表、子表，也可以是超级表。
+- `condition`： 可选参数，指定删除数据的过滤条件，不指定过滤条件则为表中所有数据，请慎重使用。特别说明，这里的 where 条件中只支持对第一列时间列的过滤。
 
 **特别说明：**
-      
-数据删除后不可恢复，请慎重使用。为了确保删除的数据确实是自己要删除的，建议可以先使用 `select` 语句加 `where` 后的删除条件查看要删除的数据内容，确认无误后再执行 `delete` 命令。      
+
+数据删除后不可恢复，请慎重使用。为了确保删除的数据确实是自己要删除的，建议可以先使用 `select` 语句加 `where` 后的删除条件查看要删除的数据内容，确认无误后再执行 `delete` 命令。
 
 **示例：**
-    
-`meters` 是一个超级表，`groupid` 是 int 类型的 tag 列，现在要删除 `meters` 表中时间小于 2021-10-01 10:40:00.100 且 tag 列 `groupid` 值为 1 的所有数据，sql 如下：
+
+`meters` 是一个超级表，`groupid` 是 int 类型的 tag 列，现在要删除 `meters` 表中时间小于 2021-10-01 10:40:00.100 的所有数据，sql 如下：
 
 ```sql
-delete from meters where ts < '2021-10-01 10:40:00.100' and groupid=1 ;
+delete from meters where ts < '2021-10-01 10:40:00.100' ;
 ```
 
 执行后显示结果为：

docs/zh/12-taos-sql/12-interval.md → docs/zh/12-taos-sql/12-distinguished.md

@@ -12,16 +12,16 @@ TDengine 提供的特色查询包括标签切分查询和窗口切分查询。
 超级表查询中，当需要针对标签进行数据切分然后在切分出的数据空间内再进行一系列的计算时使用标签切分子句，标签切分的语句如下：
 
 ```sql
-PARTITION BY tag_list
+PARTITION BY part_list
 ```
 
-其中 `tag_list` 是标签列的列表，还可以包括 tbname 伪列。
+part_list 可以是任意的标量表达式，包括列、常量、标量函数和它们的组合。
 
-TDengine 按如下方式处理标签切分子句：
+当 PARTITION BY 和标签一起使用时，TDengine 按如下方式处理标签切分子句：
 
-标签切分子句位于 `WHERE` 子句之后，且不能和 `JOIN` 子句一起使用。
-标签切分子句将超级表数据按指定的标签组合进行切分，然后对每个切分的分片进行指定的计算。计算由之后的子句定义（窗口子句、`GROUP BY` 子句或`SELECT` 子句）。
-标签切分子句可以和窗口切分子句（或 `GROUP BY` 子句）一起使用，此时后面的子句作用在每个切分的分片上。例如，下面的示例将数据按标签 `location` 进行分组，并对每个组按 10 分钟进行降采样，取其最大值。
+- 标签切分子句位于 WHERE 子句之后，且不能和 JOIN 子句一起使用。
+- 标签切分子句将超级表数据按指定的标签组合进行切分，每个切分的分片进行指定的计算。计算由之后的子句定义（窗口子句、GROUP BY 子句或 SELECT 子句）。
+- 标签切分子句可以和窗口切分子句（或 GROUP BY 子句）一起使用，此时后面的子句作用在每个切分的分片上。例如，将数据按标签 location 进行分组，并对每个组按 10 分钟进行降采样，取其最大值。
 
 ```sql
 select max(current) from meters partition by location interval(10m)

docs/zh/12-taos-sql/13-tmq.md

+---
+sidebar_label: 消息队列
+title: 消息队列
+---
+
+TDengine 3.0.0.0 开始对消息队列做了大幅的优化和增强以简化用户的解决方案。
+
+## 创建订阅主题
+
+```sql
+CREATE TOPIC [IF NOT EXISTS] topic_name AS {subquery | DATABASE db_name | STABLE stb_name };
+```
+
+订阅主题包括三种：列订阅、超级表订阅和数据库订阅。
+
+**列订阅是**用 subquery 描述，支持过滤和标量函数和 UDF 标量函数，不支持 JOIN、GROUP BY、窗口切分子句、聚合函数和 UDF 聚合函数。列订阅规则如下：
+
+1. TOPIC 一旦创建则返回结果的字段确定
+2. 被订阅或用于计算的列不可被删除、修改
+3. 列可以新增，但新增的列不出现在订阅结果字段中
+4. 对于 select \*，则订阅展开为创建时所有的列（子表、普通表为数据列，超级表为数据列加标签列）
+
+**超级表订阅和数据库订阅**规则如下：
+
+1. 被订阅主体的 schema 变更不受限
+2. 返回消息中 schema 是块级别的，每块的 schema 可能不一样
+3. 列变更后写入的数据若未落盘，将以写入时的 schema 返回
+4. 列变更后写入的数据若未已落盘，将以落盘时的 schema 返回
+
+## 删除订阅主题
+
+```sql
+DROP TOPIC [IF EXISTS] topic_name;
+```
+
+此时如果该订阅主题上存在 consumer，则此 consumer 会收到一个错误。
+
+## 查看订阅主题
+
+## SHOW TOPICS
+
+```sql
+SHOW TOPICS;
+```
+
+显示当前数据库下的所有主题的信息。
+
+## 创建消费组
+
+消费组的创建只能通过 TDengine 客户端驱动或者连接器所提供的 API 创建。
+
+## 删除消费组
+
+```sql
+DROP CONSUMER GROUP [IF EXISTS] cgroup_name ON topic_name;
+```
+
+删除主题 topic_name 上的消费组 cgroup_name。
+
+## 查看消费组
+
+```sql
+SHOW CONSUMERS;
+```
+
+显示当前数据库下所有活跃的消费者的信息。

docs/zh/12-taos-sql/14-stream.md

+---
+sidebar_label: 流式计算
+title: 流式计算
+---
+
+在时序数据的处理中，经常要对原始数据进行清洗、预处理，再使用时序数据库进行长久的储存。用户通常需要在时序数据库之外再搭建 Kafka、Flink、Spark 等流计算处理引擎，增加了用户的开发成本和维护成本。
+
+使用 TDengine 3.0 的流式计算引擎能够最大限度的减少对这些额外中间件的依赖，真正将数据的写入、预处理、长期存储、复杂分析、实时计算、实时报警触发等功能融为一体，并且，所有这些任务只需要使用 SQL 完成，极大降低了用户的学习成本、使用成本。
+
+## 创建流式计算
+
+```sql
+CREATE STREAM [IF NOT EXISTS] stream_name [stream_options] INTO stb_name AS subquery
+stream_options: {
+ TRIGGER    [AT_ONCE | WINDOW_CLOSE | MAX_DELAY time]
+ WATERMARK   time
+}
+
+```
+
+其中 subquery 是 select 普通查询语法的子集:
+
+```sql
+subquery: SELECT [DISTINCT] select_list
+    from_clause
+    [WHERE condition]
+    [PARTITION BY tag_list]
+    [window_clause]
+    [group_by_clause]
+```
+
+不支持 order_by，limit，slimit，fill 语句
+
+例如，如下语句创建流式计算，同时自动创建名为 avg_vol 的超级表，此流计算以一分钟为时间窗口、30 秒为前向增量统计这些电表的平均电压，并将来自 meters 表的数据的计算结果写入 avg_vol 表，不同 partition 的数据会分别创建子表并写入不同子表。
+
+```sql
+CREATE STREAM avg_vol_s INTO avg_vol AS
+SELECT _wstartts, count(*), avg(voltage) FROM meters PARTITION BY tbname INTERVAL(1m) SLIDING(30s);
+```
+
+## 删除流式计算
+
+```sql
+DROP STREAM [IF NOT EXISTS] stream_name
+```
+
+仅删除流式计算任务，由流式计算写入的数据不会被删除。
+
+## 展示流式计算
+
+```sql
+SHOW STREAMS;
+```
+
+## 流式计算的触发模式
+
+在创建流时，可以通过 TRIGGER 指令指定流式计算的触发模式。
+
+对于非窗口计算，流式计算的触发是实时的；对于窗口计算，目前提供 3 种触发模式：
+
+1. AT_ONCE：写入立即触发
+
+2. WINDOW_CLOSE：窗口关闭时触发（窗口关闭由事件时间决定，可配合 watermark 使用，详见《流式计算的乱序数据容忍策略》）
+
+3. MAX_DELAY time：若窗口关闭，则触发计算。若窗口未关闭，且未关闭时长超过 max delay 指定的时间，则触发计算。
+
+由于窗口关闭是由事件时间决定的，如事件流中断、或持续延迟，则事件时间无法更新，可能导致无法得到最新的计算结果。
+
+因此，流式计算提供了以事件时间结合处理时间计算的 MAX_DELAY 触发模式。
+
+MAX_DELAY 模式在窗口关闭时会立即触发计算。此外，当数据写入后，计算触发的时间超过 max delay 指定的时间，则立即触发计算
+
+## 流式计算的乱序数据容忍策略
+
+在创建流时，可以在 stream_option 中指定 watermark。
+
+流式计算通过 watermark 来度量对乱序数据的容忍程度，watermark 默认为 0。
+
+T = 最新事件时间 - watermark
+
+每批到来的数据都会以上述公式更新窗口关闭时间，并将窗口结束时间 < T 的所有打开的窗口关闭，若触发模式为 WINDOW_CLOSE 或 MAX_DELAY，则推送窗口聚合结果。
+
+流式计算的过期数据处理策略
+对于已关闭的窗口，再次落入该窗口中的数据被标记为过期数据，对于过期数据，流式计算提供两种处理方式：
+
+1. 直接丢弃：这是常见流式计算引擎提供的默认（甚至是唯一）计算模式
+
+2. 重新计算：从 TSDB 中重新查找对应窗口的所有数据并重新计算得到最新结果
+
+无论在哪种模式下，watermark 都应该被妥善设置，来得到正确结果（直接丢弃模式）或避免频繁触发重算带来的性能开销（重新计算模式）。
+
+## 流式计算的数据填充策略
+
+TODO
+
+## 流式计算与会话窗口（session window）
+
+```sql
+window_clause: {
+    SESSION(ts_col, tol_val)
+  | STATE_WINDOW(col)
+  | INTERVAL(interval_val [, interval_offset]) [SLIDING (sliding_val)] [FILL(fill_mod_and_val)]
+}
+```
+
+其中，SESSION 是会话窗口，tol_val 是时间间隔的最大范围。在 tol_val 时间间隔范围内的数据都属于同一个窗口，如果连续的两条数据的时间超过 tol_val，则自动开启下一个窗口。
+
+## 流式计算的监控与流任务分布查询
+
+TODO
+
+## 流式计算的内存控制与存算分离
+
+TODO
+
+## 流式计算的暂停与恢复
+
+```sql
+STOP STREAM stream_name;
+
+RESUME STREAM stream_name;
+```

docs/zh/12-taos-sql/19-limit.md

@@ -9,8 +9,8 @@ title: 命名与边界限制
 2. 允许英文字符或下划线开头，不允许以数字开头
 3. 不区分大小写
 4. 转义后表（列）名规则：
-   为了兼容支持更多形式的表（列）名，TDengine 引入新的转义符 "`"。可用让表名与关键词不冲突，同时不受限于上述表名称合法性约束检查。
-   转义后的表（列）名同样受到长度限制要求，且长度计算的时候不计算转义符。使用转义字符以后，不再对转义字符中的内容进行大小写统一。
+   为了兼容支持更多形式的表（列）名，TDengine 引入新的转义符 "`"。可用让表名与关键词不冲突，同时不受限于上述表名称合法性约束检查
+   转义后的表（列）名同样受到长度限制要求，且长度计算的时候不计算转义符。使用转义字符以后，不再对转义字符中的内容进行大小写统一
 
    例如：\`aBc\` 和 \`abc\` 是不同的表（列）名，但是 abc 和 aBc 是相同的表（列）名。
    需要注意的是转义字符中的内容必须是可打印字符。
@@ -23,28 +23,30 @@ title: 命名与边界限制
 
 ## 一般限制
 
-- 数据库名最大长度为 32。
+- 数据库名最大长度为 32
 - 表名最大长度为 192，不包括数据库名前缀和分隔符
-- 每行数据最大长度 48KB （注意：数据行内每个 BINARY/NCHAR 类型的列还会额外占用 2 个字节的存储位置）。
+- 每行数据最大长度 48KB （注意：数据行内每个 BINARY/NCHAR 类型的列还会额外占用 2 个字节的存储位置）
 - 列名最大长度为 64
 - 最多允许 4096 列，最少需要 2 列，第一列必须是时间戳。
 - 标签名最大长度为 64
-- 最多允许 128 个，至少要有 1 个标签，一个表中标签值的总长度不超过 16KB 。
-- SQL 语句最大长度 1048576 个字符，也可通过客户端配置参数 maxSQLLength 修改，取值范围 65480 ~ 1048576。
-- SELECT 语句的查询结果，最多允许返回 4096 列（语句中的函数调用可能也会占用一些列空间），超限时需要显式指定较少的返回数据列，以避免语句执行报错。
-- 库的数目，超级表的数目、表的数目，系统不做限制，仅受系统资源限制。
+- 最多允许 128 个，至少要有 1 个标签，一个表中标签值的总长度不超过 16KB
+- SQL 语句最大长度 1048576 个字符，也可通过客户端配置参数 maxSQLLength 修改，取值范围 65480 ~ 1048576
+- SELECT 语句的查询结果，最多允许返回 4096 列（语句中的函数调用可能也会占用一些列空间），超限时需要显式指定较少的返回数据列，以避免语句执行报错
+- 库的数目，超级表的数目、表的数目，系统不做限制，仅受系统资源限制
 - 数据库的副本数只能设置为 1 或 3
 - 用户名的最大长度是 23 个字节
 - 用户密码的最大长度是 15 个字节
-- 总数据行数取决于可用资源 
+- 总数据行数取决于可用资源
 - 单个数据库的虚拟结点数上限为 1024
 
 ## 表(列)名合法性说明
 
 ### TDengine 中的表（列）名命名规则如下：
+
 只能由字母、数字、下划线构成，数字不能在首位，长度不能超过 192 字节，不区分大小写。这里表名称不包括数据库名的前缀和分隔符。
 
 ### 转义后表（列）名规则：
+
 为了兼容支持更多形式的表（列）名，TDengine 引入新的转义符 "`"，可以避免表名与关键词的冲突，同时不受限于上述表名合法性约束检查，转义符不计入表名的长度。
 转义后的表（列）名同样受到长度限制要求，且长度计算的时候不计算转义符。使用转义字符以后，不再对转义字符中的内容进行大小写统一。
 

docs/zh/12-taos-sql/20-keywords.md

 ---
-sidebar_label: 保留关键字 
+sidebar_label: 保留关键字
 title: TDengine 保留关键字
 ---
 
@@ -58,70 +58,70 @@ title: TDengine 保留关键字
 
 ### D
 
-- DATABASE  
-- DATABASES 
-- DAYS      
-- DBS       
-- DEFERRED  
+- DATABASE
+- DATABASES
+- DAYS
+- DBS
+- DEFERRED
 - DELETE
 - DELIMITERS
-- DESC      
-- DESCRIBE  
-- DETACH    
-- DISTINCT  
-- DIVIDE    
-- DNODE     
-- DNODES    
-- DOT       
-- DOUBLE    
-- DROP  
+- DESC
+- DESCRIBE
+- DETACH
+- DISTINCT
+- DIVIDE
+- DNODE
+- DNODES
+- DOT
+- DOUBLE
+- DROP
 
 ### E
 
-- END     
-- EQ      
-- EXISTS  
-- EXPLAIN 
+- END
+- EQ
+- EXISTS
+- EXPLAIN
 
 ### F
 
-- FAIL   
-- FILE   
-- FILL   
-- FLOAT  
-- FOR    
-- FROM   
-- FSYNC  
+- FAIL
+- FILE
+- FILL
+- FLOAT
+- FOR
+- FROM
+- FSYNC
 
 ### G
 
-- GE    
-- GLOB  
+- GE
+- GLOB
 - GRANTS
-- GROUP 
-- GT  
+- GROUP
+- GT
 
 ### H
 
-- HAVING 
+- HAVING
 
 ### I
 
 - ID
 - IF
-- IGNORE 
+- IGNORE
 - IMMEDIA
-- IMPORT 
-- IN     
+- IMPORT
+- IN
 - INITIAL
-- INSERT 
+- INSERT
 - INSTEAD
-- INT    
+- INT
 - INTEGER
 - INTERVA
-- INTO   
-- IS     
-- ISNULL 
+- INTO
+- IS
+- ISNULL
 
 ### J
 
@@ -130,190 +130,147 @@ title: TDengine 保留关键字
 ### K
 
 - KEEP
-- KEY 
+- KEY
 - KILL
 
 ### L
 
-- LE    
-- LIKE  
-- LIMIT 
+- LE
+- LIKE
+- LIMIT
 - LINEAR
-- LOCAL 
-- LP    
+- LOCAL
+- LP
 - LSHIFT
-- LT 
+- LT
 
 ### M
 
-- MATCH    
-- MAXROWS  
-- MINROWS  
-- MINUS    
-- MNODES   
-- MODIFY   
-- MODULES  
+- MATCH
+- MAXROWS
+- MINROWS
+- MINUS
+- MNODES
+- MODIFY
+- MODULES
 
 ### N
 
-- NE     
-- NONE   
-- NOT    
+- NE
+- NONE
+- NOT
 - NOTNULL
-- NOW    
+- NOW
 - NULL
 
 ### O
 
-- OF    
+- OF
 - OFFSET
-- OR    
-- ORDER 
+- OR
+- ORDER
 
 ### P
 
 - PARTITION
-- PASS     
-- PLUS     
-- PPS      
+- PASS
+- PLUS
+- PPS
 - PRECISION
-- PREV     
+- PREV
 - PRIVILEGE
 
 ### Q
 
-- QTIME 
+- QTIME
 - QUERIE
-- QUERY 
+- QUERY
 - QUORUM
 
 ### R
 
-- RAISE  
-- REM    
+- RAISE
+- REM
 - REPLACE
 - REPLICA
-- RESET  
+- RESET
 - RESTRIC
-- ROW    
-- RP     
+- ROW
+- RP
 - RSHIFT
 
 ### S
 
-- SCORES 
-- SELECT 
-- SEMI   
+- SCORES
+- SELECT
+- SEMI
 - SESSION
-- SET    
-- SHOW   
-- SLASH  
+- SET
+- SHOW
+- SLASH
 - SLIDING
-- SLIMIT 
+- SLIMIT
 - SMALLIN
 - SOFFSET
-- STable 
+- STable
 - STableS
-- STAR    
-- STATE   
+- STAR
+- STATE
 - STATEMEN
 - STATE_WI
-- STORAGE 
-- STREAM  
-- STREAMS 
-- STRING  
-- SYNCDB  
+- STORAGE
+- STREAM
+- STREAMS
+- STRING
+- SYNCDB
 
 ### T
 
-- TABLE     
-- TABLES    
-- TAG       
-- TAGS      
-- TBNAME    
-- TIMES     
-- TIMESTAMP 
-- TINYINT   
-- TOPIC     
-- TOPICS    
-- TRIGGER   
-- TSERIES   
+- TABLE
+- TABLES
+- TAG
+- TAGS
+- TBNAME
+- TIMES
+- TIMESTAMP
+- TINYINT
+- TOPIC
+- TOPICS
+- TRIGGER
+- TSERIES
 
 ### U
 
-- UMINUS   
-- UNION    
-- UNSIGNED 
-- UPDATE   
-- UPLUS    
-- USE      
-- USER     
-- USERS    
-- USING  
+- UMINUS
+- UNION
+- UNSIGNED
+- UPDATE
+- UPLUS
+- USE
+- USER
+- USERS
+- USING
 
 ### V
 
-- VALUES   
-- VARIABLE 
+- VALUES
+- VARIABLE
 - VARIABLES
-- VGROUPS  
-- VIEW     
-- VNODES   
+- VGROUPS
+- VIEW
+- VNODES
 
 ### W
 
 - WAL
 - WHERE
 
-### _
-
-- _C0
-- _QSTART
-- _QSTOP
-- _QDURATION
-- _WSTART
-- _WSTOP
-- _WDURATION
-
-
-## 特殊说明
-### TBNAME
-`TBNAME` 可以视为超级表中一个特殊的标签，代表子表的表名。
-
-获取一个超级表所有的子表名及相关的标签信息：
-
-```mysql
-SELECT TBNAME, location FROM meters;
-```
-
-统计超级表下辖子表数量：
-
-```mysql
-SELECT COUNT(TBNAME) FROM meters;
-```
-
-以上两个查询均只支持在WHERE条件子句中添加针对标签（TAGS）的过滤条件。例如：
-```mysql
-taos> SELECT TBNAME, location FROM meters;
-             tbname             |            location            |
-==================================================================
- d1004                          | California.SanFrancisco        |
- d1003                          | California.SanFrancisco        |
- d1002                          | California.LosAngeles          |
- d1001                          | California.LosAngeles          |
-Query OK, 4 row(s) in set (0.000881s)
-
-taos> SELECT COUNT(tbname) FROM meters WHERE groupId > 2;
-     count(tbname)     |
-========================
-                     2 |
-Query OK, 1 row(s) in set (0.001091s)
-```
-### _QSTART/_QSTOP/_QDURATION
-表示查询过滤窗口的起始，结束以及持续时间。
-
-### _WSTART/_WSTOP/_WDURATION
-窗口切分聚合查询（例如 interval/session window/state window）中表示每个切分窗口的起始，结束以及持续时间。
-
-### _c0/_ROWTS
-_c0 _ROWTS 等价，表示表或超级表的第一列
+### \_
+
+- \_C0
+- \_QSTART
+- \_QSTOP
+- \_QDURATION
+- \_WSTART
+- \_WSTOP
+- \_WDURATION

docs/zh/12-taos-sql/21-node.md

+---
+sidebar_label: 集群管理
+title: 集群管理
+---
+
+组成 TDengine 集群的物理实体是 dnode (data node 的缩写)，它是一个运行在操作系统之上的进程。在 dnode 中可以建立负责时序数据存储的 vnode (virtual node)，在多节点集群环境下当某个数据库的 replica 为 3 时，该数据库中的每个 vgroup 由 3 个 vnode 组成；当数据库的 replica 为 1 时，该数据库中的每个 vgroup 由 1 个 vnode 组成。如果要想配置某个数据库为多副本，则集群中的 dnode 数量至少为 3。在 dnode 还可以创建 mnode (management node)，单个集群中最多可以创建三个 mnode。在 TDengine 3.0.0.0 中为了支持存算分离，引入了一种新的逻辑节点 qnode (query node)，qnode 和 vnode 既可以共存在一个 dnode 中，也可以完全分离在不同的 dnode 上。
+
+## 创建数据节点
+
+```sql
+CREATE DNODE {dnode_endpoint | dnode_host_name PORT port_val}
+```
+
+其中 `dnode_endpoint` 是形成 `hostname:port`的格式。也可以分开指定 hostname 和 port。
+
+实际操作中推荐先创建 dnode，再启动相应的 dnode 进程，这样该 dnode 就可以立即根据其配置文件中的 firstEP 加入集群。每个 dnode 在加入成功后都会被分配一个 ID。
+
+## 查看数据节点
+
+```sql
+SHOW DNODES;
+```
+
+可以列出集群中所有的数据节点，所列出的字段有 dnode 的 ID, endpoint, status。
+
+## 删除数据节点
+
+```sql
+DROP DNODE {dnode_id | dnode_endpoint}
+```
+
+可以用 dnoe_id 或 endpoint 两种方式从集群中删除一个 dnode。注意删除 dnode 不等于停止相应的进程。实际中推荐先将一个 dnode 删除之后再停止其所对应的进程。
+
+## 修改数据节点配置
+
+```sql
+ALTER DNODE dnode_id dnode_option
+
+ALTER ALL DNODES dnode_option
+
+dnode_option: {
+    'resetLog'
+  | 'balance' value
+  | 'monitor' value
+  | 'debugFlag' value
+  | 'monDebugFlag' value
+  | 'vDebugFlag' value
+  | 'mDebugFlag' value
+  | 'cDebugFlag' value
+  | 'httpDebugFlag' value
+  | 'qDebugflag' value
+  | 'sdbDebugFlag' value
+  | 'uDebugFlag' value
+  | 'tsdbDebugFlag' value
+  | 'sDebugflag' value
+  | 'rpcDebugFlag' value
+  | 'dDebugFlag' value
+  | 'mqttDebugFlag' value
+  | 'wDebugFlag' value
+  | 'tmrDebugFlag' value
+  | 'cqDebugFlag' value
+}
+```
+
+上面语法中的这些可修改配置项其配置方式与 dnode 配置文件中的配置方式相同，区别是修改是动态的立即生效，且不需要重启 dnode。
+
+## 添加管理节点
+
+```sql
+CREATE MNODE ON DNODE dnode_id
+```
+
+系统启动默认在 firstEP 节点上创建一个 MNODE，用户可以使用此语句创建更多的 MNODE 来提高系统可用性。一个集群最多存在三个 MNODE，一个 DNODE 上只能创建一个 MNODE。
+
+## 查看管理节点
+
+```sql
+SHOW MNODES;
+```
+
+列出集群中所有的管理节点，包括其 ID，所在 DNODE 以及状态。
+
+## 删除管理节点
+
+```sql
+DROP MNODE ON DNODE dnode_id;
+```
+
+删除 dnode_id 所指定的 DNODE 上的 MNODE。
+
+## 创建查询节点
+
+```sql
+CREATE QNODE ON DNODE dnode_id;
+```
+
+系统启动默认没有 QNODE，用户可以创建 QNODE 来实现计算和存储的分离。一个 DNODE 上只能创建一个 QNODE。一个 DNODE 的 `supportVnodes` 参数如果不为 0，同时又在其上创建上 QNODE，则在该 dnode 中既有负责存储管理的 vnode 又有负责查询计算的 qnode，如果还在该 dnode 上创建了 mnode，则一个 dnode 上最多三种逻辑节点都可以存在。但通过配置也可以使其彻底分离。将一个 dnode 的`supportVnodes`配置为 0，可以选择在其上创建 mnode 或者 qnode 中的一种，这样可以实现三种逻辑节点在物理上的彻底分离。
+
+## 查看查询节点
+
+```sql
+SHOW QNODES;
+```
+
+列出集群中所有查询节点，包括 ID，及所在 DNODE。
+
+## 删除查询节点
+
+```sql
+DROP QNODE ON DNODE dnode_id;
+```
+
+删除 ID 为 dnode_id 的 DNODE 上的 QNODE，但并不会影响该 dnode 的状态。
+
+## 修改客户端配置
+
+如果将客户端也看作广义的集群的一部分，可以通过如下命令动态修改客户端配置参数。
+
+```sql
+ALTER LOCAL local_option
+
+local_option: {
+    'resetLog'
+  | 'rpcDebugFlag' value
+  | 'tmrDebugFlag' value
+  | 'cDebugFlag' value
+  | 'uDebugFlag' value
+  | 'debugFlag' value
+}
+```
+
+上面语法中的参数与在配置文件中配置客户端的用法相同，但不需要重启客户端，修改后立即生效。
+
+## 查看客户端配置
+
+```sql
+SHOW LOCAL VARIABLES;
+```
+
+## 合并 vgroup
+
+```sql
+MERGE VGROUP vgroup_no1 vgroup_no2;
+```
+
+如果在系统实际运行一段时间后，因为不同时间线的数据特征不同导致在 vgroups 之间的数据和负载分布不均衡，可以通过合并或拆分 vgroups 的方式逐步实现负载均衡。
+
+## 拆分 vgroup
+
+```sql
+SPLIT VGROUP vgroup_no;
+```
+
+会创建一个新的 vgroup，并将指定 vgroup 中的数据按照一致性 HASH 迁移一部分到新的 vgroup 中。此过程中，原 vgroup 可以正常提供读写服务。

docs/zh/12-taos-sql/22-information.md

----
-sidebar_label: Information内置数据库
-title: Information内置数据库
----
-

docs/zh/12-taos-sql/22-meta.md

+---
+sidebar_label: 元数据库
+title: 元数据库
+---
+
+TDengine 内置了一个名为 `INFORMATION_SCHEMA` 的数据库，提供对数据库元数据、数据库系统信息和状态的访问，例如数据库或表的名称，当前执行的 SQL 语句等。该数据库存储有关 TDengine 维护的所有其他数据库的信息。它包含多个只读表。实际上，这些表都是视图，而不是基表，因此没有与它们关联的文件。所以对这些表只能查询，不能进行 INSERT 等写入操作。`INFORMATION_SCHEMA` 数据库旨在以一种更一致的方式来提供对 TDengine 支持的各种 SHOW 语句（如 SHOW TABLES、SHOW DATABASES）所提供的信息的访问。与 SHOW 语句相比，使用 SELECT ... FROM INFORMATION_SCHEMA.tablename 具有以下优点：
+
+1. 可以使用 USE 语句将 INFORMATION_SCHEMA 设为默认数据库
+2. 可以使用 SELECT 语句熟悉的语法，只需要学习一些表名和列名
+3. 可以对查询结果进行筛选、排序等操作。事实上，可以使用任意 TDengine 支持的 SELECT 语句对 INFORMATION_SCHEMA 中的表进行查询
+4. TDengine 在后续演进中可以灵活的添加已有 INFORMATION_SCHEMA 中表的列，而不用担心对既有业务系统造成影响
+5. 与其他数据库系统更具互操作性。例如，Oracle 数据库用户熟悉查询 Oracle 数据字典中的表
+
+Note: 由于 SHOW 语句已经被开发者熟悉和广泛使用，所以它们仍然被保留。
+
+本章将详细介绍 `INFORMATION_SCHEMA` 这个内置元数据库中的表和表结构。
+
+## DNODES
+
+提供 dnode 的相关信息。也可以使用 SHOW DNODES 来查询这些信息。
+
+| #   |    **列名**    | **数据类型** | **说明**              |
+| --- | :------------: | ------------ | --------------------- |
+| 1   |     vnodes     | SMALLINT     | dnode 中的 vnode 个数 |
+| 2   | support_vnodes | SMALLINT     | 支持的 vnode 个数     |
+| 3   |     status     | BINARY(10)   | 当前状态              |
+| 4   |      note      | BINARY(256)  | 离线原因等信息        |
+| 5   |       id       | SMALLINT     | dnode id              |
+| 6   |    endpoint    | BINARY(134)  | dnode 的地址          |
+| 7   |     create     | TIMESTAMP    | 创建时间              |
+
+## MNODES
+
+提供 mnode 的相关信息。也可以使用 SHOW MNODES 来查询这些信息。
+
+| #   |  **列名**   | **数据类型** | **说明**           |
+| --- | :---------: | ------------ | ------------------ |
+| 1   |     id      | SMALLINT     | mnode id           |
+| 2   |  endpoint   | BINARY(134)  | mnode 的地址       |
+| 3   |    role     | BINARY(10)   | 当前角色           |
+| 4   |  role_time  | TIMESTAMP    | 成为当前角色的时间 |
+| 5   | create_time | TIMESTAMP    | 创建时间           |
+
+## MODULES
+
+提供组件的相关信息。也可以使用 SHOW MODULES 来查询这些信息
+
+| #   | **列名** | **数据类型** | **说明**   |
+| --- | :------: | ------------ | ---------- |
+| 1   |    id    | SMALLINT     | module id  |
+| 2   | endpoint | BINARY(134)  | 组件的地址 |
+| 3   |  module  | BINARY(10)   | 组件状态   |
+
+## QNODES
+
+当前系统中 QNODE 的信息。也可以使用 SHOW QNODES 来查询这些信息。
+
+| #   |  **列名**   | **数据类型** | **说明**     |
+| --- | :---------: | ------------ | ------------ |
+| 1   |     id      | SMALLINT     | module id    |
+| 2   |  endpoint   | BINARY(134)  | qnode 的地址 |
+| 3   | create_time | TIMESTAMP    | 创建时间     |
+
+## USER_DATABASES
+
+提供用户创建的数据库对象的相关信息。也可以使用 SHOW DATABASES 来查询这些信息。
+
+TODO
+
+| #   |  **列名**   | **数据类型** | **说明**                                         |
+| --- | :---------: | ------------ | ------------------------------------------------ |
+| 1   |    name     | BINARY(32)   | 数据库名                                         |
+| 2   | create_time | TIMESTAMP    | 创建时间                                         |
+| 3   |   ntables   | INT          | 数据库中表的数量，包含子表和普通表但不包含超级表 |
+| 4   |   vgroups   | INT          | 数据库中有多少个 vgroup                          |
+| 5   |   replica   | INT          | 副本数                                           |
+| 6   |   quorum    | INT          | 写成功的确认数                                   |
+| 7   |    days     | INT          | 单文件存储数据的时间跨度                         |
+| 8   |    keep     | INT          | 数据保留时长                                     |
+| 9   |   buffer    | INT          | 每个 vnode 写缓存的内存块大小，单位 MB           |
+| 10  |   minrows   | INT          | 文件块中记录的最大条数                           |
+| 11  |   maxrows   | INT          | 文件块中记录的最小条数                           |
+| 12  |  wal_level   | INT          | WAL 级别                                         |
+| 13  | walfsync_period    | INT          | 数据落盘周期                                     |
+| 14  |    comp     | INT          | 数据压缩方式                                     |
+| 15  |  precision  | BINARY(2)    | 时间分辨率                                       |
+| 16  |   status    | BINARY(10)   | 数据库状态                                       |
+
+## USER_FUNCTIONS
+
+TODO
+
+## USER_INDEXES
+
+提供用户创建的索引的相关信息。也可以使用 SHOW INDEX 来查询这些信息。
+
+| #   |     **列名**     | **数据类型** | **说明**                                                                           |
+| --- | :--------------: | ------------ | ---------------------------------------------------------------------------------- |
+| 1   |     db_name      | BINARY(32)   | 包含此索引的表所在的数据库名                                                       |
+| 2   |    table_name    | BINARY(192)  | 包含此索引的表的名称                                                               |
+| 3   |    index_name    | BINARY(192)  | 索引名                                                                             |
+| 4   |   column_name    | BINARY(64)   | 建索引的列的列名                                                                   |
+| 5   |    index_type    | BINARY(10)   | 目前有 SMA 和 FULLTEXT                                                             |
+| 6   | index_extensions | BINARY(256)  | 索引的额外信息。对 SMA 类型的索引，是函数名的列表。对 FULLTEXT 类型的索引为 NULL。 |
+
+## USER_STABLES
+
+提供用户创建的超级表的相关信息。
+
+| #   |   **列名**    | **数据类型** | **说明**                 |
+| --- | :-----------: | ------------ | ------------------------ |
+| 1   |  stable_name  | BINARY(192)  | 超级表表名               |
+| 2   |    db_name    | BINARY(64)   | 超级表所在的数据库的名称 |
+| 3   |  create_time  | TIMESTAMP    | 创建时间                 |
+| 4   |    columns    | INT          | 列数目                   |
+| 5   |     tags      | INT          | 标签数目                 |
+| 6   |  last_update  | TIMESTAMP    | 最后更新时间             |
+| 7   | table_comment | BINARY(1024) | 表注释                   |
+| 8   |   watermark   | BINARY(64)   | 窗口的关闭时间           |
+| 9   |   max_delay   | BINARY(64)   | 推送计算结果的最大延迟   |
+| 10  |    rollup     | BINARY(128)  | rollup 聚合函数          |
+
+## USER_STREAMS
+
+提供用户创建的流计算的相关信息。
+
+| #   |  **列名**   | **数据类型** | **说明**                    |
+| --- | :---------: | ------------ | --------------------------- |
+| 1   | stream_name | BINARY(192)  | 流计算名称                  |
+| 2   |  user_name  | BINARY(23)   | 创建流计算的用户            |
+| 3   | dest_table  | BINARY(192)  | 流计算写入的目标表          |
+| 4   | create_time | TIMESTAMP    | 创建时间                    |
+| 5   |     sql     | BLOB         | 创建流计算时提供的 SQL 语句 |
+
+## USER_TABLES
+
+提供用户创建的普通表和子表的相关信息
+
+| #   |   **列名**    | **数据类型** | **说明**         |
+| --- | :-----------: | ------------ | ---------------- |
+| 1   |  table_name   | BINARY(192)  | 表名             |
+| 2   |    db_name    | BINARY(64)   | 数据库名         |
+| 3   |  create_time  | TIMESTAMP    | 创建时间         |
+| 4   |    columns    | INT          | 列数目           |
+| 5   |  stable_name  | BINARY(192)  | 所属的超级表表名 |
+| 6   |      uid      | BIGINT       | 表 id            |
+| 7   |   vgroup_id   | INT          | vgroup id        |
+| 8   |      ttl      | INT          | 表的生命周期     |
+| 9   | table_comment | BINARY(1024) | 表注释           |
+| 10  |     type      | BINARY(20)   | 表类型           |
+
+## USER_USERS
+
+提供系统中创建的用户的相关信息。
+
+| #   |  **列名**   | **数据类型** | **说明** |
+| --- | :---------: | ------------ | -------- |
+| 1   |  user_name  | BINARY(23)   | 用户名   |
+| 2   |  privilege  | BINARY(256)  | 权限     |
+| 3   | create_time | TIMESTAMP    | 创建时间 |
+
+## VGROUPS
+
+系统中所有 vgroups 的信息。
+
+| #   |  **列名**  | **数据类型** | **说明**                     |
+| --- | :--------: | ------------ | ---------------------------- |
+| 1   |   vg_id    | INT          | vgroup id                    |
+| 2   |  db_name   | BINARY(32)   | 数据库名                     |
+| 3   |   tables   | INT          | 此 vgroup 内有多少表         |
+| 4   |   status   | BINARY(10)   | 此 vgroup 的状态             |
+| 5   |  onlines   | INT          | 在线的成员数目               |
+| 6   |  v1_dnode  | INT          | 第一个成员所在的 dnode 的 id |
+| 7   | v1_status  | BINARY(10)   | 第一个成员的状态             |
+| 8   |  v2_dnode  | INT          | 第二个成员所在的 dnode 的 id |
+| 9   | v2_status  | BINARY(10)   | 第二个成员的状态             |
+| 10  |  v3_dnode  | INT          | 第三个成员所在的 dnode 的 id |
+| 11  | v3_status  | BINARY(10)   | 第三个成员的状态             |
+| 12  | compacting | INT          | compact 状态                 |

docs/zh/12-taos-sql/23-show.md

+---
+sidebar_label: SHOW 命令
+title: 使用 SHOW 命令查看系统元数据
+---
+
+除了使用 `select` 语句查询 `INFORMATION_SCHEMA` 数据库中的表获得系统中的各种元数据、系统信息和状态之外，也可以用 `SHOW` 命令来实现同样的目的。
+
+## SHOW ACCOUNTS
+
+```sql
+SHOW ACCOUNTS;
+```
+
+显示当前系统中所有租户的信息。
+
+注：企业版独有
+
+## SHOW APPS
+
+```sql
+SHOW APPS;
+```
+
+显示接入集群的应用（客户端）信息。
+
+## SHOW BNODES
+
+```sql
+SHOW BNODES;
+```
+
+显示当前系统中存在的 BNODE (backup node, 即备份节点）的信息。
+
+## SHOW CLUSTER
+
+```sql
+SHOW CLUSTER;
+```
+
+显示当前集群的信息
+
+## SHOW CONNECTIONS
+
+```sql
+SHOW CONNECTIONS;
+```
+
+显示当前系统中存在的连接的信息。
+
+## SHOW CONSUMERS
+
+```sql
+SHOW CONSUMERS;
+```
+
+显示当前数据库下所有活跃的消费者的信息。
+
+## SHOW CREATE DATABASE
+
+```sql
+SHOW CREATE DATABASE db_name;
+```
+
+显示 db_name 指定的数据库的创建语句。
+
+## SHOW CREATE STABLE
+
+```sql
+SHOW CREATE STABLE [db_name.]stb_name;
+```
+
+显示 tb_name 指定的超级表的创建语句
+
+## SHOW CREATE TABLE
+
+```sql
+SHOW CREATE TABLE [db_name.]tb_name
+```
+
+显示 tb_name 指定的表的创建语句。支持普通表、超级表和子表。
+
+## SHOW DATABASES
+
+```sql
+SHOW DATABASES;
+```
+
+显示用户定义的所有数据库。
+
+## SHOW DNODES
+
+```sql
+SHOW DNODES;
+```
+
+显示当前系统中 DNODE 的信息。
+
+## SHOW FUNCTIONS
+
+```sql
+SHOW FUNCTIONS;
+```
+
+显示用户定义的自定义函数。
+
+## SHOW LICENSE
+
+```sql
+SHOW LICENSE;
+SHOW GRANTS;
+```
+
+显示企业版许可授权的信息。
+
+注：企业版独有
+
+## SHOW INDEXES
+
+```sql
+SHOW INDEXES FROM tbl_name [FROM db_name];
+```
+
+显示已创建的索引。
+
+## SHOW LOCAL VARIABLES
+
+```sql
+SHOW LOCAL VARIABLES;
+```
+
+显示当前客户端配置参数的运行值。
+
+## SHOW MNODES
+
+```sql
+SHOW MNODES;
+```
+
+显示当前系统中 MNODE 的信息。
+
+## SHOW MODULES
+
+```sql
+SHOW MODULES;
+```
+
+显示当前系统中所安装的组件的信息。
+
+## SHOW QNODES
+
+```sql
+SHOW QNODES;
+```
+
+显示当前系统中 QNODE （查询节点）的信息。
+
+## SHOW SCORES
+
+```sql
+SHOW SCORES;
+```
+
+显示系统被许可授权的容量的信息。
+
+注：企业版独有
+
+## SHOW SNODES
+
+```sql
+SHOW SNODES;
+```
+
+显示当前系统中 SNODE （流计算节点）的信息。
+
+## SHOW STABLES
+
+```sql
+SHOW [db_name.]STABLES [LIKE 'pattern'];
+```
+
+显示当前数据库下的所有超级表的信息。可以使用 LIKE 对表名进行模糊匹配。
+
+## SHOW STREAMS
+
+```sql
+SHOW STREAMS;
+```
+
+显示当前系统内所有流计算的信息。
+
+## SHOW SUBSCRIPTIONS
+
+```sql
+SHOW SUBSCRIPTIONS;
+```
+
+显示当前数据库下的所有的订阅关系
+
+## SHOW TABLES
+
+```sql
+SHOW [db_name.]TABLES [LIKE 'pattern'];
+```
+
+显示当前数据库下的所有普通表和子表的信息。可以使用 LIKE 对表名进行模糊匹配。
+
+## SHOW TABLE DISTRIBUTED
+
+```sql
+SHOW TABLE DISTRIBUTED table_name;
+```
+
+显示表的数据分布信息。
+
+## SHOW TAGS
+
+```sql
+SHOW TAGS FROM child_table_name [FROM db_name];
+```
+
+显示子表的标签信息。
+
+## SHOW TOPICS
+
+```sql
+SHOW TOPICS;
+```
+
+显示当前数据库下的所有主题的信息。
+
+## SHOW TRANSACTIONS
+
+```sql
+SHOW TRANSACTIONS;
+```
+
+显示当前系统中正在执行的事务的信息
+
+## SHOW USERS
+
+```sql
+SHOW USERS;
+```
+
+显示当前系统中所有用户的信息。包括用户自定义的用户和系统默认用户。
+
+## SHOW VARIABLES
+
+```sql
+SHOW VARIABLES;
+SHOW DNODE dnode_id VARIABLES;
+```
+
+显示当前系统中各节点需要相同的配置参数的运行值，也可以指定 DNODE 来查看其的配置参数。
+
+## SHOW VGROUPS
+
+```sql
+SHOW [db_name.]VGROUPS;
+```
+
+显示当前系统中所有 VGROUP 或某个 db 的 VGROUPS 的信息。
+
+## SHOW VNODES
+
+```sql
+SHOW VNODES [dnode_name];
+```
+
+显示当前系统中所有 VNODE 或某个 DNODE 的 VNODE 的信息。

docs/zh/12-taos-sql/25-grant.md

+---
+sidebar_label: 权限管理
+title: 权限管理
+---
+
+本节讲述如何在 TDengine 中进行权限管理的相关操作。
+
+## 创建用户
+
+```sql
+CREATE USER use_name PASS password;
+```
+
+创建用户。
+
+use_name最长为23字节。
+
+password最长为128字节，合法字符包括"a-zA-Z0-9!?$%^&*()_–+={[}]:;@~#|<,>.?/"，不可以出现单双引号、撇号、反斜杠和空格，且不可以为空。
+
+## 删除用户
+
+```sql
+DROP USER user_name;
+```
+
+## 修改用户信息
+
+```sql
+ALTER USER user_name alter_user_clause
+ 
+alter_user_clause: {
+    PASS 'literal'
+  | ENABLE value
+  | SYSINFO value
+}
+```
+
+- PASS：修改用户密码。
+- ENABLE：修改用户是否启用。1表示启用此用户，0表示禁用此用户。
+- SYSINFO：修改用户是否可查看系统信息。1表示可以查看系统信息，0表示不可以查看系统信息。
+
+
+## 授权
+
+```sql
+GRANT privileges ON priv_level TO user_name
+ 
+privileges : {
+    ALL
+  | priv_type [, priv_type] ...
+}
+ 
+priv_type : {
+    READ
+  | WRITE
+}
+ 
+priv_level : {
+    dbname.*
+  | *.*
+}
+```
+
+对用户授权。
+
+授权级别支持到DATABASE，权限有READ和WRITE两种。
+
+TDengine 有超级用户和普通用户两类用户。超级用户缺省创建为root，拥有所有权限。使用超级用户创建出来的用户为普通用户。在未授权的情况下，普通用户可以创建DATABASE，并拥有自己创建的DATABASE的所有权限，包括删除数据库、修改数据库、查询时序数据和写入时序数据。超级用户可以给普通用户授予其他DATABASE的读写权限，使其可以在此DATABASE上读写数据，但不能对其进行删除和修改数据库的操作。
+
+对于非DATABASE的对象，如USER、DNODE、UDF、QNODE等，普通用户只有读权限（一般为SHOW命令），不能创建和修改。
+
+## 撤销授权
+
+```sql
+REVOKE privileges ON priv_level FROM user_name
+ 
+privileges : {
+    ALL
+  | priv_type [, priv_type] ...
+}
+ 
+priv_type : {
+    READ
+  | WRITE
+}
+ 
+priv_level : {
+    dbname.*
+  | *.*
+}
+
+```
+
+收回对用户的授权。
\ No newline at end of file

docs/zh/12-taos-sql/26-udf.md

+---
+sidebar_label: 自定义函数
+title: 用户自定义函数
+---
+
+除了 TDengine 的内置函数以外，用户还可以编写自己的函数逻辑并加入TDengine系统中。
+
+## 创建函数
+
+```sql
+CREATE [AGGREGATE] FUNCTION func_name AS library_path OUTPUTTYPE type_name [BUFSIZE value]
+```
+
+语法说明：
+
+AGGREGATE：标识此函数是标量函数还是聚集函数。
+func_name：函数名，必须与函数实现中udfNormalFunc的实际名称一致。
+library_path：包含UDF函数实现的动态链接库的绝对路径，是在客户端侧主机上的绝对路径。
+OUTPUTTYPE：标识此函数的返回类型。
+BUFSIZE：中间结果的缓冲区大小，单位是字节。不设置则默认为0。最大不可超过512字节。
+
+关于如何开发自定义函数，请参考 [UDF使用说明](../../develop/udf)。
+
+## 删除自定义函数
+
+```sql
+DROP FUNCTION func_name
+```
\ No newline at end of file

docs/zh/12-taos-sql/27-index.md

+---
+sidebar_label: 索引
+title: 使用索引
+---
+
+TDengine 从 3.0.0.0 版本开始引入了索引功能，支持 SMA 索引和 FULLTEXT 索引。
+
+## 创建索引
+
+```sql
+CREATE FULLTEXT INDEX index_name ON tb_name (col_name [, col_name] ...)
+
+CREATE SMA INDEX index_name ON tb_name index_option
+
+index_option:
+    FUNCTION(functions) INTERVAL(interval_val [, interval_offset]) [SLIDING(sliding_val)] [WATERMARK(watermark_val)] [MAX_DELAY(max_delay_val)]
+
+functions:
+    function [, function] ...
+```
+
+### SMA 索引
+
+对指定列按 INTERVAL 子句定义的时间窗口创建进行预聚合计算，预聚合计算类型由 functions_string 指定。SMA 索引能提升指定时间段的聚合查询的性能。目前，限制一个超级表只能创建一个 SMA INDEX。
+
+- 支持的函数包括 MAX、MIN 和 SUM。
+- WATERMARK: 最小单位毫秒，取值范围 [0ms, 900000ms]，默认值为 5 秒，只可用于超级表。
+- MAX_DELAY: 最小单位毫秒，取值范围 [1ms, 900000ms]，默认值为 interval 的值(但不能超过最大值)，只可用于超级表。注：不建议 MAX_DELAY 设置太小，否则会过于频繁的推送结果，影响存储和查询性能，如无特殊需求，取默认值即可。
+
+### FULLTEXT 索引
+
+对指定列建立文本索引，可以提升含有文本过滤的查询的性能。FULLTEXT 索引不支持 index_option 语法。现阶段只支持对 JSON 类型的标签列创建 FULLTEXT 索引。不支持多列联合索引，但可以为每个列分布创建 FULLTEXT 索引。
+
+## 删除索引
+
+```sql
+DROP INDEX index_name;
+```
+
+## 查看索引
+
+````sql
+```sql
+SHOW INDEXES FROM tbl_name [FROM db_name];
+````
+
+显示在所指定的数据库或表上已创建的索引。

docs/zh/12-taos-sql/28-recovery.md

+---
+sidebar_label: 异常恢复
+title: 异常恢复
+---
+
+在一个复杂的应用场景中，连接和查询任务等有可能进入一种错误状态或者耗时过长迟迟无法结束，此时需要有能够终止这些连接或任务的方法。
+
+## 终止连接
+
+```sql
+KILL CONNECTION conn_id;
+```
+
+conn_id 可以通过 `SHOW CONNECTIONS` 获取。
+
+## 终止查询
+
+```sql
+SHOW QUERY query_id;
+```
+
+query_id 可以通过 `SHOW QUERIES` 获取。
+
+## 终止事务
+
+```sql
+KILL TRANSACTION trans_id
+```
+
+trans_id 可以通过 `SHOW TRANSACTIONS` 获取。
+
+## 重置客户端缓存
+
+```sql
+RESET QUERY CACHE;
+```
+
+如果在多客户端情况下出现元数据不同步的情况，可以用这条命令强制清空客户端缓存，随后客户端会从服务端拉取最新的元数据。

docs/zh/13-operation/06-admin.md

----
-title: 用户管理
----
-
-系统管理员可以在 CLI 界面里添加、删除用户，也可以修改密码。CLI 里 SQL 语法如下：
-
-```sql
-CREATE USER <user_name> PASS <'password'>;
-```
-
-创建用户，并指定用户名和密码，密码需要用单引号引起来，单引号为英文半角
-
-```sql
-DROP USER <user_name>;
-```
-
-删除用户，限 root 用户使用
-
-```sql
-ALTER USER <user_name> PASS <'password'>;
-```
-
-修改用户密码，为避免被转换为小写，密码需要用单引号引用，单引号为英文半角
-
-```sql
-ALTER USER <user_name> PRIVILEGE <write|read>;
-```
-
-修改用户权限为：write 或 read，不需要添加单引号
-
-说明：系统内共有 super/write/read 三种权限级别，但目前不允许通过 alter 指令把 super 权限赋予用户。
-
-```sql
-SHOW USERS;
-```
-
-显示所有用户
-
-:::note
-SQL 语法中，< >表示需要用户输入的部分，但请不要输入< >本身。
-
-:::

docs/zh/13-operation/09-status.md

----
-title: 系统连接、任务查询管理
----
-
-系统管理员可以从 CLI 查询系统的连接、正在进行的查询、流式计算，并且可以关闭连接、停止正在进行的查询和流式计算。
-
-## 显示数据库的连接
-
-```sql
-SHOW CONNECTIONS;
-```
-
-其结果中的一列显示 ip:port, 为连接的 IP 地址和端口号。
-
-## 强制关闭数据库连接
-
-```sql
-KILL CONNECTION <connection-id>;
-```
-
-其中的 connection-id 是 SHOW CONNECTIONS 中显示的第一列的数字。
-
-## 显示数据查询
-
-```sql
-SHOW QUERIES;
-```
-
-其中第一列显示的以冒号隔开的两个数字为 query-id，为发起该 query 应用连接的 connection-id 和查询次数。
-
-## 强制关闭数据查询
-
-```sql
-KILL QUERY <query-id>;
-```
-
-其中 query-id 是 SHOW QUERIES 中显示的 connection-id:query-no 字串，如“105:2”，拷贝粘贴即可。
-
-## 显示连续查询
-
-```sql
-SHOW STREAMS;
-```
-
-其中第一列显示的以冒号隔开的两个数字为 stream-id, 为启动该 stream 应用连接的 connection-id 和发起 stream 的次数。
-
-## 强制关闭连续查询
-
-```sql
-KILL STREAM <stream-id>;
-```
-
-其中的 stream-id 是 SHOW STREAMS 中显示的 connection-id:stream-no 字串，如 103:2，拷贝粘贴即可。

docs/zh/14-reference/14-taosx.md

+---
+sidebar_label: taosX
+title: 使用 taosX 在集群间复制数据
+---
\ No newline at end of file

docs/zh/14-reference/_category_.yml

-label: 参考指南
+label: 参考手册
\ No newline at end of file

docs/zh/14-reference/index.md

 ---
-title: 参考指南
+title: 参考手册
 ---
 
-参考指南是对 TDengine 本身、 TDengine 各语言连接器及自带的工具最详细的介绍。
+参考手册是对 TDengine 本身、 TDengine 各语言连接器及自带的工具最详细的介绍。
 
 ```mdx-code-block
 import DocCardList from '@theme/DocCardList';

docs/zh/13-operation/01-pkg-install.md → docs/zh/17-operation/01-pkg-install.md

@@ -10,7 +10,7 @@ import TabItem from "@theme/TabItem";
 
 ## 安装
 
-关于安装，请参考 [使用安装包立即开始](../get-started/package)
+关于安装，请参考 [使用安装包立即开始](../../get-started/package)
 
 
 

docs/zh/13-operation/02-planning.mdx → docs/zh/17-operation/02-planning.mdx

@@ -5,33 +5,28 @@ title: 容量规划
 
 使用 TDengine 来搭建一个物联网大数据平台，计算资源、存储资源需要根据业务场景进行规划。下面分别讨论系统运行所需要的内存、CPU 以及硬盘空间。
 
-## 内存需求
+## 服务端内存需求
 
-每个 Database 可以创建固定数目的 vgroup，默认与 CPU 核数相同，可通过 maxVgroupsPerDb 配置；vgroup 中的每个副本会是一个 vnode；每个 vnode 会占用固定大小的内存（大小与数据库的配置参数 blocks 和 cache 有关)；每个 Table 会占用与标签总长度有关的内存；此外，系统会有一些固定的内存开销。因此，每个 DB 需要的系统内存可通过如下公式计算：
+每个 Database 可以创建固定数目的 vgroup，默认 2 个 vgroup，在创建数据库时可以通过`vgroups <num>`参数来指定，其副本数由参数`replica <num>`指定。vgroup 中的每个副本会是一个 vnode；所以每个数据库占用的内存由以下几个参数决定：
 
-```
-Database Memory Size = maxVgroupsPerDb * replica * (blocks * cache + 10MB) + numOfTables * (tagSizePerTable + 0.5KB)
-```
+- vgroups
+- replica
+- buffer
+- pages
+- pagesize
+- cachesize
 
-示例：假设 maxVgroupPerDB 是缺省值 64，cache 是缺省大小 16M, blocks 是缺省值 6，并且一个 DB 中有 10 万张表，单副本，标签总长度是 256 字节，则这个 DB 总的内存需求为：64 \* 1 \* (16 \* 6 + 10) + 100000 \* (0.25 + 0.5) / 1000 = 6792M。
+关于这些参数的详细说明请参考 [数据库管理](../../taos-sql/database)。
 
-在实际的系统运维中，我们通常会更关心 TDengine 服务进程（taosd）会占用的内存量。
+一个数据库所需要的内存大小等于
 
 ```
-taosd 内存总量 = vnode 内存 + mnode 内存 + 查询内存
+vgroups * replica * (buffer + pages * pagesize + cachesize)
 ```
 
-其中：
-
-1. “vnode 内存”指的是集群中所有的 Database 存储分摊到当前 taosd 节点上所占用的内存资源。可以按上文“Database Memory Size”计算公式估算每个 DB 的内存占用量进行加总，再按集群中总共的 TDengine 节点数做平均（如果设置为多副本，则还需要乘以对应的副本倍数）。
-2. “mnode 内存”指的是集群中管理节点所占用的资源。如果一个 taosd 节点上分布有 mnode 管理节点，则内存消耗还需要增加“0.2KB \* 集群中数据表总数”。
-3. “查询内存”指的是服务端处理查询请求时所需要占用的内存。单条查询语句至少会占用“0.2KB \* 查询涉及的数据表总数”的内存量。
+但要注意的是这些内存并不需要由单一服务器提供，而是由整个集群中所有数据节点共同负担，相当于由这些数据节点所在的服务器共同负担。如果集群中有不止一个数据库，则所需内存要累加。更复杂的场景是如果集群中的数据节点并非在最初就一次性全部建立，而是随着使用中系统负载的增加逐步增加服务器并增加数据节点，则新创建的数据库会导致新旧数据节点上的负载并不均衡，此时简单的理论计算并不能直接使用，要结合各数据节点的负载情况。
 
-注意：以上内存估算方法，主要讲解了系统的“必须内存需求”，而不是“内存总数上限”。在实际运行的生产环境中，由于操作系统缓存、资源管理调度等方面的原因，内存规划应当在估算结果的基础上保留一定冗余，以维持系统状态和系统性能的稳定性。并且，生产环境通常会配置系统资源的监控工具，以便及时发现硬件资源的紧缺情况。
-
-最后，如果内存充裕，可以考虑加大 Blocks 的配置，这样更多数据将保存在内存里，提高写入和查询速度。
-
-### 客户端内存需求
+## 客户端内存需求
 
 客户端应用采用 taosc 客户端驱动连接服务端，会有内存需求的开销。
 
@@ -56,7 +51,7 @@ CPU 的需求取决于如下两方面：
 - **数据插入** TDengine 单核每秒能至少处理一万个插入请求。每个插入请求可以带多条记录，一次插入一条记录与插入 10 条记录，消耗的计算资源差别很小。因此每次插入，条数越大，插入效率越高。如果一个插入请求带 200 条以上记录，单核就能达到每秒插入 100 万条记录的速度。但对前端数据采集的要求越高，因为需要缓存记录，然后一批插入。
 - **查询需求** TDengine 提供高效的查询，但是每个场景的查询差异很大，查询频次变化也很大，难以给出客观数字。需要用户针对自己的场景，写一些查询语句，才能确定。
 
-因此仅对数据插入而言，CPU 是可以估算出来的，但查询所耗的计算资源无法估算。在实际运营过程中，不建议 CPU 使用率超过 50%，超过后，需要增加新的节点，以获得更多计算资源。
+因此仅对数据插入而言，CPU 是可以估算出来的，但查询所耗的计算资源无法估算。在实际运行过程中，不建议 CPU 使用率超过 50%，超过后，需要增加新的节点，以获得更多计算资源。
 
 ## 存储需求
 
@@ -77,5 +72,3 @@ Raw DataSize = numOfTables * rowSizePerTable * rowsPerTable
 根据上面的内存、CPU、存储的预估，就可以知道整个系统需要多少核、多少内存、多少存储空间。如果数据副本数不为 1，总需求量需要再乘以副本数。
 
 因为 TDengine 具有很好的水平扩展能力，根据总量，再根据单个物理机或虚拟机的资源，就可以轻松决定需要购置多少台物理机或虚拟机了。
-
-**立即计算 CPU、内存、存储，请参见：[资源估算方法](https://www.taosdata.com/config/config.html)。**

docs/zh/13-operation/03-tolerance.md → docs/zh/17-operation/03-tolerance.md

@@ -4,25 +4,27 @@ title: 容错和灾备
 
 ## 容错
 
-TDengine 支持**WAL**（Write Ahead Log）机制，实现数据的容错能力，保证数据的高可用。
+TDengine 支持 **WAL**（Write Ahead Log）机制，实现数据的容错能力，保证数据的高可用。
 
 TDengine 接收到应用的请求数据包时，先将请求的原始数据包写入数据库日志文件，等数据成功写入数据库数据文件后，再删除相应的 WAL。这样保证了 TDengine 能够在断电等因素导致的服务重启时从数据库日志文件中恢复数据，避免数据的丢失。
 
 涉及的系统配置参数有两个：
 
-- walLevel：WAL 级别，0：不写 WAL; 1：写 WAL, 但不执行 fsync; 2：写 WAL, 而且执行 fsync。
-- fsync：当 walLevel 设置为 2 时，执行 fsync 的周期。设置为 0，表示每次写入，立即执行 fsync。
+- wal_level：WAL 级别，1：写 WAL，但不执行 fsync。2：写 WAL，而且执行 fsync。默认值为 1。
+- wal_fsync_period：当 wal_level 设置为 2 时，执行 fsync 的周期。设置为 0，表示每次写入，立即执行 fsync。
 
-如果要 100%的保证数据不丢失，需要将 walLevel 设置为 2，fsync 设置为 0。这时写入速度将会下降。但如果应用侧启动的写数据的线程数达到一定的数量(超过 50)，那么写入数据的性能也会很不错，只会比 fsync 设置为 3000 毫秒下降 30%左右。
+如果要 100%的保证数据不丢失，需要将 wal_level 设置为 2，wal_fsync_period 设置为 0。这时写入速度将会下降。但如果应用侧启动的写数据的线程数达到一定的数量(超过 50)，那么写入数据的性能也会很不错，只会比 wal_fsync_period 设置为 3000 毫秒下降 30%左右。
 
 ## 灾备
 
-TDengine 的集群通过多个副本的机制，来提供系统的高可用性，实现灾备能力。
+TDengine 的集群通过多个副本的机制，来提供系统的高可用性，同时具备一定的灾备能力。
 
-TDengine 集群是由 mnode 负责管理的，为保证 mnode 的高可靠，可以配置多个 mnode 副本，副本数由系统配置参数 numOfMnodes 决定，为了支持高可靠，需要设置大于 1。为保证元数据的强一致性，mnode 副本之间通过同步方式进行数据复制，保证了元数据的强一致性。
+TDengine 集群是由 mnode 负责管理的，为保证 mnode 的高可靠，可以配置 三个 mnode 副本。为保证元数据的强一致性，mnode 副本之间通过同步方式进行数据复制，保证了元数据的强一致性。
 
-TDengine 集群中的时序数据的副本数是与数据库关联的，一个集群里可以有多个数据库，每个数据库可以配置不同的副本数。创建数据库时，通过参数 replica 指定副本数。为了支持高可靠，需要设置副本数大于 1。
+TDengine 集群中的时序数据的副本数是与数据库关联的，一个集群里可以有多个数据库，每个数据库可以配置不同的副本数。创建数据库时，通过参数 replica 指定副本数。为了支持高可靠，需要设置副本数为 3。
 
 TDengine 集群的节点数必须大于等于副本数，否则创建表时将报错。
 
 当 TDengine 集群中的节点部署在不同的物理机上，并设置多个副本数时，就实现了系统的高可靠性，无需再使用其他软件或工具。TDengine 企业版还可以将副本部署在不同机房，从而实现异地容灾。
+
+另外一种灾备方式是通过 `taosX` 将一个 TDengine 集群的数据同步复制到物理上位于不同数据中心的另一个 TDengine 集群。其详细使用方法请参考 [taosX 参考手册](../../reference/taosX)

examples/c/tmq.c

@@ -29,7 +29,7 @@ static void msg_process(TAOS_RES* msg) {
   printf("vg: %d\n", tmq_get_vgroup_id(msg));
   if (tmq_get_res_type(msg) == TMQ_RES_TABLE_META) {
     tmq_raw_data raw = {0};
-    int32_t code = tmq_get_raw_meta(msg, &raw);
+    int32_t code = tmq_get_raw(msg, &raw);
     if (code == 0) {
       TAOS* pConn = taos_connect("192.168.1.86", "root", "taosdata", NULL, 0);
       if (pConn == NULL) {
@@ -50,7 +50,7 @@ static void msg_process(TAOS_RES* msg) {
       }
       taos_free_result(pRes);
 
-      int32_t ret = taos_write_raw_meta(pConn, raw);
+      int32_t ret = tmq_write_raw(pConn, raw);
       printf("write raw data: %s\n", tmq_err2str(ret));
       taos_close(pConn);
     }

include/client/taos.h

@@ -260,17 +260,20 @@ enum tmq_res_t {
 };
 
 typedef struct tmq_raw_data{
-  void*    raw_meta;
-  uint32_t raw_meta_len;
-  uint16_t raw_meta_type;
+  void*    raw;
+  uint32_t raw_len;
+  uint16_t raw_type;
 } tmq_raw_data;
 
 typedef enum tmq_res_t tmq_res_t;
 
 DLL_EXPORT tmq_res_t     tmq_get_res_type(TAOS_RES *res);
-DLL_EXPORT int32_t       tmq_get_raw_meta(TAOS_RES *res, tmq_raw_data *raw_meta);
-DLL_EXPORT int32_t       taos_write_raw_meta(TAOS *taos, tmq_raw_data raw_meta);
-DLL_EXPORT int32_t       taos_write_raw_data(TAOS *taos, TAOS_RES *res);
+DLL_EXPORT int32_t       tmq_get_raw(TAOS_RES *res, tmq_raw_data *raw);
+DLL_EXPORT int32_t       tmq_write_raw(TAOS *taos, tmq_raw_data raw);
+DLL_EXPORT int           taos_write_raw_block(TAOS *taos, int numOfRows, char *pData, const char* tbname);
+
+
+DLL_EXPORT void          tmq_free_raw(tmq_raw_data raw);
 DLL_EXPORT char         *tmq_get_json_meta(TAOS_RES *res);   // Returning null means error. Returned result need to be freed by tmq_free_json_meta
 DLL_EXPORT void          tmq_free_json_meta(char* jsonMeta);
 DLL_EXPORT const char   *tmq_get_topic_name(TAOS_RES *res);

include/common/tcommon.h

@@ -40,6 +40,7 @@ enum {
   || x == TDMT_VND_CREATE_TABLE   \
   || x == TDMT_VND_ALTER_TABLE    \
   || x == TDMT_VND_DROP_TABLE     \
+  || x == TDMT_VND_DELETE         \
 )
 // clang-format on
 

include/common/tglobal.h

@@ -41,10 +41,8 @@ extern int32_t tsCompressMsgSize;
 extern int32_t tsCompressColData;
 extern int32_t tsMaxNumOfDistinctResults;
 extern int32_t tsCompatibleModel;
-extern bool    tsEnableSlaveQuery;
 extern bool    tsPrintAuth;
 extern int64_t tsTickPerMin[3];
-
 extern int32_t tsCountAlwaysReturnValue;
 
 // multi-process
@@ -92,8 +90,6 @@ extern uint16_t tsTelemPort;
 extern int32_t tsQueryBufferSize;  // maximum allowed usage buffer size in MB for each data node during query processing
 extern int64_t tsQueryBufferSizeBytes;   // maximum allowed usage buffer size in byte for each data node
 extern bool    tsRetrieveBlockingModel;  // retrieve threads will be blocked
-extern bool    tsKeepOriginalColumnName;
-extern bool    tsDeadLockKillQuery;
 
 // query client
 extern int32_t tsQueryPolicy;
@@ -102,11 +98,6 @@ extern int32_t tsQuerySmaOptimize;
 // client
 extern int32_t tsMinSlidingTime;
 extern int32_t tsMinIntervalTime;
-extern int32_t tsMaxStreamComputDelay;
-extern int32_t tsStreamCompStartDelay;
-extern int32_t tsRetryStreamCompDelay;
-extern float   tsStreamComputDelayRatio;  // the delayed computing ration of the whole time window
-extern int64_t tsMaxRetentWindow;
 
 // build info
 extern char version[];
@@ -152,7 +143,10 @@ void    taosCfgDynamicOptions(const char *option, const char *value);
 void    taosAddDataDir(int32_t index, char *v1, int32_t level, int32_t primary);
 
 struct SConfig *taosGetCfg();
-int32_t taosSetCfg(SConfig *pCfg, char* name);
+
+void    taosSetAllDebugFlag(int32_t flag);
+void    taosSetDebugFlag(int32_t *pFlagPtr, const char *flagName, int32_t flagVal);
+int32_t taosSetCfg(SConfig *pCfg, char *name);
 
 #ifdef __cplusplus
 }

include/common/tmsgdef.h

@@ -136,6 +136,7 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_MND_DROP_INDEX, "drop-index", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_GET_INDEX, "get-index", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_GET_TABLE_INDEX, "get-table-index", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_BATCH_META, "batch-meta", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_TABLE_CFG, "table-cfg", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_CREATE_TOPIC, "create-topic", SMCreateTopicReq, SMCreateTopicRsp)
   TD_DEF_MSG_TYPE(TDMT_MND_ALTER_TOPIC, "alter-topic", NULL, NULL)
@@ -180,6 +181,7 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_VND_TABLE_META, "vnode-table-meta", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_TABLES_META, "vnode-tables-meta", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_TABLE_CFG, "vnode-table-cfg", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_BATCH_META, "vnode-batch-meta", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_CREATE_STB, "vnode-create-stb", SVCreateStbReq, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_ALTER_STB, "vnode-alter-stb", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_DROP_STB, "vnode-drop-stb", SVDropStbReq, NULL)

include/libs/executor/dataSinkMgt.h

@@ -38,6 +38,8 @@ typedef struct SDeleterRes {
   int64_t  skey;
   int64_t  ekey;
   int64_t  affectedRows;
+  char     tableName[TSDB_TABLE_NAME_LEN];
+  char     tsColName[TSDB_COL_NAME_LEN];
 } SDeleterRes;
 
 typedef struct SDeleterParam {

include/libs/executor/executor.h

@@ -64,17 +64,7 @@ qTaskInfo_t qCreateStreamExecTaskInfo(void* msg, SReadHandle* readers);
  * @param SReadHandle
  * @return
  */
-qTaskInfo_t qCreateQueueExecTaskInfo(void* msg, SReadHandle* readers, int32_t* numOfCols,
-                                     SSchemaWrapper** pSchema);
-
-/**
- * Set the input data block for the stream scan.
- * @param tinfo
- * @param input
- * @param type
- * @return
- */
-int32_t qSetStreamInput(qTaskInfo_t tinfo, const void* input, int32_t type, bool assignUid);
+qTaskInfo_t qCreateQueueExecTaskInfo(void* msg, SReadHandle* readers, int32_t* numOfCols, SSchemaWrapper** pSchema);
 
 /**
  * Set multiple input data blocks for the stream scan.
@@ -84,7 +74,7 @@ int32_t qSetStreamInput(qTaskInfo_t tinfo, const void* input, int32_t type, bool
  * @param type
  * @return
  */
-int32_t qSetMultiStreamInput(qTaskInfo_t tinfo, const void* pBlocks, size_t numOfBlocks, int32_t type, bool assignUid);
+int32_t qSetMultiStreamInput(qTaskInfo_t tinfo, const void* pBlocks, size_t numOfBlocks, int32_t type);
 
 /**
  * Update the table id list, add or remove.

include/libs/function/function.h

@@ -143,6 +143,7 @@ typedef struct SqlFunctionCtx {
   struct SExprInfo      *pExpr;
   struct SDiskbasedBuf  *pBuf;
   struct SSDataBlock    *pSrcBlock;
+  struct SSDataBlock    *pDstBlock; // used by indifinite rows function to set selectivity
   int32_t                curBufPage;
   bool                   increase;
 

include/libs/function/functionMgt.h

@@ -209,6 +209,7 @@ typedef enum EFuncDataRequired {
 } EFuncDataRequired;
 
 EFuncDataRequired fmFuncDataRequired(SFunctionNode* pFunc, STimeWindow* pTimeWindow);
+EFuncDataRequired fmFuncDynDataRequired(int32_t funcId, void* pRes, STimeWindow* pTimeWindow);
 
 int32_t fmGetFuncExecFuncs(int32_t funcId, SFuncExecFuncs* pFpSet);
 int32_t fmGetScalarFuncExecFuncs(int32_t funcId, SScalarFuncExecFuncs* pFpSet);