diff --git a/cmake/cmake.define b/cmake/cmake.define
index 6f4153c7d0..edc5dd601a 100644
--- a/cmake/cmake.define
+++ b/cmake/cmake.define
@@ -1,5 +1,4 @@
 cmake_minimum_required(VERSION 3.0)
-
 set(CMAKE_VERBOSE_MAKEFILE ON)
 set(TD_BUILD_TAOSA_INTERNAL FALSE)
 
diff --git a/docs/en/07-develop/06-stream.md b/docs/en/07-develop/06-stream.md
index 125173e60b..59a6b815cf 100644
--- a/docs/en/07-develop/06-stream.md
+++ b/docs/en/07-develop/06-stream.md
@@ -52,7 +52,7 @@ CREATE TABLE d1004 USING meters TAGS ("California.LosAngeles", 3);
 ### Create a Stream
 
 ```sql
-create stream current_stream into current_stream_output_stb as select _wstart as start, _wend as end, max(current) as max_current from meters where voltage <= 220 interval (5s);
+create stream current_stream trigger at_once into current_stream_output_stb as select _wstart as wstart, _wend as wend, max(current) as max_current from meters where voltage <= 220 interval (5s);
 ```
 
 ### Write Data
diff --git a/docs/en/07-develop/07-tmq.mdx b/docs/en/07-develop/07-tmq.mdx
index 3326164f49..5af3897afd 100644
--- a/docs/en/07-develop/07-tmq.mdx
+++ b/docs/en/07-develop/07-tmq.mdx
@@ -53,17 +53,17 @@ The related schemas and APIs in various languages are described as follows:
     typedef void(tmq_commit_cb(tmq_t *tmq, int32_t code, void *param));
 
     typedef enum tmq_conf_res_t {
-    TMQ_CONF_UNKNOWN = -2,
-    TMQ_CONF_INVALID = -1,
-    TMQ_CONF_OK = 0,
-} tmq_conf_res_t;
+        TMQ_CONF_UNKNOWN = -2,
+        TMQ_CONF_INVALID = -1,
+        TMQ_CONF_OK = 0,
+    } tmq_conf_res_t;
 
     typedef struct tmq_topic_assignment {
-    int32_t vgId;
-    int64_t currentOffset;
-    int64_t begin;
-    int64_t end;
-} tmq_topic_assignment;
+        int32_t vgId;
+        int64_t currentOffset;
+        int64_t begin;
+        int64_t end;  // The last version of wal + 1
+    } tmq_topic_assignment;
 
     DLL_EXPORT tmq_conf_t    *tmq_conf_new();
     DLL_EXPORT tmq_conf_res_t tmq_conf_set(tmq_conf_t *conf, const char *key, const char *value);
@@ -82,21 +82,21 @@ The related schemas and APIs in various languages are described as follows:
     DLL_EXPORT int32_t   tmq_subscription(tmq_t *tmq, tmq_list_t **topics);
     DLL_EXPORT TAOS_RES *tmq_consumer_poll(tmq_t *tmq, int64_t timeout);
     DLL_EXPORT int32_t   tmq_consumer_close(tmq_t *tmq);
-    DLL_EXPORT int32_t   tmq_commit_sync(tmq_t *tmq, const TAOS_RES *msg);
+    DLL_EXPORT int32_t   tmq_commit_sync(tmq_t *tmq, const TAOS_RES *msg); //Commit the msg’s offset + 1
     DLL_EXPORT void      tmq_commit_async(tmq_t *tmq, const TAOS_RES *msg, tmq_commit_cb *cb, void *param);
     DLL_EXPORT int32_t   tmq_commit_offset_sync(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset);
     DLL_EXPORT void      tmq_commit_offset_async(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset, tmq_commit_cb *cb, void *param);
     DLL_EXPORT int32_t   tmq_get_topic_assignment(tmq_t *tmq, const char *pTopicName, tmq_topic_assignment **assignment,int32_t *numOfAssignment);
     DLL_EXPORT void      tmq_free_assignment(tmq_topic_assignment* pAssignment);
     DLL_EXPORT int32_t   tmq_offset_seek(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset);
-    DLL_EXPORT int64_t   tmq_position(tmq_t *tmq, const char *pTopicName, int32_t vgId);
+    DLL_EXPORT int64_t   tmq_position(tmq_t *tmq, const char *pTopicName, int32_t vgId);  // The current offset is the offset of the last consumed message + 1
     DLL_EXPORT int64_t   tmq_committed(tmq_t *tmq, const char *pTopicName, int32_t vgId);
 
     DLL_EXPORT const char *tmq_get_topic_name(TAOS_RES *res);
     DLL_EXPORT const char *tmq_get_db_name(TAOS_RES *res);
     DLL_EXPORT int32_t     tmq_get_vgroup_id(TAOS_RES *res);
-    DLL_EXPORT int64_t     tmq_get_vgroup_offset(TAOS_RES* res);
-    DLL_EXPORT const char *tmq_err2str(int32_t code);DLL_EXPORT void           tmq_conf_set_auto_commit_cb(tmq_conf_t *conf, tmq_commit_cb *cb, void *param);
+    DLL_EXPORT int64_t     tmq_get_vgroup_offset(TAOS_RES* res);  // Get current offset of the result
+    DLL_EXPORT const char *tmq_err2str(int32_t code);
 ```
 
 The following example is based on the smart meter table described in Data Models. For complete sample code, see the C language section below.
diff --git a/docs/en/12-taos-sql/25-grant.md b/docs/en/12-taos-sql/25-grant.md
index c214e11876..5ebed12b59 100644
--- a/docs/en/12-taos-sql/25-grant.md
+++ b/docs/en/12-taos-sql/25-grant.md
@@ -4,7 +4,7 @@ sidebar_label: Access Control
 description: This document describes how to manage users and permissions in TDengine.
 ---
 
-This document describes how to manage permissions in TDengine.
+User and Access control is a distingguished feature of TDengine enterprise edition. In this section, only the most fundamental functionalities of user and access control are demonstrated. To get the full knowledge of user and access control, please contact the TDengine team.
 
 ## Create a User
 
diff --git a/docs/en/14-reference/03-connector/03-cpp.mdx b/docs/en/14-reference/03-connector/03-cpp.mdx
index 13029dbe91..0009902425 100644
--- a/docs/en/14-reference/03-connector/03-cpp.mdx
+++ b/docs/en/14-reference/03-connector/03-cpp.mdx
@@ -378,7 +378,7 @@ In addition to writing data using the SQL method or the parameter binding API, w
 - `TAOS_RES* taos_schemaless_insert(TAOS* taos, const char* lines[], int numLines, int protocol, int precision)`
 
   **Function description**
-  This interface writes the text data of the line protocol to TDengine.
+  - This interface writes the text data of the line protocol to TDengine.
 
   **Parameter description**
   - taos: database connection, established by the `taos_connect()` function.
@@ -387,12 +387,13 @@ In addition to writing data using the SQL method or the parameter binding API, w
   - protocol: the protocol type of the lines, used to identify the text data format.
   - precision: precision string for the timestamp in the text data.
 
-  **return value**
-  TAOS_RES structure, application can get error message by using `taos_errstr()` and also error code by using `taos_errno()`.
+  **Return value**
+  - TAOS_RES structure, application can get error message by using `taos_errstr()` and also error code by using `taos_errno()`.
   In some cases, the returned TAOS_RES is `NULL`, and it is still possible to call `taos_errno()` to safely get the error code information.
   The returned TAOS_RES needs to be freed by the caller in order to avoid memory leaks.
 
   **Description**
+  
   The protocol type is enumerated and contains the following three formats.
 
   - TSDB_SML_LINE_PROTOCOL: InfluxDB line protocol (Line Protocol)
@@ -427,3 +428,89 @@ In addition to writing data using the SQL method or the parameter binding API, w
   - Within _raw interfaces represent data through the passed parameters lines and len. In order to solve the problem that the original interface data contains '\0' and is truncated. The totalRows pointer returns the number of parsed data rows.
   - Within _ttl interfaces can pass the ttl parameter to control the ttl expiration time of the table.
   - Within _reqid interfaces can track the entire call chain by passing the reqid parameter.
+
+### Subscription API
+
+- `int32_t   tmq_get_topic_assignment(tmq_t *tmq, const char *pTopicName, tmq_topic_assignment **assignment, int32_t *numOfAssignment)`
+- `void      tmq_free_assignment(tmq_topic_assignment* pAssignment)`
+  
+  tmq_topic_assignment defined as follows:
+  ```c
+  typedef struct tmq_topic_assignment {
+    int32_t vgId;
+    int64_t currentOffset;
+    int64_t begin;
+    int64_t end;
+  } tmq_topic_assignment;
+  ```
+  **Function description**
+  - tmq_get_topic_assignment get the current vgroup information of this consumer
+
+  **Parameter description**
+  - numOfAssignment:the num of vgroups assigned to this consumer
+  - assignment:the information of vgroups, needed to be freed by tmq_free_assignment
+
+  **Return value**
+  - zero success,none zero failed, wrong message can be obtained through `char *tmq_err2str(int32_t code)`
+
+- `int64_t   tmq_committed(tmq_t *tmq, const char *pTopicName, int32_t vgId)`
+  **Function description**
+  - get the committed offset
+
+  **Return value**
+  - the value of committed offset, -2147467247 means no committed value, Other values less than 0 indicate failure
+
+- `int32_t   tmq_commit_sync(tmq_t *tmq, const TAOS_RES *msg)`
+- `void      tmq_commit_async(tmq_t *tmq, const TAOS_RES *msg, tmq_commit_cb *cb, void *param)`
+- `int32_t   tmq_commit_offset_sync(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset)`
+- `void      tmq_commit_offset_async(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset, tmq_commit_cb *cb, void *param)`
+  
+  **Function description**
+
+  The commit interface is divided into two types, each with synchronous and asynchronous interfaces:
+  - The first type: based on message submission, submit the progress in the message. If the message passes NULL, submit the current progress of all vgroups consumed by the current consumer: tmq_commit_sync/tmq_commit_async
+  - The second type: submit based on the offset of a Vgroup in a topic: tmq_commit_offset_sync/tmq_commit_offset_async
+  
+  **Parameter description**
+  - msg：Message consumed, If the message passes NULL, submit the current progress of all vgroups consumed by the current consumer
+
+  **Return value**
+  - zero success, none zero failed, wrong message can be obtained through `char *tmq_err2str(int32_t code)`
+
+- `int64_t     tmq_position(tmq_t *tmq, const char *pTopicName, int32_t vgId)`
+
+  **Function description**
+  - Obtain the current consumption location, which is the next location of the data consumed
+  
+  **Return value**
+  - the current consumption location, none zero failed, wrong message can be obtained through `char *tmq_err2str(int32_t code)`
+
+- `int32_t   tmq_offset_seek(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset)`
+
+  **Function description**
+  - Set the offset position of the consumer in a Vgroup of a certain topic to start consumption
+
+  **Return value**
+  - zero success, none zero failed, wrong message can be obtained through `char *tmq_err2str(int32_t code)`
+  
+- `int32_t   int64_t     tmq_get_vgroup_offset(TAOS_RES* res)`
+
+  **Function description**
+  - Obtain the starting offset of the consumed data
+
+  **Parameter description**
+  - msg：Message consumed
+
+  **Return value**
+  - the starting offset of the consumed data, none zero failed, wrong message can be obtained through `char *tmq_err2str(int32_t code)`
+  
+- `int32_t   int32_t   tmq_subscription(tmq_t *tmq, tmq_list_t **topics)`
+
+  **Function description**
+  - Obtain a list of topics subscribed by consumers
+
+  **Parameter description**
+  - topics: a list of topics subscribed by consumers，need to be freed by tmq_list_destroy
+
+  **Return value**
+  - zero success，none zero failed, wrong message can be obtained through `char *tmq_err2str(int32_t code)`
\ No newline at end of file
diff --git a/docs/en/14-reference/08-taos-shell.md b/docs/en/14-reference/08-taos-shell.md
index e66da7ec17..7e0433a8b2 100644
--- a/docs/en/14-reference/08-taos-shell.md
+++ b/docs/en/14-reference/08-taos-shell.md
@@ -81,6 +81,14 @@ For example:
 taos -h h1.taos.com -s "use db; show tables;"
 ```
 
+## Export query results to a file
+
+- You can use ">>" to export the query results to a file, the syntax is like `select * from table >> file`. If there is only file name without path, the file will be generated under the current working directory of TDegnine CLI.
+
+## Import data from CSV file
+
+- You can use `insert into table_name file 'fileName'` to import the data from the specified file into the specified table. For example, `insert into d0 file '/root/d0.csv';` means importing the data in file "/root/d0.csv" into table "d0". If there is only file name without path, that means the file is located under current working directory of TDengine CLI. 
+
 ## TDengine CLI tips
 
 - You can use the up and down keys to iterate the history of commands entered
@@ -89,3 +97,5 @@ taos -h h1.taos.com -s "use db; show tables;"
 - Execute `RESET QUERY CACHE` to clear the local cache of the table schema
 - Execute SQL statements in batches. You can store a series of shell commands (ending with ;, one line for each SQL command) in a script file and execute the command `source <file-name>` in the TDengine CLI to execute all SQL commands in that file automatically
 - Enter `q` to exit TDengine CLI
+
+  
diff --git a/docs/zh/08-connector/10-cpp.mdx b/docs/zh/08-connector/10-cpp.mdx
index 9c5095f09c..c0723cd85c 100644
--- a/docs/zh/08-connector/10-cpp.mdx
+++ b/docs/zh/08-connector/10-cpp.mdx
@@ -467,21 +467,22 @@ TDengine 的异步 API 均采用非阻塞调用模式。应用程序可以用多
 - `TAOS_RES* taos_schemaless_insert(TAOS* taos, const char* lines[], int numLines, int protocol, int precision)`
 
   **功能说明**
-  该接口将行协议的文本数据写入到 TDengine 中。
+  - 该接口将行协议的文本数据写入到 TDengine 中。
 
   **参数说明**
-  taos: 数据库连接，通过 `taos_connect()` 函数建立的数据库连接。
-  lines：文本数据。满足解析格式要求的无模式文本字符串。
-  numLines:文本数据的行数，不能为 0 。
-  protocol: 行协议类型，用于标识文本数据格式。
-  precision：文本数据中的时间戳精度字符串。
+  - taos: 数据库连接，通过 `taos_connect()` 函数建立的数据库连接。
+  - lines：文本数据。满足解析格式要求的无模式文本字符串。
+  - numLines:文本数据的行数，不能为 0 。
+  - protocol: 行协议类型，用于标识文本数据格式。
+  - precision：文本数据中的时间戳精度字符串。
 
   **返回值**
-  TAOS_RES 结构体，应用可以通过使用 `taos_errstr()` 获得错误信息，也可以使用 `taos_errno()` 获得错误码。
+  - TAOS_RES 结构体，应用可以通过使用 `taos_errstr()` 获得错误信息，也可以使用 `taos_errno()` 获得错误码。
   在某些情况下，返回的 TAOS_RES 为 `NULL`，此时仍然可以调用 `taos_errno()` 来安全地获得错误码信息。
   返回的 TAOS_RES 需要调用方来负责释放，否则会出现内存泄漏。
 
   **说明**
+  
   协议类型是枚举类型，包含以下三种格式：
 
   - TSDB_SML_LINE_PROTOCOL：InfluxDB 行协议（Line Protocol)
@@ -515,3 +516,90 @@ TDengine 的异步 API 均采用非阻塞调用模式。应用程序可以用多
   - 带_raw的接口通过传递的参数lines指针和长度len来表示数据，为了解决原始接口数据包含'\0'而被截断的问题。totalRows指针返回解析出来的数据行数。
   - 带_ttl的接口可以传递ttl参数来控制建表的ttl到期时间。
   - 带_reqid的接口可以通过传递reqid参数来追踪整个的调用链。
+
+### 数据订阅 API
+
+- `int32_t   tmq_get_topic_assignment(tmq_t *tmq, const char *pTopicName, tmq_topic_assignment **assignment, int32_t *numOfAssignment)`
+- `void      tmq_free_assignment(tmq_topic_assignment* pAssignment)`
+  
+  tmq_topic_assignment结构体定义如下：
+  ```c
+  typedef struct tmq_topic_assignment {
+    int32_t vgId;
+    int64_t currentOffset;
+    int64_t begin;
+    int64_t end;
+  } tmq_topic_assignment;
+  ```
+  **功能说明**
+  - tmq_get_topic_assignment 接口返回当前consumer分配的vgroup的信息，每个vgroup的信息包括vgId，wal的最大最小offset，以及当前消费到的offset。
+
+  **参数说明**
+  - numOfAssignment ：分配给该consumer有效的vgroup个数。
+  - assignment ：分配的信息，数据大小为numOfAssignment，需要通过 tmq_free_assignment 接口释放。
+
+  **返回值**
+  - 错误码，0成功，非0失败，可通过 `char *tmq_err2str(int32_t code)` 函数获取错误信息。
+
+- `int64_t   tmq_committed(tmq_t *tmq, const char *pTopicName, int32_t vgId)`
+  **功能说明**
+  - 获取当前 consumer 在某个 topic 和 vgroup上的 commit 位置。
+
+  **返回值**
+  - 当前commit的位置，-2147467247表示没有消费进度，其他小于0的值表示失败，错误码就是返回值
+
+- `int32_t   tmq_commit_sync(tmq_t *tmq, const TAOS_RES *msg)`
+- `void      tmq_commit_async(tmq_t *tmq, const TAOS_RES *msg, tmq_commit_cb *cb, void *param)`
+- `int32_t   tmq_commit_offset_sync(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset)`
+- `void      tmq_commit_offset_async(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset, tmq_commit_cb *cb, void *param)`
+  
+  **功能说明**
+  
+  commit接口分为两种类型，每种类型有同步和异步接口：
+  - 第一种类型：根据消息提交，提交消息里的进度，如果消息传NULL，提交当前consumer所有消费的vgroup的当前进度 : tmq_commit_sync/tmq_commit_async
+  - 第二种类型：根据某个topic的某个vgroup的offset提交 : tmq_commit_offset_sync/tmq_commit_offset_async
+  
+  **参数说明**
+  - msg：消费到的消息结构，如果msg传NULL，提交当前consumer所有消费的vgroup的当前进度
+
+  **返回值**
+  - 错误码，0成功，非0失败，可通过 `char *tmq_err2str(int32_t code)` 函数获取错误信息
+
+- `int64_t     tmq_position(tmq_t *tmq, const char *pTopicName, int32_t vgId)`
+
+  **功能说明**
+  - 获取当前消费位置，为消费到的数据位置的下一个位置
+  
+  **返回值**
+  - 消费位置，非0失败，可通过 `char *tmq_err2str(int32_t code)` 函数获取错误信息
+
+- `int32_t   tmq_offset_seek(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset)`
+
+  **功能说明**
+  - 设置 consumer 在某个topic的某个vgroup的 offset位置，开始消费
+
+  **返回值**
+  - 错误码，0成功，非0失败，可通过 `char *tmq_err2str(int32_t code)` 函数获取错误信息
+  
+- `int32_t   int64_t     tmq_get_vgroup_offset(TAOS_RES* res)`
+
+  **功能说明**
+
+  获取 poll 消费到的数据的起始offset
+  
+  **参数说明**
+  - msg：消费到的消息结构
+
+  **返回值**
+  - 消费到的offset，非0失败，可通过 `char *tmq_err2str(int32_t code)` 函数获取错误信息
+  
+- `int32_t   int32_t   tmq_subscription(tmq_t *tmq, tmq_list_t **topics)`
+
+  **功能说明**
+
+  获取消费者订阅的 topic 列表
+  **参数说明**
+  - topics: 获取的 topic 列表存储在这个结构中，接口内分配内存，需调用tmq_list_destroy释放
+
+  **返回值**
+  - 错误码，0成功，非0失败，可通过 `char *tmq_err2str(int32_t code)` 函数获取错误信息
\ No newline at end of file
diff --git a/docs/zh/12-taos-sql/14-stream.md b/docs/zh/12-taos-sql/14-stream.md
index 634f50356d..43bdc9b04a 100644
--- a/docs/zh/12-taos-sql/14-stream.md
+++ b/docs/zh/12-taos-sql/14-stream.md
@@ -249,3 +249,12 @@ T = 最新事件时间 - DELETE_MARK
 - [unique](../function/#unique)
 - [mode](../function/#mode)
 
+## 暂停、恢复流计算
+1.流计算暂停计算任务
+PAUSE STREAM [IF EXISTS] stream_name;
+没有指定IF EXISTS，如果该stream不存在，则报错；如果存在，则暂停流计算。指定了IF EXISTS，如果该stream不存在，则返回成功；如果存在，则暂停流计算
+
+2.流计算恢复计算任务
+RESUME STREAM [IF EXISTS] [IGNORE UNTREATED] stream_name;
+没有指定IF EXISTS，如果该stream不存在，则报错，如果存在，则恢复流计算；指定了IF EXISTS，如果stream不存在，则返回成功；如果存在，则恢复流计算。如果指定IGNORE UNTREATED，则恢复流计算时，忽略流计算暂停期间写入的数据。
+
diff --git a/docs/zh/12-taos-sql/25-grant.md b/docs/zh/12-taos-sql/25-grant.md
index a9c3910500..d53f951e67 100644
--- a/docs/zh/12-taos-sql/25-grant.md
+++ b/docs/zh/12-taos-sql/25-grant.md
@@ -4,7 +4,7 @@ title: 权限管理
 description: 企业版中才具有的权限管理功能
 ---
 
-本节讲述如何在 TDengine 中进行权限管理的相关操作。
+本节讲述如何在 TDengine 中进行权限管理的相关操作。权限管理是 TDengine 企业版的特有功能，本节只列举了一些基本的权限管理功能作为示例，更丰富的权限管理请联系 TDengine 销售或市场团队。
 
 ## 创建用户
 
diff --git a/docs/zh/14-reference/08-taos-shell.md b/docs/zh/14-reference/08-taos-shell.md
index 3423cf35bb..1caa580b73 100644
--- a/docs/zh/14-reference/08-taos-shell.md
+++ b/docs/zh/14-reference/08-taos-shell.md
@@ -89,3 +89,11 @@ taos -h h1.taos.com -s "use db; show tables;"
 - 执行 `RESET QUERY CACHE` 可清除本地表 Schema 的缓存
 - 批量执行 SQL 语句。可以将一系列的 TDengine CLI 命令（以英文 ; 结尾，每个 SQL 语句为一行）按行存放在文件里，在 TDengine CLI 里执行命令 `source <file-name>` 自动执行该文件里所有的 SQL 语句
 - 输入 `q` 或 `quit` 或 `exit` 回车，可以退出 TDengine CLI
+
+## TDengine CLI 导出查询结果到文件中
+
+- 可以使用符号 “>>” 导出查询结果到某个文件中，语法为： sql 查询语句 >> ‘输出文件名’; 输出文件如果不写路径的话，将输出至当前目录下。如 select * from d0 >> ‘/root/d0.csv’;  将把查询结果输出到 /root/d0.csv 中。
+
+## TDengine CLI 导入文件中的数据到表中
+
+- 可以使用 insert into table_name file '输入文件名'，把上一步中导出的数据文件再导入到指定表中。如 insert into d0 file '/root/d0.csv'; 表示把上面导出的数据全部再导致至 d0 表中。
diff --git a/include/client/taos.h b/include/client/taos.h
index a8136461f8..5b7946c9ad 100644
--- a/include/client/taos.h
+++ b/include/client/taos.h
@@ -292,14 +292,14 @@ DLL_EXPORT int32_t   tmq_unsubscribe(tmq_t *tmq);
 DLL_EXPORT int32_t   tmq_subscription(tmq_t *tmq, tmq_list_t **topics);
 DLL_EXPORT TAOS_RES *tmq_consumer_poll(tmq_t *tmq, int64_t timeout);
 DLL_EXPORT int32_t   tmq_consumer_close(tmq_t *tmq);
-DLL_EXPORT int32_t   tmq_commit_sync(tmq_t *tmq, const TAOS_RES *msg);
+DLL_EXPORT int32_t   tmq_commit_sync(tmq_t *tmq, const TAOS_RES *msg); //Commit the msg’s offset + 1
 DLL_EXPORT void      tmq_commit_async(tmq_t *tmq, const TAOS_RES *msg, tmq_commit_cb *cb, void *param);
 DLL_EXPORT int32_t   tmq_commit_offset_sync(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset);
 DLL_EXPORT void      tmq_commit_offset_async(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset, tmq_commit_cb *cb, void *param);
 DLL_EXPORT int32_t   tmq_get_topic_assignment(tmq_t *tmq, const char *pTopicName, tmq_topic_assignment **assignment,int32_t *numOfAssignment);
 DLL_EXPORT void      tmq_free_assignment(tmq_topic_assignment* pAssignment);
 DLL_EXPORT int32_t   tmq_offset_seek(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset);
-DLL_EXPORT int64_t   tmq_position(tmq_t *tmq, const char *pTopicName, int32_t vgId);
+DLL_EXPORT int64_t   tmq_position(tmq_t *tmq, const char *pTopicName, int32_t vgId);  // The current offset is the offset of the last consumed message + 1
 DLL_EXPORT int64_t   tmq_committed(tmq_t *tmq, const char *pTopicName, int32_t vgId);
 
 DLL_EXPORT const char *tmq_get_topic_name(TAOS_RES *res);
diff --git a/include/common/tcommon.h b/include/common/tcommon.h
index bdfb1d32b4..8482ba8a78 100644
--- a/include/common/tcommon.h
+++ b/include/common/tcommon.h
@@ -152,6 +152,8 @@ enum {
   STREAM_INPUT__DATA_RETRIEVE,
   STREAM_INPUT__GET_RES,
   STREAM_INPUT__CHECKPOINT,
+  STREAM_INPUT__CHECKPOINT_TRIGGER,
+  STREAM_INPUT__TRANS_STATE,
   STREAM_INPUT__REF_DATA_BLOCK,
   STREAM_INPUT__DESTROY,
 };
@@ -168,7 +170,9 @@ typedef enum EStreamType {
   STREAM_PULL_DATA,
   STREAM_PULL_OVER,
   STREAM_FILL_OVER,
+  STREAM_CHECKPOINT,
   STREAM_CREATE_CHILD_TABLE,
+  STREAM_TRANS_STATE,
 } EStreamType;
 
 #pragma pack(push, 1)
diff --git a/include/common/tdatablock.h b/include/common/tdatablock.h
index c0412d2617..dac723aa58 100644
--- a/include/common/tdatablock.h
+++ b/include/common/tdatablock.h
@@ -241,7 +241,7 @@ int32_t blockEncode(const SSDataBlock* pBlock, char* data, int32_t numOfCols);
 const char* blockDecode(SSDataBlock* pBlock, const char* pData);
 
 // for debug
-char* dumpBlockData(SSDataBlock* pDataBlock, const char* flag, char** dumpBuf);
+char* dumpBlockData(SSDataBlock* pDataBlock, const char* flag, char** dumpBuf, const char* taskIdStr);
 
 int32_t buildSubmitReqFromDataBlock(SSubmitReq2** pReq, const SSDataBlock* pDataBlocks, const STSchema* pTSchema, int64_t uid, int32_t vgId,
                                     tb_uid_t suid);
diff --git a/include/common/tglobal.h b/include/common/tglobal.h
index 0d3852cbab..5fd174e873 100644
--- a/include/common/tglobal.h
+++ b/include/common/tglobal.h
@@ -199,6 +199,7 @@ extern bool    tsFilterScalarMode;
 extern int32_t tsKeepTimeOffset;
 extern int32_t tsMaxStreamBackendCache;
 extern int32_t tsPQSortMemThreshold;
+extern int32_t tsResolveFQDNRetryTime;
 
 // #define NEEDTO_COMPRESSS_MSG(size) (tsCompressMsgSize != -1 && (size) > tsCompressMsgSize)
 
diff --git a/include/common/tmsg.h b/include/common/tmsg.h
index 01923d2b30..8aaf6bfc15 100644
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@@ -231,6 +231,7 @@ typedef struct SField {
   uint8_t type;
   int8_t  flags;
   int32_t bytes;
+  char    comment[TSDB_COL_COMMENT_LEN];
 } SField;
 
 typedef struct SRetention {
@@ -309,6 +310,7 @@ struct SSchema {
   col_id_t colId;
   int32_t  bytes;
   char     name[TSDB_COL_NAME_LEN];
+  char     comment[TSDB_COL_COMMENT_LEN];
 };
 
 struct SSchema2 {
@@ -2387,6 +2389,9 @@ typedef struct {
   int8_t  type;
   int8_t  flags;
   int32_t bytes;
+  bool    hasColComment;
+  char*   colComment;
+  int32_t colCommentLen;
   // TSDB_ALTER_TABLE_DROP_COLUMN
   // TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES
   int8_t  colModType;
diff --git a/include/common/tmsgdef.h b/include/common/tmsgdef.h
index 232551007d..60172bce3d 100644
--- a/include/common/tmsgdef.h
+++ b/include/common/tmsgdef.h
@@ -254,7 +254,6 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_STREAM_RETRIEVE, "stream-retrieve", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_STREAM_SCAN_HISTORY, "stream-scan-history", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_STREAM_SCAN_HISTORY_FINISH, "stream-scan-history-finish", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_STREAM_TRANSFER_STATE, "stream-transfer-state", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_STREAM_TASK_CHECK, "stream-task-check", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_STREAM_TASK_CHECKPOINT, "stream-checkpoint", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_STREAM_TASK_REPORT_CHECKPOINT, "stream-report-checkpoint", NULL, NULL)
diff --git a/include/common/ttokendef.h b/include/common/ttokendef.h
index eb33ac5db9..0d21e91a08 100644
--- a/include/common/ttokendef.h
+++ b/include/common/ttokendef.h
@@ -16,7 +16,6 @@
 #ifndef _TD_COMMON_TOKEN_H_
 #define _TD_COMMON_TOKEN_H_
 
-
 #define TK_OR                               1
 #define TK_AND                              2
 #define TK_UNION                            3
@@ -131,25 +130,25 @@
 #define TK_NK_EQ                          112
 #define TK_USING                          113
 #define TK_TAGS                           114
-#define TK_BOOL                           115
-#define TK_TINYINT                        116
-#define TK_SMALLINT                       117
-#define TK_INT                            118
-#define TK_INTEGER                        119
-#define TK_BIGINT                         120
-#define TK_FLOAT                          121
-#define TK_DOUBLE                         122
-#define TK_BINARY                         123
-#define TK_NCHAR                          124
-#define TK_UNSIGNED                       125
-#define TK_JSON                           126
-#define TK_VARCHAR                        127
-#define TK_MEDIUMBLOB                     128
-#define TK_BLOB                           129
-#define TK_VARBINARY                      130
-#define TK_GEOMETRY                       131
-#define TK_DECIMAL                        132
-#define TK_COMMENT                        133
+#define TK_COMMENT                        115
+#define TK_BOOL                           116
+#define TK_TINYINT                        117
+#define TK_SMALLINT                       118
+#define TK_INT                            119
+#define TK_INTEGER                        120
+#define TK_BIGINT                         121
+#define TK_FLOAT                          122
+#define TK_DOUBLE                         123
+#define TK_BINARY                         124
+#define TK_NCHAR                          125
+#define TK_UNSIGNED                       126
+#define TK_JSON                           127
+#define TK_VARCHAR                        128
+#define TK_MEDIUMBLOB                     129
+#define TK_BLOB                           130
+#define TK_VARBINARY                      131
+#define TK_GEOMETRY                       132
+#define TK_DECIMAL                        133
 #define TK_MAX_DELAY                      134
 #define TK_WATERMARK                      135
 #define TK_ROLLUP                         136
diff --git a/include/libs/function/functionMgt.h b/include/libs/function/functionMgt.h
index 402b8f0309..eebb69e6ba 100644
--- a/include/libs/function/functionMgt.h
+++ b/include/libs/function/functionMgt.h
@@ -157,6 +157,8 @@ typedef enum EFunctionType {
   FUNCTION_TYPE_AVG_MERGE,
   FUNCTION_TYPE_STDDEV_PARTIAL,
   FUNCTION_TYPE_STDDEV_MERGE,
+  FUNCTION_TYPE_IRATE_PARTIAL,
+  FUNCTION_TYPE_IRATE_MERGE,
 
   // geometry functions
   FUNCTION_TYPE_GEOM_FROM_TEXT = 4250,
diff --git a/include/libs/nodes/cmdnodes.h b/include/libs/nodes/cmdnodes.h
index f0a715e651..ff02070882 100644
--- a/include/libs/nodes/cmdnodes.h
+++ b/include/libs/nodes/cmdnodes.h
@@ -23,10 +23,11 @@ extern "C" {
 #include "query.h"
 #include "querynodes.h"
 
-#define DESCRIBE_RESULT_COLS      4
-#define DESCRIBE_RESULT_FIELD_LEN (TSDB_COL_NAME_LEN - 1 + VARSTR_HEADER_SIZE)
-#define DESCRIBE_RESULT_TYPE_LEN  (20 + VARSTR_HEADER_SIZE)
-#define DESCRIBE_RESULT_NOTE_LEN  (8 + VARSTR_HEADER_SIZE)
+#define DESCRIBE_RESULT_COLS            5
+#define DESCRIBE_RESULT_FIELD_LEN       (TSDB_COL_NAME_LEN - 1 + VARSTR_HEADER_SIZE)
+#define DESCRIBE_RESULT_TYPE_LEN        (20 + VARSTR_HEADER_SIZE)
+#define DESCRIBE_RESULT_NOTE_LEN        (8 + VARSTR_HEADER_SIZE)
+#define DESCRIBE_RESULT_COL_COMMENT_LEN (TSDB_COL_COMMENT_LEN)
 
 #define SHOW_CREATE_DB_RESULT_COLS       2
 #define SHOW_CREATE_DB_RESULT_FIELD1_LEN (TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE)
@@ -155,7 +156,7 @@ typedef struct SColumnDefNode {
   ENodeType type;
   char      colName[TSDB_COL_NAME_LEN];
   SDataType dataType;
-  char      comments[TSDB_TB_COMMENT_LEN];
+  char      comments[TSDB_COL_COMMENT_LEN];
   bool      sma;
 } SColumnDefNode;
 
@@ -214,6 +215,7 @@ typedef struct SAlterTableStmt {
   char           newColName[TSDB_COL_NAME_LEN];
   STableOptions* pOptions;
   SDataType      dataType;
+  char           colComment[TSDB_COL_COMMENT_LEN];
   SValueNode*    pVal;
 } SAlterTableStmt;
 
diff --git a/include/libs/nodes/plannodes.h b/include/libs/nodes/plannodes.h
index 4529520ace..b4f0a67fa0 100644
--- a/include/libs/nodes/plannodes.h
+++ b/include/libs/nodes/plannodes.h
@@ -608,6 +608,8 @@ typedef struct SSubplan {
   SNode*         pTagCond;
   SNode*         pTagIndexCond;
   bool           showRewrite;
+  int32_t        rowsThreshold;
+  bool           dynamicRowThreshold;
 } SSubplan;
 
 typedef enum EExplainMode { EXPLAIN_MODE_DISABLE = 1, EXPLAIN_MODE_STATIC, EXPLAIN_MODE_ANALYZE } EExplainMode;
diff --git a/include/libs/stream/tstream.h b/include/libs/stream/tstream.h
index b9b24917f3..02bb65b762 100644
--- a/include/libs/stream/tstream.h
+++ b/include/libs/stream/tstream.h
@@ -122,6 +122,7 @@ typedef struct {
   int8_t type;
 
   int32_t srcVgId;
+  int32_t srcTaskId;
   int32_t childId;
   int64_t sourceVer;
   int64_t reqId;
@@ -251,6 +252,7 @@ typedef struct SStreamChildEpInfo {
   int32_t nodeId;
   int32_t childId;
   int32_t taskId;
+  int8_t  dataAllowed;
   SEpSet  epSet;
 } SStreamChildEpInfo;
 
@@ -272,6 +274,7 @@ typedef struct SStreamStatus {
   int8_t schedStatus;
   int8_t keepTaskStatus;
   bool   transferState;
+  bool   appendTranstateBlock;  // has append the transfer state data block already, todo: remove it
   int8_t timerActive;   // timer is active
   int8_t pauseAllowed;  // allowed task status to be set to be paused
 } SStreamStatus;
@@ -399,8 +402,9 @@ typedef struct {
 
 typedef struct {
   int64_t streamId;
+  int32_t type;
   int32_t taskId;
-  int32_t dataSrcVgId;
+  int32_t srcVgId;
   int32_t upstreamTaskId;
   int32_t upstreamChildId;
   int32_t upstreamNodeId;
@@ -570,8 +574,6 @@ int32_t tDecodeStreamDispatchReq(SDecoder* pDecoder, SStreamDispatchReq* pReq);
 int32_t tDecodeStreamRetrieveReq(SDecoder* pDecoder, SStreamRetrieveReq* pReq);
 void    tDeleteStreamRetrieveReq(SStreamRetrieveReq* pReq);
 
-int32_t tInitStreamDispatchReq(SStreamDispatchReq* pReq, const SStreamTask* pTask, int32_t vgId, int32_t numOfBlocks,
-                               int64_t dstTaskId);
 void    tDeleteStreamDispatchReq(SStreamDispatchReq* pReq);
 
 int32_t streamSetupScheduleTrigger(SStreamTask* pTask);
@@ -579,6 +581,8 @@ int32_t streamSetupScheduleTrigger(SStreamTask* pTask);
 int32_t streamProcessRunReq(SStreamTask* pTask);
 int32_t streamProcessDispatchMsg(SStreamTask* pTask, SStreamDispatchReq* pReq, SRpcMsg* pMsg, bool exec);
 int32_t streamProcessDispatchRsp(SStreamTask* pTask, SStreamDispatchRsp* pRsp, int32_t code);
+void streamTaskCloseUpstreamInput(SStreamTask* pTask, int32_t taskId);
+void streamTaskOpenAllUpstreamInput(SStreamTask* pTask);
 
 int32_t streamProcessRetrieveReq(SStreamTask* pTask, SStreamRetrieveReq* pReq, SRpcMsg* pMsg);
 
@@ -589,7 +593,6 @@ int32_t streamTaskOutputResultBlock(SStreamTask* pTask, SStreamDataBlock* pBlock
 bool    streamTaskShouldStop(const SStreamStatus* pStatus);
 bool    streamTaskShouldPause(const SStreamStatus* pStatus);
 bool    streamTaskIsIdle(const SStreamTask* pTask);
-int32_t streamTaskEndScanWAL(SStreamTask* pTask);
 
 SStreamChildEpInfo* streamTaskGetUpstreamTaskEpInfo(SStreamTask* pTask, int32_t taskId);
 int32_t             streamScanExec(SStreamTask* pTask, int32_t batchSize);
@@ -626,7 +629,7 @@ int32_t streamSetParamForStreamScannerStep2(SStreamTask* pTask, SVersionRange* p
 int32_t streamSourceScanHistoryData(SStreamTask* pTask);
 int32_t streamDispatchScanHistoryFinishMsg(SStreamTask* pTask);
 
-int32_t streamDispatchTransferStateMsg(SStreamTask* pTask);
+int32_t appendTranstateIntoInputQ(SStreamTask* pTask);
 
 // agg level
 int32_t streamTaskScanHistoryPrepare(SStreamTask* pTask);
diff --git a/include/os/osRand.h b/include/os/osRand.h
index 27d07e8c6f..5d907bba15 100644
--- a/include/os/osRand.h
+++ b/include/os/osRand.h
@@ -32,6 +32,8 @@ void     taosSeedRand(uint32_t seed);
 uint32_t taosRand(void);
 uint32_t taosRandR(uint32_t* pSeed);
 void     taosRandStr(char* str, int32_t size);
+void     taosRandStr2(char* str, int32_t size);
+
 uint32_t taosSafeRand(void);
 
 #ifdef __cplusplus
diff --git a/include/util/taoserror.h b/include/util/taoserror.h
index b43985074c..a5081f2c7d 100644
--- a/include/util/taoserror.h
+++ b/include/util/taoserror.h
@@ -191,6 +191,7 @@ int32_t* taosGetErrno();
 // #define TSDB_CODE_MND_FAILED_TO_CREATE_DIR   TAOS_DEF_ERROR_CODE(0, 0x0313) // 2.x
 // #define TSDB_CODE_MND_FAILED_TO_INIT_STEP    TAOS_DEF_ERROR_CODE(0, 0x0314) // 2.x
 #define TSDB_CODE_MND_USER_DISABLED             TAOS_DEF_ERROR_CODE(0, 0x0315)
+#define TSDB_CODE_MND_INVALID_PLATFORM          TAOS_DEF_ERROR_CODE(0, 0x0316)
 
 // mnode-sdb
 #define TSDB_CODE_SDB_OBJ_ALREADY_THERE         TAOS_DEF_ERROR_CODE(0, 0x0320) // internal
diff --git a/include/util/tdef.h b/include/util/tdef.h
index e4af88bf10..1e12f12087 100644
--- a/include/util/tdef.h
+++ b/include/util/tdef.h
@@ -230,6 +230,7 @@ typedef enum ELogicConditionType {
 
 #define TSDB_APP_NAME_LEN   TSDB_UNI_LEN
 #define TSDB_TB_COMMENT_LEN 1025
+#define TSDB_COL_COMMENT_LEN 1025
 
 #define TSDB_QUERY_ID_LEN   26
 #define TSDB_TRANS_OPER_LEN 16
diff --git a/source/common/src/tdatablock.c b/source/common/src/tdatablock.c
index 5188b1e27c..bbbb6c7178 100644
--- a/source/common/src/tdatablock.c
+++ b/source/common/src/tdatablock.c
@@ -26,7 +26,7 @@ int32_t colDataGetLength(const SColumnInfoData* pColumnInfoData, int32_t numOfRo
     if (pColumnInfoData->reassigned) {
       int32_t totalSize = 0;
       for (int32_t row = 0; row < numOfRows; ++row) {
-        char* pColData = pColumnInfoData->pData + pColumnInfoData->varmeta.offset[row];
+        char*   pColData = pColumnInfoData->pData + pColumnInfoData->varmeta.offset[row];
         int32_t colSize = 0;
         if (pColumnInfoData->info.type == TSDB_DATA_TYPE_JSON) {
           colSize = getJsonValueLen(pColData);
@@ -142,7 +142,8 @@ int32_t colDataSetVal(SColumnInfoData* pColumnInfoData, uint32_t rowIndex, const
   return 0;
 }
 
-int32_t colDataReassignVal(SColumnInfoData* pColumnInfoData, uint32_t dstRowIdx, uint32_t srcRowIdx, const char* pData) {
+int32_t colDataReassignVal(SColumnInfoData* pColumnInfoData, uint32_t dstRowIdx, uint32_t srcRowIdx,
+                           const char* pData) {
   int32_t type = pColumnInfoData->info.type;
   if (IS_VAR_DATA_TYPE(type)) {
     int32_t dataLen = 0;
@@ -164,7 +165,6 @@ int32_t colDataReassignVal(SColumnInfoData* pColumnInfoData, uint32_t dstRowIdx,
   return 0;
 }
 
-
 static int32_t colDataReserve(SColumnInfoData* pColumnInfoData, size_t newSize) {
   if (!IS_VAR_DATA_TYPE(pColumnInfoData->info.type)) {
     return TSDB_CODE_SUCCESS;
@@ -188,16 +188,17 @@ static int32_t colDataReserve(SColumnInfoData* pColumnInfoData, size_t newSize)
 }
 
 static int32_t doCopyNItems(struct SColumnInfoData* pColumnInfoData, int32_t currentRow, const char* pData,
-                         int32_t itemLen, int32_t numOfRows, bool trimValue) {
+                            int32_t itemLen, int32_t numOfRows, bool trimValue) {
   if (pColumnInfoData->info.bytes < itemLen) {
-    uWarn("column/tag actual data len %d is bigger than schema len %d, trim it:%d", itemLen, pColumnInfoData->info.bytes, trimValue);
+    uWarn("column/tag actual data len %d is bigger than schema len %d, trim it:%d", itemLen,
+          pColumnInfoData->info.bytes, trimValue);
     if (trimValue) {
       itemLen = pColumnInfoData->info.bytes;
     } else {
       return TSDB_CODE_TDB_INVALID_TABLE_SCHEMA_VER;
     }
   }
-  
+
   size_t start = 1;
 
   // the first item
@@ -230,8 +231,8 @@ static int32_t doCopyNItems(struct SColumnInfoData* pColumnInfoData, int32_t cur
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t colDataSetNItems(SColumnInfoData* pColumnInfoData, uint32_t currentRow, const char* pData,
-                            uint32_t numOfRows, bool trimValue) {
+int32_t colDataSetNItems(SColumnInfoData* pColumnInfoData, uint32_t currentRow, const char* pData, uint32_t numOfRows,
+                         bool trimValue) {
   int32_t len = pColumnInfoData->info.bytes;
   if (IS_VAR_DATA_TYPE(pColumnInfoData->info.type)) {
     len = varDataTLen(pData);
@@ -262,7 +263,7 @@ static void doBitmapMerge(SColumnInfoData* pColumnInfoData, int32_t numOfRow1, c
 
   uint8_t* p = (uint8_t*)pSource->nullbitmap;
   pColumnInfoData->nullbitmap[BitmapLen(numOfRow1) - 1] &= (0B11111111 << shiftBits);  // clear remind bits
-  pColumnInfoData->nullbitmap[BitmapLen(numOfRow1) - 1] |= (p[0] >> remindBits);  // copy remind bits
+  pColumnInfoData->nullbitmap[BitmapLen(numOfRow1) - 1] |= (p[0] >> remindBits);       // copy remind bits
 
   if (BitmapLen(numOfRow1) == BitmapLen(total)) {
     return;
@@ -350,7 +351,7 @@ int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, int32_t numOfRow1, int
 
       pColumnInfoData->pData = tmp;
       if (BitmapLen(numOfRow1) < BitmapLen(finalNumOfRows)) {
-        char*    btmp = taosMemoryRealloc(pColumnInfoData->nullbitmap, BitmapLen(finalNumOfRows));
+        char* btmp = taosMemoryRealloc(pColumnInfoData->nullbitmap, BitmapLen(finalNumOfRows));
         if (btmp == NULL) {
           return TSDB_CODE_OUT_OF_MEMORY;
         }
@@ -622,7 +623,7 @@ int32_t blockDataToBuf(char* buf, const SSDataBlock* pBlock) {
 
     if (pCol->reassigned && IS_VAR_DATA_TYPE(pCol->info.type)) {
       for (int32_t row = 0; row < numOfRows; ++row) {
-        char* pColData = pCol->pData + pCol->varmeta.offset[row];
+        char*   pColData = pCol->pData + pCol->varmeta.offset[row];
         int32_t colSize = 0;
         if (pCol->info.type == TSDB_DATA_TYPE_JSON) {
           colSize = getJsonValueLen(pColData);
@@ -698,8 +699,7 @@ int32_t blockDataFromBuf(SSDataBlock* pBlock, const char* buf) {
   return TSDB_CODE_SUCCESS;
 }
 
-static bool colDataIsNNull(const SColumnInfoData* pColumnInfoData, int32_t startIndex,
-                                          uint32_t nRows) {
+static bool colDataIsNNull(const SColumnInfoData* pColumnInfoData, int32_t startIndex, uint32_t nRows) {
   if (!pColumnInfoData->hasNull) {
     return false;
   }
@@ -880,7 +880,6 @@ int32_t dataBlockCompar(const void* p1, const void* p2, const void* param) {
 }
 
 static int32_t blockDataAssign(SColumnInfoData* pCols, const SSDataBlock* pDataBlock, const int32_t* index) {
-
   size_t numOfCols = taosArrayGetSize(pDataBlock->pDataBlock);
   for (int32_t i = 0; i < numOfCols; ++i) {
     SColumnInfoData* pDst = &pCols[i];
@@ -1131,6 +1130,7 @@ static int32_t doEnsureCapacity(SColumnInfoData* pColumn, const SDataBlockInfo*
     if (tmp == NULL) {
       return TSDB_CODE_OUT_OF_MEMORY;
     }
+    // memset(tmp, 0, numOfRows * pColumn->info.bytes);
 
     // copy back the existed data
     if (pColumn->pData != NULL) {
@@ -1474,8 +1474,8 @@ size_t blockDataGetCapacityInRow(const SSDataBlock* pBlock, size_t pageSize, int
   int end = nRows;
   while (start <= end) {
     int mid = start + (end - start) / 2;
-    //data size + var data type columns offset + fixed data type columns bitmap len 
-    int midSize = rowSize * mid + numVarCols * sizeof(int32_t) * mid + numFixCols * BitmapLen(mid); 
+    // data size + var data type columns offset + fixed data type columns bitmap len
+    int midSize = rowSize * mid + numVarCols * sizeof(int32_t) * mid + numFixCols * BitmapLen(mid);
     if (midSize > payloadSize) {
       result = mid;
       end = mid - 1;
@@ -1669,7 +1669,7 @@ int32_t tEncodeDataBlock(void** buf, const SSDataBlock* pBlock) {
 
     if (pColData->reassigned && IS_VAR_DATA_TYPE(pColData->info.type)) {
       for (int32_t row = 0; row < rows; ++row) {
-        char* pData = pColData->pData + pColData->varmeta.offset[row];
+        char*   pData = pColData->pData + pColData->varmeta.offset[row];
         int32_t colSize = 0;
         if (pColData->info.type == TSDB_DATA_TYPE_JSON) {
           colSize = getJsonValueLen(pData);
@@ -1771,8 +1771,8 @@ static char* formatTimestamp(char* buf, int64_t val, int precision) {
 }
 
 // for debug
-char* dumpBlockData(SSDataBlock* pDataBlock, const char* flag, char** pDataBuf) {
-  int32_t size = 2048*1024;
+char* dumpBlockData(SSDataBlock* pDataBlock, const char* flag, char** pDataBuf, const char* taskIdStr) {
+  int32_t size = 2048 * 1024;
   *pDataBuf = taosMemoryCalloc(size, 1);
   char*   dumpBuf = *pDataBuf;
   char    pBuf[128] = {0};
@@ -1780,9 +1780,9 @@ char* dumpBlockData(SSDataBlock* pDataBlock, const char* flag, char** pDataBuf)
   int32_t rows = pDataBlock->info.rows;
   int32_t len = 0;
   len += snprintf(dumpBuf + len, size - len,
-                  "===stream===%s|block type %d|child id %d|group id:%" PRIu64 "|uid:%" PRId64
+                  "%s===stream===%s|block type %d|child id %d|group id:%" PRIu64 "|uid:%" PRId64
                   "|rows:%" PRId64 "|version:%" PRIu64 "|cal start:%" PRIu64 "|cal end:%" PRIu64 "|tbl:%s\n",
-                  flag, (int32_t)pDataBlock->info.type, pDataBlock->info.childId, pDataBlock->info.id.groupId,
+                  taskIdStr, flag, (int32_t)pDataBlock->info.type, pDataBlock->info.childId, pDataBlock->info.id.groupId,
                   pDataBlock->info.id.uid, pDataBlock->info.rows, pDataBlock->info.version,
                   pDataBlock->info.calWin.skey, pDataBlock->info.calWin.ekey, pDataBlock->info.parTbName);
   if (len >= size - 1) return dumpBuf;
@@ -2156,21 +2156,21 @@ int32_t blockEncode(const SSDataBlock* pBlock, char* data, int32_t numOfCols) {
     data += metaSize;
     dataLen += metaSize;
 
-     if (pColRes->reassigned && IS_VAR_DATA_TYPE(pColRes->info.type)) {
-        colSizes[col] = 0;
-        for (int32_t row = 0; row < numOfRows; ++row) {
-          char* pColData = pColRes->pData + pColRes->varmeta.offset[row];
-          int32_t colSize = 0;
-          if (pColRes->info.type == TSDB_DATA_TYPE_JSON) {
-            colSize = getJsonValueLen(pColData);
-          } else {
-            colSize = varDataTLen(pColData);
-          }
-          colSizes[col] += colSize;
-          dataLen += colSize;
-          memmove(data, pColData, colSize);
-          data += colSize;
+    if (pColRes->reassigned && IS_VAR_DATA_TYPE(pColRes->info.type)) {
+      colSizes[col] = 0;
+      for (int32_t row = 0; row < numOfRows; ++row) {
+        char*   pColData = pColRes->pData + pColRes->varmeta.offset[row];
+        int32_t colSize = 0;
+        if (pColRes->info.type == TSDB_DATA_TYPE_JSON) {
+          colSize = getJsonValueLen(pColData);
+        } else {
+          colSize = varDataTLen(pColData);
         }
+        colSizes[col] += colSize;
+        dataLen += colSize;
+        memmove(data, pColData, colSize);
+        data += colSize;
+      }
     } else {
       colSizes[col] = colDataGetLength(pColRes, numOfRows);
       dataLen += colSizes[col];
@@ -2181,7 +2181,8 @@ int32_t blockEncode(const SSDataBlock* pBlock, char* data, int32_t numOfCols) {
     }
 
     colSizes[col] = htonl(colSizes[col]);
-//    uError("blockEncode col bytes:%d, type:%d, size:%d, htonl size:%d", pColRes->info.bytes, pColRes->info.type, htonl(colSizes[col]), colSizes[col]);
+    //    uError("blockEncode col bytes:%d, type:%d, size:%d, htonl size:%d", pColRes->info.bytes, pColRes->info.type,
+    //    htonl(colSizes[col]), colSizes[col]);
   }
 
   *actualLen = dataLen;
@@ -2283,7 +2284,7 @@ const char* blockDecode(SSDataBlock* pBlock, const char* pData) {
 }
 
 void trimDataBlock(SSDataBlock* pBlock, int32_t totalRows, const bool* pBoolList) {
-//  int32_t totalRows = pBlock->info.rows;
+  //  int32_t totalRows = pBlock->info.rows;
   int32_t bmLen = BitmapLen(totalRows);
   char*   pBitmap = NULL;
   int32_t maxRows = 0;
@@ -2310,8 +2311,9 @@ void trimDataBlock(SSDataBlock* pBlock, int32_t totalRows, const bool* pBoolList
         if (colDataIsNull_var(pDst, j)) {
           colDataSetNull_var(pDst, numOfRows);
         } else {
-          // fix address sanitizer error. p1 may point to memory that will change during realloc of colDataSetVal, first copy it to p2
-          char* p1 = colDataGetVarData(pDst, j);
+          // fix address sanitizer error. p1 may point to memory that will change during realloc of colDataSetVal, first
+          // copy it to p2
+          char*   p1 = colDataGetVarData(pDst, j);
           int32_t len = 0;
           if (pDst->info.type == TSDB_DATA_TYPE_JSON) {
             len = getJsonValueLen(p1);
diff --git a/source/common/src/tglobal.c b/source/common/src/tglobal.c
index 3595347db3..e080c2d2ec 100644
--- a/source/common/src/tglobal.c
+++ b/source/common/src/tglobal.c
@@ -216,7 +216,11 @@ uint32_t tsCurRange = 100;                      // range
 char     tsCompressor[32] = "ZSTD_COMPRESSOR";  // ZSTD_COMPRESSOR or GZIP_COMPRESSOR
 
 // udf
-bool tsStartUdfd = true;
+#ifdef WINDOWS
+bool tsStartUdfd = false;
+#else
+bool    tsStartUdfd = true;
+#endif
 
 // wal
 int64_t tsWalFsyncDataSizeLimit = (100 * 1024 * 1024L);
@@ -236,6 +240,7 @@ int64_t tsStreamBufferSize = 128 * 1024 * 1024;
 int64_t tsCheckpointInterval = 3 * 60 * 60 * 1000;
 bool    tsFilterScalarMode = false;
 int32_t tsKeepTimeOffset = 0;  // latency of data migration
+int     tsResolveFQDNRetryTime = 100; //seconds
 
 char   tsS3Endpoint[TSDB_FQDN_LEN] = "<endpoint>";
 char   tsS3AccessKey[TSDB_FQDN_LEN] = "<accesskey>";
@@ -624,6 +629,7 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
   if (cfgAddInt32(pCfg, "keepTimeOffset", tsKeepTimeOffset, 0, 23, CFG_SCOPE_SERVER) != 0) return -1;
   if (cfgAddInt32(pCfg, "maxStreamBackendCache", tsMaxStreamBackendCache, 16, 1024, CFG_SCOPE_SERVER) != 0) return -1;
   if (cfgAddInt32(pCfg, "pqSortMemThreshold", tsPQSortMemThreshold, 1, 10240, CFG_SCOPE_SERVER) != 0) return -1;
+  if (cfgAddInt32(pCfg, "resolveFQDNRetryTime", tsResolveFQDNRetryTime, 1, 10240, 0) != 0) return -1;
 
   if (cfgAddString(pCfg, "s3Accesskey", tsS3AccessKey, CFG_SCOPE_SERVER) != 0) return -1;
   if (cfgAddString(pCfg, "s3Endpoint", tsS3Endpoint, CFG_SCOPE_SERVER) != 0) return -1;
@@ -1027,6 +1033,7 @@ static int32_t taosSetServerCfg(SConfig *pCfg) {
   tsKeepTimeOffset = cfgGetItem(pCfg, "keepTimeOffset")->i32;
   tsMaxStreamBackendCache = cfgGetItem(pCfg, "maxStreamBackendCache")->i32;
   tsPQSortMemThreshold = cfgGetItem(pCfg, "pqSortMemThreshold")->i32;
+  tsResolveFQDNRetryTime = cfgGetItem(pCfg, "resolveFQDNRetryTime")->i32;
 
   GRANT_CFG_GET;
   return 0;
diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c
index ef0006e7ab..362c829dbc 100644
--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@@ -534,6 +534,7 @@ int32_t tSerializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pReq
     if (tEncodeI8(&encoder, pField->flags) < 0) return -1;
     if (tEncodeI32(&encoder, pField->bytes) < 0) return -1;
     if (tEncodeCStr(&encoder, pField->name) < 0) return -1;
+    if (tEncodeCStr(&encoder, pField->comment) < 0) return -1;
   }
 
   for (int32_t i = 0; i < pReq->numOfTags; ++i) {
@@ -542,6 +543,7 @@ int32_t tSerializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pReq
     if (tEncodeI8(&encoder, pField->flags) < 0) return -1;
     if (tEncodeI32(&encoder, pField->bytes) < 0) return -1;
     if (tEncodeCStr(&encoder, pField->name) < 0) return -1;
+    if (tEncodeCStr(&encoder, pField->comment) < 0) return -1;
   }
 
   for (int32_t i = 0; i < pReq->numOfFuncs; ++i) {
@@ -608,6 +610,7 @@ int32_t tDeserializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pR
     if (tDecodeI8(&decoder, &field.flags) < 0) return -1;
     if (tDecodeI32(&decoder, &field.bytes) < 0) return -1;
     if (tDecodeCStrTo(&decoder, field.name) < 0) return -1;
+    if (tDecodeCStrTo(&decoder, field.comment) < 0) return -1;
     if (taosArrayPush(pReq->pColumns, &field) == NULL) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       return -1;
@@ -620,6 +623,7 @@ int32_t tDeserializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pR
     if (tDecodeI8(&decoder, &field.flags) < 0) return -1;
     if (tDecodeI32(&decoder, &field.bytes) < 0) return -1;
     if (tDecodeCStrTo(&decoder, field.name) < 0) return -1;
+    if (tDecodeCStrTo(&decoder, field.comment) < 0) return -1;
     if (taosArrayPush(pReq->pTags, &field) == NULL) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       return -1;
@@ -2301,7 +2305,7 @@ int32_t tDeserializeSTableCfgRsp(void *buf, int32_t bufLen, STableCfgRsp *pRsp)
   }
 
   int32_t totalCols = pRsp->numOfTags + pRsp->numOfColumns;
-  pRsp->pSchemas = taosMemoryMalloc(sizeof(SSchema) * totalCols);
+  pRsp->pSchemas = taosMemoryCalloc(totalCols, sizeof(SSchema));
   if (pRsp->pSchemas == NULL) return -1;
 
   for (int32_t i = 0; i < totalCols; ++i) {
@@ -3684,7 +3688,7 @@ static int32_t tDecodeSTableMetaRsp(SDecoder *pDecoder, STableMetaRsp *pRsp) {
 
   int32_t totalCols = pRsp->numOfTags + pRsp->numOfColumns;
   if (totalCols > 0) {
-    pRsp->pSchemas = taosMemoryMalloc(sizeof(SSchema) * totalCols);
+    pRsp->pSchemas = taosMemoryCalloc(totalCols, sizeof(SSchema));
     if (pRsp->pSchemas == NULL) return -1;
 
     for (int32_t i = 0; i < totalCols; ++i) {
diff --git a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
index bed9a67303..cf57deaa22 100644
--- a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
+++ b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
@@ -742,7 +742,6 @@ SArray *vmGetMsgHandles() {
   if (dmSetMgmtHandle(pArray, TDMT_STREAM_RETRIEVE_RSP, vmPutMsgToStreamQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_STREAM_SCAN_HISTORY_FINISH, vmPutMsgToStreamQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_STREAM_SCAN_HISTORY_FINISH_RSP, vmPutMsgToStreamQueue, 0) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_STREAM_TRANSFER_STATE, vmPutMsgToStreamQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_CHECK, vmPutMsgToStreamQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_CHECK_RSP, vmPutMsgToStreamQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_STREAM_TRIGGER, vmPutMsgToStreamQueue, 0) == NULL) goto _OVER;
diff --git a/source/dnode/mnode/impl/src/mndDb.c b/source/dnode/mnode/impl/src/mndDb.c
index 1bd629e56f..4f7e80c0a3 100644
--- a/source/dnode/mnode/impl/src/mndDb.c
+++ b/source/dnode/mnode/impl/src/mndDb.c
@@ -666,7 +666,12 @@ static int32_t mndProcessCreateDbReq(SRpcMsg *pReq) {
     terrno = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
-
+#ifdef WINDOWS
+  if (taosArrayGetSize(createReq.pRetensions) > 0) {
+    terrno = TSDB_CODE_MND_INVALID_PLATFORM;
+    goto _OVER;
+  }
+#endif
   mInfo("db:%s, start to create, vgroups:%d", createReq.db, createReq.numOfVgroups);
   if (mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CREATE_DB, NULL) != 0) {
     goto _OVER;
diff --git a/source/dnode/mnode/impl/src/mndFunc.c b/source/dnode/mnode/impl/src/mndFunc.c
index 4ffc7a20c2..5eb7abf026 100644
--- a/source/dnode/mnode/impl/src/mndFunc.c
+++ b/source/dnode/mnode/impl/src/mndFunc.c
@@ -359,7 +359,10 @@ static int32_t mndProcessCreateFuncReq(SRpcMsg *pReq) {
     terrno = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
-
+#ifdef WINDOWS
+  terrno = TSDB_CODE_MND_INVALID_PLATFORM;
+  goto _OVER;
+#endif
   mInfo("func:%s, start to create, size:%d", createReq.name, createReq.codeLen);
   if (mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CREATE_FUNC) != 0) {
     goto _OVER;
diff --git a/source/dnode/mnode/impl/src/mndIndex.c b/source/dnode/mnode/impl/src/mndIndex.c
index 2157804559..2e78116a86 100644
--- a/source/dnode/mnode/impl/src/mndIndex.c
+++ b/source/dnode/mnode/impl/src/mndIndex.c
@@ -79,9 +79,12 @@ int32_t mndInitIdx(SMnode *pMnode) {
   return sdbSetTable(pMnode->pSdb, table);
 }
 
-static int32_t mndFindSuperTableTagId(const SStbObj *pStb, const char *tagName) {
+static int32_t mndFindSuperTableTagId(const SStbObj *pStb, const char *tagName, int8_t *hasIdx) {
   for (int32_t tag = 0; tag < pStb->numOfTags; tag++) {
     if (strcasecmp(pStb->pTags[tag].name, tagName) == 0) {
+      if (IS_IDX_ON(&pStb->pTags[tag])) {
+        *hasIdx = 1;
+      }
       return tag;
     }
   }
@@ -597,7 +600,8 @@ static int32_t mndSetUpdateIdxStbCommitLogs(SMnode *pMnode, STrans *pTrans, SStb
   pNew->updateTime = taosGetTimestampMs();
   pNew->lock = 0;
 
-  int32_t tag = mndFindSuperTableTagId(pOld, tagName);
+  int8_t  hasIdx = 0;
+  int32_t tag = mndFindSuperTableTagId(pOld, tagName, &hasIdx);
   if (tag < 0) {
     terrno = TSDB_CODE_MND_TAG_NOT_EXIST;
     return -1;
@@ -612,14 +616,14 @@ static int32_t mndSetUpdateIdxStbCommitLogs(SMnode *pMnode, STrans *pTrans, SStb
   SSchema *pTag = pNew->pTags + tag;
 
   if (on == 1) {
-    if (IS_IDX_ON(pTag)) {
+    if (hasIdx && tag != 0) {
       terrno = TSDB_CODE_MND_TAG_INDEX_ALREADY_EXIST;
       return -1;
     } else {
       SSCHMEA_SET_IDX_ON(pTag);
     }
   } else {
-    if (!IS_IDX_ON(pTag)) {
+    if (hasIdx == 0) {
       terrno = TSDB_CODE_MND_SMA_NOT_EXIST;
     } else {
       SSCHMEA_SET_IDX_OFF(pTag);
@@ -667,7 +671,42 @@ _OVER:
   mndTransDrop(pTrans);
   return code;
 }
+int8_t mndCheckIndexNameByTagName(SMnode *pMnode, SIdxObj *pIdxObj) {
+  // build index on first tag, and no index name;
+  int8_t  exist = 0;
+  SDbObj *pDb = NULL;
+  if (strlen(pIdxObj->db) > 0) {
+    pDb = mndAcquireDb(pMnode, pIdxObj->db);
+    if (pDb == NULL) return 0;
+  }
+  SSmaAndTagIter *pIter = NULL;
+  SIdxObj        *pIdx = NULL;
+  SSdb           *pSdb = pMnode->pSdb;
 
+  while (1) {
+    pIter = sdbFetch(pSdb, SDB_IDX, pIter, (void **)&pIdx);
+    if (pIter == NULL) break;
+
+    if (NULL != pDb && pIdx->dbUid != pDb->uid) {
+      sdbRelease(pSdb, pIdx);
+      continue;
+    }
+    if (pIdxObj->stbUid != pIdx->stbUid) {
+      sdbRelease(pSdb, pIdx);
+      continue;
+    }
+    if (strncmp(pIdxObj->colName, pIdx->colName, TSDB_COL_NAME_LEN) == 0) {
+      sdbCancelFetch(pSdb, pIter);
+      sdbRelease(pSdb, pIdx);
+      exist = 1;
+      break;
+    }
+    sdbRelease(pSdb, pIdx);
+  }
+
+  mndReleaseDb(pMnode, pDb);
+  return exist;
+}
 static int32_t mndAddIndex(SMnode *pMnode, SRpcMsg *pReq, SCreateTagIndexReq *req, SDbObj *pDb, SStbObj *pStb) {
   int32_t code = -1;
   SIdxObj idxObj = {0};
@@ -681,11 +720,20 @@ static int32_t mndAddIndex(SMnode *pMnode, SRpcMsg *pReq, SCreateTagIndexReq *re
   idxObj.stbUid = pStb->uid;
   idxObj.dbUid = pStb->dbUid;
 
-  int32_t tag = mndFindSuperTableTagId(pStb, req->colName);
+  int8_t  hasIdx = 0;
+  int32_t tag = mndFindSuperTableTagId(pStb, req->colName, &hasIdx);
   if (tag < 0) {
     terrno = TSDB_CODE_MND_TAG_NOT_EXIST;
     return -1;
-  } else if (tag == 0) {
+  }
+  int8_t exist = 0;
+  if (tag == 0 && hasIdx == 1) {
+    exist = mndCheckIndexNameByTagName(pMnode, &idxObj);
+    if (exist) {
+      terrno = TSDB_CODE_MND_TAG_INDEX_ALREADY_EXIST;
+      return -1;
+    }
+  } else if (hasIdx == 1) {
     terrno = TSDB_CODE_MND_TAG_INDEX_ALREADY_EXIST;
     return -1;
   }
@@ -695,11 +743,11 @@ static int32_t mndAddIndex(SMnode *pMnode, SRpcMsg *pReq, SCreateTagIndexReq *re
     return -1;
   }
 
-  SSchema *pTag = pStb->pTags + tag;
-  if (IS_IDX_ON(pTag)) {
-    terrno = TSDB_CODE_MND_TAG_INDEX_ALREADY_EXIST;
-    return -1;
-  }
+  // SSchema *pTag = pStb->pTags + tag;
+  // if (IS_IDX_ON(pTag)) {
+  //   terrno = TSDB_CODE_MND_TAG_INDEX_ALREADY_EXIST;
+  //   return -1;
+  // }
   code = mndAddIndexImpl(pMnode, pReq, pDb, pStb, &idxObj);
 
   return code;
@@ -806,8 +854,8 @@ int32_t mndDropIdxsByStb(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *p
 
     if (pIdx->stbUid == pStb->uid) {
       if (mndSetDropIdxCommitLogs(pMnode, pTrans, pIdx) != 0) {
+        sdbCancelFetch(pSdb, pIter);
         sdbRelease(pSdb, pIdx);
-        sdbCancelFetch(pSdb, pIdx);
         return -1;
       }
     }
diff --git a/source/dnode/mnode/impl/src/mndSma.c b/source/dnode/mnode/impl/src/mndSma.c
index b84297f6bf..e186a8742f 100644
--- a/source/dnode/mnode/impl/src/mndSma.c
+++ b/source/dnode/mnode/impl/src/mndSma.c
@@ -705,7 +705,10 @@ static int32_t mndProcessCreateSmaReq(SRpcMsg *pReq) {
     terrno = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
-
+#ifdef WINDOWS
+  terrno = TSDB_CODE_MND_INVALID_PLATFORM;
+  goto _OVER;
+#endif
   mInfo("sma:%s, start to create", createReq.name);
   if (mndCheckCreateSmaReq(&createReq) != 0) {
     goto _OVER;
diff --git a/source/dnode/mnode/impl/src/mndStb.c b/source/dnode/mnode/impl/src/mndStb.c
index 70fd74afc0..a56ca552f6 100644
--- a/source/dnode/mnode/impl/src/mndStb.c
+++ b/source/dnode/mnode/impl/src/mndStb.c
@@ -18,6 +18,7 @@
 #include "mndDb.h"
 #include "mndDnode.h"
 #include "mndIndex.h"
+#include "mndIndexComm.h"
 #include "mndInfoSchema.h"
 #include "mndMnode.h"
 #include "mndPerfSchema.h"
@@ -822,7 +823,7 @@ int32_t mndBuildStbFromReq(SMnode *pMnode, SStbObj *pDst, SMCreateStbReq *pCreat
     return -1;
   }
 
-  if(pDst->nextColId < 0 || pDst->nextColId >= 0x7fff - pDst->numOfColumns - pDst->numOfTags){
+  if (pDst->nextColId < 0 || pDst->nextColId >= 0x7fff - pDst->numOfColumns - pDst->numOfTags) {
     terrno = TSDB_CODE_MND_FIELD_VALUE_OVERFLOW;
     return -1;
   }
@@ -834,6 +835,7 @@ int32_t mndBuildStbFromReq(SMnode *pMnode, SStbObj *pDst, SMCreateStbReq *pCreat
     pSchema->bytes = pField->bytes;
     pSchema->flags = pField->flags;
     memcpy(pSchema->name, pField->name, TSDB_COL_NAME_LEN);
+    memcpy(pSchema->comment, pField->comment, TSDB_COL_COMMENT_LEN);
     pSchema->colId = pDst->nextColId;
     pDst->nextColId++;
   }
@@ -847,6 +849,7 @@ int32_t mndBuildStbFromReq(SMnode *pMnode, SStbObj *pDst, SMCreateStbReq *pCreat
       SSCHMEA_SET_IDX_ON(pSchema);
     }
     memcpy(pSchema->name, pField->name, TSDB_COL_NAME_LEN);
+    memcpy(pSchema->comment, pField->comment, TSDB_COL_COMMENT_LEN);
     pSchema->colId = pDst->nextColId;
     pDst->nextColId++;
   }
@@ -857,11 +860,39 @@ static int32_t mndCreateStb(SMnode *pMnode, SRpcMsg *pReq, SMCreateStbReq *pCrea
   SStbObj stbObj = {0};
   int32_t code = -1;
 
+  char fullIdxName[TSDB_INDEX_FNAME_LEN * 2] = {0};
+
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_DB_INSIDE, pReq, "create-stb");
   if (pTrans == NULL) goto _OVER;
 
   mInfo("trans:%d, used to create stb:%s", pTrans->id, pCreate->name);
   if (mndBuildStbFromReq(pMnode, &stbObj, pCreate, pDb) != 0) goto _OVER;
+
+  char randStr[24] = {0};
+  taosRandStr2(randStr, tListLen(randStr) - 1);
+  SSchema *pSchema = &(stbObj.pTags[0]);
+  sprintf(fullIdxName, "%s.%s_%s", pDb->name, pSchema->name, randStr);
+
+  SSIdx idx = {0};
+  if (mndAcquireGlobalIdx(pMnode, fullIdxName, SDB_IDX, &idx) == 0 && idx.pIdx != NULL) {
+    terrno = TSDB_CODE_MND_TAG_INDEX_ALREADY_EXIST;
+    mndReleaseIdx(pMnode, idx.pIdx);
+
+    goto _OVER;
+  }
+
+  SIdxObj idxObj = {0};
+  memcpy(idxObj.name, fullIdxName, TSDB_INDEX_FNAME_LEN);
+  memcpy(idxObj.stb, stbObj.name, TSDB_TABLE_FNAME_LEN);
+  memcpy(idxObj.db, stbObj.db, TSDB_DB_FNAME_LEN);
+  memcpy(idxObj.colName, pSchema->name, TSDB_COL_NAME_LEN);
+  idxObj.createdTime = taosGetTimestampMs();
+  idxObj.uid = mndGenerateUid(fullIdxName, strlen(fullIdxName));
+  idxObj.stbUid = stbObj.uid;
+  idxObj.dbUid = stbObj.dbUid;
+
+  if (mndSetCreateIdxCommitLogs(pMnode, pTrans, &idxObj) < 0) goto _OVER;
+
   if (mndAddStbToTrans(pMnode, pTrans, pDb, &stbObj) < 0) goto _OVER;
   if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
   code = 0;
@@ -956,7 +987,7 @@ static int32_t mndBuildStbFromAlter(SStbObj *pStb, SStbObj *pDst, SMCreateStbReq
     return -1;
   }
 
-  if(pDst->nextColId < 0 || pDst->nextColId >= 0x7fff - pDst->numOfColumns - pDst->numOfTags){
+  if (pDst->nextColId < 0 || pDst->nextColId >= 0x7fff - pDst->numOfColumns - pDst->numOfTags) {
     terrno = TSDB_CODE_MND_FIELD_VALUE_OVERFLOW;
     return -1;
   }
@@ -1188,7 +1219,7 @@ static int32_t mndAddSuperTableTag(const SStbObj *pOld, SStbObj *pNew, SArray *p
     return -1;
   }
 
-  if(pNew->nextColId < 0 || pNew->nextColId >= 0x7fff - ntags){
+  if (pNew->nextColId < 0 || pNew->nextColId >= 0x7fff - ntags) {
     terrno = TSDB_CODE_MND_FIELD_VALUE_OVERFLOW;
     return -1;
   }
@@ -1478,7 +1509,8 @@ static int32_t mndAlterStbTagBytes(SMnode *pMnode, const SStbObj *pOld, SStbObj
 
   SSchema *pTag = pNew->pTags + tag;
 
-  if (!(pTag->type == TSDB_DATA_TYPE_BINARY || pTag->type == TSDB_DATA_TYPE_NCHAR || pTag->type == TSDB_DATA_TYPE_GEOMETRY)) {
+  if (!(pTag->type == TSDB_DATA_TYPE_BINARY || pTag->type == TSDB_DATA_TYPE_NCHAR ||
+        pTag->type == TSDB_DATA_TYPE_GEOMETRY)) {
     terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
     return -1;
   }
@@ -1506,7 +1538,7 @@ static int32_t mndAddSuperTableColumn(const SStbObj *pOld, SStbObj *pNew, SArray
     return -1;
   }
 
-  if(pNew->nextColId < 0 || pNew->nextColId >= 0x7fff - ncols){
+  if (pNew->nextColId < 0 || pNew->nextColId >= 0x7fff - ncols) {
     terrno = TSDB_CODE_MND_FIELD_VALUE_OVERFLOW;
     return -1;
   }
@@ -1598,7 +1630,8 @@ static int32_t mndAlterStbColumnBytes(SMnode *pMnode, const SStbObj *pOld, SStbO
   }
 
   SSchema *pCol = pNew->pColumns + col;
-  if (!(pCol->type == TSDB_DATA_TYPE_BINARY || pCol->type == TSDB_DATA_TYPE_NCHAR || pCol->type == TSDB_DATA_TYPE_GEOMETRY)) {
+  if (!(pCol->type == TSDB_DATA_TYPE_BINARY || pCol->type == TSDB_DATA_TYPE_NCHAR ||
+        pCol->type == TSDB_DATA_TYPE_GEOMETRY)) {
     terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
     return -1;
   }
@@ -3182,7 +3215,6 @@ static int32_t mndRetrieveStbCol(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB
   SSdb    *pSdb = pMnode->pSdb;
   SStbObj *pStb = NULL;
 
-
   int32_t numOfRows = 0;
   if (!pShow->sysDbRsp) {
     numOfRows = buildSysDbColsInfo(pBlock, pShow->db, pShow->filterTb);
@@ -3206,7 +3238,7 @@ static int32_t mndRetrieveStbCol(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB
       if (pShow->pIter == NULL) break;
     } else {
       fetch = true;
-      void  *pKey = taosHashGetKey(pShow->pIter, NULL);
+      void *pKey = taosHashGetKey(pShow->pIter, NULL);
       pStb = sdbAcquire(pSdb, SDB_STB, pKey);
       if (!pStb) continue;
     }
diff --git a/source/dnode/mnode/impl/src/mndStream.c b/source/dnode/mnode/impl/src/mndStream.c
index a0d53ec780..427a52af3b 100644
--- a/source/dnode/mnode/impl/src/mndStream.c
+++ b/source/dnode/mnode/impl/src/mndStream.c
@@ -692,7 +692,10 @@ static int32_t mndProcessCreateStreamReq(SRpcMsg *pReq) {
     terrno = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
-
+#ifdef WINDOWS
+  terrno = TSDB_CODE_MND_INVALID_PLATFORM;
+  goto _OVER;
+#endif
   mInfo("stream:%s, start to create, sql:%s", createStreamReq.name, createStreamReq.sql);
 
   if (mndCheckCreateStreamReq(&createStreamReq) != 0) {
diff --git a/source/dnode/snode/src/snode.c b/source/dnode/snode/src/snode.c
index 4000e72835..635fdcf459 100644
--- a/source/dnode/snode/src/snode.c
+++ b/source/dnode/snode/src/snode.c
@@ -77,6 +77,8 @@ int32_t sndExpandTask(SSnode *pSnode, SStreamTask *pTask, int64_t ver) {
   pTask->chkInfo.version = ver;
   pTask->pMeta = pSnode->pMeta;
 
+  streamTaskOpenAllUpstreamInput(pTask);
+
   pTask->pState = streamStateOpen(pSnode->path, pTask, false, -1, -1);
   if (pTask->pState == NULL) {
     return -1;
diff --git a/source/dnode/vnode/src/inc/vnodeInt.h b/source/dnode/vnode/src/inc/vnodeInt.h
index 4f6a5bb765..50b8e625f9 100644
--- a/source/dnode/vnode/src/inc/vnodeInt.h
+++ b/source/dnode/vnode/src/inc/vnodeInt.h
@@ -252,7 +252,6 @@ int32_t tqProcessTaskDispatchRsp(STQ* pTq, SRpcMsg* pMsg);
 int32_t tqProcessTaskRetrieveReq(STQ* pTq, SRpcMsg* pMsg);
 int32_t tqProcessTaskRetrieveRsp(STQ* pTq, SRpcMsg* pMsg);
 int32_t tqProcessTaskScanHistory(STQ* pTq, SRpcMsg* pMsg);
-int32_t tqProcessTaskTransferStateReq(STQ* pTq, SRpcMsg* pMsg);
 int32_t tqProcessTaskScanHistoryFinishReq(STQ* pTq, SRpcMsg* pMsg);
 int32_t tqProcessTaskScanHistoryFinishRsp(STQ* pTq, SRpcMsg* pMsg);
 int32_t tqCheckLogInWal(STQ* pTq, int64_t version);
diff --git a/source/dnode/vnode/src/meta/metaQuery.c b/source/dnode/vnode/src/meta/metaQuery.c
index a46186c92e..ca5346eee3 100644
--- a/source/dnode/vnode/src/meta/metaQuery.c
+++ b/source/dnode/vnode/src/meta/metaQuery.c
@@ -17,8 +17,8 @@
 #include "osMemory.h"
 #include "tencode.h"
 
-void _metaReaderInit(SMetaReader* pReader, void* pVnode, int32_t flags, SStoreMeta* pAPI) {
-  SMeta* pMeta = ((SVnode*)pVnode)->pMeta;
+void _metaReaderInit(SMetaReader *pReader, void *pVnode, int32_t flags, SStoreMeta *pAPI) {
+  SMeta *pMeta = ((SVnode *)pVnode)->pMeta;
   metaReaderDoInit(pReader, pMeta, flags);
   pReader->pAPI = pAPI;
 }
@@ -143,7 +143,7 @@ tb_uid_t metaGetTableEntryUidByName(SMeta *pMeta, const char *name) {
 int metaGetTableNameByUid(void *pVnode, uint64_t uid, char *tbName) {
   int         code = 0;
   SMetaReader mr = {0};
-  metaReaderDoInit(&mr, ((SVnode*)pVnode)->pMeta, 0);
+  metaReaderDoInit(&mr, ((SVnode *)pVnode)->pMeta, 0);
   code = metaReaderGetTableEntryByUid(&mr, uid);
   if (code < 0) {
     metaReaderClear(&mr);
@@ -195,7 +195,7 @@ int metaGetTableUidByName(void *pVnode, char *tbName, uint64_t *uid) {
 int metaGetTableTypeByName(void *pVnode, char *tbName, ETableType *tbType) {
   int         code = 0;
   SMetaReader mr = {0};
-  metaReaderDoInit(&mr, ((SVnode*)pVnode)->pMeta, 0);
+  metaReaderDoInit(&mr, ((SVnode *)pVnode)->pMeta, 0);
 
   code = metaGetTableEntryByName(&mr, tbName);
   if (code == 0) *tbType = mr.me.type;
@@ -244,7 +244,7 @@ SMTbCursor *metaOpenTbCursor(void *pVnode) {
     return NULL;
   }
 
-  SVnode* pVnodeObj = pVnode;
+  SVnode *pVnodeObj = pVnode;
   // tdbTbcMoveToFirst((TBC *)pTbCur->pDbc);
   pTbCur->pMeta = pVnodeObj->pMeta;
   pTbCur->paused = 1;
@@ -1166,7 +1166,7 @@ int32_t metaFilterTtl(void *pVnode, SMetaFltParam *arg, SArray *pUids) {
   pCursor->type = param->type;
 
   metaRLock(pMeta);
-  //ret = tdbTbcOpen(pMeta->pTtlIdx, &pCursor->pCur, NULL);
+  // ret = tdbTbcOpen(pMeta->pTtlIdx, &pCursor->pCur, NULL);
 
 END:
   if (pCursor->pMeta) metaULock(pCursor->pMeta);
@@ -1221,7 +1221,7 @@ int32_t metaFilterTableIds(void *pVnode, SMetaFltParam *arg, SArray *pUids) {
   ret = -1;
   for (int i = 0; i < oStbEntry.stbEntry.schemaTag.nCols; i++) {
     SSchema *schema = oStbEntry.stbEntry.schemaTag.pSchema + i;
-    if (schema->colId == param->cid && param->type == schema->type && (IS_IDX_ON(schema) || i == 0)) {
+    if (schema->colId == param->cid && param->type == schema->type && (IS_IDX_ON(schema))) {
       ret = 0;
     }
   }
diff --git a/source/dnode/vnode/src/meta/metaTable.c b/source/dnode/vnode/src/meta/metaTable.c
index 632e6dd872..f56837f759 100644
--- a/source/dnode/vnode/src/meta/metaTable.c
+++ b/source/dnode/vnode/src/meta/metaTable.c
@@ -450,12 +450,13 @@ int metaAddIndexToSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
       goto _err;
     }
     if (IS_IDX_ON(pNew) && !IS_IDX_ON(pOld)) {
-      if (diffIdx != -1) goto _err;
+      // if (diffIdx != -1) goto _err;
       diffIdx = i;
+      break;
     }
   }
 
-  if (diffIdx == -1 || diffIdx == 0) {
+  if (diffIdx == -1) {
     goto _err;
   }
 
@@ -586,7 +587,7 @@ int metaDropIndexFromSTable(SMeta *pMeta, int64_t version, SDropIndexReq *pReq)
   for (int i = 0; i < oStbEntry.stbEntry.schemaTag.nCols; i++) {
     SSchema *schema = oStbEntry.stbEntry.schemaTag.pSchema + i;
     if (0 == strncmp(schema->name, pReq->colName, sizeof(pReq->colName))) {
-      if (i != 0 || IS_IDX_ON(schema)) {
+      if (IS_IDX_ON(schema)) {
         pCol = schema;
       }
       break;
@@ -2094,7 +2095,7 @@ static int metaUpdateTagIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry) {
   } else {
     for (int i = 0; i < pTagSchema->nCols; i++) {
       pTagColumn = &pTagSchema->pSchema[i];
-      if (i != 0 && !IS_IDX_ON(pTagColumn)) continue;
+      if (!IS_IDX_ON(pTagColumn)) continue;
 
       STagVal tagVal = {.cid = pTagColumn->colId};
       tTagGet((const STag *)pCtbEntry->ctbEntry.pTags, &tagVal);
diff --git a/source/dnode/vnode/src/tq/tq.c b/source/dnode/vnode/src/tq/tq.c
index de34a96836..a5f7e0eb68 100644
--- a/source/dnode/vnode/src/tq/tq.c
+++ b/source/dnode/vnode/src/tq/tq.c
@@ -930,6 +930,8 @@ int32_t tqExpandTask(STQ* pTq, SStreamTask* pTask, int64_t ver) {
   pTask->pMsgCb = &pTq->pVnode->msgCb;
   pTask->pMeta = pTq->pStreamMeta;
 
+  streamTaskOpenAllUpstreamInput(pTask);
+
   // backup the initial status, and set it to be TASK_STATUS__INIT
   pTask->chkInfo.version = ver;
   pTask->chkInfo.currentVer = ver;
@@ -1274,7 +1276,9 @@ int32_t tqProcessTaskScanHistory(STQ* pTq, SRpcMsg* pMsg) {
 
     if (done) {
       pTask->tsInfo.step2Start = taosGetTimestampMs();
-      streamTaskEndScanWAL(pTask);
+      qDebug("s-task:%s scan-history from WAL stage(step 2) ended, elapsed time:%.2fs", id, 0.0);
+      appendTranstateIntoInputQ(pTask);
+      streamTryExec(pTask);  // exec directly
     } else {
       STimeWindow* pWindow = &pTask->dataRange.window;
       tqDebug("s-task:%s level:%d verRange:%" PRId64 " - %" PRId64 " window:%" PRId64 "-%" PRId64
@@ -1339,44 +1343,6 @@ int32_t tqProcessTaskScanHistory(STQ* pTq, SRpcMsg* pMsg) {
   return 0;
 }
 
-// notify the downstream tasks to transfer executor state after handle all history blocks.
-int32_t tqProcessTaskTransferStateReq(STQ* pTq, SRpcMsg* pMsg) {
-  char*   pReq = POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead));
-  int32_t len = pMsg->contLen - sizeof(SMsgHead);
-
-  SStreamTransferReq req = {0};
-
-  SDecoder decoder;
-  tDecoderInit(&decoder, (uint8_t*)pReq, len);
-  int32_t code = tDecodeStreamScanHistoryFinishReq(&decoder, &req);
-  tDecoderClear(&decoder);
-
-  tqDebug("vgId:%d start to process transfer state msg, from s-task:0x%x", pTq->pStreamMeta->vgId, req.downstreamTaskId);
-
-  SStreamTask* pTask = streamMetaAcquireTask(pTq->pStreamMeta, req.streamId, req.downstreamTaskId);
-  if (pTask == NULL) {
-    tqError("failed to find task:0x%x, it may have been dropped already. process transfer state failed", req.downstreamTaskId);
-    return -1;
-  }
-
-  int32_t remain = streamAlignTransferState(pTask);
-  if (remain > 0) {
-    tqDebug("s-task:%s receive upstream transfer state msg, remain:%d", pTask->id.idStr, remain);
-    streamMetaReleaseTask(pTq->pStreamMeta, pTask);
-    return 0;
-  }
-
-  // transfer the ownership of executor state
-  tqDebug("s-task:%s all upstream tasks send transfer msg, open transfer state flag", pTask->id.idStr);
-  ASSERT(pTask->streamTaskId.taskId != 0 && pTask->info.fillHistory == 1);
-
-  pTask->status.transferState = true;
-
-  streamSchedExec(pTask);
-  streamMetaReleaseTask(pTq->pStreamMeta, pTask);
-  return 0;
-}
-
 int32_t tqProcessTaskScanHistoryFinishReq(STQ* pTq, SRpcMsg* pMsg) {
   char*   msg = POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead));
   int32_t msgLen = pMsg->contLen - sizeof(SMsgHead);
@@ -1564,7 +1530,7 @@ int32_t tqProcessTaskDispatchRsp(STQ* pTq, SRpcMsg* pMsg) {
   if (pTask) {
     streamProcessDispatchRsp(pTask, pRsp, pMsg->code);
     streamMetaReleaseTask(pTq->pStreamMeta, pTask);
-    return 0;
+    return TSDB_CODE_SUCCESS;
   } else {
     tqDebug("vgId:%d failed to handle the dispatch rsp, since find task:0x%x failed", vgId, taskId);
     return TSDB_CODE_INVALID_MSG;
@@ -1708,6 +1674,8 @@ int32_t tqProcessTaskRetrieveRsp(STQ* pTq, SRpcMsg* pMsg) {
 
 int32_t vnodeEnqueueStreamMsg(SVnode* pVnode, SRpcMsg* pMsg) {
   STQ*      pTq = pVnode->pTq;
+  int32_t vgId = pVnode->config.vgId;
+
   SMsgHead* msgStr = pMsg->pCont;
   char*     msgBody = POINTER_SHIFT(msgStr, sizeof(SMsgHead));
   int32_t   msgLen = pMsg->contLen - sizeof(SMsgHead);
@@ -1724,7 +1692,9 @@ int32_t vnodeEnqueueStreamMsg(SVnode* pVnode, SRpcMsg* pMsg) {
   tDecoderClear(&decoder);
 
   int32_t taskId = req.taskId;
-  SStreamTask* pTask = streamMetaAcquireTask(pTq->pStreamMeta, req.streamId, req.taskId);
+  tqDebug("vgId:%d receive dispatch msg to s-task:0x%"PRIx64"-0x%x", vgId, req.streamId, taskId);
+
+  SStreamTask* pTask = streamMetaAcquireTask(pTq->pStreamMeta, req.streamId, taskId);
   if (pTask != NULL) {
     SRpcMsg rsp = {.info = pMsg->info, .code = 0};
     streamProcessDispatchMsg(pTask, &req, &rsp, false);
@@ -1741,7 +1711,7 @@ int32_t vnodeEnqueueStreamMsg(SVnode* pVnode, SRpcMsg* pMsg) {
 
 FAIL:
   if (pMsg->info.handle == NULL) {
-    tqError("s-task:0x%x vgId:%d msg handle is null, abort enqueue dispatch msg", pTq->pStreamMeta->vgId, taskId);
+    tqError("s-task:0x%x vgId:%d msg handle is null, abort enqueue dispatch msg", vgId, taskId);
     return -1;
   }
 
diff --git a/source/dnode/vnode/src/tq/tqRead.c b/source/dnode/vnode/src/tq/tqRead.c
index e0e6853ffa..7c58431b57 100644
--- a/source/dnode/vnode/src/tq/tqRead.c
+++ b/source/dnode/vnode/src/tq/tqRead.c
@@ -332,8 +332,12 @@ int32_t extractMsgFromWal(SWalReader* pReader, void** pItem, int64_t maxVer, con
     void*   pBody = POINTER_SHIFT(pReader->pHead->head.body, sizeof(SMsgHead));
     int32_t len = pReader->pHead->head.bodyLen - sizeof(SMsgHead);
 
-    extractDelDataBlock(pBody, len, ver, (SStreamRefDataBlock**)pItem);
-    tqDebug("s-task:%s delete msg extract from WAL, len:%d, ver:%"PRId64, id, len, ver);
+    code = extractDelDataBlock(pBody, len, ver, (SStreamRefDataBlock**)pItem);
+    if (code != TSDB_CODE_SUCCESS) {
+      tqError("s-task:%s extract delete msg from WAL failed, code:%s", id, tstrerror(code));
+    } else {
+      tqDebug("s-task:%s delete msg extract from WAL, len:%d, ver:%"PRId64, id, len, ver);
+    }
   } else {
     ASSERT(0);
   }
diff --git a/source/dnode/vnode/src/tq/tqRestore.c b/source/dnode/vnode/src/tq/tqRestore.c
index 3d9a91899c..ed612587f5 100644
--- a/source/dnode/vnode/src/tq/tqRestore.c
+++ b/source/dnode/vnode/src/tq/tqRestore.c
@@ -210,13 +210,23 @@ int32_t doSetOffsetForWalReader(SStreamTask *pTask, int32_t vgId) {
 }
 
 static void checkForFillHistoryVerRange(SStreamTask* pTask, int64_t ver) {
-  if ((pTask->info.fillHistory == 1) && ver > pTask->dataRange.range.maxVer) {
-    qWarn("s-task:%s fill-history scan WAL, currentVer:%" PRId64 " reach the maximum ver:%" PRId64
-          ", not scan wal anymore, set the transfer state flag",
-          pTask->id.idStr, ver, pTask->dataRange.range.maxVer);
-    pTask->status.transferState = true;
+  const char* id = pTask->id.idStr;
+  int64_t     maxVer = pTask->dataRange.range.maxVer;
 
-    /*int32_t code = */streamSchedExec(pTask);
+  if ((pTask->info.fillHistory == 1) && ver > pTask->dataRange.range.maxVer) {
+    if (!pTask->status.appendTranstateBlock) {
+      qWarn("s-task:%s fill-history scan WAL, currentVer:%" PRId64 " reach the maximum ver:%" PRId64
+            ", not scan wal anymore, add transfer-state block into inputQ",
+            id, ver, maxVer);
+
+      double el = (taosGetTimestampMs() - pTask->tsInfo.step2Start) / 1000.0;
+      qDebug("s-task:%s scan-history from WAL stage(step 2) ended, elapsed time:%.2fs", id, el);
+      appendTranstateIntoInputQ(pTask);
+      /*int32_t code = */streamSchedExec(pTask);
+    } else {
+      qWarn("s-task:%s fill-history scan WAL, currentVer:%" PRId64 " reach the maximum ver:%" PRId64 ", not scan wal",
+            id, ver, maxVer);
+    }
   }
 }
 
@@ -262,7 +272,7 @@ int32_t createStreamTaskRunReq(SStreamMeta* pStreamMeta, bool* pScanIdle) {
       continue;
     }
 
-    if ((pTask->info.fillHistory == 1) && pTask->status.transferState) {
+    if ((pTask->info.fillHistory == 1) && pTask->status.appendTranstateBlock) {
       ASSERT(status == TASK_STATUS__NORMAL);
       // the maximum version of data in the WAL has reached already, the step2 is done
       tqDebug("s-task:%s fill-history reach the maximum ver:%" PRId64 ", not scan wal anymore", pTask->id.idStr,
@@ -277,6 +287,13 @@ int32_t createStreamTaskRunReq(SStreamMeta* pStreamMeta, bool* pScanIdle) {
       continue;
     }
 
+    // downstream task has blocked the output, stopped for a while
+    if (pTask->inputStatus == TASK_INPUT_STATUS__BLOCKED) {
+      tqDebug("s-task:%s inputQ is blocked, do nothing", pTask->id.idStr);
+      streamMetaReleaseTask(pStreamMeta, pTask);
+      continue;
+    }
+
     *pScanIdle = false;
 
     // seek the stored version and extract data from WAL
diff --git a/source/dnode/vnode/src/tq/tqSink.c b/source/dnode/vnode/src/tq/tqSink.c
index b22650d249..cce31688bc 100644
--- a/source/dnode/vnode/src/tq/tqSink.c
+++ b/source/dnode/vnode/src/tq/tqSink.c
@@ -412,7 +412,7 @@ void tqSinkToTablePipeline(SStreamTask* pTask, void* vnode, int64_t ver, void* d
           if (k == 0) {
             SColumnInfoData* pColData = taosArrayGet(pDataBlock->pDataBlock, dataIndex);
             void*            colData = colDataGetData(pColData, j);
-            tqTrace("tq sink pipe2, row %d, col %d ts %" PRId64, j, k, *(int64_t*)colData);
+            tqDebug("tq sink pipe2, row %d, col %d ts %" PRId64, j, k, *(int64_t*)colData);
           }
           if (IS_SET_NULL(pCol)) {
             SColVal cv = COL_VAL_NULL(pCol->colId, pCol->type);
diff --git a/source/dnode/vnode/src/tsdb/tsdbSnapshot.c b/source/dnode/vnode/src/tsdb/tsdbSnapshot.c
index bdcf4a87c1..f547119f49 100644
--- a/source/dnode/vnode/src/tsdb/tsdbSnapshot.c
+++ b/source/dnode/vnode/src/tsdb/tsdbSnapshot.c
@@ -392,6 +392,9 @@ static int32_t tsdbSnapReadTombData(STsdbSnapReader* reader, uint8_t** data) {
     code = tTombBlockPut(reader->tombBlock, record);
     TSDB_CHECK_CODE(code, lino, _exit);
 
+    code = tsdbIterMergerNext(reader->tombIterMerger);
+    TSDB_CHECK_CODE(code, lino, _exit);
+
     if (TOMB_BLOCK_SIZE(reader->tombBlock) >= 81920) {
       break;
     }
diff --git a/source/dnode/vnode/src/vnd/vnodeQuery.c b/source/dnode/vnode/src/vnd/vnodeQuery.c
index a40accf4fe..b9880be895 100644
--- a/source/dnode/vnode/src/vnd/vnodeQuery.c
+++ b/source/dnode/vnode/src/vnd/vnodeQuery.c
@@ -216,7 +216,7 @@ int vnodeGetTableCfg(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
 
   cfgRsp.numOfTags = schemaTag.nCols;
   cfgRsp.numOfColumns = schema.nCols;
-  cfgRsp.pSchemas = (SSchema *)taosMemoryMalloc(sizeof(SSchema) * (cfgRsp.numOfColumns + cfgRsp.numOfTags));
+  cfgRsp.pSchemas = (SSchema *)taosMemoryCalloc(cfgRsp.numOfColumns + cfgRsp.numOfTags, sizeof(SSchema));
 
   memcpy(cfgRsp.pSchemas, schema.pSchema, sizeof(SSchema) * schema.nCols);
   if (schemaTag.nCols) {
diff --git a/source/dnode/vnode/src/vnd/vnodeSvr.c b/source/dnode/vnode/src/vnd/vnodeSvr.c
index 743470aac8..f75c779f4b 100644
--- a/source/dnode/vnode/src/vnd/vnodeSvr.c
+++ b/source/dnode/vnode/src/vnd/vnodeSvr.c
@@ -661,8 +661,6 @@ int32_t vnodeProcessStreamMsg(SVnode *pVnode, SRpcMsg *pMsg, SQueueInfo *pInfo)
       return tqProcessTaskRetrieveRsp(pVnode->pTq, pMsg);
     case TDMT_VND_STREAM_SCAN_HISTORY:
       return tqProcessTaskScanHistory(pVnode->pTq, pMsg);
-    case TDMT_STREAM_TRANSFER_STATE:
-      return tqProcessTaskTransferStateReq(pVnode->pTq, pMsg);
     case TDMT_STREAM_SCAN_HISTORY_FINISH:
       return tqProcessTaskScanHistoryFinishReq(pVnode->pTq, pMsg);
     case TDMT_STREAM_SCAN_HISTORY_FINISH_RSP:
diff --git a/source/libs/command/src/command.c b/source/libs/command/src/command.c
index 8ddf730d5a..1fa97904e4 100644
--- a/source/libs/command/src/command.c
+++ b/source/libs/command/src/command.c
@@ -78,6 +78,10 @@ static int32_t buildDescResultDataBlock(SSDataBlock** pOutput) {
     infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, DESCRIBE_RESULT_NOTE_LEN, 4);
     code = blockDataAppendColInfo(pBlock, &infoData);
   }
+  if (TSDB_CODE_SUCCESS == code) {
+    infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, DESCRIBE_RESULT_COL_COMMENT_LEN, 5);
+    code = blockDataAppendColInfo(pBlock, &infoData);
+  }
 
   if (TSDB_CODE_SUCCESS == code) {
     *pOutput = pBlock;
@@ -99,7 +103,9 @@ static int32_t setDescResultIntoDataBlock(bool sysInfoUser, SSDataBlock* pBlock,
   SColumnInfoData* pCol3 = taosArrayGet(pBlock->pDataBlock, 2);
   // Note
   SColumnInfoData* pCol4 = taosArrayGet(pBlock->pDataBlock, 3);
-  char             buf[DESCRIBE_RESULT_FIELD_LEN] = {0};
+  // Comment
+  SColumnInfoData* pCol5 = taosArrayGet(pBlock->pDataBlock, 4);
+  char             buf[DESCRIBE_RESULT_COL_COMMENT_LEN + VARSTR_HEADER_SIZE] = {0};
   for (int32_t i = 0; i < numOfRows; ++i) {
     if (invisibleColumn(sysInfoUser, pMeta->tableType, pMeta->schema[i].flags)) {
       continue;
@@ -112,6 +118,8 @@ static int32_t setDescResultIntoDataBlock(bool sysInfoUser, SSDataBlock* pBlock,
     colDataSetVal(pCol3, pBlock->info.rows, (const char*)&bytes, false);
     STR_TO_VARSTR(buf, i >= pMeta->tableInfo.numOfColumns ? "TAG" : "");
     colDataSetVal(pCol4, pBlock->info.rows, buf, false);
+    STR_TO_VARSTR(buf, pMeta->schema[i].comment);
+    colDataSetVal(pCol5, pBlock->info.rows, buf, false);
     ++(pBlock->info.rows);
   }
   if (pBlock->info.rows <= 0) {
@@ -456,14 +464,19 @@ void appendColumnFields(char* buf, int32_t* len, STableCfg* pCfg) {
   for (int32_t i = 0; i < pCfg->numOfColumns; ++i) {
     SSchema* pSchema = pCfg->pSchemas + i;
     char     type[32];
+    char     comments[TSDB_COL_COMMENT_LEN + 16] = {0};
     sprintf(type, "%s", tDataTypes[pSchema->type].name);
     if (TSDB_DATA_TYPE_VARCHAR == pSchema->type || TSDB_DATA_TYPE_GEOMETRY == pSchema->type) {
       sprintf(type + strlen(type), "(%d)", (int32_t)(pSchema->bytes - VARSTR_HEADER_SIZE));
     } else if (TSDB_DATA_TYPE_NCHAR == pSchema->type) {
       sprintf(type + strlen(type), "(%d)", (int32_t)((pSchema->bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE));
     }
+    if (pSchema->comment[0]) {
+      sprintf(comments, " COMMENT '%s'", pSchema->comment);
+    }
 
-    *len += sprintf(buf + VARSTR_HEADER_SIZE + *len, "%s`%s` %s", ((i > 0) ? ", " : ""), pSchema->name, type);
+    *len +=
+        sprintf(buf + VARSTR_HEADER_SIZE + *len, "%s`%s` %s%s", ((i > 0) ? ", " : ""), pSchema->name, type, comments);
   }
 }
 
@@ -471,14 +484,18 @@ void appendTagFields(char* buf, int32_t* len, STableCfg* pCfg) {
   for (int32_t i = 0; i < pCfg->numOfTags; ++i) {
     SSchema* pSchema = pCfg->pSchemas + pCfg->numOfColumns + i;
     char     type[32];
+    char     comments[TSDB_COL_COMMENT_LEN + 16] = {0};
     sprintf(type, "%s", tDataTypes[pSchema->type].name);
     if (TSDB_DATA_TYPE_VARCHAR == pSchema->type || TSDB_DATA_TYPE_GEOMETRY == pSchema->type) {
       sprintf(type + strlen(type), "(%d)", (int32_t)(pSchema->bytes - VARSTR_HEADER_SIZE));
     } else if (TSDB_DATA_TYPE_NCHAR == pSchema->type) {
       sprintf(type + strlen(type), "(%d)", (int32_t)((pSchema->bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE));
     }
+    if (pSchema->comment[0]) {
+      sprintf(comments, " COMMENT '%s'", pSchema->comment);
+    }
 
-    *len += sprintf(buf + VARSTR_HEADER_SIZE + *len, "%s`%s` %s", ((i > 0) ? ", " : ""), pSchema->name, type);
+    *len += sprintf(buf + VARSTR_HEADER_SIZE + *len, "%s`%s` %s%s", ((i > 0) ? ", " : ""), pSchema->name, type, comments);
   }
 }
 
@@ -624,7 +641,7 @@ void appendTableOptions(char* buf, int32_t* len, SDbCfgInfo* pDbCfg, STableCfg*
       }
     }
 
-    if (nSma < pCfg->numOfColumns) {
+    if (nSma < pCfg->numOfColumns && nSma > 0) {
       bool smaOn = false;
       *len += sprintf(buf + VARSTR_HEADER_SIZE + *len, " SMA(");
       for (int32_t i = 0; i < pCfg->numOfColumns; ++i) {
diff --git a/source/libs/executor/inc/executil.h b/source/libs/executor/inc/executil.h
index 2552523e73..2622903121 100644
--- a/source/libs/executor/inc/executil.h
+++ b/source/libs/executor/inc/executil.h
@@ -183,13 +183,17 @@ void    cleanupQueryTableDataCond(SQueryTableDataCond* pCond);
 
 int32_t convertFillType(int32_t mode);
 int32_t resultrowComparAsc(const void* p1, const void* p2);
-int32_t isQualifiedTable(STableKeyInfo* info, SNode* pTagCond, void* metaHandle, bool* pQualified, SStorageAPI *pAPI);
-
-void printDataBlock(SSDataBlock* pBlock, const char* flag);
+int32_t isQualifiedTable(STableKeyInfo* info, SNode* pTagCond, void* metaHandle, bool* pQualified, SStorageAPI* pAPI);
+char*   getStreamOpName(uint16_t opType);
+void    printDataBlock(SSDataBlock* pBlock, const char* flag, const char* taskIdStr);
+void    printSpecDataBlock(SSDataBlock* pBlock, const char* flag, const char* opStr, const char* taskIdStr);
 
 void getNextTimeWindow(const SInterval* pInterval, STimeWindow* tw, int32_t order);
 void getInitialStartTimeWindow(SInterval* pInterval, TSKEY ts, STimeWindow* w, bool ascQuery);
 
+TSKEY getStartTsKey(STimeWindow* win, const TSKEY* tsCols);
+void updateTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pWin, int64_t  delta);
+
 SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, SArray* pUidTagList, void* pVnode,
                                         SStorageAPI* pStorageAPI);
 #endif  // TDENGINE_EXECUTIL_H
diff --git a/source/libs/executor/inc/executorInt.h b/source/libs/executor/inc/executorInt.h
index dad15dc6bc..91c45d2bd9 100644
--- a/source/libs/executor/inc/executorInt.h
+++ b/source/libs/executor/inc/executorInt.h
@@ -470,7 +470,6 @@ typedef struct SStreamIntervalOperatorInfo {
   SArray*            pPullWins;  // SPullWindowInfo
   int32_t            pullIndex;
   SSDataBlock*       pPullDataRes;
-  bool               isFinal;
   SArray*            pChildren;
   int32_t            numOfChild;
   SStreamState*      pState;        // void
@@ -521,7 +520,6 @@ typedef struct SStreamSessionAggOperatorInfo {
   void*               pDelIterator;
   SArray*             pChildren;  // cache for children's result; final stream operator
   SPhysiNode*         pPhyNode;   // create new child
-  bool                isFinal;
   bool                ignoreExpiredData;
   bool                ignoreExpiredDataSaved;
   SArray*             pUpdated;
@@ -709,6 +707,13 @@ uint64_t calcGroupId(char* pData, int32_t len);
 void streamOpReleaseState(struct SOperatorInfo* pOperator);
 void streamOpReloadState(struct SOperatorInfo* pOperator);
 
+bool inSlidingWindow(SInterval* pInterval, STimeWindow* pWin, SDataBlockInfo* pBlockInfo);
+bool inCalSlidingWindow(SInterval* pInterval, STimeWindow* pWin, TSKEY calStart, TSKEY calEnd, EStreamType blockType);
+bool compareVal(const char* v, const SStateKeys* pKey);
+
+int32_t getNextQualifiedWindow(SInterval* pInterval, STimeWindow* pNext, SDataBlockInfo* pDataBlockInfo,
+                                      TSKEY* primaryKeys, int32_t prevPosition, int32_t order);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/libs/executor/src/eventwindowoperator.c b/source/libs/executor/src/eventwindowoperator.c
index bbdc50183e..5c335c116f 100644
--- a/source/libs/executor/src/eventwindowoperator.c
+++ b/source/libs/executor/src/eventwindowoperator.c
@@ -58,16 +58,6 @@ static void doKeepTuple(SWindowRowsSup* pRowSup, int64_t ts, uint64_t groupId) {
   pRowSup->groupId = groupId;
 }
 
-static void updateTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pWin, bool includeEndpoint) {
-  int64_t* ts = (int64_t*)pColData->pData;
-  int32_t  delta = includeEndpoint ? 1 : 0;
-
-  int64_t duration = pWin->ekey - pWin->skey + delta;
-  ts[2] = duration;            // set the duration
-  ts[3] = pWin->skey;          // window start key
-  ts[4] = pWin->ekey + delta;  // window end key
-}
-
 SOperatorInfo* createEventwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* physiNode,
                                              SExecTaskInfo* pTaskInfo) {
   SEventWindowOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SEventWindowOperatorInfo));
@@ -250,7 +240,7 @@ static void doEventWindowAggImpl(SEventWindowOperatorInfo* pInfo, SExprSupp* pSu
     T_LONG_JMP(pTaskInfo->env, TSDB_CODE_APP_ERROR);
   }
 
-  updateTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pRowSup->win, false);
+  updateTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pRowSup->win, 0);
   applyAggFunctionOnPartialTuples(pTaskInfo, pSup->pCtx, &pInfo->twAggSup.timeWindowData, startIndex, numOfRows,
                                   pBlock->info.rows, numOfOutput);
 }
diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c
index 057847e57a..c4f03c5779 100644
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@@ -1675,6 +1675,7 @@ SInterval extractIntervalInfo(const STableScanPhysiNode* pTableScanNode) {
       .intervalUnit = pTableScanNode->intervalUnit,
       .slidingUnit = pTableScanNode->slidingUnit,
       .offset = pTableScanNode->offset,
+      .precision = pTableScanNode->scan.node.pOutputDataBlockDesc->precision,
   };
 
   return interval;
@@ -2176,12 +2177,67 @@ int32_t createScanTableListInfo(SScanPhysiNode* pScanNode, SNodeList* pGroupTags
   return TSDB_CODE_SUCCESS;
 }
 
-void printDataBlock(SSDataBlock* pBlock, const char* flag) {
+char* getStreamOpName(uint16_t opType) {
+  switch (opType) {
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN:
+      return "stream scan";
+    case QUERY_NODE_PHYSICAL_PLAN_PROJECT:
+      return "project";
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL:
+      return "interval single";
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL:
+      return "interval final";
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL:
+      return "interval semi";
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL:
+      return "stream fill";
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION:
+      return "session single";
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION:
+      return "session semi";
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION:
+      return "session final";
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE:
+      return "state single";
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION:
+      return "stream partitionby";
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT:
+      return "stream event";
+  }
+  return "";
+}
+
+void printDataBlock(SSDataBlock* pBlock, const char* flag, const char* taskIdStr) {
   if (!pBlock || pBlock->info.rows == 0) {
-    qDebug("===stream===%s: Block is Null or Empty", flag);
+    qDebug("%s===stream===%s: Block is Null or Empty", taskIdStr, flag);
     return;
   }
   char* pBuf = NULL;
-  qDebug("%s", dumpBlockData(pBlock, flag, &pBuf));
+  qDebug("%s", dumpBlockData(pBlock, flag, &pBuf, taskIdStr));
   taosMemoryFree(pBuf);
 }
+
+void printSpecDataBlock(SSDataBlock* pBlock, const char* flag, const char* opStr, const char* taskIdStr) {
+  if (!pBlock || pBlock->info.rows == 0) {
+    qDebug("%s===stream===%s: Block is Null or Empty", taskIdStr, flag);
+    return;
+  }
+  if (qDebugFlag & DEBUG_DEBUG) {
+    char* pBuf = NULL;
+    char flagBuf[64];
+    snprintf(flagBuf, sizeof(flagBuf), "%s %s", flag, opStr);
+    qDebug("%s", dumpBlockData(pBlock, flagBuf, &pBuf, taskIdStr));
+    taosMemoryFree(pBuf);
+  }
+}
+
+TSKEY getStartTsKey(STimeWindow* win, const TSKEY* tsCols) { return tsCols == NULL ? win->skey : tsCols[0]; }
+
+void updateTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pWin, int64_t  delta) {
+  int64_t* ts = (int64_t*)pColData->pData;
+
+  int64_t duration = pWin->ekey - pWin->skey + delta;
+  ts[2] = duration;            // set the duration
+  ts[3] = pWin->skey;          // window start key
+  ts[4] = pWin->ekey + delta;  // window end key
+}
diff --git a/source/libs/executor/src/executor.c b/source/libs/executor/src/executor.c
index a6059c7c42..0ad2b9c116 100644
--- a/source/libs/executor/src/executor.c
+++ b/source/libs/executor/src/executor.c
@@ -589,6 +589,10 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bo
   int64_t st = taosGetTimestampUs();
 
   int32_t blockIndex = 0;
+  int32_t rowsThreshold = pTaskInfo->pSubplan->rowsThreshold;
+  if (!pTaskInfo->pSubplan->dynamicRowThreshold || 4096 <= pTaskInfo->pSubplan->rowsThreshold) {
+    rowsThreshold = 4096;
+  }
   while ((pRes = pTaskInfo->pRoot->fpSet.getNextFn(pTaskInfo->pRoot)) != NULL) {
     SSDataBlock* p = NULL;
     if (blockIndex >= taosArrayGetSize(pTaskInfo->pResultBlockList)) {
@@ -606,10 +610,13 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bo
     ASSERT(p->info.rows > 0);
     taosArrayPush(pResList, &p);
 
-    if (current >= 4096) {
+    if (current >= rowsThreshold) {
       break;
     }
   }
+  if (pTaskInfo->pSubplan->dynamicRowThreshold) {
+    pTaskInfo->pSubplan->rowsThreshold -= current;
+  }
 
   *hasMore = (pRes != NULL);
   uint64_t el = (taosGetTimestampUs() - st);
diff --git a/source/libs/executor/src/executorInt.c b/source/libs/executor/src/executorInt.c
index ebec9aa94e..a7f0e02815 100644
--- a/source/libs/executor/src/executorInt.c
+++ b/source/libs/executor/src/executorInt.c
@@ -1070,3 +1070,15 @@ void streamOpReloadState(SOperatorInfo* pOperator) {
     downstream->fpSet.reloadStreamStateFn(downstream);
   }
 }
+
+bool compareVal(const char* v, const SStateKeys* pKey) {
+  if (IS_VAR_DATA_TYPE(pKey->type)) {
+    if (varDataLen(v) != varDataLen(pKey->pData)) {
+      return false;
+    } else {
+      return memcmp(varDataVal(v), varDataVal(pKey->pData), varDataLen(v)) == 0;
+    }
+  } else {
+    return memcmp(pKey->pData, v, pKey->bytes) == 0;
+  }
+}
diff --git a/source/libs/executor/src/filloperator.c b/source/libs/executor/src/filloperator.c
index 80c88a803e..1788027bd6 100644
--- a/source/libs/executor/src/filloperator.c
+++ b/source/libs/executor/src/filloperator.c
@@ -1292,14 +1292,14 @@ static SSDataBlock* doStreamFill(SOperatorInfo* pOperator) {
       (pInfo->pFillInfo->pos != FILL_POS_INVALID && pInfo->pFillInfo->needFill == true)) {
     doStreamFillRange(pInfo->pFillInfo, pInfo->pFillSup, pInfo->pRes);
     if (pInfo->pRes->info.rows > 0) {
-      printDataBlock(pInfo->pRes, "stream fill");
+      printDataBlock(pInfo->pRes, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));
       return pInfo->pRes;
     }
   }
   if (pOperator->status == OP_RES_TO_RETURN) {
     doDeleteFillFinalize(pOperator);
     if (pInfo->pRes->info.rows > 0) {
-      printDataBlock(pInfo->pRes, "stream fill");
+      printDataBlock(pInfo->pRes, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));
       return pInfo->pRes;
     }
     setOperatorCompleted(pOperator);
@@ -1317,12 +1317,12 @@ static SSDataBlock* doStreamFill(SOperatorInfo* pOperator) {
         pOperator->status = OP_RES_TO_RETURN;
         pInfo->pFillInfo->preRowKey = INT64_MIN;
         if (pInfo->pRes->info.rows > 0) {
-          printDataBlock(pInfo->pRes, "stream fill");
+          printDataBlock(pInfo->pRes, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));
           return pInfo->pRes;
         }
         break;
       }
-      printDataBlock(pBlock, "stream fill recv");
+      printSpecDataBlock(pBlock, getStreamOpName(pOperator->operatorType), "recv", GET_TASKID(pTaskInfo));
 
       if (pInfo->pFillInfo->curGroupId != pBlock->info.id.groupId) {
         pInfo->pFillInfo->curGroupId = pBlock->info.id.groupId;
@@ -1339,7 +1339,7 @@ static SSDataBlock* doStreamFill(SOperatorInfo* pOperator) {
           pInfo->pFillSup->hasDelete = true;
           doDeleteFillResult(pOperator);
           if (pInfo->pDelRes->info.rows > 0) {
-            printDataBlock(pInfo->pDelRes, "stream fill delete");
+            printDataBlock(pInfo->pDelRes, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));
             return pInfo->pDelRes;
           }
           continue;
@@ -1378,7 +1378,7 @@ static SSDataBlock* doStreamFill(SOperatorInfo* pOperator) {
   }
 
   pOperator->resultInfo.totalRows += pInfo->pRes->info.rows;
-  printDataBlock(pInfo->pRes, "stream fill");
+  printDataBlock(pInfo->pRes, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));
   return pInfo->pRes;
 }
 
diff --git a/source/libs/executor/src/groupoperator.c b/source/libs/executor/src/groupoperator.c
index 9228c923a6..d097c58835 100644
--- a/source/libs/executor/src/groupoperator.c
+++ b/source/libs/executor/src/groupoperator.c
@@ -956,7 +956,8 @@ static bool hasRemainPartion(SStreamPartitionOperatorInfo* pInfo) { return pInfo
 static bool hasRemainTbName(SStreamPartitionOperatorInfo* pInfo) { return pInfo->pTbNameIte != NULL; }
 
 static SSDataBlock* buildStreamPartitionResult(SOperatorInfo* pOperator) {
-  SStorageAPI* pAPI = &pOperator->pTaskInfo->storageAPI;
+  SStorageAPI*   pAPI = &pOperator->pTaskInfo->storageAPI;
+  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
 
   SStreamPartitionOperatorInfo* pInfo = pOperator->info;
   SSDataBlock*                  pDest = pInfo->binfo.pRes;
@@ -994,7 +995,7 @@ static SSDataBlock* buildStreamPartitionResult(SOperatorInfo* pOperator) {
   pOperator->resultInfo.totalRows += pDest->info.rows;
   pInfo->parIte = taosHashIterate(pInfo->pPartitions, pInfo->parIte);
   ASSERT(pDest->info.rows > 0);
-  printDataBlock(pDest, "stream partitionby");
+  printDataBlock(pDest, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));
   return pDest;
 }
 
@@ -1115,7 +1116,7 @@ static SSDataBlock* doStreamHashPartition(SOperatorInfo* pOperator) {
       setOperatorCompleted(pOperator);
       return NULL;
     }
-    printDataBlock(pBlock, "stream partitionby recv");
+    printSpecDataBlock(pBlock, getStreamOpName(pOperator->operatorType), "recv", GET_TASKID(pTaskInfo));
     switch (pBlock->info.type) {
       case STREAM_NORMAL:
       case STREAM_PULL_DATA:
@@ -1125,7 +1126,7 @@ static SSDataBlock* doStreamHashPartition(SOperatorInfo* pOperator) {
       case STREAM_DELETE_DATA: {
         copyDataBlock(pInfo->pDelRes, pBlock);
         pInfo->pDelRes->info.type = STREAM_DELETE_RESULT;
-        printDataBlock(pInfo->pDelRes, "stream partitionby delete");
+        printDataBlock(pInfo->pDelRes, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));
         return pInfo->pDelRes;
       } break;
       default:
diff --git a/source/libs/executor/src/projectoperator.c b/source/libs/executor/src/projectoperator.c
index 1cc377b3ee..8e31bc042f 100644
--- a/source/libs/executor/src/projectoperator.c
+++ b/source/libs/executor/src/projectoperator.c
@@ -372,6 +372,10 @@ SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) {
     pOperator->cost.openCost = (taosGetTimestampUs() - st) / 1000.0;
   }
 
+  if (pTaskInfo->execModel == OPTR_EXEC_MODEL_STREAM) {
+    printDataBlock(p, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));
+  }
+
   return (p->info.rows > 0) ? p : NULL;
 }
 
diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c
index 4caa604c3e..bdf9719388 100644
--- a/source/libs/executor/src/scanoperator.c
+++ b/source/libs/executor/src/scanoperator.c
@@ -1343,7 +1343,7 @@ static int32_t generateIntervalScanRange(SStreamScanInfo* pInfo, SSDataBlock* pS
   if (rows == 0) {
     return TSDB_CODE_SUCCESS;
   }
-
+  SExecTaskInfo*   pTaskInfo = pInfo->pStreamScanOp->pTaskInfo;
   SColumnInfoData* pSrcStartTsCol = (SColumnInfoData*)taosArrayGet(pSrcBlock->pDataBlock, START_TS_COLUMN_INDEX);
   SColumnInfoData* pSrcEndTsCol = (SColumnInfoData*)taosArrayGet(pSrcBlock->pDataBlock, END_TS_COLUMN_INDEX);
   SColumnInfoData* pSrcUidCol = taosArrayGet(pSrcBlock->pDataBlock, UID_COLUMN_INDEX);
@@ -1360,7 +1360,7 @@ static int32_t generateIntervalScanRange(SStreamScanInfo* pInfo, SSDataBlock* pS
     TSKEY        startTs = srcStartTsCol[0];
     TSKEY        endTs = srcEndTsCol[0];
     SSDataBlock* pPreRes = readPreVersionData(pInfo->pTableScanOp, srcUid, startTs, endTs, ver);
-    printDataBlock(pPreRes, "pre res");
+    printDataBlock(pPreRes, "pre res", GET_TASKID(pTaskInfo));
     blockDataCleanup(pSrcBlock);
     int32_t code = blockDataEnsureCapacity(pSrcBlock, pPreRes->info.rows);
     if (code != TSDB_CODE_SUCCESS) {
@@ -1375,7 +1375,7 @@ static int32_t generateIntervalScanRange(SStreamScanInfo* pInfo, SSDataBlock* pS
       appendOneRowToStreamSpecialBlock(pSrcBlock, ((TSKEY*)pTsCol->pData) + i, ((TSKEY*)pTsCol->pData) + i, &srcUid,
                                        &groupId, NULL);
     }
-    printDataBlock(pSrcBlock, "new delete");
+    printDataBlock(pSrcBlock, "new delete", GET_TASKID(pTaskInfo));
   }
   uint64_t* srcGp = (uint64_t*)pSrcGpCol->pData;
   srcStartTsCol = (TSKEY*)pSrcStartTsCol->pData;
@@ -1921,38 +1921,9 @@ static SSDataBlock* doStreamScan(SOperatorInfo* pOperator) {
     switch (pInfo->scanMode) {
       case STREAM_SCAN_FROM_RES: {
         pInfo->scanMode = STREAM_SCAN_FROM_READERHANDLE;
-        printDataBlock(pInfo->pRecoverRes, "scan recover");
+        printSpecDataBlock(pInfo->pRecoverRes, getStreamOpName(pOperator->operatorType), "recover", GET_TASKID(pTaskInfo));
         return pInfo->pRecoverRes;
       } break;
-      // case STREAM_SCAN_FROM_UPDATERES: {
-      //   generateScanRange(pInfo, pInfo->pUpdateDataRes, pInfo->pUpdateRes);
-      //   prepareRangeScan(pInfo, pInfo->pUpdateRes, &pInfo->updateResIndex);
-      //   pInfo->scanMode = STREAM_SCAN_FROM_DATAREADER_RANGE;
-      //   printDataBlock(pInfo->pUpdateRes, "recover update");
-      //   return pInfo->pUpdateRes;
-      // } break;
-      // case STREAM_SCAN_FROM_DELETE_DATA: {
-      //   generateScanRange(pInfo, pInfo->pUpdateDataRes, pInfo->pUpdateRes);
-      //   prepareRangeScan(pInfo, pInfo->pUpdateRes, &pInfo->updateResIndex);
-      //   pInfo->scanMode = STREAM_SCAN_FROM_DATAREADER_RANGE;
-      //   copyDataBlock(pInfo->pDeleteDataRes, pInfo->pUpdateRes);
-      //   pInfo->pDeleteDataRes->info.type = STREAM_DELETE_DATA;
-      //   printDataBlock(pInfo->pDeleteDataRes, "recover delete");
-      //   return pInfo->pDeleteDataRes;
-      // } break;
-      // case STREAM_SCAN_FROM_DATAREADER_RANGE: {
-      //   SSDataBlock* pSDB = doRangeScan(pInfo, pInfo->pUpdateRes, pInfo->primaryTsIndex, &pInfo->updateResIndex);
-      //   if (pSDB) {
-      //     STableScanInfo* pTableScanInfo = pInfo->pTableScanOp->info;
-      //     pSDB->info.type = pInfo->scanMode == STREAM_SCAN_FROM_DATAREADER_RANGE ? STREAM_NORMAL : STREAM_PULL_DATA;
-      //     checkUpdateData(pInfo, true, pSDB, false);
-      //     printDataBlock(pSDB, "scan recover update");
-      //     calBlockTbName(pInfo, pSDB);
-      //     return pSDB;
-      //   }
-      //   blockDataCleanup(pInfo->pUpdateDataRes);
-      //   pInfo->scanMode = STREAM_SCAN_FROM_READERHANDLE;
-      // } break;
       default:
         break;
     }
@@ -1961,22 +1932,17 @@ static SSDataBlock* doStreamScan(SOperatorInfo* pOperator) {
     if (pInfo->pRecoverRes != NULL) {
       calBlockTbName(pInfo, pInfo->pRecoverRes);
       if (!pInfo->igCheckUpdate && pInfo->pUpdateInfo) {
-        // if (pStreamInfo->recoverStep == STREAM_RECOVER_STEP__SCAN1) {
         TSKEY maxTs = pAPI->stateStore.updateInfoFillBlockData(pInfo->pUpdateInfo, pInfo->pRecoverRes, pInfo->primaryTsIndex);
         pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, maxTs);
-        // } else {
-        //   pInfo->pUpdateInfo->maxDataVersion = TMAX(pInfo->pUpdateInfo->maxDataVersion, pStreamInfo->fillHistoryVer.maxVer);
-        //   doCheckUpdate(pInfo, pInfo->pRecoverRes->info.window.ekey, pInfo->pRecoverRes);
-        // }
       }
       if (pInfo->pCreateTbRes->info.rows > 0) {
         pInfo->scanMode = STREAM_SCAN_FROM_RES;
-        printDataBlock(pInfo->pCreateTbRes, "recover createTbl");
+        printSpecDataBlock(pInfo->pCreateTbRes, getStreamOpName(pOperator->operatorType), "recover", GET_TASKID(pTaskInfo));
         return pInfo->pCreateTbRes;
       }
 
       qDebug("stream recover scan get block, rows %" PRId64, pInfo->pRecoverRes->info.rows);
-      printDataBlock(pInfo->pRecoverRes, "scan recover");
+      printSpecDataBlock(pInfo->pRecoverRes, getStreamOpName(pOperator->operatorType), "recover", GET_TASKID(pTaskInfo));
       return pInfo->pRecoverRes;
     }
     pStreamInfo->recoverStep = STREAM_RECOVER_STEP__NONE;
@@ -2032,7 +1998,7 @@ FETCH_NEXT_BLOCK:
         pAPI->stateStore.updateInfoAddCloseWindowSBF(pInfo->pUpdateInfo);
       } break;
       case STREAM_DELETE_DATA: {
-        printDataBlock(pBlock, "stream scan delete recv");
+        printSpecDataBlock(pBlock, getStreamOpName(pOperator->operatorType), "delete recv", GET_TASKID(pTaskInfo));
         SSDataBlock* pDelBlock = NULL;
         if (pInfo->tqReader) {
           pDelBlock = createSpecialDataBlock(STREAM_DELETE_DATA);
@@ -2043,7 +2009,7 @@ FETCH_NEXT_BLOCK:
 
         setBlockGroupIdByUid(pInfo, pDelBlock);
         rebuildDeleteBlockData(pDelBlock, &pStreamInfo->fillHistoryWindow, id);
-        printDataBlock(pDelBlock, "stream scan delete recv filtered");
+        printSpecDataBlock(pDelBlock, getStreamOpName(pOperator->operatorType), "delete recv filtered", GET_TASKID(pTaskInfo));
         if (pDelBlock->info.rows == 0) {
           if (pInfo->tqReader) {
             blockDataDestroy(pDelBlock);
@@ -2054,7 +2020,7 @@ FETCH_NEXT_BLOCK:
         if (!isIntervalWindow(pInfo) && !isSessionWindow(pInfo) && !isStateWindow(pInfo)) {
           generateDeleteResultBlock(pInfo, pDelBlock, pInfo->pDeleteDataRes);
           pInfo->pDeleteDataRes->info.type = STREAM_DELETE_RESULT;
-          printDataBlock(pDelBlock, "stream scan delete result");
+          printSpecDataBlock(pDelBlock, getStreamOpName(pOperator->operatorType), "delete result", GET_TASKID(pTaskInfo));
           blockDataDestroy(pDelBlock);
 
           if (pInfo->pDeleteDataRes->info.rows > 0) {
@@ -2069,7 +2035,7 @@ FETCH_NEXT_BLOCK:
           prepareRangeScan(pInfo, pInfo->pUpdateRes, &pInfo->updateResIndex);
           copyDataBlock(pInfo->pDeleteDataRes, pInfo->pUpdateRes);
           pInfo->pDeleteDataRes->info.type = STREAM_DELETE_DATA;
-          printDataBlock(pDelBlock, "stream scan delete data");
+          printSpecDataBlock(pDelBlock, getStreamOpName(pOperator->operatorType), "delete result", GET_TASKID(pTaskInfo));
           if (pInfo->tqReader) {
             blockDataDestroy(pDelBlock);
           }
@@ -2084,7 +2050,7 @@ FETCH_NEXT_BLOCK:
       default:
         break;
     }
-    // printDataBlock(pBlock, "stream scan recv");
+    printDataBlock(pBlock, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));
     return pBlock;
   } else if (pInfo->blockType == STREAM_INPUT__DATA_SUBMIT) {
     qDebug("stream scan mode:%d, %s", pInfo->scanMode, id);
@@ -2120,7 +2086,7 @@ FETCH_NEXT_BLOCK:
           STableScanInfo* pTableScanInfo = pInfo->pTableScanOp->info;
           pSDB->info.type = pInfo->scanMode == STREAM_SCAN_FROM_DATAREADER_RANGE ? STREAM_NORMAL : STREAM_PULL_DATA;
           checkUpdateData(pInfo, true, pSDB, false);
-          printDataBlock(pSDB, "stream scan update");
+          printSpecDataBlock(pSDB, getStreamOpName(pOperator->operatorType), "update", GET_TASKID(pTaskInfo));
           calBlockTbName(pInfo, pSDB);
           return pSDB;
         }
diff --git a/source/libs/executor/src/streamtimewindowoperator.c b/source/libs/executor/src/streamtimewindowoperator.c
new file mode 100644
index 0000000000..a718373f60
--- /dev/null
+++ b/source/libs/executor/src/streamtimewindowoperator.c
@@ -0,0 +1,3195 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "executorInt.h"
+#include "filter.h"
+#include "function.h"
+#include "functionMgt.h"
+#include "operator.h"
+#include "querytask.h"
+#include "tcommon.h"
+#include "tcompare.h"
+#include "tdatablock.h"
+#include "tfill.h"
+#include "tglobal.h"
+#include "tlog.h"
+#include "ttime.h"
+
+#define IS_FINAL_INTERVAL_OP(op)      ((op)->operatorType == QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL)
+#define IS_FINAL_SESSION_OP(op)       ((op)->operatorType == QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION)
+#define DEAULT_DELETE_MARK            (1000LL * 60LL * 60LL * 24LL * 365LL * 10LL);
+#define STREAM_INTERVAL_OP_STATE_NAME "StreamIntervalHistoryState"
+#define STREAM_SESSION_OP_STATE_NAME  "StreamSessionHistoryState"
+#define STREAM_STATE_OP_STATE_NAME    "StreamStateHistoryState"
+
+typedef struct SStateWindowInfo {
+  SResultWindowInfo winInfo;
+  SStateKeys*       pStateKey;
+} SStateWindowInfo;
+
+typedef struct SPullWindowInfo {
+  STimeWindow window;
+  uint64_t    groupId;
+  STimeWindow calWin;
+} SPullWindowInfo;
+
+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) {
+  int firstPos = 0, lastPos = num - 1, midPos = -1;
+  int numOfRows = 0;
+
+  if (num <= 0) return -1;
+  if (order == TSDB_ORDER_DESC) {
+    // find the first position which is smaller or equal than the key
+    while (1) {
+      if (comparefn(pKey, keyList, lastPos) >= 0) return lastPos;
+      if (comparefn(pKey, keyList, firstPos) == 0) return firstPos;
+      if (comparefn(pKey, keyList, firstPos) < 0) return firstPos - 1;
+
+      numOfRows = lastPos - firstPos + 1;
+      midPos = (numOfRows >> 1) + firstPos;
+
+      if (comparefn(pKey, keyList, midPos) < 0) {
+        lastPos = midPos - 1;
+      } else if (comparefn(pKey, keyList, midPos) > 0) {
+        firstPos = midPos + 1;
+      } else {
+        break;
+      }
+    }
+
+  } else {
+    // find the first position which is bigger or equal than the key
+    while (1) {
+      if (comparefn(pKey, keyList, firstPos) <= 0) return firstPos;
+      if (comparefn(pKey, keyList, lastPos) == 0) return lastPos;
+
+      if (comparefn(pKey, keyList, lastPos) > 0) {
+        lastPos = lastPos + 1;
+        if (lastPos >= num)
+          return -1;
+        else
+          return lastPos;
+      }
+
+      numOfRows = lastPos - firstPos + 1;
+      midPos = (numOfRows >> 1) + firstPos;
+
+      if (comparefn(pKey, keyList, midPos) < 0) {
+        lastPos = midPos - 1;
+      } else if (comparefn(pKey, keyList, midPos) > 0) {
+        firstPos = midPos + 1;
+      } else {
+        break;
+      }
+    }
+  }
+
+  return midPos;
+}
+
+static int32_t comparePullWinKey(void* pKey, void* data, int32_t index) {
+  SArray*          res = (SArray*)data;
+  SPullWindowInfo* pos = taosArrayGet(res, index);
+  SPullWindowInfo* pData = (SPullWindowInfo*)pKey;
+  if (pData->groupId > pos->groupId) {
+    return 1;
+  } else if (pData->groupId < pos->groupId) {
+    return -1;
+  }
+
+  if (pData->window.skey > pos->window.ekey) {
+    return 1;
+  } else if (pData->window.ekey < pos->window.skey) {
+    return -1;
+  }
+  return 0;
+}
+
+static int32_t savePullWindow(SPullWindowInfo* pPullInfo, SArray* pPullWins) {
+  int32_t size = taosArrayGetSize(pPullWins);
+  int32_t index = binarySearchCom(pPullWins, size, pPullInfo, TSDB_ORDER_DESC, comparePullWinKey);
+  if (index == -1) {
+    index = 0;
+  } else {
+    int32_t code = comparePullWinKey(pPullInfo, pPullWins, index);
+    if (code == 0) {
+      SPullWindowInfo* pos = taosArrayGet(pPullWins, index);
+      pos->window.skey = TMIN(pos->window.skey, pPullInfo->window.skey);
+      pos->window.ekey = TMAX(pos->window.ekey, pPullInfo->window.ekey);
+      pos->calWin.skey = TMIN(pos->calWin.skey, pPullInfo->calWin.skey);
+      pos->calWin.ekey = TMAX(pos->calWin.ekey, pPullInfo->calWin.ekey);
+      return TSDB_CODE_SUCCESS;
+    } else if (code > 0) {
+      index++;
+    }
+  }
+  if (taosArrayInsert(pPullWins, index, pPullInfo) == NULL) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t saveResult(SResultWindowInfo winInfo, SSHashObj* pStUpdated) {
+  winInfo.sessionWin.win.ekey = winInfo.sessionWin.win.skey;
+  return tSimpleHashPut(pStUpdated, &winInfo.sessionWin, sizeof(SSessionKey), &winInfo, sizeof(SResultWindowInfo));
+}
+
+static int32_t saveWinResult(SWinKey* pKey, SRowBuffPos* pPos, SSHashObj* pUpdatedMap) {
+  tSimpleHashPut(pUpdatedMap, pKey, sizeof(SWinKey), &pPos, POINTER_BYTES);
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t saveWinResultInfo(TSKEY ts, uint64_t groupId, SRowBuffPos* pPos, SSHashObj* pUpdatedMap) {
+  SWinKey key = {.ts = ts, .groupId = groupId};
+  saveWinResult(&key, pPos, pUpdatedMap);
+  return TSDB_CODE_SUCCESS;
+}
+
+static void removeResults(SArray* pWins, SSHashObj* pUpdatedMap) {
+  int32_t size = taosArrayGetSize(pWins);
+  for (int32_t i = 0; i < size; i++) {
+    SWinKey* pW = taosArrayGet(pWins, i);
+    void*    tmp = tSimpleHashGet(pUpdatedMap, pW, sizeof(SWinKey));
+    if (tmp) {
+      void* value = *(void**)tmp;
+      taosMemoryFree(value);
+      tSimpleHashRemove(pUpdatedMap, pW, sizeof(SWinKey));
+    }
+  }
+}
+
+static int32_t compareWinKey(void* pKey, void* data, int32_t index) {
+  void* pDataPos = taosArrayGet((SArray*)data, index);
+  return winKeyCmprImpl(pKey, pDataPos);
+}
+
+static void removeDeleteResults(SSHashObj* pUpdatedMap, SArray* pDelWins) {
+  taosArraySort(pDelWins, winKeyCmprImpl);
+  taosArrayRemoveDuplicate(pDelWins, winKeyCmprImpl, NULL);
+  int32_t delSize = taosArrayGetSize(pDelWins);
+  if (tSimpleHashGetSize(pUpdatedMap) == 0 || delSize == 0) {
+    return;
+  }
+  void*   pIte = NULL;
+  int32_t iter = 0;
+  while ((pIte = tSimpleHashIterate(pUpdatedMap, pIte, &iter)) != NULL) {
+    SWinKey* pResKey = tSimpleHashGetKey(pIte, NULL);
+    int32_t  index = binarySearchCom(pDelWins, delSize, pResKey, TSDB_ORDER_DESC, compareWinKey);
+    if (index >= 0 && 0 == compareWinKey(pResKey, pDelWins, index)) {
+      taosArrayRemove(pDelWins, index);
+      delSize = taosArrayGetSize(pDelWins);
+    }
+  }
+}
+
+bool isOverdue(TSKEY ekey, STimeWindowAggSupp* pTwSup) {
+  ASSERTS(pTwSup->maxTs == INT64_MIN || pTwSup->maxTs > 0, "maxts should greater than 0");
+  return pTwSup->maxTs != INT64_MIN && ekey < pTwSup->maxTs - pTwSup->waterMark;
+}
+
+bool isCloseWindow(STimeWindow* pWin, STimeWindowAggSupp* pTwSup) { return isOverdue(pWin->ekey, pTwSup); }
+
+static bool doDeleteWindow(SOperatorInfo* pOperator, TSKEY ts, uint64_t groupId) {
+  SStorageAPI* pAPI = &pOperator->pTaskInfo->storageAPI;
+
+  SStreamIntervalOperatorInfo* pInfo = pOperator->info;
+  SWinKey                      key = {.ts = ts, .groupId = groupId};
+  tSimpleHashRemove(pInfo->aggSup.pResultRowHashTable, &key, sizeof(SWinKey));
+  pAPI->stateStore.streamStateDel(pInfo->pState, &key);
+  return true;
+}
+
+static int32_t getChildIndex(SSDataBlock* pBlock) { return pBlock->info.childId; }
+
+static void doDeleteWindows(SOperatorInfo* pOperator, SInterval* pInterval, SSDataBlock* pBlock, SArray* pUpWins,
+                            SSHashObj* pUpdatedMap) {
+  SStreamIntervalOperatorInfo* pInfo = pOperator->info;
+  SColumnInfoData*             pStartTsCol = taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX);
+  TSKEY*                       startTsCols = (TSKEY*)pStartTsCol->pData;
+  SColumnInfoData*             pEndTsCol = taosArrayGet(pBlock->pDataBlock, END_TS_COLUMN_INDEX);
+  TSKEY*                       endTsCols = (TSKEY*)pEndTsCol->pData;
+  SColumnInfoData*             pCalStTsCol = taosArrayGet(pBlock->pDataBlock, CALCULATE_START_TS_COLUMN_INDEX);
+  TSKEY*                       calStTsCols = (TSKEY*)pCalStTsCol->pData;
+  SColumnInfoData*             pCalEnTsCol = taosArrayGet(pBlock->pDataBlock, CALCULATE_END_TS_COLUMN_INDEX);
+  TSKEY*                       calEnTsCols = (TSKEY*)pCalEnTsCol->pData;
+  SColumnInfoData*             pGpCol = taosArrayGet(pBlock->pDataBlock, GROUPID_COLUMN_INDEX);
+  uint64_t*                    pGpDatas = (uint64_t*)pGpCol->pData;
+  for (int32_t i = 0; i < pBlock->info.rows; i++) {
+    SResultRowInfo dumyInfo = {0};
+    dumyInfo.cur.pageId = -1;
+
+    STimeWindow win = {0};
+    if (IS_FINAL_INTERVAL_OP(pOperator)) {
+      win.skey = startTsCols[i];
+      win.ekey = endTsCols[i];
+    } else {
+      win = getActiveTimeWindow(NULL, &dumyInfo, startTsCols[i], pInterval, TSDB_ORDER_ASC);
+    }
+
+    do {
+      if (!inCalSlidingWindow(pInterval, &win, calStTsCols[i], calEnTsCols[i], pBlock->info.type)) {
+        getNextTimeWindow(pInterval, &win, TSDB_ORDER_ASC);
+        continue;
+      }
+      uint64_t winGpId = pGpDatas[i];
+      SWinKey  winRes = {.ts = win.skey, .groupId = winGpId};
+      void*    chIds = taosHashGet(pInfo->pPullDataMap, &winRes, sizeof(SWinKey));
+      if (chIds) {
+        int32_t childId = getChildIndex(pBlock);
+        SArray* chArray = *(void**)chIds;
+        int32_t index = taosArraySearchIdx(chArray, &childId, compareInt32Val, TD_EQ);
+        if (index != -1) {
+          qDebug("===stream===try push delete window%" PRId64 "chId:%d ,continue", win.skey, childId);
+          getNextTimeWindow(pInterval, &win, TSDB_ORDER_ASC);
+          continue;
+        }
+      }
+      bool res = doDeleteWindow(pOperator, win.skey, winGpId);
+      if (pUpWins && res) {
+        taosArrayPush(pUpWins, &winRes);
+      }
+      if (pUpdatedMap) {
+        tSimpleHashRemove(pUpdatedMap, &winRes, sizeof(SWinKey));
+      }
+      getNextTimeWindow(pInterval, &win, TSDB_ORDER_ASC);
+    } while (win.ekey <= endTsCols[i]);
+  }
+}
+
+static int32_t getAllIntervalWindow(SSHashObj* pHashMap, SSHashObj* resWins) {
+  void*   pIte = NULL;
+  int32_t iter = 0;
+  while ((pIte = tSimpleHashIterate(pHashMap, pIte, &iter)) != NULL) {
+    SWinKey* pKey = tSimpleHashGetKey(pIte, NULL);
+    uint64_t groupId = pKey->groupId;
+    TSKEY    ts = pKey->ts;
+    int32_t  code = saveWinResultInfo(ts, groupId, *(SRowBuffPos**)pIte, resWins);
+    if (code != TSDB_CODE_SUCCESS) {
+      return code;
+    }
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t closeStreamIntervalWindow(SSHashObj* pHashMap, STimeWindowAggSupp* pTwSup, SInterval* pInterval,
+                                         SHashObj* pPullDataMap, SSHashObj* closeWins, SArray* pDelWins,
+                                         SOperatorInfo* pOperator) {
+  qDebug("===stream===close interval window");
+  void*                        pIte = NULL;
+  int32_t                      iter = 0;
+  SStreamIntervalOperatorInfo* pInfo = pOperator->info;
+  int32_t                      delSize = taosArrayGetSize(pDelWins);
+  while ((pIte = tSimpleHashIterate(pHashMap, pIte, &iter)) != NULL) {
+    void*    key = tSimpleHashGetKey(pIte, NULL);
+    SWinKey* pWinKey = (SWinKey*)key;
+    if (delSize > 0) {
+      int32_t index = binarySearchCom(pDelWins, delSize, pWinKey, TSDB_ORDER_DESC, compareWinKey);
+      if (index >= 0 && 0 == compareWinKey(pWinKey, pDelWins, index)) {
+        taosArrayRemove(pDelWins, index);
+        delSize = taosArrayGetSize(pDelWins);
+      }
+    }
+
+    void*       chIds = taosHashGet(pPullDataMap, pWinKey, sizeof(SWinKey));
+    STimeWindow win = {
+        .skey = pWinKey->ts,
+        .ekey = taosTimeAdd(win.skey, pInterval->interval, pInterval->intervalUnit, pInterval->precision) - 1,
+    };
+    if (isCloseWindow(&win, pTwSup)) {
+      if (chIds && pPullDataMap) {
+        SArray* chAy = *(SArray**)chIds;
+        int32_t size = taosArrayGetSize(chAy);
+        qDebug("===stream===window %" PRId64 " wait child size:%d", pWinKey->ts, size);
+        for (int32_t i = 0; i < size; i++) {
+          qDebug("===stream===window %" PRId64 " wait child id:%d", pWinKey->ts, *(int32_t*)taosArrayGet(chAy, i));
+        }
+        continue;
+      } else if (pPullDataMap) {
+        qDebug("===stream===close window %" PRId64, pWinKey->ts);
+      }
+
+      if (pTwSup->calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) {
+        int32_t code = saveWinResult(pWinKey, *(SRowBuffPos**)pIte, closeWins);
+        if (code != TSDB_CODE_SUCCESS) {
+          return code;
+        }
+      }
+      tSimpleHashIterateRemove(pHashMap, pWinKey, sizeof(SWinKey), &pIte, &iter);
+    }
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
+STimeWindow getFinalTimeWindow(int64_t ts, SInterval* pInterval) {
+  STimeWindow w = {.skey = ts, .ekey = INT64_MAX};
+  w.ekey = taosTimeAdd(w.skey, pInterval->interval, pInterval->intervalUnit, pInterval->precision) - 1;
+  return w;
+}
+
+static void doBuildDeleteResult(SStreamIntervalOperatorInfo* pInfo, SArray* pWins, int32_t* index,
+                                SSDataBlock* pBlock) {
+  blockDataCleanup(pBlock);
+  int32_t size = taosArrayGetSize(pWins);
+  if (*index == size) {
+    *index = 0;
+    taosArrayClear(pWins);
+    return;
+  }
+  blockDataEnsureCapacity(pBlock, size - *index);
+  uint64_t uid = 0;
+  for (int32_t i = *index; i < size; i++) {
+    SWinKey* pWin = taosArrayGet(pWins, i);
+    void*    tbname = NULL;
+    pInfo->statestore.streamStateGetParName(pInfo->pState, pWin->groupId, &tbname);
+    if (tbname == NULL) {
+      appendOneRowToStreamSpecialBlock(pBlock, &pWin->ts, &pWin->ts, &uid, &pWin->groupId, NULL);
+    } else {
+      char parTbName[VARSTR_HEADER_SIZE + TSDB_TABLE_NAME_LEN];
+      STR_WITH_MAXSIZE_TO_VARSTR(parTbName, tbname, sizeof(parTbName));
+      appendOneRowToStreamSpecialBlock(pBlock, &pWin->ts, &pWin->ts, &uid, &pWin->groupId, parTbName);
+    }
+    pInfo->statestore.streamStateFreeVal(tbname);
+    (*index)++;
+  }
+}
+
+void destroyStreamFinalIntervalOperatorInfo(void* param) {
+  SStreamIntervalOperatorInfo* pInfo = (SStreamIntervalOperatorInfo*)param;
+  cleanupBasicInfo(&pInfo->binfo);
+  cleanupAggSup(&pInfo->aggSup);
+  // it should be empty.
+  void* pIte = NULL;
+  while ((pIte = taosHashIterate(pInfo->pPullDataMap, pIte)) != NULL) {
+    taosArrayDestroy(*(void**)pIte);
+  }
+  taosHashCleanup(pInfo->pPullDataMap);
+  taosHashCleanup(pInfo->pFinalPullDataMap);
+  taosArrayDestroy(pInfo->pPullWins);
+  blockDataDestroy(pInfo->pPullDataRes);
+  taosArrayDestroy(pInfo->pDelWins);
+  blockDataDestroy(pInfo->pDelRes);
+  pInfo->statestore.streamFileStateDestroy(pInfo->pState->pFileState);
+  taosMemoryFreeClear(pInfo->pState);
+
+  nodesDestroyNode((SNode*)pInfo->pPhyNode);
+  colDataDestroy(&pInfo->twAggSup.timeWindowData);
+  pInfo->groupResInfo.pRows = taosArrayDestroy(pInfo->groupResInfo.pRows);
+  cleanupExprSupp(&pInfo->scalarSupp);
+  tSimpleHashCleanup(pInfo->pUpdatedMap);
+  pInfo->pUpdatedMap = NULL;
+  pInfo->pUpdated = taosArrayDestroy(pInfo->pUpdated);
+
+  taosMemoryFreeClear(param);
+}
+
+static bool allInvertible(SqlFunctionCtx* pFCtx, int32_t numOfCols) {
+  for (int32_t i = 0; i < numOfCols; i++) {
+    if (fmIsUserDefinedFunc(pFCtx[i].functionId) || !fmIsInvertible(pFCtx[i].functionId)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void initIntervalDownStream(SOperatorInfo* downstream, uint16_t type, SStreamIntervalOperatorInfo* pInfo) {
+  SStateStore* pAPI = &downstream->pTaskInfo->storageAPI.stateStore;
+
+  if (downstream->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN) {
+    initIntervalDownStream(downstream->pDownstream[0], type, pInfo);
+    return;
+  }
+
+  SStreamScanInfo* pScanInfo = downstream->info;
+  pScanInfo->windowSup.parentType = type;
+  pScanInfo->windowSup.pIntervalAggSup = &pInfo->aggSup;
+  if (!pScanInfo->pUpdateInfo) {
+    pScanInfo->pUpdateInfo = pAPI->updateInfoInitP(&pInfo->interval, pInfo->twAggSup.waterMark);
+  }
+
+  pScanInfo->interval = pInfo->interval;
+  pScanInfo->twAggSup = pInfo->twAggSup;
+  pScanInfo->pState = pInfo->pState;
+}
+
+void compactFunctions(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx, int32_t numOfOutput,
+                      SExecTaskInfo* pTaskInfo, SColumnInfoData* pTimeWindowData) {
+  for (int32_t k = 0; k < numOfOutput; ++k) {
+    if (fmIsWindowPseudoColumnFunc(pDestCtx[k].functionId)) {
+      if (!pTimeWindowData) {
+        continue;
+      }
+
+      SResultRowEntryInfo* pEntryInfo = GET_RES_INFO(&pDestCtx[k]);
+      char*                p = GET_ROWCELL_INTERBUF(pEntryInfo);
+      SColumnInfoData      idata = {0};
+      idata.info.type = TSDB_DATA_TYPE_BIGINT;
+      idata.info.bytes = tDataTypes[TSDB_DATA_TYPE_BIGINT].bytes;
+      idata.pData = p;
+
+      SScalarParam out = {.columnData = &idata};
+      SScalarParam tw = {.numOfRows = 5, .columnData = pTimeWindowData};
+      pDestCtx[k].sfp.process(&tw, 1, &out);
+      pEntryInfo->numOfRes = 1;
+    } else if (functionNeedToExecute(&pDestCtx[k]) && pDestCtx[k].fpSet.combine != NULL) {
+      int32_t code = pDestCtx[k].fpSet.combine(&pDestCtx[k], &pSourceCtx[k]);
+      if (code != TSDB_CODE_SUCCESS) {
+        qError("%s apply combine functions error, code: %s", GET_TASKID(pTaskInfo), tstrerror(code));
+      }
+    } else if (pDestCtx[k].fpSet.combine == NULL) {
+      char* funName = fmGetFuncName(pDestCtx[k].functionId);
+      qError("%s error, combine funcion for %s is not implemented", GET_TASKID(pTaskInfo), funName);
+      taosMemoryFreeClear(funName);
+    }
+  }
+}
+
+bool hasIntervalWindow(void* pState, SWinKey* pKey, SStateStore* pStore) {
+  return pStore->streamStateCheck(pState, pKey);
+}
+
+int32_t setIntervalOutputBuf(void* pState, STimeWindow* win, SRowBuffPos** pResult, int64_t groupId,
+                             SqlFunctionCtx* pCtx, int32_t numOfOutput, int32_t* rowEntryInfoOffset,
+                             SAggSupporter* pAggSup, SStateStore* pStore) {
+  SWinKey key = {.ts = win->skey, .groupId = groupId};
+  char*   value = NULL;
+  int32_t size = pAggSup->resultRowSize;
+
+  if (pStore->streamStateAddIfNotExist(pState, &key, (void**)&value, &size) < 0) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  *pResult = (SRowBuffPos*)value;
+  SResultRow* res = (SResultRow*)((*pResult)->pRowBuff);
+
+  // set time window for current result
+  res->win = (*win);
+  setResultRowInitCtx(res, pCtx, numOfOutput, rowEntryInfoOffset);
+  return TSDB_CODE_SUCCESS;
+}
+
+bool isDeletedStreamWindow(STimeWindow* pWin, uint64_t groupId, void* pState, STimeWindowAggSupp* pTwSup,
+                           SStateStore* pStore) {
+  if (pTwSup->maxTs != INT64_MIN && pWin->ekey < pTwSup->maxTs - pTwSup->deleteMark) {
+    SWinKey key = {.ts = pWin->skey, .groupId = groupId};
+    if (!hasIntervalWindow(pState, &key, pStore)) {
+      return true;
+    }
+    return false;
+  }
+  return false;
+}
+
+int32_t getNexWindowPos(SInterval* pInterval, SDataBlockInfo* pBlockInfo, TSKEY* tsCols, int32_t startPos, TSKEY eKey,
+                        STimeWindow* pNextWin) {
+  int32_t forwardRows =
+      getNumOfRowsInTimeWindow(pBlockInfo, tsCols, startPos, eKey, binarySearchForKey, NULL, TSDB_ORDER_ASC);
+  int32_t prevEndPos = forwardRows - 1 + startPos;
+  return getNextQualifiedWindow(pInterval, pNextWin, pBlockInfo, tsCols, prevEndPos, TSDB_ORDER_ASC);
+}
+
+void addPullWindow(SHashObj* pMap, SWinKey* pWinRes, int32_t size) {
+  SArray* childIds = taosArrayInit(8, sizeof(int32_t));
+  for (int32_t i = 0; i < size; i++) {
+    taosArrayPush(childIds, &i);
+  }
+  taosHashPut(pMap, pWinRes, sizeof(SWinKey), &childIds, sizeof(void*));
+}
+
+static void clearStreamIntervalOperator(SStreamIntervalOperatorInfo* pInfo) {
+  tSimpleHashClear(pInfo->aggSup.pResultRowHashTable);
+  clearDiskbasedBuf(pInfo->aggSup.pResultBuf);
+  initResultRowInfo(&pInfo->binfo.resultRowInfo);
+  pInfo->aggSup.currentPageId = -1;
+  pInfo->statestore.streamStateClear(pInfo->pState);
+}
+
+static void clearSpecialDataBlock(SSDataBlock* pBlock) {
+  if (pBlock->info.rows <= 0) {
+    return;
+  }
+  blockDataCleanup(pBlock);
+}
+
+static void doBuildPullDataBlock(SArray* array, int32_t* pIndex, SSDataBlock* pBlock) {
+  clearSpecialDataBlock(pBlock);
+  int32_t size = taosArrayGetSize(array);
+  if (size - (*pIndex) == 0) {
+    return;
+  }
+  blockDataEnsureCapacity(pBlock, size - (*pIndex));
+  SColumnInfoData* pStartTs = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX);
+  SColumnInfoData* pEndTs = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, END_TS_COLUMN_INDEX);
+  SColumnInfoData* pGroupId = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, GROUPID_COLUMN_INDEX);
+  SColumnInfoData* pCalStartTs = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, CALCULATE_START_TS_COLUMN_INDEX);
+  SColumnInfoData* pCalEndTs = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, CALCULATE_END_TS_COLUMN_INDEX);
+  for (; (*pIndex) < size; (*pIndex)++) {
+    SPullWindowInfo* pWin = taosArrayGet(array, (*pIndex));
+    colDataSetVal(pStartTs, pBlock->info.rows, (const char*)&pWin->window.skey, false);
+    colDataSetVal(pEndTs, pBlock->info.rows, (const char*)&pWin->window.ekey, false);
+    colDataSetVal(pGroupId, pBlock->info.rows, (const char*)&pWin->groupId, false);
+    colDataSetVal(pCalStartTs, pBlock->info.rows, (const char*)&pWin->calWin.skey, false);
+    colDataSetVal(pCalEndTs, pBlock->info.rows, (const char*)&pWin->calWin.ekey, false);
+    pBlock->info.rows++;
+  }
+  if ((*pIndex) == size) {
+    *pIndex = 0;
+    taosArrayClear(array);
+  }
+  blockDataUpdateTsWindow(pBlock, 0);
+}
+
+void 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;
+  SColumnInfoData* pEndCol = taosArrayGet(pBlock->pDataBlock, CALCULATE_END_TS_COLUMN_INDEX);
+  TSKEY*           tsEndData = (TSKEY*)pEndCol->pData;
+  SColumnInfoData* pGroupCol = taosArrayGet(pBlock->pDataBlock, GROUPID_COLUMN_INDEX);
+  uint64_t*        groupIdData = (uint64_t*)pGroupCol->pData;
+  int32_t          chId = getChildIndex(pBlock);
+  for (int32_t i = 0; i < pBlock->info.rows; i++) {
+    TSKEY winTs = tsData[i];
+    while (winTs <= tsEndData[i]) {
+      SWinKey winRes = {.ts = winTs, .groupId = groupIdData[i]};
+      void*   chIds = taosHashGet(pMap, &winRes, sizeof(SWinKey));
+      if (chIds) {
+        SArray* chArray = *(SArray**)chIds;
+        int32_t index = taosArraySearchIdx(chArray, &chId, compareInt32Val, TD_EQ);
+        if (index != -1) {
+          qDebug("===stream===retrive window %" PRId64 " delete child id %d", winRes.ts, chId);
+          taosArrayRemove(chArray, index);
+          if (taosArrayGetSize(chArray) == 0) {
+            // pull data is over
+            taosArrayDestroy(chArray);
+            taosHashRemove(pMap, &winRes, sizeof(SWinKey));
+            qDebug("===stream===retrive pull data over.window %" PRId64, winRes.ts);
+
+            void* pFinalCh = taosHashGet(pFinalMap, &winRes, sizeof(SWinKey));
+            if (pFinalCh) {
+              taosHashRemove(pFinalMap, &winRes, sizeof(SWinKey));
+              doDeleteWindow(pOperator, winRes.ts, winRes.groupId);
+              STimeWindow     nextWin = getFinalTimeWindow(winRes.ts, pInterval);
+              SPullWindowInfo pull = {.window = nextWin,
+                                      .groupId = winRes.groupId,
+                                      .calWin.skey = nextWin.skey,
+                                      .calWin.ekey = nextWin.skey};
+              // add pull data request
+              if (savePullWindow(&pull, pPullWins) == TSDB_CODE_SUCCESS) {
+                addPullWindow(pMap, &winRes, numOfCh);
+                qDebug("===stream===prepare final retrive for delete %" PRId64 ", size:%d", winRes.ts, numOfCh);
+              }
+            }
+          }
+        }
+      }
+      winTs = taosTimeAdd(winTs, pInterval->sliding, pInterval->slidingUnit, pInterval->precision);
+    }
+  }
+}
+
+static void addRetriveWindow(SArray* wins, SStreamIntervalOperatorInfo* pInfo, int32_t childId) {
+  int32_t size = taosArrayGetSize(wins);
+  for (int32_t i = 0; i < size; i++) {
+    SWinKey*    winKey = taosArrayGet(wins, i);
+    STimeWindow nextWin = getFinalTimeWindow(winKey->ts, &pInfo->interval);
+    if (isOverdue(nextWin.ekey, &pInfo->twAggSup) && pInfo->ignoreExpiredData) {
+      continue;
+    }
+    void* chIds = taosHashGet(pInfo->pPullDataMap, winKey, sizeof(SWinKey));
+    if (!chIds) {
+      SPullWindowInfo pull = {
+          .window = nextWin, .groupId = winKey->groupId, .calWin.skey = nextWin.skey, .calWin.ekey = nextWin.skey};
+      // add pull data request
+      if (savePullWindow(&pull, pInfo->pPullWins) == TSDB_CODE_SUCCESS) {
+        addPullWindow(pInfo->pPullDataMap, winKey, pInfo->numOfChild);
+        qDebug("===stream===prepare retrive for delete %" PRId64 ", size:%d", winKey->ts, pInfo->numOfChild);
+      }
+    } else {
+      SArray* chArray = *(void**)chIds;
+      int32_t index = taosArraySearchIdx(chArray, &childId, compareInt32Val, TD_EQ);
+      qDebug("===stream===check final retrive %" PRId64 ",chid:%d", winKey->ts, index);
+      if (index == -1) {
+        qDebug("===stream===add final retrive %" PRId64, winKey->ts);
+        taosHashPut(pInfo->pFinalPullDataMap, winKey, sizeof(SWinKey), NULL, 0);
+      }
+    }
+  }
+}
+
+static void clearFunctionContext(SExprSupp* pSup) {
+  for (int32_t i = 0; i < pSup->numOfExprs; i++) {
+    pSup->pCtx[i].saveHandle.currentPage = -1;
+  }
+}
+
+int32_t getOutputBuf(void* pState, SRowBuffPos* pPos, SResultRow** pResult, SStateStore* pStore) {
+  return pStore->streamStateGetByPos(pState, pPos, (void**)pResult);
+}
+
+int32_t buildDataBlockFromGroupRes(SOperatorInfo* pOperator, void* pState, SSDataBlock* pBlock, SExprSupp* pSup,
+                                   SGroupResInfo* pGroupResInfo) {
+  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
+  SStorageAPI*   pAPI = &pOperator->pTaskInfo->storageAPI;
+
+  SExprInfo*      pExprInfo = pSup->pExprInfo;
+  int32_t         numOfExprs = pSup->numOfExprs;
+  int32_t*        rowEntryOffset = pSup->rowEntryInfoOffset;
+  SqlFunctionCtx* pCtx = pSup->pCtx;
+
+  int32_t numOfRows = getNumOfTotalRes(pGroupResInfo);
+
+  for (int32_t i = pGroupResInfo->index; i < numOfRows; i += 1) {
+    SRowBuffPos* pPos = *(SRowBuffPos**)taosArrayGet(pGroupResInfo->pRows, i);
+    SResultRow*  pRow = NULL;
+    int32_t      code = getOutputBuf(pState, pPos, &pRow, &pAPI->stateStore);
+    uint64_t     groupId = ((SWinKey*)pPos->pKey)->groupId;
+    ASSERT(code == 0);
+    doUpdateNumOfRows(pCtx, pRow, numOfExprs, rowEntryOffset);
+    // no results, continue to check the next one
+    if (pRow->numOfRows == 0) {
+      pGroupResInfo->index += 1;
+      continue;
+    }
+    if (pBlock->info.id.groupId == 0) {
+      pBlock->info.id.groupId = groupId;
+      void* tbname = NULL;
+      if (pAPI->stateStore.streamStateGetParName(pTaskInfo->streamInfo.pState, pBlock->info.id.groupId, &tbname) < 0) {
+        pBlock->info.parTbName[0] = 0;
+      } else {
+        memcpy(pBlock->info.parTbName, tbname, TSDB_TABLE_NAME_LEN);
+      }
+      pAPI->stateStore.streamStateFreeVal(tbname);
+    } else {
+      // current value belongs to different group, it can't be packed into one datablock
+      if (pBlock->info.id.groupId != groupId) {
+        break;
+      }
+    }
+
+    if (pBlock->info.rows + pRow->numOfRows > pBlock->info.capacity) {
+      ASSERT(pBlock->info.rows > 0);
+      break;
+    }
+    pGroupResInfo->index += 1;
+
+    for (int32_t j = 0; j < numOfExprs; ++j) {
+      int32_t slotId = pExprInfo[j].base.resSchema.slotId;
+
+      pCtx[j].resultInfo = getResultEntryInfo(pRow, j, rowEntryOffset);
+      SResultRowEntryInfo* pEnryInfo = pCtx[j].resultInfo;
+
+      if (pCtx[j].fpSet.finalize) {
+        int32_t code1 = pCtx[j].fpSet.finalize(&pCtx[j], pBlock);
+        if (TAOS_FAILED(code1)) {
+          qError("%s build result data block error, code %s", GET_TASKID(pTaskInfo), tstrerror(code1));
+          T_LONG_JMP(pTaskInfo->env, code1);
+        }
+      } else if (strcmp(pCtx[j].pExpr->pExpr->_function.functionName, "_select_value") == 0) {
+        // do nothing, todo refactor
+      } else {
+        // expand the result into multiple rows. E.g., _wstart, top(k, 20)
+        // the _wstart needs to copy to 20 following rows, since the results of top-k expands to 20 different rows.
+        SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, slotId);
+        char*            in = GET_ROWCELL_INTERBUF(pCtx[j].resultInfo);
+        for (int32_t k = 0; k < pRow->numOfRows; ++k) {
+          colDataSetVal(pColInfoData, pBlock->info.rows + k, in, pCtx[j].resultInfo->isNullRes);
+        }
+      }
+    }
+
+    pBlock->info.rows += pRow->numOfRows;
+  }
+
+  pBlock->info.dataLoad = 1;
+  blockDataUpdateTsWindow(pBlock, 0);
+  return TSDB_CODE_SUCCESS;
+}
+
+void doBuildStreamIntervalResult(SOperatorInfo* pOperator, void* pState, SSDataBlock* pBlock,
+                                 SGroupResInfo* pGroupResInfo) {
+  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
+  // set output datablock version
+  pBlock->info.version = pTaskInfo->version;
+
+  blockDataCleanup(pBlock);
+  if (!hasRemainResults(pGroupResInfo)) {
+    return;
+  }
+
+  // clear the existed group id
+  pBlock->info.id.groupId = 0;
+  buildDataBlockFromGroupRes(pOperator, pState, pBlock, &pOperator->exprSupp, pGroupResInfo);
+}
+
+static int32_t getNextQualifiedFinalWindow(SInterval* pInterval, STimeWindow* pNext, SDataBlockInfo* pDataBlockInfo,
+                                           TSKEY* primaryKeys, int32_t prevPosition) {
+  int32_t startPos = prevPosition + 1;
+  if (startPos == pDataBlockInfo->rows) {
+    startPos = -1;
+  } else {
+    *pNext = getFinalTimeWindow(primaryKeys[startPos], pInterval);
+  }
+  return startPos;
+}
+
+static void setStreamDataVersion(SExecTaskInfo* pTaskInfo, int64_t version, int64_t ckId) {
+  pTaskInfo->streamInfo.dataVersion = version;
+  pTaskInfo->streamInfo.checkPointId = ckId;
+}
+
+static void doStreamIntervalAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBlock, uint64_t groupId,
+                                    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;
+  TSKEY*          tsCols = NULL;
+  SRowBuffPos*    pResPos = NULL;
+  SResultRow*     pResult = NULL;
+  int32_t         forwardRows = 0;
+
+  SColumnInfoData* pColDataInfo = taosArrayGet(pSDataBlock->pDataBlock, pInfo->primaryTsIndex);
+  tsCols = (int64_t*)pColDataInfo->pData;
+
+  int32_t     startPos = 0;
+  TSKEY       ts = getStartTsKey(&pSDataBlock->info.window, tsCols);
+  STimeWindow nextWin = {0};
+  if (IS_FINAL_INTERVAL_OP(pOperator)) {
+    nextWin = getFinalTimeWindow(ts, &pInfo->interval);
+  } else {
+    nextWin = getActiveTimeWindow(pInfo->aggSup.pResultBuf, pResultRowInfo, ts, &pInfo->interval, TSDB_ORDER_ASC);
+  }
+  while (1) {
+    bool isClosed = isCloseWindow(&nextWin, &pInfo->twAggSup);
+    if ((pInfo->ignoreExpiredData && isClosed && !IS_FINAL_INTERVAL_OP(pOperator)) ||
+        !inSlidingWindow(&pInfo->interval, &nextWin, &pSDataBlock->info)) {
+      startPos = getNexWindowPos(&pInfo->interval, &pSDataBlock->info, tsCols, startPos, nextWin.ekey, &nextWin);
+      if (startPos < 0) {
+        break;
+      }
+      continue;
+    }
+
+    if (IS_FINAL_INTERVAL_OP(pOperator) && pInfo->numOfChild > 0) {
+      bool    ignore = true;
+      SWinKey winRes = {
+          .ts = nextWin.skey,
+          .groupId = groupId,
+      };
+      void* chIds = taosHashGet(pInfo->pPullDataMap, &winRes, sizeof(SWinKey));
+      if (isDeletedStreamWindow(&nextWin, groupId, pInfo->pState, &pInfo->twAggSup, &pInfo->statestore) && isClosed &&
+          !chIds) {
+        SPullWindowInfo pull = {
+            .window = nextWin, .groupId = groupId, .calWin.skey = nextWin.skey, .calWin.ekey = nextWin.skey};
+        // add pull data request
+        if (savePullWindow(&pull, pInfo->pPullWins) == TSDB_CODE_SUCCESS) {
+          addPullWindow(pInfo->pPullDataMap, &winRes, pInfo->numOfChild);
+        }
+      } else {
+        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) {
+          ignore = false;
+        }
+      }
+
+      if (ignore) {
+        startPos = getNextQualifiedFinalWindow(&pInfo->interval, &nextWin, &pSDataBlock->info, tsCols, startPos);
+        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 (IS_FINAL_INTERVAL_OP(pOperator)) {
+      forwardRows = 1;
+    } else {
+      forwardRows = getNumOfRowsInTimeWindow(&pSDataBlock->info, tsCols, startPos, nextWin.ekey, binarySearchForKey,
+                                             NULL, TSDB_ORDER_ASC);
+    }
+
+    SWinKey key = {
+        .ts = pResult->win.skey,
+        .groupId = groupId,
+    };
+    if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE && pUpdatedMap) {
+      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);
+      }
+    }
+
+    if (IS_FINAL_INTERVAL_OP(pOperator)) {
+      startPos = getNextQualifiedFinalWindow(&pInfo->interval, &nextWin, &pSDataBlock->info, tsCols, prevEndPos);
+    } else {
+      startPos =
+          getNextQualifiedWindow(&pInfo->interval, &nextWin, &pSDataBlock->info, tsCols, prevEndPos, TSDB_ORDER_ASC);
+    }
+    if (startPos < 0) {
+      break;
+    }
+  }
+}
+
+static inline int winPosCmprImpl(const void* pKey1, const void* pKey2) {
+  SRowBuffPos* pos1 = *(SRowBuffPos**)pKey1;
+  SRowBuffPos* pos2 = *(SRowBuffPos**)pKey2;
+  SWinKey*     pWin1 = (SWinKey*)pos1->pKey;
+  SWinKey*     pWin2 = (SWinKey*)pos2->pKey;
+
+  if (pWin1->groupId > pWin2->groupId) {
+    return 1;
+  } else if (pWin1->groupId < pWin2->groupId) {
+    return -1;
+  }
+
+  if (pWin1->ts > pWin2->ts) {
+    return 1;
+  } else if (pWin1->ts < pWin2->ts) {
+    return -1;
+  }
+
+  return 0;
+}
+
+static void resetUnCloseWinInfo(SSHashObj* winMap) {
+  void*   pIte = NULL;
+  int32_t iter = 0;
+  while ((pIte = tSimpleHashIterate(winMap, pIte, &iter)) != NULL) {
+    SRowBuffPos* pPos = *(SRowBuffPos**)pIte;
+    pPos->beUsed = true;
+  }
+}
+
+
+static SSDataBlock* buildIntervalResult(SOperatorInfo* pOperator) {
+  SStreamIntervalOperatorInfo* pInfo = pOperator->info;
+  SExecTaskInfo*               pTaskInfo = pOperator->pTaskInfo;
+  uint16_t                     opType = pOperator->operatorType;
+  if (IS_FINAL_INTERVAL_OP(pOperator)) {
+    doBuildPullDataBlock(pInfo->pPullWins, &pInfo->pullIndex, pInfo->pPullDataRes);
+    if (pInfo->pPullDataRes->info.rows != 0) {
+      // process the rest of the data
+      printDataBlock(pInfo->pPullDataRes, getStreamOpName(opType), GET_TASKID(pTaskInfo));
+      return pInfo->pPullDataRes;
+    }
+  }
+
+  doBuildDeleteResult(pInfo, pInfo->pDelWins, &pInfo->delIndex, pInfo->pDelRes);
+  if (pInfo->pDelRes->info.rows != 0) {
+    // process the rest of the data
+    printDataBlock(pInfo->pDelRes, getStreamOpName(opType), GET_TASKID(pTaskInfo));
+    return pInfo->pDelRes;
+  }
+
+  doBuildStreamIntervalResult(pOperator, pInfo->pState, pInfo->binfo.pRes, &pInfo->groupResInfo);
+  if (pInfo->binfo.pRes->info.rows != 0) {
+    printDataBlock(pInfo->binfo.pRes, getStreamOpName(opType), GET_TASKID(pTaskInfo));
+    return pInfo->binfo.pRes;
+  }
+  return NULL;
+}
+
+static SSDataBlock* doStreamFinalIntervalAgg(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;
+    }
+
+    if (pInfo->recvGetAll) {
+      pInfo->recvGetAll = false;
+      resetUnCloseWinInfo(pInfo->aggSup.pResultRowHashTable);
+    }
+
+    setOperatorCompleted(pOperator);
+    if (!IS_FINAL_INTERVAL_OP(pOperator)) {
+      clearFunctionContext(&pOperator->exprSupp);
+      // semi interval operator clear disk buffer
+      clearStreamIntervalOperator(pInfo);
+      setStreamDataVersion(pTaskInfo, pInfo->dataVersion, pInfo->pState->checkPointId);
+      qDebug("stask:%s  ===stream===%s clear", GET_TASKID(pTaskInfo), getStreamOpName(pOperator->operatorType));
+    } else {
+      if (pInfo->twAggSup.maxTs > 0 &&
+          pInfo->twAggSup.maxTs - pInfo->twAggSup.checkPointInterval > pInfo->twAggSup.checkPointTs) {
+        pAPI->stateStore.streamStateCommit(pInfo->pState);
+        pAPI->stateStore.streamStateDeleteCheckPoint(pInfo->pState, pInfo->twAggSup.maxTs - pInfo->twAggSup.deleteMark);
+        pInfo->twAggSup.checkPointTs = pInfo->twAggSup.maxTs;
+      }
+      qDebug("stask:%s  ===stream===%s close", GET_TASKID(pTaskInfo), getStreamOpName(pOperator->operatorType));
+    }
+    return NULL;
+  } else {
+    if (!IS_FINAL_INTERVAL_OP(pOperator)) {
+      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));
+        return pInfo->pDelRes;
+      }
+    }
+  }
+
+  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);
+      if (IS_FINAL_INTERVAL_OP(pOperator)) {
+        int32_t chId = getChildIndex(pBlock);
+        addRetriveWindow(delWins, pInfo, chId);
+        if (pBlock->info.type != STREAM_CLEAR) {
+          taosArrayAddAll(pInfo->pDelWins, delWins);
+        }
+        taosArrayDestroy(delWins);
+        continue;
+      }
+      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;
+        }
+        return pInfo->pDelRes;
+      }
+
+      break;
+    } else if (pBlock->info.type == STREAM_GET_ALL && IS_FINAL_INTERVAL_OP(pOperator)) {
+      pInfo->recvGetAll = true;
+      getAllIntervalWindow(pInfo->aggSup.pResultRowHashTable, pInfo->pUpdatedMap);
+      continue;
+    } else if (pBlock->info.type == STREAM_RETRIEVE && !IS_FINAL_INTERVAL_OP(pOperator)) {
+      doDeleteWindows(pOperator, &pInfo->interval, pBlock, NULL, pInfo->pUpdatedMap);
+      if (taosArrayGetSize(pInfo->pUpdated) > 0) {
+        break;
+      }
+      continue;
+    } else if (pBlock->info.type == STREAM_PULL_OVER && IS_FINAL_INTERVAL_OP(pOperator)) {
+      processPullOver(pBlock, pInfo->pPullDataMap, pInfo->pFinalPullDataMap, &pInfo->interval, pInfo->pPullWins,
+                      pInfo->numOfChild, pOperator);
+      continue;
+    } else if (pBlock->info.type == STREAM_CREATE_CHILD_TABLE) {
+      return pBlock;
+    } 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);
+    doStreamIntervalAggImpl(pOperator, pBlock, pBlock->info.id.groupId, 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);
+  if (IS_FINAL_INTERVAL_OP(pOperator)) {
+    closeStreamIntervalWindow(pInfo->aggSup.pResultRowHashTable, &pInfo->twAggSup, &pInfo->interval,
+                              pInfo->pPullDataMap, pInfo->pUpdatedMap, pInfo->pDelWins, pOperator);
+  }
+  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);
+
+  return buildIntervalResult(pOperator);
+}
+
+static int64_t getDeleteMark(SIntervalPhysiNode* pIntervalPhyNode) {
+  if (pIntervalPhyNode->window.deleteMark <= 0) {
+    return DEAULT_DELETE_MARK;
+  }
+  int64_t deleteMark = TMAX(pIntervalPhyNode->window.deleteMark, pIntervalPhyNode->window.watermark);
+  deleteMark = TMAX(deleteMark, pIntervalPhyNode->interval);
+  return deleteMark;
+}
+
+static TSKEY compareTs(void* pKey) {
+  SWinKey* pWinKey = (SWinKey*)pKey;
+  return pWinKey->ts;
+}
+
+static int32_t getSelectivityBufSize(SqlFunctionCtx* pCtx) {
+  if (pCtx->subsidiaries.rowLen == 0) {
+    int32_t rowLen = 0;
+    for (int32_t j = 0; j < pCtx->subsidiaries.num; ++j) {
+      SqlFunctionCtx* pc = pCtx->subsidiaries.pCtx[j];
+      rowLen += pc->pExpr->base.resSchema.bytes;
+    }
+
+    return rowLen + pCtx->subsidiaries.num * sizeof(bool);
+  } else {
+    return pCtx->subsidiaries.rowLen;
+  }
+}
+
+static int32_t getMaxFunResSize(SExprSupp* pSup, int32_t numOfCols) {
+  int32_t size = 0;
+  for (int32_t i = 0; i < numOfCols; ++i) {
+    int32_t resSize = getSelectivityBufSize(pSup->pCtx + i);
+    size = TMAX(size, resSize);
+  }
+  return size;
+}
+
+static void streamIntervalReleaseState(SOperatorInfo* pOperator) {
+  if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL) {
+    SStreamIntervalOperatorInfo* pInfo = pOperator->info;
+    int32_t                      resSize = sizeof(TSKEY);
+    pInfo->statestore.streamStateSaveInfo(pInfo->pState, STREAM_INTERVAL_OP_STATE_NAME,
+                                          strlen(STREAM_INTERVAL_OP_STATE_NAME), &pInfo->twAggSup.maxTs, resSize);
+  }
+  SStreamIntervalOperatorInfo* pInfo = pOperator->info;
+  SStorageAPI*                 pAPI = &pOperator->pTaskInfo->storageAPI;
+  pAPI->stateStore.streamStateCommit(pInfo->pState);
+  SOperatorInfo* downstream = pOperator->pDownstream[0];
+  if (downstream->fpSet.releaseStreamStateFn) {
+    downstream->fpSet.releaseStreamStateFn(downstream);
+  }
+}
+
+void streamIntervalReloadState(SOperatorInfo* pOperator) {
+  if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL) {
+    SStreamIntervalOperatorInfo* pInfo = pOperator->info;
+    int32_t                      size = 0;
+    void*                        pBuf = NULL;
+    int32_t code = pInfo->statestore.streamStateGetInfo(pInfo->pState, STREAM_INTERVAL_OP_STATE_NAME,
+                                                        strlen(STREAM_INTERVAL_OP_STATE_NAME), &pBuf, &size);
+    TSKEY   ts = *(TSKEY*)pBuf;
+    taosMemoryFree(pBuf);
+    pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, ts);
+    pInfo->statestore.streamStateReloadInfo(pInfo->pState, ts);
+  }
+  SOperatorInfo* downstream = pOperator->pDownstream[0];
+  if (downstream->fpSet.reloadStreamStateFn) {
+    downstream->fpSet.reloadStreamStateFn(downstream);
+  }
+}
+
+SOperatorInfo* createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode,
+                                                     SExecTaskInfo* pTaskInfo, int32_t numOfChild) {
+  SIntervalPhysiNode*          pIntervalPhyNode = (SIntervalPhysiNode*)pPhyNode;
+  SStreamIntervalOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamIntervalOperatorInfo));
+  SOperatorInfo*               pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
+  if (pInfo == NULL || pOperator == NULL) {
+    goto _error;
+  }
+
+  pOperator->pTaskInfo = pTaskInfo;
+  SStorageAPI* pAPI = &pTaskInfo->storageAPI;
+
+  pInfo->interval = (SInterval){.interval = pIntervalPhyNode->interval,
+                                .sliding = pIntervalPhyNode->sliding,
+                                .intervalUnit = pIntervalPhyNode->intervalUnit,
+                                .slidingUnit = pIntervalPhyNode->slidingUnit,
+                                .offset = pIntervalPhyNode->offset,
+                                .precision = ((SColumnNode*)pIntervalPhyNode->window.pTspk)->node.resType.precision};
+  pInfo->twAggSup = (STimeWindowAggSupp){
+      .waterMark = pIntervalPhyNode->window.watermark,
+      .calTrigger = pIntervalPhyNode->window.triggerType,
+      .maxTs = INT64_MIN,
+      .minTs = INT64_MAX,
+      .deleteMark = getDeleteMark(pIntervalPhyNode),
+      .deleteMarkSaved = 0,
+      .calTriggerSaved = 0,
+      .checkPointTs = 0,
+      .checkPointInterval =
+          convertTimePrecision(tsCheckpointInterval, TSDB_TIME_PRECISION_MILLI, pInfo->interval.precision),
+  };
+  ASSERTS(pInfo->twAggSup.calTrigger != STREAM_TRIGGER_MAX_DELAY, "trigger type should not be max delay");
+  pInfo->primaryTsIndex = ((SColumnNode*)pIntervalPhyNode->window.pTspk)->slotId;
+  size_t keyBufSize = sizeof(int64_t) + sizeof(int64_t) + POINTER_BYTES;
+  initResultSizeInfo(&pOperator->resultInfo, 4096);
+  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);
+    if (code != TSDB_CODE_SUCCESS) {
+      goto _error;
+    }
+  }
+
+  int32_t      numOfCols = 0;
+  SExprInfo*   pExprInfo = createExprInfo(pIntervalPhyNode->window.pFuncs, NULL, &numOfCols);
+  SSDataBlock* pResBlock = createDataBlockFromDescNode(pPhyNode->pOutputDataBlockDesc);
+  initBasicInfo(&pInfo->binfo, pResBlock);
+
+  pInfo->pState = taosMemoryCalloc(1, sizeof(SStreamState));
+  *(pInfo->pState) = *(pTaskInfo->streamInfo.pState);
+
+  pAPI->stateStore.streamStateSetNumber(pInfo->pState, -1);
+  int32_t code = initAggSup(&pOperator->exprSupp, &pInfo->aggSup, pExprInfo, numOfCols, keyBufSize, pTaskInfo->id.str,
+                            pInfo->pState, &pTaskInfo->storageAPI.functionStore);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
+  initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window);
+  initResultRowInfo(&pInfo->binfo.resultRowInfo);
+
+  pInfo->numOfChild = numOfChild;
+  pInfo->pPhyNode = (SPhysiNode*)nodesCloneNode((SNode*)pPhyNode);
+
+  pInfo->pPullWins = taosArrayInit(8, sizeof(SPullWindowInfo));
+  pInfo->pullIndex = 0;
+  _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
+  pInfo->pPullDataMap = taosHashInit(64, hashFn, false, HASH_NO_LOCK);
+  pInfo->pFinalPullDataMap = taosHashInit(64, hashFn, false, HASH_NO_LOCK);
+  pInfo->pPullDataRes = createSpecialDataBlock(STREAM_RETRIEVE);
+  pInfo->ignoreExpiredData = pIntervalPhyNode->window.igExpired;
+  pInfo->ignoreExpiredDataSaved = false;
+  pInfo->pDelRes = createSpecialDataBlock(STREAM_DELETE_RESULT);
+  pInfo->delIndex = 0;
+  pInfo->pDelWins = taosArrayInit(4, sizeof(SWinKey));
+  pInfo->delKey.ts = INT64_MAX;
+  pInfo->delKey.groupId = 0;
+  pInfo->numOfDatapack = 0;
+  pInfo->pUpdated = NULL;
+  pInfo->pUpdatedMap = NULL;
+  int32_t funResSize = getMaxFunResSize(&pOperator->exprSupp, numOfCols);
+  pInfo->pState->pFileState =
+      pAPI->stateStore.streamFileStateInit(tsStreamBufferSize, sizeof(SWinKey), pInfo->aggSup.resultRowSize, funResSize,
+                                           compareTs, pInfo->pState, pInfo->twAggSup.deleteMark, GET_TASKID(pTaskInfo));
+  pInfo->dataVersion = 0;
+  pInfo->statestore = pTaskInfo->storageAPI.stateStore;
+  pInfo->recvGetAll = false;
+
+  pOperator->operatorType = pPhyNode->type;
+  if (!IS_FINAL_INTERVAL_OP(pOperator) || numOfChild == 0) {
+    pInfo->twAggSup.calTrigger = STREAM_TRIGGER_AT_ONCE;
+  }
+  pOperator->name = getStreamOpName(pOperator->operatorType);
+  pOperator->blocking = true;
+  pOperator->status = OP_NOT_OPENED;
+  pOperator->info = pInfo;
+
+  pOperator->fpSet = createOperatorFpSet(NULL, doStreamFinalIntervalAgg, NULL, destroyStreamFinalIntervalOperatorInfo,
+                                         optrDefaultBufFn, NULL);
+  setOperatorStreamStateFn(pOperator, streamIntervalReleaseState, streamIntervalReloadState);
+  if (pPhyNode->type == QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL) {
+    initIntervalDownStream(downstream, pPhyNode->type, pInfo);
+  }
+  code = appendDownstream(pOperator, &downstream, 1);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
+  return pOperator;
+
+_error:
+  destroyStreamFinalIntervalOperatorInfo(pInfo);
+  taosMemoryFreeClear(pOperator);
+  pTaskInfo->code = code;
+  return NULL;
+}
+
+void destroyStreamAggSupporter(SStreamAggSupporter* pSup) {
+  tSimpleHashCleanup(pSup->pResultRows);
+  destroyDiskbasedBuf(pSup->pResultBuf);
+  blockDataDestroy(pSup->pScanBlock);
+  taosMemoryFreeClear(pSup->pState);
+  taosMemoryFreeClear(pSup->pDummyCtx);
+}
+
+void destroyStreamSessionAggOperatorInfo(void* param) {
+  SStreamSessionAggOperatorInfo* pInfo = (SStreamSessionAggOperatorInfo*)param;
+  cleanupBasicInfo(&pInfo->binfo);
+  destroyStreamAggSupporter(&pInfo->streamAggSup);
+
+  if (pInfo->pChildren != NULL) {
+    int32_t size = taosArrayGetSize(pInfo->pChildren);
+    for (int32_t i = 0; i < size; i++) {
+      SOperatorInfo* pChild = taosArrayGetP(pInfo->pChildren, i);
+      destroyOperator(pChild);
+    }
+    taosArrayDestroy(pInfo->pChildren);
+  }
+
+  colDataDestroy(&pInfo->twAggSup.timeWindowData);
+  blockDataDestroy(pInfo->pDelRes);
+  blockDataDestroy(pInfo->pWinBlock);
+  blockDataDestroy(pInfo->pUpdateRes);
+  tSimpleHashCleanup(pInfo->pStUpdated);
+  tSimpleHashCleanup(pInfo->pStDeleted);
+
+  taosArrayDestroy(pInfo->historyWins);
+  taosMemoryFreeClear(param);
+}
+
+int32_t initBasicInfoEx(SOptrBasicInfo* pBasicInfo, SExprSupp* pSup, SExprInfo* pExprInfo, int32_t numOfCols,
+                        SSDataBlock* pResultBlock, SFunctionStateStore* pStore) {
+  initBasicInfo(pBasicInfo, pResultBlock);
+  int32_t code = initExprSupp(pSup, pExprInfo, numOfCols, pStore);
+  if (code != TSDB_CODE_SUCCESS) {
+    return code;
+  }
+
+  for (int32_t i = 0; i < numOfCols; ++i) {
+    pSup->pCtx[i].saveHandle.pBuf = NULL;
+  }
+
+  ASSERT(numOfCols > 0);
+  return TSDB_CODE_SUCCESS;
+}
+
+void initDummyFunction(SqlFunctionCtx* pDummy, SqlFunctionCtx* pCtx, int32_t nums) {
+  for (int i = 0; i < nums; i++) {
+    pDummy[i].functionId = pCtx[i].functionId;
+    pDummy[i].isNotNullFunc = pCtx[i].isNotNullFunc;
+    pDummy[i].isPseudoFunc = pCtx[i].isPseudoFunc;
+  }
+}
+
+void initDownStream(SOperatorInfo* downstream, SStreamAggSupporter* pAggSup, uint16_t type, int32_t tsColIndex,
+                    STimeWindowAggSupp* pTwSup) {
+  if (downstream->operatorType == QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION) {
+    SStreamPartitionOperatorInfo* pScanInfo = downstream->info;
+    pScanInfo->tsColIndex = tsColIndex;
+  }
+
+  if (downstream->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN) {
+    initDownStream(downstream->pDownstream[0], pAggSup, type, tsColIndex, pTwSup);
+    return;
+  }
+  SStreamScanInfo* pScanInfo = downstream->info;
+  pScanInfo->windowSup = (SWindowSupporter){.pStreamAggSup = pAggSup, .gap = pAggSup->gap, .parentType = type};
+  pScanInfo->pState = pAggSup->pState;
+  if (!pScanInfo->pUpdateInfo) {
+    pScanInfo->pUpdateInfo = pAggSup->stateStore.updateInfoInit(60000, TSDB_TIME_PRECISION_MILLI, pTwSup->waterMark);
+  }
+  pScanInfo->twAggSup = *pTwSup;
+}
+
+int32_t initStreamAggSupporter(SStreamAggSupporter* pSup, SqlFunctionCtx* pCtx, int32_t numOfOutput, int64_t gap,
+                               SStreamState* pState, int32_t keySize, int16_t keyType, SStateStore* pStore,
+                               SReadHandle* pHandle, SStorageAPI* pApi) {
+  pSup->resultRowSize = keySize + getResultRowSize(pCtx, numOfOutput);
+  pSup->pScanBlock = createSpecialDataBlock(STREAM_CLEAR);
+  pSup->gap = gap;
+  pSup->stateKeySize = keySize;
+  pSup->stateKeyType = keyType;
+  pSup->pDummyCtx = (SqlFunctionCtx*)taosMemoryCalloc(numOfOutput, sizeof(SqlFunctionCtx));
+  if (pSup->pDummyCtx == NULL) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  pSup->stateStore = *pStore;
+
+  initDummyFunction(pSup->pDummyCtx, pCtx, numOfOutput);
+  pSup->pState = taosMemoryCalloc(1, sizeof(SStreamState));
+  *(pSup->pState) = *pState;
+  pSup->stateStore.streamStateSetNumber(pSup->pState, -1);
+
+  _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
+  pSup->pResultRows = tSimpleHashInit(32, hashFn);
+
+  int32_t pageSize = 4096;
+  while (pageSize < pSup->resultRowSize * 4) {
+    pageSize <<= 1u;
+  }
+  // at least four pages need to be in buffer
+  int32_t bufSize = 4096 * 256;
+  if (bufSize <= pageSize) {
+    bufSize = pageSize * 4;
+  }
+
+  if (!osTempSpaceAvailable()) {
+    terrno = TSDB_CODE_NO_DISKSPACE;
+    qError("Init stream agg supporter failed since %s, tempDir:%s", terrstr(), tsTempDir);
+    return terrno;
+  }
+
+  int32_t code = createDiskbasedBuf(&pSup->pResultBuf, pageSize, bufSize, "function", tsTempDir);
+  for (int32_t i = 0; i < numOfOutput; ++i) {
+    pCtx[i].saveHandle.pBuf = pSup->pResultBuf;
+  }
+
+  pSup->pSessionAPI = pApi;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+bool isInTimeWindow(STimeWindow* pWin, TSKEY ts, int64_t gap) {
+  if (ts + gap >= pWin->skey && ts - gap <= pWin->ekey) {
+    return true;
+  }
+  return false;
+}
+
+bool isInWindow(SResultWindowInfo* pWinInfo, TSKEY ts, int64_t gap) {
+  return isInTimeWindow(&pWinInfo->sessionWin.win, ts, gap);
+}
+
+void getCurSessionWindow(SStreamAggSupporter* pAggSup, TSKEY startTs, TSKEY endTs, uint64_t groupId,
+                         SSessionKey* pKey) {
+  pKey->win.skey = startTs;
+  pKey->win.ekey = endTs;
+  pKey->groupId = groupId;
+  int32_t code = pAggSup->stateStore.streamStateSessionGetKeyByRange(pAggSup->pState, pKey, pKey);
+  if (code != TSDB_CODE_SUCCESS) {
+    SET_SESSION_WIN_KEY_INVALID(pKey);
+  }
+}
+
+bool isInvalidSessionWin(SResultWindowInfo* pWinInfo) { return pWinInfo->sessionWin.win.skey == 0; }
+
+bool inWinRange(STimeWindow* range, STimeWindow* cur) {
+  if (cur->skey >= range->skey && cur->ekey <= range->ekey) {
+    return true;
+  }
+  return false;
+}
+
+void setSessionOutputBuf(SStreamAggSupporter* pAggSup, TSKEY startTs, TSKEY endTs, uint64_t groupId,
+                         SResultWindowInfo* pCurWin) {
+  pCurWin->sessionWin.groupId = groupId;
+  pCurWin->sessionWin.win.skey = startTs;
+  pCurWin->sessionWin.win.ekey = endTs;
+  int32_t size = pAggSup->resultRowSize;
+  int32_t code = pAggSup->stateStore.streamStateSessionAddIfNotExist(pAggSup->pState, &pCurWin->sessionWin,
+                                                                     pAggSup->gap, &pCurWin->pOutputBuf, &size);
+  if (code == TSDB_CODE_SUCCESS && !inWinRange(&pAggSup->winRange, &pCurWin->sessionWin.win)) {
+    code = TSDB_CODE_FAILED;
+    releaseOutputBuf(pAggSup->pState, NULL, (SResultRow*)pCurWin->pOutputBuf, &pAggSup->pSessionAPI->stateStore);
+    pCurWin->pOutputBuf = taosMemoryCalloc(1, size);
+  }
+
+  if (code == TSDB_CODE_SUCCESS) {
+    pCurWin->isOutput = true;
+    pAggSup->stateStore.streamStateSessionDel(pAggSup->pState, &pCurWin->sessionWin);
+  } else {
+    pCurWin->sessionWin.win.skey = startTs;
+    pCurWin->sessionWin.win.ekey = endTs;
+  }
+}
+
+int32_t getSessionWinBuf(SStreamAggSupporter* pAggSup, SStreamStateCur* pCur, SResultWindowInfo* pWinInfo) {
+  int32_t size = 0;
+  int32_t code =
+      pAggSup->stateStore.streamStateSessionGetKVByCur(pCur, &pWinInfo->sessionWin, &pWinInfo->pOutputBuf, &size);
+  if (code != TSDB_CODE_SUCCESS) {
+    return code;
+  }
+
+  pAggSup->stateStore.streamStateCurNext(pAggSup->pState, pCur);
+  return TSDB_CODE_SUCCESS;
+}
+void saveDeleteInfo(SArray* pWins, SSessionKey key) {
+  // key.win.ekey = key.win.skey;
+  taosArrayPush(pWins, &key);
+}
+
+void saveDeleteRes(SSHashObj* pStDelete, SSessionKey key) {
+  key.win.ekey = key.win.skey;
+  tSimpleHashPut(pStDelete, &key, sizeof(SSessionKey), NULL, 0);
+}
+
+static void removeSessionResult(SSHashObj* pHashMap, SSHashObj* pResMap, SSessionKey key) {
+  key.win.ekey = key.win.skey;
+  tSimpleHashRemove(pHashMap, &key, sizeof(SSessionKey));
+  tSimpleHashRemove(pResMap, &key, sizeof(SSessionKey));
+}
+
+static void getSessionHashKey(const SSessionKey* pKey, SSessionKey* pHashKey) {
+  *pHashKey = *pKey;
+  pHashKey->win.ekey = pKey->win.skey;
+}
+
+static void removeSessionResults(SSHashObj* pHashMap, SArray* pWins) {
+  if (tSimpleHashGetSize(pHashMap) == 0) {
+    return;
+  }
+  int32_t size = taosArrayGetSize(pWins);
+  for (int32_t i = 0; i < size; i++) {
+    SSessionKey* pWin = taosArrayGet(pWins, i);
+    if (!pWin) continue;
+    SSessionKey key = {0};
+    getSessionHashKey(pWin, &key);
+    tSimpleHashRemove(pHashMap, &key, sizeof(SSessionKey));
+  }
+}
+
+int32_t updateSessionWindowInfo(SResultWindowInfo* pWinInfo, TSKEY* pStartTs, TSKEY* pEndTs, uint64_t groupId,
+                                int32_t rows, int32_t start, int64_t gap, SSHashObj* pResultRows, SSHashObj* pStUpdated,
+                                SSHashObj* pStDeleted) {
+  for (int32_t i = start; i < rows; ++i) {
+    if (!isInWindow(pWinInfo, pStartTs[i], gap) && (!pEndTs || !isInWindow(pWinInfo, pEndTs[i], gap))) {
+      return i - start;
+    }
+    if (pWinInfo->sessionWin.win.skey > pStartTs[i]) {
+      if (pStDeleted && pWinInfo->isOutput) {
+        saveDeleteRes(pStDeleted, pWinInfo->sessionWin);
+      }
+      removeSessionResult(pStUpdated, pResultRows, pWinInfo->sessionWin);
+      pWinInfo->sessionWin.win.skey = pStartTs[i];
+    }
+    pWinInfo->sessionWin.win.ekey = TMAX(pWinInfo->sessionWin.win.ekey, pStartTs[i]);
+    if (pEndTs) {
+      pWinInfo->sessionWin.win.ekey = TMAX(pWinInfo->sessionWin.win.ekey, pEndTs[i]);
+    }
+  }
+  return rows - start;
+}
+
+static int32_t initSessionOutputBuf(SResultWindowInfo* pWinInfo, SResultRow** pResult, SqlFunctionCtx* pCtx,
+                                    int32_t numOfOutput, int32_t* rowEntryInfoOffset) {
+  ASSERT(pWinInfo->sessionWin.win.skey <= pWinInfo->sessionWin.win.ekey);
+  *pResult = (SResultRow*)pWinInfo->pOutputBuf;
+  // set time window for current result
+  (*pResult)->win = pWinInfo->sessionWin.win;
+  setResultRowInitCtx(*pResult, pCtx, numOfOutput, rowEntryInfoOffset);
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t doOneWindowAggImpl(SColumnInfoData* pTimeWindowData, SResultWindowInfo* pCurWin, SResultRow** pResult,
+                                  int32_t startIndex, int32_t winRows, int32_t rows, int32_t numOutput,
+                                  SOperatorInfo* pOperator, int64_t winDelta) {
+  SExprSupp*     pSup = &pOperator->exprSupp;
+  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
+  int32_t        code = initSessionOutputBuf(pCurWin, pResult, pSup->pCtx, numOutput, pSup->rowEntryInfoOffset);
+  if (code != TSDB_CODE_SUCCESS || (*pResult) == NULL) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+  updateTimeWindowInfo(pTimeWindowData, &pCurWin->sessionWin.win, winDelta);
+  applyAggFunctionOnPartialTuples(pTaskInfo, pSup->pCtx, pTimeWindowData, startIndex, winRows, rows, numOutput);
+  return TSDB_CODE_SUCCESS;
+}
+
+static bool doDeleteSessionWindow(SStreamAggSupporter* pAggSup, SSessionKey* pKey) {
+  pAggSup->stateStore.streamStateSessionDel(pAggSup->pState, pKey);
+  SSessionKey hashKey = {0};
+  getSessionHashKey(pKey, &hashKey);
+  tSimpleHashRemove(pAggSup->pResultRows, &hashKey, sizeof(SSessionKey));
+  return true;
+}
+
+static int32_t setSessionWinOutputInfo(SSHashObj* pStUpdated, SResultWindowInfo* pWinInfo) {
+  void* pVal = tSimpleHashGet(pStUpdated, &pWinInfo->sessionWin, sizeof(SSessionKey));
+  if (pVal) {
+    SResultWindowInfo* pWin = pVal;
+    pWinInfo->isOutput = pWin->isOutput;
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
+SStreamStateCur* getNextSessionWinInfo(SStreamAggSupporter* pAggSup, SSHashObj* pStUpdated, SResultWindowInfo* pCurWin,
+                                       SResultWindowInfo* pNextWin) {
+  SStreamStateCur* pCur = pAggSup->stateStore.streamStateSessionSeekKeyNext(pAggSup->pState, &pCurWin->sessionWin);
+  pNextWin->isOutput = true;
+  setSessionWinOutputInfo(pStUpdated, pNextWin);
+  int32_t size = 0;
+  pNextWin->sessionWin = pCurWin->sessionWin;
+  int32_t code =
+      pAggSup->stateStore.streamStateSessionGetKVByCur(pCur, &pNextWin->sessionWin, &pNextWin->pOutputBuf, &size);
+  if (code != TSDB_CODE_SUCCESS) {
+    taosMemoryFreeClear(pNextWin->pOutputBuf);
+    SET_SESSION_WIN_INVALID(*pNextWin);
+  }
+  return pCur;
+}
+
+static int32_t compactSessionWindow(SOperatorInfo* pOperator, SResultWindowInfo* pCurWin, SSHashObj* pStUpdated,
+                                    SSHashObj* pStDeleted, bool addGap) {
+  SExprSupp*     pSup = &pOperator->exprSupp;
+  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
+  SStorageAPI*   pAPI = &pOperator->pTaskInfo->storageAPI;
+  int32_t        winNum = 0;
+
+  SStreamSessionAggOperatorInfo* pInfo = pOperator->info;
+  SResultRow*                    pCurResult = NULL;
+  int32_t                        numOfOutput = pOperator->exprSupp.numOfExprs;
+  SStreamAggSupporter*           pAggSup = &pInfo->streamAggSup;
+  initSessionOutputBuf(pCurWin, &pCurResult, pSup->pCtx, numOfOutput, pSup->rowEntryInfoOffset);
+  // Just look for the window behind StartIndex
+  while (1) {
+    SResultWindowInfo winInfo = {0};
+    SStreamStateCur*  pCur = getNextSessionWinInfo(pAggSup, pStUpdated, pCurWin, &winInfo);
+    if (!IS_VALID_SESSION_WIN(winInfo) || !isInWindow(pCurWin, winInfo.sessionWin.win.skey, pAggSup->gap) ||
+        !inWinRange(&pAggSup->winRange, &winInfo.sessionWin.win)) {
+      taosMemoryFree(winInfo.pOutputBuf);
+      pAPI->stateStore.streamStateFreeCur(pCur);
+      break;
+    }
+    SResultRow* pWinResult = NULL;
+    initSessionOutputBuf(&winInfo, &pWinResult, pAggSup->pDummyCtx, numOfOutput, pSup->rowEntryInfoOffset);
+    pCurWin->sessionWin.win.ekey = TMAX(pCurWin->sessionWin.win.ekey, winInfo.sessionWin.win.ekey);
+    int64_t winDelta = 0;
+    if (addGap) {
+      winDelta = pAggSup->gap;
+    }
+    updateTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pCurWin->sessionWin.win, winDelta);
+    compactFunctions(pSup->pCtx, pAggSup->pDummyCtx, numOfOutput, pTaskInfo, &pInfo->twAggSup.timeWindowData);
+    tSimpleHashRemove(pStUpdated, &winInfo.sessionWin, sizeof(SSessionKey));
+    if (winInfo.isOutput && pStDeleted) {
+      saveDeleteRes(pStDeleted, winInfo.sessionWin);
+    }
+    removeSessionResult(pStUpdated, pAggSup->pResultRows, winInfo.sessionWin);
+    doDeleteSessionWindow(pAggSup, &winInfo.sessionWin);
+    pAPI->stateStore.streamStateFreeCur(pCur);
+    taosMemoryFree(winInfo.pOutputBuf);
+    winNum++;
+  }
+  return winNum;
+}
+
+int32_t saveSessionOutputBuf(SStreamAggSupporter* pAggSup, SResultWindowInfo* pWinInfo) {
+  saveSessionDiscBuf(pAggSup->pState, &pWinInfo->sessionWin, pWinInfo->pOutputBuf, pAggSup->resultRowSize,
+                     &pAggSup->stateStore);
+  pWinInfo->pOutputBuf = NULL;
+  return TSDB_CODE_SUCCESS;
+}
+
+static void doStreamSessionAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBlock, SSHashObj* pStUpdated,
+                                   SSHashObj* pStDeleted, bool hasEndTs, bool addGap) {
+  SExecTaskInfo*                 pTaskInfo = pOperator->pTaskInfo;
+  SStreamSessionAggOperatorInfo* pInfo = pOperator->info;
+  int32_t                        numOfOutput = pOperator->exprSupp.numOfExprs;
+  uint64_t                       groupId = pSDataBlock->info.id.groupId;
+  int64_t                        code = TSDB_CODE_SUCCESS;
+  SResultRow*                    pResult = NULL;
+  int32_t                        rows = pSDataBlock->info.rows;
+  int32_t                        winRows = 0;
+  SStreamAggSupporter*           pAggSup = &pInfo->streamAggSup;
+
+  pInfo->dataVersion = TMAX(pInfo->dataVersion, pSDataBlock->info.version);
+  pAggSup->winRange = pTaskInfo->streamInfo.fillHistoryWindow;
+  if (pAggSup->winRange.ekey <= 0) {
+    pAggSup->winRange.ekey = INT64_MAX;
+  }
+
+  SColumnInfoData* pStartTsCol = taosArrayGet(pSDataBlock->pDataBlock, pInfo->primaryTsIndex);
+  TSKEY*           startTsCols = (int64_t*)pStartTsCol->pData;
+  SColumnInfoData* pEndTsCol = NULL;
+  if (hasEndTs) {
+    pEndTsCol = taosArrayGet(pSDataBlock->pDataBlock, pInfo->endTsIndex);
+  } else {
+    pEndTsCol = taosArrayGet(pSDataBlock->pDataBlock, pInfo->primaryTsIndex);
+  }
+
+  TSKEY* endTsCols = (int64_t*)pEndTsCol->pData;
+  for (int32_t i = 0; i < rows;) {
+    if (pInfo->ignoreExpiredData && isOverdue(endTsCols[i], &pInfo->twAggSup)) {
+      i++;
+      continue;
+    }
+    SResultWindowInfo winInfo = {0};
+    setSessionOutputBuf(pAggSup, startTsCols[i], endTsCols[i], groupId, &winInfo);
+    setSessionWinOutputInfo(pStUpdated, &winInfo);
+    winRows = updateSessionWindowInfo(&winInfo, startTsCols, endTsCols, groupId, rows, i, pAggSup->gap,
+                                      pAggSup->pResultRows, pStUpdated, pStDeleted);
+    // coverity scan error
+    if (!winInfo.pOutputBuf) {
+      T_LONG_JMP(pTaskInfo->env, TSDB_CODE_OUT_OF_MEMORY);
+    }
+
+    int64_t winDelta = 0;
+    if (addGap) {
+      winDelta = pAggSup->gap;
+    }
+    code = doOneWindowAggImpl(&pInfo->twAggSup.timeWindowData, &winInfo, &pResult, i, winRows, rows, numOfOutput,
+                              pOperator, winDelta);
+    if (code != TSDB_CODE_SUCCESS || pResult == NULL) {
+      T_LONG_JMP(pTaskInfo->env, TSDB_CODE_OUT_OF_MEMORY);
+    }
+    compactSessionWindow(pOperator, &winInfo, pStUpdated, pStDeleted, addGap);
+    saveSessionOutputBuf(pAggSup, &winInfo);
+
+    if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE && pStUpdated) {
+      code = saveResult(winInfo, pStUpdated);
+      if (code != TSDB_CODE_SUCCESS) {
+        T_LONG_JMP(pTaskInfo->env, TSDB_CODE_OUT_OF_MEMORY);
+      }
+    }
+    if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) {
+      SSessionKey key = {0};
+      getSessionHashKey(&winInfo.sessionWin, &key);
+      tSimpleHashPut(pAggSup->pResultRows, &key, sizeof(SSessionKey), &winInfo, sizeof(SResultWindowInfo));
+    }
+
+    i += winRows;
+  }
+}
+
+static void doDeleteTimeWindows(SStreamAggSupporter* pAggSup, SSDataBlock* pBlock, SArray* result) {
+  SColumnInfoData* pStartTsCol = taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX);
+  TSKEY*           startDatas = (TSKEY*)pStartTsCol->pData;
+  SColumnInfoData* pEndTsCol = taosArrayGet(pBlock->pDataBlock, END_TS_COLUMN_INDEX);
+  TSKEY*           endDatas = (TSKEY*)pEndTsCol->pData;
+  SColumnInfoData* pGroupCol = taosArrayGet(pBlock->pDataBlock, GROUPID_COLUMN_INDEX);
+  uint64_t*        gpDatas = (uint64_t*)pGroupCol->pData;
+  for (int32_t i = 0; i < pBlock->info.rows; i++) {
+    while (1) {
+      SSessionKey curWin = {0};
+      getCurSessionWindow(pAggSup, startDatas[i], endDatas[i], gpDatas[i], &curWin);
+      if (IS_INVALID_SESSION_WIN_KEY(curWin)) {
+        break;
+      }
+      doDeleteSessionWindow(pAggSup, &curWin);
+      if (result) {
+        saveDeleteInfo(result, curWin);
+      }
+    }
+  }
+}
+
+static inline int32_t sessionKeyCompareAsc(const void* pKey1, const void* pKey2) {
+  SSessionKey* pWin1 = (SSessionKey*)pKey1;
+  SSessionKey* pWin2 = (SSessionKey*)pKey2;
+
+  if (pWin1->groupId > pWin2->groupId) {
+    return 1;
+  } else if (pWin1->groupId < pWin2->groupId) {
+    return -1;
+  }
+
+  if (pWin1->win.skey > pWin2->win.skey) {
+    return 1;
+  } else if (pWin1->win.skey < pWin2->win.skey) {
+    return -1;
+  }
+
+  return 0;
+}
+
+static int32_t copyUpdateResult(SSHashObj* pStUpdated, SArray* pUpdated) {
+  void*   pIte = NULL;
+  int32_t iter = 0;
+  while ((pIte = tSimpleHashIterate(pStUpdated, pIte, &iter)) != NULL) {
+    void* key = tSimpleHashGetKey(pIte, NULL);
+    taosArrayPush(pUpdated, key);
+  }
+  taosArraySort(pUpdated, sessionKeyCompareAsc);
+  return TSDB_CODE_SUCCESS;
+}
+
+void doBuildDeleteDataBlock(SOperatorInfo* pOp, SSHashObj* pStDeleted, SSDataBlock* pBlock, void** Ite) {
+  SStorageAPI* pAPI = &pOp->pTaskInfo->storageAPI;
+
+  blockDataCleanup(pBlock);
+  int32_t size = tSimpleHashGetSize(pStDeleted);
+  if (size == 0) {
+    return;
+  }
+  blockDataEnsureCapacity(pBlock, size);
+  int32_t iter = 0;
+  while (((*Ite) = tSimpleHashIterate(pStDeleted, *Ite, &iter)) != NULL) {
+    if (pBlock->info.rows + 1 > pBlock->info.capacity) {
+      break;
+    }
+    SSessionKey*     res = tSimpleHashGetKey(*Ite, NULL);
+    SColumnInfoData* pStartTsCol = taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX);
+    colDataSetVal(pStartTsCol, pBlock->info.rows, (const char*)&res->win.skey, false);
+    SColumnInfoData* pEndTsCol = taosArrayGet(pBlock->pDataBlock, END_TS_COLUMN_INDEX);
+    colDataSetVal(pEndTsCol, pBlock->info.rows, (const char*)&res->win.skey, false);
+    SColumnInfoData* pUidCol = taosArrayGet(pBlock->pDataBlock, UID_COLUMN_INDEX);
+    colDataSetNULL(pUidCol, pBlock->info.rows);
+    SColumnInfoData* pGpCol = taosArrayGet(pBlock->pDataBlock, GROUPID_COLUMN_INDEX);
+    colDataSetVal(pGpCol, pBlock->info.rows, (const char*)&res->groupId, false);
+    SColumnInfoData* pCalStCol = taosArrayGet(pBlock->pDataBlock, CALCULATE_START_TS_COLUMN_INDEX);
+    colDataSetNULL(pCalStCol, pBlock->info.rows);
+    SColumnInfoData* pCalEdCol = taosArrayGet(pBlock->pDataBlock, CALCULATE_END_TS_COLUMN_INDEX);
+    colDataSetNULL(pCalEdCol, pBlock->info.rows);
+
+    SColumnInfoData* pTableCol = taosArrayGet(pBlock->pDataBlock, TABLE_NAME_COLUMN_INDEX);
+
+    void* tbname = NULL;
+    pAPI->stateStore.streamStateGetParName(pOp->pTaskInfo->streamInfo.pState, res->groupId, &tbname);
+    if (tbname == NULL) {
+      colDataSetNULL(pTableCol, pBlock->info.rows);
+    } else {
+      char parTbName[VARSTR_HEADER_SIZE + TSDB_TABLE_NAME_LEN];
+      STR_WITH_MAXSIZE_TO_VARSTR(parTbName, tbname, sizeof(parTbName));
+      colDataSetVal(pTableCol, pBlock->info.rows, (const char*)parTbName, false);
+      pAPI->stateStore.streamStateFreeVal(tbname);
+    }
+    pBlock->info.rows += 1;
+  }
+  if ((*Ite) == NULL) {
+    tSimpleHashClear(pStDeleted);
+  }
+}
+
+static void rebuildSessionWindow(SOperatorInfo* pOperator, SArray* pWinArray, SSHashObj* pStUpdated) {
+  SExprSupp*     pSup = &pOperator->exprSupp;
+  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
+  SStorageAPI*   pAPI = &pOperator->pTaskInfo->storageAPI;
+
+  int32_t                        size = taosArrayGetSize(pWinArray);
+  SStreamSessionAggOperatorInfo* pInfo = pOperator->info;
+  SStreamAggSupporter*           pAggSup = &pInfo->streamAggSup;
+  int32_t                        numOfOutput = pSup->numOfExprs;
+  int32_t                        numOfChild = taosArrayGetSize(pInfo->pChildren);
+
+  for (int32_t i = 0; i < size; i++) {
+    SSessionKey*      pWinKey = taosArrayGet(pWinArray, i);
+    int32_t           num = 0;
+    SResultWindowInfo parentWin = {0};
+    for (int32_t j = 0; j < numOfChild; j++) {
+      SOperatorInfo*                 pChild = taosArrayGetP(pInfo->pChildren, j);
+      SStreamSessionAggOperatorInfo* pChInfo = pChild->info;
+      SStreamAggSupporter*           pChAggSup = &pChInfo->streamAggSup;
+      SSessionKey                    chWinKey = {0};
+      getSessionHashKey(pWinKey, &chWinKey);
+      SStreamStateCur* pCur = pAggSup->stateStore.streamStateSessionSeekKeyCurrentNext(pChAggSup->pState, &chWinKey);
+      SResultRow*      pResult = NULL;
+      SResultRow*      pChResult = NULL;
+      while (1) {
+        SResultWindowInfo childWin = {0};
+        childWin.sessionWin = *pWinKey;
+        int32_t code = getSessionWinBuf(pChAggSup, pCur, &childWin);
+
+        if (code == TSDB_CODE_SUCCESS && !inWinRange(&pAggSup->winRange, &childWin.sessionWin.win)) {
+          continue;
+        }
+
+        if (code == TSDB_CODE_SUCCESS && inWinRange(&pWinKey->win, &childWin.sessionWin.win)) {
+          if (num == 0) {
+            setSessionOutputBuf(pAggSup, pWinKey->win.skey, pWinKey->win.ekey, pWinKey->groupId, &parentWin);
+            code = initSessionOutputBuf(&parentWin, &pResult, pSup->pCtx, numOfOutput, pSup->rowEntryInfoOffset);
+            if (code != TSDB_CODE_SUCCESS || pResult == NULL) {
+              break;
+            }
+          }
+          num++;
+          updateTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &parentWin.sessionWin.win, pAggSup->gap);
+          initSessionOutputBuf(&childWin, &pChResult, pChild->exprSupp.pCtx, numOfOutput,
+                               pChild->exprSupp.rowEntryInfoOffset);
+          compactFunctions(pSup->pCtx, pChild->exprSupp.pCtx, numOfOutput, pTaskInfo, &pInfo->twAggSup.timeWindowData);
+          compactSessionWindow(pOperator, &parentWin, pStUpdated, NULL, true);
+          saveResult(parentWin, pStUpdated);
+        } else {
+          break;
+        }
+      }
+      pAPI->stateStore.streamStateFreeCur(pCur);
+    }
+    if (num > 0) {
+      saveSessionOutputBuf(pAggSup, &parentWin);
+    }
+  }
+}
+
+int32_t closeSessionWindow(SSHashObj* pHashMap, STimeWindowAggSupp* pTwSup, SSHashObj* pClosed) {
+  void*   pIte = NULL;
+  int32_t iter = 0;
+  while ((pIte = tSimpleHashIterate(pHashMap, pIte, &iter)) != NULL) {
+    SResultWindowInfo* pWinInfo = pIte;
+    if (isCloseWindow(&pWinInfo->sessionWin.win, pTwSup)) {
+      if (pTwSup->calTrigger == STREAM_TRIGGER_WINDOW_CLOSE && pClosed) {
+        int32_t code = saveResult(*pWinInfo, pClosed);
+        if (code != TSDB_CODE_SUCCESS) {
+          return code;
+        }
+      }
+      SSessionKey* pKey = tSimpleHashGetKey(pIte, NULL);
+      tSimpleHashIterateRemove(pHashMap, pKey, sizeof(SSessionKey), &pIte, &iter);
+    }
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
+static void closeChildSessionWindow(SArray* pChildren, TSKEY maxTs) {
+  int32_t size = taosArrayGetSize(pChildren);
+  for (int32_t i = 0; i < size; i++) {
+    SOperatorInfo*                 pChildOp = taosArrayGetP(pChildren, i);
+    SStreamSessionAggOperatorInfo* pChInfo = pChildOp->info;
+    pChInfo->twAggSup.maxTs = TMAX(pChInfo->twAggSup.maxTs, maxTs);
+    closeSessionWindow(pChInfo->streamAggSup.pResultRows, &pChInfo->twAggSup, NULL);
+  }
+}
+
+int32_t getAllSessionWindow(SSHashObj* pHashMap, SSHashObj* pStUpdated) {
+  void*   pIte = NULL;
+  int32_t iter = 0;
+  while ((pIte = tSimpleHashIterate(pHashMap, pIte, &iter)) != NULL) {
+    SResultWindowInfo* pWinInfo = pIte;
+    saveResult(*pWinInfo, pStUpdated);
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
+static void copyDeleteWindowInfo(SArray* pResWins, SSHashObj* pStDeleted) {
+  int32_t size = taosArrayGetSize(pResWins);
+  for (int32_t i = 0; i < size; i++) {
+    SSessionKey* pWinKey = taosArrayGet(pResWins, i);
+    if (!pWinKey) continue;
+    SSessionKey winInfo = {0};
+    getSessionHashKey(pWinKey, &winInfo);
+    tSimpleHashPut(pStDeleted, &winInfo, sizeof(SSessionKey), NULL, 0);
+  }
+}
+
+// the allocated memory comes from outer function.
+void initGroupResInfoFromArrayList(SGroupResInfo* pGroupResInfo, SArray* pArrayList) {
+  pGroupResInfo->pRows = pArrayList;
+  pGroupResInfo->index = 0;
+  pGroupResInfo->pBuf = NULL;
+}
+
+void doBuildSessionResult(SOperatorInfo* pOperator, void* pState, SGroupResInfo* pGroupResInfo, SSDataBlock* pBlock) {
+  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
+  // set output datablock version
+  pBlock->info.version = pTaskInfo->version;
+
+  blockDataCleanup(pBlock);
+  if (!hasRemainResults(pGroupResInfo)) {
+    cleanupGroupResInfo(pGroupResInfo);
+    return;
+  }
+
+  // clear the existed group id
+  pBlock->info.id.groupId = 0;
+  buildSessionResultDataBlock(pOperator, pState, pBlock, &pOperator->exprSupp, pGroupResInfo);
+  if (pBlock->info.rows == 0) {
+    cleanupGroupResInfo(pGroupResInfo);
+  }
+}
+
+static SSDataBlock* buildSessionResult(SOperatorInfo* pOperator) {
+  SStreamSessionAggOperatorInfo* pInfo = pOperator->info;
+  SStreamAggSupporter*           pAggSup = &pInfo->streamAggSup;
+  SOptrBasicInfo*                pBInfo = &pInfo->binfo;
+  SExecTaskInfo*                 pTaskInfo = pOperator->pTaskInfo;
+  doBuildDeleteDataBlock(pOperator, pInfo->pStDeleted, pInfo->pDelRes, &pInfo->pDelIterator);
+  if (pInfo->pDelRes->info.rows > 0) {
+    printDataBlock(pInfo->pDelRes, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));
+    return pInfo->pDelRes;
+  }
+  doBuildSessionResult(pOperator, pAggSup->pState, &pInfo->groupResInfo, pBInfo->pRes);
+  if (pBInfo->pRes->info.rows > 0) {
+    printDataBlock(pBInfo->pRes, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));
+    return pBInfo->pRes;
+  }
+  return NULL;
+}
+
+void getMaxTsWins(const SArray* pAllWins, SArray* pMaxWins) {
+  int32_t size = taosArrayGetSize(pAllWins);
+  if (size == 0) {
+    return;
+  }
+
+  SSessionKey* pSeKey = taosArrayGet(pAllWins, size - 1);
+  taosArrayPush(pMaxWins, pSeKey);
+  if (pSeKey->groupId == 0) {
+    return;
+  }
+  uint64_t preGpId = pSeKey->groupId;
+  for (int32_t i = size - 2; i >= 0; i--) {
+    pSeKey = taosArrayGet(pAllWins, i);
+    if (preGpId != pSeKey->groupId) {
+      taosArrayPush(pMaxWins, pSeKey);
+      preGpId = pSeKey->groupId;
+    }
+  }
+}
+
+static SSDataBlock* doStreamSessionAgg(SOperatorInfo* pOperator) {
+  SExprSupp*                     pSup = &pOperator->exprSupp;
+  SStreamSessionAggOperatorInfo* pInfo = pOperator->info;
+  SOptrBasicInfo*                pBInfo = &pInfo->binfo;
+  SStreamAggSupporter*           pAggSup = &pInfo->streamAggSup;
+  SExecTaskInfo*                 pTaskInfo = pOperator->pTaskInfo;
+  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* opRes = buildSessionResult(pOperator);
+    if (opRes) {
+      return opRes;
+    }
+    setOperatorCompleted(pOperator);
+    return NULL;
+  }
+
+  SOperatorInfo* downstream = pOperator->pDownstream[0];
+  if (!pInfo->pUpdated) {
+    pInfo->pUpdated = taosArrayInit(16, sizeof(SSessionKey));
+  }
+  if (!pInfo->pStUpdated) {
+    _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
+    pInfo->pStUpdated = tSimpleHashInit(64, hashFn);
+  }
+  while (1) {
+    SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
+    if (pBlock == NULL) {
+      break;
+    }
+    printSpecDataBlock(pBlock, getStreamOpName(pOperator->operatorType), "recv", GET_TASKID(pTaskInfo));
+
+    if (pBlock->info.type == STREAM_DELETE_DATA || pBlock->info.type == STREAM_DELETE_RESULT ||
+        pBlock->info.type == STREAM_CLEAR) {
+      SArray* pWins = taosArrayInit(16, sizeof(SSessionKey));
+      // gap must be 0
+      doDeleteTimeWindows(pAggSup, pBlock, pWins);
+      removeSessionResults(pInfo->pStUpdated, pWins);
+      if (IS_FINAL_SESSION_OP(pOperator)) {
+        int32_t                        childIndex = getChildIndex(pBlock);
+        SOperatorInfo*                 pChildOp = taosArrayGetP(pInfo->pChildren, childIndex);
+        SStreamSessionAggOperatorInfo* pChildInfo = pChildOp->info;
+        // gap must be 0
+        doDeleteTimeWindows(&pChildInfo->streamAggSup, pBlock, NULL);
+        rebuildSessionWindow(pOperator, pWins, pInfo->pStUpdated);
+      }
+      copyDeleteWindowInfo(pWins, pInfo->pStDeleted);
+      taosArrayDestroy(pWins);
+      continue;
+    } else if (pBlock->info.type == STREAM_GET_ALL) {
+      getAllSessionWindow(pAggSup->pResultRows, pInfo->pStUpdated);
+      continue;
+    } else if (pBlock->info.type == STREAM_CREATE_CHILD_TABLE) {
+      return pBlock;
+    } else {
+      ASSERTS(pBlock->info.type == STREAM_NORMAL || 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);
+    }
+    // the pDataBlock are always the same one, no need to call this again
+    setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true);
+    doStreamSessionAggImpl(pOperator, pBlock, pInfo->pStUpdated, pInfo->pStDeleted, IS_FINAL_SESSION_OP(pOperator),
+                           true);
+    if (IS_FINAL_SESSION_OP(pOperator)) {
+      int32_t chIndex = getChildIndex(pBlock);
+      int32_t size = taosArrayGetSize(pInfo->pChildren);
+      // if chIndex + 1 - size > 0, add new child
+      for (int32_t i = 0; i < chIndex + 1 - size; i++) {
+        SOperatorInfo* pChildOp =
+            createStreamFinalSessionAggOperatorInfo(NULL, pInfo->pPhyNode, pOperator->pTaskInfo, 0, NULL);
+        if (!pChildOp) {
+          T_LONG_JMP(pOperator->pTaskInfo->env, TSDB_CODE_OUT_OF_MEMORY);
+        }
+        taosArrayPush(pInfo->pChildren, &pChildOp);
+      }
+      SOperatorInfo* pChildOp = taosArrayGetP(pInfo->pChildren, chIndex);
+      setInputDataBlock(&pChildOp->exprSupp, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true);
+      doStreamSessionAggImpl(pChildOp, pBlock, NULL, NULL, true, false);
+    }
+    pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey);
+    pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.watermark);
+  }
+  // restore the value
+  pOperator->status = OP_RES_TO_RETURN;
+
+  closeSessionWindow(pAggSup->pResultRows, &pInfo->twAggSup, pInfo->pStUpdated);
+  closeChildSessionWindow(pInfo->pChildren, pInfo->twAggSup.maxTs);
+  copyUpdateResult(pInfo->pStUpdated, pInfo->pUpdated);
+  removeSessionResults(pInfo->pStDeleted, pInfo->pUpdated);
+  tSimpleHashCleanup(pInfo->pStUpdated);
+  pInfo->pStUpdated = NULL;
+  if (pInfo->isHistoryOp) {
+    getMaxTsWins(pInfo->pUpdated, pInfo->historyWins);
+  }
+  initGroupResInfoFromArrayList(&pInfo->groupResInfo, pInfo->pUpdated);
+  pInfo->pUpdated = NULL;
+  blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity);
+
+  SSDataBlock* opRes = buildSessionResult(pOperator);
+  if (opRes) {
+    return opRes;
+  }
+
+  setOperatorCompleted(pOperator);
+  return NULL;
+}
+
+void streamSessionReleaseState(SOperatorInfo* pOperator) {
+  if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION) {
+    SStreamSessionAggOperatorInfo* pInfo = pOperator->info;
+    int32_t                        resSize = taosArrayGetSize(pInfo->historyWins) * sizeof(SSessionKey);
+    pInfo->streamAggSup.stateStore.streamStateSaveInfo(pInfo->streamAggSup.pState, STREAM_SESSION_OP_STATE_NAME,
+                                                       strlen(STREAM_SESSION_OP_STATE_NAME), pInfo->historyWins->pData,
+                                                       resSize);
+  }
+  SOperatorInfo* downstream = pOperator->pDownstream[0];
+  if (downstream->fpSet.releaseStreamStateFn) {
+    downstream->fpSet.releaseStreamStateFn(downstream);
+  }
+}
+
+void resetWinRange(STimeWindow* winRange) {
+  winRange->skey = INT64_MIN;
+  winRange->ekey = INT64_MAX;
+}
+
+void streamSessionReloadState(SOperatorInfo* pOperator) {
+  SStreamSessionAggOperatorInfo* pInfo = pOperator->info;
+  SStreamAggSupporter*           pAggSup = &pInfo->streamAggSup;
+  resetWinRange(&pAggSup->winRange);
+
+  SResultWindowInfo winInfo = {0};
+  int32_t           size = 0;
+  void*             pBuf = NULL;
+  int32_t           code = pAggSup->stateStore.streamStateGetInfo(pAggSup->pState, STREAM_SESSION_OP_STATE_NAME,
+                                                                  strlen(STREAM_SESSION_OP_STATE_NAME), &pBuf, &size);
+  int32_t           num = size / sizeof(SSessionKey);
+  SSessionKey*      pSeKeyBuf = (SSessionKey*)pBuf;
+  ASSERT(size == num * sizeof(SSessionKey));
+  if (!pInfo->pStUpdated && num > 0) {
+    _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
+    pInfo->pStUpdated = tSimpleHashInit(64, hashFn);
+  }
+  for (int32_t i = 0; i < num; i++) {
+    SResultWindowInfo winInfo = {0};
+    setSessionOutputBuf(pAggSup, pSeKeyBuf[i].win.skey, pSeKeyBuf[i].win.ekey, pSeKeyBuf[i].groupId, &winInfo);
+    int32_t winNum = compactSessionWindow(pOperator, &winInfo, pInfo->pStUpdated, pInfo->pStDeleted, true);
+    if (winNum > 0) {
+      qDebug("===stream=== reload state. save result %" PRId64 ", %" PRIu64, winInfo.sessionWin.win.skey,
+             winInfo.sessionWin.groupId);
+      if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE) {
+        saveResult(winInfo, pInfo->pStUpdated);
+      } else if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) {
+        if (!isCloseWindow(&winInfo.sessionWin.win, &pInfo->twAggSup)) {
+          saveDeleteRes(pInfo->pStDeleted, winInfo.sessionWin);
+        }
+        SSessionKey key = {0};
+        getSessionHashKey(&winInfo.sessionWin, &key);
+        tSimpleHashPut(pAggSup->pResultRows, &key, sizeof(SSessionKey), &winInfo, sizeof(SResultWindowInfo));
+      }
+    }
+    saveSessionOutputBuf(pAggSup, &winInfo);
+  }
+  taosMemoryFree(pBuf);
+
+  SOperatorInfo* downstream = pOperator->pDownstream[0];
+  if (downstream->fpSet.reloadStreamStateFn) {
+    downstream->fpSet.reloadStreamStateFn(downstream);
+  }
+}
+
+SOperatorInfo* createStreamSessionAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode,
+                                                  SExecTaskInfo* pTaskInfo, SReadHandle* pHandle) {
+  SSessionWinodwPhysiNode*       pSessionNode = (SSessionWinodwPhysiNode*)pPhyNode;
+  int32_t                        numOfCols = 0;
+  int32_t                        code = TSDB_CODE_OUT_OF_MEMORY;
+  SStreamSessionAggOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamSessionAggOperatorInfo));
+  SOperatorInfo*                 pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
+  if (pInfo == NULL || pOperator == NULL) {
+    goto _error;
+  }
+
+  pOperator->pTaskInfo = pTaskInfo;
+
+  initResultSizeInfo(&pOperator->resultInfo, 4096);
+  if (pSessionNode->window.pExprs != NULL) {
+    int32_t    numOfScalar = 0;
+    SExprInfo* pScalarExprInfo = createExprInfo(pSessionNode->window.pExprs, NULL, &numOfScalar);
+    code = initExprSupp(&pInfo->scalarSupp, pScalarExprInfo, numOfScalar, &pTaskInfo->storageAPI.functionStore);
+    if (code != TSDB_CODE_SUCCESS) {
+      goto _error;
+    }
+  }
+  SExprSupp* pSup = &pOperator->exprSupp;
+
+  SExprInfo*   pExprInfo = createExprInfo(pSessionNode->window.pFuncs, NULL, &numOfCols);
+  SSDataBlock* pResBlock = createDataBlockFromDescNode(pPhyNode->pOutputDataBlockDesc);
+  code = initBasicInfoEx(&pInfo->binfo, pSup, pExprInfo, numOfCols, pResBlock, &pTaskInfo->storageAPI.functionStore);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
+  code = initStreamAggSupporter(&pInfo->streamAggSup, pSup->pCtx, numOfCols, pSessionNode->gap,
+                                pTaskInfo->streamInfo.pState, 0, 0, &pTaskInfo->storageAPI.stateStore, pHandle,
+                                &pTaskInfo->storageAPI);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
+  pInfo->twAggSup = (STimeWindowAggSupp){
+      .waterMark = pSessionNode->window.watermark,
+      .calTrigger = pSessionNode->window.triggerType,
+      .maxTs = INT64_MIN,
+      .minTs = INT64_MAX,
+  };
+
+  initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window);
+
+  pInfo->primaryTsIndex = ((SColumnNode*)pSessionNode->window.pTspk)->slotId;
+  if (pSessionNode->window.pTsEnd) {
+    pInfo->endTsIndex = ((SColumnNode*)pSessionNode->window.pTsEnd)->slotId;
+  }
+  pInfo->binfo.pRes = pResBlock;
+  pInfo->order = TSDB_ORDER_ASC;
+  _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
+  pInfo->pStDeleted = tSimpleHashInit(64, hashFn);
+  pInfo->pDelIterator = NULL;
+  pInfo->pDelRes = createSpecialDataBlock(STREAM_DELETE_RESULT);
+  pInfo->pChildren = NULL;
+  pInfo->pPhyNode = pPhyNode;
+  pInfo->ignoreExpiredData = pSessionNode->window.igExpired;
+  pInfo->ignoreExpiredDataSaved = false;
+  pInfo->pUpdated = NULL;
+  pInfo->pStUpdated = NULL;
+  pInfo->dataVersion = 0;
+  pInfo->historyWins = taosArrayInit(4, sizeof(SSessionKey));
+  if (!pInfo->historyWins) {
+    goto _error;
+  }
+  if (pHandle) {
+    pInfo->isHistoryOp = pHandle->fillHistory;
+  }
+  pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION;
+  setOperatorInfo(pOperator, getStreamOpName(pOperator->operatorType), QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION, true,
+                  OP_NOT_OPENED, pInfo, pTaskInfo);
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamSessionAgg, NULL, destroyStreamSessionAggOperatorInfo,
+                                         optrDefaultBufFn, NULL);
+  setOperatorStreamStateFn(pOperator, streamSessionReleaseState, streamSessionReloadState);
+
+  if (downstream) {
+    initDownStream(downstream, &pInfo->streamAggSup, pOperator->operatorType, pInfo->primaryTsIndex, &pInfo->twAggSup);
+    code = appendDownstream(pOperator, &downstream, 1);
+  }
+  return pOperator;
+
+_error:
+  if (pInfo != NULL) {
+    destroyStreamSessionAggOperatorInfo(pInfo);
+  }
+
+  taosMemoryFreeClear(pOperator);
+  pTaskInfo->code = code;
+  return NULL;
+}
+
+static void clearStreamSessionOperator(SStreamSessionAggOperatorInfo* pInfo) {
+  tSimpleHashClear(pInfo->streamAggSup.pResultRows);
+  pInfo->streamAggSup.stateStore.streamStateSessionClear(pInfo->streamAggSup.pState);
+}
+
+static SSDataBlock* doStreamSessionSemiAgg(SOperatorInfo* pOperator) {
+  SStreamSessionAggOperatorInfo* pInfo = pOperator->info;
+  SOptrBasicInfo*                pBInfo = &pInfo->binfo;
+  TSKEY                          maxTs = INT64_MIN;
+  SExprSupp*                     pSup = &pOperator->exprSupp;
+  SStreamAggSupporter*           pAggSup = &pInfo->streamAggSup;
+  SExecTaskInfo*                 pTaskInfo = pOperator->pTaskInfo;
+
+  qDebug("stask:%s  %s status: %d", GET_TASKID(pTaskInfo), getStreamOpName(pOperator->operatorType), pOperator->status);
+  if (pOperator->status == OP_EXEC_DONE) {
+    return NULL;
+  }
+
+  {
+    SSDataBlock* opRes = buildSessionResult(pOperator);
+    if (opRes) {
+      return opRes;
+    }
+
+    if (pOperator->status == OP_RES_TO_RETURN) {
+      clearFunctionContext(&pOperator->exprSupp);
+      // semi interval operator clear disk buffer
+      clearStreamSessionOperator(pInfo);
+      setOperatorCompleted(pOperator);
+      return NULL;
+    }
+  }
+
+  SOperatorInfo* downstream = pOperator->pDownstream[0];
+  if (!pInfo->pUpdated) {
+    pInfo->pUpdated = taosArrayInit(16, sizeof(SSessionKey));
+  }
+  if (!pInfo->pStUpdated) {
+    _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
+    pInfo->pStUpdated = tSimpleHashInit(64, hashFn);
+  }
+  while (1) {
+    SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
+    if (pBlock == NULL) {
+      clearSpecialDataBlock(pInfo->pUpdateRes);
+      pOperator->status = OP_RES_TO_RETURN;
+      break;
+    }
+    printSpecDataBlock(pBlock, getStreamOpName(pOperator->operatorType), "recv", GET_TASKID(pTaskInfo));
+
+    if (pBlock->info.type == STREAM_DELETE_DATA || pBlock->info.type == STREAM_DELETE_RESULT ||
+        pBlock->info.type == STREAM_CLEAR) {
+      // gap must be 0
+      SArray* pWins = taosArrayInit(16, sizeof(SSessionKey));
+      doDeleteTimeWindows(&pInfo->streamAggSup, pBlock, pWins);
+      removeSessionResults(pInfo->pStUpdated, pWins);
+      copyDeleteWindowInfo(pWins, pInfo->pStDeleted);
+      taosArrayDestroy(pWins);
+      break;
+    } else if (pBlock->info.type == STREAM_GET_ALL) {
+      getAllSessionWindow(pInfo->streamAggSup.pResultRows, pInfo->pStUpdated);
+      continue;
+    } else if (pBlock->info.type == STREAM_CREATE_CHILD_TABLE) {
+      return pBlock;
+    } else {
+      ASSERTS(pBlock->info.type == STREAM_NORMAL || 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);
+    }
+    // the pDataBlock are always the same one, no need to call this again
+    setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true);
+    doStreamSessionAggImpl(pOperator, pBlock, pInfo->pStUpdated, NULL, false, false);
+    maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey);
+  }
+
+  pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, maxTs);
+  pBInfo->pRes->info.watermark = pInfo->twAggSup.maxTs;
+
+  copyUpdateResult(pInfo->pStUpdated, pInfo->pUpdated);
+  removeSessionResults(pInfo->pStDeleted, pInfo->pUpdated);
+  tSimpleHashCleanup(pInfo->pStUpdated);
+  pInfo->pStUpdated = NULL;
+  initGroupResInfoFromArrayList(&pInfo->groupResInfo, pInfo->pUpdated);
+  pInfo->pUpdated = NULL;
+  blockDataEnsureCapacity(pBInfo->pRes, pOperator->resultInfo.capacity);
+
+  SSDataBlock* opRes = buildSessionResult(pOperator);
+  if (opRes) {
+    return opRes;
+  }
+
+  clearFunctionContext(&pOperator->exprSupp);
+  // semi interval operator clear disk buffer
+  clearStreamSessionOperator(pInfo);
+  setOperatorCompleted(pOperator);
+  return NULL;
+}
+
+SOperatorInfo* createStreamFinalSessionAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode,
+                                                       SExecTaskInfo* pTaskInfo, int32_t numOfChild,
+                                                       SReadHandle* pHandle) {
+  int32_t        code = TSDB_CODE_OUT_OF_MEMORY;
+  SOperatorInfo* pOperator = createStreamSessionAggOperatorInfo(downstream, pPhyNode, pTaskInfo, pHandle);
+  if (pOperator == NULL) {
+    goto _error;
+  }
+
+  SStorageAPI*                   pAPI = &pTaskInfo->storageAPI;
+  SStreamSessionAggOperatorInfo* pInfo = pOperator->info;
+  pOperator->operatorType = pPhyNode->type;
+
+  if (pPhyNode->type != QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION) {
+    pInfo->pUpdateRes = createSpecialDataBlock(STREAM_CLEAR);
+    blockDataEnsureCapacity(pInfo->pUpdateRes, 128);
+    pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamSessionSemiAgg, NULL,
+                                           destroyStreamSessionAggOperatorInfo, optrDefaultBufFn, NULL);
+  }
+  setOperatorInfo(pOperator, getStreamOpName(pOperator->operatorType), pPhyNode->type, false, OP_NOT_OPENED, pInfo, pTaskInfo);
+
+  if (numOfChild > 0) {
+    pInfo->pChildren = taosArrayInit(numOfChild, sizeof(void*));
+    for (int32_t i = 0; i < numOfChild; i++) {
+      SOperatorInfo* pChildOp = createStreamFinalSessionAggOperatorInfo(NULL, pPhyNode, pTaskInfo, 0, NULL);
+      if (pChildOp == NULL) {
+        goto _error;
+      }
+      SStreamSessionAggOperatorInfo* pChInfo = pChildOp->info;
+      pChInfo->twAggSup.calTrigger = STREAM_TRIGGER_AT_ONCE;
+      pAPI->stateStore.streamStateSetNumber(pChInfo->streamAggSup.pState, i);
+      taosArrayPush(pInfo->pChildren, &pChildOp);
+    }
+  }
+
+  if (!IS_FINAL_SESSION_OP(pOperator) || numOfChild == 0) {
+    pInfo->twAggSup.calTrigger = STREAM_TRIGGER_AT_ONCE;
+  }
+
+  return pOperator;
+
+_error:
+  if (pInfo != NULL) {
+    destroyStreamSessionAggOperatorInfo(pInfo);
+  }
+  taosMemoryFreeClear(pOperator);
+  pTaskInfo->code = code;
+  return NULL;
+}
+
+void destroyStreamStateOperatorInfo(void* param) {
+  SStreamStateAggOperatorInfo* pInfo = (SStreamStateAggOperatorInfo*)param;
+  cleanupBasicInfo(&pInfo->binfo);
+  destroyStreamAggSupporter(&pInfo->streamAggSup);
+  cleanupGroupResInfo(&pInfo->groupResInfo);
+  if (pInfo->pChildren != NULL) {
+    int32_t size = taosArrayGetSize(pInfo->pChildren);
+    for (int32_t i = 0; i < size; i++) {
+      SOperatorInfo* pChild = taosArrayGetP(pInfo->pChildren, i);
+      destroyOperator(pChild);
+    }
+    taosArrayDestroy(pInfo->pChildren);
+  }
+  colDataDestroy(&pInfo->twAggSup.timeWindowData);
+  blockDataDestroy(pInfo->pDelRes);
+  taosArrayDestroy(pInfo->historyWins);
+  tSimpleHashCleanup(pInfo->pSeUpdated);
+  tSimpleHashCleanup(pInfo->pSeDeleted);
+  taosMemoryFreeClear(param);
+}
+
+bool isTsInWindow(SStateWindowInfo* pWin, TSKEY ts) {
+  if (pWin->winInfo.sessionWin.win.skey <= ts && ts <= pWin->winInfo.sessionWin.win.ekey) {
+    return true;
+  }
+  return false;
+}
+
+bool isEqualStateKey(SStateWindowInfo* pWin, char* pKeyData) {
+  return pKeyData && compareVal(pKeyData, pWin->pStateKey);
+}
+
+bool compareStateKey(void* data, void* key) {
+  if (!data || !key) {
+    return true;
+  }
+  SStateKeys* stateKey = (SStateKeys*)key;
+  stateKey->pData = (char*)key + sizeof(SStateKeys);
+  return compareVal(data, stateKey);
+}
+
+bool compareWinStateKey(SStateKeys* left, SStateKeys* right) {
+  if (!left || !right) {
+    return false;
+  }
+  return compareVal(left->pData, right);
+}
+
+void setStateOutputBuf(SStreamAggSupporter* pAggSup, TSKEY ts, uint64_t groupId, char* pKeyData,
+                       SStateWindowInfo* pCurWin, SStateWindowInfo* pNextWin) {
+  int32_t size = pAggSup->resultRowSize;
+  pCurWin->winInfo.sessionWin.groupId = groupId;
+  pCurWin->winInfo.sessionWin.win.skey = ts;
+  pCurWin->winInfo.sessionWin.win.ekey = ts;
+  int32_t code = pAggSup->stateStore.streamStateStateAddIfNotExist(pAggSup->pState, &pCurWin->winInfo.sessionWin,
+                                                                   pKeyData, pAggSup->stateKeySize, compareStateKey,
+                                                                   &pCurWin->winInfo.pOutputBuf, &size);
+  pCurWin->pStateKey =
+      (SStateKeys*)((char*)pCurWin->winInfo.pOutputBuf + (pAggSup->resultRowSize - pAggSup->stateKeySize));
+  pCurWin->pStateKey->bytes = pAggSup->stateKeySize - sizeof(SStateKeys);
+  pCurWin->pStateKey->type = pAggSup->stateKeyType;
+  pCurWin->pStateKey->pData = (char*)pCurWin->pStateKey + sizeof(SStateKeys);
+  pCurWin->pStateKey->isNull = false;
+
+  if (code == TSDB_CODE_SUCCESS && !inWinRange(&pAggSup->winRange, &pCurWin->winInfo.sessionWin.win)) {
+    code = TSDB_CODE_FAILED;
+    releaseOutputBuf(pAggSup->pState, NULL, (SResultRow*)pCurWin->winInfo.pOutputBuf,
+                     &pAggSup->pSessionAPI->stateStore);
+    pCurWin->winInfo.pOutputBuf = taosMemoryCalloc(1, size);
+    pCurWin->pStateKey =
+        (SStateKeys*)((char*)pCurWin->winInfo.pOutputBuf + (pAggSup->resultRowSize - pAggSup->stateKeySize));
+    pCurWin->pStateKey->bytes = pAggSup->stateKeySize - sizeof(SStateKeys);
+    pCurWin->pStateKey->type = pAggSup->stateKeyType;
+    pCurWin->pStateKey->pData = (char*)pCurWin->pStateKey + sizeof(SStateKeys);
+    pCurWin->pStateKey->isNull = false;
+    pCurWin->winInfo.sessionWin.groupId = groupId;
+    pCurWin->winInfo.sessionWin.win.skey = ts;
+    pCurWin->winInfo.sessionWin.win.ekey = ts;
+    qDebug("===stream===reset state win key. skey:%" PRId64 ", endkey:%" PRId64, pCurWin->winInfo.sessionWin.win.skey,
+           pCurWin->winInfo.sessionWin.win.ekey);
+  }
+
+  if (code == TSDB_CODE_SUCCESS) {
+    pCurWin->winInfo.isOutput = true;
+    pAggSup->stateStore.streamStateSessionDel(pAggSup->pState, &pCurWin->winInfo.sessionWin);
+  } else if (pKeyData) {
+    if (IS_VAR_DATA_TYPE(pAggSup->stateKeyType)) {
+      varDataCopy(pCurWin->pStateKey->pData, pKeyData);
+    } else {
+      memcpy(pCurWin->pStateKey->pData, pKeyData, pCurWin->pStateKey->bytes);
+    }
+  }
+
+  pNextWin->winInfo.sessionWin = pCurWin->winInfo.sessionWin;
+  SStreamStateCur* pCur =
+      pAggSup->stateStore.streamStateSessionSeekKeyNext(pAggSup->pState, &pNextWin->winInfo.sessionWin);
+  int32_t nextSize = pAggSup->resultRowSize;
+  code = pAggSup->stateStore.streamStateSessionGetKVByCur(pCur, &pNextWin->winInfo.sessionWin,
+                                                          &pNextWin->winInfo.pOutputBuf, &nextSize);
+  if (code != TSDB_CODE_SUCCESS) {
+    SET_SESSION_WIN_INVALID(pNextWin->winInfo);
+  } else {
+    pNextWin->pStateKey =
+        (SStateKeys*)((char*)pNextWin->winInfo.pOutputBuf + (pAggSup->resultRowSize - pAggSup->stateKeySize));
+    pNextWin->pStateKey->bytes = pAggSup->stateKeySize - sizeof(SStateKeys);
+    pNextWin->pStateKey->type = pAggSup->stateKeyType;
+    pNextWin->pStateKey->pData = (char*)pNextWin->pStateKey + sizeof(SStateKeys);
+    pNextWin->pStateKey->isNull = false;
+    pNextWin->winInfo.isOutput = true;
+  }
+  pAggSup->stateStore.streamStateFreeCur(pCur);
+}
+
+int32_t updateStateWindowInfo(SStateWindowInfo* pWinInfo, SStateWindowInfo* pNextWin, TSKEY* pTs, uint64_t groupId,
+                              SColumnInfoData* pKeyCol, int32_t rows, int32_t start, bool* allEqual,
+                              SSHashObj* pResultRows, SSHashObj* pSeUpdated, SSHashObj* pSeDeleted) {
+  *allEqual = true;
+  for (int32_t i = start; i < rows; ++i) {
+    char* pKeyData = colDataGetData(pKeyCol, i);
+    if (!isTsInWindow(pWinInfo, pTs[i])) {
+      if (isEqualStateKey(pWinInfo, pKeyData)) {
+        if (IS_VALID_SESSION_WIN(pNextWin->winInfo)) {
+          // ts belongs to the next window
+          if (pTs[i] >= pNextWin->winInfo.sessionWin.win.skey) {
+            return i - start;
+          }
+        }
+      } else {
+        return i - start;
+      }
+    }
+
+    if (pWinInfo->winInfo.sessionWin.win.skey > pTs[i]) {
+      if (pSeDeleted && pWinInfo->winInfo.isOutput) {
+        saveDeleteRes(pSeDeleted, pWinInfo->winInfo.sessionWin);
+      }
+      removeSessionResult(pSeUpdated, pResultRows, pWinInfo->winInfo.sessionWin);
+      pWinInfo->winInfo.sessionWin.win.skey = pTs[i];
+    }
+    pWinInfo->winInfo.sessionWin.win.ekey = TMAX(pWinInfo->winInfo.sessionWin.win.ekey, pTs[i]);
+    if (!isEqualStateKey(pWinInfo, pKeyData)) {
+      *allEqual = false;
+    }
+  }
+  return rows - start;
+}
+
+static void doStreamStateAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBlock, SSHashObj* pSeUpdated,
+                                 SSHashObj* pStDeleted) {
+  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
+  SStorageAPI*   pAPI = &pOperator->pTaskInfo->storageAPI;
+
+  SStreamStateAggOperatorInfo* pInfo = pOperator->info;
+  int32_t                      numOfOutput = pOperator->exprSupp.numOfExprs;
+  uint64_t                     groupId = pSDataBlock->info.id.groupId;
+  int64_t                      code = TSDB_CODE_SUCCESS;
+  TSKEY*                       tsCols = NULL;
+  SResultRow*                  pResult = NULL;
+  int32_t                      winRows = 0;
+  SStreamAggSupporter*         pAggSup = &pInfo->streamAggSup;
+
+  pInfo->dataVersion = TMAX(pInfo->dataVersion, pSDataBlock->info.version);
+  pAggSup->winRange = pTaskInfo->streamInfo.fillHistoryWindow;
+  if (pAggSup->winRange.ekey <= 0) {
+    pAggSup->winRange.ekey = INT64_MAX;
+  }
+
+  if (pSDataBlock->pDataBlock != NULL) {
+    SColumnInfoData* pColDataInfo = taosArrayGet(pSDataBlock->pDataBlock, pInfo->primaryTsIndex);
+    tsCols = (int64_t*)pColDataInfo->pData;
+  } else {
+    return;
+  }
+
+  int32_t rows = pSDataBlock->info.rows;
+  blockDataEnsureCapacity(pAggSup->pScanBlock, rows);
+  SColumnInfoData* pKeyColInfo = taosArrayGet(pSDataBlock->pDataBlock, pInfo->stateCol.slotId);
+  for (int32_t i = 0; i < rows; i += winRows) {
+    if (pInfo->ignoreExpiredData && isOverdue(tsCols[i], &pInfo->twAggSup) || colDataIsNull_s(pKeyColInfo, i)) {
+      i++;
+      continue;
+    }
+    char*            pKeyData = colDataGetData(pKeyColInfo, i);
+    int32_t          winIndex = 0;
+    bool             allEqual = true;
+    SStateWindowInfo curWin = {0};
+    SStateWindowInfo nextWin = {0};
+    setStateOutputBuf(pAggSup, tsCols[i], groupId, pKeyData, &curWin, &nextWin);
+    if (IS_VALID_SESSION_WIN(nextWin.winInfo)) {
+      releaseOutputBuf(pAggSup->pState, NULL, (SResultRow*)nextWin.winInfo.pOutputBuf, &pAPI->stateStore);
+    }
+    setSessionWinOutputInfo(pSeUpdated, &curWin.winInfo);
+    winRows = updateStateWindowInfo(&curWin, &nextWin, tsCols, groupId, pKeyColInfo, rows, i, &allEqual,
+                                    pAggSup->pResultRows, pSeUpdated, pStDeleted);
+    if (!allEqual) {
+      uint64_t uid = 0;
+      appendOneRowToStreamSpecialBlock(pAggSup->pScanBlock, &curWin.winInfo.sessionWin.win.skey,
+                                       &curWin.winInfo.sessionWin.win.ekey, &uid, &groupId, NULL);
+      tSimpleHashRemove(pSeUpdated, &curWin.winInfo.sessionWin, sizeof(SSessionKey));
+      doDeleteSessionWindow(pAggSup, &curWin.winInfo.sessionWin);
+      releaseOutputBuf(pAggSup->pState, NULL, (SResultRow*)curWin.winInfo.pOutputBuf, &pAPI->stateStore);
+      continue;
+    }
+    code = doOneWindowAggImpl(&pInfo->twAggSup.timeWindowData, &curWin.winInfo, &pResult, i, winRows, rows, numOfOutput,
+                              pOperator, 0);
+    if (code != TSDB_CODE_SUCCESS || pResult == NULL) {
+      T_LONG_JMP(pTaskInfo->env, TSDB_CODE_OUT_OF_MEMORY);
+    }
+    saveSessionOutputBuf(pAggSup, &curWin.winInfo);
+
+    if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE) {
+      code = saveResult(curWin.winInfo, pSeUpdated);
+      if (code != TSDB_CODE_SUCCESS) {
+        T_LONG_JMP(pTaskInfo->env, TSDB_CODE_OUT_OF_MEMORY);
+      }
+    }
+
+    if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) {
+      SSessionKey key = {0};
+      getSessionHashKey(&curWin.winInfo.sessionWin, &key);
+      tSimpleHashPut(pAggSup->pResultRows, &key, sizeof(SSessionKey), &curWin.winInfo, sizeof(SResultWindowInfo));
+    }
+  }
+}
+
+static SSDataBlock* buildStateResult(SOperatorInfo* pOperator) {
+  SStreamStateAggOperatorInfo* pInfo = pOperator->info;
+  SOptrBasicInfo*              pBInfo = &pInfo->binfo;
+  SExecTaskInfo*               pTaskInfo = pOperator->pTaskInfo;
+
+  doBuildDeleteDataBlock(pOperator, pInfo->pSeDeleted, pInfo->pDelRes, &pInfo->pDelIterator);
+  if (pInfo->pDelRes->info.rows > 0) {
+    printDataBlock(pInfo->pDelRes, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));
+    return pInfo->pDelRes;
+  }
+
+  doBuildSessionResult(pOperator, pInfo->streamAggSup.pState, &pInfo->groupResInfo, pBInfo->pRes);
+  if (pBInfo->pRes->info.rows > 0) {
+    printDataBlock(pBInfo->pRes, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));
+    return pBInfo->pRes;
+  }
+  return NULL;
+}
+
+static SSDataBlock* doStreamStateAgg(SOperatorInfo* pOperator) {
+  if (pOperator->status == OP_EXEC_DONE) {
+    return NULL;
+  }
+
+  SExprSupp*                   pSup = &pOperator->exprSupp;
+  SStreamStateAggOperatorInfo* pInfo = pOperator->info;
+  SOptrBasicInfo*              pBInfo = &pInfo->binfo;
+  SExecTaskInfo*               pTaskInfo = pOperator->pTaskInfo;
+  qDebug("===stream=== stream state agg");
+  if (pOperator->status == OP_RES_TO_RETURN) {
+    SSDataBlock* resBlock = buildStateResult(pOperator);
+    if (resBlock != NULL) {
+      return resBlock;
+    }
+
+    setOperatorCompleted(pOperator);
+    return NULL;
+  }
+
+  SOperatorInfo* downstream = pOperator->pDownstream[0];
+  if (!pInfo->pUpdated) {
+    pInfo->pUpdated = taosArrayInit(16, sizeof(SSessionKey));
+  }
+  if (!pInfo->pSeUpdated) {
+    _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
+    pInfo->pSeUpdated = tSimpleHashInit(64, hashFn);
+  }
+  while (1) {
+    SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
+    if (pBlock == NULL) {
+      break;
+    }
+    printDataBlock(pBlock, "single state recv", GET_TASKID(pTaskInfo));
+
+    if (pBlock->info.type == STREAM_DELETE_DATA || pBlock->info.type == STREAM_DELETE_RESULT ||
+        pBlock->info.type == STREAM_CLEAR) {
+      SArray* pWins = taosArrayInit(16, sizeof(SSessionKey));
+      doDeleteTimeWindows(&pInfo->streamAggSup, pBlock, pWins);
+      removeSessionResults(pInfo->pSeUpdated, pWins);
+      copyDeleteWindowInfo(pWins, pInfo->pSeDeleted);
+      taosArrayDestroy(pWins);
+      continue;
+    } else if (pBlock->info.type == STREAM_GET_ALL) {
+      getAllSessionWindow(pInfo->streamAggSup.pResultRows, pInfo->pSeUpdated);
+      continue;
+    } else if (pBlock->info.type == STREAM_CREATE_CHILD_TABLE) {
+      return pBlock;
+    } else {
+      ASSERTS(pBlock->info.type == STREAM_NORMAL || 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);
+    }
+    // the pDataBlock are always the same one, no need to call this again
+    setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true);
+    doStreamStateAggImpl(pOperator, pBlock, pInfo->pSeUpdated, pInfo->pSeDeleted);
+    pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey);
+  }
+  // restore the value
+  pOperator->status = OP_RES_TO_RETURN;
+
+  closeSessionWindow(pInfo->streamAggSup.pResultRows, &pInfo->twAggSup, pInfo->pSeUpdated);
+  copyUpdateResult(pInfo->pSeUpdated, pInfo->pUpdated);
+  removeSessionResults(pInfo->pSeDeleted, pInfo->pUpdated);
+  tSimpleHashCleanup(pInfo->pSeUpdated);
+  pInfo->pSeUpdated = NULL;
+
+  if (pInfo->isHistoryOp) {
+    getMaxTsWins(pInfo->pUpdated, pInfo->historyWins);
+  }
+
+  initGroupResInfoFromArrayList(&pInfo->groupResInfo, pInfo->pUpdated);
+  pInfo->pUpdated = NULL;
+  blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity);
+
+  SSDataBlock* resBlock = buildStateResult(pOperator);
+  if (resBlock != NULL) {
+    return resBlock;
+  }
+  setOperatorCompleted(pOperator);
+  return NULL;
+}
+
+void streamStateReleaseState(SOperatorInfo* pOperator) {
+  SStreamStateAggOperatorInfo* pInfo = pOperator->info;
+  int32_t                      resSize = taosArrayGetSize(pInfo->historyWins) * sizeof(SSessionKey);
+  qDebug("===stream=== relase state. save result count:%d", (int32_t)taosArrayGetSize(pInfo->historyWins));
+  pInfo->streamAggSup.stateStore.streamStateSaveInfo(pInfo->streamAggSup.pState, STREAM_STATE_OP_STATE_NAME,
+                                                     strlen(STREAM_STATE_OP_STATE_NAME), pInfo->historyWins->pData,
+                                                     resSize);
+  SOperatorInfo* downstream = pOperator->pDownstream[0];
+  if (downstream->fpSet.releaseStreamStateFn) {
+    downstream->fpSet.releaseStreamStateFn(downstream);
+  }
+}
+
+static void compactStateWindow(SOperatorInfo* pOperator, SResultWindowInfo* pCurWin, SResultWindowInfo* pNextWin,
+                               SSHashObj* pStUpdated, SSHashObj* pStDeleted) {
+  SExprSupp*     pSup = &pOperator->exprSupp;
+  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
+  SStorageAPI*   pAPI = &pOperator->pTaskInfo->storageAPI;
+
+  SStreamStateAggOperatorInfo* pInfo = pOperator->info;
+  SResultRow*                  pCurResult = NULL;
+  int32_t                      numOfOutput = pOperator->exprSupp.numOfExprs;
+  SStreamAggSupporter*         pAggSup = &pInfo->streamAggSup;
+  initSessionOutputBuf(pCurWin, &pCurResult, pSup->pCtx, numOfOutput, pSup->rowEntryInfoOffset);
+  SResultRow* pWinResult = NULL;
+  initSessionOutputBuf(pNextWin, &pWinResult, pAggSup->pDummyCtx, numOfOutput, pSup->rowEntryInfoOffset);
+  pCurWin->sessionWin.win.ekey = TMAX(pCurWin->sessionWin.win.ekey, pNextWin->sessionWin.win.ekey);
+
+  updateTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pCurWin->sessionWin.win, 1);
+  compactFunctions(pSup->pCtx, pAggSup->pDummyCtx, numOfOutput, pTaskInfo, &pInfo->twAggSup.timeWindowData);
+  tSimpleHashRemove(pStUpdated, &pNextWin->sessionWin, sizeof(SSessionKey));
+  if (pNextWin->isOutput && pStDeleted) {
+    qDebug("===stream=== save delete window info %" PRId64 ", %" PRIu64, pNextWin->sessionWin.win.skey,
+           pNextWin->sessionWin.groupId);
+    saveDeleteRes(pStDeleted, pNextWin->sessionWin);
+  }
+  removeSessionResult(pStUpdated, pAggSup->pResultRows, pNextWin->sessionWin);
+  doDeleteSessionWindow(pAggSup, &pNextWin->sessionWin);
+  taosMemoryFree(pNextWin->pOutputBuf);
+}
+
+void streamStateReloadState(SOperatorInfo* pOperator) {
+  SStreamStateAggOperatorInfo* pInfo = pOperator->info;
+  SStreamAggSupporter*         pAggSup = &pInfo->streamAggSup;
+  resetWinRange(&pAggSup->winRange);
+
+  SSessionKey seKey = {.win.skey = INT64_MIN, .win.ekey = INT64_MIN, .groupId = 0};
+  int32_t     size = 0;
+  void*       pBuf = NULL;
+  int32_t     code = pAggSup->stateStore.streamStateGetInfo(pAggSup->pState, STREAM_STATE_OP_STATE_NAME,
+                                                            strlen(STREAM_STATE_OP_STATE_NAME), &pBuf, &size);
+  int32_t     num = size / sizeof(SSessionKey);
+  qDebug("===stream=== reload state. get result count:%d", num);
+  SSessionKey* pSeKeyBuf = (SSessionKey*)pBuf;
+  ASSERT(size == num * sizeof(SSessionKey));
+  if (!pInfo->pSeUpdated && num > 0) {
+    _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
+    pInfo->pSeUpdated = tSimpleHashInit(64, hashFn);
+  }
+  if (!pInfo->pSeDeleted && num > 0) {
+    _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
+    pInfo->pSeDeleted = tSimpleHashInit(64, hashFn);
+  }
+  for (int32_t i = 0; i < num; i++) {
+    SStateWindowInfo curInfo = {0};
+    SStateWindowInfo nextInfo = {0};
+    SStateWindowInfo dummy = {0};
+    qDebug("===stream=== reload state. try process result %" PRId64 ", %" PRIu64 ", index:%d", pSeKeyBuf[i].win.skey,
+           pSeKeyBuf[i].groupId, i);
+    setStateOutputBuf(pAggSup, pSeKeyBuf[i].win.skey, pSeKeyBuf[i].groupId, NULL, &curInfo, &nextInfo);
+    bool cpRes = compareWinStateKey(curInfo.pStateKey, nextInfo.pStateKey);
+    qDebug("===stream=== reload state. next window info %" PRId64 ", %" PRIu64 ", compare:%d",
+           nextInfo.winInfo.sessionWin.win.skey, nextInfo.winInfo.sessionWin.groupId, cpRes);
+    if (cpRes) {
+      compactStateWindow(pOperator, &curInfo.winInfo, &nextInfo.winInfo, pInfo->pSeUpdated, pInfo->pSeDeleted);
+      qDebug("===stream=== reload state. save result %" PRId64 ", %" PRIu64, curInfo.winInfo.sessionWin.win.skey,
+             curInfo.winInfo.sessionWin.groupId);
+      if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE) {
+        saveResult(curInfo.winInfo, pInfo->pSeUpdated);
+      } else if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) {
+        if (!isCloseWindow(&curInfo.winInfo.sessionWin.win, &pInfo->twAggSup)) {
+          saveDeleteRes(pInfo->pSeDeleted, curInfo.winInfo.sessionWin);
+        }
+        SSessionKey key = {0};
+        getSessionHashKey(&curInfo.winInfo.sessionWin, &key);
+        tSimpleHashPut(pAggSup->pResultRows, &key, sizeof(SSessionKey), &curInfo.winInfo, sizeof(SResultWindowInfo));
+      }
+    } else if (IS_VALID_SESSION_WIN(nextInfo.winInfo)) {
+      releaseOutputBuf(pAggSup->pState, NULL, (SResultRow*)nextInfo.winInfo.pOutputBuf,
+                       &pAggSup->pSessionAPI->stateStore);
+    }
+
+    if (IS_VALID_SESSION_WIN(curInfo.winInfo)) {
+      saveSessionOutputBuf(pAggSup, &curInfo.winInfo);
+    }
+  }
+  taosMemoryFree(pBuf);
+
+  SOperatorInfo* downstream = pOperator->pDownstream[0];
+  if (downstream->fpSet.reloadStreamStateFn) {
+    downstream->fpSet.reloadStreamStateFn(downstream);
+  }
+}
+
+SOperatorInfo* createStreamStateAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode,
+                                                SExecTaskInfo* pTaskInfo, SReadHandle* pHandle) {
+  SStreamStateWinodwPhysiNode* pStateNode = (SStreamStateWinodwPhysiNode*)pPhyNode;
+  int32_t                      tsSlotId = ((SColumnNode*)pStateNode->window.pTspk)->slotId;
+  SColumnNode*                 pColNode = (SColumnNode*)(pStateNode->pStateKey);
+  int32_t                      code = TSDB_CODE_SUCCESS;
+
+  SStreamStateAggOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamStateAggOperatorInfo));
+  SOperatorInfo*               pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
+  if (pInfo == NULL || pOperator == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _error;
+  }
+
+  pInfo->stateCol = extractColumnFromColumnNode(pColNode);
+  initResultSizeInfo(&pOperator->resultInfo, 4096);
+  if (pStateNode->window.pExprs != NULL) {
+    int32_t    numOfScalar = 0;
+    SExprInfo* pScalarExprInfo = createExprInfo(pStateNode->window.pExprs, NULL, &numOfScalar);
+    code = initExprSupp(&pInfo->scalarSupp, pScalarExprInfo, numOfScalar, &pTaskInfo->storageAPI.functionStore);
+    if (code != TSDB_CODE_SUCCESS) {
+      goto _error;
+    }
+  }
+
+  pInfo->twAggSup = (STimeWindowAggSupp){
+      .waterMark = pStateNode->window.watermark,
+      .calTrigger = pStateNode->window.triggerType,
+      .maxTs = INT64_MIN,
+      .minTs = INT64_MAX,
+  };
+
+  initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window);
+
+  SExprSupp*   pSup = &pOperator->exprSupp;
+  int32_t      numOfCols = 0;
+  SExprInfo*   pExprInfo = createExprInfo(pStateNode->window.pFuncs, NULL, &numOfCols);
+  SSDataBlock* pResBlock = createDataBlockFromDescNode(pPhyNode->pOutputDataBlockDesc);
+  code = initBasicInfoEx(&pInfo->binfo, pSup, pExprInfo, numOfCols, pResBlock, &pTaskInfo->storageAPI.functionStore);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+  int32_t keySize = sizeof(SStateKeys) + pColNode->node.resType.bytes;
+  int16_t type = pColNode->node.resType.type;
+  code = initStreamAggSupporter(&pInfo->streamAggSup, pSup->pCtx, numOfCols, 0, pTaskInfo->streamInfo.pState, keySize,
+                                type, &pTaskInfo->storageAPI.stateStore, pHandle, &pTaskInfo->storageAPI);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
+  pInfo->primaryTsIndex = tsSlotId;
+  _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
+  pInfo->pSeDeleted = tSimpleHashInit(64, hashFn);
+  pInfo->pDelIterator = NULL;
+  pInfo->pDelRes = createSpecialDataBlock(STREAM_DELETE_RESULT);
+  pInfo->pChildren = NULL;
+  pInfo->ignoreExpiredData = pStateNode->window.igExpired;
+  pInfo->ignoreExpiredDataSaved = false;
+  pInfo->pUpdated = NULL;
+  pInfo->pSeUpdated = NULL;
+  pInfo->dataVersion = 0;
+  pInfo->historyWins = taosArrayInit(4, sizeof(SSessionKey));
+  if (!pInfo->historyWins) {
+    goto _error;
+  }
+  if (pHandle) {
+    pInfo->isHistoryOp = pHandle->fillHistory;
+  }
+
+  setOperatorInfo(pOperator, "StreamStateAggOperator", QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE, true, OP_NOT_OPENED,
+                  pInfo, pTaskInfo);
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamStateAgg, NULL, destroyStreamStateOperatorInfo,
+                                         optrDefaultBufFn, NULL);
+  setOperatorStreamStateFn(pOperator, streamStateReleaseState, streamStateReloadState);
+  initDownStream(downstream, &pInfo->streamAggSup, pOperator->operatorType, pInfo->primaryTsIndex, &pInfo->twAggSup);
+  code = appendDownstream(pOperator, &downstream, 1);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+  return pOperator;
+
+_error:
+  destroyStreamStateOperatorInfo(pInfo);
+  taosMemoryFreeClear(pOperator);
+  pTaskInfo->code = code;
+  return NULL;
+}
+
+static void cleanupAfterGroupResultGen(SMergeAlignedIntervalAggOperatorInfo* pMiaInfo, SSDataBlock* pRes) {
+  pRes->info.id.groupId = pMiaInfo->groupId;
+  pMiaInfo->curTs = INT64_MIN;
+  pMiaInfo->groupId = 0;
+}
+
+static void setInverFunction(SqlFunctionCtx* pCtx, int32_t num, EStreamType type) {
+  for (int i = 0; i < num; i++) {
+    if (type == STREAM_INVERT) {
+      fmSetInvertFunc(pCtx[i].functionId, &(pCtx[i].fpSet));
+    } else if (type == STREAM_NORMAL) {
+      fmSetNormalFunc(pCtx[i].functionId, &(pCtx[i].fpSet));
+    }
+  }
+}
+
+static SSDataBlock* doStreamIntervalAgg(SOperatorInfo* pOperator) {
+  SStreamIntervalOperatorInfo* pInfo = pOperator->info;
+  SExecTaskInfo*               pTaskInfo = pOperator->pTaskInfo;
+  SStorageAPI*                 pAPI = &pOperator->pTaskInfo->storageAPI;
+  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;
+  }
+
+  if (pOperator->status == OP_RES_TO_RETURN) {
+    SSDataBlock* resBlock = buildIntervalResult(pOperator);
+    if (resBlock != NULL) {
+      return resBlock;
+    }
+
+    if (pInfo->recvGetAll) {
+      pInfo->recvGetAll = false;
+      resetUnCloseWinInfo(pInfo->aggSup.pResultRowHashTable);
+    }
+
+    setOperatorCompleted(pOperator);
+    if (pInfo->twAggSup.maxTs > 0 &&
+        pInfo->twAggSup.maxTs - pInfo->twAggSup.checkPointInterval > pInfo->twAggSup.checkPointTs) {
+      pAPI->stateStore.streamStateCommit(pInfo->pState);
+      pAPI->stateStore.streamStateDeleteCheckPoint(pInfo->pState, pInfo->twAggSup.maxTs - pInfo->twAggSup.deleteMark);
+      setStreamDataVersion(pTaskInfo, pInfo->dataVersion, pInfo->pState->checkPointId);
+      pInfo->twAggSup.checkPointTs = pInfo->twAggSup.maxTs;
+    }
+    return NULL;
+  }
+
+  SOperatorInfo* downstream = pOperator->pDownstream[0];
+
+  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) {
+    SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
+    if (pBlock == NULL) {
+      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_DELETE_DATA || pBlock->info.type == STREAM_DELETE_RESULT ||
+        pBlock->info.type == STREAM_CLEAR) {
+      doDeleteWindows(pOperator, &pInfo->interval, pBlock, pInfo->pDelWins, pInfo->pUpdatedMap);
+      continue;
+    } else if (pBlock->info.type == STREAM_GET_ALL) {
+      qDebug("===stream===%s recv|block type STREAM_GET_ALL", getStreamOpName(pOperator->operatorType));
+      pInfo->recvGetAll = true;
+      getAllIntervalWindow(pInfo->aggSup.pResultRowHashTable, pInfo->pUpdatedMap);
+      continue;
+    } else if (pBlock->info.type == STREAM_CREATE_CHILD_TABLE) {
+      printDataBlock(pBlock, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));
+      return pBlock;
+    } else {
+      ASSERTS(pBlock->info.type == STREAM_NORMAL || pBlock->info.type == STREAM_INVALID, "invalid SSDataBlock type");
+    }
+
+    if (pBlock->info.type == STREAM_NORMAL && pBlock->info.version != 0) {
+      // set input version
+      pTaskInfo->version = pBlock->info.version;
+    }
+
+    if (pInfo->scalarSupp.pExprInfo != NULL) {
+      SExprSupp* pExprSup = &pInfo->scalarSupp;
+      projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL);
+    }
+
+    // The timewindow that overlaps the timestamps of the input pBlock need to be recalculated and return to the
+    // caller. Note that all the time window are not close till now.
+    // the pDataBlock are always the same one, no need to call this again
+    setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true);
+    if (pInfo->invertible) {
+      setInverFunction(pSup->pCtx, pOperator->exprSupp.numOfExprs, pBlock->info.type);
+    }
+
+    doStreamIntervalAggImpl(pOperator, pBlock, pBlock->info.id.groupId, pInfo->pUpdatedMap);
+    pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey);
+    pInfo->twAggSup.minTs = TMIN(pInfo->twAggSup.minTs, pBlock->info.window.skey);
+  }
+  pOperator->status = OP_RES_TO_RETURN;
+  removeDeleteResults(pInfo->pUpdatedMap, pInfo->pDelWins);
+  closeStreamIntervalWindow(pInfo->aggSup.pResultRowHashTable, &pInfo->twAggSup, &pInfo->interval, NULL,
+                            pInfo->pUpdatedMap, pInfo->pDelWins, pOperator);
+
+  void*   pIte = NULL;
+  int32_t iter = 0;
+  while ((pIte = tSimpleHashIterate(pInfo->pUpdatedMap, pIte, &iter)) != NULL) {
+    taosArrayPush(pInfo->pUpdated, pIte);
+  }
+  taosArraySort(pInfo->pUpdated, winPosCmprImpl);
+
+  initMultiResInfoFromArrayList(&pInfo->groupResInfo, pInfo->pUpdated);
+  pInfo->pUpdated = NULL;
+  blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity);
+  tSimpleHashCleanup(pInfo->pUpdatedMap);
+  pInfo->pUpdatedMap = NULL;
+
+  return buildIntervalResult(pOperator);
+}
+
+SOperatorInfo* createStreamIntervalOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode,
+                                                SExecTaskInfo* pTaskInfo) {
+  SStreamIntervalOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamIntervalOperatorInfo));
+  SOperatorInfo*               pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
+  if (pInfo == NULL || pOperator == NULL) {
+    goto _error;
+  }
+  SStreamIntervalPhysiNode* pIntervalPhyNode = (SStreamIntervalPhysiNode*)pPhyNode;
+
+  int32_t    code = TSDB_CODE_SUCCESS;
+  int32_t    numOfCols = 0;
+  SExprInfo* pExprInfo = createExprInfo(pIntervalPhyNode->window.pFuncs, NULL, &numOfCols);
+
+  SSDataBlock* pResBlock = createDataBlockFromDescNode(pPhyNode->pOutputDataBlockDesc);
+  pInfo->interval = (SInterval){
+      .interval = pIntervalPhyNode->interval,
+      .sliding = pIntervalPhyNode->sliding,
+      .intervalUnit = pIntervalPhyNode->intervalUnit,
+      .slidingUnit = pIntervalPhyNode->slidingUnit,
+      .offset = pIntervalPhyNode->offset,
+      .precision = ((SColumnNode*)pIntervalPhyNode->window.pTspk)->node.resType.precision,
+  };
+
+  pInfo->twAggSup = (STimeWindowAggSupp){
+      .waterMark = pIntervalPhyNode->window.watermark,
+      .calTrigger = pIntervalPhyNode->window.triggerType,
+      .maxTs = INT64_MIN,
+      .minTs = INT64_MAX,
+      .deleteMark = getDeleteMark(pIntervalPhyNode),
+      .checkPointTs = 0,
+      .checkPointInterval =
+          convertTimePrecision(tsCheckpointInterval, TSDB_TIME_PRECISION_MILLI, pInfo->interval.precision),
+  };
+
+  ASSERTS(pInfo->twAggSup.calTrigger != STREAM_TRIGGER_MAX_DELAY, "trigger type should not be max delay");
+
+  pOperator->pTaskInfo = pTaskInfo;
+  SStorageAPI* pAPI = &pOperator->pTaskInfo->storageAPI;
+
+  pInfo->ignoreExpiredData = pIntervalPhyNode->window.igExpired;
+  pInfo->ignoreExpiredDataSaved = false;
+
+  SExprSupp* pSup = &pOperator->exprSupp;
+  initBasicInfo(&pInfo->binfo, pResBlock);
+  initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window);
+
+  pInfo->primaryTsIndex = ((SColumnNode*)pIntervalPhyNode->window.pTspk)->slotId;
+  initResultSizeInfo(&pOperator->resultInfo, 4096);
+
+  pInfo->pState = taosMemoryCalloc(1, sizeof(SStreamState));
+  *(pInfo->pState) = *(pTaskInfo->streamInfo.pState);
+  pAPI->stateStore.streamStateSetNumber(pInfo->pState, -1);
+
+  size_t keyBufSize = sizeof(int64_t) + sizeof(int64_t) + POINTER_BYTES;
+  code = initAggSup(pSup, &pInfo->aggSup, pExprInfo, numOfCols, keyBufSize, pTaskInfo->id.str, pInfo->pState,
+                    &pTaskInfo->storageAPI.functionStore);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
+  if (pIntervalPhyNode->window.pExprs != NULL) {
+    int32_t    numOfScalar = 0;
+    SExprInfo* pScalarExprInfo = createExprInfo(pIntervalPhyNode->window.pExprs, NULL, &numOfScalar);
+    code = initExprSupp(&pInfo->scalarSupp, pScalarExprInfo, numOfScalar, &pTaskInfo->storageAPI.functionStore);
+    if (code != TSDB_CODE_SUCCESS) {
+      goto _error;
+    }
+  }
+
+  pInfo->invertible = false;
+  pInfo->pDelWins = taosArrayInit(4, sizeof(SWinKey));
+  pInfo->delIndex = 0;
+  pInfo->pDelRes = createSpecialDataBlock(STREAM_DELETE_RESULT);
+  initResultRowInfo(&pInfo->binfo.resultRowInfo);
+
+  pInfo->pPhyNode = NULL;  // create new child
+  pInfo->pPullDataMap = NULL;
+  pInfo->pFinalPullDataMap = NULL;
+  pInfo->pPullWins = NULL;  // SPullWindowInfo
+  pInfo->pullIndex = 0;
+  pInfo->pPullDataRes = NULL;
+  pInfo->numOfChild = 0;
+  pInfo->delKey.ts = INT64_MAX;
+  pInfo->delKey.groupId = 0;
+  pInfo->numOfDatapack = 0;
+  pInfo->pUpdated = NULL;
+  pInfo->pUpdatedMap = NULL;
+  int32_t funResSize = getMaxFunResSize(pSup, numOfCols);
+
+  pInfo->pState->pFileState = pTaskInfo->storageAPI.stateStore.streamFileStateInit(
+      tsStreamBufferSize, sizeof(SWinKey), pInfo->aggSup.resultRowSize, funResSize, compareTs, pInfo->pState,
+      pInfo->twAggSup.deleteMark, GET_TASKID(pTaskInfo));
+
+  setOperatorInfo(pOperator, "StreamIntervalOperator", QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL, true, OP_NOT_OPENED,
+                  pInfo, pTaskInfo);
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamIntervalAgg, NULL,
+                                         destroyStreamFinalIntervalOperatorInfo, optrDefaultBufFn, NULL);
+  setOperatorStreamStateFn(pOperator, streamIntervalReleaseState, streamIntervalReloadState);
+
+  pInfo->statestore = pTaskInfo->storageAPI.stateStore;
+  pInfo->recvGetAll = false;
+
+  initIntervalDownStream(downstream, pPhyNode->type, pInfo);
+  code = appendDownstream(pOperator, &downstream, 1);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
+  return pOperator;
+
+_error:
+  destroyStreamFinalIntervalOperatorInfo(pInfo);
+  taosMemoryFreeClear(pOperator);
+  pTaskInfo->code = code;
+  return NULL;
+}
diff --git a/source/libs/executor/src/timesliceoperator.c b/source/libs/executor/src/timesliceoperator.c
index b019985645..c9824ff2d6 100644
--- a/source/libs/executor/src/timesliceoperator.c
+++ b/source/libs/executor/src/timesliceoperator.c
@@ -848,6 +848,10 @@ static void doHandleTimeslice(SOperatorInfo* pOperator, SSDataBlock* pBlock) {
   bool                    ignoreNull = getIgoreNullRes(pSup);
   int32_t                 order = TSDB_ORDER_ASC;
 
+  if (checkWindowBoundReached(pSliceInfo)) {
+    return;
+  }
+
   int32_t code = initKeeperInfo(pSliceInfo, pBlock, &pOperator->exprSupp);
   if (code != TSDB_CODE_SUCCESS) {
     T_LONG_JMP(pTaskInfo->env, code);
diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c
index 3abb4f44f4..9e5cea2afd 100644
--- a/source/libs/executor/src/timewindowoperator.c
+++ b/source/libs/executor/src/timewindowoperator.c
@@ -26,17 +26,6 @@
 #include "tlog.h"
 #include "ttime.h"
 
-#define IS_FINAL_OP(op)    ((op)->isFinal)
-#define DEAULT_DELETE_MARK (1000LL * 60LL * 60LL * 24LL * 365LL * 10LL);
-#define STREAM_INTERVAL_OP_STATE_NAME "StreamIntervalHistoryState"
-#define STREAM_SESSION_OP_STATE_NAME "StreamSessionHistoryState"
-#define STREAM_STATE_OP_STATE_NAME "StreamStateHistoryState"
-
-typedef struct SStateWindowInfo {
-  SResultWindowInfo winInfo;
-  SStateKeys*       pStateKey;
-} SStateWindowInfo;
-
 typedef struct SSessionAggOperatorInfo {
   SOptrBasicInfo     binfo;
   SAggSupporter      aggSup;
@@ -66,11 +55,6 @@ typedef enum SResultTsInterpType {
   RESULT_ROW_END_INTERP = 2,
 } SResultTsInterpType;
 
-typedef struct SPullWindowInfo {
-  STimeWindow window;
-  uint64_t    groupId;
-  STimeWindow calWin;
-} SPullWindowInfo;
 
 typedef struct SOpenWindowInfo {
   SResultRowPosition pos;
@@ -83,8 +67,6 @@ static SResultRowPosition addToOpenWindowList(SResultRowInfo* pResultRowInfo, co
                                               uint64_t groupId);
 static void doCloseWindow(SResultRowInfo* pResultRowInfo, const SIntervalAggOperatorInfo* pInfo, SResultRow* pResult);
 
-static TSKEY getStartTsKey(STimeWindow* win, const TSKEY* tsCols) { return tsCols == NULL ? win->skey : tsCols[0]; }
-
 static int32_t setTimeWindowOutputBuf(SResultRowInfo* pResultRowInfo, STimeWindow* win, bool masterscan,
                                       SResultRow** pResult, int64_t tableGroupId, SqlFunctionCtx* pCtx,
                                       int32_t numOfOutput, int32_t* rowEntryInfoOffset, SAggSupporter* pAggSup,
@@ -106,15 +88,6 @@ static int32_t setTimeWindowOutputBuf(SResultRowInfo* pResultRowInfo, STimeWindo
   return TSDB_CODE_SUCCESS;
 }
 
-static void updateTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pWin, int64_t  delta) {
-  int64_t* ts = (int64_t*)pColData->pData;
-
-  int64_t duration = pWin->ekey - pWin->skey + delta;
-  ts[2] = duration;            // set the duration
-  ts[3] = pWin->skey;          // window start key
-  ts[4] = pWin->ekey + delta;  // window end key
-}
-
 static void doKeepTuple(SWindowRowsSup* pRowSup, int64_t ts, uint64_t groupId) {
   pRowSup->win.ekey = ts;
   pRowSup->prevTs = ts;
@@ -426,7 +399,7 @@ bool inSlidingWindow(SInterval* pInterval, STimeWindow* pWin, SDataBlockInfo* pB
   return inCalSlidingWindow(pInterval, pWin, pBlockInfo->calWin.skey, pBlockInfo->calWin.ekey, pBlockInfo->type);
 }
 
-static int32_t getNextQualifiedWindow(SInterval* pInterval, STimeWindow* pNext, SDataBlockInfo* pDataBlockInfo,
+int32_t getNextQualifiedWindow(SInterval* pInterval, STimeWindow* pNext, SDataBlockInfo* pDataBlockInfo,
                                       TSKEY* primaryKeys, int32_t prevPosition, int32_t order) {
   bool ascQuery = (order == TSDB_ORDER_ASC);
 
@@ -658,224 +631,6 @@ static void doInterpUnclosedTimeWindow(SOperatorInfo* pOperatorInfo, int32_t num
   }
 }
 
-typedef int32_t (*__compare_fn_t)(void* pKey, void* data, int32_t index);
-
-int32_t binarySearchCom(void* keyList, int num, void* pKey, int order, __compare_fn_t comparefn) {
-  int firstPos = 0, lastPos = num - 1, midPos = -1;
-  int numOfRows = 0;
-
-  if (num <= 0) return -1;
-  if (order == TSDB_ORDER_DESC) {
-    // find the first position which is smaller or equal than the key
-    while (1) {
-      if (comparefn(pKey, keyList, lastPos) >= 0) return lastPos;
-      if (comparefn(pKey, keyList, firstPos) == 0) return firstPos;
-      if (comparefn(pKey, keyList, firstPos) < 0) return firstPos - 1;
-
-      numOfRows = lastPos - firstPos + 1;
-      midPos = (numOfRows >> 1) + firstPos;
-
-      if (comparefn(pKey, keyList, midPos) < 0) {
-        lastPos = midPos - 1;
-      } else if (comparefn(pKey, keyList, midPos) > 0) {
-        firstPos = midPos + 1;
-      } else {
-        break;
-      }
-    }
-
-  } else {
-    // find the first position which is bigger or equal than the key
-    while (1) {
-      if (comparefn(pKey, keyList, firstPos) <= 0) return firstPos;
-      if (comparefn(pKey, keyList, lastPos) == 0) return lastPos;
-
-      if (comparefn(pKey, keyList, lastPos) > 0) {
-        lastPos = lastPos + 1;
-        if (lastPos >= num)
-          return -1;
-        else
-          return lastPos;
-      }
-
-      numOfRows = lastPos - firstPos + 1;
-      midPos = (numOfRows >> 1) + firstPos;
-
-      if (comparefn(pKey, keyList, midPos) < 0) {
-        lastPos = midPos - 1;
-      } else if (comparefn(pKey, keyList, midPos) > 0) {
-        firstPos = midPos + 1;
-      } else {
-        break;
-      }
-    }
-  }
-
-  return midPos;
-}
-
-typedef int64_t (*__get_value_fn_t)(void* data, int32_t index);
-
-int32_t binarySearch(void* keyList, int num, TSKEY key, int order, __get_value_fn_t getValuefn) {
-  int firstPos = 0, lastPos = num - 1, midPos = -1;
-  int numOfRows = 0;
-
-  if (num <= 0) return -1;
-  if (order == TSDB_ORDER_DESC) {
-    // find the first position which is smaller or equal than the key
-    while (1) {
-      if (key >= getValuefn(keyList, lastPos)) return lastPos;
-      if (key == getValuefn(keyList, firstPos)) return firstPos;
-      if (key < getValuefn(keyList, firstPos)) return firstPos - 1;
-
-      numOfRows = lastPos - firstPos + 1;
-      midPos = (numOfRows >> 1) + firstPos;
-
-      if (key < getValuefn(keyList, midPos)) {
-        lastPos = midPos - 1;
-      } else if (key > getValuefn(keyList, midPos)) {
-        firstPos = midPos + 1;
-      } else {
-        break;
-      }
-    }
-
-  } else {
-    // find the first position which is bigger or equal than the key
-    while (1) {
-      if (key <= getValuefn(keyList, firstPos)) return firstPos;
-      if (key == getValuefn(keyList, lastPos)) return lastPos;
-
-      if (key > getValuefn(keyList, lastPos)) {
-        lastPos = lastPos + 1;
-        if (lastPos >= num)
-          return -1;
-        else
-          return lastPos;
-      }
-
-      numOfRows = lastPos - firstPos + 1;
-      midPos = (numOfRows >> 1) + firstPos;
-
-      if (key < getValuefn(keyList, midPos)) {
-        lastPos = midPos - 1;
-      } else if (key > getValuefn(keyList, midPos)) {
-        firstPos = midPos + 1;
-      } else {
-        break;
-      }
-    }
-  }
-
-  return midPos;
-}
-
-int32_t comparePullWinKey(void* pKey, void* data, int32_t index) {
-  SArray*          res = (SArray*)data;
-  SPullWindowInfo* pos = taosArrayGet(res, index);
-  SPullWindowInfo* pData = (SPullWindowInfo*)pKey;
-  if (pData->groupId > pos->groupId) {
-    return 1;
-  } else if (pData->groupId < pos->groupId) {
-    return -1;
-  }
-
-  if (pData->window.skey > pos->window.ekey) {
-    return 1;
-  } else if (pData->window.ekey < pos->window.skey) {
-    return -1;
-  }
-  return 0;
-}
-
-static int32_t savePullWindow(SPullWindowInfo* pPullInfo, SArray* pPullWins) {
-  int32_t size = taosArrayGetSize(pPullWins);
-  int32_t index = binarySearchCom(pPullWins, size, pPullInfo, TSDB_ORDER_DESC, comparePullWinKey);
-  if (index == -1) {
-    index = 0;
-  } else {
-    int32_t code = comparePullWinKey(pPullInfo, pPullWins, index);
-    if (code == 0) {
-      SPullWindowInfo* pos = taosArrayGet(pPullWins, index);
-      pos->window.skey = TMIN(pos->window.skey, pPullInfo->window.skey);
-      pos->window.ekey = TMAX(pos->window.ekey, pPullInfo->window.ekey);
-      pos->calWin.skey = TMIN(pos->calWin.skey, pPullInfo->calWin.skey);
-      pos->calWin.ekey = TMAX(pos->calWin.ekey, pPullInfo->calWin.ekey);
-      return TSDB_CODE_SUCCESS;
-    } else if (code > 0) {
-      index++;
-    }
-  }
-  if (taosArrayInsert(pPullWins, index, pPullInfo) == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
-  }
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t saveResult(SResultWindowInfo winInfo, SSHashObj* pStUpdated) {
-  winInfo.sessionWin.win.ekey = winInfo.sessionWin.win.skey;
-  return tSimpleHashPut(pStUpdated, &winInfo.sessionWin, sizeof(SSessionKey), &winInfo, sizeof(SResultWindowInfo));
-}
-
-static int32_t saveWinResult(SWinKey* pKey, SRowBuffPos* pPos, SSHashObj* pUpdatedMap) {
-  tSimpleHashPut(pUpdatedMap, pKey, sizeof(SWinKey), &pPos, POINTER_BYTES);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t saveWinResultInfo(TSKEY ts, uint64_t groupId, SRowBuffPos* pPos, SSHashObj* pUpdatedMap) {
-  SWinKey key = {.ts = ts, .groupId = groupId};
-  saveWinResult(&key, pPos, pUpdatedMap);
-  return TSDB_CODE_SUCCESS;
-}
-
-static void removeResults(SArray* pWins, SSHashObj* pUpdatedMap) {
-  int32_t size = taosArrayGetSize(pWins);
-  for (int32_t i = 0; i < size; i++) {
-    SWinKey* pW = taosArrayGet(pWins, i);
-    void*    tmp = tSimpleHashGet(pUpdatedMap, pW, sizeof(SWinKey));
-    if (tmp) {
-      void* value = *(void**)tmp;
-      taosMemoryFree(value);
-      tSimpleHashRemove(pUpdatedMap, pW, sizeof(SWinKey));
-    }
-  }
-}
-
-int32_t compareWinKey(void* pKey, void* data, int32_t index) {
-  void* pDataPos = taosArrayGet((SArray*)data, index);
-  return winKeyCmprImpl(pKey, pDataPos);
-}
-
-static void removeDeleteResults(SSHashObj* pUpdatedMap, SArray* pDelWins) {
-  taosArraySort(pDelWins, winKeyCmprImpl);
-  taosArrayRemoveDuplicate(pDelWins, winKeyCmprImpl, NULL);
-  int32_t delSize = taosArrayGetSize(pDelWins);
-  if (tSimpleHashGetSize(pUpdatedMap) == 0 || delSize == 0) {
-    return;
-  }
-  void*   pIte = NULL;
-  int32_t iter = 0;
-  while ((pIte = tSimpleHashIterate(pUpdatedMap, pIte, &iter)) != NULL) {
-    SWinKey* pResKey = tSimpleHashGetKey(pIte, NULL);
-    int32_t  index = binarySearchCom(pDelWins, delSize, pResKey, TSDB_ORDER_DESC, compareWinKey);
-    if (index >= 0 && 0 == compareWinKey(pResKey, pDelWins, index)) {
-      taosArrayRemove(pDelWins, index);
-      delSize = taosArrayGetSize(pDelWins);
-    }
-  }
-}
-
-bool isOverdue(TSKEY ekey, STimeWindowAggSupp* pTwSup) {
-  ASSERTS(pTwSup->maxTs == INT64_MIN || pTwSup->maxTs > 0, "maxts should greater than 0");
-  return pTwSup->maxTs != INT64_MIN && ekey < pTwSup->maxTs - pTwSup->waterMark;
-}
-
-bool isCloseWindow(STimeWindow* pWin, STimeWindowAggSupp* pTwSup) { return isOverdue(pWin->ekey, pTwSup); }
-
-bool needDeleteWindowBuf(STimeWindow* pWin, STimeWindowAggSupp* pTwSup) {
-  return pTwSup->maxTs != INT64_MIN && pWin->ekey < pTwSup->maxTs - pTwSup->deleteMark;
-}
-
 static bool tsKeyCompFn(void* l, void* r, void* param) {
   TSKEY* lTS = (TSKEY*)l;
   TSKEY* rTS = (TSKEY*)r;
@@ -1127,18 +882,6 @@ static int32_t doOpenIntervalAgg(SOperatorInfo* pOperator) {
   return TSDB_CODE_SUCCESS;
 }
 
-static bool compareVal(const char* v, const SStateKeys* pKey) {
-  if (IS_VAR_DATA_TYPE(pKey->type)) {
-    if (varDataLen(v) != varDataLen(pKey->pData)) {
-      return false;
-    } else {
-      return memcmp(varDataVal(v), varDataVal(pKey->pData), varDataLen(v)) == 0;
-    }
-  } else {
-    return memcmp(pKey->pData, v, pKey->bytes) == 0;
-  }
-}
-
 static void doStateWindowAggImpl(SOperatorInfo* pOperator, SStateWindowOperatorInfo* pInfo, SSDataBlock* pBlock) {
   SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
   SExprSupp*     pSup = &pOperator->exprSupp;
@@ -1373,169 +1116,6 @@ static void doClearWindowImpl(SResultRowPosition* p1, SDiskbasedBuf* pResultBuf,
   releaseBufPage(pResultBuf, bufPage);
 }
 
-static bool doDeleteWindow(SOperatorInfo* pOperator, TSKEY ts, uint64_t groupId) {
-  SStorageAPI* pAPI = &pOperator->pTaskInfo->storageAPI;
-
-  SStreamIntervalOperatorInfo* pInfo = pOperator->info;
-  SWinKey                      key = {.ts = ts, .groupId = groupId};
-  tSimpleHashRemove(pInfo->aggSup.pResultRowHashTable, &key, sizeof(SWinKey));
-  pAPI->stateStore.streamStateDel(pInfo->pState, &key);
-  return true;
-}
-
-static int32_t getChildIndex(SSDataBlock* pBlock) { return pBlock->info.childId; }
-
-static void doDeleteWindows(SOperatorInfo* pOperator, SInterval* pInterval, SSDataBlock* pBlock, SArray* pUpWins,
-                            SSHashObj* pUpdatedMap) {
-  SStreamIntervalOperatorInfo* pInfo = pOperator->info;
-  SColumnInfoData*             pStartTsCol = taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX);
-  TSKEY*                       startTsCols = (TSKEY*)pStartTsCol->pData;
-  SColumnInfoData*             pEndTsCol = taosArrayGet(pBlock->pDataBlock, END_TS_COLUMN_INDEX);
-  TSKEY*                       endTsCols = (TSKEY*)pEndTsCol->pData;
-  SColumnInfoData*             pCalStTsCol = taosArrayGet(pBlock->pDataBlock, CALCULATE_START_TS_COLUMN_INDEX);
-  TSKEY*                       calStTsCols = (TSKEY*)pCalStTsCol->pData;
-  SColumnInfoData*             pCalEnTsCol = taosArrayGet(pBlock->pDataBlock, CALCULATE_END_TS_COLUMN_INDEX);
-  TSKEY*                       calEnTsCols = (TSKEY*)pCalEnTsCol->pData;
-  SColumnInfoData*             pGpCol = taosArrayGet(pBlock->pDataBlock, GROUPID_COLUMN_INDEX);
-  uint64_t*                    pGpDatas = (uint64_t*)pGpCol->pData;
-  for (int32_t i = 0; i < pBlock->info.rows; i++) {
-    SResultRowInfo dumyInfo = {0};
-    dumyInfo.cur.pageId = -1;
-
-    STimeWindow win = {0};
-    if (IS_FINAL_OP(pInfo)) {
-      win.skey = startTsCols[i];
-      win.ekey = endTsCols[i];
-    } else {
-      win = getActiveTimeWindow(NULL, &dumyInfo, startTsCols[i], pInterval, TSDB_ORDER_ASC);
-    }
-
-    do {
-      if (!inCalSlidingWindow(pInterval, &win, calStTsCols[i], calEnTsCols[i], pBlock->info.type)) {
-        getNextTimeWindow(pInterval, &win, TSDB_ORDER_ASC);
-        continue;
-      }
-      uint64_t winGpId = pGpDatas[i];
-      SWinKey  winRes = {.ts = win.skey, .groupId = winGpId};
-      void*    chIds = taosHashGet(pInfo->pPullDataMap, &winRes, sizeof(SWinKey));
-      if (chIds) {
-        int32_t childId = getChildIndex(pBlock);
-        SArray* chArray = *(void**)chIds;
-        int32_t index = taosArraySearchIdx(chArray, &childId, compareInt32Val, TD_EQ);
-        if (index != -1) {
-          qDebug("===stream===try push delete window%" PRId64 "chId:%d ,continue", win.skey, childId);
-          getNextTimeWindow(pInterval, &win, TSDB_ORDER_ASC);
-          continue;
-        }
-      }
-      bool res = doDeleteWindow(pOperator, win.skey, winGpId);
-      if (pUpWins && res) {
-        taosArrayPush(pUpWins, &winRes);
-      }
-      if (pUpdatedMap) {
-        tSimpleHashRemove(pUpdatedMap, &winRes, sizeof(SWinKey));
-      }
-      getNextTimeWindow(pInterval, &win, TSDB_ORDER_ASC);
-    } while (win.ekey <= endTsCols[i]);
-  }
-}
-
-static int32_t getAllIntervalWindow(SSHashObj* pHashMap, SSHashObj* resWins) {
-  void*   pIte = NULL;
-  int32_t iter = 0;
-  while ((pIte = tSimpleHashIterate(pHashMap, pIte, &iter)) != NULL) {
-    SWinKey* pKey = tSimpleHashGetKey(pIte, NULL);
-    uint64_t groupId = pKey->groupId;
-    TSKEY    ts = pKey->ts;
-    int32_t  code = saveWinResultInfo(ts, groupId, *(SRowBuffPos**)pIte, resWins);
-    if (code != TSDB_CODE_SUCCESS) {
-      return code;
-    }
-  }
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t closeStreamIntervalWindow(SSHashObj* pHashMap, STimeWindowAggSupp* pTwSup, SInterval* pInterval,
-                                         SHashObj* pPullDataMap, SSHashObj* closeWins, SArray* pDelWins,
-                                         SOperatorInfo* pOperator) {
-  qDebug("===stream===close interval window");
-  void*                        pIte = NULL;
-  int32_t                      iter = 0;
-  SStreamIntervalOperatorInfo* pInfo = pOperator->info;
-  int32_t                      delSize = taosArrayGetSize(pDelWins);
-  while ((pIte = tSimpleHashIterate(pHashMap, pIte, &iter)) != NULL) {
-    void*    key = tSimpleHashGetKey(pIte, NULL);
-    SWinKey* pWinKey = (SWinKey*)key;
-    if (delSize > 0) {
-      int32_t index = binarySearchCom(pDelWins, delSize, pWinKey, TSDB_ORDER_DESC, compareWinKey);
-      if (index >= 0 && 0 == compareWinKey(pWinKey, pDelWins, index)) {
-        taosArrayRemove(pDelWins, index);
-        delSize = taosArrayGetSize(pDelWins);
-      }
-    }
-
-    void*       chIds = taosHashGet(pPullDataMap, pWinKey, sizeof(SWinKey));
-    STimeWindow win = {
-        .skey = pWinKey->ts,
-        .ekey = taosTimeAdd(win.skey, pInterval->interval, pInterval->intervalUnit, pInterval->precision) - 1,
-    };
-    if (isCloseWindow(&win, pTwSup)) {
-      if (chIds && pPullDataMap) {
-        SArray* chAy = *(SArray**)chIds;
-        int32_t size = taosArrayGetSize(chAy);
-        qDebug("===stream===window %" PRId64 " wait child size:%d", pWinKey->ts, size);
-        for (int32_t i = 0; i < size; i++) {
-          qDebug("===stream===window %" PRId64 " wait child id:%d", pWinKey->ts, *(int32_t*)taosArrayGet(chAy, i));
-        }
-        continue;
-      } else if (pPullDataMap) {
-        qDebug("===stream===close window %" PRId64, pWinKey->ts);
-      }
-
-      if (pTwSup->calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) {
-        int32_t code = saveWinResult(pWinKey, *(SRowBuffPos**)pIte, closeWins);
-        if (code != TSDB_CODE_SUCCESS) {
-          return code;
-        }
-      }
-      tSimpleHashIterateRemove(pHashMap, pWinKey, sizeof(SWinKey), &pIte, &iter);
-    }
-  }
-  return TSDB_CODE_SUCCESS;
-}
-
-STimeWindow getFinalTimeWindow(int64_t ts, SInterval* pInterval) {
-  STimeWindow w = {.skey = ts, .ekey = INT64_MAX};
-  w.ekey = taosTimeAdd(w.skey, pInterval->interval, pInterval->intervalUnit, pInterval->precision) - 1;
-  return w;
-}
-
-static void doBuildDeleteResult(SStreamIntervalOperatorInfo* pInfo, SArray* pWins, int32_t* index,
-                                SSDataBlock* pBlock) {
-  blockDataCleanup(pBlock);
-  int32_t size = taosArrayGetSize(pWins);
-  if (*index == size) {
-    *index = 0;
-    taosArrayClear(pWins);
-    return;
-  }
-  blockDataEnsureCapacity(pBlock, size - *index);
-  uint64_t uid = 0;
-  for (int32_t i = *index; i < size; i++) {
-    SWinKey* pWin = taosArrayGet(pWins, i);
-    void*    tbname = NULL;
-    pInfo->statestore.streamStateGetParName(pInfo->pState, pWin->groupId, &tbname);
-    if (tbname == NULL) {
-      appendOneRowToStreamSpecialBlock(pBlock, &pWin->ts, &pWin->ts, &uid, &pWin->groupId, NULL);
-    } else {
-      char parTbName[VARSTR_HEADER_SIZE + TSDB_TABLE_NAME_LEN];
-      STR_WITH_MAXSIZE_TO_VARSTR(parTbName, tbname, sizeof(parTbName));
-      appendOneRowToStreamSpecialBlock(pBlock, &pWin->ts, &pWin->ts, &uid, &pWin->groupId, parTbName);
-    }
-    pInfo->statestore.streamStateFreeVal(tbname);
-    (*index)++;
-  }
-}
 
 static void destroyStateWindowOperatorInfo(void* param) {
   SStateWindowOperatorInfo* pInfo = (SStateWindowOperatorInfo*)param;
@@ -1573,40 +1153,6 @@ void destroyIntervalOperatorInfo(void* param) {
   taosMemoryFreeClear(param);
 }
 
-void destroyStreamFinalIntervalOperatorInfo(void* param) {
-  SStreamIntervalOperatorInfo* pInfo = (SStreamIntervalOperatorInfo*)param;
-  cleanupBasicInfo(&pInfo->binfo);
-  cleanupAggSup(&pInfo->aggSup);
-  // it should be empty.
-  void* pIte = NULL;
-  while ((pIte = taosHashIterate(pInfo->pPullDataMap, pIte)) != NULL) {
-    taosArrayDestroy(*(void**)pIte);
-  }
-  taosHashCleanup(pInfo->pPullDataMap);
-  taosHashCleanup(pInfo->pFinalPullDataMap);
-  taosArrayDestroy(pInfo->pPullWins);
-  blockDataDestroy(pInfo->pPullDataRes);
-  taosArrayDestroy(pInfo->pDelWins);
-  blockDataDestroy(pInfo->pDelRes);
-  pInfo->statestore.streamFileStateDestroy(pInfo->pState->pFileState);
-  taosMemoryFreeClear(pInfo->pState);
-
-  nodesDestroyNode((SNode*)pInfo->pPhyNode);
-  colDataDestroy(&pInfo->twAggSup.timeWindowData);
-  pInfo->groupResInfo.pRows = taosArrayDestroy(pInfo->groupResInfo.pRows);
-  cleanupExprSupp(&pInfo->scalarSupp);
-
-  taosMemoryFreeClear(param);
-}
-
-static bool allInvertible(SqlFunctionCtx* pFCtx, int32_t numOfCols) {
-  for (int32_t i = 0; i < numOfCols; i++) {
-    if (fmIsUserDefinedFunc(pFCtx[i].functionId) || !fmIsInvertible(pFCtx[i].functionId)) {
-      return false;
-    }
-  }
-  return true;
-}
 
 static bool timeWindowinterpNeeded(SqlFunctionCtx* pCtx, int32_t numOfCols, SIntervalAggOperatorInfo* pInfo) {
   // the primary timestamp column
@@ -1662,25 +1208,6 @@ static bool timeWindowinterpNeeded(SqlFunctionCtx* pCtx, int32_t numOfCols, SInt
   return needed;
 }
 
-void initIntervalDownStream(SOperatorInfo* downstream, uint16_t type, SStreamIntervalOperatorInfo* pInfo) {
-  SStateStore* pAPI = &downstream->pTaskInfo->storageAPI.stateStore;
-
-  if (downstream->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN) {
-    initIntervalDownStream(downstream->pDownstream[0], type, pInfo);
-    return;
-  }
-
-  SStreamScanInfo* pScanInfo = downstream->info;
-  pScanInfo->windowSup.parentType = type;
-  pScanInfo->windowSup.pIntervalAggSup = &pInfo->aggSup;
-  if (!pScanInfo->pUpdateInfo) {
-    pScanInfo->pUpdateInfo = pAPI->updateInfoInitP(&pInfo->interval, pInfo->twAggSup.waterMark);
-  }
-
-  pScanInfo->interval = pInfo->interval;
-  pScanInfo->twAggSup = pInfo->twAggSup;
-  pScanInfo->pState = pInfo->pState;
-}
 
 void initStreamFunciton(SqlFunctionCtx* pCtx, int32_t numOfExpr) {
   for (int32_t i = 0; i < numOfExpr; i++) {
@@ -2088,2540 +1615,6 @@ _error:
   return NULL;
 }
 
-void compactFunctions(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx, int32_t numOfOutput,
-                      SExecTaskInfo* pTaskInfo, SColumnInfoData* pTimeWindowData) {
-  for (int32_t k = 0; k < numOfOutput; ++k) {
-    if (fmIsWindowPseudoColumnFunc(pDestCtx[k].functionId)) {
-      if (!pTimeWindowData) {
-        continue;
-      }
-
-      SResultRowEntryInfo* pEntryInfo = GET_RES_INFO(&pDestCtx[k]);
-      char*                p = GET_ROWCELL_INTERBUF(pEntryInfo);
-      SColumnInfoData      idata = {0};
-      idata.info.type = TSDB_DATA_TYPE_BIGINT;
-      idata.info.bytes = tDataTypes[TSDB_DATA_TYPE_BIGINT].bytes;
-      idata.pData = p;
-
-      SScalarParam out = {.columnData = &idata};
-      SScalarParam tw = {.numOfRows = 5, .columnData = pTimeWindowData};
-      pDestCtx[k].sfp.process(&tw, 1, &out);
-      pEntryInfo->numOfRes = 1;
-    } else if (functionNeedToExecute(&pDestCtx[k]) && pDestCtx[k].fpSet.combine != NULL) {
-      int32_t code = pDestCtx[k].fpSet.combine(&pDestCtx[k], &pSourceCtx[k]);
-      if (code != TSDB_CODE_SUCCESS) {
-        qError("%s apply combine functions error, code: %s", GET_TASKID(pTaskInfo), tstrerror(code));
-      }
-    } else if (pDestCtx[k].fpSet.combine == NULL) {
-      char* funName = fmGetFuncName(pDestCtx[k].functionId);
-      qError("%s error, combine funcion for %s is not implemented", GET_TASKID(pTaskInfo), funName);
-      taosMemoryFreeClear(funName);
-    }
-  }
-}
-
-bool hasIntervalWindow(void* pState, SWinKey* pKey, SStateStore* pStore) { return pStore->streamStateCheck(pState, pKey); }
-
-int32_t setIntervalOutputBuf(void* pState, STimeWindow* win, SRowBuffPos** pResult, int64_t groupId,
-                             SqlFunctionCtx* pCtx, int32_t numOfOutput, int32_t* rowEntryInfoOffset,
-                             SAggSupporter* pAggSup, SStateStore* pStore) {
-
-  SWinKey key = { .ts = win->skey, .groupId = groupId };
-  char*   value = NULL;
-  int32_t size = pAggSup->resultRowSize;
-
-  if (pStore->streamStateAddIfNotExist(pState, &key, (void**)&value, &size) < 0) {
-    return TSDB_CODE_OUT_OF_MEMORY;
-  }
-
-  *pResult = (SRowBuffPos*)value;
-  SResultRow* res = (SResultRow*)((*pResult)->pRowBuff);
-
-  // set time window for current result
-  res->win = (*win);
-  setResultRowInitCtx(res, pCtx, numOfOutput, rowEntryInfoOffset);
-  return TSDB_CODE_SUCCESS;
-}
-
-bool isDeletedStreamWindow(STimeWindow* pWin, uint64_t groupId, void* pState, STimeWindowAggSupp* pTwSup, SStateStore* pStore) {
-  if (pTwSup->maxTs != INT64_MIN && pWin->ekey < pTwSup->maxTs - pTwSup->deleteMark) {
-    SWinKey key = {.ts = pWin->skey, .groupId = groupId};
-    if (!hasIntervalWindow(pState, &key, pStore)) {
-      return true;
-    }
-    return false;
-  }
-  return false;
-}
-
-int32_t getNexWindowPos(SInterval* pInterval, SDataBlockInfo* pBlockInfo, TSKEY* tsCols, int32_t startPos, TSKEY eKey,
-                        STimeWindow* pNextWin) {
-  int32_t forwardRows =
-      getNumOfRowsInTimeWindow(pBlockInfo, tsCols, startPos, eKey, binarySearchForKey, NULL, TSDB_ORDER_ASC);
-  int32_t prevEndPos = forwardRows - 1 + startPos;
-  return getNextQualifiedWindow(pInterval, pNextWin, pBlockInfo, tsCols, prevEndPos, TSDB_ORDER_ASC);
-}
-
-void addPullWindow(SHashObj* pMap, SWinKey* pWinRes, int32_t size) {
-  SArray* childIds = taosArrayInit(8, sizeof(int32_t));
-  for (int32_t i = 0; i < size; i++) {
-    taosArrayPush(childIds, &i);
-  }
-  taosHashPut(pMap, pWinRes, sizeof(SWinKey), &childIds, sizeof(void*));
-}
-
-static void clearStreamIntervalOperator(SStreamIntervalOperatorInfo* pInfo) {
-  tSimpleHashClear(pInfo->aggSup.pResultRowHashTable);
-  clearDiskbasedBuf(pInfo->aggSup.pResultBuf);
-  initResultRowInfo(&pInfo->binfo.resultRowInfo);
-  pInfo->aggSup.currentPageId = -1;
-  pInfo->statestore.streamStateClear(pInfo->pState);
-}
-
-static void clearSpecialDataBlock(SSDataBlock* pBlock) {
-  if (pBlock->info.rows <= 0) {
-    return;
-  }
-  blockDataCleanup(pBlock);
-}
-
-static void doBuildPullDataBlock(SArray* array, int32_t* pIndex, SSDataBlock* pBlock) {
-  clearSpecialDataBlock(pBlock);
-  int32_t size = taosArrayGetSize(array);
-  if (size - (*pIndex) == 0) {
-    return;
-  }
-  blockDataEnsureCapacity(pBlock, size - (*pIndex));
-  SColumnInfoData* pStartTs = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX);
-  SColumnInfoData* pEndTs = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, END_TS_COLUMN_INDEX);
-  SColumnInfoData* pGroupId = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, GROUPID_COLUMN_INDEX);
-  SColumnInfoData* pCalStartTs = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, CALCULATE_START_TS_COLUMN_INDEX);
-  SColumnInfoData* pCalEndTs = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, CALCULATE_END_TS_COLUMN_INDEX);
-  for (; (*pIndex) < size; (*pIndex)++) {
-    SPullWindowInfo* pWin = taosArrayGet(array, (*pIndex));
-    colDataSetVal(pStartTs, pBlock->info.rows, (const char*)&pWin->window.skey, false);
-    colDataSetVal(pEndTs, pBlock->info.rows, (const char*)&pWin->window.ekey, false);
-    colDataSetVal(pGroupId, pBlock->info.rows, (const char*)&pWin->groupId, false);
-    colDataSetVal(pCalStartTs, pBlock->info.rows, (const char*)&pWin->calWin.skey, false);
-    colDataSetVal(pCalEndTs, pBlock->info.rows, (const char*)&pWin->calWin.ekey, false);
-    pBlock->info.rows++;
-  }
-  if ((*pIndex) == size) {
-    *pIndex = 0;
-    taosArrayClear(array);
-  }
-  blockDataUpdateTsWindow(pBlock, 0);
-}
-
-void 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;
-  SColumnInfoData* pEndCol = taosArrayGet(pBlock->pDataBlock, CALCULATE_END_TS_COLUMN_INDEX);
-  TSKEY*           tsEndData = (TSKEY*)pEndCol->pData;
-  SColumnInfoData* pGroupCol = taosArrayGet(pBlock->pDataBlock, GROUPID_COLUMN_INDEX);
-  uint64_t*        groupIdData = (uint64_t*)pGroupCol->pData;
-  int32_t          chId = getChildIndex(pBlock);
-  for (int32_t i = 0; i < pBlock->info.rows; i++) {
-    TSKEY winTs = tsData[i];
-    while (winTs <= tsEndData[i]) {
-      SWinKey winRes = {.ts = winTs, .groupId = groupIdData[i]};
-      void*   chIds = taosHashGet(pMap, &winRes, sizeof(SWinKey));
-      if (chIds) {
-        SArray* chArray = *(SArray**)chIds;
-        int32_t index = taosArraySearchIdx(chArray, &chId, compareInt32Val, TD_EQ);
-        if (index != -1) {
-          qDebug("===stream===retrive window %" PRId64 " delete child id %d", winRes.ts, chId);
-          taosArrayRemove(chArray, index);
-          if (taosArrayGetSize(chArray) == 0) {
-            // pull data is over
-            taosArrayDestroy(chArray);
-            taosHashRemove(pMap, &winRes, sizeof(SWinKey));
-            qDebug("===stream===retrive pull data over.window %" PRId64 , winRes.ts);
-
-            void* pFinalCh = taosHashGet(pFinalMap, &winRes, sizeof(SWinKey));
-            if (pFinalCh) {
-              taosHashRemove(pFinalMap, &winRes, sizeof(SWinKey));
-              doDeleteWindow(pOperator, winRes.ts, winRes.groupId);
-              STimeWindow nextWin = getFinalTimeWindow(winRes.ts, pInterval);
-              SPullWindowInfo pull = {.window = nextWin,
-                                      .groupId = winRes.groupId,
-                                      .calWin.skey = nextWin.skey,
-                                      .calWin.ekey = nextWin.skey};
-              // add pull data request
-              if (savePullWindow(&pull, pPullWins) == TSDB_CODE_SUCCESS) {
-                addPullWindow(pMap, &winRes, numOfCh);
-                qDebug("===stream===prepare final retrive for delete %" PRId64 ", size:%d", winRes.ts, numOfCh);
-              }
-            }
-          }
-        }
-      }
-      winTs = taosTimeAdd(winTs, pInterval->sliding, pInterval->slidingUnit, pInterval->precision);
-    }
-  }
-}
-
-static void addRetriveWindow(SArray* wins, SStreamIntervalOperatorInfo* pInfo, int32_t childId) {
-  int32_t size = taosArrayGetSize(wins);
-  for (int32_t i = 0; i < size; i++) {
-    SWinKey*    winKey = taosArrayGet(wins, i);
-    STimeWindow nextWin = getFinalTimeWindow(winKey->ts, &pInfo->interval);
-    if (isOverdue(nextWin.ekey, &pInfo->twAggSup) && pInfo->ignoreExpiredData) {
-      continue;
-    }
-    void* chIds = taosHashGet(pInfo->pPullDataMap, winKey, sizeof(SWinKey));
-    if (!chIds) {
-      SPullWindowInfo pull = {
-          .window = nextWin, .groupId = winKey->groupId, .calWin.skey = nextWin.skey, .calWin.ekey = nextWin.skey};
-      // add pull data request
-      if (savePullWindow(&pull, pInfo->pPullWins) == TSDB_CODE_SUCCESS) {
-        addPullWindow(pInfo->pPullDataMap, winKey, pInfo->numOfChild);
-        qDebug("===stream===prepare retrive for delete %" PRId64 ", size:%d", winKey->ts, pInfo->numOfChild);
-      }
-    } else {
-      SArray* chArray = *(void**)chIds;
-      int32_t index = taosArraySearchIdx(chArray, &childId, compareInt32Val, TD_EQ);
-      qDebug("===stream===check final retrive %" PRId64",chid:%d", winKey->ts, index);
-      if (index == -1) {
-        qDebug("===stream===add final retrive %" PRId64, winKey->ts);
-        taosHashPut(pInfo->pFinalPullDataMap, winKey, sizeof(SWinKey), NULL, 0);
-      }
-    }
-  }
-}
-
-static void clearFunctionContext(SExprSupp* pSup) {
-  for (int32_t i = 0; i < pSup->numOfExprs; i++) {
-    pSup->pCtx[i].saveHandle.currentPage = -1;
-  }
-}
-
-int32_t getOutputBuf(void* pState, SRowBuffPos* pPos, SResultRow** pResult, SStateStore* pStore) {
-  return pStore->streamStateGetByPos(pState, pPos, (void**)pResult);
-}
-
-int32_t buildDataBlockFromGroupRes(SOperatorInfo* pOperator, void* pState, SSDataBlock* pBlock, SExprSupp* pSup,
-                                   SGroupResInfo* pGroupResInfo) {
-  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;
-  SStorageAPI* pAPI = &pOperator->pTaskInfo->storageAPI;
-
-  SExprInfo*      pExprInfo = pSup->pExprInfo;
-  int32_t         numOfExprs = pSup->numOfExprs;
-  int32_t*        rowEntryOffset = pSup->rowEntryInfoOffset;
-  SqlFunctionCtx* pCtx = pSup->pCtx;
-
-  int32_t numOfRows = getNumOfTotalRes(pGroupResInfo);
-
-  for (int32_t i = pGroupResInfo->index; i < numOfRows; i += 1) {
-    SRowBuffPos* pPos = *(SRowBuffPos**)taosArrayGet(pGroupResInfo->pRows, i);
-    SResultRow*  pRow = NULL;
-    int32_t      code = getOutputBuf(pState, pPos, &pRow, &pAPI->stateStore);
-    uint64_t     groupId = ((SWinKey*)pPos->pKey)->groupId;
-    ASSERT(code == 0);
-    doUpdateNumOfRows(pCtx, pRow, numOfExprs, rowEntryOffset);
-    // no results, continue to check the next one
-    if (pRow->numOfRows == 0) {
-      pGroupResInfo->index += 1;
-      continue;
-    }
-    if (pBlock->info.id.groupId == 0) {
-      pBlock->info.id.groupId = groupId;
-      void* tbname = NULL;
-      if (pAPI->stateStore.streamStateGetParName(pTaskInfo->streamInfo.pState, pBlock->info.id.groupId, &tbname) < 0) {
-        pBlock->info.parTbName[0] = 0;
-      } else {
-        memcpy(pBlock->info.parTbName, tbname, TSDB_TABLE_NAME_LEN);
-      }
-      pAPI->stateStore.streamStateFreeVal(tbname);
-    } else {
-      // current value belongs to different group, it can't be packed into one datablock
-      if (pBlock->info.id.groupId != groupId) {
-        break;
-      }
-    }
-
-    if (pBlock->info.rows + pRow->numOfRows > pBlock->info.capacity) {
-      ASSERT(pBlock->info.rows > 0);
-      break;
-    }
-    pGroupResInfo->index += 1;
-
-    for (int32_t j = 0; j < numOfExprs; ++j) {
-      int32_t slotId = pExprInfo[j].base.resSchema.slotId;
-
-      pCtx[j].resultInfo = getResultEntryInfo(pRow, j, rowEntryOffset);
-      SResultRowEntryInfo* pEnryInfo = pCtx[j].resultInfo;
-
-      if (pCtx[j].fpSet.finalize) {
-        int32_t code1 = pCtx[j].fpSet.finalize(&pCtx[j], pBlock);
-        if (TAOS_FAILED(code1)) {
-          qError("%s build result data block error, code %s", GET_TASKID(pTaskInfo), tstrerror(code1));
-          T_LONG_JMP(pTaskInfo->env, code1);
-        }
-      } else if (strcmp(pCtx[j].pExpr->pExpr->_function.functionName, "_select_value") == 0) {
-        // do nothing, todo refactor
-      } else {
-        // expand the result into multiple rows. E.g., _wstart, top(k, 20)
-        // the _wstart needs to copy to 20 following rows, since the results of top-k expands to 20 different rows.
-        SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, slotId);
-        char*            in = GET_ROWCELL_INTERBUF(pCtx[j].resultInfo);
-        for (int32_t k = 0; k < pRow->numOfRows; ++k) {
-          colDataSetVal(pColInfoData, pBlock->info.rows + k, in, pCtx[j].resultInfo->isNullRes);
-        }
-      }
-    }
-
-    pBlock->info.rows += pRow->numOfRows;
-  }
-
-  pBlock->info.dataLoad = 1;
-  blockDataUpdateTsWindow(pBlock, 0);
-  return TSDB_CODE_SUCCESS;
-}
-
-void doBuildStreamIntervalResult(SOperatorInfo* pOperator, void* pState, SSDataBlock* pBlock,
-                                 SGroupResInfo* pGroupResInfo) {
-  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
-  // set output datablock version
-  pBlock->info.version = pTaskInfo->version;
-
-  blockDataCleanup(pBlock);
-  if (!hasRemainResults(pGroupResInfo)) {
-    return;
-  }
-
-  // clear the existed group id
-  pBlock->info.id.groupId = 0;
-  buildDataBlockFromGroupRes(pOperator, pState, pBlock, &pOperator->exprSupp, pGroupResInfo);
-}
-
-static int32_t getNextQualifiedFinalWindow(SInterval* pInterval, STimeWindow* pNext, SDataBlockInfo* pDataBlockInfo,
-                                           TSKEY* primaryKeys, int32_t prevPosition) {
-  int32_t startPos = prevPosition + 1;
-  if (startPos == pDataBlockInfo->rows) {
-    startPos = -1;
-  } else {
-    *pNext = getFinalTimeWindow(primaryKeys[startPos], pInterval);
-  }
-  return startPos;
-}
-
-static void setStreamDataVersion(SExecTaskInfo* pTaskInfo, int64_t version, int64_t ckId) {
-  pTaskInfo->streamInfo.dataVersion = version;
-  pTaskInfo->streamInfo.checkPointId = ckId;
-}
-
-static void doStreamIntervalAggImpl(SOperatorInfo* pOperatorInfo, SSDataBlock* pSDataBlock, uint64_t groupId,
-                                    SSHashObj* pUpdatedMap) {
-  SStreamIntervalOperatorInfo* pInfo = (SStreamIntervalOperatorInfo*)pOperatorInfo->info;
-  pInfo->dataVersion = TMAX(pInfo->dataVersion, pSDataBlock->info.version);
-
-  SResultRowInfo* pResultRowInfo = &(pInfo->binfo.resultRowInfo);
-  SExecTaskInfo*  pTaskInfo = pOperatorInfo->pTaskInfo;
-  SExprSupp*      pSup = &pOperatorInfo->exprSupp;
-  int32_t         numOfOutput = pSup->numOfExprs;
-  int32_t         step = 1;
-  TSKEY*          tsCols = NULL;
-  SRowBuffPos*    pResPos = NULL;
-  SResultRow*     pResult = NULL;
-  int32_t         forwardRows = 0;
-
-  SColumnInfoData* pColDataInfo = taosArrayGet(pSDataBlock->pDataBlock, pInfo->primaryTsIndex);
-  tsCols = (int64_t*)pColDataInfo->pData;
-
-  int32_t     startPos = 0;
-  TSKEY       ts = getStartTsKey(&pSDataBlock->info.window, tsCols);
-  STimeWindow nextWin = {0};
-  if (IS_FINAL_OP(pInfo)) {
-    nextWin = getFinalTimeWindow(ts, &pInfo->interval);
-  } else {
-    nextWin = getActiveTimeWindow(pInfo->aggSup.pResultBuf, pResultRowInfo, ts, &pInfo->interval, TSDB_ORDER_ASC);
-  }
-  while (1) {
-    bool isClosed = isCloseWindow(&nextWin, &pInfo->twAggSup);
-    if ((pInfo->ignoreExpiredData && isClosed && !IS_FINAL_OP(pInfo)) || !inSlidingWindow(&pInfo->interval, &nextWin, &pSDataBlock->info)) {
-      startPos = getNexWindowPos(&pInfo->interval, &pSDataBlock->info, tsCols, startPos, nextWin.ekey, &nextWin);
-      if (startPos < 0) {
-        break;
-      }
-      continue;
-    }
-
-    if (IS_FINAL_OP(pInfo) && pInfo->numOfChild > 0) {
-      bool    ignore = true;
-      SWinKey winRes = {
-          .ts = nextWin.skey,
-          .groupId = groupId,
-      };
-      void* chIds = taosHashGet(pInfo->pPullDataMap, &winRes, sizeof(SWinKey));
-      if (isDeletedStreamWindow(&nextWin, groupId, pInfo->pState, &pInfo->twAggSup, &pInfo->statestore) && isClosed && !chIds) {
-        SPullWindowInfo pull = {
-            .window = nextWin, .groupId = groupId, .calWin.skey = nextWin.skey, .calWin.ekey = nextWin.skey};
-        // add pull data request
-        if (savePullWindow(&pull, pInfo->pPullWins) == TSDB_CODE_SUCCESS) {
-          addPullWindow(pInfo->pPullDataMap, &winRes, pInfo->numOfChild);
-        }
-      } else {
-        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) {
-          ignore = false;
-        }
-      }
-
-      if (ignore) {
-        startPos = getNextQualifiedFinalWindow(&pInfo->interval, &nextWin, &pSDataBlock->info, tsCols, startPos);
-        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 (IS_FINAL_OP(pInfo)) {
-      forwardRows = 1;
-    } else {
-      forwardRows = getNumOfRowsInTimeWindow(&pSDataBlock->info, tsCols, startPos, nextWin.ekey, binarySearchForKey,
-                                             NULL, TSDB_ORDER_ASC);
-    }
-
-    SWinKey key = {
-        .ts = pResult->win.skey,
-        .groupId = groupId,
-    };
-    if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE && pUpdatedMap) {
-      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);
-      }
-    }
-
-    if (IS_FINAL_OP(pInfo)) {
-      startPos = getNextQualifiedFinalWindow(&pInfo->interval, &nextWin, &pSDataBlock->info, tsCols, prevEndPos);
-    } else {
-      startPos =
-          getNextQualifiedWindow(&pInfo->interval, &nextWin, &pSDataBlock->info, tsCols, prevEndPos, TSDB_ORDER_ASC);
-    }
-    if (startPos < 0) {
-      break;
-    }
-  }
-}
-
-static inline int winPosCmprImpl(const void* pKey1, const void* pKey2) {
-  SRowBuffPos* pos1 = *(SRowBuffPos**)pKey1;
-  SRowBuffPos* pos2 = *(SRowBuffPos**)pKey2;
-  SWinKey*     pWin1 = (SWinKey*)pos1->pKey;
-  SWinKey*     pWin2 = (SWinKey*)pos2->pKey;
-
-  if (pWin1->groupId > pWin2->groupId) {
-    return 1;
-  } else if (pWin1->groupId < pWin2->groupId) {
-    return -1;
-  }
-
-  if (pWin1->ts > pWin2->ts) {
-    return 1;
-  } else if (pWin1->ts < pWin2->ts) {
-    return -1;
-  }
-
-  return 0;
-}
-
-static void resetUnCloseWinInfo(SSHashObj* winMap) {
-  void*   pIte = NULL;
-  int32_t iter = 0;
-  while ((pIte = tSimpleHashIterate(winMap, pIte, &iter)) != NULL) {
-    SRowBuffPos* pPos = *(SRowBuffPos**)pIte;
-    pPos->beUsed = true;
-  }
-}
-
-static SSDataBlock* doStreamFinalIntervalAgg(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("interval status %d %s", pOperator->status, IS_FINAL_OP(pInfo) ? "interval final" : "interval semi");
-
-  if (pOperator->status == OP_EXEC_DONE) {
-    return NULL;
-  } else if (pOperator->status == OP_RES_TO_RETURN) {
-    doBuildPullDataBlock(pInfo->pPullWins, &pInfo->pullIndex, pInfo->pPullDataRes);
-    if (pInfo->pPullDataRes->info.rows != 0) {
-      // process the rest of the data
-      printDataBlock(pInfo->pPullDataRes, IS_FINAL_OP(pInfo) ? "interval final" : "interval semi");
-      return pInfo->pPullDataRes;
-    }
-
-    doBuildDeleteResult(pInfo, pInfo->pDelWins, &pInfo->delIndex, pInfo->pDelRes);
-    if (pInfo->pDelRes->info.rows != 0) {
-      // process the rest of the data
-      printDataBlock(pInfo->pDelRes, IS_FINAL_OP(pInfo) ? "interval final" : "interval semi");
-      return pInfo->pDelRes;
-    }
-
-    doBuildStreamIntervalResult(pOperator, pInfo->pState, pInfo->binfo.pRes, &pInfo->groupResInfo);
-    if (pInfo->binfo.pRes->info.rows != 0) {
-      printDataBlock(pInfo->binfo.pRes, IS_FINAL_OP(pInfo) ? "interval final" : "interval semi");
-      return pInfo->binfo.pRes;
-    }
-
-    if (pInfo->recvGetAll) {
-      pInfo->recvGetAll = false;
-      resetUnCloseWinInfo(pInfo->aggSup.pResultRowHashTable);
-    }
-
-    setOperatorCompleted(pOperator);
-    if (!IS_FINAL_OP(pInfo)) {
-      clearFunctionContext(&pOperator->exprSupp);
-      // semi interval operator clear disk buffer
-      clearStreamIntervalOperator(pInfo);
-      setStreamDataVersion(pTaskInfo, pInfo->dataVersion, pInfo->pState->checkPointId);
-      qDebug("===stream===clear semi operator");
-    } else {
-      if (pInfo->twAggSup.maxTs > 0 &&
-          pInfo->twAggSup.maxTs - pInfo->twAggSup.checkPointInterval > pInfo->twAggSup.checkPointTs) {
-        pAPI->stateStore.streamStateCommit(pInfo->pState);
-        pAPI->stateStore.streamStateDeleteCheckPoint(pInfo->pState, pInfo->twAggSup.maxTs - pInfo->twAggSup.deleteMark);
-        pInfo->twAggSup.checkPointTs = pInfo->twAggSup.maxTs;
-      }
-      qDebug("===stream===interval final close");
-    }
-    return NULL;
-  } else {
-    if (!IS_FINAL_OP(pInfo)) {
-      doBuildDeleteResult(pInfo, pInfo->pDelWins, &pInfo->delIndex, pInfo->pDelRes);
-      if (pInfo->pDelRes->info.rows != 0) {
-        // process the rest of the data
-        printDataBlock(pInfo->pDelRes, IS_FINAL_OP(pInfo) ? "interval final" : "interval semi");
-        return pInfo->pDelRes;
-      }
-    }
-  }
-
-  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,
-             IS_FINAL_OP(pInfo) ? "interval final" : "interval semi", pInfo->numOfDatapack);
-      pInfo->numOfDatapack = 0;
-      break;
-    }
-    pInfo->numOfDatapack++;
-    printDataBlock(pBlock, IS_FINAL_OP(pInfo) ? "interval final recv" : "interval semi recv");
-
-    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);
-      if (IS_FINAL_OP(pInfo)) {
-        int32_t chId = getChildIndex(pBlock);
-        addRetriveWindow(delWins, pInfo, chId);
-        if (pBlock->info.type != STREAM_CLEAR) {
-          taosArrayAddAll(pInfo->pDelWins, delWins);
-        }
-        taosArrayDestroy(delWins);
-        continue;
-      }
-      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, IS_FINAL_OP(pInfo) ? "interval final" : "interval semi");
-        if (pBlock->info.type == STREAM_CLEAR) {
-          pInfo->pDelRes->info.type = STREAM_CLEAR;
-        } else {
-          pInfo->pDelRes->info.type = STREAM_DELETE_RESULT;
-        }
-        return pInfo->pDelRes;
-      }
-
-      break;
-    } else if (pBlock->info.type == STREAM_GET_ALL && IS_FINAL_OP(pInfo)) {
-      pInfo->recvGetAll = true;
-      getAllIntervalWindow(pInfo->aggSup.pResultRowHashTable, pInfo->pUpdatedMap);
-      continue;
-    } else if (pBlock->info.type == STREAM_RETRIEVE && !IS_FINAL_OP(pInfo)) {
-      doDeleteWindows(pOperator, &pInfo->interval, pBlock, NULL, pInfo->pUpdatedMap);
-      if (taosArrayGetSize(pInfo->pUpdated) > 0) {
-        break;
-      }
-      continue;
-    } else if (pBlock->info.type == STREAM_PULL_OVER && IS_FINAL_OP(pInfo)) {
-      processPullOver(pBlock, pInfo->pPullDataMap, pInfo->pFinalPullDataMap, &pInfo->interval, pInfo->pPullWins, pInfo->numOfChild, pOperator);
-      continue;
-    } else if (pBlock->info.type == STREAM_CREATE_CHILD_TABLE) {
-      return pBlock;
-    } 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);
-    doStreamIntervalAggImpl(pOperator, pBlock, pBlock->info.id.groupId, 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);
-  if (IS_FINAL_OP(pInfo)) {
-    closeStreamIntervalWindow(pInfo->aggSup.pResultRowHashTable, &pInfo->twAggSup, &pInfo->interval,
-                              pInfo->pPullDataMap, pInfo->pUpdatedMap, pInfo->pDelWins, pOperator);
-  }
-  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);
-
-  doBuildPullDataBlock(pInfo->pPullWins, &pInfo->pullIndex, pInfo->pPullDataRes);
-  if (pInfo->pPullDataRes->info.rows != 0) {
-    // process the rest of the data
-    printDataBlock(pInfo->pPullDataRes, IS_FINAL_OP(pInfo) ? "interval final" : "interval semi");
-    return pInfo->pPullDataRes;
-  }
-
-  doBuildDeleteResult(pInfo, pInfo->pDelWins, &pInfo->delIndex, pInfo->pDelRes);
-  if (pInfo->pDelRes->info.rows != 0) {
-    // process the rest of the data
-    printDataBlock(pInfo->pDelRes, IS_FINAL_OP(pInfo) ? "interval final" : "interval semi");
-    return pInfo->pDelRes;
-  }
-
-  doBuildStreamIntervalResult(pOperator, pInfo->pState, pInfo->binfo.pRes, &pInfo->groupResInfo);
-  if (pInfo->binfo.pRes->info.rows != 0) {
-    printDataBlock(pInfo->binfo.pRes, IS_FINAL_OP(pInfo) ? "interval final" : "interval semi");
-    return pInfo->binfo.pRes;
-  }
-
-  return NULL;
-}
-
-int64_t getDeleteMark(SIntervalPhysiNode* pIntervalPhyNode) {
-  if (pIntervalPhyNode->window.deleteMark <= 0) {
-    return DEAULT_DELETE_MARK;
-  }
-  int64_t deleteMark = TMAX(pIntervalPhyNode->window.deleteMark, pIntervalPhyNode->window.watermark);
-  deleteMark = TMAX(deleteMark, pIntervalPhyNode->interval);
-  return deleteMark;
-}
-
-TSKEY compareTs(void* pKey) {
-  SWinKey* pWinKey = (SWinKey*)pKey;
-  return pWinKey->ts;
-}
-
-int32_t getSelectivityBufSize(SqlFunctionCtx* pCtx) {
-  if (pCtx->subsidiaries.rowLen == 0) {
-    int32_t rowLen = 0;
-    for (int32_t j = 0; j < pCtx->subsidiaries.num; ++j) {
-      SqlFunctionCtx* pc = pCtx->subsidiaries.pCtx[j];
-      rowLen += pc->pExpr->base.resSchema.bytes;
-    }
-
-    return rowLen + pCtx->subsidiaries.num * sizeof(bool);
-  } else {
-    return pCtx->subsidiaries.rowLen;
-  }
-}
-
-int32_t getMaxFunResSize(SExprSupp* pSup, int32_t numOfCols) {
-  int32_t size = 0;
-  for (int32_t i = 0; i < numOfCols; ++i) {
-      int32_t resSize = getSelectivityBufSize(pSup->pCtx + i);
-      size = TMAX(size, resSize);
-  }
-  return size;
-}
-
-void streamIntervalReleaseState(SOperatorInfo* pOperator) {
-  if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL) {
-    SStreamIntervalOperatorInfo* pInfo = pOperator->info;
-    int32_t resSize = sizeof(TSKEY);
-    pInfo->statestore.streamStateSaveInfo(pInfo->pState, STREAM_INTERVAL_OP_STATE_NAME, strlen(STREAM_INTERVAL_OP_STATE_NAME), &pInfo->twAggSup.maxTs, resSize);
-  }
-  SStreamIntervalOperatorInfo* pInfo = pOperator->info;
-  SStorageAPI* pAPI = &pOperator->pTaskInfo->storageAPI;
-  pAPI->stateStore.streamStateCommit(pInfo->pState);
-  SOperatorInfo* downstream = pOperator->pDownstream[0];
-  if (downstream->fpSet.releaseStreamStateFn) {
-    downstream->fpSet.releaseStreamStateFn(downstream);
-  }
-}
-
-void streamIntervalReloadState(SOperatorInfo* pOperator) {
-  if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL) {
-    SStreamIntervalOperatorInfo* pInfo = pOperator->info;
-    int32_t size = 0;
-    void* pBuf = NULL;
-    int32_t code = pInfo->statestore.streamStateGetInfo(pInfo->pState, STREAM_INTERVAL_OP_STATE_NAME,
-                                                        strlen(STREAM_INTERVAL_OP_STATE_NAME), &pBuf, &size);
-    TSKEY ts = *(TSKEY*)pBuf;
-    taosMemoryFree(pBuf);
-    pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, ts);
-    pInfo->statestore.streamStateReloadInfo(pInfo->pState, ts);
-  }
-  SOperatorInfo* downstream = pOperator->pDownstream[0];
-  if (downstream->fpSet.reloadStreamStateFn) {
-    downstream->fpSet.reloadStreamStateFn(downstream);
-  }
-}
-
-SOperatorInfo* createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode,
-                                                     SExecTaskInfo* pTaskInfo, int32_t numOfChild) {
-  SIntervalPhysiNode*          pIntervalPhyNode = (SIntervalPhysiNode*)pPhyNode;
-  SStreamIntervalOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamIntervalOperatorInfo));
-  SOperatorInfo*               pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
-  if (pInfo == NULL || pOperator == NULL) {
-    goto _error;
-  }
-
-  pOperator->pTaskInfo = pTaskInfo;
-  SStorageAPI* pAPI = &pTaskInfo->storageAPI;
-
-  pInfo->interval = (SInterval){.interval = pIntervalPhyNode->interval,
-                                .sliding = pIntervalPhyNode->sliding,
-                                .intervalUnit = pIntervalPhyNode->intervalUnit,
-                                .slidingUnit = pIntervalPhyNode->slidingUnit,
-                                .offset = pIntervalPhyNode->offset,
-                                .precision = ((SColumnNode*)pIntervalPhyNode->window.pTspk)->node.resType.precision};
-  pInfo->twAggSup = (STimeWindowAggSupp){
-      .waterMark = pIntervalPhyNode->window.watermark,
-      .calTrigger = pIntervalPhyNode->window.triggerType,
-      .maxTs = INT64_MIN,
-      .minTs = INT64_MAX,
-      .deleteMark = getDeleteMark(pIntervalPhyNode),
-      .deleteMarkSaved = 0,
-      .calTriggerSaved = 0,
-      .checkPointTs = 0,
-      .checkPointInterval =
-          convertTimePrecision(tsCheckpointInterval, TSDB_TIME_PRECISION_MILLI, pInfo->interval.precision),
-  };
-  ASSERTS(pInfo->twAggSup.calTrigger != STREAM_TRIGGER_MAX_DELAY, "trigger type should not be max delay");
-  pInfo->primaryTsIndex = ((SColumnNode*)pIntervalPhyNode->window.pTspk)->slotId;
-  size_t keyBufSize = sizeof(int64_t) + sizeof(int64_t) + POINTER_BYTES;
-  initResultSizeInfo(&pOperator->resultInfo, 4096);
-  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);
-    if (code != TSDB_CODE_SUCCESS) {
-      goto _error;
-    }
-  }
-
-  int32_t      numOfCols = 0;
-  SExprInfo*   pExprInfo = createExprInfo(pIntervalPhyNode->window.pFuncs, NULL, &numOfCols);
-  SSDataBlock* pResBlock = createDataBlockFromDescNode(pPhyNode->pOutputDataBlockDesc);
-  initBasicInfo(&pInfo->binfo, pResBlock);
-
-  pInfo->pState = taosMemoryCalloc(1, sizeof(SStreamState));
-  *(pInfo->pState) = *(pTaskInfo->streamInfo.pState);
-
-  pAPI->stateStore.streamStateSetNumber(pInfo->pState, -1);
-  int32_t code = initAggSup(&pOperator->exprSupp, &pInfo->aggSup, pExprInfo, numOfCols, keyBufSize, pTaskInfo->id.str,
-                            pInfo->pState, &pTaskInfo->storageAPI.functionStore);
-  if (code != TSDB_CODE_SUCCESS) {
-    goto _error;
-  }
-
-  initStreamFunciton(pOperator->exprSupp.pCtx, pOperator->exprSupp.numOfExprs);
-  initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window);
-  initResultRowInfo(&pInfo->binfo.resultRowInfo);
-
-  pInfo->numOfChild = numOfChild;
-
-  pInfo->pPhyNode = (SPhysiNode*)nodesCloneNode((SNode*)pPhyNode);
-
-  if (pPhyNode->type == QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL) {
-    pInfo->isFinal = true;
-    pOperator->name = "StreamFinalIntervalOperator";
-  } else {
-    // semi interval operator does not catch result
-    pInfo->isFinal = false;
-    pOperator->name = "StreamSemiIntervalOperator";
-  }
-
-  if (!IS_FINAL_OP(pInfo) || numOfChild == 0) {
-    pInfo->twAggSup.calTrigger = STREAM_TRIGGER_AT_ONCE;
-  }
-
-  pInfo->pPullWins = taosArrayInit(8, sizeof(SPullWindowInfo));
-  pInfo->pullIndex = 0;
-  _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
-  pInfo->pPullDataMap = taosHashInit(64, hashFn, false, HASH_NO_LOCK);
-  pInfo->pFinalPullDataMap = taosHashInit(64, hashFn, false, HASH_NO_LOCK);
-  pInfo->pPullDataRes = createSpecialDataBlock(STREAM_RETRIEVE);
-  pInfo->ignoreExpiredData = pIntervalPhyNode->window.igExpired;
-  pInfo->ignoreExpiredDataSaved = false;
-  pInfo->pDelRes = createSpecialDataBlock(STREAM_DELETE_RESULT);
-  pInfo->delIndex = 0;
-  pInfo->pDelWins = taosArrayInit(4, sizeof(SWinKey));
-  pInfo->delKey.ts = INT64_MAX;
-  pInfo->delKey.groupId = 0;
-  pInfo->numOfDatapack = 0;
-  pInfo->pUpdated = NULL;
-  pInfo->pUpdatedMap = NULL;
-  int32_t funResSize= getMaxFunResSize(&pOperator->exprSupp, numOfCols);
-  pInfo->pState->pFileState = pAPI->stateStore.streamFileStateInit(tsStreamBufferSize, sizeof(SWinKey), pInfo->aggSup.resultRowSize, funResSize,
-                                                  compareTs, pInfo->pState, pInfo->twAggSup.deleteMark, GET_TASKID(pTaskInfo));
-  pInfo->dataVersion = 0;
-  pInfo->statestore = pTaskInfo->storageAPI.stateStore;
-  pInfo->recvGetAll = false;
-
-  pOperator->operatorType = pPhyNode->type;
-  pOperator->blocking = true;
-  pOperator->status = OP_NOT_OPENED;
-  pOperator->info = pInfo;
-
-  pOperator->fpSet = createOperatorFpSet(NULL, doStreamFinalIntervalAgg, NULL, destroyStreamFinalIntervalOperatorInfo,
-                                         optrDefaultBufFn, NULL);
-  setOperatorStreamStateFn(pOperator, streamIntervalReleaseState, streamIntervalReloadState);
-  if (pPhyNode->type == QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL) {
-    initIntervalDownStream(downstream, pPhyNode->type, pInfo);
-  }
-  code = appendDownstream(pOperator, &downstream, 1);
-  if (code != TSDB_CODE_SUCCESS) {
-    goto _error;
-  }
-
-  return pOperator;
-
-_error:
-  destroyStreamFinalIntervalOperatorInfo(pInfo);
-  taosMemoryFreeClear(pOperator);
-  pTaskInfo->code = code;
-  return NULL;
-}
-
-void destroyStreamAggSupporter(SStreamAggSupporter* pSup) {
-  tSimpleHashCleanup(pSup->pResultRows);
-  destroyDiskbasedBuf(pSup->pResultBuf);
-  blockDataDestroy(pSup->pScanBlock);
-  taosMemoryFreeClear(pSup->pState);
-  taosMemoryFreeClear(pSup->pDummyCtx);
-}
-
-void destroyStreamSessionAggOperatorInfo(void* param) {
-  SStreamSessionAggOperatorInfo* pInfo = (SStreamSessionAggOperatorInfo*)param;
-  cleanupBasicInfo(&pInfo->binfo);
-  destroyStreamAggSupporter(&pInfo->streamAggSup);
-
-  if (pInfo->pChildren != NULL) {
-    int32_t size = taosArrayGetSize(pInfo->pChildren);
-    for (int32_t i = 0; i < size; i++) {
-      SOperatorInfo* pChild = taosArrayGetP(pInfo->pChildren, i);
-      destroyOperator(pChild);
-    }
-    taosArrayDestroy(pInfo->pChildren);
-  }
-
-  colDataDestroy(&pInfo->twAggSup.timeWindowData);
-  blockDataDestroy(pInfo->pDelRes);
-  blockDataDestroy(pInfo->pWinBlock);
-  blockDataDestroy(pInfo->pUpdateRes);
-  tSimpleHashCleanup(pInfo->pStUpdated);
-  tSimpleHashCleanup(pInfo->pStDeleted);
-
-  taosArrayDestroy(pInfo->historyWins);
-  taosMemoryFreeClear(param);
-}
-
-int32_t initBasicInfoEx(SOptrBasicInfo* pBasicInfo, SExprSupp* pSup, SExprInfo* pExprInfo, int32_t numOfCols,
-                        SSDataBlock* pResultBlock, SFunctionStateStore* pStore) {
-  initBasicInfo(pBasicInfo, pResultBlock);
-  int32_t code = initExprSupp(pSup, pExprInfo, numOfCols, pStore);
-  if (code != TSDB_CODE_SUCCESS) {
-    return code;
-  }
-
-  initStreamFunciton(pSup->pCtx, pSup->numOfExprs);
-  for (int32_t i = 0; i < numOfCols; ++i) {
-    pSup->pCtx[i].saveHandle.pBuf = NULL;
-  }
-
-  ASSERT(numOfCols > 0);
-  return TSDB_CODE_SUCCESS;
-}
-
-void initDummyFunction(SqlFunctionCtx* pDummy, SqlFunctionCtx* pCtx, int32_t nums) {
-  for (int i = 0; i < nums; i++) {
-    pDummy[i].functionId = pCtx[i].functionId;
-    pDummy[i].isNotNullFunc = pCtx[i].isNotNullFunc;
-    pDummy[i].isPseudoFunc = pCtx[i].isPseudoFunc;
-  }
-}
-
-void initDownStream(SOperatorInfo* downstream, SStreamAggSupporter* pAggSup, uint16_t type, int32_t tsColIndex,
-                    STimeWindowAggSupp* pTwSup) {
-  if (downstream->operatorType == QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION) {
-    SStreamPartitionOperatorInfo* pScanInfo = downstream->info;
-    pScanInfo->tsColIndex = tsColIndex;
-  }
-
-  if (downstream->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN) {
-    initDownStream(downstream->pDownstream[0], pAggSup, type, tsColIndex, pTwSup);
-    return;
-  }
-  SStreamScanInfo* pScanInfo = downstream->info;
-  pScanInfo->windowSup = (SWindowSupporter){.pStreamAggSup = pAggSup, .gap = pAggSup->gap, .parentType = type};
-  pScanInfo->pState = pAggSup->pState;
-  if (!pScanInfo->pUpdateInfo) {
-    pScanInfo->pUpdateInfo = pAggSup->stateStore.updateInfoInit(60000, TSDB_TIME_PRECISION_MILLI, pTwSup->waterMark);
-  }
-  pScanInfo->twAggSup = *pTwSup;
-}
-
-int32_t initStreamAggSupporter(SStreamAggSupporter* pSup, SqlFunctionCtx* pCtx, int32_t numOfOutput, int64_t gap,
-                               SStreamState* pState, int32_t keySize, int16_t keyType, SStateStore* pStore, SReadHandle* pHandle, SStorageAPI* pApi) {
-  pSup->resultRowSize = keySize + getResultRowSize(pCtx, numOfOutput);
-  pSup->pScanBlock = createSpecialDataBlock(STREAM_CLEAR);
-  pSup->gap = gap;
-  pSup->stateKeySize = keySize;
-  pSup->stateKeyType = keyType;
-  pSup->pDummyCtx = (SqlFunctionCtx*)taosMemoryCalloc(numOfOutput, sizeof(SqlFunctionCtx));
-  if (pSup->pDummyCtx == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
-  }
-
-  pSup->stateStore = *pStore;
-
-  initDummyFunction(pSup->pDummyCtx, pCtx, numOfOutput);
-  pSup->pState = taosMemoryCalloc(1, sizeof(SStreamState));
-  *(pSup->pState) = *pState;
-  pSup->stateStore.streamStateSetNumber(pSup->pState, -1);
-
-  _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
-  pSup->pResultRows = tSimpleHashInit(32, hashFn);
-
-  int32_t pageSize = 4096;
-  while (pageSize < pSup->resultRowSize * 4) {
-    pageSize <<= 1u;
-  }
-  // at least four pages need to be in buffer
-  int32_t bufSize = 4096 * 256;
-  if (bufSize <= pageSize) {
-    bufSize = pageSize * 4;
-  }
-
-  if (!osTempSpaceAvailable()) {
-    terrno = TSDB_CODE_NO_DISKSPACE;
-    qError("Init stream agg supporter failed since %s, tempDir:%s", terrstr(), tsTempDir);
-    return terrno;
-  }
-
-  int32_t code = createDiskbasedBuf(&pSup->pResultBuf, pageSize, bufSize, "function", tsTempDir);
-  for (int32_t i = 0; i < numOfOutput; ++i) {
-    pCtx[i].saveHandle.pBuf = pSup->pResultBuf;
-  }
-
-  pSup->pSessionAPI = pApi;
-
-  return TSDB_CODE_SUCCESS;
-}
-
-bool isInTimeWindow(STimeWindow* pWin, TSKEY ts, int64_t gap) {
-  if (ts + gap >= pWin->skey && ts - gap <= pWin->ekey) {
-    return true;
-  }
-  return false;
-}
-
-bool isInWindow(SResultWindowInfo* pWinInfo, TSKEY ts, int64_t gap) {
-  return isInTimeWindow(&pWinInfo->sessionWin.win, ts, gap);
-}
-
-void getCurSessionWindow(SStreamAggSupporter* pAggSup, TSKEY startTs, TSKEY endTs, uint64_t groupId,
-                         SSessionKey* pKey) {
-  pKey->win.skey = startTs;
-  pKey->win.ekey = endTs;
-  pKey->groupId = groupId;
-  int32_t code = pAggSup->stateStore.streamStateSessionGetKeyByRange(pAggSup->pState, pKey, pKey);
-  if (code != TSDB_CODE_SUCCESS) {
-    SET_SESSION_WIN_KEY_INVALID(pKey);
-  }
-}
-
-bool isInvalidSessionWin(SResultWindowInfo* pWinInfo) { return pWinInfo->sessionWin.win.skey == 0; }
-
-bool inWinRange(STimeWindow* range, STimeWindow* cur) {
-  if (cur->skey >= range->skey && cur->ekey <= range->ekey) {
-    return true;
-  }
-  return false;
-}
-
-void setSessionOutputBuf(SStreamAggSupporter* pAggSup, TSKEY startTs, TSKEY endTs, uint64_t groupId,
-                         SResultWindowInfo* pCurWin) {
-  pCurWin->sessionWin.groupId = groupId;
-  pCurWin->sessionWin.win.skey = startTs;
-  pCurWin->sessionWin.win.ekey = endTs;
-  int32_t size = pAggSup->resultRowSize;
-  int32_t code = pAggSup->stateStore.streamStateSessionAddIfNotExist(pAggSup->pState, &pCurWin->sessionWin,
-                                                                     pAggSup->gap, &pCurWin->pOutputBuf, &size);
-  if (code == TSDB_CODE_SUCCESS && !inWinRange(&pAggSup->winRange, &pCurWin->sessionWin.win)) {
-    code = TSDB_CODE_FAILED;
-    releaseOutputBuf(pAggSup->pState, NULL, (SResultRow*)pCurWin->pOutputBuf, &pAggSup->pSessionAPI->stateStore);
-    pCurWin->pOutputBuf = taosMemoryCalloc(1, size);
-  }
-
-  if (code == TSDB_CODE_SUCCESS) {
-    pCurWin->isOutput = true;
-    pAggSup->stateStore.streamStateSessionDel(pAggSup->pState, &pCurWin->sessionWin);
-  } else {
-    pCurWin->sessionWin.win.skey = startTs;
-    pCurWin->sessionWin.win.ekey = endTs;
-  }
-}
-
-int32_t getSessionWinBuf(SStreamAggSupporter* pAggSup, SStreamStateCur* pCur, SResultWindowInfo* pWinInfo) {
-  int32_t size = 0;
-  int32_t code = pAggSup->stateStore.streamStateSessionGetKVByCur(pCur, &pWinInfo->sessionWin, &pWinInfo->pOutputBuf, &size);
-  if (code != TSDB_CODE_SUCCESS) {
-    return code;
-  }
-
-  pAggSup->stateStore.streamStateCurNext(pAggSup->pState, pCur);
-  return TSDB_CODE_SUCCESS;
-}
-void saveDeleteInfo(SArray* pWins, SSessionKey key) {
-  // key.win.ekey = key.win.skey;
-  taosArrayPush(pWins, &key);
-}
-
-void saveDeleteRes(SSHashObj* pStDelete, SSessionKey key) {
-  key.win.ekey = key.win.skey;
-  tSimpleHashPut(pStDelete, &key, sizeof(SSessionKey), NULL, 0);
-}
-
-static void removeSessionResult(SSHashObj* pHashMap, SSHashObj* pResMap, SSessionKey key) {
-  key.win.ekey = key.win.skey;
-  tSimpleHashRemove(pHashMap, &key, sizeof(SSessionKey));
-  tSimpleHashRemove(pResMap, &key, sizeof(SSessionKey));
-}
-
-static void getSessionHashKey(const SSessionKey* pKey, SSessionKey* pHashKey) {
-  *pHashKey = *pKey;
-  pHashKey->win.ekey = pKey->win.skey;
-}
-
-static void removeSessionResults(SSHashObj* pHashMap, SArray* pWins) {
-  if (tSimpleHashGetSize(pHashMap) == 0) {
-    return;
-  }
-  int32_t size = taosArrayGetSize(pWins);
-  for (int32_t i = 0; i < size; i++) {
-    SSessionKey* pWin = taosArrayGet(pWins, i);
-    if (!pWin) continue;
-    SSessionKey key = {0};
-    getSessionHashKey(pWin, &key);
-    tSimpleHashRemove(pHashMap, &key, sizeof(SSessionKey));
-  }
-}
-
-int32_t updateSessionWindowInfo(SResultWindowInfo* pWinInfo, TSKEY* pStartTs, TSKEY* pEndTs, uint64_t groupId,
-                                int32_t rows, int32_t start, int64_t gap, SSHashObj* pResultRows, SSHashObj* pStUpdated,
-                                SSHashObj* pStDeleted) {
-  for (int32_t i = start; i < rows; ++i) {
-    if (!isInWindow(pWinInfo, pStartTs[i], gap) && (!pEndTs || !isInWindow(pWinInfo, pEndTs[i], gap))) {
-      return i - start;
-    }
-    if (pWinInfo->sessionWin.win.skey > pStartTs[i]) {
-      if (pStDeleted && pWinInfo->isOutput) {
-        saveDeleteRes(pStDeleted, pWinInfo->sessionWin);
-      }
-      removeSessionResult(pStUpdated, pResultRows, pWinInfo->sessionWin);
-      pWinInfo->sessionWin.win.skey = pStartTs[i];
-    }
-    pWinInfo->sessionWin.win.ekey = TMAX(pWinInfo->sessionWin.win.ekey, pStartTs[i]);
-    if (pEndTs) {
-      pWinInfo->sessionWin.win.ekey = TMAX(pWinInfo->sessionWin.win.ekey, pEndTs[i]);
-    }
-  }
-  return rows - start;
-}
-
-static int32_t initSessionOutputBuf(SResultWindowInfo* pWinInfo, SResultRow** pResult, SqlFunctionCtx* pCtx,
-                                    int32_t numOfOutput, int32_t* rowEntryInfoOffset) {
-  ASSERT(pWinInfo->sessionWin.win.skey <= pWinInfo->sessionWin.win.ekey);
-  *pResult = (SResultRow*)pWinInfo->pOutputBuf;
-  // set time window for current result
-  (*pResult)->win = pWinInfo->sessionWin.win;
-  setResultRowInitCtx(*pResult, pCtx, numOfOutput, rowEntryInfoOffset);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t doOneWindowAggImpl(SColumnInfoData* pTimeWindowData, SResultWindowInfo* pCurWin, SResultRow** pResult,
-                                  int32_t startIndex, int32_t winRows, int32_t rows, int32_t numOutput,
-                                  SOperatorInfo* pOperator, int64_t winDelta) {
-  SExprSupp*     pSup = &pOperator->exprSupp;
-  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
-  int32_t        code = initSessionOutputBuf(pCurWin, pResult, pSup->pCtx, numOutput, pSup->rowEntryInfoOffset);
-  if (code != TSDB_CODE_SUCCESS || (*pResult) == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
-  }
-  updateTimeWindowInfo(pTimeWindowData, &pCurWin->sessionWin.win, winDelta);
-  applyAggFunctionOnPartialTuples(pTaskInfo, pSup->pCtx, pTimeWindowData, startIndex, winRows, rows, numOutput);
-  return TSDB_CODE_SUCCESS;
-}
-
-static bool doDeleteSessionWindow(SStreamAggSupporter* pAggSup, SSessionKey* pKey) {
-  pAggSup->stateStore.streamStateSessionDel(pAggSup->pState, pKey);
-  SSessionKey hashKey = {0};
-  getSessionHashKey(pKey, &hashKey);
-  tSimpleHashRemove(pAggSup->pResultRows, &hashKey, sizeof(SSessionKey));
-  return true;
-}
-
-static int32_t setSessionWinOutputInfo(SSHashObj* pStUpdated, SResultWindowInfo* pWinInfo) {
-  void* pVal = tSimpleHashGet(pStUpdated, &pWinInfo->sessionWin, sizeof(SSessionKey));
-  if (pVal) {
-    SResultWindowInfo* pWin = pVal;
-    pWinInfo->isOutput = pWin->isOutput;
-  }
-  return TSDB_CODE_SUCCESS;
-}
-
-SStreamStateCur* getNextSessionWinInfo(SStreamAggSupporter* pAggSup, SSHashObj* pStUpdated, SResultWindowInfo* pCurWin,
-                                       SResultWindowInfo* pNextWin) {
-  SStreamStateCur* pCur = pAggSup->stateStore.streamStateSessionSeekKeyNext(pAggSup->pState, &pCurWin->sessionWin);
-  pNextWin->isOutput = true;
-  setSessionWinOutputInfo(pStUpdated, pNextWin);
-  int32_t size = 0;
-  pNextWin->sessionWin = pCurWin->sessionWin;
-  int32_t code = pAggSup->stateStore.streamStateSessionGetKVByCur(pCur, &pNextWin->sessionWin, &pNextWin->pOutputBuf, &size);
-  if (code != TSDB_CODE_SUCCESS) {
-    taosMemoryFreeClear(pNextWin->pOutputBuf);
-    SET_SESSION_WIN_INVALID(*pNextWin);
-  }
-  return pCur;
-}
-
-static int32_t compactSessionWindow(SOperatorInfo* pOperator, SResultWindowInfo* pCurWin, SSHashObj* pStUpdated,
-                                 SSHashObj* pStDeleted, bool addGap) {
-  SExprSupp*     pSup = &pOperator->exprSupp;
-  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
-  SStorageAPI*   pAPI = &pOperator->pTaskInfo->storageAPI;
-  int32_t        winNum = 0;
-
-  SStreamSessionAggOperatorInfo* pInfo = pOperator->info;
-  SResultRow*                    pCurResult = NULL;
-  int32_t                        numOfOutput = pOperator->exprSupp.numOfExprs;
-  SStreamAggSupporter*           pAggSup = &pInfo->streamAggSup;
-  initSessionOutputBuf(pCurWin, &pCurResult, pSup->pCtx, numOfOutput, pSup->rowEntryInfoOffset);
-  // Just look for the window behind StartIndex
-  while (1) {
-    SResultWindowInfo winInfo = {0};
-    SStreamStateCur*  pCur = getNextSessionWinInfo(pAggSup, pStUpdated, pCurWin, &winInfo);
-    if (!IS_VALID_SESSION_WIN(winInfo) || !isInWindow(pCurWin, winInfo.sessionWin.win.skey, pAggSup->gap) ||
-        !inWinRange(&pAggSup->winRange, &winInfo.sessionWin.win)) {
-      taosMemoryFree(winInfo.pOutputBuf);
-      pAPI->stateStore.streamStateFreeCur(pCur);
-      break;
-    }
-    SResultRow* pWinResult = NULL;
-    initSessionOutputBuf(&winInfo, &pWinResult, pAggSup->pDummyCtx, numOfOutput, pSup->rowEntryInfoOffset);
-    pCurWin->sessionWin.win.ekey = TMAX(pCurWin->sessionWin.win.ekey, winInfo.sessionWin.win.ekey);
-    int64_t winDelta = 0;
-    if (addGap) {
-      winDelta = pAggSup->gap;
-    }
-    updateTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pCurWin->sessionWin.win, winDelta);
-    compactFunctions(pSup->pCtx, pAggSup->pDummyCtx, numOfOutput, pTaskInfo, &pInfo->twAggSup.timeWindowData);
-    tSimpleHashRemove(pStUpdated, &winInfo.sessionWin, sizeof(SSessionKey));
-    if (winInfo.isOutput && pStDeleted) {
-      saveDeleteRes(pStDeleted, winInfo.sessionWin);
-    }
-    removeSessionResult(pStUpdated, pAggSup->pResultRows, winInfo.sessionWin);
-    doDeleteSessionWindow(pAggSup, &winInfo.sessionWin);
-    pAPI->stateStore.streamStateFreeCur(pCur);
-    taosMemoryFree(winInfo.pOutputBuf);
-    winNum++;
-  }
-  return winNum;
-}
-
-int32_t saveSessionOutputBuf(SStreamAggSupporter* pAggSup, SResultWindowInfo* pWinInfo) {
-  saveSessionDiscBuf(pAggSup->pState, &pWinInfo->sessionWin, pWinInfo->pOutputBuf, pAggSup->resultRowSize, &pAggSup->stateStore);
-  pWinInfo->pOutputBuf = NULL;
-  return TSDB_CODE_SUCCESS;
-}
-
-static void doStreamSessionAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBlock, SSHashObj* pStUpdated,
-                                   SSHashObj* pStDeleted, bool hasEndTs, bool addGap) {
-  SExecTaskInfo*                 pTaskInfo = pOperator->pTaskInfo;
-  SStreamSessionAggOperatorInfo* pInfo = pOperator->info;
-  int32_t                        numOfOutput = pOperator->exprSupp.numOfExprs;
-  uint64_t                       groupId = pSDataBlock->info.id.groupId;
-  int64_t                        code = TSDB_CODE_SUCCESS;
-  SResultRow*                    pResult = NULL;
-  int32_t                        rows = pSDataBlock->info.rows;
-  int32_t                        winRows = 0;
-  SStreamAggSupporter*           pAggSup = &pInfo->streamAggSup;
-
-  pInfo->dataVersion = TMAX(pInfo->dataVersion, pSDataBlock->info.version);
-  pAggSup->winRange = pTaskInfo->streamInfo.fillHistoryWindow;
-  if (pAggSup->winRange.ekey <= 0) {
-    pAggSup->winRange.ekey = INT64_MAX;
-  }
-
-  SColumnInfoData* pStartTsCol = taosArrayGet(pSDataBlock->pDataBlock, pInfo->primaryTsIndex);
-  TSKEY*           startTsCols = (int64_t*)pStartTsCol->pData;
-  SColumnInfoData* pEndTsCol = NULL;
-  if (hasEndTs) {
-    pEndTsCol = taosArrayGet(pSDataBlock->pDataBlock, pInfo->endTsIndex);
-  } else {
-    pEndTsCol = taosArrayGet(pSDataBlock->pDataBlock, pInfo->primaryTsIndex);
-  }
-
-  TSKEY*               endTsCols = (int64_t*)pEndTsCol->pData;
-  for (int32_t i = 0; i < rows;) {
-    if (pInfo->ignoreExpiredData && isOverdue(endTsCols[i], &pInfo->twAggSup)) {
-      i++;
-      continue;
-    }
-    SResultWindowInfo winInfo = {0};
-    setSessionOutputBuf(pAggSup, startTsCols[i], endTsCols[i], groupId, &winInfo);
-    setSessionWinOutputInfo(pStUpdated, &winInfo);
-    winRows = updateSessionWindowInfo(&winInfo, startTsCols, endTsCols, groupId, rows, i, pAggSup->gap,
-                                      pAggSup->pResultRows, pStUpdated, pStDeleted);
-    // coverity scan error
-    if (!winInfo.pOutputBuf) {
-      T_LONG_JMP(pTaskInfo->env, TSDB_CODE_OUT_OF_MEMORY);
-    }
-
-    int64_t winDelta = 0;
-    if (addGap) {
-      winDelta = pAggSup->gap;
-    }
-    code = doOneWindowAggImpl(&pInfo->twAggSup.timeWindowData, &winInfo, &pResult, i, winRows, rows, numOfOutput,
-                              pOperator, winDelta);
-    if (code != TSDB_CODE_SUCCESS || pResult == NULL) {
-      T_LONG_JMP(pTaskInfo->env, TSDB_CODE_OUT_OF_MEMORY);
-    }
-    compactSessionWindow(pOperator, &winInfo, pStUpdated, pStDeleted, addGap);
-    saveSessionOutputBuf(pAggSup, &winInfo);
-
-    if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE && pStUpdated) {
-      code = saveResult(winInfo, pStUpdated);
-      if (code != TSDB_CODE_SUCCESS) {
-        T_LONG_JMP(pTaskInfo->env, TSDB_CODE_OUT_OF_MEMORY);
-      }
-    }
-    if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) {
-      SSessionKey key = {0};
-      getSessionHashKey(&winInfo.sessionWin, &key);
-      tSimpleHashPut(pAggSup->pResultRows, &key, sizeof(SSessionKey), &winInfo, sizeof(SResultWindowInfo));
-    }
-
-    i += winRows;
-  }
-}
-
-static void doDeleteTimeWindows(SStreamAggSupporter* pAggSup, SSDataBlock* pBlock, SArray* result) {
-  SColumnInfoData* pStartTsCol = taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX);
-  TSKEY*           startDatas = (TSKEY*)pStartTsCol->pData;
-  SColumnInfoData* pEndTsCol = taosArrayGet(pBlock->pDataBlock, END_TS_COLUMN_INDEX);
-  TSKEY*           endDatas = (TSKEY*)pEndTsCol->pData;
-  SColumnInfoData* pGroupCol = taosArrayGet(pBlock->pDataBlock, GROUPID_COLUMN_INDEX);
-  uint64_t*        gpDatas = (uint64_t*)pGroupCol->pData;
-  for (int32_t i = 0; i < pBlock->info.rows; i++) {
-    while (1) {
-      SSessionKey curWin = {0};
-      getCurSessionWindow(pAggSup, startDatas[i], endDatas[i], gpDatas[i], &curWin);
-      if (IS_INVALID_SESSION_WIN_KEY(curWin)) {
-        break;
-      }
-      doDeleteSessionWindow(pAggSup, &curWin);
-      if (result) {
-        saveDeleteInfo(result, curWin);
-      }
-    }
-  }
-}
-
-static inline int32_t sessionKeyCompareAsc(const void* pKey1, const void* pKey2) {
-  SSessionKey* pWin1 = (SSessionKey*)pKey1;
-  SSessionKey* pWin2 = (SSessionKey*)pKey2;
-
-  if (pWin1->groupId > pWin2->groupId) {
-    return 1;
-  } else if (pWin1->groupId < pWin2->groupId) {
-    return -1;
-  }
-
-  if (pWin1->win.skey > pWin2->win.skey) {
-    return 1;
-  } else if (pWin1->win.skey < pWin2->win.skey) {
-    return -1;
-  }
-
-  return 0;
-}
-
-static int32_t copyUpdateResult(SSHashObj* pStUpdated, SArray* pUpdated) {
-  void*   pIte = NULL;
-  int32_t iter = 0;
-  while ((pIte = tSimpleHashIterate(pStUpdated, pIte, &iter)) != NULL) {
-    void* key = tSimpleHashGetKey(pIte, NULL);
-    taosArrayPush(pUpdated, key);
-  }
-  taosArraySort(pUpdated, sessionKeyCompareAsc);
-  return TSDB_CODE_SUCCESS;
-}
-
-void doBuildDeleteDataBlock(SOperatorInfo* pOp, SSHashObj* pStDeleted, SSDataBlock* pBlock, void** Ite) {
-  SStorageAPI* pAPI = &pOp->pTaskInfo->storageAPI;
-
-  blockDataCleanup(pBlock);
-  int32_t size = tSimpleHashGetSize(pStDeleted);
-  if (size == 0) {
-    return;
-  }
-  blockDataEnsureCapacity(pBlock, size);
-  int32_t iter = 0;
-  while (((*Ite) = tSimpleHashIterate(pStDeleted, *Ite, &iter)) != NULL) {
-    if (pBlock->info.rows + 1 > pBlock->info.capacity) {
-      break;
-    }
-    SSessionKey*     res = tSimpleHashGetKey(*Ite, NULL);
-    SColumnInfoData* pStartTsCol = taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX);
-    colDataSetVal(pStartTsCol, pBlock->info.rows, (const char*)&res->win.skey, false);
-    SColumnInfoData* pEndTsCol = taosArrayGet(pBlock->pDataBlock, END_TS_COLUMN_INDEX);
-    colDataSetVal(pEndTsCol, pBlock->info.rows, (const char*)&res->win.skey, false);
-    SColumnInfoData* pUidCol = taosArrayGet(pBlock->pDataBlock, UID_COLUMN_INDEX);
-    colDataSetNULL(pUidCol, pBlock->info.rows);
-    SColumnInfoData* pGpCol = taosArrayGet(pBlock->pDataBlock, GROUPID_COLUMN_INDEX);
-    colDataSetVal(pGpCol, pBlock->info.rows, (const char*)&res->groupId, false);
-    SColumnInfoData* pCalStCol = taosArrayGet(pBlock->pDataBlock, CALCULATE_START_TS_COLUMN_INDEX);
-    colDataSetNULL(pCalStCol, pBlock->info.rows);
-    SColumnInfoData* pCalEdCol = taosArrayGet(pBlock->pDataBlock, CALCULATE_END_TS_COLUMN_INDEX);
-    colDataSetNULL(pCalEdCol, pBlock->info.rows);
-
-    SColumnInfoData* pTableCol = taosArrayGet(pBlock->pDataBlock, TABLE_NAME_COLUMN_INDEX);
-
-    void* tbname = NULL;
-    pAPI->stateStore.streamStateGetParName(pOp->pTaskInfo->streamInfo.pState, res->groupId, &tbname);
-    if (tbname == NULL) {
-      colDataSetNULL(pTableCol, pBlock->info.rows);
-    } else {
-      char parTbName[VARSTR_HEADER_SIZE + TSDB_TABLE_NAME_LEN];
-      STR_WITH_MAXSIZE_TO_VARSTR(parTbName, tbname, sizeof(parTbName));
-      colDataSetVal(pTableCol, pBlock->info.rows, (const char*)parTbName, false);
-      pAPI->stateStore.streamStateFreeVal(tbname);
-    }
-    pBlock->info.rows += 1;
-  }
-  if ((*Ite) == NULL) {
-    tSimpleHashClear(pStDeleted);
-  }
-}
-
-static void rebuildSessionWindow(SOperatorInfo* pOperator, SArray* pWinArray, SSHashObj* pStUpdated) {
-  SExprSupp*                     pSup = &pOperator->exprSupp;
-  SExecTaskInfo*                 pTaskInfo = pOperator->pTaskInfo;
-  SStorageAPI* pAPI = &pOperator->pTaskInfo->storageAPI;
-
-  int32_t                        size = taosArrayGetSize(pWinArray);
-  SStreamSessionAggOperatorInfo* pInfo = pOperator->info;
-  SStreamAggSupporter*           pAggSup = &pInfo->streamAggSup;
-  int32_t                        numOfOutput = pSup->numOfExprs;
-  int32_t                        numOfChild = taosArrayGetSize(pInfo->pChildren);
-
-  for (int32_t i = 0; i < size; i++) {
-    SSessionKey*      pWinKey = taosArrayGet(pWinArray, i);
-    int32_t           num = 0;
-    SResultWindowInfo parentWin = {0};
-    for (int32_t j = 0; j < numOfChild; j++) {
-      SOperatorInfo*                 pChild = taosArrayGetP(pInfo->pChildren, j);
-      SStreamSessionAggOperatorInfo* pChInfo = pChild->info;
-      SStreamAggSupporter*           pChAggSup = &pChInfo->streamAggSup;
-      SSessionKey                    chWinKey = {0};
-      getSessionHashKey(pWinKey, &chWinKey);
-      SStreamStateCur* pCur = pAggSup->stateStore.streamStateSessionSeekKeyCurrentNext(pChAggSup->pState, &chWinKey);
-      SResultRow*      pResult = NULL;
-      SResultRow*      pChResult = NULL;
-      while (1) {
-        SResultWindowInfo childWin = {0};
-        childWin.sessionWin = *pWinKey;
-        int32_t code = getSessionWinBuf(pChAggSup, pCur, &childWin);
-
-        if (code == TSDB_CODE_SUCCESS && !inWinRange(&pAggSup->winRange, &childWin.sessionWin.win)) {
-          continue;
-        }
-
-        if (code == TSDB_CODE_SUCCESS && inWinRange(&pWinKey->win, &childWin.sessionWin.win)) {
-          if (num == 0) {
-            setSessionOutputBuf(pAggSup, pWinKey->win.skey, pWinKey->win.ekey, pWinKey->groupId, &parentWin);
-            code = initSessionOutputBuf(&parentWin, &pResult, pSup->pCtx, numOfOutput, pSup->rowEntryInfoOffset);
-            if (code != TSDB_CODE_SUCCESS || pResult == NULL) {
-              break;
-            }
-          }
-          num++;
-          updateTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &parentWin.sessionWin.win, pAggSup->gap); 
-          initSessionOutputBuf(&childWin, &pChResult, pChild->exprSupp.pCtx, numOfOutput,
-                               pChild->exprSupp.rowEntryInfoOffset);
-          compactFunctions(pSup->pCtx, pChild->exprSupp.pCtx, numOfOutput, pTaskInfo, &pInfo->twAggSup.timeWindowData);
-          compactSessionWindow(pOperator, &parentWin, pStUpdated, NULL, true);
-          saveResult(parentWin, pStUpdated);
-        } else {
-          break;
-        }
-      }
-      pAPI->stateStore.streamStateFreeCur(pCur);
-    }
-    if (num > 0) {
-      saveSessionOutputBuf(pAggSup, &parentWin);
-    }
-  }
-}
-
-int32_t closeSessionWindow(SSHashObj* pHashMap, STimeWindowAggSupp* pTwSup, SSHashObj* pClosed) {
-  void*   pIte = NULL;
-  int32_t iter = 0;
-  while ((pIte = tSimpleHashIterate(pHashMap, pIte, &iter)) != NULL) {
-    SResultWindowInfo* pWinInfo = pIte;
-    if (isCloseWindow(&pWinInfo->sessionWin.win, pTwSup)) {
-      if (pTwSup->calTrigger == STREAM_TRIGGER_WINDOW_CLOSE && pClosed) {
-        int32_t code = saveResult(*pWinInfo, pClosed);
-        if (code != TSDB_CODE_SUCCESS) {
-          return code;
-        }
-      }
-      SSessionKey* pKey = tSimpleHashGetKey(pIte, NULL);
-      tSimpleHashIterateRemove(pHashMap, pKey, sizeof(SSessionKey), &pIte, &iter);
-    }
-  }
-  return TSDB_CODE_SUCCESS;
-}
-
-static void closeChildSessionWindow(SArray* pChildren, TSKEY maxTs) {
-  int32_t size = taosArrayGetSize(pChildren);
-  for (int32_t i = 0; i < size; i++) {
-    SOperatorInfo*                 pChildOp = taosArrayGetP(pChildren, i);
-    SStreamSessionAggOperatorInfo* pChInfo = pChildOp->info;
-    pChInfo->twAggSup.maxTs = TMAX(pChInfo->twAggSup.maxTs, maxTs);
-    closeSessionWindow(pChInfo->streamAggSup.pResultRows, &pChInfo->twAggSup, NULL);
-  }
-}
-
-int32_t getAllSessionWindow(SSHashObj* pHashMap, SSHashObj* pStUpdated) {
-  void*   pIte = NULL;
-  int32_t iter = 0;
-  while ((pIte = tSimpleHashIterate(pHashMap, pIte, &iter)) != NULL) {
-    SResultWindowInfo* pWinInfo = pIte;
-    saveResult(*pWinInfo, pStUpdated);
-  }
-  return TSDB_CODE_SUCCESS;
-}
-
-static void copyDeleteWindowInfo(SArray* pResWins, SSHashObj* pStDeleted) {
-  int32_t size = taosArrayGetSize(pResWins);
-  for (int32_t i = 0; i < size; i++) {
-    SSessionKey* pWinKey = taosArrayGet(pResWins, i);
-    if (!pWinKey) continue;
-    SSessionKey winInfo = {0};
-    getSessionHashKey(pWinKey, &winInfo);
-    tSimpleHashPut(pStDeleted, &winInfo, sizeof(SSessionKey), NULL, 0);
-  }
-}
-
-// the allocated memory comes from outer function.
-void initGroupResInfoFromArrayList(SGroupResInfo* pGroupResInfo, SArray* pArrayList) {
-  pGroupResInfo->pRows = pArrayList;
-  pGroupResInfo->index = 0;
-  pGroupResInfo->pBuf = NULL;
-}
-
-void doBuildSessionResult(SOperatorInfo* pOperator, void* pState, SGroupResInfo* pGroupResInfo,
-                          SSDataBlock* pBlock) {
-  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
-  // set output datablock version
-  pBlock->info.version = pTaskInfo->version;
-
-  blockDataCleanup(pBlock);
-  if (!hasRemainResults(pGroupResInfo)) {
-    cleanupGroupResInfo(pGroupResInfo);
-    return;
-  }
-
-  // clear the existed group id
-  pBlock->info.id.groupId = 0;
-  buildSessionResultDataBlock(pOperator, pState, pBlock, &pOperator->exprSupp, pGroupResInfo);
-  if (pBlock->info.rows == 0) {
-    cleanupGroupResInfo(pGroupResInfo);
-  }
-}
-void getMaxTsWins(const SArray* pAllWins, SArray* pMaxWins) {
-  int32_t size = taosArrayGetSize(pAllWins);
-  if (size == 0) {
-    return;
-  }
-
-  SSessionKey* pSeKey = taosArrayGet(pAllWins, size - 1);
-  taosArrayPush(pMaxWins, pSeKey);
-  if (pSeKey->groupId == 0) {
-    return;
-  }
-  uint64_t preGpId = pSeKey->groupId;
-  for (int32_t i = size - 2; i >= 0; i--) {
-    pSeKey = taosArrayGet(pAllWins, i);
-    if (preGpId != pSeKey->groupId) {
-      taosArrayPush(pMaxWins, pSeKey);
-      preGpId = pSeKey->groupId;
-    }
-  }
-}
-
-static SSDataBlock* doStreamSessionAgg(SOperatorInfo* pOperator) {
-  SExprSupp*                     pSup = &pOperator->exprSupp;
-  SStreamSessionAggOperatorInfo* pInfo = pOperator->info;
-  SOptrBasicInfo*                pBInfo = &pInfo->binfo;
-  SStreamAggSupporter*           pAggSup = &pInfo->streamAggSup;
-  qDebug("===stream=== stream session agg");
-  if (pOperator->status == OP_EXEC_DONE) {
-    return NULL;
-  } else if (pOperator->status == OP_RES_TO_RETURN) {
-    doBuildDeleteDataBlock(pOperator, pInfo->pStDeleted, pInfo->pDelRes, &pInfo->pDelIterator);
-    if (pInfo->pDelRes->info.rows > 0) {
-      printDataBlock(pInfo->pDelRes, IS_FINAL_OP(pInfo) ? "final session" : "single session");
-      return pInfo->pDelRes;
-    }
-    doBuildSessionResult(pOperator, pAggSup->pState, &pInfo->groupResInfo, pBInfo->pRes);
-    if (pBInfo->pRes->info.rows > 0) {
-      printDataBlock(pBInfo->pRes, IS_FINAL_OP(pInfo) ? "final session" : "single session");
-      return pBInfo->pRes;
-    }
-
-    setOperatorCompleted(pOperator);
-    return NULL;
-  }
-
-  SOperatorInfo* downstream = pOperator->pDownstream[0];
-  if (!pInfo->pUpdated) {
-    pInfo->pUpdated = taosArrayInit(16, sizeof(SSessionKey));
-  }
-  if (!pInfo->pStUpdated) {
-    _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
-    pInfo->pStUpdated = tSimpleHashInit(64, hashFn);
-  }
-  while (1) {
-    SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
-    if (pBlock == NULL) {
-      break;
-    }
-    printDataBlock(pBlock, IS_FINAL_OP(pInfo) ? "final session recv" : "single session recv");
-
-    if (pBlock->info.type == STREAM_DELETE_DATA || pBlock->info.type == STREAM_DELETE_RESULT ||
-        pBlock->info.type == STREAM_CLEAR) {
-      SArray* pWins = taosArrayInit(16, sizeof(SSessionKey));
-      // gap must be 0
-      doDeleteTimeWindows(pAggSup, pBlock, pWins);
-      removeSessionResults(pInfo->pStUpdated, pWins);
-      if (IS_FINAL_OP(pInfo)) {
-        int32_t                        childIndex = getChildIndex(pBlock);
-        SOperatorInfo*                 pChildOp = taosArrayGetP(pInfo->pChildren, childIndex);
-        SStreamSessionAggOperatorInfo* pChildInfo = pChildOp->info;
-        // gap must be 0
-        doDeleteTimeWindows(&pChildInfo->streamAggSup, pBlock, NULL);
-        rebuildSessionWindow(pOperator, pWins, pInfo->pStUpdated);
-      }
-      copyDeleteWindowInfo(pWins, pInfo->pStDeleted);
-      taosArrayDestroy(pWins);
-      continue;
-    } else if (pBlock->info.type == STREAM_GET_ALL) {
-      getAllSessionWindow(pAggSup->pResultRows, pInfo->pStUpdated);
-      continue;
-    } else if (pBlock->info.type == STREAM_CREATE_CHILD_TABLE) {
-      return pBlock;
-    } else {
-      ASSERTS(pBlock->info.type == STREAM_NORMAL || 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);
-    }
-    // the pDataBlock are always the same one, no need to call this again
-    setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true);
-    doStreamSessionAggImpl(pOperator, pBlock, pInfo->pStUpdated, pInfo->pStDeleted, IS_FINAL_OP(pInfo), true);
-    if (IS_FINAL_OP(pInfo)) {
-      int32_t chIndex = getChildIndex(pBlock);
-      int32_t size = taosArrayGetSize(pInfo->pChildren);
-      // if chIndex + 1 - size > 0, add new child
-      for (int32_t i = 0; i < chIndex + 1 - size; i++) {
-        SOperatorInfo* pChildOp =
-            createStreamFinalSessionAggOperatorInfo(NULL, pInfo->pPhyNode, pOperator->pTaskInfo, 0, NULL);
-        if (!pChildOp) {
-          T_LONG_JMP(pOperator->pTaskInfo->env, TSDB_CODE_OUT_OF_MEMORY);
-        }
-        taosArrayPush(pInfo->pChildren, &pChildOp);
-      }
-      SOperatorInfo* pChildOp = taosArrayGetP(pInfo->pChildren, chIndex);
-      setInputDataBlock(&pChildOp->exprSupp, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true);
-      doStreamSessionAggImpl(pChildOp, pBlock, NULL, NULL, true, false);
-    }
-    pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey);
-    pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.watermark);
-  }
-  // restore the value
-  pOperator->status = OP_RES_TO_RETURN;
-
-  closeSessionWindow(pAggSup->pResultRows, &pInfo->twAggSup, pInfo->pStUpdated);
-  closeChildSessionWindow(pInfo->pChildren, pInfo->twAggSup.maxTs);
-  copyUpdateResult(pInfo->pStUpdated, pInfo->pUpdated);
-  removeSessionResults(pInfo->pStDeleted, pInfo->pUpdated);
-  tSimpleHashCleanup(pInfo->pStUpdated);
-  pInfo->pStUpdated = NULL;
-  if(pInfo->isHistoryOp) {
-    getMaxTsWins(pInfo->pUpdated, pInfo->historyWins);
-  }
-  initGroupResInfoFromArrayList(&pInfo->groupResInfo, pInfo->pUpdated);
-  pInfo->pUpdated = NULL;
-  blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity);
-
-#if 0
-  char* pBuf = streamStateSessionDump(pAggSup->pState);
-  qDebug("===stream===final session%s", pBuf);
-  taosMemoryFree(pBuf);
-#endif
-
-  doBuildDeleteDataBlock(pOperator, pInfo->pStDeleted, pInfo->pDelRes, &pInfo->pDelIterator);
-  if (pInfo->pDelRes->info.rows > 0) {
-    printDataBlock(pInfo->pDelRes, IS_FINAL_OP(pInfo) ? "final session" : "single session");
-    return pInfo->pDelRes;
-  }
-
-  doBuildSessionResult(pOperator, pAggSup->pState, &pInfo->groupResInfo, pBInfo->pRes);
-  if (pBInfo->pRes->info.rows > 0) {
-    printDataBlock(pBInfo->pRes, IS_FINAL_OP(pInfo) ? "final session" : "single session");
-    return pBInfo->pRes;
-  }
-
-  setOperatorCompleted(pOperator);
-  return NULL;
-}
-
-void streamSessionReleaseState(SOperatorInfo* pOperator) {
-  if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION) {
-    SStreamSessionAggOperatorInfo* pInfo = pOperator->info;
-    int32_t resSize = taosArrayGetSize(pInfo->historyWins) * sizeof(SSessionKey);
-    pInfo->streamAggSup.stateStore.streamStateSaveInfo(pInfo->streamAggSup.pState, STREAM_SESSION_OP_STATE_NAME, strlen(STREAM_SESSION_OP_STATE_NAME), pInfo->historyWins->pData, resSize);
-  }
-  SOperatorInfo* downstream = pOperator->pDownstream[0];
-  if (downstream->fpSet.releaseStreamStateFn) {
-    downstream->fpSet.releaseStreamStateFn(downstream);
-  }
-}
-
-void resetWinRange(STimeWindow* winRange) {
-  winRange->skey = INT64_MIN;
-  winRange->ekey = INT64_MAX;
-}
-
-void streamSessionReloadState(SOperatorInfo* pOperator) {
-  SStreamSessionAggOperatorInfo* pInfo = pOperator->info;
-  SStreamAggSupporter* pAggSup = &pInfo->streamAggSup;
-  resetWinRange(&pAggSup->winRange);
-
-  SResultWindowInfo winInfo = {0};
-  int32_t size = 0;
-  void* pBuf = NULL;
-  int32_t code = pAggSup->stateStore.streamStateGetInfo(pAggSup->pState, STREAM_SESSION_OP_STATE_NAME,
-                                                        strlen(STREAM_SESSION_OP_STATE_NAME), &pBuf, &size);
-  int32_t num = size / sizeof(SSessionKey);
-  SSessionKey* pSeKeyBuf = (SSessionKey*) pBuf;
-  ASSERT(size == num * sizeof(SSessionKey));
-  if (!pInfo->pStUpdated && num > 0) {
-    _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
-    pInfo->pStUpdated = tSimpleHashInit(64, hashFn);
-  }
-  for (int32_t i = 0; i < num; i++) {
-    SResultWindowInfo winInfo = {0};
-    setSessionOutputBuf(pAggSup, pSeKeyBuf[i].win.skey, pSeKeyBuf[i].win.ekey, pSeKeyBuf[i].groupId, &winInfo);
-    int32_t winNum = compactSessionWindow(pOperator, &winInfo, pInfo->pStUpdated, pInfo->pStDeleted, true);
-    if (winNum > 0) {
-      qDebug("===stream=== reload state. save result %" PRId64 ", %" PRIu64, winInfo.sessionWin.win.skey, winInfo.sessionWin.groupId);
-      if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE) {
-        saveResult(winInfo, pInfo->pStUpdated);
-      } else if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) {
-        if (!isCloseWindow(&winInfo.sessionWin.win, &pInfo->twAggSup)) {
-          saveDeleteRes(pInfo->pStDeleted, winInfo.sessionWin);
-        }
-        SSessionKey key = {0};
-        getSessionHashKey(&winInfo.sessionWin, &key);
-        tSimpleHashPut(pAggSup->pResultRows, &key, sizeof(SSessionKey), &winInfo, sizeof(SResultWindowInfo));
-      }
-    }
-    saveSessionOutputBuf(pAggSup, &winInfo);
-  }
-  taosMemoryFree(pBuf);
-
-  SOperatorInfo* downstream = pOperator->pDownstream[0];
-  if (downstream->fpSet.reloadStreamStateFn) {
-    downstream->fpSet.reloadStreamStateFn(downstream);
-  }
-}
-
-SOperatorInfo* createStreamSessionAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode,
-                                                  SExecTaskInfo* pTaskInfo, SReadHandle* pHandle) {
-  SSessionWinodwPhysiNode*       pSessionNode = (SSessionWinodwPhysiNode*)pPhyNode;
-  int32_t                        numOfCols = 0;
-  int32_t                        code = TSDB_CODE_OUT_OF_MEMORY;
-  SStreamSessionAggOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamSessionAggOperatorInfo));
-  SOperatorInfo*                 pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
-  if (pInfo == NULL || pOperator == NULL) {
-    goto _error;
-  }
-
-  pOperator->pTaskInfo = pTaskInfo;
-
-  initResultSizeInfo(&pOperator->resultInfo, 4096);
-  if (pSessionNode->window.pExprs != NULL) {
-    int32_t    numOfScalar = 0;
-    SExprInfo* pScalarExprInfo = createExprInfo(pSessionNode->window.pExprs, NULL, &numOfScalar);
-    code = initExprSupp(&pInfo->scalarSupp, pScalarExprInfo, numOfScalar, &pTaskInfo->storageAPI.functionStore);
-    if (code != TSDB_CODE_SUCCESS) {
-      goto _error;
-    }
-  }
-  SExprSupp* pSup = &pOperator->exprSupp;
-
-  SExprInfo*   pExprInfo = createExprInfo(pSessionNode->window.pFuncs, NULL, &numOfCols);
-  SSDataBlock* pResBlock = createDataBlockFromDescNode(pPhyNode->pOutputDataBlockDesc);
-  code = initBasicInfoEx(&pInfo->binfo, pSup, pExprInfo, numOfCols, pResBlock, &pTaskInfo->storageAPI.functionStore);
-  if (code != TSDB_CODE_SUCCESS) {
-    goto _error;
-  }
-
-  code = initStreamAggSupporter(&pInfo->streamAggSup, pSup->pCtx, numOfCols, pSessionNode->gap,
-                                pTaskInfo->streamInfo.pState, 0, 0, &pTaskInfo->storageAPI.stateStore, pHandle, &pTaskInfo->storageAPI);
-  if (code != TSDB_CODE_SUCCESS) {
-    goto _error;
-  }
-
-  pInfo->twAggSup = (STimeWindowAggSupp){
-      .waterMark = pSessionNode->window.watermark,
-      .calTrigger = pSessionNode->window.triggerType,
-      .maxTs = INT64_MIN,
-      .minTs = INT64_MAX,
-  };
-
-  initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window);
-
-  pInfo->primaryTsIndex = ((SColumnNode*)pSessionNode->window.pTspk)->slotId;
-  if (pSessionNode->window.pTsEnd) {
-    pInfo->endTsIndex = ((SColumnNode*)pSessionNode->window.pTsEnd)->slotId;
-  }
-  pInfo->binfo.pRes = pResBlock;
-  pInfo->order = TSDB_ORDER_ASC;
-  _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
-  pInfo->pStDeleted = tSimpleHashInit(64, hashFn);
-  pInfo->pDelIterator = NULL;
-  pInfo->pDelRes = createSpecialDataBlock(STREAM_DELETE_RESULT);
-  pInfo->pChildren = NULL;
-  pInfo->isFinal = false;
-  pInfo->pPhyNode = pPhyNode;
-  pInfo->ignoreExpiredData = pSessionNode->window.igExpired;
-  pInfo->ignoreExpiredDataSaved = false;
-  pInfo->pUpdated = NULL;
-  pInfo->pStUpdated = NULL;
-  pInfo->dataVersion = 0;
-  pInfo->historyWins = taosArrayInit(4, sizeof(SSessionKey));
-  if (!pInfo->historyWins) {
-    goto _error;
-  }
-  if (pHandle) {
-    pInfo->isHistoryOp = pHandle->fillHistory;
-  }
-
-  setOperatorInfo(pOperator, "StreamSessionWindowAggOperator", QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION, true,
-                  OP_NOT_OPENED, pInfo, pTaskInfo);
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamSessionAgg, NULL, destroyStreamSessionAggOperatorInfo,
-                                         optrDefaultBufFn, NULL);
-  setOperatorStreamStateFn(pOperator, streamSessionReleaseState, streamSessionReloadState);
-
-  if (downstream) {
-    initDownStream(downstream, &pInfo->streamAggSup, pOperator->operatorType, pInfo->primaryTsIndex, &pInfo->twAggSup);
-    code = appendDownstream(pOperator, &downstream, 1);
-  }
-  return pOperator;
-
-_error:
-  if (pInfo != NULL) {
-    destroyStreamSessionAggOperatorInfo(pInfo);
-  }
-
-  taosMemoryFreeClear(pOperator);
-  pTaskInfo->code = code;
-  return NULL;
-}
-
-static void clearStreamSessionOperator(SStreamSessionAggOperatorInfo* pInfo) {
-  tSimpleHashClear(pInfo->streamAggSup.pResultRows);
-  pInfo->streamAggSup.stateStore.streamStateSessionClear(pInfo->streamAggSup.pState);
-}
-
-static SSDataBlock* doStreamSessionSemiAgg(SOperatorInfo* pOperator) {
-  SStreamSessionAggOperatorInfo* pInfo = pOperator->info;
-  SOptrBasicInfo*                pBInfo = &pInfo->binfo;
-  TSKEY                          maxTs = INT64_MIN;
-  SExprSupp*                     pSup = &pOperator->exprSupp;
-  SStreamAggSupporter*           pAggSup = &pInfo->streamAggSup;
-
-  qDebug("===stream=== stream session semi agg");
-  if (pOperator->status == OP_EXEC_DONE) {
-    return NULL;
-  }
-
-  {
-    doBuildSessionResult(pOperator, pAggSup->pState, &pInfo->groupResInfo, pBInfo->pRes);
-    if (pBInfo->pRes->info.rows > 0) {
-      printDataBlock(pBInfo->pRes, "semi session");
-      return pBInfo->pRes;
-    }
-
-    doBuildDeleteDataBlock(pOperator, pInfo->pStDeleted, pInfo->pDelRes, &pInfo->pDelIterator);
-    if (pInfo->pDelRes->info.rows > 0) {
-      printDataBlock(pInfo->pDelRes, "semi session delete");
-      return pInfo->pDelRes;
-    }
-
-    if (pOperator->status == OP_RES_TO_RETURN) {
-      clearFunctionContext(&pOperator->exprSupp);
-      // semi interval operator clear disk buffer
-      clearStreamSessionOperator(pInfo);
-      setOperatorCompleted(pOperator);
-      return NULL;
-    }
-  }
-
-  SOperatorInfo* downstream = pOperator->pDownstream[0];
-  if (!pInfo->pUpdated) {
-    pInfo->pUpdated = taosArrayInit(16, sizeof(SSessionKey));
-  }
-  if (!pInfo->pStUpdated) {
-    _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
-    pInfo->pStUpdated = tSimpleHashInit(64, hashFn);
-  }
-  while (1) {
-    SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
-    if (pBlock == NULL) {
-      clearSpecialDataBlock(pInfo->pUpdateRes);
-      pOperator->status = OP_RES_TO_RETURN;
-      break;
-    }
-    printDataBlock(pBlock, "semi session recv");
-
-    if (pBlock->info.type == STREAM_DELETE_DATA || pBlock->info.type == STREAM_DELETE_RESULT ||
-        pBlock->info.type == STREAM_CLEAR) {
-      // gap must be 0
-      SArray* pWins = taosArrayInit(16, sizeof(SSessionKey));
-      doDeleteTimeWindows(&pInfo->streamAggSup, pBlock, pWins);
-      removeSessionResults(pInfo->pStUpdated, pWins);
-      copyDeleteWindowInfo(pWins, pInfo->pStDeleted);
-      taosArrayDestroy(pWins);
-      break;
-    } else if (pBlock->info.type == STREAM_GET_ALL) {
-      getAllSessionWindow(pInfo->streamAggSup.pResultRows, pInfo->pStUpdated);
-      continue;
-    } else if (pBlock->info.type == STREAM_CREATE_CHILD_TABLE) {
-      return pBlock;
-    } else {
-      ASSERTS(pBlock->info.type == STREAM_NORMAL || 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);
-    }
-    // the pDataBlock are always the same one, no need to call this again
-    setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true);
-    doStreamSessionAggImpl(pOperator, pBlock, pInfo->pStUpdated, NULL, false, false);
-    maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey);
-  }
-
-  pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, maxTs);
-  pBInfo->pRes->info.watermark = pInfo->twAggSup.maxTs;
-
-  copyUpdateResult(pInfo->pStUpdated, pInfo->pUpdated);
-  removeSessionResults(pInfo->pStDeleted, pInfo->pUpdated);
-  tSimpleHashCleanup(pInfo->pStUpdated);
-  pInfo->pStUpdated = NULL;
-  initGroupResInfoFromArrayList(&pInfo->groupResInfo, pInfo->pUpdated);
-  pInfo->pUpdated = NULL;
-  blockDataEnsureCapacity(pBInfo->pRes, pOperator->resultInfo.capacity);
-
-#if 0
-  char* pBuf = streamStateSessionDump(pAggSup->pState);
-  qDebug("===stream===semi session%s", pBuf);
-  taosMemoryFree(pBuf);
-#endif
-
-  doBuildSessionResult(pOperator, pAggSup->pState, &pInfo->groupResInfo, pBInfo->pRes);
-  if (pBInfo->pRes->info.rows > 0) {
-    printDataBlock(pBInfo->pRes, "semi session");
-    return pBInfo->pRes;
-  }
-
-  doBuildDeleteDataBlock(pOperator, pInfo->pStDeleted, pInfo->pDelRes, &pInfo->pDelIterator);
-  if (pInfo->pDelRes->info.rows > 0) {
-    printDataBlock(pInfo->pDelRes, "semi session delete");
-    return pInfo->pDelRes;
-  }
-
-  clearFunctionContext(&pOperator->exprSupp);
-  // semi interval operator clear disk buffer
-  clearStreamSessionOperator(pInfo);
-  setOperatorCompleted(pOperator);
-  return NULL;
-}
-
-SOperatorInfo* createStreamFinalSessionAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode,
-                                                       SExecTaskInfo* pTaskInfo, int32_t numOfChild, SReadHandle* pHandle) {
-  int32_t        code = TSDB_CODE_OUT_OF_MEMORY;
-  SOperatorInfo* pOperator = createStreamSessionAggOperatorInfo(downstream, pPhyNode, pTaskInfo, pHandle);
-  if (pOperator == NULL) {
-    goto _error;
-  }
-
-  SStorageAPI* pAPI = &pTaskInfo->storageAPI;
-  SStreamSessionAggOperatorInfo* pInfo = pOperator->info;
-
-  pInfo->isFinal = (pPhyNode->type == QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION);
-  char* name = (pInfo->isFinal) ? "StreamSessionFinalAggOperator" : "StreamSessionSemiAggOperator";
-
-  if (pPhyNode->type != QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION) {
-    pInfo->pUpdateRes = createSpecialDataBlock(STREAM_CLEAR);
-    blockDataEnsureCapacity(pInfo->pUpdateRes, 128);
-    pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamSessionSemiAgg, NULL,
-                                           destroyStreamSessionAggOperatorInfo, optrDefaultBufFn, NULL);
-  }
-  setOperatorStreamStateFn(pOperator, streamSessionReleaseState, streamSessionReloadState);
-  setOperatorInfo(pOperator, name, pPhyNode->type, false, OP_NOT_OPENED, pInfo, pTaskInfo);
-
-  pOperator->operatorType = pPhyNode->type;
-  if (numOfChild > 0) {
-    pInfo->pChildren = taosArrayInit(numOfChild, sizeof(void*));
-    for (int32_t i = 0; i < numOfChild; i++) {
-      SOperatorInfo* pChildOp = createStreamFinalSessionAggOperatorInfo(NULL, pPhyNode, pTaskInfo, 0, NULL);
-      if (pChildOp == NULL) {
-        goto _error;
-      }
-      SStreamSessionAggOperatorInfo* pChInfo = pChildOp->info;
-      pChInfo->twAggSup.calTrigger = STREAM_TRIGGER_AT_ONCE;
-      pAPI->stateStore.streamStateSetNumber(pChInfo->streamAggSup.pState, i);
-      taosArrayPush(pInfo->pChildren, &pChildOp);
-    }
-  }
-
-  if (!IS_FINAL_OP(pInfo) || numOfChild == 0) {
-    pInfo->twAggSup.calTrigger = STREAM_TRIGGER_AT_ONCE;
-  }
-
-  return pOperator;
-
-_error:
-  if (pInfo != NULL) {
-    destroyStreamSessionAggOperatorInfo(pInfo);
-  }
-  taosMemoryFreeClear(pOperator);
-  pTaskInfo->code = code;
-  return NULL;
-}
-
-void destroyStreamStateOperatorInfo(void* param) {
-  SStreamStateAggOperatorInfo* pInfo = (SStreamStateAggOperatorInfo*)param;
-  cleanupBasicInfo(&pInfo->binfo);
-  destroyStreamAggSupporter(&pInfo->streamAggSup);
-  cleanupGroupResInfo(&pInfo->groupResInfo);
-  if (pInfo->pChildren != NULL) {
-    int32_t size = taosArrayGetSize(pInfo->pChildren);
-    for (int32_t i = 0; i < size; i++) {
-      SOperatorInfo* pChild = taosArrayGetP(pInfo->pChildren, i);
-      destroyOperator(pChild);
-    }
-    taosArrayDestroy(pInfo->pChildren);
-  }
-  colDataDestroy(&pInfo->twAggSup.timeWindowData);
-  blockDataDestroy(pInfo->pDelRes);
-  taosArrayDestroy(pInfo->historyWins);
-  tSimpleHashCleanup(pInfo->pSeUpdated);
-  tSimpleHashCleanup(pInfo->pSeDeleted);
-  taosMemoryFreeClear(param);
-}
-
-bool isTsInWindow(SStateWindowInfo* pWin, TSKEY ts) {
-  if (pWin->winInfo.sessionWin.win.skey <= ts && ts <= pWin->winInfo.sessionWin.win.ekey) {
-    return true;
-  }
-  return false;
-}
-
-bool isEqualStateKey(SStateWindowInfo* pWin, char* pKeyData) {
-  return pKeyData && compareVal(pKeyData, pWin->pStateKey);
-}
-
-bool compareStateKey(void* data, void* key) {
-  if (!data || !key) {
-    return true;
-  }
-  SStateKeys* stateKey = (SStateKeys*)key;
-  stateKey->pData = (char*)key + sizeof(SStateKeys);
-  return compareVal(data, stateKey);
-}
-
-bool compareWinStateKey(SStateKeys* left, SStateKeys* right) {
-  if (!left || !right) {
-    return false;
-  }
-  return compareVal(left->pData, right);
-}
-
-void setStateOutputBuf(SStreamAggSupporter* pAggSup, TSKEY ts, uint64_t groupId, char* pKeyData,
-                       SStateWindowInfo* pCurWin, SStateWindowInfo* pNextWin) {
-  int32_t size = pAggSup->resultRowSize;
-  pCurWin->winInfo.sessionWin.groupId = groupId;
-  pCurWin->winInfo.sessionWin.win.skey = ts;
-  pCurWin->winInfo.sessionWin.win.ekey = ts;
-  int32_t code =
-      pAggSup->stateStore.streamStateStateAddIfNotExist(pAggSup->pState, &pCurWin->winInfo.sessionWin, pKeyData, pAggSup->stateKeySize,
-                                    compareStateKey, &pCurWin->winInfo.pOutputBuf, &size);
-  pCurWin->pStateKey =
-      (SStateKeys*)((char*)pCurWin->winInfo.pOutputBuf + (pAggSup->resultRowSize - pAggSup->stateKeySize));
-  pCurWin->pStateKey->bytes = pAggSup->stateKeySize - sizeof(SStateKeys);
-  pCurWin->pStateKey->type = pAggSup->stateKeyType;
-  pCurWin->pStateKey->pData = (char*)pCurWin->pStateKey + sizeof(SStateKeys);
-  pCurWin->pStateKey->isNull = false;
-
-  if (code == TSDB_CODE_SUCCESS && !inWinRange(&pAggSup->winRange, &pCurWin->winInfo.sessionWin.win)) {
-    code = TSDB_CODE_FAILED;
-    releaseOutputBuf(pAggSup->pState, NULL, (SResultRow*)pCurWin->winInfo.pOutputBuf, &pAggSup->pSessionAPI->stateStore);
-    pCurWin->winInfo.pOutputBuf = taosMemoryCalloc(1, size);
-    pCurWin->pStateKey =
-      (SStateKeys*)((char*)pCurWin->winInfo.pOutputBuf + (pAggSup->resultRowSize - pAggSup->stateKeySize));
-    pCurWin->pStateKey->bytes = pAggSup->stateKeySize - sizeof(SStateKeys);
-    pCurWin->pStateKey->type = pAggSup->stateKeyType;
-    pCurWin->pStateKey->pData = (char*)pCurWin->pStateKey + sizeof(SStateKeys);
-    pCurWin->pStateKey->isNull = false;
-    pCurWin->winInfo.sessionWin.groupId = groupId;
-    pCurWin->winInfo.sessionWin.win.skey = ts;
-    pCurWin->winInfo.sessionWin.win.ekey = ts;
-    qDebug("===stream===reset state win key. skey:%" PRId64 ", endkey:%" PRId64, pCurWin->winInfo.sessionWin.win.skey, pCurWin->winInfo.sessionWin.win.ekey);
-  }
-
-  if (code == TSDB_CODE_SUCCESS) {
-    pCurWin->winInfo.isOutput = true;
-    pAggSup->stateStore.streamStateSessionDel(pAggSup->pState, &pCurWin->winInfo.sessionWin);
-  } else if (pKeyData) {
-    if (IS_VAR_DATA_TYPE(pAggSup->stateKeyType)) {
-      varDataCopy(pCurWin->pStateKey->pData, pKeyData);
-    } else {
-      memcpy(pCurWin->pStateKey->pData, pKeyData, pCurWin->pStateKey->bytes);
-    }
-  }
-
-  pNextWin->winInfo.sessionWin = pCurWin->winInfo.sessionWin;
-  SStreamStateCur* pCur = pAggSup->stateStore.streamStateSessionSeekKeyNext(pAggSup->pState, &pNextWin->winInfo.sessionWin);
-  int32_t nextSize = pAggSup->resultRowSize;
-  code = pAggSup->stateStore.streamStateSessionGetKVByCur(pCur, &pNextWin->winInfo.sessionWin, &pNextWin->winInfo.pOutputBuf, &nextSize);
-  if (code != TSDB_CODE_SUCCESS) {
-    SET_SESSION_WIN_INVALID(pNextWin->winInfo);
-  } else {
-    pNextWin->pStateKey =
-      (SStateKeys*)((char*)pNextWin->winInfo.pOutputBuf + (pAggSup->resultRowSize - pAggSup->stateKeySize));
-    pNextWin->pStateKey->bytes = pAggSup->stateKeySize - sizeof(SStateKeys);
-    pNextWin->pStateKey->type = pAggSup->stateKeyType;
-    pNextWin->pStateKey->pData = (char*)pNextWin->pStateKey + sizeof(SStateKeys);
-    pNextWin->pStateKey->isNull = false;
-    pNextWin->winInfo.isOutput = true;
-  }
-  pAggSup->stateStore.streamStateFreeCur(pCur);
-}
-
-int32_t updateStateWindowInfo(SStateWindowInfo* pWinInfo, SStateWindowInfo* pNextWin, TSKEY* pTs, uint64_t groupId,
-                              SColumnInfoData* pKeyCol, int32_t rows, int32_t start, bool* allEqual,
-                              SSHashObj* pResultRows, SSHashObj* pSeUpdated, SSHashObj* pSeDeleted) {
-  *allEqual = true;
-  for (int32_t i = start; i < rows; ++i) {
-    char* pKeyData = colDataGetData(pKeyCol, i);
-    if (!isTsInWindow(pWinInfo, pTs[i])) {
-      if (isEqualStateKey(pWinInfo, pKeyData)) {
-        if (IS_VALID_SESSION_WIN(pNextWin->winInfo)) {
-          // ts belongs to the next window
-          if (pTs[i] >= pNextWin->winInfo.sessionWin.win.skey) {
-            return i - start;
-          }
-        }
-      } else {
-        return i - start;
-      }
-    }
-
-    if (pWinInfo->winInfo.sessionWin.win.skey > pTs[i]) {
-      if (pSeDeleted && pWinInfo->winInfo.isOutput) {
-        saveDeleteRes(pSeDeleted, pWinInfo->winInfo.sessionWin);
-      }
-      removeSessionResult(pSeUpdated, pResultRows, pWinInfo->winInfo.sessionWin);
-      pWinInfo->winInfo.sessionWin.win.skey = pTs[i];
-    }
-    pWinInfo->winInfo.sessionWin.win.ekey = TMAX(pWinInfo->winInfo.sessionWin.win.ekey, pTs[i]);
-    if (!isEqualStateKey(pWinInfo, pKeyData)) {
-      *allEqual = false;
-    }
-  }
-  return rows - start;
-}
-
-static void doStreamStateAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBlock, SSHashObj* pSeUpdated,
-                                 SSHashObj* pStDeleted) {
-  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
-  SStorageAPI*   pAPI = &pOperator->pTaskInfo->storageAPI;
-
-  SStreamStateAggOperatorInfo* pInfo = pOperator->info;
-  int32_t                      numOfOutput = pOperator->exprSupp.numOfExprs;
-  uint64_t                     groupId = pSDataBlock->info.id.groupId;
-  int64_t                      code = TSDB_CODE_SUCCESS;
-  TSKEY*                       tsCols = NULL;
-  SResultRow*                  pResult = NULL;
-  int32_t                      winRows = 0;
-  SStreamAggSupporter*         pAggSup = &pInfo->streamAggSup;
-
-  pInfo->dataVersion = TMAX(pInfo->dataVersion, pSDataBlock->info.version);
-  pAggSup->winRange = pTaskInfo->streamInfo.fillHistoryWindow;
-  if (pAggSup->winRange.ekey <= 0) {
-    pAggSup->winRange.ekey = INT64_MAX;
-  }
-
-  if (pSDataBlock->pDataBlock != NULL) {
-    SColumnInfoData* pColDataInfo = taosArrayGet(pSDataBlock->pDataBlock, pInfo->primaryTsIndex);
-    tsCols = (int64_t*)pColDataInfo->pData;
-  } else {
-    return;
-  }
-
-  int32_t              rows = pSDataBlock->info.rows;
-  blockDataEnsureCapacity(pAggSup->pScanBlock, rows);
-  SColumnInfoData* pKeyColInfo = taosArrayGet(pSDataBlock->pDataBlock, pInfo->stateCol.slotId);
-  for (int32_t i = 0; i < rows; i += winRows) {
-    if (pInfo->ignoreExpiredData && isOverdue(tsCols[i], &pInfo->twAggSup) || colDataIsNull_s(pKeyColInfo, i)) {
-      i++;
-      continue;
-    }
-    char*            pKeyData = colDataGetData(pKeyColInfo, i);
-    int32_t          winIndex = 0;
-    bool             allEqual = true;
-    SStateWindowInfo curWin = {0};
-    SStateWindowInfo nextWin = {0};
-    setStateOutputBuf(pAggSup, tsCols[i], groupId, pKeyData, &curWin, &nextWin);
-    if (IS_VALID_SESSION_WIN(nextWin.winInfo)) {
-      releaseOutputBuf(pAggSup->pState, NULL, (SResultRow*)nextWin.winInfo.pOutputBuf, &pAPI->stateStore);
-    }
-    setSessionWinOutputInfo(pSeUpdated, &curWin.winInfo);
-    winRows = updateStateWindowInfo(&curWin, &nextWin, tsCols, groupId, pKeyColInfo, rows, i, &allEqual,
-                                    pAggSup->pResultRows, pSeUpdated, pStDeleted);
-    if (!allEqual) {
-      uint64_t uid = 0;
-      appendOneRowToStreamSpecialBlock(pAggSup->pScanBlock, &curWin.winInfo.sessionWin.win.skey,
-                                       &curWin.winInfo.sessionWin.win.ekey, &uid, &groupId, NULL);
-      tSimpleHashRemove(pSeUpdated, &curWin.winInfo.sessionWin, sizeof(SSessionKey));
-      doDeleteSessionWindow(pAggSup, &curWin.winInfo.sessionWin);
-      releaseOutputBuf(pAggSup->pState, NULL, (SResultRow*)curWin.winInfo.pOutputBuf, &pAPI->stateStore);
-      continue;
-    }
-    code = doOneWindowAggImpl(&pInfo->twAggSup.timeWindowData, &curWin.winInfo, &pResult, i, winRows, rows, numOfOutput,
-                              pOperator, 0);
-    if (code != TSDB_CODE_SUCCESS || pResult == NULL) {
-      T_LONG_JMP(pTaskInfo->env, TSDB_CODE_OUT_OF_MEMORY);
-    }
-    saveSessionOutputBuf(pAggSup, &curWin.winInfo);
-
-    if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE) {
-      code = saveResult(curWin.winInfo, pSeUpdated);
-      if (code != TSDB_CODE_SUCCESS) {
-        T_LONG_JMP(pTaskInfo->env, TSDB_CODE_OUT_OF_MEMORY);
-      }
-    }
-
-    if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) {
-      SSessionKey key = {0};
-      getSessionHashKey(&curWin.winInfo.sessionWin, &key);
-      tSimpleHashPut(pAggSup->pResultRows, &key, sizeof(SSessionKey), &curWin.winInfo, sizeof(SResultWindowInfo));
-    }
-  }
-}
-
-static SSDataBlock* doStreamStateAgg(SOperatorInfo* pOperator) {
-  if (pOperator->status == OP_EXEC_DONE) {
-    return NULL;
-  }
-
-  SExprSupp*                   pSup = &pOperator->exprSupp;
-  SStreamStateAggOperatorInfo* pInfo = pOperator->info;
-  SOptrBasicInfo*              pBInfo = &pInfo->binfo;
-  qDebug("===stream=== stream state agg");
-  if (pOperator->status == OP_RES_TO_RETURN) {
-    doBuildDeleteDataBlock(pOperator, pInfo->pSeDeleted, pInfo->pDelRes, &pInfo->pDelIterator);
-    if (pInfo->pDelRes->info.rows > 0) {
-      printDataBlock(pInfo->pDelRes, "single state delete");
-      return pInfo->pDelRes;
-    }
-
-    doBuildSessionResult(pOperator, pInfo->streamAggSup.pState, &pInfo->groupResInfo, pBInfo->pRes);
-    if (pBInfo->pRes->info.rows > 0) {
-      printDataBlock(pBInfo->pRes, "single state");
-      return pBInfo->pRes;
-    }
-
-    setOperatorCompleted(pOperator);
-    return NULL;
-  }
-
-  SOperatorInfo* downstream = pOperator->pDownstream[0];
-  if (!pInfo->pUpdated) {
-    pInfo->pUpdated = taosArrayInit(16, sizeof(SSessionKey));
-  }
-  if (!pInfo->pSeUpdated) {
-    _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
-    pInfo->pSeUpdated = tSimpleHashInit(64, hashFn);
-  }
-  while (1) {
-    SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
-    if (pBlock == NULL) {
-      break;
-    }
-    printDataBlock(pBlock, "single state recv");
-
-    if (pBlock->info.type == STREAM_DELETE_DATA || pBlock->info.type == STREAM_DELETE_RESULT ||
-        pBlock->info.type == STREAM_CLEAR) {
-      SArray* pWins = taosArrayInit(16, sizeof(SSessionKey));
-      doDeleteTimeWindows(&pInfo->streamAggSup, pBlock, pWins);
-      removeSessionResults(pInfo->pSeUpdated, pWins);
-      copyDeleteWindowInfo(pWins, pInfo->pSeDeleted);
-      taosArrayDestroy(pWins);
-      continue;
-    } else if (pBlock->info.type == STREAM_GET_ALL) {
-      getAllSessionWindow(pInfo->streamAggSup.pResultRows, pInfo->pSeUpdated);
-      continue;
-    } else if (pBlock->info.type == STREAM_CREATE_CHILD_TABLE) {
-      return pBlock;
-    } else {
-      ASSERTS(pBlock->info.type == STREAM_NORMAL || 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);
-    }
-    // the pDataBlock are always the same one, no need to call this again
-    setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true);
-    doStreamStateAggImpl(pOperator, pBlock, pInfo->pSeUpdated, pInfo->pSeDeleted);
-    pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey);
-  }
-  // restore the value
-  pOperator->status = OP_RES_TO_RETURN;
-
-  closeSessionWindow(pInfo->streamAggSup.pResultRows, &pInfo->twAggSup, pInfo->pSeUpdated);
-  copyUpdateResult(pInfo->pSeUpdated, pInfo->pUpdated);
-  removeSessionResults(pInfo->pSeDeleted, pInfo->pUpdated);
-  tSimpleHashCleanup(pInfo->pSeUpdated);
-  pInfo->pSeUpdated = NULL;
-
-  if(pInfo->isHistoryOp) {
-    getMaxTsWins(pInfo->pUpdated, pInfo->historyWins);
-  }
-
-  initGroupResInfoFromArrayList(&pInfo->groupResInfo, pInfo->pUpdated);
-  pInfo->pUpdated = NULL;
-  blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity);
-
-#if 0
-  char* pBuf = streamStateSessionDump(pInfo->streamAggSup.pState);
-  qDebug("===stream===final session%s", pBuf);
-  taosMemoryFree(pBuf);
-#endif
-
-  doBuildDeleteDataBlock(pOperator, pInfo->pSeDeleted, pInfo->pDelRes, &pInfo->pDelIterator);
-  if (pInfo->pDelRes->info.rows > 0) {
-    printDataBlock(pInfo->pDelRes, "single state delete");
-    return pInfo->pDelRes;
-  }
-
-  doBuildSessionResult(pOperator, pInfo->streamAggSup.pState, &pInfo->groupResInfo, pBInfo->pRes);
-  if (pBInfo->pRes->info.rows > 0) {
-    printDataBlock(pBInfo->pRes, "single state");
-    return pBInfo->pRes;
-  }
-  setOperatorCompleted(pOperator);
-  return NULL;
-}
-
-void streamStateReleaseState(SOperatorInfo* pOperator) {
-  SStreamStateAggOperatorInfo* pInfo = pOperator->info;
-  int32_t resSize = taosArrayGetSize(pInfo->historyWins) * sizeof(SSessionKey);
-  qDebug("===stream=== relase state. save result count:%d", (int32_t)taosArrayGetSize(pInfo->historyWins));
-  pInfo->streamAggSup.stateStore.streamStateSaveInfo(pInfo->streamAggSup.pState, STREAM_STATE_OP_STATE_NAME, strlen(STREAM_STATE_OP_STATE_NAME), pInfo->historyWins->pData, resSize);
-  SOperatorInfo* downstream = pOperator->pDownstream[0];
-  if (downstream->fpSet.releaseStreamStateFn) {
-    downstream->fpSet.releaseStreamStateFn(downstream);
-  }
-}
-
-static void compactStateWindow(SOperatorInfo* pOperator, SResultWindowInfo* pCurWin, SResultWindowInfo* pNextWin,
-                               SSHashObj* pStUpdated, SSHashObj* pStDeleted) {
-  SExprSupp*                     pSup = &pOperator->exprSupp;
-  SExecTaskInfo*                 pTaskInfo = pOperator->pTaskInfo;
-  SStorageAPI* pAPI = &pOperator->pTaskInfo->storageAPI;
-
-  SStreamStateAggOperatorInfo*   pInfo = pOperator->info;
-  SResultRow*                    pCurResult = NULL;
-  int32_t                        numOfOutput = pOperator->exprSupp.numOfExprs;
-  SStreamAggSupporter*           pAggSup = &pInfo->streamAggSup;
-  initSessionOutputBuf(pCurWin, &pCurResult, pSup->pCtx, numOfOutput, pSup->rowEntryInfoOffset);
-  SResultRow* pWinResult = NULL;
-  initSessionOutputBuf(pNextWin, &pWinResult, pAggSup->pDummyCtx, numOfOutput, pSup->rowEntryInfoOffset);
-  pCurWin->sessionWin.win.ekey = TMAX(pCurWin->sessionWin.win.ekey, pNextWin->sessionWin.win.ekey);
-
-  updateTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pCurWin->sessionWin.win, 1);
-  compactFunctions(pSup->pCtx, pAggSup->pDummyCtx, numOfOutput, pTaskInfo, &pInfo->twAggSup.timeWindowData);
-  tSimpleHashRemove(pStUpdated, &pNextWin->sessionWin, sizeof(SSessionKey));
-  if (pNextWin->isOutput && pStDeleted) {
-    qDebug("===stream=== save delete window info %" PRId64 ", %" PRIu64, pNextWin->sessionWin.win.skey, pNextWin->sessionWin.groupId);
-    saveDeleteRes(pStDeleted, pNextWin->sessionWin);
-  }
-  removeSessionResult(pStUpdated, pAggSup->pResultRows, pNextWin->sessionWin);
-  doDeleteSessionWindow(pAggSup, &pNextWin->sessionWin);
-  taosMemoryFree(pNextWin->pOutputBuf);
-}
-
-void streamStateReloadState(SOperatorInfo* pOperator) {
-  SStreamStateAggOperatorInfo* pInfo = pOperator->info;
-  SStreamAggSupporter* pAggSup = &pInfo->streamAggSup;
-  resetWinRange(&pAggSup->winRange);
-
-  SSessionKey seKey = {.win.skey = INT64_MIN, .win.ekey = INT64_MIN, .groupId = 0};
-  int32_t size = 0;
-  void* pBuf = NULL;
-  int32_t code = pAggSup->stateStore.streamStateGetInfo(pAggSup->pState, STREAM_STATE_OP_STATE_NAME,
-                                                        strlen(STREAM_STATE_OP_STATE_NAME), &pBuf, &size);
-  int32_t num = size / sizeof(SSessionKey);
-  qDebug("===stream=== reload state. get result count:%d", num);
-  SSessionKey* pSeKeyBuf = (SSessionKey*) pBuf;
-  ASSERT(size == num * sizeof(SSessionKey));
-  if (!pInfo->pSeUpdated && num > 0) {
-    _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
-    pInfo->pSeUpdated = tSimpleHashInit(64, hashFn);
-  }
-  if (!pInfo->pSeDeleted && num > 0) {
-    _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
-    pInfo->pSeDeleted = tSimpleHashInit(64, hashFn);
-  }
-  for (int32_t i = 0; i < num; i++) {
-    SStateWindowInfo curInfo = {0};
-    SStateWindowInfo nextInfo = {0};
-    SStateWindowInfo dummy = {0};
-    qDebug("===stream=== reload state. try process result %" PRId64 ", %" PRIu64 ", index:%d", pSeKeyBuf[i].win.skey, pSeKeyBuf[i].groupId, i);
-    setStateOutputBuf(pAggSup, pSeKeyBuf[i].win.skey, pSeKeyBuf[i].groupId, NULL, &curInfo, &nextInfo);
-    bool cpRes = compareWinStateKey(curInfo.pStateKey,nextInfo.pStateKey);
-    qDebug("===stream=== reload state. next window info %" PRId64 ", %" PRIu64 ", compare:%d", nextInfo.winInfo.sessionWin.win.skey, nextInfo.winInfo.sessionWin.groupId, cpRes);
-    if (cpRes) {
-      compactStateWindow(pOperator, &curInfo.winInfo, &nextInfo.winInfo, pInfo->pSeUpdated, pInfo->pSeDeleted);
-      qDebug("===stream=== reload state. save result %" PRId64 ", %" PRIu64, curInfo.winInfo.sessionWin.win.skey, curInfo.winInfo.sessionWin.groupId);
-      if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE) {
-        saveResult(curInfo.winInfo, pInfo->pSeUpdated);
-      } else if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) {
-        if (!isCloseWindow(&curInfo.winInfo.sessionWin.win, &pInfo->twAggSup)) {
-          saveDeleteRes(pInfo->pSeDeleted, curInfo.winInfo.sessionWin);
-        }
-        SSessionKey key = {0};
-        getSessionHashKey(&curInfo.winInfo.sessionWin, &key);
-        tSimpleHashPut(pAggSup->pResultRows, &key, sizeof(SSessionKey), &curInfo.winInfo, sizeof(SResultWindowInfo));
-      }
-    } else if (IS_VALID_SESSION_WIN(nextInfo.winInfo)) {
-      releaseOutputBuf(pAggSup->pState, NULL, (SResultRow*)nextInfo.winInfo.pOutputBuf, &pAggSup->pSessionAPI->stateStore);
-    }
-
-    if (IS_VALID_SESSION_WIN(curInfo.winInfo)) {
-      saveSessionOutputBuf(pAggSup, &curInfo.winInfo);
-    }
-  }
-  taosMemoryFree(pBuf);
-
-  SOperatorInfo* downstream = pOperator->pDownstream[0];
-  if (downstream->fpSet.reloadStreamStateFn) {
-    downstream->fpSet.reloadStreamStateFn(downstream);
-  } 
-}
-
-SOperatorInfo* createStreamStateAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode,
-                                                SExecTaskInfo* pTaskInfo, SReadHandle* pHandle) {
-  SStreamStateWinodwPhysiNode* pStateNode = (SStreamStateWinodwPhysiNode*)pPhyNode;
-  int32_t                      tsSlotId = ((SColumnNode*)pStateNode->window.pTspk)->slotId;
-  SColumnNode*                 pColNode = (SColumnNode*)(pStateNode->pStateKey);
-  int32_t                      code = TSDB_CODE_SUCCESS;
-
-  SStreamStateAggOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamStateAggOperatorInfo));
-  SOperatorInfo*               pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
-  if (pInfo == NULL || pOperator == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
-    goto _error;
-  }
-
-  pInfo->stateCol = extractColumnFromColumnNode(pColNode);
-  initResultSizeInfo(&pOperator->resultInfo, 4096);
-  if (pStateNode->window.pExprs != NULL) {
-    int32_t    numOfScalar = 0;
-    SExprInfo* pScalarExprInfo = createExprInfo(pStateNode->window.pExprs, NULL, &numOfScalar);
-    code = initExprSupp(&pInfo->scalarSupp, pScalarExprInfo, numOfScalar, &pTaskInfo->storageAPI.functionStore);
-    if (code != TSDB_CODE_SUCCESS) {
-      goto _error;
-    }
-  }
-
-  pInfo->twAggSup = (STimeWindowAggSupp){
-      .waterMark = pStateNode->window.watermark,
-      .calTrigger = pStateNode->window.triggerType,
-      .maxTs = INT64_MIN,
-      .minTs = INT64_MAX,
-  };
-
-  initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window);
-
-  SExprSupp*   pSup = &pOperator->exprSupp;
-  int32_t      numOfCols = 0;
-  SExprInfo*   pExprInfo = createExprInfo(pStateNode->window.pFuncs, NULL, &numOfCols);
-  SSDataBlock* pResBlock = createDataBlockFromDescNode(pPhyNode->pOutputDataBlockDesc);
-  code = initBasicInfoEx(&pInfo->binfo, pSup, pExprInfo, numOfCols, pResBlock, &pTaskInfo->storageAPI.functionStore);
-  if (code != TSDB_CODE_SUCCESS) {
-    goto _error;
-  }
-  int32_t keySize = sizeof(SStateKeys) + pColNode->node.resType.bytes;
-  int16_t type = pColNode->node.resType.type;
-  code = initStreamAggSupporter(&pInfo->streamAggSup, pSup->pCtx, numOfCols, 0, pTaskInfo->streamInfo.pState, keySize,
-                                type, &pTaskInfo->storageAPI.stateStore, pHandle, &pTaskInfo->storageAPI);
-  if (code != TSDB_CODE_SUCCESS) {
-    goto _error;
-  }
-
-  pInfo->primaryTsIndex = tsSlotId;
-  _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
-  pInfo->pSeDeleted = tSimpleHashInit(64, hashFn);
-  pInfo->pDelIterator = NULL;
-  pInfo->pDelRes = createSpecialDataBlock(STREAM_DELETE_RESULT);
-  pInfo->pChildren = NULL;
-  pInfo->ignoreExpiredData = pStateNode->window.igExpired;
-  pInfo->ignoreExpiredDataSaved = false;
-  pInfo->pUpdated = NULL;
-  pInfo->pSeUpdated = NULL;
-  pInfo->dataVersion = 0;
-  pInfo->historyWins = taosArrayInit(4, sizeof(SSessionKey));
-  if (!pInfo->historyWins) {
-    goto _error;
-  }
-  if (pHandle) {
-    pInfo->isHistoryOp = pHandle->fillHistory;
-  }
-
-  setOperatorInfo(pOperator, "StreamStateAggOperator", QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE, true, OP_NOT_OPENED,
-                  pInfo, pTaskInfo);
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamStateAgg, NULL, destroyStreamStateOperatorInfo,
-                                         optrDefaultBufFn, NULL);
-  setOperatorStreamStateFn(pOperator, streamStateReleaseState, streamStateReloadState);
-  initDownStream(downstream, &pInfo->streamAggSup, pOperator->operatorType, pInfo->primaryTsIndex, &pInfo->twAggSup);
-  code = appendDownstream(pOperator, &downstream, 1);
-  if (code != TSDB_CODE_SUCCESS) {
-    goto _error;
-  }
-  return pOperator;
-
-_error:
-  destroyStreamStateOperatorInfo(pInfo);
-  taosMemoryFreeClear(pOperator);
-  pTaskInfo->code = code;
-  return NULL;
-}
 
 void destroyMAIOperatorInfo(void* param) {
   SMergeAlignedIntervalAggOperatorInfo* miaInfo = (SMergeAlignedIntervalAggOperatorInfo*)param;
@@ -5196,263 +2189,3 @@ _error:
   pTaskInfo->code = code;
   return NULL;
 }
-
-static SSDataBlock* doStreamIntervalAgg(SOperatorInfo* pOperator) {
-  SStreamIntervalOperatorInfo* pInfo = pOperator->info;
-  SExecTaskInfo*               pTaskInfo = pOperator->pTaskInfo;
-  SStorageAPI* pAPI = &pOperator->pTaskInfo->storageAPI;
-
-  SExprSupp* pSup = &pOperator->exprSupp;
-
-  if (pOperator->status == OP_EXEC_DONE) {
-    return NULL;
-  }
-
-  if (pOperator->status == OP_RES_TO_RETURN) {
-    doBuildDeleteResult(pInfo, pInfo->pDelWins, &pInfo->delIndex, pInfo->pDelRes);
-    if (pInfo->pDelRes->info.rows > 0) {
-      printDataBlock(pInfo->pDelRes, "single interval delete");
-      return pInfo->pDelRes;
-    }
-
-    doBuildStreamIntervalResult(pOperator, pInfo->pState, pInfo->binfo.pRes, &pInfo->groupResInfo);
-    if (pInfo->binfo.pRes->info.rows > 0) {
-      printDataBlock(pInfo->binfo.pRes, "single interval");
-      return pInfo->binfo.pRes;
-    }
-
-    if (pInfo->recvGetAll) {
-      pInfo->recvGetAll = false;
-      resetUnCloseWinInfo(pInfo->aggSup.pResultRowHashTable);
-    }
-
-    setOperatorCompleted(pOperator);
-    if (pInfo->twAggSup.maxTs > 0 &&
-        pInfo->twAggSup.maxTs - pInfo->twAggSup.checkPointInterval > pInfo->twAggSup.checkPointTs) {
-      pAPI->stateStore.streamStateCommit(pInfo->pState);
-      pAPI->stateStore.streamStateDeleteCheckPoint(pInfo->pState, pInfo->twAggSup.maxTs - pInfo->twAggSup.deleteMark);
-      setStreamDataVersion(pTaskInfo, pInfo->dataVersion, pInfo->pState->checkPointId);
-      pInfo->twAggSup.checkPointTs = pInfo->twAggSup.maxTs;
-    }
-    return NULL;
-  }
-
-  SOperatorInfo* downstream = pOperator->pDownstream[0];
-
-  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) {
-    SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
-    if (pBlock == NULL) {
-      qDebug("===stream===return data:single interval. recv datablock num:%" PRIu64, pInfo->numOfDatapack);
-      pInfo->numOfDatapack = 0;
-      break;
-    }
-
-    pInfo->numOfDatapack++;
-    printDataBlock(pBlock, "single interval recv");
-
-    if (pBlock->info.type == STREAM_DELETE_DATA || pBlock->info.type == STREAM_DELETE_RESULT ||
-        pBlock->info.type == STREAM_CLEAR) {
-      doDeleteWindows(pOperator, &pInfo->interval, pBlock, pInfo->pDelWins, pInfo->pUpdatedMap);
-      continue;
-    } else if (pBlock->info.type == STREAM_GET_ALL) {
-      qDebug("===stream===single interval recv|block type STREAM_GET_ALL");
-      pInfo->recvGetAll = true;
-      getAllIntervalWindow(pInfo->aggSup.pResultRowHashTable, pInfo->pUpdatedMap);
-      continue;
-    } else if (pBlock->info.type == STREAM_CREATE_CHILD_TABLE) {
-      printDataBlock(pBlock, "single interval");
-      return pBlock;
-    } else {
-      ASSERTS(pBlock->info.type == STREAM_NORMAL || pBlock->info.type == STREAM_INVALID, "invalid SSDataBlock type");
-    }
-
-    if (pBlock->info.type == STREAM_NORMAL && pBlock->info.version != 0) {
-      // set input version
-      pTaskInfo->version = pBlock->info.version;
-    }
-
-    if (pInfo->scalarSupp.pExprInfo != NULL) {
-      SExprSupp* pExprSup = &pInfo->scalarSupp;
-      projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL);
-    }
-
-    // The timewindow that overlaps the timestamps of the input pBlock need to be recalculated and return to the
-    // caller. Note that all the time window are not close till now.
-    // the pDataBlock are always the same one, no need to call this again
-    setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true);
-    if (pInfo->invertible) {
-      setInverFunction(pSup->pCtx, pOperator->exprSupp.numOfExprs, pBlock->info.type);
-    }
-
-    doStreamIntervalAggImpl(pOperator, pBlock, pBlock->info.id.groupId, pInfo->pUpdatedMap);
-    pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey);
-    pInfo->twAggSup.minTs = TMIN(pInfo->twAggSup.minTs, pBlock->info.window.skey);
-  }
-  pOperator->status = OP_RES_TO_RETURN;
-  removeDeleteResults(pInfo->pUpdatedMap, pInfo->pDelWins);
-  closeStreamIntervalWindow(pInfo->aggSup.pResultRowHashTable, &pInfo->twAggSup, &pInfo->interval, NULL,
-                            pInfo->pUpdatedMap, pInfo->pDelWins, pOperator);
-
-  void*   pIte = NULL;
-  int32_t iter = 0;
-  while ((pIte = tSimpleHashIterate(pInfo->pUpdatedMap, pIte, &iter)) != NULL) {
-    taosArrayPush(pInfo->pUpdated, pIte);
-  }
-  taosArraySort(pInfo->pUpdated, winPosCmprImpl);
-
-  initMultiResInfoFromArrayList(&pInfo->groupResInfo, pInfo->pUpdated);
-  pInfo->pUpdated = NULL;
-  blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity);
-  tSimpleHashCleanup(pInfo->pUpdatedMap);
-  pInfo->pUpdatedMap = NULL;
-
-#if 0
-  char* pBuf = streamStateIntervalDump(pInfo->pState);
-  qDebug("===stream===interval state%s", pBuf);
-  taosMemoryFree(pBuf);
-#endif
-
-  doBuildDeleteResult(pInfo, pInfo->pDelWins, &pInfo->delIndex, pInfo->pDelRes);
-  if (pInfo->pDelRes->info.rows > 0) {
-    printDataBlock(pInfo->pDelRes, "single interval delete");
-    return pInfo->pDelRes;
-  }
-
-  doBuildStreamIntervalResult(pOperator, pInfo->pState, pInfo->binfo.pRes, &pInfo->groupResInfo);
-  if (pInfo->binfo.pRes->info.rows > 0) {
-    printDataBlock(pInfo->binfo.pRes, "single interval");
-    return pInfo->binfo.pRes;
-  }
-
-  return NULL;
-}
-
-SOperatorInfo* createStreamIntervalOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode,
-                                                SExecTaskInfo* pTaskInfo) {
-  SStreamIntervalOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamIntervalOperatorInfo));
-  SOperatorInfo*               pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
-  if (pInfo == NULL || pOperator == NULL) {
-    goto _error;
-  }
-  SStreamIntervalPhysiNode* pIntervalPhyNode = (SStreamIntervalPhysiNode*)pPhyNode;
-
-  int32_t    code = TSDB_CODE_SUCCESS;
-  int32_t    numOfCols = 0;
-  SExprInfo* pExprInfo = createExprInfo(pIntervalPhyNode->window.pFuncs, NULL, &numOfCols);
-
-  SSDataBlock* pResBlock = createDataBlockFromDescNode(pPhyNode->pOutputDataBlockDesc);
-  pInfo->interval = (SInterval){
-      .interval = pIntervalPhyNode->interval,
-      .sliding = pIntervalPhyNode->sliding,
-      .intervalUnit = pIntervalPhyNode->intervalUnit,
-      .slidingUnit = pIntervalPhyNode->slidingUnit,
-      .offset = pIntervalPhyNode->offset,
-      .precision = ((SColumnNode*)pIntervalPhyNode->window.pTspk)->node.resType.precision,
-  };
-
-  pInfo->twAggSup = (STimeWindowAggSupp){
-      .waterMark = pIntervalPhyNode->window.watermark,
-      .calTrigger = pIntervalPhyNode->window.triggerType,
-      .maxTs = INT64_MIN,
-      .minTs = INT64_MAX,
-      .deleteMark = getDeleteMark(pIntervalPhyNode),
-      .checkPointTs = 0,
-      .checkPointInterval =
-          convertTimePrecision(tsCheckpointInterval, TSDB_TIME_PRECISION_MILLI, pInfo->interval.precision),
-  };
-
-  ASSERTS(pInfo->twAggSup.calTrigger != STREAM_TRIGGER_MAX_DELAY, "trigger type should not be max delay");
-
-  pOperator->pTaskInfo = pTaskInfo;
-  SStorageAPI* pAPI = &pOperator->pTaskInfo->storageAPI;
-
-  pInfo->ignoreExpiredData = pIntervalPhyNode->window.igExpired;
-  pInfo->ignoreExpiredDataSaved = false;
-  pInfo->isFinal = false;
-
-  SExprSupp* pSup = &pOperator->exprSupp;
-  initBasicInfo(&pInfo->binfo, pResBlock);
-  initStreamFunciton(pSup->pCtx, pSup->numOfExprs);
-  initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window);
-
-  pInfo->primaryTsIndex = ((SColumnNode*)pIntervalPhyNode->window.pTspk)->slotId;
-  initResultSizeInfo(&pOperator->resultInfo, 4096);
-
-  pInfo->pState = taosMemoryCalloc(1, sizeof(SStreamState));
-  *(pInfo->pState) = *(pTaskInfo->streamInfo.pState);
-  pAPI->stateStore.streamStateSetNumber(pInfo->pState, -1);
-
-  size_t keyBufSize = sizeof(int64_t) + sizeof(int64_t) + POINTER_BYTES;
-  code = initAggSup(pSup, &pInfo->aggSup, pExprInfo, numOfCols, keyBufSize, pTaskInfo->id.str,
-                    pInfo->pState, &pTaskInfo->storageAPI.functionStore);
-  if (code != TSDB_CODE_SUCCESS) {
-    goto _error;
-  }
-
-  if (pIntervalPhyNode->window.pExprs != NULL) {
-    int32_t    numOfScalar = 0;
-    SExprInfo* pScalarExprInfo = createExprInfo(pIntervalPhyNode->window.pExprs, NULL, &numOfScalar);
-    code = initExprSupp(&pInfo->scalarSupp, pScalarExprInfo, numOfScalar, &pTaskInfo->storageAPI.functionStore);
-    if (code != TSDB_CODE_SUCCESS) {
-      goto _error;
-    }
-  }
-
-  pInfo->invertible = allInvertible(pSup->pCtx, numOfCols);
-  pInfo->invertible = false;
-  pInfo->pDelWins = taosArrayInit(4, sizeof(SWinKey));
-  pInfo->delIndex = 0;
-  pInfo->pDelRes = createSpecialDataBlock(STREAM_DELETE_RESULT);
-  initResultRowInfo(&pInfo->binfo.resultRowInfo);
-
-  pInfo->pPhyNode = NULL;  // create new child
-  pInfo->pPullDataMap = NULL;
-  pInfo->pFinalPullDataMap = NULL;
-  pInfo->pPullWins = NULL;  // SPullWindowInfo
-  pInfo->pullIndex = 0;
-  pInfo->pPullDataRes = NULL;
-  pInfo->isFinal = false;
-  pInfo->numOfChild = 0;
-  pInfo->delKey.ts = INT64_MAX;
-  pInfo->delKey.groupId = 0;
-  pInfo->numOfDatapack = 0;
-  pInfo->pUpdated = NULL;
-  pInfo->pUpdatedMap = NULL;
-  int32_t funResSize= getMaxFunResSize(pSup, numOfCols);
-
-  pInfo->pState->pFileState = pTaskInfo->storageAPI.stateStore.streamFileStateInit(
-      tsStreamBufferSize, sizeof(SWinKey), pInfo->aggSup.resultRowSize, funResSize, compareTs, pInfo->pState,
-      pInfo->twAggSup.deleteMark, GET_TASKID(pTaskInfo));
-
-  setOperatorInfo(pOperator, "StreamIntervalOperator", QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL, true, OP_NOT_OPENED,
-                  pInfo, pTaskInfo);
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamIntervalAgg, NULL,
-                                         destroyStreamFinalIntervalOperatorInfo, optrDefaultBufFn, NULL);
-  setOperatorStreamStateFn(pOperator, streamIntervalReleaseState, streamIntervalReloadState);
-
-  pInfo->statestore = pTaskInfo->storageAPI.stateStore;
-  pInfo->recvGetAll = false;
-
-  initIntervalDownStream(downstream, pPhyNode->type, pInfo);
-  code = appendDownstream(pOperator, &downstream, 1);
-  if (code != TSDB_CODE_SUCCESS) {
-    goto _error;
-  }
-
-  return pOperator;
-
-_error:
-  destroyStreamFinalIntervalOperatorInfo(pInfo);
-  taosMemoryFreeClear(pOperator);
-  pTaskInfo->code = code;
-  return NULL;
-}
diff --git a/source/libs/function/inc/builtinsimpl.h b/source/libs/function/inc/builtinsimpl.h
index c3afc30a7b..d2f19ed2eb 100644
--- a/source/libs/function/inc/builtinsimpl.h
+++ b/source/libs/function/inc/builtinsimpl.h
@@ -127,7 +127,10 @@ int32_t derivativeFunction(SqlFunctionCtx* pCtx);
 bool    getIrateFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
 bool    irateFuncSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo);
 int32_t irateFunction(SqlFunctionCtx* pCtx);
+int32_t irateFunctionMerge(SqlFunctionCtx* pCtx);
 int32_t irateFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
+int32_t iratePartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
+int32_t getIrateInfoSize();
 
 int32_t cachedLastRowFunction(SqlFunctionCtx* pCtx);
 
diff --git a/source/libs/function/src/builtins.c b/source/libs/function/src/builtins.c
index cee4000155..9a301b7f1c 100644
--- a/source/libs/function/src/builtins.c
+++ b/source/libs/function/src/builtins.c
@@ -1567,6 +1567,45 @@ static int32_t translateIrate(SFunctionNode* pFunc, char* pErrBuf, int32_t len)
   return TSDB_CODE_SUCCESS;
 }
 
+static int32_t translateIrateImpl(SFunctionNode* pFunc, char* pErrBuf, int32_t len, bool isPartial) {
+  uint8_t colType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  if (isPartial) {
+    if (3 != LIST_LENGTH(pFunc->pParameterList)) {
+      return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
+    }
+    if (!IS_NUMERIC_TYPE(colType)) {
+      return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
+    }
+    pFunc->node.resType = (SDataType){.bytes = getIrateInfoSize() + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY};
+  } else {
+    if (1 != LIST_LENGTH(pFunc->pParameterList)) {
+      return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
+    }
+    if (TSDB_DATA_TYPE_BINARY != colType) {
+      return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
+    }
+    pFunc->node.resType = (SDataType){.bytes = tDataTypes[TSDB_DATA_TYPE_DOUBLE].bytes, .type = TSDB_DATA_TYPE_DOUBLE};
+
+    // add database precision as param
+    uint8_t dbPrec = pFunc->node.resType.precision;
+    int32_t code = addDbPrecisonParam(&pFunc->pParameterList, dbPrec);
+    if (code != TSDB_CODE_SUCCESS) {
+      return code;
+    }
+  }
+
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t translateIratePartial(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
+  return translateIrateImpl(pFunc, pErrBuf, len, true);
+}
+
+static int32_t translateIrateMerge(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
+  return translateIrateImpl(pFunc, pErrBuf, len, false);
+}
+
 static int32_t translateInterp(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
   int32_t numOfParams = LIST_LENGTH(pFunc->pParameterList);
   uint8_t dbPrec = pFunc->node.resType.precision;
@@ -2604,6 +2643,31 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .initFunc     = irateFuncSetup,
     .processFunc  = irateFunction,
     .sprocessFunc = irateScalarFunction,
+    .finalizeFunc = irateFinalize,
+    .pPartialFunc = "_irate_partial",
+    .pMergeFunc   = "_irate_merge"
+  },
+  {
+    .name = "_irate_partial",
+    .type = FUNCTION_TYPE_IRATE_PARTIAL,
+    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_TIMELINE_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC | FUNC_MGT_FORBID_STREAM_FUNC |
+                      FUNC_MGT_FORBID_SYSTABLE_FUNC,
+    .translateFunc = translateIratePartial,
+    .getEnvFunc   = getIrateFuncEnv,
+    .initFunc     = irateFuncSetup,
+    .processFunc  = irateFunction,
+    .sprocessFunc = irateScalarFunction,
+    .finalizeFunc = iratePartialFinalize
+  },
+  {
+    .name = "_irate_merge",
+    .type = FUNCTION_TYPE_IRATE_MERGE,
+    .classification = FUNC_MGT_AGG_FUNC,
+    .translateFunc = translateIrateMerge,
+    .getEnvFunc   = getIrateFuncEnv,
+    .initFunc     = irateFuncSetup,
+    .processFunc  = irateFunctionMerge,
+    .sprocessFunc = irateScalarFunction,
     .finalizeFunc = irateFinalize
   },
   {
diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c
index fad8c9ca5b..bcbb3af950 100644
--- a/source/libs/function/src/builtinsimpl.c
+++ b/source/libs/function/src/builtinsimpl.c
@@ -5768,6 +5768,8 @@ int32_t derivativeFunction(SqlFunctionCtx* pCtx) {
   return TSDB_CODE_SUCCESS;
 }
 
+int32_t getIrateInfoSize() { return (int32_t)sizeof(SRateInfo); }
+
 bool getIrateFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
   pEnv->calcMemSize = sizeof(SRateInfo);
   return true;
@@ -5817,6 +5819,7 @@ int32_t irateFunction(SqlFunctionCtx* pCtx) {
     if (INT64_MIN == pRateInfo->lastKey) {
       pRateInfo->lastValue = v;
       pRateInfo->lastKey = tsList[i];
+      pRateInfo->hasResult = 1;
       continue;
     }
 
@@ -5868,6 +5871,99 @@ static double doCalcRate(const SRateInfo* pRateInfo, double tickPerSec) {
   return (duration > 0) ? ((double)diff) / (duration / tickPerSec) : 0.0;
 }
 
+static void irateTransferInfoImpl(TSKEY inputKey, SRateInfo* pInput, SRateInfo* pOutput, bool isFirstKey) {
+  if (inputKey > pOutput->lastKey) {
+    pOutput->firstKey   = pOutput->lastKey;
+    pOutput->firstValue = pOutput->lastValue;
+
+    pOutput->lastKey    = isFirstKey ? pInput->firstKey : pInput->lastKey;
+    pOutput->lastValue  = isFirstKey ? pInput->firstValue : pInput->lastValue;
+  } else if ((inputKey < pOutput->lastKey) && (inputKey > pOutput->firstKey)) {
+    pOutput->firstKey   = isFirstKey ? pInput->firstKey : pInput->lastKey;
+    pOutput->firstValue = isFirstKey ? pInput->firstValue : pInput->lastValue;
+  } else {
+    // inputKey < pOutput->firstKey
+  }
+}
+
+static void irateCopyInfo(SRateInfo* pInput, SRateInfo* pOutput) {
+  pOutput->firstKey = pInput->firstKey;
+  pOutput->lastKey  = pInput->lastKey;
+
+  pOutput->firstValue = pInput->firstValue;
+  pOutput->lastValue  = pInput->lastValue;
+}
+
+static int32_t irateTransferInfo(SRateInfo* pInput, SRateInfo* pOutput) {
+  if ((pInput->firstKey != INT64_MIN && (pInput->firstKey == pOutput->firstKey || pInput->firstKey == pOutput->lastKey)) ||
+      (pInput->lastKey != INT64_MIN && (pInput->lastKey  == pOutput->firstKey || pInput->lastKey  == pOutput->lastKey))) {
+    return TSDB_CODE_FUNC_DUP_TIMESTAMP;
+  }
+
+  if (pOutput->hasResult == 0) {
+    irateCopyInfo(pInput, pOutput);
+    pOutput->hasResult = pInput->hasResult;
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if (pInput->firstKey != INT64_MIN) {
+    irateTransferInfoImpl(pInput->firstKey, pInput, pOutput, true);
+  }
+
+  if (pInput->lastKey != INT64_MIN) {
+    irateTransferInfoImpl(pInput->lastKey, pInput, pOutput, false);
+  }
+
+  pOutput->hasResult = pInput->hasResult;
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t irateFunctionMerge(SqlFunctionCtx* pCtx) {
+  SInputColumnInfoData* pInput = &pCtx->input;
+  SColumnInfoData*      pCol = pInput->pData[0];
+  if (pCol->info.type != TSDB_DATA_TYPE_BINARY) {
+    return TSDB_CODE_FUNC_FUNTION_PARA_TYPE;
+  }
+
+  SRateInfo* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
+
+  int32_t start = pInput->startRowIndex;
+  for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
+    char*        data = colDataGetData(pCol, i);
+    SRateInfo*   pInputInfo = (SRateInfo*)varDataVal(data);
+    if (pInputInfo->hasResult) {
+      int32_t code = irateTransferInfo(pInputInfo, pInfo);
+      if (code != TSDB_CODE_SUCCESS) {
+        return code;
+      }
+    }
+  }
+
+  if (pInfo->hasResult) {
+    GET_RES_INFO(pCtx)->numOfRes = 1;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t iratePartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
+  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
+  SRateInfo*           pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
+  int32_t              resultBytes = getIrateInfoSize();
+  char*                res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
+
+  memcpy(varDataVal(res), pInfo, resultBytes);
+  varDataSetLen(res, resultBytes);
+
+  int32_t          slotId = pCtx->pExpr->base.resSchema.slotId;
+  SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
+
+  colDataSetVal(pCol, pBlock->info.rows, res, false);
+
+  taosMemoryFree(res);
+  return pResInfo->numOfRes;
+}
+
 int32_t irateFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
   int32_t          slotId = pCtx->pExpr->base.resSchema.slotId;
   SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
diff --git a/source/libs/nodes/src/nodesCodeFuncs.c b/source/libs/nodes/src/nodesCodeFuncs.c
index a4579f54f0..1e4eb510d9 100644
--- a/source/libs/nodes/src/nodesCodeFuncs.c
+++ b/source/libs/nodes/src/nodesCodeFuncs.c
@@ -2846,6 +2846,8 @@ static const char* jkSubplanDataSink = "DataSink";
 static const char* jkSubplanTagCond = "TagCond";
 static const char* jkSubplanTagIndexCond = "TagIndexCond";
 static const char* jkSubplanShowRewrite = "ShowRewrite";
+static const char* jkSubplanRowsThreshold = "RowThreshold";
+static const char* jkSubplanDynamicRowsThreshold = "DyRowThreshold";
 
 static int32_t subplanToJson(const void* pObj, SJson* pJson) {
   const SSubplan* pNode = (const SSubplan*)pObj;
@@ -2884,6 +2886,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 = tjsonAddIntegerToObject(pJson, jkSubplanRowsThreshold, pNode->rowsThreshold);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonAddBoolToObject(pJson, jkSubplanDynamicRowsThreshold, pNode->dynamicRowThreshold);
+  }
 
   return code;
 }
@@ -2925,6 +2933,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 = tjsonGetIntValue(pJson, jkSubplanRowsThreshold, &pNode->rowsThreshold);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonGetBoolValue(pJson, jkSubplanDynamicRowsThreshold, &pNode->dynamicRowThreshold);
+  }
 
   return code;
 }
diff --git a/source/libs/nodes/src/nodesMsgFuncs.c b/source/libs/nodes/src/nodesMsgFuncs.c
index cade77fc17..74d7aad6e8 100644
--- a/source/libs/nodes/src/nodesMsgFuncs.c
+++ b/source/libs/nodes/src/nodesMsgFuncs.c
@@ -3575,6 +3575,12 @@ static int32_t subplanInlineToMsg(const void* pObj, STlvEncoder* pEncoder) {
   if (TSDB_CODE_SUCCESS == code) {
     code = tlvEncodeValueBool(pEncoder, pNode->showRewrite);
   }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tlvEncodeValueI32(pEncoder, pNode->rowsThreshold);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tlvEncodeValueBool(pEncoder, pNode->dynamicRowThreshold);
+  }
 
   return code;
 }
@@ -3624,6 +3630,12 @@ static int32_t msgToSubplanInline(STlvDecoder* pDecoder, void* pObj) {
   if (TSDB_CODE_SUCCESS == code) {
     code = tlvDecodeValueBool(pDecoder, &pNode->showRewrite);
   }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tlvDecodeValueI32(pDecoder, &pNode->rowsThreshold);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tlvDecodeValueBool(pDecoder, &pNode->dynamicRowThreshold);
+  }
 
   return code;
 }
diff --git a/source/libs/parser/inc/parAst.h b/source/libs/parser/inc/parAst.h
index fec31b61e6..fd04b48086 100644
--- a/source/libs/parser/inc/parAst.h
+++ b/source/libs/parser/inc/parAst.h
@@ -172,8 +172,7 @@ SNode* createDropTableClause(SAstCreateContext* pCxt, bool ignoreNotExists, SNod
 SNode* createDropTableStmt(SAstCreateContext* pCxt, SNodeList* pTables);
 SNode* createDropSuperTableStmt(SAstCreateContext* pCxt, bool ignoreNotExists, SNode* pRealTable);
 SNode* createAlterTableModifyOptions(SAstCreateContext* pCxt, SNode* pRealTable, SNode* pOptions);
-SNode* createAlterTableAddModifyCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType, SToken* pColName,
-                                    SDataType dataType);
+SNode* createAlterTableAddModifyCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType, SNode* pColDefNode);
 SNode* createAlterTableDropCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType, SToken* pColName);
 SNode* createAlterTableRenameCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType, SToken* pOldColName,
                                  SToken* pNewColName);
diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y
index 2348b93bc7..5b84e8d267 100755
--- a/source/libs/parser/inc/sql.y
+++ b/source/libs/parser/inc/sql.y
@@ -312,17 +312,17 @@ cmd ::= ALTER STABLE alter_table_clause(A).
 
 alter_table_clause(A) ::= full_table_name(B) alter_table_options(C).              { A = createAlterTableModifyOptions(pCxt, B, C); }
 alter_table_clause(A) ::=
-  full_table_name(B) ADD COLUMN column_name(C) type_name(D).                      { A = createAlterTableAddModifyCol(pCxt, B, TSDB_ALTER_TABLE_ADD_COLUMN, &C, D); }
+  full_table_name(B) ADD COLUMN column_def(C).                                    { A = createAlterTableAddModifyCol(pCxt, B, TSDB_ALTER_TABLE_ADD_COLUMN, C); }
 alter_table_clause(A) ::= full_table_name(B) DROP COLUMN column_name(C).          { A = createAlterTableDropCol(pCxt, B, TSDB_ALTER_TABLE_DROP_COLUMN, &C); }
 alter_table_clause(A) ::=
-  full_table_name(B) MODIFY COLUMN column_name(C) type_name(D).                   { A = createAlterTableAddModifyCol(pCxt, B, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, &C, D); }
+  full_table_name(B) MODIFY COLUMN column_def(C).                                 { A = createAlterTableAddModifyCol(pCxt, B, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, C); }
 alter_table_clause(A) ::=
   full_table_name(B) RENAME COLUMN column_name(C) column_name(D).                 { A = createAlterTableRenameCol(pCxt, B, TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, &C, &D); }
 alter_table_clause(A) ::=
-  full_table_name(B) ADD TAG column_name(C) type_name(D).                         { A = createAlterTableAddModifyCol(pCxt, B, TSDB_ALTER_TABLE_ADD_TAG, &C, D); }
+  full_table_name(B) ADD TAG column_def(C).                                       { A = createAlterTableAddModifyCol(pCxt, B, TSDB_ALTER_TABLE_ADD_TAG, C); }
 alter_table_clause(A) ::= full_table_name(B) DROP TAG column_name(C).             { A = createAlterTableDropCol(pCxt, B, TSDB_ALTER_TABLE_DROP_TAG, &C); }
 alter_table_clause(A) ::= 
-  full_table_name(B) MODIFY TAG column_name(C) type_name(D).                      { A = createAlterTableAddModifyCol(pCxt, B, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, &C, D); }
+  full_table_name(B) MODIFY TAG column_def(C).                                    { A = createAlterTableAddModifyCol(pCxt, B, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, C); }
 alter_table_clause(A) ::= 
   full_table_name(B) RENAME TAG column_name(C) column_name(D).                    { A = createAlterTableRenameCol(pCxt, B, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &C, &D); }
 alter_table_clause(A) ::=
@@ -358,7 +358,7 @@ column_def_list(A) ::= column_def(B).
 column_def_list(A) ::= column_def_list(B) NK_COMMA column_def(C).                 { A = addNodeToList(pCxt, B, C); }
 
 column_def(A) ::= column_name(B) type_name(C).                                    { A = createColumnDefNode(pCxt, &B, C, NULL); }
-//column_def(A) ::= column_name(B) type_name(C) COMMENT NK_STRING(D).               { A = createColumnDefNode(pCxt, &B, C, &D); }
+column_def(A) ::= column_name(B) type_name(C) COMMENT NK_STRING(D).               { A = createColumnDefNode(pCxt, &B, C, &D); }
 
 %type type_name                                                                   { SDataType }
 %destructor type_name                                                             { }
diff --git a/source/libs/parser/src/parAstCreater.c b/source/libs/parser/src/parAstCreater.c
index b897faebdf..3c31aae573 100644
--- a/source/libs/parser/src/parAstCreater.c
+++ b/source/libs/parser/src/parAstCreater.c
@@ -1340,17 +1340,15 @@ SNode* createAlterTableModifyOptions(SAstCreateContext* pCxt, SNode* pRealTable,
   return createAlterTableStmtFinalize(pRealTable, pStmt);
 }
 
-SNode* createAlterTableAddModifyCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType, SToken* pColName,
-                                    SDataType dataType) {
+SNode* createAlterTableAddModifyCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType, SNode* pColDefNode) {
   CHECK_PARSER_STATUS(pCxt);
-  if (!checkColumnName(pCxt, pColName)) {
-    return NULL;
-  }
+  SColumnDefNode* pCol = (SColumnDefNode*)pColDefNode;
   SAlterTableStmt* pStmt = (SAlterTableStmt*)nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT);
   CHECK_OUT_OF_MEM(pStmt);
   pStmt->alterType = alterType;
-  COPY_STRING_FORM_ID_TOKEN(pStmt->colName, pColName);
-  pStmt->dataType = dataType;
+  strcpy(pStmt->colName, pCol->colName);
+  strcpy(pStmt->colComment, pCol->comments);
+  pStmt->dataType = pCol->dataType;
   return createAlterTableStmtFinalize(pRealTable, pStmt);
 }
 
diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c
index b55596f4af..c0f901c7e1 100644
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@@ -826,18 +826,18 @@ static bool isPrimaryKeyImpl(SNode* pExpr) {
       return true;
     }
   } else if (QUERY_NODE_OPERATOR == nodeType(pExpr)) {
-      SOperatorNode* pOper = (SOperatorNode*)pExpr;
-      if (OP_TYPE_ADD != pOper->opType && OP_TYPE_SUB != pOper->opType) {
-        return false;
-      }
-      if (!isPrimaryKeyImpl(pOper->pLeft)) {
-        return false;
-      }
-      if (QUERY_NODE_VALUE != nodeType(pOper->pRight)) {
-        return false;
-      }
-      return true;
+    SOperatorNode* pOper = (SOperatorNode*)pExpr;
+    if (OP_TYPE_ADD != pOper->opType && OP_TYPE_SUB != pOper->opType) {
+      return false;
     }
+    if (!isPrimaryKeyImpl(pOper->pLeft)) {
+      return false;
+    }
+    if (QUERY_NODE_VALUE != nodeType(pOper->pRight)) {
+      return false;
+    }
+    return true;
+  }
   return false;
 }
 
@@ -864,7 +864,7 @@ static void setColumnInfoBySchema(const SRealTableNode* pTable, const SSchema* p
   pCol->tableType = pTable->pMeta->tableType;
   pCol->colId = pColSchema->colId;
   pCol->colType = (tagFlag >= 0 ? COLUMN_TYPE_TAG : COLUMN_TYPE_COLUMN);
-  pCol->hasIndex = ((0 == tagFlag) || (pColSchema != NULL && IS_IDX_ON(pColSchema)));
+  pCol->hasIndex = (pColSchema != NULL && IS_IDX_ON(pColSchema));
   pCol->node.resType.type = pColSchema->type;
   pCol->node.resType.bytes = pColSchema->bytes;
   if (TSDB_DATA_TYPE_TIMESTAMP == pCol->node.resType.type) {
@@ -4697,6 +4697,7 @@ static int32_t columnDefNodeToField(SNodeList* pList, SArray** pArray) {
     SColumnDefNode* pCol = (SColumnDefNode*)pNode;
     SField          field = {.type = pCol->dataType.type, .bytes = calcTypeBytes(pCol->dataType)};
     strcpy(field.name, pCol->colName);
+    strcpy(field.comment, pCol->comments);
     if (pCol->sma) {
       field.flags |= COL_SMA_ON;
     }
@@ -5044,6 +5045,7 @@ static void toSchema(const SColumnDefNode* pCol, col_id_t colId, SSchema* pSchem
   pSchema->bytes = calcTypeBytes(pCol->dataType);
   pSchema->flags = flags;
   strcpy(pSchema->name, pCol->colName);
+  strcpy(pSchema->comment, pCol->comments);
 }
 
 typedef struct SSampleAstInfo {
@@ -7692,6 +7694,10 @@ static int32_t extractDescribeResultSchema(int32_t* numOfCols, SSchema** pSchema
   (*pSchema)[3].bytes = DESCRIBE_RESULT_NOTE_LEN;
   strcpy((*pSchema)[3].name, "note");
 
+  (*pSchema)[4].type = TSDB_DATA_TYPE_BINARY;
+  (*pSchema)[4].bytes = DESCRIBE_RESULT_COL_COMMENT_LEN;
+  strcpy((*pSchema)[4].name, "comment");
+
   return TSDB_CODE_SUCCESS;
 }
 
@@ -8874,6 +8880,15 @@ static int32_t buildAddColReq(STranslateContext* pCxt, SAlterTableStmt* pStmt, S
   pReq->type = pStmt->dataType.type;
   pReq->flags = COL_SMA_ON;
   pReq->bytes = calcTypeBytes(pStmt->dataType);
+  if (pStmt->colComment[0]) {
+    pReq->colComment = taosStrdup(pStmt->colComment);
+    if (pReq->colComment == NULL) {
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
+    pReq->colCommentLen = strlen(pReq->colComment);
+  } else {
+    pReq->colCommentLen = -1;
+  }
   return TSDB_CODE_SUCCESS;
 }
 
@@ -8924,6 +8939,15 @@ static int32_t buildUpdateColReq(STranslateContext* pCxt, SAlterTableStmt* pStmt
     return TSDB_CODE_OUT_OF_MEMORY;
   }
   pReq->colId = pSchema->colId;
+  if (pStmt->colComment[0]) {
+    pReq->colComment = taosStrdup(pStmt->colComment);
+    if (pReq->colComment == NULL) {
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
+    pReq->colCommentLen = strlen(pReq->colComment);
+  } else {
+    pReq->colCommentLen = -1;
+  }
 
   return TSDB_CODE_SUCCESS;
 }
diff --git a/source/libs/parser/src/sql.c b/source/libs/parser/src/sql.c
index 1d8e37fd1e..1fb803e93d 100644
--- a/source/libs/parser/src/sql.c
+++ b/source/libs/parser/src/sql.c
@@ -161,25 +161,25 @@
 #define TK_NK_EQ                          112
 #define TK_USING                          113
 #define TK_TAGS                           114
-#define TK_BOOL                           115
-#define TK_TINYINT                        116
-#define TK_SMALLINT                       117
-#define TK_INT                            118
-#define TK_INTEGER                        119
-#define TK_BIGINT                         120
-#define TK_FLOAT                          121
-#define TK_DOUBLE                         122
-#define TK_BINARY                         123
-#define TK_NCHAR                          124
-#define TK_UNSIGNED                       125
-#define TK_JSON                           126
-#define TK_VARCHAR                        127
-#define TK_MEDIUMBLOB                     128
-#define TK_BLOB                           129
-#define TK_VARBINARY                      130
-#define TK_GEOMETRY                       131
-#define TK_DECIMAL                        132
-#define TK_COMMENT                        133
+#define TK_COMMENT                        115
+#define TK_BOOL                           116
+#define TK_TINYINT                        117
+#define TK_SMALLINT                       118
+#define TK_INT                            119
+#define TK_INTEGER                        120
+#define TK_BIGINT                         121
+#define TK_FLOAT                          122
+#define TK_DOUBLE                         123
+#define TK_BINARY                         124
+#define TK_NCHAR                          125
+#define TK_UNSIGNED                       126
+#define TK_JSON                           127
+#define TK_VARCHAR                        128
+#define TK_MEDIUMBLOB                     129
+#define TK_BLOB                           130
+#define TK_VARBINARY                      131
+#define TK_GEOMETRY                       132
+#define TK_DECIMAL                        133
 #define TK_MAX_DELAY                      134
 #define TK_WATERMARK                      135
 #define TK_ROLLUP                         136
@@ -479,17 +479,17 @@ typedef union {
 #define ParseCTX_FETCH
 #define ParseCTX_STORE
 #define YYFALLBACK 1
-#define YYNSTATE             801
-#define YYNRULE              602
-#define YYNRULE_WITH_ACTION  602
+#define YYNSTATE             799
+#define YYNRULE              603
+#define YYNRULE_WITH_ACTION  603
 #define YYNTOKEN             338
-#define YY_MAX_SHIFT         800
-#define YY_MIN_SHIFTREDUCE   1182
-#define YY_MAX_SHIFTREDUCE   1783
-#define YY_ERROR_ACTION      1784
-#define YY_ACCEPT_ACTION     1785
-#define YY_NO_ACTION         1786
-#define YY_MIN_REDUCE        1787
+#define YY_MAX_SHIFT         798
+#define YY_MIN_SHIFTREDUCE   1180
+#define YY_MAX_SHIFTREDUCE   1782
+#define YY_ERROR_ACTION      1783
+#define YY_ACCEPT_ACTION     1784
+#define YY_NO_ACTION         1785
+#define YY_MIN_REDUCE        1786
 #define YY_MAX_REDUCE        2388
 /************* End control #defines *******************************************/
 #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))
@@ -557,610 +557,616 @@ typedef union {
 **  yy_default[]       Default action for each state.
 **
 *********** Begin parsing tables **********************************************/
-#define YY_ACTTAB_COUNT (2963)
+#define YY_ACTTAB_COUNT (3028)
 static const YYACTIONTYPE yy_action[] = {
- /*     0 */  2197,  535, 2175,  221,  536, 1823,  448,  538,   90, 1830,
- /*    10 */   708,  447,   48,   46, 1710,  454, 2183,  169, 2175, 1799,
- /*    20 */   402,  690, 1557,   41,   40,  372, 2179,   47,   45,   44,
- /*    30 */    43,   42, 1955, 1638, 1959, 1555,   38,  307, 2215, 2086,
- /*    40 */    41,   40, 2179, 2175,   47,   45,   44,   43,   42, 1810,
- /*    50 */  2165,  395,  707,  631, 2083,  678, 2359, 2184,  168, 2197,
- /*    60 */   349,  650, 1633, 2158, 2181,  399, 1905, 2179,   19,  671,
- /*    70 */  1584,  396, 2365,  188,  701, 1563,   30, 2360,  657,  166,
- /*    80 */  2181, 1215,  656,  362, 1582, 2359, 2196, 1966, 2232, 2215,
- /*    90 */   701,  170, 2198,  711, 2200, 2201,  706, 2215,  701, 2165,
- /*   100 */   797,  655,  188,   15,   51, 2181, 2360,  657,  223, 2165,
- /*   110 */   631,  707,  538, 2359, 1830,  701,   48,   46, 2364,  540,
- /*   120 */  1217, 2359, 1220, 1221,  402,  537, 1557, 1667, 1809, 2365,
- /*   130 */   188, 1942,  632, 2324, 2360,  657, 1750, 1638, 2363, 1555,
- /*   140 */  1640, 1641, 2360, 2362,  649, 2196,  184, 2232,  532, 1317,
- /*   150 */   112, 2198,  711, 2200, 2201,  706,  530,  701, 2004,  526,
- /*   160 */   522, 1240,  185, 1239, 2285,  405, 1633,   62,  398, 2281,
- /*   170 */  1613, 1623,   19,  163,   66,  149, 1639, 1642, 2165, 1563,
- /*   180 */   384, 1966,  190,  543, 1668, 1788,  536, 1823, 2015, 1319,
- /*   190 */  2313, 1558,  125, 1556, 1241,  124,  123,  122,  121,  120,
- /*   200 */   119,  118,  117,  116,  797, 2086,  125,   15, 2197,  124,
- /*   210 */   123,  122,  121,  120,  119,  118,  117,  116,  708, 1582,
- /*   220 */  2084,  678,  288, 1561, 1562, 1787, 1612, 1615, 1616, 1617,
- /*   230 */  1618, 1619, 1620, 1621, 1622,  703,  699, 1631, 1632, 1634,
- /*   240 */  1635, 1636, 1637,    2, 1640, 1641, 2215,  690, 1583,  134,
- /*   250 */   133,  132,  131,  130,  129,  128,  127,  126, 2165, 2364,
- /*   260 */   707,  289,   37,  400, 1662, 1663, 1664, 1665, 1666, 1670,
- /*   270 */  1671, 1672, 1673,   62, 1613, 1623, 1584,  181,   41,   40,
- /*   280 */  1639, 1642,   47,   45,   44,   43,   42,  691, 1964,  407,
- /*   290 */  1585,  109, 2010, 2012, 2196, 1558, 2232, 1556, 2070,  112,
- /*   300 */  2198,  711, 2200, 2201,  706, 2048,  701,  135,  145,  147,
- /*   310 */  1582,  151, 2256, 2285,  575, 2197, 1956,  398, 2281,   47,
- /*   320 */    45,   44,   43,   42,  289,  671, 2300, 1561, 1562,  676,
- /*   330 */  1612, 1615, 1616, 1617, 1618, 1619, 1620, 1621, 1622,  703,
- /*   340 */   699, 1631, 1632, 1634, 1635, 1636, 1637,    2,   12,   48,
- /*   350 */    46, 1557, 2297, 2215,  181,  458, 2065,  402, 1941, 1557,
- /*   360 */  1773, 1373,  668,  144, 1555, 2165,   62,  707, 1408, 1409,
- /*   370 */  1638,   12, 1555,   10,  370, 2069, 1364,  736,  735,  734,
- /*   380 */  1368,  733, 1370, 1371,  732,  729,  690, 1379,  726, 1381,
- /*   390 */  1382,  723,  720,  717,  464, 2065,  668,  144, 1583, 1633,
- /*   400 */  2300, 2196,  202, 2232, 1563,   19,  112, 2198,  711, 2200,
- /*   410 */  2201,  706, 1563,  701,  593,  592,  591, 2300,  185,  552,
- /*   420 */  2285,  583,  141,  587,  398, 2281, 2296,  586,  288,  797,
- /*   430 */   289,  405,  585,  590,  378,  377, 1738,  797,  584,  166,
- /*   440 */    15,  205,  266, 2295,   41,   40, 2314, 1966,   47,   45,
- /*   450 */    44,   43,   42,   48,   46, 1643, 1808, 1240,  677, 1239,
- /*   460 */  1614,  402,  375, 1557,  476,  670,  186, 2293, 2294,   51,
- /*   470 */   142, 2298,  140,  475, 1638,  252, 1555, 1640, 1641,  251,
- /*   480 */  1582, 2011, 2012,  643,  642, 1736, 1737, 1739, 1740, 1741,
- /*   490 */  1241,  744,  156,  155,  741,  740,  739,  153,  660, 2197,
- /*   500 */   187, 2293, 2294, 1633,  142, 2298, 2165, 1613, 1623,  708,
- /*   510 */   550, 1832, 2079, 1639, 1642,  746, 1563,  103, 1483, 1484,
- /*   520 */  1558, 1939, 1556,  289,  646,  691, 1964,  663, 1558,  436,
- /*   530 */  1556,  376, 2017,  374,  373,   52,  577, 2215, 1807,  383,
- /*   540 */    93,  797, 1957,  357,   49,  193,  382, 2015,  609, 2165,
- /*   550 */  1866,  707, 1561, 1562, 1482, 1485,  438,  434,  579, 1940,
- /*   560 */  1561, 1562,  578, 1612, 1615, 1616, 1617, 1618, 1619, 1620,
- /*   570 */  1621, 1622,  703,  699, 1631, 1632, 1634, 1635, 1636, 1637,
- /*   580 */     2, 1640, 1641,  691, 1964, 2196,  146, 2232, 2165, 2256,
- /*   590 */   112, 2198,  711, 2200, 2201,  706, 2130,  701, 1243, 1244,
- /*   600 */   411,  410, 2379,  135, 2285,  691, 1964,  651,  398, 2281,
- /*   610 */   580, 1613, 1623,   62,  652,  647,  640, 1639, 1642, 1780,
- /*   620 */   593,  592,  591, 1564,   12,   56,  746,  583,  141,  587,
- /*   630 */  1466, 1467, 1558,  586, 1556,  498,  677, 1806,  585,  590,
- /*   640 */   378,  377,   41,   40,  584,  254,   47,   45,   44,   43,
- /*   650 */    42, 2197,  491, 2065,  744,  156,  155,  741,  740,  739,
- /*   660 */   153,  708,  579, 2321, 1561, 1562,  578, 1612, 1615, 1616,
- /*   670 */  1617, 1618, 1619, 1620, 1621, 1622,  703,  699, 1631, 1632,
- /*   680 */  1634, 1635, 1636, 1637,    2,   48,   46, 2165,  675, 2215,
- /*   690 */  2079, 1328,  289,  402, 1332, 1557,  212,  211, 2017,  210,
- /*   700 */   446, 2165,  445,  707, 1327, 2017, 1638, 1331, 1555, 2148,
- /*   710 */    41,   40,  368, 2016,   47,   45,   44,   43,   42,  497,
- /*   720 */  2015, 1779,  616,  677,  571,  570,  738,  668,  144, 2008,
- /*   730 */  2197,   90,  444,  691, 1964, 1633,  661, 2196, 1749, 2232,
- /*   740 */   705, 1563,  112, 2198,  711, 2200, 2201,  706, 1563,  701,
- /*   750 */   298,  299,   34,  452, 2379,  297, 2285, 1960,   41,   40,
- /*   760 */   398, 2281,   47,   45,   44,   43,   42,  664, 2215,  507,
- /*   770 */   289, 2364,  509,  797, 2359,  686,   49, 2079,  691, 1964,
- /*   780 */  2165, 1567,  707,  756,  656,  691, 1964, 2359, 2363,   48,
- /*   790 */    46, 2363,   44,   43,   42, 2360, 2361,  402,  453, 1557,
- /*   800 */   691, 1964,  607,  655,  188,  466, 1726,  630, 2360,  657,
- /*   810 */  1638, 1805, 1555, 1640, 1641,  605, 2196,  603, 2232,  737,
- /*   820 */   481,  343, 2198,  711, 2200, 2201,  706,  704,  701,  692,
- /*   830 */  2250,  286, 2293,  667, 1804,  136,  666,  742, 2359, 1633,
- /*   840 */  2008, 2197, 1803, 1613, 1623,  691, 1964,  691, 1964, 1639,
- /*   850 */  1642,  708, 1563, 2334,  655,  188,   14,   13, 1274, 2360,
- /*   860 */   657, 2165,   36,  262, 1558,  482, 1556,  551,   41,   40,
- /*   870 */   691, 1964,   47,   45,   44,   43,   42,  797, 1802, 2215,
- /*   880 */    15,   41,   40, 1953, 2165,   47,   45,   44,   43,   42,
- /*   890 */  1961, 2165, 2165,  707, 1949, 2159, 1561, 1562, 1275, 1612,
- /*   900 */  1615, 1616, 1617, 1618, 1619, 1620, 1621, 1622,  703,  699,
- /*   910 */  1631, 1632, 1634, 1635, 1636, 1637,    2, 1640, 1641,  573,
- /*   920 */   572,  668,  144,  691, 1964,  253,  431, 2196, 2165, 2232,
- /*   930 */  1906,   60,  112, 2198,  711, 2200, 2201,  706,  628,  701,
- /*   940 */   589,  588,  631,  255, 2379, 2359, 2285, 1613, 1623,  743,
- /*   950 */   398, 2281, 2008, 1639, 1642,  691, 1964, 2017,  693, 1681,
- /*   960 */  2257, 2365,  188,  237,  392, 1951, 2360,  657, 1558, 1947,
- /*   970 */  1556, 2017, 2015,  691, 1964,  263,   41,   40,  397,  173,
- /*   980 */    47,   45,   44,   43,   42, 1714, 2015,  569,  565,  561,
- /*   990 */   557, 1582,  236,  674,    9, 1528, 1529,  695,  207, 2257,
- /*  1000 */  1561, 1562, 1863, 1612, 1615, 1616, 1617, 1618, 1619, 1620,
- /*  1010 */  1621, 1622,  703,  699, 1631, 1632, 1634, 1635, 1636, 1637,
- /*  1020 */     2, 1707,  353,  167, 1580,  189, 2293, 2294,  328,  142,
- /*  1030 */  2298,  489,   91, 1968,  505,  234,  408,  504,   86,  691,
- /*  1040 */  1964,   85,  325,   73,  166,  165,   72,  691, 1964, 2017,
- /*  1050 */   768,  766, 1966,  472,  259,  506,  406,  350, 1669,  302,
- /*  1060 */   474, 1585, 1801, 1585, 2015,  659,  614,  688,  219,  517,
- /*  1070 */   515,  512,  774,  773,  772,  771,  414, 1800,  770,  769,
- /*  1080 */   148,  764,  763,  762,  761,  760,  759,  758,  158,  754,
- /*  1090 */   753,  752,  413,  412,  749,  748,  747,  176,  175,  691,
- /*  1100 */  1964, 1648,  321,  233,  227, 1994,  371, 1582,   62,  702,
- /*  1110 */   232,  548, 2165,  631,  691, 1964, 2359,  757,  460,  689,
- /*  1120 */  1926,  744,  156,  155,  741,  740,  739,  153,  672,  225,
- /*  1130 */   691, 1964, 2365,  188,  308, 1798,   35, 2360,  657, 1220,
- /*  1140 */  1221, 1614, 1797, 1223, 2305, 1701, 1674,  111,  502, 1581,
- /*  1150 */   409,  496,  495,  494,  493,  488,  487,  486,  485,  484,
- /*  1160 */   480,  479,  478,  477,  352,  469,  468,  467, 1796,  462,
- /*  1170 */   461,  369, 1795, 2327,  166,  631,  154,   54, 2359,    3,
- /*  1180 */  1794,  283, 1967, 1785, 1793, 2165, 2151, 1792,   81,   80,
- /*  1190 */   451, 2197, 2165,  200, 2365,  188,   74, 1791, 1790, 2360,
- /*  1200 */   657,  708,   83,  638,  137,  242,  443,  441,  240,  244,
- /*  1210 */   581,  644,  243,  203, 1701,  265,  246,  351, 2165,  245,
- /*  1220 */   432, 2197, 2165,  430,  426,  422,  419,  444,  154, 2215,
- /*  1230 */  2165,  708, 1315, 2352, 2165,  424,   55, 2165,  455,  154,
- /*  1240 */   611, 2165,  610,  707,  582, 1850,   84, 2165, 2165,  264,
- /*  1250 */   248,  456, 2197,  247, 1841, 1566,  417, 1614, 1839, 2215,
- /*  1260 */   698,  416,  708,  139, 2304,  289, 1313,  594, 1833,   50,
- /*  1270 */  1904, 2165,   50,  707,  270,  277,  596, 2196, 1706, 2232,
- /*  1280 */   599,  154,  112, 2198,  711, 2200, 2201,  706, 1523,  701,
- /*  1290 */  2215,   50,   94, 1903, 2379, 1565, 2285, 1782, 1783, 1526,
- /*  1300 */   398, 2281, 2165,  631,  707,  385, 2359, 2196, 2186, 2232,
- /*  1310 */   295,   71,  112, 2198,  711, 2200, 2201,  706,  792,  701,
- /*  1320 */   598,  152, 2365,  188, 2379,  154, 2285, 2360,  657, 1735,
- /*  1330 */   398, 2281, 1734,   64,  272,  608,   14,   13, 2196,   50,
- /*  1340 */  2232,  673, 2197,  112, 2198,  711, 2200, 2201,  706,  250,
- /*  1350 */   701, 1480,  708,  411,  410, 2379, 2216, 2285,  108,   50,
- /*  1360 */   415,  398, 2281, 1571, 2188,  601,  715,  152,  105,  154,
- /*  1370 */   300,  683,  595, 2197, 1638, 2074, 1564, 1824,  249,  750,
- /*  1380 */  2215,  304,  138,  708,  152, 1358,  751, 1829, 2005,  669,
- /*  1390 */  2317,  285, 2165, 1675,  707,  282,    1,  418,    5, 1624,
- /*  1400 */   423, 1293, 1588, 1633,  366,  440,  439,  195, 1291,  196,
- /*  1410 */  2197, 2215,  442, 1569,  198, 1659, 1563,  315,   70,  320,
- /*  1420 */   708,   69, 1504, 2165, 1581,  707, 1386, 1390, 2196, 1397,
- /*  1430 */  2232,  457,  209,  112, 2198,  711, 2200, 2201,  706, 1585,
- /*  1440 */   701,  697, 1395,  459,  157, 2260,  463, 2285, 2215, 2075,
- /*  1450 */   465,  398, 2281, 1568,  500,  470, 1580,  483, 2067, 2196,
- /*  1460 */  2165, 2232,  707,  490,  112, 2198,  711, 2200, 2201,  706,
- /*  1470 */   492,  701,  499,  501,  511,  510, 2258,  508, 2285,  213,
- /*  1480 */   214,  513,  398, 2281,  514, 1586,    4,  216,  516,  518,
- /*  1490 */   533,  534,  541,  542,  544, 1583, 2196,  545, 2232, 2197,
- /*  1500 */   224,  112, 2198,  711, 2200, 2201,  706,  226,  701,  708,
- /*  1510 */  1587,  546, 1589,  694,  547, 2285,  549,  553,  574,  398,
- /*  1520 */  2281,  229,  231,  356,   88,   89,   92,  235,  114,  576,
- /*  1530 */  1954,  239, 1572, 1950, 1567,  241, 2139, 2215,  613,  615,
- /*  1540 */   159,  150,  316,  619, 2136,  256, 2135,  620, 2197, 2165,
- /*  1550 */   160,  707, 1952, 1948,  618,  161,  162,  645,  708,  258,
- /*  1560 */   260,  626,  623, 1511, 1575, 1577,  681, 2333, 2332,    8,
- /*  1570 */   635,  654,  641,  388, 2307,  276,  648,  699, 1631, 1632,
- /*  1580 */  1634, 1635, 1636, 1637,  625, 2196, 2215, 2232,  624,  268,
- /*  1590 */   113, 2198,  711, 2200, 2201,  706,  271,  701, 2165, 2318,
- /*  1600 */   707,  174, 2328,  636, 2285,  634,  633,  280, 2284, 2281,
- /*  1610 */   662,  281,  389, 2197,  665, 2382, 1701, 1584, 1704,  290,
- /*  1620 */   143,   98,  178,  708, 1590, 2080,  679, 2301,  317,  680,
- /*  1630 */  2094, 2093, 2092,  318, 2196,  394, 2232,  684, 2197,  113,
- /*  1640 */  2198,  711, 2200, 2201,  706,  685,  701,  100,  708,  319,
- /*  1650 */   102, 2215, 1965, 2285,   61, 2266,  278,  696, 2281,  279,
- /*  1660 */   104,  713, 2009, 2165,  191,  707,  311,  322, 1927,  793,
- /*  1670 */   346,   53, 2358,  796,  284,  331, 2215,  794,  345,  335,
- /*  1680 */   358,  326,  359, 2157, 2156, 2155,   78, 2152, 2165,  420,
- /*  1690 */   707, 1548,  324,  421, 1549,  194,  425, 2150,  427,  709,
- /*  1700 */   428, 2232,  429, 2197,  113, 2198,  711, 2200, 2201,  706,
- /*  1710 */  2149,  701,  367,  708, 2147,  433, 2146,  435, 2285, 2145,
- /*  1720 */  1539,  437,  361, 2281, 2196, 2126, 2232,  197, 2125,  171,
- /*  1730 */  2198,  711, 2200, 2201,  706,  199,  701,   79, 1507, 1506,
- /*  1740 */  2107, 2215, 2106, 2105, 2104,  449,  450, 2103, 1457, 2058,
- /*  1750 */  2057, 2054, 2197, 2165,  201,  707, 2053,   82, 2052, 2051,
- /*  1760 */  2056, 2055,  708,   87,  204, 2050, 2049, 2197, 2047, 2046,
- /*  1770 */  2045,  206,  471, 2044,  473, 2060, 2043,  708, 2197, 2042,
- /*  1780 */  2041,  658, 2380, 2040, 2039, 2038, 2037, 2036,  708, 2196,
- /*  1790 */  2215, 2232,  208, 2028,  113, 2198,  711, 2200, 2201,  706,
- /*  1800 */  2035,  701, 2165, 2034,  707, 2215, 2033, 2032, 2285, 2031,
- /*  1810 */   386, 2030, 2029, 2282, 2027, 2026, 2215, 2165, 2025,  707,
- /*  1820 */  2059,  387, 2024, 2023, 1459, 2022, 2021, 2020, 2165,  354,
- /*  1830 */   707,  503, 2019, 2018, 1869, 1329,  355, 1868, 2196, 1333,
- /*  1840 */  2232, 2197, 1867,  170, 2198,  711, 2200, 2201,  706, 1865,
- /*  1850 */   701,  708,  215, 2196, 1325, 2232,  217, 2197,  344, 2198,
- /*  1860 */   711, 2200, 2201,  706, 2196,  701, 2232,  708, 1862,  344,
- /*  1870 */  2198,  711, 2200, 2201,  706,  519,  701,  520,  218, 2215,
- /*  1880 */   521, 1861,  523,  525,  524, 2325, 1854,  527,  528,  529,
- /*  1890 */  1843, 2165,  531,  707, 1819, 2215,  220,   76, 2185,  182,
- /*  1900 */   183, 1222, 1818,  539,  222,   77, 2124, 2165, 2114,  707,
- /*  1910 */  2102,  228, 2101,  230, 2078, 1943, 1864, 1267, 1860,  554,
- /*  1920 */  2197,  556,  555, 1858,  558,  559, 1856, 2196,  562, 2232,
- /*  1930 */   708, 1853,  337, 2198,  711, 2200, 2201,  706,  560,  701,
- /*  1940 */   563, 1838,  564, 2196,  566, 2232, 2197,  567,  171, 2198,
- /*  1950 */   711, 2200, 2201,  706, 1836,  701,  705,   63, 2215,  568,
- /*  1960 */  1837, 1835, 1815,  393, 1945, 1402, 1401, 1944, 1316,  238,
- /*  1970 */  2165, 1314,  707, 1312, 1311, 1310,  653, 1309, 1308,  765,
- /*  1980 */  1303, 2197, 1305, 1304, 2215, 1302, 1851,  379, 1842,  767,
- /*  1990 */   380,  708, 1840,  381,  600, 1814, 2165,  597,  707, 1813,
- /*  2000 */  1812, 2381,  606,  115,  602,  604, 2196, 2197, 2232, 1533,
- /*  2010 */  1535,  344, 2198,  711, 2200, 2201,  706,  708,  701, 2215,
- /*  2020 */  1532, 1537,   29, 2123,  401,   67, 1513, 1515, 1517, 2113,
- /*  2030 */   164, 2165, 2196,  707, 2232,   57,  621,  343, 2198,  711,
- /*  2040 */  2200, 2201,  706,  622,  701, 2215, 2251, 2100,  261, 2099,
- /*  2050 */   403, 1492, 1491,  627, 2364,  629,   20, 2165,   31,  707,
- /*  2060 */    17,    6,   21,    7,   22,  274,  267, 2196,   33, 2232,
- /*  2070 */  1752, 2197,  344, 2198,  711, 2200, 2201,  706,  617,  701,
- /*  2080 */   637,  708,  269,  639,  275, 1733, 2186,   65,   23,   24,
- /*  2090 */   172, 1767,  273, 2196, 1725, 2232,  800,   32,  344, 2198,
- /*  2100 */   711, 2200, 2201,  706, 2197,  701,   95,   18, 1772, 2215,
- /*  2110 */   314, 1773,  287, 1766,  708,  390, 1771,   59, 1770,   58,
- /*  2120 */   391, 2165,  177,  707, 2098, 2077,  180,   97,  682, 1698,
- /*  2130 */  1697,   96, 2076, 2197,  790,  786,  782,  778,  293,  312,
- /*  2140 */   294,   25, 2215,  708, 1731,  296,  301,   68,   99,  303,
- /*  2150 */   306,  101,   26, 1650, 2165, 1649,  707,  612,   11, 2232,
- /*  2160 */    13, 1573,  339, 2198,  711, 2200, 2201,  706,  105,  701,
- /*  2170 */  2197, 2215, 1660, 2235,  179, 1628, 1626,  700,  192,  110,
- /*  2180 */   708, 1605,  305, 2165,  714,  707,  404,  718,  721,   39,
- /*  2190 */  2196, 1625, 2232,   16, 1378,  329, 2198,  711, 2200, 2201,
- /*  2200 */   706, 2197,  701,   27,  724, 1597,  712,   28, 2215, 1387,
- /*  2210 */   716,  708,  727,  730, 1384,  687,  719,  722,  710, 2196,
- /*  2220 */  2165, 2232,  707, 1383,  327, 2198,  711, 2200, 2201,  706,
- /*  2230 */  1380,  701,  725, 2197, 1374,  309,  728, 1377, 1372, 2215,
- /*  2240 */   731, 1376, 1375,  708,  106,  107, 1396,   75, 1392, 1265,
- /*  2250 */   292, 2165,  745,  707, 1297, 1296, 2196,  291, 2232, 1295,
- /*  2260 */  1294,  330, 2198,  711, 2200, 2201,  706, 1292,  701, 1290,
- /*  2270 */  1289, 2215, 1288, 1323,  310, 1286,  257, 1285,  755, 1284,
- /*  2280 */  1283, 1282, 1281, 2165, 1280,  707, 1318, 2196, 1320, 2232,
- /*  2290 */  1277, 1276,  336, 2198,  711, 2200, 2201,  706, 2197,  701,
- /*  2300 */  1273, 1272, 1271, 1270, 1859,  775,  776, 1857,  708,  779,
- /*  2310 */   777,  780,  781, 1855,  783,  785,  784, 1852,  787, 2196,
- /*  2320 */  1834, 2232,  791, 2197,  340, 2198,  711, 2200, 2201,  706,
- /*  2330 */   788,  701,  789,  708, 1212, 1811, 2215,  313, 1559,  795,
- /*  2340 */  1786,  323,  798,  799, 1786, 1786, 1786, 1786, 2165, 2197,
- /*  2350 */   707, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786,  708,
- /*  2360 */  2197, 2215, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786,
- /*  2370 */   708, 1786, 1786, 2165, 1786,  707, 1786, 1786, 1786, 1786,
- /*  2380 */  1786, 1786, 1786, 1786, 2196, 1786, 2232, 2215, 1786,  332,
- /*  2390 */  2198,  711, 2200, 2201,  706, 1786,  701, 1786, 2215, 2165,
- /*  2400 */  1786,  707, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 2196,
- /*  2410 */  2165, 2232,  707, 1786,  341, 2198,  711, 2200, 2201,  706,
- /*  2420 */  1786,  701, 1786, 2197, 1786, 1786, 1786, 1786, 1786, 1786,
- /*  2430 */  1786, 1786, 1786,  708, 1786, 2196, 1786, 2232, 1786, 1786,
- /*  2440 */   333, 2198,  711, 2200, 2201,  706, 2196,  701, 2232, 1786,
- /*  2450 */  1786,  342, 2198,  711, 2200, 2201,  706, 1786,  701, 1786,
- /*  2460 */  1786, 2215, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786,
- /*  2470 */  1786, 1786, 1786, 2165, 1786,  707, 1786, 1786, 1786, 1786,
- /*  2480 */  1786, 1786, 1786, 1786, 2197, 1786, 1786, 1786, 1786, 1786,
- /*  2490 */  1786, 1786, 1786, 1786,  708, 1786, 1786, 1786, 1786, 1786,
- /*  2500 */  1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 2196,
- /*  2510 */  1786, 2232, 1786, 2197,  334, 2198,  711, 2200, 2201,  706,
- /*  2520 */  1786,  701, 2215,  708, 1786, 1786, 1786, 1786, 1786, 1786,
- /*  2530 */  1786, 1786, 1786, 1786, 2165, 1786,  707, 1786, 1786, 1786,
- /*  2540 */  1786, 1786, 1786, 2197, 1786, 1786, 1786, 1786, 1786, 1786,
- /*  2550 */  1786, 2215, 1786,  708, 1786, 1786, 1786, 1786, 1786, 1786,
- /*  2560 */  1786, 1786, 1786, 2165, 2197,  707, 1786, 1786, 1786, 1786,
- /*  2570 */  2196, 1786, 2232, 1786,  708,  347, 2198,  711, 2200, 2201,
- /*  2580 */   706, 2215,  701, 1786, 1786, 1786, 1786, 1786, 1786, 1786,
- /*  2590 */  1786, 1786, 1786, 2165, 1786,  707, 1786, 1786, 1786, 2196,
- /*  2600 */  1786, 2232, 2215, 1786,  348, 2198,  711, 2200, 2201,  706,
- /*  2610 */  1786,  701, 1786, 2197, 2165, 1786,  707, 1786, 1786, 1786,
- /*  2620 */  1786, 1786, 1786,  708, 1786, 1786, 1786, 1786, 1786, 2196,
- /*  2630 */  1786, 2232, 1786, 1786, 2209, 2198,  711, 2200, 2201,  706,
- /*  2640 */  1786,  701, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786,
- /*  2650 */  2196, 2215, 2232, 1786, 1786, 2208, 2198,  711, 2200, 2201,
- /*  2660 */   706, 1786,  701, 2165, 1786,  707, 1786, 1786, 1786, 1786,
- /*  2670 */  1786, 1786, 1786, 1786, 1786, 2197, 1786, 1786, 1786, 1786,
- /*  2680 */  1786, 1786, 1786, 1786, 1786,  708, 1786, 1786, 1786, 1786,
- /*  2690 */  2197, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 2196,
- /*  2700 */   708, 2232, 1786, 1786, 2207, 2198,  711, 2200, 2201,  706,
- /*  2710 */  1786,  701, 2197, 2215, 1786, 1786, 1786, 1786, 1786, 1786,
- /*  2720 */  1786, 1786,  708, 1786, 1786, 2165, 1786,  707, 2215, 1786,
- /*  2730 */  1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786,
- /*  2740 */  2165, 2197,  707, 1786, 1786, 1786, 1786, 1786, 1786, 1786,
- /*  2750 */  2215,  708, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786,
- /*  2760 */  1786, 2196, 2165, 2232,  707, 1786,  363, 2198,  711, 2200,
- /*  2770 */  2201,  706, 1786,  701, 1786, 1786, 2196, 1786, 2232, 2215,
- /*  2780 */  1786,  364, 2198,  711, 2200, 2201,  706, 1786,  701, 1786,
- /*  2790 */  1786, 2165, 1786,  707, 1786, 1786, 1786, 1786, 2196, 1786,
- /*  2800 */  2232, 1786, 1786,  360, 2198,  711, 2200, 2201,  706, 1786,
- /*  2810 */   701, 1786, 1786, 1786, 1786, 2197, 1786, 1786, 1786, 1786,
- /*  2820 */  1786, 1786, 1786, 1786, 1786,  708, 1786, 2196, 1786, 2232,
- /*  2830 */  1786, 1786,  365, 2198,  711, 2200, 2201,  706, 1786,  701,
- /*  2840 */  1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786,
- /*  2850 */  1786, 1786, 1786, 2215, 1786, 1786, 1786, 1786, 1786, 1786,
- /*  2860 */  1786, 1786, 1786, 1786, 2197, 2165, 1786,  707, 1786, 1786,
- /*  2870 */  1786, 1786, 1786, 1786,  708, 1786, 1786, 1786, 1786, 1786,
- /*  2880 */  1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786,
- /*  2890 */  1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786,
- /*  2900 */  1786,  709, 2215, 2232, 1786, 1786,  339, 2198,  711, 2200,
- /*  2910 */  2201,  706, 1786,  701, 2165, 1786,  707, 1786, 1786, 1786,
- /*  2920 */  1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786,
- /*  2930 */  1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786,
- /*  2940 */  1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786, 1786,
- /*  2950 */  2196, 1786, 2232, 1786, 1786,  338, 2198,  711, 2200, 2201,
- /*  2960 */   706, 1786,  701,
+ /*     0 */   734, 2197, 2175,  531, 2017, 2158,  532, 1822,   90,  450,
+ /*    10 */   364,  704,   48,   46, 1709,  169, 2183, 1798, 2015,  181,
+ /*    20 */   398, 2086, 1556,   41,   40,  368, 2179,   47,   45,   44,
+ /*    30 */    43,   42,   66, 1637, 1958, 1554, 2084,  674,  366, 2069,
+ /*    40 */  2215,  146,   41,   40, 2256, 2086,   47,   45,   44,   43,
+ /*    50 */    42, 2165,  627,  703,  345, 2359, 2175,  391,  401, 2197,
+ /*    60 */  2083,  674, 1632, 1581, 2181,  395, 1965,  163,   19,  667,
+ /*    70 */  1954, 2365,  188,  380,  697, 1562, 2360,  653,   30,  686,
+ /*    80 */  2179, 2015,  652,  358,  536, 2359,  672, 2196, 2364, 2232,
+ /*    90 */   533, 2359,  170, 2198,  707, 2200, 2201,  702, 2215,  697,
+ /*   100 */   795,  651,  188,   15,   38,  303, 2360,  653, 2363, 2165,
+ /*   110 */   647,  703, 2360, 2362, 2011, 2012,   48,   46, 2181,   47,
+ /*   120 */    45,   44,   43,   42,  398, 2186, 1556, 1666,  697,  687,
+ /*   130 */  1963,   62,   62,  628, 2324,  407,  406, 1637, 1749, 1554,
+ /*   140 */  1639, 1640,  221, 1241, 1242, 2196,  534, 2232, 1829,  135,
+ /*   150 */   112, 2198,  707, 2200, 2201,  702,  571,  697, 1563,  223,
+ /*   160 */   687, 1963,  185,  534, 2285, 1829, 1632,  673,  394, 2281,
+ /*   170 */  1612, 1622,   19, 1581,  687, 1963, 1638, 1641,  168, 1562,
+ /*   180 */   135, 2188,  190,  626, 1667, 1787, 1904,  576,  567,  566,
+ /*   190 */  2313, 1557,  125, 1555,  193,  124,  123,  122,  121,  120,
+ /*   200 */   119,  118,  117,  116,  795,  548,  125,   15, 2197,  124,
+ /*   210 */   123,  122,  121,  120,  119,  118,  117,  116,  704,  546,
+ /*   220 */  1668, 2079, 1562, 1560, 1561, 1786, 1611, 1614, 1615, 1616,
+ /*   230 */  1617, 1618, 1619, 1620, 1621,  699,  695, 1630, 1631, 1633,
+ /*   240 */  1634, 1635, 1636,    2, 1639, 1640,  686, 2215, 1582,  134,
+ /*   250 */   133,  132,  131,  130,  129,  128,  127,  126, 2165, 1238,
+ /*   260 */   703, 1237,   37,  396, 1661, 1662, 1663, 1664, 1665, 1669,
+ /*   270 */  1670, 1671, 1672,  539, 1612, 1622,  532, 1822,   41,   40,
+ /*   280 */  1638, 1641,   47,   45,   44,   43,   42,  248,  285,  285,
+ /*   290 */  1584,  247, 1239,  686, 2196, 1557, 2232, 1555,   35,  112,
+ /*   300 */  2198,  707, 2200, 2201,  702,  642,  697,   60, 1673,  147,
+ /*   310 */   184,  155, 2256, 2285,  624, 2197, 1566,  394, 2281,   44,
+ /*   320 */    43,   42, 2004, 1465, 1466,  667,  103, 1560, 1561,   51,
+ /*   330 */  1611, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 1621,  699,
+ /*   340 */   695, 1630, 1631, 1633, 1634, 1635, 1636,    2,   12,   48,
+ /*   350 */    46, 1956,   93,  736, 2215,  353, 2008,  398,  378, 1556,
+ /*   360 */   605, 1372, 1582,  528,    9, 2165, 1581,  703, 1407, 1408,
+ /*   370 */  1637,  526, 1554,  646,  522,  518,   51, 1363,  732,  731,
+ /*   380 */   730, 1367,  729, 1369, 1370,  728,  725, 2364, 1378,  722,
+ /*   390 */  1380, 1381,  719,  716,  713,  648,  643,  636, 2159, 1632,
+ /*   400 */   610, 2196, 2215, 2232, 1583,   19,  112, 2198,  707, 2200,
+ /*   410 */  2201,  702, 1562,  697,  589,  588,  587,  207,  185,  575,
+ /*   420 */  2285,  579,  141,  583,  394, 2281,  371,  582,  744, 2197,
+ /*   430 */   569,  568,  581,  586,  374,  373, 2300,  795,  580,  704,
+ /*   440 */    15,  574,  262,  392,  594,  627, 2314,  627, 2359,   62,
+ /*   450 */  2359, 1965,  166,   48,   46, 1642,  645,   86,  673,  604,
+ /*   460 */    85,  398, 2297, 1556, 2365,  188, 2365,  188, 2215, 2360,
+ /*   470 */   653, 2360,  653,  246, 1637, 2300, 1554, 1639, 1640, 2165,
+ /*   480 */  1784,  703, 1482, 1483,  454, 2065,   41,   40, 1772,  597,
+ /*   490 */    47,   45,   44,   43,   42,  372,  591,  370,  369, 2197,
+ /*   500 */   573, 2296,  245, 1632,  575,  460, 2065, 1612, 1622,  704,
+ /*   510 */   671, 1831, 2079, 1638, 1641, 2196, 1562, 2232, 1481, 1484,
+ /*   520 */   113, 2198,  707, 2200, 2201,  702,  574,  697, 1557, 2017,
+ /*   530 */  1555,  202,   12,  285, 2285,  379,  664,  144, 2215, 2282,
+ /*   540 */  1583,  795,   70, 2015,   49,   69,   12, 1213,   10, 2165,
+ /*   550 */  1584,  703,  205,  413,  487, 2065,  284, 1809,  412, 1315,
+ /*   560 */  1560, 1561,  673, 1611, 1614, 1615, 1616, 1617, 1618, 1619,
+ /*   570 */  1620, 1621,  699,  695, 1630, 1631, 1633, 1634, 1635, 1636,
+ /*   580 */     2, 1639, 1640,  603, 1700, 2196, 1215, 2232, 1218, 1219,
+ /*   590 */   112, 2198,  707, 2200, 2201,  702,  601,  697,  599, 1317,
+ /*   600 */   627,  210, 2379, 2359, 2285, 1808,  285, 2165,  394, 2281,
+ /*   610 */  2048, 1612, 1622, 1238,  682, 1237, 2079, 1638, 1641, 2365,
+ /*   620 */   188,  585,  584, 1326, 2360,  653,   62,  237,  140,  612,
+ /*   630 */   687, 1963, 1557, 1865, 1555, 2175, 1325,  687, 1963,  666,
+ /*   640 */   186, 2293, 2294,  173,  142, 2298, 1239,  249, 2197, 2184,
+ /*   650 */    56,  565,  561,  557,  553, 2165,  236,  448,  704, 2179,
+ /*   660 */  2321, 1779,  766,  764, 1560, 1561,  754, 1611, 1614, 1615,
+ /*   670 */  1616, 1617, 1618, 1619, 1620, 1621,  699,  695, 1630, 1631,
+ /*   680 */  1633, 1634, 1635, 1636,    2,   48,   46, 2215,  494,  687,
+ /*   690 */  1963,  735,  284,  398, 2300, 1556,   91, 2181, 2165,  234,
+ /*   700 */   703,  503,  203,  589,  588,  587, 1637,  697, 1554,  449,
+ /*   710 */   579,  141,  583,  442,  444,  441,  582, 1527, 1528,  443,
+ /*   720 */  2295,  581,  586,  374,  373,   41,   40,  580,   52,   47,
+ /*   730 */    45,   44,   43,   42, 2196, 1632, 2232,  668,  432,  112,
+ /*   740 */  2198,  707, 2200, 2201,  702,  440,  697,  158, 1562,  212,
+ /*   750 */   211, 2379,  403, 2285,  255, 2010, 2012,  394, 2281,  687,
+ /*   760 */  1963,  627,  401, 1778, 2359,  434,  430,  233,  227,  472,
+ /*   770 */  1965,  166,  493,  795,  232,  544,   49, 1737,  471,  462,
+ /*   780 */  2365,  188, 2148,  285,  627, 2360,  653, 2359, 2017,   48,
+ /*   790 */    46, 1952,  166,  225,  388, 1807, 2197,  398,  181, 1556,
+ /*   800 */   687, 1963, 2015, 2365,  188, 2017,  704,   55, 2360,  653,
+ /*   810 */  1637,  393, 1554, 1639, 1640,  664,  144, 1713, 2070, 2015,
+ /*   820 */   477, 1748, 1940, 1581,  639,  638, 1735, 1736, 1738, 1739,
+ /*   830 */  1740, 2364, 2130,  404, 2359, 2215, 1806,  664,  144, 1632,
+ /*   840 */  2363, 1965,  166, 1612, 1622, 2165, 2165,  698,  703, 1638,
+ /*   850 */  1641, 2363, 1562,   41,   40, 2360, 2361,   47,   45,   44,
+ /*   860 */    43,   42,   34,  258, 1557, 1939, 1555,  740,   41,   40,
+ /*   870 */  2008, 1905,   47,   45,   44,   43,   42,  795,  687, 1963,
+ /*   880 */    15,  250, 2196, 2197, 2232,  285, 2165,  171, 2198,  707,
+ /*   890 */  2200, 2201,  702,  704,  697, 2334, 1560, 1561,  478, 1611,
+ /*   900 */  1614, 1615, 1616, 1617, 1618, 1619, 1620, 1621,  699,  695,
+ /*   910 */  1630, 1631, 1633, 1634, 1635, 1636,    2, 1639, 1640,  187,
+ /*   920 */  2293, 2294, 2215,  142, 2298,   90,  689,  109, 2257, 1706,
+ /*   930 */   687, 1963,  744, 2165,  691,  703, 2257,  742, 1799,  654,
+ /*   940 */  2380,  189, 2293, 2294,  145,  142, 2298, 1612, 1622, 1725,
+ /*   950 */   547, 1959, 1955, 1638, 1641,  279,  160,  159,  739,  738,
+ /*   960 */   737,  157,  687, 1963,  741,  687, 1963, 2008, 1557, 2196,
+ /*   970 */  1555, 2232, 2327, 1613,  112, 2198,  707, 2200, 2201,  702,
+ /*   980 */   640,  697, 1960, 1647,   36,  684, 2379, 1938, 2285, 1581,
+ /*   990 */    41,   40,  394, 2281,   47,   45,   44,   43,   42,  427,
+ /*  1000 */  1560, 1561, 1862, 1611, 1614, 1615, 1616, 1617, 1618, 1619,
+ /*  1010 */  1620, 1621,  699,  695, 1630, 1631, 1633, 1634, 1635, 1636,
+ /*  1020 */     2, 2017,  349,  167, 1579,  687, 1963,  402,  324,  687,
+ /*  1030 */  1963,  485,  687, 1963,  501, 2015,  273,  500,  687, 1963,
+ /*  1040 */    14,   13,  321,   73, 1581,  251,   72,  687, 1963,  259,
+ /*  1050 */  1330, 2216,  670,  468, 1805,  502,  317,  346,  298, 1994,
+ /*  1060 */   470, 1218, 1219, 1329, 1804, 1803,  139,  685,  219,  513,
+ /*  1070 */   511,  508,  772,  771,  770,  769,  410, 1802,  768,  767,
+ /*  1080 */   148,  762,  761,  760,  759,  758,  757,  756,  162,  752,
+ /*  1090 */   751,  750,  409,  408,  747,  746,  745,  176,  175, 1801,
+ /*  1100 */   687, 1963,  742,  656, 2165, 1584,  367, 1221,   62,  687,
+ /*  1110 */  1963,  294,  295, 1580, 2165, 2165,  293,  655,  456, 1556,
+ /*  1120 */   304,  160,  159,  739,  738,  737,  157, 2165,  505,  405,
+ /*  1130 */    41,   40, 1554, 2151,   47,   45,   44,   43,   42, 1613,
+ /*  1140 */   664,  144,   54, 1680,    3, 1800, 1797,  111,  498, 2165,
+ /*  1150 */  1796,  492,  491,  490,  489,  484,  483,  482,  481,  480,
+ /*  1160 */   476,  475,  474,  473,  348,  465,  464,  463, 1795,  458,
+ /*  1170 */   457,  365, 1562,   41,   40, 1948,  166,   47,   45,   44,
+ /*  1180 */    43,   42,  420, 1794, 1793, 1792, 1705, 1791,   81,   80,
+ /*  1190 */   447, 2197,  742,  200, 1613, 2165, 2165,  795, 1950,  166,
+ /*  1200 */  2165,  704,  755,  634, 1790, 1925,  439,  437, 1946,  166,
+ /*  1210 */   158,  160,  159,  739,  738,  737,  157,  347, 2165, 2197,
+ /*  1220 */   428, 2305, 1700,  426,  422,  418,  415,  440, 1789,  704,
+ /*  1230 */  2215, 2352, 1941, 2165, 2165, 2165,  652, 2165,  158, 2359,
+ /*  1240 */   451, 2165,   74,  703,  282, 2293,  663,  242,  136,  662,
+ /*  1250 */   240, 2359, 2197,  452, 2165,  651,  188,  261, 2215,  577,
+ /*  1260 */  2360,  653,  704,  659, 2304,  285, 2017,  651,  188, 2165,
+ /*  1270 */  1522,  703, 2360,  653, 1966,  166,  149, 2196, 2165, 2232,
+ /*  1280 */  2016, 1313,  112, 2198,  707, 2200, 2201,  702, 1557,  697,
+ /*  1290 */  1555, 2215,   84,  260, 2379,   83, 2285,  137, 1525,   50,
+ /*  1300 */   394, 2281, 2165,  151,  703, 2196,  150, 2232,  578, 1849,
+ /*  1310 */   112, 2198,  707, 2200, 2201,  702,  244,  697,   50,  243,
+ /*  1320 */  1560, 1561, 2379,  153, 2285,  266,  152, 1840,  394, 2281,
+ /*  1330 */  1311,  590,  607,  158,  606,   50,   94,  165, 2196,  694,
+ /*  1340 */  2232,  657, 2197,  112, 2198,  707, 2200, 2201,  702,  592,
+ /*  1350 */   697, 1838,  704,  407,  406, 2379, 1565, 2285,  291, 1734,
+ /*  1360 */  1832,  394, 2281, 1570, 1781, 1782,   71,  156, 1272,  158,
+ /*  1370 */  2197,   14,   13,  595, 1637, 1903, 1563, 1902, 1733,   64,
+ /*  1380 */   704, 2215, 1564,   50,   50,  268,  711,  411,  108,  156,
+ /*  1390 */   158,  381, 2165,  669,  703, 1479, 2074,  138,  105,  156,
+ /*  1400 */  1823, 1828,  748, 1632, 2005,  665,  281, 2317, 1273, 2215,
+ /*  1410 */   790,  278,    1,    5,  419,  414, 1562,  362,  296, 1587,
+ /*  1420 */  2165,  436,  703,  435, 1291,  195,  679,  300, 2196, 1356,
+ /*  1430 */  2232,  196, 2197,  112, 2198,  707, 2200, 2201,  702, 1674,
+ /*  1440 */   697,  693,  704, 1623,  316, 2260, 1385, 2285,  749, 1389,
+ /*  1450 */  1396,  394, 2281,  438,  198, 1503, 2196, 1394, 2232,  161,
+ /*  1460 */   311,  112, 2198,  707, 2200, 2201,  702, 1580,  697,  453,
+ /*  1470 */  1289, 2215,  209, 2258,  455, 2285, 1584,  459,  466,  394,
+ /*  1480 */  2281, 2075, 2165, 1579,  703,  461,  496,  479,  488,  486,
+ /*  1490 */   495, 2067,  497,  506, 1658,  507,  504,  213,  214, 2197,
+ /*  1500 */   509,    4,  216,  660,  510,  512,  514, 1585,  530,  704,
+ /*  1510 */   529,  613,  537,  540, 1568,  538,  224, 1582, 2196,  226,
+ /*  1520 */  2232, 1586,  541,  112, 2198,  707, 2200, 2201,  702,  798,
+ /*  1530 */   697,  542, 1571, 1588, 1566,  690,  543, 2285, 2215,  229,
+ /*  1540 */  1567,  394, 2281,  310,  545,  231,   88,   89,  549, 2165,
+ /*  1550 */   235,  703,  572,  570, 1953,  239, 1949,  241, 1951,  180,
+ /*  1560 */   609, 2197, 1947,  114, 1574, 1576,  352,  788,  784,  780,
+ /*  1570 */   776,  704,  308,   92, 2139, 2136, 2135,  695, 1630, 1631,
+ /*  1580 */  1633, 1634, 1635, 1636,  611, 2196,  154, 2232,  615,  614,
+ /*  1590 */   113, 2198,  707, 2200, 2201,  702,  252,  697,  619,  256,
+ /*  1600 */  2215, 1510,  312, 2318, 2285,  621,  622,  620, 2284, 2281,
+ /*  1610 */   616, 2165,  110,  703,  254,  301, 2328,  631,  641,  637,
+ /*  1620 */   677, 2333, 2332,  650, 2197,  384,  644,  264,  267,  629,
+ /*  1630 */  2358,    8,  174, 2307,  704,  632,  630,  277,  274,  275,
+ /*  1640 */   272, 1700,  661,  385,  658,  143, 1583, 2196,  683, 2232,
+ /*  1650 */  1703,  178,  113, 2198,  707, 2200, 2201,  702, 2301,  697,
+ /*  1660 */   286,   98,  276, 2215, 1589,  191, 2285, 2080,  313,  675,
+ /*  1670 */   692, 2281,  680,  676, 2165, 2094,  703, 2093, 2092,  314,
+ /*  1680 */   280,  390,  681,  288,   61, 2197, 2382,  100,  315,  102,
+ /*  1690 */   287,  104, 2266,  709, 1964,  701, 2009, 1926,  318,  791,
+ /*  1700 */   354, 2157,  342, 2197,  355,  792, 2156,   53, 2155,  253,
+ /*  1710 */   705,  794, 2232,  704,  322,  113, 2198,  707, 2200, 2201,
+ /*  1720 */   702,  307,  697,   78, 2215,  416, 1547,  320, 2152, 2285,
+ /*  1730 */   417, 1548,  194,  357, 2281, 2165,  421,  703, 2150,  425,
+ /*  1740 */   327, 2149, 2215,  363,  341,  331,  423,  424, 2147,  429,
+ /*  1750 */  2146,  431, 2145, 2165,  433,  703, 1538, 2126,  197, 2125,
+ /*  1760 */   199, 1506,   79, 1505, 2197, 2107, 2106, 2105, 2104,  445,
+ /*  1770 */   446, 2196, 2103, 2232,  704, 2058,  339, 2198,  707, 2200,
+ /*  1780 */  2201,  702,  700,  697,  688, 2250, 1456, 2057, 2054, 2196,
+ /*  1790 */   201, 2232, 2053,   82,  170, 2198,  707, 2200, 2201,  702,
+ /*  1800 */  2052,  697, 2051, 2215,  206,  204, 2055,  382, 2056, 2050,
+ /*  1810 */  2049, 2047, 2046, 2045, 2165,  467,  703, 2044,  469, 2060,
+ /*  1820 */  2043, 2042, 2197, 2041, 2040, 2039, 2038, 2037, 2036, 2035,
+ /*  1830 */  2034, 2033,  704, 2032, 2031, 2030, 2325, 2029,  208, 2028,
+ /*  1840 */    87, 2197, 2027, 2026, 2025, 2059, 2024, 2023, 2022, 2021,
+ /*  1850 */  2196,  704, 2232, 2020, 1458,  340, 2198,  707, 2200, 2201,
+ /*  1860 */   702, 2215,  697,  499, 2019,  383, 2018, 1868, 1867,  215,
+ /*  1870 */   350, 1866, 2165, 1327,  703, 1323, 1331,  217,  218, 1864,
+ /*  1880 */  2215, 1861, 1860, 1853,  351,  515, 1842,  516, 1818, 1817,
+ /*  1890 */   520, 2165,  519,  703,  517,  521,  523,  525,  527, 1220,
+ /*  1900 */  2124,  524,  220,  182,   76, 2114, 2102, 2101, 2196,  222,
+ /*  1910 */  2232, 2078,   77,  340, 2198,  707, 2200, 2201,  702, 2185,
+ /*  1920 */   697, 2197,  183,  535,  230, 1942,  228, 2196, 1863, 2232,
+ /*  1930 */  1859,  704,  333, 2198,  707, 2200, 2201,  702,  550,  697,
+ /*  1940 */   551,  552, 2197, 1265, 1857,  554,  555,  556, 1855,  558,
+ /*  1950 */   559,  560,  704, 1852,  562,  564, 1837, 1835,  563, 1836,
+ /*  1960 */  2215, 1834, 1814, 1944, 1401, 1400, 1943, 1314, 1312, 1310,
+ /*  1970 */  1309, 2165, 1308,  703, 1307, 1306,  649, 1301, 1850, 1841,
+ /*  1980 */   763, 2215,   63, 1839, 1303,  389,  765,  238, 1813, 1302,
+ /*  1990 */   375,  376, 2165, 1300,  703,  377,  593, 1812, 1811,  596,
+ /*  2000 */   598,   29,  600,  602,  115, 1532, 1534, 2196, 2197, 2232,
+ /*  2010 */  1531, 2123,  171, 2198,  707, 2200, 2201,  702,  701,  697,
+ /*  2020 */  1512, 1536, 1514,   67, 2113,  617, 2100, 2099, 2196,   31,
+ /*  2030 */  2232, 2364,  633,  340, 2198,  707, 2200, 2201,  702,   20,
+ /*  2040 */   697,   17, 1751,   21,  263, 2197,  635, 2215,   23,    6,
+ /*  2050 */    57,   22,    7,  271,  265,  704,  618,  270, 2165, 2186,
+ /*  2060 */   703,   33,   65,  172,  257, 2381, 2197, 1491, 1490,   24,
+ /*  2070 */  1766,  623, 1765,  386, 1770,  269,  704,  625, 1516, 1769,
+ /*  2080 */  1732, 1724,   18,   32, 2215,   95,  164,  387,  397,  283,
+ /*  2090 */  1771, 1772,   59, 1697, 2196, 2165, 2232,  703, 1696,  339,
+ /*  2100 */  2198,  707, 2200, 2201,  702, 2215,  697,  177, 2251,  399,
+ /*  2110 */  2098, 2077,   97,   96, 2076,  289, 2165,   25,  703,  290,
+ /*  2120 */  1730,  292,  297,   68, 2197,   99,  678,  302,   26,   13,
+ /*  2130 */  1572, 2196,  101, 2232,  704,  105,  340, 2198,  707, 2200,
+ /*  2140 */  2201,  702, 1649,  697, 1648, 2197, 1659,  299, 2235,   11,
+ /*  2150 */  1627, 1625, 2196,  696, 2232,  704,   39,  340, 2198,  707,
+ /*  2160 */  2200, 2201,  702, 2215,  697, 1624,  179,   16,   27,  192,
+ /*  2170 */  1596,   58, 1604,   28, 2165, 1386,  703,  706,  710,  400,
+ /*  2180 */   712,  714, 1383,  708, 2215,  715,  717, 1382,  718,  720,
+ /*  2190 */   723, 1379,  721,  726, 1373, 2165,  724,  703, 1371,  727,
+ /*  2200 */  1377, 1376, 1375, 2197, 1362, 1374,  733,  106,  305,  107,
+ /*  2210 */   608, 1395, 2232,  704, 1391,  335, 2198,  707, 2200, 2201,
+ /*  2220 */   702,   75,  697, 1295, 1294, 1293, 1263,  743, 1292, 1290,
+ /*  2230 */  1288, 2196, 1287, 2232, 1286, 2197,  325, 2198,  707, 2200,
+ /*  2240 */  2201,  702, 2215,  697, 1321,  704,  753,  306, 1284, 1281,
+ /*  2250 */  1283, 1282, 1280, 2165, 1279,  703, 1278, 1316, 1318, 1275,
+ /*  2260 */  1274, 1271, 1269, 2197, 1270, 1268, 1858,  773, 1856,  774,
+ /*  2270 */   775, 1854,  777,  704, 2215, 1851,  781,  778,  779,  785,
+ /*  2280 */  1833,  783,  782,  786,  787, 2165,  789,  703, 1210, 2196,
+ /*  2290 */  1810, 2232,  309,  793,  323, 2198,  707, 2200, 2201,  702,
+ /*  2300 */  1558,  697, 2215,  319,  796,  797, 1785, 1785, 1785, 1785,
+ /*  2310 */  1785, 1785, 1785, 2165, 1785,  703, 1785, 1785, 1785, 1785,
+ /*  2320 */  1785, 2196, 1785, 2232, 1785, 1785,  326, 2198,  707, 2200,
+ /*  2330 */  2201,  702, 1785,  697, 2197, 1785, 1785, 1785, 1785, 1785,
+ /*  2340 */  1785, 1785, 1785, 1785,  704, 1785, 1785, 1785, 1785, 2196,
+ /*  2350 */  2197, 2232, 1785, 1785,  332, 2198,  707, 2200, 2201,  702,
+ /*  2360 */   704,  697, 1785, 1785, 1785, 1785, 1785, 1785, 1785, 1785,
+ /*  2370 */  1785, 1785, 1785, 2215, 1785, 1785, 1785, 1785, 1785, 1785,
+ /*  2380 */  1785, 1785, 1785, 1785, 2165, 1785,  703, 1785, 1785, 2215,
+ /*  2390 */  1785, 1785, 1785, 1785, 1785, 1785, 1785, 1785, 1785, 1785,
+ /*  2400 */  2165, 1785,  703, 1785, 1785, 1785, 1785, 1785, 2197, 1785,
+ /*  2410 */  1785, 1785, 1785, 1785, 1785, 1785, 1785, 1785,  704, 1785,
+ /*  2420 */  2196, 1785, 2232, 1785, 1785,  336, 2198,  707, 2200, 2201,
+ /*  2430 */   702, 1785,  697, 1785, 1785, 1785, 2196, 1785, 2232, 2197,
+ /*  2440 */  1785,  328, 2198,  707, 2200, 2201,  702, 2215,  697,  704,
+ /*  2450 */  1785, 1785, 1785, 1785, 1785, 1785, 1785, 1785, 2165, 1785,
+ /*  2460 */   703, 1785, 1785, 1785, 1785, 1785, 2197, 1785, 1785, 1785,
+ /*  2470 */  1785, 1785, 1785, 1785, 1785, 1785,  704, 1785, 2215, 1785,
+ /*  2480 */  1785, 1785, 1785, 1785, 1785, 1785, 1785, 1785, 1785, 2165,
+ /*  2490 */  1785,  703, 1785, 1785, 2196, 1785, 2232, 2197, 1785,  337,
+ /*  2500 */  2198,  707, 2200, 2201,  702, 2215,  697,  704, 1785, 1785,
+ /*  2510 */  1785, 1785, 1785, 1785, 1785, 1785, 2165, 1785,  703, 1785,
+ /*  2520 */  1785, 1785, 1785, 1785, 1785, 2196, 1785, 2232, 1785, 1785,
+ /*  2530 */   329, 2198,  707, 2200, 2201,  702, 2215,  697, 1785, 1785,
+ /*  2540 */  1785, 1785, 1785, 1785, 1785, 1785, 1785, 2165, 1785,  703,
+ /*  2550 */  1785, 1785, 2196, 1785, 2232, 2197, 1785,  338, 2198,  707,
+ /*  2560 */  2200, 2201,  702, 1785,  697,  704, 1785, 1785, 1785, 1785,
+ /*  2570 */  1785, 1785, 1785, 1785, 1785, 1785, 1785, 2197, 1785, 1785,
+ /*  2580 */  1785, 1785, 1785, 2196, 1785, 2232, 1785,  704,  330, 2198,
+ /*  2590 */   707, 2200, 2201,  702, 2215,  697, 1785, 1785, 1785, 1785,
+ /*  2600 */  1785, 1785, 1785, 1785, 1785, 2165, 1785,  703, 1785, 1785,
+ /*  2610 */  1785, 1785, 1785, 1785, 1785, 1785, 2215, 1785, 1785, 1785,
+ /*  2620 */  1785, 1785, 1785, 1785, 1785, 1785, 1785, 2165, 1785,  703,
+ /*  2630 */  1785, 1785, 1785, 1785, 1785, 1785, 1785, 1785, 1785, 1785,
+ /*  2640 */  1785, 2196, 1785, 2232, 2197, 1785,  343, 2198,  707, 2200,
+ /*  2650 */  2201,  702, 1785,  697,  704, 1785, 1785, 1785, 1785, 1785,
+ /*  2660 */  1785, 1785, 1785, 2196, 1785, 2232, 1785, 1785,  344, 2198,
+ /*  2670 */   707, 2200, 2201,  702, 1785,  697, 2197, 1785, 1785, 1785,
+ /*  2680 */  1785, 1785, 1785, 2215, 1785, 1785,  704, 1785, 1785, 1785,
+ /*  2690 */  1785, 1785, 1785, 1785, 2165, 1785,  703, 1785, 1785, 1785,
+ /*  2700 */  1785, 1785, 2197, 1785, 1785, 1785, 1785, 1785, 1785, 1785,
+ /*  2710 */  1785, 1785,  704, 1785, 1785, 2215, 1785, 1785, 1785, 1785,
+ /*  2720 */  1785, 1785, 1785, 1785, 1785, 1785, 2165, 1785,  703, 1785,
+ /*  2730 */  2196, 1785, 2232, 1785, 1785, 2209, 2198,  707, 2200, 2201,
+ /*  2740 */   702, 2215,  697, 1785, 1785, 1785, 1785, 1785, 1785, 1785,
+ /*  2750 */  1785, 1785, 2165, 1785,  703, 1785, 1785, 1785, 1785, 1785,
+ /*  2760 */  1785, 1785, 2196, 1785, 2232, 1785, 1785, 2208, 2198,  707,
+ /*  2770 */  2200, 2201,  702, 1785,  697, 1785, 1785, 1785, 1785, 1785,
+ /*  2780 */  1785, 2197, 1785, 1785, 1785, 1785, 1785, 1785, 2196, 1785,
+ /*  2790 */  2232,  704, 1785, 2207, 2198,  707, 2200, 2201,  702, 1785,
+ /*  2800 */   697, 1785, 2197, 1785, 1785, 1785, 1785, 1785, 1785, 1785,
+ /*  2810 */  1785, 1785,  704, 1785, 1785, 1785, 1785, 1785, 2197, 1785,
+ /*  2820 */  2215, 1785, 1785, 1785, 1785, 1785, 1785, 1785,  704, 1785,
+ /*  2830 */  1785, 2165, 1785,  703, 1785, 1785, 1785, 1785, 1785, 2197,
+ /*  2840 */  1785, 2215, 1785, 1785, 1785, 1785, 1785, 1785, 1785,  704,
+ /*  2850 */  1785, 1785, 2165, 1785,  703, 1785, 1785, 2215, 1785, 1785,
+ /*  2860 */  1785, 1785, 1785, 1785, 1785, 1785, 1785, 2196, 2165, 2232,
+ /*  2870 */   703, 1785,  359, 2198,  707, 2200, 2201,  702, 2215,  697,
+ /*  2880 */  1785, 1785, 1785, 1785, 1785, 1785, 1785, 1785, 2196, 2165,
+ /*  2890 */  2232,  703, 1785,  360, 2198,  707, 2200, 2201,  702, 1785,
+ /*  2900 */   697, 1785, 1785, 1785, 2196, 1785, 2232, 2197, 1785,  356,
+ /*  2910 */  2198,  707, 2200, 2201,  702, 1785,  697,  704, 1785, 1785,
+ /*  2920 */  1785, 1785, 1785, 1785, 1785, 2196, 1785, 2232, 1785, 2197,
+ /*  2930 */   361, 2198,  707, 2200, 2201,  702, 1785,  697, 1785,  704,
+ /*  2940 */  1785, 1785, 1785, 1785, 1785, 1785, 2215, 1785, 1785, 1785,
+ /*  2950 */  1785, 1785, 1785, 1785, 1785, 1785, 1785, 2165, 1785,  703,
+ /*  2960 */  1785, 1785, 1785, 1785, 1785, 1785, 1785, 1785, 2215, 1785,
+ /*  2970 */  1785, 1785, 1785, 1785, 1785, 1785, 1785, 1785, 1785, 2165,
+ /*  2980 */  1785,  703, 1785, 1785, 1785, 1785, 1785, 1785, 1785, 1785,
+ /*  2990 */  1785, 1785, 1785,  705, 1785, 2232, 1785, 1785,  335, 2198,
+ /*  3000 */   707, 2200, 2201,  702, 1785,  697, 1785, 1785, 1785, 1785,
+ /*  3010 */  1785, 1785, 1785, 1785, 1785, 2196, 1785, 2232, 1785, 1785,
+ /*  3020 */   334, 2198,  707, 2200, 2201,  702, 1785,  697,
 };
 static const YYCODETYPE yy_lookahead[] = {
- /*     0 */   341,  345,  367,  346,  348,  349,  411,  350,  359,  352,
- /*    10 */   351,  416,   12,   13,   14,  350,  381,  340,  367,  342,
- /*    20 */    20,   20,   22,    8,    9,  376,  391,   12,   13,   14,
- /*    30 */    15,   16,  381,   33,  385,   35,  447,  448,  379,  393,
- /*    40 */     8,    9,  391,  367,   12,   13,   14,   15,   16,  341,
- /*    50 */   391,  405,  393,  458,  408,  409,  461,  381,  360,  341,
- /*    60 */   395,  351,   62,  411,  429,  430,  368,  391,   68,  351,
- /*    70 */    20,  371,  477,  478,  439,   75,   44,  482,  483,  379,
- /*    80 */   429,    4,  458,   68,   20,  461,  427,  387,  429,  379,
- /*    90 */   439,  432,  433,  434,  435,  436,  437,  379,  439,  391,
- /*   100 */   100,  477,  478,  103,  103,  429,  482,  483,  346,  391,
- /*   110 */   458,  393,  350,  461,  352,  439,   12,   13,  458,   14,
- /*   120 */    43,  461,   45,   46,   20,   20,   22,  112,  341,  477,
- /*   130 */   478,    0,  473,  474,  482,  483,  104,   33,  478,   35,
- /*   140 */   140,  141,  482,  483,  434,  427,  378,  429,   49,   35,
- /*   150 */   432,  433,  434,  435,  436,  437,   57,  439,  390,   60,
- /*   160 */    61,   20,  444,   22,  446,  371,   62,  103,  450,  451,
- /*   170 */   170,  171,   68,  379,    4,   44,  176,  177,  391,   75,
- /*   180 */   386,  387,  464,  345,  169,    0,  348,  349,  394,   75,
- /*   190 */   472,  191,   21,  193,   53,   24,   25,   26,   27,   28,
- /*   200 */    29,   30,   31,   32,  100,  393,   21,  103,  341,   24,
- /*   210 */    25,   26,   27,   28,   29,   30,   31,   32,  351,   20,
- /*   220 */   408,  409,  172,  223,  224,    0,  226,  227,  228,  229,
+ /*     0 */   387,  341,  367,  345,  380,  411,  348,  349,  359,  350,
+ /*    10 */   386,  351,   12,   13,   14,  340,  381,  342,  394,  380,
+ /*    20 */    20,  393,   22,    8,    9,  376,  391,   12,   13,   14,
+ /*    30 */    15,   16,    4,   33,  385,   35,  408,  409,  399,  400,
+ /*    40 */   380,  442,    8,    9,  445,  393,   12,   13,   14,   15,
+ /*    50 */    16,  391,  458,  393,  395,  461,  367,  405,  371,  341,
+ /*    60 */   408,  409,   62,   20,  429,  430,  379,  380,   68,  351,
+ /*    70 */   381,  477,  478,  386,  439,   75,  482,  483,   44,   20,
+ /*    80 */   391,  394,  458,   68,   14,  461,   20,  427,  458,  429,
+ /*    90 */    20,  461,  432,  433,  434,  435,  436,  437,  380,  439,
+ /*   100 */   100,  477,  478,  103,  447,  448,  482,  483,  478,  391,
+ /*   110 */    20,  393,  482,  483,  392,  393,   12,   13,  429,   12,
+ /*   120 */    13,   14,   15,   16,   20,   47,   22,  112,  439,  350,
+ /*   130 */   351,  103,  103,  473,  474,   12,   13,   33,  104,   35,
+ /*   140 */   140,  141,  346,   54,   55,  427,  350,  429,  352,  370,
+ /*   150 */   432,  433,  434,  435,  436,  437,  377,  439,   35,  346,
+ /*   160 */   350,  351,  444,  350,  446,  352,   62,  350,  450,  451,
+ /*   170 */   170,  171,   68,   20,  350,  351,  176,  177,  360,   75,
+ /*   180 */   370,  103,  464,   48,  169,    0,  368,  377,  355,  356,
+ /*   190 */   472,  191,   21,  193,  370,   24,   25,   26,   27,   28,
+ /*   200 */    29,   30,   31,   32,  100,   67,   21,  103,  341,   24,
+ /*   210 */    25,   26,   27,   28,   29,   30,   31,   32,  351,  402,
+ /*   220 */   169,  404,   75,  223,  224,    0,  226,  227,  228,  229,
  /*   230 */   230,  231,  232,  233,  234,  235,  236,  237,  238,  239,
- /*   240 */   240,  241,  242,  243,  140,  141,  379,   20,   20,   24,
- /*   250 */    25,   26,   27,   28,   29,   30,   31,   32,  391,    3,
- /*   260 */   393,  260,  247,  248,  249,  250,  251,  252,  253,  254,
- /*   270 */   255,  256,  257,  103,  170,  171,   20,  379,    8,    9,
- /*   280 */   176,  177,   12,   13,   14,   15,   16,  350,  351,  389,
- /*   290 */    20,  357,  392,  393,  427,  191,  429,  193,  400,  432,
- /*   300 */   433,  434,  435,  436,  437,    0,  439,  370,  374,  442,
- /*   310 */    20,  444,  445,  446,  377,  341,  382,  450,  451,   12,
- /*   320 */    13,   14,   15,   16,  260,  351,  431,  223,  224,   20,
+ /*   240 */   240,  241,  242,  243,  140,  141,   20,  380,   20,   24,
+ /*   250 */    25,   26,   27,   28,   29,   30,   31,   32,  391,   20,
+ /*   260 */   393,   22,  247,  248,  249,  250,  251,  252,  253,  254,
+ /*   270 */   255,  256,  257,  345,  170,  171,  348,  349,    8,    9,
+ /*   280 */   176,  177,   12,   13,   14,   15,   16,  135,  260,  260,
+ /*   290 */    20,  139,   53,   20,  427,  191,  429,  193,  247,  432,
+ /*   300 */   433,  434,  435,  436,  437,  175,  439,  172,  257,  442,
+ /*   310 */   378,  444,  445,  446,  179,  341,  193,  450,  451,   14,
+ /*   320 */    15,   16,  390,  170,  171,  351,  357,  223,  224,  103,
  /*   330 */   226,  227,  228,  229,  230,  231,  232,  233,  234,  235,
  /*   340 */   236,  237,  238,  239,  240,  241,  242,  243,  244,   12,
- /*   350 */    13,   22,  457,  379,  379,  350,  351,   20,    0,   22,
- /*   360 */   104,  100,  350,  351,   35,  391,  103,  393,  140,  141,
- /*   370 */    33,  244,   35,  246,  399,  400,  115,  116,  117,  118,
- /*   380 */   119,  120,  121,  122,  123,  124,   20,  126,  127,  128,
- /*   390 */   129,  130,  131,  132,  350,  351,  350,  351,   20,   62,
- /*   400 */   431,  427,  397,  429,   75,   68,  432,  433,  434,  435,
- /*   410 */   436,  437,   75,  439,   70,   71,   72,  431,  444,   67,
- /*   420 */   446,   77,   78,   79,  450,  451,  457,   83,  172,  100,
- /*   430 */   260,  371,   88,   89,   90,   91,  223,  100,   94,  379,
- /*   440 */   103,  397,  172,  457,    8,    9,  472,  387,   12,   13,
- /*   450 */    14,   15,   16,   12,   13,   14,  341,   20,  350,   22,
- /*   460 */   170,   20,   37,   22,  159,  453,  454,  455,  456,  103,
- /*   470 */   458,  459,   35,  168,   33,  135,   35,  140,  141,  139,
- /*   480 */    20,  392,  393,  270,  271,  272,  273,  274,  275,  276,
- /*   490 */    53,  133,  134,  135,  136,  137,  138,  139,   44,  341,
- /*   500 */   454,  455,  456,   62,  458,  459,  391,  170,  171,  351,
- /*   510 */   402,  353,  404,  176,  177,   67,   75,  357,  140,  141,
- /*   520 */   191,    0,  193,  260,  175,  350,  351,   44,  191,  186,
- /*   530 */   193,  106,  379,  108,  109,  103,  111,  379,  341,  386,
- /*   540 */   200,  100,  382,  203,  103,  370,  206,  394,  208,  391,
- /*   550 */     0,  393,  223,  224,  176,  177,  213,  214,  133,    0,
- /*   560 */   223,  224,  137,  226,  227,  228,  229,  230,  231,  232,
+ /*   350 */    13,  382,  200,  388,  380,  203,  391,   20,  206,   22,
+ /*   360 */   208,  100,   20,   49,   39,  391,   20,  393,  140,  141,
+ /*   370 */    33,   57,   35,  351,   60,   61,  103,  116,  117,  118,
+ /*   380 */   119,  120,  121,  122,  123,  124,  125,    3,  127,  128,
+ /*   390 */   129,  130,  131,  132,  133,  265,  266,  267,  411,   62,
+ /*   400 */   411,  427,  380,  429,   20,   68,  432,  433,  434,  435,
+ /*   410 */   436,  437,   75,  439,   70,   71,   72,   62,  444,  115,
+ /*   420 */   446,   77,   78,   79,  450,  451,   37,   83,   67,  341,
+ /*   430 */   355,  356,   88,   89,   90,   91,  431,  100,   94,  351,
+ /*   440 */   103,  137,  172,  371,    4,  458,  472,  458,  461,  103,
+ /*   450 */   461,  379,  380,   12,   13,   14,  434,  102,  350,   19,
+ /*   460 */   105,   20,  457,   22,  477,  478,  477,  478,  380,  482,
+ /*   470 */   483,  482,  483,   33,   33,  431,   35,  140,  141,  391,
+ /*   480 */   338,  393,  140,  141,  350,  351,    8,    9,  104,   49,
+ /*   490 */    12,   13,   14,   15,   16,  106,   56,  108,  109,  341,
+ /*   500 */   111,  457,   62,   62,  115,  350,  351,  170,  171,  351,
+ /*   510 */   402,  353,  404,  176,  177,  427,   75,  429,  176,  177,
+ /*   520 */   432,  433,  434,  435,  436,  437,  137,  439,  191,  380,
+ /*   530 */   193,  397,  244,  260,  446,  386,  350,  351,  380,  451,
+ /*   540 */    20,  100,  102,  394,  103,  105,  244,    4,  246,  391,
+ /*   550 */    20,  393,  397,  411,  350,  351,  172,  341,  416,   35,
+ /*   560 */   223,  224,  350,  226,  227,  228,  229,  230,  231,  232,
  /*   570 */   233,  234,  235,  236,  237,  238,  239,  240,  241,  242,
- /*   580 */   243,  140,  141,  350,  351,  427,  442,  429,  391,  445,
- /*   590 */   432,  433,  434,  435,  436,  437,  375,  439,   54,   55,
- /*   600 */    12,   13,  444,  370,  446,  350,  351,   20,  450,  451,
- /*   610 */   377,  170,  171,  103,  265,  266,  267,  176,  177,  183,
- /*   620 */    70,   71,   72,   35,  244,  370,   67,   77,   78,   79,
- /*   630 */   170,  171,  191,   83,  193,   84,  350,  341,   88,   89,
- /*   640 */    90,   91,    8,    9,   94,  424,   12,   13,   14,   15,
- /*   650 */    16,  341,  350,  351,  133,  134,  135,  136,  137,  138,
- /*   660 */   139,  351,  133,  353,  223,  224,  137,  226,  227,  228,
+ /*   580 */   243,  140,  141,   21,  259,  427,   43,  429,   45,   46,
+ /*   590 */   432,  433,  434,  435,  436,  437,   34,  439,   36,   75,
+ /*   600 */   458,  397,  444,  461,  446,  341,  260,  391,  450,  451,
+ /*   610 */     0,  170,  171,   20,  402,   22,  404,  176,  177,  477,
+ /*   620 */   478,  364,  365,   22,  482,  483,  103,   33,   35,  114,
+ /*   630 */   350,  351,  191,    0,  193,  367,   35,  350,  351,  453,
+ /*   640 */   454,  455,  456,   49,  458,  459,   53,  134,  341,  381,
+ /*   650 */   370,   57,   58,   59,   60,  391,   62,  370,  351,  391,
+ /*   660 */   353,  183,  364,  365,  223,  224,   75,  226,  227,  228,
  /*   670 */   229,  230,  231,  232,  233,  234,  235,  236,  237,  238,
- /*   680 */   239,  240,  241,  242,  243,   12,   13,  391,  402,  379,
- /*   690 */   404,   22,  260,   20,   22,   22,  145,  146,  379,  397,
- /*   700 */   190,  391,  192,  393,   35,  379,   33,   35,   35,    0,
- /*   710 */     8,    9,  386,  394,   12,   13,   14,   15,   16,  168,
- /*   720 */   394,  285,  114,  350,  355,  356,  388,  350,  351,  391,
- /*   730 */   341,  359,  222,  350,  351,   62,  282,  427,  104,  429,
- /*   740 */   351,   75,  432,  433,  434,  435,  436,  437,   75,  439,
- /*   750 */   134,  135,    2,  370,  444,  139,  446,  385,    8,    9,
- /*   760 */   450,  451,   12,   13,   14,   15,   16,  284,  379,  100,
- /*   770 */   260,  458,  100,  100,  461,  402,  103,  404,  350,  351,
- /*   780 */   391,  193,  393,   75,  458,  350,  351,  461,    3,   12,
- /*   790 */    13,  478,   14,   15,   16,  482,  483,   20,  370,   22,
- /*   800 */   350,  351,   21,  477,  478,  370,  104,   48,  482,  483,
- /*   810 */    33,  341,   35,  140,  141,   34,  427,   36,  429,  114,
- /*   820 */   370,  432,  433,  434,  435,  436,  437,  438,  439,  440,
- /*   830 */   441,  454,  455,  456,  341,  458,  459,  388,  461,   62,
- /*   840 */   391,  341,  341,  170,  171,  350,  351,  350,  351,  176,
- /*   850 */   177,  351,   75,  353,  477,  478,    1,    2,   35,  482,
- /*   860 */   483,  391,    2,  417,  191,  370,  193,  370,    8,    9,
- /*   870 */   350,  351,   12,   13,   14,   15,   16,  100,  341,  379,
- /*   880 */   103,    8,    9,  380,  391,   12,   13,   14,   15,   16,
- /*   890 */   370,  391,  391,  393,  380,  411,  223,  224,   75,  226,
+ /*   680 */   239,  240,  241,  242,  243,   12,   13,  380,   84,  350,
+ /*   690 */   351,  114,  172,   20,  431,   22,  102,  429,  391,  105,
+ /*   700 */   393,  100,  172,   70,   71,   72,   33,  439,   35,  370,
+ /*   710 */    77,   78,   79,  190,  411,  192,   83,  204,  205,  416,
+ /*   720 */   457,   88,   89,   90,   91,    8,    9,   94,  103,   12,
+ /*   730 */    13,   14,   15,   16,  427,   62,  429,  411,  186,  432,
+ /*   740 */   433,  434,  435,  436,  437,  222,  439,   44,   75,  145,
+ /*   750 */   146,  444,  389,  446,  387,  392,  393,  450,  451,  350,
+ /*   760 */   351,  458,  371,  285,  461,  213,  214,  173,  174,  159,
+ /*   770 */   379,  380,  168,  100,  180,  181,  103,  223,  168,  370,
+ /*   780 */   477,  478,    0,  260,  458,  482,  483,  461,  380,   12,
+ /*   790 */    13,  379,  380,  199,  386,  341,  341,   20,  380,   22,
+ /*   800 */   350,  351,  394,  477,  478,  380,  351,  104,  482,  483,
+ /*   810 */    33,  386,   35,  140,  141,  350,  351,   14,  400,  394,
+ /*   820 */   370,  104,    0,   20,  270,  271,  272,  273,  274,  275,
+ /*   830 */   276,  458,  375,  371,  461,  380,  341,  350,  351,   62,
+ /*   840 */     3,  379,  380,  170,  171,  391,  391,  387,  393,  176,
+ /*   850 */   177,  478,   75,    8,    9,  482,  483,   12,   13,   14,
+ /*   860 */    15,   16,    2,  417,  191,    0,  193,  388,    8,    9,
+ /*   870 */   391,  368,   12,   13,   14,   15,   16,  100,  350,  351,
+ /*   880 */   103,  424,  427,  341,  429,  260,  391,  432,  433,  434,
+ /*   890 */   435,  436,  437,  351,  439,  353,  223,  224,  370,  226,
  /*   900 */   227,  228,  229,  230,  231,  232,  233,  234,  235,  236,
- /*   910 */   237,  238,  239,  240,  241,  242,  243,  140,  141,  355,
- /*   920 */   356,  350,  351,  350,  351,  134,  217,  427,  391,  429,
- /*   930 */   368,  172,  432,  433,  434,  435,  436,  437,  179,  439,
- /*   940 */   364,  365,  458,  370,  444,  461,  446,  170,  171,  388,
- /*   950 */   450,  451,  391,  176,  177,  350,  351,  379,  443,  104,
- /*   960 */   445,  477,  478,   33,  386,  380,  482,  483,  191,  380,
- /*   970 */   193,  379,  394,  350,  351,  370,    8,    9,  386,   49,
- /*   980 */    12,   13,   14,   15,   16,   14,  394,   57,   58,   59,
- /*   990 */    60,   20,   62,  370,   39,  204,  205,  443,   62,  445,
+ /*   910 */   237,  238,  239,  240,  241,  242,  243,  140,  141,  454,
+ /*   920 */   455,  456,  380,  458,  459,  359,  443,  357,  445,    4,
+ /*   930 */   350,  351,   67,  391,  443,  393,  445,  115,  342,  484,
+ /*   940 */   485,  454,  455,  456,  374,  458,  459,  170,  171,  104,
+ /*   950 */   370,  385,  382,  176,  177,  486,  134,  135,  136,  137,
+ /*   960 */   138,  139,  350,  351,  388,  350,  351,  391,  191,  427,
+ /*   970 */   193,  429,  401,  170,  432,  433,  434,  435,  436,  437,
+ /*   980 */   475,  439,  370,   14,    2,  370,  444,    0,  446,   20,
+ /*   990 */     8,    9,  450,  451,   12,   13,   14,   15,   16,  217,
  /*  1000 */   223,  224,    0,  226,  227,  228,  229,  230,  231,  232,
  /*  1010 */   233,  234,  235,  236,  237,  238,  239,  240,  241,  242,
- /*  1020 */   243,    4,   18,   18,   20,  454,  455,  456,   23,  458,
- /*  1030 */   459,   27,  102,  380,   30,  105,  371,   33,  102,  350,
- /*  1040 */   351,  105,   37,   38,  379,  172,   41,  350,  351,  379,
- /*  1050 */   364,  365,  387,   49,  380,   51,  386,   52,  169,  370,
- /*  1060 */    56,   20,  341,   20,  394,  280,  411,  370,   63,   64,
- /*  1070 */    65,   66,   70,   71,   72,   73,   74,  342,   76,   77,
+ /*  1020 */   243,  380,   18,   18,   20,  350,  351,  386,   23,  350,
+ /*  1030 */   351,   27,  350,  351,   30,  394,  469,   33,  350,  351,
+ /*  1040 */     1,    2,   37,   38,   20,  370,   41,  350,  351,  370,
+ /*  1050 */    22,  380,  370,   49,  341,   51,  372,   52,  370,  375,
+ /*  1060 */    56,   45,   46,   35,  341,  341,  354,  370,   63,   64,
+ /*  1070 */    65,   66,   70,   71,   72,   73,   74,  341,   76,   77,
  /*  1080 */    78,   79,   80,   81,   82,   83,   84,   85,   86,   87,
- /*  1090 */    88,   89,   90,   91,   92,   93,   94,   95,   96,  350,
- /*  1100 */   351,   14,  372,  173,  174,  375,  102,   20,  103,  380,
- /*  1110 */   180,  181,  391,  458,  350,  351,  461,  366,  114,  370,
- /*  1120 */   369,  133,  134,  135,  136,  137,  138,  139,  411,  199,
- /*  1130 */   350,  351,  477,  478,  370,  341,  247,  482,  483,   45,
- /*  1140 */    46,  170,  341,   14,  258,  259,  257,  142,  144,   20,
- /*  1150 */   370,  147,  148,  149,  150,  151,  152,  153,  154,  155,
+ /*  1090 */    88,   89,   90,   91,   92,   93,   94,   95,   96,  341,
+ /*  1100 */   350,  351,  115,   44,  391,   20,  102,   14,  103,  350,
+ /*  1110 */   351,  134,  135,   20,  391,  391,  139,  280,  114,   22,
+ /*  1120 */   370,  134,  135,  136,  137,  138,  139,  391,  100,  370,
+ /*  1130 */     8,    9,   35,    0,   12,   13,   14,   15,   16,  170,
+ /*  1140 */   350,  351,   42,  104,   44,  341,  341,  142,  144,  391,
+ /*  1150 */   341,  147,  148,  149,  150,  151,  152,  153,  154,  155,
  /*  1160 */   156,  157,  158,  159,  160,  161,  162,  163,  341,  165,
- /*  1170 */   166,  167,  341,  401,  379,  458,   44,   42,  461,   44,
- /*  1180 */   341,  486,  387,  338,  341,  391,    0,  341,  183,  184,
- /*  1190 */   185,  341,  391,  188,  477,  478,  114,  341,  341,  482,
- /*  1200 */   483,  351,   42,  353,   44,  107,  201,  202,  110,  107,
- /*  1210 */    13,  475,  110,  172,  259,  172,  107,  212,  391,  110,
- /*  1220 */   215,  341,  391,  218,  219,  220,  221,  222,   44,  379,
- /*  1230 */   391,  351,   35,  353,  391,   49,  104,  391,   22,   44,
- /*  1240 */   207,  391,  209,  393,   13,    0,  164,  391,  391,   62,
- /*  1250 */   107,   35,  341,  110,    0,   35,  411,  170,    0,  379,
- /*  1260 */    68,  416,  351,  354,  353,  260,   35,   22,    0,   44,
- /*  1270 */   367,  391,   44,  393,   44,  469,   22,  427,  261,  429,
- /*  1280 */    22,   44,  432,  433,  434,  435,  436,  437,  104,  439,
- /*  1290 */   379,   44,  105,  367,  444,   35,  446,  140,  141,  104,
- /*  1300 */   450,  451,  391,  458,  393,  410,  461,  427,   47,  429,
- /*  1310 */    44,   44,  432,  433,  434,  435,  436,  437,   50,  439,
- /*  1320 */     4,   44,  477,  478,  444,   44,  446,  482,  483,  104,
- /*  1330 */   450,  451,  104,   44,  104,   19,    1,    2,  427,   44,
- /*  1340 */   429,  104,  341,  432,  433,  434,  435,  436,  437,   33,
- /*  1350 */   439,  104,  351,   12,   13,  444,  379,  446,  103,   44,
- /*  1360 */   354,  450,  451,   22,  103,   49,   44,   44,  113,   44,
- /*  1370 */   104,  104,   56,  341,   33,  401,   35,  349,   62,   13,
- /*  1380 */   379,  104,   44,  351,   44,  104,   13,  351,  390,  460,
- /*  1390 */   401,  479,  391,  104,  393,  452,  463,  412,  262,  104,
- /*  1400 */    49,   35,   20,   62,  428,  421,  206,  426,   35,  359,
- /*  1410 */   341,  379,  421,  193,  359,  223,   75,  414,  102,  104,
- /*  1420 */   351,  105,  189,  391,   20,  393,  104,  104,  427,  104,
- /*  1430 */   429,  351,   42,  432,  433,  434,  435,  436,  437,   20,
- /*  1440 */   439,  100,  104,  398,  104,  444,  351,  446,  379,  401,
- /*  1450 */   398,  450,  451,  193,  169,  396,   20,  350,  350,  427,
- /*  1460 */   391,  429,  393,  351,  432,  433,  434,  435,  436,  437,
- /*  1470 */   398,  439,  396,  396,  363,  101,  444,   99,  446,  362,
- /*  1480 */   350,   98,  450,  451,  361,   20,   48,  350,  350,  350,
- /*  1490 */   343,  347,  343,  347,  421,   20,  427,  393,  429,  341,
- /*  1500 */   359,  432,  433,  434,  435,  436,  437,  359,  439,  351,
- /*  1510 */    20,  352,   20,  444,  413,  446,  352,  350,  343,  450,
- /*  1520 */   451,  359,  359,  343,  359,  359,  103,  359,  350,  379,
- /*  1530 */   379,  379,  191,  379,  193,  379,  391,  379,  210,  425,
- /*  1540 */   379,  423,  421,  197,  391,  357,  391,  420,  341,  391,
- /*  1550 */   379,  393,  379,  379,  196,  379,  379,  269,  351,  419,
- /*  1560 */   357,  350,  393,  195,  223,  224,  268,  468,  468,  277,
- /*  1570 */   391,  182,  391,  391,  471,  470,  391,  236,  237,  238,
- /*  1580 */   239,  240,  241,  242,  412,  427,  379,  429,  418,  406,
- /*  1590 */   432,  433,  434,  435,  436,  437,  406,  439,  391,  401,
- /*  1600 */   393,  468,  401,  279,  446,  278,  263,  465,  450,  451,
- /*  1610 */   281,  412,  286,  341,  283,  487,  259,   20,  114,  357,
- /*  1620 */   351,  357,  352,  351,   20,  404,  391,  431,  406,  391,
- /*  1630 */   391,  391,  391,  406,  427,  391,  429,  174,  341,  432,
- /*  1640 */   433,  434,  435,  436,  437,  403,  439,  357,  351,  375,
- /*  1650 */   357,  379,  351,  446,  103,  449,  467,  450,  451,  466,
- /*  1660 */   103,  383,  391,  391,  462,  393,  357,  350,  369,   36,
- /*  1670 */   422,  415,  481,  343,  480,  373,  379,  344,  373,  373,
- /*  1680 */   407,  339,  407,    0,    0,    0,   42,    0,  391,   35,
- /*  1690 */   393,   35,  358,  216,   35,   35,  216,    0,   35,  427,
- /*  1700 */    35,  429,  216,  341,  432,  433,  434,  435,  436,  437,
- /*  1710 */     0,  439,  216,  351,    0,   35,    0,   22,  446,    0,
- /*  1720 */   211,   35,  450,  451,  427,    0,  429,  199,    0,  432,
- /*  1730 */   433,  434,  435,  436,  437,  199,  439,  200,  193,  191,
- /*  1740 */     0,  379,    0,    0,    0,  187,  186,    0,   47,    0,
- /*  1750 */     0,    0,  341,  391,   47,  393,    0,   42,    0,    0,
- /*  1760 */     0,    0,  351,   42,   47,    0,    0,  341,    0,    0,
- /*  1770 */     0,  159,   35,    0,  159,    0,    0,  351,  341,    0,
- /*  1780 */     0,  484,  485,    0,    0,    0,    0,    0,  351,  427,
- /*  1790 */   379,  429,   47,    0,  432,  433,  434,  435,  436,  437,
- /*  1800 */     0,  439,  391,    0,  393,  379,    0,    0,  446,    0,
- /*  1810 */   384,    0,    0,  451,    0,    0,  379,  391,    0,  393,
- /*  1820 */     0,  384,    0,    0,   22,    0,    0,    0,  391,   48,
- /*  1830 */   393,  143,    0,    0,    0,   22,   48,    0,  427,   22,
- /*  1840 */   429,  341,    0,  432,  433,  434,  435,  436,  437,    0,
- /*  1850 */   439,  351,   62,  427,   35,  429,   62,  341,  432,  433,
- /*  1860 */   434,  435,  436,  437,  427,  439,  429,  351,    0,  432,
- /*  1870 */   433,  434,  435,  436,  437,   35,  439,   49,   62,  379,
- /*  1880 */    39,    0,   35,   39,   49,  474,    0,   35,   49,   39,
- /*  1890 */     0,  391,   35,  393,    0,  379,   42,   39,   47,   44,
- /*  1900 */    47,   14,    0,   47,   40,   39,    0,  391,    0,  393,
- /*  1910 */     0,   39,    0,  182,    0,    0,    0,   69,    0,   35,
- /*  1920 */   341,   39,   49,    0,   35,   49,    0,  427,   35,  429,
- /*  1930 */   351,    0,  432,  433,  434,  435,  436,  437,   39,  439,
- /*  1940 */    49,    0,   39,  427,   35,  429,  341,   49,  432,  433,
- /*  1950 */   434,  435,  436,  437,    0,  439,  351,  112,  379,   39,
- /*  1960 */     0,    0,    0,  384,    0,   35,   22,    0,   35,  110,
- /*  1970 */   391,   35,  393,   35,   35,   35,  476,   35,   35,   44,
- /*  1980 */    22,  341,   35,   35,  379,   35,    0,   22,    0,   44,
- /*  1990 */    22,  351,    0,   22,   35,    0,  391,   51,  393,    0,
- /*  2000 */     0,  485,   22,   20,   35,   35,  427,  341,  429,   35,
- /*  2010 */    35,  432,  433,  434,  435,  436,  437,  351,  439,  379,
- /*  2020 */    35,  104,  103,    0,  384,  103,   35,   22,  198,    0,
- /*  2030 */   194,  391,  427,  393,  429,  172,   22,  432,  433,  434,
- /*  2040 */   435,  436,  437,  172,  439,  379,  441,    0,  174,    0,
- /*  2050 */   384,  172,  172,  178,    3,  178,   44,  391,  103,  393,
- /*  2060 */   264,   48,   44,   48,   44,   44,  103,  427,   44,  429,
- /*  2070 */   104,  341,  432,  433,  434,  435,  436,  437,    1,  439,
- /*  2080 */   101,  351,  104,   99,   47,  104,   47,    3,  264,   44,
- /*  2090 */   103,   35,  103,  427,  104,  429,   19,  103,  432,  433,
- /*  2100 */   434,  435,  436,  437,  341,  439,  103,  264,  104,  379,
- /*  2110 */    33,  104,   47,   35,  351,   35,   35,   44,   35,  258,
- /*  2120 */    35,  391,   47,  393,    0,    0,   49,   39,  175,  104,
- /*  2130 */   104,  103,    0,  341,   57,   58,   59,   60,   47,   62,
- /*  2140 */   104,  103,  379,  351,  104,  103,  103,  103,   39,  173,
- /*  2150 */    47,  103,   44,  101,  391,  101,  393,  427,  245,  429,
- /*  2160 */     2,   22,  432,  433,  434,  435,  436,  437,  113,  439,
- /*  2170 */   341,  379,  223,  103,   47,  104,  104,  103,   47,  102,
- /*  2180 */   351,   22,  105,  391,   35,  393,   35,   35,   35,  103,
- /*  2190 */   427,  104,  429,  103,  125,  432,  433,  434,  435,  436,
- /*  2200 */   437,  341,  439,  103,   35,  104,  114,  103,  379,  104,
- /*  2210 */   103,  351,   35,   35,  104,  138,  103,  103,  225,  427,
- /*  2220 */   391,  429,  393,  104,  432,  433,  434,  435,  436,  437,
- /*  2230 */   104,  439,  103,  341,  104,   44,  103,  125,  104,  379,
- /*  2240 */   103,  125,  125,  351,  103,  103,   35,  103,   22,   69,
- /*  2250 */   173,  391,   68,  393,   35,   35,  427,  180,  429,   35,
- /*  2260 */    35,  432,  433,  434,  435,  436,  437,   35,  439,   35,
- /*  2270 */    35,  379,   35,   75,   44,   35,  199,   35,   97,   35,
- /*  2280 */    22,   35,   35,  391,   35,  393,   35,  427,   75,  429,
- /*  2290 */    35,   35,  432,  433,  434,  435,  436,  437,  341,  439,
- /*  2300 */    35,   35,   22,   35,    0,   35,   49,    0,  351,   35,
- /*  2310 */    39,   49,   39,    0,   35,   39,   49,    0,   35,  427,
- /*  2320 */     0,  429,   35,  341,  432,  433,  434,  435,  436,  437,
- /*  2330 */    49,  439,   39,  351,   35,    0,  379,   22,   22,   21,
- /*  2340 */   488,   22,   21,   20,  488,  488,  488,  488,  391,  341,
- /*  2350 */   393,  488,  488,  488,  488,  488,  488,  488,  488,  351,
- /*  2360 */   341,  379,  488,  488,  488,  488,  488,  488,  488,  488,
- /*  2370 */   351,  488,  488,  391,  488,  393,  488,  488,  488,  488,
- /*  2380 */   488,  488,  488,  488,  427,  488,  429,  379,  488,  432,
- /*  2390 */   433,  434,  435,  436,  437,  488,  439,  488,  379,  391,
- /*  2400 */   488,  393,  488,  488,  488,  488,  488,  488,  488,  427,
- /*  2410 */   391,  429,  393,  488,  432,  433,  434,  435,  436,  437,
- /*  2420 */   488,  439,  488,  341,  488,  488,  488,  488,  488,  488,
- /*  2430 */   488,  488,  488,  351,  488,  427,  488,  429,  488,  488,
- /*  2440 */   432,  433,  434,  435,  436,  437,  427,  439,  429,  488,
- /*  2450 */   488,  432,  433,  434,  435,  436,  437,  488,  439,  488,
- /*  2460 */   488,  379,  488,  488,  488,  488,  488,  488,  488,  488,
- /*  2470 */   488,  488,  488,  391,  488,  393,  488,  488,  488,  488,
- /*  2480 */   488,  488,  488,  488,  341,  488,  488,  488,  488,  488,
- /*  2490 */   488,  488,  488,  488,  351,  488,  488,  488,  488,  488,
- /*  2500 */   488,  488,  488,  488,  488,  488,  488,  488,  488,  427,
- /*  2510 */   488,  429,  488,  341,  432,  433,  434,  435,  436,  437,
- /*  2520 */   488,  439,  379,  351,  488,  488,  488,  488,  488,  488,
- /*  2530 */   488,  488,  488,  488,  391,  488,  393,  488,  488,  488,
- /*  2540 */   488,  488,  488,  341,  488,  488,  488,  488,  488,  488,
- /*  2550 */   488,  379,  488,  351,  488,  488,  488,  488,  488,  488,
- /*  2560 */   488,  488,  488,  391,  341,  393,  488,  488,  488,  488,
- /*  2570 */   427,  488,  429,  488,  351,  432,  433,  434,  435,  436,
- /*  2580 */   437,  379,  439,  488,  488,  488,  488,  488,  488,  488,
- /*  2590 */   488,  488,  488,  391,  488,  393,  488,  488,  488,  427,
- /*  2600 */   488,  429,  379,  488,  432,  433,  434,  435,  436,  437,
- /*  2610 */   488,  439,  488,  341,  391,  488,  393,  488,  488,  488,
- /*  2620 */   488,  488,  488,  351,  488,  488,  488,  488,  488,  427,
- /*  2630 */   488,  429,  488,  488,  432,  433,  434,  435,  436,  437,
- /*  2640 */   488,  439,  488,  488,  488,  488,  488,  488,  488,  488,
- /*  2650 */   427,  379,  429,  488,  488,  432,  433,  434,  435,  436,
- /*  2660 */   437,  488,  439,  391,  488,  393,  488,  488,  488,  488,
- /*  2670 */   488,  488,  488,  488,  488,  341,  488,  488,  488,  488,
- /*  2680 */   488,  488,  488,  488,  488,  351,  488,  488,  488,  488,
- /*  2690 */   341,  488,  488,  488,  488,  488,  488,  488,  488,  427,
- /*  2700 */   351,  429,  488,  488,  432,  433,  434,  435,  436,  437,
- /*  2710 */   488,  439,  341,  379,  488,  488,  488,  488,  488,  488,
- /*  2720 */   488,  488,  351,  488,  488,  391,  488,  393,  379,  488,
- /*  2730 */   488,  488,  488,  488,  488,  488,  488,  488,  488,  488,
- /*  2740 */   391,  341,  393,  488,  488,  488,  488,  488,  488,  488,
- /*  2750 */   379,  351,  488,  488,  488,  488,  488,  488,  488,  488,
- /*  2760 */   488,  427,  391,  429,  393,  488,  432,  433,  434,  435,
- /*  2770 */   436,  437,  488,  439,  488,  488,  427,  488,  429,  379,
- /*  2780 */   488,  432,  433,  434,  435,  436,  437,  488,  439,  488,
- /*  2790 */   488,  391,  488,  393,  488,  488,  488,  488,  427,  488,
- /*  2800 */   429,  488,  488,  432,  433,  434,  435,  436,  437,  488,
- /*  2810 */   439,  488,  488,  488,  488,  341,  488,  488,  488,  488,
- /*  2820 */   488,  488,  488,  488,  488,  351,  488,  427,  488,  429,
- /*  2830 */   488,  488,  432,  433,  434,  435,  436,  437,  488,  439,
- /*  2840 */   488,  488,  488,  488,  488,  488,  488,  488,  488,  488,
- /*  2850 */   488,  488,  488,  379,  488,  488,  488,  488,  488,  488,
- /*  2860 */   488,  488,  488,  488,  341,  391,  488,  393,  488,  488,
- /*  2870 */   488,  488,  488,  488,  351,  488,  488,  488,  488,  488,
- /*  2880 */   488,  488,  488,  488,  488,  488,  488,  488,  488,  488,
- /*  2890 */   488,  488,  488,  488,  488,  488,  488,  488,  488,  488,
- /*  2900 */   488,  427,  379,  429,  488,  488,  432,  433,  434,  435,
- /*  2910 */   436,  437,  488,  439,  391,  488,  393,  488,  488,  488,
- /*  2920 */   488,  488,  488,  488,  488,  488,  488,  488,  488,  488,
- /*  2930 */   488,  488,  488,  488,  488,  488,  488,  488,  488,  488,
- /*  2940 */   488,  488,  488,  488,  488,  488,  488,  488,  488,  488,
- /*  2950 */   427,  488,  429,  488,  488,  432,  433,  434,  435,  436,
- /*  2960 */   437,  488,  439,  338,  338,  338,  338,  338,  338,  338,
- /*  2970 */   338,  338,  338,  338,  338,  338,  338,  338,  338,  338,
- /*  2980 */   338,  338,  338,  338,  338,  338,  338,  338,  338,  338,
- /*  2990 */   338,  338,  338,  338,  338,  338,  338,  338,  338,  338,
- /*  3000 */   338,  338,  338,  338,  338,  338,  338,  338,  338,  338,
- /*  3010 */   338,  338,  338,  338,  338,  338,  338,  338,  338,  338,
- /*  3020 */   338,  338,  338,  338,  338,  338,  338,  338,  338,  338,
+ /*  1170 */   166,  167,   75,    8,    9,  379,  380,   12,   13,   14,
+ /*  1180 */    15,   16,   49,  341,  341,  341,  261,  341,  183,  184,
+ /*  1190 */   185,  341,  115,  188,  170,  391,  391,  100,  379,  380,
+ /*  1200 */   391,  351,  366,  353,  341,  369,  201,  202,  379,  380,
+ /*  1210 */    44,  134,  135,  136,  137,  138,  139,  212,  391,  341,
+ /*  1220 */   215,  258,  259,  218,  219,  220,  221,  222,  341,  351,
+ /*  1230 */   380,  353,    0,  391,  391,  391,  458,  391,   44,  461,
+ /*  1240 */    22,  391,  114,  393,  454,  455,  456,  107,  458,  459,
+ /*  1250 */   110,  461,  341,   35,  391,  477,  478,  172,  380,   13,
+ /*  1260 */   482,  483,  351,   44,  353,  260,  380,  477,  478,  391,
+ /*  1270 */   104,  393,  482,  483,  379,  380,   44,  427,  391,  429,
+ /*  1280 */   394,   35,  432,  433,  434,  435,  436,  437,  191,  439,
+ /*  1290 */   193,  380,  164,   62,  444,   42,  446,   44,  104,   44,
+ /*  1300 */   450,  451,  391,  107,  393,  427,  110,  429,   13,    0,
+ /*  1310 */   432,  433,  434,  435,  436,  437,  107,  439,   44,  110,
+ /*  1320 */   223,  224,  444,  107,  446,   44,  110,    0,  450,  451,
+ /*  1330 */    35,   22,  207,   44,  209,   44,  105,  172,  427,   68,
+ /*  1340 */   429,  282,  341,  432,  433,  434,  435,  436,  437,   22,
+ /*  1350 */   439,    0,  351,   12,   13,  444,   35,  446,   44,  104,
+ /*  1360 */     0,  450,  451,   22,  140,  141,   44,   44,   35,   44,
+ /*  1370 */   341,    1,    2,   22,   33,  367,   35,  367,  104,   44,
+ /*  1380 */   351,  380,   35,   44,   44,  104,   44,  354,  103,   44,
+ /*  1390 */    44,  410,  391,  104,  393,  104,  401,   44,  113,   44,
+ /*  1400 */   349,  351,   13,   62,  390,  460,  479,  401,   75,  380,
+ /*  1410 */    50,  452,  463,  262,   49,  412,   75,  428,  104,   20,
+ /*  1420 */   391,  421,  393,  206,   35,  426,  104,  104,  427,  104,
+ /*  1430 */   429,  359,  341,  432,  433,  434,  435,  436,  437,  104,
+ /*  1440 */   439,  100,  351,  104,  104,  444,  104,  446,   13,  104,
+ /*  1450 */   104,  450,  451,  421,  359,  189,  427,  104,  429,  104,
+ /*  1460 */   414,  432,  433,  434,  435,  436,  437,   20,  439,  351,
+ /*  1470 */    35,  380,   42,  444,  398,  446,   20,  351,  396,  450,
+ /*  1480 */   451,  401,  391,   20,  393,  398,  169,  350,  398,  351,
+ /*  1490 */   396,  350,  396,  101,  223,  363,   99,  362,  350,  341,
+ /*  1500 */    98,   48,  350,  284,  361,  350,  350,   20,  347,  351,
+ /*  1510 */   343,    1,  343,  421,  193,  347,  359,   20,  427,  359,
+ /*  1520 */   429,   20,  393,  432,  433,  434,  435,  436,  437,   19,
+ /*  1530 */   439,  352,  191,   20,  193,  444,  413,  446,  380,  359,
+ /*  1540 */   193,  450,  451,   33,  352,  359,  359,  359,  350,  391,
+ /*  1550 */   359,  393,  380,  343,  380,  380,  380,  380,  380,   49,
+ /*  1560 */   210,  341,  380,  350,  223,  224,  343,   57,   58,   59,
+ /*  1570 */    60,  351,   62,  103,  391,  391,  391,  236,  237,  238,
+ /*  1580 */   239,  240,  241,  242,  425,  427,  423,  429,  197,  196,
+ /*  1590 */   432,  433,  434,  435,  436,  437,  357,  439,  393,  357,
+ /*  1600 */   380,  195,  421,  401,  446,  412,  350,  418,  450,  451,
+ /*  1610 */   420,  391,  102,  393,  419,  105,  401,  391,  269,  391,
+ /*  1620 */   268,  468,  468,  182,  341,  391,  391,  406,  406,  263,
+ /*  1630 */   481,  277,  468,  471,  351,  279,  278,  412,  467,  466,
+ /*  1640 */   470,  259,  283,  286,  281,  351,   20,  427,  138,  429,
+ /*  1650 */   114,  352,  432,  433,  434,  435,  436,  437,  431,  439,
+ /*  1660 */   357,  357,  465,  380,   20,  462,  446,  404,  406,  391,
+ /*  1670 */   450,  451,  174,  391,  391,  391,  393,  391,  391,  406,
+ /*  1680 */   480,  391,  403,  173,  103,  341,  487,  357,  375,  357,
+ /*  1690 */   180,  103,  449,  383,  351,  351,  391,  369,  350,   36,
+ /*  1700 */   407,    0,  422,  341,  407,  344,    0,  415,    0,  199,
+ /*  1710 */   427,  343,  429,  351,  339,  432,  433,  434,  435,  436,
+ /*  1720 */   437,  357,  439,   42,  380,   35,   35,  358,    0,  446,
+ /*  1730 */   216,   35,   35,  450,  451,  391,  216,  393,    0,  216,
+ /*  1740 */   373,    0,  380,  216,  373,  373,   35,   35,    0,   35,
+ /*  1750 */     0,   22,    0,  391,   35,  393,  211,    0,  199,    0,
+ /*  1760 */   199,  193,  200,  191,  341,    0,    0,    0,    0,  187,
+ /*  1770 */   186,  427,    0,  429,  351,    0,  432,  433,  434,  435,
+ /*  1780 */   436,  437,  438,  439,  440,  441,   47,    0,    0,  427,
+ /*  1790 */    47,  429,    0,   42,  432,  433,  434,  435,  436,  437,
+ /*  1800 */     0,  439,    0,  380,  159,   47,    0,  384,    0,    0,
+ /*  1810 */     0,    0,    0,    0,  391,   35,  393,    0,  159,    0,
+ /*  1820 */     0,    0,  341,    0,    0,    0,    0,    0,    0,    0,
+ /*  1830 */     0,    0,  351,    0,    0,    0,  474,    0,   47,    0,
+ /*  1840 */    42,  341,    0,    0,    0,    0,    0,    0,    0,    0,
+ /*  1850 */   427,  351,  429,    0,   22,  432,  433,  434,  435,  436,
+ /*  1860 */   437,  380,  439,  143,    0,  384,    0,    0,    0,   62,
+ /*  1870 */    48,    0,  391,   22,  393,   35,   22,   62,   62,    0,
+ /*  1880 */   380,    0,    0,    0,   48,   35,    0,   49,    0,    0,
+ /*  1890 */    49,  391,   35,  393,   39,   39,   35,   39,   35,   14,
+ /*  1900 */     0,   49,   42,   44,   39,    0,    0,    0,  427,   40,
+ /*  1910 */   429,    0,   39,  432,  433,  434,  435,  436,  437,   47,
+ /*  1920 */   439,  341,   47,   47,  182,    0,   39,  427,    0,  429,
+ /*  1930 */     0,  351,  432,  433,  434,  435,  436,  437,   35,  439,
+ /*  1940 */    49,   39,  341,   69,    0,   35,   49,   39,    0,   35,
+ /*  1950 */    49,   39,  351,    0,   35,   39,    0,    0,   49,    0,
+ /*  1960 */   380,    0,    0,    0,   35,   22,    0,   35,   35,   35,
+ /*  1970 */    35,  391,   35,  393,   35,   35,  476,   22,    0,    0,
+ /*  1980 */    44,  380,  112,    0,   35,  384,   44,  110,    0,   35,
+ /*  1990 */    22,   22,  391,   35,  393,   22,   51,    0,    0,   35,
+ /*  2000 */    35,  103,   35,   22,   20,   35,   35,  427,  341,  429,
+ /*  2010 */    35,    0,  432,  433,  434,  435,  436,  437,  351,  439,
+ /*  2020 */    35,  104,   22,  103,    0,   22,    0,    0,  427,  103,
+ /*  2030 */   429,    3,  101,  432,  433,  434,  435,  436,  437,   44,
+ /*  2040 */   439,  264,  104,   44,  103,  341,   99,  380,  264,   48,
+ /*  2050 */   172,   44,   48,   47,  104,  351,  172,   44,  391,   47,
+ /*  2060 */   393,   44,    3,  103,  174,  485,  341,  172,  172,   44,
+ /*  2070 */    35,  178,   35,   35,   35,  103,  351,  178,  198,   35,
+ /*  2080 */   104,  104,  264,  103,  380,  103,  194,   35,  384,   47,
+ /*  2090 */   104,  104,   44,  104,  427,  391,  429,  393,  104,  432,
+ /*  2100 */   433,  434,  435,  436,  437,  380,  439,   47,  441,  384,
+ /*  2110 */     0,    0,   39,  103,    0,   47,  391,  103,  393,  104,
+ /*  2120 */   104,  103,  103,  103,  341,   39,  175,   47,   44,    2,
+ /*  2130 */    22,  427,  103,  429,  351,  113,  432,  433,  434,  435,
+ /*  2140 */   436,  437,  101,  439,  101,  341,  223,  173,  103,  245,
+ /*  2150 */   104,  104,  427,  103,  429,  351,  103,  432,  433,  434,
+ /*  2160 */   435,  436,  437,  380,  439,  104,   47,  103,  103,   47,
+ /*  2170 */   104,  258,   22,  103,  391,  104,  393,  225,   35,   35,
+ /*  2180 */   103,   35,  104,  114,  380,  103,   35,  104,  103,   35,
+ /*  2190 */    35,  104,  103,   35,  104,  391,  103,  393,  104,  103,
+ /*  2200 */   126,  126,  126,  341,   22,  126,  115,  103,   44,  103,
+ /*  2210 */   427,   35,  429,  351,   22,  432,  433,  434,  435,  436,
+ /*  2220 */   437,  103,  439,   35,   35,   35,   69,   68,   35,   35,
+ /*  2230 */    35,  427,   35,  429,   35,  341,  432,  433,  434,  435,
+ /*  2240 */   436,  437,  380,  439,   75,  351,   97,   44,   35,   22,
+ /*  2250 */    35,   35,   35,  391,   35,  393,   35,   35,   75,   35,
+ /*  2260 */    35,   35,   22,  341,   35,   35,    0,   35,    0,   49,
+ /*  2270 */    39,    0,   35,  351,  380,    0,   35,   49,   39,   35,
+ /*  2280 */     0,   39,   49,   49,   39,  391,   35,  393,   35,  427,
+ /*  2290 */     0,  429,   22,   21,  432,  433,  434,  435,  436,  437,
+ /*  2300 */    22,  439,  380,   22,   21,   20,  488,  488,  488,  488,
+ /*  2310 */   488,  488,  488,  391,  488,  393,  488,  488,  488,  488,
+ /*  2320 */   488,  427,  488,  429,  488,  488,  432,  433,  434,  435,
+ /*  2330 */   436,  437,  488,  439,  341,  488,  488,  488,  488,  488,
+ /*  2340 */   488,  488,  488,  488,  351,  488,  488,  488,  488,  427,
+ /*  2350 */   341,  429,  488,  488,  432,  433,  434,  435,  436,  437,
+ /*  2360 */   351,  439,  488,  488,  488,  488,  488,  488,  488,  488,
+ /*  2370 */   488,  488,  488,  380,  488,  488,  488,  488,  488,  488,
+ /*  2380 */   488,  488,  488,  488,  391,  488,  393,  488,  488,  380,
+ /*  2390 */   488,  488,  488,  488,  488,  488,  488,  488,  488,  488,
+ /*  2400 */   391,  488,  393,  488,  488,  488,  488,  488,  341,  488,
+ /*  2410 */   488,  488,  488,  488,  488,  488,  488,  488,  351,  488,
+ /*  2420 */   427,  488,  429,  488,  488,  432,  433,  434,  435,  436,
+ /*  2430 */   437,  488,  439,  488,  488,  488,  427,  488,  429,  341,
+ /*  2440 */   488,  432,  433,  434,  435,  436,  437,  380,  439,  351,
+ /*  2450 */   488,  488,  488,  488,  488,  488,  488,  488,  391,  488,
+ /*  2460 */   393,  488,  488,  488,  488,  488,  341,  488,  488,  488,
+ /*  2470 */   488,  488,  488,  488,  488,  488,  351,  488,  380,  488,
+ /*  2480 */   488,  488,  488,  488,  488,  488,  488,  488,  488,  391,
+ /*  2490 */   488,  393,  488,  488,  427,  488,  429,  341,  488,  432,
+ /*  2500 */   433,  434,  435,  436,  437,  380,  439,  351,  488,  488,
+ /*  2510 */   488,  488,  488,  488,  488,  488,  391,  488,  393,  488,
+ /*  2520 */   488,  488,  488,  488,  488,  427,  488,  429,  488,  488,
+ /*  2530 */   432,  433,  434,  435,  436,  437,  380,  439,  488,  488,
+ /*  2540 */   488,  488,  488,  488,  488,  488,  488,  391,  488,  393,
+ /*  2550 */   488,  488,  427,  488,  429,  341,  488,  432,  433,  434,
+ /*  2560 */   435,  436,  437,  488,  439,  351,  488,  488,  488,  488,
+ /*  2570 */   488,  488,  488,  488,  488,  488,  488,  341,  488,  488,
+ /*  2580 */   488,  488,  488,  427,  488,  429,  488,  351,  432,  433,
+ /*  2590 */   434,  435,  436,  437,  380,  439,  488,  488,  488,  488,
+ /*  2600 */   488,  488,  488,  488,  488,  391,  488,  393,  488,  488,
+ /*  2610 */   488,  488,  488,  488,  488,  488,  380,  488,  488,  488,
+ /*  2620 */   488,  488,  488,  488,  488,  488,  488,  391,  488,  393,
+ /*  2630 */   488,  488,  488,  488,  488,  488,  488,  488,  488,  488,
+ /*  2640 */   488,  427,  488,  429,  341,  488,  432,  433,  434,  435,
+ /*  2650 */   436,  437,  488,  439,  351,  488,  488,  488,  488,  488,
+ /*  2660 */   488,  488,  488,  427,  488,  429,  488,  488,  432,  433,
+ /*  2670 */   434,  435,  436,  437,  488,  439,  341,  488,  488,  488,
+ /*  2680 */   488,  488,  488,  380,  488,  488,  351,  488,  488,  488,
+ /*  2690 */   488,  488,  488,  488,  391,  488,  393,  488,  488,  488,
+ /*  2700 */   488,  488,  341,  488,  488,  488,  488,  488,  488,  488,
+ /*  2710 */   488,  488,  351,  488,  488,  380,  488,  488,  488,  488,
+ /*  2720 */   488,  488,  488,  488,  488,  488,  391,  488,  393,  488,
+ /*  2730 */   427,  488,  429,  488,  488,  432,  433,  434,  435,  436,
+ /*  2740 */   437,  380,  439,  488,  488,  488,  488,  488,  488,  488,
+ /*  2750 */   488,  488,  391,  488,  393,  488,  488,  488,  488,  488,
+ /*  2760 */   488,  488,  427,  488,  429,  488,  488,  432,  433,  434,
+ /*  2770 */   435,  436,  437,  488,  439,  488,  488,  488,  488,  488,
+ /*  2780 */   488,  341,  488,  488,  488,  488,  488,  488,  427,  488,
+ /*  2790 */   429,  351,  488,  432,  433,  434,  435,  436,  437,  488,
+ /*  2800 */   439,  488,  341,  488,  488,  488,  488,  488,  488,  488,
+ /*  2810 */   488,  488,  351,  488,  488,  488,  488,  488,  341,  488,
+ /*  2820 */   380,  488,  488,  488,  488,  488,  488,  488,  351,  488,
+ /*  2830 */   488,  391,  488,  393,  488,  488,  488,  488,  488,  341,
+ /*  2840 */   488,  380,  488,  488,  488,  488,  488,  488,  488,  351,
+ /*  2850 */   488,  488,  391,  488,  393,  488,  488,  380,  488,  488,
+ /*  2860 */   488,  488,  488,  488,  488,  488,  488,  427,  391,  429,
+ /*  2870 */   393,  488,  432,  433,  434,  435,  436,  437,  380,  439,
+ /*  2880 */   488,  488,  488,  488,  488,  488,  488,  488,  427,  391,
+ /*  2890 */   429,  393,  488,  432,  433,  434,  435,  436,  437,  488,
+ /*  2900 */   439,  488,  488,  488,  427,  488,  429,  341,  488,  432,
+ /*  2910 */   433,  434,  435,  436,  437,  488,  439,  351,  488,  488,
+ /*  2920 */   488,  488,  488,  488,  488,  427,  488,  429,  488,  341,
+ /*  2930 */   432,  433,  434,  435,  436,  437,  488,  439,  488,  351,
+ /*  2940 */   488,  488,  488,  488,  488,  488,  380,  488,  488,  488,
+ /*  2950 */   488,  488,  488,  488,  488,  488,  488,  391,  488,  393,
+ /*  2960 */   488,  488,  488,  488,  488,  488,  488,  488,  380,  488,
+ /*  2970 */   488,  488,  488,  488,  488,  488,  488,  488,  488,  391,
+ /*  2980 */   488,  393,  488,  488,  488,  488,  488,  488,  488,  488,
+ /*  2990 */   488,  488,  488,  427,  488,  429,  488,  488,  432,  433,
+ /*  3000 */   434,  435,  436,  437,  488,  439,  488,  488,  488,  488,
+ /*  3010 */   488,  488,  488,  488,  488,  427,  488,  429,  488,  488,
+ /*  3020 */   432,  433,  434,  435,  436,  437,  488,  439,  338,  338,
  /*  3030 */   338,  338,  338,  338,  338,  338,  338,  338,  338,  338,
  /*  3040 */   338,  338,  338,  338,  338,  338,  338,  338,  338,  338,
  /*  3050 */   338,  338,  338,  338,  338,  338,  338,  338,  338,  338,
@@ -1188,214 +1194,217 @@ static const YYCODETYPE yy_lookahead[] = {
  /*  3270 */   338,  338,  338,  338,  338,  338,  338,  338,  338,  338,
  /*  3280 */   338,  338,  338,  338,  338,  338,  338,  338,  338,  338,
  /*  3290 */   338,  338,  338,  338,  338,  338,  338,  338,  338,  338,
- /*  3300 */   338,
+ /*  3300 */   338,  338,  338,  338,  338,  338,  338,  338,  338,  338,
+ /*  3310 */   338,  338,  338,  338,  338,  338,  338,  338,  338,  338,
+ /*  3320 */   338,  338,  338,  338,  338,  338,  338,  338,  338,  338,
+ /*  3330 */   338,  338,  338,  338,  338,  338,  338,  338,  338,  338,
+ /*  3340 */   338,  338,  338,  338,  338,  338,  338,  338,  338,  338,
+ /*  3350 */   338,  338,  338,  338,  338,  338,  338,  338,  338,  338,
+ /*  3360 */   338,  338,  338,  338,  338,  338,
 };
-#define YY_SHIFT_COUNT    (800)
+#define YY_SHIFT_COUNT    (798)
 #define YY_SHIFT_MIN      (0)
-#define YY_SHIFT_MAX      (2335)
+#define YY_SHIFT_MAX      (2290)
 static const unsigned short int yy_shift_ofst[] = {
  /*     0 */  1005,    0,  104,    0,  337,  337,  337,  337,  337,  337,
  /*    10 */   337,  337,  337,  337,  337,  337,  441,  673,  673,  777,
  /*    20 */   673,  673,  673,  673,  673,  673,  673,  673,  673,  673,
  /*    30 */   673,  673,  673,  673,  673,  673,  673,  673,  673,  673,
  /*    40 */   673,  673,  673,  673,  673,  673,  673,  673,  673,  673,
- /*    50 */   673,    1,   64,  510,  366,  263,  432,  263,  366,  366,
- /*    60 */   263, 1341,  263, 1341, 1341,  170,  263,  199,  378,  227,
- /*    70 */   227,  378,   77,   77,  460,  228,  105,  105,  227,  227,
- /*    80 */   227,  227,  227,  227,  227,  227,  227,  227,  309,  227,
- /*    90 */   227,  352,  199,  227,  227,  587,  199,  227,  309,  227,
- /*   100 */   309,  199,  227,  227,  199,  227,  199,  199,  199,  227,
- /*   110 */   448, 1004,   15,   15,  344,  171,  329,  329,  329,  329,
- /*   120 */   329,  329,  329,  329,  329,  329,  329,  329,  329,  329,
- /*   130 */   329,  329,  329,  329,  329,  425,  256,  460,  228,  544,
- /*   140 */   544,  114,   50,   50,   50,  559,  127,  127,  114,  352,
- /*   150 */   608,  380,  199,  666,  199,  666,  666,  705,  708,  261,
- /*   160 */   261,  261,  261,  261,  261,  261,  261, 2077,  550,  185,
- /*   170 */   270,  436,  213,  437,  349,  588,  588,  971,  759, 1087,
- /*   180 */   141, 1041, 1094, 1129,  529, 1043,  886,  955,  785,  886,
- /*   190 */  1135, 1017,  290, 1136, 1351, 1382, 1200,  352, 1382,  352,
- /*   200 */  1233, 1404, 1390, 1419, 1404, 1390, 1285, 1436, 1404, 1436,
- /*   210 */  1390, 1285, 1285, 1374, 1378, 1436, 1383, 1436, 1436, 1436,
- /*   220 */  1465, 1438, 1465, 1438, 1382,  352, 1475,  352, 1490, 1492,
- /*   230 */   352, 1490,  352,  352,  352, 1436,  352, 1465,  199,  199,
- /*   240 */   199,  199,  199,  199,  199,  199,  199,  199,  199, 1436,
- /*   250 */  1465,  666,  666,  666, 1328, 1423, 1382,  448, 1346, 1358,
- /*   260 */  1475,  448, 1368, 1136, 1436, 1419, 1419,  666, 1288, 1298,
- /*   270 */   666, 1288, 1298,  666,  666,  199, 1292, 1389, 1288, 1324,
- /*   280 */  1327, 1343, 1136, 1326, 1331, 1329, 1357, 1404, 1597, 1504,
- /*   290 */  1490,  448,  448, 1604, 1298,  666,  666,  666,  666,  666,
- /*   300 */  1298,  666, 1463,  448,  705,  448, 1404, 1551, 1557,  666,
- /*   310 */   708, 1436,  448, 1633, 1465, 2963, 2963, 2963, 2963, 2963,
- /*   320 */  2963, 2963, 2963, 2963, 1002,  930,  225,   32, 1316,  634,
- /*   330 */   702,  358,  750,  860,  873,  521,  968,  968,  968,  968,
- /*   340 */   968,  968,  968,  968,  968,  988,  340,  307,  307,  551,
- /*   350 */    99,  343,  305,  936,  669,  672,  781,  791,  616,  616,
- /*   360 */   778,  855,  889,  778,  778,  778, 1186,  709, 1132, 1216,
- /*   370 */  1160, 1082,  131, 1098, 1102, 1109, 1143, 1197, 1231, 1245,
- /*   380 */  1254, 1258, 1033, 1184, 1195, 1187, 1225, 1228, 1230, 1157,
- /*   390 */   454,  483, 1237, 1247, 1266, 1267, 1277, 1281, 1335, 1289,
- /*   400 */  1192, 1295, 1261, 1315, 1322, 1323, 1325, 1338, 1340, 1255,
- /*   410 */  1220, 1260, 1366, 1373,  823, 1268, 1683, 1684, 1685, 1644,
- /*   420 */  1687, 1654, 1477, 1656, 1659, 1660, 1480, 1697, 1663, 1665,
- /*   430 */  1486, 1710, 1496, 1714, 1680, 1716, 1695, 1719, 1686, 1509,
- /*   440 */  1725, 1528, 1728, 1536, 1537, 1545, 1548, 1740, 1742, 1743,
- /*   450 */  1558, 1560, 1744, 1747, 1701, 1749, 1750, 1751, 1707, 1756,
- /*   460 */  1715, 1758, 1759, 1760, 1717, 1761, 1765, 1766, 1768, 1769,
- /*   470 */  1770, 1612, 1737, 1773, 1615, 1775, 1776, 1779, 1780, 1783,
- /*   480 */  1784, 1785, 1786, 1787, 1800, 1803, 1806, 1807, 1809, 1811,
- /*   490 */  1812, 1745, 1793, 1721, 1814, 1815, 1818, 1820, 1822, 1823,
- /*   500 */  1802, 1825, 1826, 1827, 1688, 1832, 1833, 1813, 1781, 1817,
- /*   510 */  1788, 1834, 1790, 1819, 1837, 1794, 1842, 1816, 1849, 1868,
- /*   520 */  1840, 1828, 1841, 1881, 1847, 1835, 1844, 1886, 1852, 1839,
- /*   530 */  1850, 1890, 1857, 1894, 1854, 1858, 1855, 1851, 1853, 1887,
- /*   540 */  1856, 1902, 1864, 1866, 1906, 1908, 1910, 1872, 1731, 1912,
- /*   550 */  1914, 1915, 1848, 1916, 1918, 1884, 1873, 1882, 1923, 1889,
- /*   560 */  1876, 1899, 1926, 1893, 1891, 1903, 1931, 1909, 1898, 1920,
- /*   570 */  1941, 1954, 1960, 1961, 1962, 1964, 1845, 1859, 1930, 1944,
- /*   580 */  1967, 1933, 1936, 1938, 1939, 1940, 1942, 1943, 1935, 1945,
- /*   590 */  1947, 1948, 1958, 1950, 1986, 1965, 1988, 1968, 1946, 1992,
- /*   600 */  1971, 1959, 1995, 1969, 1999, 1970, 2000, 1980, 1983, 1974,
- /*   610 */  1975, 1985, 1917, 1919, 2023, 1863, 1922, 1830, 1991, 2005,
- /*   620 */  2029, 1836, 2014, 1871, 1874, 2047, 2049, 1879, 1875, 1880,
- /*   630 */  1877, 2051, 2012, 1796, 1955, 1966, 1963, 2013, 1979, 2015,
- /*   640 */  1984, 1978, 2018, 2020, 1981, 1987, 1989, 1994, 1990, 2021,
- /*   650 */  2037, 2039, 2003, 2024, 1824, 2004, 2007, 2084, 2045, 1843,
- /*   660 */  2056, 2078, 2080, 2081, 2083, 2085, 2025, 2026, 2065, 1861,
- /*   670 */  2073, 2075, 2124, 2125, 2028, 2088, 1851, 2091, 2038, 2036,
- /*   680 */  2040, 2042, 2043, 1953, 2044, 2132, 2109, 1976, 2048, 2055,
- /*   690 */  1851, 2103, 2108, 2052, 1913, 2054, 2158, 2139, 1949, 2070,
- /*   700 */  2071, 2074, 2072, 2086, 2087, 2127, 2090, 2100, 2131, 2101,
- /*   710 */  2159, 1993, 2104, 2092, 2105, 2149, 2151, 2107, 2110, 2152,
- /*   720 */  2113, 2119, 2153, 2114, 2126, 2169, 2129, 2130, 2177, 2133,
- /*   730 */  2134, 2178, 2137, 2069, 2112, 2116, 2117, 2141, 2191, 2142,
- /*   740 */  2211, 2144, 2191, 2191, 2226, 2180, 2184, 2219, 2220, 2224,
- /*   750 */  2225, 2232, 2234, 2235, 2237, 2198, 2181, 2230, 2240, 2242,
- /*   760 */  2244, 2258, 2246, 2247, 2249, 2213, 1935, 2251, 1945, 2255,
- /*   770 */  2256, 2265, 2266, 2280, 2268, 2304, 2270, 2257, 2271, 2307,
- /*   780 */  2274, 2262, 2273, 2313, 2279, 2267, 2276, 2317, 2283, 2281,
- /*   790 */  2293, 2320, 2287, 2299, 2335, 2315, 2318, 2316, 2319, 2321,
- /*   800 */  2323,
+ /*    50 */   673,  273,  346,  523,  226,   29,  625,   29,  226,  226,
+ /*    60 */    29, 1341,   29, 1341, 1341,   28,   29,   43,  342,   59,
+ /*    70 */    59,  342,  543,  543,  153,  228,   70,   70,   59,   59,
+ /*    80 */    59,   59,   59,   59,   59,   59,   59,   59,   66,   59,
+ /*    90 */    59,  138,   43,   59,   59,   90,   43,   59,   66,   59,
+ /*   100 */    66,   43,   59,   59,   43,   59,   43,   43,   43,   59,
+ /*   110 */   361, 1004,   15,   15,  344,  171, 1097, 1097, 1097, 1097,
+ /*   120 */  1097, 1097, 1097, 1097, 1097, 1097, 1097, 1097, 1097, 1097,
+ /*   130 */  1097, 1097, 1097, 1097, 1097,  389,  384,  153,  228,   89,
+ /*   140 */    89,  524,  520,  520,  520,  865,  302,  302,  524,  138,
+ /*   150 */    43,   43,   43,   43,  515,  288,   43,  147,   43,  147,
+ /*   160 */   147,  577,  591,  261,  261,  261,  261, 1510,  633,  185,
+ /*   170 */   270,  478,  554,  593,  130,  123,  123,  803,  135,  969,
+ /*   180 */   239,  530, 1016, 1093,  304, 1085,  963,  325,  837,  963,
+ /*   190 */  1100,  925, 1024, 1151, 1365, 1399, 1217,  138, 1399,  138,
+ /*   200 */  1266, 1447, 1430, 1456, 1447, 1430, 1317, 1463, 1447, 1463,
+ /*   210 */  1430, 1317, 1317, 1392, 1397, 1463, 1402, 1463, 1463, 1463,
+ /*   220 */  1487, 1453, 1487, 1453, 1399,  138, 1497,  138, 1501, 1513,
+ /*   230 */   138, 1501,  138,  138,  138, 1463,  138, 1487,   43,   43,
+ /*   240 */    43,   43,   43,   43,   43, 1463, 1487,  147,  147,  147,
+ /*   250 */  1350, 1470, 1399,  361, 1391, 1393, 1497,  361, 1406, 1151,
+ /*   260 */  1463, 1456, 1456,  147, 1349, 1352,  147, 1349, 1352,  147,
+ /*   270 */   147,   43, 1354, 1441, 1349, 1356, 1358, 1366, 1151, 1357,
+ /*   280 */  1359, 1363, 1382, 1447, 1626, 1536, 1501,  361,  361, 1644,
+ /*   290 */  1352,  147,  147,  147,  147,  147, 1352,  147, 1498,  361,
+ /*   300 */   577,  361, 1447, 1581, 1588,  147,  591, 1463,  361, 1663,
+ /*   310 */  1487, 3028, 3028, 3028, 3028, 3028, 3028, 3028, 3028, 3028,
+ /*   320 */  1002,  594,  225,   34,  440,  717,  845,  822,  860,  982,
+ /*   330 */  1165,  987, 1122, 1122, 1122, 1122, 1122, 1122, 1122, 1122,
+ /*   340 */  1122, 1077,  152,  107,  107,  604,  314,  552,  610,  355,
+ /*   350 */   601, 1028,  562,  513,  977,  977,  305, 1039,   51,  305,
+ /*   360 */   305,  305, 1133,  782,  703, 1218, 1253, 1128, 1232, 1140,
+ /*   370 */  1196, 1209, 1216, 1246, 1295, 1309, 1327, 1351, 1125, 1166,
+ /*   380 */  1194, 1231, 1255, 1274, 1281, 1224, 1059, 1219, 1289, 1291,
+ /*   390 */  1314, 1322, 1323, 1325, 1370, 1335, 1271, 1339,   78, 1340,
+ /*   400 */  1342, 1345, 1346, 1353, 1355, 1285, 1321, 1347, 1389, 1435,
+ /*   410 */  1333, 1360, 1701, 1706, 1708, 1681, 1728, 1690, 1514, 1691,
+ /*   420 */  1696, 1697, 1520, 1738, 1711, 1712, 1523, 1741, 1527, 1748,
+ /*   430 */  1714, 1750, 1729, 1752, 1719, 1545, 1757, 1559, 1759, 1561,
+ /*   440 */  1562, 1568, 1572, 1765, 1766, 1767, 1582, 1584, 1768, 1772,
+ /*   450 */  1739, 1775, 1787, 1788, 1743, 1792, 1751, 1800, 1802, 1808,
+ /*   460 */  1758, 1806, 1809, 1810, 1811, 1812, 1813, 1645, 1780, 1817,
+ /*   470 */  1659, 1819, 1820, 1821, 1823, 1824, 1825, 1826, 1827, 1828,
+ /*   480 */  1829, 1830, 1831, 1833, 1834, 1835, 1837, 1791, 1839, 1798,
+ /*   490 */  1842, 1843, 1844, 1845, 1846, 1847, 1832, 1848, 1849, 1853,
+ /*   500 */  1720, 1864, 1866, 1851, 1822, 1854, 1836, 1867, 1807, 1840,
+ /*   510 */  1868, 1815, 1871, 1816, 1879, 1881, 1850, 1838, 1855, 1882,
+ /*   520 */  1857, 1841, 1856, 1883, 1861, 1852, 1858, 1886, 1863, 1888,
+ /*   530 */  1860, 1865, 1859, 1872, 1875, 1885, 1876, 1889, 1869, 1873,
+ /*   540 */  1900, 1905, 1906, 1887, 1742, 1907, 1911, 1925, 1874, 1928,
+ /*   550 */  1930, 1903, 1891, 1902, 1944, 1910, 1897, 1908, 1948, 1914,
+ /*   560 */  1901, 1912, 1953, 1919, 1909, 1916, 1956, 1957, 1959, 1961,
+ /*   570 */  1962, 1963, 1870, 1877, 1929, 1943, 1966, 1932, 1933, 1934,
+ /*   580 */  1935, 1937, 1939, 1940, 1936, 1942, 1949, 1954, 1955, 1958,
+ /*   590 */  1978, 1968, 1979, 1969, 1945, 1983, 1973, 1964, 1988, 1965,
+ /*   600 */  1997, 1967, 1998, 1981, 1984, 1970, 1971, 1975, 1917, 1898,
+ /*   610 */  2011, 1878, 1920, 1880, 1985, 2000, 2024, 1892, 2003, 1884,
+ /*   620 */  1890, 2026, 2027, 1895, 1893, 1896, 1899, 2028, 1995, 1777,
+ /*   630 */  1926, 1938, 1941, 2001, 1931, 2004, 1947, 1950, 1999, 2007,
+ /*   640 */  1976, 1960, 1972, 1980, 1977, 2013, 2006, 2012, 1982, 2017,
+ /*   650 */  1784, 1986, 1987, 2059, 2025, 1818, 2035, 2037, 2038, 2039,
+ /*   660 */  2044, 2052, 1989, 1994, 2042, 1913, 2048, 2060, 2110, 2111,
+ /*   670 */  2010, 2073, 1872, 2068, 2014, 2015, 2016, 2018, 2019, 1951,
+ /*   680 */  2020, 2114, 2086, 1974, 2029, 2022, 1872, 2080, 2084, 2041,
+ /*   690 */  1904, 2043, 2127, 2108, 1923, 2045, 2046, 2050, 2047, 2053,
+ /*   700 */  2061, 2119, 2064, 2065, 2122, 2066, 2150, 1952, 2070, 2069,
+ /*   710 */  2071, 2143, 2144, 2077, 2078, 2146, 2082, 2083, 2151, 2085,
+ /*   720 */  2087, 2154, 2089, 2090, 2155, 2093, 2094, 2158, 2096, 2074,
+ /*   730 */  2075, 2076, 2079, 2182, 2091, 2104, 2164, 2106, 2176, 2118,
+ /*   740 */  2164, 2164, 2192, 2157, 2159, 2188, 2189, 2190, 2193, 2194,
+ /*   750 */  2195, 2197, 2199, 2169, 2149, 2203, 2213, 2215, 2216, 2227,
+ /*   760 */  2217, 2219, 2221, 2183, 1936, 2222, 1942, 2224, 2225, 2226,
+ /*   770 */  2229, 2240, 2230, 2266, 2232, 2220, 2231, 2268, 2237, 2228,
+ /*   780 */  2239, 2271, 2241, 2233, 2242, 2275, 2244, 2234, 2245, 2280,
+ /*   790 */  2251, 2253, 2290, 2270, 2272, 2278, 2281, 2283, 2285,
 };
-#define YY_REDUCE_COUNT (323)
-#define YY_REDUCE_MIN   (-411)
-#define YY_REDUCE_MAX   (2523)
+#define YY_REDUCE_COUNT (319)
+#define YY_REDUCE_MIN   (-406)
+#define YY_REDUCE_MAX   (2588)
 static const short yy_reduce_ofst[] = {
- /*     0 */   845, -282, -133,  -26,  158,  310,  500,  850,  880,  911,
- /*    10 */  1001, 1032, 1069, 1158, 1207, 1272,  389, -341, 1297, 1362,
- /*    20 */  1411, 1426, 1437, 1500, 1516, 1579, 1605, 1640, 1666, 1730,
- /*    30 */  1763, 1792, 1829, 1860, 1892, 1957, 1982, 2008, 2019, 2082,
- /*    40 */  2143, 2172, 2202, 2223, 2272, 2334, 2349, 2371, 2400, 2474,
- /*    50 */  2523,  377,  326, -405,   12, -348,  484,  655,   46,  571,
- /*    60 */   717, -365, -376, -349, -324, -340,  313, -206, -354,  -63,
- /*    70 */   233, -188, -344, -162,  -25, -100, -343, -238,  175,  255,
- /*    80 */   383,  428,    5,   44,  435,  450,  495,  302,  108,  497,
- /*    90 */   520, -351,  153,  573,  605, -290,  578,  623,  286,  689,
- /*   100 */   373, -300,  697,  749,  592,  764,   60,  670,  665,  780,
- /*   110 */   -66, -335, -411, -411, -302, -323, -292, -213,  115,  197,
- /*   120 */   296,  470,  493,  501,  537,  721,  794,  801,  827,  831,
- /*   130 */   839,  843,  846,  856,  857, -232, -105, -102,   89,  369,
- /*   140 */   564,  576, -105,  -31,  -14,  160,  515,  554,  686,  372,
- /*   150 */   221,  144,  795,  338,  319,  449,  561,  730,  751,  503,
- /*   160 */   514,  585,  589,  653,  674,  729,  653,  446,  562,  735,
- /*   170 */   772,  695,  736,  909,  806,  903,  926,  977,  895,  977,
- /*   180 */  1006,  974, 1028, 1036,  998,  989,  929,  929,  912,  929,
- /*   190 */   943,  933,  977,  985,  976,  984,  981, 1050,  991, 1055,
- /*   200 */  1003, 1080, 1045, 1048, 1095, 1052, 1059, 1107, 1112, 1108,
- /*   210 */  1072, 1076, 1077, 1111, 1117, 1130, 1123, 1137, 1138, 1139,
- /*   220 */  1147, 1144, 1149, 1146, 1073, 1141, 1104, 1148, 1159, 1101,
- /*   230 */  1162, 1164, 1163, 1165, 1166, 1167, 1168, 1175, 1150, 1151,
- /*   240 */  1152, 1154, 1156, 1161, 1171, 1173, 1174, 1176, 1177, 1178,
- /*   250 */  1180, 1145, 1153, 1155, 1114, 1118, 1121, 1188, 1127, 1140,
- /*   260 */  1169, 1203, 1170, 1172, 1211, 1198, 1201, 1179, 1099, 1183,
- /*   270 */  1181, 1100, 1190, 1182, 1185,  977, 1103, 1105, 1133, 1189,
- /*   280 */  1193, 1142, 1199, 1128, 1191, 1194,  929, 1269, 1196, 1202,
- /*   290 */  1270, 1262, 1264, 1221, 1222, 1235, 1238, 1239, 1240, 1241,
- /*   300 */  1227, 1244, 1242, 1290, 1274, 1293, 1301, 1206, 1278, 1271,
- /*   310 */  1299, 1317, 1309, 1333, 1330, 1256, 1248, 1273, 1275, 1302,
- /*   320 */  1305, 1306, 1334, 1342,
+ /*     0 */   142, -282, -133,  -26,  158,  307,  542,  850,  878,  911,
+ /*    10 */  1001, 1029, 1091, 1158, 1220, 1283, 1344, -340,  455,   88,
+ /*    20 */  1362, 1423, 1481, 1500, 1580, 1601, 1667, 1704, 1725, 1783,
+ /*    30 */  1804, 1862, 1894, 1922, 1993, 2009, 2067, 2098, 2125, 2156,
+ /*    40 */  2214, 2236, 2303, 2335, 2361, 2440, 2461, 2477, 2498, 2566,
+ /*    50 */  2588,  790, -376,  303,  186, -406,  -13,  -11,  465,  487,
+ /*    60 */   326, -365,  778, -311,  268, -370,  373, -313, -348, -221,
+ /*    70 */  -190, -372, -342,  -72, -361,  363, -204, -187, -176,  280,
+ /*    80 */   287,  339,  134,  155,  409,  450,  528,  204, -183,  580,
+ /*    90 */   612, -351,  149,  675,  679,   22,  408,  682,  108,  688,
+ /*   100 */   212,   72,  615,  697,  425,  750,  391,  641,  462,  759,
+ /*   110 */   570, -341, -343, -343, -182, -325,  216,  264,  454,  495,
+ /*   120 */   713,  723,  724,  736,  758,  804,  805,  809,  827,  842,
+ /*   130 */   843,  844,  846,  863,  887,  -68,    5,  418, -278, -167,
+ /*   140 */    75,  257,    5,   44,  263,  -31,  483,  491,  298,  566,
+ /*   150 */   412,  796,  819,  829,  457, -401,  895,  -35,  886,  479,
+ /*   160 */   576,  684,  836, -387,  367,  460, -387,  446,  503,  596,
+ /*   170 */   571,  469,  505,  712,  567, 1008, 1010,  671,  981,  671,
+ /*   180 */  1033,  995, 1051, 1050, 1014, 1006,  945,  945,  927,  945,
+ /*   190 */   959,  949,  671, 1003,  989, 1000,  999, 1072, 1032, 1095,
+ /*   200 */  1046, 1118, 1076, 1080, 1126, 1087, 1082, 1137, 1138, 1141,
+ /*   210 */  1090, 1094, 1096, 1132, 1135, 1148, 1143, 1152, 1155, 1156,
+ /*   220 */  1167, 1161, 1169, 1168, 1092, 1157, 1129, 1160, 1179, 1123,
+ /*   230 */  1180, 1192, 1186, 1187, 1188, 1198, 1191, 1210, 1172, 1174,
+ /*   240 */  1175, 1176, 1177, 1178, 1182, 1213, 1223, 1183, 1184, 1185,
+ /*   250 */  1159, 1163, 1181, 1239, 1190, 1195, 1205, 1242, 1189, 1193,
+ /*   260 */  1256, 1202, 1215, 1226, 1153, 1221, 1228, 1154, 1222, 1234,
+ /*   270 */  1235,  671, 1162, 1170, 1164, 1171, 1173, 1197, 1225, 1199,
+ /*   280 */  1149, 1200,  945, 1294, 1227, 1203, 1299, 1303, 1304, 1263,
+ /*   290 */  1262, 1278, 1282, 1284, 1286, 1287, 1273, 1290, 1279, 1330,
+ /*   300 */  1313, 1332, 1343, 1243, 1310, 1305, 1328, 1348, 1364, 1361,
+ /*   310 */  1368, 1292, 1280, 1293, 1297, 1367, 1371, 1372, 1369, 1375,
 };
 static const YYACTIONTYPE yy_default[] = {
- /*     0 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*    10 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*    20 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*    30 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*    40 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*    50 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*    60 */  2095, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*    70 */  1784, 1784, 1784, 1784, 2068, 1784, 1784, 1784, 1784, 1784,
- /*    80 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*    90 */  1784, 1873, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   100 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   110 */  1871, 2061, 2287, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   120 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   130 */  1784, 1784, 1784, 1784, 1784, 1784, 2299, 1784, 1784, 1847,
- /*   140 */  1847, 1784, 2299, 2299, 2299, 1871, 2259, 2259, 1784, 1873,
- /*   150 */  2129, 1784, 1784, 1784, 1784, 1784, 1784, 1993, 1784, 1784,
- /*   160 */  1784, 1784, 1784, 2017, 1784, 1784, 1784, 2121, 1784, 1784,
- /*   170 */  2326, 2383, 1784, 1784, 2329, 1784, 1784, 1784, 1784, 1784,
- /*   180 */  1784, 2073, 1784, 1784, 1946, 2316, 2291, 2305, 2367, 2292,
- /*   190 */  2289, 2310, 1784, 2320, 1784, 1784, 2143, 1873, 1784, 1873,
- /*   200 */  2108, 1784, 2066, 1784, 1784, 2066, 2063, 1784, 1784, 1784,
- /*   210 */  2066, 2063, 2063, 1935, 1931, 1784, 1929, 1784, 1784, 1784,
- /*   220 */  1784, 1831, 1784, 1831, 1784, 1873, 1784, 1873, 1784, 1784,
- /*   230 */  1873, 1784, 1873, 1873, 1873, 1784, 1873, 1784, 1784, 1784,
- /*   240 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   250 */  1784, 1784, 1784, 1784, 2141, 2127, 1784, 1871, 2119, 2117,
- /*   260 */  1784, 1871, 2115, 2320, 1784, 1784, 1784, 1784, 2337, 2335,
- /*   270 */  1784, 2337, 2335, 1784, 1784, 1784, 2351, 2347, 2337, 2356,
- /*   280 */  2353, 2322, 2320, 2386, 2373, 2369, 2305, 1784, 1784, 2308,
- /*   290 */  1784, 1871, 1871, 1784, 2335, 1784, 1784, 1784, 1784, 1784,
- /*   300 */  2335, 1784, 1784, 1871, 1784, 1871, 1784, 1784, 1962, 1784,
- /*   310 */  1784, 1784, 1871, 1816, 1784, 2110, 2132, 2091, 2091, 1996,
- /*   320 */  1996, 1996, 1874, 1789, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   330 */  1784, 1784, 1784, 1784, 1784, 1784, 2350, 2349, 2214, 1784,
- /*   340 */  2263, 2262, 2261, 2252, 2213, 1958, 1784, 2212, 2211, 1784,
- /*   350 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 2082, 2081,
- /*   360 */  2205, 1784, 1784, 2206, 2204, 2203, 1784, 1784, 1784, 1784,
- /*   370 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   380 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   390 */  2370, 2374, 1784, 1784, 1784, 1784, 1784, 1784, 2288, 1784,
- /*   400 */  1784, 1784, 2187, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   410 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   420 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   430 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   440 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   450 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   460 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   470 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   480 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   490 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   500 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   510 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   520 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   530 */  1784, 1784, 1784, 1784, 1784, 1784, 1821, 2192, 1784, 1784,
- /*   540 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   550 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   560 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   570 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   580 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1912, 1911,
- /*   590 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   600 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   610 */  1784, 1784, 2196, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   620 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   630 */  1784, 2366, 2323, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   640 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   650 */  1784, 2187, 1784, 2348, 1784, 1784, 2364, 1784, 2368, 1784,
- /*   660 */  1784, 1784, 1784, 1784, 1784, 1784, 2298, 2294, 1784, 1784,
- /*   670 */  2290, 1784, 1784, 1784, 1784, 1784, 2195, 1784, 1784, 1784,
- /*   680 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   690 */  2186, 1784, 2249, 1784, 1784, 1784, 2283, 1784, 1784, 2234,
- /*   700 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 2196,
- /*   710 */  1784, 2199, 1784, 1784, 1784, 1784, 1784, 1990, 1784, 1784,
- /*   720 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   730 */  1784, 1784, 1784, 1974, 1972, 1971, 1970, 1784, 2003, 1784,
- /*   740 */  1784, 1784, 1999, 1998, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   750 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1892, 1784, 1784,
- /*   760 */  1784, 1784, 1784, 1784, 1784, 1784, 1884, 1784, 1883, 1784,
- /*   770 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   780 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   790 */  1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784, 1784,
- /*   800 */  1784,
+ /*     0 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*    10 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*    20 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*    30 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*    40 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*    50 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*    60 */  2095, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*    70 */  1783, 1783, 1783, 1783, 2068, 1783, 1783, 1783, 1783, 1783,
+ /*    80 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*    90 */  1783, 1872, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   100 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   110 */  1870, 2061, 2287, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   120 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   130 */  1783, 1783, 1783, 1783, 1783, 1783, 2299, 1783, 1783, 1846,
+ /*   140 */  1846, 1783, 2299, 2299, 2299, 1870, 2259, 2259, 1783, 1872,
+ /*   150 */  1783, 1783, 1783, 1783, 2129, 1783, 1783, 1783, 1783, 1783,
+ /*   160 */  1783, 1993, 1783, 2017, 1783, 1783, 1783, 2121, 1783, 1783,
+ /*   170 */  2326, 2383, 1783, 1783, 2329, 1783, 1783, 1783, 1783, 1783,
+ /*   180 */  1783, 2073, 1783, 1783, 1945, 2316, 2291, 2305, 2367, 2292,
+ /*   190 */  2289, 2310, 1783, 2320, 1783, 1783, 2143, 1872, 1783, 1872,
+ /*   200 */  2108, 1783, 2066, 1783, 1783, 2066, 2063, 1783, 1783, 1783,
+ /*   210 */  2066, 2063, 2063, 1934, 1930, 1783, 1928, 1783, 1783, 1783,
+ /*   220 */  1783, 1830, 1783, 1830, 1783, 1872, 1783, 1872, 1783, 1783,
+ /*   230 */  1872, 1783, 1872, 1872, 1872, 1783, 1872, 1783, 1783, 1783,
+ /*   240 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   250 */  2141, 2127, 1783, 1870, 2119, 2117, 1783, 1870, 2115, 2320,
+ /*   260 */  1783, 1783, 1783, 1783, 2337, 2335, 1783, 2337, 2335, 1783,
+ /*   270 */  1783, 1783, 2351, 2347, 2337, 2356, 2353, 2322, 2320, 2386,
+ /*   280 */  2373, 2369, 2305, 1783, 1783, 2308, 1783, 1870, 1870, 1783,
+ /*   290 */  2335, 1783, 1783, 1783, 1783, 1783, 2335, 1783, 1783, 1870,
+ /*   300 */  1783, 1870, 1783, 1783, 1961, 1783, 1783, 1783, 1870, 1815,
+ /*   310 */  1783, 2110, 2132, 2091, 2091, 1996, 1996, 1996, 1873, 1788,
+ /*   320 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   330 */  1783, 1783, 2350, 2349, 2214, 1783, 2263, 2262, 2261, 2252,
+ /*   340 */  2213, 1957, 1783, 2212, 2211, 1783, 1783, 1783, 1783, 1783,
+ /*   350 */  1783, 1783, 1783, 1783, 2082, 2081, 2205, 1783, 1783, 2206,
+ /*   360 */  2204, 2203, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   370 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   380 */  1783, 1783, 1783, 1783, 1783, 1783, 2370, 2374, 1783, 1783,
+ /*   390 */  1783, 1783, 1783, 1783, 2288, 1783, 1783, 1783, 2187, 1783,
+ /*   400 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   410 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   420 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   430 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   440 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   450 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   460 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   470 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   480 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   490 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   500 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   510 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   520 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   530 */  1783, 1783, 1820, 2192, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   540 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   550 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   560 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   570 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   580 */  1783, 1783, 1783, 1783, 1911, 1910, 1783, 1783, 1783, 1783,
+ /*   590 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   600 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 2196, 1783,
+ /*   610 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   620 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 2366, 2323, 1783,
+ /*   630 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   640 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 2187, 1783, 2348,
+ /*   650 */  1783, 1783, 2364, 1783, 2368, 1783, 1783, 1783, 1783, 1783,
+ /*   660 */  1783, 1783, 2298, 2294, 1783, 1783, 2290, 1783, 1783, 1783,
+ /*   670 */  1783, 1783, 2195, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   680 */  1783, 1783, 1783, 1783, 1783, 1783, 2186, 1783, 2249, 1783,
+ /*   690 */  1783, 1783, 2283, 1783, 1783, 2234, 1783, 1783, 1783, 1783,
+ /*   700 */  1783, 1783, 1783, 1783, 1783, 2196, 1783, 2199, 1783, 1783,
+ /*   710 */  1783, 1783, 1783, 1990, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   720 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1974,
+ /*   730 */  1972, 1971, 1970, 1783, 1967, 1783, 2003, 1783, 1783, 1783,
+ /*   740 */  1999, 1998, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   750 */  1783, 1783, 1783, 1783, 1783, 1891, 1783, 1783, 1783, 1783,
+ /*   760 */  1783, 1783, 1783, 1783, 1883, 1783, 1882, 1783, 1783, 1783,
+ /*   770 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   780 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
+ /*   790 */  1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783, 1783,
 };
 /********** End of lemon-generated parsing tables *****************************/
 
@@ -1530,6 +1539,7 @@ static const YYCODETYPE yyFallback[] = {
     0,  /*      NK_EQ => nothing */
     0,  /*      USING => nothing */
     0,  /*       TAGS => nothing */
+    0,  /*    COMMENT => nothing */
     0,  /*       BOOL => nothing */
     0,  /*    TINYINT => nothing */
     0,  /*   SMALLINT => nothing */
@@ -1548,7 +1558,6 @@ static const YYCODETYPE yyFallback[] = {
     0,  /*  VARBINARY => nothing */
     0,  /*   GEOMETRY => nothing */
     0,  /*    DECIMAL => nothing */
-    0,  /*    COMMENT => nothing */
     0,  /*  MAX_DELAY => nothing */
     0,  /*  WATERMARK => nothing */
     0,  /*     ROLLUP => nothing */
@@ -1956,25 +1965,25 @@ static const char *const yyTokenName[] = {
   /*  112 */ "NK_EQ",
   /*  113 */ "USING",
   /*  114 */ "TAGS",
-  /*  115 */ "BOOL",
-  /*  116 */ "TINYINT",
-  /*  117 */ "SMALLINT",
-  /*  118 */ "INT",
-  /*  119 */ "INTEGER",
-  /*  120 */ "BIGINT",
-  /*  121 */ "FLOAT",
-  /*  122 */ "DOUBLE",
-  /*  123 */ "BINARY",
-  /*  124 */ "NCHAR",
-  /*  125 */ "UNSIGNED",
-  /*  126 */ "JSON",
-  /*  127 */ "VARCHAR",
-  /*  128 */ "MEDIUMBLOB",
-  /*  129 */ "BLOB",
-  /*  130 */ "VARBINARY",
-  /*  131 */ "GEOMETRY",
-  /*  132 */ "DECIMAL",
-  /*  133 */ "COMMENT",
+  /*  115 */ "COMMENT",
+  /*  116 */ "BOOL",
+  /*  117 */ "TINYINT",
+  /*  118 */ "SMALLINT",
+  /*  119 */ "INT",
+  /*  120 */ "INTEGER",
+  /*  121 */ "BIGINT",
+  /*  122 */ "FLOAT",
+  /*  123 */ "DOUBLE",
+  /*  124 */ "BINARY",
+  /*  125 */ "NCHAR",
+  /*  126 */ "UNSIGNED",
+  /*  127 */ "JSON",
+  /*  128 */ "VARCHAR",
+  /*  129 */ "MEDIUMBLOB",
+  /*  130 */ "BLOB",
+  /*  131 */ "VARBINARY",
+  /*  132 */ "GEOMETRY",
+  /*  133 */ "DECIMAL",
   /*  134 */ "MAX_DELAY",
   /*  135 */ "WATERMARK",
   /*  136 */ "ROLLUP",
@@ -2220,15 +2229,15 @@ static const char *const yyTokenName[] = {
   /*  376 */ "multi_drop_clause",
   /*  377 */ "alter_table_clause",
   /*  378 */ "alter_table_options",
-  /*  379 */ "column_name",
-  /*  380 */ "type_name",
+  /*  379 */ "column_def",
+  /*  380 */ "column_name",
   /*  381 */ "signed_literal",
   /*  382 */ "create_subtable_clause",
   /*  383 */ "specific_cols_opt",
   /*  384 */ "expression_list",
   /*  385 */ "drop_table_clause",
   /*  386 */ "col_name_list",
-  /*  387 */ "column_def",
+  /*  387 */ "type_name",
   /*  388 */ "duration_list",
   /*  389 */ "rollup_func_list",
   /*  390 */ "alter_table_option",
@@ -2496,13 +2505,13 @@ static const char *const yyRuleName[] = {
  /* 157 */ "cmd ::= ALTER TABLE alter_table_clause",
  /* 158 */ "cmd ::= ALTER STABLE alter_table_clause",
  /* 159 */ "alter_table_clause ::= full_table_name alter_table_options",
- /* 160 */ "alter_table_clause ::= full_table_name ADD COLUMN column_name type_name",
+ /* 160 */ "alter_table_clause ::= full_table_name ADD COLUMN column_def",
  /* 161 */ "alter_table_clause ::= full_table_name DROP COLUMN column_name",
- /* 162 */ "alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name",
+ /* 162 */ "alter_table_clause ::= full_table_name MODIFY COLUMN column_def",
  /* 163 */ "alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name",
- /* 164 */ "alter_table_clause ::= full_table_name ADD TAG column_name type_name",
+ /* 164 */ "alter_table_clause ::= full_table_name ADD TAG column_def",
  /* 165 */ "alter_table_clause ::= full_table_name DROP TAG column_name",
- /* 166 */ "alter_table_clause ::= full_table_name MODIFY TAG column_name type_name",
+ /* 166 */ "alter_table_clause ::= full_table_name MODIFY TAG column_def",
  /* 167 */ "alter_table_clause ::= full_table_name RENAME TAG column_name column_name",
  /* 168 */ "alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal",
  /* 169 */ "multi_create_clause ::= create_subtable_clause",
@@ -2518,426 +2527,427 @@ static const char *const yyRuleName[] = {
  /* 179 */ "column_def_list ::= column_def",
  /* 180 */ "column_def_list ::= column_def_list NK_COMMA column_def",
  /* 181 */ "column_def ::= column_name type_name",
- /* 182 */ "type_name ::= BOOL",
- /* 183 */ "type_name ::= TINYINT",
- /* 184 */ "type_name ::= SMALLINT",
- /* 185 */ "type_name ::= INT",
- /* 186 */ "type_name ::= INTEGER",
- /* 187 */ "type_name ::= BIGINT",
- /* 188 */ "type_name ::= FLOAT",
- /* 189 */ "type_name ::= DOUBLE",
- /* 190 */ "type_name ::= BINARY NK_LP NK_INTEGER NK_RP",
- /* 191 */ "type_name ::= TIMESTAMP",
- /* 192 */ "type_name ::= NCHAR NK_LP NK_INTEGER NK_RP",
- /* 193 */ "type_name ::= TINYINT UNSIGNED",
- /* 194 */ "type_name ::= SMALLINT UNSIGNED",
- /* 195 */ "type_name ::= INT UNSIGNED",
- /* 196 */ "type_name ::= BIGINT UNSIGNED",
- /* 197 */ "type_name ::= JSON",
- /* 198 */ "type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP",
- /* 199 */ "type_name ::= MEDIUMBLOB",
- /* 200 */ "type_name ::= BLOB",
- /* 201 */ "type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP",
- /* 202 */ "type_name ::= GEOMETRY NK_LP NK_INTEGER NK_RP",
- /* 203 */ "type_name ::= DECIMAL",
- /* 204 */ "type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP",
- /* 205 */ "type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP",
- /* 206 */ "tags_def_opt ::=",
- /* 207 */ "tags_def_opt ::= tags_def",
- /* 208 */ "tags_def ::= TAGS NK_LP column_def_list NK_RP",
- /* 209 */ "table_options ::=",
- /* 210 */ "table_options ::= table_options COMMENT NK_STRING",
- /* 211 */ "table_options ::= table_options MAX_DELAY duration_list",
- /* 212 */ "table_options ::= table_options WATERMARK duration_list",
- /* 213 */ "table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP",
- /* 214 */ "table_options ::= table_options TTL NK_INTEGER",
- /* 215 */ "table_options ::= table_options SMA NK_LP col_name_list NK_RP",
- /* 216 */ "table_options ::= table_options DELETE_MARK duration_list",
- /* 217 */ "alter_table_options ::= alter_table_option",
- /* 218 */ "alter_table_options ::= alter_table_options alter_table_option",
- /* 219 */ "alter_table_option ::= COMMENT NK_STRING",
- /* 220 */ "alter_table_option ::= TTL NK_INTEGER",
- /* 221 */ "duration_list ::= duration_literal",
- /* 222 */ "duration_list ::= duration_list NK_COMMA duration_literal",
- /* 223 */ "rollup_func_list ::= rollup_func_name",
- /* 224 */ "rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name",
- /* 225 */ "rollup_func_name ::= function_name",
- /* 226 */ "rollup_func_name ::= FIRST",
- /* 227 */ "rollup_func_name ::= LAST",
- /* 228 */ "col_name_list ::= col_name",
- /* 229 */ "col_name_list ::= col_name_list NK_COMMA col_name",
- /* 230 */ "col_name ::= column_name",
- /* 231 */ "cmd ::= SHOW DNODES",
- /* 232 */ "cmd ::= SHOW USERS",
- /* 233 */ "cmd ::= SHOW USER PRIVILEGES",
- /* 234 */ "cmd ::= SHOW DATABASES",
- /* 235 */ "cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt",
- /* 236 */ "cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt",
- /* 237 */ "cmd ::= SHOW db_name_cond_opt VGROUPS",
- /* 238 */ "cmd ::= SHOW MNODES",
- /* 239 */ "cmd ::= SHOW QNODES",
- /* 240 */ "cmd ::= SHOW FUNCTIONS",
- /* 241 */ "cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt",
- /* 242 */ "cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name",
- /* 243 */ "cmd ::= SHOW STREAMS",
- /* 244 */ "cmd ::= SHOW ACCOUNTS",
- /* 245 */ "cmd ::= SHOW APPS",
- /* 246 */ "cmd ::= SHOW CONNECTIONS",
- /* 247 */ "cmd ::= SHOW LICENCES",
- /* 248 */ "cmd ::= SHOW GRANTS",
- /* 249 */ "cmd ::= SHOW CREATE DATABASE db_name",
- /* 250 */ "cmd ::= SHOW CREATE TABLE full_table_name",
- /* 251 */ "cmd ::= SHOW CREATE STABLE full_table_name",
- /* 252 */ "cmd ::= SHOW QUERIES",
- /* 253 */ "cmd ::= SHOW SCORES",
- /* 254 */ "cmd ::= SHOW TOPICS",
- /* 255 */ "cmd ::= SHOW VARIABLES",
- /* 256 */ "cmd ::= SHOW CLUSTER VARIABLES",
- /* 257 */ "cmd ::= SHOW LOCAL VARIABLES",
- /* 258 */ "cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt",
- /* 259 */ "cmd ::= SHOW BNODES",
- /* 260 */ "cmd ::= SHOW SNODES",
- /* 261 */ "cmd ::= SHOW CLUSTER",
- /* 262 */ "cmd ::= SHOW TRANSACTIONS",
- /* 263 */ "cmd ::= SHOW TABLE DISTRIBUTED full_table_name",
- /* 264 */ "cmd ::= SHOW CONSUMERS",
- /* 265 */ "cmd ::= SHOW SUBSCRIPTIONS",
- /* 266 */ "cmd ::= SHOW TAGS FROM table_name_cond from_db_opt",
- /* 267 */ "cmd ::= SHOW TAGS FROM db_name NK_DOT table_name",
- /* 268 */ "cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt",
- /* 269 */ "cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name",
- /* 270 */ "cmd ::= SHOW VNODES NK_INTEGER",
- /* 271 */ "cmd ::= SHOW VNODES NK_STRING",
- /* 272 */ "cmd ::= SHOW db_name_cond_opt ALIVE",
- /* 273 */ "cmd ::= SHOW CLUSTER ALIVE",
- /* 274 */ "db_name_cond_opt ::=",
- /* 275 */ "db_name_cond_opt ::= db_name NK_DOT",
- /* 276 */ "like_pattern_opt ::=",
- /* 277 */ "like_pattern_opt ::= LIKE NK_STRING",
- /* 278 */ "table_name_cond ::= table_name",
- /* 279 */ "from_db_opt ::=",
- /* 280 */ "from_db_opt ::= FROM db_name",
- /* 281 */ "tag_list_opt ::=",
- /* 282 */ "tag_list_opt ::= tag_item",
- /* 283 */ "tag_list_opt ::= tag_list_opt NK_COMMA tag_item",
- /* 284 */ "tag_item ::= TBNAME",
- /* 285 */ "tag_item ::= QTAGS",
- /* 286 */ "tag_item ::= column_name",
- /* 287 */ "tag_item ::= column_name column_alias",
- /* 288 */ "tag_item ::= column_name AS column_alias",
- /* 289 */ "cmd ::= CREATE SMA INDEX not_exists_opt full_index_name ON full_table_name index_options",
- /* 290 */ "cmd ::= CREATE INDEX not_exists_opt full_index_name ON full_table_name NK_LP col_name_list NK_RP",
- /* 291 */ "cmd ::= DROP INDEX exists_opt full_index_name",
- /* 292 */ "full_index_name ::= index_name",
- /* 293 */ "full_index_name ::= db_name NK_DOT index_name",
- /* 294 */ "index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt",
- /* 295 */ "index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt sma_stream_opt",
- /* 296 */ "func_list ::= func",
- /* 297 */ "func_list ::= func_list NK_COMMA func",
- /* 298 */ "func ::= sma_func_name NK_LP expression_list NK_RP",
- /* 299 */ "sma_func_name ::= function_name",
- /* 300 */ "sma_func_name ::= COUNT",
- /* 301 */ "sma_func_name ::= FIRST",
- /* 302 */ "sma_func_name ::= LAST",
- /* 303 */ "sma_func_name ::= LAST_ROW",
- /* 304 */ "sma_stream_opt ::=",
- /* 305 */ "sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal",
- /* 306 */ "sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal",
- /* 307 */ "sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal",
- /* 308 */ "with_meta ::= AS",
- /* 309 */ "with_meta ::= WITH META AS",
- /* 310 */ "with_meta ::= ONLY META AS",
- /* 311 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery",
- /* 312 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name",
- /* 313 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt",
- /* 314 */ "cmd ::= DROP TOPIC exists_opt topic_name",
- /* 315 */ "cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name",
- /* 316 */ "cmd ::= DESC full_table_name",
- /* 317 */ "cmd ::= DESCRIBE full_table_name",
- /* 318 */ "cmd ::= RESET QUERY CACHE",
- /* 319 */ "cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery",
- /* 320 */ "cmd ::= EXPLAIN analyze_opt explain_options insert_query",
- /* 321 */ "analyze_opt ::=",
- /* 322 */ "analyze_opt ::= ANALYZE",
- /* 323 */ "explain_options ::=",
- /* 324 */ "explain_options ::= explain_options VERBOSE NK_BOOL",
- /* 325 */ "explain_options ::= explain_options RATIO NK_FLOAT",
- /* 326 */ "cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt",
- /* 327 */ "cmd ::= DROP FUNCTION exists_opt function_name",
- /* 328 */ "agg_func_opt ::=",
- /* 329 */ "agg_func_opt ::= AGGREGATE",
- /* 330 */ "bufsize_opt ::=",
- /* 331 */ "bufsize_opt ::= BUFSIZE NK_INTEGER",
- /* 332 */ "language_opt ::=",
- /* 333 */ "language_opt ::= LANGUAGE NK_STRING",
- /* 334 */ "or_replace_opt ::=",
- /* 335 */ "or_replace_opt ::= OR REPLACE",
- /* 336 */ "cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name col_list_opt tag_def_or_ref_opt subtable_opt AS query_or_subquery",
- /* 337 */ "cmd ::= DROP STREAM exists_opt stream_name",
- /* 338 */ "cmd ::= PAUSE STREAM exists_opt stream_name",
- /* 339 */ "cmd ::= RESUME STREAM exists_opt ignore_opt stream_name",
- /* 340 */ "col_list_opt ::=",
- /* 341 */ "col_list_opt ::= NK_LP col_name_list NK_RP",
- /* 342 */ "tag_def_or_ref_opt ::=",
- /* 343 */ "tag_def_or_ref_opt ::= tags_def",
- /* 344 */ "tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP",
- /* 345 */ "stream_options ::=",
- /* 346 */ "stream_options ::= stream_options TRIGGER AT_ONCE",
- /* 347 */ "stream_options ::= stream_options TRIGGER WINDOW_CLOSE",
- /* 348 */ "stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal",
- /* 349 */ "stream_options ::= stream_options WATERMARK duration_literal",
- /* 350 */ "stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER",
- /* 351 */ "stream_options ::= stream_options FILL_HISTORY NK_INTEGER",
- /* 352 */ "stream_options ::= stream_options DELETE_MARK duration_literal",
- /* 353 */ "stream_options ::= stream_options IGNORE UPDATE NK_INTEGER",
- /* 354 */ "subtable_opt ::=",
- /* 355 */ "subtable_opt ::= SUBTABLE NK_LP expression NK_RP",
- /* 356 */ "ignore_opt ::=",
- /* 357 */ "ignore_opt ::= IGNORE UNTREATED",
- /* 358 */ "cmd ::= KILL CONNECTION NK_INTEGER",
- /* 359 */ "cmd ::= KILL QUERY NK_STRING",
- /* 360 */ "cmd ::= KILL TRANSACTION NK_INTEGER",
- /* 361 */ "cmd ::= BALANCE VGROUP",
- /* 362 */ "cmd ::= BALANCE VGROUP LEADER",
- /* 363 */ "cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER",
- /* 364 */ "cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list",
- /* 365 */ "cmd ::= SPLIT VGROUP NK_INTEGER",
- /* 366 */ "dnode_list ::= DNODE NK_INTEGER",
- /* 367 */ "dnode_list ::= dnode_list DNODE NK_INTEGER",
- /* 368 */ "cmd ::= DELETE FROM full_table_name where_clause_opt",
- /* 369 */ "cmd ::= query_or_subquery",
- /* 370 */ "cmd ::= insert_query",
- /* 371 */ "insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery",
- /* 372 */ "insert_query ::= INSERT INTO full_table_name query_or_subquery",
- /* 373 */ "literal ::= NK_INTEGER",
- /* 374 */ "literal ::= NK_FLOAT",
- /* 375 */ "literal ::= NK_STRING",
- /* 376 */ "literal ::= NK_BOOL",
- /* 377 */ "literal ::= TIMESTAMP NK_STRING",
- /* 378 */ "literal ::= duration_literal",
- /* 379 */ "literal ::= NULL",
- /* 380 */ "literal ::= NK_QUESTION",
- /* 381 */ "duration_literal ::= NK_VARIABLE",
- /* 382 */ "signed ::= NK_INTEGER",
- /* 383 */ "signed ::= NK_PLUS NK_INTEGER",
- /* 384 */ "signed ::= NK_MINUS NK_INTEGER",
- /* 385 */ "signed ::= NK_FLOAT",
- /* 386 */ "signed ::= NK_PLUS NK_FLOAT",
- /* 387 */ "signed ::= NK_MINUS NK_FLOAT",
- /* 388 */ "signed_literal ::= signed",
- /* 389 */ "signed_literal ::= NK_STRING",
- /* 390 */ "signed_literal ::= NK_BOOL",
- /* 391 */ "signed_literal ::= TIMESTAMP NK_STRING",
- /* 392 */ "signed_literal ::= duration_literal",
- /* 393 */ "signed_literal ::= NULL",
- /* 394 */ "signed_literal ::= literal_func",
- /* 395 */ "signed_literal ::= NK_QUESTION",
- /* 396 */ "literal_list ::= signed_literal",
- /* 397 */ "literal_list ::= literal_list NK_COMMA signed_literal",
- /* 398 */ "db_name ::= NK_ID",
- /* 399 */ "table_name ::= NK_ID",
- /* 400 */ "column_name ::= NK_ID",
- /* 401 */ "function_name ::= NK_ID",
- /* 402 */ "table_alias ::= NK_ID",
- /* 403 */ "column_alias ::= NK_ID",
- /* 404 */ "user_name ::= NK_ID",
- /* 405 */ "topic_name ::= NK_ID",
- /* 406 */ "stream_name ::= NK_ID",
- /* 407 */ "cgroup_name ::= NK_ID",
- /* 408 */ "index_name ::= NK_ID",
- /* 409 */ "expr_or_subquery ::= expression",
- /* 410 */ "expression ::= literal",
- /* 411 */ "expression ::= pseudo_column",
- /* 412 */ "expression ::= column_reference",
- /* 413 */ "expression ::= function_expression",
- /* 414 */ "expression ::= case_when_expression",
- /* 415 */ "expression ::= NK_LP expression NK_RP",
- /* 416 */ "expression ::= NK_PLUS expr_or_subquery",
- /* 417 */ "expression ::= NK_MINUS expr_or_subquery",
- /* 418 */ "expression ::= expr_or_subquery NK_PLUS expr_or_subquery",
- /* 419 */ "expression ::= expr_or_subquery NK_MINUS expr_or_subquery",
- /* 420 */ "expression ::= expr_or_subquery NK_STAR expr_or_subquery",
- /* 421 */ "expression ::= expr_or_subquery NK_SLASH expr_or_subquery",
- /* 422 */ "expression ::= expr_or_subquery NK_REM expr_or_subquery",
- /* 423 */ "expression ::= column_reference NK_ARROW NK_STRING",
- /* 424 */ "expression ::= expr_or_subquery NK_BITAND expr_or_subquery",
- /* 425 */ "expression ::= expr_or_subquery NK_BITOR expr_or_subquery",
- /* 426 */ "expression_list ::= expr_or_subquery",
- /* 427 */ "expression_list ::= expression_list NK_COMMA expr_or_subquery",
- /* 428 */ "column_reference ::= column_name",
- /* 429 */ "column_reference ::= table_name NK_DOT column_name",
- /* 430 */ "pseudo_column ::= ROWTS",
- /* 431 */ "pseudo_column ::= TBNAME",
- /* 432 */ "pseudo_column ::= table_name NK_DOT TBNAME",
- /* 433 */ "pseudo_column ::= QSTART",
- /* 434 */ "pseudo_column ::= QEND",
- /* 435 */ "pseudo_column ::= QDURATION",
- /* 436 */ "pseudo_column ::= WSTART",
- /* 437 */ "pseudo_column ::= WEND",
- /* 438 */ "pseudo_column ::= WDURATION",
- /* 439 */ "pseudo_column ::= IROWTS",
- /* 440 */ "pseudo_column ::= ISFILLED",
- /* 441 */ "pseudo_column ::= QTAGS",
- /* 442 */ "function_expression ::= function_name NK_LP expression_list NK_RP",
- /* 443 */ "function_expression ::= star_func NK_LP star_func_para_list NK_RP",
- /* 444 */ "function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP",
- /* 445 */ "function_expression ::= literal_func",
- /* 446 */ "literal_func ::= noarg_func NK_LP NK_RP",
- /* 447 */ "literal_func ::= NOW",
- /* 448 */ "noarg_func ::= NOW",
- /* 449 */ "noarg_func ::= TODAY",
- /* 450 */ "noarg_func ::= TIMEZONE",
- /* 451 */ "noarg_func ::= DATABASE",
- /* 452 */ "noarg_func ::= CLIENT_VERSION",
- /* 453 */ "noarg_func ::= SERVER_VERSION",
- /* 454 */ "noarg_func ::= SERVER_STATUS",
- /* 455 */ "noarg_func ::= CURRENT_USER",
- /* 456 */ "noarg_func ::= USER",
- /* 457 */ "star_func ::= COUNT",
- /* 458 */ "star_func ::= FIRST",
- /* 459 */ "star_func ::= LAST",
- /* 460 */ "star_func ::= LAST_ROW",
- /* 461 */ "star_func_para_list ::= NK_STAR",
- /* 462 */ "star_func_para_list ::= other_para_list",
- /* 463 */ "other_para_list ::= star_func_para",
- /* 464 */ "other_para_list ::= other_para_list NK_COMMA star_func_para",
- /* 465 */ "star_func_para ::= expr_or_subquery",
- /* 466 */ "star_func_para ::= table_name NK_DOT NK_STAR",
- /* 467 */ "case_when_expression ::= CASE when_then_list case_when_else_opt END",
- /* 468 */ "case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END",
- /* 469 */ "when_then_list ::= when_then_expr",
- /* 470 */ "when_then_list ::= when_then_list when_then_expr",
- /* 471 */ "when_then_expr ::= WHEN common_expression THEN common_expression",
- /* 472 */ "case_when_else_opt ::=",
- /* 473 */ "case_when_else_opt ::= ELSE common_expression",
- /* 474 */ "predicate ::= expr_or_subquery compare_op expr_or_subquery",
- /* 475 */ "predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery",
- /* 476 */ "predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery",
- /* 477 */ "predicate ::= expr_or_subquery IS NULL",
- /* 478 */ "predicate ::= expr_or_subquery IS NOT NULL",
- /* 479 */ "predicate ::= expr_or_subquery in_op in_predicate_value",
- /* 480 */ "compare_op ::= NK_LT",
- /* 481 */ "compare_op ::= NK_GT",
- /* 482 */ "compare_op ::= NK_LE",
- /* 483 */ "compare_op ::= NK_GE",
- /* 484 */ "compare_op ::= NK_NE",
- /* 485 */ "compare_op ::= NK_EQ",
- /* 486 */ "compare_op ::= LIKE",
- /* 487 */ "compare_op ::= NOT LIKE",
- /* 488 */ "compare_op ::= MATCH",
- /* 489 */ "compare_op ::= NMATCH",
- /* 490 */ "compare_op ::= CONTAINS",
- /* 491 */ "in_op ::= IN",
- /* 492 */ "in_op ::= NOT IN",
- /* 493 */ "in_predicate_value ::= NK_LP literal_list NK_RP",
- /* 494 */ "boolean_value_expression ::= boolean_primary",
- /* 495 */ "boolean_value_expression ::= NOT boolean_primary",
- /* 496 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression",
- /* 497 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression",
- /* 498 */ "boolean_primary ::= predicate",
- /* 499 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP",
- /* 500 */ "common_expression ::= expr_or_subquery",
- /* 501 */ "common_expression ::= boolean_value_expression",
- /* 502 */ "from_clause_opt ::=",
- /* 503 */ "from_clause_opt ::= FROM table_reference_list",
- /* 504 */ "table_reference_list ::= table_reference",
- /* 505 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference",
- /* 506 */ "table_reference ::= table_primary",
- /* 507 */ "table_reference ::= joined_table",
- /* 508 */ "table_primary ::= table_name alias_opt",
- /* 509 */ "table_primary ::= db_name NK_DOT table_name alias_opt",
- /* 510 */ "table_primary ::= subquery alias_opt",
- /* 511 */ "table_primary ::= parenthesized_joined_table",
- /* 512 */ "alias_opt ::=",
- /* 513 */ "alias_opt ::= table_alias",
- /* 514 */ "alias_opt ::= AS table_alias",
- /* 515 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP",
- /* 516 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP",
- /* 517 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition",
- /* 518 */ "join_type ::=",
- /* 519 */ "join_type ::= INNER",
- /* 520 */ "query_specification ::= SELECT tag_mode_opt set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt",
- /* 521 */ "tag_mode_opt ::=",
- /* 522 */ "tag_mode_opt ::= TAGS",
- /* 523 */ "set_quantifier_opt ::=",
- /* 524 */ "set_quantifier_opt ::= DISTINCT",
- /* 525 */ "set_quantifier_opt ::= ALL",
- /* 526 */ "select_list ::= select_item",
- /* 527 */ "select_list ::= select_list NK_COMMA select_item",
- /* 528 */ "select_item ::= NK_STAR",
- /* 529 */ "select_item ::= common_expression",
- /* 530 */ "select_item ::= common_expression column_alias",
- /* 531 */ "select_item ::= common_expression AS column_alias",
- /* 532 */ "select_item ::= table_name NK_DOT NK_STAR",
- /* 533 */ "where_clause_opt ::=",
- /* 534 */ "where_clause_opt ::= WHERE search_condition",
- /* 535 */ "partition_by_clause_opt ::=",
- /* 536 */ "partition_by_clause_opt ::= PARTITION BY partition_list",
- /* 537 */ "partition_list ::= partition_item",
- /* 538 */ "partition_list ::= partition_list NK_COMMA partition_item",
- /* 539 */ "partition_item ::= expr_or_subquery",
- /* 540 */ "partition_item ::= expr_or_subquery column_alias",
- /* 541 */ "partition_item ::= expr_or_subquery AS column_alias",
- /* 542 */ "twindow_clause_opt ::=",
- /* 543 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP",
- /* 544 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP",
- /* 545 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt",
- /* 546 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt",
- /* 547 */ "twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition",
- /* 548 */ "sliding_opt ::=",
- /* 549 */ "sliding_opt ::= SLIDING NK_LP duration_literal NK_RP",
- /* 550 */ "fill_opt ::=",
- /* 551 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP",
- /* 552 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP",
- /* 553 */ "fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP",
- /* 554 */ "fill_mode ::= NONE",
- /* 555 */ "fill_mode ::= PREV",
- /* 556 */ "fill_mode ::= NULL",
- /* 557 */ "fill_mode ::= NULL_F",
- /* 558 */ "fill_mode ::= LINEAR",
- /* 559 */ "fill_mode ::= NEXT",
- /* 560 */ "group_by_clause_opt ::=",
- /* 561 */ "group_by_clause_opt ::= GROUP BY group_by_list",
- /* 562 */ "group_by_list ::= expr_or_subquery",
- /* 563 */ "group_by_list ::= group_by_list NK_COMMA expr_or_subquery",
- /* 564 */ "having_clause_opt ::=",
- /* 565 */ "having_clause_opt ::= HAVING search_condition",
- /* 566 */ "range_opt ::=",
- /* 567 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP",
- /* 568 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_RP",
- /* 569 */ "every_opt ::=",
- /* 570 */ "every_opt ::= EVERY NK_LP duration_literal NK_RP",
- /* 571 */ "query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt",
- /* 572 */ "query_simple ::= query_specification",
- /* 573 */ "query_simple ::= union_query_expression",
- /* 574 */ "union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery",
- /* 575 */ "union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery",
- /* 576 */ "query_simple_or_subquery ::= query_simple",
- /* 577 */ "query_simple_or_subquery ::= subquery",
- /* 578 */ "query_or_subquery ::= query_expression",
- /* 579 */ "query_or_subquery ::= subquery",
- /* 580 */ "order_by_clause_opt ::=",
- /* 581 */ "order_by_clause_opt ::= ORDER BY sort_specification_list",
- /* 582 */ "slimit_clause_opt ::=",
- /* 583 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER",
- /* 584 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER",
- /* 585 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER",
- /* 586 */ "limit_clause_opt ::=",
- /* 587 */ "limit_clause_opt ::= LIMIT NK_INTEGER",
- /* 588 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER",
- /* 589 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER",
- /* 590 */ "subquery ::= NK_LP query_expression NK_RP",
- /* 591 */ "subquery ::= NK_LP subquery NK_RP",
- /* 592 */ "search_condition ::= common_expression",
- /* 593 */ "sort_specification_list ::= sort_specification",
- /* 594 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification",
- /* 595 */ "sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt",
- /* 596 */ "ordering_specification_opt ::=",
- /* 597 */ "ordering_specification_opt ::= ASC",
- /* 598 */ "ordering_specification_opt ::= DESC",
- /* 599 */ "null_ordering_opt ::=",
- /* 600 */ "null_ordering_opt ::= NULLS FIRST",
- /* 601 */ "null_ordering_opt ::= NULLS LAST",
+ /* 182 */ "column_def ::= column_name type_name COMMENT NK_STRING",
+ /* 183 */ "type_name ::= BOOL",
+ /* 184 */ "type_name ::= TINYINT",
+ /* 185 */ "type_name ::= SMALLINT",
+ /* 186 */ "type_name ::= INT",
+ /* 187 */ "type_name ::= INTEGER",
+ /* 188 */ "type_name ::= BIGINT",
+ /* 189 */ "type_name ::= FLOAT",
+ /* 190 */ "type_name ::= DOUBLE",
+ /* 191 */ "type_name ::= BINARY NK_LP NK_INTEGER NK_RP",
+ /* 192 */ "type_name ::= TIMESTAMP",
+ /* 193 */ "type_name ::= NCHAR NK_LP NK_INTEGER NK_RP",
+ /* 194 */ "type_name ::= TINYINT UNSIGNED",
+ /* 195 */ "type_name ::= SMALLINT UNSIGNED",
+ /* 196 */ "type_name ::= INT UNSIGNED",
+ /* 197 */ "type_name ::= BIGINT UNSIGNED",
+ /* 198 */ "type_name ::= JSON",
+ /* 199 */ "type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP",
+ /* 200 */ "type_name ::= MEDIUMBLOB",
+ /* 201 */ "type_name ::= BLOB",
+ /* 202 */ "type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP",
+ /* 203 */ "type_name ::= GEOMETRY NK_LP NK_INTEGER NK_RP",
+ /* 204 */ "type_name ::= DECIMAL",
+ /* 205 */ "type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP",
+ /* 206 */ "type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP",
+ /* 207 */ "tags_def_opt ::=",
+ /* 208 */ "tags_def_opt ::= tags_def",
+ /* 209 */ "tags_def ::= TAGS NK_LP column_def_list NK_RP",
+ /* 210 */ "table_options ::=",
+ /* 211 */ "table_options ::= table_options COMMENT NK_STRING",
+ /* 212 */ "table_options ::= table_options MAX_DELAY duration_list",
+ /* 213 */ "table_options ::= table_options WATERMARK duration_list",
+ /* 214 */ "table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP",
+ /* 215 */ "table_options ::= table_options TTL NK_INTEGER",
+ /* 216 */ "table_options ::= table_options SMA NK_LP col_name_list NK_RP",
+ /* 217 */ "table_options ::= table_options DELETE_MARK duration_list",
+ /* 218 */ "alter_table_options ::= alter_table_option",
+ /* 219 */ "alter_table_options ::= alter_table_options alter_table_option",
+ /* 220 */ "alter_table_option ::= COMMENT NK_STRING",
+ /* 221 */ "alter_table_option ::= TTL NK_INTEGER",
+ /* 222 */ "duration_list ::= duration_literal",
+ /* 223 */ "duration_list ::= duration_list NK_COMMA duration_literal",
+ /* 224 */ "rollup_func_list ::= rollup_func_name",
+ /* 225 */ "rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name",
+ /* 226 */ "rollup_func_name ::= function_name",
+ /* 227 */ "rollup_func_name ::= FIRST",
+ /* 228 */ "rollup_func_name ::= LAST",
+ /* 229 */ "col_name_list ::= col_name",
+ /* 230 */ "col_name_list ::= col_name_list NK_COMMA col_name",
+ /* 231 */ "col_name ::= column_name",
+ /* 232 */ "cmd ::= SHOW DNODES",
+ /* 233 */ "cmd ::= SHOW USERS",
+ /* 234 */ "cmd ::= SHOW USER PRIVILEGES",
+ /* 235 */ "cmd ::= SHOW DATABASES",
+ /* 236 */ "cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt",
+ /* 237 */ "cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt",
+ /* 238 */ "cmd ::= SHOW db_name_cond_opt VGROUPS",
+ /* 239 */ "cmd ::= SHOW MNODES",
+ /* 240 */ "cmd ::= SHOW QNODES",
+ /* 241 */ "cmd ::= SHOW FUNCTIONS",
+ /* 242 */ "cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt",
+ /* 243 */ "cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name",
+ /* 244 */ "cmd ::= SHOW STREAMS",
+ /* 245 */ "cmd ::= SHOW ACCOUNTS",
+ /* 246 */ "cmd ::= SHOW APPS",
+ /* 247 */ "cmd ::= SHOW CONNECTIONS",
+ /* 248 */ "cmd ::= SHOW LICENCES",
+ /* 249 */ "cmd ::= SHOW GRANTS",
+ /* 250 */ "cmd ::= SHOW CREATE DATABASE db_name",
+ /* 251 */ "cmd ::= SHOW CREATE TABLE full_table_name",
+ /* 252 */ "cmd ::= SHOW CREATE STABLE full_table_name",
+ /* 253 */ "cmd ::= SHOW QUERIES",
+ /* 254 */ "cmd ::= SHOW SCORES",
+ /* 255 */ "cmd ::= SHOW TOPICS",
+ /* 256 */ "cmd ::= SHOW VARIABLES",
+ /* 257 */ "cmd ::= SHOW CLUSTER VARIABLES",
+ /* 258 */ "cmd ::= SHOW LOCAL VARIABLES",
+ /* 259 */ "cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt",
+ /* 260 */ "cmd ::= SHOW BNODES",
+ /* 261 */ "cmd ::= SHOW SNODES",
+ /* 262 */ "cmd ::= SHOW CLUSTER",
+ /* 263 */ "cmd ::= SHOW TRANSACTIONS",
+ /* 264 */ "cmd ::= SHOW TABLE DISTRIBUTED full_table_name",
+ /* 265 */ "cmd ::= SHOW CONSUMERS",
+ /* 266 */ "cmd ::= SHOW SUBSCRIPTIONS",
+ /* 267 */ "cmd ::= SHOW TAGS FROM table_name_cond from_db_opt",
+ /* 268 */ "cmd ::= SHOW TAGS FROM db_name NK_DOT table_name",
+ /* 269 */ "cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt",
+ /* 270 */ "cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name",
+ /* 271 */ "cmd ::= SHOW VNODES NK_INTEGER",
+ /* 272 */ "cmd ::= SHOW VNODES NK_STRING",
+ /* 273 */ "cmd ::= SHOW db_name_cond_opt ALIVE",
+ /* 274 */ "cmd ::= SHOW CLUSTER ALIVE",
+ /* 275 */ "db_name_cond_opt ::=",
+ /* 276 */ "db_name_cond_opt ::= db_name NK_DOT",
+ /* 277 */ "like_pattern_opt ::=",
+ /* 278 */ "like_pattern_opt ::= LIKE NK_STRING",
+ /* 279 */ "table_name_cond ::= table_name",
+ /* 280 */ "from_db_opt ::=",
+ /* 281 */ "from_db_opt ::= FROM db_name",
+ /* 282 */ "tag_list_opt ::=",
+ /* 283 */ "tag_list_opt ::= tag_item",
+ /* 284 */ "tag_list_opt ::= tag_list_opt NK_COMMA tag_item",
+ /* 285 */ "tag_item ::= TBNAME",
+ /* 286 */ "tag_item ::= QTAGS",
+ /* 287 */ "tag_item ::= column_name",
+ /* 288 */ "tag_item ::= column_name column_alias",
+ /* 289 */ "tag_item ::= column_name AS column_alias",
+ /* 290 */ "cmd ::= CREATE SMA INDEX not_exists_opt full_index_name ON full_table_name index_options",
+ /* 291 */ "cmd ::= CREATE INDEX not_exists_opt full_index_name ON full_table_name NK_LP col_name_list NK_RP",
+ /* 292 */ "cmd ::= DROP INDEX exists_opt full_index_name",
+ /* 293 */ "full_index_name ::= index_name",
+ /* 294 */ "full_index_name ::= db_name NK_DOT index_name",
+ /* 295 */ "index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt",
+ /* 296 */ "index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt sma_stream_opt",
+ /* 297 */ "func_list ::= func",
+ /* 298 */ "func_list ::= func_list NK_COMMA func",
+ /* 299 */ "func ::= sma_func_name NK_LP expression_list NK_RP",
+ /* 300 */ "sma_func_name ::= function_name",
+ /* 301 */ "sma_func_name ::= COUNT",
+ /* 302 */ "sma_func_name ::= FIRST",
+ /* 303 */ "sma_func_name ::= LAST",
+ /* 304 */ "sma_func_name ::= LAST_ROW",
+ /* 305 */ "sma_stream_opt ::=",
+ /* 306 */ "sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal",
+ /* 307 */ "sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal",
+ /* 308 */ "sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal",
+ /* 309 */ "with_meta ::= AS",
+ /* 310 */ "with_meta ::= WITH META AS",
+ /* 311 */ "with_meta ::= ONLY META AS",
+ /* 312 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery",
+ /* 313 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name",
+ /* 314 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt",
+ /* 315 */ "cmd ::= DROP TOPIC exists_opt topic_name",
+ /* 316 */ "cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name",
+ /* 317 */ "cmd ::= DESC full_table_name",
+ /* 318 */ "cmd ::= DESCRIBE full_table_name",
+ /* 319 */ "cmd ::= RESET QUERY CACHE",
+ /* 320 */ "cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery",
+ /* 321 */ "cmd ::= EXPLAIN analyze_opt explain_options insert_query",
+ /* 322 */ "analyze_opt ::=",
+ /* 323 */ "analyze_opt ::= ANALYZE",
+ /* 324 */ "explain_options ::=",
+ /* 325 */ "explain_options ::= explain_options VERBOSE NK_BOOL",
+ /* 326 */ "explain_options ::= explain_options RATIO NK_FLOAT",
+ /* 327 */ "cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt",
+ /* 328 */ "cmd ::= DROP FUNCTION exists_opt function_name",
+ /* 329 */ "agg_func_opt ::=",
+ /* 330 */ "agg_func_opt ::= AGGREGATE",
+ /* 331 */ "bufsize_opt ::=",
+ /* 332 */ "bufsize_opt ::= BUFSIZE NK_INTEGER",
+ /* 333 */ "language_opt ::=",
+ /* 334 */ "language_opt ::= LANGUAGE NK_STRING",
+ /* 335 */ "or_replace_opt ::=",
+ /* 336 */ "or_replace_opt ::= OR REPLACE",
+ /* 337 */ "cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name col_list_opt tag_def_or_ref_opt subtable_opt AS query_or_subquery",
+ /* 338 */ "cmd ::= DROP STREAM exists_opt stream_name",
+ /* 339 */ "cmd ::= PAUSE STREAM exists_opt stream_name",
+ /* 340 */ "cmd ::= RESUME STREAM exists_opt ignore_opt stream_name",
+ /* 341 */ "col_list_opt ::=",
+ /* 342 */ "col_list_opt ::= NK_LP col_name_list NK_RP",
+ /* 343 */ "tag_def_or_ref_opt ::=",
+ /* 344 */ "tag_def_or_ref_opt ::= tags_def",
+ /* 345 */ "tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP",
+ /* 346 */ "stream_options ::=",
+ /* 347 */ "stream_options ::= stream_options TRIGGER AT_ONCE",
+ /* 348 */ "stream_options ::= stream_options TRIGGER WINDOW_CLOSE",
+ /* 349 */ "stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal",
+ /* 350 */ "stream_options ::= stream_options WATERMARK duration_literal",
+ /* 351 */ "stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER",
+ /* 352 */ "stream_options ::= stream_options FILL_HISTORY NK_INTEGER",
+ /* 353 */ "stream_options ::= stream_options DELETE_MARK duration_literal",
+ /* 354 */ "stream_options ::= stream_options IGNORE UPDATE NK_INTEGER",
+ /* 355 */ "subtable_opt ::=",
+ /* 356 */ "subtable_opt ::= SUBTABLE NK_LP expression NK_RP",
+ /* 357 */ "ignore_opt ::=",
+ /* 358 */ "ignore_opt ::= IGNORE UNTREATED",
+ /* 359 */ "cmd ::= KILL CONNECTION NK_INTEGER",
+ /* 360 */ "cmd ::= KILL QUERY NK_STRING",
+ /* 361 */ "cmd ::= KILL TRANSACTION NK_INTEGER",
+ /* 362 */ "cmd ::= BALANCE VGROUP",
+ /* 363 */ "cmd ::= BALANCE VGROUP LEADER",
+ /* 364 */ "cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER",
+ /* 365 */ "cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list",
+ /* 366 */ "cmd ::= SPLIT VGROUP NK_INTEGER",
+ /* 367 */ "dnode_list ::= DNODE NK_INTEGER",
+ /* 368 */ "dnode_list ::= dnode_list DNODE NK_INTEGER",
+ /* 369 */ "cmd ::= DELETE FROM full_table_name where_clause_opt",
+ /* 370 */ "cmd ::= query_or_subquery",
+ /* 371 */ "cmd ::= insert_query",
+ /* 372 */ "insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery",
+ /* 373 */ "insert_query ::= INSERT INTO full_table_name query_or_subquery",
+ /* 374 */ "literal ::= NK_INTEGER",
+ /* 375 */ "literal ::= NK_FLOAT",
+ /* 376 */ "literal ::= NK_STRING",
+ /* 377 */ "literal ::= NK_BOOL",
+ /* 378 */ "literal ::= TIMESTAMP NK_STRING",
+ /* 379 */ "literal ::= duration_literal",
+ /* 380 */ "literal ::= NULL",
+ /* 381 */ "literal ::= NK_QUESTION",
+ /* 382 */ "duration_literal ::= NK_VARIABLE",
+ /* 383 */ "signed ::= NK_INTEGER",
+ /* 384 */ "signed ::= NK_PLUS NK_INTEGER",
+ /* 385 */ "signed ::= NK_MINUS NK_INTEGER",
+ /* 386 */ "signed ::= NK_FLOAT",
+ /* 387 */ "signed ::= NK_PLUS NK_FLOAT",
+ /* 388 */ "signed ::= NK_MINUS NK_FLOAT",
+ /* 389 */ "signed_literal ::= signed",
+ /* 390 */ "signed_literal ::= NK_STRING",
+ /* 391 */ "signed_literal ::= NK_BOOL",
+ /* 392 */ "signed_literal ::= TIMESTAMP NK_STRING",
+ /* 393 */ "signed_literal ::= duration_literal",
+ /* 394 */ "signed_literal ::= NULL",
+ /* 395 */ "signed_literal ::= literal_func",
+ /* 396 */ "signed_literal ::= NK_QUESTION",
+ /* 397 */ "literal_list ::= signed_literal",
+ /* 398 */ "literal_list ::= literal_list NK_COMMA signed_literal",
+ /* 399 */ "db_name ::= NK_ID",
+ /* 400 */ "table_name ::= NK_ID",
+ /* 401 */ "column_name ::= NK_ID",
+ /* 402 */ "function_name ::= NK_ID",
+ /* 403 */ "table_alias ::= NK_ID",
+ /* 404 */ "column_alias ::= NK_ID",
+ /* 405 */ "user_name ::= NK_ID",
+ /* 406 */ "topic_name ::= NK_ID",
+ /* 407 */ "stream_name ::= NK_ID",
+ /* 408 */ "cgroup_name ::= NK_ID",
+ /* 409 */ "index_name ::= NK_ID",
+ /* 410 */ "expr_or_subquery ::= expression",
+ /* 411 */ "expression ::= literal",
+ /* 412 */ "expression ::= pseudo_column",
+ /* 413 */ "expression ::= column_reference",
+ /* 414 */ "expression ::= function_expression",
+ /* 415 */ "expression ::= case_when_expression",
+ /* 416 */ "expression ::= NK_LP expression NK_RP",
+ /* 417 */ "expression ::= NK_PLUS expr_or_subquery",
+ /* 418 */ "expression ::= NK_MINUS expr_or_subquery",
+ /* 419 */ "expression ::= expr_or_subquery NK_PLUS expr_or_subquery",
+ /* 420 */ "expression ::= expr_or_subquery NK_MINUS expr_or_subquery",
+ /* 421 */ "expression ::= expr_or_subquery NK_STAR expr_or_subquery",
+ /* 422 */ "expression ::= expr_or_subquery NK_SLASH expr_or_subquery",
+ /* 423 */ "expression ::= expr_or_subquery NK_REM expr_or_subquery",
+ /* 424 */ "expression ::= column_reference NK_ARROW NK_STRING",
+ /* 425 */ "expression ::= expr_or_subquery NK_BITAND expr_or_subquery",
+ /* 426 */ "expression ::= expr_or_subquery NK_BITOR expr_or_subquery",
+ /* 427 */ "expression_list ::= expr_or_subquery",
+ /* 428 */ "expression_list ::= expression_list NK_COMMA expr_or_subquery",
+ /* 429 */ "column_reference ::= column_name",
+ /* 430 */ "column_reference ::= table_name NK_DOT column_name",
+ /* 431 */ "pseudo_column ::= ROWTS",
+ /* 432 */ "pseudo_column ::= TBNAME",
+ /* 433 */ "pseudo_column ::= table_name NK_DOT TBNAME",
+ /* 434 */ "pseudo_column ::= QSTART",
+ /* 435 */ "pseudo_column ::= QEND",
+ /* 436 */ "pseudo_column ::= QDURATION",
+ /* 437 */ "pseudo_column ::= WSTART",
+ /* 438 */ "pseudo_column ::= WEND",
+ /* 439 */ "pseudo_column ::= WDURATION",
+ /* 440 */ "pseudo_column ::= IROWTS",
+ /* 441 */ "pseudo_column ::= ISFILLED",
+ /* 442 */ "pseudo_column ::= QTAGS",
+ /* 443 */ "function_expression ::= function_name NK_LP expression_list NK_RP",
+ /* 444 */ "function_expression ::= star_func NK_LP star_func_para_list NK_RP",
+ /* 445 */ "function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP",
+ /* 446 */ "function_expression ::= literal_func",
+ /* 447 */ "literal_func ::= noarg_func NK_LP NK_RP",
+ /* 448 */ "literal_func ::= NOW",
+ /* 449 */ "noarg_func ::= NOW",
+ /* 450 */ "noarg_func ::= TODAY",
+ /* 451 */ "noarg_func ::= TIMEZONE",
+ /* 452 */ "noarg_func ::= DATABASE",
+ /* 453 */ "noarg_func ::= CLIENT_VERSION",
+ /* 454 */ "noarg_func ::= SERVER_VERSION",
+ /* 455 */ "noarg_func ::= SERVER_STATUS",
+ /* 456 */ "noarg_func ::= CURRENT_USER",
+ /* 457 */ "noarg_func ::= USER",
+ /* 458 */ "star_func ::= COUNT",
+ /* 459 */ "star_func ::= FIRST",
+ /* 460 */ "star_func ::= LAST",
+ /* 461 */ "star_func ::= LAST_ROW",
+ /* 462 */ "star_func_para_list ::= NK_STAR",
+ /* 463 */ "star_func_para_list ::= other_para_list",
+ /* 464 */ "other_para_list ::= star_func_para",
+ /* 465 */ "other_para_list ::= other_para_list NK_COMMA star_func_para",
+ /* 466 */ "star_func_para ::= expr_or_subquery",
+ /* 467 */ "star_func_para ::= table_name NK_DOT NK_STAR",
+ /* 468 */ "case_when_expression ::= CASE when_then_list case_when_else_opt END",
+ /* 469 */ "case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END",
+ /* 470 */ "when_then_list ::= when_then_expr",
+ /* 471 */ "when_then_list ::= when_then_list when_then_expr",
+ /* 472 */ "when_then_expr ::= WHEN common_expression THEN common_expression",
+ /* 473 */ "case_when_else_opt ::=",
+ /* 474 */ "case_when_else_opt ::= ELSE common_expression",
+ /* 475 */ "predicate ::= expr_or_subquery compare_op expr_or_subquery",
+ /* 476 */ "predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery",
+ /* 477 */ "predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery",
+ /* 478 */ "predicate ::= expr_or_subquery IS NULL",
+ /* 479 */ "predicate ::= expr_or_subquery IS NOT NULL",
+ /* 480 */ "predicate ::= expr_or_subquery in_op in_predicate_value",
+ /* 481 */ "compare_op ::= NK_LT",
+ /* 482 */ "compare_op ::= NK_GT",
+ /* 483 */ "compare_op ::= NK_LE",
+ /* 484 */ "compare_op ::= NK_GE",
+ /* 485 */ "compare_op ::= NK_NE",
+ /* 486 */ "compare_op ::= NK_EQ",
+ /* 487 */ "compare_op ::= LIKE",
+ /* 488 */ "compare_op ::= NOT LIKE",
+ /* 489 */ "compare_op ::= MATCH",
+ /* 490 */ "compare_op ::= NMATCH",
+ /* 491 */ "compare_op ::= CONTAINS",
+ /* 492 */ "in_op ::= IN",
+ /* 493 */ "in_op ::= NOT IN",
+ /* 494 */ "in_predicate_value ::= NK_LP literal_list NK_RP",
+ /* 495 */ "boolean_value_expression ::= boolean_primary",
+ /* 496 */ "boolean_value_expression ::= NOT boolean_primary",
+ /* 497 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression",
+ /* 498 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression",
+ /* 499 */ "boolean_primary ::= predicate",
+ /* 500 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP",
+ /* 501 */ "common_expression ::= expr_or_subquery",
+ /* 502 */ "common_expression ::= boolean_value_expression",
+ /* 503 */ "from_clause_opt ::=",
+ /* 504 */ "from_clause_opt ::= FROM table_reference_list",
+ /* 505 */ "table_reference_list ::= table_reference",
+ /* 506 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference",
+ /* 507 */ "table_reference ::= table_primary",
+ /* 508 */ "table_reference ::= joined_table",
+ /* 509 */ "table_primary ::= table_name alias_opt",
+ /* 510 */ "table_primary ::= db_name NK_DOT table_name alias_opt",
+ /* 511 */ "table_primary ::= subquery alias_opt",
+ /* 512 */ "table_primary ::= parenthesized_joined_table",
+ /* 513 */ "alias_opt ::=",
+ /* 514 */ "alias_opt ::= table_alias",
+ /* 515 */ "alias_opt ::= AS table_alias",
+ /* 516 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP",
+ /* 517 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP",
+ /* 518 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition",
+ /* 519 */ "join_type ::=",
+ /* 520 */ "join_type ::= INNER",
+ /* 521 */ "query_specification ::= SELECT tag_mode_opt set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt",
+ /* 522 */ "tag_mode_opt ::=",
+ /* 523 */ "tag_mode_opt ::= TAGS",
+ /* 524 */ "set_quantifier_opt ::=",
+ /* 525 */ "set_quantifier_opt ::= DISTINCT",
+ /* 526 */ "set_quantifier_opt ::= ALL",
+ /* 527 */ "select_list ::= select_item",
+ /* 528 */ "select_list ::= select_list NK_COMMA select_item",
+ /* 529 */ "select_item ::= NK_STAR",
+ /* 530 */ "select_item ::= common_expression",
+ /* 531 */ "select_item ::= common_expression column_alias",
+ /* 532 */ "select_item ::= common_expression AS column_alias",
+ /* 533 */ "select_item ::= table_name NK_DOT NK_STAR",
+ /* 534 */ "where_clause_opt ::=",
+ /* 535 */ "where_clause_opt ::= WHERE search_condition",
+ /* 536 */ "partition_by_clause_opt ::=",
+ /* 537 */ "partition_by_clause_opt ::= PARTITION BY partition_list",
+ /* 538 */ "partition_list ::= partition_item",
+ /* 539 */ "partition_list ::= partition_list NK_COMMA partition_item",
+ /* 540 */ "partition_item ::= expr_or_subquery",
+ /* 541 */ "partition_item ::= expr_or_subquery column_alias",
+ /* 542 */ "partition_item ::= expr_or_subquery AS column_alias",
+ /* 543 */ "twindow_clause_opt ::=",
+ /* 544 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP",
+ /* 545 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP",
+ /* 546 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt",
+ /* 547 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt",
+ /* 548 */ "twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition",
+ /* 549 */ "sliding_opt ::=",
+ /* 550 */ "sliding_opt ::= SLIDING NK_LP duration_literal NK_RP",
+ /* 551 */ "fill_opt ::=",
+ /* 552 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP",
+ /* 553 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP",
+ /* 554 */ "fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP",
+ /* 555 */ "fill_mode ::= NONE",
+ /* 556 */ "fill_mode ::= PREV",
+ /* 557 */ "fill_mode ::= NULL",
+ /* 558 */ "fill_mode ::= NULL_F",
+ /* 559 */ "fill_mode ::= LINEAR",
+ /* 560 */ "fill_mode ::= NEXT",
+ /* 561 */ "group_by_clause_opt ::=",
+ /* 562 */ "group_by_clause_opt ::= GROUP BY group_by_list",
+ /* 563 */ "group_by_list ::= expr_or_subquery",
+ /* 564 */ "group_by_list ::= group_by_list NK_COMMA expr_or_subquery",
+ /* 565 */ "having_clause_opt ::=",
+ /* 566 */ "having_clause_opt ::= HAVING search_condition",
+ /* 567 */ "range_opt ::=",
+ /* 568 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP",
+ /* 569 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_RP",
+ /* 570 */ "every_opt ::=",
+ /* 571 */ "every_opt ::= EVERY NK_LP duration_literal NK_RP",
+ /* 572 */ "query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt",
+ /* 573 */ "query_simple ::= query_specification",
+ /* 574 */ "query_simple ::= union_query_expression",
+ /* 575 */ "union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery",
+ /* 576 */ "union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery",
+ /* 577 */ "query_simple_or_subquery ::= query_simple",
+ /* 578 */ "query_simple_or_subquery ::= subquery",
+ /* 579 */ "query_or_subquery ::= query_expression",
+ /* 580 */ "query_or_subquery ::= subquery",
+ /* 581 */ "order_by_clause_opt ::=",
+ /* 582 */ "order_by_clause_opt ::= ORDER BY sort_specification_list",
+ /* 583 */ "slimit_clause_opt ::=",
+ /* 584 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER",
+ /* 585 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER",
+ /* 586 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER",
+ /* 587 */ "limit_clause_opt ::=",
+ /* 588 */ "limit_clause_opt ::= LIMIT NK_INTEGER",
+ /* 589 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER",
+ /* 590 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER",
+ /* 591 */ "subquery ::= NK_LP query_expression NK_RP",
+ /* 592 */ "subquery ::= NK_LP subquery NK_RP",
+ /* 593 */ "search_condition ::= common_expression",
+ /* 594 */ "sort_specification_list ::= sort_specification",
+ /* 595 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification",
+ /* 596 */ "sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt",
+ /* 597 */ "ordering_specification_opt ::=",
+ /* 598 */ "ordering_specification_opt ::= ASC",
+ /* 599 */ "ordering_specification_opt ::= DESC",
+ /* 600 */ "null_ordering_opt ::=",
+ /* 601 */ "null_ordering_opt ::= NULLS FIRST",
+ /* 602 */ "null_ordering_opt ::= NULLS LAST",
 };
 #endif /* NDEBUG */
 
@@ -3078,10 +3088,10 @@ static void yy_destructor(
     case 373: /* table_options */
     case 377: /* alter_table_clause */
     case 378: /* alter_table_options */
+    case 379: /* column_def */
     case 381: /* signed_literal */
     case 382: /* create_subtable_clause */
     case 385: /* drop_table_clause */
-    case 387: /* column_def */
     case 391: /* duration_literal */
     case 392: /* rollup_func_name */
     case 394: /* col_name */
@@ -3141,7 +3151,7 @@ static void yy_destructor(
 {
 #line 7 "sql.y"
  nodesDestroyNode((yypminor->yy840)); 
-#line 3144 "sql.c"
+#line 3154 "sql.c"
 }
       break;
     case 339: /* account_options */
@@ -3153,7 +3163,7 @@ static void yy_destructor(
 {
 #line 54 "sql.y"
  
-#line 3156 "sql.c"
+#line 3166 "sql.c"
 }
       break;
     case 343: /* user_name */
@@ -3161,7 +3171,7 @@ static void yy_destructor(
     case 351: /* table_name */
     case 352: /* topic_name */
     case 354: /* dnode_endpoint */
-    case 379: /* column_name */
+    case 380: /* column_name */
     case 393: /* function_name */
     case 401: /* column_alias */
     case 404: /* index_name */
@@ -3176,14 +3186,14 @@ static void yy_destructor(
 {
 #line 742 "sql.y"
  
-#line 3179 "sql.c"
+#line 3189 "sql.c"
 }
       break;
     case 344: /* sysinfo_opt */
 {
 #line 92 "sql.y"
  
-#line 3186 "sql.c"
+#line 3196 "sql.c"
 }
       break;
     case 345: /* privileges */
@@ -3192,14 +3202,14 @@ static void yy_destructor(
 {
 #line 101 "sql.y"
  
-#line 3195 "sql.c"
+#line 3205 "sql.c"
 }
       break;
     case 346: /* priv_level */
 {
 #line 117 "sql.y"
  
-#line 3202 "sql.c"
+#line 3212 "sql.c"
 }
       break;
     case 355: /* force_opt */
@@ -3215,7 +3225,7 @@ static void yy_destructor(
 {
 #line 146 "sql.y"
  
-#line 3218 "sql.c"
+#line 3228 "sql.c"
 }
       break;
     case 364: /* integer_list */
@@ -3250,7 +3260,7 @@ static void yy_destructor(
 {
 #line 270 "sql.y"
  nodesDestroyList((yypminor->yy56)); 
-#line 3253 "sql.c"
+#line 3263 "sql.c"
 }
       break;
     case 368: /* alter_db_option */
@@ -3258,14 +3268,14 @@ static void yy_destructor(
 {
 #line 243 "sql.y"
  
-#line 3261 "sql.c"
+#line 3271 "sql.c"
 }
       break;
-    case 380: /* type_name */
+    case 387: /* type_name */
 {
 #line 364 "sql.y"
  
-#line 3268 "sql.c"
+#line 3278 "sql.c"
 }
       break;
     case 447: /* compare_op */
@@ -3273,35 +3283,35 @@ static void yy_destructor(
 {
 #line 930 "sql.y"
  
-#line 3276 "sql.c"
+#line 3286 "sql.c"
 }
       break;
     case 460: /* join_type */
 {
 #line 1006 "sql.y"
  
-#line 3283 "sql.c"
+#line 3293 "sql.c"
 }
       break;
     case 475: /* fill_mode */
 {
 #line 1087 "sql.y"
  
-#line 3290 "sql.c"
+#line 3300 "sql.c"
 }
       break;
     case 486: /* ordering_specification_opt */
 {
 #line 1172 "sql.y"
  
-#line 3297 "sql.c"
+#line 3307 "sql.c"
 }
       break;
     case 487: /* null_ordering_opt */
 {
 #line 1178 "sql.y"
  
-#line 3304 "sql.c"
+#line 3314 "sql.c"
 }
       break;
 /********* End destructor definitions *****************************************/
@@ -3750,13 +3760,13 @@ static const YYCODETYPE yyRuleInfoLhs[] = {
    338,  /* (157) cmd ::= ALTER TABLE alter_table_clause */
    338,  /* (158) cmd ::= ALTER STABLE alter_table_clause */
    377,  /* (159) alter_table_clause ::= full_table_name alter_table_options */
-   377,  /* (160) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */
+   377,  /* (160) alter_table_clause ::= full_table_name ADD COLUMN column_def */
    377,  /* (161) alter_table_clause ::= full_table_name DROP COLUMN column_name */
-   377,  /* (162) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */
+   377,  /* (162) alter_table_clause ::= full_table_name MODIFY COLUMN column_def */
    377,  /* (163) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */
-   377,  /* (164) alter_table_clause ::= full_table_name ADD TAG column_name type_name */
+   377,  /* (164) alter_table_clause ::= full_table_name ADD TAG column_def */
    377,  /* (165) alter_table_clause ::= full_table_name DROP TAG column_name */
-   377,  /* (166) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */
+   377,  /* (166) alter_table_clause ::= full_table_name MODIFY TAG column_def */
    377,  /* (167) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */
    377,  /* (168) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */
    374,  /* (169) multi_create_clause ::= create_subtable_clause */
@@ -3771,427 +3781,428 @@ static const YYCODETYPE yyRuleInfoLhs[] = {
    370,  /* (178) full_table_name ::= db_name NK_DOT table_name */
    371,  /* (179) column_def_list ::= column_def */
    371,  /* (180) column_def_list ::= column_def_list NK_COMMA column_def */
-   387,  /* (181) column_def ::= column_name type_name */
-   380,  /* (182) type_name ::= BOOL */
-   380,  /* (183) type_name ::= TINYINT */
-   380,  /* (184) type_name ::= SMALLINT */
-   380,  /* (185) type_name ::= INT */
-   380,  /* (186) type_name ::= INTEGER */
-   380,  /* (187) type_name ::= BIGINT */
-   380,  /* (188) type_name ::= FLOAT */
-   380,  /* (189) type_name ::= DOUBLE */
-   380,  /* (190) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */
-   380,  /* (191) type_name ::= TIMESTAMP */
-   380,  /* (192) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */
-   380,  /* (193) type_name ::= TINYINT UNSIGNED */
-   380,  /* (194) type_name ::= SMALLINT UNSIGNED */
-   380,  /* (195) type_name ::= INT UNSIGNED */
-   380,  /* (196) type_name ::= BIGINT UNSIGNED */
-   380,  /* (197) type_name ::= JSON */
-   380,  /* (198) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */
-   380,  /* (199) type_name ::= MEDIUMBLOB */
-   380,  /* (200) type_name ::= BLOB */
-   380,  /* (201) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */
-   380,  /* (202) type_name ::= GEOMETRY NK_LP NK_INTEGER NK_RP */
-   380,  /* (203) type_name ::= DECIMAL */
-   380,  /* (204) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */
-   380,  /* (205) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */
-   372,  /* (206) tags_def_opt ::= */
-   372,  /* (207) tags_def_opt ::= tags_def */
-   375,  /* (208) tags_def ::= TAGS NK_LP column_def_list NK_RP */
-   373,  /* (209) table_options ::= */
-   373,  /* (210) table_options ::= table_options COMMENT NK_STRING */
-   373,  /* (211) table_options ::= table_options MAX_DELAY duration_list */
-   373,  /* (212) table_options ::= table_options WATERMARK duration_list */
-   373,  /* (213) table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */
-   373,  /* (214) table_options ::= table_options TTL NK_INTEGER */
-   373,  /* (215) table_options ::= table_options SMA NK_LP col_name_list NK_RP */
-   373,  /* (216) table_options ::= table_options DELETE_MARK duration_list */
-   378,  /* (217) alter_table_options ::= alter_table_option */
-   378,  /* (218) alter_table_options ::= alter_table_options alter_table_option */
-   390,  /* (219) alter_table_option ::= COMMENT NK_STRING */
-   390,  /* (220) alter_table_option ::= TTL NK_INTEGER */
-   388,  /* (221) duration_list ::= duration_literal */
-   388,  /* (222) duration_list ::= duration_list NK_COMMA duration_literal */
-   389,  /* (223) rollup_func_list ::= rollup_func_name */
-   389,  /* (224) rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */
-   392,  /* (225) rollup_func_name ::= function_name */
-   392,  /* (226) rollup_func_name ::= FIRST */
-   392,  /* (227) rollup_func_name ::= LAST */
-   386,  /* (228) col_name_list ::= col_name */
-   386,  /* (229) col_name_list ::= col_name_list NK_COMMA col_name */
-   394,  /* (230) col_name ::= column_name */
-   338,  /* (231) cmd ::= SHOW DNODES */
-   338,  /* (232) cmd ::= SHOW USERS */
-   338,  /* (233) cmd ::= SHOW USER PRIVILEGES */
-   338,  /* (234) cmd ::= SHOW DATABASES */
-   338,  /* (235) cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */
-   338,  /* (236) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */
-   338,  /* (237) cmd ::= SHOW db_name_cond_opt VGROUPS */
-   338,  /* (238) cmd ::= SHOW MNODES */
-   338,  /* (239) cmd ::= SHOW QNODES */
-   338,  /* (240) cmd ::= SHOW FUNCTIONS */
-   338,  /* (241) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */
-   338,  /* (242) cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name */
-   338,  /* (243) cmd ::= SHOW STREAMS */
-   338,  /* (244) cmd ::= SHOW ACCOUNTS */
-   338,  /* (245) cmd ::= SHOW APPS */
-   338,  /* (246) cmd ::= SHOW CONNECTIONS */
-   338,  /* (247) cmd ::= SHOW LICENCES */
-   338,  /* (248) cmd ::= SHOW GRANTS */
-   338,  /* (249) cmd ::= SHOW CREATE DATABASE db_name */
-   338,  /* (250) cmd ::= SHOW CREATE TABLE full_table_name */
-   338,  /* (251) cmd ::= SHOW CREATE STABLE full_table_name */
-   338,  /* (252) cmd ::= SHOW QUERIES */
-   338,  /* (253) cmd ::= SHOW SCORES */
-   338,  /* (254) cmd ::= SHOW TOPICS */
-   338,  /* (255) cmd ::= SHOW VARIABLES */
-   338,  /* (256) cmd ::= SHOW CLUSTER VARIABLES */
-   338,  /* (257) cmd ::= SHOW LOCAL VARIABLES */
-   338,  /* (258) cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */
-   338,  /* (259) cmd ::= SHOW BNODES */
-   338,  /* (260) cmd ::= SHOW SNODES */
-   338,  /* (261) cmd ::= SHOW CLUSTER */
-   338,  /* (262) cmd ::= SHOW TRANSACTIONS */
-   338,  /* (263) cmd ::= SHOW TABLE DISTRIBUTED full_table_name */
-   338,  /* (264) cmd ::= SHOW CONSUMERS */
-   338,  /* (265) cmd ::= SHOW SUBSCRIPTIONS */
-   338,  /* (266) cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */
-   338,  /* (267) cmd ::= SHOW TAGS FROM db_name NK_DOT table_name */
-   338,  /* (268) cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */
-   338,  /* (269) cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name */
-   338,  /* (270) cmd ::= SHOW VNODES NK_INTEGER */
-   338,  /* (271) cmd ::= SHOW VNODES NK_STRING */
-   338,  /* (272) cmd ::= SHOW db_name_cond_opt ALIVE */
-   338,  /* (273) cmd ::= SHOW CLUSTER ALIVE */
-   395,  /* (274) db_name_cond_opt ::= */
-   395,  /* (275) db_name_cond_opt ::= db_name NK_DOT */
-   396,  /* (276) like_pattern_opt ::= */
-   396,  /* (277) like_pattern_opt ::= LIKE NK_STRING */
-   397,  /* (278) table_name_cond ::= table_name */
-   398,  /* (279) from_db_opt ::= */
-   398,  /* (280) from_db_opt ::= FROM db_name */
-   399,  /* (281) tag_list_opt ::= */
-   399,  /* (282) tag_list_opt ::= tag_item */
-   399,  /* (283) tag_list_opt ::= tag_list_opt NK_COMMA tag_item */
-   400,  /* (284) tag_item ::= TBNAME */
-   400,  /* (285) tag_item ::= QTAGS */
-   400,  /* (286) tag_item ::= column_name */
-   400,  /* (287) tag_item ::= column_name column_alias */
-   400,  /* (288) tag_item ::= column_name AS column_alias */
-   338,  /* (289) cmd ::= CREATE SMA INDEX not_exists_opt full_index_name ON full_table_name index_options */
-   338,  /* (290) cmd ::= CREATE INDEX not_exists_opt full_index_name ON full_table_name NK_LP col_name_list NK_RP */
-   338,  /* (291) cmd ::= DROP INDEX exists_opt full_index_name */
-   402,  /* (292) full_index_name ::= index_name */
-   402,  /* (293) full_index_name ::= db_name NK_DOT index_name */
-   403,  /* (294) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */
-   403,  /* (295) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt sma_stream_opt */
-   405,  /* (296) func_list ::= func */
-   405,  /* (297) func_list ::= func_list NK_COMMA func */
-   408,  /* (298) func ::= sma_func_name NK_LP expression_list NK_RP */
-   409,  /* (299) sma_func_name ::= function_name */
-   409,  /* (300) sma_func_name ::= COUNT */
-   409,  /* (301) sma_func_name ::= FIRST */
-   409,  /* (302) sma_func_name ::= LAST */
-   409,  /* (303) sma_func_name ::= LAST_ROW */
-   407,  /* (304) sma_stream_opt ::= */
-   407,  /* (305) sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */
-   407,  /* (306) sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */
-   407,  /* (307) sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */
-   410,  /* (308) with_meta ::= AS */
-   410,  /* (309) with_meta ::= WITH META AS */
-   410,  /* (310) with_meta ::= ONLY META AS */
-   338,  /* (311) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */
-   338,  /* (312) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name */
-   338,  /* (313) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt */
-   338,  /* (314) cmd ::= DROP TOPIC exists_opt topic_name */
-   338,  /* (315) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */
-   338,  /* (316) cmd ::= DESC full_table_name */
-   338,  /* (317) cmd ::= DESCRIBE full_table_name */
-   338,  /* (318) cmd ::= RESET QUERY CACHE */
-   338,  /* (319) cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */
-   338,  /* (320) cmd ::= EXPLAIN analyze_opt explain_options insert_query */
-   414,  /* (321) analyze_opt ::= */
-   414,  /* (322) analyze_opt ::= ANALYZE */
-   415,  /* (323) explain_options ::= */
-   415,  /* (324) explain_options ::= explain_options VERBOSE NK_BOOL */
-   415,  /* (325) explain_options ::= explain_options RATIO NK_FLOAT */
-   338,  /* (326) cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt */
-   338,  /* (327) cmd ::= DROP FUNCTION exists_opt function_name */
-   418,  /* (328) agg_func_opt ::= */
-   418,  /* (329) agg_func_opt ::= AGGREGATE */
-   419,  /* (330) bufsize_opt ::= */
-   419,  /* (331) bufsize_opt ::= BUFSIZE NK_INTEGER */
-   420,  /* (332) language_opt ::= */
-   420,  /* (333) language_opt ::= LANGUAGE NK_STRING */
-   417,  /* (334) or_replace_opt ::= */
-   417,  /* (335) or_replace_opt ::= OR REPLACE */
-   338,  /* (336) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name col_list_opt tag_def_or_ref_opt subtable_opt AS query_or_subquery */
-   338,  /* (337) cmd ::= DROP STREAM exists_opt stream_name */
-   338,  /* (338) cmd ::= PAUSE STREAM exists_opt stream_name */
-   338,  /* (339) cmd ::= RESUME STREAM exists_opt ignore_opt stream_name */
-   423,  /* (340) col_list_opt ::= */
-   423,  /* (341) col_list_opt ::= NK_LP col_name_list NK_RP */
-   424,  /* (342) tag_def_or_ref_opt ::= */
-   424,  /* (343) tag_def_or_ref_opt ::= tags_def */
-   424,  /* (344) tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP */
-   422,  /* (345) stream_options ::= */
-   422,  /* (346) stream_options ::= stream_options TRIGGER AT_ONCE */
-   422,  /* (347) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */
-   422,  /* (348) stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */
-   422,  /* (349) stream_options ::= stream_options WATERMARK duration_literal */
-   422,  /* (350) stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */
-   422,  /* (351) stream_options ::= stream_options FILL_HISTORY NK_INTEGER */
-   422,  /* (352) stream_options ::= stream_options DELETE_MARK duration_literal */
-   422,  /* (353) stream_options ::= stream_options IGNORE UPDATE NK_INTEGER */
-   425,  /* (354) subtable_opt ::= */
-   425,  /* (355) subtable_opt ::= SUBTABLE NK_LP expression NK_RP */
-   426,  /* (356) ignore_opt ::= */
-   426,  /* (357) ignore_opt ::= IGNORE UNTREATED */
-   338,  /* (358) cmd ::= KILL CONNECTION NK_INTEGER */
-   338,  /* (359) cmd ::= KILL QUERY NK_STRING */
-   338,  /* (360) cmd ::= KILL TRANSACTION NK_INTEGER */
-   338,  /* (361) cmd ::= BALANCE VGROUP */
-   338,  /* (362) cmd ::= BALANCE VGROUP LEADER */
-   338,  /* (363) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */
-   338,  /* (364) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */
-   338,  /* (365) cmd ::= SPLIT VGROUP NK_INTEGER */
-   428,  /* (366) dnode_list ::= DNODE NK_INTEGER */
-   428,  /* (367) dnode_list ::= dnode_list DNODE NK_INTEGER */
-   338,  /* (368) cmd ::= DELETE FROM full_table_name where_clause_opt */
-   338,  /* (369) cmd ::= query_or_subquery */
-   338,  /* (370) cmd ::= insert_query */
-   416,  /* (371) insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */
-   416,  /* (372) insert_query ::= INSERT INTO full_table_name query_or_subquery */
-   341,  /* (373) literal ::= NK_INTEGER */
-   341,  /* (374) literal ::= NK_FLOAT */
-   341,  /* (375) literal ::= NK_STRING */
-   341,  /* (376) literal ::= NK_BOOL */
-   341,  /* (377) literal ::= TIMESTAMP NK_STRING */
-   341,  /* (378) literal ::= duration_literal */
-   341,  /* (379) literal ::= NULL */
-   341,  /* (380) literal ::= NK_QUESTION */
-   391,  /* (381) duration_literal ::= NK_VARIABLE */
-   367,  /* (382) signed ::= NK_INTEGER */
-   367,  /* (383) signed ::= NK_PLUS NK_INTEGER */
-   367,  /* (384) signed ::= NK_MINUS NK_INTEGER */
-   367,  /* (385) signed ::= NK_FLOAT */
-   367,  /* (386) signed ::= NK_PLUS NK_FLOAT */
-   367,  /* (387) signed ::= NK_MINUS NK_FLOAT */
-   381,  /* (388) signed_literal ::= signed */
-   381,  /* (389) signed_literal ::= NK_STRING */
-   381,  /* (390) signed_literal ::= NK_BOOL */
-   381,  /* (391) signed_literal ::= TIMESTAMP NK_STRING */
-   381,  /* (392) signed_literal ::= duration_literal */
-   381,  /* (393) signed_literal ::= NULL */
-   381,  /* (394) signed_literal ::= literal_func */
-   381,  /* (395) signed_literal ::= NK_QUESTION */
-   430,  /* (396) literal_list ::= signed_literal */
-   430,  /* (397) literal_list ::= literal_list NK_COMMA signed_literal */
-   350,  /* (398) db_name ::= NK_ID */
-   351,  /* (399) table_name ::= NK_ID */
-   379,  /* (400) column_name ::= NK_ID */
-   393,  /* (401) function_name ::= NK_ID */
-   431,  /* (402) table_alias ::= NK_ID */
-   401,  /* (403) column_alias ::= NK_ID */
-   343,  /* (404) user_name ::= NK_ID */
-   352,  /* (405) topic_name ::= NK_ID */
-   421,  /* (406) stream_name ::= NK_ID */
-   413,  /* (407) cgroup_name ::= NK_ID */
-   404,  /* (408) index_name ::= NK_ID */
-   432,  /* (409) expr_or_subquery ::= expression */
-   427,  /* (410) expression ::= literal */
-   427,  /* (411) expression ::= pseudo_column */
-   427,  /* (412) expression ::= column_reference */
-   427,  /* (413) expression ::= function_expression */
-   427,  /* (414) expression ::= case_when_expression */
-   427,  /* (415) expression ::= NK_LP expression NK_RP */
-   427,  /* (416) expression ::= NK_PLUS expr_or_subquery */
-   427,  /* (417) expression ::= NK_MINUS expr_or_subquery */
-   427,  /* (418) expression ::= expr_or_subquery NK_PLUS expr_or_subquery */
-   427,  /* (419) expression ::= expr_or_subquery NK_MINUS expr_or_subquery */
-   427,  /* (420) expression ::= expr_or_subquery NK_STAR expr_or_subquery */
-   427,  /* (421) expression ::= expr_or_subquery NK_SLASH expr_or_subquery */
-   427,  /* (422) expression ::= expr_or_subquery NK_REM expr_or_subquery */
-   427,  /* (423) expression ::= column_reference NK_ARROW NK_STRING */
-   427,  /* (424) expression ::= expr_or_subquery NK_BITAND expr_or_subquery */
-   427,  /* (425) expression ::= expr_or_subquery NK_BITOR expr_or_subquery */
-   384,  /* (426) expression_list ::= expr_or_subquery */
-   384,  /* (427) expression_list ::= expression_list NK_COMMA expr_or_subquery */
-   434,  /* (428) column_reference ::= column_name */
-   434,  /* (429) column_reference ::= table_name NK_DOT column_name */
-   433,  /* (430) pseudo_column ::= ROWTS */
-   433,  /* (431) pseudo_column ::= TBNAME */
-   433,  /* (432) pseudo_column ::= table_name NK_DOT TBNAME */
-   433,  /* (433) pseudo_column ::= QSTART */
-   433,  /* (434) pseudo_column ::= QEND */
-   433,  /* (435) pseudo_column ::= QDURATION */
-   433,  /* (436) pseudo_column ::= WSTART */
-   433,  /* (437) pseudo_column ::= WEND */
-   433,  /* (438) pseudo_column ::= WDURATION */
-   433,  /* (439) pseudo_column ::= IROWTS */
-   433,  /* (440) pseudo_column ::= ISFILLED */
-   433,  /* (441) pseudo_column ::= QTAGS */
-   435,  /* (442) function_expression ::= function_name NK_LP expression_list NK_RP */
-   435,  /* (443) function_expression ::= star_func NK_LP star_func_para_list NK_RP */
-   435,  /* (444) function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */
-   435,  /* (445) function_expression ::= literal_func */
-   429,  /* (446) literal_func ::= noarg_func NK_LP NK_RP */
-   429,  /* (447) literal_func ::= NOW */
-   439,  /* (448) noarg_func ::= NOW */
-   439,  /* (449) noarg_func ::= TODAY */
-   439,  /* (450) noarg_func ::= TIMEZONE */
-   439,  /* (451) noarg_func ::= DATABASE */
-   439,  /* (452) noarg_func ::= CLIENT_VERSION */
-   439,  /* (453) noarg_func ::= SERVER_VERSION */
-   439,  /* (454) noarg_func ::= SERVER_STATUS */
-   439,  /* (455) noarg_func ::= CURRENT_USER */
-   439,  /* (456) noarg_func ::= USER */
-   437,  /* (457) star_func ::= COUNT */
-   437,  /* (458) star_func ::= FIRST */
-   437,  /* (459) star_func ::= LAST */
-   437,  /* (460) star_func ::= LAST_ROW */
-   438,  /* (461) star_func_para_list ::= NK_STAR */
-   438,  /* (462) star_func_para_list ::= other_para_list */
-   440,  /* (463) other_para_list ::= star_func_para */
-   440,  /* (464) other_para_list ::= other_para_list NK_COMMA star_func_para */
-   441,  /* (465) star_func_para ::= expr_or_subquery */
-   441,  /* (466) star_func_para ::= table_name NK_DOT NK_STAR */
-   436,  /* (467) case_when_expression ::= CASE when_then_list case_when_else_opt END */
-   436,  /* (468) case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */
-   442,  /* (469) when_then_list ::= when_then_expr */
-   442,  /* (470) when_then_list ::= when_then_list when_then_expr */
-   445,  /* (471) when_then_expr ::= WHEN common_expression THEN common_expression */
-   443,  /* (472) case_when_else_opt ::= */
-   443,  /* (473) case_when_else_opt ::= ELSE common_expression */
-   446,  /* (474) predicate ::= expr_or_subquery compare_op expr_or_subquery */
-   446,  /* (475) predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */
-   446,  /* (476) predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */
-   446,  /* (477) predicate ::= expr_or_subquery IS NULL */
-   446,  /* (478) predicate ::= expr_or_subquery IS NOT NULL */
-   446,  /* (479) predicate ::= expr_or_subquery in_op in_predicate_value */
-   447,  /* (480) compare_op ::= NK_LT */
-   447,  /* (481) compare_op ::= NK_GT */
-   447,  /* (482) compare_op ::= NK_LE */
-   447,  /* (483) compare_op ::= NK_GE */
-   447,  /* (484) compare_op ::= NK_NE */
-   447,  /* (485) compare_op ::= NK_EQ */
-   447,  /* (486) compare_op ::= LIKE */
-   447,  /* (487) compare_op ::= NOT LIKE */
-   447,  /* (488) compare_op ::= MATCH */
-   447,  /* (489) compare_op ::= NMATCH */
-   447,  /* (490) compare_op ::= CONTAINS */
-   448,  /* (491) in_op ::= IN */
-   448,  /* (492) in_op ::= NOT IN */
-   449,  /* (493) in_predicate_value ::= NK_LP literal_list NK_RP */
-   450,  /* (494) boolean_value_expression ::= boolean_primary */
-   450,  /* (495) boolean_value_expression ::= NOT boolean_primary */
-   450,  /* (496) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
-   450,  /* (497) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
-   451,  /* (498) boolean_primary ::= predicate */
-   451,  /* (499) boolean_primary ::= NK_LP boolean_value_expression NK_RP */
-   444,  /* (500) common_expression ::= expr_or_subquery */
-   444,  /* (501) common_expression ::= boolean_value_expression */
-   452,  /* (502) from_clause_opt ::= */
-   452,  /* (503) from_clause_opt ::= FROM table_reference_list */
-   453,  /* (504) table_reference_list ::= table_reference */
-   453,  /* (505) table_reference_list ::= table_reference_list NK_COMMA table_reference */
-   454,  /* (506) table_reference ::= table_primary */
-   454,  /* (507) table_reference ::= joined_table */
-   455,  /* (508) table_primary ::= table_name alias_opt */
-   455,  /* (509) table_primary ::= db_name NK_DOT table_name alias_opt */
-   455,  /* (510) table_primary ::= subquery alias_opt */
-   455,  /* (511) table_primary ::= parenthesized_joined_table */
-   457,  /* (512) alias_opt ::= */
-   457,  /* (513) alias_opt ::= table_alias */
-   457,  /* (514) alias_opt ::= AS table_alias */
-   459,  /* (515) parenthesized_joined_table ::= NK_LP joined_table NK_RP */
-   459,  /* (516) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */
-   456,  /* (517) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
-   460,  /* (518) join_type ::= */
-   460,  /* (519) join_type ::= INNER */
-   461,  /* (520) query_specification ::= SELECT tag_mode_opt set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
-   462,  /* (521) tag_mode_opt ::= */
-   462,  /* (522) tag_mode_opt ::= TAGS */
-   463,  /* (523) set_quantifier_opt ::= */
-   463,  /* (524) set_quantifier_opt ::= DISTINCT */
-   463,  /* (525) set_quantifier_opt ::= ALL */
-   464,  /* (526) select_list ::= select_item */
-   464,  /* (527) select_list ::= select_list NK_COMMA select_item */
-   472,  /* (528) select_item ::= NK_STAR */
-   472,  /* (529) select_item ::= common_expression */
-   472,  /* (530) select_item ::= common_expression column_alias */
-   472,  /* (531) select_item ::= common_expression AS column_alias */
-   472,  /* (532) select_item ::= table_name NK_DOT NK_STAR */
-   412,  /* (533) where_clause_opt ::= */
-   412,  /* (534) where_clause_opt ::= WHERE search_condition */
-   465,  /* (535) partition_by_clause_opt ::= */
-   465,  /* (536) partition_by_clause_opt ::= PARTITION BY partition_list */
-   473,  /* (537) partition_list ::= partition_item */
-   473,  /* (538) partition_list ::= partition_list NK_COMMA partition_item */
-   474,  /* (539) partition_item ::= expr_or_subquery */
-   474,  /* (540) partition_item ::= expr_or_subquery column_alias */
-   474,  /* (541) partition_item ::= expr_or_subquery AS column_alias */
-   469,  /* (542) twindow_clause_opt ::= */
-   469,  /* (543) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
-   469,  /* (544) twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */
-   469,  /* (545) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
-   469,  /* (546) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
-   469,  /* (547) twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */
-   406,  /* (548) sliding_opt ::= */
-   406,  /* (549) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
-   468,  /* (550) fill_opt ::= */
-   468,  /* (551) fill_opt ::= FILL NK_LP fill_mode NK_RP */
-   468,  /* (552) fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */
-   468,  /* (553) fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */
-   475,  /* (554) fill_mode ::= NONE */
-   475,  /* (555) fill_mode ::= PREV */
-   475,  /* (556) fill_mode ::= NULL */
-   475,  /* (557) fill_mode ::= NULL_F */
-   475,  /* (558) fill_mode ::= LINEAR */
-   475,  /* (559) fill_mode ::= NEXT */
-   470,  /* (560) group_by_clause_opt ::= */
-   470,  /* (561) group_by_clause_opt ::= GROUP BY group_by_list */
-   476,  /* (562) group_by_list ::= expr_or_subquery */
-   476,  /* (563) group_by_list ::= group_by_list NK_COMMA expr_or_subquery */
-   471,  /* (564) having_clause_opt ::= */
-   471,  /* (565) having_clause_opt ::= HAVING search_condition */
-   466,  /* (566) range_opt ::= */
-   466,  /* (567) range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */
-   466,  /* (568) range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */
-   467,  /* (569) every_opt ::= */
-   467,  /* (570) every_opt ::= EVERY NK_LP duration_literal NK_RP */
-   477,  /* (571) query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */
-   478,  /* (572) query_simple ::= query_specification */
-   478,  /* (573) query_simple ::= union_query_expression */
-   482,  /* (574) union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */
-   482,  /* (575) union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */
-   483,  /* (576) query_simple_or_subquery ::= query_simple */
-   483,  /* (577) query_simple_or_subquery ::= subquery */
-   411,  /* (578) query_or_subquery ::= query_expression */
-   411,  /* (579) query_or_subquery ::= subquery */
-   479,  /* (580) order_by_clause_opt ::= */
-   479,  /* (581) order_by_clause_opt ::= ORDER BY sort_specification_list */
-   480,  /* (582) slimit_clause_opt ::= */
-   480,  /* (583) slimit_clause_opt ::= SLIMIT NK_INTEGER */
-   480,  /* (584) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
-   480,  /* (585) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
-   481,  /* (586) limit_clause_opt ::= */
-   481,  /* (587) limit_clause_opt ::= LIMIT NK_INTEGER */
-   481,  /* (588) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */
-   481,  /* (589) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */
-   458,  /* (590) subquery ::= NK_LP query_expression NK_RP */
-   458,  /* (591) subquery ::= NK_LP subquery NK_RP */
-   353,  /* (592) search_condition ::= common_expression */
-   484,  /* (593) sort_specification_list ::= sort_specification */
-   484,  /* (594) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */
-   485,  /* (595) sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */
-   486,  /* (596) ordering_specification_opt ::= */
-   486,  /* (597) ordering_specification_opt ::= ASC */
-   486,  /* (598) ordering_specification_opt ::= DESC */
-   487,  /* (599) null_ordering_opt ::= */
-   487,  /* (600) null_ordering_opt ::= NULLS FIRST */
-   487,  /* (601) null_ordering_opt ::= NULLS LAST */
+   379,  /* (181) column_def ::= column_name type_name */
+   379,  /* (182) column_def ::= column_name type_name COMMENT NK_STRING */
+   387,  /* (183) type_name ::= BOOL */
+   387,  /* (184) type_name ::= TINYINT */
+   387,  /* (185) type_name ::= SMALLINT */
+   387,  /* (186) type_name ::= INT */
+   387,  /* (187) type_name ::= INTEGER */
+   387,  /* (188) type_name ::= BIGINT */
+   387,  /* (189) type_name ::= FLOAT */
+   387,  /* (190) type_name ::= DOUBLE */
+   387,  /* (191) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */
+   387,  /* (192) type_name ::= TIMESTAMP */
+   387,  /* (193) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */
+   387,  /* (194) type_name ::= TINYINT UNSIGNED */
+   387,  /* (195) type_name ::= SMALLINT UNSIGNED */
+   387,  /* (196) type_name ::= INT UNSIGNED */
+   387,  /* (197) type_name ::= BIGINT UNSIGNED */
+   387,  /* (198) type_name ::= JSON */
+   387,  /* (199) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */
+   387,  /* (200) type_name ::= MEDIUMBLOB */
+   387,  /* (201) type_name ::= BLOB */
+   387,  /* (202) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */
+   387,  /* (203) type_name ::= GEOMETRY NK_LP NK_INTEGER NK_RP */
+   387,  /* (204) type_name ::= DECIMAL */
+   387,  /* (205) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */
+   387,  /* (206) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */
+   372,  /* (207) tags_def_opt ::= */
+   372,  /* (208) tags_def_opt ::= tags_def */
+   375,  /* (209) tags_def ::= TAGS NK_LP column_def_list NK_RP */
+   373,  /* (210) table_options ::= */
+   373,  /* (211) table_options ::= table_options COMMENT NK_STRING */
+   373,  /* (212) table_options ::= table_options MAX_DELAY duration_list */
+   373,  /* (213) table_options ::= table_options WATERMARK duration_list */
+   373,  /* (214) table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */
+   373,  /* (215) table_options ::= table_options TTL NK_INTEGER */
+   373,  /* (216) table_options ::= table_options SMA NK_LP col_name_list NK_RP */
+   373,  /* (217) table_options ::= table_options DELETE_MARK duration_list */
+   378,  /* (218) alter_table_options ::= alter_table_option */
+   378,  /* (219) alter_table_options ::= alter_table_options alter_table_option */
+   390,  /* (220) alter_table_option ::= COMMENT NK_STRING */
+   390,  /* (221) alter_table_option ::= TTL NK_INTEGER */
+   388,  /* (222) duration_list ::= duration_literal */
+   388,  /* (223) duration_list ::= duration_list NK_COMMA duration_literal */
+   389,  /* (224) rollup_func_list ::= rollup_func_name */
+   389,  /* (225) rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */
+   392,  /* (226) rollup_func_name ::= function_name */
+   392,  /* (227) rollup_func_name ::= FIRST */
+   392,  /* (228) rollup_func_name ::= LAST */
+   386,  /* (229) col_name_list ::= col_name */
+   386,  /* (230) col_name_list ::= col_name_list NK_COMMA col_name */
+   394,  /* (231) col_name ::= column_name */
+   338,  /* (232) cmd ::= SHOW DNODES */
+   338,  /* (233) cmd ::= SHOW USERS */
+   338,  /* (234) cmd ::= SHOW USER PRIVILEGES */
+   338,  /* (235) cmd ::= SHOW DATABASES */
+   338,  /* (236) cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */
+   338,  /* (237) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */
+   338,  /* (238) cmd ::= SHOW db_name_cond_opt VGROUPS */
+   338,  /* (239) cmd ::= SHOW MNODES */
+   338,  /* (240) cmd ::= SHOW QNODES */
+   338,  /* (241) cmd ::= SHOW FUNCTIONS */
+   338,  /* (242) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */
+   338,  /* (243) cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name */
+   338,  /* (244) cmd ::= SHOW STREAMS */
+   338,  /* (245) cmd ::= SHOW ACCOUNTS */
+   338,  /* (246) cmd ::= SHOW APPS */
+   338,  /* (247) cmd ::= SHOW CONNECTIONS */
+   338,  /* (248) cmd ::= SHOW LICENCES */
+   338,  /* (249) cmd ::= SHOW GRANTS */
+   338,  /* (250) cmd ::= SHOW CREATE DATABASE db_name */
+   338,  /* (251) cmd ::= SHOW CREATE TABLE full_table_name */
+   338,  /* (252) cmd ::= SHOW CREATE STABLE full_table_name */
+   338,  /* (253) cmd ::= SHOW QUERIES */
+   338,  /* (254) cmd ::= SHOW SCORES */
+   338,  /* (255) cmd ::= SHOW TOPICS */
+   338,  /* (256) cmd ::= SHOW VARIABLES */
+   338,  /* (257) cmd ::= SHOW CLUSTER VARIABLES */
+   338,  /* (258) cmd ::= SHOW LOCAL VARIABLES */
+   338,  /* (259) cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */
+   338,  /* (260) cmd ::= SHOW BNODES */
+   338,  /* (261) cmd ::= SHOW SNODES */
+   338,  /* (262) cmd ::= SHOW CLUSTER */
+   338,  /* (263) cmd ::= SHOW TRANSACTIONS */
+   338,  /* (264) cmd ::= SHOW TABLE DISTRIBUTED full_table_name */
+   338,  /* (265) cmd ::= SHOW CONSUMERS */
+   338,  /* (266) cmd ::= SHOW SUBSCRIPTIONS */
+   338,  /* (267) cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */
+   338,  /* (268) cmd ::= SHOW TAGS FROM db_name NK_DOT table_name */
+   338,  /* (269) cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */
+   338,  /* (270) cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name */
+   338,  /* (271) cmd ::= SHOW VNODES NK_INTEGER */
+   338,  /* (272) cmd ::= SHOW VNODES NK_STRING */
+   338,  /* (273) cmd ::= SHOW db_name_cond_opt ALIVE */
+   338,  /* (274) cmd ::= SHOW CLUSTER ALIVE */
+   395,  /* (275) db_name_cond_opt ::= */
+   395,  /* (276) db_name_cond_opt ::= db_name NK_DOT */
+   396,  /* (277) like_pattern_opt ::= */
+   396,  /* (278) like_pattern_opt ::= LIKE NK_STRING */
+   397,  /* (279) table_name_cond ::= table_name */
+   398,  /* (280) from_db_opt ::= */
+   398,  /* (281) from_db_opt ::= FROM db_name */
+   399,  /* (282) tag_list_opt ::= */
+   399,  /* (283) tag_list_opt ::= tag_item */
+   399,  /* (284) tag_list_opt ::= tag_list_opt NK_COMMA tag_item */
+   400,  /* (285) tag_item ::= TBNAME */
+   400,  /* (286) tag_item ::= QTAGS */
+   400,  /* (287) tag_item ::= column_name */
+   400,  /* (288) tag_item ::= column_name column_alias */
+   400,  /* (289) tag_item ::= column_name AS column_alias */
+   338,  /* (290) cmd ::= CREATE SMA INDEX not_exists_opt full_index_name ON full_table_name index_options */
+   338,  /* (291) cmd ::= CREATE INDEX not_exists_opt full_index_name ON full_table_name NK_LP col_name_list NK_RP */
+   338,  /* (292) cmd ::= DROP INDEX exists_opt full_index_name */
+   402,  /* (293) full_index_name ::= index_name */
+   402,  /* (294) full_index_name ::= db_name NK_DOT index_name */
+   403,  /* (295) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */
+   403,  /* (296) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt sma_stream_opt */
+   405,  /* (297) func_list ::= func */
+   405,  /* (298) func_list ::= func_list NK_COMMA func */
+   408,  /* (299) func ::= sma_func_name NK_LP expression_list NK_RP */
+   409,  /* (300) sma_func_name ::= function_name */
+   409,  /* (301) sma_func_name ::= COUNT */
+   409,  /* (302) sma_func_name ::= FIRST */
+   409,  /* (303) sma_func_name ::= LAST */
+   409,  /* (304) sma_func_name ::= LAST_ROW */
+   407,  /* (305) sma_stream_opt ::= */
+   407,  /* (306) sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */
+   407,  /* (307) sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */
+   407,  /* (308) sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */
+   410,  /* (309) with_meta ::= AS */
+   410,  /* (310) with_meta ::= WITH META AS */
+   410,  /* (311) with_meta ::= ONLY META AS */
+   338,  /* (312) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */
+   338,  /* (313) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name */
+   338,  /* (314) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt */
+   338,  /* (315) cmd ::= DROP TOPIC exists_opt topic_name */
+   338,  /* (316) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */
+   338,  /* (317) cmd ::= DESC full_table_name */
+   338,  /* (318) cmd ::= DESCRIBE full_table_name */
+   338,  /* (319) cmd ::= RESET QUERY CACHE */
+   338,  /* (320) cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */
+   338,  /* (321) cmd ::= EXPLAIN analyze_opt explain_options insert_query */
+   414,  /* (322) analyze_opt ::= */
+   414,  /* (323) analyze_opt ::= ANALYZE */
+   415,  /* (324) explain_options ::= */
+   415,  /* (325) explain_options ::= explain_options VERBOSE NK_BOOL */
+   415,  /* (326) explain_options ::= explain_options RATIO NK_FLOAT */
+   338,  /* (327) cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt */
+   338,  /* (328) cmd ::= DROP FUNCTION exists_opt function_name */
+   418,  /* (329) agg_func_opt ::= */
+   418,  /* (330) agg_func_opt ::= AGGREGATE */
+   419,  /* (331) bufsize_opt ::= */
+   419,  /* (332) bufsize_opt ::= BUFSIZE NK_INTEGER */
+   420,  /* (333) language_opt ::= */
+   420,  /* (334) language_opt ::= LANGUAGE NK_STRING */
+   417,  /* (335) or_replace_opt ::= */
+   417,  /* (336) or_replace_opt ::= OR REPLACE */
+   338,  /* (337) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name col_list_opt tag_def_or_ref_opt subtable_opt AS query_or_subquery */
+   338,  /* (338) cmd ::= DROP STREAM exists_opt stream_name */
+   338,  /* (339) cmd ::= PAUSE STREAM exists_opt stream_name */
+   338,  /* (340) cmd ::= RESUME STREAM exists_opt ignore_opt stream_name */
+   423,  /* (341) col_list_opt ::= */
+   423,  /* (342) col_list_opt ::= NK_LP col_name_list NK_RP */
+   424,  /* (343) tag_def_or_ref_opt ::= */
+   424,  /* (344) tag_def_or_ref_opt ::= tags_def */
+   424,  /* (345) tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP */
+   422,  /* (346) stream_options ::= */
+   422,  /* (347) stream_options ::= stream_options TRIGGER AT_ONCE */
+   422,  /* (348) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */
+   422,  /* (349) stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */
+   422,  /* (350) stream_options ::= stream_options WATERMARK duration_literal */
+   422,  /* (351) stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */
+   422,  /* (352) stream_options ::= stream_options FILL_HISTORY NK_INTEGER */
+   422,  /* (353) stream_options ::= stream_options DELETE_MARK duration_literal */
+   422,  /* (354) stream_options ::= stream_options IGNORE UPDATE NK_INTEGER */
+   425,  /* (355) subtable_opt ::= */
+   425,  /* (356) subtable_opt ::= SUBTABLE NK_LP expression NK_RP */
+   426,  /* (357) ignore_opt ::= */
+   426,  /* (358) ignore_opt ::= IGNORE UNTREATED */
+   338,  /* (359) cmd ::= KILL CONNECTION NK_INTEGER */
+   338,  /* (360) cmd ::= KILL QUERY NK_STRING */
+   338,  /* (361) cmd ::= KILL TRANSACTION NK_INTEGER */
+   338,  /* (362) cmd ::= BALANCE VGROUP */
+   338,  /* (363) cmd ::= BALANCE VGROUP LEADER */
+   338,  /* (364) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */
+   338,  /* (365) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */
+   338,  /* (366) cmd ::= SPLIT VGROUP NK_INTEGER */
+   428,  /* (367) dnode_list ::= DNODE NK_INTEGER */
+   428,  /* (368) dnode_list ::= dnode_list DNODE NK_INTEGER */
+   338,  /* (369) cmd ::= DELETE FROM full_table_name where_clause_opt */
+   338,  /* (370) cmd ::= query_or_subquery */
+   338,  /* (371) cmd ::= insert_query */
+   416,  /* (372) insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */
+   416,  /* (373) insert_query ::= INSERT INTO full_table_name query_or_subquery */
+   341,  /* (374) literal ::= NK_INTEGER */
+   341,  /* (375) literal ::= NK_FLOAT */
+   341,  /* (376) literal ::= NK_STRING */
+   341,  /* (377) literal ::= NK_BOOL */
+   341,  /* (378) literal ::= TIMESTAMP NK_STRING */
+   341,  /* (379) literal ::= duration_literal */
+   341,  /* (380) literal ::= NULL */
+   341,  /* (381) literal ::= NK_QUESTION */
+   391,  /* (382) duration_literal ::= NK_VARIABLE */
+   367,  /* (383) signed ::= NK_INTEGER */
+   367,  /* (384) signed ::= NK_PLUS NK_INTEGER */
+   367,  /* (385) signed ::= NK_MINUS NK_INTEGER */
+   367,  /* (386) signed ::= NK_FLOAT */
+   367,  /* (387) signed ::= NK_PLUS NK_FLOAT */
+   367,  /* (388) signed ::= NK_MINUS NK_FLOAT */
+   381,  /* (389) signed_literal ::= signed */
+   381,  /* (390) signed_literal ::= NK_STRING */
+   381,  /* (391) signed_literal ::= NK_BOOL */
+   381,  /* (392) signed_literal ::= TIMESTAMP NK_STRING */
+   381,  /* (393) signed_literal ::= duration_literal */
+   381,  /* (394) signed_literal ::= NULL */
+   381,  /* (395) signed_literal ::= literal_func */
+   381,  /* (396) signed_literal ::= NK_QUESTION */
+   430,  /* (397) literal_list ::= signed_literal */
+   430,  /* (398) literal_list ::= literal_list NK_COMMA signed_literal */
+   350,  /* (399) db_name ::= NK_ID */
+   351,  /* (400) table_name ::= NK_ID */
+   380,  /* (401) column_name ::= NK_ID */
+   393,  /* (402) function_name ::= NK_ID */
+   431,  /* (403) table_alias ::= NK_ID */
+   401,  /* (404) column_alias ::= NK_ID */
+   343,  /* (405) user_name ::= NK_ID */
+   352,  /* (406) topic_name ::= NK_ID */
+   421,  /* (407) stream_name ::= NK_ID */
+   413,  /* (408) cgroup_name ::= NK_ID */
+   404,  /* (409) index_name ::= NK_ID */
+   432,  /* (410) expr_or_subquery ::= expression */
+   427,  /* (411) expression ::= literal */
+   427,  /* (412) expression ::= pseudo_column */
+   427,  /* (413) expression ::= column_reference */
+   427,  /* (414) expression ::= function_expression */
+   427,  /* (415) expression ::= case_when_expression */
+   427,  /* (416) expression ::= NK_LP expression NK_RP */
+   427,  /* (417) expression ::= NK_PLUS expr_or_subquery */
+   427,  /* (418) expression ::= NK_MINUS expr_or_subquery */
+   427,  /* (419) expression ::= expr_or_subquery NK_PLUS expr_or_subquery */
+   427,  /* (420) expression ::= expr_or_subquery NK_MINUS expr_or_subquery */
+   427,  /* (421) expression ::= expr_or_subquery NK_STAR expr_or_subquery */
+   427,  /* (422) expression ::= expr_or_subquery NK_SLASH expr_or_subquery */
+   427,  /* (423) expression ::= expr_or_subquery NK_REM expr_or_subquery */
+   427,  /* (424) expression ::= column_reference NK_ARROW NK_STRING */
+   427,  /* (425) expression ::= expr_or_subquery NK_BITAND expr_or_subquery */
+   427,  /* (426) expression ::= expr_or_subquery NK_BITOR expr_or_subquery */
+   384,  /* (427) expression_list ::= expr_or_subquery */
+   384,  /* (428) expression_list ::= expression_list NK_COMMA expr_or_subquery */
+   434,  /* (429) column_reference ::= column_name */
+   434,  /* (430) column_reference ::= table_name NK_DOT column_name */
+   433,  /* (431) pseudo_column ::= ROWTS */
+   433,  /* (432) pseudo_column ::= TBNAME */
+   433,  /* (433) pseudo_column ::= table_name NK_DOT TBNAME */
+   433,  /* (434) pseudo_column ::= QSTART */
+   433,  /* (435) pseudo_column ::= QEND */
+   433,  /* (436) pseudo_column ::= QDURATION */
+   433,  /* (437) pseudo_column ::= WSTART */
+   433,  /* (438) pseudo_column ::= WEND */
+   433,  /* (439) pseudo_column ::= WDURATION */
+   433,  /* (440) pseudo_column ::= IROWTS */
+   433,  /* (441) pseudo_column ::= ISFILLED */
+   433,  /* (442) pseudo_column ::= QTAGS */
+   435,  /* (443) function_expression ::= function_name NK_LP expression_list NK_RP */
+   435,  /* (444) function_expression ::= star_func NK_LP star_func_para_list NK_RP */
+   435,  /* (445) function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */
+   435,  /* (446) function_expression ::= literal_func */
+   429,  /* (447) literal_func ::= noarg_func NK_LP NK_RP */
+   429,  /* (448) literal_func ::= NOW */
+   439,  /* (449) noarg_func ::= NOW */
+   439,  /* (450) noarg_func ::= TODAY */
+   439,  /* (451) noarg_func ::= TIMEZONE */
+   439,  /* (452) noarg_func ::= DATABASE */
+   439,  /* (453) noarg_func ::= CLIENT_VERSION */
+   439,  /* (454) noarg_func ::= SERVER_VERSION */
+   439,  /* (455) noarg_func ::= SERVER_STATUS */
+   439,  /* (456) noarg_func ::= CURRENT_USER */
+   439,  /* (457) noarg_func ::= USER */
+   437,  /* (458) star_func ::= COUNT */
+   437,  /* (459) star_func ::= FIRST */
+   437,  /* (460) star_func ::= LAST */
+   437,  /* (461) star_func ::= LAST_ROW */
+   438,  /* (462) star_func_para_list ::= NK_STAR */
+   438,  /* (463) star_func_para_list ::= other_para_list */
+   440,  /* (464) other_para_list ::= star_func_para */
+   440,  /* (465) other_para_list ::= other_para_list NK_COMMA star_func_para */
+   441,  /* (466) star_func_para ::= expr_or_subquery */
+   441,  /* (467) star_func_para ::= table_name NK_DOT NK_STAR */
+   436,  /* (468) case_when_expression ::= CASE when_then_list case_when_else_opt END */
+   436,  /* (469) case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */
+   442,  /* (470) when_then_list ::= when_then_expr */
+   442,  /* (471) when_then_list ::= when_then_list when_then_expr */
+   445,  /* (472) when_then_expr ::= WHEN common_expression THEN common_expression */
+   443,  /* (473) case_when_else_opt ::= */
+   443,  /* (474) case_when_else_opt ::= ELSE common_expression */
+   446,  /* (475) predicate ::= expr_or_subquery compare_op expr_or_subquery */
+   446,  /* (476) predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */
+   446,  /* (477) predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */
+   446,  /* (478) predicate ::= expr_or_subquery IS NULL */
+   446,  /* (479) predicate ::= expr_or_subquery IS NOT NULL */
+   446,  /* (480) predicate ::= expr_or_subquery in_op in_predicate_value */
+   447,  /* (481) compare_op ::= NK_LT */
+   447,  /* (482) compare_op ::= NK_GT */
+   447,  /* (483) compare_op ::= NK_LE */
+   447,  /* (484) compare_op ::= NK_GE */
+   447,  /* (485) compare_op ::= NK_NE */
+   447,  /* (486) compare_op ::= NK_EQ */
+   447,  /* (487) compare_op ::= LIKE */
+   447,  /* (488) compare_op ::= NOT LIKE */
+   447,  /* (489) compare_op ::= MATCH */
+   447,  /* (490) compare_op ::= NMATCH */
+   447,  /* (491) compare_op ::= CONTAINS */
+   448,  /* (492) in_op ::= IN */
+   448,  /* (493) in_op ::= NOT IN */
+   449,  /* (494) in_predicate_value ::= NK_LP literal_list NK_RP */
+   450,  /* (495) boolean_value_expression ::= boolean_primary */
+   450,  /* (496) boolean_value_expression ::= NOT boolean_primary */
+   450,  /* (497) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
+   450,  /* (498) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
+   451,  /* (499) boolean_primary ::= predicate */
+   451,  /* (500) boolean_primary ::= NK_LP boolean_value_expression NK_RP */
+   444,  /* (501) common_expression ::= expr_or_subquery */
+   444,  /* (502) common_expression ::= boolean_value_expression */
+   452,  /* (503) from_clause_opt ::= */
+   452,  /* (504) from_clause_opt ::= FROM table_reference_list */
+   453,  /* (505) table_reference_list ::= table_reference */
+   453,  /* (506) table_reference_list ::= table_reference_list NK_COMMA table_reference */
+   454,  /* (507) table_reference ::= table_primary */
+   454,  /* (508) table_reference ::= joined_table */
+   455,  /* (509) table_primary ::= table_name alias_opt */
+   455,  /* (510) table_primary ::= db_name NK_DOT table_name alias_opt */
+   455,  /* (511) table_primary ::= subquery alias_opt */
+   455,  /* (512) table_primary ::= parenthesized_joined_table */
+   457,  /* (513) alias_opt ::= */
+   457,  /* (514) alias_opt ::= table_alias */
+   457,  /* (515) alias_opt ::= AS table_alias */
+   459,  /* (516) parenthesized_joined_table ::= NK_LP joined_table NK_RP */
+   459,  /* (517) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */
+   456,  /* (518) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
+   460,  /* (519) join_type ::= */
+   460,  /* (520) join_type ::= INNER */
+   461,  /* (521) query_specification ::= SELECT tag_mode_opt set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
+   462,  /* (522) tag_mode_opt ::= */
+   462,  /* (523) tag_mode_opt ::= TAGS */
+   463,  /* (524) set_quantifier_opt ::= */
+   463,  /* (525) set_quantifier_opt ::= DISTINCT */
+   463,  /* (526) set_quantifier_opt ::= ALL */
+   464,  /* (527) select_list ::= select_item */
+   464,  /* (528) select_list ::= select_list NK_COMMA select_item */
+   472,  /* (529) select_item ::= NK_STAR */
+   472,  /* (530) select_item ::= common_expression */
+   472,  /* (531) select_item ::= common_expression column_alias */
+   472,  /* (532) select_item ::= common_expression AS column_alias */
+   472,  /* (533) select_item ::= table_name NK_DOT NK_STAR */
+   412,  /* (534) where_clause_opt ::= */
+   412,  /* (535) where_clause_opt ::= WHERE search_condition */
+   465,  /* (536) partition_by_clause_opt ::= */
+   465,  /* (537) partition_by_clause_opt ::= PARTITION BY partition_list */
+   473,  /* (538) partition_list ::= partition_item */
+   473,  /* (539) partition_list ::= partition_list NK_COMMA partition_item */
+   474,  /* (540) partition_item ::= expr_or_subquery */
+   474,  /* (541) partition_item ::= expr_or_subquery column_alias */
+   474,  /* (542) partition_item ::= expr_or_subquery AS column_alias */
+   469,  /* (543) twindow_clause_opt ::= */
+   469,  /* (544) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
+   469,  /* (545) twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */
+   469,  /* (546) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
+   469,  /* (547) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
+   469,  /* (548) twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */
+   406,  /* (549) sliding_opt ::= */
+   406,  /* (550) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
+   468,  /* (551) fill_opt ::= */
+   468,  /* (552) fill_opt ::= FILL NK_LP fill_mode NK_RP */
+   468,  /* (553) fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */
+   468,  /* (554) fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */
+   475,  /* (555) fill_mode ::= NONE */
+   475,  /* (556) fill_mode ::= PREV */
+   475,  /* (557) fill_mode ::= NULL */
+   475,  /* (558) fill_mode ::= NULL_F */
+   475,  /* (559) fill_mode ::= LINEAR */
+   475,  /* (560) fill_mode ::= NEXT */
+   470,  /* (561) group_by_clause_opt ::= */
+   470,  /* (562) group_by_clause_opt ::= GROUP BY group_by_list */
+   476,  /* (563) group_by_list ::= expr_or_subquery */
+   476,  /* (564) group_by_list ::= group_by_list NK_COMMA expr_or_subquery */
+   471,  /* (565) having_clause_opt ::= */
+   471,  /* (566) having_clause_opt ::= HAVING search_condition */
+   466,  /* (567) range_opt ::= */
+   466,  /* (568) range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */
+   466,  /* (569) range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */
+   467,  /* (570) every_opt ::= */
+   467,  /* (571) every_opt ::= EVERY NK_LP duration_literal NK_RP */
+   477,  /* (572) query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */
+   478,  /* (573) query_simple ::= query_specification */
+   478,  /* (574) query_simple ::= union_query_expression */
+   482,  /* (575) union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */
+   482,  /* (576) union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */
+   483,  /* (577) query_simple_or_subquery ::= query_simple */
+   483,  /* (578) query_simple_or_subquery ::= subquery */
+   411,  /* (579) query_or_subquery ::= query_expression */
+   411,  /* (580) query_or_subquery ::= subquery */
+   479,  /* (581) order_by_clause_opt ::= */
+   479,  /* (582) order_by_clause_opt ::= ORDER BY sort_specification_list */
+   480,  /* (583) slimit_clause_opt ::= */
+   480,  /* (584) slimit_clause_opt ::= SLIMIT NK_INTEGER */
+   480,  /* (585) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
+   480,  /* (586) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+   481,  /* (587) limit_clause_opt ::= */
+   481,  /* (588) limit_clause_opt ::= LIMIT NK_INTEGER */
+   481,  /* (589) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */
+   481,  /* (590) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+   458,  /* (591) subquery ::= NK_LP query_expression NK_RP */
+   458,  /* (592) subquery ::= NK_LP subquery NK_RP */
+   353,  /* (593) search_condition ::= common_expression */
+   484,  /* (594) sort_specification_list ::= sort_specification */
+   484,  /* (595) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */
+   485,  /* (596) sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */
+   486,  /* (597) ordering_specification_opt ::= */
+   486,  /* (598) ordering_specification_opt ::= ASC */
+   486,  /* (599) ordering_specification_opt ::= DESC */
+   487,  /* (600) null_ordering_opt ::= */
+   487,  /* (601) null_ordering_opt ::= NULLS FIRST */
+   487,  /* (602) null_ordering_opt ::= NULLS LAST */
 };
 
 /* For rule J, yyRuleInfoNRhs[J] contains the negative of the number
@@ -4357,13 +4368,13 @@ static const signed char yyRuleInfoNRhs[] = {
    -3,  /* (157) cmd ::= ALTER TABLE alter_table_clause */
    -3,  /* (158) cmd ::= ALTER STABLE alter_table_clause */
    -2,  /* (159) alter_table_clause ::= full_table_name alter_table_options */
-   -5,  /* (160) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */
+   -4,  /* (160) alter_table_clause ::= full_table_name ADD COLUMN column_def */
    -4,  /* (161) alter_table_clause ::= full_table_name DROP COLUMN column_name */
-   -5,  /* (162) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */
+   -4,  /* (162) alter_table_clause ::= full_table_name MODIFY COLUMN column_def */
    -5,  /* (163) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */
-   -5,  /* (164) alter_table_clause ::= full_table_name ADD TAG column_name type_name */
+   -4,  /* (164) alter_table_clause ::= full_table_name ADD TAG column_def */
    -4,  /* (165) alter_table_clause ::= full_table_name DROP TAG column_name */
-   -5,  /* (166) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */
+   -4,  /* (166) alter_table_clause ::= full_table_name MODIFY TAG column_def */
    -5,  /* (167) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */
    -6,  /* (168) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */
    -1,  /* (169) multi_create_clause ::= create_subtable_clause */
@@ -4379,426 +4390,427 @@ static const signed char yyRuleInfoNRhs[] = {
    -1,  /* (179) column_def_list ::= column_def */
    -3,  /* (180) column_def_list ::= column_def_list NK_COMMA column_def */
    -2,  /* (181) column_def ::= column_name type_name */
-   -1,  /* (182) type_name ::= BOOL */
-   -1,  /* (183) type_name ::= TINYINT */
-   -1,  /* (184) type_name ::= SMALLINT */
-   -1,  /* (185) type_name ::= INT */
-   -1,  /* (186) type_name ::= INTEGER */
-   -1,  /* (187) type_name ::= BIGINT */
-   -1,  /* (188) type_name ::= FLOAT */
-   -1,  /* (189) type_name ::= DOUBLE */
-   -4,  /* (190) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */
-   -1,  /* (191) type_name ::= TIMESTAMP */
-   -4,  /* (192) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */
-   -2,  /* (193) type_name ::= TINYINT UNSIGNED */
-   -2,  /* (194) type_name ::= SMALLINT UNSIGNED */
-   -2,  /* (195) type_name ::= INT UNSIGNED */
-   -2,  /* (196) type_name ::= BIGINT UNSIGNED */
-   -1,  /* (197) type_name ::= JSON */
-   -4,  /* (198) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */
-   -1,  /* (199) type_name ::= MEDIUMBLOB */
-   -1,  /* (200) type_name ::= BLOB */
-   -4,  /* (201) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */
-   -4,  /* (202) type_name ::= GEOMETRY NK_LP NK_INTEGER NK_RP */
-   -1,  /* (203) type_name ::= DECIMAL */
-   -4,  /* (204) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */
-   -6,  /* (205) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */
-    0,  /* (206) tags_def_opt ::= */
-   -1,  /* (207) tags_def_opt ::= tags_def */
-   -4,  /* (208) tags_def ::= TAGS NK_LP column_def_list NK_RP */
-    0,  /* (209) table_options ::= */
-   -3,  /* (210) table_options ::= table_options COMMENT NK_STRING */
-   -3,  /* (211) table_options ::= table_options MAX_DELAY duration_list */
-   -3,  /* (212) table_options ::= table_options WATERMARK duration_list */
-   -5,  /* (213) table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */
-   -3,  /* (214) table_options ::= table_options TTL NK_INTEGER */
-   -5,  /* (215) table_options ::= table_options SMA NK_LP col_name_list NK_RP */
-   -3,  /* (216) table_options ::= table_options DELETE_MARK duration_list */
-   -1,  /* (217) alter_table_options ::= alter_table_option */
-   -2,  /* (218) alter_table_options ::= alter_table_options alter_table_option */
-   -2,  /* (219) alter_table_option ::= COMMENT NK_STRING */
-   -2,  /* (220) alter_table_option ::= TTL NK_INTEGER */
-   -1,  /* (221) duration_list ::= duration_literal */
-   -3,  /* (222) duration_list ::= duration_list NK_COMMA duration_literal */
-   -1,  /* (223) rollup_func_list ::= rollup_func_name */
-   -3,  /* (224) rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */
-   -1,  /* (225) rollup_func_name ::= function_name */
-   -1,  /* (226) rollup_func_name ::= FIRST */
-   -1,  /* (227) rollup_func_name ::= LAST */
-   -1,  /* (228) col_name_list ::= col_name */
-   -3,  /* (229) col_name_list ::= col_name_list NK_COMMA col_name */
-   -1,  /* (230) col_name ::= column_name */
-   -2,  /* (231) cmd ::= SHOW DNODES */
-   -2,  /* (232) cmd ::= SHOW USERS */
-   -3,  /* (233) cmd ::= SHOW USER PRIVILEGES */
-   -2,  /* (234) cmd ::= SHOW DATABASES */
-   -4,  /* (235) cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */
-   -4,  /* (236) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */
-   -3,  /* (237) cmd ::= SHOW db_name_cond_opt VGROUPS */
-   -2,  /* (238) cmd ::= SHOW MNODES */
-   -2,  /* (239) cmd ::= SHOW QNODES */
-   -2,  /* (240) cmd ::= SHOW FUNCTIONS */
-   -5,  /* (241) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */
-   -6,  /* (242) cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name */
-   -2,  /* (243) cmd ::= SHOW STREAMS */
-   -2,  /* (244) cmd ::= SHOW ACCOUNTS */
-   -2,  /* (245) cmd ::= SHOW APPS */
-   -2,  /* (246) cmd ::= SHOW CONNECTIONS */
-   -2,  /* (247) cmd ::= SHOW LICENCES */
-   -2,  /* (248) cmd ::= SHOW GRANTS */
-   -4,  /* (249) cmd ::= SHOW CREATE DATABASE db_name */
-   -4,  /* (250) cmd ::= SHOW CREATE TABLE full_table_name */
-   -4,  /* (251) cmd ::= SHOW CREATE STABLE full_table_name */
-   -2,  /* (252) cmd ::= SHOW QUERIES */
-   -2,  /* (253) cmd ::= SHOW SCORES */
-   -2,  /* (254) cmd ::= SHOW TOPICS */
-   -2,  /* (255) cmd ::= SHOW VARIABLES */
-   -3,  /* (256) cmd ::= SHOW CLUSTER VARIABLES */
-   -3,  /* (257) cmd ::= SHOW LOCAL VARIABLES */
-   -5,  /* (258) cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */
-   -2,  /* (259) cmd ::= SHOW BNODES */
-   -2,  /* (260) cmd ::= SHOW SNODES */
-   -2,  /* (261) cmd ::= SHOW CLUSTER */
-   -2,  /* (262) cmd ::= SHOW TRANSACTIONS */
-   -4,  /* (263) cmd ::= SHOW TABLE DISTRIBUTED full_table_name */
-   -2,  /* (264) cmd ::= SHOW CONSUMERS */
-   -2,  /* (265) cmd ::= SHOW SUBSCRIPTIONS */
-   -5,  /* (266) cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */
-   -6,  /* (267) cmd ::= SHOW TAGS FROM db_name NK_DOT table_name */
-   -7,  /* (268) cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */
-   -8,  /* (269) cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name */
-   -3,  /* (270) cmd ::= SHOW VNODES NK_INTEGER */
-   -3,  /* (271) cmd ::= SHOW VNODES NK_STRING */
-   -3,  /* (272) cmd ::= SHOW db_name_cond_opt ALIVE */
-   -3,  /* (273) cmd ::= SHOW CLUSTER ALIVE */
-    0,  /* (274) db_name_cond_opt ::= */
-   -2,  /* (275) db_name_cond_opt ::= db_name NK_DOT */
-    0,  /* (276) like_pattern_opt ::= */
-   -2,  /* (277) like_pattern_opt ::= LIKE NK_STRING */
-   -1,  /* (278) table_name_cond ::= table_name */
-    0,  /* (279) from_db_opt ::= */
-   -2,  /* (280) from_db_opt ::= FROM db_name */
-    0,  /* (281) tag_list_opt ::= */
-   -1,  /* (282) tag_list_opt ::= tag_item */
-   -3,  /* (283) tag_list_opt ::= tag_list_opt NK_COMMA tag_item */
-   -1,  /* (284) tag_item ::= TBNAME */
-   -1,  /* (285) tag_item ::= QTAGS */
-   -1,  /* (286) tag_item ::= column_name */
-   -2,  /* (287) tag_item ::= column_name column_alias */
-   -3,  /* (288) tag_item ::= column_name AS column_alias */
-   -8,  /* (289) cmd ::= CREATE SMA INDEX not_exists_opt full_index_name ON full_table_name index_options */
-   -9,  /* (290) cmd ::= CREATE INDEX not_exists_opt full_index_name ON full_table_name NK_LP col_name_list NK_RP */
-   -4,  /* (291) cmd ::= DROP INDEX exists_opt full_index_name */
-   -1,  /* (292) full_index_name ::= index_name */
-   -3,  /* (293) full_index_name ::= db_name NK_DOT index_name */
-  -10,  /* (294) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */
-  -12,  /* (295) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt sma_stream_opt */
-   -1,  /* (296) func_list ::= func */
-   -3,  /* (297) func_list ::= func_list NK_COMMA func */
-   -4,  /* (298) func ::= sma_func_name NK_LP expression_list NK_RP */
-   -1,  /* (299) sma_func_name ::= function_name */
-   -1,  /* (300) sma_func_name ::= COUNT */
-   -1,  /* (301) sma_func_name ::= FIRST */
-   -1,  /* (302) sma_func_name ::= LAST */
-   -1,  /* (303) sma_func_name ::= LAST_ROW */
-    0,  /* (304) sma_stream_opt ::= */
-   -3,  /* (305) sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */
-   -3,  /* (306) sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */
-   -3,  /* (307) sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */
-   -1,  /* (308) with_meta ::= AS */
-   -3,  /* (309) with_meta ::= WITH META AS */
-   -3,  /* (310) with_meta ::= ONLY META AS */
-   -6,  /* (311) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */
-   -7,  /* (312) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name */
-   -8,  /* (313) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt */
-   -4,  /* (314) cmd ::= DROP TOPIC exists_opt topic_name */
-   -7,  /* (315) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */
-   -2,  /* (316) cmd ::= DESC full_table_name */
-   -2,  /* (317) cmd ::= DESCRIBE full_table_name */
-   -3,  /* (318) cmd ::= RESET QUERY CACHE */
-   -4,  /* (319) cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */
-   -4,  /* (320) cmd ::= EXPLAIN analyze_opt explain_options insert_query */
-    0,  /* (321) analyze_opt ::= */
-   -1,  /* (322) analyze_opt ::= ANALYZE */
-    0,  /* (323) explain_options ::= */
-   -3,  /* (324) explain_options ::= explain_options VERBOSE NK_BOOL */
-   -3,  /* (325) explain_options ::= explain_options RATIO NK_FLOAT */
-  -12,  /* (326) cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt */
-   -4,  /* (327) cmd ::= DROP FUNCTION exists_opt function_name */
-    0,  /* (328) agg_func_opt ::= */
-   -1,  /* (329) agg_func_opt ::= AGGREGATE */
-    0,  /* (330) bufsize_opt ::= */
-   -2,  /* (331) bufsize_opt ::= BUFSIZE NK_INTEGER */
-    0,  /* (332) language_opt ::= */
-   -2,  /* (333) language_opt ::= LANGUAGE NK_STRING */
-    0,  /* (334) or_replace_opt ::= */
-   -2,  /* (335) or_replace_opt ::= OR REPLACE */
-  -12,  /* (336) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name col_list_opt tag_def_or_ref_opt subtable_opt AS query_or_subquery */
-   -4,  /* (337) cmd ::= DROP STREAM exists_opt stream_name */
-   -4,  /* (338) cmd ::= PAUSE STREAM exists_opt stream_name */
-   -5,  /* (339) cmd ::= RESUME STREAM exists_opt ignore_opt stream_name */
-    0,  /* (340) col_list_opt ::= */
-   -3,  /* (341) col_list_opt ::= NK_LP col_name_list NK_RP */
-    0,  /* (342) tag_def_or_ref_opt ::= */
-   -1,  /* (343) tag_def_or_ref_opt ::= tags_def */
-   -4,  /* (344) tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP */
-    0,  /* (345) stream_options ::= */
-   -3,  /* (346) stream_options ::= stream_options TRIGGER AT_ONCE */
-   -3,  /* (347) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */
-   -4,  /* (348) stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */
-   -3,  /* (349) stream_options ::= stream_options WATERMARK duration_literal */
-   -4,  /* (350) stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */
-   -3,  /* (351) stream_options ::= stream_options FILL_HISTORY NK_INTEGER */
-   -3,  /* (352) stream_options ::= stream_options DELETE_MARK duration_literal */
-   -4,  /* (353) stream_options ::= stream_options IGNORE UPDATE NK_INTEGER */
-    0,  /* (354) subtable_opt ::= */
-   -4,  /* (355) subtable_opt ::= SUBTABLE NK_LP expression NK_RP */
-    0,  /* (356) ignore_opt ::= */
-   -2,  /* (357) ignore_opt ::= IGNORE UNTREATED */
-   -3,  /* (358) cmd ::= KILL CONNECTION NK_INTEGER */
-   -3,  /* (359) cmd ::= KILL QUERY NK_STRING */
-   -3,  /* (360) cmd ::= KILL TRANSACTION NK_INTEGER */
-   -2,  /* (361) cmd ::= BALANCE VGROUP */
-   -3,  /* (362) cmd ::= BALANCE VGROUP LEADER */
-   -4,  /* (363) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */
-   -4,  /* (364) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */
-   -3,  /* (365) cmd ::= SPLIT VGROUP NK_INTEGER */
-   -2,  /* (366) dnode_list ::= DNODE NK_INTEGER */
-   -3,  /* (367) dnode_list ::= dnode_list DNODE NK_INTEGER */
-   -4,  /* (368) cmd ::= DELETE FROM full_table_name where_clause_opt */
-   -1,  /* (369) cmd ::= query_or_subquery */
-   -1,  /* (370) cmd ::= insert_query */
-   -7,  /* (371) insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */
-   -4,  /* (372) insert_query ::= INSERT INTO full_table_name query_or_subquery */
-   -1,  /* (373) literal ::= NK_INTEGER */
-   -1,  /* (374) literal ::= NK_FLOAT */
-   -1,  /* (375) literal ::= NK_STRING */
-   -1,  /* (376) literal ::= NK_BOOL */
-   -2,  /* (377) literal ::= TIMESTAMP NK_STRING */
-   -1,  /* (378) literal ::= duration_literal */
-   -1,  /* (379) literal ::= NULL */
-   -1,  /* (380) literal ::= NK_QUESTION */
-   -1,  /* (381) duration_literal ::= NK_VARIABLE */
-   -1,  /* (382) signed ::= NK_INTEGER */
-   -2,  /* (383) signed ::= NK_PLUS NK_INTEGER */
-   -2,  /* (384) signed ::= NK_MINUS NK_INTEGER */
-   -1,  /* (385) signed ::= NK_FLOAT */
-   -2,  /* (386) signed ::= NK_PLUS NK_FLOAT */
-   -2,  /* (387) signed ::= NK_MINUS NK_FLOAT */
-   -1,  /* (388) signed_literal ::= signed */
-   -1,  /* (389) signed_literal ::= NK_STRING */
-   -1,  /* (390) signed_literal ::= NK_BOOL */
-   -2,  /* (391) signed_literal ::= TIMESTAMP NK_STRING */
-   -1,  /* (392) signed_literal ::= duration_literal */
-   -1,  /* (393) signed_literal ::= NULL */
-   -1,  /* (394) signed_literal ::= literal_func */
-   -1,  /* (395) signed_literal ::= NK_QUESTION */
-   -1,  /* (396) literal_list ::= signed_literal */
-   -3,  /* (397) literal_list ::= literal_list NK_COMMA signed_literal */
-   -1,  /* (398) db_name ::= NK_ID */
-   -1,  /* (399) table_name ::= NK_ID */
-   -1,  /* (400) column_name ::= NK_ID */
-   -1,  /* (401) function_name ::= NK_ID */
-   -1,  /* (402) table_alias ::= NK_ID */
-   -1,  /* (403) column_alias ::= NK_ID */
-   -1,  /* (404) user_name ::= NK_ID */
-   -1,  /* (405) topic_name ::= NK_ID */
-   -1,  /* (406) stream_name ::= NK_ID */
-   -1,  /* (407) cgroup_name ::= NK_ID */
-   -1,  /* (408) index_name ::= NK_ID */
-   -1,  /* (409) expr_or_subquery ::= expression */
-   -1,  /* (410) expression ::= literal */
-   -1,  /* (411) expression ::= pseudo_column */
-   -1,  /* (412) expression ::= column_reference */
-   -1,  /* (413) expression ::= function_expression */
-   -1,  /* (414) expression ::= case_when_expression */
-   -3,  /* (415) expression ::= NK_LP expression NK_RP */
-   -2,  /* (416) expression ::= NK_PLUS expr_or_subquery */
-   -2,  /* (417) expression ::= NK_MINUS expr_or_subquery */
-   -3,  /* (418) expression ::= expr_or_subquery NK_PLUS expr_or_subquery */
-   -3,  /* (419) expression ::= expr_or_subquery NK_MINUS expr_or_subquery */
-   -3,  /* (420) expression ::= expr_or_subquery NK_STAR expr_or_subquery */
-   -3,  /* (421) expression ::= expr_or_subquery NK_SLASH expr_or_subquery */
-   -3,  /* (422) expression ::= expr_or_subquery NK_REM expr_or_subquery */
-   -3,  /* (423) expression ::= column_reference NK_ARROW NK_STRING */
-   -3,  /* (424) expression ::= expr_or_subquery NK_BITAND expr_or_subquery */
-   -3,  /* (425) expression ::= expr_or_subquery NK_BITOR expr_or_subquery */
-   -1,  /* (426) expression_list ::= expr_or_subquery */
-   -3,  /* (427) expression_list ::= expression_list NK_COMMA expr_or_subquery */
-   -1,  /* (428) column_reference ::= column_name */
-   -3,  /* (429) column_reference ::= table_name NK_DOT column_name */
-   -1,  /* (430) pseudo_column ::= ROWTS */
-   -1,  /* (431) pseudo_column ::= TBNAME */
-   -3,  /* (432) pseudo_column ::= table_name NK_DOT TBNAME */
-   -1,  /* (433) pseudo_column ::= QSTART */
-   -1,  /* (434) pseudo_column ::= QEND */
-   -1,  /* (435) pseudo_column ::= QDURATION */
-   -1,  /* (436) pseudo_column ::= WSTART */
-   -1,  /* (437) pseudo_column ::= WEND */
-   -1,  /* (438) pseudo_column ::= WDURATION */
-   -1,  /* (439) pseudo_column ::= IROWTS */
-   -1,  /* (440) pseudo_column ::= ISFILLED */
-   -1,  /* (441) pseudo_column ::= QTAGS */
-   -4,  /* (442) function_expression ::= function_name NK_LP expression_list NK_RP */
-   -4,  /* (443) function_expression ::= star_func NK_LP star_func_para_list NK_RP */
-   -6,  /* (444) function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */
-   -1,  /* (445) function_expression ::= literal_func */
-   -3,  /* (446) literal_func ::= noarg_func NK_LP NK_RP */
-   -1,  /* (447) literal_func ::= NOW */
-   -1,  /* (448) noarg_func ::= NOW */
-   -1,  /* (449) noarg_func ::= TODAY */
-   -1,  /* (450) noarg_func ::= TIMEZONE */
-   -1,  /* (451) noarg_func ::= DATABASE */
-   -1,  /* (452) noarg_func ::= CLIENT_VERSION */
-   -1,  /* (453) noarg_func ::= SERVER_VERSION */
-   -1,  /* (454) noarg_func ::= SERVER_STATUS */
-   -1,  /* (455) noarg_func ::= CURRENT_USER */
-   -1,  /* (456) noarg_func ::= USER */
-   -1,  /* (457) star_func ::= COUNT */
-   -1,  /* (458) star_func ::= FIRST */
-   -1,  /* (459) star_func ::= LAST */
-   -1,  /* (460) star_func ::= LAST_ROW */
-   -1,  /* (461) star_func_para_list ::= NK_STAR */
-   -1,  /* (462) star_func_para_list ::= other_para_list */
-   -1,  /* (463) other_para_list ::= star_func_para */
-   -3,  /* (464) other_para_list ::= other_para_list NK_COMMA star_func_para */
-   -1,  /* (465) star_func_para ::= expr_or_subquery */
-   -3,  /* (466) star_func_para ::= table_name NK_DOT NK_STAR */
-   -4,  /* (467) case_when_expression ::= CASE when_then_list case_when_else_opt END */
-   -5,  /* (468) case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */
-   -1,  /* (469) when_then_list ::= when_then_expr */
-   -2,  /* (470) when_then_list ::= when_then_list when_then_expr */
-   -4,  /* (471) when_then_expr ::= WHEN common_expression THEN common_expression */
-    0,  /* (472) case_when_else_opt ::= */
-   -2,  /* (473) case_when_else_opt ::= ELSE common_expression */
-   -3,  /* (474) predicate ::= expr_or_subquery compare_op expr_or_subquery */
-   -5,  /* (475) predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */
-   -6,  /* (476) predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */
-   -3,  /* (477) predicate ::= expr_or_subquery IS NULL */
-   -4,  /* (478) predicate ::= expr_or_subquery IS NOT NULL */
-   -3,  /* (479) predicate ::= expr_or_subquery in_op in_predicate_value */
-   -1,  /* (480) compare_op ::= NK_LT */
-   -1,  /* (481) compare_op ::= NK_GT */
-   -1,  /* (482) compare_op ::= NK_LE */
-   -1,  /* (483) compare_op ::= NK_GE */
-   -1,  /* (484) compare_op ::= NK_NE */
-   -1,  /* (485) compare_op ::= NK_EQ */
-   -1,  /* (486) compare_op ::= LIKE */
-   -2,  /* (487) compare_op ::= NOT LIKE */
-   -1,  /* (488) compare_op ::= MATCH */
-   -1,  /* (489) compare_op ::= NMATCH */
-   -1,  /* (490) compare_op ::= CONTAINS */
-   -1,  /* (491) in_op ::= IN */
-   -2,  /* (492) in_op ::= NOT IN */
-   -3,  /* (493) in_predicate_value ::= NK_LP literal_list NK_RP */
-   -1,  /* (494) boolean_value_expression ::= boolean_primary */
-   -2,  /* (495) boolean_value_expression ::= NOT boolean_primary */
-   -3,  /* (496) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
-   -3,  /* (497) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
-   -1,  /* (498) boolean_primary ::= predicate */
-   -3,  /* (499) boolean_primary ::= NK_LP boolean_value_expression NK_RP */
-   -1,  /* (500) common_expression ::= expr_or_subquery */
-   -1,  /* (501) common_expression ::= boolean_value_expression */
-    0,  /* (502) from_clause_opt ::= */
-   -2,  /* (503) from_clause_opt ::= FROM table_reference_list */
-   -1,  /* (504) table_reference_list ::= table_reference */
-   -3,  /* (505) table_reference_list ::= table_reference_list NK_COMMA table_reference */
-   -1,  /* (506) table_reference ::= table_primary */
-   -1,  /* (507) table_reference ::= joined_table */
-   -2,  /* (508) table_primary ::= table_name alias_opt */
-   -4,  /* (509) table_primary ::= db_name NK_DOT table_name alias_opt */
-   -2,  /* (510) table_primary ::= subquery alias_opt */
-   -1,  /* (511) table_primary ::= parenthesized_joined_table */
-    0,  /* (512) alias_opt ::= */
-   -1,  /* (513) alias_opt ::= table_alias */
-   -2,  /* (514) alias_opt ::= AS table_alias */
-   -3,  /* (515) parenthesized_joined_table ::= NK_LP joined_table NK_RP */
-   -3,  /* (516) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */
-   -6,  /* (517) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
-    0,  /* (518) join_type ::= */
-   -1,  /* (519) join_type ::= INNER */
-  -13,  /* (520) query_specification ::= SELECT tag_mode_opt set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
-    0,  /* (521) tag_mode_opt ::= */
-   -1,  /* (522) tag_mode_opt ::= TAGS */
-    0,  /* (523) set_quantifier_opt ::= */
-   -1,  /* (524) set_quantifier_opt ::= DISTINCT */
-   -1,  /* (525) set_quantifier_opt ::= ALL */
-   -1,  /* (526) select_list ::= select_item */
-   -3,  /* (527) select_list ::= select_list NK_COMMA select_item */
-   -1,  /* (528) select_item ::= NK_STAR */
-   -1,  /* (529) select_item ::= common_expression */
-   -2,  /* (530) select_item ::= common_expression column_alias */
-   -3,  /* (531) select_item ::= common_expression AS column_alias */
-   -3,  /* (532) select_item ::= table_name NK_DOT NK_STAR */
-    0,  /* (533) where_clause_opt ::= */
-   -2,  /* (534) where_clause_opt ::= WHERE search_condition */
-    0,  /* (535) partition_by_clause_opt ::= */
-   -3,  /* (536) partition_by_clause_opt ::= PARTITION BY partition_list */
-   -1,  /* (537) partition_list ::= partition_item */
-   -3,  /* (538) partition_list ::= partition_list NK_COMMA partition_item */
-   -1,  /* (539) partition_item ::= expr_or_subquery */
-   -2,  /* (540) partition_item ::= expr_or_subquery column_alias */
-   -3,  /* (541) partition_item ::= expr_or_subquery AS column_alias */
-    0,  /* (542) twindow_clause_opt ::= */
-   -6,  /* (543) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
-   -4,  /* (544) twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */
-   -6,  /* (545) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
-   -8,  /* (546) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
-   -7,  /* (547) twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */
-    0,  /* (548) sliding_opt ::= */
-   -4,  /* (549) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
-    0,  /* (550) fill_opt ::= */
-   -4,  /* (551) fill_opt ::= FILL NK_LP fill_mode NK_RP */
-   -6,  /* (552) fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */
-   -6,  /* (553) fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */
-   -1,  /* (554) fill_mode ::= NONE */
-   -1,  /* (555) fill_mode ::= PREV */
-   -1,  /* (556) fill_mode ::= NULL */
-   -1,  /* (557) fill_mode ::= NULL_F */
-   -1,  /* (558) fill_mode ::= LINEAR */
-   -1,  /* (559) fill_mode ::= NEXT */
-    0,  /* (560) group_by_clause_opt ::= */
-   -3,  /* (561) group_by_clause_opt ::= GROUP BY group_by_list */
-   -1,  /* (562) group_by_list ::= expr_or_subquery */
-   -3,  /* (563) group_by_list ::= group_by_list NK_COMMA expr_or_subquery */
-    0,  /* (564) having_clause_opt ::= */
-   -2,  /* (565) having_clause_opt ::= HAVING search_condition */
-    0,  /* (566) range_opt ::= */
-   -6,  /* (567) range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */
-   -4,  /* (568) range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */
-    0,  /* (569) every_opt ::= */
-   -4,  /* (570) every_opt ::= EVERY NK_LP duration_literal NK_RP */
-   -4,  /* (571) query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */
-   -1,  /* (572) query_simple ::= query_specification */
-   -1,  /* (573) query_simple ::= union_query_expression */
-   -4,  /* (574) union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */
-   -3,  /* (575) union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */
-   -1,  /* (576) query_simple_or_subquery ::= query_simple */
-   -1,  /* (577) query_simple_or_subquery ::= subquery */
-   -1,  /* (578) query_or_subquery ::= query_expression */
-   -1,  /* (579) query_or_subquery ::= subquery */
-    0,  /* (580) order_by_clause_opt ::= */
-   -3,  /* (581) order_by_clause_opt ::= ORDER BY sort_specification_list */
-    0,  /* (582) slimit_clause_opt ::= */
-   -2,  /* (583) slimit_clause_opt ::= SLIMIT NK_INTEGER */
-   -4,  /* (584) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
-   -4,  /* (585) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
-    0,  /* (586) limit_clause_opt ::= */
-   -2,  /* (587) limit_clause_opt ::= LIMIT NK_INTEGER */
-   -4,  /* (588) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */
-   -4,  /* (589) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */
-   -3,  /* (590) subquery ::= NK_LP query_expression NK_RP */
-   -3,  /* (591) subquery ::= NK_LP subquery NK_RP */
-   -1,  /* (592) search_condition ::= common_expression */
-   -1,  /* (593) sort_specification_list ::= sort_specification */
-   -3,  /* (594) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */
-   -3,  /* (595) sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */
-    0,  /* (596) ordering_specification_opt ::= */
-   -1,  /* (597) ordering_specification_opt ::= ASC */
-   -1,  /* (598) ordering_specification_opt ::= DESC */
-    0,  /* (599) null_ordering_opt ::= */
-   -2,  /* (600) null_ordering_opt ::= NULLS FIRST */
-   -2,  /* (601) null_ordering_opt ::= NULLS LAST */
+   -4,  /* (182) column_def ::= column_name type_name COMMENT NK_STRING */
+   -1,  /* (183) type_name ::= BOOL */
+   -1,  /* (184) type_name ::= TINYINT */
+   -1,  /* (185) type_name ::= SMALLINT */
+   -1,  /* (186) type_name ::= INT */
+   -1,  /* (187) type_name ::= INTEGER */
+   -1,  /* (188) type_name ::= BIGINT */
+   -1,  /* (189) type_name ::= FLOAT */
+   -1,  /* (190) type_name ::= DOUBLE */
+   -4,  /* (191) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */
+   -1,  /* (192) type_name ::= TIMESTAMP */
+   -4,  /* (193) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */
+   -2,  /* (194) type_name ::= TINYINT UNSIGNED */
+   -2,  /* (195) type_name ::= SMALLINT UNSIGNED */
+   -2,  /* (196) type_name ::= INT UNSIGNED */
+   -2,  /* (197) type_name ::= BIGINT UNSIGNED */
+   -1,  /* (198) type_name ::= JSON */
+   -4,  /* (199) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */
+   -1,  /* (200) type_name ::= MEDIUMBLOB */
+   -1,  /* (201) type_name ::= BLOB */
+   -4,  /* (202) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */
+   -4,  /* (203) type_name ::= GEOMETRY NK_LP NK_INTEGER NK_RP */
+   -1,  /* (204) type_name ::= DECIMAL */
+   -4,  /* (205) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */
+   -6,  /* (206) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */
+    0,  /* (207) tags_def_opt ::= */
+   -1,  /* (208) tags_def_opt ::= tags_def */
+   -4,  /* (209) tags_def ::= TAGS NK_LP column_def_list NK_RP */
+    0,  /* (210) table_options ::= */
+   -3,  /* (211) table_options ::= table_options COMMENT NK_STRING */
+   -3,  /* (212) table_options ::= table_options MAX_DELAY duration_list */
+   -3,  /* (213) table_options ::= table_options WATERMARK duration_list */
+   -5,  /* (214) table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */
+   -3,  /* (215) table_options ::= table_options TTL NK_INTEGER */
+   -5,  /* (216) table_options ::= table_options SMA NK_LP col_name_list NK_RP */
+   -3,  /* (217) table_options ::= table_options DELETE_MARK duration_list */
+   -1,  /* (218) alter_table_options ::= alter_table_option */
+   -2,  /* (219) alter_table_options ::= alter_table_options alter_table_option */
+   -2,  /* (220) alter_table_option ::= COMMENT NK_STRING */
+   -2,  /* (221) alter_table_option ::= TTL NK_INTEGER */
+   -1,  /* (222) duration_list ::= duration_literal */
+   -3,  /* (223) duration_list ::= duration_list NK_COMMA duration_literal */
+   -1,  /* (224) rollup_func_list ::= rollup_func_name */
+   -3,  /* (225) rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */
+   -1,  /* (226) rollup_func_name ::= function_name */
+   -1,  /* (227) rollup_func_name ::= FIRST */
+   -1,  /* (228) rollup_func_name ::= LAST */
+   -1,  /* (229) col_name_list ::= col_name */
+   -3,  /* (230) col_name_list ::= col_name_list NK_COMMA col_name */
+   -1,  /* (231) col_name ::= column_name */
+   -2,  /* (232) cmd ::= SHOW DNODES */
+   -2,  /* (233) cmd ::= SHOW USERS */
+   -3,  /* (234) cmd ::= SHOW USER PRIVILEGES */
+   -2,  /* (235) cmd ::= SHOW DATABASES */
+   -4,  /* (236) cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */
+   -4,  /* (237) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */
+   -3,  /* (238) cmd ::= SHOW db_name_cond_opt VGROUPS */
+   -2,  /* (239) cmd ::= SHOW MNODES */
+   -2,  /* (240) cmd ::= SHOW QNODES */
+   -2,  /* (241) cmd ::= SHOW FUNCTIONS */
+   -5,  /* (242) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */
+   -6,  /* (243) cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name */
+   -2,  /* (244) cmd ::= SHOW STREAMS */
+   -2,  /* (245) cmd ::= SHOW ACCOUNTS */
+   -2,  /* (246) cmd ::= SHOW APPS */
+   -2,  /* (247) cmd ::= SHOW CONNECTIONS */
+   -2,  /* (248) cmd ::= SHOW LICENCES */
+   -2,  /* (249) cmd ::= SHOW GRANTS */
+   -4,  /* (250) cmd ::= SHOW CREATE DATABASE db_name */
+   -4,  /* (251) cmd ::= SHOW CREATE TABLE full_table_name */
+   -4,  /* (252) cmd ::= SHOW CREATE STABLE full_table_name */
+   -2,  /* (253) cmd ::= SHOW QUERIES */
+   -2,  /* (254) cmd ::= SHOW SCORES */
+   -2,  /* (255) cmd ::= SHOW TOPICS */
+   -2,  /* (256) cmd ::= SHOW VARIABLES */
+   -3,  /* (257) cmd ::= SHOW CLUSTER VARIABLES */
+   -3,  /* (258) cmd ::= SHOW LOCAL VARIABLES */
+   -5,  /* (259) cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */
+   -2,  /* (260) cmd ::= SHOW BNODES */
+   -2,  /* (261) cmd ::= SHOW SNODES */
+   -2,  /* (262) cmd ::= SHOW CLUSTER */
+   -2,  /* (263) cmd ::= SHOW TRANSACTIONS */
+   -4,  /* (264) cmd ::= SHOW TABLE DISTRIBUTED full_table_name */
+   -2,  /* (265) cmd ::= SHOW CONSUMERS */
+   -2,  /* (266) cmd ::= SHOW SUBSCRIPTIONS */
+   -5,  /* (267) cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */
+   -6,  /* (268) cmd ::= SHOW TAGS FROM db_name NK_DOT table_name */
+   -7,  /* (269) cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */
+   -8,  /* (270) cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name */
+   -3,  /* (271) cmd ::= SHOW VNODES NK_INTEGER */
+   -3,  /* (272) cmd ::= SHOW VNODES NK_STRING */
+   -3,  /* (273) cmd ::= SHOW db_name_cond_opt ALIVE */
+   -3,  /* (274) cmd ::= SHOW CLUSTER ALIVE */
+    0,  /* (275) db_name_cond_opt ::= */
+   -2,  /* (276) db_name_cond_opt ::= db_name NK_DOT */
+    0,  /* (277) like_pattern_opt ::= */
+   -2,  /* (278) like_pattern_opt ::= LIKE NK_STRING */
+   -1,  /* (279) table_name_cond ::= table_name */
+    0,  /* (280) from_db_opt ::= */
+   -2,  /* (281) from_db_opt ::= FROM db_name */
+    0,  /* (282) tag_list_opt ::= */
+   -1,  /* (283) tag_list_opt ::= tag_item */
+   -3,  /* (284) tag_list_opt ::= tag_list_opt NK_COMMA tag_item */
+   -1,  /* (285) tag_item ::= TBNAME */
+   -1,  /* (286) tag_item ::= QTAGS */
+   -1,  /* (287) tag_item ::= column_name */
+   -2,  /* (288) tag_item ::= column_name column_alias */
+   -3,  /* (289) tag_item ::= column_name AS column_alias */
+   -8,  /* (290) cmd ::= CREATE SMA INDEX not_exists_opt full_index_name ON full_table_name index_options */
+   -9,  /* (291) cmd ::= CREATE INDEX not_exists_opt full_index_name ON full_table_name NK_LP col_name_list NK_RP */
+   -4,  /* (292) cmd ::= DROP INDEX exists_opt full_index_name */
+   -1,  /* (293) full_index_name ::= index_name */
+   -3,  /* (294) full_index_name ::= db_name NK_DOT index_name */
+  -10,  /* (295) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */
+  -12,  /* (296) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt sma_stream_opt */
+   -1,  /* (297) func_list ::= func */
+   -3,  /* (298) func_list ::= func_list NK_COMMA func */
+   -4,  /* (299) func ::= sma_func_name NK_LP expression_list NK_RP */
+   -1,  /* (300) sma_func_name ::= function_name */
+   -1,  /* (301) sma_func_name ::= COUNT */
+   -1,  /* (302) sma_func_name ::= FIRST */
+   -1,  /* (303) sma_func_name ::= LAST */
+   -1,  /* (304) sma_func_name ::= LAST_ROW */
+    0,  /* (305) sma_stream_opt ::= */
+   -3,  /* (306) sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */
+   -3,  /* (307) sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */
+   -3,  /* (308) sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */
+   -1,  /* (309) with_meta ::= AS */
+   -3,  /* (310) with_meta ::= WITH META AS */
+   -3,  /* (311) with_meta ::= ONLY META AS */
+   -6,  /* (312) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */
+   -7,  /* (313) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name */
+   -8,  /* (314) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt */
+   -4,  /* (315) cmd ::= DROP TOPIC exists_opt topic_name */
+   -7,  /* (316) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */
+   -2,  /* (317) cmd ::= DESC full_table_name */
+   -2,  /* (318) cmd ::= DESCRIBE full_table_name */
+   -3,  /* (319) cmd ::= RESET QUERY CACHE */
+   -4,  /* (320) cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */
+   -4,  /* (321) cmd ::= EXPLAIN analyze_opt explain_options insert_query */
+    0,  /* (322) analyze_opt ::= */
+   -1,  /* (323) analyze_opt ::= ANALYZE */
+    0,  /* (324) explain_options ::= */
+   -3,  /* (325) explain_options ::= explain_options VERBOSE NK_BOOL */
+   -3,  /* (326) explain_options ::= explain_options RATIO NK_FLOAT */
+  -12,  /* (327) cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt */
+   -4,  /* (328) cmd ::= DROP FUNCTION exists_opt function_name */
+    0,  /* (329) agg_func_opt ::= */
+   -1,  /* (330) agg_func_opt ::= AGGREGATE */
+    0,  /* (331) bufsize_opt ::= */
+   -2,  /* (332) bufsize_opt ::= BUFSIZE NK_INTEGER */
+    0,  /* (333) language_opt ::= */
+   -2,  /* (334) language_opt ::= LANGUAGE NK_STRING */
+    0,  /* (335) or_replace_opt ::= */
+   -2,  /* (336) or_replace_opt ::= OR REPLACE */
+  -12,  /* (337) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name col_list_opt tag_def_or_ref_opt subtable_opt AS query_or_subquery */
+   -4,  /* (338) cmd ::= DROP STREAM exists_opt stream_name */
+   -4,  /* (339) cmd ::= PAUSE STREAM exists_opt stream_name */
+   -5,  /* (340) cmd ::= RESUME STREAM exists_opt ignore_opt stream_name */
+    0,  /* (341) col_list_opt ::= */
+   -3,  /* (342) col_list_opt ::= NK_LP col_name_list NK_RP */
+    0,  /* (343) tag_def_or_ref_opt ::= */
+   -1,  /* (344) tag_def_or_ref_opt ::= tags_def */
+   -4,  /* (345) tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP */
+    0,  /* (346) stream_options ::= */
+   -3,  /* (347) stream_options ::= stream_options TRIGGER AT_ONCE */
+   -3,  /* (348) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */
+   -4,  /* (349) stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */
+   -3,  /* (350) stream_options ::= stream_options WATERMARK duration_literal */
+   -4,  /* (351) stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */
+   -3,  /* (352) stream_options ::= stream_options FILL_HISTORY NK_INTEGER */
+   -3,  /* (353) stream_options ::= stream_options DELETE_MARK duration_literal */
+   -4,  /* (354) stream_options ::= stream_options IGNORE UPDATE NK_INTEGER */
+    0,  /* (355) subtable_opt ::= */
+   -4,  /* (356) subtable_opt ::= SUBTABLE NK_LP expression NK_RP */
+    0,  /* (357) ignore_opt ::= */
+   -2,  /* (358) ignore_opt ::= IGNORE UNTREATED */
+   -3,  /* (359) cmd ::= KILL CONNECTION NK_INTEGER */
+   -3,  /* (360) cmd ::= KILL QUERY NK_STRING */
+   -3,  /* (361) cmd ::= KILL TRANSACTION NK_INTEGER */
+   -2,  /* (362) cmd ::= BALANCE VGROUP */
+   -3,  /* (363) cmd ::= BALANCE VGROUP LEADER */
+   -4,  /* (364) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */
+   -4,  /* (365) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */
+   -3,  /* (366) cmd ::= SPLIT VGROUP NK_INTEGER */
+   -2,  /* (367) dnode_list ::= DNODE NK_INTEGER */
+   -3,  /* (368) dnode_list ::= dnode_list DNODE NK_INTEGER */
+   -4,  /* (369) cmd ::= DELETE FROM full_table_name where_clause_opt */
+   -1,  /* (370) cmd ::= query_or_subquery */
+   -1,  /* (371) cmd ::= insert_query */
+   -7,  /* (372) insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */
+   -4,  /* (373) insert_query ::= INSERT INTO full_table_name query_or_subquery */
+   -1,  /* (374) literal ::= NK_INTEGER */
+   -1,  /* (375) literal ::= NK_FLOAT */
+   -1,  /* (376) literal ::= NK_STRING */
+   -1,  /* (377) literal ::= NK_BOOL */
+   -2,  /* (378) literal ::= TIMESTAMP NK_STRING */
+   -1,  /* (379) literal ::= duration_literal */
+   -1,  /* (380) literal ::= NULL */
+   -1,  /* (381) literal ::= NK_QUESTION */
+   -1,  /* (382) duration_literal ::= NK_VARIABLE */
+   -1,  /* (383) signed ::= NK_INTEGER */
+   -2,  /* (384) signed ::= NK_PLUS NK_INTEGER */
+   -2,  /* (385) signed ::= NK_MINUS NK_INTEGER */
+   -1,  /* (386) signed ::= NK_FLOAT */
+   -2,  /* (387) signed ::= NK_PLUS NK_FLOAT */
+   -2,  /* (388) signed ::= NK_MINUS NK_FLOAT */
+   -1,  /* (389) signed_literal ::= signed */
+   -1,  /* (390) signed_literal ::= NK_STRING */
+   -1,  /* (391) signed_literal ::= NK_BOOL */
+   -2,  /* (392) signed_literal ::= TIMESTAMP NK_STRING */
+   -1,  /* (393) signed_literal ::= duration_literal */
+   -1,  /* (394) signed_literal ::= NULL */
+   -1,  /* (395) signed_literal ::= literal_func */
+   -1,  /* (396) signed_literal ::= NK_QUESTION */
+   -1,  /* (397) literal_list ::= signed_literal */
+   -3,  /* (398) literal_list ::= literal_list NK_COMMA signed_literal */
+   -1,  /* (399) db_name ::= NK_ID */
+   -1,  /* (400) table_name ::= NK_ID */
+   -1,  /* (401) column_name ::= NK_ID */
+   -1,  /* (402) function_name ::= NK_ID */
+   -1,  /* (403) table_alias ::= NK_ID */
+   -1,  /* (404) column_alias ::= NK_ID */
+   -1,  /* (405) user_name ::= NK_ID */
+   -1,  /* (406) topic_name ::= NK_ID */
+   -1,  /* (407) stream_name ::= NK_ID */
+   -1,  /* (408) cgroup_name ::= NK_ID */
+   -1,  /* (409) index_name ::= NK_ID */
+   -1,  /* (410) expr_or_subquery ::= expression */
+   -1,  /* (411) expression ::= literal */
+   -1,  /* (412) expression ::= pseudo_column */
+   -1,  /* (413) expression ::= column_reference */
+   -1,  /* (414) expression ::= function_expression */
+   -1,  /* (415) expression ::= case_when_expression */
+   -3,  /* (416) expression ::= NK_LP expression NK_RP */
+   -2,  /* (417) expression ::= NK_PLUS expr_or_subquery */
+   -2,  /* (418) expression ::= NK_MINUS expr_or_subquery */
+   -3,  /* (419) expression ::= expr_or_subquery NK_PLUS expr_or_subquery */
+   -3,  /* (420) expression ::= expr_or_subquery NK_MINUS expr_or_subquery */
+   -3,  /* (421) expression ::= expr_or_subquery NK_STAR expr_or_subquery */
+   -3,  /* (422) expression ::= expr_or_subquery NK_SLASH expr_or_subquery */
+   -3,  /* (423) expression ::= expr_or_subquery NK_REM expr_or_subquery */
+   -3,  /* (424) expression ::= column_reference NK_ARROW NK_STRING */
+   -3,  /* (425) expression ::= expr_or_subquery NK_BITAND expr_or_subquery */
+   -3,  /* (426) expression ::= expr_or_subquery NK_BITOR expr_or_subquery */
+   -1,  /* (427) expression_list ::= expr_or_subquery */
+   -3,  /* (428) expression_list ::= expression_list NK_COMMA expr_or_subquery */
+   -1,  /* (429) column_reference ::= column_name */
+   -3,  /* (430) column_reference ::= table_name NK_DOT column_name */
+   -1,  /* (431) pseudo_column ::= ROWTS */
+   -1,  /* (432) pseudo_column ::= TBNAME */
+   -3,  /* (433) pseudo_column ::= table_name NK_DOT TBNAME */
+   -1,  /* (434) pseudo_column ::= QSTART */
+   -1,  /* (435) pseudo_column ::= QEND */
+   -1,  /* (436) pseudo_column ::= QDURATION */
+   -1,  /* (437) pseudo_column ::= WSTART */
+   -1,  /* (438) pseudo_column ::= WEND */
+   -1,  /* (439) pseudo_column ::= WDURATION */
+   -1,  /* (440) pseudo_column ::= IROWTS */
+   -1,  /* (441) pseudo_column ::= ISFILLED */
+   -1,  /* (442) pseudo_column ::= QTAGS */
+   -4,  /* (443) function_expression ::= function_name NK_LP expression_list NK_RP */
+   -4,  /* (444) function_expression ::= star_func NK_LP star_func_para_list NK_RP */
+   -6,  /* (445) function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */
+   -1,  /* (446) function_expression ::= literal_func */
+   -3,  /* (447) literal_func ::= noarg_func NK_LP NK_RP */
+   -1,  /* (448) literal_func ::= NOW */
+   -1,  /* (449) noarg_func ::= NOW */
+   -1,  /* (450) noarg_func ::= TODAY */
+   -1,  /* (451) noarg_func ::= TIMEZONE */
+   -1,  /* (452) noarg_func ::= DATABASE */
+   -1,  /* (453) noarg_func ::= CLIENT_VERSION */
+   -1,  /* (454) noarg_func ::= SERVER_VERSION */
+   -1,  /* (455) noarg_func ::= SERVER_STATUS */
+   -1,  /* (456) noarg_func ::= CURRENT_USER */
+   -1,  /* (457) noarg_func ::= USER */
+   -1,  /* (458) star_func ::= COUNT */
+   -1,  /* (459) star_func ::= FIRST */
+   -1,  /* (460) star_func ::= LAST */
+   -1,  /* (461) star_func ::= LAST_ROW */
+   -1,  /* (462) star_func_para_list ::= NK_STAR */
+   -1,  /* (463) star_func_para_list ::= other_para_list */
+   -1,  /* (464) other_para_list ::= star_func_para */
+   -3,  /* (465) other_para_list ::= other_para_list NK_COMMA star_func_para */
+   -1,  /* (466) star_func_para ::= expr_or_subquery */
+   -3,  /* (467) star_func_para ::= table_name NK_DOT NK_STAR */
+   -4,  /* (468) case_when_expression ::= CASE when_then_list case_when_else_opt END */
+   -5,  /* (469) case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */
+   -1,  /* (470) when_then_list ::= when_then_expr */
+   -2,  /* (471) when_then_list ::= when_then_list when_then_expr */
+   -4,  /* (472) when_then_expr ::= WHEN common_expression THEN common_expression */
+    0,  /* (473) case_when_else_opt ::= */
+   -2,  /* (474) case_when_else_opt ::= ELSE common_expression */
+   -3,  /* (475) predicate ::= expr_or_subquery compare_op expr_or_subquery */
+   -5,  /* (476) predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */
+   -6,  /* (477) predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */
+   -3,  /* (478) predicate ::= expr_or_subquery IS NULL */
+   -4,  /* (479) predicate ::= expr_or_subquery IS NOT NULL */
+   -3,  /* (480) predicate ::= expr_or_subquery in_op in_predicate_value */
+   -1,  /* (481) compare_op ::= NK_LT */
+   -1,  /* (482) compare_op ::= NK_GT */
+   -1,  /* (483) compare_op ::= NK_LE */
+   -1,  /* (484) compare_op ::= NK_GE */
+   -1,  /* (485) compare_op ::= NK_NE */
+   -1,  /* (486) compare_op ::= NK_EQ */
+   -1,  /* (487) compare_op ::= LIKE */
+   -2,  /* (488) compare_op ::= NOT LIKE */
+   -1,  /* (489) compare_op ::= MATCH */
+   -1,  /* (490) compare_op ::= NMATCH */
+   -1,  /* (491) compare_op ::= CONTAINS */
+   -1,  /* (492) in_op ::= IN */
+   -2,  /* (493) in_op ::= NOT IN */
+   -3,  /* (494) in_predicate_value ::= NK_LP literal_list NK_RP */
+   -1,  /* (495) boolean_value_expression ::= boolean_primary */
+   -2,  /* (496) boolean_value_expression ::= NOT boolean_primary */
+   -3,  /* (497) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
+   -3,  /* (498) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
+   -1,  /* (499) boolean_primary ::= predicate */
+   -3,  /* (500) boolean_primary ::= NK_LP boolean_value_expression NK_RP */
+   -1,  /* (501) common_expression ::= expr_or_subquery */
+   -1,  /* (502) common_expression ::= boolean_value_expression */
+    0,  /* (503) from_clause_opt ::= */
+   -2,  /* (504) from_clause_opt ::= FROM table_reference_list */
+   -1,  /* (505) table_reference_list ::= table_reference */
+   -3,  /* (506) table_reference_list ::= table_reference_list NK_COMMA table_reference */
+   -1,  /* (507) table_reference ::= table_primary */
+   -1,  /* (508) table_reference ::= joined_table */
+   -2,  /* (509) table_primary ::= table_name alias_opt */
+   -4,  /* (510) table_primary ::= db_name NK_DOT table_name alias_opt */
+   -2,  /* (511) table_primary ::= subquery alias_opt */
+   -1,  /* (512) table_primary ::= parenthesized_joined_table */
+    0,  /* (513) alias_opt ::= */
+   -1,  /* (514) alias_opt ::= table_alias */
+   -2,  /* (515) alias_opt ::= AS table_alias */
+   -3,  /* (516) parenthesized_joined_table ::= NK_LP joined_table NK_RP */
+   -3,  /* (517) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */
+   -6,  /* (518) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
+    0,  /* (519) join_type ::= */
+   -1,  /* (520) join_type ::= INNER */
+  -13,  /* (521) query_specification ::= SELECT tag_mode_opt set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
+    0,  /* (522) tag_mode_opt ::= */
+   -1,  /* (523) tag_mode_opt ::= TAGS */
+    0,  /* (524) set_quantifier_opt ::= */
+   -1,  /* (525) set_quantifier_opt ::= DISTINCT */
+   -1,  /* (526) set_quantifier_opt ::= ALL */
+   -1,  /* (527) select_list ::= select_item */
+   -3,  /* (528) select_list ::= select_list NK_COMMA select_item */
+   -1,  /* (529) select_item ::= NK_STAR */
+   -1,  /* (530) select_item ::= common_expression */
+   -2,  /* (531) select_item ::= common_expression column_alias */
+   -3,  /* (532) select_item ::= common_expression AS column_alias */
+   -3,  /* (533) select_item ::= table_name NK_DOT NK_STAR */
+    0,  /* (534) where_clause_opt ::= */
+   -2,  /* (535) where_clause_opt ::= WHERE search_condition */
+    0,  /* (536) partition_by_clause_opt ::= */
+   -3,  /* (537) partition_by_clause_opt ::= PARTITION BY partition_list */
+   -1,  /* (538) partition_list ::= partition_item */
+   -3,  /* (539) partition_list ::= partition_list NK_COMMA partition_item */
+   -1,  /* (540) partition_item ::= expr_or_subquery */
+   -2,  /* (541) partition_item ::= expr_or_subquery column_alias */
+   -3,  /* (542) partition_item ::= expr_or_subquery AS column_alias */
+    0,  /* (543) twindow_clause_opt ::= */
+   -6,  /* (544) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
+   -4,  /* (545) twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */
+   -6,  /* (546) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
+   -8,  /* (547) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
+   -7,  /* (548) twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */
+    0,  /* (549) sliding_opt ::= */
+   -4,  /* (550) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
+    0,  /* (551) fill_opt ::= */
+   -4,  /* (552) fill_opt ::= FILL NK_LP fill_mode NK_RP */
+   -6,  /* (553) fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */
+   -6,  /* (554) fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */
+   -1,  /* (555) fill_mode ::= NONE */
+   -1,  /* (556) fill_mode ::= PREV */
+   -1,  /* (557) fill_mode ::= NULL */
+   -1,  /* (558) fill_mode ::= NULL_F */
+   -1,  /* (559) fill_mode ::= LINEAR */
+   -1,  /* (560) fill_mode ::= NEXT */
+    0,  /* (561) group_by_clause_opt ::= */
+   -3,  /* (562) group_by_clause_opt ::= GROUP BY group_by_list */
+   -1,  /* (563) group_by_list ::= expr_or_subquery */
+   -3,  /* (564) group_by_list ::= group_by_list NK_COMMA expr_or_subquery */
+    0,  /* (565) having_clause_opt ::= */
+   -2,  /* (566) having_clause_opt ::= HAVING search_condition */
+    0,  /* (567) range_opt ::= */
+   -6,  /* (568) range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */
+   -4,  /* (569) range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */
+    0,  /* (570) every_opt ::= */
+   -4,  /* (571) every_opt ::= EVERY NK_LP duration_literal NK_RP */
+   -4,  /* (572) query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */
+   -1,  /* (573) query_simple ::= query_specification */
+   -1,  /* (574) query_simple ::= union_query_expression */
+   -4,  /* (575) union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */
+   -3,  /* (576) union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */
+   -1,  /* (577) query_simple_or_subquery ::= query_simple */
+   -1,  /* (578) query_simple_or_subquery ::= subquery */
+   -1,  /* (579) query_or_subquery ::= query_expression */
+   -1,  /* (580) query_or_subquery ::= subquery */
+    0,  /* (581) order_by_clause_opt ::= */
+   -3,  /* (582) order_by_clause_opt ::= ORDER BY sort_specification_list */
+    0,  /* (583) slimit_clause_opt ::= */
+   -2,  /* (584) slimit_clause_opt ::= SLIMIT NK_INTEGER */
+   -4,  /* (585) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
+   -4,  /* (586) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+    0,  /* (587) limit_clause_opt ::= */
+   -2,  /* (588) limit_clause_opt ::= LIMIT NK_INTEGER */
+   -4,  /* (589) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */
+   -4,  /* (590) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+   -3,  /* (591) subquery ::= NK_LP query_expression NK_RP */
+   -3,  /* (592) subquery ::= NK_LP subquery NK_RP */
+   -1,  /* (593) search_condition ::= common_expression */
+   -1,  /* (594) sort_specification_list ::= sort_specification */
+   -3,  /* (595) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */
+   -3,  /* (596) sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */
+    0,  /* (597) ordering_specification_opt ::= */
+   -1,  /* (598) ordering_specification_opt ::= ASC */
+   -1,  /* (599) ordering_specification_opt ::= DESC */
+    0,  /* (600) null_ordering_opt ::= */
+   -2,  /* (601) null_ordering_opt ::= NULLS FIRST */
+   -2,  /* (602) null_ordering_opt ::= NULLS LAST */
 };
 
 static void yy_accept(yyParser*);  /* Forward Declaration */
@@ -4843,19 +4855,19 @@ static YYACTIONTYPE yy_reduce(
       case 0: /* cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */
 #line 50 "sql.y"
 { pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_EXPRIE_STATEMENT); }
-#line 4846 "sql.c"
+#line 4858 "sql.c"
   yy_destructor(yypParser,339,&yymsp[0].minor);
         break;
       case 1: /* cmd ::= ALTER ACCOUNT NK_ID alter_account_options */
 #line 51 "sql.y"
 { pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_EXPRIE_STATEMENT); }
-#line 4852 "sql.c"
+#line 4864 "sql.c"
   yy_destructor(yypParser,340,&yymsp[0].minor);
         break;
       case 2: /* account_options ::= */
 #line 55 "sql.y"
 { }
-#line 4858 "sql.c"
+#line 4870 "sql.c"
         break;
       case 3: /* account_options ::= account_options PPS literal */
       case 4: /* account_options ::= account_options TSERIES literal */ yytestcase(yyruleno==4);
@@ -4869,7 +4881,7 @@ static YYACTIONTYPE yy_reduce(
 {  yy_destructor(yypParser,339,&yymsp[-2].minor);
 #line 56 "sql.y"
 { }
-#line 4872 "sql.c"
+#line 4884 "sql.c"
   yy_destructor(yypParser,341,&yymsp[0].minor);
 }
         break;
@@ -4877,14 +4889,14 @@ static YYACTIONTYPE yy_reduce(
 {  yy_destructor(yypParser,342,&yymsp[0].minor);
 #line 68 "sql.y"
 { }
-#line 4880 "sql.c"
+#line 4892 "sql.c"
 }
         break;
       case 13: /* alter_account_options ::= alter_account_options alter_account_option */
 {  yy_destructor(yypParser,340,&yymsp[-1].minor);
 #line 69 "sql.y"
 { }
-#line 4887 "sql.c"
+#line 4899 "sql.c"
   yy_destructor(yypParser,342,&yymsp[0].minor);
 }
         break;
@@ -4900,490 +4912,490 @@ static YYACTIONTYPE yy_reduce(
       case 23: /* alter_account_option ::= STATE literal */ yytestcase(yyruleno==23);
 #line 73 "sql.y"
 { }
-#line 4903 "sql.c"
+#line 4915 "sql.c"
   yy_destructor(yypParser,341,&yymsp[0].minor);
         break;
       case 24: /* cmd ::= CREATE USER user_name PASS NK_STRING sysinfo_opt */
 #line 85 "sql.y"
 { pCxt->pRootNode = createCreateUserStmt(pCxt, &yymsp[-3].minor.yy129, &yymsp[-1].minor.yy0, yymsp[0].minor.yy215); }
-#line 4909 "sql.c"
+#line 4921 "sql.c"
         break;
       case 25: /* cmd ::= ALTER USER user_name PASS NK_STRING */
 #line 86 "sql.y"
 { pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy129, TSDB_ALTER_USER_PASSWD, &yymsp[0].minor.yy0); }
-#line 4914 "sql.c"
+#line 4926 "sql.c"
         break;
       case 26: /* cmd ::= ALTER USER user_name ENABLE NK_INTEGER */
 #line 87 "sql.y"
 { pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy129, TSDB_ALTER_USER_ENABLE, &yymsp[0].minor.yy0); }
-#line 4919 "sql.c"
+#line 4931 "sql.c"
         break;
       case 27: /* cmd ::= ALTER USER user_name SYSINFO NK_INTEGER */
 #line 88 "sql.y"
 { pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy129, TSDB_ALTER_USER_SYSINFO, &yymsp[0].minor.yy0); }
-#line 4924 "sql.c"
+#line 4936 "sql.c"
         break;
       case 28: /* cmd ::= DROP USER user_name */
 #line 89 "sql.y"
 { pCxt->pRootNode = createDropUserStmt(pCxt, &yymsp[0].minor.yy129); }
-#line 4929 "sql.c"
+#line 4941 "sql.c"
         break;
       case 29: /* sysinfo_opt ::= */
 #line 93 "sql.y"
 { yymsp[1].minor.yy215 = 1; }
-#line 4934 "sql.c"
+#line 4946 "sql.c"
         break;
       case 30: /* sysinfo_opt ::= SYSINFO NK_INTEGER */
 #line 94 "sql.y"
 { yymsp[-1].minor.yy215 = taosStr2Int8(yymsp[0].minor.yy0.z, NULL, 10); }
-#line 4939 "sql.c"
+#line 4951 "sql.c"
         break;
       case 31: /* cmd ::= GRANT privileges ON priv_level with_opt TO user_name */
 #line 97 "sql.y"
 { pCxt->pRootNode = createGrantStmt(pCxt, yymsp[-5].minor.yy717, &yymsp[-3].minor.yy505, &yymsp[0].minor.yy129, yymsp[-2].minor.yy840); }
-#line 4944 "sql.c"
+#line 4956 "sql.c"
         break;
       case 32: /* cmd ::= REVOKE privileges ON priv_level with_opt FROM user_name */
 #line 98 "sql.y"
 { pCxt->pRootNode = createRevokeStmt(pCxt, yymsp[-5].minor.yy717, &yymsp[-3].minor.yy505, &yymsp[0].minor.yy129, yymsp[-2].minor.yy840); }
-#line 4949 "sql.c"
+#line 4961 "sql.c"
         break;
       case 33: /* privileges ::= ALL */
 #line 102 "sql.y"
 { yymsp[0].minor.yy717 = PRIVILEGE_TYPE_ALL; }
-#line 4954 "sql.c"
+#line 4966 "sql.c"
         break;
       case 34: /* privileges ::= priv_type_list */
       case 36: /* priv_type_list ::= priv_type */ yytestcase(yyruleno==36);
 #line 103 "sql.y"
 { yylhsminor.yy717 = yymsp[0].minor.yy717; }
-#line 4960 "sql.c"
+#line 4972 "sql.c"
   yymsp[0].minor.yy717 = yylhsminor.yy717;
         break;
       case 35: /* privileges ::= SUBSCRIBE */
 #line 104 "sql.y"
 { yymsp[0].minor.yy717 = PRIVILEGE_TYPE_SUBSCRIBE; }
-#line 4966 "sql.c"
+#line 4978 "sql.c"
         break;
       case 37: /* priv_type_list ::= priv_type_list NK_COMMA priv_type */
 #line 109 "sql.y"
 { yylhsminor.yy717 = yymsp[-2].minor.yy717 | yymsp[0].minor.yy717; }
-#line 4971 "sql.c"
+#line 4983 "sql.c"
   yymsp[-2].minor.yy717 = yylhsminor.yy717;
         break;
       case 38: /* priv_type ::= READ */
 #line 113 "sql.y"
 { yymsp[0].minor.yy717 = PRIVILEGE_TYPE_READ; }
-#line 4977 "sql.c"
+#line 4989 "sql.c"
         break;
       case 39: /* priv_type ::= WRITE */
 #line 114 "sql.y"
 { yymsp[0].minor.yy717 = PRIVILEGE_TYPE_WRITE; }
-#line 4982 "sql.c"
+#line 4994 "sql.c"
         break;
       case 40: /* priv_level ::= NK_STAR NK_DOT NK_STAR */
 #line 118 "sql.y"
 { yylhsminor.yy505.first = yymsp[-2].minor.yy0; yylhsminor.yy505.second = yymsp[0].minor.yy0; }
-#line 4987 "sql.c"
+#line 4999 "sql.c"
   yymsp[-2].minor.yy505 = yylhsminor.yy505;
         break;
       case 41: /* priv_level ::= db_name NK_DOT NK_STAR */
 #line 119 "sql.y"
 { yylhsminor.yy505.first = yymsp[-2].minor.yy129; yylhsminor.yy505.second = yymsp[0].minor.yy0; }
-#line 4993 "sql.c"
+#line 5005 "sql.c"
   yymsp[-2].minor.yy505 = yylhsminor.yy505;
         break;
       case 42: /* priv_level ::= db_name NK_DOT table_name */
 #line 120 "sql.y"
 { yylhsminor.yy505.first = yymsp[-2].minor.yy129; yylhsminor.yy505.second = yymsp[0].minor.yy129; }
-#line 4999 "sql.c"
+#line 5011 "sql.c"
   yymsp[-2].minor.yy505 = yylhsminor.yy505;
         break;
       case 43: /* priv_level ::= topic_name */
 #line 121 "sql.y"
 { yylhsminor.yy505.first = yymsp[0].minor.yy129; yylhsminor.yy505.second = nil_token; }
-#line 5005 "sql.c"
+#line 5017 "sql.c"
   yymsp[0].minor.yy505 = yylhsminor.yy505;
         break;
       case 44: /* with_opt ::= */
       case 144: /* start_opt ::= */ yytestcase(yyruleno==144);
       case 148: /* end_opt ::= */ yytestcase(yyruleno==148);
-      case 276: /* like_pattern_opt ::= */ yytestcase(yyruleno==276);
-      case 354: /* subtable_opt ::= */ yytestcase(yyruleno==354);
-      case 472: /* case_when_else_opt ::= */ yytestcase(yyruleno==472);
-      case 502: /* from_clause_opt ::= */ yytestcase(yyruleno==502);
-      case 533: /* where_clause_opt ::= */ yytestcase(yyruleno==533);
-      case 542: /* twindow_clause_opt ::= */ yytestcase(yyruleno==542);
-      case 548: /* sliding_opt ::= */ yytestcase(yyruleno==548);
-      case 550: /* fill_opt ::= */ yytestcase(yyruleno==550);
-      case 564: /* having_clause_opt ::= */ yytestcase(yyruleno==564);
-      case 566: /* range_opt ::= */ yytestcase(yyruleno==566);
-      case 569: /* every_opt ::= */ yytestcase(yyruleno==569);
-      case 582: /* slimit_clause_opt ::= */ yytestcase(yyruleno==582);
-      case 586: /* limit_clause_opt ::= */ yytestcase(yyruleno==586);
+      case 277: /* like_pattern_opt ::= */ yytestcase(yyruleno==277);
+      case 355: /* subtable_opt ::= */ yytestcase(yyruleno==355);
+      case 473: /* case_when_else_opt ::= */ yytestcase(yyruleno==473);
+      case 503: /* from_clause_opt ::= */ yytestcase(yyruleno==503);
+      case 534: /* where_clause_opt ::= */ yytestcase(yyruleno==534);
+      case 543: /* twindow_clause_opt ::= */ yytestcase(yyruleno==543);
+      case 549: /* sliding_opt ::= */ yytestcase(yyruleno==549);
+      case 551: /* fill_opt ::= */ yytestcase(yyruleno==551);
+      case 565: /* having_clause_opt ::= */ yytestcase(yyruleno==565);
+      case 567: /* range_opt ::= */ yytestcase(yyruleno==567);
+      case 570: /* every_opt ::= */ yytestcase(yyruleno==570);
+      case 583: /* slimit_clause_opt ::= */ yytestcase(yyruleno==583);
+      case 587: /* limit_clause_opt ::= */ yytestcase(yyruleno==587);
 #line 123 "sql.y"
 { yymsp[1].minor.yy840 = NULL; }
-#line 5026 "sql.c"
+#line 5038 "sql.c"
         break;
       case 45: /* with_opt ::= WITH search_condition */
-      case 503: /* from_clause_opt ::= FROM table_reference_list */ yytestcase(yyruleno==503);
-      case 534: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==534);
-      case 565: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==565);
+      case 504: /* from_clause_opt ::= FROM table_reference_list */ yytestcase(yyruleno==504);
+      case 535: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==535);
+      case 566: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==566);
 #line 124 "sql.y"
 { yymsp[-1].minor.yy840 = yymsp[0].minor.yy840; }
-#line 5034 "sql.c"
+#line 5046 "sql.c"
         break;
       case 46: /* cmd ::= CREATE DNODE dnode_endpoint */
 #line 127 "sql.y"
 { pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[0].minor.yy129, NULL); }
-#line 5039 "sql.c"
+#line 5051 "sql.c"
         break;
       case 47: /* cmd ::= CREATE DNODE dnode_endpoint PORT NK_INTEGER */
 #line 128 "sql.y"
 { pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[-2].minor.yy129, &yymsp[0].minor.yy0); }
-#line 5044 "sql.c"
+#line 5056 "sql.c"
         break;
       case 48: /* cmd ::= DROP DNODE NK_INTEGER force_opt */
 #line 129 "sql.y"
 { pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy313, false); }
-#line 5049 "sql.c"
+#line 5061 "sql.c"
         break;
       case 49: /* cmd ::= DROP DNODE dnode_endpoint force_opt */
 #line 130 "sql.y"
 { pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy129, yymsp[0].minor.yy313, false); }
-#line 5054 "sql.c"
+#line 5066 "sql.c"
         break;
       case 50: /* cmd ::= DROP DNODE NK_INTEGER unsafe_opt */
 #line 131 "sql.y"
 { pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy0, false, yymsp[0].minor.yy313); }
-#line 5059 "sql.c"
+#line 5071 "sql.c"
         break;
       case 51: /* cmd ::= DROP DNODE dnode_endpoint unsafe_opt */
 #line 132 "sql.y"
 { pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy129, false, yymsp[0].minor.yy313); }
-#line 5064 "sql.c"
+#line 5076 "sql.c"
         break;
       case 52: /* cmd ::= ALTER DNODE NK_INTEGER NK_STRING */
 #line 133 "sql.y"
 { pCxt->pRootNode = createAlterDnodeStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, NULL); }
-#line 5069 "sql.c"
+#line 5081 "sql.c"
         break;
       case 53: /* cmd ::= ALTER DNODE NK_INTEGER NK_STRING NK_STRING */
 #line 134 "sql.y"
 { pCxt->pRootNode = createAlterDnodeStmt(pCxt, &yymsp[-2].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); }
-#line 5074 "sql.c"
+#line 5086 "sql.c"
         break;
       case 54: /* cmd ::= ALTER ALL DNODES NK_STRING */
 #line 135 "sql.y"
 { pCxt->pRootNode = createAlterDnodeStmt(pCxt, NULL, &yymsp[0].minor.yy0, NULL); }
-#line 5079 "sql.c"
+#line 5091 "sql.c"
         break;
       case 55: /* cmd ::= ALTER ALL DNODES NK_STRING NK_STRING */
 #line 136 "sql.y"
 { pCxt->pRootNode = createAlterDnodeStmt(pCxt, NULL, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); }
-#line 5084 "sql.c"
+#line 5096 "sql.c"
         break;
       case 56: /* cmd ::= RESTORE DNODE NK_INTEGER */
 #line 137 "sql.y"
 { pCxt->pRootNode = createRestoreComponentNodeStmt(pCxt, QUERY_NODE_RESTORE_DNODE_STMT, &yymsp[0].minor.yy0); }
-#line 5089 "sql.c"
+#line 5101 "sql.c"
         break;
       case 57: /* dnode_endpoint ::= NK_STRING */
       case 58: /* dnode_endpoint ::= NK_ID */ yytestcase(yyruleno==58);
       case 59: /* dnode_endpoint ::= NK_IPTOKEN */ yytestcase(yyruleno==59);
-      case 300: /* sma_func_name ::= COUNT */ yytestcase(yyruleno==300);
-      case 301: /* sma_func_name ::= FIRST */ yytestcase(yyruleno==301);
-      case 302: /* sma_func_name ::= LAST */ yytestcase(yyruleno==302);
-      case 303: /* sma_func_name ::= LAST_ROW */ yytestcase(yyruleno==303);
-      case 398: /* db_name ::= NK_ID */ yytestcase(yyruleno==398);
-      case 399: /* table_name ::= NK_ID */ yytestcase(yyruleno==399);
-      case 400: /* column_name ::= NK_ID */ yytestcase(yyruleno==400);
-      case 401: /* function_name ::= NK_ID */ yytestcase(yyruleno==401);
-      case 402: /* table_alias ::= NK_ID */ yytestcase(yyruleno==402);
-      case 403: /* column_alias ::= NK_ID */ yytestcase(yyruleno==403);
-      case 404: /* user_name ::= NK_ID */ yytestcase(yyruleno==404);
-      case 405: /* topic_name ::= NK_ID */ yytestcase(yyruleno==405);
-      case 406: /* stream_name ::= NK_ID */ yytestcase(yyruleno==406);
-      case 407: /* cgroup_name ::= NK_ID */ yytestcase(yyruleno==407);
-      case 408: /* index_name ::= NK_ID */ yytestcase(yyruleno==408);
-      case 448: /* noarg_func ::= NOW */ yytestcase(yyruleno==448);
-      case 449: /* noarg_func ::= TODAY */ yytestcase(yyruleno==449);
-      case 450: /* noarg_func ::= TIMEZONE */ yytestcase(yyruleno==450);
-      case 451: /* noarg_func ::= DATABASE */ yytestcase(yyruleno==451);
-      case 452: /* noarg_func ::= CLIENT_VERSION */ yytestcase(yyruleno==452);
-      case 453: /* noarg_func ::= SERVER_VERSION */ yytestcase(yyruleno==453);
-      case 454: /* noarg_func ::= SERVER_STATUS */ yytestcase(yyruleno==454);
-      case 455: /* noarg_func ::= CURRENT_USER */ yytestcase(yyruleno==455);
-      case 456: /* noarg_func ::= USER */ yytestcase(yyruleno==456);
-      case 457: /* star_func ::= COUNT */ yytestcase(yyruleno==457);
-      case 458: /* star_func ::= FIRST */ yytestcase(yyruleno==458);
-      case 459: /* star_func ::= LAST */ yytestcase(yyruleno==459);
-      case 460: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==460);
+      case 301: /* sma_func_name ::= COUNT */ yytestcase(yyruleno==301);
+      case 302: /* sma_func_name ::= FIRST */ yytestcase(yyruleno==302);
+      case 303: /* sma_func_name ::= LAST */ yytestcase(yyruleno==303);
+      case 304: /* sma_func_name ::= LAST_ROW */ yytestcase(yyruleno==304);
+      case 399: /* db_name ::= NK_ID */ yytestcase(yyruleno==399);
+      case 400: /* table_name ::= NK_ID */ yytestcase(yyruleno==400);
+      case 401: /* column_name ::= NK_ID */ yytestcase(yyruleno==401);
+      case 402: /* function_name ::= NK_ID */ yytestcase(yyruleno==402);
+      case 403: /* table_alias ::= NK_ID */ yytestcase(yyruleno==403);
+      case 404: /* column_alias ::= NK_ID */ yytestcase(yyruleno==404);
+      case 405: /* user_name ::= NK_ID */ yytestcase(yyruleno==405);
+      case 406: /* topic_name ::= NK_ID */ yytestcase(yyruleno==406);
+      case 407: /* stream_name ::= NK_ID */ yytestcase(yyruleno==407);
+      case 408: /* cgroup_name ::= NK_ID */ yytestcase(yyruleno==408);
+      case 409: /* index_name ::= NK_ID */ yytestcase(yyruleno==409);
+      case 449: /* noarg_func ::= NOW */ yytestcase(yyruleno==449);
+      case 450: /* noarg_func ::= TODAY */ yytestcase(yyruleno==450);
+      case 451: /* noarg_func ::= TIMEZONE */ yytestcase(yyruleno==451);
+      case 452: /* noarg_func ::= DATABASE */ yytestcase(yyruleno==452);
+      case 453: /* noarg_func ::= CLIENT_VERSION */ yytestcase(yyruleno==453);
+      case 454: /* noarg_func ::= SERVER_VERSION */ yytestcase(yyruleno==454);
+      case 455: /* noarg_func ::= SERVER_STATUS */ yytestcase(yyruleno==455);
+      case 456: /* noarg_func ::= CURRENT_USER */ yytestcase(yyruleno==456);
+      case 457: /* noarg_func ::= USER */ yytestcase(yyruleno==457);
+      case 458: /* star_func ::= COUNT */ yytestcase(yyruleno==458);
+      case 459: /* star_func ::= FIRST */ yytestcase(yyruleno==459);
+      case 460: /* star_func ::= LAST */ yytestcase(yyruleno==460);
+      case 461: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==461);
 #line 141 "sql.y"
 { yylhsminor.yy129 = yymsp[0].minor.yy0; }
-#line 5124 "sql.c"
+#line 5136 "sql.c"
   yymsp[0].minor.yy129 = yylhsminor.yy129;
         break;
       case 60: /* force_opt ::= */
       case 84: /* not_exists_opt ::= */ yytestcase(yyruleno==84);
       case 86: /* exists_opt ::= */ yytestcase(yyruleno==86);
-      case 321: /* analyze_opt ::= */ yytestcase(yyruleno==321);
-      case 328: /* agg_func_opt ::= */ yytestcase(yyruleno==328);
-      case 334: /* or_replace_opt ::= */ yytestcase(yyruleno==334);
-      case 356: /* ignore_opt ::= */ yytestcase(yyruleno==356);
-      case 521: /* tag_mode_opt ::= */ yytestcase(yyruleno==521);
-      case 523: /* set_quantifier_opt ::= */ yytestcase(yyruleno==523);
+      case 322: /* analyze_opt ::= */ yytestcase(yyruleno==322);
+      case 329: /* agg_func_opt ::= */ yytestcase(yyruleno==329);
+      case 335: /* or_replace_opt ::= */ yytestcase(yyruleno==335);
+      case 357: /* ignore_opt ::= */ yytestcase(yyruleno==357);
+      case 522: /* tag_mode_opt ::= */ yytestcase(yyruleno==522);
+      case 524: /* set_quantifier_opt ::= */ yytestcase(yyruleno==524);
 #line 147 "sql.y"
 { yymsp[1].minor.yy313 = false; }
-#line 5138 "sql.c"
+#line 5150 "sql.c"
         break;
       case 61: /* force_opt ::= FORCE */
       case 62: /* unsafe_opt ::= UNSAFE */ yytestcase(yyruleno==62);
-      case 322: /* analyze_opt ::= ANALYZE */ yytestcase(yyruleno==322);
-      case 329: /* agg_func_opt ::= AGGREGATE */ yytestcase(yyruleno==329);
-      case 522: /* tag_mode_opt ::= TAGS */ yytestcase(yyruleno==522);
-      case 524: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==524);
+      case 323: /* analyze_opt ::= ANALYZE */ yytestcase(yyruleno==323);
+      case 330: /* agg_func_opt ::= AGGREGATE */ yytestcase(yyruleno==330);
+      case 523: /* tag_mode_opt ::= TAGS */ yytestcase(yyruleno==523);
+      case 525: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==525);
 #line 148 "sql.y"
 { yymsp[0].minor.yy313 = true; }
-#line 5148 "sql.c"
+#line 5160 "sql.c"
         break;
       case 63: /* cmd ::= ALTER LOCAL NK_STRING */
 #line 155 "sql.y"
 { pCxt->pRootNode = createAlterLocalStmt(pCxt, &yymsp[0].minor.yy0, NULL); }
-#line 5153 "sql.c"
+#line 5165 "sql.c"
         break;
       case 64: /* cmd ::= ALTER LOCAL NK_STRING NK_STRING */
 #line 156 "sql.y"
 { pCxt->pRootNode = createAlterLocalStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); }
-#line 5158 "sql.c"
+#line 5170 "sql.c"
         break;
       case 65: /* cmd ::= CREATE QNODE ON DNODE NK_INTEGER */
 #line 159 "sql.y"
 { pCxt->pRootNode = createCreateComponentNodeStmt(pCxt, QUERY_NODE_CREATE_QNODE_STMT, &yymsp[0].minor.yy0); }
-#line 5163 "sql.c"
+#line 5175 "sql.c"
         break;
       case 66: /* cmd ::= DROP QNODE ON DNODE NK_INTEGER */
 #line 160 "sql.y"
 { pCxt->pRootNode = createDropComponentNodeStmt(pCxt, QUERY_NODE_DROP_QNODE_STMT, &yymsp[0].minor.yy0); }
-#line 5168 "sql.c"
+#line 5180 "sql.c"
         break;
       case 67: /* cmd ::= RESTORE QNODE ON DNODE NK_INTEGER */
 #line 161 "sql.y"
 { pCxt->pRootNode = createRestoreComponentNodeStmt(pCxt, QUERY_NODE_RESTORE_QNODE_STMT, &yymsp[0].minor.yy0); }
-#line 5173 "sql.c"
+#line 5185 "sql.c"
         break;
       case 68: /* cmd ::= CREATE BNODE ON DNODE NK_INTEGER */
 #line 164 "sql.y"
 { pCxt->pRootNode = createCreateComponentNodeStmt(pCxt, QUERY_NODE_CREATE_BNODE_STMT, &yymsp[0].minor.yy0); }
-#line 5178 "sql.c"
+#line 5190 "sql.c"
         break;
       case 69: /* cmd ::= DROP BNODE ON DNODE NK_INTEGER */
 #line 165 "sql.y"
 { pCxt->pRootNode = createDropComponentNodeStmt(pCxt, QUERY_NODE_DROP_BNODE_STMT, &yymsp[0].minor.yy0); }
-#line 5183 "sql.c"
+#line 5195 "sql.c"
         break;
       case 70: /* cmd ::= CREATE SNODE ON DNODE NK_INTEGER */
 #line 168 "sql.y"
 { pCxt->pRootNode = createCreateComponentNodeStmt(pCxt, QUERY_NODE_CREATE_SNODE_STMT, &yymsp[0].minor.yy0); }
-#line 5188 "sql.c"
+#line 5200 "sql.c"
         break;
       case 71: /* cmd ::= DROP SNODE ON DNODE NK_INTEGER */
 #line 169 "sql.y"
 { pCxt->pRootNode = createDropComponentNodeStmt(pCxt, QUERY_NODE_DROP_SNODE_STMT, &yymsp[0].minor.yy0); }
-#line 5193 "sql.c"
+#line 5205 "sql.c"
         break;
       case 72: /* cmd ::= CREATE MNODE ON DNODE NK_INTEGER */
 #line 172 "sql.y"
 { pCxt->pRootNode = createCreateComponentNodeStmt(pCxt, QUERY_NODE_CREATE_MNODE_STMT, &yymsp[0].minor.yy0); }
-#line 5198 "sql.c"
+#line 5210 "sql.c"
         break;
       case 73: /* cmd ::= DROP MNODE ON DNODE NK_INTEGER */
 #line 173 "sql.y"
 { pCxt->pRootNode = createDropComponentNodeStmt(pCxt, QUERY_NODE_DROP_MNODE_STMT, &yymsp[0].minor.yy0); }
-#line 5203 "sql.c"
+#line 5215 "sql.c"
         break;
       case 74: /* cmd ::= RESTORE MNODE ON DNODE NK_INTEGER */
 #line 174 "sql.y"
 { pCxt->pRootNode = createRestoreComponentNodeStmt(pCxt, QUERY_NODE_RESTORE_MNODE_STMT, &yymsp[0].minor.yy0); }
-#line 5208 "sql.c"
+#line 5220 "sql.c"
         break;
       case 75: /* cmd ::= RESTORE VNODE ON DNODE NK_INTEGER */
 #line 177 "sql.y"
 { pCxt->pRootNode = createRestoreComponentNodeStmt(pCxt, QUERY_NODE_RESTORE_VNODE_STMT, &yymsp[0].minor.yy0); }
-#line 5213 "sql.c"
+#line 5225 "sql.c"
         break;
       case 76: /* cmd ::= CREATE DATABASE not_exists_opt db_name db_options */
 #line 180 "sql.y"
 { pCxt->pRootNode = createCreateDatabaseStmt(pCxt, yymsp[-2].minor.yy313, &yymsp[-1].minor.yy129, yymsp[0].minor.yy840); }
-#line 5218 "sql.c"
+#line 5230 "sql.c"
         break;
       case 77: /* cmd ::= DROP DATABASE exists_opt db_name */
 #line 181 "sql.y"
 { pCxt->pRootNode = createDropDatabaseStmt(pCxt, yymsp[-1].minor.yy313, &yymsp[0].minor.yy129); }
-#line 5223 "sql.c"
+#line 5235 "sql.c"
         break;
       case 78: /* cmd ::= USE db_name */
 #line 182 "sql.y"
 { pCxt->pRootNode = createUseDatabaseStmt(pCxt, &yymsp[0].minor.yy129); }
-#line 5228 "sql.c"
+#line 5240 "sql.c"
         break;
       case 79: /* cmd ::= ALTER DATABASE db_name alter_db_options */
 #line 183 "sql.y"
 { pCxt->pRootNode = createAlterDatabaseStmt(pCxt, &yymsp[-1].minor.yy129, yymsp[0].minor.yy840); }
-#line 5233 "sql.c"
+#line 5245 "sql.c"
         break;
       case 80: /* cmd ::= FLUSH DATABASE db_name */
 #line 184 "sql.y"
 { pCxt->pRootNode = createFlushDatabaseStmt(pCxt, &yymsp[0].minor.yy129); }
-#line 5238 "sql.c"
+#line 5250 "sql.c"
         break;
       case 81: /* cmd ::= TRIM DATABASE db_name speed_opt */
 #line 185 "sql.y"
 { pCxt->pRootNode = createTrimDatabaseStmt(pCxt, &yymsp[-1].minor.yy129, yymsp[0].minor.yy356); }
-#line 5243 "sql.c"
+#line 5255 "sql.c"
         break;
       case 82: /* cmd ::= COMPACT DATABASE db_name start_opt end_opt */
 #line 186 "sql.y"
 { pCxt->pRootNode = createCompactStmt(pCxt, &yymsp[-2].minor.yy129, yymsp[-1].minor.yy840, yymsp[0].minor.yy840); }
-#line 5248 "sql.c"
+#line 5260 "sql.c"
         break;
       case 83: /* not_exists_opt ::= IF NOT EXISTS */
 #line 190 "sql.y"
 { yymsp[-2].minor.yy313 = true; }
-#line 5253 "sql.c"
+#line 5265 "sql.c"
         break;
       case 85: /* exists_opt ::= IF EXISTS */
-      case 335: /* or_replace_opt ::= OR REPLACE */ yytestcase(yyruleno==335);
-      case 357: /* ignore_opt ::= IGNORE UNTREATED */ yytestcase(yyruleno==357);
+      case 336: /* or_replace_opt ::= OR REPLACE */ yytestcase(yyruleno==336);
+      case 358: /* ignore_opt ::= IGNORE UNTREATED */ yytestcase(yyruleno==358);
 #line 195 "sql.y"
 { yymsp[-1].minor.yy313 = true; }
-#line 5260 "sql.c"
+#line 5272 "sql.c"
         break;
       case 87: /* db_options ::= */
 #line 198 "sql.y"
 { yymsp[1].minor.yy840 = createDefaultDatabaseOptions(pCxt); }
-#line 5265 "sql.c"
+#line 5277 "sql.c"
         break;
       case 88: /* db_options ::= db_options BUFFER NK_INTEGER */
 #line 199 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_BUFFER, &yymsp[0].minor.yy0); }
-#line 5270 "sql.c"
+#line 5282 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 89: /* db_options ::= db_options CACHEMODEL NK_STRING */
 #line 200 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_CACHEMODEL, &yymsp[0].minor.yy0); }
-#line 5276 "sql.c"
+#line 5288 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 90: /* db_options ::= db_options CACHESIZE NK_INTEGER */
 #line 201 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_CACHESIZE, &yymsp[0].minor.yy0); }
-#line 5282 "sql.c"
+#line 5294 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 91: /* db_options ::= db_options COMP NK_INTEGER */
 #line 202 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_COMP, &yymsp[0].minor.yy0); }
-#line 5288 "sql.c"
+#line 5300 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 92: /* db_options ::= db_options DURATION NK_INTEGER */
       case 93: /* db_options ::= db_options DURATION NK_VARIABLE */ yytestcase(yyruleno==93);
 #line 203 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_DAYS, &yymsp[0].minor.yy0); }
-#line 5295 "sql.c"
+#line 5307 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 94: /* db_options ::= db_options MAXROWS NK_INTEGER */
 #line 205 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_MAXROWS, &yymsp[0].minor.yy0); }
-#line 5301 "sql.c"
+#line 5313 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 95: /* db_options ::= db_options MINROWS NK_INTEGER */
 #line 206 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_MINROWS, &yymsp[0].minor.yy0); }
-#line 5307 "sql.c"
+#line 5319 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 96: /* db_options ::= db_options KEEP integer_list */
       case 97: /* db_options ::= db_options KEEP variable_list */ yytestcase(yyruleno==97);
 #line 207 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_KEEP, yymsp[0].minor.yy56); }
-#line 5314 "sql.c"
+#line 5326 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 98: /* db_options ::= db_options PAGES NK_INTEGER */
 #line 209 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_PAGES, &yymsp[0].minor.yy0); }
-#line 5320 "sql.c"
+#line 5332 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 99: /* db_options ::= db_options PAGESIZE NK_INTEGER */
 #line 210 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_PAGESIZE, &yymsp[0].minor.yy0); }
-#line 5326 "sql.c"
+#line 5338 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 100: /* db_options ::= db_options TSDB_PAGESIZE NK_INTEGER */
 #line 211 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_TSDB_PAGESIZE, &yymsp[0].minor.yy0); }
-#line 5332 "sql.c"
+#line 5344 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 101: /* db_options ::= db_options PRECISION NK_STRING */
 #line 212 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_PRECISION, &yymsp[0].minor.yy0); }
-#line 5338 "sql.c"
+#line 5350 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 102: /* db_options ::= db_options REPLICA NK_INTEGER */
 #line 213 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_REPLICA, &yymsp[0].minor.yy0); }
-#line 5344 "sql.c"
+#line 5356 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 103: /* db_options ::= db_options VGROUPS NK_INTEGER */
 #line 215 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_VGROUPS, &yymsp[0].minor.yy0); }
-#line 5350 "sql.c"
+#line 5362 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 104: /* db_options ::= db_options SINGLE_STABLE NK_INTEGER */
 #line 216 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_SINGLE_STABLE, &yymsp[0].minor.yy0); }
-#line 5356 "sql.c"
+#line 5368 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 105: /* db_options ::= db_options RETENTIONS retention_list */
 #line 217 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_RETENTIONS, yymsp[0].minor.yy56); }
-#line 5362 "sql.c"
+#line 5374 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 106: /* db_options ::= db_options SCHEMALESS NK_INTEGER */
 #line 218 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_SCHEMALESS, &yymsp[0].minor.yy0); }
-#line 5368 "sql.c"
+#line 5380 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 107: /* db_options ::= db_options WAL_LEVEL NK_INTEGER */
 #line 219 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_WAL, &yymsp[0].minor.yy0); }
-#line 5374 "sql.c"
+#line 5386 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 108: /* db_options ::= db_options WAL_FSYNC_PERIOD NK_INTEGER */
 #line 220 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_FSYNC, &yymsp[0].minor.yy0); }
-#line 5380 "sql.c"
+#line 5392 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 109: /* db_options ::= db_options WAL_RETENTION_PERIOD NK_INTEGER */
 #line 221 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_WAL_RETENTION_PERIOD, &yymsp[0].minor.yy0); }
-#line 5386 "sql.c"
+#line 5398 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 110: /* db_options ::= db_options WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */
@@ -5393,13 +5405,13 @@ static YYACTIONTYPE yy_reduce(
                                                                                     t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z;
                                                                                     yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-3].minor.yy840, DB_OPTION_WAL_RETENTION_PERIOD, &t);
                                                                                   }
-#line 5396 "sql.c"
+#line 5408 "sql.c"
   yymsp[-3].minor.yy840 = yylhsminor.yy840;
         break;
       case 111: /* db_options ::= db_options WAL_RETENTION_SIZE NK_INTEGER */
 #line 227 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_WAL_RETENTION_SIZE, &yymsp[0].minor.yy0); }
-#line 5402 "sql.c"
+#line 5414 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 112: /* db_options ::= db_options WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */
@@ -5409,106 +5421,106 @@ static YYACTIONTYPE yy_reduce(
                                                                                     t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z;
                                                                                     yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-3].minor.yy840, DB_OPTION_WAL_RETENTION_SIZE, &t);
                                                                                   }
-#line 5412 "sql.c"
+#line 5424 "sql.c"
   yymsp[-3].minor.yy840 = yylhsminor.yy840;
         break;
       case 113: /* db_options ::= db_options WAL_ROLL_PERIOD NK_INTEGER */
 #line 233 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_WAL_ROLL_PERIOD, &yymsp[0].minor.yy0); }
-#line 5418 "sql.c"
+#line 5430 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 114: /* db_options ::= db_options WAL_SEGMENT_SIZE NK_INTEGER */
 #line 234 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_WAL_SEGMENT_SIZE, &yymsp[0].minor.yy0); }
-#line 5424 "sql.c"
+#line 5436 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 115: /* db_options ::= db_options STT_TRIGGER NK_INTEGER */
 #line 235 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_STT_TRIGGER, &yymsp[0].minor.yy0); }
-#line 5430 "sql.c"
+#line 5442 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 116: /* db_options ::= db_options TABLE_PREFIX signed */
 #line 236 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_TABLE_PREFIX, yymsp[0].minor.yy840); }
-#line 5436 "sql.c"
+#line 5448 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 117: /* db_options ::= db_options TABLE_SUFFIX signed */
 #line 237 "sql.y"
 { yylhsminor.yy840 = setDatabaseOption(pCxt, yymsp[-2].minor.yy840, DB_OPTION_TABLE_SUFFIX, yymsp[0].minor.yy840); }
-#line 5442 "sql.c"
+#line 5454 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 118: /* alter_db_options ::= alter_db_option */
 #line 239 "sql.y"
 { yylhsminor.yy840 = createAlterDatabaseOptions(pCxt); yylhsminor.yy840 = setAlterDatabaseOption(pCxt, yylhsminor.yy840, &yymsp[0].minor.yy461); }
-#line 5448 "sql.c"
+#line 5460 "sql.c"
   yymsp[0].minor.yy840 = yylhsminor.yy840;
         break;
       case 119: /* alter_db_options ::= alter_db_options alter_db_option */
 #line 240 "sql.y"
 { yylhsminor.yy840 = setAlterDatabaseOption(pCxt, yymsp[-1].minor.yy840, &yymsp[0].minor.yy461); }
-#line 5454 "sql.c"
+#line 5466 "sql.c"
   yymsp[-1].minor.yy840 = yylhsminor.yy840;
         break;
       case 120: /* alter_db_option ::= BUFFER NK_INTEGER */
 #line 244 "sql.y"
 { yymsp[-1].minor.yy461.type = DB_OPTION_BUFFER; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; }
-#line 5460 "sql.c"
+#line 5472 "sql.c"
         break;
       case 121: /* alter_db_option ::= CACHEMODEL NK_STRING */
 #line 245 "sql.y"
 { yymsp[-1].minor.yy461.type = DB_OPTION_CACHEMODEL; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; }
-#line 5465 "sql.c"
+#line 5477 "sql.c"
         break;
       case 122: /* alter_db_option ::= CACHESIZE NK_INTEGER */
 #line 246 "sql.y"
 { yymsp[-1].minor.yy461.type = DB_OPTION_CACHESIZE; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; }
-#line 5470 "sql.c"
+#line 5482 "sql.c"
         break;
       case 123: /* alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER */
 #line 247 "sql.y"
 { yymsp[-1].minor.yy461.type = DB_OPTION_FSYNC; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; }
-#line 5475 "sql.c"
+#line 5487 "sql.c"
         break;
       case 124: /* alter_db_option ::= KEEP integer_list */
       case 125: /* alter_db_option ::= KEEP variable_list */ yytestcase(yyruleno==125);
 #line 248 "sql.y"
 { yymsp[-1].minor.yy461.type = DB_OPTION_KEEP; yymsp[-1].minor.yy461.pList = yymsp[0].minor.yy56; }
-#line 5481 "sql.c"
+#line 5493 "sql.c"
         break;
       case 126: /* alter_db_option ::= PAGES NK_INTEGER */
 #line 250 "sql.y"
 { yymsp[-1].minor.yy461.type = DB_OPTION_PAGES; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; }
-#line 5486 "sql.c"
+#line 5498 "sql.c"
         break;
       case 127: /* alter_db_option ::= REPLICA NK_INTEGER */
 #line 251 "sql.y"
 { yymsp[-1].minor.yy461.type = DB_OPTION_REPLICA; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; }
-#line 5491 "sql.c"
+#line 5503 "sql.c"
         break;
       case 128: /* alter_db_option ::= WAL_LEVEL NK_INTEGER */
 #line 253 "sql.y"
 { yymsp[-1].minor.yy461.type = DB_OPTION_WAL; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; }
-#line 5496 "sql.c"
+#line 5508 "sql.c"
         break;
       case 129: /* alter_db_option ::= STT_TRIGGER NK_INTEGER */
 #line 254 "sql.y"
 { yymsp[-1].minor.yy461.type = DB_OPTION_STT_TRIGGER; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; }
-#line 5501 "sql.c"
+#line 5513 "sql.c"
         break;
       case 130: /* alter_db_option ::= MINROWS NK_INTEGER */
 #line 255 "sql.y"
 { yymsp[-1].minor.yy461.type = DB_OPTION_MINROWS; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; }
-#line 5506 "sql.c"
+#line 5518 "sql.c"
         break;
       case 131: /* alter_db_option ::= WAL_RETENTION_PERIOD NK_INTEGER */
 #line 256 "sql.y"
 { yymsp[-1].minor.yy461.type = DB_OPTION_WAL_RETENTION_PERIOD; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; }
-#line 5511 "sql.c"
+#line 5523 "sql.c"
         break;
       case 132: /* alter_db_option ::= WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */
 #line 257 "sql.y"
@@ -5517,12 +5529,12 @@ static YYACTIONTYPE yy_reduce(
                                                                                     t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z;
                                                                                     yymsp[-2].minor.yy461.type = DB_OPTION_WAL_RETENTION_PERIOD; yymsp[-2].minor.yy461.val = t;
                                                                                   }
-#line 5520 "sql.c"
+#line 5532 "sql.c"
         break;
       case 133: /* alter_db_option ::= WAL_RETENTION_SIZE NK_INTEGER */
 #line 262 "sql.y"
 { yymsp[-1].minor.yy461.type = DB_OPTION_WAL_RETENTION_SIZE; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; }
-#line 5525 "sql.c"
+#line 5537 "sql.c"
         break;
       case 134: /* alter_db_option ::= WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */
 #line 263 "sql.y"
@@ -5531,1596 +5543,1602 @@ static YYACTIONTYPE yy_reduce(
                                                                                     t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z;
                                                                                     yymsp[-2].minor.yy461.type = DB_OPTION_WAL_RETENTION_SIZE; yymsp[-2].minor.yy461.val = t;
                                                                                   }
-#line 5534 "sql.c"
+#line 5546 "sql.c"
         break;
       case 135: /* integer_list ::= NK_INTEGER */
 #line 271 "sql.y"
 { yylhsminor.yy56 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); }
-#line 5539 "sql.c"
+#line 5551 "sql.c"
   yymsp[0].minor.yy56 = yylhsminor.yy56;
         break;
       case 136: /* integer_list ::= integer_list NK_COMMA NK_INTEGER */
-      case 367: /* dnode_list ::= dnode_list DNODE NK_INTEGER */ yytestcase(yyruleno==367);
+      case 368: /* dnode_list ::= dnode_list DNODE NK_INTEGER */ yytestcase(yyruleno==368);
 #line 272 "sql.y"
 { yylhsminor.yy56 = addNodeToList(pCxt, yymsp[-2].minor.yy56, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); }
-#line 5546 "sql.c"
+#line 5558 "sql.c"
   yymsp[-2].minor.yy56 = yylhsminor.yy56;
         break;
       case 137: /* variable_list ::= NK_VARIABLE */
 #line 276 "sql.y"
 { yylhsminor.yy56 = createNodeList(pCxt, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); }
-#line 5552 "sql.c"
+#line 5564 "sql.c"
   yymsp[0].minor.yy56 = yylhsminor.yy56;
         break;
       case 138: /* variable_list ::= variable_list NK_COMMA NK_VARIABLE */
 #line 277 "sql.y"
 { yylhsminor.yy56 = addNodeToList(pCxt, yymsp[-2].minor.yy56, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); }
-#line 5558 "sql.c"
+#line 5570 "sql.c"
   yymsp[-2].minor.yy56 = yylhsminor.yy56;
         break;
       case 139: /* retention_list ::= retention */
       case 169: /* multi_create_clause ::= create_subtable_clause */ yytestcase(yyruleno==169);
       case 172: /* multi_drop_clause ::= drop_table_clause */ yytestcase(yyruleno==172);
       case 179: /* column_def_list ::= column_def */ yytestcase(yyruleno==179);
-      case 223: /* rollup_func_list ::= rollup_func_name */ yytestcase(yyruleno==223);
-      case 228: /* col_name_list ::= col_name */ yytestcase(yyruleno==228);
-      case 282: /* tag_list_opt ::= tag_item */ yytestcase(yyruleno==282);
-      case 296: /* func_list ::= func */ yytestcase(yyruleno==296);
-      case 396: /* literal_list ::= signed_literal */ yytestcase(yyruleno==396);
-      case 463: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==463);
-      case 469: /* when_then_list ::= when_then_expr */ yytestcase(yyruleno==469);
-      case 526: /* select_list ::= select_item */ yytestcase(yyruleno==526);
-      case 537: /* partition_list ::= partition_item */ yytestcase(yyruleno==537);
-      case 593: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==593);
+      case 224: /* rollup_func_list ::= rollup_func_name */ yytestcase(yyruleno==224);
+      case 229: /* col_name_list ::= col_name */ yytestcase(yyruleno==229);
+      case 283: /* tag_list_opt ::= tag_item */ yytestcase(yyruleno==283);
+      case 297: /* func_list ::= func */ yytestcase(yyruleno==297);
+      case 397: /* literal_list ::= signed_literal */ yytestcase(yyruleno==397);
+      case 464: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==464);
+      case 470: /* when_then_list ::= when_then_expr */ yytestcase(yyruleno==470);
+      case 527: /* select_list ::= select_item */ yytestcase(yyruleno==527);
+      case 538: /* partition_list ::= partition_item */ yytestcase(yyruleno==538);
+      case 594: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==594);
 #line 281 "sql.y"
 { yylhsminor.yy56 = createNodeList(pCxt, yymsp[0].minor.yy840); }
-#line 5577 "sql.c"
+#line 5589 "sql.c"
   yymsp[0].minor.yy56 = yylhsminor.yy56;
         break;
       case 140: /* retention_list ::= retention_list NK_COMMA retention */
       case 173: /* multi_drop_clause ::= multi_drop_clause NK_COMMA drop_table_clause */ yytestcase(yyruleno==173);
       case 180: /* column_def_list ::= column_def_list NK_COMMA column_def */ yytestcase(yyruleno==180);
-      case 224: /* rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ yytestcase(yyruleno==224);
-      case 229: /* col_name_list ::= col_name_list NK_COMMA col_name */ yytestcase(yyruleno==229);
-      case 283: /* tag_list_opt ::= tag_list_opt NK_COMMA tag_item */ yytestcase(yyruleno==283);
-      case 297: /* func_list ::= func_list NK_COMMA func */ yytestcase(yyruleno==297);
-      case 397: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==397);
-      case 464: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==464);
-      case 527: /* select_list ::= select_list NK_COMMA select_item */ yytestcase(yyruleno==527);
-      case 538: /* partition_list ::= partition_list NK_COMMA partition_item */ yytestcase(yyruleno==538);
-      case 594: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==594);
+      case 225: /* rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ yytestcase(yyruleno==225);
+      case 230: /* col_name_list ::= col_name_list NK_COMMA col_name */ yytestcase(yyruleno==230);
+      case 284: /* tag_list_opt ::= tag_list_opt NK_COMMA tag_item */ yytestcase(yyruleno==284);
+      case 298: /* func_list ::= func_list NK_COMMA func */ yytestcase(yyruleno==298);
+      case 398: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==398);
+      case 465: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==465);
+      case 528: /* select_list ::= select_list NK_COMMA select_item */ yytestcase(yyruleno==528);
+      case 539: /* partition_list ::= partition_list NK_COMMA partition_item */ yytestcase(yyruleno==539);
+      case 595: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==595);
 #line 282 "sql.y"
 { yylhsminor.yy56 = addNodeToList(pCxt, yymsp[-2].minor.yy56, yymsp[0].minor.yy840); }
-#line 5594 "sql.c"
+#line 5606 "sql.c"
   yymsp[-2].minor.yy56 = yylhsminor.yy56;
         break;
       case 141: /* retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */
 #line 284 "sql.y"
 { yylhsminor.yy840 = createNodeListNodeEx(pCxt, createDurationValueNode(pCxt, &yymsp[-2].minor.yy0), createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); }
-#line 5600 "sql.c"
+#line 5612 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 142: /* speed_opt ::= */
-      case 330: /* bufsize_opt ::= */ yytestcase(yyruleno==330);
+      case 331: /* bufsize_opt ::= */ yytestcase(yyruleno==331);
 #line 288 "sql.y"
 { yymsp[1].minor.yy356 = 0; }
-#line 5607 "sql.c"
+#line 5619 "sql.c"
         break;
       case 143: /* speed_opt ::= MAX_SPEED NK_INTEGER */
-      case 331: /* bufsize_opt ::= BUFSIZE NK_INTEGER */ yytestcase(yyruleno==331);
+      case 332: /* bufsize_opt ::= BUFSIZE NK_INTEGER */ yytestcase(yyruleno==332);
 #line 289 "sql.y"
 { yymsp[-1].minor.yy356 = taosStr2Int32(yymsp[0].minor.yy0.z, NULL, 10); }
-#line 5613 "sql.c"
+#line 5625 "sql.c"
         break;
       case 145: /* start_opt ::= START WITH NK_INTEGER */
       case 149: /* end_opt ::= END WITH NK_INTEGER */ yytestcase(yyruleno==149);
 #line 292 "sql.y"
 { yymsp[-2].minor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); }
-#line 5619 "sql.c"
+#line 5631 "sql.c"
         break;
       case 146: /* start_opt ::= START WITH NK_STRING */
       case 150: /* end_opt ::= END WITH NK_STRING */ yytestcase(yyruleno==150);
 #line 293 "sql.y"
 { yymsp[-2].minor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); }
-#line 5625 "sql.c"
+#line 5637 "sql.c"
         break;
       case 147: /* start_opt ::= START WITH TIMESTAMP NK_STRING */
       case 151: /* end_opt ::= END WITH TIMESTAMP NK_STRING */ yytestcase(yyruleno==151);
 #line 294 "sql.y"
 { yymsp[-3].minor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); }
-#line 5631 "sql.c"
+#line 5643 "sql.c"
         break;
       case 152: /* cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */
       case 154: /* cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ yytestcase(yyruleno==154);
 #line 303 "sql.y"
 { pCxt->pRootNode = createCreateTableStmt(pCxt, yymsp[-6].minor.yy313, yymsp[-5].minor.yy840, yymsp[-3].minor.yy56, yymsp[-1].minor.yy56, yymsp[0].minor.yy840); }
-#line 5637 "sql.c"
+#line 5649 "sql.c"
         break;
       case 153: /* cmd ::= CREATE TABLE multi_create_clause */
 #line 304 "sql.y"
 { pCxt->pRootNode = createCreateMultiTableStmt(pCxt, yymsp[0].minor.yy56); }
-#line 5642 "sql.c"
+#line 5654 "sql.c"
         break;
       case 155: /* cmd ::= DROP TABLE multi_drop_clause */
 #line 307 "sql.y"
 { pCxt->pRootNode = createDropTableStmt(pCxt, yymsp[0].minor.yy56); }
-#line 5647 "sql.c"
+#line 5659 "sql.c"
         break;
       case 156: /* cmd ::= DROP STABLE exists_opt full_table_name */
 #line 308 "sql.y"
 { pCxt->pRootNode = createDropSuperTableStmt(pCxt, yymsp[-1].minor.yy313, yymsp[0].minor.yy840); }
-#line 5652 "sql.c"
+#line 5664 "sql.c"
         break;
       case 157: /* cmd ::= ALTER TABLE alter_table_clause */
-      case 369: /* cmd ::= query_or_subquery */ yytestcase(yyruleno==369);
-      case 370: /* cmd ::= insert_query */ yytestcase(yyruleno==370);
+      case 370: /* cmd ::= query_or_subquery */ yytestcase(yyruleno==370);
+      case 371: /* cmd ::= insert_query */ yytestcase(yyruleno==371);
 #line 310 "sql.y"
 { pCxt->pRootNode = yymsp[0].minor.yy840; }
-#line 5659 "sql.c"
+#line 5671 "sql.c"
         break;
       case 158: /* cmd ::= ALTER STABLE alter_table_clause */
 #line 311 "sql.y"
 { pCxt->pRootNode = setAlterSuperTableType(yymsp[0].minor.yy840); }
-#line 5664 "sql.c"
+#line 5676 "sql.c"
         break;
       case 159: /* alter_table_clause ::= full_table_name alter_table_options */
 #line 313 "sql.y"
 { yylhsminor.yy840 = createAlterTableModifyOptions(pCxt, yymsp[-1].minor.yy840, yymsp[0].minor.yy840); }
-#line 5669 "sql.c"
+#line 5681 "sql.c"
   yymsp[-1].minor.yy840 = yylhsminor.yy840;
         break;
-      case 160: /* alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */
+      case 160: /* alter_table_clause ::= full_table_name ADD COLUMN column_def */
 #line 315 "sql.y"
-{ yylhsminor.yy840 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy840, TSDB_ALTER_TABLE_ADD_COLUMN, &yymsp[-1].minor.yy129, yymsp[0].minor.yy784); }
-#line 5675 "sql.c"
-  yymsp[-4].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy840 = createAlterTableAddModifyCol(pCxt, yymsp[-3].minor.yy840, TSDB_ALTER_TABLE_ADD_COLUMN, yymsp[0].minor.yy840); }
+#line 5687 "sql.c"
+  yymsp[-3].minor.yy840 = yylhsminor.yy840;
         break;
       case 161: /* alter_table_clause ::= full_table_name DROP COLUMN column_name */
 #line 316 "sql.y"
 { yylhsminor.yy840 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy840, TSDB_ALTER_TABLE_DROP_COLUMN, &yymsp[0].minor.yy129); }
-#line 5681 "sql.c"
+#line 5693 "sql.c"
   yymsp[-3].minor.yy840 = yylhsminor.yy840;
         break;
-      case 162: /* alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */
+      case 162: /* alter_table_clause ::= full_table_name MODIFY COLUMN column_def */
 #line 318 "sql.y"
-{ yylhsminor.yy840 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy840, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, &yymsp[-1].minor.yy129, yymsp[0].minor.yy784); }
-#line 5687 "sql.c"
-  yymsp[-4].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy840 = createAlterTableAddModifyCol(pCxt, yymsp[-3].minor.yy840, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, yymsp[0].minor.yy840); }
+#line 5699 "sql.c"
+  yymsp[-3].minor.yy840 = yylhsminor.yy840;
         break;
       case 163: /* alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */
 #line 320 "sql.y"
 { yylhsminor.yy840 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy840, TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, &yymsp[-1].minor.yy129, &yymsp[0].minor.yy129); }
-#line 5693 "sql.c"
+#line 5705 "sql.c"
   yymsp[-4].minor.yy840 = yylhsminor.yy840;
         break;
-      case 164: /* alter_table_clause ::= full_table_name ADD TAG column_name type_name */
+      case 164: /* alter_table_clause ::= full_table_name ADD TAG column_def */
 #line 322 "sql.y"
-{ yylhsminor.yy840 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy840, TSDB_ALTER_TABLE_ADD_TAG, &yymsp[-1].minor.yy129, yymsp[0].minor.yy784); }
-#line 5699 "sql.c"
-  yymsp[-4].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy840 = createAlterTableAddModifyCol(pCxt, yymsp[-3].minor.yy840, TSDB_ALTER_TABLE_ADD_TAG, yymsp[0].minor.yy840); }
+#line 5711 "sql.c"
+  yymsp[-3].minor.yy840 = yylhsminor.yy840;
         break;
       case 165: /* alter_table_clause ::= full_table_name DROP TAG column_name */
 #line 323 "sql.y"
 { yylhsminor.yy840 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy840, TSDB_ALTER_TABLE_DROP_TAG, &yymsp[0].minor.yy129); }
-#line 5705 "sql.c"
+#line 5717 "sql.c"
   yymsp[-3].minor.yy840 = yylhsminor.yy840;
         break;
-      case 166: /* alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */
+      case 166: /* alter_table_clause ::= full_table_name MODIFY TAG column_def */
 #line 325 "sql.y"
-{ yylhsminor.yy840 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy840, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, &yymsp[-1].minor.yy129, yymsp[0].minor.yy784); }
-#line 5711 "sql.c"
-  yymsp[-4].minor.yy840 = yylhsminor.yy840;
+{ yylhsminor.yy840 = createAlterTableAddModifyCol(pCxt, yymsp[-3].minor.yy840, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, yymsp[0].minor.yy840); }
+#line 5723 "sql.c"
+  yymsp[-3].minor.yy840 = yylhsminor.yy840;
         break;
       case 167: /* alter_table_clause ::= full_table_name RENAME TAG column_name column_name */
 #line 327 "sql.y"
 { yylhsminor.yy840 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy840, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &yymsp[-1].minor.yy129, &yymsp[0].minor.yy129); }
-#line 5717 "sql.c"
+#line 5729 "sql.c"
   yymsp[-4].minor.yy840 = yylhsminor.yy840;
         break;
       case 168: /* alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */
 #line 329 "sql.y"
 { yylhsminor.yy840 = createAlterTableSetTag(pCxt, yymsp[-5].minor.yy840, &yymsp[-2].minor.yy129, yymsp[0].minor.yy840); }
-#line 5723 "sql.c"
+#line 5735 "sql.c"
   yymsp[-5].minor.yy840 = yylhsminor.yy840;
         break;
       case 170: /* multi_create_clause ::= multi_create_clause create_subtable_clause */
-      case 470: /* when_then_list ::= when_then_list when_then_expr */ yytestcase(yyruleno==470);
+      case 471: /* when_then_list ::= when_then_list when_then_expr */ yytestcase(yyruleno==471);
 #line 334 "sql.y"
 { yylhsminor.yy56 = addNodeToList(pCxt, yymsp[-1].minor.yy56, yymsp[0].minor.yy840); }
-#line 5730 "sql.c"
+#line 5742 "sql.c"
   yymsp[-1].minor.yy56 = yylhsminor.yy56;
         break;
       case 171: /* create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP expression_list NK_RP table_options */
 #line 338 "sql.y"
 { yylhsminor.yy840 = createCreateSubTableClause(pCxt, yymsp[-9].minor.yy313, yymsp[-8].minor.yy840, yymsp[-6].minor.yy840, yymsp[-5].minor.yy56, yymsp[-2].minor.yy56, yymsp[0].minor.yy840); }
-#line 5736 "sql.c"
+#line 5748 "sql.c"
   yymsp[-9].minor.yy840 = yylhsminor.yy840;
         break;
       case 174: /* drop_table_clause ::= exists_opt full_table_name */
 #line 345 "sql.y"
 { yylhsminor.yy840 = createDropTableClause(pCxt, yymsp[-1].minor.yy313, yymsp[0].minor.yy840); }
-#line 5742 "sql.c"
+#line 5754 "sql.c"
   yymsp[-1].minor.yy840 = yylhsminor.yy840;
         break;
       case 175: /* specific_cols_opt ::= */
-      case 206: /* tags_def_opt ::= */ yytestcase(yyruleno==206);
-      case 281: /* tag_list_opt ::= */ yytestcase(yyruleno==281);
-      case 340: /* col_list_opt ::= */ yytestcase(yyruleno==340);
-      case 342: /* tag_def_or_ref_opt ::= */ yytestcase(yyruleno==342);
-      case 535: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==535);
-      case 560: /* group_by_clause_opt ::= */ yytestcase(yyruleno==560);
-      case 580: /* order_by_clause_opt ::= */ yytestcase(yyruleno==580);
+      case 207: /* tags_def_opt ::= */ yytestcase(yyruleno==207);
+      case 282: /* tag_list_opt ::= */ yytestcase(yyruleno==282);
+      case 341: /* col_list_opt ::= */ yytestcase(yyruleno==341);
+      case 343: /* tag_def_or_ref_opt ::= */ yytestcase(yyruleno==343);
+      case 536: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==536);
+      case 561: /* group_by_clause_opt ::= */ yytestcase(yyruleno==561);
+      case 581: /* order_by_clause_opt ::= */ yytestcase(yyruleno==581);
 #line 349 "sql.y"
 { yymsp[1].minor.yy56 = NULL; }
-#line 5755 "sql.c"
+#line 5767 "sql.c"
         break;
       case 176: /* specific_cols_opt ::= NK_LP col_name_list NK_RP */
-      case 341: /* col_list_opt ::= NK_LP col_name_list NK_RP */ yytestcase(yyruleno==341);
+      case 342: /* col_list_opt ::= NK_LP col_name_list NK_RP */ yytestcase(yyruleno==342);
 #line 350 "sql.y"
 { yymsp[-2].minor.yy56 = yymsp[-1].minor.yy56; }
-#line 5761 "sql.c"
+#line 5773 "sql.c"
         break;
       case 177: /* full_table_name ::= table_name */
 #line 352 "sql.y"
 { yylhsminor.yy840 = createRealTableNode(pCxt, NULL, &yymsp[0].minor.yy129, NULL); }
-#line 5766 "sql.c"
+#line 5778 "sql.c"
   yymsp[0].minor.yy840 = yylhsminor.yy840;
         break;
       case 178: /* full_table_name ::= db_name NK_DOT table_name */
 #line 353 "sql.y"
 { yylhsminor.yy840 = createRealTableNode(pCxt, &yymsp[-2].minor.yy129, &yymsp[0].minor.yy129, NULL); }
-#line 5772 "sql.c"
+#line 5784 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
       case 181: /* column_def ::= column_name type_name */
 #line 360 "sql.y"
 { yylhsminor.yy840 = createColumnDefNode(pCxt, &yymsp[-1].minor.yy129, yymsp[0].minor.yy784, NULL); }
-#line 5778 "sql.c"
+#line 5790 "sql.c"
   yymsp[-1].minor.yy840 = yylhsminor.yy840;
         break;
-      case 182: /* type_name ::= BOOL */
+      case 182: /* column_def ::= column_name type_name COMMENT NK_STRING */
+#line 361 "sql.y"
+{ yylhsminor.yy840 = createColumnDefNode(pCxt, &yymsp[-3].minor.yy129, yymsp[-2].minor.yy784, &yymsp[0].minor.yy0); }
+#line 5796 "sql.c"
+  yymsp[-3].minor.yy840 = yylhsminor.yy840;
+        break;
+      case 183: /* type_name ::= BOOL */
 #line 365 "sql.y"
 { yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_BOOL); }
-#line 5784 "sql.c"
+#line 5802 "sql.c"
         break;
-      case 183: /* type_name ::= TINYINT */
+      case 184: /* type_name ::= TINYINT */
 #line 366 "sql.y"
 { yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_TINYINT); }
-#line 5789 "sql.c"
+#line 5807 "sql.c"
         break;
-      case 184: /* type_name ::= SMALLINT */
+      case 185: /* type_name ::= SMALLINT */
 #line 367 "sql.y"
 { yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_SMALLINT); }
-#line 5794 "sql.c"
+#line 5812 "sql.c"
         break;
-      case 185: /* type_name ::= INT */
-      case 186: /* type_name ::= INTEGER */ yytestcase(yyruleno==186);
+      case 186: /* type_name ::= INT */
+      case 187: /* type_name ::= INTEGER */ yytestcase(yyruleno==187);
 #line 368 "sql.y"
 { yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_INT); }
-#line 5800 "sql.c"
+#line 5818 "sql.c"
         break;
-      case 187: /* type_name ::= BIGINT */
+      case 188: /* type_name ::= BIGINT */
 #line 370 "sql.y"
 { yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_BIGINT); }
-#line 5805 "sql.c"
+#line 5823 "sql.c"
         break;
-      case 188: /* type_name ::= FLOAT */
+      case 189: /* type_name ::= FLOAT */
 #line 371 "sql.y"
 { yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_FLOAT); }
-#line 5810 "sql.c"
+#line 5828 "sql.c"
         break;
-      case 189: /* type_name ::= DOUBLE */
+      case 190: /* type_name ::= DOUBLE */
 #line 372 "sql.y"
 { yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_DOUBLE); }
-#line 5815 "sql.c"
+#line 5833 "sql.c"
         break;
-      case 190: /* type_name ::= BINARY NK_LP NK_INTEGER NK_RP */
+      case 191: /* type_name ::= BINARY NK_LP NK_INTEGER NK_RP */
 #line 373 "sql.y"
 { yymsp[-3].minor.yy784 = createVarLenDataType(TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy0); }
-#line 5820 "sql.c"
+#line 5838 "sql.c"
         break;
-      case 191: /* type_name ::= TIMESTAMP */
+      case 192: /* type_name ::= TIMESTAMP */
 #line 374 "sql.y"
 { yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_TIMESTAMP); }
-#line 5825 "sql.c"
+#line 5843 "sql.c"
         break;
-      case 192: /* type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */
+      case 193: /* type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */
 #line 375 "sql.y"
 { yymsp[-3].minor.yy784 = createVarLenDataType(TSDB_DATA_TYPE_NCHAR, &yymsp[-1].minor.yy0); }
-#line 5830 "sql.c"
+#line 5848 "sql.c"
         break;
-      case 193: /* type_name ::= TINYINT UNSIGNED */
+      case 194: /* type_name ::= TINYINT UNSIGNED */
 #line 376 "sql.y"
 { yymsp[-1].minor.yy784 = createDataType(TSDB_DATA_TYPE_UTINYINT); }
-#line 5835 "sql.c"
+#line 5853 "sql.c"
         break;
-      case 194: /* type_name ::= SMALLINT UNSIGNED */
+      case 195: /* type_name ::= SMALLINT UNSIGNED */
 #line 377 "sql.y"
 { yymsp[-1].minor.yy784 = createDataType(TSDB_DATA_TYPE_USMALLINT); }
-#line 5840 "sql.c"
+#line 5858 "sql.c"
         break;
-      case 195: /* type_name ::= INT UNSIGNED */
+      case 196: /* type_name ::= INT UNSIGNED */
 #line 378 "sql.y"
 { yymsp[-1].minor.yy784 = createDataType(TSDB_DATA_TYPE_UINT); }
-#line 5845 "sql.c"
+#line 5863 "sql.c"
         break;
-      case 196: /* type_name ::= BIGINT UNSIGNED */
+      case 197: /* type_name ::= BIGINT UNSIGNED */
 #line 379 "sql.y"
 { yymsp[-1].minor.yy784 = createDataType(TSDB_DATA_TYPE_UBIGINT); }
-#line 5850 "sql.c"
+#line 5868 "sql.c"
         break;
-      case 197: /* type_name ::= JSON */
+      case 198: /* type_name ::= JSON */
 #line 380 "sql.y"
 { yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_JSON); }
-#line 5855 "sql.c"
+#line 5873 "sql.c"
         break;
-      case 198: /* type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */
+      case 199: /* type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */
 #line 381 "sql.y"
 { yymsp[-3].minor.yy784 = createVarLenDataType(TSDB_DATA_TYPE_VARCHAR, &yymsp[-1].minor.yy0); }
-#line 5860 "sql.c"
+#line 5878 "sql.c"
         break;
-      case 199: /* type_name ::= MEDIUMBLOB */
+      case 200: /* type_name ::= MEDIUMBLOB */
 #line 382 "sql.y"
 { yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_MEDIUMBLOB); }
-#line 5865 "sql.c"
+#line 5883 "sql.c"
         break;
-      case 200: /* type_name ::= BLOB */
+      case 201: /* type_name ::= BLOB */
 #line 383 "sql.y"
 { yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_BLOB); }
-#line 5870 "sql.c"
+#line 5888 "sql.c"
         break;
-      case 201: /* type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */
+      case 202: /* type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */
 #line 384 "sql.y"
 { yymsp[-3].minor.yy784 = createVarLenDataType(TSDB_DATA_TYPE_VARBINARY, &yymsp[-1].minor.yy0); }
-#line 5875 "sql.c"
+#line 5893 "sql.c"
         break;
-      case 202: /* type_name ::= GEOMETRY NK_LP NK_INTEGER NK_RP */
+      case 203: /* type_name ::= GEOMETRY NK_LP NK_INTEGER NK_RP */
 #line 385 "sql.y"
 { yymsp[-3].minor.yy784 = createVarLenDataType(TSDB_DATA_TYPE_GEOMETRY, &yymsp[-1].minor.yy0); }
-#line 5880 "sql.c"
+#line 5898 "sql.c"
         break;
-      case 203: /* type_name ::= DECIMAL */
+      case 204: /* type_name ::= DECIMAL */
 #line 386 "sql.y"
 { yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_DECIMAL); }
-#line 5885 "sql.c"
+#line 5903 "sql.c"
         break;
-      case 204: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */
+      case 205: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */
 #line 387 "sql.y"
 { yymsp[-3].minor.yy784 = createDataType(TSDB_DATA_TYPE_DECIMAL); }
-#line 5890 "sql.c"
+#line 5908 "sql.c"
         break;
-      case 205: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */
+      case 206: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */
 #line 388 "sql.y"
 { yymsp[-5].minor.yy784 = createDataType(TSDB_DATA_TYPE_DECIMAL); }
-#line 5895 "sql.c"
+#line 5913 "sql.c"
         break;
-      case 207: /* tags_def_opt ::= tags_def */
-      case 343: /* tag_def_or_ref_opt ::= tags_def */ yytestcase(yyruleno==343);
-      case 462: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==462);
+      case 208: /* tags_def_opt ::= tags_def */
+      case 344: /* tag_def_or_ref_opt ::= tags_def */ yytestcase(yyruleno==344);
+      case 463: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==463);
 #line 393 "sql.y"
 { yylhsminor.yy56 = yymsp[0].minor.yy56; }
-#line 5902 "sql.c"
+#line 5920 "sql.c"
   yymsp[0].minor.yy56 = yylhsminor.yy56;
         break;
-      case 208: /* tags_def ::= TAGS NK_LP column_def_list NK_RP */
-      case 344: /* tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP */ yytestcase(yyruleno==344);
+      case 209: /* tags_def ::= TAGS NK_LP column_def_list NK_RP */
+      case 345: /* tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP */ yytestcase(yyruleno==345);
 #line 397 "sql.y"
 { yymsp[-3].minor.yy56 = yymsp[-1].minor.yy56; }
-#line 5909 "sql.c"
+#line 5927 "sql.c"
         break;
-      case 209: /* table_options ::= */
+      case 210: /* table_options ::= */
 #line 399 "sql.y"
 { yymsp[1].minor.yy840 = createDefaultTableOptions(pCxt); }
-#line 5914 "sql.c"
+#line 5932 "sql.c"
         break;
-      case 210: /* table_options ::= table_options COMMENT NK_STRING */
+      case 211: /* table_options ::= table_options COMMENT NK_STRING */
 #line 400 "sql.y"
 { yylhsminor.yy840 = setTableOption(pCxt, yymsp[-2].minor.yy840, TABLE_OPTION_COMMENT, &yymsp[0].minor.yy0); }
-#line 5919 "sql.c"
+#line 5937 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 211: /* table_options ::= table_options MAX_DELAY duration_list */
+      case 212: /* table_options ::= table_options MAX_DELAY duration_list */
 #line 401 "sql.y"
 { yylhsminor.yy840 = setTableOption(pCxt, yymsp[-2].minor.yy840, TABLE_OPTION_MAXDELAY, yymsp[0].minor.yy56); }
-#line 5925 "sql.c"
-  yymsp[-2].minor.yy840 = yylhsminor.yy840;
-        break;
-      case 212: /* table_options ::= table_options WATERMARK duration_list */
-#line 402 "sql.y"
-{ yylhsminor.yy840 = setTableOption(pCxt, yymsp[-2].minor.yy840, TABLE_OPTION_WATERMARK, yymsp[0].minor.yy56); }
-#line 5931 "sql.c"
-  yymsp[-2].minor.yy840 = yylhsminor.yy840;
-        break;
-      case 213: /* table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */
-#line 403 "sql.y"
-{ yylhsminor.yy840 = setTableOption(pCxt, yymsp[-4].minor.yy840, TABLE_OPTION_ROLLUP, yymsp[-1].minor.yy56); }
-#line 5937 "sql.c"
-  yymsp[-4].minor.yy840 = yylhsminor.yy840;
-        break;
-      case 214: /* table_options ::= table_options TTL NK_INTEGER */
-#line 404 "sql.y"
-{ yylhsminor.yy840 = setTableOption(pCxt, yymsp[-2].minor.yy840, TABLE_OPTION_TTL, &yymsp[0].minor.yy0); }
 #line 5943 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 215: /* table_options ::= table_options SMA NK_LP col_name_list NK_RP */
-#line 405 "sql.y"
-{ yylhsminor.yy840 = setTableOption(pCxt, yymsp[-4].minor.yy840, TABLE_OPTION_SMA, yymsp[-1].minor.yy56); }
+      case 213: /* table_options ::= table_options WATERMARK duration_list */
+#line 402 "sql.y"
+{ yylhsminor.yy840 = setTableOption(pCxt, yymsp[-2].minor.yy840, TABLE_OPTION_WATERMARK, yymsp[0].minor.yy56); }
 #line 5949 "sql.c"
+  yymsp[-2].minor.yy840 = yylhsminor.yy840;
+        break;
+      case 214: /* table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */
+#line 403 "sql.y"
+{ yylhsminor.yy840 = setTableOption(pCxt, yymsp[-4].minor.yy840, TABLE_OPTION_ROLLUP, yymsp[-1].minor.yy56); }
+#line 5955 "sql.c"
   yymsp[-4].minor.yy840 = yylhsminor.yy840;
         break;
-      case 216: /* table_options ::= table_options DELETE_MARK duration_list */
+      case 215: /* table_options ::= table_options TTL NK_INTEGER */
+#line 404 "sql.y"
+{ yylhsminor.yy840 = setTableOption(pCxt, yymsp[-2].minor.yy840, TABLE_OPTION_TTL, &yymsp[0].minor.yy0); }
+#line 5961 "sql.c"
+  yymsp[-2].minor.yy840 = yylhsminor.yy840;
+        break;
+      case 216: /* table_options ::= table_options SMA NK_LP col_name_list NK_RP */
+#line 405 "sql.y"
+{ yylhsminor.yy840 = setTableOption(pCxt, yymsp[-4].minor.yy840, TABLE_OPTION_SMA, yymsp[-1].minor.yy56); }
+#line 5967 "sql.c"
+  yymsp[-4].minor.yy840 = yylhsminor.yy840;
+        break;
+      case 217: /* table_options ::= table_options DELETE_MARK duration_list */
 #line 406 "sql.y"
 { yylhsminor.yy840 = setTableOption(pCxt, yymsp[-2].minor.yy840, TABLE_OPTION_DELETE_MARK, yymsp[0].minor.yy56); }
-#line 5955 "sql.c"
+#line 5973 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 217: /* alter_table_options ::= alter_table_option */
+      case 218: /* alter_table_options ::= alter_table_option */
 #line 408 "sql.y"
 { yylhsminor.yy840 = createAlterTableOptions(pCxt); yylhsminor.yy840 = setTableOption(pCxt, yylhsminor.yy840, yymsp[0].minor.yy461.type, &yymsp[0].minor.yy461.val); }
-#line 5961 "sql.c"
+#line 5979 "sql.c"
   yymsp[0].minor.yy840 = yylhsminor.yy840;
         break;
-      case 218: /* alter_table_options ::= alter_table_options alter_table_option */
+      case 219: /* alter_table_options ::= alter_table_options alter_table_option */
 #line 409 "sql.y"
 { yylhsminor.yy840 = setTableOption(pCxt, yymsp[-1].minor.yy840, yymsp[0].minor.yy461.type, &yymsp[0].minor.yy461.val); }
-#line 5967 "sql.c"
+#line 5985 "sql.c"
   yymsp[-1].minor.yy840 = yylhsminor.yy840;
         break;
-      case 219: /* alter_table_option ::= COMMENT NK_STRING */
+      case 220: /* alter_table_option ::= COMMENT NK_STRING */
 #line 413 "sql.y"
 { yymsp[-1].minor.yy461.type = TABLE_OPTION_COMMENT; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; }
-#line 5973 "sql.c"
+#line 5991 "sql.c"
         break;
-      case 220: /* alter_table_option ::= TTL NK_INTEGER */
+      case 221: /* alter_table_option ::= TTL NK_INTEGER */
 #line 414 "sql.y"
 { yymsp[-1].minor.yy461.type = TABLE_OPTION_TTL; yymsp[-1].minor.yy461.val = yymsp[0].minor.yy0; }
-#line 5978 "sql.c"
+#line 5996 "sql.c"
         break;
-      case 221: /* duration_list ::= duration_literal */
-      case 426: /* expression_list ::= expr_or_subquery */ yytestcase(yyruleno==426);
+      case 222: /* duration_list ::= duration_literal */
+      case 427: /* expression_list ::= expr_or_subquery */ yytestcase(yyruleno==427);
 #line 418 "sql.y"
 { yylhsminor.yy56 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy840)); }
-#line 5984 "sql.c"
+#line 6002 "sql.c"
   yymsp[0].minor.yy56 = yylhsminor.yy56;
         break;
-      case 222: /* duration_list ::= duration_list NK_COMMA duration_literal */
-      case 427: /* expression_list ::= expression_list NK_COMMA expr_or_subquery */ yytestcase(yyruleno==427);
+      case 223: /* duration_list ::= duration_list NK_COMMA duration_literal */
+      case 428: /* expression_list ::= expression_list NK_COMMA expr_or_subquery */ yytestcase(yyruleno==428);
 #line 419 "sql.y"
 { yylhsminor.yy56 = addNodeToList(pCxt, yymsp[-2].minor.yy56, releaseRawExprNode(pCxt, yymsp[0].minor.yy840)); }
-#line 5991 "sql.c"
+#line 6009 "sql.c"
   yymsp[-2].minor.yy56 = yylhsminor.yy56;
         break;
-      case 225: /* rollup_func_name ::= function_name */
+      case 226: /* rollup_func_name ::= function_name */
 #line 426 "sql.y"
 { yylhsminor.yy840 = createFunctionNode(pCxt, &yymsp[0].minor.yy129, NULL); }
-#line 5997 "sql.c"
+#line 6015 "sql.c"
   yymsp[0].minor.yy840 = yylhsminor.yy840;
         break;
-      case 226: /* rollup_func_name ::= FIRST */
-      case 227: /* rollup_func_name ::= LAST */ yytestcase(yyruleno==227);
-      case 285: /* tag_item ::= QTAGS */ yytestcase(yyruleno==285);
+      case 227: /* rollup_func_name ::= FIRST */
+      case 228: /* rollup_func_name ::= LAST */ yytestcase(yyruleno==228);
+      case 286: /* tag_item ::= QTAGS */ yytestcase(yyruleno==286);
 #line 427 "sql.y"
 { yylhsminor.yy840 = createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL); }
-#line 6005 "sql.c"
+#line 6023 "sql.c"
   yymsp[0].minor.yy840 = yylhsminor.yy840;
         break;
-      case 230: /* col_name ::= column_name */
-      case 286: /* tag_item ::= column_name */ yytestcase(yyruleno==286);
+      case 231: /* col_name ::= column_name */
+      case 287: /* tag_item ::= column_name */ yytestcase(yyruleno==287);
 #line 435 "sql.y"
 { yylhsminor.yy840 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy129); }
-#line 6012 "sql.c"
+#line 6030 "sql.c"
   yymsp[0].minor.yy840 = yylhsminor.yy840;
         break;
-      case 231: /* cmd ::= SHOW DNODES */
+      case 232: /* cmd ::= SHOW DNODES */
 #line 438 "sql.y"
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DNODES_STMT); }
-#line 6018 "sql.c"
+#line 6036 "sql.c"
         break;
-      case 232: /* cmd ::= SHOW USERS */
+      case 233: /* cmd ::= SHOW USERS */
 #line 439 "sql.y"
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_USERS_STMT); }
-#line 6023 "sql.c"
+#line 6041 "sql.c"
         break;
-      case 233: /* cmd ::= SHOW USER PRIVILEGES */
+      case 234: /* cmd ::= SHOW USER PRIVILEGES */
 #line 440 "sql.y"
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_USER_PRIVILEGES_STMT); }
-#line 6028 "sql.c"
+#line 6046 "sql.c"
         break;
-      case 234: /* cmd ::= SHOW DATABASES */
+      case 235: /* cmd ::= SHOW DATABASES */
 #line 441 "sql.y"
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DATABASES_STMT); }
-#line 6033 "sql.c"
+#line 6051 "sql.c"
         break;
-      case 235: /* cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */
+      case 236: /* cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */
 #line 442 "sql.y"
 { pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TABLES_STMT, yymsp[-2].minor.yy840, yymsp[0].minor.yy840, OP_TYPE_LIKE); }
-#line 6038 "sql.c"
+#line 6056 "sql.c"
         break;
-      case 236: /* cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */
+      case 237: /* cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */
 #line 443 "sql.y"
 { pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_STABLES_STMT, yymsp[-2].minor.yy840, yymsp[0].minor.yy840, OP_TYPE_LIKE); }
-#line 6043 "sql.c"
+#line 6061 "sql.c"
         break;
-      case 237: /* cmd ::= SHOW db_name_cond_opt VGROUPS */
+      case 238: /* cmd ::= SHOW db_name_cond_opt VGROUPS */
 #line 444 "sql.y"
 { pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VGROUPS_STMT, yymsp[-1].minor.yy840, NULL, OP_TYPE_LIKE); }
-#line 6048 "sql.c"
+#line 6066 "sql.c"
         break;
-      case 238: /* cmd ::= SHOW MNODES */
+      case 239: /* cmd ::= SHOW MNODES */
 #line 445 "sql.y"
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_MNODES_STMT); }
-#line 6053 "sql.c"
+#line 6071 "sql.c"
         break;
-      case 239: /* cmd ::= SHOW QNODES */
+      case 240: /* cmd ::= SHOW QNODES */
 #line 447 "sql.y"
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_QNODES_STMT); }
-#line 6058 "sql.c"
+#line 6076 "sql.c"
         break;
-      case 240: /* cmd ::= SHOW FUNCTIONS */
+      case 241: /* cmd ::= SHOW FUNCTIONS */
 #line 448 "sql.y"
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_FUNCTIONS_STMT); }
-#line 6063 "sql.c"
+#line 6081 "sql.c"
         break;
-      case 241: /* cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */
+      case 242: /* cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */
 #line 449 "sql.y"
 { pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, yymsp[0].minor.yy840, yymsp[-1].minor.yy840, OP_TYPE_EQUAL); }
-#line 6068 "sql.c"
+#line 6086 "sql.c"
         break;
-      case 242: /* cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name */
+      case 243: /* cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name */
 #line 450 "sql.y"
 { pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy129), createIdentifierValueNode(pCxt, &yymsp[0].minor.yy129), OP_TYPE_EQUAL); }
-#line 6073 "sql.c"
+#line 6091 "sql.c"
         break;
-      case 243: /* cmd ::= SHOW STREAMS */
+      case 244: /* cmd ::= SHOW STREAMS */
 #line 451 "sql.y"
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_STREAMS_STMT); }
-#line 6078 "sql.c"
+#line 6096 "sql.c"
         break;
-      case 244: /* cmd ::= SHOW ACCOUNTS */
+      case 245: /* cmd ::= SHOW ACCOUNTS */
 #line 452 "sql.y"
 { pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_EXPRIE_STATEMENT); }
-#line 6083 "sql.c"
+#line 6101 "sql.c"
         break;
-      case 245: /* cmd ::= SHOW APPS */
+      case 246: /* cmd ::= SHOW APPS */
 #line 453 "sql.y"
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_APPS_STMT); }
-#line 6088 "sql.c"
+#line 6106 "sql.c"
         break;
-      case 246: /* cmd ::= SHOW CONNECTIONS */
+      case 247: /* cmd ::= SHOW CONNECTIONS */
 #line 454 "sql.y"
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CONNECTIONS_STMT); }
-#line 6093 "sql.c"
+#line 6111 "sql.c"
         break;
-      case 247: /* cmd ::= SHOW LICENCES */
-      case 248: /* cmd ::= SHOW GRANTS */ yytestcase(yyruleno==248);
+      case 248: /* cmd ::= SHOW LICENCES */
+      case 249: /* cmd ::= SHOW GRANTS */ yytestcase(yyruleno==249);
 #line 455 "sql.y"
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_LICENCES_STMT); }
-#line 6099 "sql.c"
+#line 6117 "sql.c"
         break;
-      case 249: /* cmd ::= SHOW CREATE DATABASE db_name */
+      case 250: /* cmd ::= SHOW CREATE DATABASE db_name */
 #line 457 "sql.y"
 { pCxt->pRootNode = createShowCreateDatabaseStmt(pCxt, &yymsp[0].minor.yy129); }
-#line 6104 "sql.c"
+#line 6122 "sql.c"
         break;
-      case 250: /* cmd ::= SHOW CREATE TABLE full_table_name */
+      case 251: /* cmd ::= SHOW CREATE TABLE full_table_name */
 #line 458 "sql.y"
 { pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_TABLE_STMT, yymsp[0].minor.yy840); }
-#line 6109 "sql.c"
+#line 6127 "sql.c"
         break;
-      case 251: /* cmd ::= SHOW CREATE STABLE full_table_name */
+      case 252: /* cmd ::= SHOW CREATE STABLE full_table_name */
 #line 459 "sql.y"
 { pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_STABLE_STMT, yymsp[0].minor.yy840); }
-#line 6114 "sql.c"
+#line 6132 "sql.c"
         break;
-      case 252: /* cmd ::= SHOW QUERIES */
+      case 253: /* cmd ::= SHOW QUERIES */
 #line 460 "sql.y"
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_QUERIES_STMT); }
-#line 6119 "sql.c"
+#line 6137 "sql.c"
         break;
-      case 253: /* cmd ::= SHOW SCORES */
+      case 254: /* cmd ::= SHOW SCORES */
 #line 461 "sql.y"
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SCORES_STMT); }
-#line 6124 "sql.c"
+#line 6142 "sql.c"
         break;
-      case 254: /* cmd ::= SHOW TOPICS */
+      case 255: /* cmd ::= SHOW TOPICS */
 #line 462 "sql.y"
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TOPICS_STMT); }
-#line 6129 "sql.c"
+#line 6147 "sql.c"
         break;
-      case 255: /* cmd ::= SHOW VARIABLES */
-      case 256: /* cmd ::= SHOW CLUSTER VARIABLES */ yytestcase(yyruleno==256);
+      case 256: /* cmd ::= SHOW VARIABLES */
+      case 257: /* cmd ::= SHOW CLUSTER VARIABLES */ yytestcase(yyruleno==257);
 #line 463 "sql.y"
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_VARIABLES_STMT); }
-#line 6135 "sql.c"
+#line 6153 "sql.c"
         break;
-      case 257: /* cmd ::= SHOW LOCAL VARIABLES */
+      case 258: /* cmd ::= SHOW LOCAL VARIABLES */
 #line 465 "sql.y"
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT); }
-#line 6140 "sql.c"
+#line 6158 "sql.c"
         break;
-      case 258: /* cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */
+      case 259: /* cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */
 #line 466 "sql.y"
 { pCxt->pRootNode = createShowDnodeVariablesStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[-2].minor.yy0), yymsp[0].minor.yy840); }
-#line 6145 "sql.c"
+#line 6163 "sql.c"
         break;
-      case 259: /* cmd ::= SHOW BNODES */
+      case 260: /* cmd ::= SHOW BNODES */
 #line 467 "sql.y"
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_BNODES_STMT); }
-#line 6150 "sql.c"
+#line 6168 "sql.c"
         break;
-      case 260: /* cmd ::= SHOW SNODES */
+      case 261: /* cmd ::= SHOW SNODES */
 #line 468 "sql.y"
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SNODES_STMT); }
-#line 6155 "sql.c"
+#line 6173 "sql.c"
         break;
-      case 261: /* cmd ::= SHOW CLUSTER */
+      case 262: /* cmd ::= SHOW CLUSTER */
 #line 469 "sql.y"
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CLUSTER_STMT); }
-#line 6160 "sql.c"
+#line 6178 "sql.c"
         break;
-      case 262: /* cmd ::= SHOW TRANSACTIONS */
+      case 263: /* cmd ::= SHOW TRANSACTIONS */
 #line 470 "sql.y"
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TRANSACTIONS_STMT); }
-#line 6165 "sql.c"
+#line 6183 "sql.c"
         break;
-      case 263: /* cmd ::= SHOW TABLE DISTRIBUTED full_table_name */
+      case 264: /* cmd ::= SHOW TABLE DISTRIBUTED full_table_name */
 #line 471 "sql.y"
 { pCxt->pRootNode = createShowTableDistributedStmt(pCxt, yymsp[0].minor.yy840); }
-#line 6170 "sql.c"
+#line 6188 "sql.c"
         break;
-      case 264: /* cmd ::= SHOW CONSUMERS */
+      case 265: /* cmd ::= SHOW CONSUMERS */
 #line 472 "sql.y"
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CONSUMERS_STMT); }
-#line 6175 "sql.c"
+#line 6193 "sql.c"
         break;
-      case 265: /* cmd ::= SHOW SUBSCRIPTIONS */
+      case 266: /* cmd ::= SHOW SUBSCRIPTIONS */
 #line 473 "sql.y"
 { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT); }
-#line 6180 "sql.c"
+#line 6198 "sql.c"
         break;
-      case 266: /* cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */
+      case 267: /* cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */
 #line 474 "sql.y"
 { pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, yymsp[0].minor.yy840, yymsp[-1].minor.yy840, OP_TYPE_EQUAL); }
-#line 6185 "sql.c"
+#line 6203 "sql.c"
         break;
-      case 267: /* cmd ::= SHOW TAGS FROM db_name NK_DOT table_name */
+      case 268: /* cmd ::= SHOW TAGS FROM db_name NK_DOT table_name */
 #line 475 "sql.y"
 { pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy129), createIdentifierValueNode(pCxt, &yymsp[0].minor.yy129), OP_TYPE_EQUAL); }
-#line 6190 "sql.c"
+#line 6208 "sql.c"
         break;
-      case 268: /* cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */
+      case 269: /* cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */
 #line 476 "sql.y"
 { pCxt->pRootNode = createShowTableTagsStmt(pCxt, yymsp[-1].minor.yy840, yymsp[0].minor.yy840, yymsp[-3].minor.yy56); }
-#line 6195 "sql.c"
+#line 6213 "sql.c"
         break;
-      case 269: /* cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name */
+      case 270: /* cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name */
 #line 477 "sql.y"
 { pCxt->pRootNode = createShowTableTagsStmt(pCxt, createIdentifierValueNode(pCxt, &yymsp[0].minor.yy129), createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy129), yymsp[-4].minor.yy56); }
-#line 6200 "sql.c"
+#line 6218 "sql.c"
         break;
-      case 270: /* cmd ::= SHOW VNODES NK_INTEGER */
+      case 271: /* cmd ::= SHOW VNODES NK_INTEGER */
 #line 478 "sql.y"
 { pCxt->pRootNode = createShowVnodesStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0), NULL); }
-#line 6205 "sql.c"
+#line 6223 "sql.c"
         break;
-      case 271: /* cmd ::= SHOW VNODES NK_STRING */
+      case 272: /* cmd ::= SHOW VNODES NK_STRING */
 #line 479 "sql.y"
 { pCxt->pRootNode = createShowVnodesStmt(pCxt, NULL, createValueNode(pCxt, TSDB_DATA_TYPE_VARCHAR, &yymsp[0].minor.yy0)); }
-#line 6210 "sql.c"
+#line 6228 "sql.c"
         break;
-      case 272: /* cmd ::= SHOW db_name_cond_opt ALIVE */
+      case 273: /* cmd ::= SHOW db_name_cond_opt ALIVE */
 #line 481 "sql.y"
 { pCxt->pRootNode = createShowAliveStmt(pCxt, yymsp[-1].minor.yy840,    QUERY_NODE_SHOW_DB_ALIVE_STMT); }
-#line 6215 "sql.c"
+#line 6233 "sql.c"
         break;
-      case 273: /* cmd ::= SHOW CLUSTER ALIVE */
+      case 274: /* cmd ::= SHOW CLUSTER ALIVE */
 #line 482 "sql.y"
 { pCxt->pRootNode = createShowAliveStmt(pCxt, NULL, QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT); }
-#line 6220 "sql.c"
+#line 6238 "sql.c"
         break;
-      case 274: /* db_name_cond_opt ::= */
-      case 279: /* from_db_opt ::= */ yytestcase(yyruleno==279);
+      case 275: /* db_name_cond_opt ::= */
+      case 280: /* from_db_opt ::= */ yytestcase(yyruleno==280);
 #line 484 "sql.y"
 { yymsp[1].minor.yy840 = createDefaultDatabaseCondValue(pCxt); }
-#line 6226 "sql.c"
+#line 6244 "sql.c"
         break;
-      case 275: /* db_name_cond_opt ::= db_name NK_DOT */
+      case 276: /* db_name_cond_opt ::= db_name NK_DOT */
 #line 485 "sql.y"
 { yylhsminor.yy840 = createIdentifierValueNode(pCxt, &yymsp[-1].minor.yy129); }
-#line 6231 "sql.c"
+#line 6249 "sql.c"
   yymsp[-1].minor.yy840 = yylhsminor.yy840;
         break;
-      case 277: /* like_pattern_opt ::= LIKE NK_STRING */
+      case 278: /* like_pattern_opt ::= LIKE NK_STRING */
 #line 488 "sql.y"
 { yymsp[-1].minor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); }
-#line 6237 "sql.c"
+#line 6255 "sql.c"
         break;
-      case 278: /* table_name_cond ::= table_name */
+      case 279: /* table_name_cond ::= table_name */
 #line 490 "sql.y"
 { yylhsminor.yy840 = createIdentifierValueNode(pCxt, &yymsp[0].minor.yy129); }
-#line 6242 "sql.c"
+#line 6260 "sql.c"
   yymsp[0].minor.yy840 = yylhsminor.yy840;
         break;
-      case 280: /* from_db_opt ::= FROM db_name */
+      case 281: /* from_db_opt ::= FROM db_name */
 #line 493 "sql.y"
 { yymsp[-1].minor.yy840 = createIdentifierValueNode(pCxt, &yymsp[0].minor.yy129); }
-#line 6248 "sql.c"
+#line 6266 "sql.c"
         break;
-      case 284: /* tag_item ::= TBNAME */
+      case 285: /* tag_item ::= TBNAME */
 #line 501 "sql.y"
 { yylhsminor.yy840 = setProjectionAlias(pCxt, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL), &yymsp[0].minor.yy0); }
-#line 6253 "sql.c"
+#line 6271 "sql.c"
   yymsp[0].minor.yy840 = yylhsminor.yy840;
         break;
-      case 287: /* tag_item ::= column_name column_alias */
+      case 288: /* tag_item ::= column_name column_alias */
 #line 504 "sql.y"
 { yylhsminor.yy840 = setProjectionAlias(pCxt, createColumnNode(pCxt, NULL, &yymsp[-1].minor.yy129), &yymsp[0].minor.yy129); }
-#line 6259 "sql.c"
+#line 6277 "sql.c"
   yymsp[-1].minor.yy840 = yylhsminor.yy840;
         break;
-      case 288: /* tag_item ::= column_name AS column_alias */
+      case 289: /* tag_item ::= column_name AS column_alias */
 #line 505 "sql.y"
 { yylhsminor.yy840 = setProjectionAlias(pCxt, createColumnNode(pCxt, NULL, &yymsp[-2].minor.yy129), &yymsp[0].minor.yy129); }
-#line 6265 "sql.c"
+#line 6283 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 289: /* cmd ::= CREATE SMA INDEX not_exists_opt full_index_name ON full_table_name index_options */
+      case 290: /* cmd ::= CREATE SMA INDEX not_exists_opt full_index_name ON full_table_name index_options */
 #line 509 "sql.y"
 { pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_SMA, yymsp[-4].minor.yy313, yymsp[-3].minor.yy840, yymsp[-1].minor.yy840, NULL, yymsp[0].minor.yy840); }
-#line 6271 "sql.c"
+#line 6289 "sql.c"
         break;
-      case 290: /* cmd ::= CREATE INDEX not_exists_opt full_index_name ON full_table_name NK_LP col_name_list NK_RP */
+      case 291: /* cmd ::= CREATE INDEX not_exists_opt full_index_name ON full_table_name NK_LP col_name_list NK_RP */
 #line 511 "sql.y"
 { pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_NORMAL, yymsp[-6].minor.yy313, yymsp[-5].minor.yy840, yymsp[-3].minor.yy840, yymsp[-1].minor.yy56, NULL); }
-#line 6276 "sql.c"
+#line 6294 "sql.c"
         break;
-      case 291: /* cmd ::= DROP INDEX exists_opt full_index_name */
+      case 292: /* cmd ::= DROP INDEX exists_opt full_index_name */
 #line 512 "sql.y"
 { pCxt->pRootNode = createDropIndexStmt(pCxt, yymsp[-1].minor.yy313, yymsp[0].minor.yy840); }
-#line 6281 "sql.c"
+#line 6299 "sql.c"
         break;
-      case 292: /* full_index_name ::= index_name */
+      case 293: /* full_index_name ::= index_name */
 #line 514 "sql.y"
 { yylhsminor.yy840 = createRealTableNodeForIndexName(pCxt, NULL, &yymsp[0].minor.yy129); }
-#line 6286 "sql.c"
+#line 6304 "sql.c"
   yymsp[0].minor.yy840 = yylhsminor.yy840;
         break;
-      case 293: /* full_index_name ::= db_name NK_DOT index_name */
+      case 294: /* full_index_name ::= db_name NK_DOT index_name */
 #line 515 "sql.y"
 { yylhsminor.yy840 = createRealTableNodeForIndexName(pCxt, &yymsp[-2].minor.yy129, &yymsp[0].minor.yy129); }
-#line 6292 "sql.c"
+#line 6310 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 294: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */
+      case 295: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */
 #line 518 "sql.y"
 { yymsp[-9].minor.yy840 = createIndexOption(pCxt, yymsp[-7].minor.yy56, releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), NULL, yymsp[-1].minor.yy840, yymsp[0].minor.yy840); }
-#line 6298 "sql.c"
+#line 6316 "sql.c"
         break;
-      case 295: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt sma_stream_opt */
+      case 296: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt sma_stream_opt */
 #line 521 "sql.y"
 { yymsp[-11].minor.yy840 = createIndexOption(pCxt, yymsp[-9].minor.yy56, releaseRawExprNode(pCxt, yymsp[-5].minor.yy840), releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), yymsp[-1].minor.yy840, yymsp[0].minor.yy840); }
-#line 6303 "sql.c"
+#line 6321 "sql.c"
         break;
-      case 298: /* func ::= sma_func_name NK_LP expression_list NK_RP */
+      case 299: /* func ::= sma_func_name NK_LP expression_list NK_RP */
 #line 528 "sql.y"
 { yylhsminor.yy840 = createFunctionNode(pCxt, &yymsp[-3].minor.yy129, yymsp[-1].minor.yy56); }
-#line 6308 "sql.c"
+#line 6326 "sql.c"
   yymsp[-3].minor.yy840 = yylhsminor.yy840;
         break;
-      case 299: /* sma_func_name ::= function_name */
-      case 513: /* alias_opt ::= table_alias */ yytestcase(yyruleno==513);
+      case 300: /* sma_func_name ::= function_name */
+      case 514: /* alias_opt ::= table_alias */ yytestcase(yyruleno==514);
 #line 532 "sql.y"
 { yylhsminor.yy129 = yymsp[0].minor.yy129; }
-#line 6315 "sql.c"
+#line 6333 "sql.c"
   yymsp[0].minor.yy129 = yylhsminor.yy129;
         break;
-      case 304: /* sma_stream_opt ::= */
-      case 345: /* stream_options ::= */ yytestcase(yyruleno==345);
+      case 305: /* sma_stream_opt ::= */
+      case 346: /* stream_options ::= */ yytestcase(yyruleno==346);
 #line 538 "sql.y"
 { yymsp[1].minor.yy840 = createStreamOptions(pCxt); }
-#line 6322 "sql.c"
+#line 6340 "sql.c"
         break;
-      case 305: /* sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */
+      case 306: /* sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */
 #line 539 "sql.y"
 { ((SStreamOptions*)yymsp[-2].minor.yy840)->pWatermark = releaseRawExprNode(pCxt, yymsp[0].minor.yy840); yylhsminor.yy840 = yymsp[-2].minor.yy840; }
-#line 6327 "sql.c"
+#line 6345 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 306: /* sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */
+      case 307: /* sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */
 #line 540 "sql.y"
 { ((SStreamOptions*)yymsp[-2].minor.yy840)->pDelay = releaseRawExprNode(pCxt, yymsp[0].minor.yy840); yylhsminor.yy840 = yymsp[-2].minor.yy840; }
-#line 6333 "sql.c"
+#line 6351 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 307: /* sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */
+      case 308: /* sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */
 #line 541 "sql.y"
 { ((SStreamOptions*)yymsp[-2].minor.yy840)->pDeleteMark = releaseRawExprNode(pCxt, yymsp[0].minor.yy840); yylhsminor.yy840 = yymsp[-2].minor.yy840; }
-#line 6339 "sql.c"
+#line 6357 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 308: /* with_meta ::= AS */
+      case 309: /* with_meta ::= AS */
 #line 546 "sql.y"
 { yymsp[0].minor.yy356 = 0; }
-#line 6345 "sql.c"
+#line 6363 "sql.c"
         break;
-      case 309: /* with_meta ::= WITH META AS */
+      case 310: /* with_meta ::= WITH META AS */
 #line 547 "sql.y"
 { yymsp[-2].minor.yy356 = 1; }
-#line 6350 "sql.c"
+#line 6368 "sql.c"
         break;
-      case 310: /* with_meta ::= ONLY META AS */
+      case 311: /* with_meta ::= ONLY META AS */
 #line 548 "sql.y"
 { yymsp[-2].minor.yy356 = 2; }
-#line 6355 "sql.c"
+#line 6373 "sql.c"
         break;
-      case 311: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */
+      case 312: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */
 #line 550 "sql.y"
 { pCxt->pRootNode = createCreateTopicStmtUseQuery(pCxt, yymsp[-3].minor.yy313, &yymsp[-2].minor.yy129, yymsp[0].minor.yy840); }
-#line 6360 "sql.c"
+#line 6378 "sql.c"
         break;
-      case 312: /* cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name */
+      case 313: /* cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name */
 #line 552 "sql.y"
 { pCxt->pRootNode = createCreateTopicStmtUseDb(pCxt, yymsp[-4].minor.yy313, &yymsp[-3].minor.yy129, &yymsp[0].minor.yy129, yymsp[-2].minor.yy356); }
-#line 6365 "sql.c"
+#line 6383 "sql.c"
         break;
-      case 313: /* cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt */
+      case 314: /* cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt */
 #line 554 "sql.y"
 { pCxt->pRootNode = createCreateTopicStmtUseTable(pCxt, yymsp[-5].minor.yy313, &yymsp[-4].minor.yy129, yymsp[-1].minor.yy840, yymsp[-3].minor.yy356, yymsp[0].minor.yy840); }
-#line 6370 "sql.c"
+#line 6388 "sql.c"
         break;
-      case 314: /* cmd ::= DROP TOPIC exists_opt topic_name */
+      case 315: /* cmd ::= DROP TOPIC exists_opt topic_name */
 #line 556 "sql.y"
 { pCxt->pRootNode = createDropTopicStmt(pCxt, yymsp[-1].minor.yy313, &yymsp[0].minor.yy129); }
-#line 6375 "sql.c"
+#line 6393 "sql.c"
         break;
-      case 315: /* cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */
+      case 316: /* cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */
 #line 557 "sql.y"
 { pCxt->pRootNode = createDropCGroupStmt(pCxt, yymsp[-3].minor.yy313, &yymsp[-2].minor.yy129, &yymsp[0].minor.yy129); }
-#line 6380 "sql.c"
+#line 6398 "sql.c"
         break;
-      case 316: /* cmd ::= DESC full_table_name */
-      case 317: /* cmd ::= DESCRIBE full_table_name */ yytestcase(yyruleno==317);
+      case 317: /* cmd ::= DESC full_table_name */
+      case 318: /* cmd ::= DESCRIBE full_table_name */ yytestcase(yyruleno==318);
 #line 560 "sql.y"
 { pCxt->pRootNode = createDescribeStmt(pCxt, yymsp[0].minor.yy840); }
-#line 6386 "sql.c"
+#line 6404 "sql.c"
         break;
-      case 318: /* cmd ::= RESET QUERY CACHE */
+      case 319: /* cmd ::= RESET QUERY CACHE */
 #line 564 "sql.y"
 { pCxt->pRootNode = createResetQueryCacheStmt(pCxt); }
-#line 6391 "sql.c"
+#line 6409 "sql.c"
         break;
-      case 319: /* cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */
-      case 320: /* cmd ::= EXPLAIN analyze_opt explain_options insert_query */ yytestcase(yyruleno==320);
+      case 320: /* cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */
+      case 321: /* cmd ::= EXPLAIN analyze_opt explain_options insert_query */ yytestcase(yyruleno==321);
 #line 567 "sql.y"
 { pCxt->pRootNode = createExplainStmt(pCxt, yymsp[-2].minor.yy313, yymsp[-1].minor.yy840, yymsp[0].minor.yy840); }
-#line 6397 "sql.c"
+#line 6415 "sql.c"
         break;
-      case 323: /* explain_options ::= */
+      case 324: /* explain_options ::= */
 #line 575 "sql.y"
 { yymsp[1].minor.yy840 = createDefaultExplainOptions(pCxt); }
-#line 6402 "sql.c"
+#line 6420 "sql.c"
         break;
-      case 324: /* explain_options ::= explain_options VERBOSE NK_BOOL */
+      case 325: /* explain_options ::= explain_options VERBOSE NK_BOOL */
 #line 576 "sql.y"
 { yylhsminor.yy840 = setExplainVerbose(pCxt, yymsp[-2].minor.yy840, &yymsp[0].minor.yy0); }
-#line 6407 "sql.c"
+#line 6425 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 325: /* explain_options ::= explain_options RATIO NK_FLOAT */
+      case 326: /* explain_options ::= explain_options RATIO NK_FLOAT */
 #line 577 "sql.y"
 { yylhsminor.yy840 = setExplainRatio(pCxt, yymsp[-2].minor.yy840, &yymsp[0].minor.yy0); }
-#line 6413 "sql.c"
+#line 6431 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 326: /* cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt */
+      case 327: /* cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt */
 #line 582 "sql.y"
 { pCxt->pRootNode = createCreateFunctionStmt(pCxt, yymsp[-7].minor.yy313, yymsp[-9].minor.yy313, &yymsp[-6].minor.yy129, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy784, yymsp[-1].minor.yy356, &yymsp[0].minor.yy129, yymsp[-10].minor.yy313); }
-#line 6419 "sql.c"
+#line 6437 "sql.c"
         break;
-      case 327: /* cmd ::= DROP FUNCTION exists_opt function_name */
+      case 328: /* cmd ::= DROP FUNCTION exists_opt function_name */
 #line 583 "sql.y"
 { pCxt->pRootNode = createDropFunctionStmt(pCxt, yymsp[-1].minor.yy313, &yymsp[0].minor.yy129); }
-#line 6424 "sql.c"
+#line 6442 "sql.c"
         break;
-      case 332: /* language_opt ::= */
+      case 333: /* language_opt ::= */
 #line 597 "sql.y"
 { yymsp[1].minor.yy129 = nil_token; }
-#line 6429 "sql.c"
+#line 6447 "sql.c"
         break;
-      case 333: /* language_opt ::= LANGUAGE NK_STRING */
+      case 334: /* language_opt ::= LANGUAGE NK_STRING */
 #line 598 "sql.y"
 { yymsp[-1].minor.yy129 = yymsp[0].minor.yy0; }
-#line 6434 "sql.c"
+#line 6452 "sql.c"
         break;
-      case 336: /* cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name col_list_opt tag_def_or_ref_opt subtable_opt AS query_or_subquery */
+      case 337: /* cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name col_list_opt tag_def_or_ref_opt subtable_opt AS query_or_subquery */
 #line 608 "sql.y"
 { pCxt->pRootNode = createCreateStreamStmt(pCxt, yymsp[-9].minor.yy313, &yymsp[-8].minor.yy129, yymsp[-5].minor.yy840, yymsp[-7].minor.yy840, yymsp[-3].minor.yy56, yymsp[-2].minor.yy840, yymsp[0].minor.yy840, yymsp[-4].minor.yy56); }
-#line 6439 "sql.c"
+#line 6457 "sql.c"
         break;
-      case 337: /* cmd ::= DROP STREAM exists_opt stream_name */
+      case 338: /* cmd ::= DROP STREAM exists_opt stream_name */
 #line 609 "sql.y"
 { pCxt->pRootNode = createDropStreamStmt(pCxt, yymsp[-1].minor.yy313, &yymsp[0].minor.yy129); }
-#line 6444 "sql.c"
+#line 6462 "sql.c"
         break;
-      case 338: /* cmd ::= PAUSE STREAM exists_opt stream_name */
+      case 339: /* cmd ::= PAUSE STREAM exists_opt stream_name */
 #line 610 "sql.y"
 { pCxt->pRootNode = createPauseStreamStmt(pCxt, yymsp[-1].minor.yy313, &yymsp[0].minor.yy129); }
-#line 6449 "sql.c"
+#line 6467 "sql.c"
         break;
-      case 339: /* cmd ::= RESUME STREAM exists_opt ignore_opt stream_name */
+      case 340: /* cmd ::= RESUME STREAM exists_opt ignore_opt stream_name */
 #line 611 "sql.y"
 { pCxt->pRootNode = createResumeStreamStmt(pCxt, yymsp[-2].minor.yy313, yymsp[-1].minor.yy313, &yymsp[0].minor.yy129); }
-#line 6454 "sql.c"
+#line 6472 "sql.c"
         break;
-      case 346: /* stream_options ::= stream_options TRIGGER AT_ONCE */
-      case 347: /* stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ yytestcase(yyruleno==347);
+      case 347: /* stream_options ::= stream_options TRIGGER AT_ONCE */
+      case 348: /* stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ yytestcase(yyruleno==348);
 #line 625 "sql.y"
 { yylhsminor.yy840 = setStreamOptions(pCxt, yymsp[-2].minor.yy840, SOPT_TRIGGER_TYPE_SET, &yymsp[0].minor.yy0, NULL); }
-#line 6460 "sql.c"
+#line 6478 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 348: /* stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */
+      case 349: /* stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */
 #line 627 "sql.y"
 { yylhsminor.yy840 = setStreamOptions(pCxt, yymsp[-3].minor.yy840, SOPT_TRIGGER_TYPE_SET, &yymsp[-1].minor.yy0, releaseRawExprNode(pCxt, yymsp[0].minor.yy840)); }
-#line 6466 "sql.c"
+#line 6484 "sql.c"
   yymsp[-3].minor.yy840 = yylhsminor.yy840;
         break;
-      case 349: /* stream_options ::= stream_options WATERMARK duration_literal */
+      case 350: /* stream_options ::= stream_options WATERMARK duration_literal */
 #line 628 "sql.y"
 { yylhsminor.yy840 = setStreamOptions(pCxt, yymsp[-2].minor.yy840, SOPT_WATERMARK_SET, NULL, releaseRawExprNode(pCxt, yymsp[0].minor.yy840)); }
-#line 6472 "sql.c"
-  yymsp[-2].minor.yy840 = yylhsminor.yy840;
-        break;
-      case 350: /* stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */
-#line 629 "sql.y"
-{ yylhsminor.yy840 = setStreamOptions(pCxt, yymsp[-3].minor.yy840, SOPT_IGNORE_EXPIRED_SET, &yymsp[0].minor.yy0, NULL); }
-#line 6478 "sql.c"
-  yymsp[-3].minor.yy840 = yylhsminor.yy840;
-        break;
-      case 351: /* stream_options ::= stream_options FILL_HISTORY NK_INTEGER */
-#line 630 "sql.y"
-{ yylhsminor.yy840 = setStreamOptions(pCxt, yymsp[-2].minor.yy840, SOPT_FILL_HISTORY_SET, &yymsp[0].minor.yy0, NULL); }
-#line 6484 "sql.c"
-  yymsp[-2].minor.yy840 = yylhsminor.yy840;
-        break;
-      case 352: /* stream_options ::= stream_options DELETE_MARK duration_literal */
-#line 631 "sql.y"
-{ yylhsminor.yy840 = setStreamOptions(pCxt, yymsp[-2].minor.yy840, SOPT_DELETE_MARK_SET, NULL, releaseRawExprNode(pCxt, yymsp[0].minor.yy840)); }
 #line 6490 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 353: /* stream_options ::= stream_options IGNORE UPDATE NK_INTEGER */
-#line 632 "sql.y"
-{ yylhsminor.yy840 = setStreamOptions(pCxt, yymsp[-3].minor.yy840, SOPT_IGNORE_UPDATE_SET, &yymsp[0].minor.yy0, NULL); }
+      case 351: /* stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */
+#line 629 "sql.y"
+{ yylhsminor.yy840 = setStreamOptions(pCxt, yymsp[-3].minor.yy840, SOPT_IGNORE_EXPIRED_SET, &yymsp[0].minor.yy0, NULL); }
 #line 6496 "sql.c"
   yymsp[-3].minor.yy840 = yylhsminor.yy840;
         break;
-      case 355: /* subtable_opt ::= SUBTABLE NK_LP expression NK_RP */
-      case 549: /* sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ yytestcase(yyruleno==549);
-      case 570: /* every_opt ::= EVERY NK_LP duration_literal NK_RP */ yytestcase(yyruleno==570);
+      case 352: /* stream_options ::= stream_options FILL_HISTORY NK_INTEGER */
+#line 630 "sql.y"
+{ yylhsminor.yy840 = setStreamOptions(pCxt, yymsp[-2].minor.yy840, SOPT_FILL_HISTORY_SET, &yymsp[0].minor.yy0, NULL); }
+#line 6502 "sql.c"
+  yymsp[-2].minor.yy840 = yylhsminor.yy840;
+        break;
+      case 353: /* stream_options ::= stream_options DELETE_MARK duration_literal */
+#line 631 "sql.y"
+{ yylhsminor.yy840 = setStreamOptions(pCxt, yymsp[-2].minor.yy840, SOPT_DELETE_MARK_SET, NULL, releaseRawExprNode(pCxt, yymsp[0].minor.yy840)); }
+#line 6508 "sql.c"
+  yymsp[-2].minor.yy840 = yylhsminor.yy840;
+        break;
+      case 354: /* stream_options ::= stream_options IGNORE UPDATE NK_INTEGER */
+#line 632 "sql.y"
+{ yylhsminor.yy840 = setStreamOptions(pCxt, yymsp[-3].minor.yy840, SOPT_IGNORE_UPDATE_SET, &yymsp[0].minor.yy0, NULL); }
+#line 6514 "sql.c"
+  yymsp[-3].minor.yy840 = yylhsminor.yy840;
+        break;
+      case 356: /* subtable_opt ::= SUBTABLE NK_LP expression NK_RP */
+      case 550: /* sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ yytestcase(yyruleno==550);
+      case 571: /* every_opt ::= EVERY NK_LP duration_literal NK_RP */ yytestcase(yyruleno==571);
 #line 635 "sql.y"
 { yymsp[-3].minor.yy840 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy840); }
-#line 6504 "sql.c"
+#line 6522 "sql.c"
         break;
-      case 358: /* cmd ::= KILL CONNECTION NK_INTEGER */
+      case 359: /* cmd ::= KILL CONNECTION NK_INTEGER */
 #line 643 "sql.y"
 { pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_CONNECTION_STMT, &yymsp[0].minor.yy0); }
-#line 6509 "sql.c"
+#line 6527 "sql.c"
         break;
-      case 359: /* cmd ::= KILL QUERY NK_STRING */
+      case 360: /* cmd ::= KILL QUERY NK_STRING */
 #line 644 "sql.y"
 { pCxt->pRootNode = createKillQueryStmt(pCxt, &yymsp[0].minor.yy0); }
-#line 6514 "sql.c"
+#line 6532 "sql.c"
         break;
-      case 360: /* cmd ::= KILL TRANSACTION NK_INTEGER */
+      case 361: /* cmd ::= KILL TRANSACTION NK_INTEGER */
 #line 645 "sql.y"
 { pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_TRANSACTION_STMT, &yymsp[0].minor.yy0); }
-#line 6519 "sql.c"
+#line 6537 "sql.c"
         break;
-      case 361: /* cmd ::= BALANCE VGROUP */
+      case 362: /* cmd ::= BALANCE VGROUP */
 #line 648 "sql.y"
 { pCxt->pRootNode = createBalanceVgroupStmt(pCxt); }
-#line 6524 "sql.c"
+#line 6542 "sql.c"
         break;
-      case 362: /* cmd ::= BALANCE VGROUP LEADER */
+      case 363: /* cmd ::= BALANCE VGROUP LEADER */
 #line 649 "sql.y"
 { pCxt->pRootNode = createBalanceVgroupLeaderStmt(pCxt); }
-#line 6529 "sql.c"
+#line 6547 "sql.c"
         break;
-      case 363: /* cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */
+      case 364: /* cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */
 #line 650 "sql.y"
 { pCxt->pRootNode = createMergeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); }
-#line 6534 "sql.c"
+#line 6552 "sql.c"
         break;
-      case 364: /* cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */
+      case 365: /* cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */
 #line 651 "sql.y"
 { pCxt->pRootNode = createRedistributeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy56); }
-#line 6539 "sql.c"
+#line 6557 "sql.c"
         break;
-      case 365: /* cmd ::= SPLIT VGROUP NK_INTEGER */
+      case 366: /* cmd ::= SPLIT VGROUP NK_INTEGER */
 #line 652 "sql.y"
 { pCxt->pRootNode = createSplitVgroupStmt(pCxt, &yymsp[0].minor.yy0); }
-#line 6544 "sql.c"
+#line 6562 "sql.c"
         break;
-      case 366: /* dnode_list ::= DNODE NK_INTEGER */
+      case 367: /* dnode_list ::= DNODE NK_INTEGER */
 #line 656 "sql.y"
 { yymsp[-1].minor.yy56 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); }
-#line 6549 "sql.c"
+#line 6567 "sql.c"
         break;
-      case 368: /* cmd ::= DELETE FROM full_table_name where_clause_opt */
+      case 369: /* cmd ::= DELETE FROM full_table_name where_clause_opt */
 #line 663 "sql.y"
 { pCxt->pRootNode = createDeleteStmt(pCxt, yymsp[-1].minor.yy840, yymsp[0].minor.yy840); }
-#line 6554 "sql.c"
+#line 6572 "sql.c"
         break;
-      case 371: /* insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */
+      case 372: /* insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */
 #line 672 "sql.y"
 { yymsp[-6].minor.yy840 = createInsertStmt(pCxt, yymsp[-4].minor.yy840, yymsp[-2].minor.yy56, yymsp[0].minor.yy840); }
-#line 6559 "sql.c"
+#line 6577 "sql.c"
         break;
-      case 372: /* insert_query ::= INSERT INTO full_table_name query_or_subquery */
+      case 373: /* insert_query ::= INSERT INTO full_table_name query_or_subquery */
 #line 673 "sql.y"
 { yymsp[-3].minor.yy840 = createInsertStmt(pCxt, yymsp[-1].minor.yy840, NULL, yymsp[0].minor.yy840); }
-#line 6564 "sql.c"
+#line 6582 "sql.c"
         break;
-      case 373: /* literal ::= NK_INTEGER */
+      case 374: /* literal ::= NK_INTEGER */
 #line 676 "sql.y"
 { yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0)); }
-#line 6569 "sql.c"
-  yymsp[0].minor.yy840 = yylhsminor.yy840;
-        break;
-      case 374: /* literal ::= NK_FLOAT */
-#line 677 "sql.y"
-{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0)); }
-#line 6575 "sql.c"
-  yymsp[0].minor.yy840 = yylhsminor.yy840;
-        break;
-      case 375: /* literal ::= NK_STRING */
-#line 678 "sql.y"
-{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); }
-#line 6581 "sql.c"
-  yymsp[0].minor.yy840 = yylhsminor.yy840;
-        break;
-      case 376: /* literal ::= NK_BOOL */
-#line 679 "sql.y"
-{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0)); }
 #line 6587 "sql.c"
   yymsp[0].minor.yy840 = yylhsminor.yy840;
         break;
-      case 377: /* literal ::= TIMESTAMP NK_STRING */
+      case 375: /* literal ::= NK_FLOAT */
+#line 677 "sql.y"
+{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0)); }
+#line 6593 "sql.c"
+  yymsp[0].minor.yy840 = yylhsminor.yy840;
+        break;
+      case 376: /* literal ::= NK_STRING */
+#line 678 "sql.y"
+{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); }
+#line 6599 "sql.c"
+  yymsp[0].minor.yy840 = yylhsminor.yy840;
+        break;
+      case 377: /* literal ::= NK_BOOL */
+#line 679 "sql.y"
+{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0)); }
+#line 6605 "sql.c"
+  yymsp[0].minor.yy840 = yylhsminor.yy840;
+        break;
+      case 378: /* literal ::= TIMESTAMP NK_STRING */
 #line 680 "sql.y"
 { yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0)); }
-#line 6593 "sql.c"
+#line 6611 "sql.c"
   yymsp[-1].minor.yy840 = yylhsminor.yy840;
         break;
-      case 378: /* literal ::= duration_literal */
-      case 388: /* signed_literal ::= signed */ yytestcase(yyruleno==388);
-      case 409: /* expr_or_subquery ::= expression */ yytestcase(yyruleno==409);
-      case 410: /* expression ::= literal */ yytestcase(yyruleno==410);
-      case 411: /* expression ::= pseudo_column */ yytestcase(yyruleno==411);
-      case 412: /* expression ::= column_reference */ yytestcase(yyruleno==412);
-      case 413: /* expression ::= function_expression */ yytestcase(yyruleno==413);
-      case 414: /* expression ::= case_when_expression */ yytestcase(yyruleno==414);
-      case 445: /* function_expression ::= literal_func */ yytestcase(yyruleno==445);
-      case 494: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==494);
-      case 498: /* boolean_primary ::= predicate */ yytestcase(yyruleno==498);
-      case 500: /* common_expression ::= expr_or_subquery */ yytestcase(yyruleno==500);
-      case 501: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==501);
-      case 504: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==504);
-      case 506: /* table_reference ::= table_primary */ yytestcase(yyruleno==506);
-      case 507: /* table_reference ::= joined_table */ yytestcase(yyruleno==507);
-      case 511: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==511);
-      case 572: /* query_simple ::= query_specification */ yytestcase(yyruleno==572);
-      case 573: /* query_simple ::= union_query_expression */ yytestcase(yyruleno==573);
-      case 576: /* query_simple_or_subquery ::= query_simple */ yytestcase(yyruleno==576);
-      case 578: /* query_or_subquery ::= query_expression */ yytestcase(yyruleno==578);
+      case 379: /* literal ::= duration_literal */
+      case 389: /* signed_literal ::= signed */ yytestcase(yyruleno==389);
+      case 410: /* expr_or_subquery ::= expression */ yytestcase(yyruleno==410);
+      case 411: /* expression ::= literal */ yytestcase(yyruleno==411);
+      case 412: /* expression ::= pseudo_column */ yytestcase(yyruleno==412);
+      case 413: /* expression ::= column_reference */ yytestcase(yyruleno==413);
+      case 414: /* expression ::= function_expression */ yytestcase(yyruleno==414);
+      case 415: /* expression ::= case_when_expression */ yytestcase(yyruleno==415);
+      case 446: /* function_expression ::= literal_func */ yytestcase(yyruleno==446);
+      case 495: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==495);
+      case 499: /* boolean_primary ::= predicate */ yytestcase(yyruleno==499);
+      case 501: /* common_expression ::= expr_or_subquery */ yytestcase(yyruleno==501);
+      case 502: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==502);
+      case 505: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==505);
+      case 507: /* table_reference ::= table_primary */ yytestcase(yyruleno==507);
+      case 508: /* table_reference ::= joined_table */ yytestcase(yyruleno==508);
+      case 512: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==512);
+      case 573: /* query_simple ::= query_specification */ yytestcase(yyruleno==573);
+      case 574: /* query_simple ::= union_query_expression */ yytestcase(yyruleno==574);
+      case 577: /* query_simple_or_subquery ::= query_simple */ yytestcase(yyruleno==577);
+      case 579: /* query_or_subquery ::= query_expression */ yytestcase(yyruleno==579);
 #line 681 "sql.y"
 { yylhsminor.yy840 = yymsp[0].minor.yy840; }
-#line 6619 "sql.c"
-  yymsp[0].minor.yy840 = yylhsminor.yy840;
-        break;
-      case 379: /* literal ::= NULL */
-#line 682 "sql.y"
-{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0)); }
-#line 6625 "sql.c"
-  yymsp[0].minor.yy840 = yylhsminor.yy840;
-        break;
-      case 380: /* literal ::= NK_QUESTION */
-#line 683 "sql.y"
-{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0)); }
-#line 6631 "sql.c"
-  yymsp[0].minor.yy840 = yylhsminor.yy840;
-        break;
-      case 381: /* duration_literal ::= NK_VARIABLE */
-#line 685 "sql.y"
-{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); }
 #line 6637 "sql.c"
   yymsp[0].minor.yy840 = yylhsminor.yy840;
         break;
-      case 382: /* signed ::= NK_INTEGER */
-#line 687 "sql.y"
-{ yylhsminor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); }
+      case 380: /* literal ::= NULL */
+#line 682 "sql.y"
+{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0)); }
 #line 6643 "sql.c"
   yymsp[0].minor.yy840 = yylhsminor.yy840;
         break;
-      case 383: /* signed ::= NK_PLUS NK_INTEGER */
+      case 381: /* literal ::= NK_QUESTION */
+#line 683 "sql.y"
+{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0)); }
+#line 6649 "sql.c"
+  yymsp[0].minor.yy840 = yylhsminor.yy840;
+        break;
+      case 382: /* duration_literal ::= NK_VARIABLE */
+#line 685 "sql.y"
+{ yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); }
+#line 6655 "sql.c"
+  yymsp[0].minor.yy840 = yylhsminor.yy840;
+        break;
+      case 383: /* signed ::= NK_INTEGER */
+#line 687 "sql.y"
+{ yylhsminor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); }
+#line 6661 "sql.c"
+  yymsp[0].minor.yy840 = yylhsminor.yy840;
+        break;
+      case 384: /* signed ::= NK_PLUS NK_INTEGER */
 #line 688 "sql.y"
 { yymsp[-1].minor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); }
-#line 6649 "sql.c"
+#line 6667 "sql.c"
         break;
-      case 384: /* signed ::= NK_MINUS NK_INTEGER */
+      case 385: /* signed ::= NK_MINUS NK_INTEGER */
 #line 689 "sql.y"
 { 
                                                                                     SToken t = yymsp[-1].minor.yy0;
                                                                                     t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z;
                                                                                     yylhsminor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &t);
                                                                                   }
-#line 6658 "sql.c"
+#line 6676 "sql.c"
   yymsp[-1].minor.yy840 = yylhsminor.yy840;
         break;
-      case 385: /* signed ::= NK_FLOAT */
+      case 386: /* signed ::= NK_FLOAT */
 #line 694 "sql.y"
 { yylhsminor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); }
-#line 6664 "sql.c"
+#line 6682 "sql.c"
   yymsp[0].minor.yy840 = yylhsminor.yy840;
         break;
-      case 386: /* signed ::= NK_PLUS NK_FLOAT */
+      case 387: /* signed ::= NK_PLUS NK_FLOAT */
 #line 695 "sql.y"
 { yymsp[-1].minor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); }
-#line 6670 "sql.c"
+#line 6688 "sql.c"
         break;
-      case 387: /* signed ::= NK_MINUS NK_FLOAT */
+      case 388: /* signed ::= NK_MINUS NK_FLOAT */
 #line 696 "sql.y"
 { 
                                                                                     SToken t = yymsp[-1].minor.yy0;
                                                                                     t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z;
                                                                                     yylhsminor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &t);
                                                                                   }
-#line 6679 "sql.c"
+#line 6697 "sql.c"
   yymsp[-1].minor.yy840 = yylhsminor.yy840;
         break;
-      case 389: /* signed_literal ::= NK_STRING */
+      case 390: /* signed_literal ::= NK_STRING */
 #line 703 "sql.y"
 { yylhsminor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); }
-#line 6685 "sql.c"
+#line 6703 "sql.c"
   yymsp[0].minor.yy840 = yylhsminor.yy840;
         break;
-      case 390: /* signed_literal ::= NK_BOOL */
+      case 391: /* signed_literal ::= NK_BOOL */
 #line 704 "sql.y"
 { yylhsminor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0); }
-#line 6691 "sql.c"
-  yymsp[0].minor.yy840 = yylhsminor.yy840;
-        break;
-      case 391: /* signed_literal ::= TIMESTAMP NK_STRING */
-#line 705 "sql.y"
-{ yymsp[-1].minor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); }
-#line 6697 "sql.c"
-        break;
-      case 392: /* signed_literal ::= duration_literal */
-      case 394: /* signed_literal ::= literal_func */ yytestcase(yyruleno==394);
-      case 465: /* star_func_para ::= expr_or_subquery */ yytestcase(yyruleno==465);
-      case 529: /* select_item ::= common_expression */ yytestcase(yyruleno==529);
-      case 539: /* partition_item ::= expr_or_subquery */ yytestcase(yyruleno==539);
-      case 577: /* query_simple_or_subquery ::= subquery */ yytestcase(yyruleno==577);
-      case 579: /* query_or_subquery ::= subquery */ yytestcase(yyruleno==579);
-      case 592: /* search_condition ::= common_expression */ yytestcase(yyruleno==592);
-#line 706 "sql.y"
-{ yylhsminor.yy840 = releaseRawExprNode(pCxt, yymsp[0].minor.yy840); }
 #line 6709 "sql.c"
   yymsp[0].minor.yy840 = yylhsminor.yy840;
         break;
-      case 393: /* signed_literal ::= NULL */
+      case 392: /* signed_literal ::= TIMESTAMP NK_STRING */
+#line 705 "sql.y"
+{ yymsp[-1].minor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); }
+#line 6715 "sql.c"
+        break;
+      case 393: /* signed_literal ::= duration_literal */
+      case 395: /* signed_literal ::= literal_func */ yytestcase(yyruleno==395);
+      case 466: /* star_func_para ::= expr_or_subquery */ yytestcase(yyruleno==466);
+      case 530: /* select_item ::= common_expression */ yytestcase(yyruleno==530);
+      case 540: /* partition_item ::= expr_or_subquery */ yytestcase(yyruleno==540);
+      case 578: /* query_simple_or_subquery ::= subquery */ yytestcase(yyruleno==578);
+      case 580: /* query_or_subquery ::= subquery */ yytestcase(yyruleno==580);
+      case 593: /* search_condition ::= common_expression */ yytestcase(yyruleno==593);
+#line 706 "sql.y"
+{ yylhsminor.yy840 = releaseRawExprNode(pCxt, yymsp[0].minor.yy840); }
+#line 6727 "sql.c"
+  yymsp[0].minor.yy840 = yylhsminor.yy840;
+        break;
+      case 394: /* signed_literal ::= NULL */
 #line 707 "sql.y"
 { yylhsminor.yy840 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0); }
-#line 6715 "sql.c"
+#line 6733 "sql.c"
   yymsp[0].minor.yy840 = yylhsminor.yy840;
         break;
-      case 395: /* signed_literal ::= NK_QUESTION */
+      case 396: /* signed_literal ::= NK_QUESTION */
 #line 709 "sql.y"
 { yylhsminor.yy840 = createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0); }
-#line 6721 "sql.c"
+#line 6739 "sql.c"
   yymsp[0].minor.yy840 = yylhsminor.yy840;
         break;
-      case 415: /* expression ::= NK_LP expression NK_RP */
-      case 499: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==499);
-      case 591: /* subquery ::= NK_LP subquery NK_RP */ yytestcase(yyruleno==591);
+      case 416: /* expression ::= NK_LP expression NK_RP */
+      case 500: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==500);
+      case 592: /* subquery ::= NK_LP subquery NK_RP */ yytestcase(yyruleno==592);
 #line 770 "sql.y"
 { yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy840)); }
-#line 6729 "sql.c"
+#line 6747 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 416: /* expression ::= NK_PLUS expr_or_subquery */
+      case 417: /* expression ::= NK_PLUS expr_or_subquery */
 #line 771 "sql.y"
 {
                                                                                     SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
                                                                                     yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy840));
                                                                                   }
-#line 6738 "sql.c"
+#line 6756 "sql.c"
   yymsp[-1].minor.yy840 = yylhsminor.yy840;
         break;
-      case 417: /* expression ::= NK_MINUS expr_or_subquery */
+      case 418: /* expression ::= NK_MINUS expr_or_subquery */
 #line 775 "sql.y"
 {
                                                                                     SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
                                                                                     yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_MINUS, releaseRawExprNode(pCxt, yymsp[0].minor.yy840), NULL));
                                                                                   }
-#line 6747 "sql.c"
+#line 6765 "sql.c"
   yymsp[-1].minor.yy840 = yylhsminor.yy840;
         break;
-      case 418: /* expression ::= expr_or_subquery NK_PLUS expr_or_subquery */
+      case 419: /* expression ::= expr_or_subquery NK_PLUS expr_or_subquery */
 #line 779 "sql.y"
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
                                                                                     yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_ADD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840))); 
                                                                                   }
-#line 6757 "sql.c"
+#line 6775 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 419: /* expression ::= expr_or_subquery NK_MINUS expr_or_subquery */
+      case 420: /* expression ::= expr_or_subquery NK_MINUS expr_or_subquery */
 #line 784 "sql.y"
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
                                                                                     yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_SUB, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840))); 
                                                                                   }
-#line 6767 "sql.c"
+#line 6785 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 420: /* expression ::= expr_or_subquery NK_STAR expr_or_subquery */
+      case 421: /* expression ::= expr_or_subquery NK_STAR expr_or_subquery */
 #line 789 "sql.y"
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
                                                                                     yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MULTI, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840))); 
                                                                                   }
-#line 6777 "sql.c"
+#line 6795 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 421: /* expression ::= expr_or_subquery NK_SLASH expr_or_subquery */
+      case 422: /* expression ::= expr_or_subquery NK_SLASH expr_or_subquery */
 #line 794 "sql.y"
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
                                                                                     yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_DIV, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840))); 
                                                                                   }
-#line 6787 "sql.c"
+#line 6805 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 422: /* expression ::= expr_or_subquery NK_REM expr_or_subquery */
+      case 423: /* expression ::= expr_or_subquery NK_REM expr_or_subquery */
 #line 799 "sql.y"
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
                                                                                     yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_REM, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840)));
                                                                                   }
-#line 6797 "sql.c"
+#line 6815 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 423: /* expression ::= column_reference NK_ARROW NK_STRING */
+      case 424: /* expression ::= column_reference NK_ARROW NK_STRING */
 #line 804 "sql.y"
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840);
                                                                                     yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_JSON_GET_VALUE, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0))); 
                                                                                   }
-#line 6806 "sql.c"
+#line 6824 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 424: /* expression ::= expr_or_subquery NK_BITAND expr_or_subquery */
+      case 425: /* expression ::= expr_or_subquery NK_BITAND expr_or_subquery */
 #line 808 "sql.y"
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
                                                                                     yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840)));
                                                                                   }
-#line 6816 "sql.c"
+#line 6834 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 425: /* expression ::= expr_or_subquery NK_BITOR expr_or_subquery */
+      case 426: /* expression ::= expr_or_subquery NK_BITOR expr_or_subquery */
 #line 813 "sql.y"
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
                                                                                     yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840)));
                                                                                   }
-#line 6826 "sql.c"
+#line 6844 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 428: /* column_reference ::= column_name */
+      case 429: /* column_reference ::= column_name */
 #line 824 "sql.y"
 { yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy129, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy129)); }
-#line 6832 "sql.c"
+#line 6850 "sql.c"
   yymsp[0].minor.yy840 = yylhsminor.yy840;
         break;
-      case 429: /* column_reference ::= table_name NK_DOT column_name */
+      case 430: /* column_reference ::= table_name NK_DOT column_name */
 #line 825 "sql.y"
 { yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy129, &yymsp[0].minor.yy129, createColumnNode(pCxt, &yymsp[-2].minor.yy129, &yymsp[0].minor.yy129)); }
-#line 6838 "sql.c"
+#line 6856 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 430: /* pseudo_column ::= ROWTS */
-      case 431: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==431);
-      case 433: /* pseudo_column ::= QSTART */ yytestcase(yyruleno==433);
-      case 434: /* pseudo_column ::= QEND */ yytestcase(yyruleno==434);
-      case 435: /* pseudo_column ::= QDURATION */ yytestcase(yyruleno==435);
-      case 436: /* pseudo_column ::= WSTART */ yytestcase(yyruleno==436);
-      case 437: /* pseudo_column ::= WEND */ yytestcase(yyruleno==437);
-      case 438: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==438);
-      case 439: /* pseudo_column ::= IROWTS */ yytestcase(yyruleno==439);
-      case 440: /* pseudo_column ::= ISFILLED */ yytestcase(yyruleno==440);
-      case 441: /* pseudo_column ::= QTAGS */ yytestcase(yyruleno==441);
-      case 447: /* literal_func ::= NOW */ yytestcase(yyruleno==447);
+      case 431: /* pseudo_column ::= ROWTS */
+      case 432: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==432);
+      case 434: /* pseudo_column ::= QSTART */ yytestcase(yyruleno==434);
+      case 435: /* pseudo_column ::= QEND */ yytestcase(yyruleno==435);
+      case 436: /* pseudo_column ::= QDURATION */ yytestcase(yyruleno==436);
+      case 437: /* pseudo_column ::= WSTART */ yytestcase(yyruleno==437);
+      case 438: /* pseudo_column ::= WEND */ yytestcase(yyruleno==438);
+      case 439: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==439);
+      case 440: /* pseudo_column ::= IROWTS */ yytestcase(yyruleno==440);
+      case 441: /* pseudo_column ::= ISFILLED */ yytestcase(yyruleno==441);
+      case 442: /* pseudo_column ::= QTAGS */ yytestcase(yyruleno==442);
+      case 448: /* literal_func ::= NOW */ yytestcase(yyruleno==448);
 #line 827 "sql.y"
 { yylhsminor.yy840 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); }
-#line 6855 "sql.c"
+#line 6873 "sql.c"
   yymsp[0].minor.yy840 = yylhsminor.yy840;
         break;
-      case 432: /* pseudo_column ::= table_name NK_DOT TBNAME */
+      case 433: /* pseudo_column ::= table_name NK_DOT TBNAME */
 #line 829 "sql.y"
 { yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy129, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-2].minor.yy129)))); }
-#line 6861 "sql.c"
+#line 6879 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 442: /* function_expression ::= function_name NK_LP expression_list NK_RP */
-      case 443: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==443);
+      case 443: /* function_expression ::= function_name NK_LP expression_list NK_RP */
+      case 444: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==444);
 #line 840 "sql.y"
 { yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy129, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy129, yymsp[-1].minor.yy56)); }
-#line 6868 "sql.c"
+#line 6886 "sql.c"
   yymsp[-3].minor.yy840 = yylhsminor.yy840;
         break;
-      case 444: /* function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */
+      case 445: /* function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */
 #line 843 "sql.y"
 { yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), yymsp[-1].minor.yy784)); }
-#line 6874 "sql.c"
+#line 6892 "sql.c"
   yymsp[-5].minor.yy840 = yylhsminor.yy840;
         break;
-      case 446: /* literal_func ::= noarg_func NK_LP NK_RP */
+      case 447: /* literal_func ::= noarg_func NK_LP NK_RP */
 #line 846 "sql.y"
 { yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy129, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-2].minor.yy129, NULL)); }
-#line 6880 "sql.c"
+#line 6898 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 461: /* star_func_para_list ::= NK_STAR */
+      case 462: /* star_func_para_list ::= NK_STAR */
 #line 870 "sql.y"
 { yylhsminor.yy56 = createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); }
-#line 6886 "sql.c"
+#line 6904 "sql.c"
   yymsp[0].minor.yy56 = yylhsminor.yy56;
         break;
-      case 466: /* star_func_para ::= table_name NK_DOT NK_STAR */
-      case 532: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==532);
+      case 467: /* star_func_para ::= table_name NK_DOT NK_STAR */
+      case 533: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==533);
 #line 879 "sql.y"
 { yylhsminor.yy840 = createColumnNode(pCxt, &yymsp[-2].minor.yy129, &yymsp[0].minor.yy0); }
-#line 6893 "sql.c"
+#line 6911 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 467: /* case_when_expression ::= CASE when_then_list case_when_else_opt END */
+      case 468: /* case_when_expression ::= CASE when_then_list case_when_else_opt END */
 #line 882 "sql.y"
 { yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, createCaseWhenNode(pCxt, NULL, yymsp[-2].minor.yy56, yymsp[-1].minor.yy840)); }
-#line 6899 "sql.c"
+#line 6917 "sql.c"
   yymsp[-3].minor.yy840 = yylhsminor.yy840;
         break;
-      case 468: /* case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */
+      case 469: /* case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */
 #line 884 "sql.y"
 { yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-4].minor.yy0, &yymsp[0].minor.yy0, createCaseWhenNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), yymsp[-2].minor.yy56, yymsp[-1].minor.yy840)); }
-#line 6905 "sql.c"
+#line 6923 "sql.c"
   yymsp[-4].minor.yy840 = yylhsminor.yy840;
         break;
-      case 471: /* when_then_expr ::= WHEN common_expression THEN common_expression */
+      case 472: /* when_then_expr ::= WHEN common_expression THEN common_expression */
 #line 891 "sql.y"
 { yymsp[-3].minor.yy840 = createWhenThenNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840)); }
-#line 6911 "sql.c"
+#line 6929 "sql.c"
         break;
-      case 473: /* case_when_else_opt ::= ELSE common_expression */
+      case 474: /* case_when_else_opt ::= ELSE common_expression */
 #line 894 "sql.y"
 { yymsp[-1].minor.yy840 = releaseRawExprNode(pCxt, yymsp[0].minor.yy840); }
-#line 6916 "sql.c"
+#line 6934 "sql.c"
         break;
-      case 474: /* predicate ::= expr_or_subquery compare_op expr_or_subquery */
-      case 479: /* predicate ::= expr_or_subquery in_op in_predicate_value */ yytestcase(yyruleno==479);
+      case 475: /* predicate ::= expr_or_subquery compare_op expr_or_subquery */
+      case 480: /* predicate ::= expr_or_subquery in_op in_predicate_value */ yytestcase(yyruleno==480);
 #line 897 "sql.y"
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
                                                                                     yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, yymsp[-1].minor.yy76, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840)));
                                                                                   }
-#line 6926 "sql.c"
+#line 6944 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 475: /* predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */
+      case 476: /* predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */
 #line 904 "sql.y"
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy840);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
                                                                                     yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-4].minor.yy840), releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840)));
                                                                                   }
-#line 6936 "sql.c"
+#line 6954 "sql.c"
   yymsp[-4].minor.yy840 = yylhsminor.yy840;
         break;
-      case 476: /* predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */
+      case 477: /* predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */
 #line 910 "sql.y"
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy840);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
                                                                                     yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createNotBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy840), releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840)));
                                                                                   }
-#line 6946 "sql.c"
+#line 6964 "sql.c"
   yymsp[-5].minor.yy840 = yylhsminor.yy840;
         break;
-      case 477: /* predicate ::= expr_or_subquery IS NULL */
+      case 478: /* predicate ::= expr_or_subquery IS NULL */
 #line 915 "sql.y"
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840);
                                                                                     yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), NULL));
                                                                                   }
-#line 6955 "sql.c"
+#line 6973 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 478: /* predicate ::= expr_or_subquery IS NOT NULL */
+      case 479: /* predicate ::= expr_or_subquery IS NOT NULL */
 #line 919 "sql.y"
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy840);
                                                                                     yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), NULL));
                                                                                   }
-#line 6964 "sql.c"
+#line 6982 "sql.c"
   yymsp[-3].minor.yy840 = yylhsminor.yy840;
         break;
-      case 480: /* compare_op ::= NK_LT */
+      case 481: /* compare_op ::= NK_LT */
 #line 931 "sql.y"
 { yymsp[0].minor.yy76 = OP_TYPE_LOWER_THAN; }
-#line 6970 "sql.c"
+#line 6988 "sql.c"
         break;
-      case 481: /* compare_op ::= NK_GT */
+      case 482: /* compare_op ::= NK_GT */
 #line 932 "sql.y"
 { yymsp[0].minor.yy76 = OP_TYPE_GREATER_THAN; }
-#line 6975 "sql.c"
+#line 6993 "sql.c"
         break;
-      case 482: /* compare_op ::= NK_LE */
+      case 483: /* compare_op ::= NK_LE */
 #line 933 "sql.y"
 { yymsp[0].minor.yy76 = OP_TYPE_LOWER_EQUAL; }
-#line 6980 "sql.c"
+#line 6998 "sql.c"
         break;
-      case 483: /* compare_op ::= NK_GE */
+      case 484: /* compare_op ::= NK_GE */
 #line 934 "sql.y"
 { yymsp[0].minor.yy76 = OP_TYPE_GREATER_EQUAL; }
-#line 6985 "sql.c"
+#line 7003 "sql.c"
         break;
-      case 484: /* compare_op ::= NK_NE */
+      case 485: /* compare_op ::= NK_NE */
 #line 935 "sql.y"
 { yymsp[0].minor.yy76 = OP_TYPE_NOT_EQUAL; }
-#line 6990 "sql.c"
+#line 7008 "sql.c"
         break;
-      case 485: /* compare_op ::= NK_EQ */
+      case 486: /* compare_op ::= NK_EQ */
 #line 936 "sql.y"
 { yymsp[0].minor.yy76 = OP_TYPE_EQUAL; }
-#line 6995 "sql.c"
+#line 7013 "sql.c"
         break;
-      case 486: /* compare_op ::= LIKE */
+      case 487: /* compare_op ::= LIKE */
 #line 937 "sql.y"
 { yymsp[0].minor.yy76 = OP_TYPE_LIKE; }
-#line 7000 "sql.c"
+#line 7018 "sql.c"
         break;
-      case 487: /* compare_op ::= NOT LIKE */
+      case 488: /* compare_op ::= NOT LIKE */
 #line 938 "sql.y"
 { yymsp[-1].minor.yy76 = OP_TYPE_NOT_LIKE; }
-#line 7005 "sql.c"
+#line 7023 "sql.c"
         break;
-      case 488: /* compare_op ::= MATCH */
+      case 489: /* compare_op ::= MATCH */
 #line 939 "sql.y"
 { yymsp[0].minor.yy76 = OP_TYPE_MATCH; }
-#line 7010 "sql.c"
+#line 7028 "sql.c"
         break;
-      case 489: /* compare_op ::= NMATCH */
+      case 490: /* compare_op ::= NMATCH */
 #line 940 "sql.y"
 { yymsp[0].minor.yy76 = OP_TYPE_NMATCH; }
-#line 7015 "sql.c"
+#line 7033 "sql.c"
         break;
-      case 490: /* compare_op ::= CONTAINS */
+      case 491: /* compare_op ::= CONTAINS */
 #line 941 "sql.y"
 { yymsp[0].minor.yy76 = OP_TYPE_JSON_CONTAINS; }
-#line 7020 "sql.c"
+#line 7038 "sql.c"
         break;
-      case 491: /* in_op ::= IN */
+      case 492: /* in_op ::= IN */
 #line 945 "sql.y"
 { yymsp[0].minor.yy76 = OP_TYPE_IN; }
-#line 7025 "sql.c"
+#line 7043 "sql.c"
         break;
-      case 492: /* in_op ::= NOT IN */
+      case 493: /* in_op ::= NOT IN */
 #line 946 "sql.y"
 { yymsp[-1].minor.yy76 = OP_TYPE_NOT_IN; }
-#line 7030 "sql.c"
+#line 7048 "sql.c"
         break;
-      case 493: /* in_predicate_value ::= NK_LP literal_list NK_RP */
+      case 494: /* in_predicate_value ::= NK_LP literal_list NK_RP */
 #line 948 "sql.y"
 { yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy56)); }
-#line 7035 "sql.c"
+#line 7053 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 495: /* boolean_value_expression ::= NOT boolean_primary */
+      case 496: /* boolean_value_expression ::= NOT boolean_primary */
 #line 952 "sql.y"
 {
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
                                                                                     yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy840), NULL));
                                                                                   }
-#line 7044 "sql.c"
+#line 7062 "sql.c"
   yymsp[-1].minor.yy840 = yylhsminor.yy840;
         break;
-      case 496: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
+      case 497: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
 #line 957 "sql.y"
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
                                                                                     yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840)));
                                                                                   }
-#line 7054 "sql.c"
+#line 7072 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 497: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
+      case 498: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
 #line 963 "sql.y"
 {
                                                                                     SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy840);
                                                                                     SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy840);
                                                                                     yylhsminor.yy840 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), releaseRawExprNode(pCxt, yymsp[0].minor.yy840)));
                                                                                   }
-#line 7064 "sql.c"
+#line 7082 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 505: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */
+      case 506: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */
 #line 981 "sql.y"
 { yylhsminor.yy840 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, yymsp[-2].minor.yy840, yymsp[0].minor.yy840, NULL); }
-#line 7070 "sql.c"
+#line 7088 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 508: /* table_primary ::= table_name alias_opt */
+      case 509: /* table_primary ::= table_name alias_opt */
 #line 987 "sql.y"
 { yylhsminor.yy840 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy129, &yymsp[0].minor.yy129); }
-#line 7076 "sql.c"
+#line 7094 "sql.c"
   yymsp[-1].minor.yy840 = yylhsminor.yy840;
         break;
-      case 509: /* table_primary ::= db_name NK_DOT table_name alias_opt */
+      case 510: /* table_primary ::= db_name NK_DOT table_name alias_opt */
 #line 988 "sql.y"
 { yylhsminor.yy840 = createRealTableNode(pCxt, &yymsp[-3].minor.yy129, &yymsp[-1].minor.yy129, &yymsp[0].minor.yy129); }
-#line 7082 "sql.c"
+#line 7100 "sql.c"
   yymsp[-3].minor.yy840 = yylhsminor.yy840;
         break;
-      case 510: /* table_primary ::= subquery alias_opt */
+      case 511: /* table_primary ::= subquery alias_opt */
 #line 989 "sql.y"
 { yylhsminor.yy840 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy840), &yymsp[0].minor.yy129); }
-#line 7088 "sql.c"
+#line 7106 "sql.c"
   yymsp[-1].minor.yy840 = yylhsminor.yy840;
         break;
-      case 512: /* alias_opt ::= */
+      case 513: /* alias_opt ::= */
 #line 994 "sql.y"
 { yymsp[1].minor.yy129 = nil_token;  }
-#line 7094 "sql.c"
+#line 7112 "sql.c"
         break;
-      case 514: /* alias_opt ::= AS table_alias */
+      case 515: /* alias_opt ::= AS table_alias */
 #line 996 "sql.y"
 { yymsp[-1].minor.yy129 = yymsp[0].minor.yy129; }
-#line 7099 "sql.c"
+#line 7117 "sql.c"
         break;
-      case 515: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */
-      case 516: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==516);
+      case 516: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */
+      case 517: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==517);
 #line 998 "sql.y"
 { yymsp[-2].minor.yy840 = yymsp[-1].minor.yy840; }
-#line 7105 "sql.c"
+#line 7123 "sql.c"
         break;
-      case 517: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
+      case 518: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
 #line 1003 "sql.y"
 { yylhsminor.yy840 = createJoinTableNode(pCxt, yymsp[-4].minor.yy708, yymsp[-5].minor.yy840, yymsp[-2].minor.yy840, yymsp[0].minor.yy840); }
-#line 7110 "sql.c"
+#line 7128 "sql.c"
   yymsp[-5].minor.yy840 = yylhsminor.yy840;
         break;
-      case 518: /* join_type ::= */
+      case 519: /* join_type ::= */
 #line 1007 "sql.y"
 { yymsp[1].minor.yy708 = JOIN_TYPE_INNER; }
-#line 7116 "sql.c"
+#line 7134 "sql.c"
         break;
-      case 519: /* join_type ::= INNER */
+      case 520: /* join_type ::= INNER */
 #line 1008 "sql.y"
 { yymsp[0].minor.yy708 = JOIN_TYPE_INNER; }
-#line 7121 "sql.c"
+#line 7139 "sql.c"
         break;
-      case 520: /* query_specification ::= SELECT tag_mode_opt set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
+      case 521: /* query_specification ::= SELECT tag_mode_opt set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
 #line 1014 "sql.y"
 {
                                                                                     yymsp[-12].minor.yy840 = createSelectStmt(pCxt, yymsp[-10].minor.yy313, yymsp[-9].minor.yy56, yymsp[-8].minor.yy840);
@@ -7134,213 +7152,213 @@ static YYACTIONTYPE yy_reduce(
                                                                                     yymsp[-12].minor.yy840 = addEveryClause(pCxt, yymsp[-12].minor.yy840, yymsp[-4].minor.yy840);
                                                                                     yymsp[-12].minor.yy840 = addFillClause(pCxt, yymsp[-12].minor.yy840, yymsp[-3].minor.yy840);
                                                                                   }
-#line 7137 "sql.c"
+#line 7155 "sql.c"
         break;
-      case 525: /* set_quantifier_opt ::= ALL */
+      case 526: /* set_quantifier_opt ::= ALL */
 #line 1036 "sql.y"
 { yymsp[0].minor.yy313 = false; }
-#line 7142 "sql.c"
+#line 7160 "sql.c"
         break;
-      case 528: /* select_item ::= NK_STAR */
+      case 529: /* select_item ::= NK_STAR */
 #line 1043 "sql.y"
 { yylhsminor.yy840 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0); }
-#line 7147 "sql.c"
+#line 7165 "sql.c"
   yymsp[0].minor.yy840 = yylhsminor.yy840;
         break;
-      case 530: /* select_item ::= common_expression column_alias */
-      case 540: /* partition_item ::= expr_or_subquery column_alias */ yytestcase(yyruleno==540);
+      case 531: /* select_item ::= common_expression column_alias */
+      case 541: /* partition_item ::= expr_or_subquery column_alias */ yytestcase(yyruleno==541);
 #line 1045 "sql.y"
 { yylhsminor.yy840 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy840), &yymsp[0].minor.yy129); }
-#line 7154 "sql.c"
+#line 7172 "sql.c"
   yymsp[-1].minor.yy840 = yylhsminor.yy840;
         break;
-      case 531: /* select_item ::= common_expression AS column_alias */
-      case 541: /* partition_item ::= expr_or_subquery AS column_alias */ yytestcase(yyruleno==541);
+      case 532: /* select_item ::= common_expression AS column_alias */
+      case 542: /* partition_item ::= expr_or_subquery AS column_alias */ yytestcase(yyruleno==542);
 #line 1046 "sql.y"
 { yylhsminor.yy840 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), &yymsp[0].minor.yy129); }
-#line 7161 "sql.c"
+#line 7179 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 536: /* partition_by_clause_opt ::= PARTITION BY partition_list */
-      case 561: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==561);
-      case 581: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==581);
+      case 537: /* partition_by_clause_opt ::= PARTITION BY partition_list */
+      case 562: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==562);
+      case 582: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==582);
 #line 1055 "sql.y"
 { yymsp[-2].minor.yy56 = yymsp[0].minor.yy56; }
-#line 7169 "sql.c"
+#line 7187 "sql.c"
         break;
-      case 543: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
+      case 544: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
 #line 1068 "sql.y"
 { yymsp[-5].minor.yy840 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), releaseRawExprNode(pCxt, yymsp[-1].minor.yy840)); }
-#line 7174 "sql.c"
+#line 7192 "sql.c"
         break;
-      case 544: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */
+      case 545: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */
 #line 1069 "sql.y"
 { yymsp[-3].minor.yy840 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy840)); }
-#line 7179 "sql.c"
+#line 7197 "sql.c"
         break;
-      case 545: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
+      case 546: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
 #line 1071 "sql.y"
 { yymsp[-5].minor.yy840 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), NULL, yymsp[-1].minor.yy840, yymsp[0].minor.yy840); }
-#line 7184 "sql.c"
+#line 7202 "sql.c"
         break;
-      case 546: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
+      case 547: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
 #line 1074 "sql.y"
 { yymsp[-7].minor.yy840 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy840), releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), yymsp[-1].minor.yy840, yymsp[0].minor.yy840); }
-#line 7189 "sql.c"
+#line 7207 "sql.c"
         break;
-      case 547: /* twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */
+      case 548: /* twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */
 #line 1076 "sql.y"
 { yymsp[-6].minor.yy840 = createEventWindowNode(pCxt, yymsp[-3].minor.yy840, yymsp[0].minor.yy840); }
-#line 7194 "sql.c"
+#line 7212 "sql.c"
         break;
-      case 551: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */
+      case 552: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */
 #line 1082 "sql.y"
 { yymsp[-3].minor.yy840 = createFillNode(pCxt, yymsp[-1].minor.yy694, NULL); }
-#line 7199 "sql.c"
+#line 7217 "sql.c"
         break;
-      case 552: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */
+      case 553: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */
 #line 1083 "sql.y"
 { yymsp[-5].minor.yy840 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy56)); }
-#line 7204 "sql.c"
+#line 7222 "sql.c"
         break;
-      case 553: /* fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */
+      case 554: /* fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */
 #line 1084 "sql.y"
 { yymsp[-5].minor.yy840 = createFillNode(pCxt, FILL_MODE_VALUE_F, createNodeListNode(pCxt, yymsp[-1].minor.yy56)); }
-#line 7209 "sql.c"
+#line 7227 "sql.c"
         break;
-      case 554: /* fill_mode ::= NONE */
+      case 555: /* fill_mode ::= NONE */
 #line 1088 "sql.y"
 { yymsp[0].minor.yy694 = FILL_MODE_NONE; }
-#line 7214 "sql.c"
+#line 7232 "sql.c"
         break;
-      case 555: /* fill_mode ::= PREV */
+      case 556: /* fill_mode ::= PREV */
 #line 1089 "sql.y"
 { yymsp[0].minor.yy694 = FILL_MODE_PREV; }
-#line 7219 "sql.c"
+#line 7237 "sql.c"
         break;
-      case 556: /* fill_mode ::= NULL */
+      case 557: /* fill_mode ::= NULL */
 #line 1090 "sql.y"
 { yymsp[0].minor.yy694 = FILL_MODE_NULL; }
-#line 7224 "sql.c"
+#line 7242 "sql.c"
         break;
-      case 557: /* fill_mode ::= NULL_F */
+      case 558: /* fill_mode ::= NULL_F */
 #line 1091 "sql.y"
 { yymsp[0].minor.yy694 = FILL_MODE_NULL_F; }
-#line 7229 "sql.c"
+#line 7247 "sql.c"
         break;
-      case 558: /* fill_mode ::= LINEAR */
+      case 559: /* fill_mode ::= LINEAR */
 #line 1092 "sql.y"
 { yymsp[0].minor.yy694 = FILL_MODE_LINEAR; }
-#line 7234 "sql.c"
+#line 7252 "sql.c"
         break;
-      case 559: /* fill_mode ::= NEXT */
+      case 560: /* fill_mode ::= NEXT */
 #line 1093 "sql.y"
 { yymsp[0].minor.yy694 = FILL_MODE_NEXT; }
-#line 7239 "sql.c"
+#line 7257 "sql.c"
         break;
-      case 562: /* group_by_list ::= expr_or_subquery */
+      case 563: /* group_by_list ::= expr_or_subquery */
 #line 1102 "sql.y"
 { yylhsminor.yy56 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy840))); }
-#line 7244 "sql.c"
+#line 7262 "sql.c"
   yymsp[0].minor.yy56 = yylhsminor.yy56;
         break;
-      case 563: /* group_by_list ::= group_by_list NK_COMMA expr_or_subquery */
+      case 564: /* group_by_list ::= group_by_list NK_COMMA expr_or_subquery */
 #line 1103 "sql.y"
 { yylhsminor.yy56 = addNodeToList(pCxt, yymsp[-2].minor.yy56, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy840))); }
-#line 7250 "sql.c"
+#line 7268 "sql.c"
   yymsp[-2].minor.yy56 = yylhsminor.yy56;
         break;
-      case 567: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */
+      case 568: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */
 #line 1110 "sql.y"
 { yymsp[-5].minor.yy840 = createInterpTimeRange(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy840), releaseRawExprNode(pCxt, yymsp[-1].minor.yy840)); }
-#line 7256 "sql.c"
+#line 7274 "sql.c"
         break;
-      case 568: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */
+      case 569: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */
 #line 1112 "sql.y"
 { yymsp[-3].minor.yy840 = createInterpTimePoint(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy840)); }
-#line 7261 "sql.c"
+#line 7279 "sql.c"
         break;
-      case 571: /* query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */
+      case 572: /* query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */
 #line 1119 "sql.y"
 {
                                                                                     yylhsminor.yy840 = addOrderByClause(pCxt, yymsp[-3].minor.yy840, yymsp[-2].minor.yy56);
                                                                                     yylhsminor.yy840 = addSlimitClause(pCxt, yylhsminor.yy840, yymsp[-1].minor.yy840);
                                                                                     yylhsminor.yy840 = addLimitClause(pCxt, yylhsminor.yy840, yymsp[0].minor.yy840);
                                                                                   }
-#line 7270 "sql.c"
+#line 7288 "sql.c"
   yymsp[-3].minor.yy840 = yylhsminor.yy840;
         break;
-      case 574: /* union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */
+      case 575: /* union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */
 #line 1129 "sql.y"
 { yylhsminor.yy840 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy840, yymsp[0].minor.yy840); }
-#line 7276 "sql.c"
+#line 7294 "sql.c"
   yymsp[-3].minor.yy840 = yylhsminor.yy840;
         break;
-      case 575: /* union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */
+      case 576: /* union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */
 #line 1131 "sql.y"
 { yylhsminor.yy840 = createSetOperator(pCxt, SET_OP_TYPE_UNION, yymsp[-2].minor.yy840, yymsp[0].minor.yy840); }
-#line 7282 "sql.c"
+#line 7300 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 583: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */
-      case 587: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==587);
+      case 584: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */
+      case 588: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==588);
 #line 1145 "sql.y"
 { yymsp[-1].minor.yy840 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); }
-#line 7289 "sql.c"
+#line 7307 "sql.c"
         break;
-      case 584: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
-      case 588: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==588);
+      case 585: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
+      case 589: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==589);
 #line 1146 "sql.y"
 { yymsp[-3].minor.yy840 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); }
-#line 7295 "sql.c"
+#line 7313 "sql.c"
         break;
-      case 585: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
-      case 589: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==589);
+      case 586: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+      case 590: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==590);
 #line 1147 "sql.y"
 { yymsp[-3].minor.yy840 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); }
-#line 7301 "sql.c"
+#line 7319 "sql.c"
         break;
-      case 590: /* subquery ::= NK_LP query_expression NK_RP */
+      case 591: /* subquery ::= NK_LP query_expression NK_RP */
 #line 1155 "sql.y"
 { yylhsminor.yy840 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy840); }
-#line 7306 "sql.c"
+#line 7324 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 595: /* sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */
+      case 596: /* sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */
 #line 1169 "sql.y"
 { yylhsminor.yy840 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy840), yymsp[-1].minor.yy82, yymsp[0].minor.yy521); }
-#line 7312 "sql.c"
+#line 7330 "sql.c"
   yymsp[-2].minor.yy840 = yylhsminor.yy840;
         break;
-      case 596: /* ordering_specification_opt ::= */
+      case 597: /* ordering_specification_opt ::= */
 #line 1173 "sql.y"
 { yymsp[1].minor.yy82 = ORDER_ASC; }
-#line 7318 "sql.c"
+#line 7336 "sql.c"
         break;
-      case 597: /* ordering_specification_opt ::= ASC */
+      case 598: /* ordering_specification_opt ::= ASC */
 #line 1174 "sql.y"
 { yymsp[0].minor.yy82 = ORDER_ASC; }
-#line 7323 "sql.c"
+#line 7341 "sql.c"
         break;
-      case 598: /* ordering_specification_opt ::= DESC */
+      case 599: /* ordering_specification_opt ::= DESC */
 #line 1175 "sql.y"
 { yymsp[0].minor.yy82 = ORDER_DESC; }
-#line 7328 "sql.c"
+#line 7346 "sql.c"
         break;
-      case 599: /* null_ordering_opt ::= */
+      case 600: /* null_ordering_opt ::= */
 #line 1179 "sql.y"
 { yymsp[1].minor.yy521 = NULL_ORDER_DEFAULT; }
-#line 7333 "sql.c"
+#line 7351 "sql.c"
         break;
-      case 600: /* null_ordering_opt ::= NULLS FIRST */
+      case 601: /* null_ordering_opt ::= NULLS FIRST */
 #line 1180 "sql.y"
 { yymsp[-1].minor.yy521 = NULL_ORDER_FIRST; }
-#line 7338 "sql.c"
+#line 7356 "sql.c"
         break;
-      case 601: /* null_ordering_opt ::= NULLS LAST */
+      case 602: /* null_ordering_opt ::= NULLS LAST */
 #line 1181 "sql.y"
 { yymsp[-1].minor.yy521 = NULL_ORDER_LAST; }
-#line 7343 "sql.c"
+#line 7361 "sql.c"
         break;
       default:
         break;
@@ -7413,7 +7431,7 @@ static void yy_syntax_error(
   } else if (TSDB_CODE_PAR_DB_NOT_SPECIFIED == pCxt->errCode && TK_NK_FLOAT == TOKEN.type) {
     pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_SYNTAX_ERROR, TOKEN.z);
   }
-#line 7416 "sql.c"
+#line 7434 "sql.c"
 /************ End %syntax_error code ******************************************/
   ParseARG_STORE /* Suppress warning about unused %extra_argument variable */
   ParseCTX_STORE
diff --git a/source/libs/planner/inc/planInt.h b/source/libs/planner/inc/planInt.h
index 092fe17411..24d77cb9a4 100644
--- a/source/libs/planner/inc/planInt.h
+++ b/source/libs/planner/inc/planInt.h
@@ -43,8 +43,14 @@ int32_t splitLogicPlan(SPlanContext* pCxt, SLogicSubplan* pLogicSubplan);
 int32_t scaleOutLogicPlan(SPlanContext* pCxt, SLogicSubplan* pLogicSubplan, SQueryLogicPlan** pLogicPlan);
 int32_t createPhysiPlan(SPlanContext* pCxt, SQueryLogicPlan* pLogicPlan, SQueryPlan** pPlan, SArray* pExecNodeList);
 
-bool    isPartTableAgg(SAggLogicNode* pAgg);
-bool    isPartTableWinodw(SWindowLogicNode* pWindow);
+bool isPartTableAgg(SAggLogicNode* pAgg);
+bool isPartTagAgg(SAggLogicNode* pAgg);
+bool isPartTableWinodw(SWindowLogicNode* pWindow);
+
+#define CLONE_LIMIT 1
+#define CLONE_SLIMIT 1 << 1
+#define CLONE_LIMIT_SLIMIT (CLONE_LIMIT | CLONE_SLIMIT)
+bool cloneLimit(SLogicNode* pParent, SLogicNode* pChild, uint8_t cloneWhat);
 
 #ifdef __cplusplus
 }
diff --git a/source/libs/planner/src/planOptimizer.c b/source/libs/planner/src/planOptimizer.c
index a9e36d4d03..2d21359c62 100644
--- a/source/libs/planner/src/planOptimizer.c
+++ b/source/libs/planner/src/planOptimizer.c
@@ -368,8 +368,8 @@ static void scanPathOptSetGroupOrderScan(SScanLogicNode* pScan) {
 
   if (pScan->node.pParent && nodeType(pScan->node.pParent) == QUERY_NODE_LOGIC_PLAN_AGG) {
     SAggLogicNode* pAgg = (SAggLogicNode*)pScan->node.pParent;
-    bool           withSlimit = pAgg->node.pSlimit != NULL || (pAgg->node.pParent && pAgg->node.pParent->pSlimit);
-    if (withSlimit && isPartTableAgg(pAgg)) {
+    bool           withSlimit = pAgg->node.pSlimit != NULL;
+    if (withSlimit && (isPartTableAgg(pAgg) || isPartTagAgg(pAgg))) {
       pScan->groupOrderScan = pAgg->node.forceCreateNonBlockingOptr = true;
     }
   }
@@ -2702,39 +2702,31 @@ static void swapLimit(SLogicNode* pParent, SLogicNode* pChild) {
   pParent->pLimit = NULL;
 }
 
-static void cloneLimit(SLogicNode* pParent, SLogicNode* pChild) {
-  SLimitNode* pLimit = NULL;
-  if (pParent->pLimit) {
-    pChild->pLimit = nodesCloneNode(pParent->pLimit);
-    pLimit = (SLimitNode*)pChild->pLimit;
-    pLimit->limit += pLimit->offset;
-    pLimit->offset = 0;
-  }
-
-  if (pParent->pSlimit) {
-    pChild->pSlimit = nodesCloneNode(pParent->pSlimit);
-    pLimit = (SLimitNode*)pChild->pSlimit;
-    pLimit->limit += pLimit->offset;
-    pLimit->offset = 0;
-  }
-}
-
 static bool pushDownLimitHow(SLogicNode* pNodeWithLimit, SLogicNode* pNodeLimitPushTo);
 static bool pushDownLimitTo(SLogicNode* pNodeWithLimit, SLogicNode* pNodeLimitPushTo) {
   switch (nodeType(pNodeLimitPushTo)) {
     case QUERY_NODE_LOGIC_PLAN_WINDOW: {
       SWindowLogicNode* pWindow = (SWindowLogicNode*)pNodeLimitPushTo;
       if (pWindow->winType != WINDOW_TYPE_INTERVAL) break;
-      cloneLimit(pNodeWithLimit, pNodeLimitPushTo);
+      cloneLimit(pNodeWithLimit, pNodeLimitPushTo, CLONE_LIMIT_SLIMIT);
       return true;
     }
     case QUERY_NODE_LOGIC_PLAN_FILL:
     case QUERY_NODE_LOGIC_PLAN_SORT: {
-      cloneLimit(pNodeWithLimit, pNodeLimitPushTo);
+      cloneLimit(pNodeWithLimit, pNodeLimitPushTo, CLONE_LIMIT_SLIMIT);
       SNode* pChild = NULL;
       FOREACH(pChild, pNodeLimitPushTo->pChildren) { pushDownLimitHow(pNodeLimitPushTo, (SLogicNode*)pChild); }
       return true;
     }
+    case QUERY_NODE_LOGIC_PLAN_AGG: {
+      if (nodeType(pNodeWithLimit) == QUERY_NODE_LOGIC_PLAN_PROJECT &&
+          (isPartTagAgg((SAggLogicNode*)pNodeLimitPushTo) || isPartTableAgg((SAggLogicNode*)pNodeLimitPushTo))) {
+        // when part by tag, slimit will be cloned to agg, and it will be pipelined.
+        // The scan below will do scanning with group order
+        return cloneLimit(pNodeWithLimit, pNodeLimitPushTo, CLONE_SLIMIT);
+      }
+      break;
+    }
     case QUERY_NODE_LOGIC_PLAN_SCAN:
       if (nodeType(pNodeWithLimit) == QUERY_NODE_LOGIC_PLAN_PROJECT && pNodeWithLimit->pLimit) {
         swapLimit(pNodeWithLimit, pNodeLimitPushTo);
diff --git a/source/libs/planner/src/planPhysiCreater.c b/source/libs/planner/src/planPhysiCreater.c
index 5f78b5de9c..c180be173a 100644
--- a/source/libs/planner/src/planPhysiCreater.c
+++ b/source/libs/planner/src/planPhysiCreater.c
@@ -887,12 +887,16 @@ static int32_t rewritePrecalcExpr(SPhysiPlanContext* pCxt, SNode* pNode, SNodeLi
 }
 
 static int32_t createAggPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChildren, SAggLogicNode* pAggLogicNode,
-                                  SPhysiNode** pPhyNode) {
+                                  SPhysiNode** pPhyNode, SSubplan* pSubPlan) {
   SAggPhysiNode* pAgg =
       (SAggPhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pAggLogicNode, QUERY_NODE_PHYSICAL_PLAN_HASH_AGG);
   if (NULL == pAgg) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }
+  if (pAgg->node.pSlimit) {
+    pSubPlan->dynamicRowThreshold = true;
+    pSubPlan->rowsThreshold = ((SLimitNode*)pAgg->node.pSlimit)->limit;
+  }
 
   pAgg->mergeDataBlock = (GROUP_ACTION_KEEP == pAggLogicNode->node.groupAction ? false : true);
   pAgg->groupKeyOptimized = pAggLogicNode->hasGroupKeyOptimized;
@@ -1632,7 +1636,7 @@ static int32_t doCreatePhysiNode(SPhysiPlanContext* pCxt, SLogicNode* pLogicNode
     case QUERY_NODE_LOGIC_PLAN_JOIN:
       return createJoinPhysiNode(pCxt, pChildren, (SJoinLogicNode*)pLogicNode, pPhyNode);
     case QUERY_NODE_LOGIC_PLAN_AGG:
-      return createAggPhysiNode(pCxt, pChildren, (SAggLogicNode*)pLogicNode, pPhyNode);
+      return createAggPhysiNode(pCxt, pChildren, (SAggLogicNode*)pLogicNode, pPhyNode, pSubplan);
     case QUERY_NODE_LOGIC_PLAN_PROJECT:
       return createProjectPhysiNode(pCxt, pChildren, (SProjectLogicNode*)pLogicNode, pPhyNode);
     case QUERY_NODE_LOGIC_PLAN_EXCHANGE:
@@ -1736,6 +1740,8 @@ static SSubplan* makeSubplan(SPhysiPlanContext* pCxt, SLogicSubplan* pLogicSubpl
   pSubplan->id = pLogicSubplan->id;
   pSubplan->subplanType = pLogicSubplan->subplanType;
   pSubplan->level = pLogicSubplan->level;
+  pSubplan->rowsThreshold = 4096;
+  pSubplan->dynamicRowThreshold = false;
   if (NULL != pCxt->pPlanCxt->pUser) {
     snprintf(pSubplan->user, sizeof(pSubplan->user), "%s", pCxt->pPlanCxt->pUser);
   }
diff --git a/source/libs/planner/src/planSpliter.c b/source/libs/planner/src/planSpliter.c
index 3f6c73b4e5..868aee7147 100644
--- a/source/libs/planner/src/planSpliter.c
+++ b/source/libs/planner/src/planSpliter.c
@@ -867,8 +867,16 @@ static int32_t stbSplSplitAggNodeForPartTable(SSplitContext* pCxt, SStableSplitI
 static int32_t stbSplSplitAggNodeForCrossTable(SSplitContext* pCxt, SStableSplitInfo* pInfo) {
   SLogicNode* pPartAgg = NULL;
   int32_t     code = stbSplCreatePartAggNode((SAggLogicNode*)pInfo->pSplitNode, &pPartAgg);
+
+
   if (TSDB_CODE_SUCCESS == code) {
-    code = stbSplCreateExchangeNode(pCxt, pInfo->pSplitNode, pPartAgg);
+    // if slimit was pushed down to agg, agg will be pipelined mode, add sort merge before parent agg
+    if ((SAggLogicNode*)pInfo->pSplitNode->pSlimit)
+      code = stbSplCreateMergeNode(pCxt, NULL, pInfo->pSplitNode, NULL, pPartAgg, true);
+    else
+      code = stbSplCreateExchangeNode(pCxt, pInfo->pSplitNode, pPartAgg);
+  } else {
+    nodesDestroyNode((SNode*)pPartAgg);
   }
   if (TSDB_CODE_SUCCESS == code) {
     code = nodesListMakeStrictAppend(&pInfo->pSubplan->pChildren,
diff --git a/source/libs/planner/src/planUtil.c b/source/libs/planner/src/planUtil.c
index 88086cde1d..9febe102f6 100644
--- a/source/libs/planner/src/planUtil.c
+++ b/source/libs/planner/src/planUtil.c
@@ -349,7 +349,7 @@ static bool stbHasPartTbname(SNodeList* pPartKeys) {
   return false;
 }
 
-static SNodeList* stbSplGetPartKeys(SLogicNode* pNode) {
+static SNodeList* stbGetPartKeys(SLogicNode* pNode) {
   if (QUERY_NODE_LOGIC_PLAN_SCAN == nodeType(pNode)) {
     return ((SScanLogicNode*)pNode)->pGroupTags;
   } else if (QUERY_NODE_LOGIC_PLAN_PARTITION == nodeType(pNode)) {
@@ -367,11 +367,58 @@ bool isPartTableAgg(SAggLogicNode* pAgg) {
     return stbHasPartTbname(pAgg->pGroupKeys) &&
            stbNotSystemScan((SLogicNode*)nodesListGetNode(pAgg->node.pChildren, 0));
   }
-  return stbHasPartTbname(stbSplGetPartKeys((SLogicNode*)nodesListGetNode(pAgg->node.pChildren, 0)));
+  return stbHasPartTbname(stbGetPartKeys((SLogicNode*)nodesListGetNode(pAgg->node.pChildren, 0)));
+}
+
+static bool stbHasPartTag(SNodeList* pPartKeys) {
+  if (NULL == pPartKeys) {
+    return false;
+  }
+  SNode* pPartKey = NULL;
+  FOREACH(pPartKey, pPartKeys) {
+    if (QUERY_NODE_GROUPING_SET == nodeType(pPartKey)) {
+      pPartKey = nodesListGetNode(((SGroupingSetNode*)pPartKey)->pParameterList, 0);
+    }
+    if ((QUERY_NODE_FUNCTION == nodeType(pPartKey) && FUNCTION_TYPE_TAGS == ((SFunctionNode*)pPartKey)->funcType) ||
+        (QUERY_NODE_COLUMN == nodeType(pPartKey) && COLUMN_TYPE_TAG == ((SColumnNode*)pPartKey)->colType)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool isPartTagAgg(SAggLogicNode* pAgg) {
+  if (1 != LIST_LENGTH(pAgg->node.pChildren)) {
+    return false;
+  }
+  if (pAgg->pGroupKeys) {
+    return stbHasPartTag(pAgg->pGroupKeys) &&
+      stbNotSystemScan((SLogicNode*)nodesListGetNode(pAgg->node.pChildren, 0));
+  }
+  return stbHasPartTag(stbGetPartKeys((SLogicNode*)nodesListGetNode(pAgg->node.pChildren, 0)));
 }
 
 bool isPartTableWinodw(SWindowLogicNode* pWindow) {
-  return stbHasPartTbname(stbSplGetPartKeys((SLogicNode*)nodesListGetNode(pWindow->node.pChildren, 0)));
+  return stbHasPartTbname(stbGetPartKeys((SLogicNode*)nodesListGetNode(pWindow->node.pChildren, 0)));
 }
 
+bool cloneLimit(SLogicNode* pParent, SLogicNode* pChild, uint8_t cloneWhat) {
+  SLimitNode* pLimit;
+  bool cloned = false;
+  if (pParent->pLimit && (cloneWhat & CLONE_LIMIT)) {
+    pChild->pLimit = nodesCloneNode(pParent->pLimit);
+    pLimit = (SLimitNode*)pChild->pLimit;
+    pLimit->limit += pLimit->offset;
+    pLimit->offset = 0;
+    cloned = true;
+  }
 
+  if (pParent->pSlimit && (cloneWhat & CLONE_SLIMIT)) {
+    pChild->pSlimit = nodesCloneNode(pParent->pSlimit);
+    pLimit = (SLimitNode*)pChild->pSlimit;
+    pLimit->limit += pLimit->offset;
+    pLimit->offset = 0;
+    cloned = true;
+  }
+  return cloned;
+}
diff --git a/source/libs/stream/inc/streamInt.h b/source/libs/stream/inc/streamInt.h
index 32d6dc65d9..7a557a744a 100644
--- a/source/libs/stream/inc/streamInt.h
+++ b/source/libs/stream/inc/streamInt.h
@@ -52,7 +52,6 @@ int32_t streamBroadcastToChildren(SStreamTask* pTask, const SSDataBlock* pBlock)
 
 int32_t tEncodeStreamRetrieveReq(SEncoder* pEncoder, const SStreamRetrieveReq* pReq);
 
-int32_t streamDispatchAllBlocks(SStreamTask* pTask, const SStreamDataBlock* pData);
 int32_t streamDispatchCheckMsg(SStreamTask* pTask, const SStreamTaskCheckReq* pReq, int32_t nodeId, SEpSet* pEpSet);
 
 int32_t streamDoDispatchScanHistoryFinishMsg(SStreamTask* pTask, const SStreamScanHistoryFinishReq* pReq, int32_t vgId,
@@ -63,6 +62,7 @@ SStreamQueueItem* streamMergeQueueItem(SStreamQueueItem* dst, SStreamQueueItem*
 int32_t streamAddEndScanHistoryMsg(SStreamTask* pTask, SRpcHandleInfo* pRpcInfo, SStreamScanHistoryFinishReq* pReq);
 int32_t streamNotifyUpstreamContinue(SStreamTask* pTask);
 int32_t streamTaskFillHistoryFinished(SStreamTask* pTask);
+int32_t streamTransferStateToStreamTask(SStreamTask* pTask);
 
 extern int32_t streamBackendId;
 extern int32_t streamBackendCfWrapperId;
diff --git a/source/libs/stream/src/stream.c b/source/libs/stream/src/stream.c
index f85ade591c..03a0f3586d 100644
--- a/source/libs/stream/src/stream.c
+++ b/source/libs/stream/src/stream.c
@@ -142,40 +142,6 @@ int32_t streamSchedExec(SStreamTask* pTask) {
   return 0;
 }
 
-int32_t streamTaskEnqueueBlocks(SStreamTask* pTask, const SStreamDispatchReq* pReq, SRpcMsg* pRsp) {
-  int8_t status = 0;
-
-  SStreamDataBlock* pBlock = createStreamDataFromDispatchMsg(pReq, STREAM_INPUT__DATA_BLOCK, pReq->dataSrcVgId);
-  if (pBlock == NULL) {
-    streamTaskInputFail(pTask);
-    status = TASK_INPUT_STATUS__FAILED;
-    qError("vgId:%d, s-task:%s failed to receive dispatch msg, reason: out of memory", pTask->pMeta->vgId,
-           pTask->id.idStr);
-  } else {
-    int32_t code = tAppendDataToInputQueue(pTask, (SStreamQueueItem*)pBlock);
-    // input queue is full, upstream is blocked now
-    status = (code == TSDB_CODE_SUCCESS)? TASK_INPUT_STATUS__NORMAL:TASK_INPUT_STATUS__BLOCKED;
-  }
-
-  // rsp by input status
-  void* buf = rpcMallocCont(sizeof(SMsgHead) + sizeof(SStreamDispatchRsp));
-  ((SMsgHead*)buf)->vgId = htonl(pReq->upstreamNodeId);
-  SStreamDispatchRsp* pDispatchRsp = POINTER_SHIFT(buf, sizeof(SMsgHead));
-
-  pDispatchRsp->inputStatus = status;
-  pDispatchRsp->streamId = htobe64(pReq->streamId);
-  pDispatchRsp->upstreamNodeId = htonl(pReq->upstreamNodeId);
-  pDispatchRsp->upstreamTaskId = htonl(pReq->upstreamTaskId);
-  pDispatchRsp->downstreamNodeId = htonl(pTask->info.nodeId);
-  pDispatchRsp->downstreamTaskId = htonl(pTask->id.taskId);
-
-  pRsp->pCont = buf;
-  pRsp->contLen = sizeof(SMsgHead) + sizeof(SStreamDispatchRsp);
-  tmsgSendRsp(pRsp);
-
-  return status == TASK_INPUT_STATUS__NORMAL ? 0 : -1;
-}
-
 int32_t streamTaskEnqueueRetrieve(SStreamTask* pTask, SStreamRetrieveReq* pReq, SRpcMsg* pRsp) {
   SStreamDataBlock* pData = taosAllocateQitem(sizeof(SStreamDataBlock), DEF_QITEM, 0);
   int8_t            status = TASK_INPUT_STATUS__NORMAL;
@@ -235,90 +201,115 @@ int32_t streamTaskOutputResultBlock(SStreamTask* pTask, SStreamDataBlock* pBlock
   return 0;
 }
 
+
+
+static int32_t streamTaskAppendInputBlocks(SStreamTask* pTask, const SStreamDispatchReq* pReq) {
+  int8_t status = 0;
+
+  SStreamDataBlock* pBlock = createStreamDataFromDispatchMsg(pReq, pReq->type, pReq->srcVgId);
+  if (pBlock == NULL) {
+    streamTaskInputFail(pTask);
+    status = TASK_INPUT_STATUS__FAILED;
+    qError("vgId:%d, s-task:%s failed to receive dispatch msg, reason: out of memory", pTask->pMeta->vgId,
+           pTask->id.idStr);
+  } else {
+    if (pBlock->type == STREAM_INPUT__TRANS_STATE) {
+      pTask->status.appendTranstateBlock = true;
+    }
+
+    int32_t code = tAppendDataToInputQueue(pTask, (SStreamQueueItem*)pBlock);
+    // input queue is full, upstream is blocked now
+    status = (code == TSDB_CODE_SUCCESS) ? TASK_INPUT_STATUS__NORMAL : TASK_INPUT_STATUS__BLOCKED;
+  }
+
+  return status;
+}
+
+static int32_t buildDispatchRsp(const SStreamTask* pTask, const SStreamDispatchReq* pReq, int32_t status, void** pBuf) {
+  *pBuf = rpcMallocCont(sizeof(SMsgHead) + sizeof(SStreamDispatchRsp));
+  if (*pBuf == NULL) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  ((SMsgHead*)(*pBuf))->vgId = htonl(pReq->upstreamNodeId);
+  SStreamDispatchRsp* pDispatchRsp = POINTER_SHIFT((*pBuf), sizeof(SMsgHead));
+
+  pDispatchRsp->inputStatus = status;
+  pDispatchRsp->streamId = htobe64(pReq->streamId);
+  pDispatchRsp->upstreamNodeId = htonl(pReq->upstreamNodeId);
+  pDispatchRsp->upstreamTaskId = htonl(pReq->upstreamTaskId);
+  pDispatchRsp->downstreamNodeId = htonl(pTask->info.nodeId);
+  pDispatchRsp->downstreamTaskId = htonl(pTask->id.taskId);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+void streamTaskCloseUpstreamInput(SStreamTask* pTask, int32_t taskId) {
+  SStreamChildEpInfo* pInfo = streamTaskGetUpstreamTaskEpInfo(pTask, taskId);
+  if (pInfo != NULL) {
+    pInfo->dataAllowed = false;
+  }
+}
+
 int32_t streamProcessDispatchMsg(SStreamTask* pTask, SStreamDispatchReq* pReq, SRpcMsg* pRsp, bool exec) {
   qDebug("s-task:%s receive dispatch msg from taskId:0x%x(vgId:%d), msgLen:%" PRId64, pTask->id.idStr,
          pReq->upstreamTaskId, pReq->upstreamNodeId, pReq->totalLen);
 
-  // todo add the input queue buffer limitation
-  streamTaskEnqueueBlocks(pTask, pReq, pRsp);
-  tDeleteStreamDispatchReq(pReq);
+  int32_t status = 0;
 
-  if (exec) {
-    if (streamTryExec(pTask) < 0) {
-      return -1;
-    }
+  SStreamChildEpInfo* pInfo = streamTaskGetUpstreamTaskEpInfo(pTask, pReq->upstreamTaskId);
+  ASSERT(pInfo != NULL);
+
+  if (!pInfo->dataAllowed) {
+    qWarn("s-task:%s data from task:0x%x is denied, since inputQ is closed for it", pTask->id.idStr, pReq->upstreamTaskId);
+    status = TASK_INPUT_STATUS__BLOCKED;
   } else {
-    streamSchedExec(pTask);
+    // Current task has received the checkpoint req from the upstream task, from which the message should all be blocked
+    if (pReq->type == STREAM_INPUT__CHECKPOINT_TRIGGER) {
+      streamTaskCloseUpstreamInput(pTask, pReq->upstreamTaskId);
+      qDebug("s-task:%s close inputQ for upstream:0x%x", pTask->id.idStr, pReq->upstreamTaskId);
+    }
+
+    status = streamTaskAppendInputBlocks(pTask, pReq);
   }
 
-  return 0;
-}
-
-// todo record the idle time for dispatch data
-int32_t streamProcessDispatchRsp(SStreamTask* pTask, SStreamDispatchRsp* pRsp, int32_t code) {
-  if (code != TSDB_CODE_SUCCESS) {
-    // dispatch message failed: network error, or node not available.
-    // in case of the input queue is full, the code will be TSDB_CODE_SUCCESS, the and pRsp>inputStatus will be set
-    // flag. here we need to retry dispatch this message to downstream task immediately. handle the case the failure
-    // happened too fast. todo handle the shuffle dispatch failure
-    if (code == TSDB_CODE_STREAM_TASK_NOT_EXIST) {
-      qError("s-task:%s failed to dispatch msg to task:0x%x, code:%s, no-retry", pTask->id.idStr,
-             pRsp->downstreamTaskId, tstrerror(code));
+  {
+    // do send response with the input status
+    int32_t code = buildDispatchRsp(pTask, pReq, status, &pRsp->pCont);
+    if (code != TSDB_CODE_SUCCESS) {
+      // todo handle failure
       return code;
-    } else {
-      qError("s-task:%s failed to dispatch msg to task:0x%x, code:%s, retry cnt:%d", pTask->id.idStr,
-             pRsp->downstreamTaskId, tstrerror(code), ++pTask->msgInfo.retryCount);
-      return streamDispatchAllBlocks(pTask, pTask->msgInfo.pData);
-    }
-  }
-
-  qDebug("s-task:%s receive dispatch rsp, output status:%d code:%d", pTask->id.idStr, pRsp->inputStatus, code);
-
-  // there are other dispatch message not response yet
-  if (pTask->outputInfo.type == TASK_OUTPUT__SHUFFLE_DISPATCH) {
-    int32_t leftRsp = atomic_sub_fetch_32(&pTask->shuffleDispatcher.waitingRspCnt, 1);
-    qDebug("s-task:%s is shuffle, left waiting rsp %d", pTask->id.idStr, leftRsp);
-    if (leftRsp > 0) {
-      return 0;
-    }
-  }
-
-  pTask->msgInfo.retryCount = 0;
-  ASSERT(pTask->outputInfo.status == TASK_OUTPUT_STATUS__WAIT);
-
-  qDebug("s-task:%s output status is set to:%d", pTask->id.idStr, pTask->outputInfo.status);
-
-  // the input queue of the (down stream) task that receive the output data is full,
-  // so the TASK_INPUT_STATUS_BLOCKED is rsp
-  // todo blocking the output status
-  if (pRsp->inputStatus == TASK_INPUT_STATUS__BLOCKED) {
-    pTask->msgInfo.blockingTs = taosGetTimestampMs(); // record the blocking start time
-
-    int32_t waitDuration = 300; //  300 ms
-    qError("s-task:%s inputQ of downstream task:0x%x is full, time:%" PRId64 "wait for %dms and retry dispatch data",
-           pTask->id.idStr, pRsp->downstreamTaskId, pTask->msgInfo.blockingTs, waitDuration);
-    streamRetryDispatchStreamBlock(pTask, waitDuration);
-  } else { // pipeline send data in output queue
-    // this message has been sent successfully, let's try next one.
-    destroyStreamDataBlock(pTask->msgInfo.pData);
-    pTask->msgInfo.pData = NULL;
-
-    if (pTask->msgInfo.blockingTs != 0) {
-      int64_t el = taosGetTimestampMs() - pTask->msgInfo.blockingTs;
-      qDebug("s-task:%s resume to normal from inputQ blocking, idle time:%"PRId64"ms", pTask->id.idStr, el);
-      pTask->msgInfo.blockingTs = 0;
     }
 
-    // now ready for next data output
-    atomic_store_8(&pTask->outputInfo.status, TASK_OUTPUT_STATUS__NORMAL);
-
-    // otherwise, continue dispatch the first block to down stream task in pipeline
-    streamDispatchStreamBlock(pTask);
+    pRsp->contLen = sizeof(SMsgHead) + sizeof(SStreamDispatchRsp);
+    tmsgSendRsp(pRsp);
   }
 
+  tDeleteStreamDispatchReq(pReq);
+  streamSchedExec(pTask);
+
   return 0;
 }
 
+//int32_t streamProcessDispatchMsg(SStreamTask* pTask, SStreamDispatchReq* pReq, SRpcMsg* pRsp, bool exec) {
+//  qDebug("s-task:%s receive dispatch msg from taskId:0x%x(vgId:%d), msgLen:%" PRId64, pTask->id.idStr,
+//         pReq->upstreamTaskId, pReq->upstreamNodeId, pReq->totalLen);
+//
+//  // todo add the input queue buffer limitation
+//  streamTaskEnqueueBlocks(pTask, pReq, pRsp);
+//  tDeleteStreamDispatchReq(pReq);
+//
+//  if (exec) {
+//    if (streamTryExec(pTask) < 0) {
+//      return -1;
+//    }
+//  } else {
+//    streamSchedExec(pTask);
+//  }
+//
+//  return 0;
+//}
+
 int32_t streamProcessRunReq(SStreamTask* pTask) {
   if (streamTryExec(pTask) < 0) {
     return -1;
@@ -371,7 +362,7 @@ int32_t tAppendDataToInputQueue(SStreamTask* pTask, SStreamQueueItem* pItem) {
            msgLen, ver, total, size + msgLen/1048576.0);
   } else if (type == STREAM_INPUT__DATA_BLOCK || type == STREAM_INPUT__DATA_RETRIEVE ||
              type == STREAM_INPUT__REF_DATA_BLOCK) {
-    if ((pTask->info.taskLevel == TASK_LEVEL__SOURCE) && (tInputQueueIsFull(pTask))) {
+    if (/*(pTask->info.taskLevel == TASK_LEVEL__SOURCE) && */(tInputQueueIsFull(pTask))) {
       qError("s-task:%s input queue is full, capacity:%d size:%d MiB, current(blocks:%d, size:%.2fMiB) abort",
              pTask->id.idStr, STREAM_TASK_INPUT_QUEUE_CAPACITY, STREAM_TASK_INPUT_QUEUE_CAPACITY_IN_SIZE, total,
              size);
@@ -385,12 +376,15 @@ int32_t tAppendDataToInputQueue(SStreamTask* pTask, SStreamQueueItem* pItem) {
       destroyStreamDataBlock((SStreamDataBlock*) pItem);
       return code;
     }
-  } else if (type == STREAM_INPUT__CHECKPOINT) {
+  } else if (type == STREAM_INPUT__CHECKPOINT || type == STREAM_INPUT__TRANS_STATE) {
     taosWriteQitem(pTask->inputQueue->queue, pItem);
+    qDebug("s-task:%s checkpoint/trans-state blockdata enqueue, total in queue:%d, size:%.2fMiB", pTask->id.idStr, total, size);
   } else if (type == STREAM_INPUT__GET_RES) {
     // use the default memory limit, refactor later.
     taosWriteQitem(pTask->inputQueue->queue, pItem);
     qDebug("s-task:%s data res enqueue, current(blocks:%d, size:%.2fMiB)", pTask->id.idStr, total, size);
+  } else {
+    ASSERT(0);
   }
 
   if (type != STREAM_INPUT__GET_RES && type != STREAM_INPUT__CHECKPOINT && pTask->triggerParam != 0) {
@@ -433,4 +427,16 @@ SStreamChildEpInfo * streamTaskGetUpstreamTaskEpInfo(SStreamTask* pTask, int32_t
   }
 
   return NULL;
-}
\ No newline at end of file
+}
+
+void streamTaskOpenAllUpstreamInput(SStreamTask* pTask) {
+  int32_t num = taosArrayGetSize(pTask->pUpstreamEpInfoList);
+  if (num == 0) {
+    return;
+  }
+
+  for(int32_t i = 0; i < num; ++i) {
+    SStreamChildEpInfo* pInfo = taosArrayGetP(pTask->pUpstreamEpInfoList, i);
+    pInfo->dataAllowed = true;
+  }
+}
diff --git a/source/libs/stream/src/streamData.c b/source/libs/stream/src/streamData.c
index bb4b842787..fc1b788b77 100644
--- a/source/libs/stream/src/streamData.c
+++ b/source/libs/stream/src/streamData.c
@@ -204,7 +204,7 @@ void streamFreeQitem(SStreamQueueItem* data) {
   if (type == STREAM_INPUT__GET_RES) {
     blockDataDestroy(((SStreamTrigger*)data)->pBlock);
     taosFreeQitem(data);
-  } else if (type == STREAM_INPUT__DATA_BLOCK || type == STREAM_INPUT__DATA_RETRIEVE) {
+  } else if (type == STREAM_INPUT__DATA_BLOCK || type == STREAM_INPUT__DATA_RETRIEVE || type == STREAM_INPUT__TRANS_STATE) {
     taosArrayDestroyEx(((SStreamDataBlock*)data)->blocks, (FDelete)blockDataFreeRes);
     taosFreeQitem(data);
   } else if (type == STREAM_INPUT__DATA_SUBMIT) {
diff --git a/source/libs/stream/src/streamDispatch.c b/source/libs/stream/src/streamDispatch.c
index 6771d0cc28..694b0808f2 100644
--- a/source/libs/stream/src/streamDispatch.c
+++ b/source/libs/stream/src/streamDispatch.c
@@ -25,6 +25,9 @@ typedef struct SBlockName {
   char     parTbName[TSDB_TABLE_NAME_LEN];
 } SBlockName;
 
+static int32_t tInitStreamDispatchReq(SStreamDispatchReq* pReq, const SStreamTask* pTask, int32_t vgId,
+                                      int32_t numOfBlocks, int64_t dstTaskId, int32_t type);
+
 static void initRpcMsg(SRpcMsg* pMsg, int32_t msgType, void* pCont, int32_t contLen) {
     pMsg->msgType = msgType;
     pMsg->pCont = pCont;
@@ -35,8 +38,9 @@ static int32_t tEncodeStreamDispatchReq(SEncoder* pEncoder, const SStreamDispatc
   if (tStartEncode(pEncoder) < 0) return -1;
   if (tEncodeI64(pEncoder, pReq->streamId) < 0) return -1;
   if (tEncodeI32(pEncoder, pReq->taskId) < 0) return -1;
+  if (tEncodeI32(pEncoder, pReq->type) < 0) return -1;
   if (tEncodeI32(pEncoder, pReq->upstreamTaskId) < 0) return -1;
-  if (tEncodeI32(pEncoder, pReq->dataSrcVgId) < 0) return -1;
+  if (tEncodeI32(pEncoder, pReq->srcVgId) < 0) return -1;
   if (tEncodeI32(pEncoder, pReq->upstreamChildId) < 0) return -1;
   if (tEncodeI32(pEncoder, pReq->upstreamNodeId) < 0) return -1;
   if (tEncodeI32(pEncoder, pReq->blockNum) < 0) return -1;
@@ -88,8 +92,9 @@ int32_t tDecodeStreamDispatchReq(SDecoder* pDecoder, SStreamDispatchReq* pReq) {
   if (tStartDecode(pDecoder) < 0) return -1;
   if (tDecodeI64(pDecoder, &pReq->streamId) < 0) return -1;
   if (tDecodeI32(pDecoder, &pReq->taskId) < 0) return -1;
+  if (tDecodeI32(pDecoder, &pReq->type) < 0) return -1;
   if (tDecodeI32(pDecoder, &pReq->upstreamTaskId) < 0) return -1;
-  if (tDecodeI32(pDecoder, &pReq->dataSrcVgId) < 0) return -1;
+  if (tDecodeI32(pDecoder, &pReq->srcVgId) < 0) return -1;
   if (tDecodeI32(pDecoder, &pReq->upstreamChildId) < 0) return -1;
   if (tDecodeI32(pDecoder, &pReq->upstreamNodeId) < 0) return -1;
   if (tDecodeI32(pDecoder, &pReq->blockNum) < 0) return -1;
@@ -113,14 +118,15 @@ int32_t tDecodeStreamDispatchReq(SDecoder* pDecoder, SStreamDispatchReq* pReq) {
 }
 
 int32_t tInitStreamDispatchReq(SStreamDispatchReq* pReq, const SStreamTask* pTask, int32_t vgId, int32_t numOfBlocks,
-                               int64_t dstTaskId) {
+                               int64_t dstTaskId, int32_t type) {
   pReq->streamId = pTask->id.streamId;
-  pReq->dataSrcVgId = vgId;
+  pReq->srcVgId = vgId;
   pReq->upstreamTaskId = pTask->id.taskId;
   pReq->upstreamChildId = pTask->info.selfChildId;
   pReq->upstreamNodeId = pTask->info.nodeId;
   pReq->blockNum = numOfBlocks;
   pReq->taskId = dstTaskId;
+  pReq->type = type;
 
   pReq->data = taosArrayInit(numOfBlocks, POINTER_BYTES);
   pReq->dataLen = taosArrayInit(numOfBlocks, sizeof(int32_t));
@@ -358,7 +364,8 @@ static int32_t doSendDispatchMsg(SStreamTask* pTask, const SStreamDispatchReq* p
   msg.pCont = buf;
   msg.msgType = pTask->msgInfo.msgType;
 
-  qDebug("s-task:%s dispatch msg to taskId:0x%x vgId:%d data msg", pTask->id.idStr, pReq->taskId, vgId);
+  qDebug("s-task:%s dispatch msg to taskId:0x%x vgId:%d data msg, len:%d", pTask->id.idStr, pReq->taskId, vgId,
+         msg.contLen);
   return tmsgSendReq(pEpSet, &msg);
 
 FAIL:
@@ -436,9 +443,8 @@ int32_t streamSearchAndAddBlock(SStreamTask* pTask, SStreamDispatchReq* pReqs, S
   return 0;
 }
 
-int32_t streamDispatchAllBlocks(SStreamTask* pTask, const SStreamDataBlock* pData) {
+static int32_t doDispatchAllBlocks(SStreamTask* pTask, const SStreamDataBlock* pData) {
   int32_t code = 0;
-
   int32_t numOfBlocks = taosArrayGetSize(pData->blocks);
   ASSERT(numOfBlocks != 0);
 
@@ -446,15 +452,15 @@ int32_t streamDispatchAllBlocks(SStreamTask* pTask, const SStreamDataBlock* pDat
     SStreamDispatchReq req = {0};
 
     int32_t downstreamTaskId = pTask->fixedEpDispatcher.taskId;
-    code = tInitStreamDispatchReq(&req, pTask, pData->srcVgId, numOfBlocks, downstreamTaskId);
+    code = tInitStreamDispatchReq(&req, pTask, pData->srcVgId, numOfBlocks, downstreamTaskId, pData->type);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
     }
 
     for (int32_t i = 0; i < numOfBlocks; i++) {
       SSDataBlock* pDataBlock = taosArrayGet(pData->blocks, i);
-      code = streamAddBlockIntoDispatchMsg(pDataBlock, &req);
 
+      code = streamAddBlockIntoDispatchMsg(pDataBlock, &req);
       if (code != TSDB_CODE_SUCCESS) {
         taosArrayDestroyP(req.data, taosMemoryFree);
         taosArrayDestroy(req.dataLen);
@@ -487,7 +493,7 @@ int32_t streamDispatchAllBlocks(SStreamTask* pTask, const SStreamDataBlock* pDat
 
     for (int32_t i = 0; i < vgSz; i++) {
       SVgroupInfo* pVgInfo = taosArrayGet(vgInfo, i);
-      code = tInitStreamDispatchReq(&pReqs[i], pTask, pData->srcVgId, 0, pVgInfo->taskId);
+      code = tInitStreamDispatchReq(&pReqs[i], pTask, pData->srcVgId, 0, pVgInfo->taskId, pData->type);
       if (code != TSDB_CODE_SUCCESS) {
         goto FAIL_SHUFFLE_DISPATCH;
       }
@@ -497,8 +503,7 @@ int32_t streamDispatchAllBlocks(SStreamTask* pTask, const SStreamDataBlock* pDat
       SSDataBlock* pDataBlock = taosArrayGet(pData->blocks, i);
 
       // TODO: do not use broadcast
-      if (pDataBlock->info.type == STREAM_DELETE_RESULT) {
-
+      if (pDataBlock->info.type == STREAM_DELETE_RESULT || pDataBlock->info.type == STREAM_CHECKPOINT || pDataBlock->info.type == STREAM_TRANS_STATE) {
         for (int32_t j = 0; j < vgSz; j++) {
           if (streamAddBlockIntoDispatchMsg(pDataBlock, &pReqs[j]) < 0) {
             goto FAIL_SHUFFLE_DISPATCH;
@@ -518,14 +523,14 @@ int32_t streamDispatchAllBlocks(SStreamTask* pTask, const SStreamDataBlock* pDat
       }
     }
 
-    qDebug("s-task:%s (child taskId:%d) shuffle-dispatch blocks:%d to %d vgroups", pTask->id.idStr, pTask->info.selfChildId,
-           numOfBlocks, vgSz);
+    qDebug("s-task:%s (child taskId:%d) shuffle-dispatch blocks:%d to %d vgroups", pTask->id.idStr,
+           pTask->info.selfChildId, numOfBlocks, vgSz);
 
     for (int32_t i = 0; i < vgSz; i++) {
       if (pReqs[i].blockNum > 0) {
         SVgroupInfo* pVgInfo = taosArrayGet(vgInfo, i);
-        qDebug("s-task:%s (child taskId:%d) shuffle-dispatch blocks:%d to vgId:%d", pTask->id.idStr, pTask->info.selfChildId,
-               pReqs[i].blockNum, pVgInfo->vgId);
+        qDebug("s-task:%s (child taskId:%d) shuffle-dispatch blocks:%d to vgId:%d", pTask->id.idStr,
+               pTask->info.selfChildId, pReqs[i].blockNum, pVgInfo->vgId);
 
         code = doSendDispatchMsg(pTask, &pReqs[i], pVgInfo->vgId, &pVgInfo->epSet);
         if (code < 0) {
@@ -536,7 +541,7 @@ int32_t streamDispatchAllBlocks(SStreamTask* pTask, const SStreamDataBlock* pDat
 
     code = 0;
 
-  FAIL_SHUFFLE_DISPATCH:
+    FAIL_SHUFFLE_DISPATCH:
     for (int32_t i = 0; i < vgSz; i++) {
       taosArrayDestroyP(pReqs[i].data, taosMemoryFree);
       taosArrayDestroy(pReqs[i].dataLen);
@@ -559,7 +564,7 @@ static void doRetryDispatchData(void* param, void* tmrId) {
 
   ASSERT(pTask->outputInfo.status == TASK_OUTPUT_STATUS__WAIT);
 
-  int32_t code = streamDispatchAllBlocks(pTask, pTask->msgInfo.pData);
+  int32_t code = doDispatchAllBlocks(pTask, pTask->msgInfo.pData);
   if (code != TSDB_CODE_SUCCESS) {
     if (!streamTaskShouldStop(&pTask->status)) {
       qDebug("s-task:%s reset the waitRspCnt to be 0 before launch retry dispatch", pTask->id.idStr);
@@ -607,12 +612,13 @@ int32_t streamDispatchStreamBlock(SStreamTask* pTask) {
   }
 
   pTask->msgInfo.pData = pBlock;
-  ASSERT(pBlock->type == STREAM_INPUT__DATA_BLOCK);
+  ASSERT(pBlock->type == STREAM_INPUT__DATA_BLOCK || pBlock->type == STREAM_INPUT__CHECKPOINT_TRIGGER ||
+         pBlock->type == STREAM_INPUT__TRANS_STATE);
 
   int32_t retryCount = 0;
 
   while (1) {
-    int32_t code = streamDispatchAllBlocks(pTask, pBlock);
+    int32_t code = doDispatchAllBlocks(pTask, pBlock);
     if (code == TSDB_CODE_SUCCESS) {
       break;
     }
@@ -729,3 +735,88 @@ int32_t streamNotifyUpstreamContinue(SStreamTask* pTask) {
          num);
   return 0;
 }
+
+int32_t streamProcessDispatchRsp(SStreamTask* pTask, SStreamDispatchRsp* pRsp, int32_t code) {
+  const char* id = pTask->id.idStr;
+
+  if (code != TSDB_CODE_SUCCESS) {
+    // dispatch message failed: network error, or node not available.
+    // in case of the input queue is full, the code will be TSDB_CODE_SUCCESS, the and pRsp>inputStatus will be set
+    // flag. here we need to retry dispatch this message to downstream task immediately. handle the case the failure
+    // happened too fast.
+    // todo handle the shuffle dispatch failure
+    if (code == TSDB_CODE_STREAM_TASK_NOT_EXIST) { // destination task does not exist, not retry anymore
+      qWarn("s-task:%s failed to dispatch msg to task:0x%x, no retry, since it is destroyed already", id, pRsp->downstreamTaskId);
+    } else {
+      qError("s-task:%s failed to dispatch msg to task:0x%x, code:%s, retry cnt:%d", id, pRsp->downstreamTaskId,
+             tstrerror(code), ++pTask->msgInfo.retryCount);
+      int32_t ret = doDispatchAllBlocks(pTask, pTask->msgInfo.pData);
+      if (ret != TSDB_CODE_SUCCESS) {
+      }
+    }
+
+    return TSDB_CODE_SUCCESS;
+  }
+
+  qDebug("s-task:%s recv dispatch rsp from 0x%x, downstream task input status:%d code:%d", id, pRsp->downstreamTaskId,
+         pRsp->inputStatus, code);
+
+  // there are other dispatch message not response yet
+  if (pTask->outputInfo.type == TASK_OUTPUT__SHUFFLE_DISPATCH) {
+    int32_t leftRsp = atomic_sub_fetch_32(&pTask->shuffleDispatcher.waitingRspCnt, 1);
+    qDebug("s-task:%s is shuffle, left waiting rsp %d", id, leftRsp);
+    if (leftRsp > 0) {
+      return 0;
+    }
+  }
+
+  // transtate msg has been sent to downstream successfully. let's transfer the fill-history task state
+  SStreamDataBlock* p = pTask->msgInfo.pData;
+  if (p->type == STREAM_INPUT__TRANS_STATE) {
+    qDebug("s-task:%s dispatch transtate msg to downstream successfully, start to transfer state", id);
+    ASSERT(pTask->info.fillHistory == 1);
+    code = streamTransferStateToStreamTask(pTask);
+    if (code != TSDB_CODE_SUCCESS) {  // todo: do nothing if error happens
+    }
+
+    streamFreeQitem(pTask->msgInfo.pData);
+    return TSDB_CODE_SUCCESS;
+  }
+
+  pTask->msgInfo.retryCount = 0;
+  ASSERT(pTask->outputInfo.status == TASK_OUTPUT_STATUS__WAIT);
+
+  qDebug("s-task:%s output status is set to:%d", id, pTask->outputInfo.status);
+
+  // the input queue of the (down stream) task that receive the output data is full,
+  // so the TASK_INPUT_STATUS_BLOCKED is rsp
+  if (pRsp->inputStatus == TASK_INPUT_STATUS__BLOCKED) {
+    pTask->inputStatus = TASK_INPUT_STATUS__BLOCKED;   // block the input of current task, to push pressure to upstream
+    pTask->msgInfo.blockingTs = taosGetTimestampMs();  // record the blocking start time
+    qError("s-task:%s inputQ of downstream task:0x%x is full, time:%" PRId64 " wait for %dms and retry dispatch data",
+           id, pRsp->downstreamTaskId, pTask->msgInfo.blockingTs, DISPATCH_RETRY_INTERVAL_MS);
+    streamRetryDispatchStreamBlock(pTask, DISPATCH_RETRY_INTERVAL_MS);
+  } else {  // pipeline send data in output queue
+    // this message has been sent successfully, let's try next one.
+    destroyStreamDataBlock(pTask->msgInfo.pData);
+    pTask->msgInfo.pData = NULL;
+
+    if (pTask->msgInfo.blockingTs != 0) {
+      int64_t el = taosGetTimestampMs() - pTask->msgInfo.blockingTs;
+      qDebug("s-task:%s downstream task:0x%x resume to normal from inputQ blocking, blocking time:%" PRId64 "ms", id,
+             pRsp->downstreamTaskId, el);
+      pTask->msgInfo.blockingTs = 0;
+
+      // put data into inputQ of current task is also allowed
+      pTask->inputStatus = TASK_INPUT_STATUS__NORMAL;
+    }
+
+    // now ready for next data output
+    atomic_store_8(&pTask->outputInfo.status, TASK_OUTPUT_STATUS__NORMAL);
+
+    // otherwise, continue dispatch the first block to down stream task in pipeline
+    streamDispatchStreamBlock(pTask);
+  }
+
+  return 0;
+}
diff --git a/source/libs/stream/src/streamExec.c b/source/libs/stream/src/streamExec.c
index c7da80fdaf..fa33793087 100644
--- a/source/libs/stream/src/streamExec.c
+++ b/source/libs/stream/src/streamExec.c
@@ -191,6 +191,12 @@ int32_t streamScanExec(SStreamTask* pTask, int32_t batchSize) {
         return 0;
       }
 
+      if (pTask->inputStatus == TASK_INPUT_STATUS__BLOCKED) {
+        qDebug("s-task:%s inputQ is blocked, wait for 10sec and retry", pTask->id.idStr);
+        taosMsleep(10000);
+        continue;
+      }
+
       SSDataBlock* output = NULL;
       uint64_t     ts = 0;
       code = qExecTask(exec, &output, &ts);
@@ -287,21 +293,32 @@ static void waitForTaskIdle(SStreamTask* pTask, SStreamTask* pStreamTask) {
   }
 }
 
-static int32_t streamDoTransferStateToStreamTask(SStreamTask* pTask) {
+int32_t streamDoTransferStateToStreamTask(SStreamTask* pTask) {
   SStreamMeta* pMeta = pTask->pMeta;
 
   SStreamTask* pStreamTask = streamMetaAcquireTask(pMeta, pTask->streamTaskId.streamId, pTask->streamTaskId.taskId);
   if (pStreamTask == NULL) {
-    // todo: destroy the fill-history task here
-    qError("s-task:%s failed to find related stream task:0x%x, it may have been destroyed or closed", pTask->id.idStr,
-           pTask->streamTaskId.taskId);
+    qError(
+        "s-task:%s failed to find related stream task:0x%x, it may have been destroyed or closed, destroy the related "
+        "fill-history task",
+        pTask->id.idStr, pTask->streamTaskId.taskId);
+
+    // 1. free it and remove fill-history task from disk meta-store
+    streamMetaUnregisterTask(pMeta, pTask->id.streamId, pTask->id.taskId);
+
+    // 2. save to disk
+    taosWLockLatch(&pMeta->lock);
+    if (streamMetaCommit(pMeta) < 0) {
+      // persist to disk
+    }
+    taosWUnLockLatch(&pMeta->lock);
     return TSDB_CODE_STREAM_TASK_NOT_EXIST;
   } else {
     qDebug("s-task:%s fill-history task end, update related stream task:%s info, transfer exec state", pTask->id.idStr,
            pStreamTask->id.idStr);
   }
 
-  ASSERT(pStreamTask->historyTaskId.taskId == pTask->id.taskId && pTask->status.transferState == true);
+  ASSERT(pStreamTask->historyTaskId.taskId == pTask->id.taskId && pTask->status.appendTranstateBlock == true);
 
   STimeWindow* pTimeWindow = &pStreamTask->dataRange.window;
 
@@ -380,34 +397,52 @@ static int32_t streamDoTransferStateToStreamTask(SStreamTask* pTask) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t streamTransferStateToStreamTask(SStreamTask* pTask) {
+int32_t streamTransferStateToStreamTask(SStreamTask* pTask) {
   int32_t code = TSDB_CODE_SUCCESS;
-  if (!pTask->status.transferState) {
-    return code;
-  }
+  ASSERT(pTask->status.appendTranstateBlock == 1);
 
   int32_t level = pTask->info.taskLevel;
   if (level == TASK_LEVEL__SOURCE) {
     streamTaskFillHistoryFinished(pTask);
-    streamTaskEndScanWAL(pTask);
-  } else if (level == TASK_LEVEL__AGG) { // do transfer task operator states.
+  }
+
+  if (level == TASK_LEVEL__AGG || level == TASK_LEVEL__SOURCE) {  // do transfer task operator states.
     code = streamDoTransferStateToStreamTask(pTask);
-    if (code != TSDB_CODE_SUCCESS) {  // todo handle this
-      return code;
-    }
   }
 
   return code;
 }
 
-static int32_t extractMsgFromInputQ(SStreamTask* pTask, SStreamQueueItem** pInput, int32_t* numOfBlocks,
-                                    const char* id) {
-  int32_t retryTimes = 0;
-  int32_t MAX_RETRY_TIMES = 5;
+static int32_t extractBlocksFromInputQ(SStreamTask* pTask, SStreamQueueItem** pInput, int32_t* numOfBlocks) {
+  int32_t     retryTimes = 0;
+  int32_t     MAX_RETRY_TIMES = 5;
+  const char* id = pTask->id.idStr;
 
+  if (pTask->info.taskLevel == TASK_LEVEL__SINK) {  // extract block from inputQ, one-by-one
+    while (1) {
+      if (streamTaskShouldPause(&pTask->status) || streamTaskShouldStop(&pTask->status)) {
+        qDebug("s-task:%s task should pause, extract input blocks:%d", pTask->id.idStr, *numOfBlocks);
+        return TSDB_CODE_SUCCESS;
+      }
+
+      SStreamQueueItem* qItem = streamQueueNextItem(pTask->inputQueue);
+      if (qItem == NULL) {
+        qDebug("===stream===break batchSize:%d, %s", *numOfBlocks, id);
+        return TSDB_CODE_SUCCESS;
+      }
+
+      qDebug("s-task:%s sink task handle block one-by-one, type:%d", id, qItem->type);
+
+      *numOfBlocks = 1;
+      *pInput = qItem;
+      return TSDB_CODE_SUCCESS;
+    }
+  }
+
+  // non sink task
   while (1) {
-    if (streamTaskShouldPause(&pTask->status)) {
-      qDebug("s-task:%s task should pause, input blocks:%d", pTask->id.idStr, *numOfBlocks);
+    if (streamTaskShouldPause(&pTask->status) || streamTaskShouldStop(&pTask->status)) {
+      qDebug("s-task:%s task should pause, extract input blocks:%d", pTask->id.idStr, *numOfBlocks);
       return TSDB_CODE_SUCCESS;
     }
 
@@ -415,51 +450,111 @@ static int32_t extractMsgFromInputQ(SStreamTask* pTask, SStreamQueueItem** pInpu
     if (qItem == NULL) {
       if (pTask->info.taskLevel == TASK_LEVEL__SOURCE && (++retryTimes) < MAX_RETRY_TIMES) {
         taosMsleep(10);
-        qDebug("===stream===try again batchSize:%d, retry:%d", *numOfBlocks, retryTimes);
+        qDebug("try again batchSize:%d, retry:%d, %s", *numOfBlocks, retryTimes, id);
         continue;
       }
 
-      qDebug("===stream===break batchSize:%d", *numOfBlocks);
+      qDebug("break batchSize:%d, %s", *numOfBlocks, id);
       return TSDB_CODE_SUCCESS;
     }
 
-    // do not merge blocks for sink node
-    if (pTask->info.taskLevel == TASK_LEVEL__SINK) {
-      *numOfBlocks = 1;
-      *pInput = qItem;
-      return TSDB_CODE_SUCCESS;
-    }
-
-    if (*pInput == NULL) {
-      ASSERT((*numOfBlocks) == 0);
-      *pInput = qItem;
-    } else {
-      // todo we need to sort the data block, instead of just appending into the array list.
-      void* newRet = streamMergeQueueItem(*pInput, qItem);
-      if (newRet == NULL) {
-        if (terrno == 0) {
-          qDebug("s-task:%s failed to merge blocks from inputQ, numOfBlocks:%d", id, *numOfBlocks);
-        } else {
-          qDebug("s-task:%s failed to merge blocks from inputQ, numOfBlocks:%d, code:%s", id, *numOfBlocks,
-              tstrerror(terrno));
-        }
+    // do not merge blocks for sink node and check point data block
+    if (qItem->type == STREAM_INPUT__CHECKPOINT || qItem->type == STREAM_INPUT__CHECKPOINT_TRIGGER ||
+        qItem->type == STREAM_INPUT__TRANS_STATE) {
+      if (*pInput == NULL) {
+        qDebug("s-task:%s checkpoint/transtate msg extracted, start to process immediately", id);
+        *numOfBlocks = 1;
+        *pInput = qItem;
+        return TSDB_CODE_SUCCESS;
+      } else {
+        // previous existed blocks needs to be handle, before handle the checkpoint msg block
+        qDebug("s-task:%s checkpoint/transtate msg extracted, handle previous blocks, numOfBlocks:%d", id, *numOfBlocks);
         streamQueueProcessFail(pTask->inputQueue);
         return TSDB_CODE_SUCCESS;
       }
+    } else {
+      if (*pInput == NULL) {
+        ASSERT((*numOfBlocks) == 0);
+        *pInput = qItem;
+      } else {
+        // todo we need to sort the data block, instead of just appending into the array list.
+        void* newRet = streamMergeQueueItem(*pInput, qItem);
+        if (newRet == NULL) {
+          qError("s-task:%s failed to merge blocks from inputQ, numOfBlocks:%d", id, *numOfBlocks);
+          streamQueueProcessFail(pTask->inputQueue);
+          return TSDB_CODE_SUCCESS;
+        }
 
-      *pInput = newRet;
-    }
+        *pInput = newRet;
+      }
 
-    *numOfBlocks += 1;
-    streamQueueProcessSuccess(pTask->inputQueue);
+      *numOfBlocks += 1;
+      streamQueueProcessSuccess(pTask->inputQueue);
 
-    if (*numOfBlocks >= MAX_STREAM_EXEC_BATCH_NUM) {
-      qDebug("s-task:%s batch size limit:%d reached, start to process blocks", id, MAX_STREAM_EXEC_BATCH_NUM);
-      return TSDB_CODE_SUCCESS;
+      if (*numOfBlocks >= MAX_STREAM_EXEC_BATCH_NUM) {
+        qDebug("s-task:%s batch size limit:%d reached, start to process blocks", id, MAX_STREAM_EXEC_BATCH_NUM);
+        return TSDB_CODE_SUCCESS;
+      }
     }
   }
 }
 
+int32_t streamProcessTranstateBlock(SStreamTask* pTask, SStreamDataBlock* pBlock) {
+  const char* id = pTask->id.idStr;
+  int32_t     code = TSDB_CODE_SUCCESS;
+
+  int32_t level = pTask->info.taskLevel;
+  if (level == TASK_LEVEL__AGG || level == TASK_LEVEL__SINK) {
+    int32_t remain = streamAlignTransferState(pTask);
+    if (remain > 0) {
+      streamFreeQitem((SStreamQueueItem*)pBlock);
+      qDebug("s-task:%s receive upstream transfer state msg, remain:%d", id, remain);
+      return 0;
+    }
+  }
+
+  // dispatch the tran-state block to downstream task immediately
+  int32_t type = pTask->outputInfo.type;
+
+  // transfer the ownership of executor state
+  if (type == TASK_OUTPUT__FIXED_DISPATCH || type == TASK_OUTPUT__SHUFFLE_DISPATCH) {
+    if (level == TASK_LEVEL__SOURCE) {
+      qDebug("s-task:%s add transfer-state block into outputQ", id);
+    } else {
+      qDebug("s-task:%s all upstream tasks send transfer-state block, add transfer-state block into outputQ", id);
+      ASSERT(pTask->streamTaskId.taskId != 0 && pTask->info.fillHistory == 1);
+    }
+
+    // agg task should dispatch trans-state msg to sink task, to flush all data to sink task.
+    if (level == TASK_LEVEL__AGG || level == TASK_LEVEL__SOURCE) {
+      pBlock->srcVgId = pTask->pMeta->vgId;
+      code = taosWriteQitem(pTask->outputInfo.queue->queue, pBlock);
+      if (code == 0) {
+        streamDispatchStreamBlock(pTask);
+      } else {
+        streamFreeQitem((SStreamQueueItem*)pBlock);
+      }
+    } else {  // level == TASK_LEVEL__SINK
+      streamFreeQitem((SStreamQueueItem*)pBlock);
+    }
+  } else { // non-dispatch task, do task state transfer directly
+    streamFreeQitem((SStreamQueueItem*)pBlock);
+    if (level != TASK_LEVEL__SINK) {
+      qDebug("s-task:%s non-dispatch task, start to transfer state directly", id);
+      ASSERT(pTask->info.fillHistory == 1);
+      code = streamTransferStateToStreamTask(pTask);
+
+      if (code != TSDB_CODE_SUCCESS) {
+        atomic_store_8(&pTask->status.schedStatus, TASK_SCHED_STATUS__INACTIVE);
+      }
+    } else {
+      qDebug("s-task:%s sink task does not transfer state", id);
+    }
+  }
+
+  return code;
+}
+
 /**
  * todo: the batch of blocks should be tuned dynamic, according to the total elapsed time of each batch of blocks, the
  * appropriate batch of blocks should be handled in 5 to 10 sec.
@@ -478,12 +573,17 @@ int32_t streamExecForAll(SStreamTask* pTask) {
     // merge multiple input data if possible in the input queue.
     qDebug("s-task:%s start to extract data block from inputQ", id);
 
-    /*int32_t code = */extractMsgFromInputQ(pTask, &pInput, &batchSize, id);
+    /*int32_t code = */extractBlocksFromInputQ(pTask, &pInput, &batchSize);
     if (pInput == NULL) {
       ASSERT(batchSize == 0);
       break;
     }
 
+    if (pInput->type == STREAM_INPUT__TRANS_STATE) {
+      streamProcessTranstateBlock(pTask, (SStreamDataBlock*)pInput);
+      continue;
+    }
+
     if (pTask->info.taskLevel == TASK_LEVEL__SINK) {
       ASSERT(pInput->type == STREAM_INPUT__DATA_BLOCK);
       qDebug("s-task:%s sink task start to sink %d blocks", id, batchSize);
@@ -551,27 +651,6 @@ bool streamTaskIsIdle(const SStreamTask* pTask) {
           pTask->status.taskStatus == TASK_STATUS__DROPPING);
 }
 
-int32_t streamTaskEndScanWAL(SStreamTask* pTask) {
-  const char* id = pTask->id.idStr;
-  double      el = (taosGetTimestampMs() - pTask->tsInfo.step2Start) / 1000.0;
-  qDebug("s-task:%s scan-history from WAL stage(step 2) ended, elapsed time:%.2fs", id, el);
-
-  // 1. notify all downstream tasks to transfer executor state after handle all history blocks.
-  int32_t code = streamDispatchTransferStateMsg(pTask);
-  if (code != TSDB_CODE_SUCCESS) {
-    // todo handle error
-  }
-
-  // 2. do transfer stream task operator states.
-  pTask->status.transferState = true;
-  code = streamDoTransferStateToStreamTask(pTask);
-  if (code != TSDB_CODE_SUCCESS) { // todo handle error
-    return code;
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
 int32_t streamTryExec(SStreamTask* pTask) {
   // this function may be executed by multi-threads, so status check is required.
   int8_t schedStatus =
@@ -587,27 +666,13 @@ int32_t streamTryExec(SStreamTask* pTask) {
     }
 
     // todo the task should be commit here
-    if (taosQueueEmpty(pTask->inputQueue->queue)) {
-      // fill-history WAL scan has completed
-      if (pTask->status.transferState) {
-        code = streamTransferStateToStreamTask(pTask);
-        if (code != TSDB_CODE_SUCCESS) {
-          return code;
-        }
-        streamSchedExec(pTask);
-      } else {
-        atomic_store_8(&pTask->status.schedStatus, TASK_SCHED_STATUS__INACTIVE);
-        qDebug("s-task:%s exec completed, status:%s, sched-status:%d", id, streamGetTaskStatusStr(pTask->status.taskStatus),
-               pTask->status.schedStatus);
-      }
-    } else {
-      atomic_store_8(&pTask->status.schedStatus, TASK_SCHED_STATUS__INACTIVE);
-      qDebug("s-task:%s exec completed, status:%s, sched-status:%d", id, streamGetTaskStatusStr(pTask->status.taskStatus),
-             pTask->status.schedStatus);
+    atomic_store_8(&pTask->status.schedStatus, TASK_SCHED_STATUS__INACTIVE);
+    qDebug("s-task:%s exec completed, status:%s, sched-status:%d", id, streamGetTaskStatusStr(pTask->status.taskStatus),
+           pTask->status.schedStatus);
 
-      if ((!streamTaskShouldStop(&pTask->status)) && (!streamTaskShouldPause(&pTask->status))) {
-        streamSchedExec(pTask);
-      }
+    if (!(taosQueueEmpty(pTask->inputQueue->queue) || streamTaskShouldStop(&pTask->status) ||
+          streamTaskShouldPause(&pTask->status))) {
+      streamSchedExec(pTask);
     }
   } else {
     qDebug("s-task:%s already started to exec by other thread, status:%s, sched-status:%d", id,
diff --git a/source/libs/stream/src/streamQueue.c b/source/libs/stream/src/streamQueue.c
index aaf9fdec72..65135ec9a1 100644
--- a/source/libs/stream/src/streamQueue.c
+++ b/source/libs/stream/src/streamQueue.c
@@ -130,11 +130,11 @@ SStreamQueueItem* doReadMultiBlocksFromQueue(SQueueReader* pReader, const char*
       if (pReader->taskLevel == TASK_LEVEL__SOURCE && numOfBlocks < MIN_STREAM_EXEC_BATCH_NUM && tryCount < pReader->waitDuration) {
         tryCount++;
         taosMsleep(1);
-        qDebug("===stream===try again batchSize:%d", numOfBlocks);
+        qDebug("try again batchSize:%d", numOfBlocks);
         continue;
       }
 
-      qDebug("===stream===break batchSize:%d", numOfBlocks);
+      qDebug("break batchSize:%d", numOfBlocks);
       break;
     }
 
diff --git a/source/libs/stream/src/streamRecover.c b/source/libs/stream/src/streamRecover.c
index 1e17ef7ef1..2506dbaead 100644
--- a/source/libs/stream/src/streamRecover.c
+++ b/source/libs/stream/src/streamRecover.c
@@ -372,68 +372,35 @@ int32_t streamDispatchScanHistoryFinishMsg(SStreamTask* pTask) {
   return 0;
 }
 
-static int32_t doDispatchTransferMsg(SStreamTask* pTask, const SStreamTransferReq* pReq, int32_t vgId, SEpSet* pEpSet) {
-  void*   buf = NULL;
-  int32_t code = -1;
-  SRpcMsg msg = {0};
-
-  int32_t tlen;
-  tEncodeSize(tEncodeStreamScanHistoryFinishReq, pReq, tlen, code);
-  if (code < 0) {
-    return -1;
+int32_t appendTranstateIntoInputQ(SStreamTask* pTask) {
+  SStreamDataBlock* pTranstate = taosAllocateQitem(sizeof(SStreamDataBlock), DEF_QITEM, sizeof(SSDataBlock));
+  if (pTranstate == NULL) {
+    return TSDB_CODE_OUT_OF_MEMORY;
   }
 
-  buf = rpcMallocCont(sizeof(SMsgHead) + tlen);
-  if (buf == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+  SSDataBlock* pBlock = taosMemoryCalloc(1, sizeof(SSDataBlock));
+  if (pBlock == NULL) {
+    taosFreeQitem(pTranstate);
+    return TSDB_CODE_OUT_OF_MEMORY;
   }
 
-  ((SMsgHead*)buf)->vgId = htonl(vgId);
-  void* abuf = POINTER_SHIFT(buf, sizeof(SMsgHead));
+  pTranstate->type = STREAM_INPUT__TRANS_STATE;
 
-  SEncoder encoder;
-  tEncoderInit(&encoder, abuf, tlen);
-  if ((code = tEncodeStreamScanHistoryFinishReq(&encoder, pReq)) < 0) {
-    if (buf) {
-      rpcFreeCont(buf);
-    }
-    return code;
+  pBlock->info.type = STREAM_TRANS_STATE;
+  pBlock->info.rows = 1;
+  pBlock->info.childId = pTask->info.selfChildId;
+
+  pTranstate->blocks = taosArrayInit(4, sizeof(SSDataBlock));//pBlock;
+  taosArrayPush(pTranstate->blocks, pBlock);
+
+  taosMemoryFree(pBlock);
+  if (tAppendDataToInputQueue(pTask, (SStreamQueueItem*)pTranstate) < 0) {
+    taosFreeQitem(pTranstate);
+    return TSDB_CODE_OUT_OF_MEMORY;
   }
 
-  tEncoderClear(&encoder);
-
-  msg.contLen = tlen + sizeof(SMsgHead);
-  msg.pCont = buf;
-  msg.msgType = TDMT_STREAM_TRANSFER_STATE;
-  msg.info.noResp = 1;
-
-  tmsgSendReq(pEpSet, &msg);
-  qDebug("s-task:%s level:%d, status:%s dispatch transfer state msg to taskId:0x%x (vgId:%d)", pTask->id.idStr,
-         pTask->info.taskLevel, streamGetTaskStatusStr(pTask->status.taskStatus), pReq->downstreamTaskId, vgId);
-
-  return 0;
-}
-
-int32_t streamDispatchTransferStateMsg(SStreamTask* pTask) {
-  SStreamTransferReq req = { .streamId = pTask->id.streamId, .childId = pTask->info.selfChildId };
-
-  // serialize
-  if (pTask->outputInfo.type == TASK_OUTPUT__FIXED_DISPATCH) {
-    req.downstreamTaskId = pTask->fixedEpDispatcher.taskId;
-    doDispatchTransferMsg(pTask, &req, pTask->fixedEpDispatcher.nodeId, &pTask->fixedEpDispatcher.epSet);
-  } else if (pTask->outputInfo.type == TASK_OUTPUT__SHUFFLE_DISPATCH) {
-    SArray* vgInfo = pTask->shuffleDispatcher.dbInfo.pVgroupInfos;
-
-    int32_t numOfVgs = taosArrayGetSize(vgInfo);
-    for (int32_t i = 0; i < numOfVgs; i++) {
-      SVgroupInfo* pVgInfo = taosArrayGet(vgInfo, i);
-      req.downstreamTaskId = pVgInfo->taskId;
-      doDispatchTransferMsg(pTask, &req, pVgInfo->vgId, &pVgInfo->epSet);
-    }
-  }
-
-  return 0;
+  pTask->status.appendTranstateBlock = true;
+  return TSDB_CODE_SUCCESS;
 }
 
 // agg
diff --git a/source/libs/sync/src/syncUtil.c b/source/libs/sync/src/syncUtil.c
index ae1c775a18..9acc17e130 100644
--- a/source/libs/sync/src/syncUtil.c
+++ b/source/libs/sync/src/syncUtil.c
@@ -21,6 +21,7 @@
 #include "syncRaftCfg.h"
 #include "syncRaftStore.h"
 #include "syncSnapshot.h"
+#include "tglobal.h"
 
 void syncCfg2SimpleStr(const SSyncCfg* pCfg, char* buf, int32_t bufLen) {
   int32_t len = snprintf(buf, bufLen, "{num:%d, as:%d, [", pCfg->replicaNum, pCfg->myIndex);
@@ -41,7 +42,22 @@ void syncUtilNodeInfo2EpSet(const SNodeInfo* pInfo, SEpSet* pEpSet) {
 }
 
 bool syncUtilNodeInfo2RaftId(const SNodeInfo* pInfo, SyncGroupId vgId, SRaftId* raftId) {
-  uint32_t ipv4 = taosGetIpv4FromFqdn(pInfo->nodeFqdn);
+  uint32_t ipv4 = 0xFFFFFFFF;
+  sDebug("vgId:%d, start to resolve sync addr fqdn in %d seconds, "
+        "dnode:%d cluster:%" PRId64 " fqdn:%s port:%u ", 
+        vgId, tsResolveFQDNRetryTime,
+        pInfo->nodeId, pInfo->clusterId, pInfo->nodeFqdn, pInfo->nodePort);
+  for(int i = 0; i < tsResolveFQDNRetryTime; i++){
+    ipv4 = taosGetIpv4FromFqdn(pInfo->nodeFqdn);
+    if (ipv4 == 0xFFFFFFFF || ipv4 == 1) {
+      sError("failed to resolve ipv4 addr, fqdn:%s, wait one second", pInfo->nodeFqdn);
+      taosSsleep(1);
+    }
+    else{
+      break;
+    }
+  }
+  
   if (ipv4 == 0xFFFFFFFF || ipv4 == 1) {
     sError("failed to resolve ipv4 addr, fqdn:%s", pInfo->nodeFqdn);
     terrno = TSDB_CODE_TSC_INVALID_FQDN;
diff --git a/source/libs/wal/src/walMeta.c b/source/libs/wal/src/walMeta.c
index 2acdd975e5..e700ef3d0a 100644
--- a/source/libs/wal/src/walMeta.c
+++ b/source/libs/wal/src/walMeta.c
@@ -20,6 +20,7 @@
 #include "tutil.h"
 #include "walInt.h"
 
+
 bool FORCE_INLINE walLogExist(SWal* pWal, int64_t ver) {
   return !walIsEmpty(pWal) && walGetFirstVer(pWal) <= ver && walGetLastVer(pWal) >= ver;
 }
diff --git a/source/os/src/osRand.c b/source/os/src/osRand.c
index 83c36a422d..9cb6f6e52a 100644
--- a/source/os/src/osRand.c
+++ b/source/os/src/osRand.c
@@ -27,11 +27,11 @@ void taosSeedRand(uint32_t seed) { return srand(seed); }
 
 uint32_t taosRand(void) {
 #ifdef WINDOWS
-    unsigned int pSeed;
-    rand_s(&pSeed);
-    return pSeed;
+  unsigned int pSeed;
+  rand_s(&pSeed);
+  return pSeed;
 #else
-    return rand();
+  return rand();
 #endif
 }
 
@@ -80,6 +80,15 @@ void taosRandStr(char* str, int32_t size) {
   const char* set = "abcdefghijklmnopqrstuvwxyz0123456789-_.";
   int32_t     len = 39;
 
+  for (int32_t i = 0; i < size; ++i) {
+    str[i] = set[taosRand() % len];
+  }
+}
+
+void taosRandStr2(char* str, int32_t size) {
+  const char* set = "abcdefghijklmnopqrstuvwxyz0123456789";
+  int32_t     len = 36;
+
   for (int32_t i = 0; i < size; ++i) {
     str[i] = set[taosRand() % len];
   }
diff --git a/source/util/src/terror.c b/source/util/src/terror.c
index b0b407e2a5..466b9985e7 100644
--- a/source/util/src/terror.c
+++ b/source/util/src/terror.c
@@ -151,6 +151,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_SHOWOBJ,          "Data expired")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_QUERY_ID,         "Invalid query id")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_CONN_ID,          "Invalid connection id")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_USER_DISABLED,            "User is disabled")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_PLATFORM,         "Unsupported feature on this platform")
 
 // mnode-sdb
 TAOS_DEFINE_ERROR(TSDB_CODE_SDB_OBJ_ALREADY_THERE,        "Object already there")
diff --git a/tests/parallel_test/cases.task b/tests/parallel_test/cases.task
index 0a65340976..741226f101 100644
--- a/tests/parallel_test/cases.task
+++ b/tests/parallel_test/cases.task
@@ -1204,6 +1204,9 @@
 ,,y,script,./test.sh -f tsim/tag/drop_tag.sim
 ,,y,script,./test.sh -f tsim/tag/tbNameIn.sim
 ,,y,script,./test.sh -f tmp/monitor.sim
+,,y,script,./test.sh -f tsim/tagindex/add_index.sim 
+,,n,script,./test.sh -f tsim/tagindex/sma_and_tag_index.sim 
+
 
 #develop test
 ,,n,develop-test,python3 ./test.py -f 2-query/table_count_scan.py
diff --git a/tests/script/tsim/sma/drop_sma.sim b/tests/script/tsim/sma/drop_sma.sim
index 8fd8ebdcfd..fcf48f2b36 100644
--- a/tests/script/tsim/sma/drop_sma.sim
+++ b/tests/script/tsim/sma/drop_sma.sim
@@ -52,19 +52,35 @@ sql create sma index sma_index_name1 on stb function(max(c1),max(c2),min(c1)) in
 
 print --> show sma
 sql show indexes from stb from d1;
-if $rows != 1 then
+if $rows != 2 then
   return -1
 endi
-if $data[0][0] != sma_index_name1 then
-  return -1
-endi
-if $data[0][1] != d1 then
-  return -1
-endi
-if $data[0][2] != stb then
-  return -1
+
+if $data[0][6] == tag_index then 
+    if $data[1][0] != sma_index_name1 then
+      return -1
+    endi
+    if $data[1][1] != d1 then
+      return -1
+    endi
+    if $data[1][2] != stb then
+      return -1
+    endi
+else
+    if $data[0][0] != sma_index_name1 then
+      return -1
+    endi
+    if $data[0][1] != d1 then
+      return -1
+    endi
+    if $data[0][2] != stb then
+      return -1
+    endi
 endi
 
+
+
+
 print --> drop stb
 sql drop table stb;
 
@@ -78,17 +94,30 @@ sql create sma index sma_index_name1 on stb function(max(c1),max(c2),min(c1)) in
 
 print --> show sma
 sql show indexes from stb from d1;
-if $rows != 1 then
+if $rows != 2 then
   return -1
 endi
-if $data[0][0] != sma_index_name1 then
-  return -1
-endi
-if $data[0][1] != d1 then
-  return -1
-endi
-if $data[0][2] != stb then
-  return -1
+
+if $data[0][6] == tag_index then
+  if $data[1][0] != sma_index_name1 then
+    return -1
+  endi
+  if $data[1][1] != d1 then
+    return -1
+  endi
+  if $data[1][2] != stb then
+    return -1
+  endi
+else 
+  if $data[0][0] != sma_index_name1 then
+    return -1
+  endi
+  if $data[0][1] != d1 then
+    return -1
+  endi
+  if $data[0][2] != stb then
+    return -1
+  endi
 endi
 
 print --> drop stb
diff --git a/tests/script/tsim/tagindex/add_index.sim b/tests/script/tsim/tagindex/add_index.sim
index cfbec90542..a6e9cae670 100644
--- a/tests/script/tsim/tagindex/add_index.sim
+++ b/tests/script/tsim/tagindex/add_index.sim
@@ -7,7 +7,7 @@ print ======== step0
 $dbPrefix = ta_3_db
 $tbPrefix = ta_3_tb
 $mtPrefix = ta_3_mt
-$tbNum = 500 
+$tbNum = 50 
 $rowNum = 20
 $totalNum = 200
 
@@ -48,12 +48,16 @@ while $i < $tbNum
   $i = $i + 1
 endw
 
-
+sql_error create index ti1 on $mtPrefix (t1)
 sql create index ti2 on $mtPrefix (t2)
 sql create index ti5 on $mtPrefix (t5)
 
 print ==== test name conflict
 # 
+
+sql_error create index ti1 on $mtPrefix(t1) 
+sql_error create index ti11 on $mtPrefix(t1) 
+
 sql_error create index ti3 on $mtPrefix(t2) 
 
 sql_error create index ti2 on $mtPrefix(t2) 
@@ -73,6 +77,15 @@ while $i < $tbNum
   $i = $i + 1
 endw
 
+$i = 0
+while $i < $tbNum
+  sql select * from $mtPrefix where t1= $i ;
+  if $rows != 1 then
+    return -1
+  endi
+  $i = $i + 1
+endw
+
 
 
 print ===== test operator great equal 
@@ -250,7 +263,7 @@ endw
 print === show index
 
 sql select * from information_schema.ins_indexes
-if $rows != 1 then 
+if $rows != 2 then 
   return -1
 endi
 
@@ -259,12 +272,41 @@ print === drop index ti2
 sql drop index ti2
 
 print === drop not exist index
+
+sql select * from information_schema.ins_indexes
+if $rows != 1 then 
+  return -1
+endi
+
+sql drop index $data[0][0]
+
+if $rows != 0 then 
+  return -1
+endi
+
+
 sql_error drop index t2
 sql_error drop index t3
 
 
 
+sql create index ti0 on $mtPrefix (t1)
+
+$i = $interval 
+while $i < $limit
+  sql select * from $mtPrefix where t1 <= $i ;
+  
+  $tmp = $i  - $interval
+  $tmp = $tmp + 1
+  if $rows != $tmp then
+    return -1
+  endi
+  $i = $i + 1
+endw
 sql_error create index ti0 on $mtPrefix (t1)
+sql_error create index ti2 on $mtPrefix (t1)
+
+
 sql_error create index t2i on ta_3_tb17 (t2)
 
 
diff --git a/tests/script/tsim/tagindex/sma_and_tag_index.sim b/tests/script/tsim/tagindex/sma_and_tag_index.sim
index b15d22d439..e7e4682810 100644
--- a/tests/script/tsim/tagindex/sma_and_tag_index.sim
+++ b/tests/script/tsim/tagindex/sma_and_tag_index.sim
@@ -69,7 +69,7 @@ sql create sma index smat2i on $mtPrefix function(max(c1)) interval(6m,10s) slid
 
 
 sql select * from information_schema.ins_indexes
-if $rows != 2 then 
+if $rows != 3 then 
   return -1
 endi
 
@@ -84,7 +84,7 @@ while $i < 5
 endw
 
 sql select * from information_schema.ins_indexes
-if $rows != 6 then 
+if $rows != 7 then 
   return -1
 endi
 
@@ -114,13 +114,13 @@ sql use $dbPrefix
 sql create table if not exists $mtPrefix (ts timestamp, c1 int) tags (t1 int, t2 int, t3 int, t4 int, t5 int)
 sql create index tagt2i on $mtPrefix (t2)
 sql select * from information_schema.ins_indexes
-if $rows != 1 then 
+if $rows != 2 then 
   return -1
 endi
 sql alter table $mtPrefix drop tag t2
 
 sql select * from information_schema.ins_indexes
-if $rows != 0 then 
+if $rows != 1 then 
   return -1
 endi
 
@@ -128,18 +128,22 @@ endi
 print ==== rename tag name, and update index colName
 sql create index tagt3i on $mtPrefix (t3)
 sql select * from information_schema.ins_indexes
-if $rows != 1 then 
+if $rows != 2 then 
   return -1
 endi
 
 sql alter table $mtPrefix rename tag t3 txxx 
 sql select * from information_schema.ins_indexes
-if $rows != 1 then 
+if $rows != 2 then 
   return -1
 endi
 
-if $data05 != txxx then
-  return -1
+if $data05 == txxx then
+  print "manual created index" 
+elif $data15 == txxx then
+  print "auto created index at tag0"
+else 
+  return -1;
 endi
 
 
@@ -153,7 +157,7 @@ sql create table if not exists $mtPrefix (ts timestamp, c1 int) tags (t1 int, t2
 sql create index tagt3i on $mtPrefix (t3)
 sql select * from information_schema.ins_indexes  
 
-if $rows != 2 then 
+if $rows != 4 then 
   return -1
 endi
 
diff --git a/tests/system-test/0-others/show.py b/tests/system-test/0-others/show.py
index 9d26b3a2ae..5445352f43 100644
--- a/tests/system-test/0-others/show.py
+++ b/tests/system-test/0-others/show.py
@@ -210,6 +210,66 @@ class TDTestCase:
         licences_info = tdSql.queryResult
         tdSql.checkEqual(grants_info,licences_info)
 
+    def show_create_table_with_col_comment(self):
+        tdSql.execute("create database comment_test_db")
+        tdSql.execute("use comment_test_db")
+        tdSql.execute("create table normal_table(ts timestamp, c2 int comment 'c2 comment')")
+        tdSql.execute("create stable super_table(ts timestamp comment 'ts', c2 int comment 'c2 comment') tags(tg int comment 'tg comment')")
+
+        create_sql = "create table `normal_table` (`ts` timestamp, `c2` int)"
+        tdSql.query('show create table normal_table')
+        tdSql.checkEqual(tdSql.queryResult[0][1].lower(), create_sql)
+        tdSql.query('show create table super_table')
+        create_sql = "create stable `super_table` (`ts` timestamp, `c2` int) tags (`tg` int)"
+        tdSql.checkEqual(tdSql.queryResult[0][1].lower(), create_sql)
+
+        tdSql.query("desc normal_table")
+        tdSql.checkCols(5)
+        tdSql.checkData(0, 4, "")
+
+        tdSql.query("desc super_table")
+        tdSql.checkCols(5)
+        tdSql.checkData(0, 4, "")
+
+        tdSql.execute("drop database comment_test_db")
+
+    def alter_table_with_col_comment(self):
+        tdSql.execute("create database comment_test_db")
+        tdSql.execute("use comment_test_db")
+        tdSql.execute("create table normal_table(ts timestamp, c2 int comment 'c2 comment')")
+        tdSql.execute("create stable super_table(ts timestamp comment 'ts', c2 int comment 'c2 comment') tags(tg int comment 'tg comment')")
+
+        create_sql = "create table `normal_table` (`ts` timestamp, `c2` int, `c3` int)"
+        tdSql.execute("alter table normal_table add column c3 int comment 'c3 comment'", queryTimes=1)
+        tdSql.query("show create table normal_table")
+        tdSql.checkEqual(tdSql.queryResult[0][1].lower(), create_sql)
+
+        create_sql = "create table `normal_table` (`ts` timestamp, `c2` int, `c3` int, `c4` varchar(255))"
+        tdSql.execute("alter table normal_table add column c4 varchar(255) comment 'c4 comment'", queryTimes=1)
+        tdSql.query("show create table normal_table")
+        tdSql.checkEqual(tdSql.queryResult[0][1].lower(), create_sql)
+
+        create_sql = "create table `normal_table` (`ts` timestamp, `c2` int, `c3` int, `c4` varchar(255), `c5` varchar(255))"
+        tdSql.execute("alter table normal_table add column c5 varchar(255)", queryTimes=1)
+        tdSql.query("show create table normal_table")
+        tdSql.checkEqual(tdSql.queryResult[0][1].lower(), create_sql)
+
+        create_sql = "create stable `super_table` (`ts` timestamp, `c2` int, `c3` int) tags (`tg` int) sma(`ts`,`c2`)"
+        tdSql.execute("alter table super_table add column c3 int comment 'c3 comment'", queryTimes=1)
+        tdSql.query("show create table super_table")
+        tdSql.checkEqual(tdSql.queryResult[0][1].lower(), create_sql)
+
+        create_sql = "create stable `super_table` (`ts` timestamp, `c2` int, `c3` int, `c4` varchar(255)) tags (`tg` int) sma(`ts`,`c2`)"
+        tdSql.execute("alter table super_table add column c4 varchar(255) comment 'c4 comment'", queryTimes=1)
+        tdSql.query("show create table super_table")
+        tdSql.checkEqual(tdSql.queryResult[0][1].lower(), create_sql)
+
+        create_sql = "create stable `super_table` (`ts` timestamp, `c2` int, `c3` int, `c4` varchar(256)) tags (`tg` int) sma(`ts`,`c2`)"
+        tdSql.execute("alter table super_table modify column c4 varchar(256) comment 'c4 256 comment'", queryTimes=1)
+        tdSql.query("show create table super_table")
+        tdSql.checkEqual(tdSql.queryResult[0][1].lower(), create_sql)
+        tdSql.execute("drop database comment_test_db")
+
     def run(self):
         self.check_gitinfo()
         self.show_base()
@@ -218,6 +278,8 @@ class TDTestCase:
         self.show_create_sql()
         self.show_create_sysdb_sql()
         self.show_create_systb_sql()
+        self.show_create_table_with_col_comment()
+        self.alter_table_with_col_comment()
 
     def stop(self):
         tdSql.close()
diff --git a/tests/system-test/0-others/show_tag_index.py b/tests/system-test/0-others/show_tag_index.py
index 663426b7ff..d39f9eaab9 100644
--- a/tests/system-test/0-others/show_tag_index.py
+++ b/tests/system-test/0-others/show_tag_index.py
@@ -59,14 +59,18 @@ class TDTestCase:
             tdSql.checkData(1, 2, 2)
 
     def check_indexes(self):
-        tdSql.checkRows(1)
-        tdSql.checkCols(7)
-        tdSql.checkData(0, 0, 'idx1')
-        tdSql.checkData(0, 1, 'db')
-        tdSql.checkData(0, 2, 'stb')
-        tdSql.checkData(0, 3, None)
-        tdSql.checkData(0, 5, 't1')
-        tdSql.checkData(0, 6, 'tag_index')
+        tdSql.checkRows(2)
+        for i in range(2):
+            col_name = tdSql.getData(i, 5)
+            if col_name == "t0":
+                continue
+            tdSql.checkCols(7)
+            tdSql.checkData(i, 0, 'idx1')
+            tdSql.checkData(i, 1, 'db')
+            tdSql.checkData(i, 2, 'stb')
+            tdSql.checkData(i, 3, None)
+            tdSql.checkData(i, 5, 't1')
+            tdSql.checkData(i, 6, 'tag_index')
 
     def run(self):
         tdSql.execute(f'create database db')
diff --git a/tests/system-test/0-others/tag_index_basic.py b/tests/system-test/0-others/tag_index_basic.py
index 72ed559ffd..c1e1d521d2 100644
--- a/tests/system-test/0-others/tag_index_basic.py
+++ b/tests/system-test/0-others/tag_index_basic.py
@@ -118,12 +118,15 @@ class TDTestCase:
     def show_tagidx(self, stbname):
         sql = f'select index_name,column_name from information_schema.ins_indexes where db_name="db"'
         tdSql.query(sql)
-        rows = len(self.tag_dict.keys())-1
+        rows = len(self.tag_dict.keys())
         tdSql.checkRows(rows)
 
         for i in range(rows):
             col_name = tdSql.getData(i, 1)
             idx_name = f'idx_{col_name}'
+            # skip first tag
+            if col_name == "t1":
+                continue
             tdSql.checkData(i, 0, idx_name)
 
         tdLog.info(f' show {rows} tag indexs ok.')
@@ -201,7 +204,7 @@ class TDTestCase:
         # check idx result is 0
         sql = f'select index_name,column_name from information_schema.ins_indexes where db_name="db"'
         tdSql.query(sql)
-        tdSql.checkRows(0)
+        tdSql.checkRows(1)
         tdLog.info(f' drop {cnt} tag indexs ok.')
 
     # create long name idx 
diff --git a/tests/system-test/0-others/walRetention.py b/tests/system-test/0-others/walRetention.py
index 2b340b7969..5257b7644a 100644
--- a/tests/system-test/0-others/walRetention.py
+++ b/tests/system-test/0-others/walRetention.py
@@ -460,8 +460,7 @@ class TDTestCase:
         #self.test_db("db2", 5, 10*24*3600, 2*1024) # 2M size
         
         # period + size        
-        self.test_db("db", checkTime = 5*60, wal_period = 60, wal_size_kb=10)
-        #self.test_db("db", checkTime = 3*60, wal_period = 0, wal_size_kb=0)
+        self.test_db("db", checkTime = 3*60, wal_period = 60, wal_size_kb=500)
 
 
     def stop(self):
diff --git a/tests/system-test/2-query/interp.py b/tests/system-test/2-query/interp.py
index 986c63839b..c2eb7bee2e 100644
--- a/tests/system-test/2-query/interp.py
+++ b/tests/system-test/2-query/interp.py
@@ -20,6 +20,7 @@ class TDTestCase:
         tbname = "tb"
         tbname1 = "tb1"
         tbname2 = "tb2"
+        tbname3 = "tb3"
         stbname = "stb"
         ctbname1 = "ctb1"
         ctbname2 = "ctb2"
@@ -5607,6 +5608,44 @@ class TDTestCase:
         tdSql.query(f"select _irowts, _isfilled, interp(c0) from {dbname}.{stbname_single} partition by tbname range('2020-02-01 00:00:06') fill(linear)")
         tdSql.checkRows(0)
 
+        #### TS-3799 ####
+
+        tdSql.execute(
+            f'''create table if not exists {dbname}.{tbname3} (ts timestamp, c0 double)'''
+        )
+
+        tdSql.execute(f"insert into {dbname}.{tbname3} values ('2023-08-06 23:59:51.000000000', 4.233947800000000)")
+        tdSql.execute(f"insert into {dbname}.{tbname3} values ('2023-08-06 23:59:52.000000000', 3.606781000000000)")
+        tdSql.execute(f"insert into {dbname}.{tbname3} values ('2023-08-06 23:59:52.500000000', 3.162353500000000)")
+        tdSql.execute(f"insert into {dbname}.{tbname3} values ('2023-08-06 23:59:53.000000000', 3.162292500000000)")
+        tdSql.execute(f"insert into {dbname}.{tbname3} values ('2023-08-06 23:59:53.500000000', 4.998230000000000)")
+        tdSql.execute(f"insert into {dbname}.{tbname3} values ('2023-08-06 23:59:54.400000000', 8.800414999999999)")
+        tdSql.execute(f"insert into {dbname}.{tbname3} values ('2023-08-06 23:59:54.900000000', 8.853271500000000)")
+        tdSql.execute(f"insert into {dbname}.{tbname3} values ('2023-08-06 23:59:55.900000000', 7.507751500000000)")
+        tdSql.execute(f"insert into {dbname}.{tbname3} values ('2023-08-06 23:59:56.400000000', 7.510681000000000)")
+        tdSql.execute(f"insert into {dbname}.{tbname3} values ('2023-08-06 23:59:56.900000000', 7.841614000000000)")
+        tdSql.execute(f"insert into {dbname}.{tbname3} values ('2023-08-06 23:59:57.900000000', 8.153809000000001)")
+        tdSql.execute(f"insert into {dbname}.{tbname3} values ('2023-08-06 23:59:58.500000000', 6.866455000000000)")
+        tdSql.execute(f"insert into {dbname}.{tbname3} values ('2023-08-06 23:59:59.000000000', 6.869140600000000)")
+        tdSql.execute(f"insert into {dbname}.{tbname3} values ('2023-08-07 00:00:00.000000000', 0.261475000000001)")
+
+        tdSql.query(f"select _irowts, interp(c0) from {dbname}.{tbname3} range('2023-08-06 23:59:00','2023-08-06 23:59:59') every(1m) fill(next)")
+        tdSql.checkRows(1);
+        tdSql.checkData(0,  0, '2023-08-06 23:59:00')
+        tdSql.checkData(0,  1, 4.233947800000000)
+
+        tdSql.query(f"select _irowts, interp(c0) from {dbname}.{tbname3} range('2023-08-06 23:59:00','2023-08-06 23:59:59') every(1m) fill(value, 1)")
+        tdSql.checkRows(1);
+        tdSql.checkData(0,  0, '2023-08-06 23:59:00')
+        tdSql.checkData(0,  1, 1)
+
+        tdSql.query(f"select _irowts, interp(c0) from {dbname}.{tbname3} range('2023-08-06 23:59:00','2023-08-06 23:59:59') every(1m) fill(null)")
+        tdSql.checkRows(1);
+        tdSql.checkData(0,  0, '2023-08-06 23:59:00')
+        tdSql.checkData(0,  1, None)
+
+
+
     def stop(self):
         tdSql.close()
         tdLog.success(f"{__file__} successfully executed")
diff --git a/tests/system-test/7-tmq/tmqCommon.py b/tests/system-test/7-tmq/tmqCommon.py
index 3ea8273e7f..7f972d857e 100644
--- a/tests/system-test/7-tmq/tmqCommon.py
+++ b/tests/system-test/7-tmq/tmqCommon.py
@@ -578,18 +578,40 @@ class TMQCom:
         tdLog.info("wait subscriptions exit for %d s"%wait_cnt)
 
     def killProcesser(self, processerName):
-        killCmd = (
-            "ps -ef|grep -w %s| grep -v grep | awk '{print $2}' | xargs kill -TERM > /dev/null 2>&1"
-            % processerName
-        )
-
-        psCmd = "ps -ef|grep -w %s| grep -v grep | awk '{print $2}'" % processerName
-        processID = subprocess.check_output(psCmd, shell=True)
+        if platform.system().lower() == 'windows':
+            killCmd = ("wmic process where name=\"%s.exe\" call terminate > NUL 2>&1" % processerName)
+            psCmd = ("wmic process where name=\"%s.exe\" | findstr \"%s.exe\"" % (processerName, processerName))
+        else:
+            killCmd = (
+                "ps -ef|grep -w %s| grep -v grep | awk '{print $2}' | xargs kill -TERM > /dev/null 2>&1"
+                % processerName
+            )
+            psCmd = ("ps -ef|grep -w %s| grep -v grep | awk '{print $2}'" % processerName)
 
+        processID = ""
+        
+        try: 
+            processID = subprocess.check_output(psCmd, shell=True)
+        except Exception as err:
+            processID = ""
+            print('**** warn: ', err)        
+        
         while processID:
             os.system(killCmd)
             time.sleep(1)
-            processID = subprocess.check_output(psCmd, shell=True)
+            try: 
+                processID = subprocess.check_output(psCmd, shell=True)
+            except Exception as err:
+                processID = ""
+                print('**** warn: ', err)
+                
+    def startProcess(self, processName, param):
+        if platform.system().lower() == 'windows':
+            cmd = f"mintty -h never %s %s > NUL 2>&1" % (processName, param)
+        else:
+            cmd = f"nohup %s %s > /dev/null 2>&1 &" % (processName, param)
+        tdLog.info("%s"%(cmd))
+        os.system(cmd)                
 
     def close(self):
         self.cursor.close()
diff --git a/tests/system-test/7-tmq/tmqDropConsumer.py b/tests/system-test/7-tmq/tmqDropConsumer.py
index 06ce4c0fd7..137b5c6584 100644
--- a/tests/system-test/7-tmq/tmqDropConsumer.py
+++ b/tests/system-test/7-tmq/tmqDropConsumer.py
@@ -176,9 +176,7 @@ class TDTestCase:
         
         # use taosBenchmark to subscribe  
         binPath = self.getPath()
-        cmd = "nohup %s -f ./7-tmq/tmqDropConsumer.json > /dev/null 2>&1 & " % binPath
-        tdLog.info("%s"%(cmd))
-        os.system(cmd)
+        tmqCom.startProcess(binPath, "-f ./7-tmq/tmqDropConsumer.json")        
                 
         expectTopicNum = len(topicNameList)
         consumerThreadNum = 2
diff --git a/tests/system-test/7-tmq/tmqMaxGroupIds.py b/tests/system-test/7-tmq/tmqMaxGroupIds.py
index d22b79a44c..75e2993a5b 100644
--- a/tests/system-test/7-tmq/tmqMaxGroupIds.py
+++ b/tests/system-test/7-tmq/tmqMaxGroupIds.py
@@ -176,9 +176,7 @@ class TDTestCase:
         
         # use taosBenchmark to subscribe  
         binPath = self.getPath()
-        cmd = "nohup %s -f ./7-tmq/tmqMaxGroupIds.json > /dev/null 2>&1 & " % binPath
-        tdLog.info("%s"%(cmd))
-        os.system(cmd)
+        tmqCom.startProcess(binPath, "-f ./7-tmq/tmqMaxGroupIds.json")
                 
         expectTopicNum = 1
         expectConsumerNUm = 99
diff --git a/tools/shell/src/shellEngine.c b/tools/shell/src/shellEngine.c
index 860622ea18..e084f97fb5 100644
--- a/tools/shell/src/shellEngine.c
+++ b/tools/shell/src/shellEngine.c
@@ -771,7 +771,7 @@ int32_t shellCalcColWidth(TAOS_FIELD *field, int32_t precision) {
       if (field->bytes > shell.args.displayWidth) {
         return TMAX(shell.args.displayWidth, width);
       } else {
-        return TMAX(field->bytes, width);
+        return TMAX(field->bytes + 2, width);
       }
 
     case TSDB_DATA_TYPE_NCHAR:
@@ -780,7 +780,7 @@ int32_t shellCalcColWidth(TAOS_FIELD *field, int32_t precision) {
       if (bytes > shell.args.displayWidth) {
         return TMAX(shell.args.displayWidth, width);
       } else {
-        return TMAX(bytes, width);
+        return TMAX(bytes + 2, width);
       }
     }