Merge branch '3.0' into feature/TD-11274-3.0

cmake/taostools_CMakeLists.txt.in

@@ -2,7 +2,7 @@
 # taos-tools
 ExternalProject_Add(taos-tools
         GIT_REPOSITORY https://github.com/taosdata/taos-tools.git
-        GIT_TAG c9cc20f
+        GIT_TAG 8a5e336
         SOURCE_DIR "${TD_SOURCE_DIR}/tools/taos-tools"
         BINARY_DIR ""
         #BUILD_IN_SOURCE TRUE

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

 ---
-sidebar_label: Interval
-title: Aggregate by Time Window
+sidebar_label: Distinguished
+title: Distinguished Query for Time Series Database
 ---
 
 Aggregation by time window is supported in TDengine. For example, in the case where temperature sensors report the temperature every seconds, the average temperature for every 10 minutes can be retrieved by performing a query with a time window.

docs/en/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/en/12-taos-sql/14-limit.md

----
-title: Naming & Restrictions
----
-
-## Naming Rules
-
-1. Only characters from the English alphabet, digits and underscore are allowed
-2. Names cannot start with a digit
-3. Case insensitive without escape character "\`"
-4. Identifier with escape character "\`"
-   To support more flexible table or column names, a new escape character "\`" is introduced. For more details please refer to [escape](/taos-sql/escape).
-
-## Password Rule
-
-The legal character set is `[a-zA-Z0-9!?$%^&*()_–+={[}]:;@~#|<,>.?/]`.
-
-## General Limits
-
-- Maximum length of database name is 32 bytes, and it can't include "." or special characters.
-- Maximum length of table name is 192 bytes, excluding the database name prefix and the separator.
-- Maximum length of each data row is 48K bytes. Please note that the upper limit includes the extra 2 bytes consumed by each column of BINARY/NCHAR type.
-- Maximum length of column name is 64.
-- Maximum number of columns is 4096. There must be at least 2 columns, and the first column must be timestamp.
-- Maximum length of tag name is 64.
-- Maximum number of tags is 128. There must be at least 1 tag. The total length of tag values should not exceed 16K bytes.
-- Maximum length of singe SQL statement is 1048576, i.e. 1 MB. It can be configured in the parameter `maxSQLLength` in the client side, the applicable range is [65480, 1048576].
-- At most 4096 columns can be returned by `SELECT`. Functions in the query statement constitute columns. An error is returned if the limit is exceeded.
-- Maximum numbers of databases, STables, tables are dependent only on the system resources.
-- Maximum number of replicas for a database is 3.
-- Maximum length of user name is 23 bytes.
-- Maximum length of password is 15 bytes.
-- Maximum number of rows depends only on the storage space.
-- Maximum number of vnodes for a single database is 1024.
-
-## Restrictions of Table/Column Names
-
-### Name Restrictions of Table/Column
-
-The name of a table or column can only be composed of ASCII characters, digits and underscore and it cannot start with a digit. The maximum length is 192 bytes. Names are case insensitive. The name mentioned in this rule doesn't include the database name prefix and the separator.
-
-### Name Restrictions After Escaping
-
-To support more flexible table or column names, new escape character "\`" is introduced in TDengine to avoid the conflict between table name and keywords and break the above restrictions for table names. The escape character is not counted in the length of table name.
-
-With escaping, the string inside escape characters are case sensitive, i.e. will not be converted to lower case internally.
-
-For example:
-\`aBc\` and \`abc\` are different table or column names, but "abc" and "aBc" are same names because internally they are all "abc".
-
-:::note
-The characters inside escape characters must be printable characters.
-
-:::

docs/en/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/en/12-taos-sql/19-limit.md

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

docs/en/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/en/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` 这个内置元数据库中的表和表结构。
+
+## INS_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    | 创建时间                  |
+
+## INS_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    | 创建时间           |
+
+## INS_MODULES
+
+提供组件的相关信息。也可以使用 SHOW MODULES 来查询这些信息
+
+| #   | **列名** | **数据类型** | **说明**   |
+| --- | :------: | ------------ | ---------- |
+| 1   |    id    | SMALLINT     | module id  |
+| 2   | endpoint | BINARY(134)  | 组件的地址 |
+| 3   |  module  | BINARY(10)   | 组件状态   |
+
+## INS_QNODES
+
+当前系统中 QNODE 的信息。也可以使用 SHOW QNODES 来查询这些信息。
+
+| #   |  **列名**   | **数据类型** | **说明**     |
+| --- | :---------: | ------------ | ------------ |
+| 1   |     id      | SMALLINT     | qnode id     |
+| 2   |  endpoint   | BINARY(134)  | qnode 的地址 |
+| 3   | create_time | TIMESTAMP    | 创建时间     |
+
+## INS_CLUSTER
+
+存储集群相关信息。
+
+| #   |  **列名**   | **数据类型** | **说明**   |
+| --- | :---------: | ------------ | ---------- |
+| 1   |     id      | BIGINT       | cluster id |
+| 2   |    name     | BINARY(134)  | 集群名称   |
+| 3   | create_time | TIMESTAMP    | 创建时间   |
+
+## INS_DATABASES
+
+提供用户创建的数据库对象的相关信息。也可以使用 SHOW DATABASES 来查询这些信息。
+
+| #   |       **列名**       | **数据类型**     | **说明**                                         |
+| --- | :------------------: | ---------------- | ------------------------------------------------ |
+| 1   |         name         | BINARY(32)       | 数据库名                                         |
+| 2   |     create_time      | TIMESTAMP        | 创建时间                                         |
+| 3   |       ntables        | INT              | 数据库中表的数量，包含子表和普通表但不包含超级表 |
+| 4   |       vgroups        | INT              | 数据库中有多少个 vgroup                          |
+| 6   |       replica        | INT              | 副本数                                           |
+| 7   |        quorum        | BINARY(3)        | 强一致性                                         |
+| 8   |       duration       | INT              | 单文件存储数据的时间跨度                         |
+| 9   |         keep         | INT              | 数据保留时长                                     |
+| 10  |        buffer        | INT              | 每个 vnode 写缓存的内存块大小，单位 MB           |
+| 11  |       pagesize       | INT              | 每个 VNODE 中元数据存储引擎的页大小，单位为 KB   |
+| 12  |        pages         | INT              | 每个 vnode 元数据存储引擎的缓存页个数            |
+| 13  |       minrows        | INT              | 文件块中记录的最大条数                           |
+| 14  |       maxrows        | INT              | 文件块中记录的最小条数                           |
+| 15  |         comp         | INT              | 数据压缩方式                                     |
+| 16  |      precision       | BINARY(2)        | 时间分辨率                                       |
+| 17  |        status        | BINARY(10)       | 数据库状态                                       |
+| 18  |      retention       | BINARY (60)      | 数据的聚合周期和保存时长                         |
+| 19  |    single_stable     | BOOL             | 表示此数据库中是否只可以创建一个超级表           |
+| 20  |      cachemodel      | BINARY(60)       | 表示是否在内存中缓存子表的最近数据               |
+| 21  |      cachesize       | INT              | 表示每个 vnode 中用于缓存子表最近数据的内存大小  |
+| 22  |      wal_level       | INT              | WAL 级别                                         |
+| 23  |   wal_fsync_period   | INT              | 数据落盘周期                                     |
+| 24  | wal_retention_period | INT              | WAL 的保存时长                                   |
+| 25  |  wal_retention_size  | INT              | WAL 的保存上限                                   |
+| 26  |   wal_roll_period    | INT              | wal 文件切换时长                                 |
+| 27  |   wal_segment_size   | wal 单个文件大小 |
+
+## INS_FUNCTIONS
+
+用户创建的自定义函数的信息。
+
+| #   |  **列名**   | **数据类型** | **说明**       |
+| --- | :---------: | ------------ | -------------- |
+| 1   |    name     | BINARY(64)   | 函数名         |
+| 2   |   comment   | BINARY(255)  | 补充说明       |
+| 3   |  aggregate  | INT          | 是否为聚合函数 |
+| 4   | output_type | BINARY(31)   | 输出类型       |
+| 5   | create_time | TIMESTAMP    | 创建时间       |
+| 6   |  code_len   | INT          | 代码长度       |
+| 7   |   bufsize   | INT          | buffer 大小    |
+
+## INS_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。 |
+
+## INS_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 聚合函数          |
+
+## INS_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)   | 表类型           |
+
+## INS_TAGS
+
+| #   |  **列名**   | **数据类型**  | **说明**               |
+| --- | :---------: | ------------- | ---------------------- |
+| 1   | table_name  | BINARY(192)   | 表名                   |
+| 2   |   db_name   | BINARY(64)    | 该表所在的数据库的名称 |
+| 3   | stable_name | BINARY(192)   | 所属的超级表表名       |
+| 4   |  tag_name   | BINARY(64)    | tag 的名称             |
+| 5   |  tag_type   | BINARY(64)    | tag 的类型             |
+| 6   |  tag_value  | BINARY(16384) | tag 的值               |
+
+## INS_USERS
+
+提供系统中创建的用户的相关信息。
+
+| #   |  **列名**   | **数据类型** | **说明** |
+| --- | :---------: | ------------ | -------- |
+| 1   |  user_name  | BINARY(23)   | 用户名   |
+| 2   |  privilege  | BINARY(256)  | 权限     |
+| 3   | create_time | TIMESTAMP    | 创建时间 |
+
+## INS_GRANTS
+
+提供企业版授权的相关信息。
+
+| #   |  **列名**   | **数据类型** | **说明**                                           |
+| --- | :---------: | ------------ | -------------------------------------------------- |
+| 1   |   version   | BINARY(9)    | 企业版授权说明：official(官方授权的)/trial(试用的) |
+| 2   |  cpu_cores  | BINARY(9)    | 授权使用的 CPU 核心数量                            |
+| 3   |   dnodes    | BINARY(10)   | 授权使用的 dnode 节点数量                          |
+| 4   |   streams   | BINARY(10)   | 授权创建的流数量                                   |
+| 5   |    users    | BINARY(10)   | 授权创建的用户数量                                 |
+| 6   |  accounts   | BINARY(10)   | 授权创建的帐户数量                                 |
+| 7   |   storage   | BINARY(21)   | 授权使用的存储空间大小                             |
+| 8   | connections | BINARY(21)   | 授权使用的客户端连接数量                           |
+| 9   |  databases  | BINARY(11)   | 授权使用的数据库数量                               |
+| 10  |    speed    | BINARY(9)    | 授权使用的数据点每秒写入数量                       |
+| 11  |  querytime  | BINARY(9)    | 授权使用的查询总时长                               |
+| 12  | timeseries  | BINARY(21)   | 授权使用的测点数量                                 |
+| 13  |   expired   | BINARY(5)    | 是否到期，true：到期，false：未到期                |
+| 14  | expire_time | BINARY(19)   | 试用期到期时间                                     |
+
+## INS_VGROUPS
+
+系统中所有 vgroups 的信息。
+
+| #   | **列名**  | **数据类型** | **说明**                                               |
+| --- | :-------: | ------------ | ------------------------------------------------------ |
+| 1   | vgroup_id | INT          | vgroup id                                              |
+| 2   |  db_name  | BINARY(32)   | 数据库名                                               |
+| 3   |  tables   | INT          | 此 vgroup 内有多少表                                   |
+| 4   |  status   | BINARY(10)   | 此 vgroup 的状态                                       |
+| 5   | v1_dnode  | INT          | 第一个成员所在的 dnode 的 id                           |
+| 6   | v1_status | BINARY(10)   | 第一个成员的状态                                       |
+| 7   | v2_dnode  | INT          | 第二个成员所在的 dnode 的 id                           |
+| 8   | v2_status | BINARY(10)   | 第二个成员的状态                                       |
+| 9   | v3_dnode  | INT          | 第三个成员所在的 dnode 的 id                           |
+| 10  | v3_status | BINARY(10)   | 第三个成员的状态                                       |
+| 11  |  nfiles   | INT          | 此 vgroup 中数据/元数据文件的数量                      |
+| 12  | file_size | INT          | 此 vgroup 中数据/元数据文件的大小                      |
+| 13  |   tsma    | TINYINT      | 此 vgroup 是否专用于 Time-range-wise SMA，1: 是, 0: 否 |
+
+## INS_CONFIGS
+
+系统配置参数。
+
+| #   | **列名** | **数据类型** | **说明**     |
+| --- | :------: | ------------ | ------------ |
+| 1   |   name   | BINARY(32)   | 配置项名称   |
+| 2   |  value   | BINARY(64)   | 该配置项的值 |
+
+## INS_DNODE_VARIABLES
+
+系统中每个 dnode 的配置参数。
+
+| #   | **列名** | **数据类型** | **说明**     |
+| --- | :------: | ------------ | ------------ |
+| 1   | dnode_id | INT          | dnode 的 ID  |
+| 2   |   name   | BINARY(32)   | 配置项名称   |
+| 3   |  value   | BINARY(64)   | 该配置项的值 |

docs/en/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/en/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/en/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/en/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/examples/csharp/AsyncQueryExample.cs

+using System;
+using System.Collections.Generic;
 using TDengineDriver;
+using TDengineDriver.Impl;
 using System.Runtime.InteropServices;
 
 namespace TDengineExample
@@ -19,8 +22,8 @@ namespace TDengineExample
         {
             if (code == 0 && taosRes != IntPtr.Zero)
             {
-                FetchRowAsyncCallback fetchRowAsyncCallback = new FetchRowAsyncCallback(FetchRowCallback);
-                TDengine.FetchRowAsync(taosRes, fetchRowAsyncCallback, param);
+                FetchRawBlockAsyncCallback fetchRowAsyncCallback = new FetchRawBlockAsyncCallback(FetchRawBlockCallback);
+                TDengine.FetchRawBlockAsync(taosRes, fetchRowAsyncCallback, param);
             }
             else
             {
@@ -28,179 +31,44 @@ namespace TDengineExample
             }
         }
 
-        static void FetchRowCallback(IntPtr param, IntPtr taosRes, int numOfRows)
+               // Iteratively call this interface until "numOfRows" is no greater than 0.
+        static void FetchRawBlockCallback(IntPtr param, IntPtr taosRes, int numOfRows)
         {
             if (numOfRows > 0)
             {
                 Console.WriteLine($"{numOfRows} rows async retrieved");
-                DisplayRes(taosRes);
-                TDengine.FetchRowAsync(taosRes, FetchRowCallback, param);
+                IntPtr pdata = TDengine.GetRawBlock(taosRes);
+                List<TDengineMeta> metaList = TDengine.FetchFields(taosRes);
+                List<object> dataList = LibTaos.ReadRawBlock(pdata, metaList, numOfRows);
+
+                for (int i = 0; i < dataList.Count; i++)
+                {
+                    if (i != 0 && (i+1) % metaList.Count == 0)
+                    {
+                        Console.WriteLine("{0}\t|", dataList[i]);
+                    }
+                    else
+                    {
+                        Console.Write("{0}\t|", dataList[i]);
+                    }
+                }
+                Console.WriteLine("");
+                TDengine.FetchRawBlockAsync(taosRes, FetchRawBlockCallback, param);
             }
             else
             {
                 if (numOfRows == 0)
                 {
                     Console.WriteLine("async retrieve complete.");
-
                 }
                 else
                 {
-                    Console.WriteLine($"FetchRowAsync callback error, error code {numOfRows}");
+                    Console.WriteLine($"FetchRawBlockCallback callback error, error code {numOfRows}");
                 }
                 TDengine.FreeResult(taosRes);
             }
         }
 
-        public static void DisplayRes(IntPtr res)
-        {
-            if (!IsValidResult(res))
-            {
-                TDengine.Cleanup();
-                System.Environment.Exit(1);
-            }
-
-            List<TDengineMeta> metaList = TDengine.FetchFields(res);
-            int fieldCount = metaList.Count;
-            // metaList.ForEach((item) => { Console.Write("{0} ({1}) \t|\t", item.name, item.size); });
-
-            List<object> dataList = QueryRes(res, metaList);
-            for (int index = 0; index < dataList.Count; index++)
-            {
-                if (index % fieldCount == 0 && index != 0)
-                {
-                    Console.WriteLine("");
-                }
-                Console.Write("{0} \t|\t", dataList[index].ToString());
-
-            }
-            Console.WriteLine("");
-        }
-
-        public static bool IsValidResult(IntPtr res)
-        {
-            if ((res == IntPtr.Zero) || (TDengine.ErrorNo(res) != 0))
-            {
-                if (res != IntPtr.Zero)
-                {
-                    Console.Write("reason: " + TDengine.Error(res));
-                    return false;
-                }
-                Console.WriteLine("");
-                return false;
-            }
-            return true;
-        }
-
-        private static List<object> QueryRes(IntPtr res, List<TDengineMeta> meta)
-        {
-            IntPtr taosRow;
-            List<object> dataRaw = new();
-            while ((taosRow = TDengine.FetchRows(res)) != IntPtr.Zero)
-            {
-                dataRaw.AddRange(FetchRow(taosRow, res));
-            }
-            if (TDengine.ErrorNo(res) != 0)
-            {
-                Console.Write("Query is not complete, Error {0} {1}", TDengine.ErrorNo(res), TDengine.Error(res));
-            }
-            TDengine.FreeResult(res);
-            Console.WriteLine("");
-            return dataRaw;
-        }
-
-        public static List<object> FetchRow(IntPtr taosRow, IntPtr taosRes)//, List<TDengineMeta> metaList, int numOfFiled
-        {
-            List<TDengineMeta> metaList = TDengine.FetchFields(taosRes);
-            int numOfFiled = TDengine.FieldCount(taosRes);
-
-
-            List<object> dataRaw = new();
-
-            IntPtr colLengthPrt = TDengine.FetchLengths(taosRes);
-            int[] colLengthArr = new int[numOfFiled];
-            Marshal.Copy(colLengthPrt, colLengthArr, 0, numOfFiled);
-
-            for (int i = 0; i < numOfFiled; i++)
-            {
-                TDengineMeta meta = metaList[i];
-                IntPtr data = Marshal.ReadIntPtr(taosRow, IntPtr.Size * i);
-
-                if (data == IntPtr.Zero)
-                {
-                    dataRaw.Add("NULL");
-                    continue;
-                }
-                switch ((TDengineDataType)meta.type)
-                {
-                    case TDengineDataType.TSDB_DATA_TYPE_BOOL:
-                        bool v1 = Marshal.ReadByte(data) != 0;
-                        dataRaw.Add(v1);
-                        break;
-                    case TDengineDataType.TSDB_DATA_TYPE_TINYINT:
-                        sbyte v2 = (sbyte)Marshal.ReadByte(data);
-                        dataRaw.Add(v2);
-                        break;
-                    case TDengineDataType.TSDB_DATA_TYPE_SMALLINT:
-                        short v3 = Marshal.ReadInt16(data);
-                        dataRaw.Add(v3);
-                        break;
-                    case TDengineDataType.TSDB_DATA_TYPE_INT:
-                        int v4 = Marshal.ReadInt32(data);
-                        dataRaw.Add(v4);
-                        break;
-                    case TDengineDataType.TSDB_DATA_TYPE_BIGINT:
-                        long v5 = Marshal.ReadInt64(data);
-                        dataRaw.Add(v5);
-                        break;
-                    case TDengineDataType.TSDB_DATA_TYPE_FLOAT:
-                        float v6 = (float)Marshal.PtrToStructure(data, typeof(float));
-                        dataRaw.Add(v6);
-                        break;
-                    case TDengineDataType.TSDB_DATA_TYPE_DOUBLE:
-                        double v7 = (double)Marshal.PtrToStructure(data, typeof(double));
-                        dataRaw.Add(v7);
-                        break;
-                    case TDengineDataType.TSDB_DATA_TYPE_BINARY:
-                        string v8 = Marshal.PtrToStringUTF8(data, colLengthArr[i]);
-                        dataRaw.Add(v8);
-                        break;
-                    case TDengineDataType.TSDB_DATA_TYPE_TIMESTAMP:
-                        long v9 = Marshal.ReadInt64(data);
-                        dataRaw.Add(v9);
-                        break;
-                    case TDengineDataType.TSDB_DATA_TYPE_NCHAR:
-                        string v10 = Marshal.PtrToStringUTF8(data, colLengthArr[i]);
-                        dataRaw.Add(v10);
-                        break;
-                    case TDengineDataType.TSDB_DATA_TYPE_UTINYINT:
-                        byte v12 = Marshal.ReadByte(data);
-                        dataRaw.Add(v12.ToString());
-                        break;
-                    case TDengineDataType.TSDB_DATA_TYPE_USMALLINT:
-                        ushort v13 = (ushort)Marshal.ReadInt16(data);
-                        dataRaw.Add(v13);
-                        break;
-                    case TDengineDataType.TSDB_DATA_TYPE_UINT:
-                        uint v14 = (uint)Marshal.ReadInt32(data);
-                        dataRaw.Add(v14);
-                        break;
-                    case TDengineDataType.TSDB_DATA_TYPE_UBIGINT:
-                        ulong v15 = (ulong)Marshal.ReadInt64(data);
-                        dataRaw.Add(v15);
-                        break;
-                    case TDengineDataType.TSDB_DATA_TYPE_JSONTAG:
-                        string v16 = Marshal.PtrToStringUTF8(data, colLengthArr[i]);
-                        dataRaw.Add(v16);
-                        break;
-                    default:
-                        dataRaw.Add("nonsupport data type");
-                        break;
-                }
-
-            }
-            return dataRaw;
-        }
-
         static IntPtr GetConnection()
         {
             string host = "localhost";
@@ -223,16 +91,16 @@ namespace TDengineExample
     }
 }
 
-//output:
-// Connect to TDengine success
-// 8 rows async retrieved
-
-// 1538548685500   |       11.8    |       221     |       0.28    |       california.losangeles   |       2       |
-// 1538548696600   |       13.4    |       223     |       0.29    |       california.losangeles   |       2       |
-// 1538548685000   |       10.8    |       223     |       0.29    |       california.losangeles   |       3       |
-// 1538548686500   |       11.5    |       221     |       0.35    |       california.losangeles   |       3       |
-// 1538548685000   |       10.3    |       219     |       0.31    |       california.sanfrancisco         |       2       |
-// 1538548695000   |       12.6    |       218     |       0.33    |       california.sanfrancisco         |       2       |
-// 1538548696800   |       12.3    |       221     |       0.31    |       california.sanfrancisco         |       2       |
-// 1538548696650   |       10.3    |       218     |       0.25    |       california.sanfrancisco         |       3       |
-// async retrieve complete.
+// //output:
+// // Connect to TDengine success
+// // 8 rows async retrieved
+
+// // 1538548685500   |       11.8    |       221     |       0.28    |       california.losangeles   |       2       |
+// // 1538548696600   |       13.4    |       223     |       0.29    |       california.losangeles   |       2       |
+// // 1538548685000   |       10.8    |       223     |       0.29    |       california.losangeles   |       3       |
+// // 1538548686500   |       11.5    |       221     |       0.35    |       california.losangeles   |       3       |
+// // 1538548685000   |       10.3    |       219     |       0.31    |       california.sanfrancisco         |       2       |
+// // 1538548695000   |       12.6    |       218     |       0.33    |       california.sanfrancisco         |       2       |
+// // 1538548696800   |       12.3    |       221     |       0.31    |       california.sanfrancisco         |       2       |
+// // 1538548696650   |       10.3    |       218     |       0.25    |       california.sanfrancisco         |       3       |
+// // async retrieve complete.
\ No newline at end of file

docs/examples/csharp/QueryExample.cs

 using TDengineDriver;
+using TDengineDriver.Impl;
 using System.Runtime.InteropServices;
 
 namespace TDengineExample
@@ -23,7 +24,7 @@ namespace TDengineExample
             Console.WriteLine("fieldCount=" + fieldCount);
 
             // print column names
-            List<TDengineMeta> metas = TDengine.FetchFields(res);
+            List<TDengineMeta> metas = LibTaos.GetMeta(res);
             for (int i = 0; i < metas.Count; i++)
             {
                 Console.Write(metas[i].name + "\t");
@@ -31,98 +32,17 @@ namespace TDengineExample
             Console.WriteLine();
 
             // print values
-            IntPtr row;
-            while ((row = TDengine.FetchRows(res)) != IntPtr.Zero)
+            List<Object> resData = LibTaos.GetData(res);
+            for (int i = 0; i < resData.Count; i++)
             {
-                List<TDengineMeta> metaList = TDengine.FetchFields(res);
-                int numOfFiled = TDengine.FieldCount(res);
-
-                List<String> dataRaw = new List<string>();
-
-                IntPtr colLengthPrt = TDengine.FetchLengths(res);
-                int[] colLengthArr = new int[numOfFiled];
-                Marshal.Copy(colLengthPrt, colLengthArr, 0, numOfFiled);
-
-                for (int i = 0; i < numOfFiled; i++)
+                Console.Write($"|{resData[i].ToString()} \t");
+                if (((i + 1) % metas.Count == 0))
                 {
-                    TDengineMeta meta = metaList[i];
-                    IntPtr data = Marshal.ReadIntPtr(row, IntPtr.Size * i);
-
-                    if (data == IntPtr.Zero)
-                    {
-                        Console.Write("NULL\t");
-                        continue;
-                    }
-                    switch ((TDengineDataType)meta.type)
-                    {
-                        case TDengineDataType.TSDB_DATA_TYPE_BOOL:
-                            bool v1 = Marshal.ReadByte(data) == 0 ? false : true;
-                            Console.Write(v1.ToString() + "\t");
-                            break;
-                        case TDengineDataType.TSDB_DATA_TYPE_TINYINT:
-                            sbyte v2 = (sbyte)Marshal.ReadByte(data);
-                            Console.Write(v2.ToString() + "\t");
-                            break;
-                        case TDengineDataType.TSDB_DATA_TYPE_SMALLINT:
-                            short v3 = Marshal.ReadInt16(data);
-                            Console.Write(v3.ToString() + "\t");
-                            break;
-                        case TDengineDataType.TSDB_DATA_TYPE_INT:
-                            int v4 = Marshal.ReadInt32(data);
-                            Console.Write(v4.ToString() + "\t");
-                            break;
-                        case TDengineDataType.TSDB_DATA_TYPE_BIGINT:
-                            long v5 = Marshal.ReadInt64(data);
-                            Console.Write(v5.ToString() + "\t");
-                            break;
-                        case TDengineDataType.TSDB_DATA_TYPE_FLOAT:
-                            float v6 = (float)Marshal.PtrToStructure(data, typeof(float));
-                            Console.Write(v6.ToString() + "\t");
-                            break;
-                        case TDengineDataType.TSDB_DATA_TYPE_DOUBLE:
-                            double v7 = (double)Marshal.PtrToStructure(data, typeof(double));
-                            Console.Write(v7.ToString() + "\t");
-                            break;
-                        case TDengineDataType.TSDB_DATA_TYPE_BINARY:
-                            string v8 = Marshal.PtrToStringUTF8(data, colLengthArr[i]);
-                            Console.Write(v8 + "\t");
-                            break;
-                        case TDengineDataType.TSDB_DATA_TYPE_TIMESTAMP:
-                            long v9 = Marshal.ReadInt64(data);
-                            Console.Write(v9.ToString() + "\t");
-                            break;
-                        case TDengineDataType.TSDB_DATA_TYPE_NCHAR:
-                            string v10 = Marshal.PtrToStringUTF8(data, colLengthArr[i]);
-                            Console.Write(v10 + "\t");
-                            break;
-                        case TDengineDataType.TSDB_DATA_TYPE_UTINYINT:
-                            byte v12 = Marshal.ReadByte(data);
-                            Console.Write(v12.ToString() + "\t");
-                            break;
-                        case TDengineDataType.TSDB_DATA_TYPE_USMALLINT:
-                            ushort v13 = (ushort)Marshal.ReadInt16(data);
-                            Console.Write(v13.ToString() + "\t");
-                            break;
-                        case TDengineDataType.TSDB_DATA_TYPE_UINT:
-                            uint v14 = (uint)Marshal.ReadInt32(data);
-                            Console.Write(v14.ToString() + "\t");
-                            break;
-                        case TDengineDataType.TSDB_DATA_TYPE_UBIGINT:
-                            ulong v15 = (ulong)Marshal.ReadInt64(data);
-                            Console.Write(v15.ToString() + "\t");
-                            break;
-                        case TDengineDataType.TSDB_DATA_TYPE_JSONTAG:
-                            string v16 = Marshal.PtrToStringUTF8(data, colLengthArr[i]);
-                            Console.Write(v16 + "\t");
-                            break;
-                        default:
-                            Console.Write("nonsupport data type value");
-                            break;
-                    }
-
+                    Console.WriteLine("");
                 }
-                Console.WriteLine();
             }
+            Console.WriteLine();
+            
             if (TDengine.ErrorNo(res) != 0)
             {
                 Console.WriteLine($"Query is not complete, Error {TDengine.ErrorNo(res)} {TDengine.Error(res)}");

docs/examples/csharp/SQLInsertExample.cs

@@ -15,10 +15,10 @@ namespace TDengineExample
             CheckRes(conn, res, "failed to change database");
             res = TDengine.Query(conn, "CREATE STABLE power.meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT)");
             CheckRes(conn, res, "failed to create stable");
-            var sql = "INSERT INTO d1001 USING meters TAGS(California.SanFrancisco, 2) VALUES ('2018-10-03 14:38:05.000', 10.30000, 219, 0.31000) ('2018-10-03 14:38:15.000', 12.60000, 218, 0.33000) ('2018-10-03 14:38:16.800', 12.30000, 221, 0.31000) " +
-                        "d1002 USING power.meters TAGS(California.SanFrancisco, 3) VALUES('2018-10-03 14:38:16.650', 10.30000, 218, 0.25000) " +
-                        "d1003 USING power.meters TAGS(California.LosAngeles, 2) VALUES('2018-10-03 14:38:05.500', 11.80000, 221, 0.28000)('2018-10-03 14:38:16.600', 13.40000, 223, 0.29000) " +
-                        "d1004 USING power.meters TAGS(California.LosAngeles, 3) VALUES('2018-10-03 14:38:05.000', 10.80000, 223, 0.29000)('2018-10-03 14:38:06.500', 11.50000, 221, 0.35000)";
+            var sql = "INSERT INTO d1001 USING meters TAGS('California.SanFrancisco', 2) VALUES ('2018-10-03 14:38:05.000', 10.30000, 219, 0.31000) ('2018-10-03 14:38:15.000', 12.60000, 218, 0.33000) ('2018-10-03 14:38:16.800', 12.30000, 221, 0.31000) " +
+                        "d1002 USING power.meters TAGS('California.SanFrancisco', 3) VALUES('2018-10-03 14:38:16.650', 10.30000, 218, 0.25000) " +
+                        "d1003 USING power.meters TAGS('California.LosAngeles', 2) VALUES('2018-10-03 14:38:05.500', 11.80000, 221, 0.28000)('2018-10-03 14:38:16.600', 13.40000, 223, 0.29000) " +
+                        "d1004 USING power.meters TAGS('California.LosAngeles', 3) VALUES('2018-10-03 14:38:05.000', 10.80000, 223, 0.29000)('2018-10-03 14:38:06.500', 11.50000, 221, 0.35000)";
             res = TDengine.Query(conn, sql);
             CheckRes(conn, res, "failed to insert data");
             int affectedRows = TDengine.AffectRows(res);

docs/examples/csharp/StmtInsertExample.cs

@@ -21,7 +21,7 @@ namespace TDengineExample
             CheckStmtRes(res, "failed to prepare stmt");
 
             // 2. bind table name and tags
-            TAOS_BIND[] tags = new TAOS_BIND[2] { TaosBind.BindBinary("California.SanFrancisco"), TaosBind.BindInt(2) };
+            TAOS_MULTI_BIND[] tags = new TAOS_MULTI_BIND[2] { TaosMultiBind.MultiBindBinary(new string[]{"California.SanFrancisco"}), TaosMultiBind.MultiBindInt(new int?[] {2}) };
             res = TDengine.StmtSetTbnameTags(stmt, "d1001", tags);
             CheckStmtRes(res, "failed to bind table name and tags");
 
@@ -44,7 +44,7 @@ namespace TDengineExample
             CheckStmtRes(res, "faild to execute");
 
             // 6. free 
-            TaosBind.FreeTaosBind(tags);
+            TaosMultiBind.FreeTaosBind(tags);
             TaosMultiBind.FreeTaosBind(values);
             TDengine.Close(conn);
             TDengine.Cleanup();

docs/examples/csharp/SubscribeDemo.cs

 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using TDengineTMQ;
+using TDengineDriver;
+using System.Runtime.InteropServices;
 
-namespace csharp
+namespace TMQExample
 {
     internal class SubscribeDemo
     {
+        static void Main(string[] args)
+        {
+            IntPtr conn = GetConnection();
+            string topic = "topic_example";
+            Console.WriteLine($"create topic if not exist {topic} as select * from meters");
+            //create topic 
+            IntPtr res = TDengine.Query(conn, $"create topic if not exists {topic} as select * from meters");
+           
+            if (res == IntPtr.Zero)
+            {
+                throw new Exception($"create topic failed, reason:{TDengine.Error(res)}");
+            }
+
+            var cfg = new ConsumerConfig
+            {
+                GourpId = "group_1",
+                TDConnectUser = "root",
+                TDConnectPasswd = "taosdata",
+                MsgWithTableName = "true",
+                TDConnectIp = "127.0.0.1",                
+            };
+
+            // create consumer 
+            var consumer = new ConsumerBuilder(cfg)
+                .Build();
+
+            // subscribe
+            consumer.Subscribe(topic);
+
+            // consume 
+            for (int i = 0; i < 5; i++)
+            {
+                var consumeRes = consumer.Consume(300);
+                // print consumeResult
+                foreach (KeyValuePair<TopicPartition, TaosResult> kv in consumeRes.Message)
+                {
+                    Console.WriteLine("topic partitions:\n{0}", kv.Key.ToString());
+
+                    kv.Value.Metas.ForEach(meta =>
+                    {
+                        Console.Write("{0} {1}({2}) \t|", meta.name, meta.TypeName(), meta.size);
+                    });
+                    Console.WriteLine("");
+                    kv.Value.Datas.ForEach(data =>
+                    {
+                        Console.WriteLine(data.ToString());
+                    });
+                }
+
+                consumer.Commit(consumeRes);
+                Console.WriteLine("\n================ {0} done ", i);
+
+            }
+
+            // retrieve topic list
+            List<string> topics = consumer.Subscription();
+            topics.ForEach(t => Console.WriteLine("topic name:{0}", t));
+
+
+            // unsubscribe
+            consumer.Unsubscribe();
+
+            // close consumer after use.Otherwise will lead memory leak.
+            consumer.Close();
+            TDengine.Close(conn);
+
+
+        }
+
+        static IntPtr GetConnection()
+        {
+            string host = "localhost";
+            short port = 6030;
+            string username = "root";
+            string password = "taosdata";
+            string dbname = "power";
+            var conn = TDengine.Connect(host, username, password, dbname, port);
+            if (conn == IntPtr.Zero)
+            {
+                Console.WriteLine("Connect to TDengine failed");
+                System.Environment.Exit(0);
+            }
+            else
+            {
+                Console.WriteLine("Connect to TDengine success");
+            }
+            return conn;
+        }
     }
+
 }

docs/examples/csharp/asyncquery.csproj

@@ -9,7 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="TDengine.Connector" Version="1.0.6" />
+    <PackageReference Include="TDengine.Connector" Version="3.0.0" />
   </ItemGroup>
 
 </Project>

docs/examples/csharp/connect.csproj

@@ -9,7 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="TDengine.Connector" Version="1.0.6" />
+    <PackageReference Include="TDengine.Connector" Version="3.0.0" />
   </ItemGroup>
 
 </Project>

docs/examples/csharp/influxdbline.csproj

@@ -9,7 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="TDengine.Connector" Version="1.0.6" />
+    <PackageReference Include="TDengine.Connector" Version="3.0.0" />
   </ItemGroup>
 
 </Project>

docs/examples/csharp/optsjson.csproj

@@ -9,7 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="TDengine.Connector" Version="1.0.6" />
+    <PackageReference Include="TDengine.Connector" Version="3.0.0" />
   </ItemGroup>
 
 </Project>

docs/examples/csharp/optstelnet.csproj

@@ -9,7 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="TDengine.Connector" Version="1.0.6" />
+    <PackageReference Include="TDengine.Connector" Version="3.0.0" />
   </ItemGroup>
 
 </Project>

docs/examples/csharp/query.csproj

@@ -9,7 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="TDengine.Connector" Version="1.0.6" />
+    <PackageReference Include="TDengine.Connector" Version="3.0.0" />
   </ItemGroup>
 
 </Project>

docs/examples/csharp/sqlinsert.csproj

@@ -9,7 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="TDengine.Connector" Version="1.0.6" />
+    <PackageReference Include="TDengine.Connector" Version="3.0.0" />
   </ItemGroup>
 
 </Project>

docs/examples/csharp/stmtinsert.csproj

@@ -9,7 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="TDengine.Connector" Version="1.0.6" />
+    <PackageReference Include="TDengine.Connector" Version="3.0.0" />
   </ItemGroup>
 
 </Project>

docs/examples/csharp/subscribe.csproj

@@ -5,11 +5,11 @@
     <TargetFramework>net6.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
-    <StartupObject>TDengineExample.SubscribeDemo</StartupObject>
+    <StartupObject>TMQExample.SubscribeDemo</StartupObject>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="TDengine.Connector" Version="1.0.6" />
+    <PackageReference Include="TDengine.Connector" Version="3.0.0" />
   </ItemGroup>
 
 </Project>

docs/zh/12-taos-sql/24-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/14-reference/03-connector/csharp.mdx

@@ -22,7 +22,9 @@ import CSAsyncQuery from "../../07-develop/04-query-data/_cs_async.mdx"
 
 本文介绍如何在 Linux 或 Windows 环境中安装 `TDengine.Connector`，并通过 `TDengine.Connector` 连接 TDengine 集群，进行数据写入、查询等基本操作。
 
-`TDengine.Connector` 的源码托管在 [GitHub](https://github.com/taosdata/taos-connector-dotnet)。
+注意：`TDengine.Connector` 3.x 不兼容 TDengine 2.x，如果在运行 TDengine 2.x 版本的环境下需要使用 C# 连接器请使用 TDengine.Connector 的 1.x 版本 。
+
+`TDengine.Connector` 的源码托管在 [GitHub](https://github.com/taosdata/taos-connector-dotnet/tree/3.0)。
 
 ## 支持的平台
 
@@ -63,15 +65,15 @@ dotnet add package TDengine.Connector
 </TabItem>
 <TabItem value="source" label="使用源码获取 C# 驱动">
 
-可以下载 TDengine 的源码，直接引用最新版本的 TDengine.Connector 库
+也可以[下载源码](https://github.com/taosdata/taos-connector-dotnet/tree/3.0)，直接引用 TDengine.Connector 库
 
 ```bash
-git clone https://github.com/taosdata/TDengine.git
-cd TDengine/src/connector/C#/src/
-cp -r TDengineDriver/ myProject
+git clone -b 3.0 https://github.com/taosdata/taos-connector-dotnet.git
+cd taos-connector-dotnet
+cp -r src/ myProject
 
 cd myProject
-dotnet add TDengineDriver/TDengineDriver.csproj
+dotnet add exmaple.csproj reference src/TDengine.csproj
 ```
 </TabItem>
 </Tabs>
@@ -145,20 +147,19 @@ namespace TDengineExample
 
 |示例程序                                                                                                               | 示例程序描述                                       |
 |--------------------------------------------------------------------------------------------------------------------|--------------------------------------------|
-| [C#checker](https://github.com/taosdata/TDengine/tree/develop/examples/C%23/C%23checker)                           | 使用 TDengine.Connector 可以通过 help 命令中提供的参数，测试C# Driver的同步写入和查询    |
-| [TDengineTest](https://github.com/taosdata/TDengine/tree/develop/examples/C%23/TDengineTest)                       | 使用 TDengine.Connector 实现的简单写入和查询的示例 |
-| [insertCn](https://github.com/taosdata/TDengine/tree/develop/examples/C%23/insertCn)                               | 使用 TDengine.Connector 实现的写入和查询中文字符的示例    |
-| [jsonTag](https://github.com/taosdata/TDengine/tree/develop/examples/C%23/jsonTag)                                 | 使用 TDengine.Connector 实现的写入和查询 json tag 类型数据的示例 |
-| [stmt](https://github.com/taosdata/TDengine/tree/develop/examples/C%23/stmt)                                       | 使用 TDengine.Connector 实现的参数绑定的示例 |
-| [schemaless](https://github.com/taosdata/TDengine/tree/develop/examples/C%23/schemaless)                           | 使用 TDengine.Connector 实现的使用 schemaless 写入的示例 |
-| [benchmark](https://github.com/taosdata/TDengine/tree/develop/examples/C%23/taosdemo)                              | 使用 TDengine.Connector 实现的简易 Benchmark |
-| [async   query](https://github.com/taosdata/taos-connector-dotnet/blob/develop/examples/QueryAsyncSample.cs) | 使用 TDengine.Connector 实现的异步查询的示例 |
-| [subscribe](https://github.com/taosdata/taos-connector-dotnet/blob/develop/examples/SubscribeSample.cs)      | 使用 TDengine.Connector 实现的订阅数据的示例 |
+| [CURD](https://github.com/taosdata/taos-connector-dotnet/blob/3.0/examples/Query/Query.cs)                         | 使用 TDengine.Connector 实现的建表、插入、查询示例    |
+| [JSON Tag](https://github.com/taosdata/taos-connector-dotnet/blob/3.0/examples/JSONTag)                             | 使用 TDengine.Connector 实现的写入和查询 JSON tag 类型数据的示例 |
+| [stmt](https://github.com/taosdata/taos-connector-dotnet/tree/3.0/examples/Stmt)                                   | 使用 TDengine.Connector 实现的参数绑定插入和查询的示例 |
+| [schemaless](https://github.com/taosdata/taos-connector-dotnet/blob/3.0/examples/schemaless)                       | 使用 TDengine.Connector 实现的使用 schemaless 写入的示例 |
+| [async query](https://github.com/taosdata/taos-connector-dotnet/blob/3.0/examples/AsyncQuery/QueryAsync.cs) | 使用 TDengine.Connector 实现的异步查询的示例 |
+| [TMQ](https://github.com/taosdata/taos-connector-dotnet/blob/3.0/examples/TMQ/TMQ.cs)      | 使用 TDengine.Connector 实现的订阅数据的示例 |
 
 ## 重要更新记录
 
 | TDengine.Connector | 说明                           |
 |--------------------|--------------------------------|
+|        3.0.0       | 支持 TDengine 3.0.0.0，不兼容 2.x。新增接口TDengine.Impl.GetData()，解析查询结果。 |
+|        1.0.7       | 修复 TDengine.Query()内存泄露。 |
 |        1.0.6       | 修复 schemaless 在 1.0.4 和 1.0.5 中失效 bug。 |
 |        1.0.5       | 修复 Windows 同步查询中文报错 bug。   |
 |        1.0.4       | 新增异步查询，订阅等功能。修复绑定参数 bug。    |

docs/zh/14-reference/05-taosbenchmark.md

@@ -227,40 +227,12 @@ taosBenchmark -A INT,DOUBLE,NCHAR,BINARY\(16\)
 
 #### 数据库相关配置参数
 
-创建数据库时的相关参数在 json 配置文件中的 `dbinfo` 中配置，具体参数如下。这些参数与 TDengine 中 `create database` 时所指定的数据库参数相对应。
+创建数据库时的相关参数在 json 配置文件中的 `dbinfo` 中配置，个别具体参数如下。其余参数均与 TDengine 中 `create database` 时所指定的数据库参数相对应，详见[../../taos-sql/database]
 
 - **name** : 数据库名。
 
 - **drop** : 插入前是否删除数据库，默认为 true。
 
-- **replica** : 创建数据库时指定的副本数。
-
-- **days** : 单个数据文件中存储数据的时间跨度，默认值为 10。
-
-- **cache** : 缓存块的大小，单位是 MB，默认值是 16。
-
-- **blocks** : 每个 vnode 中缓存块的数量，默认为 6。
-
-- **precision** : 数据库时间精度，默认值为 "ms"。
-
-- **keep** : 保留数据的天数，默认值为 3650。
-
-- **minRows** : 文件块中的最小记录数，默认值为 100。
-
-- **maxRows** : 文件块中的最大记录数，默认值为 4096。
-
-- **comp** : 文件压缩标志，默认值为 2。
-
-- **walLevel** : WAL 级别，默认为 1。
-
-- **cacheLast** : 是否允许将每个表的最后一条记录保留在内存中，默认值为 0，可选值为 0，1，2，3。
-
-- **quorum** : 多副本模式下的写确认数量，默认值为 1。
-
-- **fsync** : 当 wal 设置为 2 时，fsync 的间隔时间，单位为 ms，默认值为 3000。
-
-- **update** : 是否支持数据更新，默认值为 0， 可选值为 0， 1， 2。
-
 #### 超级表相关配置参数
 
 创建超级表时的相关参数在 json 配置文件中的 `super_tables` 中配置，具体参数如下表。
@@ -335,6 +307,8 @@ taosBenchmark -A INT,DOUBLE,NCHAR,BINARY\(16\)
 
 - **values** : nchar/binary 列/标签的值域，将从值中随机选择。
 
+- **sma**: 将该列加入bsma中，值为 "yes" 或者 "no"，默认为 "no"。
+
 #### 插入行为配置参数
 
 - **thread_count** : 插入数据的线程数量，默认为 8。

docs/zh/17-operation/17-diagnose.md

----
-title: 诊断及其他
----
-
-## 网络连接诊断
-
-当出现客户端应用无法访问服务端时，需要确认客户端与服务端之间网络的各端口连通情况，以便有针对性地排除故障。
-
-目前网络连接诊断支持在：Linux 与 Linux，Linux 与 Windows 之间进行诊断测试。
-
-诊断步骤：
-
-1. 如拟诊断的端口范围与服务器 taosd 实例的端口范围相同，须先停掉 taosd 实例
-2. 服务端命令行输入：`taos -n server -P <port> -l <pktlen>` 以服务端身份启动对端口 port 为基准端口的监听
-3. 客户端命令行输入：`taos -n client -h <fqdn of server> -P <port> -l <pktlen>` 以客户端身份启动对指定的服务器、指定的端口发送测试包
- 
--l <pktlen\>： 测试网络包的大小（单位：字节）。最小值是 11、最大值是 64000，默认值为 1000。
-注：两端命令行中指定的测试包长度必须一致，否则测试显示失败。
-
-服务端运行正常的话会输出以下信息：
-
-```bash
-# taos -n server -P 6000
-12/21 14:50:13.522509 0x7f536f455200 UTL work as server, host:172.27.0.7 startPort:6000 endPort:6011 pkgLen:1000
-
-12/21 14:50:13.522659 0x7f5352242700 UTL TCP server at port:6000 is listening
-12/21 14:50:13.522727 0x7f5351240700 UTL TCP server at port:6001 is listening
-...
-...
-...
-12/21 14:50:13.523954 0x7f5342fed700 UTL TCP server at port:6011 is listening
-12/21 14:50:13.523989 0x7f53437ee700 UTL UDP server at port:6010 is listening
-12/21 14:50:13.524019 0x7f53427ec700 UTL UDP server at port:6011 is listening
-12/21 14:50:22.192849 0x7f5352242700 UTL TCP: read:1000 bytes from 172.27.0.8 at 6000
-12/21 14:50:22.192993 0x7f5352242700 UTL TCP: write:1000 bytes to 172.27.0.8 at 6000
-12/21 14:50:22.237082 0x7f5351a41700 UTL UDP: recv:1000 bytes from 172.27.0.8 at 6000
-12/21 14:50:22.237203 0x7f5351a41700 UTL UDP: send:1000 bytes to 172.27.0.8 at 6000
-12/21 14:50:22.237450 0x7f5351240700 UTL TCP: read:1000 bytes from 172.27.0.8 at 6001
-12/21 14:50:22.237576 0x7f5351240700 UTL TCP: write:1000 bytes to 172.27.0.8 at 6001
-12/21 14:50:22.281038 0x7f5350a3f700 UTL UDP: recv:1000 bytes from 172.27.0.8 at 6001
-12/21 14:50:22.281141 0x7f5350a3f700 UTL UDP: send:1000 bytes to 172.27.0.8 at 6001
-...
-...
-...
-12/21 14:50:22.677443 0x7f5342fed700 UTL TCP: read:1000 bytes from 172.27.0.8 at 6011
-12/21 14:50:22.677576 0x7f5342fed700 UTL TCP: write:1000 bytes to 172.27.0.8 at 6011
-12/21 14:50:22.721144 0x7f53427ec700 UTL UDP: recv:1000 bytes from 172.27.0.8 at 6011
-12/21 14:50:22.721261 0x7f53427ec700 UTL UDP: send:1000 bytes to 172.27.0.8 at 6011
-```
-
-客户端运行正常会输出以下信息：
-
-```bash
-# taos -n client -h 172.27.0.7 -P 6000
-12/21 14:50:22.192434 0x7fc95d859200 UTL work as client, host:172.27.0.7 startPort:6000 endPort:6011 pkgLen:1000
-
-12/21 14:50:22.192472 0x7fc95d859200 UTL server ip:172.27.0.7 is resolved from host:172.27.0.7
-12/21 14:50:22.236869 0x7fc95d859200 UTL successed to test TCP port:6000
-12/21 14:50:22.237215 0x7fc95d859200 UTL successed to test UDP port:6000
-...
-...
-...
-12/21 14:50:22.676891 0x7fc95d859200 UTL successed to test TCP port:6010
-12/21 14:50:22.677240 0x7fc95d859200 UTL successed to test UDP port:6010
-12/21 14:50:22.720893 0x7fc95d859200 UTL successed to test TCP port:6011
-12/21 14:50:22.721274 0x7fc95d859200 UTL successed to test UDP port:6011
-```
-
-仔细阅读打印出来的错误信息，可以帮助管理员找到原因，以解决问题。
-
-## 启动状态及 RPC 诊断
-
-`taos -n startup -h <fqdn of server>`
-
-判断 taosd 服务端是否成功启动，是数据库管理员经常遇到的一种情形。特别当若干台服务器组成集群时，判断每个服务端实例是否成功启动就会是一个重要问题。除检索 taosd 服务端日志文件进行问题定位、分析外，还可以通过 `taos -n startup -h <fqdn of server>` 来诊断一个 taosd 进程的启动状态。
-
-针对多台服务器组成的集群，当服务启动过程耗时较长时，可通过该命令行来诊断每台服务器的 taosd 实例的启动状态，以准确定位问题。
-
-`taos -n rpc -h <fqdn of server>`
-
-该命令用来诊断已经启动的 taosd 实例的端口是否可正常访问。如果 taosd 程序异常或者失去响应，可以通过 `taos -n rpc -h <fqdn of server>` 来发起一个与指定 fqdn 的 rpc 通信，看看 taosd 是否能收到，以此来判定是网络问题还是 taosd 程序异常问题。
-
-## sync 及 arbitrator 诊断
-
-```
-taos -n sync -P 6040 -h <fqdn of server>
-taos -n sync -P 6042 -h <fqdn of server>
-```
-
-用来诊断 sync 端口是否工作正常，判断服务端 sync 模块是否成功工作。另外，-P 6042 用来诊断 arbitrator 是否配置正常，判断指定服务器的 arbitrator 是否能正常工作。
-
-## 网络速度诊断
-
-`taos -n speed -h <fqdn of server> -P 6030 -N 10 -l 10000000 -S TCP`
-
-从 2.2.0.0 版本开始，taos 工具新提供了一个网络速度诊断的模式，可以对一个正在运行中的 taosd 实例或者 `taos -n server` 方式模拟的一个服务端实例，以非压缩传输的方式进行网络测速。这个模式下可供调整的参数如下：
-
--n：设为“speed”时，表示对网络速度进行诊断。
--h：所要连接的服务端的 FQDN 或 ip 地址。如果不设置这一项，会使用本机 taos.cfg 文件中 FQDN 参数的设置作为默认值。
--P：所连接服务端的网络端口。默认值为 6030。
--N：诊断过程中使用的网络包总数。最小值是 1、最大值是 10000，默认值为 100。
--l：单个网络包的大小（单位：字节）。最小值是 1024、最大值是 1024 `*` 1024 `*` 1024，默认值为 1024。
--S：网络封包的类型。可以是 TCP 或 UDP，默认值为 TCP。
-
-## FQDN 解析速度诊断
-
-`taos -n fqdn -h <fqdn of server>`
-
-从 2.2.0.0 版本开始，taos 工具新提供了一个 FQDN 解析速度的诊断模式，可以对一个目标 FQDN 地址尝试解析，并记录解析过程中所消耗的时间。这个模式下可供调整的参数如下：
-
--n：设为“fqdn”时，表示对 FQDN 解析进行诊断。
--h：所要解析的目标 FQDN 地址。如果不设置这一项，会使用本机 taos.cfg 文件中 FQDN 参数的设置作为默认值。
-
-## 服务端日志
-
-taosd 服务端日志文件标志位 debugflag 默认为 131，在 debug 时往往需要将其提升到 135 或 143 。
-
-一旦设定为 135 或 143，日志文件增长很快，特别是写入、查询请求量较大时，增长速度惊人。如合并保存日志，很容易把日志内的关键信息（如配置信息、错误信息等）冲掉。为此，服务端将重要信息日志与其他日志分开存放：
-
-- taosinfo 存放重要信息日志, 包括：INFO/ERROR/WARNING 级别的日志信息。不记录 DEBUG、TRACE 级别的日志。
-- taosdlog 服务器端生成的日志，记录 taosinfo 中全部信息外，还根据设置的日志输出级别，记录 DEBUG（日志级别 135）、TRACE（日志级别是 143）。
-
-## 客户端日志
-
-每个独立运行的客户端（一个进程）生成一个独立的客户端日志，其命名方式采用 taoslog+<序号> 的方式命名。文件标志位 debugflag 默认为 131，在 debug 时往往需要将其提升到 135 或 143 。
-
-- taoslog 客户端（driver）生成的日志，默认记录客户端 INFO/ERROR/WARNING 级别日志，还根据设置的日志输出级别，记录 DEBUG（日志级别 135）、TRACE（日志级别是 143）。
-
-其中，日志文件最大长度由 numOfLogLines 来进行配置，一个 taosd 实例最多保留两个文件。
-
-taosd 服务端日志采用异步落盘写入机制，优点是可以避免硬盘写入压力太大，对性能造成很大影响。缺点是，在极端情况下，存在少量日志行数丢失的可能。
+---
+title: 诊断及其他
+---
+
+## 网络连接诊断
+
+当出现客户端应用无法访问服务端时，需要确认客户端与服务端之间网络的各端口连通情况，以便有针对性地排除故障。
+
+目前网络连接诊断支持在：Linux 与 Linux，Linux 与 Windows 之间进行诊断测试。
+
+诊断步骤：
+
+1. 如拟诊断的端口范围与服务器 taosd 实例的端口范围相同，须先停掉 taosd 实例
+2. 服务端命令行输入：`taos -n server -P <port> -l <pktlen>` 以服务端身份启动对端口 port 为基准端口的监听
+3. 客户端命令行输入：`taos -n client -h <fqdn of server> -P <port> -l <pktlen>` 以客户端身份启动对指定的服务器、指定的端口发送测试包
+
+-l <pktlen\>： 测试网络包的大小（单位：字节）。最小值是 11、最大值是 64000，默认值为 1000。
+注：两端命令行中指定的测试包长度必须一致，否则测试显示失败。
+
+服务端运行正常的话会输出以下信息：
+
+```bash
+# taos -n server -P 6030 -l 1000
+network test server is initialized, port:6030
+request is received, size:1000
+request is received, size:1000
+...
+...
+...
+request is received, size:1000
+request is received, size:1000
+```
+
+客户端运行正常会输出以下信息：
+
+```bash
+# taos -n client -h 172.27.0.7 -P 6000
+taos -n client -h v3s2 -P 6030 -l 1000
+network test client is initialized, the server is v3s2:6030
+request is sent, size:1000
+response is received, size:1000
+request is sent, size:1000
+response is received, size:1000
+...
+...
+...
+request is sent, size:1000
+response is received, size:1000
+request is sent, size:1000
+response is received, size:1000
+
+total succ:  100/100	cost:   16.23 ms	speed:    5.87 MB/s
+```
+
+仔细阅读打印出来的错误信息，可以帮助管理员找到原因，以解决问题。
+
+## 服务端日志
+
+taosd 服务端日志文件标志位 debugflag 默认为 131，在 debug 时往往需要将其提升到 135 或 143 。
+
+一旦设定为 135 或 143，日志文件增长很快，特别是写入、查询请求量较大时，增长速度惊人。请注意日志文件目录所在磁盘的空间大小。
+
+## 客户端日志
+
+每个独立运行的客户端（一个进程）生成一个独立的客户端日志，其命名方式采用 taoslog+<序号> 的方式命名。文件标志位 debugflag 默认为 131，在 debug 时往往需要将其提升到 135 或 143 。
+
+- taoslog 客户端（driver）生成的日志，默认记录客户端 INFO/ERROR/WARNING 级别日志，还根据设置的日志输出级别，记录 DEBUG（日志级别 135）、TRACE（日志级别是 143）。
+
+其中，日志文件最大长度由 numOfLogLines 来进行配置，一个 taosd 实例最多保留两个文件。
+
+taosd 服务端日志采用异步落盘写入机制，优点是可以避免硬盘写入压力太大，对性能造成很大影响。缺点是，在极端情况下，存在少量日志行数丢失的可能。当问题分析需要的时候，可以考虑将 参数 asynclog 设置成 0，修改为同步落盘写入机制，保证日志不会丢失。

include/libs/stream/tstream.h

@@ -66,6 +66,25 @@ enum {
   TASK_OUTPUT_STATUS__BLOCKED,
 };
 
+enum {
+  TASK_TRIGGER_STATUS__INACTIVE = 1,
+  TASK_TRIGGER_STATUS__ACTIVE,
+};
+
+enum {
+  TASK_LEVEL__SOURCE = 1,
+  TASK_LEVEL__AGG,
+  TASK_LEVEL__SINK,
+};
+
+enum {
+  TASK_OUTPUT__FIXED_DISPATCH = 1,
+  TASK_OUTPUT__SHUFFLE_DISPATCH,
+  TASK_OUTPUT__TABLE,
+  TASK_OUTPUT__SMA,
+  TASK_OUTPUT__FETCH,
+};
+
 typedef struct {
   int8_t type;
 } SStreamQueueItem;
@@ -202,29 +221,6 @@ typedef struct {
   int8_t reserved;
 } STaskSinkFetch;
 
-enum {
-  TASK_EXEC__NONE = 1,
-  TASK_EXEC__PIPE,
-};
-
-enum {
-  TASK_DISPATCH__NONE = 1,
-  TASK_DISPATCH__FIXED,
-  TASK_DISPATCH__SHUFFLE,
-};
-
-enum {
-  TASK_SINK__NONE = 1,
-  TASK_SINK__TABLE,
-  TASK_SINK__SMA,
-  TASK_SINK__FETCH,
-};
-
-enum {
-  TASK_TRIGGER_STATUS__IN_ACTIVE = 1,
-  TASK_TRIGGER_STATUS__ACTIVE,
-};
-
 typedef struct {
   int32_t nodeId;
   int32_t childId;
@@ -237,11 +233,8 @@ typedef struct {
 typedef struct SStreamTask {
   int64_t streamId;
   int32_t taskId;
-  int8_t  isDataScan;
-  int8_t  execType;
-  int8_t  sinkType;
-  int8_t  dispatchType;
-  int8_t  isStreamDistributed;
+  int8_t  taskLevel;
+  int8_t  outputType;
   int16_t dispatchMsgType;
 
   int8_t taskStatus;
@@ -252,13 +245,12 @@ typedef struct SStreamTask {
   int32_t nodeId;
   SEpSet  epSet;
 
-  // used for semi or single task,
-  // while final task should have processedVer for each child
+  // used for task source and sink,
+  // while task agg should have processedVer for each child
   int64_t recoverSnapVer;
   int64_t startVer;
   int64_t checkpointVer;
   int64_t processedVer;
-  // int32_t numOfVgroups;
 
   // children info
   SArray* childEpInfo;  // SArray<SStreamChildEpInfo*>
@@ -266,19 +258,13 @@ typedef struct SStreamTask {
   // exec
   STaskExec exec;
 
-  // TODO: unify sink and dispatch
-
-  //  local sink
-  union {
-    STaskSinkTb    tbSink;
-    STaskSinkSma   smaSink;
-    STaskSinkFetch fetchSink;
-  };
-
-  // remote dispatcher
+  // output
   union {
     STaskDispatcherFixedEp fixedEpDispatcher;
     STaskDispatcherShuffle shuffleDispatcher;
+    STaskSinkTb            tbSink;
+    STaskSinkSma           smaSink;
+    STaskSinkFetch         fetchSink;
   };
 
   int8_t inputStatus;
@@ -292,9 +278,6 @@ typedef struct SStreamTask {
   int64_t triggerParam;
   void*   timer;
 
-  // application storage
-  // void* ahandle;
-
   // msg handle
   SMsgCb* pMsgCb;
 } SStreamTask;
@@ -331,7 +314,7 @@ static FORCE_INLINE int32_t streamTaskInput(SStreamTask* pTask, SStreamQueueItem
   }
 
   if (pItem->type != STREAM_INPUT__GET_RES && pItem->type != STREAM_INPUT__CHECKPOINT && pTask->triggerParam != 0) {
-    atomic_val_compare_exchange_8(&pTask->triggerStatus, TASK_TRIGGER_STATUS__IN_ACTIVE, TASK_TRIGGER_STATUS__ACTIVE);
+    atomic_val_compare_exchange_8(&pTask->triggerStatus, TASK_TRIGGER_STATUS__INACTIVE, TASK_TRIGGER_STATUS__ACTIVE);
   }
 
 #if 0
@@ -346,18 +329,15 @@ static FORCE_INLINE void streamTaskInputFail(SStreamTask* pTask) {
 }
 
 static FORCE_INLINE int32_t streamTaskOutput(SStreamTask* pTask, SStreamDataBlock* pBlock) {
-  if (pTask->sinkType == TASK_SINK__TABLE) {
-    ASSERT(pTask->dispatchType == TASK_DISPATCH__NONE);
+  if (pTask->outputType == TASK_OUTPUT__TABLE) {
     pTask->tbSink.tbSinkFunc(pTask, pTask->tbSink.vnode, 0, pBlock->blocks);
     taosArrayDestroyEx(pBlock->blocks, (FDelete)blockDataFreeRes);
     taosFreeQitem(pBlock);
-  } else if (pTask->sinkType == TASK_SINK__SMA) {
-    ASSERT(pTask->dispatchType == TASK_DISPATCH__NONE);
+  } else if (pTask->outputType == TASK_OUTPUT__SMA) {
     pTask->smaSink.smaSink(pTask->smaSink.vnode, pTask->smaSink.smaId, pBlock->blocks);
     taosArrayDestroyEx(pBlock->blocks, (FDelete)blockDataFreeRes);
     taosFreeQitem(pBlock);
   } else {
-    ASSERT(pTask->dispatchType != TASK_DISPATCH__NONE);
     taosWriteQitem(pTask->outputQueue->queue, pBlock);
   }
   return 0;

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

@@ -98,13 +98,11 @@ END:
 }
 
 int32_t mndAddSinkToTask(SMnode* pMnode, SStreamObj* pStream, SStreamTask* pTask) {
-  pTask->dispatchType = TASK_DISPATCH__NONE;
-  // sink
   if (pStream->smaId != 0) {
-    pTask->sinkType = TASK_SINK__SMA;
+    pTask->outputType = TASK_OUTPUT__SMA;
     pTask->smaSink.smaId = pStream->smaId;
   } else {
-    pTask->sinkType = TASK_SINK__TABLE;
+    pTask->outputType = TASK_OUTPUT__TABLE;
     pTask->tbSink.stbUid = pStream->targetStbUid;
     memcpy(pTask->tbSink.stbFullName, pStream->targetSTbName, TSDB_TABLE_FNAME_LEN);
     pTask->tbSink.pSchemaWrapper = tCloneSSchemaWrapper(&pStream->outputSchema);
@@ -113,8 +111,6 @@ int32_t mndAddSinkToTask(SMnode* pMnode, SStreamObj* pStream, SStreamTask* pTask
 }
 
 int32_t mndAddDispatcherToInnerTask(SMnode* pMnode, SStreamObj* pStream, SStreamTask* pTask) {
-  pTask->sinkType = TASK_SINK__NONE;
-
   bool isShuffle = false;
 
   if (pStream->fixedSinkVgId == 0) {
@@ -122,7 +118,7 @@ int32_t mndAddDispatcherToInnerTask(SMnode* pMnode, SStreamObj* pStream, SStream
     ASSERT(pDb);
     if (pDb->cfg.numOfVgroups > 1) {
       isShuffle = true;
-      pTask->dispatchType = TASK_DISPATCH__SHUFFLE;
+      pTask->outputType = TASK_OUTPUT__SHUFFLE_DISPATCH;
       pTask->dispatchMsgType = TDMT_STREAM_TASK_DISPATCH;
       if (mndExtractDbInfo(pMnode, pDb, &pTask->shuffleDispatcher.dbInfo, NULL) < 0) {
         ASSERT(0);
@@ -152,7 +148,7 @@ int32_t mndAddDispatcherToInnerTask(SMnode* pMnode, SStreamObj* pStream, SStream
       }
     }
   } else {
-    pTask->dispatchType = TASK_DISPATCH__FIXED;
+    pTask->outputType = TASK_OUTPUT__FIXED_DISPATCH;
     pTask->dispatchMsgType = TDMT_STREAM_TASK_DISPATCH;
     SArray* pArray = taosArrayGetP(pStream->tasks, 0);
     // one sink only
@@ -178,7 +174,6 @@ int32_t mndAssignTaskToVg(SMnode* pMnode, SStreamTask* pTask, SSubplan* plan, co
     terrno = TSDB_CODE_QRY_INVALID_INPUT;
     return -1;
   }
-  ASSERT(pTask->dispatchType != TASK_DISPATCH__NONE || pTask->sinkType != TASK_SINK__NONE);
   return 0;
 }
 
@@ -249,26 +244,20 @@ int32_t mndAddShuffleSinkTasksToStream(SMnode* pMnode, SStreamObj* pStream) {
     pTask->nodeId = pVgroup->vgId;
     pTask->epSet = mndGetVgroupEpset(pMnode, pVgroup);
 
-    // source
-    pTask->isDataScan = 0;
-
-    // exec
-    pTask->execType = TASK_EXEC__NONE;
+    // type
+    pTask->taskLevel = TASK_LEVEL__SINK;
 
     // sink
     if (pStream->smaId != 0) {
-      pTask->sinkType = TASK_SINK__SMA;
+      pTask->outputType = TASK_OUTPUT__SMA;
       pTask->smaSink.smaId = pStream->smaId;
     } else {
-      pTask->sinkType = TASK_SINK__TABLE;
+      pTask->outputType = TASK_OUTPUT__TABLE;
       pTask->tbSink.stbUid = pStream->targetStbUid;
       memcpy(pTask->tbSink.stbFullName, pStream->targetSTbName, TSDB_TABLE_FNAME_LEN);
       pTask->tbSink.pSchemaWrapper = tCloneSSchemaWrapper(&pStream->outputSchema);
       ASSERT(pTask->tbSink.pSchemaWrapper);
     }
-
-    // dispatch
-    pTask->dispatchType = TASK_DISPATCH__NONE;
   }
   return 0;
 }
@@ -295,25 +284,19 @@ int32_t mndAddFixedSinkTaskToStream(SMnode* pMnode, SStreamObj* pStream) {
 #endif
   pTask->epSet = mndGetVgroupEpset(pMnode, &pStream->fixedSinkVg);
 
-  // source
-  pTask->isDataScan = 0;
-
-  // exec
-  pTask->execType = TASK_EXEC__NONE;
+  pTask->taskLevel = TASK_LEVEL__SINK;
 
   // sink
   if (pStream->smaId != 0) {
-    pTask->sinkType = TASK_SINK__SMA;
+    pTask->outputType = TASK_OUTPUT__SMA;
     pTask->smaSink.smaId = pStream->smaId;
   } else {
-    pTask->sinkType = TASK_SINK__TABLE;
+    pTask->outputType = TASK_OUTPUT__TABLE;
     pTask->tbSink.stbUid = pStream->targetStbUid;
     memcpy(pTask->tbSink.stbFullName, pStream->targetSTbName, TSDB_TABLE_FNAME_LEN);
     pTask->tbSink.pSchemaWrapper = tCloneSSchemaWrapper(&pStream->outputSchema);
   }
 
-  // dispatch
-  pTask->dispatchType = TASK_DISPATCH__NONE;
   return 0;
 }
 
@@ -338,6 +321,7 @@ int32_t mndScheduleStream(SMnode* pMnode, SStreamObj* pStream) {
   bool multiTarget = pDbObj->cfg.numOfVgroups > 1;
 
   if (totLevel == 2 || externalTargetDB || multiTarget) {
+    /*if (true) {*/
     SArray* taskOneLevel = taosArrayInit(0, sizeof(void*));
     taosArrayPush(pStream->tasks, &taskOneLevel);
     // add extra sink
@@ -376,8 +360,7 @@ int32_t mndScheduleStream(SMnode* pMnode, SStreamObj* pStream) {
 
       pInnerTask->childEpInfo = taosArrayInit(0, sizeof(void*));
 
-      // source
-      pInnerTask->isDataScan = 0;
+      pInnerTask->taskLevel = TASK_LEVEL__AGG;
 
       // trigger
       pInnerTask->triggerParam = pStream->triggerParam;
@@ -388,9 +371,6 @@ int32_t mndScheduleStream(SMnode* pMnode, SStreamObj* pStream) {
         return -1;
       }
 
-      // exec
-      pInnerTask->execType = TASK_EXEC__PIPE;
-
 #if 0
       SDbObj* pSourceDb = mndAcquireDb(pMnode, pStream->sourceDb);
       ASSERT(pDbObj != NULL);
@@ -452,19 +432,16 @@ int32_t mndScheduleStream(SMnode* pMnode, SStreamObj* pStream) {
       mndAddTaskToTaskSet(taskSourceLevel, pTask);
 
       // source
-      pTask->isDataScan = 1;
+      pTask->taskLevel = TASK_LEVEL__SOURCE;
 
       // add fixed vg dispatch
-      pTask->sinkType = TASK_SINK__NONE;
       pTask->dispatchMsgType = TDMT_STREAM_TASK_DISPATCH;
-      pTask->dispatchType = TASK_DISPATCH__FIXED;
+      pTask->outputType = TASK_OUTPUT__FIXED_DISPATCH;
 
       pTask->fixedEpDispatcher.taskId = pInnerTask->taskId;
       pTask->fixedEpDispatcher.nodeId = pInnerTask->nodeId;
       pTask->fixedEpDispatcher.epSet = pInnerTask->epSet;
 
-      // exec
-      pTask->execType = TASK_EXEC__PIPE;
       if (mndAssignTaskToVg(pMnode, pTask, plan, pVgroup) < 0) {
         sdbRelease(pSdb, pVgroup);
         qDestroyQueryPlan(pPlan);
@@ -515,7 +492,7 @@ int32_t mndScheduleStream(SMnode* pMnode, SStreamObj* pStream) {
       mndAddTaskToTaskSet(taskOneLevel, pTask);
 
       // source
-      pTask->isDataScan = 1;
+      pTask->taskLevel = TASK_LEVEL__SOURCE;
 
       // trigger
       pTask->triggerParam = pStream->triggerParam;
@@ -527,8 +504,6 @@ int32_t mndScheduleStream(SMnode* pMnode, SStreamObj* pStream) {
         mndAddSinkToTask(pMnode, pStream, pTask);
       }
 
-      // exec
-      pTask->execType = TASK_EXEC__PIPE;
       if (mndAssignTaskToVg(pMnode, pTask, plan, pVgroup) < 0) {
         sdbRelease(pSdb, pVgroup);
         qDestroyQueryPlan(pPlan);

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

@@ -323,8 +323,7 @@ FAIL:
 }
 
 int32_t mndPersistTaskDeployReq(STrans *pTrans, const SStreamTask *pTask) {
-  ASSERT(pTask->isDataScan == 0 || pTask->isDataScan == 1);
-  if (pTask->isDataScan == 0 && pTask->sinkType == TASK_SINK__NONE) {
+  if (pTask->taskLevel == TASK_LEVEL__AGG) {
     ASSERT(taosArrayGetSize(pTask->childEpInfo) != 0);
   }
   SEncoder encoder;
@@ -548,7 +547,7 @@ int32_t mndRecoverStreamTasks(SMnode *pMnode, STrans *pTrans, SStreamObj *pStrea
       SArray      *pTasks = taosArrayGetP(pStream->tasks, i);
       int32_t      sz = taosArrayGetSize(pTasks);
       SStreamTask *pTask = taosArrayGetP(pTasks, 0);
-      if (!pTask->isDataScan && pTask->execType != TASK_EXEC__NONE) {
+      if (pTask->taskLevel == TASK_LEVEL__AGG) {
         ASSERT(sz == 1);
         if (mndPersistTaskRecoverReq(pTrans, pTask) < 0) {
           return -1;
@@ -564,8 +563,8 @@ int32_t mndRecoverStreamTasks(SMnode *pMnode, STrans *pTrans, SStreamObj *pStrea
       int32_t sz = taosArrayGetSize(pTasks);
       for (int32_t j = 0; j < sz; j++) {
         SStreamTask *pTask = taosArrayGetP(pTasks, j);
-        if (!pTask->isDataScan) break;
-        ASSERT(pTask->execType != TASK_EXEC__NONE);
+        if (pTask->taskLevel != TASK_LEVEL__SOURCE) break;
+        ASSERT(pTask->taskLevel != TASK_LEVEL__SINK);
         if (mndPersistTaskRecoverReq(pTrans, pTask) < 0) {
           return -1;
         }

source/dnode/snode/src/snode.c

@@ -110,9 +110,6 @@ static int32_t sndProcessTaskDeployReq(SSnode *pNode, SRpcMsg *pMsg) {
 
   pTask->pMsgCb = &pNode->msgCb;
 
-  ASSERT(pTask->execType != TASK_EXEC__NONE);
-
-  ASSERT(pTask->isDataScan == 0);
   pTask->exec.executor = qCreateStreamExecTaskInfo(pTask->exec.qmsg, NULL);
   ASSERT(pTask->exec.executor);
 

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

@@ -604,8 +604,8 @@ int32_t tqProcessVgChangeReq(STQ* pTq, char* msg, int32_t msgLen) {
 
 int32_t tqExpandTask(STQ* pTq, SStreamTask* pTask) {
   int32_t code = 0;
-  ASSERT(pTask->isDataScan == 0 || pTask->isDataScan == 1);
-  if (pTask->isDataScan == 0 && pTask->sinkType == TASK_SINK__NONE) {
+
+  if (pTask->taskLevel == TASK_LEVEL__AGG) {
     ASSERT(taosArrayGetSize(pTask->childEpInfo) != 0);
   }
 
@@ -624,32 +624,30 @@ int32_t tqExpandTask(STQ* pTq, SStreamTask* pTask) {
 
   pTask->pMsgCb = &pTq->pVnode->msgCb;
 
-  // exec
-  if (pTask->execType != TASK_EXEC__NONE) {
-    // expand runners
-    if (pTask->isDataScan) {
-      SReadHandle handle = {
-          .meta = pTq->pVnode->pMeta,
-          .vnode = pTq->pVnode,
-          .initTqReader = 1,
-      };
-      pTask->exec.executor = qCreateStreamExecTaskInfo(pTask->exec.qmsg, &handle);
-    } else {
-      SReadHandle mgHandle = {
-          .vnode = NULL,
-          .numOfVgroups = (int32_t)taosArrayGetSize(pTask->childEpInfo),
-      };
-      pTask->exec.executor = qCreateStreamExecTaskInfo(pTask->exec.qmsg, &mgHandle);
-    }
+  // expand executor
+  if (pTask->taskLevel == TASK_LEVEL__SOURCE) {
+    SReadHandle handle = {
+        .meta = pTq->pVnode->pMeta,
+        .vnode = pTq->pVnode,
+        .initTqReader = 1,
+    };
+    pTask->exec.executor = qCreateStreamExecTaskInfo(pTask->exec.qmsg, &handle);
+    ASSERT(pTask->exec.executor);
+  } else if (pTask->taskLevel == TASK_LEVEL__AGG) {
+    SReadHandle mgHandle = {
+        .vnode = NULL,
+        .numOfVgroups = (int32_t)taosArrayGetSize(pTask->childEpInfo),
+    };
+    pTask->exec.executor = qCreateStreamExecTaskInfo(pTask->exec.qmsg, &mgHandle);
     ASSERT(pTask->exec.executor);
   }
 
   // sink
   /*pTask->ahandle = pTq->pVnode;*/
-  if (pTask->sinkType == TASK_SINK__SMA) {
+  if (pTask->outputType == TASK_OUTPUT__SMA) {
     pTask->smaSink.vnode = pTq->pVnode;
     pTask->smaSink.smaSink = smaHandleRes;
-  } else if (pTask->sinkType == TASK_SINK__TABLE) {
+  } else if (pTask->outputType == TASK_OUTPUT__TABLE) {
     pTask->tbSink.vnode = pTq->pVnode;
     pTask->tbSink.tbSinkFunc = tqTableSink;
 
@@ -715,7 +713,7 @@ int32_t tqProcessStreamTrigger(STQ* pTq, SSubmitReq* pReq, int64_t ver) {
     pIter = taosHashIterate(pTq->pStreamTasks, pIter);
     if (pIter == NULL) break;
     SStreamTask* pTask = *(SStreamTask**)pIter;
-    if (!pTask->isDataScan) continue;
+    if (pTask->taskLevel != TASK_LEVEL__SOURCE) continue;
 
     qDebug("data submit enqueue stream task: %d, ver: %" PRId64, pTask->taskId, ver);
 

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

@@ -416,7 +416,7 @@ int32_t tqUpdateTbUidList(STQ* pTq, const SArray* tbUidList, bool isAdd) {
     pIter = taosHashIterate(pTq->pStreamTasks, pIter);
     if (pIter == NULL) break;
     SStreamTask* pTask = *(SStreamTask**)pIter;
-    if (pTask->isDataScan) {
+    if (pTask->taskLevel == TASK_LEVEL__SOURCE) {
       int32_t code = qUpdateQualifiedTableId(pTask->exec.executor, tbUidList, isAdd);
       ASSERT(code == 0);
     }

source/libs/executor/src/timewindowoperator.c

@@ -2375,6 +2375,8 @@ SOperatorInfo* createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode
   pOperator->fpSet =
       createOperatorFpSet(operatorDummyOpenFn, doTimeslice, NULL, NULL, destroyBasicOperatorInfo, NULL, NULL, NULL);
 
+  blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
+
   code = appendDownstream(pOperator, &downstream, 1);
   return pOperator;
 

source/libs/function/src/builtins.c

@@ -2298,7 +2298,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
   {
     .name = "derivative",
     .type = FUNCTION_TYPE_DERIVATIVE,
-    .classification = FUNC_MGT_INDEFINITE_ROWS_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_TIMELINE_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC | 
+    .classification = FUNC_MGT_INDEFINITE_ROWS_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_TIMELINE_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC |
                       FUNC_MGT_KEEP_ORDER_FUNC | FUNC_MGT_CUMULATIVE_FUNC | FUNC_MGT_FORBID_STREAM_FUNC,
     .translateFunc = translateDerivative,
     .getEnvFunc   = getDerivativeFuncEnv,

source/libs/parser/inc/parUtil.h

@@ -31,7 +31,8 @@ extern "C" {
 #define parserDebug(param, ...) qDebug("PARSER: " param, ##__VA_ARGS__)
 #define parserTrace(param, ...) qTrace("PARSER: " param, ##__VA_ARGS__)
 
-#define PK_TS_COL_INTERNAL_NAME "_rowts"
+#define ROWTS_PSEUDO_COLUMN_NAME "_rowts"
+#define C0_PSEUDO_COLUMN_NAME    "_c0"
 
 typedef struct SMsgBuf {
   int32_t len;

source/libs/parser/src/parAstCreater.c

@@ -443,19 +443,23 @@ SNode* createNotBetweenAnd(SAstCreateContext* pCxt, SNode* pExpr, SNode* pLeft,
                                   createOperatorNode(pCxt, OP_TYPE_GREATER_THAN, nodesCloneNode(pExpr), pRight));
 }
 
-static SNode* createPrimaryKeyCol(SAstCreateContext* pCxt) {
+static SNode* createPrimaryKeyCol(SAstCreateContext* pCxt, const SToken* pFuncName) {
   CHECK_PARSER_STATUS(pCxt);
   SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
   CHECK_OUT_OF_MEM(pCol);
   pCol->colId = PRIMARYKEY_TIMESTAMP_COL_ID;
-  strcpy(pCol->colName, PK_TS_COL_INTERNAL_NAME);
+  if (NULL == pFuncName) {
+    strcpy(pCol->colName, ROWTS_PSEUDO_COLUMN_NAME);
+  } else {
+    strncpy(pCol->colName, pFuncName->z, pFuncName->n);
+  }
   return (SNode*)pCol;
 }
 
 SNode* createFunctionNode(SAstCreateContext* pCxt, const SToken* pFuncName, SNodeList* pParameterList) {
   CHECK_PARSER_STATUS(pCxt);
   if (0 == strncasecmp("_rowts", pFuncName->z, pFuncName->n) || 0 == strncasecmp("_c0", pFuncName->z, pFuncName->n)) {
-    return createPrimaryKeyCol(pCxt);
+    return createPrimaryKeyCol(pCxt, pFuncName);
   }
   SFunctionNode* func = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION);
   CHECK_OUT_OF_MEM(func);
@@ -586,7 +590,7 @@ SNode* createStateWindowNode(SAstCreateContext* pCxt, SNode* pExpr) {
   CHECK_PARSER_STATUS(pCxt);
   SStateWindowNode* state = (SStateWindowNode*)nodesMakeNode(QUERY_NODE_STATE_WINDOW);
   CHECK_OUT_OF_MEM(state);
-  state->pCol = createPrimaryKeyCol(pCxt);
+  state->pCol = createPrimaryKeyCol(pCxt, NULL);
   if (NULL == state->pCol) {
     nodesDestroyNode((SNode*)state);
     CHECK_OUT_OF_MEM(state->pCol);
@@ -600,7 +604,7 @@ SNode* createIntervalWindowNode(SAstCreateContext* pCxt, SNode* pInterval, SNode
   CHECK_PARSER_STATUS(pCxt);
   SIntervalWindowNode* interval = (SIntervalWindowNode*)nodesMakeNode(QUERY_NODE_INTERVAL_WINDOW);
   CHECK_OUT_OF_MEM(interval);
-  interval->pCol = createPrimaryKeyCol(pCxt);
+  interval->pCol = createPrimaryKeyCol(pCxt, NULL);
   if (NULL == interval->pCol) {
     nodesDestroyNode((SNode*)interval);
     CHECK_OUT_OF_MEM(interval->pCol);
@@ -639,7 +643,7 @@ SNode* createGroupingSetNode(SAstCreateContext* pCxt, SNode* pNode) {
 
 SNode* createInterpTimeRange(SAstCreateContext* pCxt, SNode* pStart, SNode* pEnd) {
   CHECK_PARSER_STATUS(pCxt);
-  return createBetweenAnd(pCxt, createPrimaryKeyCol(pCxt), pStart, pEnd);
+  return createBetweenAnd(pCxt, createPrimaryKeyCol(pCxt, NULL), pStart, pEnd);
 }
 
 SNode* setProjectionAlias(SAstCreateContext* pCxt, SNode* pNode, SToken* pAlias) {
@@ -752,7 +756,7 @@ SNode* addFillClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pFill) {
   if (QUERY_NODE_SELECT_STMT == nodeType(pStmt) && NULL != pFill) {
     SFillNode* pFillClause = (SFillNode*)pFill;
     nodesDestroyNode(pFillClause->pWStartTs);
-    pFillClause->pWStartTs = createPrimaryKeyCol(pCxt);
+    pFillClause->pWStartTs = createPrimaryKeyCol(pCxt, NULL);
     ((SSelectStmt*)pStmt)->pFill = (SNode*)pFillClause;
   }
   return pStmt;
@@ -1731,7 +1735,7 @@ SNode* createCountFuncForDelete(SAstCreateContext* pCxt) {
   SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION);
   CHECK_OUT_OF_MEM(pFunc);
   strcpy(pFunc->functionName, "count");
-  if (TSDB_CODE_SUCCESS != nodesListMakeStrictAppend(&pFunc->pParameterList, createPrimaryKeyCol(pCxt))) {
+  if (TSDB_CODE_SUCCESS != nodesListMakeStrictAppend(&pFunc->pParameterList, createPrimaryKeyCol(pCxt, NULL))) {
     nodesDestroyNode((SNode*)pFunc);
     CHECK_OUT_OF_MEM(NULL);
   }

source/libs/parser/src/parTranslater.c

@@ -612,7 +612,8 @@ static int32_t createColumnsByTable(STranslateContext* pCxt, const STableNode* p
 }
 
 static bool isInternalPrimaryKey(const SColumnNode* pCol) {
-  return PRIMARYKEY_TIMESTAMP_COL_ID == pCol->colId && 0 == strcmp(pCol->colName, PK_TS_COL_INTERNAL_NAME);
+  return PRIMARYKEY_TIMESTAMP_COL_ID == pCol->colId &&
+         (0 == strcmp(pCol->colName, ROWTS_PSEUDO_COLUMN_NAME) || 0 == strcmp(pCol->colName, C0_PSEUDO_COLUMN_NAME));
 }
 
 static int32_t findAndSetColumn(STranslateContext* pCxt, SColumnNode** pColRef, const STableNode* pTable,
@@ -2566,7 +2567,7 @@ static int32_t createDefaultFillNode(STranslateContext* pCxt, SNode** pOutput) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }
   pCol->colId = PRIMARYKEY_TIMESTAMP_COL_ID;
-  strcpy(pCol->colName, PK_TS_COL_INTERNAL_NAME);
+  strcpy(pCol->colName, ROWTS_PSEUDO_COLUMN_NAME);
   pFill->pWStartTs = (SNode*)pCol;
 
   *pOutput = (SNode*)pFill;
@@ -2652,7 +2653,7 @@ static int32_t createPrimaryKeyColByTable(STranslateContext* pCxt, STableNode* p
     return TSDB_CODE_OUT_OF_MEMORY;
   }
   pCol->colId = PRIMARYKEY_TIMESTAMP_COL_ID;
-  strcpy(pCol->colName, PK_TS_COL_INTERNAL_NAME);
+  strcpy(pCol->colName, ROWTS_PSEUDO_COLUMN_NAME);
   bool    found = false;
   int32_t code = findAndSetColumn(pCxt, &pCol, pTable, &found);
   if (TSDB_CODE_SUCCESS != code || !found) {
@@ -3878,7 +3879,7 @@ static int32_t buildSampleAst(STranslateContext* pCxt, SSampleAstInfo* pInfo, ch
     return TSDB_CODE_OUT_OF_MEMORY;
   }
   ((SColumnNode*)pInterval->pCol)->colId = PRIMARYKEY_TIMESTAMP_COL_ID;
-  strcpy(((SColumnNode*)pInterval->pCol)->colName, PK_TS_COL_INTERNAL_NAME);
+  strcpy(((SColumnNode*)pInterval->pCol)->colName, ROWTS_PSEUDO_COLUMN_NAME);
 
   pCxt->createStream = true;
   int32_t code = translateQuery(pCxt, (SNode*)pSelect);

source/libs/planner/src/planOptimizer.c

@@ -436,8 +436,8 @@ static int32_t pushDownCondOptDealScan(SOptimizeContext* pCxt, SScanLogicNode* p
 
   SNode*  pPrimaryKeyCond = NULL;
   SNode*  pOtherCond = NULL;
-  int32_t code = filterPartitionCond(&pScan->node.pConditions, &pPrimaryKeyCond, &pScan->pTagIndexCond, &pScan->pTagCond,
-                                    &pOtherCond);
+  int32_t code = filterPartitionCond(&pScan->node.pConditions, &pPrimaryKeyCond, &pScan->pTagIndexCond,
+                                     &pScan->pTagCond, &pOtherCond);
   if (TSDB_CODE_SUCCESS == code && NULL != pScan->pTagCond) {
     code = pushDownCondOptRebuildTbanme(&pScan->pTagCond);
   }
@@ -1711,7 +1711,7 @@ static bool eliminateProjOptCanChildConditionUseChildTargets(SLogicNode* pChild,
     if (!cxt.canUse) return false;
   }
   if (QUERY_NODE_LOGIC_PLAN_JOIN == nodeType(pChild) && NULL != ((SJoinLogicNode*)pChild)->pOnConditions) {
-    SJoinLogicNode* pJoinLogicNode = (SJoinLogicNode*)pChild;
+    SJoinLogicNode*         pJoinLogicNode = (SJoinLogicNode*)pChild;
     CheckNewChildTargetsCxt cxt = {.pNewChildTargets = pNewChildTargets, .canUse = false};
     nodesWalkExpr(pJoinLogicNode->pOnConditions, eliminateProjOptCanUseNewChildTargetsImpl, &cxt);
     if (!cxt.canUse) return false;
@@ -1768,7 +1768,7 @@ static int32_t eliminateProjOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan*
   if (TSDB_CODE_SUCCESS == code) {
     NODES_CLEAR_LIST(pProjectNode->node.pChildren);
     nodesDestroyNode((SNode*)pProjectNode);
-    //if pChild is a project logic node, remove its projection which is not reference by its target.
+    // if pChild is a project logic node, remove its projection which is not reference by its target.
     alignProjectionWithTarget(pChild);
   }
   pCxt->optimized = true;
@@ -2404,6 +2404,9 @@ static const SOptimizeRule optimizeRuleSet[] = {
 static const int32_t optimizeRuleNum = (sizeof(optimizeRuleSet) / sizeof(SOptimizeRule));
 
 static void dumpLogicSubplan(const char* pRuleName, SLogicSubplan* pSubplan) {
+  if (0 == (qDebugFlag & DEBUG_DEBUG)) {
+    return;
+  }
   char* pStr = NULL;
   nodesNodeToString((SNode*)pSubplan, false, &pStr, NULL);
   if (NULL == pRuleName) {

source/libs/planner/src/planSpliter.c

@@ -264,7 +264,7 @@ static bool stbSplNeedSplitJoin(bool streamQuery, SJoinLogicNode* pJoin) {
 static bool stbSplNeedSplit(bool streamQuery, SLogicNode* pNode) {
   switch (nodeType(pNode)) {
     case QUERY_NODE_LOGIC_PLAN_SCAN:
-      return stbSplIsMultiTbScan(streamQuery, (SScanLogicNode*)pNode);
+      return streamQuery ? false : stbSplIsMultiTbScan(streamQuery, (SScanLogicNode*)pNode);
     case QUERY_NODE_LOGIC_PLAN_JOIN:
       return stbSplNeedSplitJoin(streamQuery, (SJoinLogicNode*)pNode);
     case QUERY_NODE_LOGIC_PLAN_PARTITION:
@@ -1423,6 +1423,9 @@ static const SSplitRule splitRuleSet[] = {
 static const int32_t splitRuleNum = (sizeof(splitRuleSet) / sizeof(SSplitRule));
 
 static void dumpLogicSubplan(const char* pRuleName, SLogicSubplan* pSubplan) {
+  if (0 == (qDebugFlag & DEBUG_DEBUG)) {
+    return;
+  }
   char* pStr = NULL;
   nodesNodeToString((SNode*)pSubplan, false, &pStr, NULL);
   if (NULL == pRuleName) {

source/libs/planner/src/planner.c

@@ -19,6 +19,9 @@
 #include "scalar.h"
 
 static void dumpQueryPlan(SQueryPlan* pPlan) {
+  if (0 == (qDebugFlag & DEBUG_DEBUG)) {
+    return;
+  }
   char* pStr = NULL;
   nodesNodeToString((SNode*)pPlan, false, &pStr, NULL);
   planDebugL("QID:0x%" PRIx64 " Query Plan: %s", pPlan->queryId, pStr);
@@ -42,6 +45,9 @@ int32_t qCreateQueryPlan(SPlanContext* pCxt, SQueryPlan** pPlan, SArray* pExecNo
   if (TSDB_CODE_SUCCESS == code) {
     code = createPhysiPlan(pCxt, pLogicPlan, pPlan, pExecNodeList);
   }
+  if (TSDB_CODE_SUCCESS == code) {
+    dumpQueryPlan(*pPlan);
+  }
 
   nodesDestroyNode((SNode*)pLogicSubplan);
   nodesDestroyNode((SNode*)pLogicPlan);
@@ -79,6 +85,7 @@ static int32_t setSubplanExecutionNode(SPhysiNode* pNode, int32_t groupId, SDown
 }
 
 int32_t qSetSubplanExecutionNode(SSubplan* subplan, int32_t groupId, SDownstreamSourceNode* pSource) {
+  planDebug("QID:0x%" PRIx64 " set subplan execution node, groupId:%d", subplan->id.groupId, groupId);
   return setSubplanExecutionNode(subplan->pNode, groupId, pSource);
 }
 

source/libs/scalar/src/filter.c

@@ -3246,6 +3246,10 @@ _return:
 }
 
 bool filterRangeExecute(SFilterInfo *info, SColumnDataAgg *pDataStatis, int32_t numOfCols, int32_t numOfRows) {
+  if (info->scalarMode) {
+    return true;
+  }
+  
   if (FILTER_EMPTY_RES(info)) {
     return false;
   }

source/libs/stream/src/stream.c

@@ -65,7 +65,7 @@ void streamSchedByTimer(void* param, void* tmrId) {
     }
     trigger->pBlock->info.type = STREAM_GET_ALL;
 
-    atomic_store_8(&pTask->triggerStatus, TASK_TRIGGER_STATUS__IN_ACTIVE);
+    atomic_store_8(&pTask->triggerStatus, TASK_TRIGGER_STATUS__INACTIVE);
 
     streamTaskInput(pTask, (SStreamQueueItem*)trigger);
     streamSchedExec(pTask);
@@ -77,7 +77,7 @@ void streamSchedByTimer(void* param, void* tmrId) {
 int32_t streamSetupTrigger(SStreamTask* pTask) {
   if (pTask->triggerParam != 0) {
     pTask->timer = taosTmrStart(streamSchedByTimer, (int32_t)pTask->triggerParam, pTask, streamEnv.timer);
-    pTask->triggerStatus = TASK_TRIGGER_STATUS__IN_ACTIVE;
+    pTask->triggerStatus = TASK_TRIGGER_STATUS__INACTIVE;
   }
   return 0;
 }
@@ -186,7 +186,7 @@ int32_t streamProcessDispatchReq(SStreamTask* pTask, SStreamDispatchReq* pReq, S
   if (exec) {
     streamTryExec(pTask);
 
-    if (pTask->dispatchType != TASK_DISPATCH__NONE) {
+    if (pTask->outputType == TASK_OUTPUT__FIXED_DISPATCH || pTask->outputType == TASK_OUTPUT__SHUFFLE_DISPATCH) {
       streamDispatch(pTask);
     }
   } else {
@@ -201,7 +201,7 @@ int32_t streamProcessDispatchRsp(SStreamTask* pTask, SStreamDispatchRsp* pRsp) {
 
   qDebug("task %d receive dispatch rsp", pTask->taskId);
 
-  if (pTask->dispatchType == TASK_DISPATCH__SHUFFLE) {
+  if (pTask->outputType == TASK_OUTPUT__SHUFFLE_DISPATCH) {
     int32_t leftRsp = atomic_sub_fetch_32(&pTask->shuffleDispatcher.waitingRspCnt, 1);
     qDebug("task %d is shuffle, left waiting rsp %d", pTask->taskId, leftRsp);
     if (leftRsp > 0) return 0;
@@ -222,7 +222,7 @@ int32_t streamProcessDispatchRsp(SStreamTask* pTask, SStreamDispatchRsp* pRsp) {
 int32_t streamProcessRunReq(SStreamTask* pTask) {
   streamTryExec(pTask);
 
-  if (pTask->dispatchType != TASK_DISPATCH__NONE) {
+  if (pTask->outputType == TASK_OUTPUT__FIXED_DISPATCH || pTask->outputType == TASK_OUTPUT__SHUFFLE_DISPATCH) {
     streamDispatch(pTask);
   }
   return 0;
@@ -250,7 +250,7 @@ int32_t streamProcessRecoverRsp(SStreamTask* pTask, SStreamTaskRecoverRsp* pRsp)
 
     streamProcessRunReq(pTask);
 
-    if (pTask->isDataScan) {
+    if (pTask->taskLevel == TASK_LEVEL__SOURCE) {
       // scan data to recover
       pTask->inputStatus = TASK_INPUT_STATUS__RECOVER;
       pTask->taskStatus = TASK_STATUS__RECOVERING;
@@ -272,12 +272,11 @@ int32_t streamProcessRetrieveReq(SStreamTask* pTask, SStreamRetrieveReq* pReq, S
 
   streamTaskEnqueueRetrieve(pTask, pReq, pRsp);
 
-  ASSERT(pTask->execType != TASK_EXEC__NONE);
+  ASSERT(pTask->taskLevel != TASK_LEVEL__SINK);
   streamSchedExec(pTask);
 
   /*streamTryExec(pTask);*/
 
-  /*ASSERT(pTask->dispatchType != TASK_DISPATCH__NONE);*/
   /*streamDispatch(pTask);*/
 
   return 0;

source/libs/stream/src/streamDispatch.c

@@ -242,7 +242,7 @@ int32_t streamDispatchAllBlocks(SStreamTask* pTask, const SStreamDataBlock* pDat
   int32_t blockNum = taosArrayGetSize(pData->blocks);
   ASSERT(blockNum != 0);
 
-  if (pTask->dispatchType == TASK_DISPATCH__FIXED) {
+  if (pTask->outputType == TASK_OUTPUT__FIXED_DISPATCH) {
     SStreamDispatchReq req = {
         .streamId = pTask->streamId,
         .dataSrcVgId = pData->srcVgId,
@@ -282,7 +282,7 @@ int32_t streamDispatchAllBlocks(SStreamTask* pTask, const SStreamDataBlock* pDat
     taosArrayDestroy(req.dataLen);
     return code;
 
-  } else if (pTask->dispatchType == TASK_DISPATCH__SHUFFLE) {
+  } else if (pTask->outputType == TASK_OUTPUT__SHUFFLE_DISPATCH) {
     int32_t rspCnt = atomic_load_32(&pTask->shuffleDispatcher.waitingRspCnt);
     ASSERT(rspCnt == 0);
 
@@ -393,11 +393,11 @@ int32_t streamBuildDispatchMsg(SStreamTask* pTask, const SStreamDataBlock* data,
   int32_t vgId = 0;
   int32_t downstreamTaskId = 0;
   // find ep
-  if (pTask->dispatchType == TASK_DISPATCH__FIXED) {
+  if (pTask->outputType == TASK_OUTPUT__FIXED_DISPATCH) {
     vgId = pTask->fixedEpDispatcher.nodeId;
     *ppEpSet = &pTask->fixedEpDispatcher.epSet;
     downstreamTaskId = pTask->fixedEpDispatcher.taskId;
-  } else if (pTask->dispatchType == TASK_DISPATCH__SHUFFLE) {
+  } else if (pTask->outputType == TASK_OUTPUT__SHUFFLE_DISPATCH) {
     // TODO get ctbName for each block
     SSDataBlock* pBlock = taosArrayGet(data->blocks, 0);
     char*        ctbName = buildCtbNameByGroupId(pTask->shuffleDispatcher.stbFullName, pBlock->info.groupId);
@@ -439,8 +439,7 @@ FAIL:
 }
 
 int32_t streamDispatch(SStreamTask* pTask) {
-  ASSERT(pTask->dispatchType != TASK_DISPATCH__NONE);
-  ASSERT(pTask->sinkType == TASK_SINK__NONE);
+  ASSERT(pTask->outputType == TASK_OUTPUT__FIXED_DISPATCH || pTask->outputType == TASK_OUTPUT__SHUFFLE_DISPATCH);
 
   int8_t old =
       atomic_val_compare_exchange_8(&pTask->outputStatus, TASK_OUTPUT_STATUS__NORMAL, TASK_OUTPUT_STATUS__WAIT);

source/libs/stream/src/streamExec.c

@@ -24,7 +24,7 @@ static int32_t streamTaskExecImpl(SStreamTask* pTask, void* data, SArray* pRes)
     SStreamTrigger* pTrigger = (SStreamTrigger*)data;
     qSetMultiStreamInput(exec, pTrigger->pBlock, 1, STREAM_INPUT__DATA_BLOCK);
   } else if (pItem->type == STREAM_INPUT__DATA_SUBMIT) {
-    ASSERT(pTask->isDataScan);
+    ASSERT(pTask->taskLevel == TASK_LEVEL__SOURCE);
     SStreamDataSubmit* pSubmit = (SStreamDataSubmit*)data;
     qDebug("task %d %p set submit input %p %p %d 1", pTask->taskId, pTask, pSubmit, pSubmit->data, *pSubmit->dataRef);
     qSetMultiStreamInput(exec, pSubmit->data, 1, STREAM_INPUT__DATA_SUBMIT);
@@ -92,7 +92,7 @@ static FORCE_INLINE int32_t streamUpdateVer(SStreamTask* pTask, SStreamDataBlock
 }
 
 int32_t streamPipelineExec(SStreamTask* pTask, int32_t batchNum) {
-  ASSERT(pTask->execType != TASK_EXEC__NONE);
+  ASSERT(pTask->taskLevel != TASK_LEVEL__SINK);
 
   void* exec = pTask->exec.executor;
 
@@ -139,8 +139,7 @@ int32_t streamPipelineExec(SStreamTask* pTask, int32_t batchNum) {
       return -1;
     }
 
-    if (pTask->dispatchType != TASK_DISPATCH__NONE) {
-      ASSERT(pTask->sinkType == TASK_SINK__NONE);
+    if (pTask->outputType == TASK_OUTPUT__FIXED_DISPATCH || pTask->outputType == TASK_OUTPUT__SHUFFLE_DISPATCH) {
       streamDispatch(pTask);
     }
   }
@@ -161,7 +160,7 @@ int32_t streamExecForAll(SStreamTask* pTask) {
       if (data == NULL) {
         data = qItem;
         streamQueueProcessSuccess(pTask->inputQueue);
-        if (pTask->execType == TASK_EXEC__NONE) {
+        if (pTask->taskLevel == TASK_LEVEL__SINK) {
           break;
         }
       } else {
@@ -187,7 +186,7 @@ int32_t streamExecForAll(SStreamTask* pTask) {
       break;
     }
 
-    if (pTask->execType == TASK_EXEC__NONE) {
+    if (pTask->taskLevel == TASK_LEVEL__SINK) {
       ASSERT(((SStreamQueueItem*)data)->type == STREAM_INPUT__DATA_BLOCK);
       streamTaskOutput(pTask, data);
       continue;

source/libs/stream/src/streamMeta.c

@@ -52,15 +52,16 @@ SStreamMeta* streamMetaOpen(const char* path, void* ahandle, FTaskExpand expandF
 
   pMeta->ahandle = ahandle;
   pMeta->expandFunc = expandFunc;
-
+  return pMeta;
 _err:
-
   return NULL;
 }
 
 void streamMetaClose(SStreamMeta* pMeta) {
-  //
-  return;
+  tdbCommit(pMeta->db, &pMeta->txn);
+  tdbTbClose(pMeta->pTaskDb);
+  tdbTbClose(pMeta->pStateDb);
+  tdbClose(pMeta->db);
 }
 
 int32_t streamMetaAddTask(SStreamMeta* pMeta, SStreamTask* pTask) {
@@ -123,13 +124,32 @@ int32_t streamMetaCommit(SStreamMeta* pMeta) {
   if (tdbCommit(pMeta->db, &pMeta->txn) < 0) {
     return -1;
   }
+  memset(&pMeta->txn, 0, sizeof(TXN));
+  if (tdbTxnOpen(&pMeta->txn, 0, tdbDefaultMalloc, tdbDefaultFree, NULL, TDB_TXN_WRITE | TDB_TXN_READ_UNCOMMITTED) <
+      0) {
+    return -1;
+  }
+  if (tdbBegin(pMeta->db, &pMeta->txn) < 0) {
+    return -1;
+  }
   return 0;
 }
 
-int32_t streamMetaRollBack(SStreamMeta* pMeta) {
-  // TODO tdb rollback
+int32_t streamMetaAbort(SStreamMeta* pMeta) {
+  if (tdbAbort(pMeta->db, &pMeta->txn) < 0) {
+    return -1;
+  }
+  memset(&pMeta->txn, 0, sizeof(TXN));
+  if (tdbTxnOpen(&pMeta->txn, 0, tdbDefaultMalloc, tdbDefaultFree, NULL, TDB_TXN_WRITE | TDB_TXN_READ_UNCOMMITTED) <
+      0) {
+    return -1;
+  }
+  if (tdbBegin(pMeta->db, &pMeta->txn) < 0) {
+    return -1;
+  }
   return 0;
 }
+
 int32_t streamRestoreTask(SStreamMeta* pMeta) {
   TBC* pCur = NULL;
   if (tdbTbcOpen(pMeta->pTaskDb, &pCur, NULL) < 0) {
@@ -153,6 +173,18 @@ int32_t streamRestoreTask(SStreamMeta* pMeta) {
     tDecoderInit(&decoder, (uint8_t*)pVal, vLen);
     tDecodeSStreamTask(&decoder, pTask);
     tDecoderClear(&decoder);
+
+    if (pMeta->expandFunc(pMeta->ahandle, pTask) < 0) {
+      return -1;
+    }
+
+    if (taosHashPut(pMeta->pTasks, &pTask->taskId, sizeof(int32_t), &pTask, sizeof(void*)) < 0) {
+      return -1;
+    }
+  }
+
+  if (tdbTbcClose(pCur) < 0) {
+    return -1;
   }
 
   return 0;

source/libs/stream/src/streamRecover.c

@@ -88,14 +88,15 @@ int32_t tDecodeSMStreamTaskRecoverRsp(SDecoder* pDecoder, SMStreamTaskRecoverRsp
 }
 
 int32_t streamProcessFailRecoverReq(SStreamTask* pTask, SMStreamTaskRecoverReq* pReq, SRpcMsg* pRsp) {
+#if 0
   if (pTask->taskStatus != TASK_STATUS__FAIL) {
     return 0;
   }
 
   if (pTask->isStreamDistributed) {
-    if (pTask->isDataScan) {
+    if (pTask->taskType == TASK_TYPE__SOURCE) {
       pTask->taskStatus = TASK_STATUS__PREPARE_RECOVER;
-    } else if (pTask->execType != TASK_EXEC__NONE) {
+    } else if (pTask->taskType != TASK_TYPE__SINK) {
       pTask->taskStatus = TASK_STATUS__PREPARE_RECOVER;
       bool    hasCheckpoint = false;
       int32_t childSz = taosArrayGetSize(pTask->childEpInfo);
@@ -113,7 +114,7 @@ int32_t streamProcessFailRecoverReq(SStreamTask* pTask, SMStreamTaskRecoverReq*
       }
     }
   } else {
-    if (pTask->isDataScan) {
+    if (pTask->taskType == TASK_TYPE__SOURCE) {
       if (pTask->checkpointVer != -1) {
         // load from checkpoint
       } else {
@@ -133,5 +134,6 @@ int32_t streamProcessFailRecoverReq(SStreamTask* pTask, SMStreamTaskRecoverReq*
     }
   }
 
+#endif
   return 0;
 }

source/libs/stream/src/streamTask.c

@@ -52,10 +52,8 @@ int32_t tEncodeSStreamTask(SEncoder* pEncoder, const SStreamTask* pTask) {
   /*if (tStartEncode(pEncoder) < 0) return -1;*/
   if (tEncodeI64(pEncoder, pTask->streamId) < 0) return -1;
   if (tEncodeI32(pEncoder, pTask->taskId) < 0) return -1;
-  if (tEncodeI8(pEncoder, pTask->isDataScan) < 0) return -1;
-  if (tEncodeI8(pEncoder, pTask->execType) < 0) return -1;
-  if (tEncodeI8(pEncoder, pTask->sinkType) < 0) return -1;
-  if (tEncodeI8(pEncoder, pTask->dispatchType) < 0) return -1;
+  if (tEncodeI8(pEncoder, pTask->taskLevel) < 0) return -1;
+  if (tEncodeI8(pEncoder, pTask->outputType) < 0) return -1;
   if (tEncodeI16(pEncoder, pTask->dispatchMsgType) < 0) return -1;
 
   if (tEncodeI8(pEncoder, pTask->taskStatus) < 0) return -1;
@@ -73,27 +71,23 @@ int32_t tEncodeSStreamTask(SEncoder* pEncoder, const SStreamTask* pTask) {
     if (tEncodeStreamEpInfo(pEncoder, pInfo) < 0) return -1;
   }
 
-  if (pTask->execType != TASK_EXEC__NONE) {
+  if (pTask->taskLevel != TASK_LEVEL__SINK) {
     if (tEncodeCStr(pEncoder, pTask->exec.qmsg) < 0) return -1;
   }
 
-  if (pTask->sinkType == TASK_SINK__TABLE) {
+  if (pTask->outputType == TASK_OUTPUT__TABLE) {
     if (tEncodeI64(pEncoder, pTask->tbSink.stbUid) < 0) return -1;
     if (tEncodeCStr(pEncoder, pTask->tbSink.stbFullName) < 0) return -1;
     if (tEncodeSSchemaWrapper(pEncoder, pTask->tbSink.pSchemaWrapper) < 0) return -1;
-  } else if (pTask->sinkType == TASK_SINK__SMA) {
+  } else if (pTask->outputType == TASK_OUTPUT__SMA) {
     if (tEncodeI64(pEncoder, pTask->smaSink.smaId) < 0) return -1;
-  } else if (pTask->sinkType == TASK_SINK__FETCH) {
+  } else if (pTask->outputType == TASK_OUTPUT__FETCH) {
     if (tEncodeI8(pEncoder, pTask->fetchSink.reserved) < 0) return -1;
-  } else {
-    ASSERT(pTask->sinkType == TASK_SINK__NONE);
-  }
-
-  if (pTask->dispatchType == TASK_DISPATCH__FIXED) {
+  } else if (pTask->outputType == TASK_OUTPUT__FIXED_DISPATCH) {
     if (tEncodeI32(pEncoder, pTask->fixedEpDispatcher.taskId) < 0) return -1;
     if (tEncodeI32(pEncoder, pTask->fixedEpDispatcher.nodeId) < 0) return -1;
     if (tEncodeSEpSet(pEncoder, &pTask->fixedEpDispatcher.epSet) < 0) return -1;
-  } else if (pTask->dispatchType == TASK_DISPATCH__SHUFFLE) {
+  } else if (pTask->outputType == TASK_OUTPUT__SHUFFLE_DISPATCH) {
     if (tSerializeSUseDbRspImp(pEncoder, &pTask->shuffleDispatcher.dbInfo) < 0) return -1;
     if (tEncodeCStr(pEncoder, pTask->shuffleDispatcher.stbFullName) < 0) return -1;
   }
@@ -107,10 +101,8 @@ int32_t tDecodeSStreamTask(SDecoder* pDecoder, SStreamTask* pTask) {
   /*if (tStartDecode(pDecoder) < 0) return -1;*/
   if (tDecodeI64(pDecoder, &pTask->streamId) < 0) return -1;
   if (tDecodeI32(pDecoder, &pTask->taskId) < 0) return -1;
-  if (tDecodeI8(pDecoder, &pTask->isDataScan) < 0) return -1;
-  if (tDecodeI8(pDecoder, &pTask->execType) < 0) return -1;
-  if (tDecodeI8(pDecoder, &pTask->sinkType) < 0) return -1;
-  if (tDecodeI8(pDecoder, &pTask->dispatchType) < 0) return -1;
+  if (tDecodeI8(pDecoder, &pTask->taskLevel) < 0) return -1;
+  if (tDecodeI8(pDecoder, &pTask->outputType) < 0) return -1;
   if (tDecodeI16(pDecoder, &pTask->dispatchMsgType) < 0) return -1;
 
   if (tDecodeI8(pDecoder, &pTask->taskStatus) < 0) return -1;
@@ -131,29 +123,25 @@ int32_t tDecodeSStreamTask(SDecoder* pDecoder, SStreamTask* pTask) {
     taosArrayPush(pTask->childEpInfo, &pInfo);
   }
 
-  if (pTask->execType != TASK_EXEC__NONE) {
+  if (pTask->taskLevel != TASK_LEVEL__SINK) {
     if (tDecodeCStrAlloc(pDecoder, &pTask->exec.qmsg) < 0) return -1;
   }
 
-  if (pTask->sinkType == TASK_SINK__TABLE) {
+  if (pTask->outputType == TASK_OUTPUT__TABLE) {
     if (tDecodeI64(pDecoder, &pTask->tbSink.stbUid) < 0) return -1;
     if (tDecodeCStrTo(pDecoder, pTask->tbSink.stbFullName) < 0) return -1;
     pTask->tbSink.pSchemaWrapper = taosMemoryCalloc(1, sizeof(SSchemaWrapper));
     if (pTask->tbSink.pSchemaWrapper == NULL) return -1;
     if (tDecodeSSchemaWrapper(pDecoder, pTask->tbSink.pSchemaWrapper) < 0) return -1;
-  } else if (pTask->sinkType == TASK_SINK__SMA) {
+  } else if (pTask->outputType == TASK_OUTPUT__SMA) {
     if (tDecodeI64(pDecoder, &pTask->smaSink.smaId) < 0) return -1;
-  } else if (pTask->sinkType == TASK_SINK__FETCH) {
+  } else if (pTask->outputType == TASK_OUTPUT__FETCH) {
     if (tDecodeI8(pDecoder, &pTask->fetchSink.reserved) < 0) return -1;
-  } else {
-    ASSERT(pTask->sinkType == TASK_SINK__NONE);
-  }
-
-  if (pTask->dispatchType == TASK_DISPATCH__FIXED) {
+  } else if (pTask->outputType == TASK_OUTPUT__FIXED_DISPATCH) {
     if (tDecodeI32(pDecoder, &pTask->fixedEpDispatcher.taskId) < 0) return -1;
     if (tDecodeI32(pDecoder, &pTask->fixedEpDispatcher.nodeId) < 0) return -1;
     if (tDecodeSEpSet(pDecoder, &pTask->fixedEpDispatcher.epSet) < 0) return -1;
-  } else if (pTask->dispatchType == TASK_DISPATCH__SHUFFLE) {
+  } else if (pTask->outputType == TASK_OUTPUT__SHUFFLE_DISPATCH) {
     if (tDeserializeSUseDbRspImp(pDecoder, &pTask->shuffleDispatcher.dbInfo) < 0) return -1;
     if (tDecodeCStrTo(pDecoder, pTask->shuffleDispatcher.stbFullName) < 0) return -1;
   }

source/libs/sync/inc/syncInt.h

@@ -212,6 +212,7 @@ void       syncNodeRelease(SSyncNode* pNode);
 
 // raft state change --------------
 void syncNodeUpdateTerm(SSyncNode* pSyncNode, SyncTerm term);
+void syncNodeUpdateTermWithoutStepDown(SSyncNode* pSyncNode, SyncTerm term);
 void syncNodeBecomeFollower(SSyncNode* pSyncNode, const char* debugStr);
 void syncNodeBecomeLeader(SSyncNode* pSyncNode, const char* debugStr);
 

source/libs/sync/src/syncAppendEntries.c

@@ -717,24 +717,15 @@ int32_t syncNodeOnAppendEntriesSnapshot2Cb(SSyncNode* ths, SyncAppendEntriesBatc
 
       // maybe update commit index, leader notice me
       if (pMsg->commitIndex > ths->commitIndex) {
-        // has commit entry in local
-        if (pMsg->commitIndex <= ths->pLogStore->syncLogLastIndex(ths->pLogStore)) {
-          // advance commit index to sanpshot first
-          SSnapshot snapshot;
-          ths->pFsm->FpGetSnapshotInfo(ths->pFsm, &snapshot);
-          if (snapshot.lastApplyIndex >= 0 && snapshot.lastApplyIndex > ths->commitIndex) {
-            SyncIndex commitBegin = ths->commitIndex;
-            SyncIndex commitEnd = snapshot.lastApplyIndex;
-            ths->commitIndex = snapshot.lastApplyIndex;
+        SyncIndex lastIndex = ths->pLogStore->syncLogLastIndex(ths->pLogStore);
 
-            char eventLog[128];
-            snprintf(eventLog, sizeof(eventLog), "commit by snapshot from index:%" PRId64 " to index:%" PRId64,
-                     commitBegin, commitEnd);
-            syncNodeEventLog(ths, eventLog);
-          }
+        SyncIndex beginIndex = 0;
+        SyncIndex endIndex = -1;
 
-          SyncIndex beginIndex = ths->commitIndex + 1;
-          SyncIndex endIndex = pMsg->commitIndex;
+        // has commit entry in local
+        if (pMsg->commitIndex <= lastIndex) {
+          beginIndex = ths->commitIndex + 1;
+          endIndex = pMsg->commitIndex;
 
           // update commit index
           ths->commitIndex = pMsg->commitIndex;
@@ -743,10 +734,22 @@ int32_t syncNodeOnAppendEntriesSnapshot2Cb(SSyncNode* ths, SyncAppendEntriesBatc
           code = ths->pLogStore->updateCommitIndex(ths->pLogStore, ths->commitIndex);
           ASSERT(code == 0);
 
-          code = syncNodeCommit(ths, beginIndex, endIndex, ths->state);
+        } else if (pMsg->commitIndex > lastIndex && ths->commitIndex < lastIndex) {
+          beginIndex = ths->commitIndex + 1;
+          endIndex = lastIndex;
+
+          // update commit index, speed up
+          ths->commitIndex = lastIndex;
+
+          // call back Wal
+          code = ths->pLogStore->updateCommitIndex(ths->pLogStore, ths->commitIndex);
           ASSERT(code == 0);
         }
+
+        code = syncNodeCommit(ths, beginIndex, endIndex, ths->state);
+        ASSERT(code == 0);
       }
+
       return 0;
     }
   } while (0);

source/libs/sync/src/syncCommit.c

@@ -73,7 +73,7 @@ void syncMaybeAdvanceCommitIndex(SSyncNode* pSyncNode) {
       ASSERT(pEntry != NULL);
 
       // cannot commit, even if quorum agree. need check term!
-      if (pEntry->term == pSyncNode->pRaftStore->currentTerm) {
+      if (pEntry->term <= pSyncNode->pRaftStore->currentTerm) {
         // update commit index
         newCommitIndex = index;
 

source/libs/sync/src/syncMain.c

@@ -1562,7 +1562,7 @@ char* syncNode2Str(const SSyncNode* pSyncNode) {
   return serialized;
 }
 
-void syncNodeEventLog(const SSyncNode* pSyncNode, char* str) {
+inline void syncNodeEventLog(const SSyncNode* pSyncNode, char* str) {
   int32_t userStrLen = strlen(str);
 
   SSnapshot snapshot = {.data = NULL, .lastApplyIndex = -1, .lastApplyTerm = 0};
@@ -1634,7 +1634,7 @@ void syncNodeEventLog(const SSyncNode* pSyncNode, char* str) {
   taosMemoryFree(pCfgStr);
 }
 
-void syncNodeErrorLog(const SSyncNode* pSyncNode, char* str) {
+inline void syncNodeErrorLog(const SSyncNode* pSyncNode, char* str) {
   int32_t userStrLen = strlen(str);
 
   SSnapshot snapshot = {.data = NULL, .lastApplyIndex = -1, .lastApplyTerm = 0};
@@ -1701,7 +1701,7 @@ void syncNodeErrorLog(const SSyncNode* pSyncNode, char* str) {
   taosMemoryFree(pCfgStr);
 }
 
-char* syncNode2SimpleStr(const SSyncNode* pSyncNode) {
+inline char* syncNode2SimpleStr(const SSyncNode* pSyncNode) {
   int   len = 256;
   char* s = (char*)taosMemoryMalloc(len);
 
@@ -1724,7 +1724,7 @@ char* syncNode2SimpleStr(const SSyncNode* pSyncNode) {
   return s;
 }
 
-bool syncNodeInConfig(SSyncNode* pSyncNode, const SSyncCfg* config) {
+inline bool syncNodeInConfig(SSyncNode* pSyncNode, const SSyncCfg* config) {
   bool b1 = false;
   bool b2 = false;
 
@@ -1987,6 +1987,12 @@ void syncNodeUpdateTerm(SSyncNode* pSyncNode, SyncTerm term) {
   }
 }
 
+void syncNodeUpdateTermWithoutStepDown(SSyncNode* pSyncNode, SyncTerm term) {
+  if (term > pSyncNode->pRaftStore->currentTerm) {
+    raftStoreSetTerm(pSyncNode->pRaftStore, term);
+  }
+}
+
 void syncNodeBecomeFollower(SSyncNode* pSyncNode, const char* debugStr) {
   // maybe clear leader cache
   if (pSyncNode->state == TAOS_SYNC_STATE_LEADER) {
@@ -2614,7 +2620,7 @@ int32_t syncNodeOnClientRequestBatchCb(SSyncNode* ths, SyncClientRequestBatch* p
   // fsync once
   SSyncLogStoreData* pData = ths->pLogStore->data;
   SWal*              pWal = pData->pWal;
-  walFsync(pWal, true);
+  walFsync(pWal, false);
 
   if (ths->replicaNum > 1) {
     // if multi replica, start replicate right now
@@ -2797,11 +2803,28 @@ bool syncNodeIsOptimizedOneReplica(SSyncNode* ths, SRpcMsg* pMsg) {
 }
 
 int32_t syncNodeCommit(SSyncNode* ths, SyncIndex beginIndex, SyncIndex endIndex, uint64_t flag) {
+  if (beginIndex > endIndex) {
+    return 0;
+  }
+
+  // advance commit index to sanpshot first
+  SSnapshot snapshot = {0};
+  ths->pFsm->FpGetSnapshotInfo(ths->pFsm, &snapshot);
+  if (snapshot.lastApplyIndex >= 0 && snapshot.lastApplyIndex >= beginIndex) {
+    char eventLog[128];
+    snprintf(eventLog, sizeof(eventLog), "commit by snapshot from index:%" PRId64 " to index:%" PRId64, beginIndex,
+             snapshot.lastApplyIndex);
+    syncNodeEventLog(ths, eventLog);
+
+    // update begin index
+    beginIndex = snapshot.lastApplyIndex + 1;
+  }
+
   int32_t    code = 0;
   ESyncState state = flag;
 
   char eventLog[128];
-  snprintf(eventLog, sizeof(eventLog), "commit wal from index:%" PRId64 " to index:%" PRId64, beginIndex, endIndex);
+  snprintf(eventLog, sizeof(eventLog), "commit by wal from index:%" PRId64 " to index:%" PRId64, beginIndex, endIndex);
   syncNodeEventLog(ths, eventLog);
 
   // execute fsm
@@ -2942,7 +2965,7 @@ bool syncNodeCanChange(SSyncNode* pSyncNode) {
   return true;
 }
 
-void syncLogSendRequestVote(SSyncNode* pSyncNode, const SyncRequestVote* pMsg, const char* s) {
+inline void syncLogSendRequestVote(SSyncNode* pSyncNode, const SyncRequestVote* pMsg, const char* s) {
   char     host[64];
   uint16_t port;
   syncUtilU642Addr(pMsg->destId.addr, host, sizeof(host), &port);
@@ -2953,7 +2976,7 @@ void syncLogSendRequestVote(SSyncNode* pSyncNode, const SyncRequestVote* pMsg, c
   syncNodeEventLog(pSyncNode, logBuf);
 }
 
-void syncLogRecvRequestVote(SSyncNode* pSyncNode, const SyncRequestVote* pMsg, const char* s) {
+inline void syncLogRecvRequestVote(SSyncNode* pSyncNode, const SyncRequestVote* pMsg, const char* s) {
   char     logBuf[256];
   char     host[64];
   uint16_t port;
@@ -2964,7 +2987,7 @@ void syncLogRecvRequestVote(SSyncNode* pSyncNode, const SyncRequestVote* pMsg, c
   syncNodeEventLog(pSyncNode, logBuf);
 }
 
-void syncLogSendRequestVoteReply(SSyncNode* pSyncNode, const SyncRequestVoteReply* pMsg, const char* s) {
+inline void syncLogSendRequestVoteReply(SSyncNode* pSyncNode, const SyncRequestVoteReply* pMsg, const char* s) {
   char     host[64];
   uint16_t port;
   syncUtilU642Addr(pMsg->destId.addr, host, sizeof(host), &port);
@@ -2974,7 +2997,7 @@ void syncLogSendRequestVoteReply(SSyncNode* pSyncNode, const SyncRequestVoteRepl
   syncNodeEventLog(pSyncNode, logBuf);
 }
 
-void syncLogRecvRequestVoteReply(SSyncNode* pSyncNode, const SyncRequestVoteReply* pMsg, const char* s) {
+inline void syncLogRecvRequestVoteReply(SSyncNode* pSyncNode, const SyncRequestVoteReply* pMsg, const char* s) {
   char     host[64];
   uint16_t port;
   syncUtilU642Addr(pMsg->srcId.addr, host, sizeof(host), &port);
@@ -2984,7 +3007,7 @@ void syncLogRecvRequestVoteReply(SSyncNode* pSyncNode, const SyncRequestVoteRepl
   syncNodeEventLog(pSyncNode, logBuf);
 }
 
-void syncLogSendAppendEntries(SSyncNode* pSyncNode, const SyncAppendEntries* pMsg, const char* s) {
+inline void syncLogSendAppendEntries(SSyncNode* pSyncNode, const SyncAppendEntries* pMsg, const char* s) {
   char     host[64];
   uint16_t port;
   syncUtilU642Addr(pMsg->destId.addr, host, sizeof(host), &port);
@@ -2999,7 +3022,7 @@ void syncLogSendAppendEntries(SSyncNode* pSyncNode, const SyncAppendEntries* pMs
   syncNodeEventLog(pSyncNode, logBuf);
 }
 
-void syncLogRecvAppendEntries(SSyncNode* pSyncNode, const SyncAppendEntries* pMsg, const char* s) {
+inline void syncLogRecvAppendEntries(SSyncNode* pSyncNode, const SyncAppendEntries* pMsg, const char* s) {
   char     host[64];
   uint16_t port;
   syncUtilU642Addr(pMsg->srcId.addr, host, sizeof(host), &port);
@@ -3014,7 +3037,7 @@ void syncLogRecvAppendEntries(SSyncNode* pSyncNode, const SyncAppendEntries* pMs
   syncNodeEventLog(pSyncNode, logBuf);
 }
 
-void syncLogSendAppendEntriesBatch(SSyncNode* pSyncNode, const SyncAppendEntriesBatch* pMsg, const char* s) {
+inline void syncLogSendAppendEntriesBatch(SSyncNode* pSyncNode, const SyncAppendEntriesBatch* pMsg, const char* s) {
   char     host[64];
   uint16_t port;
   syncUtilU642Addr(pMsg->destId.addr, host, sizeof(host), &port);
@@ -3027,7 +3050,7 @@ void syncLogSendAppendEntriesBatch(SSyncNode* pSyncNode, const SyncAppendEntries
   syncNodeEventLog(pSyncNode, logBuf);
 }
 
-void syncLogRecvAppendEntriesBatch(SSyncNode* pSyncNode, const SyncAppendEntriesBatch* pMsg, const char* s) {
+inline void syncLogRecvAppendEntriesBatch(SSyncNode* pSyncNode, const SyncAppendEntriesBatch* pMsg, const char* s) {
   char     host[64];
   uint16_t port;
   syncUtilU642Addr(pMsg->srcId.addr, host, sizeof(host), &port);
@@ -3040,7 +3063,7 @@ void syncLogRecvAppendEntriesBatch(SSyncNode* pSyncNode, const SyncAppendEntries
   syncNodeEventLog(pSyncNode, logBuf);
 }
 
-void syncLogSendAppendEntriesReply(SSyncNode* pSyncNode, const SyncAppendEntriesReply* pMsg, const char* s) {
+inline void syncLogSendAppendEntriesReply(SSyncNode* pSyncNode, const SyncAppendEntriesReply* pMsg, const char* s) {
   char     host[64];
   uint16_t port;
   syncUtilU642Addr(pMsg->destId.addr, host, sizeof(host), &port);
@@ -3052,7 +3075,7 @@ void syncLogSendAppendEntriesReply(SSyncNode* pSyncNode, const SyncAppendEntries
   syncNodeEventLog(pSyncNode, logBuf);
 }
 
-void syncLogRecvAppendEntriesReply(SSyncNode* pSyncNode, const SyncAppendEntriesReply* pMsg, const char* s) {
+inline void syncLogRecvAppendEntriesReply(SSyncNode* pSyncNode, const SyncAppendEntriesReply* pMsg, const char* s) {
   char     host[64];
   uint16_t port;
   syncUtilU642Addr(pMsg->srcId.addr, host, sizeof(host), &port);

source/libs/sync/src/syncRaftLog.c

@@ -237,51 +237,6 @@ static int32_t raftLogAppendEntry(struct SSyncLogStore* pLogStore, SSyncRaftEntr
   return 0;
 }
 
-#if 0
-static int32_t raftLogAppendEntry(struct SSyncLogStore* pLogStore, SSyncRaftEntry* pEntry) {
-  SSyncLogStoreData* pData = pLogStore->data;
-  SWal*              pWal = pData->pWal;
-
-  SyncIndex writeIndex = raftLogWriteIndex(pLogStore);
-  if (pEntry->index != writeIndex) {
-    sError("vgId:%d, wal write index error, entry-index:%" PRId64 " update to %" PRId64, pData->pSyncNode->vgId,
-           pEntry->index, writeIndex);
-    pEntry->index = writeIndex;
-  }
-
-  int          code = 0;
-  SWalSyncInfo syncMeta;
-  syncMeta.isWeek = pEntry->isWeak;
-  syncMeta.seqNum = pEntry->seqNum;
-  syncMeta.term = pEntry->term;
-  code = walWriteWithSyncInfo(pWal, pEntry->index, pEntry->originalRpcType, syncMeta, pEntry->data, pEntry->dataLen);
-  if (code != 0) {
-    int32_t     err = terrno;
-    const char* errStr = tstrerror(err);
-    int32_t     sysErr = errno;
-    const char* sysErrStr = strerror(errno);
-
-    char logBuf[128];
-    snprintf(logBuf, sizeof(logBuf), "wal write error, index:%" PRId64 ", err:%d %X, msg:%s, syserr:%d, sysmsg:%s",
-             pEntry->index, err, err, errStr, sysErr, sysErrStr);
-    syncNodeErrorLog(pData->pSyncNode, logBuf);
-
-    ASSERT(0);
-  }
-
-  // walFsync(pWal, true);
-
-  do {
-    char eventLog[128];
-    snprintf(eventLog, sizeof(eventLog), "write index:%" PRId64 ", type:%s,%d, type2:%s,%d", pEntry->index,
-             TMSG_INFO(pEntry->msgType), pEntry->msgType, TMSG_INFO(pEntry->originalRpcType), pEntry->originalRpcType);
-    syncNodeEventLog(pData->pSyncNode, eventLog);
-  } while (0);
-
-  return code;
-}
-#endif
-
 // entry found, return 0
 // entry not found, return -1, terrno = TSDB_CODE_WAL_LOG_NOT_EXIST
 // other error, return -1
@@ -400,45 +355,6 @@ static int32_t raftLogGetLastEntry(SSyncLogStore* pLogStore, SSyncRaftEntry** pp
 //-------------------------------
 // log[0 .. n]
 
-#if 0
-int32_t logStoreAppendEntry(SSyncLogStore* pLogStore, SSyncRaftEntry* pEntry) {
-  SSyncLogStoreData* pData = pLogStore->data;
-  SWal*              pWal = pData->pWal;
-
-  SyncIndex lastIndex = logStoreLastIndex(pLogStore);
-  ASSERT(pEntry->index == lastIndex + 1);
-
-  int          code = 0;
-  SWalSyncInfo syncMeta;
-  syncMeta.isWeek = pEntry->isWeak;
-  syncMeta.seqNum = pEntry->seqNum;
-  syncMeta.term = pEntry->term;
-  code = walWriteWithSyncInfo(pWal, pEntry->index, pEntry->originalRpcType, syncMeta, pEntry->data, pEntry->dataLen);
-  if (code != 0) {
-    int32_t     err = terrno;
-    const char* errStr = tstrerror(err);
-    int32_t     sysErr = errno;
-    const char* sysErrStr = strerror(errno);
-
-    char logBuf[128];
-    snprintf(logBuf, sizeof(logBuf), "wal write error, index:%" PRId64 ", err:%d %X, msg:%s, syserr:%d, sysmsg:%s",
-             pEntry->index, err, err, errStr, sysErr, sysErrStr);
-    syncNodeErrorLog(pData->pSyncNode, logBuf);
-
-    ASSERT(0);
-  }
-
-  // walFsync(pWal, true);
-
-  char eventLog[128];
-  snprintf(eventLog, sizeof(eventLog), "old write index:%" PRId64 ", type:%s,%d, type2:%s,%d", pEntry->index,
-           TMSG_INFO(pEntry->msgType), pEntry->msgType, TMSG_INFO(pEntry->originalRpcType), pEntry->originalRpcType);
-  syncNodeEventLog(pData->pSyncNode, eventLog);
-
-  return code;
-}
-#endif
-
 int32_t logStoreAppendEntry(SSyncLogStore* pLogStore, SSyncRaftEntry* pEntry) {
   SSyncLogStoreData* pData = pLogStore->data;
   SWal*              pWal = pData->pWal;

source/libs/sync/src/syncReplication.c

@@ -140,9 +140,6 @@ int32_t syncNodeAppendEntriesPeersSnapshot2(SSyncNode* pSyncNode) {
       sError("vgId:%d, sync get pre term error, nextIndex:%" PRId64 ", update next-index:%" PRId64
              ", match-index:%d, raftid:%" PRId64,
              pSyncNode->vgId, nextIndex, newNextIndex, SYNC_INDEX_INVALID, pDestId->addr);
-
-      // syncNodeRestartNowHeartbeatTimer(pSyncNode);
-      syncNodeStartNowHeartbeatTimer(pSyncNode);
       return -1;
     }
 

source/libs/sync/src/syncRequestVote.c

@@ -51,15 +51,20 @@ int32_t syncNodeOnRequestVoteCb(SSyncNode* ths, SyncRequestVote* pMsg) {
     return -1;
   }
 
+  bool logOK = (pMsg->lastLogTerm > ths->pLogStore->getLastTerm(ths->pLogStore)) ||
+               ((pMsg->lastLogTerm == ths->pLogStore->getLastTerm(ths->pLogStore)) &&
+                (pMsg->lastLogIndex >= ths->pLogStore->getLastIndex(ths->pLogStore)));
+
   // maybe update term
   if (pMsg->term > ths->pRaftStore->currentTerm) {
-    syncNodeUpdateTerm(ths, pMsg->term);
+    if (logOK) {
+      syncNodeUpdateTerm(ths, pMsg->term);
+    } else {
+      syncNodeUpdateTermWithoutStepDown(ths, pMsg->term);
+    }
   }
   ASSERT(pMsg->term <= ths->pRaftStore->currentTerm);
 
-  bool logOK = (pMsg->lastLogTerm > ths->pLogStore->getLastTerm(ths->pLogStore)) ||
-               ((pMsg->lastLogTerm == ths->pLogStore->getLastTerm(ths->pLogStore)) &&
-                (pMsg->lastLogIndex >= ths->pLogStore->getLastIndex(ths->pLogStore)));
   bool grant = (pMsg->term == ths->pRaftStore->currentTerm) && logOK &&
                ((!raftStoreHasVoted(ths->pRaftStore)) || (syncUtilSameId(&(ths->pRaftStore->voteFor), &(pMsg->srcId))));
   if (grant) {
@@ -94,48 +99,6 @@ int32_t syncNodeOnRequestVoteCb(SSyncNode* ths, SyncRequestVote* pMsg) {
   return ret;
 }
 
-#if 0
-int32_t syncNodeOnRequestVoteCb(SSyncNode* ths, SyncRequestVote* pMsg) {
-  int32_t ret = 0;
-
-  char logBuf[128] = {0};
-  snprintf(logBuf, sizeof(logBuf), "==syncNodeOnRequestVoteCb== term:%" PRIu64, ths->pRaftStore->currentTerm);
-  syncRequestVoteLog2(logBuf, pMsg);
-
-  if (pMsg->term > ths->pRaftStore->currentTerm) {
-    syncNodeUpdateTerm(ths, pMsg->term);
-  }
-  ASSERT(pMsg->term <= ths->pRaftStore->currentTerm);
-
-  bool logOK = (pMsg->lastLogTerm > ths->pLogStore->getLastTerm(ths->pLogStore)) ||
-               ((pMsg->lastLogTerm == ths->pLogStore->getLastTerm(ths->pLogStore)) &&
-                (pMsg->lastLogIndex >= ths->pLogStore->getLastIndex(ths->pLogStore)));
-  bool grant = (pMsg->term == ths->pRaftStore->currentTerm) && logOK &&
-               ((!raftStoreHasVoted(ths->pRaftStore)) || (syncUtilSameId(&(ths->pRaftStore->voteFor), &(pMsg->srcId))));
-  if (grant) {
-    // maybe has already voted for pMsg->srcId
-    // vote again, no harm
-    raftStoreVote(ths->pRaftStore, &(pMsg->srcId));
-
-    // forbid elect for this round
-    syncNodeResetElectTimer(ths);
-  }
-
-  SyncRequestVoteReply* pReply = syncRequestVoteReplyBuild(ths->vgId);
-  pReply->srcId = ths->myRaftId;
-  pReply->destId = pMsg->srcId;
-  pReply->term = ths->pRaftStore->currentTerm;
-  pReply->voteGranted = grant;
-
-  SRpcMsg rpcMsg;
-  syncRequestVoteReply2RpcMsg(pReply, &rpcMsg);
-  syncNodeSendMsgById(&pReply->destId, ths, &rpcMsg);
-  syncRequestVoteReplyDestroy(pReply);
-
-  return ret;
-}
-#endif
-
 static bool syncNodeOnRequestVoteLogOK(SSyncNode* pSyncNode, SyncRequestVote* pMsg) {
   SyncTerm  myLastTerm = syncNodeGetLastTerm(pSyncNode);
   SyncIndex myLastIndex = syncNodeGetLastIndex(pSyncNode);
@@ -200,13 +163,18 @@ int32_t syncNodeOnRequestVoteSnapshotCb(SSyncNode* ths, SyncRequestVote* pMsg) {
     return -1;
   }
 
+  bool logOK = syncNodeOnRequestVoteLogOK(ths, pMsg);
+
   // maybe update term
   if (pMsg->term > ths->pRaftStore->currentTerm) {
-    syncNodeUpdateTerm(ths, pMsg->term);
+    if (logOK) {
+      syncNodeUpdateTerm(ths, pMsg->term);
+    } else {
+      syncNodeUpdateTermWithoutStepDown(ths, pMsg->term);
+    }
   }
   ASSERT(pMsg->term <= ths->pRaftStore->currentTerm);
 
-  bool logOK = syncNodeOnRequestVoteLogOK(ths, pMsg);
   bool grant = (pMsg->term == ths->pRaftStore->currentTerm) && logOK &&
                ((!raftStoreHasVoted(ths->pRaftStore)) || (syncUtilSameId(&(ths->pRaftStore->voteFor), &(pMsg->srcId))));
   if (grant) {

source/libs/sync/src/syncRequestVoteReply.c

@@ -93,65 +93,6 @@ int32_t syncNodeOnRequestVoteReplyCb(SSyncNode* ths, SyncRequestVoteReply* pMsg)
   return 0;
 }
 
-#if 0
-int32_t syncNodeOnRequestVoteReplyCb(SSyncNode* ths, SyncRequestVoteReply* pMsg) {
-  int32_t ret = 0;
-
-  char logBuf[128] = {0};
-  snprintf(logBuf, sizeof(logBuf), "==syncNodeOnRequestVoteReplyCb== term:%" PRIu64, ths->pRaftStore->currentTerm);
-  syncRequestVoteReplyLog2(logBuf, pMsg);
-
-  if (pMsg->term < ths->pRaftStore->currentTerm) {
-    sTrace("DropStaleResponse, receive term:%" PRIu64 ", current term:%" PRIu64 "", pMsg->term,
-           ths->pRaftStore->currentTerm);
-    return ret;
-  }
-
-  // ASSERT(!(pMsg->term > ths->pRaftStore->currentTerm));
-  //  no need this code, because if I receive reply.term, then I must have sent for that term.
-  //   if (pMsg->term > ths->pRaftStore->currentTerm) {
-  //     syncNodeUpdateTerm(ths, pMsg->term);
-  //   }
-
-  if (pMsg->term > ths->pRaftStore->currentTerm) {
-    char logBuf[128] = {0};
-    snprintf(logBuf, sizeof(logBuf), "syncNodeOnRequestVoteReplyCb error term, receive:%" PRIu64 " current:%" PRIu64, pMsg->term,
-             ths->pRaftStore->currentTerm);
-    syncNodePrint2(logBuf, ths);
-    sError("%s", logBuf);
-    return ret;
-  }
-
-  ASSERT(pMsg->term == ths->pRaftStore->currentTerm);
-
-  // This tallies votes even when the current state is not Candidate,
-  // but they won't be looked at, so it doesn't matter.
-  if (ths->state == TAOS_SYNC_STATE_CANDIDATE) {
-    votesRespondAdd(ths->pVotesRespond, pMsg);
-    if (pMsg->voteGranted) {
-      // add vote
-      voteGrantedVote(ths->pVotesGranted, pMsg);
-
-      // maybe to leader
-      if (voteGrantedMajority(ths->pVotesGranted)) {
-        if (!ths->pVotesGranted->toLeader) {
-          syncNodeCandidate2Leader(ths);
-
-          // prevent to leader again!
-          ths->pVotesGranted->toLeader = true;
-        }
-      }
-    } else {
-      ;
-      // do nothing
-      // UNCHANGED <<votesGranted, voterLog>>
-    }
-  }
-
-  return ret;
-}
-#endif
-
 int32_t syncNodeOnRequestVoteReplySnapshotCb(SSyncNode* ths, SyncRequestVoteReply* pMsg) {
   int32_t ret = 0;
 
@@ -184,6 +125,14 @@ int32_t syncNodeOnRequestVoteReplySnapshotCb(SSyncNode* ths, SyncRequestVoteRepl
   // This tallies votes even when the current state is not Candidate,
   // but they won't be looked at, so it doesn't matter.
   if (ths->state == TAOS_SYNC_STATE_CANDIDATE) {
+    if (ths->pVotesRespond->term != pMsg->term) {
+      char logBuf[128];
+      snprintf(logBuf, sizeof(logBuf), "vote respond error vote-respond-mgr term:%lu, msg term:lu",
+               ths->pVotesRespond->term, pMsg->term);
+      syncNodeErrorLog(ths, logBuf);
+      return -1;
+    }
+
     votesRespondAdd(ths->pVotesRespond, pMsg);
     if (pMsg->voteGranted) {
       // add vote

source/libs/sync/test/sh/a.sh

@@ -81,4 +81,16 @@ for file in `ls ${logpath}/log.dnode*vgId*`;do
 
 done
 
+echo ""
+echo "generate log.commit ..."
+tmpfile=${logpath}/log.commits.tmp
+touch ${tmpfile}
+for file in `ls ${logpath}/log.dnode*.vgId*.commit`;do
+	line=`cat ${file} | tail -n1`
+	echo $line | awk '{print $5, $0}' >> ${tmpfile}
+done
+cat ${tmpfile} | sort -k1 > ${logpath}/log.commits
+
 exit 0
+
+

tests/script/tsim/parser/nestquery.sim

@@ -160,12 +160,12 @@ endi
 
 sql select stddev(c1) from (select c1 from nest_tb0);
 sql_error select percentile(c1, 20) from (select * from nest_tb0);
-sql select interp(c1) from (select * from nest_tb0);
+#sql select interp(c1) from (select * from nest_tb0);
 sql_error select derivative(val, 1s, 0) from (select c1 val from nest_tb0);
 sql_error select twa(c1) from (select c1 from nest_tb0);
 sql_error select irate(c1) from (select c1 from nest_tb0);
 sql_error select diff(c1), twa(c1) from (select * from nest_tb0);
-sql_error select irate(c1), interp(c1), twa(c1) from (select * from nest_tb0);
+#sql_error select irate(c1), interp(c1), twa(c1) from (select * from nest_tb0);
 
 sql select _wstart, apercentile(c1, 50) from (select * from nest_tb0) interval(1d)
 if $rows != 7 then

tests/system-test/fulltest.sh

@@ -199,25 +199,25 @@ python3 ./test.py -f 6-cluster/5dnode3mnodeStop2Follower.py  -N 5 -M 3
 python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_createDb_replica1.py -N 4 -M 1
 python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica1_insertdatas.py -N 4 -M 1
 python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica1_insertdatas_querys.py -N 4 -M 1
-python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_force_stop_all_dnodes.py -N 4 -M 1
+# python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_force_stop_all_dnodes.py -N 4 -M 1
 python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas.py -N 4 -M 1
-python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_querys_loop_restart_all_vnode.py -N 4 -M 1
-python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_querys_loop_restart_follower.py -N 4 -M 1
+# python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_querys_loop_restart_all_vnode.py -N 4 -M 1
+# python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_querys_loop_restart_follower.py -N 4 -M 1
 # python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_querys_loop_restart_leader.py -N 4 -M 1
 python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_querys.py -N 4 -M 1
 # python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_stop_all_dnodes.py -N 4 -M 1
-python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_stop_follower_sync.py -N 4 -M 1
+# python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_stop_follower_sync.py -N 4 -M 1
 # python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_stop_follower_unsync_force_stop.py -N 4 -M 1
 # python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_stop_follower_unsync.py -N 4 -M 1
 # python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_stop_leader_forece_stop.py -N 4 -M 1
 # python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_stop_leader.py -N 4 -M 1
-python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_mnode3_insertdatas_querys.py -N 4 -M 1
+# python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_mnode3_insertdatas_querys.py -N 4 -M 1
 # python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_querydatas_stop_follower_force_stop.py -N 4 -M 1
-python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_querydatas_stop_follower.py -N 4 -M 1
+# python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_querydatas_stop_follower.py -N 4 -M 1
 # python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_querydatas_stop_leader_force_stop.py -N 4 -M 1 
 # python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_querydatas_stop_leader.py -N 4 -M 1 
 python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_vgroups.py  -N 4 -M 1
-python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_vgroups_stopOne.py -N 4 -M 1
+# python3 test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_vgroups_stopOne.py -N 4 -M 1
 
 
 python3 ./test.py -f 7-tmq/dropDbR3ConflictTransaction.py -N 3