other: merge 3.0

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

@@ -15,45 +15,83 @@ import Node from "./_sub_node.mdx";
 import CSharp from "./_sub_cs.mdx";
 import CDemo from "./_sub_c.mdx";
 
-为了帮助应用实时获取写入 TDengine 的数据，或者以事件到达顺序处理数据，TDengine 提供了类似消息队列产品的数据订阅、消费接口。这样在很多场景下，采用 TDengine 的时序数据处理系统不再需要集成消息队列产品，比如 kafka, 从而简化系统设计的复杂度，降低运营维护成本。
 
-与 kafka 一样，你需要定义 *topic*, 但 TDengine 的 *topic* 是基于一个已经存在的超级表、子表或普通表的查询条件，即一个 `SELECT` 语句。你可以使用 SQL 对标签、表名、列、表达式等条件进行过滤，以及对数据进行标量函数与 UDF 计算（不包括数据聚合）。与其他消息队列软件相比，这是 TDengine 数据订阅功能的最大的优势，它提供了更大的灵活性，数据的颗粒度可以由应用随时调整，而且数据的过滤与预处理交给 TDengine，而不是应用完成，有效的减少传输的数据量与应用的复杂度。
+为了帮助应用实时获取写入 TDengine 的数据，或者以事件到达顺序处理数据，TDengine 提供了类似 kafka 的数据订阅功能。这样在很多场景下，采用 TDengine 的时序数据处理系统不再需要集成消息队列产品，比如 kafka, 从而简化系统设计的复杂度，降低运营维护成本。
 
-消费者订阅 *topic* 后，可以实时获得最新的数据。多个消费者可以组成一个消费者组 (consumer group), 一个消费者组里的多个消费者共享消费进度，便于多线程、分布式地消费数据，提高消费速度。但不同消费者组中的消费者即使消费同一个 topic, 并不共享消费进度。一个消费者可以订阅多个 topic。如果订阅的是超级表，数据可能会分布在多个不同的 vnode 上，也就是多个 shard 上，这样一个消费组里有多个消费者可以提高消费效率。TDengine 的消息队列提供了消息的 ACK 机制，在宕机、重启等复杂环境下确保 at least once 消费。
+# 介绍
+## 主题
+与 kafka 一样，你需要定义 topic, TDengine 的 topic 有三种，可以是数据库，超级表，或者一个 `SELECT` 语句，具体的语法参见 [CREATE TOPIC](../../12-taos-sql/13-tmq)。与其他消息队列软件相比，这是 TDengine 数据订阅功能的最大的优势，它提供了更大的灵活性，数据的颗粒度可以由应用随时调整，而且数据的过滤与预处理交给 TDengine，而不是应用完成，有效的减少传输的数据量与应用的复杂度。
 
-为了实现上述功能，TDengine 会为 WAL (Write-Ahead-Log) 文件自动创建索引以支持快速随机访问，并提供了灵活可配置的文件切换与保留机制：用户可以按需指定 WAL 文件保留的时间以及大小（详见 create database 语句）。通过以上方式将 WAL 改造成了一个保留事件到达顺序的、可持久化的存储引擎（但由于 TSDB 具有远比 WAL 更高的压缩率，我们不推荐保留太长时间，一般来说，不超过几天）。 对于以 topic 形式创建的查询，TDengine 将对接 WAL 而不是 TSDB 作为其存储引擎。在消费时，TDengine 根据当前消费进度从 WAL 直接读取数据，并使用统一的查询引擎实现过滤、变换等操作，将数据推送给消费者。
+如下图，每个 topic 涉及到的数据表可能分布在多个 vnode（相当于 kafka 里的 partition） 上，每个 vnode 上的数据保存在 WAL(Write-Ahead-Log) 文件中，WAL 文件里的数据是顺序写入的（由于 WAL 文件中存储的不只有数据，还有元数据，写入消息等，所以数据的版本号不是连续的）。
 
-下面为关于数据订阅的一些说明，需要对TDengine的架构有一些了解，结合各个语言链接器的接口使用。(可使用时再了解)
+![img_5.png](img_5.png)
-- 一个消费组消费同一个topic下的所有数据，不同消费组之间相互独立；
-- 一个消费组消费同一个topic所有的vgroup，消费组可由多个消费者组成，但一个vgroup仅被一个消费者消费，如果消费者数量超过了vgroup数量，多余的消费者不消费数据；
-- 在服务端每个vgroup仅保存一个offset，每个vgroup的offset是单调递增的，但不一定连续。各个vgroup的offset之间没有关联；
-- 每次poll服务端会返回一个结果block，该block属于一个vgroup，可能包含多个wal版本的数据，可以通过 offset 接口获得是该block第一条记录的offset；
-- 一个消费组如果从未commit过offset，当其成员消费者重启重新拉取数据时，均从参数auto.offset.reset设定值开始消费；在一个消费者生命周期中，客户端本地记录了最近一次拉取数据的offset，不会拉取重复数据；
-- 消费者如果异常终止（没有调用tmq_close），需等约12秒后触发其所属消费组rebalance，该消费者在服务端状态变为LOST，约1天后该消费者自动被删除；正常退出，退出后就会删除消费者；新增消费者，需等约2秒触发rebalance，该消费者在服务端状态变为ready；
-- 消费组rebalance会对该组所有ready状态的消费者成员重新进行vgroup分配，消费者仅能对自己负责的vgroup进行assignment/seek/commit/poll操作；
-- 消费者可利用 position 获得当前消费的offset，并seek到指定offset，重新消费；
-- seek将position指向指定offset，不执行commit操作，一旦seek成功，可poll拉取指定offset及以后的数据；
-- seek 操作之前须调用 assignment 接口获取该consumer的vgroup ID和offset范围。seek 操作会检测vgroup ID 和 offset是否合法，如非法将报错；
-- position是获取当前的消费位置，是下次要取的位置，不是当前消费到的位置
-- commit是提交消费位置，不带参数的话，是提交当前消费位置（下次要取的位置，不是当前消费到的位置），带参数的话，是提交参数里的位置（也即下次退出重启后要取的位置）
-- seek是设置consumer消费位置，seek到哪，position就返回哪，都是下次要取的位置
-- seek不会影响commit，commit不影响seek，相互独立，两个是不同的概念
-- begin接口为wal 第一条数据的offset，end 接口为wal 最后一条数据的offset + 1
-- offset接口获取的是记录所在结果block块里的第一条数据的offset，当seek至该offset时，将消费到这个block里的全部数据。参见第四点；
-- 由于存在 WAL 过期删除机制，即使seek 操作成功，poll数据时有可能offset已失效。如果poll 的offset 小于 WAL 最小版本号，将会从WAL最小版本号消费；
-- 数据订阅是从 WAL 消费数据，如果一些 WAL 文件被基于 WAL 保留策略删除，则已经删除的 WAL 文件中的数据就无法再消费到。需要根据业务需要在创建数据库时合理设置 `WAL_RETENTION_PERIOD` 或 `WAL_RETENTION_SIZE` ，并确保应用及时消费数据，这样才不会产生数据丢失的现象。数据订阅的行为与 Kafka 等广泛使用的消息队列类产品的行为相似；
 
-本文档不对消息队列本身的知识做更多的介绍，如果需要了解，请自行搜索。
+TDengine 会为 WAL 文件自动创建索引以支持快速随机访问，并提供了灵活可配置的文件切换与保留机制，用户可以按需指定 WAL 文件保留的时间以及大小（详见 [CREATE DATABASE](../../12-taos-sql/02-database) 语句，由于消费是通过 WAL 实现的，所以应该根据写入消费速度来确定 WAL 的保存时长）。通过以上方式将 WAL 改造成了一个保留事件到达顺序的、可持久化的存储引擎。
 
-说明：
+对于 `SELECT` 语句形式的 topic，在消费时，TDengine 根据当前消费进度从 WAL 直接读取数据，并使用统一的查询引擎实现过滤、变换等操作，将数据推送给消费者。
+
+## 生产者
+写入 topic 相关联的数据表中数据的都是生产者，生产者实际生产的数据写入到了子表或普通表中，即表所在 vnode 的 WAL 里。
+
+## 消费者
+### 消费者组
+消费者订阅 topic 后，可以消费 topic 里的所有数据（这些数据所在的表可能分布在多个 vnode 上，即 db 所在的所有 vnode）。订阅 topic 时，需要指定一个消费者组 (consumer group)，如果这个消费者组里只有一个消费者，那么这个消费者会顺序的消费这些 vnode 上的数据。
+
+为了提高消费速度，便于多线程、分布式地消费数据，可以在一个消费组里添加多个消费者，这些消费者将均分数据所在的 vnode 进行消费（比如数据分布在 4 个 vnode 上，有 2 个消费者的话，那么每个消费者消费 2 个 vnode；有 3 个消费者的话，2 个消费者各消费 1 个 vnode，1 个消费者消费 2 个 vnode；有 5 个消费者的话，4 个各分配 1 个 vnode 消费，另外 1 个不消费），如下图：
+
+![img_6.png](img_6.png)
+
+在一个消费组里添加一个消费者后，在 Mnode 上通过 rebalance 的机制实现消费者的重新分配，该操作对用户是透明的。
+
+一个消费者可以订阅多个 topic。TDengine 的数据订阅在宕机、重启等复杂环境下确保 at least once 消费。
+### 消费进度
+在 topic 的一个消费组的一个 vnode 上有消费进度。消费者消费的同时，可以提交消费进度，消费进度即 vnode 上 WAL 的版本号（对于 kafka 里的 offset），消费进度可以手动提交，也可以通过参数（auto.commit.interval.ms）设置为周期性自动提交。
+
+首次消费数据时通过订阅参数（auto.offset.reset）来确定消费位置为最新数据（latest）还是最旧数据（earliest）。
+
+消费进度在一个 vnode 上对于同一个 topic 和 消费者组是唯一的。所以如果同一个 topic 和 消费者组在一个 vnode 上的消费者退出了，并且提交了消费进度。然后同一个 topic 和 消费者组里重新建了一个新的消费者消费这个 vnode，那么这个新消费者将继承之前的消费进度继续消费。
+
+如果之前的消费者没有提交消费进度，那个新的消费者将根据订阅参数（auto.offset.reset）设置的值来确定起始消费位置。
+
+不同消费者组中的消费者即使消费同一个 topic, 并不共享消费进度。
+
+![img_7.png](img_7.png)
+
+作为一个数据库产品， WAL 文件中存储的不全是数据，也包括其他写入消息，元数据等，所以消费进度不是连续的。
+
+##说明
 从3.2.0.0版本开始，数据订阅支持vnode迁移和分裂。
-由于数据订阅依赖wal文件，而在vnode迁移和分裂的过程中，wal并不会同步过去，所以迁移或分裂后，之前没消费完的wal数据后消费不到。所以请保证之前把数据全部消费完后，再进行vnode迁移或分裂，否则，消费会丢失数据。
 
-## 主要数据结构和 API
+由于数据订阅依赖wal文件，而在vnode迁移和分裂的过程中，wal并不会同步过去，所以迁移或分裂后，之前没消费完的wal数据后消费不到。所以请保证迁移和分裂之前把数据全部消费完后，再进行vnode迁移或分裂，否则，消费会丢失数据。
 
-不同语言下， TMQ 订阅相关的 API 及数据结构如下（注意consumer结构不是线程安全的，在一个线程使用consumer时，不要在另一个线程close这个consumer）：
+# 语法说明
+
+具体的语法参见 [数据订阅](../../12-taos-sql/13-tmq)
+
+# 消费参数
+
+消费参数主要用于消费者创建时指定，基础配置项如下表所示：
+
+|            参数名称            |  类型   | 参数说明                                                 | 备注                                        |
+| :----------------------------: | :-----: | -------------------------------------------------------- | ------------------------------------------- |
+|        `td.connect.ip`         | string  | 服务端的 IP 地址                          |                                          |
+|       `td.connect.user`        | string  | 用户名                         |    |
+|       `td.connect.pass`        | string  | 密码                          |  |
+|       `td.connect.port`        | integer | 服务端的端口号                         |  |
+|           `group.id`           | string  | 消费组 ID，同一消费组共享消费进度                        | <br />**必填项**。最大长度：192。<br />每个topic最多可建立100个 consumer group                 |
+|          `client.id`           | string  | 客户端 ID                                                | 最大长度：192。                             |
+|      `auto.offset.reset`       |  enum   | 消费组订阅的初始位置                                     | <br />`earliest`: default(version < 3.2.0.0);从头开始订阅; <br/>`latest`: default(version >= 3.2.0.0);仅从最新数据开始订阅; <br/>`none`: 没有提交的 offset 无法订阅 |
+|      `enable.auto.commit`      | boolean | 是否启用消费位点自动提交，true: 自动提交，客户端应用无需commit；false：客户端应用需要自行commit     | 默认值为 true                   |
+|   `auto.commit.interval.ms`    | integer | 消费记录自动提交消费位点时间间隔，单位为毫秒           | 默认值为 5000                                |
+|     `msg.with.table.name`      | boolean | 是否允许从消息中解析表名, 不适用于列订阅（列订阅时可将 tbname 作为列写入 subquery 语句）（从3.2.0.0版本该参数废弃，恒为true）               |默认关闭 |
+|     `enable.replay`            | boolean | 是否开启数据回放功能               |默认关闭 |
+
+# 主要数据结构和 API 接口
+
+不同语言下， TMQ 订阅相关的 API 及数据结构如下（详细的接口说明可以参考连接器章节，注意consumer结构不是线程安全的，在一个线程使用consumer时，不要在另一个线程close这个consumer）：
 
 <Tabs defaultValue="java" groupId="lang">
+    
     <TabItem value="c" label="C">
 
         ```c
@@ -109,9 +147,6 @@ import CDemo from "./_sub_c.mdx";
         DLL_EXPORT int64_t     tmq_get_vgroup_offset(TAOS_RES* res);
         DLL_EXPORT const char *tmq_err2str(int32_t code);
         ```
-
-下面介绍一下它们的具体用法（超级表和子表结构请参考“数据建模”一节），完整的示例代码请见下面 C 语言的示例代码。
-
     </TabItem>
     <TabItem value="java" label="Java">
 
@@ -269,10 +304,10 @@ List<TopicPartitionOffset> Commit()
     
         void Close()
         ```
-
     </TabItem>
 </Tabs>
 
+# 数据订阅示例
 ## 写入数据
 
 首先完成建库、建一张超级表和多张子表操作，然后就可以写入数据了，比如：
@@ -286,83 +321,21 @@ CREATE TABLE tmqdb.ctb1 USING tmqdb.stb TAGS(1, "subtable1");
 INSERT INTO tmqdb.ctb0 VALUES(now, 0, 0, 'a0')(now+1s, 0, 0, 'a00');
 INSERT INTO tmqdb.ctb1 VALUES(now, 1, 1, 'a1')(now+1s, 11, 11, 'a11');
 ```
+## 创建 topic
 
-## 创建 *topic*
+使用 SQL 创建一个 topic：
-
-TDengine 使用 SQL 创建一个 topic：
 
 ```sql
 CREATE TOPIC topic_name AS SELECT ts, c1, c2, c3 FROM tmqdb.stb WHERE c1 > 1;
 ```
-- topic创建个数有上限，通过参数 tmqMaxTopicNum 控制，默认 20 个
-
-TMQ 支持多种订阅类型：
-
-### 列订阅
-
-语法：
-
-```sql
-CREATE TOPIC topic_name as subquery
-```
-
-通过 `SELECT` 语句订阅（包括 `SELECT *`，或 `SELECT ts, c1` 等指定列订阅，可以带条件过滤、标量函数计算，但不支持聚合函数、不支持时间窗口聚合）。需要注意的是：
-
-- 该类型 TOPIC 一旦创建则订阅数据的结构确定。
-- 被订阅或用于计算的列或标签不可被删除（`ALTER table DROP`）、修改（`ALTER table MODIFY`）。
-- 若发生表结构变更，新增的列不出现在结果中。
-
-### 超级表订阅
-
-语法：
-
-```sql
-CREATE TOPIC topic_name [with meta] AS STABLE stb_name [where_condition]
-```
-
-与 `SELECT * from stbName` 订阅的区别是：
-
-- 不会限制用户的表结构变更。
-- 返回的是非结构化的数据：返回数据的结构会随之超级表的表结构变化而变化。
-- with meta 参数可选，选择时将返回创建超级表，子表等语句，主要用于taosx做超级表迁移
-- where_condition 参数可选，选择时将用来过滤符合条件的子表，订阅这些子表。where 条件里不能有普通列，只能是tag或tbname，where条件里可以用函数，用来过滤tag，但是不能是聚合函数，因为子表tag值无法做聚合。也可以是常量表达式，比如 2 > 1（订阅全部子表），或者 false（订阅0个子表）
-- 返回数据不包含标签。
-
-### 数据库订阅
-
-语法：
-
-```sql
-CREATE TOPIC topic_name [with meta] AS DATABASE db_name;
-```
-
-通过该语句可创建一个包含数据库所有表数据的订阅
-
-- with meta 参数可选，选择时将返回创建数据库里所有超级表，子表的语句，主要用于taosx做数据库迁移
 
 ## 创建消费者 *consumer*
 
-消费者需要通过一系列配置选项创建，基础配置项如下表所示：
-
-|            参数名称            |  类型   | 参数说明                                                 | 备注                                        |
-| :----------------------------: | :-----: | -------------------------------------------------------- | ------------------------------------------- |
-|        `td.connect.ip`         | string  | 服务端的 IP 地址                          |                                          |
-|       `td.connect.user`        | string  | 用户名                         |    |
-|       `td.connect.pass`        | string  | 密码                          |  |
-|       `td.connect.port`        | integer | 服务端的端口号                         |  |
-|           `group.id`           | string  | 消费组 ID，同一消费组共享消费进度                        | <br />**必填项**。最大长度：192。<br />每个topic最多可建立100个 consumer group                 |
-|          `client.id`           | string  | 客户端 ID                                                | 最大长度：192。                             |
-|      `auto.offset.reset`       |  enum   | 消费组订阅的初始位置                                     | <br />`earliest`: default(version < 3.2.0.0);从头开始订阅; <br/>`latest`: default(version >= 3.2.0.0);仅从最新数据开始订阅; <br/>`none`: 没有提交的 offset 无法订阅 |
-|      `enable.auto.commit`      | boolean | 是否启用消费位点自动提交，true: 自动提交，客户端应用无需commit；false：客户端应用需要自行commit     | 默认值为 true                   |
-|   `auto.commit.interval.ms`    | integer | 消费记录自动提交消费位点时间间隔，单位为毫秒           | 默认值为 5000                                |
-|     `msg.with.table.name`      | boolean | 是否允许从消息中解析表名, 不适用于列订阅（列订阅时可将 tbname 作为列写入 subquery 语句）（从3.2.0.0版本该参数废弃，恒为true）               |默认关闭 |
-|     `enable.replay`            | boolean | 是否开启数据回放功能               |默认关闭 |
-
 对于不同编程语言，其设置方式如下：
 
 <Tabs defaultValue="java" groupId="lang">
-<TabItem value="c" label="C">
 
+    <TabItem value="c" label="C">
         ```c
         /* 根据需要，设置消费组 (group.id)、自动提交 (enable.auto.commit)、
            自动提交时间间隔 (auto.commit.interval.ms)、用户名 (td.connect.user)、密码 (td.connect.pass) 等参数 */
@@ -379,8 +352,8 @@ tmq_conf_set_auto_commit_cb(conf, tmq_commit_cb_print, NULL);
         tmq_t* tmq = tmq_consumer_new(conf, NULL, 0);
         tmq_conf_destroy(conf);
         ```
-
     </TabItem>
+
     <TabItem value="java" label="Java">
 
         对于 Java 程序，还可以使用如下配置项：
@@ -414,7 +387,6 @@ import com.taosdata.jdbc.tmq.ReferenceDeserializer;
         public class MetersDeserializer extends ReferenceDeserializer<Meters> {
         }
         ```
-
     </TabItem>
 
     <TabItem label="Go" value="Go">
@@ -523,29 +495,12 @@ var consumer = new ConsumerBuilder<Dictionary<string, object>>(cfg).Build();
     
 上述配置中包括 consumer group ID，如果多个 consumer 指定的 consumer group ID 一样，则自动形成一个 consumer group，共享消费进度。
     
-数据回放功能说明：
-- 订阅增加 replay 功能，按照数据写入的时间回放。
-  比如，如下时间写入三条数据
-  ```sql
-    2023/09/22 00:00:00.000
-    2023/09/22 00:00:05.000
-    2023/09/22 00:00:08.000
-    ```
-  则订阅出第一条数据 5s 后返回第二条数据，获取第二条数据 3s 后返回第三条数据。
-- 仅列订阅支持数据回放
-  - 回放需要保证独立时间线
-  - 如果是子表订阅或者普通表订阅，只有一个vnode上有数据，保证是一个时间线
-  - 如果超级表订阅，则需保证该 DB 只有一个vnode，否则报错（因为多个vnode上订阅出的数据不在一个时间线上）
-- 超级表和库订阅不支持回放
-- 增加 enable.replay 参数，true表示开启订阅回放功能，false表示不开启订阅回放功能，默认不开启。
-- 回放不支持进度保存，所以回放参数 enable.replay = true 时，auto commit 自动关闭
-- 因为数据回放本身需要处理时间，所以回放的精度存在几十ms的误差
-
 ## 订阅 *topics*
 
 一个 consumer 支持同时订阅多个 topic。
     
 <Tabs defaultValue="java" groupId="lang">
+
     <TabItem value="c" label="C">
     
         ```c
@@ -625,6 +580,7 @@ consumer.Subscribe(topics);
 以下代码展示了不同语言下如何对 TMQ 消息进行消费。
 
 <Tabs defaultValue="java" groupId="lang">
+
     <TabItem value="c" label="C">
 
         ```c
@@ -761,6 +717,7 @@ while (true)
 消费结束后，应当取消订阅。
 
 <Tabs defaultValue="java" groupId="lang">
+    
     <TabItem value="c" label="C">
 
         ```c
@@ -837,36 +794,7 @@ consumer.Close();
 
 </Tabs>
 
-## 删除 *topic*
+## 完整示例代码
-
-如果不再需要订阅数据，可以删除 topic，需要注意：只有当前未在订阅中的 TOPIC 才能被删除。
-
-```sql
-/* 删除 topic */
-DROP TOPIC topic_name;
-```
-
-## 状态查看
-
-1、*topics*：查询已经创建的 topic
-
-```sql
-SHOW TOPICS;
-```
-
-2、consumers：查询 consumer 的状态及其订阅的 topic
-
-```sql
-SHOW CONSUMERS;
-```
-
-3、subscriptions：查询 consumer 与 vgroup 之间的分配关系
-
-```sql
-SHOW SUBSCRIPTIONS;
-```
-
-## 示例代码
 
 以下是各语言的完整示例代码。
 
@@ -908,3 +836,22 @@ SHOW SUBSCRIPTIONS;
     </TabItem>
     
 </Tabs>
+
+#订阅高级功能
+##数据回放
+- 订阅支持 replay 功能，按照数据写入的时间回放。
+  比如，如下时间写入三条数据
+  ```sql
+        2023/09/22 00:00:00.000
+        2023/09/22 00:00:05.000
+        2023/09/22 00:00:08.000
+        ```
+  则订阅出第一条数据 5s 后返回第二条数据，获取第二条数据 3s 后返回第三条数据。
+- 仅查询订阅支持数据回放
+  - 回放需要保证独立时间线
+  - 如果是子表订阅或者普通表订阅，只有一个vnode上有数据，保证是一个时间线
+  - 如果超级表订阅，则需保证该 DB 只有一个vnode，否则报错（因为多个vnode上订阅出的数据不在一个时间线上）
+- 超级表和库订阅不支持回放
+- enable.replay 参数，true表示开启订阅回放功能，false表示不开启订阅回放功能，默认不开启。
+- 回放不支持进度保存，所以回放参数 enable.replay = true 时，auto commit 自动关闭
+- 因为数据回放本身需要处理时间，所以回放的精度存在几十ms的误差

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

@@ -6,32 +6,68 @@ description: TDengine 消息队列提供的数据订阅功能
 
 TDengine 3.0.0.0 开始对消息队列做了大幅的优化和增强以简化用户的解决方案。
 
-## 创建订阅主题
+## 创建 topic
+
+TDengine 创建 topic 的个数上限通过参数 tmqMaxTopicNum 控制，默认 20 个。
+
+TDengine 使用 SQL 创建一个 topic，共有三种类型的 topic：
+
+### 查询 topic
+
+语法：
 
 ```sql
-CREATE TOPIC [IF NOT EXISTS] topic_name AS subquery;
+CREATE TOPIC [IF NOT EXISTS] topic_name as subquery
 ```
 
+通过 `SELECT` 语句订阅（包括 `SELECT *`，或 `SELECT ts, c1` 等指定查询订阅，可以带条件过滤、标量函数计算，但不支持聚合函数、不支持时间窗口聚合）。需要注意的是：
 
-TOPIC 支持过滤和标量函数和 UDF 标量函数，不支持 JOIN、GROUP BY、窗口切分子句、聚合函数和 UDF 聚合函数。列订阅规则如下：
+- 该类型 TOPIC 一旦创建则订阅数据的结构确定。
+- 被订阅或用于计算的列或标签不可被删除（`ALTER table DROP`）、修改（`ALTER table MODIFY`）。
+- 若发生表结构变更，新增的列不出现在结果中。
+- 对于 select \*，则订阅展开为创建时所有的列（子表、普通表为数据列，超级表为数据列加标签列）
+### 超级表 topic
 
-1. TOPIC 一旦创建则返回结果的字段确定
+语法：
-2. 被订阅或用于计算的列不可被删除、修改
-3. 列可以新增，但新增的列不出现在订阅结果字段中
-4. 对于 select \*，则订阅展开为创建时所有的列（子表、普通表为数据列，超级表为数据列加标签列）
-
-
-## 删除订阅主题
 
 ```sql
+CREATE TOPIC [IF NOT EXISTS] topic_name [with meta] AS STABLE stb_name [where_condition]
+```
+
+与 `SELECT * from stbName` 订阅的区别是：
+
+- 不会限制用户的表结构变更。
+- 返回的是非结构化的数据：返回数据的结构会随之超级表的表结构变化而变化。
+- with meta 参数可选，选择时将返回创建超级表，子表等语句，主要用于taosx做超级表迁移
+- where_condition 参数可选，选择时将用来过滤符合条件的子表，订阅这些子表。where 条件里不能有普通列，只能是tag或tbname，where条件里可以用函数，用来过滤tag，但是不能是聚合函数，因为子表tag值无法做聚合。也可以是常量表达式，比如 2 > 1（订阅全部子表），或者 false（订阅0个子表）
+- 返回数据不包含标签。
+
+### 数据库 topic
+
+语法：
+
+```sql
+CREATE TOPIC [IF NOT EXISTS] topic_name [with meta] AS DATABASE db_name;
+```
+
+通过该语句可创建一个包含数据库所有表数据的订阅
+
+- with meta 参数可选，选择时将返回创建数据库里所有超级表，子表的语句，主要用于taosx做数据库迁移
+
+说明： 超级表订阅和库订阅属于高级订阅模式，容易出错，如确实要使用，请咨询专业人员。
+
+## 删除 topic
+
+如果不再需要订阅数据，可以删除 topic，需要注意：只有当前未在订阅中的 TOPIC 才能被删除。
+
+```sql
+/* 删除 topic */
 DROP TOPIC [IF EXISTS] topic_name;
 ```
 
 此时如果该订阅主题上存在 consumer，则此 consumer 会收到一个错误。
 
-## 查看订阅主题
+## 查看 topic
-
-## SHOW TOPICS
 
 ```sql
 SHOW TOPICS;
@@ -58,3 +94,11 @@ SHOW CONSUMERS;
 ```
 
 显示当前数据库下所有活跃的消费者的信息。
+
+## 查看订阅信息
+
+```sql
+SHOW SUBSCRIPTIONS;
+```
+
+显示 consumer 与 vgroup 之间的分配关系和消费信息

include/common/systable.h

@@ -65,6 +65,11 @@ extern "C" {
 #define TSDB_PERFS_TABLE_TRANS       "perf_trans"
 #define TSDB_PERFS_TABLE_APPS        "perf_apps"
 
+#define TSDB_AUDIT_DB                "audit"
+#define TSDB_AUDIT_STB_OPERATION     "operations"
+#define TSDB_AUDIT_CTB_OPERATION     "t_operations_"
+#define TSDB_AUDIT_CTB_OPERATION_LEN 13
+
 typedef struct SSysDbTableSchema {
   const char*   name;
   const int32_t type;

include/common/tcommon.h

@@ -171,6 +171,7 @@ typedef enum EStreamType {
   STREAM_CHECKPOINT,
   STREAM_CREATE_CHILD_TABLE,
   STREAM_TRANS_STATE,
+  STREAM_MID_RETRIEVE,
 } EStreamType;
 
 #pragma pack(push, 1)

include/common/tglobal.h

@@ -211,6 +211,7 @@ extern int32_t tsUptimeInterval;
 
 extern bool    tsDisableStream;
 extern int64_t tsStreamBufferSize;
+extern int     tsStreamAggCnt;
 extern bool    tsFilterScalarMode;
 extern int32_t tsMaxStreamBackendCache;
 extern int32_t tsPQSortMemThreshold;
@@ -232,7 +233,7 @@ struct SConfig *taosGetCfg();
 void    taosSetAllDebugFlag(int32_t flag);
 void    taosSetDebugFlag(int32_t *pFlagPtr, const char *flagName, int32_t flagVal);
 void    taosLocalCfgForbiddenToChange(char *name, bool *forbidden);
-int8_t  taosGranted();
+int8_t  taosGranted(int8_t type);
 
 #ifdef __cplusplus
 }

include/common/tgrant.h

@@ -30,6 +30,9 @@ extern "C" {
 
 #define GRANT_HEART_BEAT_MIN 2
 #define GRANT_ACTIVE_CODE    "activeCode"
+#define GRANT_FLAG_ALL       (0x01)
+#define GRANT_FLAG_AUDIT     (0x02)
+#define GRANT_FLAG_VIEW      (0x04)
 
 typedef enum {
   TSDB_GRANT_ALL,
@@ -50,63 +53,39 @@ typedef enum {
   TSDB_GRANT_SUBSCRIPTION,
   TSDB_GRANT_AUDIT,
   TSDB_GRANT_CSV,
+  TSDB_GRANT_VIEW,
   TSDB_GRANT_MULTI_TIER,
   TSDB_GRANT_BACKUP_RESTORE,
 } EGrantType;
 
 int32_t grantCheck(EGrantType grant);
+int32_t grantCheckExpire(EGrantType grant);
 char*   tGetMachineId();
-#ifndef TD_UNIQ_GRANT
+#ifdef TD_UNIQ_GRANT
-int32_t grantAlterActiveCode(int32_t did, const char* old, const char* newer, char* out, int8_t type);
+int32_t grantCheckLE(EGrantType grant);
 #endif
 
 // #ifndef GRANTS_CFG
 #ifdef TD_ENTERPRISE
-#ifdef TD_UNIQ_GRANT
 #define GRANTS_SCHEMA                                                                             \
   static const SSysDbTableSchema grantsSchema[] = {                                               \
       {.name = "version", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},       \
       {.name = "expire_time", .bytes = 19 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},  \
       {.name = "service_time", .bytes = 19 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR}, \
       {.name = "expired", .bytes = 5 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},       \
-      {.name = "state", .bytes = 21 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},        \
+      {.name = "state", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},         \
       {.name = "timeseries", .bytes = 21 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},   \
       {.name = "dnodes", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},       \
       {.name = "cpu_cores", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},    \
   }
 #else
-#define GRANTS_SCHEMA                                                                                         \
-  static const SSysDbTableSchema grantsSchema[] = {                                                           \
-      {.name = "version", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},                   \
-      {.name = "expire_time", .bytes = 19 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},              \
-      {.name = "expired", .bytes = 5 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},                   \
-      {.name = "storage", .bytes = 21 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},                  \
-      {.name = "timeseries", .bytes = 21 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},               \
-      {.name = "databases", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},                \
-      {.name = "users", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},                    \
-      {.name = "accounts", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},                 \
-      {.name = "dnodes", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},                   \
-      {.name = "connections", .bytes = 11 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},              \
-      {.name = "streams", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},                   \
-      {.name = "cpu_cores", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},                 \
-      {.name = "speed", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},                     \
-      {.name = "querytime", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},                 \
-      {.name = "opc_da", .bytes = GRANTS_COL_MAX_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},   \
-      {.name = "opc_ua", .bytes = GRANTS_COL_MAX_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},   \
-      {.name = "pi", .bytes = GRANTS_COL_MAX_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},       \
-      {.name = "kafka", .bytes = GRANTS_COL_MAX_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},    \
-      {.name = "influxdb", .bytes = GRANTS_COL_MAX_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR}, \
-      {.name = "mqtt", .bytes = GRANTS_COL_MAX_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},     \
-  }
-#endif
-#else
 #define GRANTS_SCHEMA                                                                             \
   static const SSysDbTableSchema grantsSchema[] = {                                               \
       {.name = "version", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},       \
       {.name = "expire_time", .bytes = 19 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},  \
       {.name = "service_time", .bytes = 19 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR}, \
       {.name = "expired", .bytes = 5 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},       \
-      {.name = "state", .bytes = 21 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},        \
+      {.name = "state", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},         \
       {.name = "timeseries", .bytes = 21 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},   \
       {.name = "dnodes", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},       \
       {.name = "cpu_cores", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},    \

include/common/tmsg.h

@@ -431,7 +431,8 @@ typedef enum ENodeType {
   QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT,
   QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN,
   QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE,
-  QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL
+  QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL
 } ENodeType;
 
 typedef struct {
@@ -3638,6 +3639,7 @@ typedef struct {
   int64_t      timeout;
   STqOffsetVal reqOffset;
   int8_t       enableReplay;
+  int8_t       sourceExcluded;
 } SMqPollReq;
 
 int32_t tSerializeSMqPollReq(void* buf, int32_t bufLen, SMqPollReq* pReq);
@@ -3767,6 +3769,7 @@ typedef struct {
   int32_t      vgId;
   STqOffsetVal offset;
   int64_t      rows;
+  int64_t      ever;
 } OffsetRows;
 
 typedef struct {
@@ -3922,6 +3925,10 @@ int32_t tDeserializeSMqSeekReq(void* buf, int32_t bufLen, SMqSeekReq* pReq);
 
 #define SUBMIT_REQ_AUTO_CREATE_TABLE  0x1
 #define SUBMIT_REQ_COLUMN_DATA_FORMAT 0x2
+#define SUBMIT_REQ_FROM_FILE          0x4
+
+#define SOURCE_NULL  0
+#define SOURCE_TAOSX 1
 
 typedef struct {
   int32_t        flags;
@@ -3934,6 +3941,7 @@ typedef struct {
     SArray* aCol;
   };
   int64_t ctimeMs;
+  int8_t  source;
 } SSubmitTbData;
 
 typedef struct {

include/libs/executor/executor.h

@@ -197,6 +197,8 @@ int32_t qStreamPrepareScan(qTaskInfo_t tinfo, STqOffsetVal* pOffset, int8_t subT
 
 void qStreamSetOpen(qTaskInfo_t tinfo);
 
+void qStreamSetSourceExcluded(qTaskInfo_t tinfo, int8_t sourceExcluded);
+
 void qStreamExtractOffset(qTaskInfo_t tinfo, STqOffsetVal* pOffset);
 
 SMqMetaRsp* qStreamExtractMetaMsg(qTaskInfo_t tinfo);

include/libs/function/functionMgt.h

@@ -244,7 +244,7 @@ bool fmIsSkipScanCheckFunc(int32_t funcId);
 void getLastCacheDataType(SDataType* pType);
 SFunctionNode* createFunction(const char* pName, SNodeList* pParameterList);
 
-int32_t fmGetDistMethod(const SFunctionNode* pFunc, SFunctionNode** pPartialFunc, SFunctionNode** pMergeFunc);
+int32_t fmGetDistMethod(const SFunctionNode* pFunc, SFunctionNode** pPartialFunc, SFunctionNode** pMidFunc, SFunctionNode** pMergeFunc);
 
 typedef enum EFuncDataRequired {
   FUNC_DATA_REQUIRED_DATA_LOAD = 1,

include/libs/nodes/plannodes.h

@@ -257,6 +257,7 @@ typedef enum EWindowAlgorithm {
   SESSION_ALGO_STREAM_FINAL,
   SESSION_ALGO_STREAM_SINGLE,
   SESSION_ALGO_MERGE,
+  INTERVAL_ALGO_STREAM_MID,
 } EWindowAlgorithm;
 
 typedef struct SWindowLogicNode {
@@ -587,6 +588,7 @@ typedef SIntervalPhysiNode SMergeAlignedIntervalPhysiNode;
 typedef SIntervalPhysiNode SStreamIntervalPhysiNode;
 typedef SIntervalPhysiNode SStreamFinalIntervalPhysiNode;
 typedef SIntervalPhysiNode SStreamSemiIntervalPhysiNode;
+typedef SIntervalPhysiNode SStreamMidIntervalPhysiNode;
 
 typedef struct SFillPhysiNode {
   SPhysiNode  node;
@@ -713,8 +715,10 @@ typedef struct SSubplan {
   SNode*         pTagCond;
   SNode*         pTagIndexCond;
   bool           showRewrite;
-  int32_t        rowsThreshold;
+  bool           isView;
+  bool           isAudit;
   bool           dynamicRowThreshold;
+  int32_t        rowsThreshold;
 } SSubplan;
 
 typedef enum EExplainMode { EXPLAIN_MODE_DISABLE = 1, EXPLAIN_MODE_STATIC, EXPLAIN_MODE_ANALYZE } EExplainMode;

include/libs/parser/parser.h

@@ -86,8 +86,10 @@ typedef struct SParseContext {
   bool             enableSysInfo;
   bool             async;
   bool             hasInvisibleCol;
-  const char*      svrVer;
+  bool             isView;
+  bool             isAudit;
   bool             nodeOffline;
+  const char*      svrVer;
   SArray*          pTableMetaPos;    // sql table pos => catalog data pos
   SArray*          pTableVgroupPos;  // sql table pos => catalog data pos
   int64_t          allocatorId;

include/libs/planner/planner.h

@@ -32,6 +32,8 @@ typedef struct SPlanContext {
   bool        streamQuery;
   bool        rSmaQuery;
   bool        showRewrite;
+  bool        isView;
+  bool        isAudit;
   int8_t      triggerType;
   int64_t     watermark;
   int64_t     deleteMark;

include/libs/qcom/query.h

@@ -66,7 +66,11 @@ typedef enum {
 #define QUERY_RSP_POLICY_QUICK 1
 
 #define QUERY_MSG_MASK_SHOW_REWRITE() (1 << 0)
+#define QUERY_MSG_MASK_AUDIT()        (1 << 1)
+#define QUERY_MSG_MASK_VIEW()         (1 << 2)
 #define TEST_SHOW_REWRITE_MASK(m)     (((m) & QUERY_MSG_MASK_SHOW_REWRITE()) != 0)
+#define TEST_AUDIT_MASK(m)            (((m) & QUERY_MSG_MASK_AUDIT()) != 0)
+#define TEST_VIEW_MASK(m)             (((m) & QUERY_MSG_MASK_VIEW()) != 0)
 
 typedef struct STableComInfo {
   uint8_t  numOfTags;     // the number of tags in schema
@@ -338,6 +342,11 @@ extern int32_t (*queryProcessMsgRsp[TDMT_MAX])(void* output, char* msg, int32_t
 
 #define IS_SYS_DBNAME(_dbname) (IS_INFORMATION_SCHEMA_DB(_dbname) || IS_PERFORMANCE_SCHEMA_DB(_dbname))
 
+#define IS_AUDIT_DBNAME(_dbname)    ((*(_dbname) == 'a') && (0 == strcmp(_dbname, TSDB_AUDIT_DB)))
+#define IS_AUDIT_STB_NAME(_stbname) ((*(_stbname) == 'o') && (0 == strcmp(_stbname, TSDB_AUDIT_STB_OPERATION)))
+#define IS_AUDIT_CTB_NAME(_ctbname) \
+  ((*(_ctbname) == 't') && (0 == strncmp(_ctbname, TSDB_AUDIT_CTB_OPERATION, TSDB_AUDIT_CTB_OPERATION_LEN)))
+
 #define qFatal(...)                                                     \
   do {                                                                  \
     if (qDebugFlag & DEBUG_FATAL) {                                     \

include/libs/stream/tstream.h

@@ -463,7 +463,8 @@ struct SStreamTask {
   struct SStreamMeta* pMeta;
   SSHashObj*          pNameMap;
   void*               pBackend;
-  char                reserve[256];
+  int8_t              subtableWithoutMd5;
+  char                reserve[255];
 };
 
 typedef int32_t (*startComplete_fn_t)(struct SStreamMeta*);
@@ -532,7 +533,7 @@ int32_t tEncodeStreamEpInfo(SEncoder* pEncoder, const SStreamChildEpInfo* pInfo)
 int32_t tDecodeStreamEpInfo(SDecoder* pDecoder, SStreamChildEpInfo* pInfo);
 
 SStreamTask* tNewStreamTask(int64_t streamId, int8_t taskLevel, SEpSet* pEpset, bool fillHistory, int64_t triggerParam,
-                            SArray* pTaskList, bool hasFillhistory);
+                            SArray* pTaskList, bool hasFillhistory, int8_t subtableWithoutMd5);
 int32_t      tEncodeStreamTask(SEncoder* pEncoder, const SStreamTask* pTask);
 int32_t      tDecodeStreamTask(SDecoder* pDecoder, SStreamTask* pTask);
 void         tFreeStreamTask(SStreamTask* pTask);
@@ -747,7 +748,6 @@ int32_t tEncodeStreamDispatchReq(SEncoder* pEncoder, const SStreamDispatchReq* p
 int32_t tDecodeStreamDispatchReq(SDecoder* pDecoder, SStreamDispatchReq* pReq);
 
 int32_t tDecodeStreamRetrieveReq(SDecoder* pDecoder, SStreamRetrieveReq* pReq);
-void    tDeleteStreamRetrieveReq(SStreamRetrieveReq* pReq);
 void    tDeleteStreamDispatchReq(SStreamDispatchReq* pReq);
 
 typedef struct SStreamTaskCheckpointReq {
@@ -764,7 +764,7 @@ int32_t streamSetupScheduleTrigger(SStreamTask* pTask);
 int32_t streamProcessDispatchMsg(SStreamTask* pTask, SStreamDispatchReq* pReq, SRpcMsg* pMsg);
 int32_t streamProcessDispatchRsp(SStreamTask* pTask, SStreamDispatchRsp* pRsp, int32_t code);
 
-int32_t             streamProcessRetrieveReq(SStreamTask* pTask, SStreamRetrieveReq* pReq, SRpcMsg* pMsg);
+int32_t             streamProcessRetrieveReq(SStreamTask* pTask, SStreamRetrieveReq* pReq);
 SStreamChildEpInfo* streamTaskGetUpstreamTaskEpInfo(SStreamTask* pTask, int32_t taskId);
 
 void    streamTaskInputFail(SStreamTask* pTask);
@@ -843,7 +843,8 @@ SScanhistoryDataInfo streamScanHistoryData(SStreamTask* pTask, int64_t st);
 // stream task meta
 void         streamMetaInit();
 void         streamMetaCleanup();
-SStreamMeta* streamMetaOpen(const char* path, void* ahandle, FTaskExpand expandFunc, int32_t vgId, int64_t stage, startComplete_fn_t fn);
+SStreamMeta* streamMetaOpen(const char* path, void* ahandle, FTaskExpand expandFunc, int32_t vgId, int64_t stage,
+                            startComplete_fn_t fn);
 void         streamMetaClose(SStreamMeta* streamMeta);
 int32_t      streamMetaSaveTask(SStreamMeta* pMeta, SStreamTask* pTask);  // save to stream meta store
 int32_t      streamMetaRemoveTask(SStreamMeta* pMeta, STaskId* pKey);
@@ -893,6 +894,9 @@ int32_t buildCheckpointSourceRsp(SStreamCheckpointSourceReq* pReq, SRpcHandleInf
 
 SStreamTaskSM* streamCreateStateMachine(SStreamTask* pTask);
 void*          streamDestroyStateMachine(SStreamTaskSM* pSM);
+
+int32_t broadcastRetrieveMsg(SStreamTask* pTask, SStreamRetrieveReq* req);
+void    sendRetrieveRsp(SStreamRetrieveReq* pReq, SRpcMsg* pRsp);
 #ifdef __cplusplus
 }
 #endif

include/os/osThread.h

@@ -69,6 +69,19 @@ typedef pthread_key_t        TdThreadKey;
 
 #define taosThreadCleanupPush pthread_cleanup_push
 #define taosThreadCleanupPop  pthread_cleanup_pop
+#if !defined(WINDOWS)
+#if defined(_TD_DARWIN_64)  // MACOS
+#define taosThreadRwlockAttrSetKindNP(A, B) ((void)0)
+#else  // LINUX
+#if _XOPEN_SOURCE >= 500 || _POSIX_C_SOURCE >= 200809L
+#define taosThreadRwlockAttrSetKindNP(A, B) pthread_rwlockattr_setkind_np(A, B)
+#else
+#define taosThreadRwlockAttrSetKindNP(A, B) ((void)0)
+#endif
+#endif
+#else  // WINDOWS
+#define taosThreadRwlockAttrSetKindNP(A, B) ((void)0)
+#endif
 
 #if defined(WINDOWS) && !defined(__USE_PTHREAD)
 #define TD_PTHREAD_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER_FORBID

include/util/taoserror.h

@@ -575,8 +575,6 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_GRANT_OPT_EXPIRE_TOO_LARGE    TAOS_DEF_ERROR_CODE(0, 0x0821)
 #define TSDB_CODE_GRANT_DUPLICATED_ACTIVE       TAOS_DEF_ERROR_CODE(0, 0x0822)
 #define TSDB_CODE_GRANT_VIEW_LIMITED            TAOS_DEF_ERROR_CODE(0, 0x0823)
-#define TSDB_CODE_GRANT_CSV_LIMITED             TAOS_DEF_ERROR_CODE(0, 0x0824)
-#define TSDB_CODE_GRANT_AUDIT_LIMITED           TAOS_DEF_ERROR_CODE(0, 0x0825)
 
 // sync
 // #define TSDB_CODE_SYN_INVALID_CONFIG         TAOS_DEF_ERROR_CODE(0, 0x0900) // 2.x

include/util/tdef.h

@@ -287,6 +287,7 @@ typedef enum ELogicConditionType {
 #define TSDB_DNODE_VALUE_LEN  256
 
 #define TSDB_CLUSTER_VALUE_LEN   1000
+#define TSDB_GRANT_LOG_COL_LEN   15600
 
 #define TSDB_ACTIVE_KEY_LEN      109
 #define TSDB_CONN_ACTIVE_KEY_LEN 255

source/client/src/clientEnv.c

@@ -681,8 +681,9 @@ void taos_init_imp(void) {
   snprintf(logDirName, 64, "taoslog");
 #endif
   if (taosCreateLog(logDirName, 10, configDir, NULL, NULL, NULL, NULL, 1) != 0) {
-    // ignore create log failed, only print
     printf(" WARING: Create %s failed:%s. configDir=%s\n", logDirName, strerror(errno), configDir);
+    tscInitRes = -1;
+    return;
   }
 
   if (taosInitCfg(configDir, NULL, NULL, NULL, NULL, 1) != 0) {
@@ -750,8 +751,11 @@ int taos_options_imp(TSDB_OPTION option, const char *str) {
     tstrncpy(configDir, str, PATH_MAX);
     tscInfo("set cfg:%s to %s", configDir, str);
     return 0;
-  } else {
+  }
-    taos_init();  // initialize global config
+
+  // initialize global config
+  if (taos_init() != 0) {
+    return -1;
   }
 
   SConfig     *pCfg = taosGetCfg();

source/client/src/clientHb.c

@@ -843,7 +843,7 @@ int32_t hbGetExpiredViewInfo(SClientHbKey *connKey, struct SCatalog *pCatalog, S
     view->version = htonl(view->version);
   }
 
-  tscDebug("hb got %d expired view, valueLen:%lu", viewNum, sizeof(SViewVersion) * viewNum);
+  tscDebug("hb got %u expired view, valueLen:%lu", viewNum, sizeof(SViewVersion) * viewNum);
 
   if (NULL == req->info) {
     req->info = taosHashInit(64, hbKeyHashFunc, 1, HASH_ENTRY_LOCK);

source/client/src/clientImpl.c

@@ -1154,6 +1154,8 @@ static int32_t asyncExecSchQuery(SRequestObj* pRequest, SQuery* pQuery, SMetaDat
                         .mgmtEpSet = getEpSet_s(&pRequest->pTscObj->pAppInfo->mgmtEp),
                         .pAstRoot = pQuery->pRoot,
                         .showRewrite = pQuery->showRewrite,
+                        .isView = pWrapper->pParseCtx->isView,
+                        .isAudit = pWrapper->pParseCtx->isAudit,
                         .pMsg = pRequest->msgBuf,
                         .msgLen = ERROR_MSG_BUF_DEFAULT_SIZE,
                         .pUser = pRequest->pTscObj->user,

source/client/src/clientTmq.c

@@ -63,6 +63,7 @@ struct tmq_conf_t {
   int8_t         withTbName;
   int8_t         snapEnable;
   int8_t         replayEnable;
+  int8_t         sourceExcluded;   // do not consume, bit
   uint16_t       port;
   int32_t        autoCommitInterval;
   char*          ip;
@@ -82,6 +83,7 @@ struct tmq_t {
   int32_t        autoCommitInterval;
   int8_t         resetOffsetCfg;
   int8_t         replayEnable;
+  int8_t         sourceExcluded;   // do not consume, bit
   uint64_t       consumerId;
   tmq_commit_cb* commitCb;
   void*          commitCbUserParam;
@@ -385,6 +387,10 @@ tmq_conf_res_t tmq_conf_set(tmq_conf_t* conf, const char* key, const char* value
       return TMQ_CONF_INVALID;
     }
   }
+  if (strcasecmp(key, "msg.consume.excluded") == 0) {
+    conf->sourceExcluded = taosStr2int64(value);
+    return TMQ_CONF_OK;
+  }
 
   if (strcasecmp(key, "td.connect.db") == 0) {
     return TMQ_CONF_OK;
@@ -783,7 +789,6 @@ void tmqSendHbReq(void* param, void* tmrId) {
   req.consumerId = tmq->consumerId;
   req.epoch = tmq->epoch;
   taosRLockLatch(&tmq->lock);
-//  if(tmq->needReportOffsetRows){
   req.topics = taosArrayInit(taosArrayGetSize(tmq->clientTopics), sizeof(TopicOffsetRows));
   for(int i = 0; i < taosArrayGetSize(tmq->clientTopics); i++){
     SMqClientTopic* pTopic = taosArrayGet(tmq->clientTopics, i);
@@ -796,14 +801,14 @@ void tmqSendHbReq(void* param, void* tmrId) {
       OffsetRows* offRows = taosArrayReserve(data->offsetRows, 1);
       offRows->vgId = pVg->vgId;
       offRows->rows = pVg->numOfRows;
-        offRows->offset = pVg->offsetInfo.beginOffset;
+      offRows->offset = pVg->offsetInfo.endOffset;
+      offRows->ever   = pVg->offsetInfo.walVerEnd;
       char buf[TSDB_OFFSET_LEN] = {0};
       tFormatOffset(buf, TSDB_OFFSET_LEN, &offRows->offset);
-        tscInfo("consumer:0x%" PRIx64 ",report offset: vgId:%d, offset:%s, rows:%"PRId64, tmq->consumerId, offRows->vgId, buf, offRows->rows);
+      tscInfo("consumer:0x%" PRIx64 ",report offset, group:%s vgId:%d, offset:%s/%"PRId64", rows:%"PRId64,
+              tmq->consumerId, tmq->groupId, offRows->vgId, buf, offRows->ever, offRows->rows);
     }
   }
-//    tmq->needReportOffsetRows = false;
-//  }
   taosRUnLockLatch(&tmq->lock);
 
   int32_t tlen = tSerializeSMqHbReq(NULL, 0, &req);
@@ -1108,6 +1113,7 @@ tmq_t* tmq_consumer_new(tmq_conf_t* conf, char* errstr, int32_t errstrLen) {
   pTmq->commitCbUserParam = conf->commitCbUserParam;
   pTmq->resetOffsetCfg = conf->resetOffset;
   pTmq->replayEnable = conf->replayEnable;
+  pTmq->sourceExcluded = conf->sourceExcluded;
   if(conf->replayEnable){
     pTmq->autoCommit = false;
   }
@@ -1576,6 +1582,7 @@ void tmqBuildConsumeReqImpl(SMqPollReq* pReq, tmq_t* tmq, int64_t timeout, SMqCl
   pReq->useSnapshot = tmq->useSnapshot;
   pReq->reqId = generateRequestId();
   pReq->enableReplay = tmq->replayEnable;
+  pReq->sourceExcluded = tmq->sourceExcluded;
 }
 
 SMqMetaRspObj* tmqBuildMetaRspFromWrapper(SMqPollRspWrapper* pWrapper) {

source/common/src/systable.c

@@ -349,21 +349,21 @@ static const SSysDbTableSchema userCompactsDetailSchema[] = {
 };
 
 static const SSysDbTableSchema useGrantsFullSchema[] = {
-    {.name = "grant_name", .bytes = 32 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
+    {.name = "grant_name", .bytes = 32 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
-    {.name = "display_name", .bytes = 256 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
+    {.name = "display_name", .bytes = 256 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
-    {.name = "expire", .bytes = 32 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
+    {.name = "expire", .bytes = 32 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
-    {.name = "limits", .bytes = 512 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
+    {.name = "limits", .bytes = 512 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
 };
 
 static const SSysDbTableSchema useGrantsLogsSchema[] = {
-    {.name = "state", .bytes = 1536 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
+    {.name = "state", .bytes = 1536 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
-    {.name = "active", .bytes = 512 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
+    {.name = "active", .bytes = 512 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
-    {.name = "machine", .bytes = 9088 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
+    {.name = "machine", .bytes = TSDB_GRANT_LOG_COL_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
 };
 
 static const SSysDbTableSchema useMachinesSchema[] = {
     {.name = "id", .bytes = TSDB_CLUSTER_ID_LEN + 1 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
-    {.name = "machine", .bytes = 6016 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
+    {.name = "machine", .bytes = 7552 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
 };
 
 static const SSysTableMeta infosMeta[] = {

source/common/src/tglobal.c

@@ -265,6 +265,7 @@ bool    tsDisableStream = false;
 int64_t tsStreamBufferSize = 128 * 1024 * 1024;
 bool    tsFilterScalarMode = false;
 int     tsResolveFQDNRetryTime = 100;  // seconds
+int     tsStreamAggCnt = 1000;
 
 char   tsS3Endpoint[TSDB_FQDN_LEN] = "<endpoint>";
 char   tsS3AccessKey[TSDB_FQDN_LEN] = "<accesskey>";
@@ -750,6 +751,8 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
   if (cfgAddBool(pCfg, "disableStream", tsDisableStream, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER) != 0) return -1;
   if (cfgAddInt64(pCfg, "streamBufferSize", tsStreamBufferSize, 0, INT64_MAX, CFG_SCOPE_SERVER, CFG_DYN_NONE) != 0)
     return -1;
+  if (cfgAddInt64(pCfg, "streamAggCnt", tsStreamAggCnt, 2, INT32_MAX, CFG_SCOPE_SERVER, CFG_DYN_NONE) != 0)
+    return -1;
 
   if (cfgAddInt32(pCfg, "checkpointInterval", tsStreamCheckpointInterval, 60, 1200, CFG_SCOPE_SERVER,
                   CFG_DYN_ENT_SERVER) != 0)
@@ -1213,6 +1216,8 @@ static int32_t taosSetServerCfg(SConfig *pCfg) {
 
   tsDisableStream = cfgGetItem(pCfg, "disableStream")->bval;
   tsStreamBufferSize = cfgGetItem(pCfg, "streamBufferSize")->i64;
+  tsStreamAggCnt = cfgGetItem(pCfg, "streamAggCnt")->i32;
+  tsStreamBufferSize = cfgGetItem(pCfg, "streamBufferSize")->i64;
   tsStreamCheckpointInterval = cfgGetItem(pCfg, "checkpointInterval")->i32;
   tsSinkDataRate = cfgGetItem(pCfg, "streamSinkDataRate")->fval;
 
@@ -1801,4 +1806,17 @@ void taosSetAllDebugFlag(int32_t flag) {
   if (terrno == TSDB_CODE_CFG_NOT_FOUND) terrno = TSDB_CODE_SUCCESS;  // ignore not exist
 }
 
-int8_t taosGranted() { return atomic_load_8(&tsGrant); }
+int8_t taosGranted(int8_t type) {
+  switch (type) {
+    case TSDB_GRANT_ALL:
+      return atomic_load_8(&tsGrant) & GRANT_FLAG_ALL;
+    case TSDB_GRANT_AUDIT:
+      return atomic_load_8(&tsGrant) & GRANT_FLAG_AUDIT;
+    case TSDB_GRANT_VIEW:
+      return atomic_load_8(&tsGrant) & GRANT_FLAG_VIEW;
+    default:
+      ASSERTS(0, "undefined grant type:%" PRIi8, type);
+      break;
+  }
+  return 0;
+}

source/common/src/tgrant.c

@@ -19,5 +19,13 @@
 #ifndef _GRANT
 
 int32_t grantCheck(EGrantType grant) { return TSDB_CODE_SUCCESS; }
+int32_t grantCheckExpire(EGrantType grant) { return TSDB_CODE_SUCCESS; }
 
+#ifdef TD_UNIQ_GRANT
+int32_t grantCheckLE(EGrantType grant) { return TSDB_CODE_SUCCESS; }
+#endif
+#else
+#ifdef TD_UNIQ_GRANT
+int32_t grantCheckExpire(EGrantType grant) { return TSDB_CODE_SUCCESS; }
+#endif
 #endif

source/common/src/tmsg.c

@@ -6252,6 +6252,7 @@ int32_t tSerializeSMqHbReq(void *buf, int32_t bufLen, SMqHbReq *pReq) {
       if (tEncodeI32(&encoder, offRows->vgId) < 0) return -1;
       if (tEncodeI64(&encoder, offRows->rows) < 0) return -1;
       if (tEncodeSTqOffsetVal(&encoder, &offRows->offset) < 0) return -1;
+      if (tEncodeI64(&encoder, offRows->ever) < 0) return -1;
     }
   }
 
@@ -6289,6 +6290,7 @@ int32_t tDeserializeSMqHbReq(void *buf, int32_t bufLen, SMqHbReq *pReq) {
           if (tDecodeI32(&decoder, &offRows->vgId) < 0) return -1;
           if (tDecodeI64(&decoder, &offRows->rows) < 0) return -1;
           if (tDecodeSTqOffsetVal(&decoder, &offRows->offset) < 0) return -1;
+          if (tDecodeI64(&decoder, &offRows->ever) < 0) return -1;
         }
       }
     }
@@ -6600,6 +6602,7 @@ int32_t tSerializeSMqPollReq(void *buf, int32_t bufLen, SMqPollReq *pReq) {
   if (tEncodeI64(&encoder, pReq->timeout) < 0) return -1;
   if (tSerializeSTqOffsetVal(&encoder, &pReq->reqOffset) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->enableReplay) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->sourceExcluded) < 0) return -1;
 
   tEndEncode(&encoder);
 
@@ -6640,6 +6643,10 @@ int32_t tDeserializeSMqPollReq(void *buf, int32_t bufLen, SMqPollReq *pReq) {
     if (tDecodeI8(&decoder, &pReq->enableReplay) < 0) return -1;
   }
 
+  if (!tDecodeIsEnd(&decoder)) {
+    if (tDecodeI8(&decoder, &pReq->sourceExcluded) < 0) return -1;
+  }
+
   tEndDecode(&decoder);
 
   tDecoderClear(&decoder);
@@ -8663,6 +8670,7 @@ static int32_t tEncodeSSubmitTbData(SEncoder *pCoder, const SSubmitTbData *pSubm
     }
   }
   if (tEncodeI64(pCoder, pSubmitTbData->ctimeMs) < 0) return -1;
+  if (tEncodeI8(pCoder, pSubmitTbData->source) < 0) return -1;
 
   tEndEncode(pCoder);
   return 0;
@@ -8750,6 +8758,12 @@ static int32_t tDecodeSSubmitTbData(SDecoder *pCoder, SSubmitTbData *pSubmitTbDa
       goto _exit;
     }
   }
+  if (!tDecodeIsEnd(pCoder)) {
+    if (tDecodeI8(pCoder, &pSubmitTbData->source) < 0) {
+      code = TSDB_CODE_INVALID_MSG;
+      goto _exit;
+    }
+  }
 
   tEndDecode(pCoder);
 

source/dnode/mnode/impl/inc/mndDef.h

@@ -697,6 +697,9 @@ typedef struct {
 
   // 3.0.5.
   int64_t checkpointId;
+
+  int32_t indexForMultiAggBalance;
+  int8_t  subTableWithoutMd5;
   char    reserve[256];
 
 } SStreamObj;

source/dnode/mnode/impl/inc/mndGrant.h

@@ -36,10 +36,8 @@
   int32_t  mndGrantActionDelete(SSdb * pSdb, SGrantLogObj * pGrant);
   int32_t  mndGrantActionUpdate(SSdb * pSdb, SGrantLogObj * pOldGrant, SGrantLogObj * pNewGrant);
 
-#ifdef TD_UNIQ_GRANT
   int32_t grantAlterActiveCode(SMnode * pMnode, SGrantLogObj * pObj, const char *oldActive, const char *newActive,
                                char **mergeActive);
-#endif
 
   int32_t mndProcessConfigGrantReq(SMnode * pMnode, SRpcMsg * pReq, SMCfgClusterReq * pCfg);
   int32_t mndProcessUpdGrantLog(SMnode * pMnode, SRpcMsg * pReq, SArray * pMachines, SGrantState * pState);

source/dnode/mnode/impl/inc/mndStream.h

@@ -24,7 +24,7 @@ extern "C" {
 #endif
 
 #define MND_STREAM_RESERVE_SIZE 64
-#define MND_STREAM_VER_NUMBER   4
+#define MND_STREAM_VER_NUMBER   5
 
 #define MND_STREAM_CREATE_NAME      "stream-create"
 #define MND_STREAM_CHECKPOINT_NAME  "stream-checkpoint"

source/dnode/mnode/impl/inc/mndTrans.h

@@ -82,9 +82,11 @@ void    mndTransSetSerial(STrans *pTrans);
 void    mndTransSetParallel(STrans *pTrans);
 void    mndTransSetOper(STrans *pTrans, EOperType oper);
 int32_t mndTransCheckConflict(SMnode *pMnode, STrans *pTrans);
+#ifndef BUILD_NO_CALL
 static int32_t mndTrancCheckConflict(SMnode *pMnode, STrans *pTrans) {
     return mndTransCheckConflict(pMnode, pTrans);
 }
+#endif
 int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans);
 int32_t mndTransProcessRsp(SRpcMsg *pRsp);
 void    mndTransPullup(SMnode *pMnode);

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

@@ -409,7 +409,7 @@ int32_t mndProcessConfigClusterReq(SRpcMsg *pReq) {
   }
 
   {  // audit
-    auditRecord(pReq, pMnode->clusterId, "alterCluster", "", "", cfgReq.sql, cfgReq.sqlLen);
+    auditRecord(pReq, pMnode->clusterId, "alterCluster", "", "", cfgReq.sql, TMIN(cfgReq.sqlLen, GRANT_ACTIVE_HEAD_LEN << 1));
   }
 _exit:
   tFreeSMCfgClusterReq(&cfgReq);

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

@@ -107,7 +107,7 @@ static int32_t validateTopics(STrans *pTrans, const SArray *pTopicList, SMnode *
       goto FAILED;
     }
 
-    if ((terrno = grantCheck(TSDB_GRANT_SUBSCRIPTION)) < 0) {
+    if ((terrno = grantCheckExpire(TSDB_GRANT_SUBSCRIPTION)) < 0) {
       code = terrno;
       goto FAILED;
     }
@@ -240,7 +240,8 @@ static int32_t checkPrivilege(SMnode  *pMnode, SMqConsumerObj *pConsumer, SMqHbR
     }
     STopicPrivilege *data = taosArrayReserve(rsp->topicPrivileges, 1);
     strcpy(data->topic, topic);
-    if (mndCheckTopicPrivilege(pMnode, user, MND_OPER_SUBSCRIBE, pTopic) != 0 || grantCheck(TSDB_GRANT_SUBSCRIPTION) < 0) {
+    if (mndCheckTopicPrivilege(pMnode, user, MND_OPER_SUBSCRIBE, pTopic) != 0 ||
+        grantCheckExpire(TSDB_GRANT_SUBSCRIPTION) < 0) {
       data->noPrivilege = 1;
     } else {
       data->noPrivilege = 0;

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

@@ -85,6 +85,7 @@ int32_t tEncodeSStreamObj(SEncoder *pEncoder, const SStreamObj *pObj) {
 
   // 3.0.50 ver = 3
   if (tEncodeI64(pEncoder, pObj->checkpointId) < 0) return -1;
+  if (tEncodeI8(pEncoder, pObj->subTableWithoutMd5) < 0) return -1;
 
   if (tEncodeCStrWithLen(pEncoder, pObj->reserve, sizeof(pObj->reserve) - 1) < 0) return -1;
 
@@ -168,6 +169,10 @@ int32_t tDecodeSStreamObj(SDecoder *pDecoder, SStreamObj *pObj, int32_t sver) {
   if (sver >= 3) {
     if (tDecodeI64(pDecoder, &pObj->checkpointId) < 0) return -1;
   }
+
+  if (sver >= 5) {
+    if (tDecodeI8(pDecoder, &pObj->subTableWithoutMd5) < 0) return -1;
+  }
   if (tDecodeCStrTo(pDecoder, pObj->reserve) < 0) return -1;
 
   tEndDecode(pDecoder);
@@ -422,27 +427,12 @@ void *tDecodeSMqConsumerObj(const void *buf, SMqConsumerObj *pConsumer, int8_t s
   return (void *)buf;
 }
 
-// SMqConsumerEp *tCloneSMqConsumerEp(const SMqConsumerEp *pConsumerEpOld) {
+int32_t tEncodeOffRows(void **buf, SArray *offsetRows){
-//   SMqConsumerEp *pConsumerEpNew = taosMemoryMalloc(sizeof(SMqConsumerEp));
-//   if (pConsumerEpNew == NULL) return NULL;
-//   pConsumerEpNew->consumerId = pConsumerEpOld->consumerId;
-//   pConsumerEpNew->vgs = taosArrayDup(pConsumerEpOld->vgs, NULL);
-//   return pConsumerEpNew;
-// }
-//
-// void tDeleteSMqConsumerEp(void *data) {
-//   SMqConsumerEp *pConsumerEp = (SMqConsumerEp *)data;
-//   taosArrayDestroy(pConsumerEp->vgs);
-// }
-
-int32_t tEncodeSMqConsumerEp(void **buf, const SMqConsumerEp *pConsumerEp) {
   int32_t tlen = 0;
-  tlen += taosEncodeFixedI64(buf, pConsumerEp->consumerId);
+  int32_t szVgs = taosArrayGetSize(offsetRows);
-  tlen += taosEncodeArray(buf, pConsumerEp->vgs, (FEncode)tEncodeSMqVgEp);
-  int32_t szVgs = taosArrayGetSize(pConsumerEp->offsetRows);
   tlen += taosEncodeFixedI32(buf, szVgs);
   for (int32_t j = 0; j < szVgs; ++j) {
-    OffsetRows *offRows = taosArrayGet(pConsumerEp->offsetRows, j);
+    OffsetRows *offRows = taosArrayGet(offsetRows, j);
     tlen += taosEncodeFixedI32(buf, offRows->vgId);
     tlen += taosEncodeFixedI64(buf, offRows->rows);
     tlen += taosEncodeFixedI8(buf, offRows->offset.type);
@@ -454,29 +444,29 @@ int32_t tEncodeSMqConsumerEp(void **buf, const SMqConsumerEp *pConsumerEp) {
     } else {
       // do nothing
     }
+    tlen += taosEncodeFixedI64(buf, offRows->ever);
   }
-  // #if 0
+
-  //   int32_t sz = taosArrayGetSize(pConsumerEp->vgs);
-  //   tlen += taosEncodeFixedI32(buf, sz);
-  //   for (int32_t i = 0; i < sz; i++) {
-  //     SMqVgEp *pVgEp = taosArrayGetP(pConsumerEp->vgs, i);
-  //     tlen += tEncodeSMqVgEp(buf, pVgEp);
-  //   }
-  // #endif
   return tlen;
 }
 
-void *tDecodeSMqConsumerEp(const void *buf, SMqConsumerEp *pConsumerEp, int8_t sver) {
+int32_t tEncodeSMqConsumerEp(void **buf, const SMqConsumerEp *pConsumerEp) {
-  buf = taosDecodeFixedI64(buf, &pConsumerEp->consumerId);
+  int32_t tlen = 0;
-  buf = taosDecodeArray(buf, &pConsumerEp->vgs, (FDecode)tDecodeSMqVgEp, sizeof(SMqVgEp), sver);
+  tlen += taosEncodeFixedI64(buf, pConsumerEp->consumerId);
-  if (sver > 1) {
+  tlen += taosEncodeArray(buf, pConsumerEp->vgs, (FEncode)tEncodeSMqVgEp);
+
+
+  return tlen + tEncodeOffRows(buf, pConsumerEp->offsetRows);
+}
+
+void *tDecodeOffRows(const void *buf, SArray **offsetRows, int8_t sver){
   int32_t szVgs = 0;
   buf = taosDecodeFixedI32(buf, &szVgs);
   if (szVgs > 0) {
-      pConsumerEp->offsetRows = taosArrayInit(szVgs, sizeof(OffsetRows));
+    *offsetRows = taosArrayInit(szVgs, sizeof(OffsetRows));
-      if (NULL == pConsumerEp->offsetRows) return NULL;
+    if (NULL == *offsetRows) return NULL;
     for (int32_t j = 0; j < szVgs; ++j) {
-        OffsetRows *offRows = taosArrayReserve(pConsumerEp->offsetRows, 1);
+      OffsetRows *offRows = taosArrayReserve(*offsetRows, 1);
       buf = taosDecodeFixedI32(buf, &offRows->vgId);
       buf = taosDecodeFixedI64(buf, &offRows->rows);
       buf = taosDecodeFixedI8(buf, &offRows->offset.type);
@@ -488,19 +478,20 @@ void *tDecodeSMqConsumerEp(const void *buf, SMqConsumerEp *pConsumerEp, int8_t s
       } else {
         // do nothing
       }
+      if(sver > 2){
+        buf = taosDecodeFixedI64(buf, &offRows->ever);
       }
     }
   }
-  // #if 0
+  return (void *)buf;
-  //   int32_t sz;
+}
-  //   buf = taosDecodeFixedI32(buf, &sz);
+
-  //   pConsumerEp->vgs = taosArrayInit(sz, sizeof(void *));
+void *tDecodeSMqConsumerEp(const void *buf, SMqConsumerEp *pConsumerEp, int8_t sver) {
-  //   for (int32_t i = 0; i < sz; i++) {
+  buf = taosDecodeFixedI64(buf, &pConsumerEp->consumerId);
-  //     SMqVgEp *pVgEp = taosMemoryMalloc(sizeof(SMqVgEp));
+  buf = taosDecodeArray(buf, &pConsumerEp->vgs, (FDecode)tDecodeSMqVgEp, sizeof(SMqVgEp), sver);
-  //     buf = tDecodeSMqVgEp(buf, pVgEp);
+  if (sver > 1) {
-  //     taosArrayPush(pConsumerEp->vgs, &pVgEp);
+    buf = tDecodeOffRows(buf, &pConsumerEp->offsetRows, sver);
-  //   }
+  }
-  // #endif
 
   return (void *)buf;
 }
@@ -596,22 +587,7 @@ int32_t tEncodeSubscribeObj(void **buf, const SMqSubscribeObj *pSub) {
   tlen += taosEncodeArray(buf, pSub->unassignedVgs, (FEncode)tEncodeSMqVgEp);
   tlen += taosEncodeString(buf, pSub->dbName);
 
-  int32_t szVgs = taosArrayGetSize(pSub->offsetRows);
+  tlen += tEncodeOffRows(buf, pSub->offsetRows);
-  tlen += taosEncodeFixedI32(buf, szVgs);
-  for (int32_t j = 0; j < szVgs; ++j) {
-    OffsetRows *offRows = taosArrayGet(pSub->offsetRows, j);
-    tlen += taosEncodeFixedI32(buf, offRows->vgId);
-    tlen += taosEncodeFixedI64(buf, offRows->rows);
-    tlen += taosEncodeFixedI8(buf, offRows->offset.type);
-    if (offRows->offset.type == TMQ_OFFSET__SNAPSHOT_DATA || offRows->offset.type == TMQ_OFFSET__SNAPSHOT_META) {
-      tlen += taosEncodeFixedI64(buf, offRows->offset.uid);
-      tlen += taosEncodeFixedI64(buf, offRows->offset.ts);
-    } else if (offRows->offset.type == TMQ_OFFSET__LOG) {
-      tlen += taosEncodeFixedI64(buf, offRows->offset.version);
-    } else {
-      // do nothing
-    }
-  }
   tlen += taosEncodeString(buf, pSub->qmsg);
   return tlen;
 }
@@ -639,26 +615,7 @@ void *tDecodeSubscribeObj(const void *buf, SMqSubscribeObj *pSub, int8_t sver) {
   buf = taosDecodeStringTo(buf, pSub->dbName);
 
   if (sver > 1) {
-    int32_t szVgs = 0;
+    buf = tDecodeOffRows(buf, &pSub->offsetRows, sver);
-    buf = taosDecodeFixedI32(buf, &szVgs);
-    if (szVgs > 0) {
-      pSub->offsetRows = taosArrayInit(szVgs, sizeof(OffsetRows));
-      if (NULL == pSub->offsetRows) return NULL;
-      for (int32_t j = 0; j < szVgs; ++j) {
-        OffsetRows *offRows = taosArrayReserve(pSub->offsetRows, 1);
-        buf = taosDecodeFixedI32(buf, &offRows->vgId);
-        buf = taosDecodeFixedI64(buf, &offRows->rows);
-        buf = taosDecodeFixedI8(buf, &offRows->offset.type);
-        if (offRows->offset.type == TMQ_OFFSET__SNAPSHOT_DATA || offRows->offset.type == TMQ_OFFSET__SNAPSHOT_META) {
-          buf = taosDecodeFixedI64(buf, &offRows->offset.uid);
-          buf = taosDecodeFixedI64(buf, &offRows->offset.ts);
-        } else if (offRows->offset.type == TMQ_OFFSET__LOG) {
-          buf = taosDecodeFixedI64(buf, &offRows->offset.version);
-        } else {
-          // do nothing
-        }
-      }
-    }
     buf = taosDecodeString(buf, &pSub->qmsg);
   } else {
     pSub->qmsg = taosStrdup("");

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

@@ -141,7 +141,7 @@ static int32_t mndCreateDefaultDnode(SMnode *pMnode) {
     memcpy(dnodeObj.machineId, machineId, TSDB_MACHINE_ID_LEN);
     taosMemoryFreeClear(machineId);
   } else {
-#ifdef TD_UNIQ_GRANT
+#ifdef TD_ENTERPRISE
     terrno = TSDB_CODE_DNODE_NO_MACHINE_CODE;
     goto _OVER;
 #endif

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

@@ -79,11 +79,6 @@ char   *tGetMachineId() { return NULL; };
 int32_t dmProcessGrantReq(void *pInfo, SRpcMsg *pMsg) { return TSDB_CODE_SUCCESS; }
 int32_t dmProcessGrantNotify(void *pInfo, SRpcMsg *pMsg) { return TSDB_CODE_SUCCESS; }
 int32_t mndProcessConfigGrantReq(SMnode *pMnode, SRpcMsg *pReq, SMCfgClusterReq *pCfg) { return 0; }
-#else 
-#ifndef TD_UNIQ_GRANT
-char   *tGetMachineId() { return NULL; };
-int32_t mndProcessConfigGrantReq(SMnode *pMnode, SRpcMsg *pReq, SMCfgClusterReq *pCfg) { return 0; }
-#endif
 #endif
 
 void mndGenerateMachineCode() { grantParseParameter(); }

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

@@ -14,22 +14,19 @@
  */
 
 #include "mndScheduler.h"
-#include "tmisce.h"
-#include "mndMnode.h"
 #include "mndDb.h"
+#include "mndMnode.h"
 #include "mndSnode.h"
 #include "mndVgroup.h"
 #include "parser.h"
 #include "tcompare.h"
+#include "tmisce.h"
 #include "tname.h"
 #include "tuuid.h"
 
 #define SINK_NODE_LEVEL (0)
 extern bool tsDeployOnSnode;
 
-static int32_t doAddSinkTask(SStreamObj* pStream, SArray* pTaskList, SMnode* pMnode, int32_t vgId, SVgObj* pVgroup,
-                             SEpSet* pEpset, bool isFillhistory);
-
 int32_t mndConvertRsmaTask(char** pDst, int32_t* pDstLen, const char* ast, int64_t uid, int8_t triggerType,
                            int64_t watermark, int64_t deleteMark) {
   SNode*      pAst = NULL;
@@ -89,6 +86,8 @@ END:
 int32_t mndSetSinkTaskInfo(SStreamObj* pStream, SStreamTask* pTask) {
   STaskOutputInfo* pInfo = &pTask->outputInfo;
 
+  mDebug("mndSetSinkTaskInfo to sma or table, taskId:%s", pTask->id.idStr);
+
   if (pStream->smaId != 0) {
     pInfo->type = TASK_OUTPUT__SMA;
     pInfo->smaSink.smaId = pStream->smaId;
@@ -157,12 +156,7 @@ int32_t mndAssignStreamTaskToVgroup(SMnode* pMnode, SStreamTask* pTask, SSubplan
 
   plan->execNode.nodeId = pTask->info.nodeId;
   plan->execNode.epSet = pTask->info.epSet;
-  if (qSubPlanToString(plan, &pTask->exec.qmsg, &msgLen) < 0) {
+  return qSubPlanToString(plan, &pTask->exec.qmsg, &msgLen);
-    terrno = TSDB_CODE_QRY_INVALID_INPUT;
-    return -1;
-  }
-
-  return 0;
 }
 
 SSnodeObj* mndSchedFetchOneSnode(SMnode* pMnode) {
@@ -184,32 +178,79 @@ int32_t mndAssignStreamTaskToSnode(SMnode* pMnode, SStreamTask* pTask, SSubplan*
   plan->execNode.epSet = pTask->info.epSet;
   mDebug("s-task:0x%x set the agg task to snode:%d", pTask->id.taskId, SNODE_HANDLE);
 
-  if (qSubPlanToString(plan, &pTask->exec.qmsg, &msgLen) < 0) {
+  return qSubPlanToString(plan, &pTask->exec.qmsg, &msgLen);
-    terrno = TSDB_CODE_QRY_INVALID_INPUT;
-    return -1;
-  }
-  return 0;
 }
 
-// todo random choose a node to do compute
+// random choose a node to do compute
-SVgObj* mndSchedFetchOneVg(SMnode* pMnode, int64_t dbUid) {
+SVgObj* mndSchedFetchOneVg(SMnode* pMnode, SStreamObj* pStream) {
+  SDbObj* pDbObj = mndAcquireDb(pMnode, pStream->sourceDb);
+  if (pDbObj == NULL) {
+    terrno = TSDB_CODE_QRY_INVALID_INPUT;
+    return NULL;
+  }
+
+  if (pStream->indexForMultiAggBalance == -1) {
+    taosSeedRand(taosSafeRand());
+    pStream->indexForMultiAggBalance = taosRand() % pDbObj->cfg.numOfVgroups;
+  }
+
+  int32_t index = 0;
   void*   pIter = NULL;
   SVgObj* pVgroup = NULL;
   while (1) {
     pIter = sdbFetch(pMnode->pSdb, SDB_VGROUP, pIter, (void**)&pVgroup);
     if (pIter == NULL) break;
-    if (pVgroup->dbUid != dbUid) {
+    if (pVgroup->dbUid != pStream->sourceDbUid) {
       sdbRelease(pMnode->pSdb, pVgroup);
       continue;
     }
+    if (index++ == pStream->indexForMultiAggBalance) {
+      pStream->indexForMultiAggBalance++;
+      pStream->indexForMultiAggBalance %= pDbObj->cfg.numOfVgroups;
       sdbCancelFetch(pMnode->pSdb, pIter);
-    return pVgroup;
+      break;
     }
+    sdbRelease(pMnode->pSdb, pVgroup);
+  }
+  sdbRelease(pMnode->pSdb, pDbObj);
+
   return pVgroup;
 }
 
+static int32_t doAddSinkTask(SStreamObj* pStream, SMnode* pMnode, SVgObj* pVgroup, SEpSet* pEpset, bool isFillhistory) {
+  int64_t  uid = (isFillhistory) ? pStream->hTaskUid : pStream->uid;
+  SArray** pTaskList = (isFillhistory) ? taosArrayGetLast(pStream->pHTasksList) : taosArrayGetLast(pStream->tasks);
+
+  SStreamTask* pTask = tNewStreamTask(uid, TASK_LEVEL__SINK, pEpset, isFillhistory, 0, *pTaskList,
+                                      pStream->conf.fillHistory, pStream->subTableWithoutMd5);
+  if (pTask == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
+  }
+
+  mDebug("doAddSinkTask taskId:%s, vgId:%d, isFillHistory:%d", pTask->id.idStr, pVgroup->vgId, isFillhistory);
+
+  pTask->info.nodeId = pVgroup->vgId;
+  pTask->info.epSet = mndGetVgroupEpset(pMnode, pVgroup);
+  return mndSetSinkTaskInfo(pStream, pTask);
+}
+
+static int32_t doAddSinkTaskToVg(SMnode* pMnode, SStreamObj* pStream, SEpSet* pEpset, SVgObj* vgObj) {
+  int32_t code = doAddSinkTask(pStream, pMnode, vgObj, pEpset, false);
+  if (code != 0) {
+    return code;
+  }
+  if (pStream->conf.fillHistory) {
+    code = doAddSinkTask(pStream, pMnode, vgObj, pEpset, true);
+    if (code != 0) {
+      return code;
+    }
+  }
+  return TDB_CODE_SUCCESS;
+}
+
 // create sink node for each vgroup.
-int32_t doAddShuffleSinkTask(SMnode* pMnode, SArray* pTaskList, SStreamObj* pStream, SEpSet* pEpset, bool fillHistory) {
+static int32_t doAddShuffleSinkTask(SMnode* pMnode, SStreamObj* pStream, SEpSet* pEpset) {
   SSdb* pSdb = pMnode->pSdb;
   void* pIter = NULL;
 
@@ -225,27 +266,16 @@ int32_t doAddShuffleSinkTask(SMnode* pMnode, SArray* pTaskList, SStreamObj* pStr
       continue;
     }
 
-    doAddSinkTask(pStream, pTaskList, pMnode, pVgroup->vgId, pVgroup, pEpset, fillHistory);
+    int32_t code = doAddSinkTaskToVg(pMnode, pStream, pEpset, pVgroup);
+    if (code != 0) {
+      sdbRelease(pSdb, pVgroup);
+      return code;
+    }
+
     sdbRelease(pSdb, pVgroup);
   }
 
-  return 0;
+  return TDB_CODE_SUCCESS;
-}
-
-int32_t doAddSinkTask(SStreamObj* pStream, SArray* pTaskList, SMnode* pMnode, int32_t vgId, SVgObj* pVgroup,
-                      SEpSet* pEpset, bool isFillhistory) {
-  int64_t      uid = (isFillhistory) ? pStream->hTaskUid : pStream->uid;
-  SStreamTask* pTask =
-      tNewStreamTask(uid, TASK_LEVEL__SINK, pEpset, isFillhistory, 0, pTaskList, pStream->conf.fillHistory);
-  if (pTask == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  pTask->info.nodeId = vgId;
-  pTask->info.epSet = mndGetVgroupEpset(pMnode, pVgroup);
-  mndSetSinkTaskInfo(pStream, pTask);
-  return 0;
 }
 
 static int64_t getVgroupLastVer(const SArray* pList, int32_t vgId) {
@@ -285,49 +315,39 @@ static void streamTaskSetDataRange(SStreamTask* pTask, int64_t skey, SArray* pVe
     pRange->range.minVer = latestVer + 1;
     pRange->range.maxVer = INT64_MAX;
 
-    mDebug("add source task 0x%x timeWindow:%" PRId64 "-%" PRId64 " verRange:%" PRId64 "-%" PRId64,
+    mDebug("add source task 0x%x timeWindow:%" PRId64 "-%" PRId64 " verRange:%" PRId64 "-%" PRId64, pTask->id.taskId,
-           pTask->id.taskId, pWindow->skey, pWindow->ekey, pRange->range.minVer, pRange->range.maxVer);
+           pWindow->skey, pWindow->ekey, pRange->range.minVer, pRange->range.maxVer);
   }
 }
 
-static int32_t addSourceTask(SMnode* pMnode, SVgObj* pVgroup, SArray* pTaskList, SArray* pSinkTaskList,
+static SStreamTask* buildSourceTask(SStreamObj* pStream, SEpSet* pEpset, bool isFillhistory, bool useTriggerParam) {
-                             SStreamObj* pStream, SSubplan* plan, uint64_t uid, SEpSet* pEpset, int64_t skey,
+  uint64_t uid = (isFillhistory) ? pStream->hTaskUid : pStream->uid;
-                             SArray* pVerList, bool fillHistory, bool hasExtraSink, bool hasFillHistory) {
+  SArray** pTaskList = (isFillhistory) ? taosArrayGetLast(pStream->pHTasksList) : taosArrayGetLast(pStream->tasks);
-  int64_t t = pStream->conf.triggerParam;
+
-  SStreamTask* pTask = tNewStreamTask(uid, TASK_LEVEL__SOURCE, pEpset, fillHistory, t, pTaskList, hasFillHistory);
+  SStreamTask* pTask =
+      tNewStreamTask(uid, TASK_LEVEL__SOURCE, pEpset, isFillhistory, useTriggerParam ? pStream->conf.triggerParam : 0,
+                     *pTaskList, pStream->conf.fillHistory, pStream->subTableWithoutMd5);
   if (pTask == NULL) {
-    return terrno;
+    return NULL;
   }
 
-  streamTaskSetDataRange(pTask, skey, pVerList, pVgroup->vgId);
+  return pTask;
-
-  // sink or dispatch
-  if (hasExtraSink) {
-    mndAddDispatcherForInternalTask(pMnode, pStream, pSinkTaskList, pTask);
-  } else {
-    mndSetSinkTaskInfo(pStream, pTask);
 }
 
-  if (mndAssignStreamTaskToVgroup(pMnode, pTask, plan, pVgroup) < 0) {
+static void addNewTaskList(SStreamObj* pStream) {
-    return terrno;
-  }
-
-  for(int32_t i = 0; i < taosArrayGetSize(pSinkTaskList); ++i) {
-    SStreamTask* pSinkTask = taosArrayGetP(pSinkTaskList, i);
-    streamTaskSetUpstreamInfo(pSinkTask, pTask);
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static SArray* addNewTaskList(SArray* pTasksList) {
   SArray* pTaskList = taosArrayInit(0, POINTER_BYTES);
-  taosArrayPush(pTasksList, &pTaskList);
+  taosArrayPush(pStream->tasks, &pTaskList);
-  return pTaskList;
+  if (pStream->conf.fillHistory) {
+    pTaskList = taosArrayInit(0, POINTER_BYTES);
+    taosArrayPush(pStream->pHTasksList, &pTaskList);
+  }
 }
 
 // set the history task id
-static void setHTasksId(SArray* pTaskList, const SArray* pHTaskList) {
+static void setHTasksId(SStreamObj* pStream) {
+  SArray* pTaskList = *(SArray**)taosArrayGetLast(pStream->tasks);
+  SArray* pHTaskList = *(SArray**)taosArrayGetLast(pStream->pHTasksList);
+
   for (int32_t i = 0; i < taosArrayGetSize(pTaskList); ++i) {
     SStreamTask** pStreamTask = taosArrayGet(pTaskList, i);
     SStreamTask** pHTask = taosArrayGet(pHTaskList, i);
@@ -343,199 +363,63 @@ static void setHTasksId(SArray* pTaskList, const SArray* pHTaskList) {
   }
 }
 
-static int32_t addSourceTasksForOneLevelStream(SMnode* pMnode, const SQueryPlan* pPlan, SStreamObj* pStream,
+static int32_t doAddSourceTask(SMnode* pMnode, SSubplan* plan, SStreamObj* pStream, SEpSet* pEpset, int64_t skey,
-                                               SEpSet* pEpset, bool hasExtraSink, int64_t skey, SArray* pVerList) {
+                               SArray* pVerList, SVgObj* pVgroup, bool isFillhistory, bool useTriggerParam) {
-  // create exec stream task, since only one level, the exec task is also the source task
-  SArray* pTaskList = addNewTaskList(pStream->tasks);
-  SSdb*   pSdb = pMnode->pSdb;
-
-  SArray* pHTaskList = NULL;
-  if (pStream->conf.fillHistory) {
-    pHTaskList = addNewTaskList(pStream->pHTasksList);
-  }
-
-  SNodeListNode* inner = (SNodeListNode*)nodesListGetNode(pPlan->pSubplans, 0);
-  if (LIST_LENGTH(inner->pNodeList) != 1) {
-    terrno = TSDB_CODE_QRY_INVALID_INPUT;
-    return -1;
-  }
-
-  SSubplan* plan = (SSubplan*)nodesListGetNode(inner->pNodeList, 0);
-  if (plan->subplanType != SUBPLAN_TYPE_SCAN) {
-    terrno = TSDB_CODE_QRY_INVALID_INPUT;
-    return -1;
-  }
-
-  void* pIter = NULL;
-  while (1) {
-    SVgObj* pVgroup;
-    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void**)&pVgroup);
-    if (pIter == NULL) {
-      break;
-    }
-
-    if (!mndVgroupInDb(pVgroup, pStream->sourceDbUid)) {
-      sdbRelease(pSdb, pVgroup);
-      continue;
-    }
-
   // new stream task
-    SArray** pSinkTaskList = taosArrayGet(pStream->tasks, SINK_NODE_LEVEL);
+  SStreamTask* pTask = buildSourceTask(pStream, pEpset, isFillhistory, useTriggerParam);
-    int32_t  code = addSourceTask(pMnode, pVgroup, pTaskList, *pSinkTaskList, pStream, plan, pStream->uid, pEpset, skey,
-                                  pVerList, false, hasExtraSink, pStream->conf.fillHistory);
-    if (code != TSDB_CODE_SUCCESS) {
-      sdbRelease(pSdb, pVgroup);
-      return -1;
-    }
-
-    if (pStream->conf.fillHistory) {
-      SArray** pHSinkTaskList = taosArrayGet(pStream->pHTasksList, SINK_NODE_LEVEL);
-      code = addSourceTask(pMnode, pVgroup, pHTaskList, *pHSinkTaskList, pStream, plan, pStream->hTaskUid, pEpset, skey,
-                           pVerList, true, hasExtraSink, true);
-    }
-
-    sdbRelease(pSdb, pVgroup);
-    if (code != TSDB_CODE_SUCCESS) {
-      return -1;
-    }
-  }
-
-  if (pStream->conf.fillHistory) {
-    setHTasksId(pTaskList, pHTaskList);
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t addSourceTaskForMultiLevelStream(SArray* pTaskList, bool isFillhistory, int64_t uid,
-                                                SStreamTask* pDownstreamTask, SMnode* pMnode, SSubplan* pPlan,
-                                                SVgObj* pVgroup, SEpSet* pEpset, int64_t skey, SArray* pVerList,
-                                                bool hasFillHistory) {
-  SStreamTask* pTask = tNewStreamTask(uid, TASK_LEVEL__SOURCE, pEpset, isFillhistory, 0, pTaskList, hasFillHistory);
   if (pTask == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    return terrno;
   }
+  mDebug("doAddSourceTask taskId:%s, vgId:%d, isFillHistory:%d", pTask->id.idStr, pVgroup->vgId, isFillhistory);
 
   streamTaskSetDataRange(pTask, skey, pVerList, pVgroup->vgId);
 
-  // all the source tasks dispatch result to a single agg node.
+  int32_t code = mndAssignStreamTaskToVgroup(pMnode, pTask, plan, pVgroup);
-  streamTaskSetFixedDownstreamInfo(pTask, pDownstreamTask);
+  if (code != 0) {
-  if (mndAssignStreamTaskToVgroup(pMnode, pTask, pPlan, pVgroup) < 0) {
+    terrno = code;
-    return -1;
+    return terrno;
+  }
+  return TDB_CODE_SUCCESS;
 }
 
-  return streamTaskSetUpstreamInfo(pDownstreamTask, pTask);
+static SSubplan* getScanSubPlan(const SQueryPlan* pPlan) {
-}
+  int32_t        numOfPlanLevel = LIST_LENGTH(pPlan->pSubplans);
-
+  SNodeListNode* inner = (SNodeListNode*)nodesListGetNode(pPlan->pSubplans, numOfPlanLevel - 1);
-static int32_t doAddAggTask(uint64_t uid, SArray* pTaskList, SArray* pSinkNodeList, SMnode* pMnode, SStreamObj* pStream,
+  if (LIST_LENGTH(inner->pNodeList) != 1) {
-                            SEpSet* pEpset, bool fillHistory, SStreamTask** pAggTask, bool hasFillhistory) {
-  *pAggTask = tNewStreamTask(uid, TASK_LEVEL__AGG, pEpset, fillHistory, pStream->conf.triggerParam, pTaskList, hasFillhistory);
-  if (*pAggTask == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  // dispatch
-  if (mndAddDispatcherForInternalTask(pMnode, pStream, pSinkNodeList, *pAggTask) < 0) {
-    return -1;
-  }
-
-  return 0;
-}
-
-static int32_t addAggTask(SStreamObj* pStream, SMnode* pMnode, SQueryPlan* pPlan, SEpSet* pEpset,
-                          SStreamTask** pAggTask, SStreamTask** pHAggTask) {
-  SArray* pAggTaskList = addNewTaskList(pStream->tasks);
-  SSdb*   pSdb = pMnode->pSdb;
-
-  SNodeListNode* pInnerNode = (SNodeListNode*)nodesListGetNode(pPlan->pSubplans, 0);
-  SSubplan*      plan = (SSubplan*)nodesListGetNode(pInnerNode->pNodeList, 0);
-  if (plan->subplanType != SUBPLAN_TYPE_MERGE) {
     terrno = TSDB_CODE_QRY_INVALID_INPUT;
-    return -1;
+    return NULL;
   }
 
-  *pAggTask = NULL;
-  SArray* pSinkNodeList = taosArrayGetP(pStream->tasks, SINK_NODE_LEVEL);
-
-  int32_t code = doAddAggTask(pStream->uid, pAggTaskList, pSinkNodeList, pMnode, pStream, pEpset, false, pAggTask,
-                              pStream->conf.fillHistory);
-  if (code != TSDB_CODE_SUCCESS) {
-    return -1;
-  }
-
-  SVgObj*    pVgroup = NULL;
-  SSnodeObj* pSnode = NULL;
-
-  if (tsDeployOnSnode) {
-    pSnode = mndSchedFetchOneSnode(pMnode);
-    if (pSnode == NULL) {
-      pVgroup = mndSchedFetchOneVg(pMnode, pStream->sourceDbUid);
-    }
-  } else {
-    pVgroup = mndSchedFetchOneVg(pMnode, pStream->sourceDbUid);
-  }
-
-  if (pSnode != NULL) {
-    code = mndAssignStreamTaskToSnode(pMnode, *pAggTask, plan, pSnode);
-  } else {
-    code = mndAssignStreamTaskToVgroup(pMnode, *pAggTask, plan, pVgroup);
-  }
-
-  if (pStream->conf.fillHistory) {
-    SArray* pHAggTaskList = addNewTaskList(pStream->pHTasksList);
-    SArray* pHSinkNodeList = taosArrayGetP(pStream->pHTasksList, SINK_NODE_LEVEL);
-
-    *pHAggTask = NULL;
-    code = doAddAggTask(pStream->hTaskUid, pHAggTaskList, pHSinkNodeList, pMnode, pStream, pEpset, pStream->conf.fillHistory,
-                        pHAggTask, pStream->conf.fillHistory);
-    if (code != TSDB_CODE_SUCCESS) {
-      if (pSnode != NULL) {
-        sdbRelease(pSdb, pSnode);
-      } else {
-        sdbRelease(pSdb, pVgroup);
-      }
-      return code;
-    }
-
-    if (pSnode != NULL) {
-      code = mndAssignStreamTaskToSnode(pMnode, *pHAggTask, plan, pSnode);
-    } else {
-      code = mndAssignStreamTaskToVgroup(pMnode, *pHAggTask, plan, pVgroup);
-    }
-
-    setHTasksId(pAggTaskList, pHAggTaskList);
-  }
-
-  if (pSnode != NULL) {
-    sdbRelease(pSdb, pSnode);
-  } else {
-    sdbRelease(pSdb, pVgroup);
-  }
-
-  return code;
-}
-
-static int32_t addSourceTasksForMultiLevelStream(SMnode* pMnode, SQueryPlan* pPlan, SStreamObj* pStream,
-                                                 SStreamTask* pDownstreamTask, SStreamTask* pHDownstreamTask,
-                                                 SEpSet* pEpset, int64_t skey, SArray* pVerList) {
-  SArray* pSourceTaskList = addNewTaskList(pStream->tasks);
-
-  SArray* pHSourceTaskList = NULL;
-  if (pStream->conf.fillHistory) {
-    pHSourceTaskList = addNewTaskList(pStream->pHTasksList);
-  }
-
-  SSdb*          pSdb = pMnode->pSdb;
-  SNodeListNode* inner = (SNodeListNode*)nodesListGetNode(pPlan->pSubplans, 1);
   SSubplan* plan = (SSubplan*)nodesListGetNode(inner->pNodeList, 0);
   if (plan->subplanType != SUBPLAN_TYPE_SCAN) {
     terrno = TSDB_CODE_QRY_INVALID_INPUT;
-    return -1;
+    return NULL;
+  }
+  return plan;
 }
 
+static SSubplan* getAggSubPlan(const SQueryPlan* pPlan, int index) {
+  SNodeListNode* inner = (SNodeListNode*)nodesListGetNode(pPlan->pSubplans, index);
+  if (LIST_LENGTH(inner->pNodeList) != 1) {
+    terrno = TSDB_CODE_QRY_INVALID_INPUT;
+    return NULL;
+  }
+
+  SSubplan* plan = (SSubplan*)nodesListGetNode(inner->pNodeList, 0);
+  if (plan->subplanType != SUBPLAN_TYPE_MERGE) {
+    terrno = TSDB_CODE_QRY_INVALID_INPUT;
+    return NULL;
+  }
+  return plan;
+}
+
+static int32_t addSourceTask(SMnode* pMnode, SSubplan* plan, SStreamObj* pStream, SEpSet* pEpset,
+                             int64_t nextWindowSkey, SArray* pVerList, bool useTriggerParam) {
+  addNewTaskList(pStream);
+
   void* pIter = NULL;
+  SSdb* pSdb = pMnode->pSdb;
   while (1) {
     SVgObj* pVgroup;
     pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void**)&pVgroup);
@@ -548,18 +432,16 @@ static int32_t addSourceTasksForMultiLevelStream(SMnode* pMnode, SQueryPlan* pPl
       continue;
     }
 
-    int32_t code = addSourceTaskForMultiLevelStream(pSourceTaskList, false, pStream->uid, pDownstreamTask, pMnode, plan, pVgroup, pEpset,
+    int code =
-                                   skey, pVerList, pStream->conf.fillHistory);
+        doAddSourceTask(pMnode, plan, pStream, pEpset, nextWindowSkey, pVerList, pVgroup, false, useTriggerParam);
-    if (code != TSDB_CODE_SUCCESS) {
+    if (code != 0) {
       sdbRelease(pSdb, pVgroup);
-      terrno = code;
+      return code;
-      return -1;
     }
 
     if (pStream->conf.fillHistory) {
-      code = addSourceTaskForMultiLevelStream(pHSourceTaskList, true, pStream->hTaskUid, pHDownstreamTask, pMnode, plan, pVgroup, pEpset,
+      code = doAddSourceTask(pMnode, plan, pStream, pEpset, nextWindowSkey, pVerList, pVgroup, true, useTriggerParam);
-                             skey, pVerList, pStream->conf.fillHistory);
+      if (code != 0) {
-      if (code != TSDB_CODE_SUCCESS) {
         sdbRelease(pSdb, pVgroup);
         return code;
       }
@@ -569,49 +451,160 @@ static int32_t addSourceTasksForMultiLevelStream(SMnode* pMnode, SQueryPlan* pPl
   }
 
   if (pStream->conf.fillHistory) {
-    setHTasksId(pSourceTaskList, pHSourceTaskList);
+    setHTasksId(pStream);
   }
 
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t addSinkTasks(SArray* pTasksList, SMnode* pMnode, SStreamObj* pStream, SArray** pCreatedTaskList,
+static SStreamTask* buildAggTask(SStreamObj* pStream, SEpSet* pEpset, bool isFillhistory, bool useTriggerParam) {
-                            SEpSet* pEpset, bool fillHistory) {
+  uint64_t uid = (isFillhistory) ? pStream->hTaskUid : pStream->uid;
-  SArray* pSinkTaskList = addNewTaskList(pTasksList);
+  SArray** pTaskList = (isFillhistory) ? taosArrayGetLast(pStream->pHTasksList) : taosArrayGetLast(pStream->tasks);
-  if (pStream->fixedSinkVgId == 0) {
+
-    if (doAddShuffleSinkTask(pMnode, pSinkTaskList, pStream, pEpset, fillHistory) < 0) {
+  SStreamTask* pAggTask =
-      // TODO free
+      tNewStreamTask(uid, TASK_LEVEL__AGG, pEpset, isFillhistory, useTriggerParam ? pStream->conf.triggerParam : 0,
-      return -1;
+                     *pTaskList, pStream->conf.fillHistory, pStream->subTableWithoutMd5);
+  if (pAggTask == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
+
+  return pAggTask;
+}
+
+static int32_t doAddAggTask(SStreamObj* pStream, SMnode* pMnode, SSubplan* plan, SEpSet* pEpset, SVgObj* pVgroup,
+                            SSnodeObj* pSnode, bool isFillhistory, bool useTriggerParam) {
+  int32_t      code = 0;
+  SStreamTask* pTask = buildAggTask(pStream, pEpset, isFillhistory, useTriggerParam);
+  if (pTask == NULL) {
+    return terrno;
+  }
+  if (pSnode != NULL) {
+    code = mndAssignStreamTaskToSnode(pMnode, pTask, plan, pSnode);
+    mDebug("doAddAggTask taskId:%s, snode id:%d, isFillHistory:%d", pTask->id.idStr, pSnode->id, isFillhistory);
+
+  } else {
+    code = mndAssignStreamTaskToVgroup(pMnode, pTask, plan, pVgroup);
+    mDebug("doAddAggTask taskId:%s, vgId:%d, isFillHistory:%d", pTask->id.idStr, pVgroup->vgId, isFillhistory);
+  }
+  return code;
+}
+
+static int32_t addAggTask(SStreamObj* pStream, SMnode* pMnode, SSubplan* plan, SEpSet* pEpset, bool useTriggerParam) {
+  SVgObj*    pVgroup = NULL;
+  SSnodeObj* pSnode = NULL;
+  int32_t    code = 0;
+  if (tsDeployOnSnode) {
+    pSnode = mndSchedFetchOneSnode(pMnode);
+    if (pSnode == NULL) {
+      pVgroup = mndSchedFetchOneVg(pMnode, pStream);
     }
   } else {
-    if (doAddSinkTask(pStream, pSinkTaskList, pMnode, pStream->fixedSinkVgId, &pStream->fixedSinkVg, pEpset,
+    pVgroup = mndSchedFetchOneVg(pMnode, pStream);
-                           fillHistory) < 0) {
+  }
-      // TODO free
+
-      return -1;
+  code = doAddAggTask(pStream, pMnode, plan, pEpset, pVgroup, pSnode, false, useTriggerParam);
+  if (code != 0) {
+    goto END;
+  }
+
+  if (pStream->conf.fillHistory) {
+    code = doAddAggTask(pStream, pMnode, plan, pEpset, pVgroup, pSnode, true, useTriggerParam);
+    if (code != 0) {
+      goto END;
+    }
+
+    setHTasksId(pStream);
+  }
+
+END:
+  if (pSnode != NULL) {
+    sdbRelease(pMnode->pSdb, pSnode);
+  } else {
+    sdbRelease(pMnode->pSdb, pVgroup);
+  }
+  return code;
+}
+
+static int32_t addSinkTask(SMnode* pMnode, SStreamObj* pStream, SEpSet* pEpset) {
+  int32_t code = 0;
+  addNewTaskList(pStream);
+
+  if (pStream->fixedSinkVgId == 0) {
+    code = doAddShuffleSinkTask(pMnode, pStream, pEpset);
+    if (code != 0) {
+      return code;
+    }
+  } else {
+    code = doAddSinkTaskToVg(pMnode, pStream, pEpset, &pStream->fixedSinkVg);
+    if (code != 0) {
+      return code;
     }
   }
 
-  *pCreatedTaskList = pSinkTaskList;
+  if (pStream->conf.fillHistory) {
-  return TSDB_CODE_SUCCESS;
+    setHTasksId(pStream);
+  }
+  return TDB_CODE_SUCCESS;
 }
 
-static void setSinkTaskUpstreamInfo(SArray* pTasksList, const SStreamTask* pUpstreamTask) {
+static void bindTaskToSinkTask(SStreamObj* pStream, SMnode* pMnode, SArray* pSinkTaskList, SStreamTask* task) {
-  if (taosArrayGetSize(pTasksList) < SINK_NODE_LEVEL || pUpstreamTask == NULL) {
+  mndAddDispatcherForInternalTask(pMnode, pStream, pSinkTaskList, task);
-    return;
+  for (int32_t k = 0; k < taosArrayGetSize(pSinkTaskList); k++) {
+    SStreamTask* pSinkTask = taosArrayGetP(pSinkTaskList, k);
+    streamTaskSetUpstreamInfo(pSinkTask, task);
+  }
+  mDebug("bindTaskToSinkTask taskId:%s to sink task list", task->id.idStr);
 }
 
-  SArray* pSinkTaskList = taosArrayGetP(pTasksList, SINK_NODE_LEVEL);
+static void bindAggSink(SStreamObj* pStream, SMnode* pMnode, SArray* tasks) {
-  for(int32_t i = 0; i < taosArrayGetSize(pSinkTaskList); ++i) {
+  SArray*  pSinkTaskList = taosArrayGetP(tasks, SINK_NODE_LEVEL);
-    SStreamTask* pSinkTask = taosArrayGetP(pSinkTaskList, i);
+  SArray** pAggTaskList = taosArrayGetLast(tasks);
-    streamTaskSetUpstreamInfo(pSinkTask, pUpstreamTask);
+
+  for (int i = 0; i < taosArrayGetSize(*pAggTaskList); i++) {
+    SStreamTask* pAggTask = taosArrayGetP(*pAggTaskList, i);
+    bindTaskToSinkTask(pStream, pMnode, pSinkTaskList, pAggTask);
+    mDebug("bindAggSink taskId:%s to sink task list", pAggTask->id.idStr);
   }
 }
 
+static void bindSourceSink(SStreamObj* pStream, SMnode* pMnode, SArray* tasks, bool hasExtraSink) {
+  SArray* pSinkTaskList = taosArrayGetP(tasks, SINK_NODE_LEVEL);
+  SArray* pSourceTaskList = taosArrayGetP(tasks, hasExtraSink ? SINK_NODE_LEVEL + 1 : SINK_NODE_LEVEL);
+
+  for (int i = 0; i < taosArrayGetSize(pSourceTaskList); i++) {
+    SStreamTask* pSourceTask = taosArrayGetP(pSourceTaskList, i);
+    mDebug("bindSourceSink taskId:%s to sink task list", pSourceTask->id.idStr);
+
+    if (hasExtraSink) {
+      bindTaskToSinkTask(pStream, pMnode, pSinkTaskList, pSourceTask);
+    } else {
+      mndSetSinkTaskInfo(pStream, pSourceTask);
+    }
+  }
+}
+
+static void bindTwoLevel(SArray* tasks, int32_t begin, int32_t end) {
+  size_t size = taosArrayGetSize(tasks);
+  ASSERT(size >= 2);
+  SArray* pDownTaskList = taosArrayGetP(tasks, size - 1);
+  SArray* pUpTaskList = taosArrayGetP(tasks, size - 2);
+
+  SStreamTask** pDownTask = taosArrayGetLast(pDownTaskList);
+  end = end > taosArrayGetSize(pUpTaskList) ? taosArrayGetSize(pUpTaskList) : end;
+  for (int i = begin; i < end; i++) {
+    SStreamTask* pUpTask = taosArrayGetP(pUpTaskList, i);
+    pUpTask->info.selfChildId = i - begin;
+    streamTaskSetFixedDownstreamInfo(pUpTask, *pDownTask);
+    streamTaskSetUpstreamInfo(*pDownTask, pUpTask);
+  }
+  mDebug("bindTwoLevel task list(%d-%d) to taskId:%s", begin, end - 1, (*(pDownTask))->id.idStr);
+}
+
 static int32_t doScheduleStream(SStreamObj* pStream, SMnode* pMnode, SQueryPlan* pPlan, SEpSet* pEpset, int64_t skey,
                                 SArray* pVerList) {
   SSdb*   pSdb = pMnode->pSdb;
   int32_t numOfPlanLevel = LIST_LENGTH(pPlan->pSubplans);
-
   bool    hasExtraSink = false;
   bool    externalTargetDB = strcmp(pStream->sourceDb, pStream->targetDb) != 0;
   SDbObj* pDbObj = mndAcquireDb(pMnode, pStream->targetDb);
@@ -623,54 +616,90 @@ static int32_t doScheduleStream(SStreamObj* pStream, SMnode* pMnode, SQueryPlan*
   bool multiTarget = (pDbObj->cfg.numOfVgroups > 1);
   sdbRelease(pSdb, pDbObj);
 
+  mDebug("doScheduleStream numOfPlanLevel:%d, exDb:%d, multiTarget:%d, fix vgId:%d, physicalPlan:%s", numOfPlanLevel,
+         externalTargetDB, multiTarget, pStream->fixedSinkVgId, pStream->physicalPlan);
   pStream->tasks = taosArrayInit(numOfPlanLevel + 1, POINTER_BYTES);
   pStream->pHTasksList = taosArrayInit(numOfPlanLevel + 1, POINTER_BYTES);
 
-  if (numOfPlanLevel == 2 || externalTargetDB || multiTarget || pStream->fixedSinkVgId) {
+  if (numOfPlanLevel > 1 || externalTargetDB || multiTarget || pStream->fixedSinkVgId) {
     // add extra sink
     hasExtraSink = true;
-
+    int32_t code = addSinkTask(pMnode, pStream, pEpset);
-    SArray* pSinkTaskList = NULL;
-    int32_t code = addSinkTasks(pStream->tasks, pMnode, pStream, &pSinkTaskList, pEpset, 0);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
     }
-
-    // check for fill history
-    if (pStream->conf.fillHistory) {
-      SArray* pHSinkTaskList = NULL;
-      code = addSinkTasks(pStream->pHTasksList, pMnode, pStream, &pHSinkTaskList, pEpset, 1);
-      if (code != TSDB_CODE_SUCCESS) {
-        return code;
-      }
-
-      setHTasksId(pSinkTaskList, pHSinkTaskList);
-    }
   }
 
   pStream->totalLevel = numOfPlanLevel + hasExtraSink;
 
-  if (numOfPlanLevel > 1) {
+  SSubplan* plan = getScanSubPlan(pPlan);  // source plan
-    SStreamTask* pAggTask = NULL;
+  if (plan == NULL) {
-    SStreamTask* pHAggTask = NULL;
+    return terrno;
-
+  }
-    int32_t code = addAggTask(pStream, pMnode, pPlan, pEpset, &pAggTask, &pHAggTask);
+  int32_t code = addSourceTask(pMnode, plan, pStream, pEpset, skey, pVerList, numOfPlanLevel == 1);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
 
-    setSinkTaskUpstreamInfo(pStream->tasks, pAggTask);
+  if (numOfPlanLevel == 1) {
-    if (pHAggTask != NULL) {
+    bindSourceSink(pStream, pMnode, pStream->tasks, hasExtraSink);
-      setSinkTaskUpstreamInfo(pStream->pHTasksList, pHAggTask);
+    if (pStream->conf.fillHistory) {
+      bindSourceSink(pStream, pMnode, pStream->pHTasksList, hasExtraSink);
+    }
+    return TDB_CODE_SUCCESS;
   }
 
-    // source level
+  if (numOfPlanLevel == 3) {
-    return addSourceTasksForMultiLevelStream(pMnode, pPlan, pStream, pAggTask, pHAggTask, pEpset, skey, pVerList);
+    plan = getAggSubPlan(pPlan, 1);  // middle agg plan
-  } else if (numOfPlanLevel == 1) {
+    if (plan == NULL) {
-    return addSourceTasksForOneLevelStream(pMnode, pPlan, pStream, pEpset, hasExtraSink, skey, pVerList);
+      return terrno;
+    }
+    do {
+      SArray** list = taosArrayGetLast(pStream->tasks);
+      float    size = (float)taosArrayGetSize(*list);
+      size_t   cnt = (size_t)ceil(size / tsStreamAggCnt);
+      if (cnt <= 1) break;
+
+      mDebug("doScheduleStream add middle agg, size:%d, cnt:%d", (int)size, (int)cnt);
+      addNewTaskList(pStream);
+
+      for (int j = 0; j < cnt; j++) {
+        code = addAggTask(pStream, pMnode, plan, pEpset, false);
+        if (code != TSDB_CODE_SUCCESS) {
+          return code;
         }
 
-  return 0;
+        bindTwoLevel(pStream->tasks, j * tsStreamAggCnt, (j + 1) * tsStreamAggCnt);
+        if (pStream->conf.fillHistory) {
+          bindTwoLevel(pStream->pHTasksList, j * tsStreamAggCnt, (j + 1) * tsStreamAggCnt);
+        }
+      }
+    } while (1);
+  }
+
+  plan = getAggSubPlan(pPlan, 0);
+  if (plan == NULL) {
+    return terrno;
+  }
+
+  mDebug("doScheduleStream add final agg");
+  SArray** list = taosArrayGetLast(pStream->tasks);
+  size_t   size = taosArrayGetSize(*list);
+  addNewTaskList(pStream);
+  code = addAggTask(pStream, pMnode, plan, pEpset, true);
+  if (code != TSDB_CODE_SUCCESS) {
+    return code;
+  }
+  bindTwoLevel(pStream->tasks, 0, size);
+  if (pStream->conf.fillHistory) {
+    bindTwoLevel(pStream->pHTasksList, 0, size);
+  }
+
+  bindAggSink(pStream, pMnode, pStream->tasks);
+  if (pStream->conf.fillHistory) {
+    bindAggSink(pStream, pMnode, pStream->pHTasksList);
+  }
+  return TDB_CODE_SUCCESS;
 }
 
 int32_t mndScheduleStream(SMnode* pMnode, SStreamObj* pStream, int64_t skey, SArray* pVgVerList) {

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

@@ -566,6 +566,8 @@ static int32_t mndCreateSma(SMnode *pMnode, SRpcMsg *pReq, SMCreateSmaReq *pCrea
   streamObj.conf.trigger = STREAM_TRIGGER_WINDOW_CLOSE;
   streamObj.conf.triggerParam = pCreate->maxDelay;
   streamObj.ast = taosStrdup(smaObj.ast);
+  streamObj.indexForMultiAggBalance = -1;
+  streamObj.subTableWithoutMd5 = 1;
 
   // check the maxDelay
   if (streamObj.conf.triggerParam < TSDB_MIN_ROLLUP_MAX_DELAY) {

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

@@ -297,6 +297,7 @@ static int32_t mndBuildStreamObjFromCreateReq(SMnode *pMnode, SStreamObj *pObj,
   pObj->updateTime = pObj->createTime;
   pObj->version = 1;
   pObj->smaId = 0;
+  pObj->indexForMultiAggBalance = -1;
 
   pObj->uid = mndGenerateUid(pObj->name, strlen(pObj->name));
 
@@ -802,8 +803,7 @@ static int32_t mndProcessStreamCheckpointTmr(SRpcMsg *pReq) {
 }
 
 static int32_t mndBuildStreamCheckpointSourceReq(void **pBuf, int32_t *pLen, int32_t nodeId, int64_t checkpointId,
-                                                  int64_t streamId, int32_t taskId, int32_t transId,
+                                                 int64_t streamId, int32_t taskId, int32_t transId, int8_t mndTrigger) {
-                                                  int8_t mndTrigger) {
   SStreamCheckpointSourceReq req = {0};
   req.checkpointId = checkpointId;
   req.nodeId = nodeId;
@@ -882,7 +882,6 @@ static int32_t mndProcessStreamCheckpointTrans(SMnode *pMnode, SStreamObj *pStre
     return -1;
   }
 
-
   bool conflict = mndStreamTransConflictCheck(pMnode, pStream->uid, MND_STREAM_CHECKPOINT_NAME, lock);
   if (conflict) {
     mndAddtoCheckpointWaitingList(pStream, checkpointId);
@@ -1617,7 +1616,7 @@ static int32_t mndProcessResumeStreamReq(SRpcMsg *pReq) {
   SMnode     *pMnode = pReq->info.node;
   SStreamObj *pStream = NULL;
 
-  if(grantCheck(TSDB_GRANT_STREAMS) < 0){
+  if (grantCheckExpire(TSDB_GRANT_STREAMS) < 0) {
     terrno = TSDB_CODE_GRANT_EXPIRED;
     return -1;
   }

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

@@ -225,7 +225,7 @@ int32_t mndProcessStreamHb(SRpcMsg *pReq) {
   SArray      *pFailedTasks = taosArrayInit(4, sizeof(SFailedCheckpointInfo));
   SArray      *pOrphanTasks = taosArrayInit(3, sizeof(SOrphanTask));
 
-  if(grantCheck(TSDB_GRANT_STREAMS) < 0){
+  if(grantCheckExpire(TSDB_GRANT_STREAMS) < 0){
     if(suspendAllStreams(pMnode, &pReq->info) < 0){
       return -1;
     }

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

@@ -24,7 +24,7 @@
 #include "tcompare.h"
 #include "tname.h"
 
-#define MND_SUBSCRIBE_VER_NUMBER   2
+#define MND_SUBSCRIBE_VER_NUMBER   3
 #define MND_SUBSCRIBE_RESERVE_SIZE 64
 
 #define MND_CONSUMER_LOST_HB_CNT          6
@@ -530,7 +530,6 @@ static int32_t mndDoRebalance(SMnode *pMnode, const SMqRebInputObj *pInput, SMqR
     }
   }
 
-//  if(taosHashGetSize(pOutput->pSub->consumerHash) == 0) {                            // if all consumer is removed
   SMqSubscribeObj *pSub = mndAcquireSubscribeByKey(pMnode, pInput->pRebInfo->key);  // put all offset rows
   if (pSub) {
     taosRLockLatch(&pSub->lock);
@@ -562,6 +561,7 @@ static int32_t mndDoRebalance(SMnode *pMnode, const SMqRebInputObj *pInput, SMqR
           if (d1->vgId == d2->vgId) {
             d2->rows += d1->rows;
             d2->offset = d1->offset;
+            d2->ever = d1->ever;
             find = true;
             mInfo("pSub->offsetRows add vgId:%d, after:%"PRId64", before:%"PRId64, d2->vgId, d2->rows, d1->rows);
             break;
@@ -574,7 +574,6 @@ static int32_t mndDoRebalance(SMnode *pMnode, const SMqRebInputObj *pInput, SMqR
     }
     taosRUnLockLatch(&pSub->lock);
     mndReleaseSubscribe(pMnode, pSub);
-//    }
   }
 
   // 8. generate logs
@@ -1405,8 +1404,9 @@ static int32_t buildResult(SSDataBlock *pBlock, int32_t* numOfRows, int64_t cons
     }
     if(data){
       // vg id
-      char buf[TSDB_OFFSET_LEN + VARSTR_HEADER_SIZE] = {0};
+      char buf[TSDB_OFFSET_LEN*2 + VARSTR_HEADER_SIZE] = {0};
       tFormatOffset(varDataVal(buf), TSDB_OFFSET_LEN, &data->offset);
+      sprintf(varDataVal(buf) + strlen(varDataVal(buf)), "/%"PRId64, data->ever);
       varDataSetLen(buf, strlen(varDataVal(buf)));
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
       colDataSetVal(pColInfo, *numOfRows, (const char *)buf, false);

source/dnode/mnode/impl/test/stream/CMakeLists.txt

@@ -4,7 +4,7 @@ aux_source_directory(. MNODE_STREAM_TEST_SRC)
 add_executable(streamTest ${MNODE_STREAM_TEST_SRC})
 target_link_libraries(
         streamTest
-        PRIVATE dnode  gtest
+        PRIVATE dnode nodes planner gtest qcom
 )
 
 add_test(

source/dnode/vnode/inc/vnode.h

@@ -223,7 +223,7 @@ bool tqReaderIsQueriedTable(STqReader *pReader, uint64_t uid);
 bool tqCurrentBlockConsumed(const STqReader *pReader);
 
 int32_t      tqReaderSeek(STqReader *pReader, int64_t ver, const char *id);
-bool         tqNextBlockInWal(STqReader *pReader, const char *idstr);
+bool         tqNextBlockInWal(STqReader *pReader, const char *idstr, int sourceExcluded);
 bool         tqNextBlockImpl(STqReader *pReader, const char *idstr);
 SWalReader  *tqGetWalReader(STqReader *pReader);
 SSDataBlock *tqGetResultBlock(STqReader *pReader);

source/dnode/vnode/src/inc/tq.h

@@ -118,7 +118,7 @@ int32_t tqScanData(STQ* pTq, STqHandle* pHandle, SMqDataRsp* pRsp, STqOffsetVal*
 int32_t tqFetchLog(STQ* pTq, STqHandle* pHandle, int64_t* fetchOffset, uint64_t reqId);
 
 // tqExec
-int32_t tqTaosxScanLog(STQ* pTq, STqHandle* pHandle, SPackedData submit, STaosxRsp* pRsp, int32_t* totalRows);
+int32_t tqTaosxScanLog(STQ* pTq, STqHandle* pHandle, SPackedData submit, STaosxRsp* pRsp, int32_t* totalRows, int8_t sourceExcluded);
 int32_t tqAddBlockDataToRsp(const SSDataBlock* pBlock, SMqDataRsp* pRsp, int32_t numOfCols, int8_t precision);
 int32_t tqSendDataRsp(STqHandle* pHandle, const SRpcMsg* pMsg, const SMqPollReq* pReq, const SMqDataRsp* pRsp,
                       int32_t type, int32_t vgId);

source/dnode/vnode/src/meta/metaOpen.c

@@ -27,7 +27,14 @@ static int taskIdxKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int k
 static int btimeIdxCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2);
 static int ncolIdxCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2);
 
-static int32_t metaInitLock(SMeta *pMeta) { return taosThreadRwlockInit(&pMeta->lock, NULL); }
+static int32_t metaInitLock(SMeta *pMeta) {
+  TdThreadRwlockAttr attr;
+  taosThreadRwlockAttrInit(&attr);
+  taosThreadRwlockAttrSetKindNP(&attr, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP);
+  taosThreadRwlockInit(&pMeta->lock, &attr);
+  taosThreadRwlockAttrDestroy(&attr);
+  return 0;
+}
 static int32_t metaDestroyLock(SMeta *pMeta) { return taosThreadRwlockDestroy(&pMeta->lock); }
 
 static void metaCleanup(SMeta **ppMeta);

source/dnode/vnode/src/sma/smaTimeRange.c

@@ -193,7 +193,7 @@ int32_t smaBlockToSubmit(SVnode *pVnode, const SArray *pBlocks, const STSchema *
       continue;
     }
 
-    SSubmitTbData tbData = {.suid = suid, .uid = 0, .sver = pTSchema->version, .flags = SUBMIT_REQ_AUTO_CREATE_TABLE,};
+    SSubmitTbData tbData = {.suid = suid, .uid = 0, .sver = pTSchema->version, .flags = SUBMIT_REQ_AUTO_CREATE_TABLE, .source = SOURCE_NULL};
 
     int32_t cid = taosArrayGetSize(pDataBlock->pDataBlock) + 1;
     tbData.pCreateTbReq = buildAutoCreateTableReq(stbFullName, suid, cid, pDataBlock, tagArray, true);

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

@@ -368,7 +368,7 @@ int32_t extractMsgFromWal(SWalReader* pReader, void** pItem, int64_t maxVer, con
 }
 
 // todo ignore the error in wal?
-bool tqNextBlockInWal(STqReader* pReader, const char* id) {
+bool tqNextBlockInWal(STqReader* pReader, const char* id, int sourceExcluded) {
   SWalReader* pWalReader = pReader->pWalReader;
   SSDataBlock* pDataBlock = NULL;
 
@@ -391,7 +391,10 @@ bool tqNextBlockInWal(STqReader* pReader, const char* id) {
           numOfBlocks, pReader->msg.msgLen, pReader->msg.ver);
 
       SSubmitTbData* pSubmitTbData = taosArrayGet(pReader->submit.aSubmitTbData, pReader->nextBlk);
-
+      if ((pSubmitTbData->source & sourceExcluded) != 0){
+        pReader->nextBlk += 1;
+        continue;
+      }
       if (pReader->tbIdHash == NULL || taosHashGet(pReader->tbIdHash, &pSubmitTbData->uid, sizeof(int64_t)) != NULL) {
         tqTrace("tq reader return submit block, uid:%" PRId64, pSubmitTbData->uid);
         SSDataBlock* pRes = NULL;

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

@@ -93,6 +93,7 @@ int32_t tqScanData(STQ* pTq, STqHandle* pHandle, SMqDataRsp* pRsp, STqOffsetVal*
     return -1;
   }
 
+  qStreamSetSourceExcluded(task, pRequest->sourceExcluded);
   while (1) {
     SSDataBlock* pDataBlock = NULL;
     code = getDataBlock(task, pHandle, vgId, &pDataBlock);
@@ -249,7 +250,7 @@ int32_t tqScanTaosx(STQ* pTq, const STqHandle* pHandle, STaosxRsp* pRsp, SMqMeta
   return 0;
 }
 
-int32_t tqTaosxScanLog(STQ* pTq, STqHandle* pHandle, SPackedData submit, STaosxRsp* pRsp, int32_t* totalRows) {
+int32_t tqTaosxScanLog(STQ* pTq, STqHandle* pHandle, SPackedData submit, STaosxRsp* pRsp, int32_t* totalRows, int8_t sourceExcluded) {
   STqExecHandle* pExec = &pHandle->execHandle;
   SArray*        pBlocks = taosArrayInit(0, sizeof(SSDataBlock));
   SArray*        pSchemas = taosArrayInit(0, sizeof(void*));
@@ -264,6 +265,10 @@ int32_t tqTaosxScanLog(STQ* pTq, STqHandle* pHandle, SPackedData submit, STaosxR
       if (tqRetrieveTaosxBlock(pReader, pBlocks, pSchemas, &pSubmitTbDataRet) < 0) {
         if (terrno == TSDB_CODE_TQ_TABLE_SCHEMA_NOT_FOUND) goto loop_table;
       }
+
+      if ((pSubmitTbDataRet->source & sourceExcluded) != 0){
+        goto loop_table;
+      }
       if (pRsp->withTbName) {
         int64_t uid = pExec->pTqReader->lastBlkUid;
         if (tqAddTbNameToRsp(pTq, uid, pRsp, taosArrayGetSize(pBlocks)) < 0) {
@@ -328,6 +333,10 @@ int32_t tqTaosxScanLog(STQ* pTq, STqHandle* pHandle, SPackedData submit, STaosxR
       if (tqRetrieveTaosxBlock(pReader, pBlocks, pSchemas, &pSubmitTbDataRet) < 0) {
         if (terrno == TSDB_CODE_TQ_TABLE_SCHEMA_NOT_FOUND) goto loop_db;
       }
+
+      if ((pSubmitTbDataRet->source & sourceExcluded) != 0){
+        goto loop_db;
+      }
       if (pRsp->withTbName) {
         int64_t uid = pExec->pTqReader->lastBlkUid;
         if (tqAddTbNameToRsp(pTq, uid, pRsp, taosArrayGetSize(pBlocks)) < 0) {

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

@@ -33,12 +33,15 @@ static int32_t doBuildAndSendDeleteMsg(SVnode* pVnode, char* stbFullName, SSData
                                        int64_t suid);
 static int32_t doBuildAndSendSubmitMsg(SVnode* pVnode, SStreamTask* pTask, SSubmitReq2* pReq, int32_t numOfBlocks);
 static int32_t buildSubmitMsgImpl(SSubmitReq2* pSubmitReq, int32_t vgId, void** pMsg, int32_t* msgLen);
-static int32_t doConvertRows(SSubmitTbData* pTableData, const STSchema* pTSchema, SSDataBlock* pDataBlock, const char* id);
+static int32_t doConvertRows(SSubmitTbData* pTableData, const STSchema* pTSchema, SSDataBlock* pDataBlock,
+                             const char* id);
 static int32_t doWaitForDstTableCreated(SVnode* pVnode, SStreamTask* pTask, STableSinkInfo* pTableSinkInfo,
                                         const char* dstTableName, int64_t* uid);
-static int32_t doPutIntoCache(SSHashObj* pSinkTableMap, STableSinkInfo* pTableSinkInfo, uint64_t groupId, const char* id);
+static int32_t doPutIntoCache(SSHashObj* pSinkTableMap, STableSinkInfo* pTableSinkInfo, uint64_t groupId,
+                              const char* id);
 static bool    isValidDstChildTable(SMetaReader* pReader, int32_t vgId, const char* ctbName, int64_t suid);
-static int32_t initCreateTableMsg(SVCreateTbReq* pCreateTableReq, uint64_t suid, const char* stbFullName, int32_t numOfTags);
+static int32_t initCreateTableMsg(SVCreateTbReq* pCreateTableReq, uint64_t suid, const char* stbFullName,
+                                  int32_t numOfTags);
 static SArray* createDefaultTagColName();
 static void setCreateTableMsgTableName(SVCreateTbReq* pCreateTableReq, SSDataBlock* pDataBlock, const char* stbFullName,
                                        int64_t gid, bool newSubTableRule);
@@ -68,10 +71,7 @@ int32_t tqBuildDeleteReq(STQ* pTq, const char* stbFullName, const SSDataBlock* p
     if (varTbName != NULL && varTbName != (void*)-1) {
       name = taosMemoryCalloc(1, TSDB_TABLE_NAME_LEN);
       memcpy(name, varDataVal(varTbName), varDataLen(varTbName));
-      if(newSubTableRule &&
+      if (newSubTableRule && !isAutoTableName(name) && !alreadyAddGroupId(name) && groupId != 0) {
-         !isAutoTableName(name) &&
-         !alreadyAddGroupId(name) &&
-          groupId != 0) {
         buildCtbNameAddGruopId(name, groupId);
       }
     } else if (stbFullName) {
@@ -181,10 +181,8 @@ SArray* createDefaultTagColName() {
 void setCreateTableMsgTableName(SVCreateTbReq* pCreateTableReq, SSDataBlock* pDataBlock, const char* stbFullName,
                                 int64_t gid, bool newSubTableRule) {
   if (pDataBlock->info.parTbName[0]) {
-    if(newSubTableRule &&
+    if (newSubTableRule && !isAutoTableName(pDataBlock->info.parTbName) &&
-        !isAutoTableName(pDataBlock->info.parTbName) &&
+        !alreadyAddGroupId(pDataBlock->info.parTbName) && gid != 0) {
-        !alreadyAddGroupId(pDataBlock->info.parTbName) &&
-        gid != 0) {
       pCreateTableReq->name = taosMemoryCalloc(1, TSDB_TABLE_NAME_LEN);
       strcpy(pCreateTableReq->name, pDataBlock->info.parTbName);
       buildCtbNameAddGruopId(pCreateTableReq->name, gid);
@@ -196,13 +194,14 @@ void setCreateTableMsgTableName(SVCreateTbReq* pCreateTableReq, SSDataBlock* pDa
   }
 }
 
-static int32_t doBuildAndSendCreateTableMsg(SVnode* pVnode, char* stbFullName, SSDataBlock* pDataBlock, SStreamTask* pTask,
+static int32_t doBuildAndSendCreateTableMsg(SVnode* pVnode, char* stbFullName, SSDataBlock* pDataBlock,
-                                            int64_t suid) {
+                                            SStreamTask* pTask, int64_t suid) {
   tqDebug("s-task:%s build create table msg", pTask->id.idStr);
 
   STSchema* pTSchema = pTask->outputInfo.tbSink.pTSchema;
   int32_t   rows = pDataBlock->info.rows;
-  SArray*   tagArray = taosArrayInit(4, sizeof(STagVal));;
+  SArray*   tagArray = taosArrayInit(4, sizeof(STagVal));
+  ;
   int32_t code = 0;
 
   SVCreateTbBatchReq reqs = {0};
@@ -262,7 +261,8 @@ static int32_t doBuildAndSendCreateTableMsg(SVnode* pVnode, char* stbFullName, S
       ASSERT(gid == *(int64_t*)pGpIdData);
     }
 
-    setCreateTableMsgTableName(pCreateTbReq, pDataBlock, stbFullName, gid, pTask->ver >= SSTREAM_TASK_SUBTABLE_CHANGED_VER);
+    setCreateTableMsgTableName(pCreateTbReq, pDataBlock, stbFullName, gid,
+                               pTask->ver >= SSTREAM_TASK_SUBTABLE_CHANGED_VER && pTask->subtableWithoutMd5 != 1);
 
     taosArrayPush(reqs.pArray, pCreateTbReq);
     tqDebug("s-task:%s build create table:%s msg complete", pTask->id.idStr, pCreateTbReq->name);
@@ -361,7 +361,8 @@ int32_t doMergeExistedRows(SSubmitTbData* pExisted, const SSubmitTbData* pNew, c
   pExisted->aRowP = pFinal;
 
   tqTrace("s-task:%s rows merged, final rows:%d, uid:%" PRId64 ", existed auto-create table:%d, new-block:%d", id,
-          (int32_t)taosArrayGetSize(pFinal), pExisted->uid, (pExisted->pCreateTbReq != NULL), (pNew->pCreateTbReq != NULL));
+          (int32_t)taosArrayGetSize(pFinal), pExisted->uid, (pExisted->pCreateTbReq != NULL),
+          (pNew->pCreateTbReq != NULL));
 
   tdDestroySVCreateTbReq(pNew->pCreateTbReq);
   taosMemoryFree(pNew->pCreateTbReq);
@@ -373,7 +374,7 @@ int32_t doBuildAndSendDeleteMsg(SVnode* pVnode, char* stbFullName, SSDataBlock*
   SBatchDeleteReq deleteReq = {.suid = suid, .deleteReqs = taosArrayInit(0, sizeof(SSingleDeleteReq))};
 
   int32_t code = tqBuildDeleteReq(pVnode->pTq, stbFullName, pDataBlock, &deleteReq, pTask->id.idStr,
-                                  pTask->ver >= SSTREAM_TASK_SUBTABLE_CHANGED_VER);
+                                  pTask->ver >= SSTREAM_TASK_SUBTABLE_CHANGED_VER && pTask->subtableWithoutMd5 != 1);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
@@ -416,8 +417,8 @@ bool isValidDstChildTable(SMetaReader* pReader, int32_t vgId, const char* ctbNam
   }
 
   if (pReader->me.ctbEntry.suid != suid) {
-    tqError("vgId:%d, failed to write into %s, since suid mismatch, expect suid:%" PRId64 ", actual:%" PRId64,
+    tqError("vgId:%d, failed to write into %s, since suid mismatch, expect suid:%" PRId64 ", actual:%" PRId64, vgId,
-            vgId, ctbName, suid, pReader->me.ctbEntry.suid);
+            ctbName, suid, pReader->me.ctbEntry.suid);
     terrno = TSDB_CODE_TDB_TABLE_IN_OTHER_STABLE;
     return false;
   }
@@ -667,10 +668,8 @@ int32_t setDstTableDataUid(SVnode* pVnode, SStreamTask* pTask, SSDataBlock* pDat
       memset(dstTableName, 0, TSDB_TABLE_NAME_LEN);
       buildCtbNameByGroupIdImpl(stbFullName, groupId, dstTableName);
     } else {
-      if(pTask->ver >= SSTREAM_TASK_SUBTABLE_CHANGED_VER &&
+      if (pTask->ver >= SSTREAM_TASK_SUBTABLE_CHANGED_VER && pTask->subtableWithoutMd5 != 1 &&
-          !isAutoTableName(dstTableName) &&
+          !isAutoTableName(dstTableName) && !alreadyAddGroupId(dstTableName) && groupId != 0) {
-          !alreadyAddGroupId(dstTableName) &&
-          groupId != 0) {
         buildCtbNameAddGruopId(dstTableName, groupId);
       }
     }
@@ -714,7 +713,8 @@ int32_t setDstTableDataUid(SVnode* pVnode, SStreamTask* pTask, SSDataBlock* pDat
 
       pTableData->flags = SUBMIT_REQ_AUTO_CREATE_TABLE;
       pTableData->pCreateTbReq =
-          buildAutoCreateTableReq(stbFullName, suid, pTSchema->numOfCols + 1, pDataBlock, pTagArray, pTask->ver >= SSTREAM_TASK_SUBTABLE_CHANGED_VER);
+          buildAutoCreateTableReq(stbFullName, suid, pTSchema->numOfCols + 1, pDataBlock, pTagArray,
+                                  pTask->ver >= SSTREAM_TASK_SUBTABLE_CHANGED_VER && pTask->subtableWithoutMd5 != 1);
       taosArrayDestroy(pTagArray);
 
       if (pTableData->pCreateTbReq == NULL) {
@@ -750,8 +750,8 @@ int32_t tqSetDstTableDataPayload(uint64_t suid, const STSchema *pTSchema, int32_
                                  SSubmitTbData* pTableData, const char* id) {
   int32_t numOfRows = pDataBlock->info.rows;
 
-  tqDebug("s-task:%s sink data pipeline, build submit msg from %dth resBlock, including %d rows, dst suid:%" PRId64,
+  tqDebug("s-task:%s sink data pipeline, build submit msg from %dth resBlock, including %d rows, dst suid:%" PRId64, id,
-          id, blockIndex + 1, numOfRows, suid);
+          blockIndex + 1, numOfRows, suid);
   char* dstTableName = pDataBlock->info.parTbName;
 
   // convert all rows
@@ -815,7 +815,7 @@ void tqSinkDataIntoDstTable(SStreamTask* pTask, void* vnode, void* data) {
           return;
         }
 
-        SSubmitTbData tbData = {.suid = suid, .uid = 0, .sver = pTSchema->version};
+        SSubmitTbData tbData = {.suid = suid, .uid = 0, .sver = pTSchema->version, .source = SOURCE_NULL};
         code = setDstTableDataUid(pVnode, pTask, pDataBlock, stbFullName, &tbData);
         if (code != TSDB_CODE_SUCCESS) {
           continue;
@@ -832,7 +832,8 @@ void tqSinkDataIntoDstTable(SStreamTask* pTask, void* vnode, void* data) {
     }
   } else {
     tqDebug("vgId:%d, s-task:%s write %d stream resBlock(s) into table, merge submit msg", vgId, id, numOfBlocks);
-    SHashObj* pTableIndexMap = taosHashInit(numOfBlocks, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
+    SHashObj* pTableIndexMap =
+        taosHashInit(numOfBlocks, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
 
     SSubmitReq2 submitReq = {.aSubmitTbData = taosArrayInit(1, sizeof(SSubmitTbData))};
     if (submitReq.aSubmitTbData == NULL) {
@@ -859,7 +860,7 @@ void tqSinkDataIntoDstTable(SStreamTask* pTask, void* vnode, void* data) {
       pTask->execInfo.sink.numOfBlocks += 1;
       uint64_t groupId = pDataBlock->info.id.groupId;
 
-      SSubmitTbData tbData = {.suid = suid, .uid = 0, .sver = pTSchema->version};
+      SSubmitTbData tbData = {.suid = suid, .uid = 0, .sver = pTSchema->version, .source = SOURCE_NULL};
 
       int32_t* index = taosHashGet(pTableIndexMap, &groupId, sizeof(groupId));
       if (index == NULL) {  // no data yet, append it

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

@@ -250,7 +250,7 @@ static int32_t extractDataAndRspForDbStbSubscribe(STQ* pTq, STqHandle* pHandle,
           .ver = pHead->version,
       };
 
-      code = tqTaosxScanLog(pTq, pHandle, submit, &taosxRsp, &totalRows);
+      code = tqTaosxScanLog(pTq, pHandle, submit, &taosxRsp, &totalRows, pRequest->sourceExcluded);
       if (code < 0) {
         tqError("tmq poll: tqTaosxScanLog error %" PRId64 ", in vgId:%d, subkey %s", pRequest->consumerId, vgId,
                 pRequest->subKey);

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

@@ -317,15 +317,25 @@ int32_t tqStreamTaskProcessRetrieveReq(SStreamMeta* pMeta, SRpcMsg* pMsg) {
   if (pTask == NULL) {
     tqError("vgId:%d process retrieve req, failed to acquire task:0x%x, it may have been dropped already", pMeta->vgId,
             req.dstTaskId);
+    taosMemoryFree(req.pRetrieve);
     return -1;
   }
 
+  int32_t code = 0;
+  if(pTask->info.taskLevel == TASK_LEVEL__SOURCE){
+    code = streamProcessRetrieveReq(pTask, &req);
+  }else{
+    req.srcNodeId = pTask->info.nodeId;
+    req.srcTaskId = pTask->id.taskId;
+    code = broadcastRetrieveMsg(pTask, &req);
+  }
+
   SRpcMsg rsp = {.info = pMsg->info, .code = 0};
-  streamProcessRetrieveReq(pTask, &req, &rsp);
+  sendRetrieveRsp(&req, &rsp);
 
   streamMetaReleaseTask(pMeta, pTask);
-  tDeleteStreamRetrieveReq(&req);
+  taosMemoryFree(req.pRetrieve);
-  return 0;
+  return code;
 }
 
 int32_t tqStreamTaskProcessCheckReq(SStreamMeta* pMeta, SRpcMsg* pMsg) {

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

@@ -719,7 +719,7 @@ static int32_t mergeLastCid(tb_uid_t uid, STsdb *pTsdb, SArray **ppLastArray, SC
 
 static int32_t mergeLastRowCid(tb_uid_t uid, STsdb *pTsdb, SArray **ppLastArray, SCacheRowsReader *pr, int16_t *aCols,
                                int nCols, int16_t *slotIds);
-#if 1
+#ifdef BUILD_NO_CALL
 int32_t tsdbCacheGetSlow(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArray, SCacheRowsReader *pr, int8_t ltype) {
   rocksdb_writebatch_t *wb = NULL;
   int32_t               code = 0;
@@ -821,7 +821,6 @@ int32_t tsdbCacheGetSlow(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArray, SCacheR
 
   return code;
 }
-#endif
 
 static SLastCol *tsdbCacheLoadCol(STsdb *pTsdb, SCacheRowsReader *pr, int16_t slotid, tb_uid_t uid, int16_t cid,
                                   int8_t ltype) {
@@ -880,6 +879,7 @@ static SLastCol *tsdbCacheLoadCol(STsdb *pTsdb, SCacheRowsReader *pr, int16_t sl
 
   return pLastCol;
 }
+#endif
 
 static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArray, SArray *remainCols,
                                     SCacheRowsReader *pr, int8_t ltype) {
@@ -1359,6 +1359,7 @@ static void getTableCacheKey(tb_uid_t uid, int cacheType, char *key, int *len) {
   *len = sizeof(uint64_t);
 }
 
+#ifdef BUILD_NO_CALL
 static void deleteTableCacheLast(const void *key, size_t keyLen, void *value, void *ud) {
   (void)ud;
   SArray *pLastArray = (SArray *)value;
@@ -1670,6 +1671,7 @@ int32_t tsdbCacheInsertLast(SLRUCache *pCache, tb_uid_t uid, TSDBROW *row, STsdb
 
   return code;
 }
+#endif
 
 static tb_uid_t getTableSuidByUid(tb_uid_t uid, STsdb *pTsdb) {
   tb_uid_t suid = 0;
@@ -1715,6 +1717,7 @@ static int32_t getTableDelDataFromTbData(STbData *pTbData, SArray *aDelData) {
   return code;
 }
 
+#ifdef BUILD_NO_CALL
 static int32_t getTableDelData(STbData *pMem, STbData *pIMem, SDelFReader *pDelReader, SDelIdx *pDelIdx,
                                SArray *aDelData) {
   int32_t code = 0;
@@ -1759,6 +1762,7 @@ _err:
   }
   return code;
 }
+#endif
 
 static void freeTableInfoFunc(void *param) {
   void **p = (void **)param;
@@ -2716,6 +2720,7 @@ _err:
   return code;
 }
 
+#ifdef BUILD_NO_CALL
 static int32_t initLastColArray(STSchema *pTSchema, SArray **ppColArray) {
   SArray *pColArray = taosArrayInit(pTSchema->numOfCols, sizeof(SLastCol));
   if (NULL == pColArray) {
@@ -2729,6 +2734,7 @@ static int32_t initLastColArray(STSchema *pTSchema, SArray **ppColArray) {
   *ppColArray = pColArray;
   return TSDB_CODE_SUCCESS;
 }
+#endif
 
 static int32_t initLastColArrayPartial(STSchema *pTSchema, SArray **ppColArray, int16_t *slotIds, int nCols) {
   SArray *pColArray = taosArrayInit(nCols, sizeof(SLastCol));
@@ -3089,7 +3095,9 @@ void tsdbCacheSetCapacity(SVnode *pVnode, size_t capacity) {
   taosLRUCacheSetCapacity(pVnode->pTsdb->lruCache, capacity);
 }
 
+#ifdef BUILD_NO_CALL
 size_t tsdbCacheGetCapacity(SVnode *pVnode) { return taosLRUCacheGetCapacity(pVnode->pTsdb->lruCache); }
+#endif
 
 size_t tsdbCacheGetUsage(SVnode *pVnode) {
   size_t usage = 0;
@@ -3185,6 +3193,7 @@ int32_t tsdbCacheGetBlockIdx(SLRUCache *pCache, SDataFReader *pFileReader, LRUHa
   return code;
 }
 
+#ifdef BUILD_NO_CALL
 int32_t tsdbBICacheRelease(SLRUCache *pCache, LRUHandle *h) {
   int32_t code = 0;
 
@@ -3193,6 +3202,7 @@ int32_t tsdbBICacheRelease(SLRUCache *pCache, LRUHandle *h) {
 
   return code;
 }
+#endif
 
 // block cache
 static void getBCacheKey(int32_t fid, int64_t commitID, int64_t blkno, char *key, int *len) {

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

@@ -16,6 +16,7 @@
 #include "tsdb.h"
 #include "vnodeInt.h"
 
+#ifdef BUILD_NO_CALL
 // STsdbDataIter2
 /* open */
 int32_t tsdbOpenDataFileDataIter(SDataFReader* pReader, STsdbDataIter2** ppIter) {
@@ -451,6 +452,7 @@ int32_t tsdbDataIterNext2(STsdbDataIter2* pIter, STsdbFilterInfo* pFilterInfo) {
     return code;
   }
 }
+#endif
 
 /* get */
 

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

@@ -29,6 +29,7 @@ void tMapDataClear(SMapData *pMapData) {
   pMapData->aOffset = NULL;
 }
 
+#ifdef BUILD_NO_CALL
 int32_t tMapDataPutItem(SMapData *pMapData, void *pItem, int32_t (*tPutItemFn)(uint8_t *, void *)) {
   int32_t code = 0;
   int32_t offset = pMapData->nData;
@@ -95,12 +96,14 @@ int32_t tMapDataSearch(SMapData *pMapData, void *pSearchItem, int32_t (*tGetItem
 _exit:
   return code;
 }
+#endif
 
 void tMapDataGetItemByIdx(SMapData *pMapData, int32_t idx, void *pItem, int32_t (*tGetItemFn)(uint8_t *, void *)) {
   ASSERT(idx >= 0 && idx < pMapData->nItem);
   tGetItemFn(pMapData->pData + pMapData->aOffset[idx], pItem);
 }
 
+#ifdef BUILD_NO_CALL
 int32_t tMapDataToArray(SMapData *pMapData, int32_t itemSize, int32_t (*tGetItemFn)(uint8_t *, void *),
                         SArray **ppArray) {
   int32_t code = 0;
@@ -140,6 +143,7 @@ int32_t tPutMapData(uint8_t *p, SMapData *pMapData) {
 
   return n;
 }
+#endif
 
 int32_t tGetMapData(uint8_t *p, SMapData *pMapData) {
   int32_t n = 0;
@@ -167,6 +171,7 @@ int32_t tGetMapData(uint8_t *p, SMapData *pMapData) {
   return n;
 }
 
+#ifdef BUILD_NO_CALL
 // TABLEID =======================================================================
 int32_t tTABLEIDCmprFn(const void *p1, const void *p2) {
   TABLEID *pId1 = (TABLEID *)p1;
@@ -199,6 +204,7 @@ int32_t tPutBlockIdx(uint8_t *p, void *ph) {
 
   return n;
 }
+#endif
 
 int32_t tGetBlockIdx(uint8_t *p, void *ph) {
   int32_t    n = 0;
@@ -212,6 +218,7 @@ int32_t tGetBlockIdx(uint8_t *p, void *ph) {
   return n;
 }
 
+#ifdef BUILD_NO_CALL
 int32_t tCmprBlockIdx(void const *lhs, void const *rhs) {
   SBlockIdx *lBlockIdx = (SBlockIdx *)lhs;
   SBlockIdx *rBlockIdx = (SBlockIdx *)rhs;
@@ -280,6 +287,7 @@ int32_t tPutDataBlk(uint8_t *p, void *ph) {
 
   return n;
 }
+#endif
 
 int32_t tGetDataBlk(uint8_t *p, void *ph) {
   int32_t   n = 0;
@@ -310,6 +318,7 @@ int32_t tGetDataBlk(uint8_t *p, void *ph) {
   return n;
 }
 
+#ifdef BUILD_NO_CALL
 int32_t tDataBlkCmprFn(const void *p1, const void *p2) {
   SDataBlk *pBlock1 = (SDataBlk *)p1;
   SDataBlk *pBlock2 = (SDataBlk *)p2;
@@ -349,6 +358,7 @@ int32_t tPutSttBlk(uint8_t *p, void *ph) {
 
   return n;
 }
+#endif
 
 int32_t tGetSttBlk(uint8_t *p, void *ph) {
   int32_t  n = 0;
@@ -438,6 +448,7 @@ int32_t tGetBlockCol(uint8_t *p, void *ph) {
   return n;
 }
 
+#ifdef BUILD_NO_CALL
 int32_t tBlockColCmprFn(const void *p1, const void *p2) {
   if (((SBlockCol *)p1)->cid < ((SBlockCol *)p2)->cid) {
     return -1;
@@ -479,6 +490,7 @@ int32_t tPutDelIdx(uint8_t *p, void *ph) {
 
   return n;
 }
+#endif
 
 int32_t tGetDelIdx(uint8_t *p, void *ph) {
   SDelIdx *pDelIdx = (SDelIdx *)ph;
@@ -492,6 +504,7 @@ int32_t tGetDelIdx(uint8_t *p, void *ph) {
   return n;
 }
 
+#ifdef BUILD_NO_CALL
 // SDelData ======================================================
 int32_t tPutDelData(uint8_t *p, void *ph) {
   SDelData *pDelData = (SDelData *)ph;
@@ -503,6 +516,7 @@ int32_t tPutDelData(uint8_t *p, void *ph) {
 
   return n;
 }
+#endif
 
 int32_t tGetDelData(uint8_t *p, void *ph) {
   SDelData *pDelData = (SDelData *)ph;
@@ -1269,6 +1283,7 @@ _exit:
   return code;
 }
 
+#ifdef BUILD_NO_CALL
 int32_t tBlockDataTryUpsertRow(SBlockData *pBlockData, TSDBROW *pRow, int64_t uid) {
   if (pBlockData->nRow == 0) {
     return 1;
@@ -1286,6 +1301,7 @@ int32_t tBlockDataUpsertRow(SBlockData *pBlockData, TSDBROW *pRow, STSchema *pTS
     return tBlockDataAppendRow(pBlockData, pRow, pTSchema, uid);
   }
 }
+#endif
 
 void tBlockDataGetColData(SBlockData *pBlockData, int16_t cid, SColData **ppColData) {
   ASSERT(cid != PRIMARYKEY_TIMESTAMP_COL_ID);

source/dnode/vnode/src/vnd/vnodeSvr.c

@@ -238,6 +238,11 @@ static int32_t vnodePreProcessSubmitTbData(SVnode *pVnode, SDecoder *pCoder, int
     TSDB_CHECK_CODE(code, lino, _exit);
   }
 
+  if (submitTbData.flags & SUBMIT_REQ_FROM_FILE) {
+    code = grantCheck(TSDB_GRANT_CSV);
+    TSDB_CHECK_CODE(code, lino, _exit);
+  }
+
   int64_t uid;
   if (submitTbData.flags & SUBMIT_REQ_AUTO_CREATE_TABLE) {
     code = vnodePreprocessCreateTableReq(pVnode, pCoder, btimeMs, &uid);

source/libs/catalog/src/ctgRent.c

@@ -300,7 +300,3 @@ int32_t ctgUpdateRentViewVersion(SCatalog *pCtg, char *dbFName, char *viewName,
 
   return TSDB_CODE_SUCCESS;
 }
-
-
-
-

source/libs/executor/inc/executorInt.h

@@ -556,6 +556,11 @@ typedef struct SStreamIntervalOperatorInfo {
   bool                reCkBlock;
   SSDataBlock*        pCheckpointRes;
   struct SUpdateInfo* pUpdateInfo;
+  bool                recvRetrive;
+  SSDataBlock*        pMidRetriveRes;
+  bool                recvPullover;
+  SSDataBlock*        pMidPulloverRes;
+  bool                clearState;
 } SStreamIntervalOperatorInfo;
 
 typedef struct SDataGroupInfo {

source/libs/executor/inc/querytask.h

@@ -59,6 +59,7 @@ typedef struct STaskStopInfo {
 typedef struct {
   STqOffsetVal         currentOffset;  // for tmq
   SMqMetaRsp           metaRsp;        // for tmq fetching meta
+  int8_t               sourceExcluded;
   int64_t              snapshotVer;
   SSchemaWrapper*      schema;
   char                 tbName[TSDB_TABLE_NAME_LEN];  // this is the current scan table: todo refactor

source/libs/executor/src/executil.c

@@ -2229,6 +2229,8 @@ char* getStreamOpName(uint16_t opType) {
       return "interval final";
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL:
       return "interval semi";
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL:
+      return "interval mid";
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL:
       return "stream fill";
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION:

source/libs/executor/src/executor.c

@@ -947,7 +947,7 @@ int32_t qSetStreamOperatorOptionForScanHistory(qTaskInfo_t tinfo) {
   while (1) {
     int32_t type = pOperator->operatorType;
     if (type == QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL || type == QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL ||
-        type == QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL) {
+        type == QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL || type == QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL) {
       SStreamIntervalOperatorInfo* pInfo = pOperator->info;
       STimeWindowAggSupp* pSup = &pInfo->twAggSup;
 
@@ -1035,7 +1035,7 @@ int32_t qRestoreStreamOperatorOption(qTaskInfo_t tinfo) {
   while (1) {
     uint16_t type = pOperator->operatorType;
     if (type == QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL || type == QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL ||
-        type == QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL) {
+        type == QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL || type == QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL) {
       SStreamIntervalOperatorInfo* pInfo = pOperator->info;
       pInfo->twAggSup.calTrigger = pInfo->twAggSup.calTriggerSaved;
       pInfo->twAggSup.deleteMark = pInfo->twAggSup.deleteMarkSaved;
@@ -1152,6 +1152,11 @@ void qStreamSetOpen(qTaskInfo_t tinfo) {
   pOperator->status = OP_NOT_OPENED;
 }
 
+void qStreamSetSourceExcluded(qTaskInfo_t tinfo, int8_t sourceExcluded) {
+  SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo;
+  pTaskInfo->streamInfo.sourceExcluded = sourceExcluded;
+}
+
 int32_t qStreamPrepareScan(qTaskInfo_t tinfo, STqOffsetVal* pOffset, int8_t subType) {
   SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo;
   SStorageAPI*   pAPI = &pTaskInfo->storageAPI;

source/libs/executor/src/operator.c

@@ -489,6 +489,9 @@ SOperatorInfo* createOperator(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SR
   } else if (QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL == type) {
     int32_t children = 0;
     pOptr = createStreamFinalIntervalOperatorInfo(ops[0], pPhyNode, pTaskInfo, children, pHandle);
+  } else if (QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL == type) {
+    int32_t children = pHandle->numOfVgroups;
+    pOptr = createStreamFinalIntervalOperatorInfo(ops[0], pPhyNode, pTaskInfo, children, pHandle);
   } else if (QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL == type) {
     int32_t children = pHandle->numOfVgroups;
     pOptr = createStreamFinalIntervalOperatorInfo(ops[0], pPhyNode, pTaskInfo, children, pHandle);

source/libs/executor/src/scanoperator.c

@@ -1272,6 +1272,7 @@ static bool isStateWindow(SStreamScanInfo* pInfo) {
 static bool isIntervalWindow(SStreamScanInfo* pInfo) {
   return pInfo->windowSup.parentType == QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL ||
          pInfo->windowSup.parentType == QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL ||
+         pInfo->windowSup.parentType == QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL ||
          pInfo->windowSup.parentType == QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL;
 }
 
@@ -2010,7 +2011,7 @@ static SSDataBlock* doQueueScan(SOperatorInfo* pOperator) {
   if (pTaskInfo->streamInfo.currentOffset.type == TMQ_OFFSET__LOG) {
 
     while (1) {
-      bool hasResult = pAPI->tqReaderFn.tqReaderNextBlockInWal(pInfo->tqReader, id);
+      bool hasResult = pAPI->tqReaderFn.tqReaderNextBlockInWal(pInfo->tqReader, id, pTaskInfo->streamInfo.sourceExcluded);
 
       SSDataBlock* pRes = pAPI->tqReaderFn.tqGetResultBlock(pInfo->tqReader);
       struct SWalReader* pWalReader = pAPI->tqReaderFn.tqReaderGetWalReader(pInfo->tqReader);

source/libs/executor/src/streameventwindowoperator.c

@@ -349,6 +349,7 @@ static void doStreamEventAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBl
     }
 
     if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) {
+      curWin.winInfo.pStatePos->beUpdated = true;
       SSessionKey key = {0};
       getSessionHashKey(&curWin.winInfo.sessionWin, &key);
       tSimpleHashPut(pAggSup->pResultRows, &key, sizeof(SSessionKey), &curWin.winInfo, sizeof(SResultWindowInfo));

source/libs/executor/src/streamtimewindowoperator.c

@@ -28,6 +28,7 @@
 #include "ttime.h"
 
 #define IS_FINAL_INTERVAL_OP(op)           ((op)->operatorType == QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL)
+#define IS_MID_INTERVAL_OP(op)             ((op)->operatorType == QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL)
 #define IS_FINAL_SESSION_OP(op)            ((op)->operatorType == QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION)
 #define DEAULT_DELETE_MARK                 INT64_MAX
 #define STREAM_INTERVAL_OP_STATE_NAME      "StreamIntervalHistoryState"
@@ -48,6 +49,8 @@ typedef struct SPullWindowInfo {
   STimeWindow calWin;
 } SPullWindowInfo;
 
+static SSDataBlock* doStreamMidIntervalAgg(SOperatorInfo* pOperator);
+
 typedef int32_t (*__compare_fn_t)(void* pKey, void* data, int32_t index);
 
 static int32_t binarySearchCom(void* keyList, int num, void* pKey, int order, __compare_fn_t comparefn) {
@@ -235,7 +238,7 @@ static void doDeleteWindows(SOperatorInfo* pOperator, SInterval* pInterval, SSDa
     dumyInfo.cur.pageId = -1;
 
     STimeWindow win = {0};
-    if (IS_FINAL_INTERVAL_OP(pOperator)) {
+    if (IS_FINAL_INTERVAL_OP(pOperator) || IS_MID_INTERVAL_OP(pOperator)) {
       win.skey = startTsCols[i];
       win.ekey = endTsCols[i];
     } else {
@@ -407,6 +410,8 @@ void destroyStreamFinalIntervalOperatorInfo(void* param) {
   blockDataDestroy(pInfo->pPullDataRes);
   taosArrayDestroy(pInfo->pDelWins);
   blockDataDestroy(pInfo->pDelRes);
+  blockDataDestroy(pInfo->pMidRetriveRes);
+  blockDataDestroy(pInfo->pMidPulloverRes);
   pInfo->stateStore.streamFileStateDestroy(pInfo->pState->pFileState);
 
   if (pInfo->pState->dump == 1) {
@@ -599,7 +604,7 @@ static void doBuildPullDataBlock(SArray* array, int32_t* pIndex, SSDataBlock* pB
   blockDataUpdateTsWindow(pBlock, 0);
 }
 
-void processPullOver(SSDataBlock* pBlock, SHashObj* pMap, SHashObj* pFinalMap, SInterval* pInterval, SArray* pPullWins,
+static bool processPullOver(SSDataBlock* pBlock, SHashObj* pMap, SHashObj* pFinalMap, SInterval* pInterval, SArray* pPullWins,
                      int32_t numOfCh, SOperatorInfo* pOperator) {
   SColumnInfoData* pStartCol = taosArrayGet(pBlock->pDataBlock, CALCULATE_START_TS_COLUMN_INDEX);
   TSKEY*           tsData = (TSKEY*)pStartCol->pData;
@@ -608,6 +613,7 @@ void processPullOver(SSDataBlock* pBlock, SHashObj* pMap, SHashObj* pFinalMap, S
   SColumnInfoData* pGroupCol = taosArrayGet(pBlock->pDataBlock, GROUPID_COLUMN_INDEX);
   uint64_t*        groupIdData = (uint64_t*)pGroupCol->pData;
   int32_t          chId = getChildIndex(pBlock);
+  bool             res = false;
   for (int32_t i = 0; i < pBlock->info.rows; i++) {
     TSKEY winTs = tsData[i];
     while (winTs <= tsEndData[i]) {
@@ -623,6 +629,7 @@ void processPullOver(SSDataBlock* pBlock, SHashObj* pMap, SHashObj* pFinalMap, S
             // pull data is over
             taosArrayDestroy(chArray);
             taosHashRemove(pMap, &winRes, sizeof(SWinKey));
+            res =true;
             qDebug("===stream===retrive pull data over.window %" PRId64, winRes.ts);
 
             void* pFinalCh = taosHashGet(pFinalMap, &winRes, sizeof(SWinKey));
@@ -646,6 +653,7 @@ void processPullOver(SSDataBlock* pBlock, SHashObj* pMap, SHashObj* pFinalMap, S
       winTs = taosTimeAdd(winTs, pInterval->sliding, pInterval->slidingUnit, pInterval->precision);
     }
   }
+  return res;
 }
 
 static void addRetriveWindow(SArray* wins, SStreamIntervalOperatorInfo* pInfo, int32_t childId) {
@@ -1182,6 +1190,12 @@ static SSDataBlock* buildIntervalResult(SOperatorInfo* pOperator) {
     printDataBlock(pInfo->binfo.pRes, getStreamOpName(opType), GET_TASKID(pTaskInfo));
     return pInfo->binfo.pRes;
   }
+
+  if (pInfo->recvPullover) {
+    pInfo->recvPullover = false;
+    printDataBlock(pInfo->pMidPulloverRes, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));
+    return pInfo->pMidPulloverRes;
+  }
   return NULL;
 }
 
@@ -1236,11 +1250,15 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) {
     return NULL;
   } else {
     if (!IS_FINAL_INTERVAL_OP(pOperator)) {
-      doBuildDeleteResult(pInfo, pInfo->pDelWins, &pInfo->delIndex, pInfo->pDelRes);
+      SSDataBlock* resBlock = buildIntervalResult(pOperator);
-      if (pInfo->pDelRes->info.rows != 0) {
+      if (resBlock != NULL) {
-        // process the rest of the data
+        return resBlock;
-        printDataBlock(pInfo->pDelRes, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));
+      }
-        return pInfo->pDelRes;
+
+      if (pInfo->recvRetrive) {
+        pInfo->recvRetrive = false;
+        printDataBlock(pInfo->pMidRetriveRes, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));
+        return pInfo->pMidRetriveRes;
       }
     }
   }
@@ -1314,9 +1332,12 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) {
       pInfo->recvGetAll = true;
       getAllIntervalWindow(pInfo->aggSup.pResultRowHashTable, pInfo->pUpdatedMap);
       continue;
-    } else if (pBlock->info.type == STREAM_RETRIEVE && !IS_FINAL_INTERVAL_OP(pOperator)) {
+    } else if (pBlock->info.type == STREAM_RETRIEVE) {
+      if(!IS_FINAL_INTERVAL_OP(pOperator)) {
+        pInfo->recvRetrive = true;
+        copyDataBlock(pInfo->pMidRetriveRes, pBlock);
+        pInfo->pMidRetriveRes->info.type = STREAM_MID_RETRIEVE;
         doDeleteWindows(pOperator, &pInfo->interval, pBlock, NULL, pInfo->pUpdatedMap);
-      if (taosArrayGetSize(pInfo->pUpdated) > 0) {
         break;
       }
       continue;
@@ -1331,6 +1352,8 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) {
       doStreamIntervalSaveCheckpoint(pOperator);
       copyDataBlock(pInfo->pCheckpointRes, pBlock);
       continue;
+    } else if (IS_FINAL_INTERVAL_OP(pOperator) && pBlock->info.type == STREAM_MID_RETRIEVE) {
+      continue;
     } else {
       ASSERTS(pBlock->info.type == STREAM_INVALID, "invalid SSDataBlock type");
     }
@@ -1359,7 +1382,18 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) {
   pInfo->pUpdated = NULL;
   blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity);
 
-  return buildIntervalResult(pOperator);
+  SSDataBlock* resBlock = buildIntervalResult(pOperator);
+  if (resBlock != NULL) {
+    return resBlock;
+  }
+
+  if (pInfo->recvRetrive) {
+    pInfo->recvRetrive = false;
+    printDataBlock(pInfo->pMidRetriveRes, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));
+    return pInfo->pMidRetriveRes;
+  }
+
+  return NULL;
 }
 
 int64_t getDeleteMark(SWindowPhysiNode* pWinPhyNode, int64_t interval) {
@@ -1400,7 +1434,8 @@ static int32_t getMaxFunResSize(SExprSupp* pSup, int32_t numOfCols) {
 }
 
 static void streamIntervalReleaseState(SOperatorInfo* pOperator) {
-  if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL) {
+  if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL &&
+      pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL) {
     SStreamIntervalOperatorInfo* pInfo = pOperator->info;
     int32_t                      resSize = sizeof(TSKEY);
     pInfo->stateStore.streamStateSaveInfo(pInfo->pState, STREAM_INTERVAL_OP_STATE_NAME,
@@ -1417,7 +1452,8 @@ static void streamIntervalReleaseState(SOperatorInfo* pOperator) {
 
 void streamIntervalReloadState(SOperatorInfo* pOperator) {
   SStreamIntervalOperatorInfo* pInfo = pOperator->info;
-  if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL) {
+  if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL &&
+      pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL) {
     int32_t                      size = 0;
     void*                        pBuf = NULL;
     int32_t code = pInfo->stateStore.streamStateGetInfo(pInfo->pState, STREAM_INTERVAL_OP_STATE_NAME,
@@ -1442,6 +1478,7 @@ SOperatorInfo* createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream,
   SIntervalPhysiNode*          pIntervalPhyNode = (SIntervalPhysiNode*)pPhyNode;
   SStreamIntervalOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamIntervalOperatorInfo));
   SOperatorInfo*               pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
+  int32_t                      code = 0;
   if (pInfo == NULL || pOperator == NULL) {
     goto _error;
   }
@@ -1471,7 +1508,7 @@ SOperatorInfo* createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream,
   if (pIntervalPhyNode->window.pExprs != NULL) {
     int32_t    numOfScalar = 0;
     SExprInfo* pScalarExprInfo = createExprInfo(pIntervalPhyNode->window.pExprs, NULL, &numOfScalar);
-    int32_t code = initExprSupp(&pInfo->scalarSupp, pScalarExprInfo, numOfScalar, &pTaskInfo->storageAPI.functionStore);
+    code = initExprSupp(&pInfo->scalarSupp, pScalarExprInfo, numOfScalar, &pTaskInfo->storageAPI.functionStore);
     if (code != TSDB_CODE_SUCCESS) {
       goto _error;
     }
@@ -1490,7 +1527,7 @@ SOperatorInfo* createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream,
   qInfo("copy state %p to %p", pTaskInfo->streamInfo.pState, pInfo->pState);
 
   pAPI->stateStore.streamStateSetNumber(pInfo->pState, -1);
-  int32_t code = initAggSup(&pOperator->exprSupp, &pInfo->aggSup, pExprInfo, numOfCols, keyBufSize, pTaskInfo->id.str,
+  code = initAggSup(&pOperator->exprSupp, &pInfo->aggSup, pExprInfo, numOfCols, keyBufSize, pTaskInfo->id.str,
                             pInfo->pState, &pTaskInfo->storageAPI.functionStore);
   if (code != TSDB_CODE_SUCCESS) {
     goto _error;
@@ -1526,6 +1563,10 @@ SOperatorInfo* createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream,
   pInfo->stateStore = pTaskInfo->storageAPI.stateStore;
   pInfo->recvGetAll = false;
   pInfo->pCheckpointRes = createSpecialDataBlock(STREAM_CHECKPOINT);
+  pInfo->recvRetrive = false;
+  pInfo->pMidRetriveRes = createSpecialDataBlock(STREAM_MID_RETRIEVE);
+  pInfo->pMidPulloverRes = createSpecialDataBlock(STREAM_MID_RETRIEVE);
+  pInfo->clearState = false;
 
   pOperator->operatorType = pPhyNode->type;
   if (!IS_FINAL_INTERVAL_OP(pOperator) || numOfChild == 0) {
@@ -1536,10 +1577,16 @@ SOperatorInfo* createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream,
   pOperator->status = OP_NOT_OPENED;
   pOperator->info = pInfo;
 
+  if (pPhyNode->type == QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL) {
+    pOperator->fpSet = createOperatorFpSet(NULL, doStreamMidIntervalAgg, NULL, destroyStreamFinalIntervalOperatorInfo,
+                                           optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
+  } else {
     pOperator->fpSet = createOperatorFpSet(NULL, doStreamFinalIntervalAgg, NULL, destroyStreamFinalIntervalOperatorInfo,
                                            optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
+  }
   setOperatorStreamStateFn(pOperator, streamIntervalReleaseState, streamIntervalReloadState);
-  if (pPhyNode->type == QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL) {
+  if (pPhyNode->type == QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL ||
+      pPhyNode->type == QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL) {
     initIntervalDownStream(downstream, pPhyNode->type, pInfo);
   }
   code = appendDownstream(pOperator, &downstream, 1);
@@ -2083,6 +2130,7 @@ static void doStreamSessionAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSData
       }
     }
     if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) {
+      winInfo.pStatePos->beUpdated = true;
       SSessionKey key = {0};
       getSessionHashKey(&winInfo.sessionWin, &key);
       tSimpleHashPut(pAggSup->pResultRows, &key, sizeof(SSessionKey), &winInfo, sizeof(SResultWindowInfo));
@@ -2286,6 +2334,10 @@ int32_t getAllSessionWindow(SSHashObj* pHashMap, SSHashObj* pStUpdated) {
   int32_t iter = 0;
   while ((pIte = tSimpleHashIterate(pHashMap, pIte, &iter)) != NULL) {
     SResultWindowInfo* pWinInfo = pIte;
+    if (!pWinInfo->pStatePos->beUpdated) {
+      continue;
+    }
+    pWinInfo->pStatePos->beUpdated = false;
     saveResult(*pWinInfo, pStUpdated);
   }
   return TSDB_CODE_SUCCESS;
@@ -3425,6 +3477,7 @@ static void doStreamStateAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBl
     }
 
     if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) {
+      curWin.winInfo.pStatePos->beUpdated = true;
       SSessionKey key = {0};
       getSessionHashKey(&curWin.winInfo.sessionWin, &key);
       tSimpleHashPut(pAggSup->pResultRows, &key, sizeof(SSessionKey), &curWin.winInfo, sizeof(SResultWindowInfo));
@@ -4108,6 +4161,285 @@ _error:
   return NULL;
 }
 
+static void doStreamMidIntervalAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBlock, SSHashObj* pUpdatedMap) {
+  SStreamIntervalOperatorInfo* pInfo = (SStreamIntervalOperatorInfo*)pOperator->info;
+  pInfo->dataVersion = TMAX(pInfo->dataVersion, pSDataBlock->info.version);
+
+  SResultRowInfo*  pResultRowInfo = &(pInfo->binfo.resultRowInfo);
+  SExecTaskInfo*   pTaskInfo = pOperator->pTaskInfo;
+  SExprSupp*       pSup = &pOperator->exprSupp;
+  int32_t          numOfOutput = pSup->numOfExprs;
+  int32_t          step = 1;
+  SRowBuffPos*     pResPos = NULL;
+  SResultRow*      pResult = NULL;
+  int32_t          forwardRows = 1;
+  uint64_t         groupId = pSDataBlock->info.id.groupId;
+  SColumnInfoData* pColDataInfo = taosArrayGet(pSDataBlock->pDataBlock, pInfo->primaryTsIndex);
+  TSKEY*           tsCol = (int64_t*)pColDataInfo->pData;
+
+  int32_t     startPos = 0;
+  TSKEY       ts = getStartTsKey(&pSDataBlock->info.window, tsCol);
+  STimeWindow nextWin = getFinalTimeWindow(ts, &pInfo->interval);
+
+  while (1) {
+    SWinKey key = {
+        .ts = nextWin.skey,
+        .groupId = groupId,
+    };
+    void* chIds = taosHashGet(pInfo->pPullDataMap, &key, sizeof(SWinKey));
+    int32_t index = -1;
+    SArray* chArray = NULL;
+    int32_t chId = 0;
+    if (chIds) {
+      chArray = *(void**)chIds;
+      chId = getChildIndex(pSDataBlock);
+      index = taosArraySearchIdx(chArray, &chId, compareInt32Val, TD_EQ);
+    }
+    if (!(index == -1 || pSDataBlock->info.type == STREAM_PULL_DATA)) {
+      startPos = getNextQualifiedFinalWindow(&pInfo->interval, &nextWin, &pSDataBlock->info, tsCol, startPos);
+      if (startPos < 0) {
+        break;
+      }
+      continue;
+    }
+
+    if (!inSlidingWindow(&pInfo->interval, &nextWin, &pSDataBlock->info)) {
+      startPos = getNexWindowPos(&pInfo->interval, &pSDataBlock->info, tsCol, startPos, nextWin.ekey, &nextWin);
+      if (startPos < 0) {
+        break;
+      }
+      continue;
+    }
+
+    int32_t code = setIntervalOutputBuf(pInfo->pState, &nextWin, &pResPos, groupId, pSup->pCtx, numOfOutput,
+                                        pSup->rowEntryInfoOffset, &pInfo->aggSup, &pInfo->stateStore);
+    pResult = (SResultRow*)pResPos->pRowBuff;
+    if (code != TSDB_CODE_SUCCESS || pResult == NULL) {
+      T_LONG_JMP(pTaskInfo->env, TSDB_CODE_OUT_OF_MEMORY);
+    }
+
+    if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE) {
+      saveWinResult(&key, pResPos, pUpdatedMap);
+    }
+
+    if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) {
+      tSimpleHashPut(pInfo->aggSup.pResultRowHashTable, &key, sizeof(SWinKey), &pResPos, POINTER_BYTES);
+    }
+
+    updateTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &nextWin, 1);
+    applyAggFunctionOnPartialTuples(pTaskInfo, pSup->pCtx, &pInfo->twAggSup.timeWindowData, startPos, forwardRows,
+                                    pSDataBlock->info.rows, numOfOutput);
+    key.ts = nextWin.skey;
+
+    if (pInfo->delKey.ts > key.ts) {
+      pInfo->delKey = key;
+    }
+    int32_t prevEndPos = (forwardRows - 1) * step + startPos;
+    if (pSDataBlock->info.window.skey <= 0 || pSDataBlock->info.window.ekey <= 0) {
+      qError("table uid %" PRIu64 " data block timestamp range may not be calculated! minKey %" PRId64
+             ",maxKey %" PRId64,
+             pSDataBlock->info.id.uid, pSDataBlock->info.window.skey, pSDataBlock->info.window.ekey);
+      blockDataUpdateTsWindow(pSDataBlock, 0);
+
+      // timestamp of the data is incorrect
+      if (pSDataBlock->info.window.skey <= 0 || pSDataBlock->info.window.ekey <= 0) {
+        qError("table uid %" PRIu64 " data block timestamp is out of range! minKey %" PRId64 ",maxKey %" PRId64,
+               pSDataBlock->info.id.uid, pSDataBlock->info.window.skey, pSDataBlock->info.window.ekey);
+      }
+    }
+    startPos = getNextQualifiedFinalWindow(&pInfo->interval, &nextWin, &pSDataBlock->info, tsCol, prevEndPos);
+    if (startPos < 0) {
+      break;
+    }
+  }
+}
+
+static void addMidRetriveWindow(SArray* wins, SHashObj* pMidPullMap, int32_t numOfChild) {
+  int32_t size = taosArrayGetSize(wins);
+  for (int32_t i = 0; i < size; i++) {
+    SWinKey*    winKey = taosArrayGet(wins, i);
+    void* chIds = taosHashGet(pMidPullMap, winKey, sizeof(SWinKey));
+    if (!chIds) {
+      addPullWindow(pMidPullMap, winKey, numOfChild);
+      qDebug("===stream===prepare mid operator retrive for delete %" PRId64 ", size:%d", winKey->ts, numOfChild);
+    }
+  }
+}
+
+static SSDataBlock* doStreamMidIntervalAgg(SOperatorInfo* pOperator) {
+  SStreamIntervalOperatorInfo* pInfo = pOperator->info;
+  SExecTaskInfo*               pTaskInfo = pOperator->pTaskInfo;
+  SStorageAPI*                 pAPI = &pOperator->pTaskInfo->storageAPI;
+  SOperatorInfo*               downstream = pOperator->pDownstream[0];
+  SExprSupp*                   pSup = &pOperator->exprSupp;
+
+  qDebug("stask:%s  %s status: %d", GET_TASKID(pTaskInfo), getStreamOpName(pOperator->operatorType), pOperator->status);
+
+  if (pOperator->status == OP_EXEC_DONE) {
+    return NULL;
+  } else if (pOperator->status == OP_RES_TO_RETURN) {
+    SSDataBlock* resBlock = buildIntervalResult(pOperator);
+    if (resBlock != NULL) {
+      return resBlock;
+    }
+
+    setOperatorCompleted(pOperator);
+    clearFunctionContext(&pOperator->exprSupp);
+    clearStreamIntervalOperator(pInfo);
+    qDebug("stask:%s  ===stream===%s clear", GET_TASKID(pTaskInfo), getStreamOpName(pOperator->operatorType));
+    return NULL;
+  } else {
+    SSDataBlock* resBlock = buildIntervalResult(pOperator);
+    if (resBlock != NULL) {
+      return resBlock;
+    }
+
+    if (pInfo->recvRetrive) {
+      pInfo->recvRetrive = false;
+      printDataBlock(pInfo->pMidRetriveRes, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));
+      return pInfo->pMidRetriveRes;
+    }
+
+    if (pInfo->clearState) {
+      pInfo->clearState = false;
+      clearFunctionContext(&pOperator->exprSupp);
+      clearStreamIntervalOperator(pInfo);
+    }
+  }
+
+  if (!pInfo->pUpdated) {
+    pInfo->pUpdated = taosArrayInit(4096, POINTER_BYTES);
+  }
+  if (!pInfo->pUpdatedMap) {
+    _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
+    pInfo->pUpdatedMap = tSimpleHashInit(4096, hashFn);
+  }
+
+  while (1) {
+    if (isTaskKilled(pTaskInfo)) {
+      if (pInfo->pUpdated != NULL) {
+        pInfo->pUpdated = taosArrayDestroy(pInfo->pUpdated);
+      }
+
+      if (pInfo->pUpdatedMap != NULL) {
+        tSimpleHashCleanup(pInfo->pUpdatedMap);
+        pInfo->pUpdatedMap = NULL;
+      }
+
+      T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+    }
+
+    SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
+    if (pBlock == NULL) {
+      pOperator->status = OP_RES_TO_RETURN;
+      qDebug("===stream===return data:%s. recv datablock num:%" PRIu64, getStreamOpName(pOperator->operatorType),
+             pInfo->numOfDatapack);
+      pInfo->numOfDatapack = 0;
+      break;
+    }
+    pInfo->numOfDatapack++;
+    printSpecDataBlock(pBlock, getStreamOpName(pOperator->operatorType), "recv", GET_TASKID(pTaskInfo));
+
+    if (pBlock->info.type == STREAM_NORMAL || pBlock->info.type == STREAM_PULL_DATA) {
+      pInfo->binfo.pRes->info.type = pBlock->info.type;
+    } else if (pBlock->info.type == STREAM_DELETE_DATA || pBlock->info.type == STREAM_DELETE_RESULT ||
+               pBlock->info.type == STREAM_CLEAR) {
+      SArray* delWins = taosArrayInit(8, sizeof(SWinKey));
+      doDeleteWindows(pOperator, &pInfo->interval, pBlock, delWins, pInfo->pUpdatedMap);
+      removeResults(delWins, pInfo->pUpdatedMap);
+      taosArrayAddAll(pInfo->pDelWins, delWins);
+      taosArrayDestroy(delWins);
+
+      doBuildDeleteResult(pInfo, pInfo->pDelWins, &pInfo->delIndex, pInfo->pDelRes);
+      if (pInfo->pDelRes->info.rows != 0) {
+        // process the rest of the data
+        printDataBlock(pInfo->pDelRes, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));
+        if (pBlock->info.type == STREAM_CLEAR) {
+          pInfo->pDelRes->info.type = STREAM_CLEAR;
+        } else {
+          pInfo->pDelRes->info.type = STREAM_DELETE_RESULT;
+        }
+        ASSERT(taosArrayGetSize(pInfo->pUpdated) == 0);
+        return pInfo->pDelRes;
+      }
+      continue;
+    } else if (pBlock->info.type == STREAM_CREATE_CHILD_TABLE) {
+      return pBlock;
+    } else if (pBlock->info.type == STREAM_PULL_OVER) {
+      pInfo->recvPullover = processPullOver(pBlock, pInfo->pPullDataMap, pInfo->pFinalPullDataMap, &pInfo->interval,
+                                            pInfo->pPullWins, pInfo->numOfChild, pOperator);
+      if (pInfo->recvPullover) {
+        copyDataBlock(pInfo->pMidPulloverRes, pBlock);
+        pInfo->clearState = true;
+        break;
+      }
+      continue;
+    } else if (pBlock->info.type == STREAM_CHECKPOINT) {
+      pAPI->stateStore.streamStateCommit(pInfo->pState);
+      doStreamIntervalSaveCheckpoint(pOperator);
+      copyDataBlock(pInfo->pCheckpointRes, pBlock);
+      continue;
+    } else if (pBlock->info.type == STREAM_MID_RETRIEVE) {
+      SArray* delWins = taosArrayInit(8, sizeof(SWinKey));
+      doDeleteWindows(pOperator, &pInfo->interval, pBlock, delWins, pInfo->pUpdatedMap);
+      addMidRetriveWindow(delWins, pInfo->pPullDataMap, pInfo->numOfChild);
+      taosArrayDestroy(delWins);
+      pInfo->recvRetrive = true;
+      copyDataBlock(pInfo->pMidRetriveRes, pBlock);
+      pInfo->pMidRetriveRes->info.type = STREAM_MID_RETRIEVE;
+      pInfo->clearState = true;
+      break;
+    } else {
+      ASSERTS(pBlock->info.type == STREAM_INVALID, "invalid SSDataBlock type");
+    }
+
+    if (pInfo->scalarSupp.pExprInfo != NULL) {
+      SExprSupp* pExprSup = &pInfo->scalarSupp;
+      projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL);
+    }
+    setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true);
+    doStreamMidIntervalAggImpl(pOperator, pBlock, pInfo->pUpdatedMap);
+    pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey);
+    pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.watermark);
+    pInfo->twAggSup.minTs = TMIN(pInfo->twAggSup.minTs, pBlock->info.window.skey);
+  }
+
+  removeDeleteResults(pInfo->pUpdatedMap, pInfo->pDelWins);
+  pInfo->binfo.pRes->info.watermark = pInfo->twAggSup.maxTs;
+
+  void*   pIte = NULL;
+  int32_t iter = 0;
+  while ((pIte = tSimpleHashIterate(pInfo->pUpdatedMap, pIte, &iter)) != NULL) {
+    taosArrayPush(pInfo->pUpdated, pIte);
+  }
+
+  tSimpleHashCleanup(pInfo->pUpdatedMap);
+  pInfo->pUpdatedMap = NULL;
+  taosArraySort(pInfo->pUpdated, winPosCmprImpl);
+
+  initMultiResInfoFromArrayList(&pInfo->groupResInfo, pInfo->pUpdated);
+  pInfo->pUpdated = NULL;
+  blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity);
+
+  SSDataBlock* resBlock = buildIntervalResult(pOperator);
+  if (resBlock != NULL) {
+    return resBlock;
+  }
+
+  if (pInfo->recvRetrive) {
+    pInfo->recvRetrive = false;
+    printDataBlock(pInfo->pMidRetriveRes, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));
+    return pInfo->pMidRetriveRes;
+  }
+
+  if (pInfo->clearState) {
+    pInfo->clearState = false;
+    clearFunctionContext(&pOperator->exprSupp);
+    clearStreamIntervalOperator(pInfo);
+  }
+  return NULL;
+}
+
 void setStreamOperatorCompleted(SOperatorInfo* pOperator) {
   setOperatorCompleted(pOperator);
   qDebug("stask:%s  %s status: %d. set completed", GET_TASKID(pOperator->pTaskInfo), getStreamOpName(pOperator->operatorType), pOperator->status);

source/libs/function/inc/builtins.h

@@ -45,6 +45,7 @@ typedef struct SBuiltinFuncDefinition {
 #endif
   FExecCombine               combineFunc;
   const char*                pPartialFunc;
+  const char*                pMiddleFunc;
   const char*                pMergeFunc;
   FCreateMergeFuncParameters createMergeParaFuc;
   FEstimateReturnRows        estimateReturnRowsFunc;

source/libs/function/src/builtins.c

@@ -433,6 +433,20 @@ static int32_t translateAvgPartial(SFunctionNode* pFunc, char* pErrBuf, int32_t
   return TSDB_CODE_SUCCESS;
 }
 
+static int32_t translateAvgMiddle(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
+  if (1 != LIST_LENGTH(pFunc->pParameterList)) {
+    return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
+  }
+
+  uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  if (TSDB_DATA_TYPE_BINARY != paraType) {
+    return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
+  }
+
+  pFunc->node.resType = (SDataType){.bytes = getAvgInfoSize() + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY};
+  return TSDB_CODE_SUCCESS;
+}
+
 static int32_t translateAvgMerge(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
   if (1 != LIST_LENGTH(pFunc->pParameterList)) {
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
@@ -2515,6 +2529,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
 #endif
     .combineFunc  = avgCombine,
     .pPartialFunc = "_avg_partial",
+    .pMiddleFunc  = "_avg_middle",
     .pMergeFunc   = "_avg_merge"
   },
   {
@@ -3775,6 +3790,21 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .sprocessFunc = toCharFunction,
     .finalizeFunc = NULL
   },
+  {
+    .name = "_avg_middle",
+    .type = FUNCTION_TYPE_AVG_PARTIAL,
+    .classification = FUNC_MGT_AGG_FUNC,
+    .translateFunc = translateAvgMiddle,
+    .dataRequiredFunc = statisDataRequired,
+    .getEnvFunc   = getAvgFuncEnv,
+    .initFunc     = avgFunctionSetup,
+    .processFunc  = avgFunctionMerge,
+    .finalizeFunc = avgPartialFinalize,
+#ifdef BUILD_NO_CALL
+    .invertFunc   = avgInvertFunction,
+#endif
+    .combineFunc  = avgCombine,
+  },
   {
     .name = "_vgver",
     .type = FUNCTION_TYPE_VGVER,
@@ -3785,7 +3815,6 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .sprocessFunc = qPseudoTagFunction,
     .finalizeFunc = NULL
   }
-  
 };
 // clang-format on
 

source/libs/function/src/functionMgt.c

@@ -424,6 +424,35 @@ static int32_t createMergeFuncPara(const SFunctionNode* pSrcFunc, const SFunctio
   }
 }
 
+static int32_t createMidFunction(const SFunctionNode* pSrcFunc, const SFunctionNode* pPartialFunc,
+                                   SFunctionNode** pMidFunc) {
+  SNodeList*     pParameterList = NULL;
+  SFunctionNode* pFunc = NULL;
+
+  int32_t code = createMergeFuncPara(pSrcFunc, pPartialFunc, &pParameterList);
+  if (TSDB_CODE_SUCCESS == code) {
+    if(funcMgtBuiltins[pSrcFunc->funcId].pMiddleFunc != NULL){
+      pFunc = createFunction(funcMgtBuiltins[pSrcFunc->funcId].pMiddleFunc, pParameterList);
+    }else{
+      pFunc = createFunction(funcMgtBuiltins[pSrcFunc->funcId].pMergeFunc, pParameterList);
+    }
+    if (NULL == pFunc) {
+      code = TSDB_CODE_OUT_OF_MEMORY;
+    }
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    strcpy(pFunc->node.aliasName, pPartialFunc->node.aliasName);
+  }
+
+  if (TSDB_CODE_SUCCESS == code) {
+    *pMidFunc = pFunc;
+  } else {
+    nodesDestroyList(pParameterList);
+  }
+
+  return code;
+}
+
 static int32_t createMergeFunction(const SFunctionNode* pSrcFunc, const SFunctionNode* pPartialFunc,
                                    SFunctionNode** pMergeFunc) {
   SNodeList*     pParameterList = NULL;
@@ -453,18 +482,22 @@ static int32_t createMergeFunction(const SFunctionNode* pSrcFunc, const SFunctio
   return code;
 }
 
-int32_t fmGetDistMethod(const SFunctionNode* pFunc, SFunctionNode** pPartialFunc, SFunctionNode** pMergeFunc) {
+int32_t fmGetDistMethod(const SFunctionNode* pFunc, SFunctionNode** pPartialFunc, SFunctionNode** pMidFunc, SFunctionNode** pMergeFunc) {
   if (!fmIsDistExecFunc(pFunc->funcId)) {
     return TSDB_CODE_FAILED;
   }
 
   int32_t code = createPartialFunction(pFunc, pPartialFunc);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = createMidFunction(pFunc, *pPartialFunc, pMidFunc);
+  }
   if (TSDB_CODE_SUCCESS == code) {
     code = createMergeFunction(pFunc, *pPartialFunc, pMergeFunc);
   }
 
   if (TSDB_CODE_SUCCESS != code) {
     nodesDestroyNode((SNode*)*pPartialFunc);
+    nodesDestroyNode((SNode*)*pMidFunc);
     nodesDestroyNode((SNode*)*pMergeFunc);
   }
 

source/libs/index/src/indexFstRegex.c

@@ -42,6 +42,7 @@ void regexDestroy(FstRegex *regex) {
   taosMemoryFree(regex);
 }
 
+#ifdef BUILD_NO_CALL
 uint32_t regexAutomStart(FstRegex *regex) {
   ///// no nothing
   return 0;
@@ -65,3 +66,4 @@ bool regexAutomAccept(FstRegex *regex, uint32_t state, uint8_t byte, uint32_t *r
   }
   return dfaAccept(regex->dfa, state, byte, result);
 }
+#endif

source/libs/index/src/indexTfile.c

@@ -684,12 +684,14 @@ int idxTFileSearch(void* tfile, SIndexTermQuery* query, SIdxTRslt* result) {
 
   return tfileReaderSearch(reader, query, result);
 }
+#ifdef BUILD_NO_CALL
 int idxTFilePut(void* tfile, SIndexTerm* term, uint64_t uid) {
   // TFileWriterOpt wOpt = {.suid = term->suid, .colType = term->colType, .colName = term->colName, .nColName =
   // term->nColName, .version = 1};
 
   return 0;
 }
+#endif
 static bool tfileIteratorNext(Iterate* iiter) {
   IterateValue* iv = &iiter->val;
   iterateValueDestroy(iv, false);

source/libs/nodes/src/nodesCloneFuncs.c

@@ -959,6 +959,7 @@ SNode* nodesCloneNode(const SNode* pNode) {
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL:
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL:
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL:
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL:
       code = physiIntervalCopy((const SIntervalPhysiNode*)pNode, (SIntervalPhysiNode*)pDst);
       break;
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION:

source/libs/nodes/src/nodesCodeFuncs.c

@@ -369,6 +369,8 @@ const char* nodesNodeName(ENodeType type) {
       return "PhysiStreamFinalInterval";
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL:
       return "PhysiStreamSemiInterval";
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL:
+      return "PhysiStreamMidInterval";
     case QUERY_NODE_PHYSICAL_PLAN_FILL:
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL:
       return "PhysiFill";
@@ -3294,6 +3296,8 @@ static const char* jkSubplanTagIndexCond = "TagIndexCond";
 static const char* jkSubplanShowRewrite = "ShowRewrite";
 static const char* jkSubplanRowsThreshold = "RowThreshold";
 static const char* jkSubplanDynamicRowsThreshold = "DyRowThreshold";
+static const char* jkSubplanIsView = "IsView";
+static const char* jkSubplanIsAudit = "IsAudit";
 
 static int32_t subplanToJson(const void* pObj, SJson* pJson) {
   const SSubplan* pNode = (const SSubplan*)pObj;
@@ -3332,6 +3336,12 @@ static int32_t subplanToJson(const void* pObj, SJson* pJson) {
   if (TSDB_CODE_SUCCESS == code) {
     code = tjsonAddBoolToObject(pJson, jkSubplanShowRewrite, pNode->showRewrite);
   }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonAddBoolToObject(pJson, jkSubplanIsView, pNode->isView);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonAddBoolToObject(pJson, jkSubplanIsAudit, pNode->isAudit);
+  }
   if (TSDB_CODE_SUCCESS == code) {
     code = tjsonAddIntegerToObject(pJson, jkSubplanRowsThreshold, pNode->rowsThreshold);
   }
@@ -3379,6 +3389,12 @@ static int32_t jsonToSubplan(const SJson* pJson, void* pObj) {
   if (TSDB_CODE_SUCCESS == code) {
     code = tjsonGetBoolValue(pJson, jkSubplanShowRewrite, &pNode->showRewrite);
   }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonGetBoolValue(pJson, jkSubplanIsView, &pNode->isView);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonGetBoolValue(pJson, jkSubplanIsAudit, &pNode->isAudit);
+  }
   if (TSDB_CODE_SUCCESS == code) {
     code = tjsonGetIntValue(pJson, jkSubplanRowsThreshold, &pNode->rowsThreshold);
   }
@@ -7192,6 +7208,7 @@ static int32_t specificNodeToJson(const void* pObj, SJson* pJson) {
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL:
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL:
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL:
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL:
       return physiIntervalNodeToJson(pObj, pJson);
     case QUERY_NODE_PHYSICAL_PLAN_FILL:
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL:
@@ -7531,6 +7548,7 @@ static int32_t jsonToSpecificNode(const SJson* pJson, void* pObj) {
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL:
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL:
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL:
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL:
       return jsonToPhysiIntervalNode(pJson, pObj);
     case QUERY_NODE_PHYSICAL_PLAN_FILL:
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL:

source/libs/nodes/src/nodesMsgFuncs.c

@@ -3930,6 +3930,12 @@ static int32_t subplanInlineToMsg(const void* pObj, STlvEncoder* pEncoder) {
   if (TSDB_CODE_SUCCESS == code) {
     code = tlvEncodeValueBool(pEncoder, pNode->dynamicRowThreshold);
   }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tlvEncodeValueBool(pEncoder, pNode->isView);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tlvEncodeValueBool(pEncoder, pNode->isAudit);
+  }
 
   return code;
 }
@@ -3985,7 +3991,12 @@ static int32_t msgToSubplanInline(STlvDecoder* pDecoder, void* pObj) {
   if (TSDB_CODE_SUCCESS == code) {
     code = tlvDecodeValueBool(pDecoder, &pNode->dynamicRowThreshold);
   }
-
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tlvDecodeValueBool(pDecoder, &pNode->isView);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tlvDecodeValueBool(pDecoder, &pNode->isAudit);
+  }
   return code;
 }
 
@@ -4168,6 +4179,7 @@ static int32_t specificNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL:
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL:
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL:
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL:
       code = physiIntervalNodeToMsg(pObj, pEncoder);
       break;
     case QUERY_NODE_PHYSICAL_PLAN_FILL:
@@ -4322,6 +4334,7 @@ static int32_t msgToSpecificNode(STlvDecoder* pDecoder, void* pObj) {
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL:
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL:
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL:
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL:
       code = msgToPhysiIntervalNode(pDecoder, pObj);
       break;
     case QUERY_NODE_PHYSICAL_PLAN_FILL:

source/libs/nodes/src/nodesUtilFuncs.c

@@ -564,6 +564,8 @@ SNode* nodesMakeNode(ENodeType type) {
       return makeNode(type, sizeof(SStreamFinalIntervalPhysiNode));
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL:
       return makeNode(type, sizeof(SStreamSemiIntervalPhysiNode));
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL:
+      return makeNode(type, sizeof(SStreamMidIntervalPhysiNode));
     case QUERY_NODE_PHYSICAL_PLAN_FILL:
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL:
       return makeNode(type, sizeof(SFillPhysiNode));
@@ -1391,6 +1393,7 @@ void nodesDestroyNode(SNode* pNode) {
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL:
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL:
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL:
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL:
       destroyWinodwPhysiNode((SWindowPhysiNode*)pNode);
       break;
     case QUERY_NODE_PHYSICAL_PLAN_FILL:

source/libs/parser/inc/sql.y

@@ -516,7 +516,7 @@ cmd ::= SHOW VNODES.
 // show alive
 cmd ::= SHOW db_name_cond_opt(A) ALIVE.                                           { pCxt->pRootNode = createShowAliveStmt(pCxt, A,    QUERY_NODE_SHOW_DB_ALIVE_STMT); }
 cmd ::= SHOW CLUSTER ALIVE.                                                       { pCxt->pRootNode = createShowAliveStmt(pCxt, NULL, QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT); }
-cmd ::= SHOW db_name_cond_opt(A) VIEWS.                                           { pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VIEWS_STMT, A, NULL, OP_TYPE_LIKE); }
+cmd ::= SHOW db_name_cond_opt(A) VIEWS like_pattern_opt(B).                       { pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VIEWS_STMT, A, B, OP_TYPE_LIKE); }
 cmd ::= SHOW CREATE VIEW full_table_name(A).                                      { pCxt->pRootNode = createShowCreateViewStmt(pCxt, QUERY_NODE_SHOW_CREATE_VIEW_STMT, A); }
 cmd ::= SHOW COMPACTS.                                                            { pCxt->pRootNode = createShowCompactsStmt(pCxt, QUERY_NODE_SHOW_COMPACTS_STMT); }
 cmd ::= SHOW COMPACT NK_INTEGER(A).                                               { pCxt->pRootNode = createShowCompactDetailsStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &A)); }

source/libs/parser/src/parInsertSql.c

@@ -2144,13 +2144,15 @@ static int32_t parseDataFromFileImpl(SInsertParseContext* pCxt, SVnodeModifyOpSt
     pStmt->pTableCxtHashObj =
         taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
   }
-
   int32_t numOfRows = 0;
   int32_t code = parseCsvFile(pCxt, pStmt, rowsDataCxt, &numOfRows);
   if (TSDB_CODE_SUCCESS == code) {
     pStmt->totalRowsNum += numOfRows;
     pStmt->totalTbNum += 1;
     TSDB_QUERY_SET_TYPE(pStmt->insertType, TSDB_QUERY_TYPE_FILE_INSERT);
+    if (rowsDataCxt.pTableDataCxt && rowsDataCxt.pTableDataCxt->pData) {
+      rowsDataCxt.pTableDataCxt->pData->flags |= SUBMIT_REQ_FROM_FILE;
+    }
     if (!pStmt->fileProcessing) {
       taosCloseFile(&pStmt->fp);
     } else {

source/libs/parser/src/parInsertUtil.c

@@ -211,6 +211,7 @@ static int32_t createTableDataCxt(STableMeta* pTableMeta, SVCreateTbReq** pCreat
                                   bool colMode, bool ignoreColVals) {
   STableDataCxt* pTableCxt = taosMemoryCalloc(1, sizeof(STableDataCxt));
   if (NULL == pTableCxt) {
+    *pOutput = NULL;
     return TSDB_CODE_OUT_OF_MEMORY;
   }
 
@@ -268,12 +269,8 @@ static int32_t createTableDataCxt(STableMeta* pTableMeta, SVCreateTbReq** pCreat
     }
   }
 
-  if (TSDB_CODE_SUCCESS == code) {
   *pOutput = pTableCxt;
-    qDebug("tableDataCxt created, uid:%" PRId64 ", vgId:%d", pTableMeta->uid, pTableMeta->vgId);
+  qDebug("tableDataCxt created, code:%d, uid:%" PRId64 ", vgId:%d", code, pTableMeta->uid, pTableMeta->vgId);
-  } else {
-    taosMemoryFree(pTableCxt);
-  }
 
   return code;
 }
@@ -288,6 +285,7 @@ static int32_t rebuildTableData(SSubmitTbData* pSrc, SSubmitTbData** pDst) {
     pTmp->suid = pSrc->suid;
     pTmp->uid = pSrc->uid;
     pTmp->sver = pSrc->sver;
+    pTmp->source = pSrc->source;
     pTmp->pCreateTbReq = NULL;
     if (pTmp->flags & SUBMIT_REQ_AUTO_CREATE_TABLE) {
       if (pSrc->pCreateTbReq) {
@@ -344,6 +342,10 @@ int32_t insGetTableDataCxt(SHashObj* pHash, void* id, int32_t idLen, STableMeta*
     void* pData = *pTableCxt;  // deal scan coverity
     code = taosHashPut(pHash, id, idLen, &pData, POINTER_BYTES);
   }
+
+  if (TSDB_CODE_SUCCESS != code) {
+    insDestroyTableDataCxt(*pTableCxt);
+  }
   return code;
 }
 
@@ -651,6 +653,7 @@ int rawBlockBindData(SQuery* query, STableMeta* pTableMeta, void* data, SVCreate
     goto end;
   }
 
+  pTableCxt->pData->source = SOURCE_TAOSX;
   if(tmp == NULL){
     ret = initTableColSubmitData(pTableCxt);
     if (ret != TSDB_CODE_SUCCESS) {

source/libs/parser/src/parTranslater.c

@@ -3165,6 +3165,19 @@ static int32_t checkJoinTable(STranslateContext* pCxt, SJoinTableNode* pJoinTabl
   return TSDB_CODE_SUCCESS;
 }
 
+static int32_t translateAudit(STranslateContext* pCxt, SRealTableNode* pRealTable, SName* pName) {
+  if (pRealTable->pMeta->tableType == TSDB_SUPER_TABLE) {
+    if (IS_AUDIT_DBNAME(pName->dbname) && IS_AUDIT_STB_NAME(pName->tname)) {
+      pCxt->pParseCxt->isAudit = true;
+    }
+  } else if (pRealTable->pMeta->tableType == TSDB_CHILD_TABLE) {
+    if (IS_AUDIT_DBNAME(pName->dbname) && IS_AUDIT_CTB_NAME(pName->tname)) {
+      pCxt->pParseCxt->isAudit = true;
+    }
+  }
+  return 0;
+}
+
 int32_t translateTable(STranslateContext* pCxt, SNode** pTable) {
   int32_t code = TSDB_CODE_SUCCESS;
   switch (nodeType(*pTable)) {
@@ -3184,6 +3197,7 @@ int32_t translateTable(STranslateContext* pCxt, SNode** pTable) {
         if (TSDB_VIEW_TABLE == pRealTable->pMeta->tableType) {
           return translateView(pCxt, pTable, &name);
         }
+        translateAudit(pCxt, pRealTable, &name);
 #endif
         code = setTableVgroupList(pCxt, &name, pRealTable);
         if (TSDB_CODE_SUCCESS == code) {
@@ -4432,7 +4446,7 @@ static int32_t findVgroupsFromEqualTbname(STranslateContext* pCxt, SEqCondTbName
     SName snameTb;
     char* tbName = taosArrayGetP(pInfo->aTbnames, j);
     toName(pCxt->pParseCxt->acctId, dbName, tbName, &snameTb);
-    SVgroupInfo vgInfo;
+    SVgroupInfo vgInfo = {0};
     bool        bExists;
     int32_t     code = catalogGetCachedTableHashVgroup(pCxt->pParseCxt->pCatalog, &snameTb, &vgInfo, &bExists);
     if (code == TSDB_CODE_SUCCESS && bExists) {
@@ -8203,13 +8217,13 @@ static int32_t createLastTsSelectStmt(char* pDb, char* pTable, STableMeta* pMeta
     return TSDB_CODE_OUT_OF_MEMORY;
   }
 
-  code = nodesListAppend(pNode1->pParameterList, (SNode*)pFunc1);
+  code = nodesListStrictAppend(pNode1->pParameterList, nodesCloneNode((SNode*)pFunc1));
   if (code) {
     nodesDestroyNode((SNode*)pNode1);
     return code;
   }
 
-  code = nodesListAppend((*pSelect1)->pGroupByList, nodesCloneNode((const SNode*)pNode1));
+  code = nodesListAppend((*pSelect1)->pGroupByList, (SNode*)pNode1);
   if (code) {
     return code;
   }
@@ -8226,7 +8240,7 @@ static int32_t createLastTsSelectStmt(char* pDb, char* pTable, STableMeta* pMeta
     return TSDB_CODE_OUT_OF_MEMORY;
   }
 
-  code = nodesListAppend(pNode2->pParameterList, nodesCloneNode((const SNode*)pFunc2));
+  code = nodesListStrictAppend(pNode2->pParameterList, nodesCloneNode((SNode*)pFunc2));
   if (code) {
     nodesDestroyNode((SNode*)pNode2);
     return code;
@@ -9385,7 +9399,20 @@ static int32_t createOperatorNode(EOperatorType opType, const char* pColName, SN
 }
 
 static const char* getTbNameColName(ENodeType type) {
-  return (QUERY_NODE_SHOW_STABLES_STMT == type ? "stable_name" : "table_name");
+  const char* colName;
+  switch (type)
+  {
+  case QUERY_NODE_SHOW_VIEWS_STMT:
+    colName = "view_name";
+    break;
+  case QUERY_NODE_SHOW_STABLES_STMT:
+    colName = "stable_name";
+    break;
+  default:
+    colName = "table_name";
+    break;
+  }
+  return colName;
 }
 
 static int32_t createLogicCondNode(SNode* pCond1, SNode* pCond2, SNode** pCond, ELogicConditionType logicCondType) {

source/libs/parser/test/mockCatalogService.cpp

@@ -755,6 +755,7 @@ void MockCatalogService::destoryCatalogReq(SCatalogReq* pReq) {
   taosArrayDestroy(pReq->pUser);
   taosArrayDestroy(pReq->pTableIndex);
   taosArrayDestroy(pReq->pTableCfg);
+  taosArrayDestroyEx(pReq->pView, destoryTablesReq);
   delete pReq;
 }
 
@@ -781,6 +782,7 @@ void MockCatalogService::destoryMetaData(SMetaData* pData) {
   taosArrayDestroyEx(pData->pQnodeList, destoryMetaRes);
   taosArrayDestroyEx(pData->pTableCfg, destoryMetaRes);
   taosArrayDestroyEx(pData->pDnodeList, destoryMetaArrayRes);
+  taosArrayDestroyEx(pData->pView, destoryMetaRes);
   taosMemoryFree(pData->pSvrVer);
   delete pData;
 }

source/libs/parser/test/parAlterToBalanceTest.cpp

@@ -73,6 +73,7 @@ TEST_F(ParserInitialATest, alterDnode) {
     ASSERT_EQ(req.dnodeId, expect.dnodeId);
     ASSERT_EQ(std::string(req.config), std::string(expect.config));
     ASSERT_EQ(std::string(req.value), std::string(expect.value));
+    tFreeSMCfgDnodeReq(&req);
   });
 
   setCfgDnodeReq(1, "resetLog");
@@ -183,6 +184,7 @@ TEST_F(ParserInitialATest, alterDatabase) {
     ASSERT_EQ(req.minRows, expect.minRows);
     ASSERT_EQ(req.walRetentionPeriod, expect.walRetentionPeriod);
     ASSERT_EQ(req.walRetentionSize, expect.walRetentionSize);
+    tFreeSAlterDbReq(&req);
   });
 
   const int32_t MINUTE_PER_DAY = MILLISECOND_PER_DAY / MILLISECOND_PER_MINUTE;
@@ -827,6 +829,7 @@ TEST_F(ParserInitialATest, alterUser) {
     ASSERT_EQ(std::string(req.user), std::string(expect.user));
     ASSERT_EQ(std::string(req.pass), std::string(expect.pass));
     ASSERT_EQ(std::string(req.objname), std::string(expect.objname));
+    tFreeSAlterUserReq(&req);
   });
 
   setAlterUserReq("wxy", TSDB_ALTER_USER_PASSWD, "123456");
@@ -853,6 +856,7 @@ TEST_F(ParserInitialATest, balanceVgroup) {
     ASSERT_EQ(pQuery->pCmdMsg->msgType, TDMT_MND_BALANCE_VGROUP);
     SBalanceVgroupReq req = {0};
     ASSERT_EQ(tDeserializeSBalanceVgroupReq(pQuery->pCmdMsg->pMsg, pQuery->pCmdMsg->msgLen, &req), TSDB_CODE_SUCCESS);
+    tFreeSBalanceVgroupReq(&req);
   });
 
   run("BALANCE VGROUP");
@@ -870,6 +874,7 @@ TEST_F(ParserInitialATest, balanceVgroupLeader) {
     SBalanceVgroupLeaderReq req = {0};
     ASSERT_EQ(tDeserializeSBalanceVgroupLeaderReq(pQuery->pCmdMsg->pMsg, pQuery->pCmdMsg->msgLen, &req),
               TSDB_CODE_SUCCESS);
+    tFreeSBalanceVgroupLeaderReq(&req);
   });
 
   run("BALANCE VGROUP LEADER");

source/libs/parser/test/parExplainToSyncdbTest.cpp

@@ -52,6 +52,7 @@ TEST_F(ParserExplainToSyncdbTest, grant) {
     ASSERT_EQ(req.alterType, expect.alterType);
     ASSERT_EQ(string(req.user), string(expect.user));
     ASSERT_EQ(string(req.objname), string(expect.objname));
+    tFreeSAlterUserReq(&req);
   });
 
   setAlterUserReq(TSDB_ALTER_USER_ADD_PRIVILEGES, PRIVILEGE_TYPE_ALL, "wxy", "0.*");
@@ -183,6 +184,7 @@ TEST_F(ParserExplainToSyncdbTest, redistributeVgroup) {
     ASSERT_EQ(req.dnodeId1, expect.dnodeId1);
     ASSERT_EQ(req.dnodeId2, expect.dnodeId2);
     ASSERT_EQ(req.dnodeId3, expect.dnodeId3);
+    tFreeSRedistributeVgroupReq(&req);
   });
 
   setRedistributeVgroupReqFunc(3, 1);
@@ -228,6 +230,7 @@ TEST_F(ParserExplainToSyncdbTest, restoreDnode) {
     ASSERT_EQ(tDeserializeSRestoreDnodeReq(pQuery->pCmdMsg->pMsg, pQuery->pCmdMsg->msgLen, &req), TSDB_CODE_SUCCESS);
     ASSERT_EQ(req.dnodeId, expect.dnodeId);
     ASSERT_EQ(req.restoreType, expect.restoreType);
+    tFreeSRestoreDnodeReq(&req);
   });
 
   setRestoreDnodeReq(1, RESTORE_TYPE__ALL);
@@ -272,6 +275,7 @@ TEST_F(ParserExplainToSyncdbTest, revoke) {
     ASSERT_EQ(req.alterType, expect.alterType);
     ASSERT_EQ(string(req.user), string(expect.user));
     ASSERT_EQ(string(req.objname), string(expect.objname));
+    tFreeSAlterUserReq(&req);
   });
 
   setAlterUserReq(TSDB_ALTER_USER_DEL_PRIVILEGES, PRIVILEGE_TYPE_ALL, "wxy", "0.*");

source/libs/parser/test/parInitialCTest.cpp

@@ -43,6 +43,7 @@ TEST_F(ParserInitialCTest, compact) {
     ASSERT_EQ(std::string(req.db), std::string(expect.db));
     ASSERT_EQ(req.timeRange.skey, expect.timeRange.skey);
     ASSERT_EQ(req.timeRange.ekey, expect.timeRange.ekey);
+    tFreeSCompactDbReq(&req);
   });
 
   setCompactDbReq("test");
@@ -374,6 +375,7 @@ TEST_F(ParserInitialCTest, createDnode) {
 
     ASSERT_EQ(std::string(req.fqdn), std::string(expect.fqdn));
     ASSERT_EQ(req.port, expect.port);
+    tFreeSCreateDnodeReq(&req);
   });
 
   setCreateDnodeReq("abc1", 7030);
@@ -599,6 +601,7 @@ TEST_F(ParserInitialCTest, createMnode) {
                 tDeserializeSCreateDropMQSNodeReq(pQuery->pCmdMsg->pMsg, pQuery->pCmdMsg->msgLen, &req));
 
     ASSERT_EQ(req.dnodeId, expect.dnodeId);
+    tFreeSMCreateQnodeReq(&req);
   });
 
   setCreateMnodeReq(1);
@@ -622,6 +625,7 @@ TEST_F(ParserInitialCTest, createQnode) {
                 tDeserializeSCreateDropMQSNodeReq(pQuery->pCmdMsg->pMsg, pQuery->pCmdMsg->msgLen, &req));
 
     ASSERT_EQ(req.dnodeId, expect.dnodeId);
+    tFreeSMCreateQnodeReq(&req);
   });
 
   setCreateQnodeReq(1);
@@ -1326,6 +1330,7 @@ TEST_F(ParserInitialCTest, createUser) {
     ASSERT_EQ(req.enable, expect.enable);
     ASSERT_EQ(std::string(req.user), std::string(expect.user));
     ASSERT_EQ(std::string(req.pass), std::string(expect.pass));
+    tFreeSCreateUserReq(&req);
   });
 
   setCreateUserReq("wxy", "123456");

source/libs/parser/test/parInitialDTest.cpp

@@ -117,6 +117,7 @@ TEST_F(ParserInitialDTest, dropDnode) {
     ASSERT_EQ(req.port, expect.port);
     ASSERT_EQ(req.force, expect.force);
     ASSERT_EQ(req.unsafe, expect.unsafe);
+    tFreeSDropDnodeReq(&req);
   });
 
   setDropDnodeReqById(1);
@@ -208,6 +209,7 @@ TEST_F(ParserInitialDTest, dropQnode) {
                 tDeserializeSCreateDropMQSNodeReq(pQuery->pCmdMsg->pMsg, pQuery->pCmdMsg->msgLen, &req));
 
     ASSERT_EQ(req.dnodeId, expect.dnodeId);
+    tFreeSDDropQnodeReq(&req);
   });
 
   setDropQnodeReq(1);
@@ -245,6 +247,7 @@ TEST_F(ParserInitialDTest, dropStream) {
 
     ASSERT_EQ(std::string(req.name), std::string(expect.name));
     ASSERT_EQ(req.igNotExists, expect.igNotExists);
+    tFreeMDropStreamReq(&req);
   });
 
   setDropStreamReq("s1");
@@ -285,6 +288,7 @@ TEST_F(ParserInitialDTest, dropUser) {
     ASSERT_TRUE(TSDB_CODE_SUCCESS == tDeserializeSDropUserReq(pQuery->pCmdMsg->pMsg, pQuery->pCmdMsg->msgLen, &req));
 
     ASSERT_EQ(std::string(req.user), std::string(expect.user));
+    tFreeSDropUserReq(&req);
   });
 
   setDropUserReq("wxy");

source/libs/planner/src/planOptimizer.c

@@ -2977,6 +2977,7 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic
     }
     nodesClearList(cxt.pLastCols);
   }
+  nodesClearList(cxt.pOtherCols);
 
   pAgg->hasLastRow = false;
   pAgg->hasLast = false;

source/libs/planner/src/planPhysiCreater.c

@@ -1617,6 +1617,8 @@ static ENodeType getIntervalOperatorType(EWindowAlgorithm windowAlgo) {
       return QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL;
     case INTERVAL_ALGO_STREAM_SEMI:
       return QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL;
+    case INTERVAL_ALGO_STREAM_MID:
+      return QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL;
     case INTERVAL_ALGO_STREAM_SINGLE:
       return QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL;
     case SESSION_ALGO_STREAM_FINAL:
@@ -2164,6 +2166,8 @@ static SSubplan* makeSubplan(SPhysiPlanContext* pCxt, SLogicSubplan* pLogicSubpl
   pSubplan->level = pLogicSubplan->level;
   pSubplan->rowsThreshold = 4096;
   pSubplan->dynamicRowThreshold = false;
+  pSubplan->isView = pCxt->pPlanCxt->isView;
+  pSubplan->isAudit = pCxt->pPlanCxt->isAudit;
   if (NULL != pCxt->pPlanCxt->pUser) {
     snprintf(pSubplan->user, sizeof(pSubplan->user), "%s", pCxt->pPlanCxt->pUser);
   }

source/libs/planner/src/planSpliter.c

@@ -344,11 +344,12 @@ static bool stbSplFindSplitNode(SSplitContext* pCxt, SLogicSubplan* pSubplan, SL
   return false;
 }
 
-static int32_t stbSplRewriteFuns(const SNodeList* pFuncs, SNodeList** pPartialFuncs, SNodeList** pMergeFuncs) {
+static int32_t stbSplRewriteFuns(const SNodeList* pFuncs, SNodeList** pPartialFuncs, SNodeList** pMidFuncs, SNodeList** pMergeFuncs) {
   SNode* pNode = NULL;
   FOREACH(pNode, pFuncs) {
     SFunctionNode* pFunc = (SFunctionNode*)pNode;
     SFunctionNode* pPartFunc = NULL;
+    SFunctionNode* pMidFunc = NULL;
     SFunctionNode* pMergeFunc = NULL;
     int32_t        code = TSDB_CODE_SUCCESS;
     if (fmIsWindowPseudoColumnFunc(pFunc->funcId)) {
@@ -359,18 +360,33 @@ static int32_t stbSplRewriteFuns(const SNodeList* pFuncs, SNodeList** pPartialFu
         nodesDestroyNode((SNode*)pMergeFunc);
         code = TSDB_CODE_OUT_OF_MEMORY;
       }
+      if(pMidFuncs != NULL){
+        pMidFunc = (SFunctionNode*)nodesCloneNode(pNode);
+        if (NULL == pMidFunc) {
+          nodesDestroyNode((SNode*)pMidFunc);
+          code = TSDB_CODE_OUT_OF_MEMORY;
+        }
+      }
     } else {
-      code = fmGetDistMethod(pFunc, &pPartFunc, &pMergeFunc);
+      code = fmGetDistMethod(pFunc, &pPartFunc, &pMidFunc, &pMergeFunc);
     }
     if (TSDB_CODE_SUCCESS == code) {
       code = nodesListMakeStrictAppend(pPartialFuncs, (SNode*)pPartFunc);
     }
+    if (TSDB_CODE_SUCCESS == code) {
+      if(pMidFuncs != NULL){
+        code = nodesListMakeStrictAppend(pMidFuncs, (SNode*)pMidFunc);
+      }else{
+        nodesDestroyNode((SNode*)pMidFunc);
+      }
+    }
     if (TSDB_CODE_SUCCESS == code) {
       code = nodesListMakeStrictAppend(pMergeFuncs, (SNode*)pMergeFunc);
     }
     if (TSDB_CODE_SUCCESS != code) {
-      nodesDestroyList(*pPartialFuncs);
+      nodesDestroyNode((SNode*)pPartFunc);
-      nodesDestroyList(*pMergeFuncs);
+      nodesDestroyNode((SNode*)pMidFunc);
+      nodesDestroyNode((SNode*)pMergeFunc);
       return code;
     }
   }
@@ -463,7 +479,7 @@ static int32_t stbSplCreatePartWindowNode(SWindowLogicNode* pMergeWindow, SLogic
   splSetParent((SLogicNode*)pPartWin);
 
   int32_t index = 0;
-  int32_t code = stbSplRewriteFuns(pFunc, &pPartWin->pFuncs, &pMergeWindow->pFuncs);
+  int32_t code = stbSplRewriteFuns(pFunc, &pPartWin->pFuncs, NULL, &pMergeWindow->pFuncs);
   if (TSDB_CODE_SUCCESS == code) {
     code = stbSplAppendWStart(pPartWin->pFuncs, &index, ((SColumnNode*)pMergeWindow->pTspk)->node.resType.precision);
   }
@@ -488,6 +504,85 @@ static int32_t stbSplCreatePartWindowNode(SWindowLogicNode* pMergeWindow, SLogic
   return code;
 }
 
+static int32_t stbSplCreatePartMidWindowNode(SWindowLogicNode* pMergeWindow, SLogicNode** pPartWindow, SLogicNode** pMidWindow) {
+  SNodeList* pFunc = pMergeWindow->pFuncs;
+  pMergeWindow->pFuncs = NULL;
+  SNodeList* pTargets = pMergeWindow->node.pTargets;
+  pMergeWindow->node.pTargets = NULL;
+  SNodeList* pChildren = pMergeWindow->node.pChildren;
+  pMergeWindow->node.pChildren = NULL;
+  SNode* pConditions = pMergeWindow->node.pConditions;
+  pMergeWindow->node.pConditions = NULL;
+
+  SWindowLogicNode* pPartWin = (SWindowLogicNode*)nodesCloneNode((SNode*)pMergeWindow);
+  if (NULL == pPartWin) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  SWindowLogicNode* pMidWin = (SWindowLogicNode*)nodesCloneNode((SNode*)pMergeWindow);
+  if (NULL == pMidWin) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  pPartWin->node.groupAction = GROUP_ACTION_KEEP;
+  pMidWin->node.groupAction = GROUP_ACTION_KEEP;
+  pMergeWindow->node.pTargets = pTargets;
+  pMergeWindow->node.pConditions = pConditions;
+
+  pPartWin->node.pChildren = pChildren;
+  splSetParent((SLogicNode*)pPartWin);
+
+  SNodeList* pFuncPart = NULL;
+  SNodeList* pFuncMid = NULL;
+  SNodeList* pFuncMerge = NULL;
+  int32_t code = stbSplRewriteFuns(pFunc, &pFuncPart, &pFuncMid, &pFuncMerge);
+  pPartWin->pFuncs = pFuncPart;
+  pMidWin->pFuncs = pFuncMid;
+  pMergeWindow->pFuncs = pFuncMerge;
+
+  int32_t index = 0;
+  if (TSDB_CODE_SUCCESS == code) {
+    code = stbSplAppendWStart(pPartWin->pFuncs, &index, ((SColumnNode*)pMergeWindow->pTspk)->node.resType.precision);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = createColumnByRewriteExprs(pPartWin->pFuncs, &pPartWin->node.pTargets);
+  }
+
+  if (TSDB_CODE_SUCCESS == code) {
+    nodesDestroyNode(pMidWin->pTspk);
+    pMidWin->pTspk = nodesCloneNode(nodesListGetNode(pPartWin->node.pTargets, index));
+    if (NULL == pMidWin->pTspk) {
+      code = TSDB_CODE_OUT_OF_MEMORY;
+    }
+  }
+
+  if (TSDB_CODE_SUCCESS == code) {
+    code = stbSplAppendWStart(pMidWin->pFuncs, &index, ((SColumnNode*)pMergeWindow->pTspk)->node.resType.precision);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = createColumnByRewriteExprs(pMidWin->pFuncs, &pMidWin->node.pTargets);
+  }
+
+  if (TSDB_CODE_SUCCESS == code) {
+    nodesDestroyNode(pMergeWindow->pTspk);
+    pMergeWindow->pTspk = nodesCloneNode(nodesListGetNode(pMidWin->node.pTargets, index));
+    if (NULL == pMergeWindow->pTspk) {
+      code = TSDB_CODE_OUT_OF_MEMORY;
+    }
+  }
+
+  nodesDestroyList(pFunc);
+  if (TSDB_CODE_SUCCESS == code) {
+    *pPartWindow = (SLogicNode*)pPartWin;
+    *pMidWindow = (SLogicNode*)pMidWin;
+  } else {
+    nodesDestroyNode((SNode*)pPartWin);
+    nodesDestroyNode((SNode*)pMidWin);
+  }
+
+  return code;
+}
+
 static int32_t stbSplGetNumOfVgroups(SLogicNode* pNode) {
   if (QUERY_NODE_LOGIC_PLAN_SCAN == nodeType(pNode)) {
     return ((SScanLogicNode*)pNode)->pVgroupList->numOfVgroups;
@@ -635,18 +730,31 @@ static int32_t stbSplSplitIntervalForBatch(SSplitContext* pCxt, SStableSplitInfo
   return code;
 }
 
-static int32_t stbSplSplitIntervalForStream(SSplitContext* pCxt, SStableSplitInfo* pInfo) {
+static int32_t stbSplSplitIntervalForStreamMultiAgg(SSplitContext* pCxt, SStableSplitInfo* pInfo) {
   SLogicNode* pPartWindow = NULL;
-  int32_t     code = stbSplCreatePartWindowNode((SWindowLogicNode*)pInfo->pSplitNode, &pPartWindow);
+  SLogicNode* pMidWindow  = NULL;
+  int32_t     code = stbSplCreatePartMidWindowNode((SWindowLogicNode*)pInfo->pSplitNode, &pPartWindow, &pMidWindow);
   if (TSDB_CODE_SUCCESS == code) {
-    ((SWindowLogicNode*)pPartWindow)->windowAlgo = INTERVAL_ALGO_STREAM_SEMI;
+    ((SWindowLogicNode*)pMidWindow)->windowAlgo = INTERVAL_ALGO_STREAM_MID;
     ((SWindowLogicNode*)pInfo->pSplitNode)->windowAlgo = INTERVAL_ALGO_STREAM_FINAL;
-    code = stbSplCreateExchangeNode(pCxt, pInfo->pSplitNode, pPartWindow);
+    ((SWindowLogicNode*)pPartWindow)->windowAlgo = INTERVAL_ALGO_STREAM_SEMI;
-  }
+    code = stbSplCreateExchangeNode(pCxt, pInfo->pSplitNode, pMidWindow);
     if (TSDB_CODE_SUCCESS == code) {
-    code = nodesListMakeStrictAppend(&pInfo->pSubplan->pChildren,
+      code = stbSplCreateExchangeNode(pCxt, pMidWindow, pPartWindow);
-                                     (SNode*)splCreateScanSubplan(pCxt, pPartWindow, SPLIT_FLAG_STABLE_SPLIT));
     }
+  }
+
+  if (TSDB_CODE_SUCCESS == code) {
+    SNode* subPlan = (SNode*)splCreateSubplan(pCxt, pMidWindow);
+    ((SLogicSubplan*)subPlan)->subplanType = SUBPLAN_TYPE_MERGE;
+
+    code = nodesListMakeStrictAppend(&((SLogicSubplan*)subPlan)->pChildren,
+                                     (SNode*)splCreateScanSubplan(pCxt, pPartWindow, SPLIT_FLAG_STABLE_SPLIT));
+    if (TSDB_CODE_SUCCESS == code) {
+      code = nodesListMakeStrictAppend(&pInfo->pSubplan->pChildren, subPlan);
+    }
+  }
+
   pInfo->pSubplan->subplanType = SUBPLAN_TYPE_MERGE;
   ++(pCxt->groupId);
   return code;
@@ -654,7 +762,7 @@ static int32_t stbSplSplitIntervalForStream(SSplitContext* pCxt, SStableSplitInf
 
 static int32_t stbSplSplitInterval(SSplitContext* pCxt, SStableSplitInfo* pInfo) {
   if (pCxt->pPlanCxt->streamQuery) {
-    return stbSplSplitIntervalForStream(pCxt, pInfo);
+    return stbSplSplitIntervalForStreamMultiAgg(pCxt, pInfo);
   } else {
     return stbSplSplitIntervalForBatch(pCxt, pInfo);
   }
@@ -860,7 +968,7 @@ static int32_t stbSplCreatePartAggNode(SAggLogicNode* pMergeAgg, SLogicNode** pO
     pPartAgg->node.pChildren = pChildren;
     splSetParent((SLogicNode*)pPartAgg);
 
-    code = stbSplRewriteFuns(pFunc, &pPartAgg->pAggFuncs, &pMergeAgg->pAggFuncs);
+    code = stbSplRewriteFuns(pFunc, &pPartAgg->pAggFuncs, NULL, &pMergeAgg->pAggFuncs);
   }
   if (TSDB_CODE_SUCCESS == code) {
     code = createColumnByRewriteExprs(pPartAgg->pAggFuncs, &pPartAgg->node.pTargets);

source/libs/planner/src/planValidator.c

@@ -95,6 +95,7 @@ int32_t doValidatePhysiNode(SValidatePlanContext* pCxt, SNode* pNode) {
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL:
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL:
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL:
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL:
     case QUERY_NODE_PHYSICAL_PLAN_FILL:
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL:
     case QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION:

source/libs/qworker/src/qwMsg.c

@@ -360,11 +360,25 @@ int32_t qWorkerPreprocessQueryMsg(void *qWorkerMgmt, SRpcMsg *pMsg, bool chkGran
     QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
   }
 
-  if (chkGrant && (!TEST_SHOW_REWRITE_MASK(msg.msgMask)) && !taosGranted()) {
+  if (chkGrant) {
+    if ((!TEST_SHOW_REWRITE_MASK(msg.msgMask))) {
+      if (!taosGranted(TSDB_GRANT_ALL)) {
         QW_ELOG("query failed cause of grant expired, msgMask:%d", msg.msgMask);
         tFreeSSubQueryMsg(&msg);
         QW_ERR_RET(TSDB_CODE_GRANT_EXPIRED);
       }
+      if ((TEST_VIEW_MASK(msg.msgMask)) && !taosGranted(TSDB_GRANT_VIEW)) {
+        QW_ELOG("query failed cause of view grant expired, msgMask:%d", msg.msgMask);
+        tFreeSSubQueryMsg(&msg);
+        QW_ERR_RET(TSDB_CODE_GRANT_EXPIRED);
+      }
+      if ((TEST_AUDIT_MASK(msg.msgMask)) && !taosGranted(TSDB_GRANT_AUDIT)) {
+        QW_ELOG("query failed cause of audit grant expired, msgMask:%d", msg.msgMask);
+        tFreeSSubQueryMsg(&msg);
+        QW_ERR_RET(TSDB_CODE_GRANT_EXPIRED);
+      }
+    }
+  }
 
   uint64_t sId = msg.sId;
   uint64_t qId = msg.queryId;

source/libs/scheduler/src/schJob.c

@@ -66,7 +66,7 @@ FORCE_INLINE bool schJobNeedToStop(SSchJob *pJob, int8_t *pStatus) {
     return true;
   }
 
-  if ((*pJob->chkKillFp)(pJob->chkKillParam)) {
+  if (pJob->chkKillFp && (*pJob->chkKillFp)(pJob->chkKillParam)) {
     schUpdateJobErrCode(pJob, TSDB_CODE_TSC_QUERY_KILLED);
     return true;
   }

source/libs/scheduler/src/schRemote.c

@@ -1109,6 +1109,8 @@ int32_t schBuildAndSendMsg(SSchJob *pJob, SSchTask *pTask, SQueryNodeAddr *addr,
       qMsg.refId = pJob->refId;
       qMsg.execId = pTask->execId;
       qMsg.msgMask = (pTask->plan->showRewrite) ? QUERY_MSG_MASK_SHOW_REWRITE() : 0;
+      qMsg.msgMask |= (pTask->plan->isView) ? QUERY_MSG_MASK_VIEW() : 0;
+      qMsg.msgMask |= (pTask->plan->isAudit) ? QUERY_MSG_MASK_AUDIT() : 0;
       qMsg.taskType = TASK_TYPE_TEMP;
       qMsg.explain = SCH_IS_EXPLAIN_JOB(pJob);
       qMsg.needFetch = SCH_TASK_NEED_FETCH(pTask);

source/libs/scheduler/test/schedulerTests.cpp

@@ -54,9 +54,8 @@
 
 namespace {
 
-extern "C" int32_t schHandleResponseMsg(SSchJob *job, SSchTask *task, int32_t msgType, char *msg, int32_t msgSize,
+extern "C" int32_t schHandleResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SDataBuf *pMsg, int32_t rspCode);
-                                        int32_t rspCode);
+extern "C" int32_t schHandleCallback(void *param, const SDataBuf *pMsg, int32_t rspCode);
-extern "C" int32_t schHandleCallback(void *param, const SDataBuf *pMsg, int32_t msgType, int32_t rspCode);
 
 int64_t insertJobRefId = 0;
 int64_t queryJobRefId = 0;
@@ -67,7 +66,7 @@ uint64_t schtQueryId = 1;
 
 bool    schtTestStop = false;
 bool    schtTestDeadLoop = false;
-int32_t schtTestMTRunSec = 10;
+int32_t schtTestMTRunSec = 1;
 int32_t schtTestPrintNum = 1000;
 int32_t schtStartFetch = 0;
 
@@ -85,10 +84,69 @@ void schtInitLogFile() {
 }
 
 void schtQueryCb(SExecResult *pResult, void *param, int32_t code) {
-  assert(TSDB_CODE_SUCCESS == code);
   *(int32_t *)param = 1;
 }
 
+int32_t schtBuildQueryRspMsg(uint32_t *msize, void** rspMsg) {
+  SQueryTableRsp  rsp = {0};
+  rsp.code = 0;
+  rsp.affectedRows = 0;
+  rsp.tbVerInfo = NULL;
+
+  int32_t msgSize = tSerializeSQueryTableRsp(NULL, 0, &rsp);
+  if (msgSize < 0) {
+    qError("tSerializeSQueryTableRsp failed");
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+  
+  void *pRsp = taosMemoryCalloc(msgSize, 1);
+  if (NULL == pRsp) {
+    qError("rpcMallocCont %d failed", msgSize);
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  if (tSerializeSQueryTableRsp(pRsp, msgSize, &rsp) < 0) {
+    qError("tSerializeSQueryTableRsp %d failed", msgSize);
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  *rspMsg = pRsp;
+  *msize = msgSize;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
+int32_t schtBuildFetchRspMsg(uint32_t *msize, void** rspMsg) {
+  SRetrieveTableRsp* rsp = (SRetrieveTableRsp*)taosMemoryCalloc(sizeof(SRetrieveTableRsp), 1);
+  rsp->completed = 1;
+  rsp->numOfRows = 10;
+  rsp->compLen = 0;
+
+  *rspMsg = rsp;
+  *msize = sizeof(SRetrieveTableRsp);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t schtBuildSubmitRspMsg(uint32_t *msize, void** rspMsg) {
+  SSubmitRsp2 submitRsp = {0};
+  int32_t msgSize = 0, ret = 0;
+  SEncoder     ec = {0};
+  
+  tEncodeSize(tEncodeSSubmitRsp2, &submitRsp, msgSize, ret);
+  void* msg = taosMemoryCalloc(1, msgSize);
+  tEncoderInit(&ec, (uint8_t*)msg, msgSize);
+  tEncodeSSubmitRsp2(&ec, &submitRsp);
+  tEncoderClear(&ec);
+
+  *rspMsg = msg;
+  *msize = msgSize;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
 void schtBuildQueryDag(SQueryPlan *dag) {
   uint64_t qId = schtQueryId;
 
@@ -98,8 +156,8 @@ void schtBuildQueryDag(SQueryPlan *dag) {
   SNodeListNode *scan = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST);
   SNodeListNode *merge = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST);
 
-  SSubplan *scanPlan = (SSubplan *)taosMemoryCalloc(1, sizeof(SSubplan));
+  SSubplan *scanPlan = (SSubplan*)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN);
-  SSubplan *mergePlan = (SSubplan *)taosMemoryCalloc(1, sizeof(SSubplan));
+  SSubplan *mergePlan = (SSubplan*)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN);
 
   scanPlan->id.queryId = qId;
   scanPlan->id.groupId = 0x0000000000000002;
@@ -113,7 +171,7 @@ void schtBuildQueryDag(SQueryPlan *dag) {
   scanPlan->pChildren = NULL;
   scanPlan->level = 1;
   scanPlan->pParents = nodesMakeList();
-  scanPlan->pNode = (SPhysiNode *)taosMemoryCalloc(1, sizeof(SPhysiNode));
+  scanPlan->pNode = (SPhysiNode *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN);
   scanPlan->msgType = TDMT_SCH_QUERY;
 
   mergePlan->id.queryId = qId;
@@ -125,7 +183,7 @@ void schtBuildQueryDag(SQueryPlan *dag) {
 
   mergePlan->pChildren = nodesMakeList();
   mergePlan->pParents = NULL;
-  mergePlan->pNode = (SPhysiNode *)taosMemoryCalloc(1, sizeof(SPhysiNode));
+  mergePlan->pNode = (SPhysiNode *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_MERGE);
   mergePlan->msgType = TDMT_SCH_QUERY;
 
   merge->pNodeList = nodesMakeList();
@@ -151,8 +209,7 @@ void schtBuildQueryFlowCtrlDag(SQueryPlan *dag) {
   SNodeListNode *scan = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST);
   SNodeListNode *merge = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST);
 
-  SSubplan *scanPlan = (SSubplan *)taosMemoryCalloc(scanPlanNum, sizeof(SSubplan));
+  SSubplan *mergePlan = (SSubplan*)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN);
-  SSubplan *mergePlan = (SSubplan *)taosMemoryCalloc(1, sizeof(SSubplan));
 
   merge->pNodeList = nodesMakeList();
   scan->pNodeList = nodesMakeList();
@@ -160,29 +217,30 @@ void schtBuildQueryFlowCtrlDag(SQueryPlan *dag) {
   mergePlan->pChildren = nodesMakeList();
 
   for (int32_t i = 0; i < scanPlanNum; ++i) {
-    scanPlan[i].id.queryId = qId;
+    SSubplan *scanPlan = (SSubplan*)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN);
-    scanPlan[i].id.groupId = 0x0000000000000002;
+    scanPlan->id.queryId = qId;
-    scanPlan[i].id.subplanId = 0x0000000000000003 + i;
+    scanPlan->id.groupId = 0x0000000000000002;
-    scanPlan[i].subplanType = SUBPLAN_TYPE_SCAN;
+    scanPlan->id.subplanId = 0x0000000000000003 + i;
+    scanPlan->subplanType = SUBPLAN_TYPE_SCAN;
 
-    scanPlan[i].execNode.nodeId = 1 + i;
+    scanPlan->execNode.nodeId = 1 + i;
-    scanPlan[i].execNode.epSet.inUse = 0;
+    scanPlan->execNode.epSet.inUse = 0;
-    scanPlan[i].execNodeStat.tableNum = taosRand() % 30;
+    scanPlan->execNodeStat.tableNum = taosRand() % 30;
-    addEpIntoEpSet(&scanPlan[i].execNode.epSet, "ep0", 6030);
+    addEpIntoEpSet(&scanPlan->execNode.epSet, "ep0", 6030);
-    addEpIntoEpSet(&scanPlan[i].execNode.epSet, "ep1", 6030);
+    addEpIntoEpSet(&scanPlan->execNode.epSet, "ep1", 6030);
-    addEpIntoEpSet(&scanPlan[i].execNode.epSet, "ep2", 6030);
+    addEpIntoEpSet(&scanPlan->execNode.epSet, "ep2", 6030);
-    scanPlan[i].execNode.epSet.inUse = taosRand() % 3;
+    scanPlan->execNode.epSet.inUse = taosRand() % 3;
 
-    scanPlan[i].pChildren = NULL;
+    scanPlan->pChildren = NULL;
-    scanPlan[i].level = 1;
+    scanPlan->level = 1;
-    scanPlan[i].pParents = nodesMakeList();
+    scanPlan->pParents = nodesMakeList();
-    scanPlan[i].pNode = (SPhysiNode *)taosMemoryCalloc(1, sizeof(SPhysiNode));
+    scanPlan->pNode = (SPhysiNode *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN);
-    scanPlan[i].msgType = TDMT_SCH_QUERY;
+    scanPlan->msgType = TDMT_SCH_QUERY;
 
-    nodesListAppend(scanPlan[i].pParents, (SNode *)mergePlan);
+    nodesListAppend(scanPlan->pParents, (SNode *)mergePlan);
-    nodesListAppend(mergePlan->pChildren, (SNode *)(scanPlan + i));
+    nodesListAppend(mergePlan->pChildren, (SNode *)scanPlan);
 
-    nodesListAppend(scan->pNodeList, (SNode *)(scanPlan + i));
+    nodesListAppend(scan->pNodeList, (SNode *)scanPlan);
   }
 
   mergePlan->id.queryId = qId;
@@ -193,7 +251,7 @@ void schtBuildQueryFlowCtrlDag(SQueryPlan *dag) {
   mergePlan->execNode.epSet.numOfEps = 0;
 
   mergePlan->pParents = NULL;
-  mergePlan->pNode = (SPhysiNode *)taosMemoryCalloc(1, sizeof(SPhysiNode));
+  mergePlan->pNode = (SPhysiNode *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_MERGE);
   mergePlan->msgType = TDMT_SCH_QUERY;
 
   nodesListAppend(merge->pNodeList, (SNode *)mergePlan);
@@ -211,45 +269,50 @@ void schtBuildInsertDag(SQueryPlan *dag) {
   dag->numOfSubplans = 2;
   dag->pSubplans = nodesMakeList();
   SNodeListNode *inserta = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST);
-
-  SSubplan *insertPlan = (SSubplan *)taosMemoryCalloc(2, sizeof(SSubplan));
-
-  insertPlan[0].id.queryId = qId;
-  insertPlan[0].id.groupId = 0x0000000000000003;
-  insertPlan[0].id.subplanId = 0x0000000000000004;
-  insertPlan[0].subplanType = SUBPLAN_TYPE_MODIFY;
-  insertPlan[0].level = 0;
-
-  insertPlan[0].execNode.nodeId = 1;
-  insertPlan[0].execNode.epSet.inUse = 0;
-  addEpIntoEpSet(&insertPlan[0].execNode.epSet, "ep0", 6030);
-
-  insertPlan[0].pChildren = NULL;
-  insertPlan[0].pParents = NULL;
-  insertPlan[0].pNode = NULL;
-  insertPlan[0].pDataSink = (SDataSinkNode *)taosMemoryCalloc(1, sizeof(SDataSinkNode));
-  insertPlan[0].msgType = TDMT_VND_SUBMIT;
-
-  insertPlan[1].id.queryId = qId;
-  insertPlan[1].id.groupId = 0x0000000000000003;
-  insertPlan[1].id.subplanId = 0x0000000000000005;
-  insertPlan[1].subplanType = SUBPLAN_TYPE_MODIFY;
-  insertPlan[1].level = 0;
-
-  insertPlan[1].execNode.nodeId = 1;
-  insertPlan[1].execNode.epSet.inUse = 0;
-  addEpIntoEpSet(&insertPlan[1].execNode.epSet, "ep0", 6030);
-
-  insertPlan[1].pChildren = NULL;
-  insertPlan[1].pParents = NULL;
-  insertPlan[1].pNode = NULL;
-  insertPlan[1].pDataSink = (SDataSinkNode *)taosMemoryCalloc(1, sizeof(SDataSinkNode));
-  insertPlan[1].msgType = TDMT_VND_SUBMIT;
-
   inserta->pNodeList = nodesMakeList();
 
+  SSubplan *insertPlan = (SSubplan*)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN);
+
+  insertPlan->id.queryId = qId;
+  insertPlan->id.groupId = 0x0000000000000003;
+  insertPlan->id.subplanId = 0x0000000000000004;
+  insertPlan->subplanType = SUBPLAN_TYPE_MODIFY;
+  insertPlan->level = 0;
+
+  insertPlan->execNode.nodeId = 1;
+  insertPlan->execNode.epSet.inUse = 0;
+  addEpIntoEpSet(&insertPlan->execNode.epSet, "ep0", 6030);
+
+  insertPlan->pChildren = NULL;
+  insertPlan->pParents = NULL;
+  insertPlan->pNode = NULL;
+  insertPlan->pDataSink = (SDataSinkNode*)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_INSERT);
+  ((SDataInserterNode*)insertPlan->pDataSink)->size = 1;
+  ((SDataInserterNode*)insertPlan->pDataSink)->pData = taosMemoryCalloc(1, 1);
+  insertPlan->msgType = TDMT_VND_SUBMIT;
+
   nodesListAppend(inserta->pNodeList, (SNode *)insertPlan);
-  insertPlan += 1;
+
+  insertPlan = (SSubplan*)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN);
+
+  insertPlan->id.queryId = qId;
+  insertPlan->id.groupId = 0x0000000000000003;
+  insertPlan->id.subplanId = 0x0000000000000005;
+  insertPlan->subplanType = SUBPLAN_TYPE_MODIFY;
+  insertPlan->level = 0;
+
+  insertPlan->execNode.nodeId = 1;
+  insertPlan->execNode.epSet.inUse = 0;
+  addEpIntoEpSet(&insertPlan->execNode.epSet, "ep0", 6030);
+
+  insertPlan->pChildren = NULL;
+  insertPlan->pParents = NULL;
+  insertPlan->pNode = NULL;
+  insertPlan->pDataSink = (SDataSinkNode*)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_INSERT);
+  ((SDataInserterNode*)insertPlan->pDataSink)->size = 1;
+  ((SDataInserterNode*)insertPlan->pDataSink)->pData = taosMemoryCalloc(1, 1);
+  insertPlan->msgType = TDMT_VND_SUBMIT;
+
   nodesListAppend(inserta->pNodeList, (SNode *)insertPlan);
 
   nodesListAppend(dag->pSubplans, (SNode *)inserta);
@@ -325,7 +388,7 @@ void schtSetRpcSendRequest() {
   }
 }
 
-int32_t schtAsyncSendMsgToServer(void *pTransporter, SEpSet *epSet, int64_t *pTransporterId, SMsgSendInfo *pInfo) {
+int32_t schtAsyncSendMsgToServer(void *pTransporter, SEpSet *epSet, int64_t *pTransporterId, SMsgSendInfo *pInfo, bool persistHandle, void* rpcCtx) {
   if (pInfo) {
     taosMemoryFreeClear(pInfo->param);
     taosMemoryFreeClear(pInfo->msgInfo.pData);
@@ -336,17 +399,17 @@ int32_t schtAsyncSendMsgToServer(void *pTransporter, SEpSet *epSet, int64_t *pTr
 
 void schtSetAsyncSendMsgToServer() {
   static Stub stub;
-  stub.set(asyncSendMsgToServer, schtAsyncSendMsgToServer);
+  stub.set(asyncSendMsgToServerExt, schtAsyncSendMsgToServer);
   {
 #ifdef WINDOWS
     AddrAny                       any;
     std::map<std::string, void *> result;
-    any.get_func_addr("asyncSendMsgToServer", result);
+    any.get_func_addr("asyncSendMsgToServerExt", result);
 #endif
 #ifdef LINUX
     AddrAny                       any("libtransport.so");
     std::map<std::string, void *> result;
-    any.get_global_func_addr_dynsym("^asyncSendMsgToServer$", result);
+    any.get_global_func_addr_dynsym("^asyncSendMsgToServerExt$", result);
 #endif
     for (const auto &f : result) {
       stub.set(f.second, schtAsyncSendMsgToServer);
@@ -374,9 +437,13 @@ void *schtSendRsp(void *param) {
   while (pIter) {
     SSchTask *task = *(SSchTask **)pIter;
 
-    SSubmitRsp rsp = {0};
+    SDataBuf msg = {0};
-    rsp.affectedRows = 10;
+    void* rmsg = NULL;
-    schHandleResponseMsg(pJob, task, TDMT_VND_SUBMIT_RSP, (char *)&rsp, sizeof(rsp), 0);
+    schtBuildSubmitRspMsg(&msg.len, &rmsg);
+    msg.msgType = TDMT_VND_SUBMIT_RSP;
+    msg.pData = rmsg;
+    
+    schHandleResponseMsg(pJob, task, task->execId, &msg, 0);
 
     pIter = taosHashIterate(pJob->execTasks, pIter);
   }
@@ -393,11 +460,13 @@ void *schtCreateFetchRspThread(void *param) {
   taosSsleep(1);
 
   int32_t            code = 0;
-  SRetrieveTableRsp *rsp = (SRetrieveTableRsp *)taosMemoryCalloc(1, sizeof(SRetrieveTableRsp));
+  SDataBuf msg = {0};
-  rsp->completed = 1;
+  void* rmsg = NULL;
-  rsp->numOfRows = 10;
+  schtBuildFetchRspMsg(&msg.len, &rmsg);
+  msg.msgType = TDMT_SCH_MERGE_FETCH_RSP;
+  msg.pData = rmsg;
   
-  code = schHandleResponseMsg(pJob, pJob->fetchTask, TDMT_SCH_FETCH_RSP, (char *)rsp, sizeof(*rsp), 0);
+  code = schHandleResponseMsg(pJob, pJob->fetchTask, pJob->fetchTask->execId, &msg, 0);
 
   schReleaseJob(job);
 
@@ -414,7 +483,7 @@ void *schtFetchRspThread(void *aa) {
       continue;
     }
 
-    taosUsleep(1);
+    taosUsleep(100);
 
     param = (SSchTaskCallbackParam *)taosMemoryCalloc(1, sizeof(*param));
 
@@ -426,10 +495,11 @@ void *schtFetchRspThread(void *aa) {
     rsp->completed = 1;
     rsp->numOfRows = 10;
 
+    dataBuf.msgType = TDMT_SCH_FETCH_RSP;
     dataBuf.pData = rsp;
     dataBuf.len = sizeof(*rsp);
 
-    code = schHandleCallback(param, &dataBuf, TDMT_SCH_FETCH_RSP, 0);
+    code = schHandleCallback(param, &dataBuf, 0);
 
     assert(code == 0 || code);
   }
@@ -456,7 +526,7 @@ void *schtRunJobThread(void *aa) {
   char       *dbname = "1.db1";
   char       *tablename = "table1";
   SVgroupInfo vgInfo = {0};
-  SQueryPlan  dag;
+  SQueryPlan* dag = (SQueryPlan*)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN);
 
   schtInitLogFile();
 
@@ -470,19 +540,19 @@ void *schtRunJobThread(void *aa) {
   SSchJob               *pJob = NULL;
   SSchTaskCallbackParam *param = NULL;
   SHashObj              *execTasks = NULL;
-  SDataBuf               dataBuf = {0};
   uint32_t               jobFinished = 0;
   int32_t                queryDone = 0;
 
   while (!schtTestStop) {
-    schtBuildQueryDag(&dag);
+    schtBuildQueryDag(dag);
 
-    SArray *qnodeList = taosArrayInit(1, sizeof(SEp));
+    SArray *qnodeList = taosArrayInit(1, sizeof(SQueryNodeLoad));
 
-    SEp qnodeAddr = {0};
+    SQueryNodeLoad load = {0};
-    strcpy(qnodeAddr.fqdn, "qnode0.ep");
+    load.addr.epSet.numOfEps = 1;
-    qnodeAddr.port = 6031;
+    strcpy(load.addr.epSet.eps[0].fqdn, "qnode0.ep");
-    taosArrayPush(qnodeList, &qnodeAddr);
+    load.addr.epSet.eps[0].port = 6031;
+    taosArrayPush(qnodeList, &load);
 
     queryDone = 0;
 
@@ -492,7 +562,7 @@ void *schtRunJobThread(void *aa) {
     req.syncReq = false;
     req.pConn = &conn;
     req.pNodeList = qnodeList;
-    req.pDag = &dag;
+    req.pDag = dag;
     req.sql = "select * from tb";
     req.execFp = schtQueryCb;
     req.cbParam = &queryDone;
@@ -503,7 +573,7 @@ void *schtRunJobThread(void *aa) {
     pJob = schAcquireJob(queryJobRefId);
     if (NULL == pJob) {
       taosArrayDestroy(qnodeList);
-      schtFreeQueryDag(&dag);
+      schtFreeQueryDag(dag);
       continue;
     }
 
@@ -526,11 +596,14 @@ void *schtRunJobThread(void *aa) {
       SSchTask *task = (SSchTask *)pIter;
 
       param->taskId = task->taskId;
-      SQueryTableRsp rsp = {0};
-      dataBuf.pData = &rsp;
-      dataBuf.len = sizeof(rsp);
 
-      code = schHandleCallback(param, &dataBuf, TDMT_SCH_QUERY_RSP, 0);
+      SDataBuf msg = {0};
+      void* rmsg = NULL;
+      schtBuildQueryRspMsg(&msg.len, &rmsg);
+      msg.msgType = TDMT_SCH_QUERY_RSP;
+      msg.pData = rmsg;
+
+      code = schHandleCallback(param, &msg, 0);
       assert(code == 0 || code);
 
       pIter = taosHashIterate(execTasks, pIter);
@@ -545,11 +618,13 @@ void *schtRunJobThread(void *aa) {
       SSchTask *task = (SSchTask *)pIter;
 
       param->taskId = task->taskId - 1;
-      SQueryTableRsp rsp = {0};
+      SDataBuf msg = {0};
-      dataBuf.pData = &rsp;
+      void* rmsg = NULL;
-      dataBuf.len = sizeof(rsp);
+      schtBuildQueryRspMsg(&msg.len, &rmsg);
+      msg.msgType = TDMT_SCH_QUERY_RSP;
+      msg.pData = rmsg;
 
-      code = schHandleCallback(param, &dataBuf, TDMT_SCH_QUERY_RSP, 0);
+      code = schHandleCallback(param, &msg, 0);
       assert(code == 0 || code);
 
       pIter = taosHashIterate(execTasks, pIter);
@@ -575,7 +650,6 @@ void *schtRunJobThread(void *aa) {
     if (0 == code) {
       SRetrieveTableRsp *pRsp = (SRetrieveTableRsp *)data;
       assert(pRsp->completed == 1);
-      assert(pRsp->numOfRows == 10);
     }
 
     data = NULL;
@@ -587,7 +661,7 @@ void *schtRunJobThread(void *aa) {
     taosHashCleanup(execTasks);
     taosArrayDestroy(qnodeList);
 
-    schtFreeQueryDag(&dag);
+    schtFreeQueryDag(dag);
 
     if (++jobFinished % schtTestPrintNum == 0) {
       printf("jobFinished:%d\n", jobFinished);
@@ -609,6 +683,7 @@ void *schtFreeJobThread(void *aa) {
   return NULL;
 }
 
+
 }  // namespace
 
 TEST(queryTest, normalCase) {
@@ -618,21 +693,20 @@ TEST(queryTest, normalCase) {
   char       *tablename = "table1";
   SVgroupInfo vgInfo = {0};
   int64_t     job = 0;
-  SQueryPlan  dag;
+  SQueryPlan* dag = (SQueryPlan*)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN);
 
-  memset(&dag, 0, sizeof(dag));
+  SArray *qnodeList = taosArrayInit(1, sizeof(SQueryNodeLoad));
 
-  SArray *qnodeList = taosArrayInit(1, sizeof(SEp));
+  SQueryNodeLoad load = {0};
-
+  load.addr.epSet.numOfEps = 1;
-  SEp qnodeAddr = {0};
+  strcpy(load.addr.epSet.eps[0].fqdn, "qnode0.ep");
-  strcpy(qnodeAddr.fqdn, "qnode0.ep");
+  load.addr.epSet.eps[0].port = 6031;
-  qnodeAddr.port = 6031;
+  taosArrayPush(qnodeList, &load);
-  taosArrayPush(qnodeList, &qnodeAddr);
 
   int32_t code = schedulerInit();
   ASSERT_EQ(code, 0);
 
-  schtBuildQueryDag(&dag);
+  schtBuildQueryDag(dag);
 
   schtSetPlanToString();
   schtSetExecNode();
@@ -645,7 +719,7 @@ TEST(queryTest, normalCase) {
   SSchedulerReq req = {0};
   req.pConn = &conn;
   req.pNodeList = qnodeList;
-  req.pDag = &dag;
+  req.pDag = dag;
   req.sql = "select * from tb";
   req.execFp = schtQueryCb;
   req.cbParam = &queryDone;
@@ -659,8 +733,13 @@ TEST(queryTest, normalCase) {
   while (pIter) {
     SSchTask *task = *(SSchTask **)pIter;
 
-    SQueryTableRsp rsp = {0};
+    SDataBuf msg = {0};
-    code = schHandleResponseMsg(pJob, task, TDMT_SCH_QUERY_RSP, (char *)&rsp, sizeof(rsp), 0);
+    void* rmsg = NULL;
+    schtBuildQueryRspMsg(&msg.len, &rmsg);
+    msg.msgType = TDMT_SCH_QUERY_RSP;
+    msg.pData = rmsg;
+    
+    code = schHandleResponseMsg(pJob, task, task->execId, &msg, 0);
     
     ASSERT_EQ(code, 0);
     pIter = taosHashIterate(pJob->execTasks, pIter);
@@ -669,11 +748,18 @@ TEST(queryTest, normalCase) {
   pIter = taosHashIterate(pJob->execTasks, NULL);
   while (pIter) {
     SSchTask *task = *(SSchTask **)pIter;
+    if (JOB_TASK_STATUS_EXEC == task->status) {
+      SDataBuf msg = {0};
+      void* rmsg = NULL;
+      schtBuildQueryRspMsg(&msg.len, &rmsg);
+      msg.msgType = TDMT_SCH_QUERY_RSP;
+      msg.pData = rmsg;
       
-    SQueryTableRsp rsp = {0};
+      code = schHandleResponseMsg(pJob, task, task->execId, &msg, 0);
-    code = schHandleResponseMsg(pJob, task, TDMT_SCH_QUERY_RSP, (char *)&rsp, sizeof(rsp), 0);
       
       ASSERT_EQ(code, 0);
+    }
+
     pIter = taosHashIterate(pJob->execTasks, pIter);
   }
 
@@ -703,18 +789,12 @@ TEST(queryTest, normalCase) {
   ASSERT_EQ(pRsp->numOfRows, 10);
   taosMemoryFreeClear(data);
 
-  data = NULL;
-  code = schedulerFetchRows(job, &req);
-  ASSERT_EQ(code, 0);
-  ASSERT_TRUE(data == NULL);
-
   schReleaseJob(job);
   
+  schedulerDestroy();
+
   schedulerFreeJob(&job, 0);
 
-  schtFreeQueryDag(&dag);
-
-  schedulerDestroy();
 }
 
 TEST(queryTest, readyFirstCase) {
@@ -724,21 +804,20 @@ TEST(queryTest, readyFirstCase) {
   char       *tablename = "table1";
   SVgroupInfo vgInfo = {0};
   int64_t     job = 0;
-  SQueryPlan  dag;
+  SQueryPlan* dag = (SQueryPlan*)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN);
 
-  memset(&dag, 0, sizeof(dag));
+  SArray *qnodeList = taosArrayInit(1, sizeof(SQueryNodeLoad));
 
-  SArray *qnodeList = taosArrayInit(1, sizeof(SEp));
+  SQueryNodeLoad load = {0};
-
+  load.addr.epSet.numOfEps = 1;
-  SEp qnodeAddr = {0};
+  strcpy(load.addr.epSet.eps[0].fqdn, "qnode0.ep");
-  strcpy(qnodeAddr.fqdn, "qnode0.ep");
+  load.addr.epSet.eps[0].port = 6031;
-  qnodeAddr.port = 6031;
+  taosArrayPush(qnodeList, &load);  
-  taosArrayPush(qnodeList, &qnodeAddr);
 
   int32_t code = schedulerInit();
   ASSERT_EQ(code, 0);
 
-  schtBuildQueryDag(&dag);
+  schtBuildQueryDag(dag);
 
   schtSetPlanToString();
   schtSetExecNode();
@@ -751,7 +830,7 @@ TEST(queryTest, readyFirstCase) {
   SSchedulerReq req = {0};
   req.pConn = &conn;
   req.pNodeList = qnodeList;
-  req.pDag = &dag;
+  req.pDag = dag;
   req.sql = "select * from tb";
   req.execFp = schtQueryCb;
   req.cbParam = &queryDone;
@@ -764,8 +843,13 @@ TEST(queryTest, readyFirstCase) {
   while (pIter) {
     SSchTask *task = *(SSchTask **)pIter;
 
-    SQueryTableRsp rsp = {0};
+    SDataBuf msg = {0};
-    code = schHandleResponseMsg(pJob, task, TDMT_SCH_QUERY_RSP, (char *)&rsp, sizeof(rsp), 0);
+    void* rmsg = NULL;
+    schtBuildQueryRspMsg(&msg.len, &rmsg);
+    msg.msgType = TDMT_SCH_QUERY_RSP;
+    msg.pData = rmsg;
+    
+    code = schHandleResponseMsg(pJob, task, task->execId, &msg, 0);
 
     ASSERT_EQ(code, 0);
     pIter = taosHashIterate(pJob->execTasks, pIter);
@@ -775,10 +859,18 @@ TEST(queryTest, readyFirstCase) {
   while (pIter) {
     SSchTask *task = *(SSchTask **)pIter;
 
-    SQueryTableRsp rsp = {0};
+    if (JOB_TASK_STATUS_EXEC == task->status) {
-    code = schHandleResponseMsg(pJob, task, TDMT_SCH_QUERY_RSP, (char *)&rsp, sizeof(rsp), 0);
+      SDataBuf msg = {0};
+      void* rmsg = NULL;
+      schtBuildQueryRspMsg(&msg.len, &rmsg);
+      msg.msgType = TDMT_SCH_QUERY_RSP;
+      msg.pData = rmsg;
+      
+      code = schHandleResponseMsg(pJob, task, task->execId, &msg, 0);
       
       ASSERT_EQ(code, 0);
+    }
+
     pIter = taosHashIterate(pJob->execTasks, pIter);
   }
 
@@ -807,18 +899,11 @@ TEST(queryTest, readyFirstCase) {
   ASSERT_EQ(pRsp->numOfRows, 10);
   taosMemoryFreeClear(data);
 
-  data = NULL;
-  code = schedulerFetchRows(job, &req);
-  ASSERT_EQ(code, 0);
-  ASSERT_TRUE(data == NULL);
-
   schReleaseJob(job);
 
-  schedulerFreeJob(&job, 0);
-
-  schtFreeQueryDag(&dag);
-
   schedulerDestroy();
+
+  schedulerFreeJob(&job, 0);
 }
 
 TEST(queryTest, flowCtrlCase) {
@@ -828,35 +913,39 @@ TEST(queryTest, flowCtrlCase) {
   char       *tablename = "table1";
   SVgroupInfo vgInfo = {0};
   int64_t     job = 0;
-  SQueryPlan  dag;
+  SQueryPlan* dag = (SQueryPlan*)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN);
 
   schtInitLogFile();
 
   taosSeedRand(taosGetTimestampSec());
 
-  SArray *qnodeList = taosArrayInit(1, sizeof(SEp));
+  SArray *qnodeList = taosArrayInit(1, sizeof(SQueryNodeLoad));
+
+  SQueryNodeLoad load = {0};
+  load.addr.epSet.numOfEps = 1;
+  strcpy(load.addr.epSet.eps[0].fqdn, "qnode0.ep");
+  load.addr.epSet.eps[0].port = 6031;
+  taosArrayPush(qnodeList, &load);
 
-  SEp qnodeAddr = {0};
-  strcpy(qnodeAddr.fqdn, "qnode0.ep");
-  qnodeAddr.port = 6031;
-  taosArrayPush(qnodeList, &qnodeAddr);
 
   int32_t code = schedulerInit();
   ASSERT_EQ(code, 0);
 
-  schtBuildQueryFlowCtrlDag(&dag);
+  schtBuildQueryFlowCtrlDag(dag);
 
   schtSetPlanToString();
   schtSetExecNode();
   schtSetAsyncSendMsgToServer();
 
+  initTaskQueue();
+
   int32_t          queryDone = 0;
   SRequestConnInfo conn = {0};
   conn.pTrans = mockPointer;
   SSchedulerReq req = {0};
   req.pConn = &conn;
   req.pNodeList = qnodeList;
-  req.pDag = &dag;
+  req.pDag = dag;
   req.sql = "select * from tb";
   req.execFp = schtQueryCb;
   req.cbParam = &queryDone;
@@ -866,41 +955,27 @@ TEST(queryTest, flowCtrlCase) {
 
   SSchJob *pJob = schAcquireJob(job);
 
-  bool qDone = false;
+  while (!queryDone) {
-
-  while (!qDone) {
     void *pIter = taosHashIterate(pJob->execTasks, NULL);
-    if (NULL == pIter) {
-      break;
-    }
-
     while (pIter) {
       SSchTask *task = *(SSchTask **)pIter;
 
-      taosHashCancelIterate(pJob->execTasks, pIter);
+      if (JOB_TASK_STATUS_EXEC == task->status && 0 != task->lastMsgType) {
+        SDataBuf msg = {0};
+        void* rmsg = NULL;
+        schtBuildQueryRspMsg(&msg.len, &rmsg);
+        msg.msgType = TDMT_SCH_QUERY_RSP;
+        msg.pData = rmsg;
         
-      if (task->lastMsgType == TDMT_SCH_QUERY) {
+        code = schHandleResponseMsg(pJob, task, task->execId, &msg, 0);
-        SQueryTableRsp rsp = {0};
-        code = schHandleResponseMsg(pJob, task, TDMT_SCH_QUERY_RSP, (char *)&rsp, sizeof(rsp), 0);
         
         ASSERT_EQ(code, 0);
-      } else {
-        qDone = true;
-        break;
       }
 
-      pIter = NULL;
+      pIter = taosHashIterate(pJob->execTasks, pIter);
     }
   }
 
-  while (true) {
-    if (queryDone) {
-      break;
-    }
-
-    taosUsleep(10000);
-  }
-
   TdThreadAttr thattr;
   taosThreadAttrInit(&thattr);
 
@@ -918,18 +993,11 @@ TEST(queryTest, flowCtrlCase) {
   ASSERT_EQ(pRsp->numOfRows, 10);
   taosMemoryFreeClear(data);
 
-  data = NULL;
-  code = schedulerFetchRows(job, &req);
-  ASSERT_EQ(code, 0);
-  ASSERT_TRUE(data == NULL);
-
   schReleaseJob(job);
 
-  schedulerFreeJob(&job, 0);
-
-  schtFreeQueryDag(&dag);
-
   schedulerDestroy();
+
+  schedulerFreeJob(&job, 0);
 }
 
 TEST(insertTest, normalCase) {
@@ -938,20 +1006,21 @@ TEST(insertTest, normalCase) {
   char       *dbname = "1.db1";
   char       *tablename = "table1";
   SVgroupInfo vgInfo = {0};
-  SQueryPlan  dag;
+  SQueryPlan* dag = (SQueryPlan*)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN);
   uint64_t    numOfRows = 0;
 
-  SArray *qnodeList = taosArrayInit(1, sizeof(SEp));
+  SArray *qnodeList = taosArrayInit(1, sizeof(SQueryNodeLoad));
 
-  SEp qnodeAddr = {0};
+  SQueryNodeLoad load = {0};
-  strcpy(qnodeAddr.fqdn, "qnode0.ep");
+  load.addr.epSet.numOfEps = 1;
-  qnodeAddr.port = 6031;
+  strcpy(load.addr.epSet.eps[0].fqdn, "qnode0.ep");
-  taosArrayPush(qnodeList, &qnodeAddr);
+  load.addr.epSet.eps[0].port = 6031;
+  taosArrayPush(qnodeList, &load);
 
   int32_t code = schedulerInit();
   ASSERT_EQ(code, 0);
 
-  schtBuildInsertDag(&dag);
+  schtBuildInsertDag(dag);
 
   schtSetPlanToString();
   schtSetAsyncSendMsgToServer();
@@ -962,21 +1031,19 @@ TEST(insertTest, normalCase) {
   TdThread thread1;
   taosThreadCreate(&(thread1), &thattr, schtSendRsp, &insertJobRefId);
 
-  SExecResult res = {0};
+  int32_t          queryDone = 0;
-
   SRequestConnInfo conn = {0};
   conn.pTrans = mockPointer;
   SSchedulerReq req = {0};
   req.pConn = &conn;
   req.pNodeList = qnodeList;
-  req.pDag = &dag;
+  req.pDag = dag;
   req.sql = "insert into tb values(now,1)";
   req.execFp = schtQueryCb;
-  req.cbParam = NULL;
+  req.cbParam = &queryDone;
 
   code = schedulerExecJob(&req, &insertJobRefId);
   ASSERT_EQ(code, 0);
-  ASSERT_EQ(res.numOfRows, 20);
 
   schedulerFreeJob(&insertJobRefId, 0);
 
@@ -989,7 +1056,7 @@ TEST(multiThread, forceFree) {
 
   TdThread thread1, thread2, thread3;
   taosThreadCreate(&(thread1), &thattr, schtRunJobThread, NULL);
-  taosThreadCreate(&(thread2), &thattr, schtFreeJobThread, NULL);
+//  taosThreadCreate(&(thread2), &thattr, schtFreeJobThread, NULL);
   taosThreadCreate(&(thread3), &thattr, schtFetchRspThread, NULL);
 
   while (true) {
@@ -1002,7 +1069,7 @@ TEST(multiThread, forceFree) {
   }
 
   schtTestStop = true;
-  taosSsleep(3);
+  //taosSsleep(3);
 }
 
 int main(int argc, char **argv) {

source/libs/stream/inc/streamInt.h

@@ -107,7 +107,7 @@ SStreamDataBlock* createStreamBlockFromResults(SStreamQueueItem* pItem, SStreamT
 void              destroyStreamDataBlock(SStreamDataBlock* pBlock);
 
 int32_t streamRetrieveReqToData(const SStreamRetrieveReq* pReq, SStreamDataBlock* pData);
-int32_t streamBroadcastToChildren(SStreamTask* pTask, const SSDataBlock* pBlock);
+int32_t streamBroadcastToUpTasks(SStreamTask* pTask, const SSDataBlock* pBlock);
 
 int32_t tEncodeStreamRetrieveReq(SEncoder* pEncoder, const SStreamRetrieveReq* pReq);
 

source/libs/stream/src/stream.c

@@ -181,7 +181,7 @@ static int32_t streamTaskAppendInputBlocks(SStreamTask* pTask, const SStreamDisp
   return status;
 }
 
-int32_t streamTaskEnqueueRetrieve(SStreamTask* pTask, SStreamRetrieveReq* pReq, SRpcMsg* pRsp) {
+int32_t streamTaskEnqueueRetrieve(SStreamTask* pTask, SStreamRetrieveReq* pReq) {
   SStreamDataBlock* pData = taosAllocateQitem(sizeof(SStreamDataBlock), DEF_QITEM, sizeof(SStreamDataBlock));
   int8_t            status = TASK_INPUT_STATUS__NORMAL;
 
@@ -203,17 +203,6 @@ int32_t streamTaskEnqueueRetrieve(SStreamTask* pTask, SStreamRetrieveReq* pReq,
     /*status = TASK_INPUT_STATUS__FAILED;*/
   }
 
-  // rsp by input status
-  void* buf = rpcMallocCont(sizeof(SMsgHead) + sizeof(SStreamRetrieveRsp));
-  ((SMsgHead*)buf)->vgId = htonl(pReq->srcNodeId);
-  SStreamRetrieveRsp* pCont = POINTER_SHIFT(buf, sizeof(SMsgHead));
-  pCont->streamId = pReq->streamId;
-  pCont->rspToTaskId = pReq->srcTaskId;
-  pCont->rspFromTaskId = pReq->dstTaskId;
-  pRsp->pCont = buf;
-  pRsp->contLen = sizeof(SMsgHead) + sizeof(SStreamRetrieveRsp);
-  tmsgSendRsp(pRsp);
-
   return status == TASK_INPUT_STATUS__NORMAL ? 0 : -1;
 }
 
@@ -295,11 +284,12 @@ int32_t streamProcessDispatchMsg(SStreamTask* pTask, SStreamDispatchReq* pReq, S
   return 0;
 }
 
-int32_t streamProcessRetrieveReq(SStreamTask* pTask, SStreamRetrieveReq* pReq, SRpcMsg* pRsp) {
+int32_t streamProcessRetrieveReq(SStreamTask* pTask, SStreamRetrieveReq* pReq) {
-  streamTaskEnqueueRetrieve(pTask, pReq, pRsp);
+  int32_t code = streamTaskEnqueueRetrieve(pTask, pReq);
-  ASSERT(pTask->info.taskLevel != TASK_LEVEL__SINK);
+  if(code != 0){
-  streamSchedExec(pTask);
+    return code;
-  return 0;
+  }
+  return streamSchedExec(pTask);
 }
 
 void streamTaskInputFail(SStreamTask* pTask) { atomic_store_8(&pTask->inputq.status, TASK_INPUT_STATUS__FAILED); }

source/libs/stream/src/streamDispatch.c

@@ -162,16 +162,71 @@ int32_t tDecodeStreamRetrieveReq(SDecoder* pDecoder, SStreamRetrieveReq* pReq) {
   return 0;
 }
 
-void tDeleteStreamRetrieveReq(SStreamRetrieveReq* pReq) { taosMemoryFree(pReq->pRetrieve); }
+void sendRetrieveRsp(SStreamRetrieveReq *pReq, SRpcMsg* pRsp){
+  void* buf = rpcMallocCont(sizeof(SMsgHead) + sizeof(SStreamRetrieveRsp));
+  ((SMsgHead*)buf)->vgId = htonl(pReq->srcNodeId);
+  SStreamRetrieveRsp* pCont = POINTER_SHIFT(buf, sizeof(SMsgHead));
+  pCont->streamId = pReq->streamId;
+  pCont->rspToTaskId = pReq->srcTaskId;
+  pCont->rspFromTaskId = pReq->dstTaskId;
+  pRsp->pCont = buf;
+  pRsp->contLen = sizeof(SMsgHead) + sizeof(SStreamRetrieveRsp);
+  tmsgSendRsp(pRsp);
+}
 
-int32_t streamBroadcastToChildren(SStreamTask* pTask, const SSDataBlock* pBlock) {
+int32_t broadcastRetrieveMsg(SStreamTask* pTask, SStreamRetrieveReq *req){
-  int32_t            code = -1;
+  int32_t code = 0;
-  SRetrieveTableRsp* pRetrieve = NULL;
   void*   buf = NULL;
+  int32_t sz = taosArrayGetSize(pTask->upstreamInfo.pList);
+  ASSERT(sz > 0);
+  for (int32_t i = 0; i < sz; i++) {
+    req->reqId = tGenIdPI64();
+    SStreamChildEpInfo* pEpInfo = taosArrayGetP(pTask->upstreamInfo.pList, i);
+    req->dstNodeId = pEpInfo->nodeId;
+    req->dstTaskId = pEpInfo->taskId;
+    int32_t len;
+    tEncodeSize(tEncodeStreamRetrieveReq, req, len, code);
+    if (code != 0) {
+      ASSERT(0);
+      return code;
+    }
+
+    buf = rpcMallocCont(sizeof(SMsgHead) + len);
+    if (buf == NULL) {
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      return code;
+    }
+
+    ((SMsgHead*)buf)->vgId = htonl(pEpInfo->nodeId);
+    void*    abuf = POINTER_SHIFT(buf, sizeof(SMsgHead));
+    SEncoder encoder;
+    tEncoderInit(&encoder, abuf, len);
+    tEncodeStreamRetrieveReq(&encoder, req);
+    tEncoderClear(&encoder);
+
+    SRpcMsg rpcMsg = {0};
+    initRpcMsg(&rpcMsg, TDMT_STREAM_RETRIEVE, buf, len + sizeof(SMsgHead));
+
+    code = tmsgSendReq(&pEpInfo->epSet, &rpcMsg);
+    if (code != 0) {
+      ASSERT(0);
+      rpcFreeCont(buf);
+      return code;
+    }
+
+    buf = NULL;
+    stDebug("s-task:%s (child %d) send retrieve req to task:0x%x (vgId:%d), reqId:0x%" PRIx64, pTask->id.idStr,
+            pTask->info.selfChildId, pEpInfo->taskId, pEpInfo->nodeId, req->reqId);
+  }
+  return code;
+}
+
+static int32_t buildStreamRetrieveReq(SStreamTask* pTask, const SSDataBlock* pBlock, SStreamRetrieveReq* req){
+  SRetrieveTableRsp* pRetrieve = NULL;
   int32_t            dataStrLen = sizeof(SRetrieveTableRsp) + blockGetEncodeSize(pBlock);
 
   pRetrieve = taosMemoryCalloc(1, dataStrLen);
-  if (pRetrieve == NULL) return -1;
+  if (pRetrieve == NULL) return TSDB_CODE_OUT_OF_MEMORY;
 
   int32_t numOfCols = taosArrayGetSize(pBlock->pDataBlock);
   pRetrieve->useconds = 0;
@@ -187,57 +242,24 @@ int32_t streamBroadcastToChildren(SStreamTask* pTask, const SSDataBlock* pBlock)
 
   int32_t actualLen = blockEncode(pBlock, pRetrieve->data, numOfCols);
 
-  SStreamRetrieveReq req = {
+  req->streamId = pTask->id.streamId;
-      .streamId = pTask->id.streamId,
+  req->srcNodeId = pTask->info.nodeId;
-      .srcNodeId = pTask->info.nodeId,
+  req->srcTaskId = pTask->id.taskId;
-      .srcTaskId = pTask->id.taskId,
+  req->pRetrieve = pRetrieve;
-      .pRetrieve = pRetrieve,
+  req->retrieveLen = dataStrLen;
-      .retrieveLen = dataStrLen,
+  return 0;
-  };
-
-  int32_t sz = taosArrayGetSize(pTask->upstreamInfo.pList);
-  ASSERT(sz > 0);
-  for (int32_t i = 0; i < sz; i++) {
-    req.reqId = tGenIdPI64();
-    SStreamChildEpInfo* pEpInfo = taosArrayGetP(pTask->upstreamInfo.pList, i);
-    req.dstNodeId = pEpInfo->nodeId;
-    req.dstTaskId = pEpInfo->taskId;
-    int32_t len;
-    tEncodeSize(tEncodeStreamRetrieveReq, &req, len, code);
-    if (code < 0) {
-      ASSERT(0);
-      return -1;
 }
 
-    buf = rpcMallocCont(sizeof(SMsgHead) + len);
+int32_t streamBroadcastToUpTasks(SStreamTask* pTask, const SSDataBlock* pBlock) {
-    if (buf == NULL) {
+  SStreamRetrieveReq req;
-      goto CLEAR;
+  int32_t code = buildStreamRetrieveReq(pTask, pBlock, &req);
+  if(code != 0){
+    return code;
   }
 
-    ((SMsgHead*)buf)->vgId = htonl(pEpInfo->nodeId);
+  code = broadcastRetrieveMsg(pTask, &req);
-    void*    abuf = POINTER_SHIFT(buf, sizeof(SMsgHead));
+  taosMemoryFree(req.pRetrieve);
-    SEncoder encoder;
-    tEncoderInit(&encoder, abuf, len);
-    tEncodeStreamRetrieveReq(&encoder, &req);
-    tEncoderClear(&encoder);
 
-    SRpcMsg rpcMsg = {0};
-    initRpcMsg(&rpcMsg, TDMT_STREAM_RETRIEVE, buf, len + sizeof(SMsgHead));
-
-    if (tmsgSendReq(&pEpInfo->epSet, &rpcMsg) < 0) {
-      ASSERT(0);
-      goto CLEAR;
-    }
-
-    buf = NULL;
-    stDebug("s-task:%s (child %d) send retrieve req to task:0x%x (vgId:%d), reqId:0x%" PRIx64, pTask->id.idStr,
-            pTask->info.selfChildId, pEpInfo->taskId, pEpInfo->nodeId, req.reqId);
-  }
-  code = 0;
-
-CLEAR:
-  taosMemoryFree(pRetrieve);
-  rpcFreeCont(buf);
   return code;
 }
 
@@ -547,6 +569,7 @@ int32_t streamSearchAndAddBlock(SStreamTask* pTask, SStreamDispatchReq* pReqs, S
     char ctbName[TSDB_TABLE_FNAME_LEN] = {0};
     if (pDataBlock->info.parTbName[0]) {
       if(pTask->ver >= SSTREAM_TASK_SUBTABLE_CHANGED_VER &&
+          pTask->subtableWithoutMd5 != 1 &&
           !isAutoTableName(pDataBlock->info.parTbName) &&
           !alreadyAddGroupId(pDataBlock->info.parTbName) &&
           groupId != 0){

source/libs/stream/src/streamExec.c

@@ -138,7 +138,7 @@ static int32_t streamTaskExecImpl(SStreamTask* pTask, SStreamQueueItem* pItem, i
     }
 
     if (output->info.type == STREAM_RETRIEVE) {
-      if (streamBroadcastToChildren(pTask, output) < 0) {
+      if (streamBroadcastToUpTasks(pTask, output) < 0) {
         // TODO
       }
       continue;

source/libs/stream/src/streamTask.c

@@ -80,7 +80,7 @@ static SStreamChildEpInfo* createStreamTaskEpInfo(const SStreamTask* pTask) {
 }
 
 SStreamTask* tNewStreamTask(int64_t streamId, int8_t taskLevel, SEpSet* pEpset, bool fillHistory, int64_t triggerParam,
-                            SArray* pTaskList, bool hasFillhistory) {
+                            SArray* pTaskList, bool hasFillhistory, int8_t subtableWithoutMd5) {
   SStreamTask* pTask = (SStreamTask*)taosMemoryCalloc(1, sizeof(SStreamTask));
   if (pTask == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -96,6 +96,7 @@ SStreamTask* tNewStreamTask(int64_t streamId, int8_t taskLevel, SEpSet* pEpset,
   pTask->info.taskLevel = taskLevel;
   pTask->info.fillHistory = fillHistory;
   pTask->info.triggerParam = triggerParam;
+  pTask->subtableWithoutMd5 = subtableWithoutMd5;
 
   pTask->status.pSM = streamCreateStateMachine(pTask);
   if (pTask->status.pSM == NULL) {
@@ -104,7 +105,7 @@ SStreamTask* tNewStreamTask(int64_t streamId, int8_t taskLevel, SEpSet* pEpset,
   }
 
   char buf[128] = {0};
-  sprintf(buf, "0x%" PRIx64 "-%d", pTask->id.streamId, pTask->id.taskId);
+  sprintf(buf, "0x%" PRIx64 "-0x%x", pTask->id.streamId, pTask->id.taskId);
 
   pTask->id.idStr = taosStrdup(buf);
   pTask->status.schedStatus = TASK_SCHED_STATUS__INACTIVE;
@@ -205,6 +206,7 @@ int32_t tEncodeStreamTask(SEncoder* pEncoder, const SStreamTask* pTask) {
     if (tEncodeCStr(pEncoder, pTask->outputInfo.shuffleDispatcher.stbFullName) < 0) return -1;
   }
   if (tEncodeI64(pEncoder, pTask->info.triggerParam) < 0) return -1;
+  if (tEncodeI8(pEncoder, pTask->subtableWithoutMd5) < 0) return -1;
   if (tEncodeCStrWithLen(pEncoder, pTask->reserve, sizeof(pTask->reserve) - 1) < 0) return -1;
 
   tEndEncode(pEncoder);
@@ -287,6 +289,7 @@ int32_t tDecodeStreamTask(SDecoder* pDecoder, SStreamTask* pTask) {
     if (tDecodeCStrTo(pDecoder, pTask->outputInfo.shuffleDispatcher.stbFullName) < 0) return -1;
   }
   if (tDecodeI64(pDecoder, &pTask->info.triggerParam) < 0) return -1;
+  if (tDecodeI8(pDecoder, &pTask->subtableWithoutMd5) < 0) return -1;
   if (tDecodeCStrTo(pDecoder, pTask->reserve) < 0) return -1;
 
   tEndDecode(pDecoder);
@@ -879,9 +882,7 @@ void streamTaskResume(SStreamTask* pTask) {
   }
 }
 
-bool streamTaskIsSinkTask(const SStreamTask* pTask) {
+bool streamTaskIsSinkTask(const SStreamTask* pTask) { return pTask->info.taskLevel == TASK_LEVEL__SINK; }
-  return pTask->info.taskLevel == TASK_LEVEL__SINK;
-}
 
 int32_t streamTaskSendCheckpointReq(SStreamTask* pTask) {
   int32_t     code;

source/libs/stream/src/streamUpdate.c

@@ -261,6 +261,7 @@ void updateInfoDestroy(SUpdateInfo *pInfo) {
 
   taosArrayDestroy(pInfo->pTsSBFs);
   taosHashCleanup(pInfo->pMap);
+  updateInfoDestoryColseWinSBF(pInfo);
   taosMemoryFree(pInfo);
 }