Merge branch '3.0' into cpwu/3.0

2022-08-11 15:15:38 +08:00 · 2022-08-11 15:15:38 +08:00 · adc047c6c1
parent 1236375ded 8ad76f4307
commit adc047c6c1
82 changed files with 1922 additions and 5147 deletions
--- a/88
+++ b/88
@ -38,40 +38,21 @@ def pre_test(){
    sh '''
        cd ${WK}
        git reset --hard
        git remote prune origin
        git fetch
        cd ${WKC}
        git reset --hard
        git clean -fxd
        git remote prune origin
        git fetch
    '''
    script {
-        if (env.CHANGE_TARGET == 'master') {
+        sh '''
-            sh '''
+            cd ${WK}
-                cd ${WK}
+            git checkout ''' + env.CHANGE_TARGET + '''
-                git checkout master
+            cd ${WKC}
-                cd ${WKC}
+            git checkout ''' + env.CHANGE_TARGET + '''
-                git checkout master
+        '''
            '''
        } else if(env.CHANGE_TARGET == '2.0') {
            sh '''
                cd ${WK}
                git checkout 2.0
                cd ${WKC}
                git checkout 2.0
            '''
        } else if(env.CHANGE_TARGET == '3.0') {
            sh '''
                cd ${WK}
                git checkout 3.0
                cd ${WKC}
                git checkout 3.0
            '''
        } else {
            sh '''
                cd ${WK}
                git checkout develop
                cd ${WKC}
                git checkout develop
            '''
        }
    }
    if (env.CHANGE_URL =~ /\/TDengine\//) {
        sh '''
@ -169,49 +150,24 @@ def pre_test_win(){
    bat '''
        cd %WIN_INTERNAL_ROOT%
        git reset --hard
        git remote prune origin
        git fetch
    '''
    bat '''
        cd %WIN_COMMUNITY_ROOT%
        git reset --hard
        git remote prune origin
        git fetch
    '''
    script {
-        if (env.CHANGE_TARGET == 'master') {
+        bat '''
-            bat '''
+            cd %WIN_INTERNAL_ROOT%
-                cd %WIN_INTERNAL_ROOT%
+            git checkout ''' + env.CHANGE_TARGET + '''
-                git checkout master
+        '''
-            '''
+        bat '''
-            bat '''
+            cd %WIN_COMMUNITY_ROOT%
-                cd %WIN_COMMUNITY_ROOT%
+            git checkout ''' + env.CHANGE_TARGET + '''
-                git checkout master
+        '''
            '''
        } else if(env.CHANGE_TARGET == '2.0') {
            bat '''
                cd %WIN_INTERNAL_ROOT%
                git checkout 2.0
            '''
            bat '''
                cd %WIN_COMMUNITY_ROOT%
                git checkout 2.0
            '''
        } else if(env.CHANGE_TARGET == '3.0') {
            bat '''
                cd %WIN_INTERNAL_ROOT%
                git checkout 3.0
            '''
            bat '''
                cd %WIN_COMMUNITY_ROOT%
                git checkout 3.0
            '''
        } else {
            bat '''
                cd %WIN_INTERNAL_ROOT%
                git checkout develop
            '''
            bat '''
                cd %WIN_COMMUNITY_ROOT%
                git checkout develop
            '''
        }
    }
    script {
        if (env.CHANGE_URL =~ /\/TDengine\//) {
--- a/cmake/taosadapter_CMakeLists.txt.in
+++ b/cmake/taosadapter_CMakeLists.txt.in
@ -2,7 +2,7 @@
 # taosadapter
 ExternalProject_Add(taosadapter
        GIT_REPOSITORY https://github.com/taosdata/taosadapter.git
-        GIT_TAG ed6a160
+        GIT_TAG 3d21433
        SOURCE_DIR "${TD_SOURCE_DIR}/tools/taosadapter"
        BINARY_DIR ""
        #BUILD_IN_SOURCE TRUE
--- a/cmake/taostools_CMakeLists.txt.in
+++ b/cmake/taostools_CMakeLists.txt.in
@ -2,7 +2,7 @@
 # taos-tools
 ExternalProject_Add(taos-tools
        GIT_REPOSITORY https://github.com/taosdata/taos-tools.git
-        GIT_TAG 2d68404
+        GIT_TAG 57bdfbf
        SOURCE_DIR "${TD_SOURCE_DIR}/tools/taos-tools"
        BINARY_DIR ""
        #BUILD_IN_SOURCE TRUE
--- a/cmake/taosws_CMakeLists.txt.in
+++ b/cmake/taosws_CMakeLists.txt.in
@ -2,7 +2,7 @@
 # taosws-rs
 ExternalProject_Add(taosws-rs
        GIT_REPOSITORY https://github.com/taosdata/taos-connector-rust.git
-        GIT_TAG 97c4bac
+        GIT_TAG 7a54d21
        SOURCE_DIR "${TD_SOURCE_DIR}/tools/taosws-rs"
        BINARY_DIR ""
        #BUILD_IN_SOURCE TRUE
--- a/docs/en/14-reference/08-taos-shell.md
+++ b/docs/en/14-reference/08-taos-shell.md
@ -47,27 +47,28 @@ If the displayed content is followed by `...` you can use this command to change
 You can change the behavior of TDengine CLI by specifying command-line parameters. The following parameters are commonly used.
- -h, --host=HOST: FQDN of the server where the TDengine server is to be connected. Default is to connect to the local service
+- -h HOST: FQDN of the server where the TDengine server is to be connected. Default is to connect to the local service
- -P, --port=PORT: Specify the port number to be used by the server. Default is `6030`
+- -P PORT: Specify the port number to be used by the server. Default is `6030`
- -u, --user=USER: the user name to use when connecting. Default is `root`
+- -u USER: the user name to use when connecting. Default is `root`
- -p, --password=PASSWORD: the password to use when connecting to the server. Default is `taosdata`
+- -p PASSWORD: the password to use when connecting to the server. Default is `taosdata`
 - -?, --help: print out all command-line arguments 
 And many more parameters.
- -c, --config-dir: Specify the directory where configuration file exists. The default is `/etc/taos`, and the default name of the configuration file in this directory is `taos.cfg`
+- -a AUTHSTR: The auth string to use when connecting to the server
- -C, --dump-config: Print the configuration parameters of `taos.cfg` in the default directory or specified by -c
+- -A: Generate auth string from password
- -d, --database=DATABASE: Specify the database to use when connecting to the server
+- -c CONFIGDIR: Specify the directory where configuration file exists. The default is `/etc/taos`, and the default name of the configuration file in this directory is `taos.cfg`
- -D, --directory=DIRECTORY: Import the SQL script file in the specified path
+- -C: Print the configuration parameters of `taos.cfg` in the default directory or specified by -c
- -f, --file=FILE: Execute the SQL script file in non-interactive mode
+- -d DATABASE: Specify the database to use when connecting to the server
- -k, --check=CHECK: Specify the table to be checked
+- -f FILE: Execute the SQL script file in non-interactive mode
- -l, --pktlen=PKTLEN: Test package size to be used for network testing
+- -k: Check the service status, 0: unavailable，1: network ok，2: service ok，3: service degraded，4: exiting
- -n, --netrole=NETROLE: test scope for network connection test, default is `startup`. The value can be `client`, `server`, `rpc`, `startup`, `sync`, `speed`, or `fqdn`.
+- -l PKTLEN: Test package length to be used for network testing
- -r, --raw-time: output the timestamp format as unsigned 64-bits integer (uint64_t in C language)
+- -n NETROLE: test scope for network connection test, default is `client`. The value can be `client`, `server`
- -s, --commands=COMMAND: execute SQL commands in non-interactive mode
+- -N PKTNUM: Test package numbers to be used for network testing
- -S, --pkttype=PKTTYPE: Specify the packet type used for network testing. The default is TCP, can be specified as either TCP or UDP when `speed` is specified to `netrole` parameter
+- -r: output the timestamp format as unsigned 64-bits integer (uint64_t in C language)
- -T, --thread=THREADNUM: The number of threads to import data in multi-threaded mode
+- -s COMMAND: execute SQL commands in non-interactive mode
- -s, --commands: Run TDengine CLI commands without entering the terminal
+- -t: Check the details of the service status，status same as -k
 - -w DISPLAYWIDTH: 客户端列显示宽度
 - -z, --timezone=TIMEZONE: Specify time zone. Default is the value of current configuration file
 - -V, --version: Print out the current version number
--- a/docs/en/14-reference/09-support-platform/index.md
+++ b/docs/en/14-reference/09-support-platform/index.md
@ -5,12 +5,11 @@ description: "List of platforms supported by TDengine server, client, and connec
 ## List of supported platforms for TDengine server
-|              | **CentOS 7/8** | **Ubuntu 16/18/20** | **Other Linux** |
+|                    | **Windows 10/11** | **CentOS 7.9/8** | **Ubuntu 18/20** | **Other Linux** | **UOS** | **Kylin** | **Ningsi V60/V80** | **HUAWEI EulerOS** |
-| ------------ | -------------- | ------------------- | --------------- |
+| ------------------ | ----------------- | ---------------- | ---------------- | --------------- | ------- | --------- | ------------------ | ------------------ |
-| X64          | ●              | ●                   |                 |
+| X64                | ●                 | ●                | ●                |                 | ●       | ●         | ●                  |                    |
-| MIPS64       |                |                     | ●               |
+| Raspberry Pi ARM64 |                   |                  |                  | ●               |         |           |                    |                    |
-| ARM64        |                | ○                   | ○               |
+| HUAWEI cloud ARM64 |                   |                  |                  |                 |         |           |                    | ●                  |
 | Alpha64      |                |                     | ○               |
 Note: ● means officially tested and verified, ○ means unofficially tested and verified.
--- a/docs/en/14-reference/12-directory.md
+++ b/docs/en/14-reference/12-directory.md
@ -25,7 +25,6 @@ All executable files of TDengine are in the _/usr/local/taos/bin_ directory by d
 - _taosBenchmark_: TDengine testing tool
 - _remove.sh_: script to uninstall TDengine, please execute it carefully, link to the **rmtaos** command in the /usr/bin directory. Will remove the TDengine installation directory `/usr/local/taos`, but will keep `/etc/taos`, `/var/lib/taos`, `/var/log/taos`
 - _taosadapter_: server-side executable that provides RESTful services and accepts writing requests from a variety of other softwares
 - _tarbitrator_: provides arbitration for two-node cluster deployments
 - _TDinsight.sh_: script to download TDinsight and install it
 - _set_core.sh_: script for setting up the system to generate core dump files for easy debugging
 - _taosd-dump-cfg.gdb_: script to facilitate debugging of taosd's gdb execution.
--- a/docs/zh/05-get-started/01-docker.md
+++ b/docs/zh/05-get-started/01-docker.md
@ -2,6 +2,9 @@
 sidebar_label: Docker
 title: 通过 Docker 快速体验 TDengine
 ---
 :::info
 如果您希望对 TDengine 贡献代码或对内部实现感兴趣，请参考我们的 [TDengine GitHub 主页](https://github.com/taosdata/TDengine) 下载源码构建和安装.
 :::
 本节首先介绍如何通过 Docker 快速体验 TDengine，然后介绍如何在 Docker 环境下体验 TDengine 的写入和查询功能。
@ -63,6 +66,10 @@ taos>
 taosAdapter 是 TDengine 中提供 REST 服务的组件。下面这条命令会在容器中同时启动 `taosd` 和 `taosadapter` 两个服务组件。默认 Docker 镜像同时启动 TDengine 后台服务 taosd 和 taosAdatper。
 ```shell
 docker run -d --name tdengine -p 6041:6041 tdengine/tdengine
 ```
 可以在宿主机使用 curl 通过 RESTful 端口访问 Docker 容器内的 TDengine server。
 ```
--- a/docs/zh/12-taos-sql/14-stream.md
+++ b/docs/zh/12-taos-sql/14-stream.md
@ -89,10 +89,6 @@ T = 最新事件时间 - watermark
 无论在哪种模式下，watermark 都应该被妥善设置，来得到正确结果（直接丢弃模式）或避免频繁触发重算带来的性能开销（重新计算模式）。
 ## 流式计算的数据填充策略
 TODO
 ## 流式计算与会话窗口（session window）
 ```sql
@ -105,14 +101,6 @@ window_clause: {
 其中，SESSION 是会话窗口，tol_val 是时间间隔的最大范围。在 tol_val 时间间隔范围内的数据都属于同一个窗口，如果连续的两条数据的时间超过 tol_val，则自动开启下一个窗口。
 ## 流式计算的监控与流任务分布查询
 TODO
 ## 流式计算的内存控制与存算分离
 TODO
 ## 流式计算的暂停与恢复
 ```sql
--- a/docs/zh/12-taos-sql/22-meta.md
+++ b/docs/zh/12-taos-sql/22-meta.md
@ -1,6 +1,6 @@
 ---
-sidebar_label: 元数据库
+sidebar_label: 元数据
-title: 元数据库
+title: 存储元数据的 Information_Schema 数据库
 ---
 TDengine 内置了一个名为 `INFORMATION_SCHEMA` 的数据库，提供对数据库元数据、数据库系统信息和状态的访问，例如数据库或表的名称，当前执行的 SQL 语句等。该数据库存储有关 TDengine 维护的所有其他数据库的信息。它包含多个只读表。实际上，这些表都是视图，而不是基表，因此没有与它们关联的文件。所以对这些表只能查询，不能进行 INSERT 等写入操作。`INFORMATION_SCHEMA` 数据库旨在以一种更一致的方式来提供对 TDengine 支持的各种 SHOW 语句（如 SHOW TABLES、SHOW DATABASES）所提供的信息的访问。与 SHOW 语句相比，使用 SELECT ... FROM INFORMATION_SCHEMA.tablename 具有以下优点：
--- a/docs/zh/12-taos-sql/23-perf.md
+++ b/docs/zh/12-taos-sql/23-perf.md
@ -0,0 +1,129 @@
 ---
 sidebar_label: 统计数据
 title: 存储统计数据的 Performance_Schema 数据库
 ---
 TDengine 3.0 版本开始提供一个内置数据库 `performance_schema`，其中存储了与性能有关的统计数据。本节详细介绍其中的表和表结构。
 ## PERF_APP
 提供接入集群的应用（客户端）的相关信息。也可以使用 SHOW APPS 来查询这些信息。
 | #   |   **列名**   | **数据类型** | **说明**                        |
 | --- | :----------: | ------------ | ------------------------------- |
 | 1   |    app_id    | UBIGINT      | 客户端 ID                       |
 | 2   |      ip      | BINARY(16)   | 客户端地址                      |
 | 3   |     pid      | INT          | 客户端进程 号                   |
 | 4   |     name     | BINARY(24)   | 客户端名称                      |
 | 5   |  start_time  | TIMESTAMP    | 客户端启动时间                  |
 | 6   |  insert_req  | UBIGINT      | insert 请求次数                 |
 | 7   |  insert_row  | UBIGINT      | insert 插入行数                 |
 | 8   | insert_time  | UBIGINT      | insert 请求的处理时间，单位微秒 |
 | 9   | insert_bytes | UBIGINT      | insert 请求消息字节数           |
 | 10  | fetch_bytes  | UBIGINT      | 查询结果字节数                  |
 | 11  |  query_time  | UBIGINT      | 查询请求处理时间                |
 | 12  |  slow_query  | UBIGINT      | 慢查询（处理时间 >= 3 秒）个数  |
 | 13  |  total_req   | UBIGINT      | 总请求数                        |
 | 14  | current_req  | UBIGINT      | 当前正在处理的请求个数          |
 | 15  | last_access  | TIMESTAMP    | 最后更新时间                    |
 ## PERF_CONNECTIONS
 数据库的连接的相关信息。也可以使用 SHOW CONNECTIONS 来查询这些信息。
 | #   |  **列名**   | **数据类型** | **说明**                                           |
 | --- | :---------: | ------------ | -------------------------------------------------- |
 | 1   |   conn_id   | INT          | 连接 ID                                            |
 | 2   |    user     | BINARY(24)   | 用户名                                             |
 | 3   |     app     | BINARY(24)   | 客户端名称                                         |
 | 4   |     pid     | UINT         | 发起此连接的客户端在自己所在服务器或主机上的进程号 |
 | 5   |  end_point  | BINARY(128)  | 客户端地址                                         |
 | 6   | login_time  | TIMESTAMP    | 登录时间                                           |
 | 7   | last_access | TIMESTAMP    | 最后更新时间                                       |
 ## PERF_QUERIES
 提供当前正在执行的 SQL 语句的信息。也可以使用 SHOW QUERIES 来查询这些信息。
 | #   |   **列名**   | **数据类型** | **说明**                     |
 | --- | :----------: | ------------ | ---------------------------- |
 | 1   |   kill_id    | UBIGINT      | 用来停止查询的 ID            |
 | 2   |   query_id   | INT          | 查询 ID                      |
 | 3   |   conn_id    | UINT         | 连接 ID                      |
 | 4   |     app      | BINARY(24)   | app 名称                     |
 | 5   |     pid      | INT          | app 在自己所在主机上的进程号 |
 | 6   |     user     | BINARY(24)   | 用户名                       |
 | 7   |  end_point   | BINARY(16)   | 客户端地址                   |
 | 8   | create_time  | TIMESTAMP    | 创建时间                     |
 | 9   |  exec_usec   | BIGINT       | 已执行时间                   |
 | 10  | stable_query | BOOL         | 是否是超级表查询             |
 | 11  |   sub_num    | INT          | 子查询数量                   |
 | 12  |  sub_status  | BINARY(1000) | 子查询状态                   |
 | 13  |     sql      | BINARY(1024) | SQL 语句                     |
 ## PERF_TOPICS
 | #   |  **列名**   | **数据类型** | **说明**                       |
 | --- | :---------: | ------------ | ------------------------------ |
 | 1   | topic_name  | BINARY(192)  | topic 名称                     |
 | 2   |   db_name   | BINARY(64)   | topic 相关的 DB                |
 | 3   | create_time | TIMESTAMP    | topic 的 创建时间              |
 | 4   |     sql     | BINARY(1024) | 创建该 topic 时所用的 SQL 语句 |
 ## PERF_CONSUMERS
 | #   |    **列名**    | **数据类型** | **说明**                                                    |
 | --- | :------------: | ------------ | ----------------------------------------------------------- |
 | 1   |  consumer_id   | BIGINT       | 消费者的唯一 ID                                             |
 | 2   | consumer_group | BINARY(192)  | 消费者组                                                    |
 | 3   |   client_id    | BINARY(192)  | 用户自定义字符串，通过创建 consumer 时指定 client_id 来展示 |
 | 4   |     status     | BINARY(20)   | 消费者当前状态                                              |
 | 5   |     topics     | BINARY(204)  | 被订阅的 topic。若订阅多个 topic，则展示为多行              |
 | 6   |    up_time     | TIMESTAMP    | 第一次连接 taosd 的时间                                     |
 | 7   | subscribe_time | TIMESTAMP    | 上一次发起订阅的时间                                        |
 | 8   | rebalance_time | TIMESTAMP    | 上一次触发 rebalance 的时间                                 |
 ## PERF_SUBSCRIPTIONS
 | #   |    **列名**    | **数据类型** | **说明**                 |
 | --- | :------------: | ------------ | ------------------------ |
 | 1   |   topic_name   | BINARY(204)  | 被订阅的 topic           |
 | 2   | consumer_group | BINARY(193)  | 订阅者的消费者组         |
 | 3   |   vgroup_id    | INT          | 消费者被分配的 vgroup id |
 | 4   |  consumer_id   | BIGINT       | 消费者的唯一 id          |
 ## PERF_TRANS
 | #   |     **列名**     | **数据类型** | **说明** |
 | --- | :--------------: | ------------ | -------- |
 | 1   |        id        | INT          |          |
 | 2   |   create_time    | TIMESTAMP    |          |
 | 3   |      stage       | BINARY(12)   |          |
 | 4   |       db1        | BINARY(64)   |          |
 | 5   |       db2        | BINARY(64)   |          |
 | 6   |   failed_times   | INT          |          |
 | 7   |  last_exec_time  | TIMESTAMP    |          |
 | 8   | last_action_info | BINARY(511)  |          |
 ## PERF_SMAS
 | #   |  **列名**   | **数据类型** | **说明**                                    |
 | --- | :---------: | ------------ | ------------------------------------------- |
 | 1   |  sma_name   | BINARY(192)  | 时间维度的预计算 (time-range-wise sma) 名称 |
 | 2   | create_time | TIMESTAMP    | sma 创建时间                                |
 | 3   | stable_name | BINARY(192)  | sma 所属的超级表名称                        |
 | 4   |  vgroup_id  | INT          | sma 专属的 vgroup 名称                      |
 ## PERF_STREAMS
 | #   |   **列名**   | **数据类型** | **说明**                                |
 | --- | :----------: | ------------ | --------------------------------------- |
 | 1   | stream_name  | BINARY(64)   | 流计算名称                              |
 | 2   | create_time  | TIMESTAMP    | 创建时间                                |
 | 3   |     sql      | BINARY(1024) | 创建流计算时提供的 SQL 语句             |
 | 4   |    status    | BIANRY(20)   | 流当前状态                              |
 | 5   |  source_db   | BINARY(64)   | 源数据库                                |
 | 6   |  target_db   | BIANRY(64)   | 目的数据库                              |
 | 7   | target_table | BINARY(192)  | 流计算写入的目标表                      |
 | 8   |  watermark   | BIGINT       | watermark，详见 SQL 手册流式计算        |
 | 9   |   trigger    | INT          | 计算结果推送模式，详见 SQL 手册流式计算 |
--- a/docs/zh/14-reference/03-connector/03-connector.mdx
+++ b/docs/zh/14-reference/03-connector/03-connector.mdx
@ -10,14 +10,14 @@ TDengine 提供了丰富的应用程序开发接口，为了便于用户快速
 目前 TDengine 的原生接口连接器可支持的平台包括：X64/X86/ARM64/ARM32/MIPS/Alpha 等硬件平台，以及 Linux/Win64/Win32 等开发环境。对照矩阵如下：
-| **CPU**        | **OS**    | **JDBC** | **Python** | **Go** | **Node.js** | **C#** | **Rust** | C/C++ |
+| **CPU**        | **OS**    | **Java** | **Python** | **Go** | **Node.js** | **C#** | **Rust** | C/C++ |
 | -------------- | --------- | -------- | ---------- | ------ | ----------- | ------ | -------- | ----- |
 | **X86 64bit**  | **Linux** | ●        | ●          | ●      | ●           | ●      | ●        | ●     |
 | **X86 64bit**  | **Win64** | ●        | ●          | ●      | ●           | ●      | ●        | ●     |
 | **X86 64bit**  | **Win32** | ●        | ●          | ●      | ●           | ○      | ○        | ●     |
 | **X86 32bit**  | **Win32** | ○        | ○          | ○      | ○           | ○      | ○        | ●     |
 | **ARM64**      | **Linux** | ●        | ●          | ●      | ●           | ○      | ○        | ●     |
-| **ARM32**      | **Linux** | ●        | ●          | ●      | ●           | ○      | ○        | ●     |
+| **ARM32**      | **Linux** | ○        | ○          | ○      | ○           | ○      | ○        | ●     |
 | **MIPS 龙芯**  | **Linux** | ○        | ○          | ○      | ○           | ○      | ○        | ○     |
 | **Alpha 申威** | **Linux** | ○        | ○          | --     | --          | --     | --       | ○     |
 | **X86 海光**   | **Linux** | ○        | ○          | ○      | --          | --     | --       | ○     |
@ -32,6 +32,7 @@ TDengine 版本更新往往会增加新的功能特性，列表中的连接器
 | **TDengine 版本**     | **Java** | **Python** | **Go**       | **C#**        | **Node.js**     | **Rust** |
 | --------------------- | -------- | ---------- | ------------ | ------------- | --------------- | -------- |
 | **3.0.0.0 及以上**    | 3.0.0    | 当前版本   | 3.0 分支     | 3.0.0         | 3.0.0           | 当前版本 |
 | **2.4.0.14 及以上**   | 2.0.38   | 当前版本   | develop 分支 | 1.0.2 - 1.0.6 | 2.0.10 - 2.0.12 | 当前版本 |
 | **2.4.0.6 及以上**    | 2.0.37   | 当前版本   | develop 分支 | 1.0.2 - 1.0.6 | 2.0.10 - 2.0.12 | 当前版本 |
 | **2.4.0.4 - 2.4.0.5** | 2.0.37   | 当前版本   | develop 分支 | 1.0.2 - 1.0.6 | 2.0.10 - 2.0.12 | 当前版本 |
@ -48,9 +49,8 @@ TDengine 版本更新往往会增加新的功能特性，列表中的连接器
 | -------------- | -------- | ---------- | ------ | ------ | ----------- | -------- |
 | **连接管理**   | 支持     | 支持       | 支持   | 支持   | 支持        | 支持     |
 | **普通查询**   | 支持     | 支持       | 支持   | 支持   | 支持        | 支持     |
 | **连续查询**   | 支持     | 支持       | 支持   | 支持   | 支持        | 支持     |
 | **参数绑定**   | 支持     | 支持       | 支持   | 支持   | 支持        | 支持     |
-| **订阅功能**   | 支持     | 支持       | 支持   | 支持   | 支持        | 暂不支持 |
+| ** TMQ **      | 支持     | 支持       | 支持   | 支持   | 支持        | 支持     |
 | **Schemaless** | 支持     | 支持       | 支持   | 支持   | 支持        | 支持     |
 | **DataFrame**  | 不支持   | 支持       | 不支持 | 不支持 | 不支持      | 不支持   |
@ -58,17 +58,17 @@ TDengine 版本更新往往会增加新的功能特性，列表中的连接器
 由于不同编程语言数据库框架规范不同，并不意味着所有 C/C++ 接口都需要对应封装支持。
 :::
-### 使用 REST 接口
+### 使用 http (REST 或 WebSocket) 接口
 | **功能特性**                   | **Java** | **Python** | **Go**   | **C#（暂不支持）** | **Node.js** | **Rust** |
 | ------------------------------ | -------- | ---------- | -------- | ------------------ | ----------- | -------- |
 | **连接管理**                   | 支持     | 支持       | 支持     | N/A                | 支持        | 支持     |
 | **普通查询**                   | 支持     | 支持       | 支持     | N/A                | 支持        | 支持     |
 | **连续查询**                   | 支持     | 支持       | 支持     | N/A                | 支持        | 支持     |
-| **参数绑定**                   | 不支持   | 不支持     | 不支持   | N/A                | 不支持      | 不支持   |
+| **参数绑定**                   | 不支持   | 暂不支持   | 暂不支持 | N/A                | 不支持      | 支持     |
-| **订阅功能**                   | 不支持   | 不支持     | 不支持   | N/A                | 不支持      | 不支持   |
+| ** TMQ **                      | 不支持   | 暂不支持   | 暂不支持 | N/A                | 不支持      | 支持     |
-| **Schemaless**                 | 暂不支持 | 暂不支持   | 暂不支持 | N/A                | 暂不支持    | 暂不支持 |
+| **Schemaless**                 | 暂不支持 | 暂不支持   | 暂不支持 | N/A                | 不支持      | 暂不支持 |
-| **批量拉取（基于 WebSocket）** | 支持     | 暂不支持   | 暂不支持 | N/A                | 暂不支持    | 暂不支持 |
+| **批量拉取（基于 WebSocket）** | 支持     | 支持       | 暂不支持 | N/A                | 不支持      | 支持     |
 | **DataFrame**                  | 不支持   | 支持       | 不支持   | N/A                | 不支持      | 不支持   |
 :::warning
--- a/docs/zh/14-reference/08-taos-shell.md
+++ b/docs/zh/14-reference/08-taos-shell.md
@ -48,29 +48,30 @@ taos> SET MAX_BINARY_DISPLAY_WIDTH <nn>;
 您可通过配置命令行参数来改变 TDengine CLI 的行为。以下为常用的几个命令行参数：
- -h, --host=HOST: 要连接的 TDengine 服务端所在服务器的 FQDN, 默认为连接本地服务
+- -h HOST: 要连接的 TDengine 服务端所在服务器的 FQDN, 默认为连接本地服务
- -P, --port=PORT: 指定服务端所用端口号
+- -P PORT: 指定服务端所用端口号
- -u, --user=USER: 连接时使用的用户名
+- -u USER: 连接时使用的用户名
- -p, --password=PASSWORD: 连接服务端时使用的密码
+- -p PASSWORD: 连接服务端时使用的密码
 - -?, --help: 打印出所有命令行参数
 还有更多其他参数：
- -c, --config-dir: 指定配置文件目录，Linux 环境下默认为 `/etc/taos`，该目录下的配置文件默认名称为 `taos.cfg`
+- -a AUTHSTR: 连接服务端的授权信息
- -C, --dump-config: 打印 -c 指定的目录中 `taos.cfg` 的配置参数
+- -A: 通过用户名和密码计算授权信息
- -d, --database=DATABASE: 指定连接到服务端时使用的数据库
+- -c CONFIGDIR: 指定配置文件目录，Linux 环境下默认为 `/etc/taos`，该目录下的配置文件默认名称为 `taos.cfg`
- -D, --directory=DIRECTORY: 导入指定路径中的 SQL 脚本文件
+- -C: 打印 -c 指定的目录中 `taos.cfg` 的配置参数
- -f, --file=FILE: 以非交互模式执行 SQL 脚本文件。文件中一个 SQL 语句只能占一行
+- -d DATABASE: 指定连接到服务端时使用的数据库
- -k, --check=CHECK: 指定要检查的表
+- -f FILE: 以非交互模式执行 SQL 脚本文件。文件中一个 SQL 语句只能占一行
- -l, --pktlen=PKTLEN: 网络测试时使用的测试包大小
+- -k: 测试服务端运行状态，0: unavailable，1: network ok，2: service ok，3: service degraded，4: exiting
- -n, --netrole=NETROLE: 网络连接测试时的测试范围，默认为 `startup`, 可选值为 `client`、`server`、`rpc`、`startup`、`sync`、`speed` 和 `fqdn` 之一
+- -l PKTLEN: 网络测试时使用的测试包大小
- -r, --raw-time: 将时间输出出无符号 64 位整数类型(即 C 语音中 uint64_t)
+- -n NETROLE: 网络连接测试时的测试范围，默认为 `client`, 可选值为 `client`、`server`
- -s, --commands=COMMAND: 以非交互模式执行的 SQL 命令
+- -N PKTNUM: 网络测试时使用的测试包数量
- -S, --pkttype=PKTTYPE: 指定网络测试所用的包类型，默认为 TCP。只有 netrole 为 `speed` 时既可以指定为 TCP 也可以指定为 UDP
+- -r: 将时间输出出无符号 64 位整数类型(即 C 语音中 uint64_t)
- -T, --thread=THREADNUM: 以多线程模式导入数据时的线程数
+- -s COMMAND: 以非交互模式执行的 SQL 命令
- -s, --commands: 在不进入终端的情况下运行 TDengine 命令
+- -t: 测试服务端启动状态，状态同-k
- -z, --timezone=TIMEZONE: 指定时区，默认为本地时区
+- -w DISPLAYWIDTH: 客户端列显示宽度
- -V, --version: 打印出当前版本号
+- -z TIMEZONE: 指定时区，默认为本地时区
 - -V: 打印出当前版本号
 示例：
--- a/docs/zh/14-reference/09-support-platform/index.md
+++ b/docs/zh/14-reference/09-support-platform/index.md
@ -5,18 +5,11 @@ description: "TDengine 服务端、客户端和连接器支持的平台列表"
 ## TDengine 服务端支持的平台列表
-|              | **CentOS 7/8** | **Ubuntu 16/18/20** | **Other Linux** | **统信 UOS** | **银河/中标麒麟** | **凝思 V60/V80** | **华为 EulerOS** |
+|              | **Windows 10/11** | **CentOS 7.9/8** | **Ubuntu 18/20** | **Other Linux** | **统信 UOS** | **银河/中标麒麟** | **凝思 V60/V80** | **华为 EulerOS** |
-| ------------ | -------------- | ------------------- | --------------- | ------------ | ----------------- | ---------------- | ---------------- |
+| ------------ | ----------------- | ---------------- | ---------------- | --------------- | ------------ | ----------------- | ---------------- | ---------------- |
-| X64          | ●              | ●                   |                 | ○            | ●                 | ●                | ●                |
+| X64          | ●                 | ●                | ●                |                 | ●            | ●                 | ●                |                  |
-| 龙芯 MIPS64  |                |                     | ●               |              |                   |                  |                  |
+| 树莓派 ARM64 |                   |                  |                  | ●               |              |                   |                  |                  |
-| 鲲鹏 ARM64   |                | ○                   | ○               |              | ●                 |                  |                  |
+| 华为云 ARM64 |                   |                  |                  |                 |              |                   |                  | ●                |
 | 申威 Alpha64 |                |                     | ○               | ●            |                   |                  |                  |
 | 飞腾 ARM64   |                | ○ 优麒麟            |                 |              |                   |                  |                  |
 | 海光 X64     | ●              | ●                   | ●               | ○            | ●                 | ●                |                  |
 | 瑞芯微 ARM64 |                |                     | ○               |              |                   |                  |                  |
 | 全志 ARM64   |                |                     | ○               |              |                   |                  |                  |
 | 炬力 ARM64   |                |                     | ○               |              |                   |                  |                  |
 | 华为云 ARM64 |                |                     |                 |              |                   |                  | ●                |
 注： ● 表示经过官方测试验证， ○ 表示非官方测试验证。
--- a/docs/zh/14-reference/12-directory.md
+++ b/docs/zh/14-reference/12-directory.md
@ -25,7 +25,6 @@ TDengine 的所有可执行文件默认存放在 _/usr/local/taos/bin_ 目录下
 - _taosBenchmark_：TDengine 测试工具
 - _remove.sh_：卸载 TDengine 的脚本，请谨慎执行，链接到/usr/bin 目录下的**rmtaos**命令。会删除 TDengine 的安装目录/usr/local/taos，但会保留/etc/taos、/var/lib/taos、/var/log/taos
 - _taosadapter_: 提供 RESTful 服务和接受其他多种软件写入请求的服务端可执行文件
 - _tarbitrator_: 提供双节点集群部署的仲裁功能
 - _TDinsight.sh_：用于下载 TDinsight 并安装的脚本
 - _set_core.sh_：用于方便调试设置系统生成 core dump 文件的脚本
 - _taosd-dump-cfg.gdb_：用于方便调试 taosd 的 gdb 执行脚本。
--- a/examples/c/tmq.c
+++ b/examples/c/tmq.c
@ -21,17 +21,17 @@
 #include "taos.h"
 static int  running = 1;
-static char dbName[64]    = "tmqdb";
+static char dbName[64] = "tmqdb";
-static char stbName[64]   = "stb";
+static char stbName[64] = "stb";
 static char topicName[64] = "topicname";
 static int32_t msg_process(TAOS_RES* msg) {
-  char buf[1024];
+  char    buf[1024];
  int32_t rows = 0;
  const char* topicName = tmq_get_topic_name(msg);
-  const char* dbName    = tmq_get_db_name(msg);
+  const char* dbName = tmq_get_db_name(msg);
-  int32_t     vgroupId  = tmq_get_vgroup_id(msg);
+  int32_t     vgroupId = tmq_get_vgroup_id(msg);
  printf("topic: %s\n", topicName);
  printf("db: %s\n", dbName);
@ -41,14 +41,14 @@ static int32_t msg_process(TAOS_RES* msg) {
    TAOS_ROW row = taos_fetch_row(msg);
    if (row == NULL) break;
-    TAOS_FIELD* fields      = taos_fetch_fields(msg);
+    TAOS_FIELD* fields = taos_fetch_fields(msg);
    int32_t     numOfFields = taos_field_count(msg);
-    int32_t*    length      = taos_fetch_lengths(msg);
+    int32_t*    length = taos_fetch_lengths(msg);
-    int32_t     precision   = taos_result_precision(msg);
+    int32_t     precision = taos_result_precision(msg);
-    const char* tbName      = tmq_get_table_name(msg);
+    const char* tbName = tmq_get_table_name(msg);
-	rows++; 
+    rows++;
    taos_print_row(buf, row, fields, numOfFields);
-    printf("row content from %s: %s\n", (tbName != NULL ? tbName : "null table"), buf);
+    printf("row content from %s: %s\n", (tbName != NULL ? tbName : "table null"), buf);
  }
  return rows;
@ -80,7 +80,8 @@ static int32_t init_env() {
  // create super table
  printf("create super table\n");
-  pRes = taos_query(pConn, "create table tmqdb.stb (ts timestamp, c1 int, c2 float, c3 varchar(16)) tags(t1 int, t3 varchar(16))");
+  pRes = taos_query(
      pConn, "create table tmqdb.stb (ts timestamp, c1 int, c2 float, c3 varchar(16)) tags(t1 int, t3 varchar(16))");
  if (taos_errno(pRes) != 0) {
    printf("failed to create super table stb, reason:%s\n", taos_errstr(pRes));
    return -1;
@ -166,7 +167,6 @@ int32_t create_topic() {
  }
  taos_free_result(pRes);
  //  pRes = taos_query(pConn, "create topic topic_ctb_column with meta as database abc1");
  pRes = taos_query(pConn, "create topic topicname as select ts, c1, c2, c3 from tmqdb.stb where c1 > 1");
  if (taos_errno(pRes) != 0) {
    printf("failed to create topic topicname, reason:%s\n", taos_errstr(pRes));
@ -184,26 +184,28 @@ void tmq_commit_cb_print(tmq_t* tmq, int32_t code, void* param) {
 tmq_t* build_consumer() {
  tmq_conf_res_t code;
-  tmq_conf_t* conf = tmq_conf_new();
+  tmq_conf_t*    conf = tmq_conf_new();
  code = tmq_conf_set(conf, "enable.auto.commit", "true");
  if (TMQ_CONF_OK != code) return NULL;
  code = tmq_conf_set(conf, "auto.commit.interval.ms", "1000");
  if (TMQ_CONF_OK != code) return NULL;
  code = tmq_conf_set(conf, "group.id", "cgrpName");
  if (TMQ_CONF_OK != code) return NULL;
  code = tmq_conf_set(conf, "client.id", "user defined name");
  if (TMQ_CONF_OK != code) return NULL;
  code = tmq_conf_set(conf, "td.connect.user", "root");
  if (TMQ_CONF_OK != code) return NULL;
  code = tmq_conf_set(conf, "td.connect.pass", "taosdata");
  if (TMQ_CONF_OK != code) return NULL;
-  code = tmq_conf_set(conf, "auto.offset.reset", "earliest");	
+  code = tmq_conf_set(conf, "auto.offset.reset", "earliest");
  if (TMQ_CONF_OK != code) return NULL;
  code = tmq_conf_set(conf, "experimental.snapshot.enable", "true");
  if (TMQ_CONF_OK != code) return NULL;
  code = tmq_conf_set(conf, "msg.with.table.name", "true");
  if (TMQ_CONF_OK != code) return NULL;
-  
+
-  tmq_conf_set_auto_commit_cb(conf, tmq_commit_cb_print, NULL);	
+  tmq_conf_set_auto_commit_cb(conf, tmq_commit_cb_print, NULL);
-  
+
  tmq_t* tmq = tmq_consumer_new(conf, NULL, 0);
  tmq_conf_destroy(conf);
  return tmq;
@ -211,7 +213,7 @@ tmq_t* build_consumer() {
 tmq_list_t* build_topic_list() {
  tmq_list_t* topicList = tmq_list_new();
-  int32_t code = tmq_list_append(topicList, "topicname");
+  int32_t     code = tmq_list_append(topicList, "topicname");
  if (code) {
    return NULL;
  }
@ -228,18 +230,18 @@ void basic_consume_loop(tmq_t* tmq, tmq_list_t* topicList) {
  int32_t totalRows = 0;
  int32_t msgCnt = 0;
-  int32_t consumeDelay = 5000;
+  int32_t timeout = 5000;
  while (running) {
-    TAOS_RES* tmqmsg = tmq_consumer_poll(tmq, consumeDelay);
+    TAOS_RES* tmqmsg = tmq_consumer_poll(tmq, timeout);
    if (tmqmsg) {
      msgCnt++;
      totalRows += msg_process(tmqmsg);
      taos_free_result(tmqmsg);
-    } else {
+      /*} else {*/
-      break;
+      /*break;*/
-	}
+    }
  }
-  
+
  fprintf(stderr, "%d msg consumed, include %d rows\n", msgCnt, totalRows);
 }
@ -256,32 +258,30 @@ int main(int argc, char* argv[]) {
  tmq_t* tmq = build_consumer();
  if (NULL == tmq) {
-  	fprintf(stderr, "%% build_consumer() fail!\n");
+    fprintf(stderr, "%% build_consumer() fail!\n");
    return -1;
  }
  tmq_list_t* topic_list = build_topic_list();
  if (NULL == topic_list) {
    return -1;
-  }  
+  }
-  
+
  basic_consume_loop(tmq, topic_list);
  code = tmq_unsubscribe(tmq);
  if (code) {
    fprintf(stderr, "%% Failed to unsubscribe: %s\n", tmq_err2str(code));
-  }
+  } else {
  else {
    fprintf(stderr, "%% unsubscribe\n");
  }
  code = tmq_consumer_close(tmq);
  if (code) {
    fprintf(stderr, "%% Failed to close consumer: %s\n", tmq_err2str(code));
-  }
+  } else {
  else {
    fprintf(stderr, "%% Consumer closed\n");
  }
-  
+
  return 0;
 }
--- a/examples/rust
+++ b/examples/rust
@ -1 +0,0 @@
 Subproject commit 7ed7a97715388fa144718764d6bf20f9bfc29a12
--- a/include/client/taos.h
+++ b/include/client/taos.h
@ -196,15 +196,6 @@ DLL_EXPORT void        taos_fetch_rows_a(TAOS_RES *res, __taos_async_fn_t fp, vo
 DLL_EXPORT void        taos_fetch_raw_block_a(TAOS_RES *res, __taos_async_fn_t fp, void *param);
 DLL_EXPORT const void *taos_get_raw_block(TAOS_RES *res);
 // Shuduo: temporary enable for app build
 #if 1
 typedef void (*__taos_sub_fn_t)(TAOS_SUB *tsub, TAOS_RES *res, void *param, int code);
 DLL_EXPORT TAOS_SUB *taos_subscribe(TAOS *taos, int restart, const char *topic, const char *sql, __taos_sub_fn_t fp,
                                    void *param, int interval);
 DLL_EXPORT TAOS_RES *taos_consume(TAOS_SUB *tsub);
 DLL_EXPORT void      taos_unsubscribe(TAOS_SUB *tsub, int keepProgress);
 #endif
 DLL_EXPORT int       taos_load_table_info(TAOS *taos, const char *tableNameList);
 DLL_EXPORT TAOS_RES *taos_schemaless_insert(TAOS *taos, char *lines[], int numLines, int protocol, int precision);
@ -281,10 +272,6 @@ DLL_EXPORT const char   *tmq_get_table_name(TAOS_RES *res);
 /* ------------------------------ TMQ END -------------------------------- */
 #if 1  // Shuduo: temporary enable for app build
 typedef void (*TAOS_SUBSCRIBE_CALLBACK)(TAOS_SUB *tsub, TAOS_RES *res, void *param, int code);
 #endif
 typedef enum {
  TSDB_SRV_STATUS_UNAVAILABLE = 0,
  TSDB_SRV_STATUS_NETWORK_OK = 1,
--- a/include/common/tcommon.h
+++ b/include/common/tcommon.h
@ -103,12 +103,12 @@ typedef struct SDataBlockInfo {
  int16_t     hasVarCol;
  uint32_t    capacity;
  // TODO: optimize and remove following
-  int64_t     version;  // used for stream, and need serialization
+  int64_t     version;    // used for stream, and need serialization
-  int64_t     ts;       // used for stream, and need serialization
+  int64_t     ts;         // used for stream, and need serialization
-  int32_t     childId;  // used for stream, do not serialize
+  int32_t     childId;    // used for stream, do not serialize
-  EStreamType type;     // used for stream, do not serialize
+  EStreamType type;       // used for stream, do not serialize
-  STimeWindow calWin;   // used for stream, do not serialize
+  STimeWindow calWin;     // used for stream, do not serialize
-  TSKEY       watermark;// used for stream
+  TSKEY       watermark;  // used for stream
 } SDataBlockInfo;
 typedef struct SSDataBlock {
@ -268,6 +268,15 @@ typedef struct SSortExecInfo {
  int32_t readBytes;   // read io bytes
 } SSortExecInfo;
 // stream special block column
 #define START_TS_COLUMN_INDEX           0
 #define END_TS_COLUMN_INDEX             1
 #define UID_COLUMN_INDEX                2
 #define GROUPID_COLUMN_INDEX            3
 #define CALCULATE_START_TS_COLUMN_INDEX 4
 #define CALCULATE_END_TS_COLUMN_INDEX   5
 #ifdef __cplusplus
 }
 #endif
--- a/include/common/tdataformat.h
+++ b/include/common/tdataformat.h
@ -200,8 +200,6 @@ struct STag {
 #if 1  //================================================================================================================================================
 // Imported since 3.0 and use bitmap to demonstrate None/Null/Norm, while use Null/Norm below 3.0 without of bitmap.
 #define TD_SUPPORT_BITMAP
 #define TD_SUPPORT_READ2
 #define TD_SUPPORT_BACK2  // suppport back compatibility of 2.0
 #define TASSERT(x) ASSERT(x)
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@ -1369,8 +1369,8 @@ typedef struct {
  int32_t numOfCols;
  int64_t skey;
  int64_t ekey;
-  int64_t version;  // for stream
+  int64_t version;    // for stream
-  TSKEY   watermark;// for stream
+  TSKEY   watermark;  // for stream
  char    data[];
 } SRetrieveTableRsp;
@ -3080,6 +3080,22 @@ typedef struct SDeleteRes {
 int32_t tEncodeDeleteRes(SEncoder* pCoder, const SDeleteRes* pRes);
 int32_t tDecodeDeleteRes(SDecoder* pCoder, SDeleteRes* pRes);
 typedef struct {
  int64_t uid;
  int64_t ts;
 } SSingleDeleteReq;
 int32_t tEncodeSSingleDeleteReq(SEncoder* pCoder, const SSingleDeleteReq* pReq);
 int32_t tDecodeSSingleDeleteReq(SDecoder* pCoder, SSingleDeleteReq* pReq);
 typedef struct {
  int64_t suid;
  SArray* deleteReqs;  // SArray<SSingleDeleteReq>
 } SBatchDeleteReq;
 int32_t tEncodeSBatchDeleteReq(SEncoder* pCoder, const SBatchDeleteReq* pReq);
 int32_t tDecodeSBatchDeleteReq(SDecoder* pCoder, SBatchDeleteReq* pReq);
 typedef struct {
  int32_t msgIdx;
  int32_t msgType;
--- a/include/common/tmsgdef.h
+++ b/include/common/tmsgdef.h
@ -202,6 +202,7 @@ enum {
  TD_DEF_MSG_TYPE(TDMT_VND_SUBMIT_RSMA, "vnode-submit-rsma", SSubmitReq, SSubmitRsp)
  TD_DEF_MSG_TYPE(TDMT_VND_FETCH_RSMA, "vnode-fetch-rsma", SRSmaFetchMsg, NULL)
  TD_DEF_MSG_TYPE(TDMT_VND_DELETE, "delete-data", SVDeleteReq, SVDeleteRsp)
  TD_DEF_MSG_TYPE(TDMT_VND_BATCH_DEL, "batch-delete", SBatchDeleteReq, NULL)
  TD_DEF_MSG_TYPE(TDMT_VND_ALTER_CONFIG, "alter-config", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_VND_ALTER_REPLICA, "alter-replica", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_VND_ALTER_CONFIRM, "alter-confirm", NULL, NULL)
--- a/include/common/trow.h
+++ b/include/common/trow.h
@ -319,21 +319,17 @@ typedef struct {
  col_id_t  kvIdx;   // [0, nKvCols)
 } STSRowIter;
-void    tdSTSRowIterReset(STSRowIter *pIter, STSRow *pRow);
+void tdSTSRowIterInit(STSRowIter *pIter, STSchema *pSchema);
-void    tdSTSRowIterInit(STSRowIter *pIter, STSchema *pSchema);
+void tdSTSRowIterReset(STSRowIter *pIter, STSRow *pRow);
 bool tdSTSRowIterFetch(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCellVal *pVal);
 bool tdSTSRowIterNext(STSRowIter *pIter, SCellVal *pVal);
 int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow);
 bool    tdSTSRowGetVal(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCellVal *pVal);
 bool    tdGetTpRowDataOfCol(STSRowIter *pIter, col_type_t colType, int32_t offset, SCellVal *pVal);
 bool    tdGetKvRowValOfColEx(STSRowIter *pIter, col_id_t colId, col_type_t colType, col_id_t *nIdx, SCellVal *pVal);
 bool    tdSTSRowIterNext(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCellVal *pVal);
 bool    tdSTpRowGetVal(STSRow *pRow, col_id_t colId, col_type_t colType, int32_t flen, uint32_t offset, col_id_t colIdx,
                       SCellVal *pVal);
 bool    tdSKvRowGetVal(STSRow *pRow, col_id_t colId, col_id_t colIdx, SCellVal *pVal);
 void    tdSCellValPrint(SCellVal *pVal, int8_t colType);
 void    tdSRowPrint(STSRow *row, STSchema *pSchema, const char *tag);
 #ifdef __cplusplus
 }
 #endif
-#endif /*_TD_COMMON_ROW_H_*/
+#endif /*_TD_COMMON_ROW_H_*/
--- a/include/libs/function/function.h
+++ b/include/libs/function/function.h
@ -54,10 +54,6 @@ typedef struct SFuncExecFuncs {
  FExecCombine combine;
 } SFuncExecFuncs;
 typedef struct SFileBlockInfo {
  int32_t numBlocksOfStep;
 } SFileBlockInfo;
 #define MAX_INTERVAL_TIME_WINDOW  1000000  // maximum allowed time windows in final results
 #define TOP_BOTTOM_QUERY_LIMIT    100
@ -171,8 +167,6 @@ typedef struct tExprNode {
  };
 } tExprNode;
 void tExprTreeDestroy(tExprNode *pNode, void (*fp)(void *));
 struct SScalarParam {
  bool             colAlloced;
  SColumnInfoData *columnData;
@ -182,14 +176,10 @@ struct SScalarParam {
  int32_t          numOfRows;
 };
-int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionId, int32_t param, SResultDataInfo* pInfo, int16_t extLength,
+void    cleanupResultRowEntry(struct SResultRowEntryInfo* pCell);
                          bool isSuperTable);
 void resetResultRowEntryResult(SqlFunctionCtx* pCtx, int32_t num);
 void cleanupResultRowEntry(struct SResultRowEntryInfo* pCell);
 int32_t getNumOfResult(SqlFunctionCtx* pCtx, int32_t num, SSDataBlock* pResBlock);
-bool isRowEntryCompleted(struct SResultRowEntryInfo* pEntry);
+bool    isRowEntryCompleted(struct SResultRowEntryInfo* pEntry);
-bool isRowEntryInitialized(struct SResultRowEntryInfo* pEntry);
+bool    isRowEntryInitialized(struct SResultRowEntryInfo* pEntry);
 typedef struct SPoint {
  int64_t key;
--- a/include/libs/stream/tstream.h
+++ b/include/libs/stream/tstream.h
@ -34,6 +34,8 @@ typedef struct SStreamTask SStreamTask;
 enum {
  STREAM_STATUS__NORMAL = 0,
  STREAM_STATUS__STOP,
  STREAM_STATUS__FAILED,
  STREAM_STATUS__RECOVER,
 };
@ -118,7 +120,7 @@ typedef struct {
  int64_t sourceVer;
  int64_t reqId;
-  SArray* blocks;  // SArray<SSDataBlock*>
+  SArray* blocks;  // SArray<SSDataBlock>
 } SStreamDataBlock;
 typedef struct {
--- a/include/libs/sync/sync.h
+++ b/include/libs/sync/sync.h
@ -129,6 +129,9 @@ typedef struct SSyncFSM {
  void (*FpReConfigCb)(struct SSyncFSM* pFsm, const SRpcMsg* pMsg, SReConfigCbMeta cbMeta);
  void (*FpLeaderTransferCb)(struct SSyncFSM* pFsm, const SRpcMsg* pMsg, SFsmCbMeta cbMeta);
  void (*FpBecomeLeaderCb)(struct SSyncFSM* pFsm);
  void (*FpBecomeFollowerCb)(struct SSyncFSM* pFsm);
  int32_t (*FpGetSnapshot)(struct SSyncFSM* pFsm, SSnapshot* pSnapshot, void* pReaderParam, void** ppReader);
  int32_t (*FpGetSnapshotInfo)(struct SSyncFSM* pFsm, SSnapshot* pSnapshot);
--- a/include/util/taoserror.h
+++ b/include/util/taoserror.h
@ -284,11 +284,13 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_MND_CONSUMER_NOT_READY        TAOS_DEF_ERROR_CODE(0, 0x03EA)
 #define TSDB_CODE_MND_TOPIC_SUBSCRIBED          TAOS_DEF_ERROR_CODE(0, 0x03EB)
 #define TSDB_CODE_MND_CGROUP_USED               TAOS_DEF_ERROR_CODE(0, 0x03EC)
 #define TSDB_CODE_MND_TOPIC_MUST_BE_DELETED     TAOS_DEF_ERROR_CODE(0, 0x03ED)
 // mnode-stream
 #define TSDB_CODE_MND_STREAM_ALREADY_EXIST      TAOS_DEF_ERROR_CODE(0, 0x03F0)
 #define TSDB_CODE_MND_STREAM_NOT_EXIST          TAOS_DEF_ERROR_CODE(0, 0x03F1)
 #define TSDB_CODE_MND_INVALID_STREAM_OPTION     TAOS_DEF_ERROR_CODE(0, 0x03F2)
 #define TSDB_CODE_MND_STREAM_MUST_BE_DELETED    TAOS_DEF_ERROR_CODE(0, 0x03F3)
 // mnode-sma
 #define TSDB_CODE_MND_SMA_ALREADY_EXIST         TAOS_DEF_ERROR_CODE(0, 0x0480)
@ -619,6 +621,7 @@ int32_t* taosGetErrno();
 //tmq
 #define TSDB_CODE_TMQ_INVALID_MSG                TAOS_DEF_ERROR_CODE(0, 0x4000)
 #define TSDB_CODE_TMQ_CONSUMER_MISMATCH          TAOS_DEF_ERROR_CODE(0, 0x4001)
 #ifdef __cplusplus
 }
--- a/source/client/src/TSDBJNIConnector.c
+++ b/source/client/src/TSDBJNIConnector.c
@ -611,65 +611,6 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_closeConnectionIm
  }
 }
 JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_subscribeImp(JNIEnv *env, jobject jobj, jlong con,
                                                                             jboolean restart, jstring jtopic,
                                                                             jstring jsql, jint jinterval) {
  jlong sub = 0;
  TAOS *taos = (TAOS *)con;
  char *topic = NULL;
  char *sql = NULL;
  jniGetGlobalMethod(env);
  jniDebug("jobj:%p, in TSDBJNIConnector_subscribeImp", jobj);
  if (jtopic != NULL) {
    topic = (char *)(*env)->GetStringUTFChars(env, jtopic, NULL);
  }
  if (jsql != NULL) {
    sql = (char *)(*env)->GetStringUTFChars(env, jsql, NULL);
  }
  if (topic == NULL || sql == NULL) {
    jniDebug("jobj:%p, invalid argument: topic or sql is NULL", jobj);
    return sub;
  }
  TAOS_SUB *tsub = taos_subscribe(taos, (int)restart, topic, sql, NULL, NULL, jinterval);
  sub = (jlong)tsub;
  if (sub == 0) {
    jniDebug("jobj:%p, failed to subscribe: topic:%s", jobj, topic);
  } else {
    jniDebug("jobj:%p, successfully subscribe: topic: %s", jobj, topic);
  }
  (*env)->ReleaseStringUTFChars(env, jtopic, topic);
  (*env)->ReleaseStringUTFChars(env, jsql, sql);
  return sub;
 }
 JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_consumeImp(JNIEnv *env, jobject jobj, jlong sub) {
  jniDebug("jobj:%p, in TSDBJNIConnector_consumeImp, sub:%lld", jobj, sub);
  jniGetGlobalMethod(env);
  TAOS_SUB *tsub = (TAOS_SUB *)sub;
  TAOS_RES *res = taos_consume(tsub);
  if (res == NULL) {
    jniError("jobj:%p, tsub:%p, taos_consume returns NULL", jobj, tsub);
    return 0l;
  }
  return (jlong)res;
 }
 JNIEXPORT void JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_unsubscribeImp(JNIEnv *env, jobject jobj, jlong sub,
                                                                              jboolean keepProgress) {
  TAOS_SUB *tsub = (TAOS_SUB *)sub;
  taos_unsubscribe(tsub, keepProgress);
 }
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_validateCreateTableSqlImp(JNIEnv *env, jobject jobj,
                                                                                         jlong con, jbyteArray jsql) {
  TAOS *tscon = (TAOS *)con;
@ -1087,4 +1028,4 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_schemalessInsert
    return JNI_OUT_OF_MEMORY;
  }
  return (jlong)tres;
-}
+}
--- a/source/client/src/clientMain.c
+++ b/source/client/src/clientMain.c
@ -939,21 +939,6 @@ const void *taos_get_raw_block(TAOS_RES *res) {
  return pRequest->body.resInfo.pData;
 }
 TAOS_SUB *taos_subscribe(TAOS *taos, int restart, const char *topic, const char *sql, TAOS_SUBSCRIBE_CALLBACK fp,
                         void *param, int interval) {
  // TODO
  return NULL;
 }
 TAOS_RES *taos_consume(TAOS_SUB *tsub) {
  // TODO
  return NULL;
 }
 void taos_unsubscribe(TAOS_SUB *tsub, int keepProgress) {
  // TODO
 }
 int taos_load_table_info(TAOS *taos, const char *tableNameList) {
  if (NULL == taos) {
    terrno = TSDB_CODE_TSC_DISCONNECTED;
--- a/source/client/src/tmq.c
+++ b/source/client/src/tmq.c
@ -122,6 +122,7 @@ enum {
  TMQ_CONSUMER_STATUS__INIT = 0,
  TMQ_CONSUMER_STATUS__READY,
  TMQ_CONSUMER_STATUS__NO_TOPIC,
  TMQ_CONSUMER_STATUS__RECOVER,
 };
 enum {
@ -134,10 +135,8 @@ typedef struct {
  // statistics
  int64_t pollCnt;
  // offset
-  /*int64_t      committedOffset;*/
+  STqOffsetVal committedOffset;
-  /*int64_t      currentOffset;*/
+  STqOffsetVal currentOffset;
  STqOffsetVal committedOffsetNew;
  STqOffsetVal currentOffsetNew;
  // connection info
  int32_t vgId;
  int32_t vgStatus;
@ -152,7 +151,6 @@ typedef struct {
  SArray* vgs;  // SArray<SMqClientVg>
  int8_t         isSchemaAdaptive;
  SSchemaWrapper schema;
 } SMqClientTopic;
@ -190,10 +188,9 @@ typedef struct {
 } SMqPollCbParam;
 typedef struct {
-  tmq_t* tmq;
+  tmq_t*         tmq;
-  int8_t automatic;
+  int8_t         automatic;
-  int8_t async;
+  int8_t         async;
  /*int8_t         freeOffsets;*/
  int32_t        waitingRspNum;
  int32_t        totalRspNum;
  int32_t        rspErr;
@ -207,7 +204,7 @@ typedef struct {
 typedef struct {
  SMqCommitCbParamSet* params;
  STqOffset*           pOffset;
-} SMqCommitCbParam2;
+} SMqCommitCbParam;
 tmq_conf_t* tmq_conf_new() {
  tmq_conf_t* conf = taosMemoryCalloc(1, sizeof(tmq_conf_t));
@ -215,6 +212,7 @@ tmq_conf_t* tmq_conf_new() {
  conf->autoCommit = true;
  conf->autoCommitInterval = 5000;
  conf->resetOffset = TMQ_CONF__RESET_OFFSET__EARLIEAST;
  conf->hbBgEnable = true;
  return conf;
 }
@ -371,8 +369,8 @@ static int32_t tmqMakeTopicVgKey(char* dst, const char* topicName, int32_t vg) {
  return sprintf(dst, "%s:%d", topicName, vg);
 }
-int32_t tmqCommitCb2(void* param, SDataBuf* pBuf, int32_t code) {
+int32_t tmqCommitCb(void* param, SDataBuf* pBuf, int32_t code) {
-  SMqCommitCbParam2*   pParam = (SMqCommitCbParam2*)param;
+  SMqCommitCbParam*    pParam = (SMqCommitCbParam*)param;
  SMqCommitCbParamSet* pParamSet = (SMqCommitCbParamSet*)pParam->params;
  // push into array
 #if 0
@ -418,7 +416,7 @@ static int32_t tmqSendCommitReq(tmq_t* tmq, SMqClientVg* pVg, SMqClientTopic* pT
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    return -1;
  }
-  pOffset->val = pVg->currentOffsetNew;
+  pOffset->val = pVg->currentOffset;
  int32_t groupLen = strlen(tmq->groupId);
  memcpy(pOffset->subKey, tmq->groupId, groupLen);
@ -443,7 +441,7 @@ static int32_t tmqSendCommitReq(tmq_t* tmq, SMqClientVg* pVg, SMqClientTopic* pT
  tEncodeSTqOffset(&encoder, pOffset);
  // build param
-  SMqCommitCbParam2* pParam = taosMemoryCalloc(1, sizeof(SMqCommitCbParam2));
+  SMqCommitCbParam* pParam = taosMemoryCalloc(1, sizeof(SMqCommitCbParam));
  pParam->params = pParamSet;
  pParam->pOffset = pOffset;
@ -462,13 +460,13 @@ static int32_t tmqSendCommitReq(tmq_t* tmq, SMqClientVg* pVg, SMqClientTopic* pT
           pVg->vgId, pOffset->val.version);
  // TODO: put into cb
-  pVg->committedOffsetNew = pVg->currentOffsetNew;
+  pVg->committedOffset = pVg->currentOffset;
  pMsgSendInfo->requestId = generateRequestId();
  pMsgSendInfo->requestObjRefId = 0;
  pMsgSendInfo->param = pParam;
  pMsgSendInfo->paramFreeFp = taosMemoryFree;
-  pMsgSendInfo->fp = tmqCommitCb2;
+  pMsgSendInfo->fp = tmqCommitCb;
  pMsgSendInfo->msgType = TDMT_VND_MQ_COMMIT_OFFSET;
  // send msg
@ -504,7 +502,6 @@ int32_t tmqCommitMsgImpl(tmq_t* tmq, const TAOS_RES* msg, int8_t async, tmq_comm
  pParamSet->tmq = tmq;
  pParamSet->automatic = 0;
  pParamSet->async = async;
  /*pParamSet->freeOffsets = 1;*/
  pParamSet->userCb = userCb;
  pParamSet->userParam = userParam;
  tsem_init(&pParamSet->rspSem, 0, 0);
@ -518,7 +515,7 @@ int32_t tmqCommitMsgImpl(tmq_t* tmq, const TAOS_RES* msg, int8_t async, tmq_comm
      SMqClientVg* pVg = taosArrayGet(pTopic->vgs, j);
      if (pVg->vgId != vgId) continue;
-      if (pVg->currentOffsetNew.type > 0 && !tOffsetEqual(&pVg->currentOffsetNew, &pVg->committedOffsetNew)) {
+      if (pVg->currentOffset.type > 0 && !tOffsetEqual(&pVg->currentOffset, &pVg->committedOffset)) {
        if (tmqSendCommitReq(tmq, pVg, pTopic, pParamSet) < 0) {
          goto FAIL;
        }
@ -550,8 +547,8 @@ FAIL:
  return 0;
 }
-int32_t tmqCommitInner2(tmq_t* tmq, const TAOS_RES* msg, int8_t automatic, int8_t async, tmq_commit_cb* userCb,
+int32_t tmqCommitInner(tmq_t* tmq, const TAOS_RES* msg, int8_t automatic, int8_t async, tmq_commit_cb* userCb,
-                        void* userParam) {
+                       void* userParam) {
  int32_t code = -1;
  if (msg != NULL) {
@ -566,7 +563,6 @@ int32_t tmqCommitInner2(tmq_t* tmq, const TAOS_RES* msg, int8_t automatic, int8_
  pParamSet->tmq = tmq;
  pParamSet->automatic = automatic;
  pParamSet->async = async;
  /*pParamSet->freeOffsets = 1;*/
  pParamSet->userCb = userCb;
  pParamSet->userParam = userParam;
  tsem_init(&pParamSet->rspSem, 0, 0);
@ -583,7 +579,9 @@ int32_t tmqCommitInner2(tmq_t* tmq, const TAOS_RES* msg, int8_t automatic, int8_
      tscDebug("consumer:%" PRId64 ", begin commit for topic %s, vgId:%d", tmq->consumerId, pTopic->topicName,
               pVg->vgId);
-      if (pVg->currentOffsetNew.type > 0 && !tOffsetEqual(&pVg->currentOffsetNew, &pVg->committedOffsetNew)) {
+      if (pVg->currentOffset.type > 0 && !tOffsetEqual(&pVg->currentOffset, &pVg->committedOffset)) {
        tscDebug("consumer: %ld, vg:%d, current %ld, committed %ld", tmq->consumerId, pVg->vgId,
                 pVg->currentOffset.version, pVg->committedOffset.version);
        if (tmqSendCommitReq(tmq, pVg, pTopic, pParamSet) < 0) {
          continue;
        }
@ -699,7 +697,7 @@ int32_t tmqHandleAllDelayedTask(tmq_t* tmq) {
      tmqAskEp(tmq, true);
      taosTmrReset(tmqAssignAskEpTask, 1000, tmq, tmqMgmt.timer, &tmq->epTimer);
    } else if (*pTaskType == TMQ_DELAYED_TASK__COMMIT) {
-      tmqCommitInner2(tmq, NULL, 1, 1, tmq->commitCb, tmq->commitCbUserParam);
+      tmqCommitInner(tmq, NULL, 1, 1, tmq->commitCb, tmq->commitCbUserParam);
      taosTmrReset(tmqAssignDelayedCommitTask, tmq->autoCommitInterval, tmq, tmqMgmt.timer, &tmq->commitTimer);
    } else if (*pTaskType == TMQ_DELAYED_TASK__REPORT) {
    } else {
@ -888,12 +886,6 @@ FAIL:
  return NULL;
 }
 #if 0
 int32_t tmq_commit(tmq_t* tmq, const tmq_topic_vgroup_list_t* offsets, int32_t async) {
  return tmqCommitInner2(tmq, offsets, 0, async, tmq->commitCb, tmq->commitCbUserParam);
 }
 #endif
 int32_t tmq_subscribe(tmq_t* tmq, const tmq_list_t* topic_list) {
  const SArray*   container = &topic_list->container;
  int32_t         sz = taosArrayGetSize(container);
@ -967,7 +959,11 @@ int32_t tmq_subscribe(tmq_t* tmq, const tmq_list_t* topic_list) {
  code = param.rspErr;
  if (code != 0) goto FAIL;
  int32_t retryCnt = 0;
  while (TSDB_CODE_MND_CONSUMER_NOT_READY == tmqAskEp(tmq, false)) {
    if (retryCnt++ > 10) {
      goto FAIL;
    }
    tscDebug("consumer not ready, retry");
    taosMsleep(500);
  }
@ -1006,8 +1002,12 @@ int32_t tmqPollCb(void* param, SDataBuf* pMsg, int32_t code) {
  int32_t         epoch = pParam->epoch;
  taosMemoryFree(pParam);
  if (code != 0) {
-    tscWarn("msg discard from vgId:%d, epoch %d, code:%x", vgId, epoch, code);
+    tscWarn("msg discard from vgId:%d, epoch %d, since %s", vgId, epoch, terrstr());
-    if (pMsg->pData) taosMemoryFreeClear(pMsg->pData);
+    if (pMsg->pData) taosMemoryFree(pMsg->pData);
    if (code == TSDB_CODE_TMQ_CONSUMER_MISMATCH) {
      atomic_store_8(&tmq->status, TMQ_CONSUMER_STATUS__RECOVER);
      goto CREATE_MSG_FAIL;
    }
    if (code == TSDB_CODE_TQ_NO_COMMITTED_OFFSET) {
      SMqPollRspWrapper* pRspWrapper = taosAllocateQitem(sizeof(SMqPollRspWrapper), DEF_QITEM);
      if (pRspWrapper == NULL) {
@ -1083,7 +1083,7 @@ CREATE_MSG_FAIL:
  return -1;
 }
-bool tmqUpdateEp2(tmq_t* tmq, int32_t epoch, SMqAskEpRsp* pRsp) {
+bool tmqUpdateEp(tmq_t* tmq, int32_t epoch, SMqAskEpRsp* pRsp) {
  bool set = false;
  int32_t topicNumGet = taosArrayGetSize(pRsp->topics);
@ -1112,10 +1112,10 @@ bool tmqUpdateEp2(tmq_t* tmq, int32_t epoch, SMqAskEpRsp* pRsp) {
        SMqClientVg* pVgCur = taosArrayGet(pTopicCur->vgs, j);
        sprintf(vgKey, "%s:%d", pTopicCur->topicName, pVgCur->vgId);
        char buf[80];
-        tFormatOffset(buf, 80, &pVgCur->currentOffsetNew);
+        tFormatOffset(buf, 80, &pVgCur->currentOffset);
        tscDebug("consumer:%" PRId64 ", epoch %d vgId:%d vgKey is %s, offset is %s", tmq->consumerId, epoch,
                 pVgCur->vgId, vgKey, buf);
-        taosHashPut(pHash, vgKey, strlen(vgKey), &pVgCur->currentOffsetNew, sizeof(STqOffsetVal));
+        taosHashPut(pHash, vgKey, strlen(vgKey), &pVgCur->currentOffset, sizeof(STqOffsetVal));
      }
    }
  }
@ -1142,7 +1142,7 @@ bool tmqUpdateEp2(tmq_t* tmq, int32_t epoch, SMqAskEpRsp* pRsp) {
      SMqClientVg clientVg = {
          .pollCnt = 0,
-          .currentOffsetNew = offsetNew,
+          .currentOffset = offsetNew,
          .vgId = pVgEp->vgId,
          .epSet = pVgEp->epSet,
          .vgStatus = TMQ_VG_STATUS__IDLE,
@ -1166,93 +1166,6 @@ bool tmqUpdateEp2(tmq_t* tmq, int32_t epoch, SMqAskEpRsp* pRsp) {
  return set;
 }
 #if 0
 bool tmqUpdateEp(tmq_t* tmq, int32_t epoch, SMqAskEpRsp* pRsp) {
  /*printf("call update ep %d\n", epoch);*/
  bool    set = false;
  int32_t topicNumGet = taosArrayGetSize(pRsp->topics);
  char    vgKey[TSDB_TOPIC_FNAME_LEN + 22];
  tscDebug("consumer:%" PRId64 ", update ep epoch %d to epoch %d, topic num: %d", tmq->consumerId, tmq->epoch, epoch,
           topicNumGet);
  SArray* newTopics = taosArrayInit(topicNumGet, sizeof(SMqClientTopic));
  if (newTopics == NULL) {
    return false;
  }
  SHashObj* pHash = taosHashInit(64, MurmurHash3_32, false, HASH_NO_LOCK);
  if (pHash == NULL) {
    taosArrayDestroy(newTopics);
    return false;
  }
  // find topic, build hash
  for (int32_t i = 0; i < topicNumGet; i++) {
    SMqClientTopic topic = {0};
    SMqSubTopicEp* pTopicEp = taosArrayGet(pRsp->topics, i);
    topic.schema = pTopicEp->schema;
    taosHashClear(pHash);
    topic.topicName = strdup(pTopicEp->topic);
    tstrncpy(topic.db, pTopicEp->db, TSDB_DB_FNAME_LEN);
    tscDebug("consumer:%" PRId64 ", update topic: %s", tmq->consumerId, topic.topicName);
    int32_t topicNumCur = taosArrayGetSize(tmq->clientTopics);
    for (int32_t j = 0; j < topicNumCur; j++) {
      // find old topic
      SMqClientTopic* pTopicCur = taosArrayGet(tmq->clientTopics, j);
      if (pTopicCur->vgs && strcmp(pTopicCur->topicName, pTopicEp->topic) == 0) {
        int32_t vgNumCur = taosArrayGetSize(pTopicCur->vgs);
        tscDebug("consumer:%" PRId64 ", new vg num: %d", tmq->consumerId, vgNumCur);
        if (vgNumCur == 0) break;
        for (int32_t k = 0; k < vgNumCur; k++) {
          SMqClientVg* pVgCur = taosArrayGet(pTopicCur->vgs, k);
          sprintf(vgKey, "%s:%d", topic.topicName, pVgCur->vgId);
          tscDebug("consumer:%" PRId64 ", epoch %d vgId:%d build %s", tmq->consumerId, epoch, pVgCur->vgId, vgKey);
          taosHashPut(pHash, vgKey, strlen(vgKey), &pVgCur->currentOffset, sizeof(int64_t));
        }
        break;
      }
    }
    int32_t vgNumGet = taosArrayGetSize(pTopicEp->vgs);
    topic.vgs = taosArrayInit(vgNumGet, sizeof(SMqClientVg));
    for (int32_t j = 0; j < vgNumGet; j++) {
      SMqSubVgEp* pVgEp = taosArrayGet(pTopicEp->vgs, j);
      sprintf(vgKey, "%s:%d", topic.topicName, pVgEp->vgId);
      int64_t* pOffset = taosHashGet(pHash, vgKey, strlen(vgKey));
      int64_t  offset = pVgEp->offset;
      tscDebug("consumer:%" PRId64 ", (epoch %d) original offset of vgId:%d is %" PRId64, tmq->consumerId, epoch, pVgEp->vgId, offset);
      if (pOffset != NULL) {
        offset = *pOffset;
        tscDebug("consumer:%" PRId64 ", (epoch %d) receive offset of vgId:%d, full key is %s", tmq->consumerId, epoch, pVgEp->vgId,
                 vgKey);
      }
      tscDebug("consumer:%" PRId64 ", (epoch %d) offset of vgId:%d updated to %" PRId64, tmq->consumerId, epoch, pVgEp->vgId, offset);
      SMqClientVg clientVg = {
          .pollCnt = 0,
          .currentOffset = offset,
          .vgId = pVgEp->vgId,
          .epSet = pVgEp->epSet,
          .vgStatus = TMQ_VG_STATUS__IDLE,
          .vgSkipCnt = 0,
      };
      taosArrayPush(topic.vgs, &clientVg);
      set = true;
    }
    taosArrayPush(newTopics, &topic);
  }
  if (tmq->clientTopics) taosArrayDestroy(tmq->clientTopics);
  taosHashCleanup(pHash);
  tmq->clientTopics = newTopics;
  if (taosArrayGetSize(tmq->clientTopics) == 0)
    atomic_store_8(&tmq->status, TMQ_CONSUMER_STATUS__NO_TOPIC);
  else
    atomic_store_8(&tmq->status, TMQ_CONSUMER_STATUS__READY);
  atomic_store_32(&tmq->epoch, epoch);
  return set;
 }
 #endif
 int32_t tmqAskEpCb(void* param, SDataBuf* pMsg, int32_t code) {
  SMqAskEpCbParam* pParam = (SMqAskEpCbParam*)param;
  tmq_t*           tmq = pParam->tmq;
@ -1278,7 +1191,7 @@ int32_t tmqAskEpCb(void* param, SDataBuf* pMsg, int32_t code) {
    tDecodeSMqAskEpRsp(POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), &rsp);
    /*printf("rsp epoch %" PRId64 " sz %" PRId64 "\n", rsp.epoch, rsp.topics->size);*/
    /*printf("tmq epoch %" PRId64 " sz %" PRId64 "\n", tmq->epoch, tmq->clientTopics->size);*/
-    tmqUpdateEp2(tmq, head->epoch, &rsp);
+    tmqUpdateEp(tmq, head->epoch, &rsp);
    tDeleteSMqAskEpRsp(&rsp);
  } else {
    SMqAskEpRspWrapper* pWrapper = taosAllocateQitem(sizeof(SMqAskEpRspWrapper), DEF_QITEM);
@ -1401,17 +1314,6 @@ int32_t tmq_seek(tmq_t* tmq, const tmq_topic_vgroup_t* offset) {
 #endif
 SMqPollReq* tmqBuildConsumeReqImpl(tmq_t* tmq, int64_t timeout, SMqClientTopic* pTopic, SMqClientVg* pVg) {
  /*int64_t reqOffset;*/
  /*if (pVg->currentOffset >= 0) {*/
  /*reqOffset = pVg->currentOffset;*/
  /*} else {*/
  /*if (tmq->resetOffsetCfg == TMQ_CONF__RESET_OFFSET__NONE) {*/
  /*tscError("unable to poll since no committed offset but reset offset is set to none");*/
  /*return NULL;*/
  /*}*/
  /*reqOffset = tmq->resetOffsetCfg;*/
  /*}*/
  SMqPollReq* pReq = taosMemoryCalloc(1, sizeof(SMqPollReq));
  if (pReq == NULL) {
    return NULL;
@ -1430,7 +1332,7 @@ SMqPollReq* tmqBuildConsumeReqImpl(tmq_t* tmq, int64_t timeout, SMqClientTopic*
  pReq->consumerId = tmq->consumerId;
  pReq->epoch = tmq->epoch;
  /*pReq->currentOffset = reqOffset;*/
-  pReq->reqOffset = pVg->currentOffsetNew;
+  pReq->reqOffset = pVg->currentOffset;
  pReq->reqId = generateRequestId();
  pReq->useSnapshot = tmq->useSnapshot;
@ -1534,7 +1436,7 @@ int32_t tmqPollImpl(tmq_t* tmq, int64_t timeout) {
      /*printf("send poll\n");*/
      char offsetFormatBuf[80];
-      tFormatOffset(offsetFormatBuf, 80, &pVg->currentOffsetNew);
+      tFormatOffset(offsetFormatBuf, 80, &pVg->currentOffset);
      tscDebug("consumer:%" PRId64 ", send poll to %s vgId:%d, epoch %d, req offset:%s, reqId:%" PRIu64,
               tmq->consumerId, pTopic->topicName, pVg->vgId, tmq->epoch, offsetFormatBuf, pReq->reqId);
      /*printf("send vgId:%d %" PRId64 "\n", pVg->vgId, pVg->currentOffset);*/
@ -1552,7 +1454,7 @@ int32_t tmqHandleNoPollRsp(tmq_t* tmq, SMqRspWrapper* rspWrapper, bool* pReset)
    if (rspWrapper->epoch > atomic_load_32(&tmq->epoch)) {
      SMqAskEpRspWrapper* pEpRspWrapper = (SMqAskEpRspWrapper*)rspWrapper;
      SMqAskEpRsp*        rspMsg = &pEpRspWrapper->msg;
-      tmqUpdateEp2(tmq, rspWrapper->epoch, rspMsg);
+      tmqUpdateEp(tmq, rspWrapper->epoch, rspMsg);
      /*tmqClearUnhandleMsg(tmq);*/
      *pReset = true;
    } else {
@ -1586,7 +1488,7 @@ void* tmqHandleAllRsp(tmq_t* tmq, int64_t timeout, bool pollIfReset) {
        SMqClientVg* pVg = pollRspWrapper->vgHandle;
        /*printf("vgId:%d, offset %" PRId64 " up to %" PRId64 "\n", pVg->vgId, pVg->currentOffset,
         * rspMsg->msg.rspOffset);*/
-        pVg->currentOffsetNew = pollRspWrapper->dataRsp.rspOffset;
+        pVg->currentOffset = pollRspWrapper->dataRsp.rspOffset;
        atomic_store_32(&pVg->vgStatus, TMQ_VG_STATUS__IDLE);
        if (pollRspWrapper->dataRsp.blockNum == 0) {
          taosFreeQitem(pollRspWrapper);
@ -1609,8 +1511,8 @@ void* tmqHandleAllRsp(tmq_t* tmq, int64_t timeout, bool pollIfReset) {
        SMqClientVg* pVg = pollRspWrapper->vgHandle;
        /*printf("vgId:%d, offset %" PRId64 " up to %" PRId64 "\n", pVg->vgId, pVg->currentOffset,
         * rspMsg->msg.rspOffset);*/
-        pVg->currentOffsetNew.version = pollRspWrapper->metaRsp.rspOffset;
+        pVg->currentOffset.version = pollRspWrapper->metaRsp.rspOffset;
-        pVg->currentOffsetNew.type = TMQ_OFFSET__LOG;
+        pVg->currentOffset.type = TMQ_OFFSET__LOG;
        atomic_store_32(&pVg->vgStatus, TMQ_VG_STATUS__IDLE);
        // build rsp
        SMqMetaRspObj* pRsp = tmqBuildMetaRspFromWrapper(pollRspWrapper);
@ -1653,6 +1555,17 @@ TAOS_RES* tmq_consumer_poll(tmq_t* tmq, int64_t timeout) {
    return NULL;
  }
  if (atomic_load_8(&tmq->status) == TMQ_CONSUMER_STATUS__RECOVER) {
    int32_t retryCnt = 0;
    while (TSDB_CODE_MND_CONSUMER_NOT_READY == tmqAskEp(tmq, false)) {
      if (retryCnt++ > 10) {
        return NULL;
      }
      tscDebug("consumer not ready, retry");
      taosMsleep(500);
    }
  }
  while (1) {
    tmqHandleAllDelayedTask(tmq);
    if (tmqPollImpl(tmq, timeout) < 0) return NULL;
@ -3384,10 +3297,10 @@ int32_t tmq_write_raw(TAOS* taos, tmq_raw_data raw) {
 void tmq_commit_async(tmq_t* tmq, const TAOS_RES* msg, tmq_commit_cb* cb, void* param) {
  //
-  tmqCommitInner2(tmq, msg, 0, 1, cb, param);
+  tmqCommitInner(tmq, msg, 0, 1, cb, param);
 }
 int32_t tmq_commit_sync(tmq_t* tmq, const TAOS_RES* msg) {
  //
-  return tmqCommitInner2(tmq, msg, 0, 0, NULL, NULL);
+  return tmqCommitInner(tmq, msg, 0, 0, NULL, NULL);
 }
--- a/source/common/src/systable.c
+++ b/source/common/src/systable.c
@ -135,12 +135,12 @@ static const SSysDbTableSchema streamSchema[] = {
    {.name = "stream_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_VARCHAR},
    {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP},
    {.name = "sql", .bytes = TSDB_SHOW_SQL_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},
-    {.name = "status", .bytes = 20 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY},
+    {.name = "status", .bytes = 20 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},
    {.name = "source_db", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_VARCHAR},
    {.name = "target_db", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_VARCHAR},
    {.name = "target_table", .bytes = SYSTABLE_SCH_TABLE_NAME_LEN, .type = TSDB_DATA_TYPE_VARCHAR},
    {.name = "watermark", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT},
-    {.name = "trigger", .bytes = 4, .type = TSDB_DATA_TYPE_INT},
+    {.name = "trigger", .bytes = 20 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},
 };
 static const SSysDbTableSchema userTblsSchema[] = {
@ -284,8 +284,7 @@ static const SSysDbTableSchema consumerSchema[] = {
    {.name = "client_id", .bytes = SYSTABLE_SCH_TABLE_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY},
    {.name = "status", .bytes = 20 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY},
    {.name = "topics", .bytes = TSDB_TOPIC_FNAME_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY},
-    {.name = "pid", .bytes = 4, .type = TSDB_DATA_TYPE_INT},
+    /*{.name = "end_point", .bytes = TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},*/
    {.name = "end_point", .bytes = TSDB_EP_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY},
    {.name = "up_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP},
    {.name = "subscribe_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP},
    {.name = "rebalance_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP},
--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@ -305,7 +305,7 @@ static int32_t tDeserializeSClientHbReq(SDecoder *pDecoder, SClientHbReq *pReq)
              taosArrayPush(desc.subDesc, &sDesc);
            }
          }
-          
+
          ASSERT(desc.subPlanNum == taosArrayGetSize(desc.subDesc));
          taosArrayPush(pReq->query->queryDesc, &desc);
@ -5770,3 +5770,40 @@ int32_t tDecodeSMqDataRsp(SDecoder *pDecoder, SMqDataRsp *pRsp) {
  }
  return 0;
 }
 int32_t tEncodeSSingleDeleteReq(SEncoder *pEncoder, const SSingleDeleteReq *pReq) {
  if (tEncodeI64(pEncoder, pReq->uid) < 0) return -1;
  if (tEncodeI64(pEncoder, pReq->ts) < 0) return -1;
  return 0;
 }
 int32_t tDecodeSSingleDeleteReq(SDecoder *pDecoder, SSingleDeleteReq *pReq) {
  if (tDecodeI64(pDecoder, &pReq->uid) < 0) return -1;
  if (tDecodeI64(pDecoder, &pReq->ts) < 0) return -1;
  return 0;
 }
 int32_t tEncodeSBatchDeleteReq(SEncoder *pEncoder, const SBatchDeleteReq *pReq) {
  if (tEncodeI64(pEncoder, pReq->suid) < 0) return -1;
  int32_t sz = taosArrayGetSize(pReq->deleteReqs);
  if (tEncodeI32(pEncoder, sz) < 0) return -1;
  for (int32_t i = 0; i < sz; i++) {
    SSingleDeleteReq *pOneReq = taosArrayGet(pReq->deleteReqs, i);
    if (tEncodeSSingleDeleteReq(pEncoder, pOneReq) < 0) return -1;
  }
  return 0;
 }
 int32_t tDecodeSBatchDeleteReq(SDecoder *pDecoder, SBatchDeleteReq *pReq) {
  if (tDecodeI64(pDecoder, &pReq->suid) < 0) return -1;
  int32_t sz;
  if (tDecodeI32(pDecoder, &sz) < 0) return -1;
  pReq->deleteReqs = taosArrayInit(0, sizeof(SSingleDeleteReq));
  if (pReq->deleteReqs == NULL) return -1;
  for (int32_t i = 0; i < sz; i++) {
    SSingleDeleteReq deleteReq;
    if (tDecodeSSingleDeleteReq(pDecoder, &deleteReq) < 0) return -1;
    taosArrayPush(pReq->deleteReqs, &deleteReq);
  }
  return 0;
 }
--- a/source/common/src/trow.c
+++ b/source/common/src/trow.c
@ -32,9 +32,13 @@ const uint8_t tdVTypeByte[2][3] = {{
 };
 // declaration
-static uint8_t              tdGetBitmapByte(uint8_t byte);
+static uint8_t tdGetBitmapByte(uint8_t byte);
-static int32_t              tdCompareColId(const void *arg1, const void *arg2);
+static bool    tdSTSRowIterGetTpVal(STSRowIter *pIter, col_type_t colType, int32_t offset, SCellVal *pVal);
-static FORCE_INLINE int32_t compareKvRowColId(const void *key1, const void *key2);
+static bool    tdSTSRowIterGetKvVal(STSRowIter *pIter, col_id_t colId, col_id_t *nIdx, SCellVal *pVal);
 static bool    tdSTpRowGetVal(STSRow *pRow, col_id_t colId, col_type_t colType, int32_t flen, uint32_t offset,
                              col_id_t colIdx, SCellVal *pVal);
 static bool    tdSKvRowGetVal(STSRow *pRow, col_id_t colId, col_id_t colIdx, SCellVal *pVal);
 static void    tdSCellValPrint(SCellVal *pVal, int8_t colType);
 // implementation
 /**
@ -330,14 +334,14 @@ void tdSRowPrint(STSRow *row, STSchema *pSchema, const char *tag) {
  tdSTSRowIterInit(&iter, pSchema);
  tdSTSRowIterReset(&iter, row);
  printf("%s >>>type:%d,sver:%d ", tag, (int32_t)TD_ROW_TYPE(row), (int32_t)TD_ROW_SVER(row));
-  for (int i = 0; i < pSchema->numOfCols; ++i) {
+  STColumn *cols = (STColumn *)&iter.pSchema->columns;
-    STColumn *stCol = pSchema->columns + i;
+  while (true) {
-    SCellVal  sVal = {255, NULL};
+    SCellVal sVal = {.valType = 255, NULL};
-    if (!tdSTSRowIterNext(&iter, stCol->colId, stCol->type, &sVal)) {
+    if (!tdSTSRowIterNext(&iter, &sVal)) {
      break;
    }
    ASSERT(sVal.valType == 0 || sVal.valType == 1 || sVal.valType == 2);
-    tdSCellValPrint(&sVal, stCol->type);
+    tdSCellValPrint(&sVal, cols[iter.colIdx - 1].type);
  }
  printf("\n");
 }
@ -420,6 +424,16 @@ void tdSCellValPrint(SCellVal *pVal, int8_t colType) {
  }
 }
 static FORCE_INLINE int32_t compareKvRowColId(const void *key1, const void *key2) {
  if (*(col_id_t *)key1 > ((SKvRowIdx *)key2)->colId) {
    return 1;
  } else if (*(col_id_t *)key1 < ((SKvRowIdx *)key2)->colId) {
    return -1;
  } else {
    return 0;
  }
 }
 bool tdSKvRowGetVal(STSRow *pRow, col_id_t colId, col_id_t colIdx, SCellVal *pVal) {
  if (colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
    tdRowSetVal(pVal, TD_VTYPE_NORM, TD_ROW_KEY_ADDR(pRow));
@ -456,7 +470,7 @@ bool tdSTpRowGetVal(STSRow *pRow, col_id_t colId, col_type_t colType, int32_t fl
  return true;
 }
-bool tdSTSRowIterNext(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCellVal *pVal) {
+bool tdSTSRowIterFetch(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCellVal *pVal) {
  if (colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
    pVal->val = &pIter->pRow->ts;
    pVal->valType = TD_VTYPE_NORM;
@ -477,10 +491,10 @@ bool tdSTSRowIterNext(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCe
        return false;
      }
    }
-    tdGetTpRowDataOfCol(pIter, pCol->type, pCol->offset - sizeof(TSKEY), pVal);
+    tdSTSRowIterGetTpVal(pIter, pCol->type, pCol->offset - sizeof(TSKEY), pVal);
    ++pIter->colIdx;
  } else if (TD_IS_KV_ROW(pIter->pRow)) {
-    return tdGetKvRowValOfColEx(pIter, colId, colType, &pIter->kvIdx, pVal);
+    return tdSTSRowIterGetKvVal(pIter, colId, &pIter->kvIdx, pVal);
  } else {
    pVal->valType = TD_VTYPE_NONE;
    terrno = TSDB_CODE_INVALID_PARA;
@ -489,13 +503,68 @@ bool tdSTSRowIterNext(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCe
  return true;
 }
-bool tdGetKvRowValOfColEx(STSRowIter *pIter, col_id_t colId, col_type_t colType, col_id_t *nIdx, SCellVal *pVal) {
+bool tdSTSRowIterNext(STSRowIter *pIter, SCellVal *pVal) {
  if (pIter->colIdx >= pIter->pSchema->numOfCols) {
    return false;
  }
  STColumn *pCol = &pIter->pSchema->columns[pIter->colIdx];
  if (pCol->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
    pVal->val = &pIter->pRow->ts;
    pVal->valType = TD_VTYPE_NORM;
    ++pIter->colIdx;
    return true;
  }
  if (TD_IS_TP_ROW(pIter->pRow)) {
    tdSTSRowIterGetTpVal(pIter, pCol->type, pCol->offset - sizeof(TSKEY), pVal);
  } else if (TD_IS_KV_ROW(pIter->pRow)) {
    tdSTSRowIterGetKvVal(pIter, pCol->colId, &pIter->kvIdx, pVal);
  } else {
    ASSERT(0);
  }
  ++pIter->colIdx;
  return true;
 }
 bool tdSTSRowIterGetTpVal(STSRowIter *pIter, col_type_t colType, int32_t offset, SCellVal *pVal) {
  STSRow *pRow = pIter->pRow;
  if (pRow->statis == 0) {
    pVal->valType = TD_VTYPE_NORM;
    if (IS_VAR_DATA_TYPE(colType)) {
      pVal->val = POINTER_SHIFT(pRow, *(VarDataOffsetT *)POINTER_SHIFT(TD_ROW_DATA(pRow), offset));
    } else {
      pVal->val = POINTER_SHIFT(TD_ROW_DATA(pRow), offset);
    }
    return TSDB_CODE_SUCCESS;
  }
  if (tdGetBitmapValType(pIter->pBitmap, pIter->colIdx - 1, &pVal->valType, 0) != TSDB_CODE_SUCCESS) {
    pVal->valType = TD_VTYPE_NONE;
    return terrno;
  }
  if (pVal->valType == TD_VTYPE_NORM) {
    if (IS_VAR_DATA_TYPE(colType)) {
      pVal->val = POINTER_SHIFT(pRow, *(VarDataOffsetT *)POINTER_SHIFT(TD_ROW_DATA(pRow), offset));
    } else {
      pVal->val = POINTER_SHIFT(TD_ROW_DATA(pRow), offset);
    }
  }
  return true;
 }
 bool tdSTSRowIterGetKvVal(STSRowIter *pIter, col_id_t colId, col_id_t *nIdx, SCellVal *pVal) {
  STSRow    *pRow = pIter->pRow;
  SKvRowIdx *pKvIdx = NULL;
  bool       colFound = false;
  col_id_t   kvNCols = tdRowGetNCols(pRow) - 1;
  void      *pColIdx = TD_ROW_COL_IDX(pRow);
  while (*nIdx < kvNCols) {
-    pKvIdx = (SKvRowIdx *)POINTER_SHIFT(TD_ROW_COL_IDX(pRow), *nIdx * sizeof(SKvRowIdx));
+    pKvIdx = (SKvRowIdx *)POINTER_SHIFT(pColIdx, *nIdx * sizeof(SKvRowIdx));
    if (pKvIdx->colId == colId) {
      ++(*nIdx);
      pVal->val = POINTER_SHIFT(pRow, pKvIdx->offset);
@ -518,48 +587,13 @@ bool tdGetKvRowValOfColEx(STSRowIter *pIter, col_id_t colId, col_type_t colType,
    }
  }
-#ifdef TD_SUPPORT_BITMAP
+  if (tdGetBitmapValType(pIter->pBitmap, pIter->kvIdx - 1, &pVal->valType, 0) != TSDB_CODE_SUCCESS) {
  int16_t colIdx = -1;
  if (pKvIdx) colIdx = POINTER_DISTANCE(pKvIdx, TD_ROW_COL_IDX(pRow)) / sizeof(SKvRowIdx);
  if (tdGetBitmapValType(pIter->pBitmap, colIdx, &pVal->valType, 0) != TSDB_CODE_SUCCESS) {
    pVal->valType = TD_VTYPE_NONE;
  }
 #else
  pVal->valType = isNull(pVal->val, colType) ? TD_VTYPE_NULL : TD_VTYPE_NORM;
 #endif
  return true;
 }
 bool tdGetTpRowDataOfCol(STSRowIter *pIter, col_type_t colType, int32_t offset, SCellVal *pVal) {
  STSRow *pRow = pIter->pRow;
  if (IS_VAR_DATA_TYPE(colType)) {
    pVal->val = POINTER_SHIFT(pRow, *(VarDataOffsetT *)POINTER_SHIFT(TD_ROW_DATA(pRow), offset));
  } else {
    pVal->val = POINTER_SHIFT(TD_ROW_DATA(pRow), offset);
  }
 #ifdef TD_SUPPORT_BITMAP
  if (tdGetBitmapValType(pIter->pBitmap, pIter->colIdx - 1, &pVal->valType, 0) != TSDB_CODE_SUCCESS) {
    pVal->valType = TD_VTYPE_NONE;
  }
 #else
  pVal->valType = isNull(pVal->val, colType) ? TD_VTYPE_NULL : TD_VTYPE_NORM;
 #endif
  return true;
 }
 static FORCE_INLINE int32_t compareKvRowColId(const void *key1, const void *key2) {
  if (*(col_id_t *)key1 > ((SKvRowIdx *)key2)->colId) {
    return 1;
  } else if (*(col_id_t *)key1 < ((SKvRowIdx *)key2)->colId) {
    return -1;
  } else {
    return 0;
  }
 }
 int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow) {
  STColumn *pTColumn;
  SColVal  *pColVal;
@ -625,7 +659,7 @@ int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow) {
  if (maxVarDataLen > 0) {
    varBuf = taosMemoryMalloc(maxVarDataLen);
    if (!varBuf) {
-      if(isAlloc) {
+      if (isAlloc) {
        taosMemoryFreeClear(*ppRow);
      }
      terrno = TSDB_CODE_OUT_OF_MEMORY;
@ -673,6 +707,19 @@ int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow) {
  return 0;
 }
 static FORCE_INLINE int32_t tdCompareColId(const void *arg1, const void *arg2) {
  int32_t   colId = *(int32_t *)arg1;
  STColumn *pCol = (STColumn *)arg2;
  if (colId < pCol->colId) {
    return -1;
  } else if (colId == pCol->colId) {
    return 0;
  } else {
    return 1;
  }
 }
 bool tdSTSRowGetVal(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCellVal *pVal) {
  if (colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
    pVal->val = &pIter->pRow->ts;
@ -712,19 +759,6 @@ bool tdSTSRowGetVal(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCell
  return true;
 }
 static int32_t tdCompareColId(const void *arg1, const void *arg2) {
  int32_t   colId = *(int32_t *)arg1;
  STColumn *pCol = (STColumn *)arg2;
  if (colId < pCol->colId) {
    return -1;
  } else if (colId == pCol->colId) {
    return 0;
  } else {
    return 1;
  }
 }
 int32_t tdGetBitmapValTypeII(const void *pBitmap, int16_t colIdx, TDRowValT *pValType) {
  if (!pBitmap || colIdx < 0) {
    TASSERT(0);
@ -938,7 +972,7 @@ int32_t tdAppendColValToRow(SRowBuilder *pBuilder, col_id_t colId, int8_t colTyp
      break;
    case TD_VTYPE_NONE:
      if (!pBuilder->hasNone) pBuilder->hasNone = true;
-      break;
+      return TSDB_CODE_SUCCESS;
    default:
      ASSERT(0);
      break;
@ -970,13 +1004,11 @@ int32_t tdAppendColValToKvRow(SRowBuilder *pBuilder, TDRowValT valType, const vo
  STSRow *row = pBuilder->pBuf;
  // No need to store None/Null values.
  SKvRowIdx *pColIdx = (SKvRowIdx *)POINTER_SHIFT(TD_ROW_COL_IDX(row), offset);
  pColIdx->colId = colId;
  pColIdx->offset = TD_ROW_LEN(row);  // the offset include the TD_ROW_HEAD_LEN
  if (valType == TD_VTYPE_NORM) {
-    // ts key stored in STSRow.ts
+    char *ptr = (char *)POINTER_SHIFT(row, TD_ROW_LEN(row));
    SKvRowIdx *pColIdx = (SKvRowIdx *)POINTER_SHIFT(TD_ROW_COL_IDX(row), offset);
    char      *ptr = (char *)POINTER_SHIFT(row, TD_ROW_LEN(row));
    pColIdx->colId = colId;
    pColIdx->offset = TD_ROW_LEN(row);  // the offset include the TD_ROW_HEAD_LEN
    if (IS_VAR_DATA_TYPE(colType)) {
      if (isCopyVarData) {
        memcpy(ptr, val, varDataTLen(val));
@ -987,26 +1019,6 @@ int32_t tdAppendColValToKvRow(SRowBuilder *pBuilder, TDRowValT valType, const vo
      TD_ROW_LEN(row) += TYPE_BYTES[colType];
    }
  }
 #ifdef TD_SUPPORT_BACK2
  // NULL/None value
  else {
    SKvRowIdx *pColIdx = (SKvRowIdx *)POINTER_SHIFT(TD_ROW_COL_IDX(row), offset);
    char      *ptr = (char *)POINTER_SHIFT(row, TD_ROW_LEN(row));
    pColIdx->colId = colId;
    pColIdx->offset = TD_ROW_LEN(row);  // the offset include the TD_ROW_HEAD_LEN
    const void *nullVal = getNullValue(colType);
    if (IS_VAR_DATA_TYPE(colType)) {
      if (isCopyVarData) {
        memcpy(ptr, nullVal, varDataTLen(nullVal));
      }
      TD_ROW_LEN(row) += varDataTLen(nullVal);
    } else {
      memcpy(ptr, nullVal, TYPE_BYTES[colType]);
      TD_ROW_LEN(row) += TYPE_BYTES[colType];
    }
  }
 #endif
  return 0;
 }
@ -1044,24 +1056,6 @@ int32_t tdAppendColValToTpRow(SRowBuilder *pBuilder, TDRowValT valType, const vo
      memcpy(POINTER_SHIFT(TD_ROW_DATA(row), offset), val, TYPE_BYTES[colType]);
    }
  }
 #ifdef TD_SUPPORT_BACK2
  // NULL/None value
  else {
    // TODO: Null value for new data types imported since 3.0 need to be defined.
    const void *nullVal = getNullValue(colType);
    if (IS_VAR_DATA_TYPE(colType)) {
      // ts key stored in STSRow.ts
      *(VarDataOffsetT *)POINTER_SHIFT(TD_ROW_DATA(row), offset) = TD_ROW_LEN(row);
      if (isCopyVarData) {
        memcpy(POINTER_SHIFT(row, TD_ROW_LEN(row)), nullVal, varDataTLen(nullVal));
      }
      TD_ROW_LEN(row) += varDataTLen(nullVal);
    } else {
      memcpy(POINTER_SHIFT(TD_ROW_DATA(row), offset), nullVal, TYPE_BYTES[colType]);
    }
  }
 #endif
  return 0;
 }
@ -1329,7 +1323,7 @@ void tdSTSRowIterReset(STSRowIter *pIter, STSRow *pRow) {
  pIter->pRow = pRow;
  pIter->pBitmap = tdGetBitmapAddr(pRow, pRow->type, pIter->pSchema->flen, tdRowGetNCols(pRow));
  pIter->offset = 0;
-  pIter->colIdx = PRIMARYKEY_TIMESTAMP_COL_ID;
+  pIter->colIdx = 0;  // PRIMARYKEY_TIMESTAMP_COL_ID;
  pIter->kvIdx = 0;
 }
@ -1367,4 +1361,4 @@ void tTSRowGetVal(STSRow *pRow, STSchema *pTSchema, int16_t iCol, SColVal *pColV
    *pColVal = COL_VAL_VALUE(pTColumn->colId, pTColumn->type, value);
  }
-}
+}
--- a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
+++ b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
@ -364,6 +364,7 @@ SArray *vmGetMsgHandles() {
  if (dmSetMgmtHandle(pArray, TDMT_VND_CHECK_ALTER_INFO, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_VND_CONSUME, vmPutMsgToFetchQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_VND_DELETE, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_VND_BATCH_DEL, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_VND_COMMIT, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_SCH_QUERY_HEARTBEAT, vmPutMsgToFetchQueue, 0) == NULL) goto _OVER;
--- a/source/dnode/mnode/impl/inc/mndTopic.h
+++ b/source/dnode/mnode/impl/inc/mndTopic.h
@ -32,6 +32,7 @@ SSdbRaw *mndTopicActionEncode(SMqTopicObj *pTopic);
 SSdbRow *mndTopicActionDecode(SSdbRaw *pRaw);
 int32_t mndDropTopicByDB(SMnode *pMnode, STrans *pTrans, SDbObj *pDb);
 int32_t mndCheckTopicExist(SMnode *pMnode, SDbObj *pDb);
 const char *mndTopicGetShowName(const char topic[TSDB_TOPIC_FNAME_LEN]);
--- a/source/dnode/mnode/impl/src/mndConsumer.c
+++ b/source/dnode/mnode/impl/src/mndConsumer.c
@ -131,8 +131,9 @@ static int32_t mndProcessConsumerRecoverMsg(SRpcMsg *pMsg) {
  mInfo("receive consumer recover msg, consumer id %" PRId64 ", status %s", pRecoverMsg->consumerId,
        mndConsumerStatusName(pConsumer->status));
-  if (pConsumer->status != MQ_CONSUMER_STATUS__READY) {
+  if (pConsumer->status != MQ_CONSUMER_STATUS__LOST_REBD) {
    mndReleaseConsumer(pMnode, pConsumer);
    terrno = TSDB_CODE_MND_CONSUMER_NOT_READY;
    return -1;
  }
@ -275,6 +276,7 @@ static int32_t mndProcessMqHbReq(SRpcMsg *pMsg) {
  int32_t status = atomic_load_32(&pConsumer->status);
  if (status == MQ_CONSUMER_STATUS__LOST_REBD) {
    mInfo("try to recover consumer %ld", consumerId);
    SMqConsumerRecoverMsg *pRecoverMsg = rpcMallocCont(sizeof(SMqConsumerRecoverMsg));
    pRecoverMsg->consumerId = consumerId;
@ -305,15 +307,14 @@ static int32_t mndProcessAskEpReq(SRpcMsg *pMsg) {
  ASSERT(strcmp(pReq->cgroup, pConsumer->cgroup) == 0);
 #if 1
  atomic_store_32(&pConsumer->hbStatus, 0);
 #endif
  // 1. check consumer status
  int32_t status = atomic_load_32(&pConsumer->status);
 #if 1
  if (status == MQ_CONSUMER_STATUS__LOST_REBD) {
    mInfo("try to recover consumer %ld", consumerId);
    SMqConsumerRecoverMsg *pRecoverMsg = rpcMallocCont(sizeof(SMqConsumerRecoverMsg));
    pRecoverMsg->consumerId = consumerId;
@ -326,6 +327,7 @@ static int32_t mndProcessAskEpReq(SRpcMsg *pMsg) {
 #endif
  if (status != MQ_CONSUMER_STATUS__READY) {
    mInfo("consumer %ld not ready, status: %s", consumerId, mndConsumerStatusName(status));
    terrno = TSDB_CODE_MND_CONSUMER_NOT_READY;
    return -1;
  }
@ -939,13 +941,9 @@ static int32_t mndRetrieveConsumer(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *
        colDataAppend(pColInfo, numOfRows, NULL, true);
      }
      // pid
      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
      colDataAppend(pColInfo, numOfRows, (const char *)&pConsumer->pid, true);
      // end point
-      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      /*pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);*/
-      colDataAppend(pColInfo, numOfRows, (const char *)&pConsumer->ep, true);
+      /*colDataAppend(pColInfo, numOfRows, (const char *)&pConsumer->ep, true);*/
      // up time
      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
--- a/source/dnode/mnode/impl/src/mndDb.c
+++ b/source/dnode/mnode/impl/src/mndDb.c
@ -995,11 +995,13 @@ static int32_t mndDropDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb) {
  mDebug("trans:%d, used to drop db:%s", pTrans->id, pDb->name);
  mndTransSetDbName(pTrans, pDb->name, NULL);
  if (mndCheckTopicExist(pMnode, pDb) < 0) goto _OVER;
  if (mndSetDropDbRedoLogs(pMnode, pTrans, pDb) != 0) goto _OVER;
  if (mndSetDropDbCommitLogs(pMnode, pTrans, pDb) != 0) goto _OVER;
-  if (mndDropOffsetByDB(pMnode, pTrans, pDb) != 0) goto _OVER;
+  /*if (mndDropOffsetByDB(pMnode, pTrans, pDb) != 0) goto _OVER;*/
-  if (mndDropSubByDB(pMnode, pTrans, pDb) != 0) goto _OVER;
+  /*if (mndDropSubByDB(pMnode, pTrans, pDb) != 0) goto _OVER;*/
-  if (mndDropTopicByDB(pMnode, pTrans, pDb) != 0) goto _OVER;
+  /*if (mndDropTopicByDB(pMnode, pTrans, pDb) != 0) goto _OVER;*/
  if (mndDropStreamByDb(pMnode, pTrans, pDb) != 0) goto _OVER;
  if (mndDropSmasByDb(pMnode, pTrans, pDb) != 0) goto _OVER;
  if (mndSetDropDbRedoActions(pMnode, pTrans, pDb) != 0) goto _OVER;
@ -1706,7 +1708,7 @@ static void setPerfSchemaDbCfg(SDbObj *pDbObj) {
 static bool mndGetTablesOfDbFp(SMnode *pMnode, void *pObj, void *p1, void *p2, void *p3) {
  SVgObj  *pVgroup = pObj;
  int32_t *numOfTables = p1;
-  int64_t uid = *(int64_t*)p2;
+  int64_t  uid = *(int64_t *)p2;
  if (pVgroup->dbUid == uid) {
    *numOfTables += pVgroup->numOfTables;
  }
--- a/source/dnode/mnode/impl/src/mndStream.c
+++ b/source/dnode/mnode/impl/src/mndStream.c
@ -197,6 +197,30 @@ void mndReleaseStream(SMnode *pMnode, SStreamObj *pStream) {
  sdbRelease(pSdb, pStream);
 }
 static void mndShowStreamStatus(char *dst, SStreamObj *pStream) {
  int8_t status = atomic_load_8(&pStream->status);
  if (status == STREAM_STATUS__NORMAL) {
    strcpy(dst, "normal");
  } else if (status == STREAM_STATUS__STOP) {
    strcpy(dst, "stop");
  } else if (status == STREAM_STATUS__FAILED) {
    strcpy(dst, "failed");
  } else if (status == STREAM_STATUS__RECOVER) {
    strcpy(dst, "recover");
  }
 }
 static void mndShowStreamTrigger(char *dst, SStreamObj *pStream) {
  int8_t trigger = pStream->trigger;
  if (trigger == STREAM_TRIGGER_AT_ONCE) {
    strcpy(dst, "at once");
  } else if (trigger == STREAM_TRIGGER_WINDOW_CLOSE) {
    strcpy(dst, "window close");
  } else if (trigger == STREAM_TRIGGER_MAX_DELAY) {
    strcpy(dst, "max delay");
  }
 }
 static int32_t mndCheckCreateStreamReq(SCMCreateStreamReq *pCreate) {
  if (pCreate->name[0] == 0 || pCreate->sql == NULL || pCreate->sql[0] == 0 || pCreate->sourceDB[0] == 0 ||
      pCreate->targetStbFullName[0] == 0) {
@ -837,7 +861,7 @@ int32_t mndDropStreamByDb(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {
        sdbCancelFetch(pSdb, pIter);
        mError("db:%s, failed to drop stream:%s since sourceDbUid:%" PRId64 " not match with targetDbUid:%" PRId64,
               pDb->name, pStream->name, pStream->sourceDbUid, pStream->targetDbUid);
-        terrno = TSDB_CODE_MND_STREAM_ALREADY_EXIST;
+        terrno = TSDB_CODE_MND_STREAM_MUST_BE_DELETED;
        return -1;
      } else {
 #if 0
@ -926,23 +950,46 @@ static int32_t mndRetrieveStream(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB
    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
    colDataAppend(pColInfo, numOfRows, (const char *)sql, false);
    char status[20 + VARSTR_HEADER_SIZE] = {0};
    mndShowStreamStatus(&status[VARSTR_HEADER_SIZE], pStream);
    varDataSetLen(status, strlen(varDataVal(status)));
    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, numOfRows, (const char *)&pStream->status, true);
+    colDataAppend(pColInfo, numOfRows, (const char *)&status, false);
    char sourceDB[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
    tNameFromString(&n, pStream->sourceDb, T_NAME_ACCT | T_NAME_DB);
    tNameGetDbName(&n, varDataVal(sourceDB));
    varDataSetLen(sourceDB, strlen(varDataVal(sourceDB)));
    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, numOfRows, (const char *)&pStream->sourceDb, true);
+    colDataAppend(pColInfo, numOfRows, (const char *)&sourceDB, false);
    char targetDB[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
    tNameFromString(&n, pStream->targetDb, T_NAME_ACCT | T_NAME_DB);
    tNameGetDbName(&n, varDataVal(targetDB));
    varDataSetLen(targetDB, strlen(varDataVal(targetDB)));
    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, numOfRows, (const char *)&pStream->targetDb, true);
+    colDataAppend(pColInfo, numOfRows, (const char *)&targetDB, false);
-    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    if (pStream->targetSTbName[0] == 0) {
-    colDataAppend(pColInfo, numOfRows, (const char *)&pStream->targetSTbName, true);
+      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
      colDataAppend(pColInfo, numOfRows, NULL, true);
    } else {
      char targetSTB[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
      tNameFromString(&n, pStream->targetSTbName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
      strcpy(&targetSTB[VARSTR_HEADER_SIZE], tNameGetTableName(&n));
      varDataSetLen(targetSTB, strlen(varDataVal(targetSTB)));
      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
      colDataAppend(pColInfo, numOfRows, (const char *)&targetSTB, false);
    }
    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
    colDataAppend(pColInfo, numOfRows, (const char *)&pStream->watermark, false);
    char trigger[20 + VARSTR_HEADER_SIZE] = {0};
    mndShowStreamTrigger(&trigger[VARSTR_HEADER_SIZE], pStream);
    varDataSetLen(trigger, strlen(varDataVal(trigger)));
    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, numOfRows, (const char *)&pStream->trigger, false);
+    colDataAppend(pColInfo, numOfRows, (const char *)&trigger, false);
    numOfRows++;
    sdbRelease(pSdb, pStream);
--- a/source/dnode/mnode/impl/src/mndSubscribe.c
+++ b/source/dnode/mnode/impl/src/mndSubscribe.c
@ -398,13 +398,27 @@ static int32_t mndDoRebalance(SMnode *pMnode, const SMqRebInputObj *pInput, SMqR
    }
  }
-  // 8. TODO generate logs
+  // 8. generate logs
-  mInfo("rebalance calculation completed, rebalanced vg:");
+  mInfo("mq rebalance: calculation completed, rebalanced vg:");
  for (int32_t i = 0; i < taosArrayGetSize(pOutput->rebVgs); i++) {
    SMqRebOutputVg *pOutputRebVg = taosArrayGet(pOutput->rebVgs, i);
-    mInfo("vgId:%d, moved from consumer:%" PRId64 ", to consumer:%" PRId64, pOutputRebVg->pVgEp->vgId,
+    mInfo("mq rebalance: vgId:%d, moved from consumer:%" PRId64 ", to consumer:%" PRId64, pOutputRebVg->pVgEp->vgId,
          pOutputRebVg->oldConsumerId, pOutputRebVg->newConsumerId);
  }
  {
    void *pIter = NULL;
    while (1) {
      pIter = taosHashIterate(pOutput->pSub->consumerHash, pIter);
      if (pIter == NULL) break;
      SMqConsumerEp *pConsumerEp = (SMqConsumerEp *)pIter;
      int32_t        sz = taosArrayGetSize(pConsumerEp->vgs);
      mInfo("mq rebalance: final cfg: consumer %ld has %d vg", pConsumerEp->consumerId, sz);
      for (int32_t i = 0; i < sz; i++) {
        SMqVgEp *pVgEp = taosArrayGetP(pConsumerEp->vgs, i);
        mInfo("mq rebalance: final cfg: vg %d to consumer %ld", pVgEp->vgId, pConsumerEp->consumerId);
      }
    }
  }
  // 9. clear
  taosHashCleanup(pHash);
--- a/source/dnode/mnode/impl/src/mndSync.c
+++ b/source/dnode/mnode/impl/src/mndSync.c
@ -166,6 +166,18 @@ void mndLeaderTransfer(struct SSyncFSM *pFsm, const SRpcMsg *pMsg, SFsmCbMeta cb
  mDebug("vgId:1, mnode leader transfer finish");
 }
 static void mndBecomeFollower(struct SSyncFSM *pFsm) {
  SMnode *pMnode = pFsm->data;
  mDebug("vgId:1, become follower");
  // clear old leader resource
 }
 static void mndBecomeLeader(struct SSyncFSM *pFsm) {
  SMnode *pMnode = pFsm->data;
  mDebug("vgId:1, become leader");
 }
 SSyncFSM *mndSyncMakeFsm(SMnode *pMnode) {
  SSyncFSM *pFsm = taosMemoryCalloc(1, sizeof(SSyncFSM));
  pFsm->data = pMnode;
@ -175,6 +187,8 @@ SSyncFSM *mndSyncMakeFsm(SMnode *pMnode) {
  pFsm->FpRestoreFinishCb = mndRestoreFinish;
  pFsm->FpLeaderTransferCb = mndLeaderTransfer;
  pFsm->FpReConfigCb = mndReConfig;
  pFsm->FpBecomeLeaderCb = mndBecomeLeader;
  pFsm->FpBecomeFollowerCb = mndBecomeFollower;
  pFsm->FpGetSnapshot = mndSyncGetSnapshot;
  pFsm->FpGetSnapshotInfo = mndSyncGetSnapshotInfo;
  pFsm->FpSnapshotStartRead = mndSnapshotStartRead;
--- a/source/dnode/mnode/impl/src/mndTopic.c
+++ b/source/dnode/mnode/impl/src/mndTopic.c
@ -782,6 +782,26 @@ static void mndCancelGetNextTopic(SMnode *pMnode, void *pIter) {
  sdbCancelFetch(pSdb, pIter);
 }
 int32_t mndCheckTopicExist(SMnode *pMnode, SDbObj *pDb) {
  SSdb *pSdb = pMnode->pSdb;
  void        *pIter = NULL;
  SMqTopicObj *pTopic = NULL;
  while (1) {
    pIter = sdbFetch(pSdb, SDB_TOPIC, pIter, (void **)&pTopic);
    if (pIter == NULL) break;
    if (pTopic->dbUid == pDb->uid) {
      sdbRelease(pSdb, pTopic);
      terrno = TSDB_CODE_MND_TOPIC_MUST_BE_DELETED;
      return -1;
    }
    sdbRelease(pSdb, pTopic);
  }
  return 0;
 }
 int32_t mndDropTopicByDB(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {
  int32_t code = 0;
  SSdb   *pSdb = pMnode->pSdb;
--- a/source/dnode/vnode/src/inc/vnodeInt.h
+++ b/source/dnode/vnode/src/inc/vnodeInt.h
@ -157,7 +157,7 @@ int32_t tqCheckColModifiable(STQ* pTq, int64_t tbUid, int32_t colId);
 int32_t tqProcessCheckAlterInfoReq(STQ* pTq, char* msg, int32_t msgLen);
 int32_t tqProcessVgChangeReq(STQ* pTq, char* msg, int32_t msgLen);
 int32_t tqProcessVgDeleteReq(STQ* pTq, char* msg, int32_t msgLen);
-int32_t tqProcessOffsetCommitReq(STQ* pTq, char* msg, int32_t msgLen);
+int32_t tqProcessOffsetCommitReq(STQ* pTq, char* msg, int32_t msgLen, int64_t ver);
 int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg);
 int32_t tqProcessTaskDeployReq(STQ* pTq, char* msg, int32_t msgLen);
 int32_t tqProcessTaskDropReq(STQ* pTq, char* msg, int32_t msgLen);
@ -171,8 +171,8 @@ int32_t tqProcessTaskRetrieveReq(STQ* pTq, SRpcMsg* pMsg);
 int32_t tqProcessTaskRetrieveRsp(STQ* pTq, SRpcMsg* pMsg);
 int32_t tsdbGetStbIdList(SMeta* pMeta, int64_t suid, SArray* list);
-SSubmitReq* tdBlockToSubmit(const SArray* pBlocks, const STSchema* pSchema, bool createTb, int64_t suid,
+SSubmitReq* tdBlockToSubmit(SVnode* pVnode, const SArray* pBlocks, const STSchema* pSchema, bool createTb, int64_t suid,
-                            const char* stbFullName, int32_t vgId);
+                            const char* stbFullName, int32_t vgId, SBatchDeleteReq* pDeleteReq);
 // sma
 int32_t smaInit();
--- a/source/dnode/vnode/src/sma/smaTimeRange.c
+++ b/source/dnode/vnode/src/sma/smaTimeRange.c
@ -119,7 +119,7 @@ int32_t tdProcessTSmaCreateImpl(SSma *pSma, int64_t version, const char *pMsg) {
    SName stbFullName = {0};
    tNameFromString(&stbFullName, pCfg->dstTbName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
    SVCreateStbReq pReq = {0};
-    pReq.name = (char*)tNameGetTableName(&stbFullName);
+    pReq.name = (char *)tNameGetTableName(&stbFullName);
    pReq.suid = pCfg->dstTbUid;
    pReq.schemaRow = pCfg->schemaRow;
    pReq.schemaTag = pCfg->schemaTag;
@ -200,8 +200,10 @@ int32_t tdProcessTSmaInsertImpl(SSma *pSma, int64_t indexUid, const char *msg) {
    goto _err;
  }
-  SSubmitReq *pSubmitReq = tdBlockToSubmit((const SArray *)msg, pTsmaStat->pTSchema, true, pTsmaStat->pTSma->dstTbUid,
+  SBatchDeleteReq deleteReq;
-                                           pTsmaStat->pTSma->dstTbName, pTsmaStat->pTSma->dstVgId);
+  SSubmitReq     *pSubmitReq =
      tdBlockToSubmit(pSma->pVnode, (const SArray *)msg, pTsmaStat->pTSchema, true, pTsmaStat->pTSma->dstTbUid,
                      pTsmaStat->pTSma->dstTbName, pTsmaStat->pTSma->dstVgId, &deleteReq);
  if (!pSubmitReq) {
    smaError("vgId:%d, failed to gen submit blk while tsma insert for smaIndex %" PRIi64 " since %s", SMA_VID(pSma),
@ -230,4 +232,4 @@ int32_t tdProcessTSmaInsertImpl(SSma *pSma, int64_t indexUid, const char *msg) {
 _err:
  tdUnRefSmaStat(pSma, pStat);
  return TSDB_CODE_FAILED;
-}
+}
--- a/source/dnode/vnode/src/tq/tq.c
+++ b/source/dnode/vnode/src/tq/tq.c
@ -183,7 +183,7 @@ int32_t tqSendDataRsp(STQ* pTq, const SRpcMsg* pMsg, const SMqPollReq* pReq, con
  return 0;
 }
-int32_t tqProcessOffsetCommitReq(STQ* pTq, char* msg, int32_t msgLen) {
+int32_t tqProcessOffsetCommitReq(STQ* pTq, char* msg, int32_t msgLen, int64_t ver) {
  STqOffset offset = {0};
  SDecoder  decoder;
  tDecoderInit(&decoder, msg, msgLen);
@ -302,6 +302,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg) {
    tqError("tmq poll: consumer handle mismatch for consumer:%" PRId64
            ", in vgId:%d, subkey %s, handle consumer id %" PRId64,
            consumerId, TD_VID(pTq->pVnode), pReq->subKey, pHandle->consumerId);
    terrno = TSDB_CODE_TMQ_CONSUMER_MISMATCH;
    return -1;
  }
--- a/source/dnode/vnode/src/tq/tqRead.c
+++ b/source/dnode/vnode/src/tq/tqRead.c
@ -325,7 +325,7 @@ int32_t tqRetrieveDataBlock(SSDataBlock* pBlock, STqReader* pReader) {
    for (int32_t i = 0; i < colActual; i++) {
      SColumnInfoData* pColData = taosArrayGet(pBlock->pDataBlock, i);
      SCellVal         sVal = {0};
-      if (!tdSTSRowIterNext(&iter, pColData->info.colId, pColData->info.type, &sVal)) {
+      if (!tdSTSRowIterFetch(&iter, pColData->info.colId, pColData->info.type, &sVal)) {
        break;
      }
      if (colDataAppend(pColData, curRow, sVal.val, sVal.valType != TD_VTYPE_NORM) < 0) {
--- a/source/dnode/vnode/src/tq/tqSink.c
+++ b/source/dnode/vnode/src/tq/tqSink.c
@ -13,10 +13,44 @@
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 #include "tcommon.h"
 #include "tmsg.h"
 #include "tq.h"
-SSubmitReq* tdBlockToSubmit(const SArray* pBlocks, const STSchema* pTSchema, bool createTb, int64_t suid,
+int32_t tdBuildDeleteReq(SVnode* pVnode, const char* stbFullName, const SSDataBlock* pDataBlock,
-                            const char* stbFullName, int32_t vgId) {
+                         SBatchDeleteReq* deleteReq) {
  ASSERT(pDataBlock->info.type == STREAM_DELETE_RESULT);
  int32_t          totRow = pDataBlock->info.rows;
  SColumnInfoData* pTsCol = taosArrayGet(pDataBlock->pDataBlock, START_TS_COLUMN_INDEX);
  SColumnInfoData* pGidCol = taosArrayGet(pDataBlock->pDataBlock, GROUPID_COLUMN_INDEX);
  for (int32_t row = 0; row < totRow; row++) {
    int64_t ts = *(int64_t*)colDataGetData(pTsCol, row);
    /*int64_t     groupId = *(int64_t*)colDataGetData(pGidCol, row);*/
    int64_t groupId = 0;
    char*   name = buildCtbNameByGroupId(stbFullName, groupId);
    tqDebug("stream delete msg: groupId :%ld, name: %s", groupId, name);
    SMetaReader mr = {0};
    metaReaderInit(&mr, pVnode->pMeta, 0);
    if (metaGetTableEntryByName(&mr, name) < 0) {
      metaReaderClear(&mr);
      taosMemoryFree(name);
      return -1;
    }
    int64_t uid = mr.me.uid;
    metaReaderClear(&mr);
    taosMemoryFree(name);
    SSingleDeleteReq req = {
        .ts = ts,
        .uid = uid,
    };
    taosArrayPush(deleteReq->deleteReqs, &req);
  }
  return 0;
 }
 SSubmitReq* tdBlockToSubmit(SVnode* pVnode, const SArray* pBlocks, const STSchema* pTSchema, bool createTb,
                            int64_t suid, const char* stbFullName, int32_t vgId, SBatchDeleteReq* pDeleteReq) {
  SSubmitReq* ret = NULL;
  SArray*     schemaReqs = NULL;
  SArray*     schemaReqSz = NULL;
@ -33,10 +67,17 @@ SSubmitReq* tdBlockToSubmit(const SArray* pBlocks, const STSchema* pTSchema, boo
    schemaReqSz = taosArrayInit(sz, sizeof(int32_t));
    for (int32_t i = 0; i < sz; i++) {
      SSDataBlock* pDataBlock = taosArrayGet(pBlocks, i);
-      STagVal      tagVal = {
+      if (pDataBlock->info.type == STREAM_DELETE_RESULT) {
-               .cid = taosArrayGetSize(pDataBlock->pDataBlock) + 1,
+        int32_t padding1 = 0;
-               .type = TSDB_DATA_TYPE_UBIGINT,
+        void*   padding2 = taosMemoryMalloc(1);
-               .i64 = (int64_t)pDataBlock->info.groupId,
+        taosArrayPush(schemaReqSz, &padding1);
        taosArrayPush(schemaReqs, &padding2);
      }
      STagVal tagVal = {
          .cid = taosArrayGetSize(pDataBlock->pDataBlock) + 1,
          .type = TSDB_DATA_TYPE_UBIGINT,
          .i64 = (int64_t)pDataBlock->info.groupId,
      };
      STag* pTag = NULL;
      taosArrayClear(tagArray);
@ -94,7 +135,10 @@ SSubmitReq* tdBlockToSubmit(const SArray* pBlocks, const STSchema* pTSchema, boo
  int32_t cap = sizeof(SSubmitReq);
  for (int32_t i = 0; i < sz; i++) {
    SSDataBlock* pDataBlock = taosArrayGet(pBlocks, i);
-    int32_t      rows = pDataBlock->info.rows;
+    if (pDataBlock->info.type == STREAM_DELETE_RESULT) {
      continue;
    }
    int32_t rows = pDataBlock->info.rows;
    // TODO min
    int32_t rowSize = pDataBlock->info.rowSize;
    int32_t maxLen = TD_ROW_MAX_BYTES_FROM_SCHEMA(pTSchema);
@ -116,6 +160,11 @@ SSubmitReq* tdBlockToSubmit(const SArray* pBlocks, const STSchema* pTSchema, boo
  SSubmitBlk* blkHead = POINTER_SHIFT(ret, sizeof(SSubmitReq));
  for (int32_t i = 0; i < sz; i++) {
    SSDataBlock* pDataBlock = taosArrayGet(pBlocks, i);
    if (pDataBlock->info.type == STREAM_DELETE_RESULT) {
      pDeleteReq->suid = suid;
      tdBuildDeleteReq(pVnode, stbFullName, pDataBlock, pDeleteReq);
      continue;
    }
    blkHead->numOfRows = htonl(pDataBlock->info.rows);
    blkHead->sversion = htonl(pTSchema->version);
@ -177,17 +226,47 @@ SSubmitReq* tdBlockToSubmit(const SArray* pBlocks, const STSchema* pTSchema, boo
 }
 void tqTableSink(SStreamTask* pTask, void* vnode, int64_t ver, void* data) {
-  const SArray* pRes = (const SArray*)data;
+  const SArray*   pRes = (const SArray*)data;
-  SVnode*       pVnode = (SVnode*)vnode;
+  SVnode*         pVnode = (SVnode*)vnode;
  SBatchDeleteReq deleteReq = {0};
  tqDebug("vgId:%d, task %d write into table, block num: %d", TD_VID(pVnode), pTask->taskId, (int32_t)pRes->size);
  ASSERT(pTask->tbSink.pTSchema);
-  SSubmitReq* pReq = tdBlockToSubmit(pRes, pTask->tbSink.pTSchema, true, pTask->tbSink.stbUid,
+  deleteReq.deleteReqs = taosArrayInit(0, sizeof(SSingleDeleteReq));
-                                     pTask->tbSink.stbFullName, pVnode->config.vgId);
+  SSubmitReq* pReq = tdBlockToSubmit(pVnode, pRes, pTask->tbSink.pTSchema, true, pTask->tbSink.stbUid,
                                     pTask->tbSink.stbFullName, pVnode->config.vgId, &deleteReq);
  tqDebug("vgId:%d, task %d convert blocks over, put into write-queue", TD_VID(pVnode), pTask->taskId);
  int32_t code;
  int32_t len;
  tEncodeSize(tEncodeSBatchDeleteReq, &deleteReq, len, code);
  if (code < 0) {
    //
    ASSERT(0);
  }
  SEncoder encoder;
  void*    buf = rpcMallocCont(len + sizeof(SMsgHead));
  void*    abuf = POINTER_SHIFT(buf, sizeof(SMsgHead));
  tEncoderInit(&encoder, abuf, len);
  tEncodeSBatchDeleteReq(&encoder, &deleteReq);
  tEncoderClear(&encoder);
  ((SMsgHead*)buf)->vgId = pVnode->config.vgId;
  if (taosArrayGetSize(deleteReq.deleteReqs) != 0) {
    SRpcMsg msg = {
        .msgType = TDMT_VND_BATCH_DEL,
        .pCont = buf,
        .contLen = len + sizeof(SMsgHead),
    };
    if (tmsgPutToQueue(&pVnode->msgCb, WRITE_QUEUE, &msg) != 0) {
      tqDebug("failed to put into write-queue since %s", terrstr());
    }
  }
  taosArrayDestroy(deleteReq.deleteReqs);
  /*tPrintFixedSchemaSubmitReq(pReq, pTask->tbSink.pTSchema);*/
  // build write msg
  SRpcMsg msg = {
--- a/source/dnode/vnode/src/tsdb/tsdbRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbRead.c
@ -182,7 +182,7 @@ static int32_t setColumnIdSlotList(STsdbReader* pReader, SSDataBlock* pBlock) {
    if (IS_VAR_DATA_TYPE(pCol->info.type)) {
      pSupInfo->buildBuf[i] = taosMemoryMalloc(pCol->info.bytes);
-      tsdbInfo("-------------------%d\n", pCol->info.bytes);
+      // tsdbInfo("-------------------%d\n", pCol->info.bytes);
    }
  }
--- a/source/dnode/vnode/src/vnd/vnodeSvr.c
+++ b/source/dnode/vnode/src/vnd/vnodeSvr.c
@ -29,6 +29,7 @@ static int32_t vnodeProcessAlterConfigReq(SVnode *pVnode, int64_t version, void
 static int32_t vnodeProcessDropTtlTbReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp);
 static int32_t vnodeProcessTrimReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp);
 static int32_t vnodeProcessDeleteReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp);
 static int32_t vnodeProcessBatchDeleteReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp);
 int32_t vnodePreProcessWriteMsg(SVnode *pVnode, SRpcMsg *pMsg) {
  int32_t  code = 0;
@ -144,7 +145,7 @@ int32_t vnodeProcessWriteMsg(SVnode *pVnode, SRpcMsg *pMsg, int64_t version, SRp
  int32_t len;
  int32_t ret;
-  vTrace("vgId:%d, start to process write request %s, index:%" PRId64, TD_VID(pVnode), TMSG_INFO(pMsg->msgType),
+  vDebug("vgId:%d, start to process write request %s, index:%" PRId64, TD_VID(pVnode), TMSG_INFO(pMsg->msgType),
         version);
  pVnode->state.applied = version;
@ -190,6 +191,9 @@ int32_t vnodeProcessWriteMsg(SVnode *pVnode, SRpcMsg *pMsg, int64_t version, SRp
    case TDMT_VND_DELETE:
      if (vnodeProcessDeleteReq(pVnode, version, pReq, len, pRsp) < 0) goto _err;
      break;
    case TDMT_VND_BATCH_DEL:
      if (vnodeProcessBatchDeleteReq(pVnode, version, pReq, len, pRsp) < 0) goto _err;
      break;
    /* TQ */
    case TDMT_VND_MQ_VG_CHANGE:
      if (tqProcessVgChangeReq(pVnode->pTq, POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead)),
@ -204,7 +208,7 @@ int32_t vnodeProcessWriteMsg(SVnode *pVnode, SRpcMsg *pMsg, int64_t version, SRp
      break;
    case TDMT_VND_MQ_COMMIT_OFFSET:
      if (tqProcessOffsetCommitReq(pVnode->pTq, POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead)),
-                                   pMsg->contLen - sizeof(SMsgHead)) < 0) {
+                                   pMsg->contLen - sizeof(SMsgHead), version) < 0) {
        goto _err;
      }
      break;
@ -1053,6 +1057,24 @@ static int32_t vnodeProcessAlterConfigReq(SVnode *pVnode, int64_t version, void
  return 0;
 }
 static int32_t vnodeProcessBatchDeleteReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp) {
  SBatchDeleteReq deleteReq;
  SDecoder        decoder;
  tDecoderInit(&decoder, pReq, len);
  tDecodeSBatchDeleteReq(&decoder, &deleteReq);
  int32_t sz = taosArrayGetSize(deleteReq.deleteReqs);
  for (int32_t i = 0; i < sz; i++) {
    SSingleDeleteReq *pOneReq = taosArrayGet(deleteReq.deleteReqs, i);
    int32_t code = tsdbDeleteTableData(pVnode->pTsdb, version, deleteReq.suid, pOneReq->uid, pOneReq->ts, pOneReq->ts);
    if (code) {
      // TODO
    }
  }
  taosArrayDestroy(deleteReq.deleteReqs);
  return 0;
 }
 static int32_t vnodeProcessDeleteReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp) {
  int32_t     code = 0;
  SDecoder   *pCoder = &(SDecoder){0};
--- a/source/dnode/vnode/src/vnd/vnodeSync.c
+++ b/source/dnode/vnode/src/vnd/vnodeSync.c
@ -672,6 +672,18 @@ static void vnodeRestoreFinish(struct SSyncFSM *pFsm) {
  vDebug("vgId:%d, sync restore finished", pVnode->config.vgId);
 }
 static void vnodeBecomeFollower(struct SSyncFSM *pFsm) {
  SVnode *pVnode = pFsm->data;
  vDebug("vgId:%d, become follower", pVnode->config.vgId);
  // clear old leader resource
 }
 static void vnodeBecomeLeader(struct SSyncFSM *pFsm) {
  SVnode *pVnode = pFsm->data;
  vDebug("vgId:%d, become leader", pVnode->config.vgId);
 }
 static SSyncFSM *vnodeSyncMakeFsm(SVnode *pVnode) {
  SSyncFSM *pFsm = taosMemoryCalloc(1, sizeof(SSyncFSM));
  pFsm->data = pVnode;
@ -681,6 +693,8 @@ static SSyncFSM *vnodeSyncMakeFsm(SVnode *pVnode) {
  pFsm->FpGetSnapshotInfo = vnodeSyncGetSnapshot;
  pFsm->FpRestoreFinishCb = vnodeRestoreFinish;
  pFsm->FpLeaderTransferCb = vnodeLeaderTransfer;
  pFsm->FpBecomeLeaderCb = vnodeBecomeLeader;
  pFsm->FpBecomeFollowerCb = vnodeBecomeFollower;
  pFsm->FpReConfigCb = vnodeSyncReconfig;
  pFsm->FpSnapshotStartRead = vnodeSnapshotStartRead;
  pFsm->FpSnapshotStopRead = vnodeSnapshotStopRead;
--- a/source/libs/catalog/src/ctgUtil.c
+++ b/source/libs/catalog/src/ctgUtil.c
@ -883,6 +883,32 @@ int32_t ctgGetVgInfoFromHashValue(SCatalog *pCtg, SDBVgInfo *dbInfo, const SName
  CTG_RET(code);
 }
 int32_t ctgHashValueComp(void const *lp, void const *rp) {
  uint32_t *key = (uint32_t *)lp;
  SVgroupInfo *pVg = *(SVgroupInfo **)rp;
  if (*key < pVg->hashBegin) {
    return -1;
  } else if (*key > pVg->hashEnd) {
    return 1;
  }
  return 0;
 }
 int ctgVgInfoComp(const void* lp, const void* rp) {
  SVgroupInfo *pLeft = *(SVgroupInfo **)lp;
  SVgroupInfo *pRight = *(SVgroupInfo **)rp;
  if (pLeft->hashBegin < pRight->hashBegin) {
    return -1;
  } else if (pLeft->hashBegin > pRight->hashBegin) {
    return 1;
  }
  return 0;
 }
 int32_t ctgGetVgInfosFromHashValue(SCatalog *pCtg, SCtgTaskReq* tReq, SDBVgInfo *dbInfo, SCtgTbHashsCtx *pCtx, char* dbFName, SArray* pNames, bool update) {
  int32_t code = 0;
  SCtgTask* pTask = tReq->pTask;
@ -923,9 +949,19 @@ int32_t ctgGetVgInfosFromHashValue(SCatalog *pCtg, SCtgTaskReq* tReq, SDBVgInfo
      }
    }
    taosHashCancelIterate(dbInfo->vgHash, pIter);
    return TSDB_CODE_SUCCESS;
  }
  SArray* pVgList = taosArrayInit(vgNum, POINTER_BYTES);
  void *pIter = taosHashIterate(dbInfo->vgHash, NULL);
  while (pIter) {
    taosArrayPush(pVgList, &pIter);
    pIter = taosHashIterate(dbInfo->vgHash, pIter);
  }
  taosArraySort(pVgList, ctgVgInfoComp);
  char tbFullName[TSDB_TABLE_FNAME_LEN];
  sprintf(tbFullName, "%s.", dbFName);
  int32_t offset = strlen(tbFullName);
@ -940,25 +976,20 @@ int32_t ctgGetVgInfosFromHashValue(SCatalog *pCtg, SCtgTaskReq* tReq, SDBVgInfo
    uint32_t hashValue = (*fp)(tbFullName, (uint32_t)tbNameLen);
-    void *pIter = taosHashIterate(dbInfo->vgHash, NULL);
+    SVgroupInfo **p = taosArraySearch(pVgList, &hashValue, ctgHashValueComp, TD_EQ);
    while (pIter) {
      vgInfo = pIter;
      if (hashValue >= vgInfo->hashBegin && hashValue <= vgInfo->hashEnd) {
        taosHashCancelIterate(dbInfo->vgHash, pIter);
        break;
      }
      pIter = taosHashIterate(dbInfo->vgHash, pIter);
      vgInfo = NULL;
    }
-    if (NULL == vgInfo) {
+    if (NULL == p) {
      ctgError("no hash range found for hash value [%u], db:%s, numOfVgId:%d", hashValue, dbFName, taosHashGetSize(dbInfo->vgHash));
      ASSERT(0);
      taosArrayDestroy(pVgList);
      CTG_ERR_RET(TSDB_CODE_CTG_INTERNAL_ERROR);
    }
    vgInfo = *p;
    SVgroupInfo* pNewVg = taosMemoryMalloc(sizeof(SVgroupInfo));
    if (NULL == pNewVg) {
      taosArrayDestroy(pVgList);
      CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
    }
@ -977,6 +1008,8 @@ int32_t ctgGetVgInfosFromHashValue(SCatalog *pCtg, SCtgTaskReq* tReq, SDBVgInfo
    }    
  }
  taosArrayDestroy(pVgList);
  CTG_RET(code);
 }
--- a/source/libs/executor/inc/executorimpl.h
+++ b/source/libs/executor/inc/executorimpl.h
@ -52,13 +52,6 @@ typedef int32_t (*__block_search_fn_t)(char* data, int32_t num, int64_t key, int
 #define NEEDTO_COMPRESS_QUERY(size) ((size) > tsCompressColData ? 1 : 0)
 #define START_TS_COLUMN_INDEX             0
 #define END_TS_COLUMN_INDEX               1
 #define UID_COLUMN_INDEX                  2
 #define GROUPID_COLUMN_INDEX              3
 #define CALCULATE_START_TS_COLUMN_INDEX   4
 #define CALCULATE_END_TS_COLUMN_INDEX     5
 enum {
  // when this task starts to execute, this status will set
  TASK_NOT_COMPLETED = 0x1u,
@ -741,6 +734,7 @@ typedef struct STimeSliceOperatorInfo {
  SArray*                 pPrevRow;      // SArray<SGroupValue>
  SArray*                 pNextRow;      // SArray<SGroupValue>
  SArray*                 pLinearInfo;   // SArray<SFillLinearInfo>
  bool                    fillLastPoint;
  bool                    isPrevRowSet;
  bool                    isNextRowSet;
  int32_t                 fillType;      // fill type
@ -1017,6 +1011,7 @@ bool isInTimeWindow(STimeWindow* pWin, TSKEY ts, int64_t gap);
 int32_t updateSessionWindowInfo(SResultWindowInfo* pWinInfo, TSKEY* pStartTs,
    TSKEY* pEndTs, int32_t rows, int32_t start, int64_t gap, SHashObj* pStDeleted);
 bool functionNeedToExecute(SqlFunctionCtx* pCtx);
 bool isOverdue(TSKEY ts, STimeWindowAggSupp* pSup);
 bool isCloseWindow(STimeWindow* pWin, STimeWindowAggSupp* pSup);
 bool isDeletedWindow(STimeWindow* pWin, uint64_t groupId, SAggSupporter* pSup);
 void appendOneRow(SSDataBlock* pBlock, TSKEY* pStartTs, TSKEY* pEndTs, uint64_t* pUid);
--- a/source/libs/executor/inc/tfill.h
+++ b/source/libs/executor/inc/tfill.h
@ -37,7 +37,6 @@ typedef struct SFillLinearInfo {
  SPoint  start;
  SPoint  end;
  bool    hasNull;
  bool    fillLastPoint;
  int16_t type;
  int32_t bytes;
 } SFillLinearInfo;
--- a/source/libs/executor/src/executorimpl.c
+++ b/source/libs/executor/src/executorimpl.c
@ -1277,8 +1277,12 @@ void destroyTableQueryInfoImpl(STableQueryInfo* pTableQueryInfo) {
 }
 void setResultRowInitCtx(SResultRow* pResult, SqlFunctionCtx* pCtx, int32_t numOfOutput, int32_t* rowEntryInfoOffset) {
  bool init = false;
  for (int32_t i = 0; i < numOfOutput; ++i) {
    pCtx[i].resultInfo = getResultEntryInfo(pResult, i, rowEntryInfoOffset);
    if (init) {
      continue;
    }
    struct SResultRowEntryInfo* pResInfo = pCtx[i].resultInfo;
    if (isRowEntryCompleted(pResInfo) && isRowEntryInitialized(pResInfo)) {
@ -1295,6 +1299,8 @@ void setResultRowInitCtx(SResultRow* pResult, SqlFunctionCtx* pCtx, int32_t numO
      } else {
        pResInfo->initialized = true;
      }
    } else {
      init = true;
    }
  }
 }
@ -1943,6 +1949,7 @@ int32_t loadRemoteDataCallback(void* param, SDataBuf* pMsg, int32_t code) {
  SExchangeInfo* pExchangeInfo = taosAcquireRef(exchangeObjRefPool, pWrapper->exchangeId);
  if (pExchangeInfo == NULL) {
    qWarn("failed to acquire exchange operator, since it may have been released");
    taosMemoryFree(pMsg->pData);
    return TSDB_CODE_SUCCESS;
  }
@ -1963,6 +1970,7 @@ int32_t loadRemoteDataCallback(void* param, SDataBuf* pMsg, int32_t code) {
    qDebug("%s fetch rsp received, index:%d, blocks:%d, rows:%d", pSourceDataInfo->taskId, index, pRsp->numOfBlocks,
           pRsp->numOfRows);
  } else {
    taosMemoryFree(pMsg->pData);
    pSourceDataInfo->code = code;
    qDebug("%s fetch rsp received, index:%d, error:%d", pSourceDataInfo->taskId, index, tstrerror(code));
  }
@ -3416,6 +3424,7 @@ int32_t doInitAggInfoSup(SAggSupporter* pAggSup, SqlFunctionCtx* pCtx, int32_t n
  }
  int32_t code = createDiskbasedBuf(&pAggSup->pResultBuf, defaultPgsz, defaultBufsz, pKey, tsTempDir);
  if (code != TSDB_CODE_SUCCESS) {
    qError("Create agg result buf failed since %s", tstrerror(code));
    return code;
  }
@ -3435,7 +3444,11 @@ int32_t initAggInfo(SExprSupp* pSup, SAggSupporter* pAggSup, SExprInfo* pExprInf
    return code;
  }
-  doInitAggInfoSup(pAggSup, pSup->pCtx, numOfCols, keyBufSize, pkey);
+  code = doInitAggInfoSup(pAggSup, pSup->pCtx, numOfCols, keyBufSize, pkey);
  if (code != TSDB_CODE_SUCCESS) {
    return code;
  }
  for (int32_t i = 0; i < numOfCols; ++i) {
    pSup->pCtx[i].pBuf = pAggSup->pResultBuf;
  }
--- a/source/libs/executor/src/joinoperator.c
+++ b/source/libs/executor/src/joinoperator.c
@ -132,6 +132,8 @@ void destroyMergeJoinOperator(void* param, int32_t numOfOutput) {
  SJoinOperatorInfo* pJoinOperator = (SJoinOperatorInfo*)param;
  nodesDestroyNode(pJoinOperator->pCondAfterMerge);
  pJoinOperator->pRes = blockDataDestroy(pJoinOperator->pRes);
  taosMemoryFreeClear(param);
 }
--- a/source/libs/executor/src/scanoperator.c
+++ b/source/libs/executor/src/scanoperator.c
@ -319,6 +319,7 @@ static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanInfo* pTableSca
             pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows);
      return TSDB_CODE_SUCCESS;
    } else {
      qDebug("%s failed to load SMA, since not all columns have SMA", GET_TASKID(pTaskInfo));
      *status = FUNC_DATA_REQUIRED_DATA_LOAD;
    }
  }
@ -326,20 +327,19 @@ static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanInfo* pTableSca
  ASSERT(*status == FUNC_DATA_REQUIRED_DATA_LOAD);
  // try to filter data block according to sma info
-  if (pTableScanInfo->pFilterNode != NULL) {
+  if (pTableScanInfo->pFilterNode != NULL && (!loadSMA)) {
-    if (!loadSMA) {
+    bool success = doLoadBlockSMA(pTableScanInfo, pBlock, pTaskInfo);
-      doLoadBlockSMA(pTableScanInfo, pBlock, pTaskInfo);
+    if (success) {
-    }
+      size_t size = taosArrayGetSize(pBlock->pDataBlock);
      bool   keep = doFilterByBlockSMA(pTableScanInfo->pFilterNode, pBlock->pBlockAgg, size, pBlockInfo->rows);
      if (!keep) {
        qDebug("%s data block filter out by block SMA, brange:%" PRId64 "-%" PRId64 ", rows:%d", GET_TASKID(pTaskInfo),
               pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows);
        pCost->filterOutBlocks += 1;
        (*status) = FUNC_DATA_REQUIRED_FILTEROUT;
-    bool keep = doFilterByBlockSMA(pTableScanInfo->pFilterNode, pBlock->pBlockAgg, taosArrayGetSize(pBlock->pDataBlock),
+        return TSDB_CODE_SUCCESS;
-                                   pBlockInfo->rows);
+      }
    if (!keep) {
      qDebug("%s data block filter out by block SMA, brange:%" PRId64 "-%" PRId64 ", rows:%d", GET_TASKID(pTaskInfo),
             pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows);
      pCost->filterOutBlocks += 1;
      (*status) = FUNC_DATA_REQUIRED_FILTEROUT;
      return TSDB_CODE_SUCCESS;
    }
  }
@ -1174,10 +1174,15 @@ static void checkUpdateData(SStreamScanInfo* pInfo, bool invertible, SSDataBlock
  for (int32_t rowId = 0; rowId < pBlock->info.rows; rowId++) {
    SResultRowInfo dumyInfo;
    dumyInfo.cur.pageId = -1;
-    STimeWindow win = getActiveTimeWindow(NULL, &dumyInfo, tsCol[rowId], &pInfo->interval, TSDB_ORDER_ASC);
+    bool isClosed = false;
    STimeWindow win = {.skey = INT64_MIN, .ekey = INT64_MAX};
    if (isOverdue(tsCol[rowId], &pInfo->twAggSup)) {
      win = getActiveTimeWindow(NULL, &dumyInfo, tsCol[rowId], &pInfo->interval, TSDB_ORDER_ASC);
      isClosed = isCloseWindow(&win, &pInfo->twAggSup);
    }
    // must check update info first.
    bool update = updateInfoIsUpdated(pInfo->pUpdateInfo, pBlock->info.uid, tsCol[rowId]);
-    if ((update || (isSignleIntervalWindow(pInfo) && isCloseWindow(&win, &pInfo->twAggSup) &&
+    if ((update || (isSignleIntervalWindow(pInfo) && isClosed &&
        isDeletedWindow(&win, pBlock->info.groupId, pInfo->sessionSup.pIntervalAggSup))) && out) {
      appendOneRow(pInfo->pUpdateDataRes, tsCol + rowId, tsCol + rowId, &pBlock->info.uid);
    }
@ -2458,81 +2463,6 @@ static SSDataBlock* doTagScan(SOperatorInfo* pOperator) {
  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
 #if 0
  int32_t maxNumOfTables = (int32_t)pResultInfo->capacity;
  STagScanInfo *pInfo = pOperator->info;
  SSDataBlock  *pRes = pInfo->pRes;
  int32_t count = 0;
  SArray* pa = GET_TABLEGROUP(pRuntimeEnv, 0);
  int32_t functionId = getExprFunctionId(&pOperator->exprSupp.pExprInfo[0]);
  if (functionId == FUNCTION_TID_TAG) { // return the tags & table Id
    assert(pQueryAttr->numOfOutput == 1);
    SExprInfo* pExprInfo = &pOperator->exprSupp.pExprInfo[0];
    int32_t rsize = pExprInfo->base.resSchema.bytes;
    count = 0;
    int16_t bytes = pExprInfo->base.resSchema.bytes;
    int16_t type  = pExprInfo->base.resSchema.type;
    for(int32_t i = 0; i < pQueryAttr->numOfTags; ++i) {
      if (pQueryAttr->tagColList[i].colId == pExprInfo->base.pColumns->info.colId) {
        bytes = pQueryAttr->tagColList[i].bytes;
        type = pQueryAttr->tagColList[i].type;
        break;
      }
    }
    SColumnInfoData* pColInfo = taosArrayGet(pRes->pDataBlock, 0);
    while(pInfo->curPos < pInfo->totalTables && count < maxNumOfTables) {
      int32_t i = pInfo->curPos++;
      STableQueryInfo *item = taosArrayGetP(pa, i);
      char *output = pColInfo->pData + count * rsize;
      varDataSetLen(output, rsize - VARSTR_HEADER_SIZE);
      output = varDataVal(output);
      STableId* id = TSDB_TABLEID(item->pTable);
      *(int16_t *)output = 0;
      output += sizeof(int16_t);
      *(int64_t *)output = id->uid;  // memory align problem, todo serialize
      output += sizeof(id->uid);
      *(int32_t *)output = id->tid;
      output += sizeof(id->tid);
      *(int32_t *)output = pQueryAttr->vgId;
      output += sizeof(pQueryAttr->vgId);
      char* data = NULL;
      if (pExprInfo->base.pColumns->info.colId == TSDB_TBNAME_COLUMN_INDEX) {
        data = tsdbGetTableName(item->pTable);
      } else {
        data = tsdbGetTableTagVal(item->pTable, pExprInfo->base.pColumns->info.colId, type, bytes);
      }
      doSetTagValueToResultBuf(output, data, type, bytes);
      count += 1;
    }
    //qDebug("QInfo:0x%"PRIx64" create (tableId, tag) info completed, rows:%d", GET_TASKID(pRuntimeEnv), count);
  } else if (functionId == FUNCTION_COUNT) {// handle the "count(tbname)" query
    SColumnInfoData* pColInfo = taosArrayGet(pRes->pDataBlock, 0);
    *(int64_t*)pColInfo->pData = pInfo->totalTables;
    count = 1;
    pOperator->status = OP_EXEC_DONE;
    //qDebug("QInfo:0x%"PRIx64" create count(tbname) query, res:%d rows:1", GET_TASKID(pRuntimeEnv), count);
  } else {  // return only the tags|table name etc.
 #endif
  STagScanInfo* pInfo = pOperator->info;
  SExprInfo*    pExprInfo = &pOperator->exprSupp.pExprInfo[0];
  SSDataBlock*  pRes = pInfo->pRes;
@ -2610,6 +2540,8 @@ static void destroyTagScanOperatorInfo(void* param, int32_t numOfOutput) {
  STagScanInfo* pInfo = (STagScanInfo*)param;
  pInfo->pRes = blockDataDestroy(pInfo->pRes);
  taosArrayDestroy(pInfo->pColMatchInfo);
  taosMemoryFreeClear(param);
 }
--- a/source/libs/executor/src/timewindowoperator.c
+++ b/source/libs/executor/src/timewindowoperator.c
@ -851,23 +851,34 @@ static int32_t saveResult(int64_t ts, int32_t pageId, int32_t offset, uint64_t g
  return TSDB_CODE_SUCCESS;
 }
 static int32_t saveWinResult(int64_t ts, int32_t pageId, int32_t offset, uint64_t groupId, SHashObj* pUpdatedMap) {
  SResKeyPos* newPos = taosMemoryMalloc(sizeof(SResKeyPos) + sizeof(uint64_t));
  if (newPos == NULL) {
    return TSDB_CODE_OUT_OF_MEMORY;
  }
  newPos->groupId = groupId;
  newPos->pos = (SResultRowPosition){.pageId = pageId, .offset = offset};
  *(int64_t*)newPos->key = ts;
  SWinRes key = {.ts = ts, .groupId = groupId};
  if (taosHashPut(pUpdatedMap, &key, sizeof(SWinRes), &newPos, sizeof(void*)) != TSDB_CODE_SUCCESS) {
    taosMemoryFree(newPos);
  }
  return TSDB_CODE_SUCCESS;
 }
 static int32_t saveWinResultRow(SResultRow* result, uint64_t groupId, SHashObj* pUpdatedMap) {
  return saveWinResult(result->win.skey, result->pageId, result->offset, groupId, pUpdatedMap);;
 }
 static int32_t saveResultRow(SResultRow* result, uint64_t groupId, SArray* pUpdated) {
  return saveResult(result->win.skey, result->pageId, result->offset, groupId, pUpdated);
 }
-static void removeResult(SArray* pUpdated, SWinRes* pKey) {
+static void removeResults(SArray* pWins, SHashObj* pUpdatedMap) {
  int32_t size = taosArrayGetSize(pUpdated);
  int32_t index = binarySearchCom(pUpdated, size, pKey, TSDB_ORDER_DESC, compareResKey);
  if (index >= 0 && 0 == compareResKey(pKey, pUpdated, index)) {
    taosArrayRemove(pUpdated, index);
  }
 }
 static void removeResults(SArray* pWins, SArray* pUpdated) {
  int32_t size = taosArrayGetSize(pWins);
  for (int32_t i = 0; i < size; i++) {
    SWinRes* pW = taosArrayGet(pWins, i);
-    removeResult(pUpdated, pW);
+    taosHashRemove(pUpdatedMap, pW, sizeof(SWinRes));
  }
 }
@ -894,11 +905,14 @@ int32_t compareWinRes(void* pKey, void* data, int32_t index) {
  return -1;
 }
-static void removeDeleteResults(SArray* pUpdated, SArray* pDelWins) {
+static void removeDeleteResults(SHashObj* pUpdatedMap, SArray* pDelWins) {
-  int32_t upSize = taosArrayGetSize(pUpdated);
+  if (!pUpdatedMap || taosHashGetSize(pUpdatedMap) == 0) {
    return;
  } 
  int32_t delSize = taosArrayGetSize(pDelWins);
-  for (int32_t i = 0; i < upSize; i++) {
+  void* pIte = NULL;
-    SResKeyPos* pResKey = taosArrayGetP(pUpdated, i);
+  while ((pIte = taosHashIterate(pUpdatedMap, pIte)) != NULL) {
    SResKeyPos* pResKey = (SResKeyPos*)pIte;
    int32_t     index = binarySearchCom(pDelWins, delSize, pResKey, TSDB_ORDER_DESC, compareWinRes);
    if (index >= 0 && 0 == compareWinRes(pResKey, pDelWins, index)) {
      taosArrayRemove(pDelWins, index);
@ -914,7 +928,7 @@ bool isOverdue(TSKEY ts, STimeWindowAggSupp* pSup) {
 bool isCloseWindow(STimeWindow* pWin, STimeWindowAggSupp* pSup) { return isOverdue(pWin->ekey, pSup); }
 static void hashIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResultRowInfo, SSDataBlock* pBlock,
-                            int32_t scanFlag, SArray* pUpdated) {
+                            int32_t scanFlag, SHashObj* pUpdatedMap) {
  SIntervalAggOperatorInfo* pInfo = (SIntervalAggOperatorInfo*)pOperatorInfo->info;
  SExecTaskInfo* pTaskInfo = pOperatorInfo->pTaskInfo;
@ -940,7 +954,7 @@ static void hashIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResul
    }
    if (pInfo->execModel == OPTR_EXEC_MODEL_STREAM && pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE) {
-      saveResultRow(pResult, tableGroupId, pUpdated);
+      saveWinResultRow(pResult, tableGroupId, pUpdatedMap);
      setResultBufPageDirty(pInfo->aggSup.pResultBuf, &pResultRowInfo->cur);
    }
  }
@ -997,7 +1011,7 @@ static void hashIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResul
    }
    if (pInfo->execModel == OPTR_EXEC_MODEL_STREAM && pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE) {
-      saveResultRow(pResult, tableGroupId, pUpdated);
+      saveWinResultRow(pResult, tableGroupId, pUpdatedMap);
      setResultBufPageDirty(pInfo->aggSup.pResultBuf, &pResultRowInfo->cur);
    }
@ -1437,7 +1451,7 @@ static void doClearWindows(SAggSupporter* pAggSup, SExprSupp* pSup1, SInterval*
  }
 }
-static int32_t getAllIntervalWindow(SHashObj* pHashMap, SArray* resWins) {
+static int32_t getAllIntervalWindow(SHashObj* pHashMap, SHashObj* resWins) {
  void*  pIte = NULL;
  size_t keyLen = 0;
  while ((pIte = taosHashIterate(pHashMap, pIte)) != NULL) {
@ -1446,7 +1460,7 @@ static int32_t getAllIntervalWindow(SHashObj* pHashMap, SArray* resWins) {
    ASSERT(keyLen == GET_RES_WINDOW_KEY_LEN(sizeof(TSKEY)));
    TSKEY               ts = *(int64_t*)((char*)key + sizeof(uint64_t));
    SResultRowPosition* pPos = (SResultRowPosition*)pIte;
-    int32_t             code = saveResult(ts, pPos->pageId, pPos->offset, groupId, resWins);
+    int32_t             code = saveWinResult(ts, pPos->pageId, pPos->offset, groupId, resWins);
    if (code != TSDB_CODE_SUCCESS) {
      return code;
    }
@ -1455,7 +1469,7 @@ static int32_t getAllIntervalWindow(SHashObj* pHashMap, SArray* resWins) {
 }
 static int32_t closeIntervalWindow(SHashObj* pHashMap, STimeWindowAggSupp* pSup, SInterval* pInterval,
-                                   SHashObj* pPullDataMap, SArray* closeWins, SArray* pRecyPages,
+                                   SHashObj* pPullDataMap, SHashObj* closeWins, SArray* pRecyPages,
                                   SDiskbasedBuf* pDiscBuf) {
  qDebug("===stream===close interval window");
  void*  pIte = NULL;
@ -1487,7 +1501,7 @@ static int32_t closeIntervalWindow(SHashObj* pHashMap, STimeWindowAggSupp* pSup,
      }
      SResultRowPosition* pPos = (SResultRowPosition*)pIte;
      if (pSup->calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) {
-        int32_t code = saveResult(ts, pPos->pageId, pPos->offset, groupId, closeWins);
+        int32_t code = saveWinResult(ts, pPos->pageId, pPos->offset, groupId, closeWins);
        if (code != TSDB_CODE_SUCCESS) {
          return code;
        }
@ -1577,11 +1591,14 @@ static SSDataBlock* doStreamIntervalAgg(SOperatorInfo* pOperator) {
  SOperatorInfo* downstream = pOperator->pDownstream[0];
  SArray* pUpdated = taosArrayInit(4, POINTER_BYTES);  // SResKeyPos
  _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_TIMESTAMP);
  SHashObj* pUpdatedMap = taosHashInit(1024, hashFn, false, HASH_NO_LOCK);
  while (1) {
    SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
    if (pBlock == NULL) {
      break;
    }
    // qInfo("===stream===%ld", pBlock->info.version);
    printDataBlock(pBlock, "single interval recv");
    if (pBlock->info.type == STREAM_CLEAR) {
@ -1594,7 +1611,7 @@ static SSDataBlock* doStreamIntervalAgg(SOperatorInfo* pOperator) {
      doDeleteSpecifyIntervalWindow(&pInfo->aggSup, pBlock, pInfo->pDelWins, &pInfo->interval);
      continue;
    } else if (pBlock->info.type == STREAM_GET_ALL) {
-      getAllIntervalWindow(pInfo->aggSup.pResultRowHashTable, pUpdated);
+      getAllIntervalWindow(pInfo->aggSup.pResultRowHashTable, pUpdatedMap);
      continue;
    }
@ -1617,17 +1634,24 @@ static SSDataBlock* doStreamIntervalAgg(SOperatorInfo* pOperator) {
    }
    pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey);
-    hashIntervalAgg(pOperator, &pInfo->binfo.resultRowInfo, pBlock, MAIN_SCAN, pUpdated);
+    hashIntervalAgg(pOperator, &pInfo->binfo.resultRowInfo, pBlock, MAIN_SCAN, pUpdatedMap);
  }
  pOperator->status = OP_RES_TO_RETURN;
-  closeIntervalWindow(pInfo->aggSup.pResultRowHashTable, &pInfo->twAggSup, &pInfo->interval, NULL, pUpdated,
+  closeIntervalWindow(pInfo->aggSup.pResultRowHashTable, &pInfo->twAggSup, &pInfo->interval, NULL, pUpdatedMap,
                      pInfo->pRecycledPages, pInfo->aggSup.pResultBuf);
  void* pIte = NULL;
  while ((pIte = taosHashIterate(pUpdatedMap, pIte)) != NULL) {
    taosArrayPush(pUpdated, pIte);
  }
  taosHashCleanup(pUpdatedMap);
  taosArraySort(pUpdated, resultrowComparAsc);
  finalizeUpdatedResult(pOperator->exprSupp.numOfExprs, pInfo->aggSup.pResultBuf, pUpdated, pSup->rowEntryInfoOffset);
  initMultiResInfoFromArrayList(&pInfo->groupResInfo, pUpdated);
  blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity);
-  removeDeleteResults(pUpdated, pInfo->pDelWins);
+  removeDeleteResults(pUpdatedMap, pInfo->pDelWins);
  doBuildDeleteResult(pInfo->pDelWins, &pInfo->delIndex, pInfo->pDelRes);
  if (pInfo->pDelRes->info.rows > 0) {
    return pInfo->pDelRes;
@ -1695,7 +1719,7 @@ void destroyStreamFinalIntervalOperatorInfo(void* param, int32_t numOfOutput) {
 static bool allInvertible(SqlFunctionCtx* pFCtx, int32_t numOfCols) {
  for (int32_t i = 0; i < numOfCols; i++) {
-    if (!fmIsInvertible(pFCtx[i].functionId)) {
+    if (fmIsUserDefinedFunc(pFCtx[i].functionId) || !fmIsInvertible(pFCtx[i].functionId)) {
      return false;
    }
  }
@ -2088,8 +2112,10 @@ static void doKeepNextRows(STimeSliceOperatorInfo* pSliceInfo, const SSDataBlock
  pSliceInfo->isNextRowSet = true;
 }
-static void doKeepLinearInfo(STimeSliceOperatorInfo* pSliceInfo, const SSDataBlock* pBlock, int32_t rowIndex) {
+static void doKeepLinearInfo(STimeSliceOperatorInfo* pSliceInfo, const SSDataBlock* pBlock, int32_t rowIndex,
                             bool isLastRow) {
  int32_t numOfCols = taosArrayGetSize(pBlock->pDataBlock);
  bool fillLastPoint = pSliceInfo->fillLastPoint;
  for (int32_t i = 0; i < numOfCols; ++i) {
    SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, i);
    SColumnInfoData* pTsCol = taosArrayGet(pBlock->pDataBlock, pSliceInfo->tsCol.slotId);
@ -2097,16 +2123,22 @@ static void doKeepLinearInfo(STimeSliceOperatorInfo* pSliceInfo, const SSDataBlo
    // null data should not be kept since it can not be used to perform interpolation
    if (!colDataIsNull_s(pColInfoData, i)) {
-      int64_t startKey = *(int64_t*)colDataGetData(pTsCol, rowIndex);
+      if (isLastRow) {
-      int64_t endKey   = *(int64_t*)colDataGetData(pTsCol, rowIndex + 1);
+        pLinearInfo->start.key = *(int64_t*)colDataGetData(pTsCol, rowIndex);
-      pLinearInfo->start.key = startKey;
+        memcpy(pLinearInfo->start.val, colDataGetData(pColInfoData, rowIndex), pLinearInfo->bytes);
-      pLinearInfo->end.key   = endKey;
+      } else if (fillLastPoint) {
        pLinearInfo->end.key = *(int64_t*)colDataGetData(pTsCol, rowIndex);
        memcpy(pLinearInfo->end.val, colDataGetData(pColInfoData, rowIndex), pLinearInfo->bytes);
      } else {
        pLinearInfo->start.key = *(int64_t*)colDataGetData(pTsCol, rowIndex);
        pLinearInfo->end.key = *(int64_t*)colDataGetData(pTsCol, rowIndex + 1);
-      char* val;
+        char* val;
-      val = colDataGetData(pColInfoData, rowIndex);
+        val = colDataGetData(pColInfoData, rowIndex);
-      memcpy(pLinearInfo->start.val, val, pLinearInfo->bytes);
+        memcpy(pLinearInfo->start.val, val, pLinearInfo->bytes);
-      val = colDataGetData(pColInfoData, rowIndex + 1);
+        val = colDataGetData(pColInfoData, rowIndex + 1);
-      memcpy(pLinearInfo->end.val, val, pLinearInfo->bytes);
+        memcpy(pLinearInfo->end.val, val, pLinearInfo->bytes);
      }
      pLinearInfo->hasNull = false;
    } else {
@ -2114,6 +2146,8 @@ static void doKeepLinearInfo(STimeSliceOperatorInfo* pSliceInfo, const SSDataBlo
    }
  }
  pSliceInfo->fillLastPoint = isLastRow ? true : false;
 }
 static void genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp* pExprSup,
@ -2270,7 +2304,7 @@ static int32_t initFillLinearInfo(STimeSliceOperatorInfo* pInfo, SSDataBlock* pB
  }
  pInfo->pLinearInfo = taosArrayInit(4, sizeof(SFillLinearInfo));
-  if (pInfo->pNextRow == NULL) {
+  if (pInfo->pLinearInfo == NULL) {
    return TSDB_CODE_OUT_OF_MEMORY;
  }
@ -2284,15 +2318,20 @@ static int32_t initFillLinearInfo(STimeSliceOperatorInfo* pInfo, SSDataBlock* pB
    linearInfo.start.val = taosMemoryCalloc(1, pColInfo->info.bytes);
    linearInfo.end.val   = taosMemoryCalloc(1, pColInfo->info.bytes);
    linearInfo.hasNull   = false;
    linearInfo.fillLastPoint = false;
    linearInfo.type  = pColInfo->info.type;
    linearInfo.bytes = pColInfo->info.bytes;
    taosArrayPush(pInfo->pLinearInfo, &linearInfo);
  }
  pInfo->fillLastPoint = false;
  return TSDB_CODE_SUCCESS;
 }
 static bool needToFillLastPoint(STimeSliceOperatorInfo* pSliceInfo) {
  return (pSliceInfo->fillLastPoint == true && pSliceInfo->fillType == TSDB_FILL_LINEAR);
 }
 static int32_t initKeeperInfo(STimeSliceOperatorInfo* pInfo, SSDataBlock* pBlock) {
  int32_t code;
  code = initPrevRowsKeeper(pInfo, pBlock);
@ -2357,6 +2396,23 @@ static SSDataBlock* doTimeslice(SOperatorInfo* pOperator) {
    for (int32_t i = 0; i < pBlock->info.rows; ++i) {
      int64_t ts = *(int64_t*)colDataGetData(pTsCol, i);
      if (i == 0 && needToFillLastPoint(pSliceInfo)) { // first row in current block
        doKeepLinearInfo(pSliceInfo, pBlock, i, false);
        while (pSliceInfo->current < ts && pSliceInfo->current <= pSliceInfo->win.ekey) {
          genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock);
          pSliceInfo->current =
              taosTimeAdd(pSliceInfo->current, pInterval->interval, pInterval->intervalUnit, pInterval->precision);
          if (pResBlock->info.rows >= pResBlock->info.capacity) {
            break;
          }
        }
        if (pSliceInfo->current > pSliceInfo->win.ekey) {
          doSetOperatorCompleted(pOperator);
          break;
        }
      }
      if (ts == pSliceInfo->current) {
        for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) {
          SExprInfo* pExprInfo = &pOperator->exprSupp.pExprInfo[j];
@ -2375,9 +2431,10 @@ static SSDataBlock* doTimeslice(SOperatorInfo* pOperator) {
        // for linear interpolation, always fill value between this and next points;
        // if its the first point in data block, also fill values between previous(if there's any) and this point;
-        // if its the last point in data block, no need to fill, but reserve this point as the start value for next data block.
+        // if its the last point in data block, no need to fill, but reserve this point as the start value and do
        // the interpolation when processing next data block.
        if (pSliceInfo->fillType == TSDB_FILL_LINEAR) {
-          doKeepLinearInfo(pSliceInfo, pBlock, i);
+          doKeepLinearInfo(pSliceInfo, pBlock, i, false);
          pSliceInfo->current =
              taosTimeAdd(pSliceInfo->current, pInterval->interval, pInterval->intervalUnit, pInterval->precision);
          if (i < pBlock->info.rows - 1) {
@ -2397,6 +2454,9 @@ static SSDataBlock* doTimeslice(SOperatorInfo* pOperator) {
                break;
              }
            }
          } else {// it is the last row of current block
            //store ts value as start, and calculate interp value when processing next block
            doKeepLinearInfo(pSliceInfo, pBlock, i, true);
          }
        } else { // non-linear interpolation
          pSliceInfo->current =
@ -2415,7 +2475,7 @@ static SSDataBlock* doTimeslice(SOperatorInfo* pOperator) {
        doKeepPrevRows(pSliceInfo, pBlock, i);
        if (pSliceInfo->fillType == TSDB_FILL_LINEAR) {
-          doKeepLinearInfo(pSliceInfo, pBlock, i);
+          doKeepLinearInfo(pSliceInfo, pBlock, i, false);
          // no need to increate pSliceInfo->current here
          //pSliceInfo->current =
          //    taosTimeAdd(pSliceInfo->current, pInterval->interval, pInterval->intervalUnit, pInterval->precision);
@ -2495,7 +2555,7 @@ static SSDataBlock* doTimeslice(SOperatorInfo* pOperator) {
          if (pSliceInfo->fillType == TSDB_FILL_LINEAR) {
-            doKeepLinearInfo(pSliceInfo, pBlock, i);
+            doKeepLinearInfo(pSliceInfo, pBlock, i, false);
            pSliceInfo->current =
                taosTimeAdd(pSliceInfo->current, pInterval->interval, pInterval->intervalUnit, pInterval->precision);
            if (i < pBlock->info.rows - 1) {
@ -2831,7 +2891,7 @@ STimeWindow getFinalTimeWindow(int64_t ts, SInterval* pInterval) {
 }
 static void doHashInterval(SOperatorInfo* pOperatorInfo, SSDataBlock* pSDataBlock, uint64_t tableGroupId,
-                           SArray* pUpdated) {
+                           SHashObj* pUpdatedMap) {
  SStreamFinalIntervalOperatorInfo* pInfo = (SStreamFinalIntervalOperatorInfo*)pOperatorInfo->info;
  SResultRowInfo*                   pResultRowInfo = &(pInfo->binfo.resultRowInfo);
  SExecTaskInfo*                    pTaskInfo = pOperatorInfo->pTaskInfo;
@ -2913,8 +2973,8 @@ static void doHashInterval(SOperatorInfo* pOperatorInfo, SSDataBlock* pSDataBloc
      forwardRows = getNumOfRowsInTimeWindow(&pSDataBlock->info, tsCols, startPos, nextWin.ekey, binarySearchForKey,
                                             NULL, TSDB_ORDER_ASC);
    }
-    if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE && pUpdated) {
+    if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE && pUpdatedMap) {
-      saveResultRow(pResult, tableGroupId, pUpdated);
+      saveWinResultRow(pResult, tableGroupId, pUpdatedMap);
      setResultBufPageDirty(pInfo->aggSup.pResultBuf, &pResultRowInfo->cur);
    }
    updateTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &nextWin, true);
@ -3020,6 +3080,8 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) {
  SStreamFinalIntervalOperatorInfo* pInfo = pOperator->info;
  SOperatorInfo*                    downstream = pOperator->pDownstream[0];
  SArray*                           pUpdated = taosArrayInit(4, POINTER_BYTES);
  _hash_fn_t                        hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_TIMESTAMP);
  SHashObj*                         pUpdatedMap = taosHashInit(1024, hashFn, false, HASH_NO_LOCK);
  TSKEY                             maxTs = INT64_MIN;
  SExprSupp* pSup = &pOperator->exprSupp;
@ -3077,7 +3139,7 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) {
    SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
    if (pBlock == NULL) {
      clearSpecialDataBlock(pInfo->pUpdateRes);
-      removeDeleteResults(pUpdated, pInfo->pDelWins);
+      removeDeleteResults(pUpdatedMap, pInfo->pDelWins);
      pOperator->status = OP_RES_TO_RETURN;
      qDebug("%s return data", IS_FINAL_OP(pInfo) ? "interval final" : "interval semi");
      break;
@ -3104,7 +3166,7 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) {
        taosArrayDestroy(pUpWins);
        continue;
      }
-      removeResults(pUpWins, pUpdated);
+      removeResults(pUpWins, pUpdatedMap);
      copyDataBlock(pInfo->pUpdateRes, pBlock);
      // copyUpdateDataBlock(pInfo->pUpdateRes, pBlock, pInfo->primaryTsIndex);
      pInfo->returnUpdate = true;
@ -3122,15 +3184,15 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) {
                              pOperator->exprSupp.numOfExprs, pOperator->pTaskInfo, pUpdated);
        continue;
      }
-      removeResults(pInfo->pDelWins, pUpdated);
+      removeResults(pInfo->pDelWins, pUpdatedMap);
      break;
    } else if (pBlock->info.type == STREAM_GET_ALL && IS_FINAL_OP(pInfo)) {
-      getAllIntervalWindow(pInfo->aggSup.pResultRowHashTable, pUpdated);
+      getAllIntervalWindow(pInfo->aggSup.pResultRowHashTable, pUpdatedMap);
      continue;
    } else if (pBlock->info.type == STREAM_RETRIEVE && !IS_FINAL_OP(pInfo)) {
      SArray* pUpWins = taosArrayInit(8, sizeof(SWinRes));
      doClearWindows(&pInfo->aggSup, pSup, &pInfo->interval, pOperator->exprSupp.numOfExprs, pBlock, pUpWins);
-      removeResults(pUpWins, pUpdated);
+      removeResults(pUpWins, pUpdatedMap);
      taosArrayDestroy(pUpWins);
      if (taosArrayGetSize(pUpdated) > 0) {
        break;
@ -3146,7 +3208,7 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) {
      projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL);
    }
    setInputDataBlock(pOperator, pSup->pCtx, pBlock, pInfo->order, MAIN_SCAN, true);
-    doHashInterval(pOperator, pBlock, pBlock->info.groupId, pUpdated);
+    doHashInterval(pOperator, pBlock, pBlock->info.groupId, pUpdatedMap);
    if (IS_FINAL_OP(pInfo)) {
      int32_t chIndex = getChildIndex(pBlock);
      int32_t size = taosArrayGetSize(pInfo->pChildren);
@ -3171,12 +3233,19 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) {
  pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, maxTs);
  if (IS_FINAL_OP(pInfo)) {
    closeIntervalWindow(pInfo->aggSup.pResultRowHashTable, &pInfo->twAggSup, &pInfo->interval, pInfo->pPullDataMap,
-                        pUpdated, pInfo->pRecycledPages, pInfo->aggSup.pResultBuf);
+                        pUpdatedMap, pInfo->pRecycledPages, pInfo->aggSup.pResultBuf);
    closeChildIntervalWindow(pInfo->pChildren, pInfo->twAggSup.maxTs);
  } else {
    pInfo->binfo.pRes->info.watermark = pInfo->twAggSup.maxTs;
  }
  void* pIte = NULL;
  while ((pIte = taosHashIterate(pUpdatedMap, pIte)) != NULL) {
    taosArrayPush(pUpdated, pIte);
  }
  taosHashCleanup(pUpdatedMap);
  taosArraySort(pUpdated, resultrowComparAsc);
  finalizeUpdatedResult(pOperator->exprSupp.numOfExprs, pInfo->aggSup.pResultBuf, pUpdated, pSup->rowEntryInfoOffset);
  initMultiResInfoFromArrayList(&pInfo->groupResInfo, pUpdated);
  blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity);
--- a/source/libs/executor/src/tsimplehash.c
+++ b/source/libs/executor/src/tsimplehash.c
@ -13,38 +13,37 @@
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 #include "os.h"
 #include "tsimplehash.h"
 #include "os.h"
 #include "taoserror.h"
 #define SHASH_DEFAULT_LOAD_FACTOR 0.75
-#define HASH_MAX_CAPACITY         (1024*1024*16)
+#define HASH_MAX_CAPACITY         (1024 * 1024 * 16)
 #define SHASH_NEED_RESIZE(_h)     ((_h)->size >= (_h)->capacity * SHASH_DEFAULT_LOAD_FACTOR)
-#define GET_SHASH_NODE_KEY(_n, _dl)  ((char*)(_n) + sizeof(SHNode) + (_dl))
+#define GET_SHASH_NODE_KEY(_n, _dl) ((char *)(_n) + sizeof(SHNode) + (_dl))
-#define GET_SHASH_NODE_DATA(_n)      ((char*)(_n) + sizeof(SHNode))
+#define GET_SHASH_NODE_DATA(_n)     ((char *)(_n) + sizeof(SHNode))
-#define HASH_INDEX(v, c)         ((v) & ((c)-1))
+#define HASH_INDEX(v, c) ((v) & ((c)-1))
 #define HASH_NEED_RESIZE(_h)     ((_h)->size >= (_h)->capacity * SHASH_DEFAULT_LOAD_FACTOR)
-#define FREE_HASH_NODE(_n) \
+#define FREE_HASH_NODE(_n)   \
-  do {                     \
+  do {                       \
-    taosMemoryFreeClear(_n);             \
+    taosMemoryFreeClear(_n); \
  } while (0);
 typedef struct SHNode {
-  struct SHNode   *next;
+  struct SHNode *next;
-  char             data[];
+  char           data[];
 } SHNode;
 struct SSHashObj {
-  SHNode         **hashList;
+  SHNode    **hashList;
-  size_t           capacity;     // number of slots
+  size_t      capacity;  // number of slots
-  int64_t          size;         // number of elements in hash table
+  int64_t     size;      // number of elements in hash table
-  _hash_fn_t       hashFp;       // hash function
+  _hash_fn_t  hashFp;    // hash function
-  _equal_fn_t      equalFp;      // equal function
+  _equal_fn_t equalFp;   // equal function
-  int32_t          keyLen;
+  int32_t     keyLen;
-  int32_t          dataLen;
+  int32_t     dataLen;
 };
 static FORCE_INLINE int32_t taosHashCapacity(int32_t length) {
@ -62,7 +61,7 @@ SSHashObj *tSimpleHashInit(size_t capacity, _hash_fn_t fn, size_t keyLen, size_t
    capacity = 4;
  }
-  SSHashObj* pHashObj = (SSHashObj*) taosMemoryCalloc(1, sizeof(SSHashObj));
+  SSHashObj *pHashObj = (SSHashObj *)taosMemoryCalloc(1, sizeof(SSHashObj));
  if (pHashObj == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    return NULL;
@ -72,7 +71,7 @@ SSHashObj *tSimpleHashInit(size_t capacity, _hash_fn_t fn, size_t keyLen, size_t
  pHashObj->capacity = taosHashCapacity((int32_t)capacity);
  pHashObj->equalFp = memcmp;
-  pHashObj->hashFp  = fn;
+  pHashObj->hashFp = fn;
  ASSERT((pHashObj->capacity & (pHashObj->capacity - 1)) == 0);
  pHashObj->keyLen = keyLen;
@ -91,7 +90,7 @@ int32_t tSimpleHashGetSize(const SSHashObj *pHashObj) {
  if (pHashObj == NULL) {
    return 0;
  }
-  return (int32_t)atomic_load_64((int64_t*)&pHashObj->size);
+  return (int32_t)atomic_load_64((int64_t *)&pHashObj->size);
 }
 static SHNode *doCreateHashNode(const void *key, size_t keyLen, const void *pData, size_t dsize, uint32_t hashVal) {
@ -108,41 +107,42 @@ static SHNode *doCreateHashNode(const void *key, size_t keyLen, const void *pDat
 }
 static void taosHashTableResize(SSHashObj *pHashObj) {
-  if (!HASH_NEED_RESIZE(pHashObj)) {
+  if (!SHASH_NEED_RESIZE(pHashObj)) {
    return;
  }
  int32_t newCapacity = (int32_t)(pHashObj->capacity << 1u);
  if (newCapacity > HASH_MAX_CAPACITY) {
-//    uDebug("current capacity:%zu, maximum capacity:%d, no resize applied due to limitation is reached",
+    //    uDebug("current capacity:%zu, maximum capacity:%d, no resize applied due to limitation is reached",
-//           pHashObj->capacity, HASH_MAX_CAPACITY);
+    //           pHashObj->capacity, HASH_MAX_CAPACITY);
    return;
  }
  int64_t st = taosGetTimestampUs();
-  void *pNewEntryList = taosMemoryRealloc(pHashObj->hashList, sizeof(void *) * newCapacity);
+  void   *pNewEntryList = taosMemoryRealloc(pHashObj->hashList, sizeof(void *) * newCapacity);
  if (pNewEntryList == NULL) {
-//    qWarn("hash resize failed due to out of memory, capacity remain:%zu", pHashObj->capacity);
+    //    qWarn("hash resize failed due to out of memory, capacity remain:%zu", pHashObj->capacity);
    return;
  }
  size_t inc = newCapacity - pHashObj->capacity;
-  memset((char*)pNewEntryList + pHashObj->capacity * sizeof(void*), 0, inc);
+  memset((char *)pNewEntryList + pHashObj->capacity * sizeof(void *), 0, inc);
  pHashObj->hashList = pNewEntryList;
  pHashObj->capacity = newCapacity;
  for (int32_t idx = 0; idx < pHashObj->capacity; ++idx) {
-    SHNode* pNode = pHashObj->hashList[idx];
+    SHNode *pNode = pHashObj->hashList[idx];
    SHNode *pNext;
    SHNode *pPrev = NULL;
    if (pNode == NULL) {
      continue;
    }
    SHNode *pNext;
    SHNode *pPrev = NULL;
    while (pNode != NULL) {
-      void* key = GET_SHASH_NODE_KEY(pNode, pHashObj->dataLen);
+      void    *key = GET_SHASH_NODE_KEY(pNode, pHashObj->dataLen);
      uint32_t hashVal = (*pHashObj->hashFp)(key, (uint32_t)pHashObj->dataLen);
      int32_t newIdx = HASH_INDEX(hashVal, pHashObj->capacity);
@ -166,8 +166,9 @@ static void taosHashTableResize(SSHashObj *pHashObj) {
  int64_t et = taosGetTimestampUs();
-//  uDebug("hash table resize completed, new capacity:%d, load factor:%f, elapsed time:%fms", (int32_t)pHashObj->capacity,
+  //  uDebug("hash table resize completed, new capacity:%d, load factor:%f, elapsed time:%fms",
-//         ((double)pHashObj->size) / pHashObj->capacity, (et - st) / 1000.0);
+  //  (int32_t)pHashObj->capacity,
  //         ((double)pHashObj->size) / pHashObj->capacity, (et - st) / 1000.0);
 }
 int32_t tSimpleHashPut(SSHashObj *pHashObj, const void *key, const void *data) {
@ -210,7 +211,7 @@ int32_t tSimpleHashPut(SSHashObj *pHashObj, const void *key, const void *data) {
    pNewNode->next = pHashObj->hashList[slot];
    pHashObj->hashList[slot] = pNewNode;
    atomic_add_fetch_64(&pHashObj->size, 1);
-  } else {  //update data
+  } else {  // update data
    memcpy(GET_SHASH_NODE_DATA(pNode), data, pHashObj->dataLen);
  }
@ -230,9 +231,7 @@ static FORCE_INLINE SHNode *doSearchInEntryList(SSHashObj *pHashObj, const void
  return pNode;
 }
-static FORCE_INLINE bool taosHashTableEmpty(const SSHashObj *pHashObj) {
+static FORCE_INLINE bool taosHashTableEmpty(const SSHashObj *pHashObj) { return tSimpleHashGetSize(pHashObj) == 0; }
  return tSimpleHashGetSize(pHashObj) == 0;
 }
 void *tSimpleHashGet(SSHashObj *pHashObj, const void *key) {
  if (pHashObj == NULL || taosHashTableEmpty(pHashObj) || key == NULL) {
@ -299,9 +298,9 @@ size_t tSimpleHashGetMemSize(const SSHashObj *pHashObj) {
  return (pHashObj->capacity * sizeof(void *)) + sizeof(SHNode) * tSimpleHashGetSize(pHashObj) + sizeof(SSHashObj);
 }
-void *tSimpleHashGetKey(const SSHashObj* pHashObj, void *data, size_t* keyLen) {
+void *tSimpleHashGetKey(const SSHashObj *pHashObj, void *data, size_t *keyLen) {
  int32_t offset = offsetof(SHNode, data);
-  SHNode *node = ((SHNode*)(char*)data - offset);
+  SHNode *node = ((SHNode *)(char *)data - offset);
  if (keyLen != NULL) {
    *keyLen = pHashObj->keyLen;
  }
--- a/source/libs/function/inc/tfunctionInt.h
+++ b/source/libs/function/inc/tfunctionInt.h
@ -13,8 +13,8 @@
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
-#ifndef TDENGINE_TAGGFUNCTION_H
+#ifndef TDENGINE_TFUNCTIONINT_H
-#define TDENGINE_TAGGFUNCTION_H
+#define TDENGINE_TFUNCTIONINT_H
 #ifdef __cplusplus
 extern "C" {
@ -28,17 +28,6 @@ extern "C" {
 #include "function.h"
 #include "tudf.h"
 #define AVG_FUNCTION_INTER_BUFFER_SIZE 50
 #define DATA_SET_FLAG ','  // to denote the output area has data, not null value
 #define DATA_SET_FLAG_SIZE sizeof(DATA_SET_FLAG)
 typedef struct SInterpInfoDetail {
  TSKEY  ts;  // interp specified timestamp
  int8_t type;
  int8_t primaryCol;
 } SInterpInfoDetail;
 bool topbot_datablock_filter(SqlFunctionCtx *pCtx, const char *minval, const char *maxval);
 /**
@ -57,4 +46,4 @@ static FORCE_INLINE void initResultRowEntry(SResultRowEntryInfo *pResInfo, int32
 }
 #endif
-#endif  // TDENGINE_TAGGFUNCTION_H
+#endif  // TDENGINE_TFUNCTIONINT_H
--- a/source/libs/function/src/builtinsimpl.c
+++ b/source/libs/function/src/builtinsimpl.c
@ -18,10 +18,10 @@
 #include "function.h"
 #include "query.h"
 #include "querynodes.h"
 #include "taggfunction.h"
 #include "tcompare.h"
 #include "tdatablock.h"
 #include "tdigest.h"
 #include "tfunctionInt.h"
 #include "tglobal.h"
 #include "thistogram.h"
 #include "tpercentile.h"
@ -312,14 +312,6 @@ typedef struct SGroupKeyInfo {
 #define GET_TS_LIST(x)    ((TSKEY*)((x)->ptsList))
 #define GET_TS_DATA(x, y) (GET_TS_LIST(x)[(y)])
 #define DO_UPDATE_TAG_COLUMNS_WITHOUT_TS(ctx)                      \
  do {                                                             \
    for (int32_t _i = 0; _i < (ctx)->tagInfo.numOfTagCols; ++_i) { \
      SqlFunctionCtx* __ctx = (ctx)->tagInfo.pTagCtxList[_i];      \
      __ctx->fpSet.process(__ctx);                                 \
    }                                                              \
  } while (0);
 #define DO_UPDATE_SUBSID_RES(ctx, ts)                          \
  do {                                                         \
    for (int32_t _i = 0; _i < (ctx)->subsidiaries.num; ++_i) { \
@ -506,8 +498,7 @@ int32_t functionFinalizeWithResultBuf(SqlFunctionCtx* pCtx, SSDataBlock* pBlock,
  SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
-  pResInfo->isNullRes = (pResInfo->numOfRes == 0) ? 1 : 0;
+  pResInfo->isNullRes = (pResInfo->isNullRes == 1) ? 1 : (pResInfo->numOfRes == 0);;
  cleanupResultRowEntry(pResInfo);
  char* in = finalResult;
  colDataAppend(pCol, pBlock->info.rows, in, pResInfo->isNullRes);
@ -4284,9 +4275,9 @@ static int32_t histogramFunctionImpl(SqlFunctionCtx* pCtx, bool isPartial) {
  }
  if (!isPartial) {
-    SET_VAL(GET_RES_INFO(pCtx), numOfElems, pInfo->numOfBins);
+    GET_RES_INFO(pCtx)->numOfRes = pInfo->numOfBins;
  } else {
-    SET_VAL(GET_RES_INFO(pCtx), numOfElems, 1);
+    GET_RES_INFO(pCtx)->numOfRes = 1;
  }
  return TSDB_CODE_SUCCESS;
 }
--- a/source/libs/function/src/taggfunction.c
+++ b/source/libs/function/src/taggfunction.c
--- a/source/libs/function/src/texpr.c
+++ b/source/libs/function/src/texpr.c
@ -1,67 +0,0 @@
 /*
 * 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 "function.h"
 #include "os.h"
 #include "texception.h"
 #include "tmsg.h"
 static void doExprTreeDestroy(tExprNode **pExpr, void (*fp)(void *));
 void tExprTreeDestroy(tExprNode *pNode, void (*fp)(void *)) {
  if (pNode == NULL) {
    return;
  }
  if (pNode->nodeType == TEXPR_BINARYEXPR_NODE || pNode->nodeType == TEXPR_UNARYEXPR_NODE) {
    doExprTreeDestroy(&pNode, fp);
  }
  taosMemoryFree(pNode);
 }
 static void doExprTreeDestroy(tExprNode **pExpr, void (*fp)(void *)) {
  if (*pExpr == NULL) {
    return;
  }
  taosMemoryFree(*pExpr);
  *pExpr = NULL;
 }
 // TODO: these three functions should be made global
 static void* exception_calloc(size_t nmemb, size_t size) {
  void* p = taosMemoryCalloc(nmemb, size);
  if (p == NULL) {
    THROW(TSDB_CODE_QRY_OUT_OF_MEMORY);
  }
  return p;
 }
 static void* exception_malloc(size_t size) {
  void* p = taosMemoryMalloc(size);
  if (p == NULL) {
    THROW(TSDB_CODE_QRY_OUT_OF_MEMORY);
  }
  return p;
 }
 static UNUSED_FUNC char* exception_strdup(const char* str) {
  char* p = strdup(str);
  if (p == NULL) {
    THROW(TSDB_CODE_QRY_OUT_OF_MEMORY);
  }
  return p;
 }
--- a/source/libs/function/src/tfunctionInt.c
+++ b/source/libs/function/src/tfunctionInt.c
@ -0,0 +1,75 @@
 /*
 * 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 "os.h"
 #include "taosdef.h"
 #include "tmsg.h"
 #include "thash.h"
 #include "ttypes.h"
 #include "function.h"
 #include "tbuffer.h"
 #include "tcompression.h"
 #include "tdatablock.h"
 #include "tfunctionInt.h"
 #include "thistogram.h"
 #include "tpercentile.h"
 #include "ttszip.h"
 #include "tudf.h"
 void cleanupResultRowEntry(struct SResultRowEntryInfo* pCell) {
  pCell->initialized = false;
 }
 int32_t getNumOfResult(SqlFunctionCtx* pCtx, int32_t num, SSDataBlock* pResBlock) {
  int32_t maxRows = 0;
  for (int32_t j = 0; j < num; ++j) {
    SResultRowEntryInfo *pResInfo = GET_RES_INFO(&pCtx[j]);
    if (pResInfo != NULL && maxRows < pResInfo->numOfRes) {
      maxRows = pResInfo->numOfRes;
    }
  }
  assert(maxRows >= 0);
  blockDataEnsureCapacity(pResBlock, maxRows);
  for(int32_t i = 0; i < num; ++i) {
    SColumnInfoData* pCol = taosArrayGet(pResBlock->pDataBlock, i);
    SResultRowEntryInfo *pResInfo = GET_RES_INFO(&pCtx[i]);
    if (pResInfo->numOfRes == 0) {
      for(int32_t j = 0; j < pResInfo->numOfRes; ++j) {
        colDataAppend(pCol, j, NULL, true);  // TODO add set null data api
      }
    } else {
      for (int32_t j = 0; j < pResInfo->numOfRes; ++j) {
        colDataAppend(pCol, j, GET_ROWCELL_INTERBUF(pResInfo), false);
      }
    }
  }
  pResBlock->info.rows = maxRows;
  return maxRows;
 }
 bool isRowEntryCompleted(struct SResultRowEntryInfo* pEntry) {
  assert(pEntry != NULL);
  return pEntry->complete;
 }
 bool isRowEntryInitialized(struct SResultRowEntryInfo* pEntry) {
  return pEntry->initialized;
 }
--- a/source/libs/parser/src/parInsert.c
+++ b/source/libs/parser/src/parInsert.c
@ -1192,7 +1192,10 @@ static int parseOneRow(SInsertParseContext* pCxt, STableDataBlocks* pDataBlocks,
      pBuilder->hasNone = true;
    }
    tdSRowEnd(pBuilder);
    *gotRow = true;
 #ifdef TD_DEBUG_PRINT_ROW
    STSchema* pSTSchema = tdGetSTSChemaFromSSChema(schema, spd->numOfCols, 1);
    tdSRowPrint(row, pSTSchema, __func__);
@ -1201,7 +1204,6 @@ static int parseOneRow(SInsertParseContext* pCxt, STableDataBlocks* pDataBlocks,
  }
  // *len = pBuilder->extendedRowSize;
  tdSRowEnd(pBuilder);
  return TSDB_CODE_SUCCESS;
 }
--- a/source/libs/stream/inc/streamInc.h
+++ b/source/libs/stream/inc/streamInc.h
@ -44,7 +44,7 @@ int32_t streamBroadcastToChildren(SStreamTask* pTask, const SSDataBlock* pBlock)
 int32_t tEncodeStreamRetrieveReq(SEncoder* pEncoder, const SStreamRetrieveReq* pReq);
-SStreamQueueItem* streamAppendQueueItem(SStreamQueueItem* dst, SStreamQueueItem* elem);
+SStreamQueueItem* streamMergeQueueItem(SStreamQueueItem* dst, SStreamQueueItem* elem);
 void              streamFreeQitem(SStreamQueueItem* data);
 #ifdef __cplusplus
--- a/source/libs/stream/src/streamData.c
+++ b/source/libs/stream/src/streamData.c
@ -124,7 +124,7 @@ void streamDataSubmitRefDec(SStreamDataSubmit* pDataSubmit) {
  }
 }
-SStreamQueueItem* streamAppendQueueItem(SStreamQueueItem* dst, SStreamQueueItem* elem) {
+SStreamQueueItem* streamMergeQueueItem(SStreamQueueItem* dst, SStreamQueueItem* elem) {
  ASSERT(elem);
  if (dst->type == STREAM_INPUT__DATA_BLOCK && elem->type == STREAM_INPUT__DATA_BLOCK) {
    SStreamDataBlock* pBlock = (SStreamDataBlock*)dst;
@ -171,8 +171,8 @@ void streamFreeQitem(SStreamQueueItem* data) {
      int32_t  ref = atomic_sub_fetch_32(pRef, 1);
      ASSERT(ref >= 0);
      if (ref == 0) {
-        void* data = taosArrayGetP(pMerge->reqs, i);
+        void* dataStr = taosArrayGetP(pMerge->reqs, i);
-        taosMemoryFree(data);
+        taosMemoryFree(dataStr);
        taosMemoryFree(pRef);
      }
    }
--- a/source/libs/stream/src/streamDispatch.c
+++ b/source/libs/stream/src/streamDispatch.c
@ -370,80 +370,6 @@ int32_t streamDispatchAllBlocks(SStreamTask* pTask, const SStreamDataBlock* pDat
  return 0;
 }
 int32_t streamBuildDispatchMsg(SStreamTask* pTask, const SStreamDataBlock* data, SRpcMsg* pMsg, SEpSet** ppEpSet) {
  void*   buf = NULL;
  int32_t code = -1;
  int32_t blockNum = taosArrayGetSize(data->blocks);
  ASSERT(blockNum != 0);
  SStreamDispatchReq req = {
      .streamId = pTask->streamId,
      .dataSrcVgId = data->srcVgId,
      .upstreamTaskId = pTask->taskId,
      .upstreamChildId = pTask->selfChildId,
      .upstreamNodeId = pTask->nodeId,
      .blockNum = blockNum,
  };
  req.data = taosArrayInit(blockNum, sizeof(void*));
  req.dataLen = taosArrayInit(blockNum, sizeof(int32_t));
  if (req.data == NULL || req.dataLen == NULL) {
    goto FAIL;
  }
  for (int32_t i = 0; i < blockNum; i++) {
    SSDataBlock* pDataBlock = taosArrayGet(data->blocks, i);
    if (streamAddBlockToDispatchMsg(pDataBlock, &req) < 0) {
      goto FAIL;
    }
  }
  int32_t vgId = 0;
  int32_t downstreamTaskId = 0;
  // find ep
  if (pTask->outputType == TASK_OUTPUT__FIXED_DISPATCH) {
    vgId = pTask->fixedEpDispatcher.nodeId;
    *ppEpSet = &pTask->fixedEpDispatcher.epSet;
    downstreamTaskId = pTask->fixedEpDispatcher.taskId;
  } else if (pTask->outputType == TASK_OUTPUT__SHUFFLE_DISPATCH) {
    // TODO get ctbName for each block
    SSDataBlock* pBlock = taosArrayGet(data->blocks, 0);
    char*        ctbName = buildCtbNameByGroupId(pTask->shuffleDispatcher.stbFullName, pBlock->info.groupId);
    // TODO: get hash function by hashMethod
    // get groupId, compute hash value
    uint32_t hashValue = MurmurHash3_32(ctbName, strlen(ctbName));
    // get node
    // TODO: optimize search process
    SArray* vgInfo = pTask->shuffleDispatcher.dbInfo.pVgroupInfos;
    int32_t sz = taosArrayGetSize(vgInfo);
    for (int32_t i = 0; i < sz; i++) {
      SVgroupInfo* pVgInfo = taosArrayGet(vgInfo, i);
      ASSERT(pVgInfo->vgId > 0);
      if (hashValue >= pVgInfo->hashBegin && hashValue <= pVgInfo->hashEnd) {
        vgId = pVgInfo->vgId;
        downstreamTaskId = pVgInfo->taskId;
        *ppEpSet = &pVgInfo->epSet;
        break;
      }
    }
  }
  ASSERT(vgId > 0 || vgId == SNODE_HANDLE);
  req.taskId = downstreamTaskId;
  qDebug("dispatch from task %d (child id %d) to down stream task %d in vnode %d", pTask->taskId, pTask->selfChildId,
         downstreamTaskId, vgId);
  streamDispatchOneReq(pTask, &req, vgId, *ppEpSet);
  code = 0;
 FAIL:
  if (code < 0 && buf) rpcFreeCont(buf);
  if (req.data) taosArrayDestroyP(req.data, (FDelete)taosMemoryFree);
  if (req.dataLen) taosArrayDestroy(req.dataLen);
  return code;
 }
 int32_t streamDispatch(SStreamTask* pTask) {
  ASSERT(pTask->outputType == TASK_OUTPUT__FIXED_DISPATCH || pTask->outputType == TASK_OUTPUT__SHUFFLE_DISPATCH);
@ -461,7 +387,7 @@ int32_t streamDispatch(SStreamTask* pTask) {
  }
  ASSERT(pBlock->type == STREAM_INPUT__DATA_BLOCK);
-  qDebug("stream continue dispatching: task %d", pTask->taskId);
+  qDebug("stream dispatching: task %d", pTask->taskId);
  int32_t code = 0;
  if (streamDispatchAllBlocks(pTask, pBlock) < 0) {
--- a/source/libs/stream/src/streamExec.c
+++ b/source/libs/stream/src/streamExec.c
@ -82,17 +82,6 @@ static int32_t streamTaskExecImpl(SStreamTask* pTask, const void* data, SArray*
  return 0;
 }
 #if 0
 static FORCE_INLINE int32_t streamUpdateVer(SStreamTask* pTask, SStreamDataBlock* pBlock) {
  ASSERT(pBlock->type == STREAM_INPUT__DATA_BLOCK);
  int32_t             childId = pBlock->childId;
  int64_t             ver = pBlock->sourceVer;
  SStreamChildEpInfo* pChildInfo = taosArrayGetP(pTask->childEpInfo, childId);
  /*pChildInfo-> = ver;*/
  return 0;
 }
 #endif
 int32_t streamPipelineExec(SStreamTask* pTask, int32_t batchNum, bool dispatch) {
  ASSERT(pTask->taskLevel != TASK_LEVEL__SINK);
@ -150,10 +139,11 @@ int32_t streamPipelineExec(SStreamTask* pTask, int32_t batchNum, bool dispatch)
  return 0;
 }
 // TODO: handle version
 int32_t streamExecForAll(SStreamTask* pTask) {
  while (1) {
-    int32_t cnt = 1;
+    int32_t batchCnt = 1;
    void*   data = NULL;
    while (1) {
      SStreamQueueItem* qItem = streamQueueNextItem(pTask->inputQueue);
@ -169,13 +159,12 @@ int32_t streamExecForAll(SStreamTask* pTask) {
        }
      } else {
        void* newRet;
-        if ((newRet = streamAppendQueueItem(data, qItem)) == NULL) {
+        if ((newRet = streamMergeQueueItem(data, qItem)) == NULL) {
          streamQueueProcessFail(pTask->inputQueue);
          break;
        } else {
-          cnt++;
+          batchCnt++;
          data = newRet;
          /*streamUpdateVer(pTask, (SStreamDataBlock*)qItem);*/
          streamQueueProcessSuccess(pTask->inputQueue);
        }
      }
@ -198,16 +187,14 @@ int32_t streamExecForAll(SStreamTask* pTask) {
    SArray* pRes = taosArrayInit(0, sizeof(SSDataBlock));
-    qDebug("stream task %d exec begin, msg batch: %d", pTask->taskId, cnt);
+    qDebug("stream task %d exec begin, msg batch: %d", pTask->taskId, batchCnt);
    streamTaskExecImpl(pTask, data, pRes);
    qDebug("stream task %d exec end", pTask->taskId);
    if (taosArrayGetSize(pRes) != 0) {
      SStreamDataBlock* qRes = taosAllocateQitem(sizeof(SStreamDataBlock), DEF_QITEM);
      if (qRes == NULL) {
-        // TODO log failed ver
+        taosArrayDestroyEx(pRes, (FDelete)blockDataFreeRes);
        streamQueueProcessFail(pTask->inputQueue);
        taosArrayDestroy(pRes);
        streamFreeQitem(data);
        return -1;
      }
@ -218,17 +205,18 @@ int32_t streamExecForAll(SStreamTask* pTask) {
        SStreamDataSubmit* pSubmit = (SStreamDataSubmit*)data;
        qRes->childId = pTask->selfChildId;
        qRes->sourceVer = pSubmit->ver;
      } else if (((SStreamQueueItem*)data)->type == STREAM_INPUT__MERGED_SUBMIT) {
        SStreamMergedSubmit* pMerged = (SStreamMergedSubmit*)data;
        qRes->childId = pTask->selfChildId;
        qRes->sourceVer = pMerged->ver;
      }
      if (streamTaskOutput(pTask, qRes) < 0) {
        // TODO save failed ver
        /*streamQueueProcessFail(pTask->inputQueue);*/
        taosArrayDestroyEx(pRes, (FDelete)blockDataFreeRes);
        taosFreeQitem(qRes);
        streamFreeQitem(data);
        taosFreeQitem(qRes);
        return -1;
      }
      /*streamQueueProcessSuccess(pTask->inputQueue);*/
    } else {
      taosArrayDestroy(pRes);
    }
--- a/source/libs/stream/src/streamUpdate.c
+++ b/source/libs/stream/src/streamUpdate.c
@ -124,7 +124,7 @@ SUpdateInfo *updateInfoInit(int64_t interval, int32_t precision, int64_t waterma
  }
  pInfo->numBuckets = DEFAULT_BUCKET_SIZE;
  pInfo->pCloseWinSBF = NULL;
-  _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
+  _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT);
  pInfo->pMap = taosHashInit(DEFAULT_MAP_CAPACITY, hashFn, true, HASH_NO_LOCK);
  pInfo->maxVersion = 0;
  pInfo->scanGroupId = 0;
--- a/source/libs/sync/inc/syncInt.h
+++ b/source/libs/sync/inc/syncInt.h
@ -163,6 +163,7 @@ typedef struct SSyncNode {
  bool changing;
  int64_t startTime;
  int64_t leaderTime;
  int64_t lastReplicateTime;
 } SSyncNode;
--- a/source/libs/sync/inc/syncRespMgr.h
+++ b/source/libs/sync/inc/syncRespMgr.h
@ -32,9 +32,9 @@ typedef struct SRespStub {
 } SRespStub;
 typedef struct SSyncRespMgr {
-  SHashObj *    pRespHash;
+  SHashObj     *pRespHash;
  int64_t       ttl;
-  void *        data;
+  void         *data;
  TdThreadMutex mutex;
  uint64_t      seqNum;
 } SSyncRespMgr;
@ -46,7 +46,8 @@ int32_t       syncRespMgrDel(SSyncRespMgr *pObj, uint64_t index);
 int32_t       syncRespMgrGet(SSyncRespMgr *pObj, uint64_t index, SRespStub *pStub);
 int32_t       syncRespMgrGetAndDel(SSyncRespMgr *pObj, uint64_t index, SRespStub *pStub);
 void          syncRespClean(SSyncRespMgr *pObj);
-void          syncRespCleanByTTL(SSyncRespMgr *pObj, int64_t ttl);
+void          syncRespCleanRsp(SSyncRespMgr *pObj);
 void          syncRespCleanByTTL(SSyncRespMgr *pObj, int64_t ttl, bool rsp);
 #ifdef __cplusplus
 }
--- a/source/libs/sync/src/syncMain.c
+++ b/source/libs/sync/src/syncMain.c
@ -1100,6 +1100,7 @@ SSyncNode* syncNodeOpen(const SSyncInfo* pOldSyncInfo) {
  int64_t timeNow = taosGetTimestampMs();
  pSyncNode->startTime = timeNow;
  pSyncNode->leaderTime = timeNow;
  pSyncNode->lastReplicateTime = timeNow;
  syncNodeEventLog(pSyncNode, "sync open");
@ -2015,6 +2016,8 @@ void syncNodeUpdateTermWithoutStepDown(SSyncNode* pSyncNode, SyncTerm term) {
  }
 }
 void syncNodeLeaderChangeRsp(SSyncNode* pSyncNode) { syncRespCleanRsp(pSyncNode->pSyncRespMgr); }
 void syncNodeBecomeFollower(SSyncNode* pSyncNode, const char* debugStr) {
  // maybe clear leader cache
  if (pSyncNode->state == TAOS_SYNC_STATE_LEADER) {
@ -2028,6 +2031,14 @@ void syncNodeBecomeFollower(SSyncNode* pSyncNode, const char* debugStr) {
  // reset elect timer
  syncNodeResetElectTimer(pSyncNode);
  // send rsp to client
  syncNodeLeaderChangeRsp(pSyncNode);
  // call back
  if (pSyncNode->pFsm != NULL && pSyncNode->pFsm->FpBecomeFollowerCb != NULL) {
    pSyncNode->pFsm->FpBecomeFollowerCb(pSyncNode->pFsm);
  }
  // trace log
  do {
    int32_t debugStrLen = strlen(debugStr);
@ -2063,6 +2074,8 @@ void syncNodeBecomeFollower(SSyncNode* pSyncNode, const char* debugStr) {
 //     /\ UNCHANGED <<messages, currentTerm, votedFor, candidateVars, logVars>>
 //
 void syncNodeBecomeLeader(SSyncNode* pSyncNode, const char* debugStr) {
  pSyncNode->leaderTime = taosGetTimestampMs();
  // reset restoreFinish
  pSyncNode->restoreFinish = false;
@ -2109,6 +2122,11 @@ void syncNodeBecomeLeader(SSyncNode* pSyncNode, const char* debugStr) {
  // start heartbeat timer
  syncNodeStartHeartbeatTimer(pSyncNode);
  // call back
  if (pSyncNode->pFsm != NULL && pSyncNode->pFsm->FpBecomeLeaderCb != NULL) {
    pSyncNode->pFsm->FpBecomeLeaderCb(pSyncNode->pFsm);
  }
  // trace log
  do {
    int32_t debugStrLen = strlen(debugStr);
@ -2944,8 +2962,11 @@ int32_t syncNodeCommit(SSyncNode* ths, SyncIndex beginIndex, SyncIndex endIndex,
            }
            ths->restoreFinish = true;
            int64_t restoreDelay = taosGetTimestampMs() - ths->leaderTime;
            char eventLog[128];
-            snprintf(eventLog, sizeof(eventLog), "restore finish, index:%" PRId64, pEntry->index);
+            snprintf(eventLog, sizeof(eventLog), "restore finish, index:%ld, elapsed:%ld ms, ", pEntry->index,
                     restoreDelay);
            syncNodeEventLog(ths, eventLog);
          }
        }
@ -3100,7 +3121,7 @@ void syncLogRecvAppendEntriesBatch(SSyncNode* pSyncNode, const SyncAppendEntries
  syncNodeEventLog(pSyncNode, logBuf);
 }
- void syncLogSendAppendEntriesReply(SSyncNode* pSyncNode, const SyncAppendEntriesReply* pMsg, const char* s) {
+void syncLogSendAppendEntriesReply(SSyncNode* pSyncNode, const SyncAppendEntriesReply* pMsg, const char* s) {
  char     host[64];
  uint16_t port;
  syncUtilU642Addr(pMsg->destId.addr, host, sizeof(host), &port);
--- a/source/libs/sync/src/syncRespMgr.c
+++ b/source/libs/sync/src/syncRespMgr.c
@ -108,13 +108,19 @@ int32_t syncRespMgrGetAndDel(SSyncRespMgr *pObj, uint64_t index, SRespStub *pStu
  return 0;  // get none object
 }
-void syncRespClean(SSyncRespMgr *pObj) {
+void syncRespCleanRsp(SSyncRespMgr *pObj) {
  taosThreadMutexLock(&(pObj->mutex));
-  syncRespCleanByTTL(pObj, pObj->ttl);
+  syncRespCleanByTTL(pObj, -1, true);
  taosThreadMutexUnlock(&(pObj->mutex));
 }
-void syncRespCleanByTTL(SSyncRespMgr *pObj, int64_t ttl) {
+void syncRespClean(SSyncRespMgr *pObj) {
  taosThreadMutexLock(&(pObj->mutex));
  syncRespCleanByTTL(pObj, pObj->ttl, false);
  taosThreadMutexUnlock(&(pObj->mutex));
 }
 void syncRespCleanByTTL(SSyncRespMgr *pObj, int64_t ttl, bool rsp) {
  SRespStub *pStub = (SRespStub *)taosHashIterate(pObj->pRespHash, NULL);
  int        cnt = 0;
  int        sum = 0;
@ -126,12 +132,12 @@ void syncRespCleanByTTL(SSyncRespMgr *pObj, int64_t ttl) {
  while (pStub) {
    size_t    len;
-    void *    key = taosHashGetKey(pStub, &len);
+    void     *key = taosHashGetKey(pStub, &len);
    uint64_t *pSeqNum = (uint64_t *)key;
    sum++;
    int64_t nowMS = taosGetTimestampMs();
-    if (nowMS - pStub->createTime > ttl) {
+    if (nowMS - pStub->createTime > ttl || -1 == ttl) {
      taosArrayPush(delIndexArray, pSeqNum);
      cnt++;
@ -148,7 +154,14 @@ void syncRespCleanByTTL(SSyncRespMgr *pObj, int64_t ttl) {
      pStub->rpcMsg.pCont = NULL;
      pStub->rpcMsg.contLen = 0;
-      pSyncNode->pFsm->FpCommitCb(pSyncNode->pFsm, &(pStub->rpcMsg), cbMeta);
+
      // TODO: and make rpcMsg body, call commit cb
      // pSyncNode->pFsm->FpCommitCb(pSyncNode->pFsm, &(pStub->rpcMsg), cbMeta);
      pStub->rpcMsg.code = TSDB_CODE_SYN_NOT_LEADER;
      if (pStub->rpcMsg.info.handle != NULL) {
        tmsgSendRsp(&(pStub->rpcMsg));
      }
    }
    pStub = (SRespStub *)taosHashIterate(pObj->pRespHash, pStub);
--- a/source/libs/wal/src/walWrite.c
+++ b/source/libs/wal/src/walWrite.c
@ -421,6 +421,8 @@ static FORCE_INLINE int32_t walWriteImpl(SWal *pWal, int64_t index, tmsg_t msgTy
  pWal->writeHead.cksumHead = walCalcHeadCksum(&pWal->writeHead);
  pWal->writeHead.cksumBody = walCalcBodyCksum(body, bodyLen);
  wDebug("vgId:%d, wal write log %ld, msgType: %s", pWal->cfg.vgId, index, TMSG_INFO(msgType));
  if (taosWriteFile(pWal->pLogFile, &pWal->writeHead, sizeof(SWalCkHead)) != sizeof(SWalCkHead)) {
    // TODO ftruncate
    terrno = TAOS_SYSTEM_ERROR(errno);
--- a/source/os/src/osSemaphore.c
+++ b/source/os/src/osSemaphore.c
@ -16,8 +16,8 @@
 #define ALLOW_FORBID_FUNC
 #define _DEFAULT_SOURCE
 #include "os.h"
 #include "tdef.h"
 #include "pthread.h"
 #include "tdef.h"
 #ifdef WINDOWS
@ -77,8 +77,8 @@ int32_t tsem_wait(tsem_t* sem) {
 int32_t tsem_timewait(tsem_t* sem, int64_t nanosecs) {
  struct timespec ts, rel;
-  FILETIME ft_before, ft_after;
+  FILETIME        ft_before, ft_after;
-  int rc;
+  int             rc;
  rel.tv_sec = 0;
  rel.tv_nsec = nanosecs;
@ -218,7 +218,8 @@ int32_t tsem_timewait(tsem_t* sem, int64_t nanosecs) {
 //     int e = errno;
 //     if (e == EEXIST) continue;
 //     if (e == EINTR) continue;
-//     fprintf(stderr, "==%s[%d]%s():[%p]==not created[%d]%s\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__, sem,
+//     fprintf(stderr, "==%s[%d]%s():[%p]==not created[%d]%s\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
 //     sem,
 //             e, strerror(e));
 //     abort();
 //   } while (p->sem == SEM_FAILED);
@ -232,7 +233,8 @@ int32_t tsem_timewait(tsem_t* sem, int64_t nanosecs) {
 //   }
 //   kern_return_t ret = semaphore_create(sem_port, &p->sem, SYNC_POLICY_FIFO, value);
 //   if (ret != KERN_SUCCESS) {
-//     fprintf(stderr, "==%s[%d]%s():[%p]==semophore_create failed\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
+//     fprintf(stderr, "==%s[%d]%s():[%p]==semophore_create failed\n", taosDirEntryBaseName(__FILE__), __LINE__,
 //     __func__,
 //             sem);
 //     // we fail-fast here, because we have less-doc about semaphore_create for the moment
 //     abort();
@ -259,8 +261,8 @@ int32_t tsem_timewait(tsem_t* sem, int64_t nanosecs) {
 //   }
 //   struct tsem_s *p = *sem;
 //   if (!p->valid) {
-//     fprintf(stderr, "==%s[%d]%s():[%p]==already destroyed\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__, sem);
+//     fprintf(stderr, "==%s[%d]%s():[%p]==already destroyed\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
-//     abort();
+//     sem); abort();
 //   }
 // #ifdef SEM_USE_PTHREAD
 //   if (taosThreadMutexLock(&p->lock)) {
@ -271,7 +273,8 @@ int32_t tsem_timewait(tsem_t* sem, int64_t nanosecs) {
 //   p->val -= 1;
 //   if (p->val < 0) {
 //     if (taosThreadCondWait(&p->cond, &p->lock)) {
-//       fprintf(stderr, "==%s[%d]%s():[%p]==internal logic error\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
+//       fprintf(stderr, "==%s[%d]%s():[%p]==internal logic error\n", taosDirEntryBaseName(__FILE__), __LINE__,
 //       __func__,
 //               sem);
 //       abort();
 //     }
@ -298,8 +301,8 @@ int32_t tsem_timewait(tsem_t* sem, int64_t nanosecs) {
 //   }
 //   struct tsem_s *p = *sem;
 //   if (!p->valid) {
-//     fprintf(stderr, "==%s[%d]%s():[%p]==already destroyed\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__, sem);
+//     fprintf(stderr, "==%s[%d]%s():[%p]==already destroyed\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
-//     abort();
+//     sem); abort();
 //   }
 // #ifdef SEM_USE_PTHREAD
 //   if (taosThreadMutexLock(&p->lock)) {
@ -310,7 +313,8 @@ int32_t tsem_timewait(tsem_t* sem, int64_t nanosecs) {
 //   p->val += 1;
 //   if (p->val <= 0) {
 //     if (taosThreadCondSignal(&p->cond)) {
-//       fprintf(stderr, "==%s[%d]%s():[%p]==internal logic error\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
+//       fprintf(stderr, "==%s[%d]%s():[%p]==internal logic error\n", taosDirEntryBaseName(__FILE__), __LINE__,
 //       __func__,
 //               sem);
 //       abort();
 //     }
@ -333,7 +337,8 @@ int32_t tsem_timewait(tsem_t* sem, int64_t nanosecs) {
 // int tsem_destroy(tsem_t *sem) {
 //   // fprintf(stderr, "==%s[%d]%s():[%p]==destroying\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__, sem);
 //   if (!*sem) {
-//     // fprintf(stderr, "==%s[%d]%s():[%p]==not initialized\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__, sem);
+//     // fprintf(stderr, "==%s[%d]%s():[%p]==not initialized\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
 //     sem);
 //     // abort();
 //     return 0;
 //   }
@ -371,7 +376,8 @@ int32_t tsem_timewait(tsem_t* sem, int64_t nanosecs) {
 //   int r = sem_unlink(name);
 //   if (r) {
 //     int e = errno;
-//     fprintf(stderr, "==%s[%d]%s():[%p]==unlink failed[%d]%s\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__, sem,
+//     fprintf(stderr, "==%s[%d]%s():[%p]==unlink failed[%d]%s\n", taosDirEntryBaseName(__FILE__), __LINE__, __func__,
 //     sem,
 //             e, strerror(e));
 //     abort();
 //   }
@ -386,225 +392,189 @@ int32_t tsem_timewait(tsem_t* sem, int64_t nanosecs) {
 //   *sem = NULL;
 //   return 0;
 // }
-typedef struct
+typedef struct {
-{
+  pthread_mutex_t count_lock;
-    pthread_mutex_t count_lock;
+  pthread_cond_t  count_bump;
-    pthread_cond_t  count_bump;
+  unsigned int    count;
-    unsigned int count;
+} bosal_sem_t;
 }bosal_sem_t;
-int tsem_init(tsem_t *psem, int flags, unsigned int count)
+int tsem_init(tsem_t *psem, int flags, unsigned int count) {
-{
+  bosal_sem_t *pnewsem;
-    bosal_sem_t *pnewsem;
+  int          result;
    int result;
-    pnewsem = (bosal_sem_t *)malloc(sizeof(bosal_sem_t));
+  pnewsem = (bosal_sem_t *)malloc(sizeof(bosal_sem_t));
-    if (! pnewsem)
+  if (!pnewsem) {
-    {
+    return -1;
-        return -1;
+  }
-    }
+  result = pthread_mutex_init(&pnewsem->count_lock, NULL);
-    result = pthread_mutex_init(&pnewsem->count_lock, NULL);
+  if (result) {
-    if (result)
+    free(pnewsem);
-    {
+    return result;
-        free(pnewsem);
+  }
-        return result;
+  result = pthread_cond_init(&pnewsem->count_bump, NULL);
-    }
+  if (result) {
-    result = pthread_cond_init(&pnewsem->count_bump, NULL);
+    pthread_mutex_destroy(&pnewsem->count_lock);
-    if (result)
+    free(pnewsem);
-    {
+    return result;
-        pthread_mutex_destroy(&pnewsem->count_lock);
+  }
-        free(pnewsem);
+  pnewsem->count = count;
-        return result;
+  *psem = (tsem_t)pnewsem;
-    }
+  return 0;
    pnewsem->count = count;
    *psem = (tsem_t)pnewsem;
    return 0;
 }
-int tsem_destroy(tsem_t *psem)
+int tsem_destroy(tsem_t *psem) {
-{
+  bosal_sem_t *poldsem;
    bosal_sem_t *poldsem;
-    if (! psem)
+  if (!psem) {
-    {
+    return EINVAL;
-        return EINVAL;
+  }
-    }
+  poldsem = (bosal_sem_t *)*psem;
    poldsem = (bosal_sem_t *)*psem;
-    pthread_mutex_destroy(&poldsem->count_lock);
+  pthread_mutex_destroy(&poldsem->count_lock);
-    pthread_cond_destroy(&poldsem->count_bump);
+  pthread_cond_destroy(&poldsem->count_bump);
-    free(poldsem);
+  free(poldsem);
-    return 0;
+  return 0;
 }
-int tsem_post(tsem_t *psem)
+int tsem_post(tsem_t *psem) {
-{
+  bosal_sem_t *pxsem;
-     bosal_sem_t *pxsem;
+  int          result, xresult;
    int result, xresult;
-    if (! psem)
+  if (!psem) {
-    {
+    return EINVAL;
-        return EINVAL;
+  }
-    }
+  pxsem = (bosal_sem_t *)*psem;
    pxsem = (bosal_sem_t *)*psem;
-    result = pthread_mutex_lock(&pxsem->count_lock);
+  result = pthread_mutex_lock(&pxsem->count_lock);
-    if (result)
+  if (result) {
-    {
+    return result;
-        return result;
+  }
-    }
+  pxsem->count = pxsem->count + 1;
    pxsem->count = pxsem->count + 1;
-    xresult = pthread_cond_signal(&pxsem->count_bump);
+  xresult = pthread_cond_signal(&pxsem->count_bump);
-    result = pthread_mutex_unlock(&pxsem->count_lock);
+  result = pthread_mutex_unlock(&pxsem->count_lock);
-    if (result)
+  if (result) {
-    {
+    return result;
-        return result;
+  }
-    }
+  if (xresult) {
-    if (xresult)
+    errno = xresult;
-    {
+    return -1;
-        errno = xresult;
+  }
-        return -1;
+  return 0;
    }
    return 0;
 }
-int tsem_trywait(tsem_t *psem)
+int tsem_trywait(tsem_t *psem) {
-{
+  bosal_sem_t *pxsem;
-    bosal_sem_t *pxsem;
+  int          result, xresult;
    int result, xresult;
-    if (! psem)
+  if (!psem) {
-    {
+    return EINVAL;
-        return EINVAL;
+  }
-    }
+  pxsem = (bosal_sem_t *)*psem;
    pxsem = (bosal_sem_t *)*psem;
-    result = pthread_mutex_lock(&pxsem->count_lock);
+  result = pthread_mutex_lock(&pxsem->count_lock);
-    if (result)
+  if (result) {
-    {
+    return result;
-        return result;
+  }
-    }
+  xresult = 0;
    xresult = 0;
-    if (pxsem->count > 0)
+  if (pxsem->count > 0) {
-    {
+    pxsem->count--;
-        pxsem->count--;
+  } else {
-    }
+    xresult = EAGAIN;
-    else
+  }
-    {
+  result = pthread_mutex_unlock(&pxsem->count_lock);
-        xresult = EAGAIN;
+  if (result) {
-    }
+    return result;
-    result = pthread_mutex_unlock(&pxsem->count_lock);
+  }
-    if (result)
+  if (xresult) {
-    {
+    errno = xresult;
-        return result;
+    return -1;
-    }
+  }
-    if (xresult)
+  return 0;
    {
        errno = xresult;
        return -1;
    }
    return 0;
 }
-int tsem_wait(tsem_t *psem)
+int tsem_wait(tsem_t *psem) {
-{
+  bosal_sem_t *pxsem;
-    bosal_sem_t *pxsem;
+  int          result, xresult;
    int result, xresult;
-    if (! psem)
+  if (!psem) {
-    {
+    return EINVAL;
-        return EINVAL;
+  }
-    }
+  pxsem = (bosal_sem_t *)*psem;
    pxsem = (bosal_sem_t *)*psem;
-    result = pthread_mutex_lock(&pxsem->count_lock);
+  result = pthread_mutex_lock(&pxsem->count_lock);
-    if (result)
+  if (result) {
-    {
+    return result;
-        return result;
+  }
-    }
+  xresult = 0;
    xresult = 0;
-    if (pxsem->count == 0)
+  if (pxsem->count == 0) {
-    {
+    xresult = pthread_cond_wait(&pxsem->count_bump, &pxsem->count_lock);
-        xresult = pthread_cond_wait(&pxsem->count_bump, &pxsem->count_lock);
+  }
  if (!xresult) {
    if (pxsem->count > 0) {
      pxsem->count--;
    }
-    if (! xresult)
+  }
-    {
+  result = pthread_mutex_unlock(&pxsem->count_lock);
-        if (pxsem->count > 0)
+  if (result) {
-        {
+    return result;
-            pxsem->count--;
+  }
-        }
+  if (xresult) {
-    }
+    errno = xresult;
-    result = pthread_mutex_unlock(&pxsem->count_lock);
+    return -1;
-    if (result)
+  }
-    {
+  return 0;
        return result;
    }
    if (xresult)
    {
        errno = xresult;
        return -1;
    }
    return 0;
 }
-int tsem_timewait(tsem_t *psem, int64_t nanosecs)
+int tsem_timewait(tsem_t *psem, int64_t nanosecs) {
 {
  struct timespec abstim = {
      .tv_sec = 0,
      .tv_nsec = nanosecs,
  };
-    bosal_sem_t *pxsem;
+  bosal_sem_t *pxsem;
-    int result, xresult;
+  int          result, xresult;
-    if (! psem)
+  if (!psem) {
-    {
+    return EINVAL;
-        return EINVAL;
+  }
-    }
+  pxsem = (bosal_sem_t *)*psem;
    pxsem = (bosal_sem_t *)*psem;
-    result = pthread_mutex_lock(&pxsem->count_lock);
+  result = pthread_mutex_lock(&pxsem->count_lock);
-    if (result)
+  if (result) {
-    {
+    return result;
-        return result;
+  }
-    }
+  xresult = 0;
    xresult = 0;
-    if (pxsem->count == 0)
+  if (pxsem->count == 0) {
-    {
+    xresult = pthread_cond_timedwait(&pxsem->count_bump, &pxsem->count_lock, &abstim);
-        xresult = pthread_cond_timedwait(&pxsem->count_bump, &pxsem->count_lock, &abstim);
+  }
  if (!xresult) {
    if (pxsem->count > 0) {
      pxsem->count--;
    }
-    if (! xresult)
+  }
-    {
+  result = pthread_mutex_unlock(&pxsem->count_lock);
-        if (pxsem->count > 0)
+  if (result) {
-        {
+    return result;
-            pxsem->count--;
+  }
-        }
+  if (xresult) {
-    }
+    errno = xresult;
-    result = pthread_mutex_unlock(&pxsem->count_lock);
+    return -1;
-    if (result)
+  }
-    {
+  return 0;
        return result;
    }
    if (xresult)
    {
        errno = xresult;
        return -1;
    }
    return 0;
 }
-bool taosCheckPthreadValid(TdThread thread) { 
+bool taosCheckPthreadValid(TdThread thread) {
  int32_t ret = taosThreadKill(thread, 0);
  if (ret == ESRCH) return false;
  if (ret == EINVAL) return false;
  // alive
  return true;
- }
+}
 int64_t taosGetSelfPthreadId() {
  TdThread thread = taosThreadSelf();
@ -651,7 +621,13 @@ int64_t taosGetSelfPthreadId() {
 int64_t taosGetPthreadId(TdThread thread) { return (int64_t)thread; }
 void    taosResetPthread(TdThread* thread) { *thread = 0; }
 bool    taosComparePthread(TdThread first, TdThread second) { return first == second; }
-int32_t taosGetPId() { return getpid(); }
+
 int32_t taosGetPId() {
  static int32_t pid;
  if (pid != 0) return pid;
  pid = getpid();
  return pid;
 }
 int32_t taosGetAppName(char* name, int32_t* len) {
  const char* self = "/proc/self/exe";
--- a/source/util/src/terror.c
+++ b/source/util/src/terror.c
@ -281,11 +281,12 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TOPIC,            "Invalid topic")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TOPIC_QUERY,      "Topic with invalid query")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TOPIC_OPTION,     "Topic with invalid option")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_CONSUMER_NOT_EXIST,       "Consumer not exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOPIC_OPTION_UNCHNAGED,   "Consumer unchanged")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOPIC_OPTION_UNCHNAGED,   "Topic unchanged")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_SUBSCRIBE_NOT_EXIST,      "Subcribe not exist")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_OFFSET_NOT_EXIST,         "Offset not exist")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_CONSUMER_NOT_READY,       "Consumer not ready")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOPIC_SUBSCRIBED,         "Topic subscribed cannot be dropped")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOPIC_MUST_BE_DELETED,    "Topic must be dropped first")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_CGROUP_USED,              "Consumer group being used by some consumer")
 // mnode-stream
@ -623,6 +624,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_INDEX_REBUILDING,               "Invalid index file"
 //tmq
 TAOS_DEFINE_ERROR(TSDB_CODE_TMQ_INVALID_MSG,                "Invalid message")
 TAOS_DEFINE_ERROR(TSDB_CODE_TMQ_CONSUMER_MISMATCH,          "Consumer mismatch")
 #ifdef TAOS_ERROR_C
 };
--- a/tests/script/jenkins/basic.txt
+++ b/tests/script/jenkins/basic.txt
@ -237,8 +237,8 @@
 ./test.sh -f tsim/stream/distributeInterval0.sim
 ./test.sh -f tsim/stream/distributeIntervalRetrive0.sim
 ./test.sh -f tsim/stream/distributeSession0.sim
-./test.sh -f tsim/stream/session0.sim
+#./test.sh -f tsim/stream/session0.sim
-./test.sh -f tsim/stream/session1.sim
+#./test.sh -f tsim/stream/session1.sim
 ./test.sh -f tsim/stream/state0.sim
 ./test.sh -f tsim/stream/triggerInterval0.sim
 ./test.sh -f tsim/stream/triggerSession0.sim
--- a/tests/system-test/2-query/interp.py
+++ b/tests/system-test/2-query/interp.py
@ -0,0 +1,559 @@
 import taos
 import sys
 from util.log import *
 from util.sql import *
 from util.cases import *
 class TDTestCase:
    def init(self, conn, logSql):
        tdLog.debug(f"start to excute {__file__}")
        tdSql.init(conn.cursor())
    def run(self):
        dbname = "db"
        tbname = "tb"
        tdSql.prepare()
        tdLog.printNoPrefix("==========step1:create table")
        tdSql.execute(
            f'''create table if not exists {dbname}.{tbname}
            (ts timestamp, c0 tinyint, c1 smallint, c2 int, c3 bigint, c4 double, c5 float, c6 bool, c7 varchar(10), c8 nchar(10))
            '''
        )
        tdLog.printNoPrefix("==========step2:insert data")
        tdSql.execute(f"insert into {dbname}.{tbname} values ('2020-02-01 00:00:05', 5, 5, 5, 5, 5.0, 5.0, true, 'varchar', 'nchar')")
        tdSql.execute(f"insert into {dbname}.{tbname} values ('2020-02-01 00:00:10', 10, 10, 10, 10, 10.0, 10.0, true, 'varchar', 'nchar')")
        tdSql.execute(f"insert into {dbname}.{tbname} values ('2020-02-01 00:00:15', 15, 15, 15, 15, 15.0, 15.0, true, 'varchar', 'nchar')")
        tdLog.printNoPrefix("==========step3:fill null")
        ## {. . .}
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:04', '2020-02-01 00:00:16') every(1s) fill(null)")
        tdSql.checkRows(13)
        tdSql.checkData(0, 0, None)
        tdSql.checkData(1, 0, 5)
        tdSql.checkData(2, 0, None)
        tdSql.checkData(3, 0, None)
        tdSql.checkData(4, 0, None)
        tdSql.checkData(5, 0, None)
        tdSql.checkData(6, 0, 10)
        tdSql.checkData(7, 0, None)
        tdSql.checkData(8, 0, None)
        tdSql.checkData(9, 0, None)
        tdSql.checkData(10, 0, None)
        tdSql.checkData(11, 0, 15)
        tdSql.checkData(12, 0, None)
        ## {} ...
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:01', '2020-02-01 00:00:04') every(1s) fill(null)")
        tdSql.checkRows(4)
        tdSql.checkData(0, 0, None)
        tdSql.checkData(1, 0, None)
        tdSql.checkData(2, 0, None)
        tdSql.checkData(3, 0, None)
        ## {.}..
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:03', '2020-02-01 00:00:07') every(1s) fill(null)")
        tdSql.checkRows(5)
        tdSql.checkData(0, 0, None)
        tdSql.checkData(1, 0, None)
        tdSql.checkData(2, 0, 5)
        tdSql.checkData(3, 0, None)
        tdSql.checkData(4, 0, None)
        ## .{}..
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:06', '2020-02-01 00:00:09') every(1s) fill(null)")
        tdSql.checkRows(4)
        tdSql.checkData(0, 0, None)
        tdSql.checkData(1, 0, None)
        tdSql.checkData(2, 0, None)
        tdSql.checkData(3, 0, None)
        ## .{.}.
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:08', '2020-02-01 00:00:12') every(1s) fill(null)")
        tdSql.checkRows(5)
        tdSql.checkData(0, 0, None)
        tdSql.checkData(1, 0, None)
        tdSql.checkData(2, 0, 10)
        tdSql.checkData(3, 0, None)
        tdSql.checkData(4, 0, None)
        ## ..{.}
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:13', '2020-02-01 00:00:17') every(1s) fill(null)")
        tdSql.checkRows(5)
        tdSql.checkData(0, 0, None)
        tdSql.checkData(1, 0, None)
        tdSql.checkData(2, 0, 15)
        tdSql.checkData(3, 0, None)
        tdSql.checkData(4, 0, None)
        ## ... {}
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:16', '2020-02-01 00:00:19') every(1s) fill(null)")
        tdSql.checkRows(4)
        tdSql.checkData(0, 0, None)
        tdSql.checkData(1, 0, None)
        tdSql.checkData(2, 0, None)
        tdSql.checkData(3, 0, None)
        tdLog.printNoPrefix("==========step4:fill value")
        ## {. . .}
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:04', '2020-02-01 00:00:16') every(1s) fill(value, 1)")
        tdSql.checkRows(13)
        tdSql.checkData(0, 0, 1)
        tdSql.checkData(1, 0, 5)
        tdSql.checkData(2, 0, 1)
        tdSql.checkData(3, 0, 1)
        tdSql.checkData(4, 0, 1)
        tdSql.checkData(5, 0, 1)
        tdSql.checkData(6, 0, 10)
        tdSql.checkData(7, 0, 1)
        tdSql.checkData(8, 0, 1)
        tdSql.checkData(9, 0, 1)
        tdSql.checkData(10, 0, 1)
        tdSql.checkData(11, 0, 15)
        tdSql.checkData(12, 0, 1)
        ## {} ...
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:01', '2020-02-01 00:00:04') every(1s) fill(value, 1)")
        tdSql.checkRows(4)
        tdSql.checkData(0, 0, 1)
        tdSql.checkData(1, 0, 1)
        tdSql.checkData(2, 0, 1)
        tdSql.checkData(3, 0, 1)
        ## {.}..
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:03', '2020-02-01 00:00:07') every(1s) fill(value, 1)")
        tdSql.checkRows(5)
        tdSql.checkData(0, 0, 1)
        tdSql.checkData(1, 0, 1)
        tdSql.checkData(2, 0, 5)
        tdSql.checkData(3, 0, 1)
        tdSql.checkData(4, 0, 1)
        ## .{}..
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:06', '2020-02-01 00:00:09') every(1s) fill(value, 1)")
        tdSql.checkRows(4)
        tdSql.checkData(0, 0, 1)
        tdSql.checkData(1, 0, 1)
        tdSql.checkData(2, 0, 1)
        tdSql.checkData(3, 0, 1)
        ## .{.}.
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:08', '2020-02-01 00:00:12') every(1s) fill(value, 1)")
        tdSql.checkRows(5)
        tdSql.checkData(0, 0, 1)
        tdSql.checkData(1, 0, 1)
        tdSql.checkData(2, 0, 10)
        tdSql.checkData(3, 0, 1)
        tdSql.checkData(4, 0, 1)
        ## ..{.}
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:13', '2020-02-01 00:00:17') every(1s) fill(value, 1)")
        tdSql.checkRows(5)
        tdSql.checkData(0, 0, 1)
        tdSql.checkData(1, 0, 1)
        tdSql.checkData(2, 0, 15)
        tdSql.checkData(3, 0, 1)
        tdSql.checkData(4, 0, 1)
        ## ... {}
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:16', '2020-02-01 00:00:19') every(1s) fill(value, 1)")
        tdSql.checkRows(4)
        tdSql.checkData(0, 0, 1)
        tdSql.checkData(1, 0, 1)
        tdSql.checkData(2, 0, 1)
        tdSql.checkData(3, 0, 1)
        tdLog.printNoPrefix("==========step5:fill prev")
        ## {. . .}
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:04', '2020-02-01 00:00:16') every(1s) fill(prev)")
        tdSql.checkRows(12)
        tdSql.checkData(0, 0, 5)
        tdSql.checkData(1, 0, 5)
        tdSql.checkData(2, 0, 5)
        tdSql.checkData(3, 0, 5)
        tdSql.checkData(4, 0, 5)
        tdSql.checkData(5, 0, 10)
        tdSql.checkData(6, 0, 10)
        tdSql.checkData(7, 0, 10)
        tdSql.checkData(8, 0, 10)
        tdSql.checkData(9, 0, 10)
        tdSql.checkData(10, 0, 15)
        tdSql.checkData(11, 0, 15)
        ## {} ...
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:01', '2020-02-01 00:00:04') every(1s) fill(prev)")
        tdSql.checkRows(0)
        ## {.}..
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:03', '2020-02-01 00:00:07') every(1s) fill(prev)")
        tdSql.checkRows(3)
        tdSql.checkData(0, 0, 5)
        tdSql.checkData(1, 0, 5)
        tdSql.checkData(2, 0, 5)
        ## .{}..
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:06', '2020-02-01 00:00:09') every(1s) fill(prev)")
        tdSql.checkRows(4)
        tdSql.checkData(0, 0, 5)
        tdSql.checkData(1, 0, 5)
        tdSql.checkData(2, 0, 5)
        tdSql.checkData(3, 0, 5)
        ## .{.}.
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:08', '2020-02-01 00:00:12') every(1s) fill(prev)")
        tdSql.checkRows(5)
        tdSql.checkData(0, 0, 5)
        tdSql.checkData(1, 0, 5)
        tdSql.checkData(2, 0, 10)
        tdSql.checkData(3, 0, 10)
        tdSql.checkData(4, 0, 10)
        ## ..{.}
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:13', '2020-02-01 00:00:17') every(1s) fill(prev)")
        tdSql.checkRows(5)
        tdSql.checkData(0, 0, 10)
        tdSql.checkData(1, 0, 10)
        tdSql.checkData(2, 0, 15)
        tdSql.checkData(3, 0, 15)
        tdSql.checkData(4, 0, 15)
        ## ... {}
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:16', '2020-02-01 00:00:19') every(1s) fill(prev)")
        tdSql.checkRows(4)
        tdSql.checkData(0, 0, 15)
        tdSql.checkData(1, 0, 15)
        tdSql.checkData(2, 0, 15)
        tdSql.checkData(3, 0, 15)
        tdLog.printNoPrefix("==========step6:fill next")
        ## {. . .}
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:04', '2020-02-01 00:00:16') every(1s) fill(next)")
        tdSql.checkRows(12)
        tdSql.checkData(0, 0, 5)
        tdSql.checkData(1, 0, 5)
        tdSql.checkData(2, 0, 10)
        tdSql.checkData(3, 0, 10)
        tdSql.checkData(4, 0, 10)
        tdSql.checkData(5, 0, 10)
        tdSql.checkData(6, 0, 10)
        tdSql.checkData(7, 0, 15)
        tdSql.checkData(8, 0, 15)
        tdSql.checkData(9, 0, 15)
        tdSql.checkData(10, 0, 15)
        tdSql.checkData(11, 0, 15)
        ## {} ...
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:01', '2020-02-01 00:00:04') every(1s) fill(next)")
        tdSql.checkRows(4)
        tdSql.checkData(0, 0, 5)
        tdSql.checkData(1, 0, 5)
        tdSql.checkData(2, 0, 5)
        tdSql.checkData(3, 0, 5)
        ## {.}..
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:03', '2020-02-01 00:00:07') every(1s) fill(next)")
        tdSql.checkRows(5)
        tdSql.checkData(0, 0, 5)
        tdSql.checkData(1, 0, 5)
        tdSql.checkData(2, 0, 5)
        tdSql.checkData(3, 0, 10)
        tdSql.checkData(4, 0, 10)
        ## .{}..
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:06', '2020-02-01 00:00:09') every(1s) fill(next)")
        tdSql.checkRows(4)
        tdSql.checkData(0, 0, 10)
        tdSql.checkData(1, 0, 10)
        tdSql.checkData(2, 0, 10)
        tdSql.checkData(3, 0, 10)
        ## .{.}.
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:08', '2020-02-01 00:00:12') every(1s) fill(next)")
        tdSql.checkRows(5)
        tdSql.checkData(0, 0, 10)
        tdSql.checkData(1, 0, 10)
        tdSql.checkData(2, 0, 10)
        tdSql.checkData(3, 0, 15)
        tdSql.checkData(4, 0, 15)
        ## ..{.}
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:13', '2020-02-01 00:00:17') every(1s) fill(next)")
        tdSql.checkRows(3)
        tdSql.checkData(0, 0, 15)
        tdSql.checkData(1, 0, 15)
        tdSql.checkData(2, 0, 15)
        ## ... {}
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:16', '2020-02-01 00:00:19') every(1s) fill(next)")
        tdSql.checkRows(0)
        tdLog.printNoPrefix("==========step7:fill linear")
        ## {. . .}
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:04', '2020-02-01 00:00:16') every(1s) fill(linear)")
        tdSql.checkRows(11)
        tdSql.checkData(0, 0, 5)
        tdSql.checkData(1, 0, 6)
        tdSql.checkData(2, 0, 7)
        tdSql.checkData(3, 0, 8)
        tdSql.checkData(4, 0, 9)
        tdSql.checkData(5, 0, 10)
        tdSql.checkData(6, 0, 11)
        tdSql.checkData(7, 0, 12)
        tdSql.checkData(8, 0, 13)
        tdSql.checkData(9, 0, 14)
        tdSql.checkData(10, 0, 15)
        ## {} ...
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:01', '2020-02-01 00:00:04') every(1s) fill(linear)")
        tdSql.checkRows(0)
        ## {.}..
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:03', '2020-02-01 00:00:07') every(1s) fill(linear)")
        tdSql.checkRows(3)
        tdSql.checkData(0, 0, 5)
        tdSql.checkData(1, 0, 6)
        tdSql.checkData(2, 0, 7)
        ## .{}..
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:06', '2020-02-01 00:00:09') every(1s) fill(linear)")
        tdSql.checkRows(4)
        tdSql.checkData(0, 0, 6)
        tdSql.checkData(1, 0, 7)
        tdSql.checkData(2, 0, 8)
        tdSql.checkData(3, 0, 9)
        ## .{.}.
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:08', '2020-02-01 00:00:12') every(1s) fill(linear)")
        tdSql.checkRows(5)
        tdSql.checkData(0, 0, 8)
        tdSql.checkData(1, 0, 9)
        tdSql.checkData(2, 0, 10)
        tdSql.checkData(3, 0, 11)
        tdSql.checkData(4, 0, 12)
        ## ..{.}
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:13', '2020-02-01 00:00:17') every(1s) fill(linear)")
        tdSql.checkRows(3)
        tdSql.checkData(0, 0, 13)
        tdSql.checkData(1, 0, 14)
        tdSql.checkData(2, 0, 15)
        ## ... {}
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:16', '2020-02-01 00:00:19') every(1s) fill(linear)")
        tdSql.checkRows(0)
        tdLog.printNoPrefix("==========step8:test intra block interpolation")
        tdSql.execute(f"drop database {dbname}");
        tdSql.prepare()
        tdSql.execute(f"create table if not exists {dbname}.{tbname} (ts timestamp, c0 tinyint, c1 smallint, c2 int, c3 bigint, c4 double, c5 float, c6 bool, c7 varchar(10), c8 nchar(10))")
        # set two data point has 10 days interval will be stored in different datablocks
        tdSql.execute(f"insert into {dbname}.{tbname} values ('2020-02-01 00:00:05', 5, 5, 5, 5, 5.0, 5.0, true, 'varchar', 'nchar')")
        tdSql.execute(f"insert into {dbname}.{tbname} values ('2020-02-11 00:00:05', 15, 15, 15, 15, 15.0, 15.0, true, 'varchar', 'nchar')")
        tdSql.execute(f"flush database {dbname}");
        # test fill null
        ## | {. | | .} |
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:05', '2020-02-11 00:00:05') every(1d) fill(null)")
        tdSql.checkRows(11)
        tdSql.checkData(0, 0, 5)
        tdSql.checkData(1, 0, None)
        tdSql.checkData(2, 0, None)
        tdSql.checkData(3, 0, None)
        tdSql.checkData(4, 0, None)
        tdSql.checkData(5, 0, None)
        tdSql.checkData(6, 0, None)
        tdSql.checkData(7, 0, None)
        tdSql.checkData(8, 0, None)
        tdSql.checkData(9, 0, None)
        tdSql.checkData(10, 0, 15)
        ## | . | {} | . |
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-03 00:00:05', '2020-02-07 00:00:05') every(1d) fill(null)")
        tdSql.checkRows(5)
        tdSql.checkData(0, 0, None)
        tdSql.checkData(1, 0, None)
        tdSql.checkData(2, 0, None)
        tdSql.checkData(3, 0, None)
        tdSql.checkData(4, 0, None)
        ## | {. | } | . |
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-01-31 00:00:05', '2020-02-05 00:00:05') every(1d) fill(null)")
        tdSql.checkRows(6)
        tdSql.checkData(0, 0, None)
        tdSql.checkData(1, 0, 5)
        tdSql.checkData(2, 0, None)
        tdSql.checkData(3, 0, None)
        tdSql.checkData(4, 0, None)
        tdSql.checkData(5, 0, None)
        ## | . | { | .} |
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-10 00:00:05', '2020-02-15 00:00:05') every(1d) fill(null)")
        tdSql.checkRows(6)
        tdSql.checkData(0, 0, None)
        tdSql.checkData(1, 0, 15)
        tdSql.checkData(2, 0, None)
        tdSql.checkData(3, 0, None)
        tdSql.checkData(4, 0, None)
        tdSql.checkData(5, 0, None)
        # test fill value
        ## | {. | | .} |
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:05', '2020-02-11 00:00:05') every(1d) fill(value, 1)")
        tdSql.checkRows(11)
        tdSql.checkData(0, 0, 5)
        tdSql.checkData(1, 0, 1)
        tdSql.checkData(2, 0, 1)
        tdSql.checkData(3, 0, 1)
        tdSql.checkData(4, 0, 1)
        tdSql.checkData(5, 0, 1)
        tdSql.checkData(6, 0, 1)
        tdSql.checkData(7, 0, 1)
        tdSql.checkData(8, 0, 1)
        tdSql.checkData(9, 0, 1)
        tdSql.checkData(10, 0, 15)
        ## | . | {} | . |
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-03 00:00:05', '2020-02-07 00:00:05') every(1d) fill(value, 1)")
        tdSql.checkRows(5)
        tdSql.checkData(0, 0, 1)
        tdSql.checkData(1, 0, 1)
        tdSql.checkData(2, 0, 1)
        tdSql.checkData(3, 0, 1)
        tdSql.checkData(4, 0, 1)
        ## | {. | } | . |
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-01-31 00:00:05', '2020-02-05 00:00:05') every(1d) fill(value, 1)")
        tdSql.checkRows(6)
        tdSql.checkData(0, 0, 1)
        tdSql.checkData(1, 0, 5)
        tdSql.checkData(2, 0, 1)
        tdSql.checkData(3, 0, 1)
        tdSql.checkData(4, 0, 1)
        tdSql.checkData(5, 0, 1)
        ## | . | { | .} |
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-10 00:00:05', '2020-02-15 00:00:05') every(1d) fill(value, 1)")
        tdSql.checkRows(6)
        tdSql.checkData(0, 0, 1)
        tdSql.checkData(1, 0, 15)
        tdSql.checkData(2, 0, 1)
        tdSql.checkData(3, 0, 1)
        tdSql.checkData(4, 0, 1)
        tdSql.checkData(5, 0, 1)
        # test fill prev
        ## | {. | | .} |
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:05', '2020-02-11 00:00:05') every(1d) fill(prev)")
        tdSql.checkRows(11)
        tdSql.checkData(0, 0, 5)
        tdSql.checkData(1, 0, 5)
        tdSql.checkData(2, 0, 5)
        tdSql.checkData(3, 0, 5)
        tdSql.checkData(4, 0, 5)
        tdSql.checkData(5, 0, 5)
        tdSql.checkData(6, 0, 5)
        tdSql.checkData(7, 0, 5)
        tdSql.checkData(8, 0, 5)
        tdSql.checkData(9, 0, 5)
        tdSql.checkData(10, 0, 15)
        ## | . | {} | . |
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-03 00:00:05', '2020-02-07 00:00:05') every(1d) fill(prev)")
        tdSql.checkRows(5)
        tdSql.checkData(0, 0, 5)
        tdSql.checkData(1, 0, 5)
        tdSql.checkData(2, 0, 5)
        tdSql.checkData(3, 0, 5)
        tdSql.checkData(4, 0, 5)
        ## | {. | } | . |
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-01-31 00:00:05', '2020-02-05 00:00:05') every(1d) fill(prev)")
        tdSql.checkRows(5)
        tdSql.checkData(0, 0, 5)
        tdSql.checkData(1, 0, 5)
        tdSql.checkData(2, 0, 5)
        tdSql.checkData(3, 0, 5)
        tdSql.checkData(4, 0, 5)
        ## | . | { | .} |
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-10 00:00:05', '2020-02-15 00:00:05') every(1d) fill(prev)")
        tdSql.checkRows(6)
        tdSql.checkData(0, 0, 5)
        tdSql.checkData(1, 0, 15)
        tdSql.checkData(2, 0, 15)
        tdSql.checkData(3, 0, 15)
        tdSql.checkData(4, 0, 15)
        tdSql.checkData(5, 0, 15)
        # test fill next
        ## | {. | | .} |
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-01 00:00:05', '2020-02-11 00:00:05') every(1d) fill(next)")
        tdSql.checkRows(11)
        tdSql.checkData(0, 0, 5)
        tdSql.checkData(1, 0, 15)
        tdSql.checkData(2, 0, 15)
        tdSql.checkData(3, 0, 15)
        tdSql.checkData(4, 0, 15)
        tdSql.checkData(5, 0, 15)
        tdSql.checkData(6, 0, 15)
        tdSql.checkData(7, 0, 15)
        tdSql.checkData(8, 0, 15)
        tdSql.checkData(9, 0, 15)
        tdSql.checkData(10, 0, 15)
        ## | . | {} | . |
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-03 00:00:05', '2020-02-07 00:00:05') every(1d) fill(next)")
        tdSql.checkRows(5)
        tdSql.checkData(0, 0, 15)
        tdSql.checkData(1, 0, 15)
        tdSql.checkData(2, 0, 15)
        tdSql.checkData(3, 0, 15)
        tdSql.checkData(4, 0, 15)
        ## | {. | } | . |
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-01-31 00:00:05', '2020-02-05 00:00:05') every(1d) fill(next)")
        tdSql.checkRows(6)
        tdSql.checkData(0, 0, 5)
        tdSql.checkData(1, 0, 5)
        tdSql.checkData(2, 0, 15)
        tdSql.checkData(3, 0, 15)
        tdSql.checkData(4, 0, 15)
        tdSql.checkData(5, 0, 15)
        ## | . | { | .} |
        tdSql.query(f"select interp(c0) from {dbname}.{tbname} range('2020-02-10 00:00:05', '2020-02-15 00:00:05') every(1d) fill(next)")
        tdSql.checkRows(2)
        tdSql.checkData(0, 0, 15)
        tdSql.checkData(1, 0, 15)
    def stop(self):
        tdSql.close()
        tdLog.success(f"{__file__} successfully executed")
 tdCases.addLinux(__file__, TDTestCase())
 tdCases.addWindows(__file__, TDTestCase())
--- a/tests/system-test/2-query/sample.py
+++ b/tests/system-test/2-query/sample.py
@ -335,7 +335,7 @@ class TDTestCase:
        # case11 = {"alias": ", st1"}
        # self.checksample(**case11)
        tdSql.query("select sample( c1 , 1 ) , st1 from t1")
-        
+
        # case12 = {"alias": ", c1"}
        # self.checksample(**case12)
@ -497,7 +497,7 @@ class TDTestCase:
        # tdSql.query(" select sample(c1 , 1) + 2 from t1 ")
        err41 = {"alias": "+ avg(c1)"}
        # self.checksample(**err41)         # mix with arithmetic 2
-        
+
        # err42 = {"alias": ", c1"}
        # self.checksample(**err42)
        tdSql.query("select sample( c1 , 1 ) , c1 from t1")
@ -605,14 +605,14 @@ class TDTestCase:
            tdSql.execute(f"create table tt{i} using stb2 tags({i})")
        pass
-    
+
    def check_sample(self , sample_query , origin_query ):
        tdSql.query(origin_query)
        origin_datas = tdSql.queryResult
-        
+
        tdSql.query(sample_query)
        sample_datas = tdSql.queryResult
@ -620,7 +620,7 @@ class TDTestCase:
        for ind , sample_data in enumerate(sample_datas):
            if sample_data not in origin_datas:
                status = False
-        
+
        if status:
            tdLog.info(" sample data is in datas groups ,successed sql is :  %s" % sample_query )
        else:
@ -637,7 +637,7 @@ class TDTestCase:
            tags (t1 int)
            '''
        )
-        
+
        tdSql.execute(
            '''
            create table t1
@ -689,7 +689,7 @@ class TDTestCase:
        tdSql.error(" select sample(c1,ts) from t1 ")
        tdSql.error(" select sample(c1,false) from t1 ")
        tdSql.query(" select sample(123,1) from t1 ")
-        
+
        tdSql.query(" select sample(c1,2) from t1 ")
        tdSql.checkRows(2)
        tdSql.query(" select sample(c1,10) from t1 ")
@ -704,10 +704,10 @@ class TDTestCase:
        tdSql.checkRows(9)
        tdSql.error(" select sample(c1,-1) from t1  ")
-        # bug need fix 
+        # bug need fix
        # tdSql.query("select sample(c1 ,2) , 123 from stb1;")
-        # all type support 
+        # all type support
        tdSql.query(" select sample(c1 , 20 ) from ct4 ")
        tdSql.checkRows(9)
@ -761,7 +761,7 @@ class TDTestCase:
        self.check_sample("select sample( c1 ,3 )  from t1 where c1 between 1 and 10" ,"select c1  from t1 where c1 between 1 and 10")
-        # join 
+        # join
        tdSql.query("select sample( ct4.c1 , 1 )  from ct1, ct4 where ct4.ts=ct1.ts")
@ -772,22 +772,22 @@ class TDTestCase:
        self.check_sample("select sample(c1,2) from stb1 partition by tbname" , "select c1 from stb1 partition by tbname")
-        # nest query 
+        # nest query
        # tdSql.query("select sample(c1,2) from (select c1 from t1); ")
        # tdSql.checkRows(2)
-        # union all 
+        # union all
        tdSql.query("select sample(c1,2) from t1 union all select sample(c1,3) from t1")
        tdSql.checkRows(5)
        # fill interval
-        # not support mix with other function 
+        # not support mix with other function
        tdSql.error("select top(c1,2) , sample(c1,2) from ct1")
        tdSql.error("select max(c1) , sample(c1,2) from ct1")
        tdSql.query("select c1 , sample(c1,2) from ct1")
-        # bug for mix with scalar 
+        # bug for mix with scalar
        tdSql.query("select 123 , sample(c1,100) from ct1")
        tdSql.query("select sample(c1,100)+2 from ct1")
        tdSql.query("select abs(sample(c1,100)) from ct1")
@ -864,13 +864,13 @@ class TDTestCase:
        for i in range(2000):
            ts = self.ts+i*10
            tdSql.execute(f"insert into sub_tb values({ts} ,{i})")
-        
+
        tdSql.query("select count(*) from st")
        tdSql.checkData(0,0,2000)
        tdSql.query("select sample(c1 ,1000) from st")
        tdSql.checkRows(1000)
-        # bug need fix 
+        # bug need fix
        tdSql.query("select c1 ,t1, sample(c1,2) from db.stb1 partition by c1 ")
        tdSql.query("select sample(c1,2) from db.stb1 partition by c1 ")
        # tdSql.query("select c1 ,ind, sample(c1,2) from sample_db.st partition by c1 ")
--- a/tests/system-test/fulltest.sh
+++ b/tests/system-test/fulltest.sh
@ -109,6 +109,9 @@ python3 ./test.py -f 2-query/function_stateduration.py -R
 python3 ./test.py -f 2-query/histogram.py
 python3 ./test.py -f 2-query/histogram.py -R
 python3 ./test.py -f 2-query/interp.py
 python3 ./test.py -f 2-query/interp.py -R
 python3 ./test.py -f 1-insert/update_data.py
@ -343,6 +346,7 @@ python3 ./test.py -f 2-query/arcsin.py -Q 2
 python3 ./test.py -f 2-query/arccos.py -Q 2
 python3 ./test.py -f 2-query/arctan.py -Q 2
 python3 ./test.py -f 2-query/query_cols_tags_and_or.py  -Q 2
 python3 ./test.py -f 2-query/interp.py  -Q 2
 # python3 ./test.py -f 2-query/nestedQuery.py  -Q 2
 # python3 ./test.py -f 2-query/nestedQuery_str.py  -Q 2
@ -462,3 +466,4 @@ python3 ./test.py -f 2-query/max_partition.py -Q 3
 python3 ./test.py -f 2-query/last_row.py -Q 3
 python3 ./test.py -f 2-query/tsbsQuery.py -Q 3
 python3 ./test.py -f 2-query/sml.py -Q 3
 python3 ./test.py -f 2-query/interp.py -Q 3
--- a/tools/CMakeLists.txt
+++ b/tools/CMakeLists.txt
@ -112,7 +112,7 @@ ELSE ()
                COMMAND CGO_CFLAGS=-I${CMAKE_CURRENT_SOURCE_DIR}/../include/client CGO_LDFLAGS=-L${CMAKE_BINARY_DIR}/build/lib  go build -a -ldflags "-s -w -X github.com/taosdata/taosadapter/version.Version=${taos_version} -X github.com/taosdata/taosadapter/version.CommitID=${taosadapter_commit_sha1}"
                COMMAND CGO_CFLAGS=-I${CMAKE_CURRENT_SOURCE_DIR}/../include/client CGO_LDFLAGS=-L${CMAKE_BINARY_DIR}/build/lib  go build -a -o taosadapter-debug -ldflags "-X github.com/taosdata/taosadapter/version.Version=${taos_version} -X github.com/taosdata/taosadapter/version.CommitID=${taosadapter_commit_sha1}"
                INSTALL_COMMAND
-                COMMAND wget -c https://github.com/upx/upx/releases/download/v3.96/upx-3.96-${PLATFORM_ARCH_STR}_linux.tar.xz -O $ENV{HOME}/upx.tar.xz && tar -xvJf $ENV{HOME}/upx.tar.xz -C $ENV{HOME}/ --strip-components 1 > /dev/null && $ENV{HOME}/upx taosadapter || :
+                COMMAND wget -nc https://github.com/upx/upx/releases/download/v3.96/upx-3.96-${PLATFORM_ARCH_STR}_linux.tar.xz -O $ENV{HOME}/upx.tar.xz && tar -xvJf $ENV{HOME}/upx.tar.xz -C $ENV{HOME}/ --strip-components 1 > /dev/null && $ENV{HOME}/upx taosadapter || :
                COMMAND cmake -E copy taosadapter ${CMAKE_BINARY_DIR}/build/bin
                COMMAND cmake -E make_directory ${CMAKE_BINARY_DIR}/test/cfg/
                COMMAND cmake -E copy ./example/config/taosadapter.toml ${CMAKE_BINARY_DIR}/test/cfg/
--- a/tools/shell/src/shellArguments.c
+++ b/tools/shell/src/shellArguments.c
@ -38,7 +38,7 @@
 #define SHELL_STARTUP  "Check the details of the service status."
 #define SHELL_WIDTH    "Set the default binary display width, default is 30."
 #define SHELL_NET_ROLE "Net role when network connectivity test, options: client|server."
-#define SHELL_PKG_LEN  "Packet length used for net test, default is 1024 bytes."
+#define SHELL_PKT_LEN  "Packet length used for net test, default is 1024 bytes."
 #define SHELL_PKT_NUM  "Packet numbers used for net test, default is 100."
 #define SHELL_VERSION  "Print program version."
 #define SHELL_EMAIL    "<support@taosdata.com>"
@ -62,7 +62,7 @@ void shellPrintHelp() {
  printf("%s%s%s%s\r\n", indent, "-f,", indent, SHELL_FILE);
  printf("%s%s%s%s\r\n", indent, "-h,", indent, SHELL_HOST);
  printf("%s%s%s%s\r\n", indent, "-k,", indent, SHELL_CHECK);
-  printf("%s%s%s%s\r\n", indent, "-l,", indent, SHELL_PKG_LEN);
+  printf("%s%s%s%s\r\n", indent, "-l,", indent, SHELL_PKT_LEN);
  printf("%s%s%s%s\r\n", indent, "-n,", indent, SHELL_NET_ROLE);
  printf("%s%s%s%s\r\n", indent, "-N,", indent, SHELL_PKT_NUM);
  printf("%s%s%s%s\r\n", indent, "-p,", indent, SHELL_PASSWORD);
@ -105,11 +105,11 @@ static struct argp_option shellOptions[] = {
    {"startup", 't', 0, 0, SHELL_STARTUP},
    {"display-width", 'w', "WIDTH", 0, SHELL_WIDTH},
    {"netrole", 'n', "NETROLE", 0, SHELL_NET_ROLE},
-    {"pktlen", 'l', "PKTLEN", 0, SHELL_PKG_LEN},
+    {"pktlen", 'l', "PKTLEN", 0, SHELL_PKT_LEN},
 #ifdef WEBSOCKET
    {"dsn", 'E', "DSN", 0, SHELL_DSN},
    {"restful", 'R', 0, 0, SHELL_REST},
-	{"timeout", 'T', "SECONDS", 0, SHELL_TIMEOUT},
+	  {"timeout", 'T', "SECONDS", 0, SHELL_TIMEOUT},
 #endif
    {"pktnum", 'N', "PKTNUM", 0, SHELL_PKT_NUM},
    {0},
@ -228,7 +228,7 @@ int32_t shellParseArgsWithoutArgp(int argc, char *argv[]) {
  SShellArgs *pArgs = &shell.args;
  for (int i = 1; i < argc; i++) {
-    if (strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "--usage") == 0 || strcmp(argv[i], "-?") == 0) {
+    if (strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "--usage") == 0 || strcmp(argv[i], "-?") == 0 || strcmp(argv[i], "/?") == 0) {
      shellParseSingleOpt('?', NULL);
      return 0;
    }
--- a/tools/taos-tools
+++ b/tools/taos-tools
@ -1 +0,0 @@
 Subproject commit 3c7dafeea3e558968165b73bee0f51024898e3da
		`@ -1 +0,0 @@`
			`Subproject commit 7ed7a97715388fa144718764d6bf20f9bfc29a12`
		`@ -1 +0,0 @@`
			`Subproject commit 3c7dafeea3e558968165b73bee0f51024898e3da`