Merge branch 'feature/TD-14761' of https://github.com/taosdata/TDengine into feature/TD-14761

4ee32f4d · wmmhello · 113250da · b4032570 · 4ee32f4d · 4ee32f4d
260 changed file
--- a/cmake/cmake.options
+++ b/cmake/cmake.options
@@ -51,6 +51,13 @@ IF(${TD_WINDOWS})
        "If build unit tests using googletest" 
        ON
    )
+    option(
+        TDENGINE_3
+        "TDengine 3.x"
+        ON
+        )
 ELSEIF (TD_DARWIN_64)
    add_definitions(-DCOMPILER_SUPPORTS_CXX13)
    option(

--- a/docs/en/14-reference/03-connector/java.mdx
+++ b/docs/en/14-reference/03-connector/java.mdx
@@ -91,7 +91,7 @@ Add following dependency in the `pom.xml` file of your Maven project:
 You can build Java connector from source code after cloning the TDengine project:
 ```
-git clone https://github.com/taosdata/taos-connector-jdbc.git
+git clone https://github.com/taosdata/taos-connector-jdbc.git --branch 2.0
 cd taos-connector-jdbc
 mvn clean install -Dmaven.test.skip=true
 ```
@@ -140,34 +140,34 @@ When you use a JDBC native connection to connect to a TDengine cluster, you can
 1. Do not specify hostname and port in Java applications.
-    ```java
+   ```java
-    public Connection getConn() throws Exception{
+   public Connection getConn() throws Exception{
-    Class.forName("com.taosdata.jdbc.TSDBDriver");
+   Class.forName("com.taosdata.jdbc.TSDBDriver");
-    String jdbcUrl = "jdbc:TAOS://:/test?user=root&password=taosdata";
+   String jdbcUrl = "jdbc:TAOS://:/test?user=root&password=taosdata";
-    Properties connProps = new Properties();
+   Properties connProps = new Properties();
-    connProps.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
+   connProps.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
-    connProps.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
+   connProps.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
-    connProps.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
+   connProps.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
-    Connection conn = DriverManager.getConnection(jdbcUrl, connProps);
+   Connection conn = DriverManager.getConnection(jdbcUrl, connProps);
-    return conn;
+   return conn;
-    }
+   }
-    ```
+   ```
 2. specify the firstEp and the secondEp in the configuration file taos.cfg
-    ```shell
+   ```shell
-    # first fully qualified domain name (FQDN) for TDengine system
+   # first fully qualified domain name (FQDN) for TDengine system
-    firstEp               cluster_node1:6030
+   firstEp               cluster_node1:6030
-    # second fully qualified domain name (FQDN) for TDengine system, for cluster only
+   # second fully qualified domain name (FQDN) for TDengine system, for cluster only
-    secondEp              cluster_node2:6030
+   secondEp              cluster_node2:6030
-    # default system charset
+   # default system charset
-    # charset               UTF-8
+   # charset               UTF-8
-    # system locale
+   # system locale
-    # locale                en_US.UTF-8
+   # locale                en_US.UTF-8
-    ```
+   ```
 In the above example, JDBC uses the client's configuration file to establish a connection to a hostname `cluster_node1`, port 6030, and a database named `test`. When the firstEp node in the cluster fails, JDBC attempts to connect to the cluster using secondEp.

--- a/docs/zh/02-intro.md
+++ b/docs/zh/02-intro.md
@@ -52,7 +52,7 @@ TDengine的主要功能如下：
 采用 TDengine，可将典型的物联网、车联网、工业互联网大数据平台的总拥有成本大幅降低。表现在几个方面：
 1. 由于其超强性能，它能将系统需要的计算资源和存储资源大幅降低
-2. 因为采用 SQL 接口，能与众多第三放软件无缝集成，学习迁移成本大幅下降
+2. 因为采用 SQL 接口，能与众多第三方软件无缝集成，学习迁移成本大幅下降
 3. 因为其 All In One 的特性，系统复杂度降低，能降研发成本
 4. 因为运维维护简单，运营维护成本能大幅降低

--- a/docs/zh/05-get-started/03-package.md
+++ b/docs/zh/05-get-started/03-package.md
 ---
 sidebar_label: 安装包
-title: 使用安装包安装和卸载
+title: 使用安装包立即开始
 ---
 import Tabs from "@theme/Tabs";
@@ -169,72 +169,128 @@ install.sh 安装脚本在执行过程中，会通过命令行交互界面询问
 :::
-## 卸载
+## 启动
-<Tabs>
+安装后，请使用 `systemctl` 命令来启动 TDengine 的服务进程。
-<TabItem label="apt-get 卸载" value="aptremove">
-内容 TBD
+```bash
+systemctl start taosd
+```
-</TabItem>
+检查服务是否正常工作：
-<TabItem label="Deb 卸载" value="debuninst">
+```bash
+systemctl status taosd
+```
-卸载命令如下:
+如果服务进程处于活动状态，则 status 指令会显示如下的相关信息：
 ```
-$ sudo dpkg -r tdengine
+Active: active (running)
-(Reading database ... 137504 files and directories currently installed.)
+```
-Removing tdengine (2.4.0.7) ...
-TDengine is removed successfully!
+如果后台服务进程处于停止状态，则 status 指令会显示如下的相关信息：
+```
+Active: inactive (dead)
 ```
-</TabItem>
+如果 TDengine 服务正常工作，那么您可以通过 TDengine 的命令行程序 `taos` 来访问并体验 TDengine。
+systemctl 命令汇总：
+- 启动服务进程：`systemctl start taosd`
+- 停止服务进程：`systemctl stop taosd`
+- 重启服务进程：`systemctl restart taosd`
+- 查看服务状态：`systemctl status taosd`
+:::info
+- systemctl 命令需要 _root_ 权限来运行，如果您非 _root_ 用户，请在命令前添加 sudo 。
+- `systemctl stop taosd` 指令在执行后并不会马上停止 TDengine 服务，而是会等待系统中必要的落盘工作正常完成。在数据量很大的情况下，这可能会消耗较长时间。
+- 如果系统中不支持 `systemd`，也可以用手动运行 `/usr/local/taos/bin/taosd` 方式启动 TDengine 服务。
+:::
-<TabItem label="RPM 卸载" value="rpmuninst">
+## TDengine 命令行 (CLI)
-卸载命令如下:
+为便于检查 TDengine 的状态，执行数据库 (Database) 的各种即席(Ad Hoc)查询，TDengine 提供一命令行应用程序(以下简称为 TDengine CLI) taos。要进入 TDengine 命令行，您只要在安装有 TDengine 的 Linux 终端执行 `taos` 即可。
+```bash
+taos
 ```
-$ sudo rpm -e tdengine
-TDengine is removed successfully!
+如果连接服务成功，将会打印出欢迎消息和版本信息。如果失败，则会打印错误消息出来（请参考 [FAQ](/train-faq/faq) 来解决终端连接服务端失败的问题）。 TDengine CLI 的提示符号如下：
+```cmd
+taos>
 ```
-</TabItem>
+在 TDengine CLI 中，用户可以通过 SQL 命令来创建/删除数据库、表等，并进行数据库(database)插入查询操作。在终端中运行的 SQL 语句需要以分号结束来运行。示例：
+```sql
+create database demo;
+use demo;
+create table t (ts timestamp, speed int);
+insert into t values ('2019-07-15 00:00:00', 10);
+insert into t values ('2019-07-15 01:00:00', 20);
+select * from t;
+           ts            |    speed    |
+========================================
+ 2019-07-15 00:00:00.000 |          10 |
+ 2019-07-15 01:00:00.000 |          20 |
+Query OK, 2 row(s) in set (0.003128s)
+```
-<TabItem label="tar.gz 卸载" value="taruninst">
+除执行 SQL 语句外，系统管理员还可以从 TDengine CLI 进行检查系统运行状态、添加删除用户账号等操作。TDengine CLI 连同应用驱动也可以独立安装在 Linux 或 Windows 机器上运行，更多细节请参考 [这里](../reference/taos-shell/)
-卸载命令如下:
+## 使用 taosBenchmark 体验写入速度
-```
+启动 TDengine 的服务，在 Linux 终端执行 `taosBenchmark` （曾命名为 `taosdemo`）：
-$ rmtaos
-Nginx for TDengine is running, stopping it...
-TDengine is removed successfully!
-taosKeeper is removed successfully!
+```bash
+taosBenchmark
 ```
-</TabItem>
+该命令将在数据库 test 下面自动创建一张超级表 meters，该超级表下有 1 万张表，表名为 "d0" 到 "d9999"，每张表有 1 万条记录，每条记录有 (ts, current, voltage, phase) 四个字段，时间戳从 "2017-07-14 10:40:00 000" 到 "2017-07-14 10:40:09 999"，每张表带有标签 location 和 groupId，groupId 被设置为 1 到 10， location 被设置为 "California.SanFrancisco" 或者 "California.LosAngeles"。
-</Tabs>
-:::info
+这条命令很快完成 1 亿条记录的插入。具体时间取决于硬件性能，即使在一台普通的 PC 服务器往往也仅需十几秒。
+taosBenchmark 命令本身带有很多选项，配置表的数目、记录条数等等，您可以设置不同参数进行体验，请执行 `taosBenchmark --help` 详细列出。taosBenchmark 详细使用方法请参照 [如何使用 taosBenchmark 对 TDengine 进行性能测试](https://www.taosdata.com/2021/10/09/3111.html)。
+## 使用 TDengine CLI 体验查询速度
+使用上述 taosBenchmark 插入数据后，可以在 TDengine CLI 输入查询命令，体验查询速度。
+查询超级表下记录总条数：
- TDengine 提供了多种安装包，但最好不要在一个系统上同时使用 tar.gz 安装包和 deb 或 rpm 安装包。否则会相互影响，导致在使用时出现问题。
+```sql
+taos> select count(*) from test.meters;
+```
- 对于 deb 包安装后，如果安装目录被手工误删了部分，出现卸载、或重新安装不能成功。此时，需要清除 TDengine 包的安装信息，执行如下命令：
+查询 1 亿条记录的平均值、最大值、最小值等：
-  ```
+```sql
-  $ sudo rm -f /var/lib/dpkg/info/tdengine*
+taos> select avg(current), max(voltage), min(phase) from test.meters;
-  ```
+```
-然后再重新进行安装就可以了。
+查询 location="California.SanFrancisco" 的记录总条数：
- 对于 rpm 包安装后，如果安装目录被手工误删了部分，出现卸载、或重新安装不能成功。此时，需要清除 TDengine 包的安装信息，执行如下命令：
+```sql
+taos> select count(*) from test.meters where location="California.SanFrancisco";
+```
-  ```
+查询 groupId=10 的所有记录的平均值、最大值、最小值等：
-  $ sudo rpm -e --noscripts tdengine
-  ```
+```sql
+taos> select avg(current), max(voltage), min(phase) from test.meters where groupId=10;
+```
-然后再重新进行安装就可以了。
+对表 d10 按 10s 进行平均值、最大值和最小值聚合统计：
-:::
+```sql
\ No newline at end of file
+taos> select avg(current), max(voltage), min(phase) from test.d10 interval(10s);
+```
\ No newline at end of file
--- a/docs/zh/05-get-started/06-first-use.md
+++ b/docs/zh/05-get-started/06-first-use.md
---
-sidebar_label: 开始使用
-title: 快速体验 TDengine
---
-import Tabs from "@theme/Tabs";
-import TabItem from "@theme/TabItem";
-import PkgInstall from "./\_pkg_install.mdx";
-import AptGetInstall from "./\_apt_get_install.mdx";
-## 启动
-安装后，请使用 `systemctl` 命令来启动 TDengine 的服务进程。
-```bash
-systemctl start taosd
-```
-检查服务是否正常工作：
-```bash
-systemctl status taosd
-```
-如果服务进程处于活动状态，则 status 指令会显示如下的相关信息：
-```
-Active: active (running)
-```
-如果后台服务进程处于停止状态，则 status 指令会显示如下的相关信息：
-```
-Active: inactive (dead)
-```
-如果 TDengine 服务正常工作，那么您可以通过 TDengine 的命令行程序 `taos` 来访问并体验 TDengine。
-systemctl 命令汇总：
- 启动服务进程：`systemctl start taosd`
- 停止服务进程：`systemctl stop taosd`
- 重启服务进程：`systemctl restart taosd`
- 查看服务状态：`systemctl status taosd`
-:::info
- systemctl 命令需要 _root_ 权限来运行，如果您非 _root_ 用户，请在命令前添加 sudo 。
- `systemctl stop taosd` 指令在执行后并不会马上停止 TDengine 服务，而是会等待系统中必要的落盘工作正常完成。在数据量很大的情况下，这可能会消耗较长时间。
- 如果系统中不支持 `systemd`，也可以用手动运行 `/usr/local/taos/bin/taosd` 方式启动 TDengine 服务。
-:::
-## TDengine 命令行 (CLI)
-为便于检查 TDengine 的状态，执行数据库 (Database) 的各种即席(Ad Hoc)查询，TDengine 提供一命令行应用程序(以下简称为 TDengine CLI) taos。要进入 TDengine 命令行，您只要在安装有 TDengine 的 Linux 终端执行 `taos` 即可。
-```bash
-taos
-```
-如果连接服务成功，将会打印出欢迎消息和版本信息。如果失败，则会打印错误消息出来（请参考 [FAQ](/train-faq/faq) 来解决终端连接服务端失败的问题）。 TDengine CLI 的提示符号如下：
-```cmd
-taos>
-```
-在 TDengine CLI 中，用户可以通过 SQL 命令来创建/删除数据库、表等，并进行数据库(database)插入查询操作。在终端中运行的 SQL 语句需要以分号结束来运行。示例：
-```sql
-create database demo;
-use demo;
-create table t (ts timestamp, speed int);
-insert into t values ('2019-07-15 00:00:00', 10);
-insert into t values ('2019-07-15 01:00:00', 20);
-select * from t;
-           ts            |    speed    |
-========================================
- 2019-07-15 00:00:00.000 |          10 |
- 2019-07-15 01:00:00.000 |          20 |
-Query OK, 2 row(s) in set (0.003128s)
-```
-除执行 SQL 语句外，系统管理员还可以从 TDengine CLI 进行检查系统运行状态、添加删除用户账号等操作。TDengine CLI 连同应用驱动也可以独立安装在 Linux 或 Windows 机器上运行，更多细节请参考 [这里](../reference/taos-shell/)
-## 使用 taosBenchmark 体验写入速度
-启动 TDengine 的服务，在 Linux 终端执行 `taosBenchmark` （曾命名为 `taosdemo`）：
-```bash
-taosBenchmark
-```
-该命令将在数据库 test 下面自动创建一张超级表 meters，该超级表下有 1 万张表，表名为 "d0" 到 "d9999"，每张表有 1 万条记录，每条记录有 (ts, current, voltage, phase) 四个字段，时间戳从 "2017-07-14 10:40:00 000" 到 "2017-07-14 10:40:09 999"，每张表带有标签 location 和 groupId，groupId 被设置为 1 到 10， location 被设置为 "California.SanFrancisco" 或者 "California.LosAngeles"。
-这条命令很快完成 1 亿条记录的插入。具体时间取决于硬件性能，即使在一台普通的 PC 服务器往往也仅需十几秒。
-taosBenchmark 命令本身带有很多选项，配置表的数目、记录条数等等，您可以设置不同参数进行体验，请执行 `taosBenchmark --help` 详细列出。taosBenchmark 详细使用方法请参照 [如何使用 taosBenchmark 对 TDengine 进行性能测试](https://www.taosdata.com/2021/10/09/3111.html)。
-## 使用 TDengine CLI 体验查询速度
-使用上述 taosBenchmark 插入数据后，可以在 TDengine CLI 输入查询命令，体验查询速度。
-查询超级表下记录总条数：
-```sql
-taos> select count(*) from test.meters;
-```
-查询 1 亿条记录的平均值、最大值、最小值等：
-```sql
-taos> select avg(current), max(voltage), min(phase) from test.meters;
-```
-查询 location="California.SanFrancisco" 的记录总条数：
-```sql
-taos> select count(*) from test.meters where location="California.SanFrancisco";
-```
-查询 groupId=10 的所有记录的平均值、最大值、最小值等：
-```sql
-taos> select avg(current), max(voltage), min(phase) from test.meters where groupId=10;
-```
-对表 d10 按 10s 进行平均值、最大值和最小值聚合统计：
-```sql
-taos> select avg(current), max(voltage), min(phase) from test.d10 interval(10s);
-```
--- a/docs/zh/05-get-started/index.md
+++ b/docs/zh/05-get-started/index.md
 ---
 title: 立即开始
-description: '从 Docker，安装包或使用 apt-get 快速安装 TDengine, 通过命令行程序TDengine CLI和工具 taosdemo 快速体验 TDengine 功能'
+description: '快速设置 TDengine 环境并体验其高效写入和查询'
 ---
-import Tabs from "@theme/Tabs";
-import TabItem from "@theme/TabItem";
-import PkgInstall from "./\_pkg_install.mdx";
-import AptGetInstall from "./\_apt_get_install.mdx";
-## 安装
+本章主要介绍如何利用 Docker 或者安装包快速设置 TDengine 环境并体验其高效写入和查询。
-TDengine 完整的软件包包括服务端（taosd）、用于与第三方系统对接并提供 RESTful 接口的 taosAdapter、应用驱动（taosc）、命令行程序 (CLI，taos) 和一些工具软件，目前 2.X 版服务端 taosd 和 taosAdapter 仅在 Linux 系统上安装和运行，后续将支持 Windows、macOS 等系统。应用驱动 taosc 与 TDengine CLI 可以在 Windows 或 Linux 上安装和运行。TDengine 除了提供多种语言的连接器之外，还通过 [taosAdapter](/reference/taosadapter) 提供 [RESTful 接口](/reference/rest-api)。但在 2.4 之前的版本中没有 taosAdapter，RESTful 接口是由 taosd 内置的 HTTP 服务提供的。
+```mdx-code-block
+import DocCardList from '@theme/DocCardList';
+import {useCurrentSidebarCategory} from '@docusaurus/theme-common';
-TDengine 支持 X64/ARM64/MIPS64/Alpha64 硬件平台，后续将支持 ARM32、RISC-V 等 CPU 架构。
+<DocCardList items={useCurrentSidebarCategory().items}/>
+```
-<Tabs defaultValue="apt-get">
\ No newline at end of file
-<TabItem value="docker" label="Docker">
-如果已经安装了 docker， 只需执行下面的命令。
-```shell
-docker run -d -p 6030-6049:6030-6049 -p 6030-6049:6030-6049/udp tdengine/tdengine
-```
-确定该容器已经启动并且在正常运行
-```shell
-docker ps
-```
-进入该容器并执行 bash
-```shell
-docker exec -it <container name> bash
-```
-然后就可以执行相关的 Linux 命令操作和访问 TDengine
-详细操作方法请参照 [通过 Docker 快速体验 TDengine](/train-faq/docker)。
-:::info
-从 2.4.0.10 开始，除 taosd 以外，Docker 镜像还包含：taos、taosAdapter、taosdump、taosBenchmark、TDinsight 安装脚本和示例代码。启动 Docker 容器时，将同时启动 taosAdapter 和 taosd，实现对 RESTful 的支持。
-:::
-</TabItem>
-<TabItem value="apt-get" label="apt-get">
-<AptGetInstall />
-</TabItem>
-<TabItem value="pkg" label="安装包">
-<PkgInstall />
-</TabItem>
-<TabItem value="src" label="源码">
-如果您希望对 TDengine 贡献代码或对内部实现感兴趣，请参考我们的 [TDengine GitHub 主页](https://github.com/taosdata/TDengine) 下载源码构建和安装.
-下载其他组件、最新 Beta 版及之前版本的安装包，请点击[这里](https://www.taosdata.com/cn/all-downloads/)。
-</TabItem>
-</Tabs>
-## 启动
-安装后，请使用 `systemctl` 命令来启动 TDengine 的服务进程。
-```bash
-systemctl start taosd
-```
-检查服务是否正常工作：
-```bash
-systemctl status taosd
-```
-如果 TDengine 服务正常工作，那么您可以通过 TDengine 的命令行程序 `taos` 来访问并体验 TDengine。
-:::info
- systemctl 命令需要 _root_ 权限来运行，如果您非 _root_ 用户，请在命令前添加 sudo 。
- 为更好的获得产品反馈，改善产品，TDengine 会采集基本的使用信息，但您可以修改系统配置文件 taos.cfg 里的配置参数 telemetryReporting，将其设为 0，就可将其关闭。
- TDengine 采用 FQDN（一般就是 hostname）作为节点的 ID，为保证正常运行，需要给运行 taosd 的服务器配置好 FQDN，在 TDengine CLI 或应用运行的机器配置好 DNS 服务或 hosts 文件，保证 FQDN 能够解析。
- `systemctl stop taosd` 指令在执行后并不会马上停止 TDengine 服务，而是会等待系统中必要的落盘工作正常完成。在数据量很大的情况下，这可能会消耗较长时间。
-TDengine 支持在使用 [`systemd`](https://en.wikipedia.org/wiki/Systemd) 做进程服务管理的 Linux 系统上安装，用 `which systemctl` 命令来检测系统中是否存在 `systemd` 包:
-```bash
-which systemctl
-```
-如果系统中不支持 `systemd`，也可以用手动运行 `/usr/local/taos/bin/taosd` 方式启动 TDengine 服务。
-:::note
-## TDengine 命令行 (CLI)
-为便于检查 TDengine 的状态，执行数据库 (Database) 的各种即席(Ad Hoc)查询，TDengine 提供一命令行应用程序(以下简称为 TDengine CLI) taos。要进入 TDengine 命令行，您只要在安装有 TDengine 的 Linux 终端执行 `taos` 即可。
-```bash
-taos
-```
-如果连接服务成功，将会打印出欢迎消息和版本信息。如果失败，则会打印错误消息出来（请参考 [FAQ](/train-faq/faq) 来解决终端连接服务端失败的问题）。 TDengine CLI 的提示符号如下：
-```cmd
-taos>
-```
-在 TDengine CLI 中，用户可以通过 SQL 命令来创建/删除数据库、表等，并进行数据库(database)插入查询操作。在终端中运行的 SQL 语句需要以分号结束来运行。示例：
-```sql
-create database demo;
-use demo;
-create table t (ts timestamp, speed int);
-insert into t values ('2019-07-15 00:00:00', 10);
-insert into t values ('2019-07-15 01:00:00', 20);
-select * from t;
-           ts            |    speed    |
-========================================
- 2019-07-15 00:00:00.000 |          10 |
- 2019-07-15 01:00:00.000 |          20 |
-Query OK, 2 row(s) in set (0.003128s)
-```
-除执行 SQL 语句外，系统管理员还可以从 TDengine CLI 进行检查系统运行状态、添加删除用户账号等操作。TDengine CLI 连同应用驱动也可以独立安装在 Linux 或 Windows 机器上运行，更多细节请参考 [这里](../reference/taos-shell/)
-## 使用 taosBenchmark 体验写入速度
-启动 TDengine 的服务，在 Linux 终端执行 `taosBenchmark` （曾命名为 `taosdemo`）：
-```bash
-taosBenchmark
-```
-该命令将在数据库 test 下面自动创建一张超级表 meters，该超级表下有 1 万张表，表名为 "d0" 到 "d9999"，每张表有 1 万条记录，每条记录有 (ts, current, voltage, phase) 四个字段，时间戳从 "2017-07-14 10:40:00 000" 到 "2017-07-14 10:40:09 999"，每张表带有标签 location 和 groupId，groupId 被设置为 1 到 10， location 被设置为 "California.SanFrancisco" 或者 "California.LosAngeles"。
-这条命令很快完成 1 亿条记录的插入。具体时间取决于硬件性能，即使在一台普通的 PC 服务器往往也仅需十几秒。
-taosBenchmark 命令本身带有很多选项，配置表的数目、记录条数等等，您可以设置不同参数进行体验，请执行 `taosBenchmark --help` 详细列出。taosBenchmark 详细使用方法请参照 [如何使用 taosBenchmark 对 TDengine 进行性能测试](https://www.taosdata.com/2021/10/09/3111.html)。
-## 使用 TDengine CLI 体验查询速度
-使用上述 taosBenchmark 插入数据后，可以在 TDengine CLI 输入查询命令，体验查询速度。
-查询超级表下记录总条数：
-```sql
-taos> select count(*) from test.meters;
-```
-查询 1 亿条记录的平均值、最大值、最小值等：
-```sql
-taos> select avg(current), max(voltage), min(phase) from test.meters;
-```
-查询 location="California.SanFrancisco" 的记录总条数：
-```sql
-taos> select count(*) from test.meters where location="California.SanFrancisco";
-```
-查询 groupId=10 的所有记录的平均值、最大值、最小值等：
-```sql
-taos> select avg(current), max(voltage), min(phase) from test.meters where groupId=10;
-```
-对表 d10 按 10s 进行平均值、最大值和最小值聚合统计：
-```sql
-taos> select avg(current), max(voltage), min(phase) from test.d10 interval(10s);
-```
--- a/docs/zh/10-deployment/01-deploy.md
+++ b/docs/zh/10-deployment/01-deploy.md
@@ -55,6 +55,8 @@ fqdn                  h1.taosdata.com
 // 配置本数据节点的端口号，缺省是 6030
 serverPort            6030
+```
 一定要修改的参数是 firstEp 和 fqdn。在每个数据节点，firstEp 需全部配置成一样，但 fqdn 一定要配置成其所在数据节点的值。其他参数可不做任何修改，除非你很清楚为什么要修改。
 加入到集群中的数据节点 dnode，下表中涉及集群相关的参数必须完全相同，否则不能成功加入到集群中。
@@ -68,12 +70,9 @@ serverPort            6030
 ## 启动集群
-### 启动第一个数据节点
 按照《立即开始》里的步骤，启动第一个数据节点，例如 h1.taosdata.com，然后执行 taos，启动 taos shell，从 shell 里执行命令“SHOW DNODES”，如下所示：
 ```
 Welcome to the TDengine shell from Linux, Client Version:3.0.0.0
 Copyright (c) 2022 by TAOS Data, Inc. All rights reserved.
@@ -85,15 +84,12 @@ id | endpoint | vnodes | support_vnodes | status | create_time | note |
 1 | h1.taosdata.com:6030 | 0 | 1024 | ready | 2022-07-16 10:50:42.673 | |
 Query OK, 1 rows affected (0.007984s)
-taos>
-taos>
+```
-````
 上述命令里，可以看到刚启动的数据节点的 End Point 是：h1.taos.com:6030，就是这个新集群的 firstEp。
-### 添加数据节点
+## 添加数据节点
 将后续的数据节点添加到现有集群，具体有以下几步：

--- a/docs/zh/13-operation/01-pkg-install.md
+++ b/docs/zh/13-operation/01-pkg-install.md
@@ -8,9 +8,11 @@ import TabItem from "@theme/TabItem";
 本节将介绍一些关于安装和卸载更深层次的内容，以及升级的注意事项。
-## 安装和卸载
+## 安装
+关于安装，请参考 [使用安装包立即开始](../get-started/package)
-关于安装和卸载，请参考 [安装和卸载](/get-started/package)
 ## 安装目录说明
@@ -40,6 +42,76 @@ lrwxrwxrwx  1 root root   13 Feb 22 09:34 log -> /var/log/taos/
 - /usr/local/taos/driver 目录下的动态库文件，会软链接到 /usr/lib 目录下；
 - /usr/local/taos/include 目录下的头文件，会软链接到到 /usr/include 目录下；
+## 卸载
+<Tabs>
+<TabItem label="apt-get 卸载" value="aptremove">
+内容 TBD
+</TabItem>
+<TabItem label="Deb 卸载" value="debuninst">
+卸载命令如下:
+```
+$ sudo dpkg -r tdengine
+(Reading database ... 137504 files and directories currently installed.)
+Removing tdengine (2.4.0.7) ...
+TDengine is removed successfully!
+```
+</TabItem>
+<TabItem label="RPM 卸载" value="rpmuninst">
+卸载命令如下:
+```
+$ sudo rpm -e tdengine
+TDengine is removed successfully!
+```
+</TabItem>
+<TabItem label="tar.gz 卸载" value="taruninst">
+卸载命令如下:
+```
+$ rmtaos
+Nginx for TDengine is running, stopping it...
+TDengine is removed successfully!
+taosKeeper is removed successfully!
+```
+</TabItem>
+</Tabs>
+:::info
+- TDengine 提供了多种安装包，但最好不要在一个系统上同时使用 tar.gz 安装包和 deb 或 rpm 安装包。否则会相互影响，导致在使用时出现问题。
+- 对于 deb 包安装后，如果安装目录被手工误删了部分，出现卸载、或重新安装不能成功。此时，需要清除 TDengine 包的安装信息，执行如下命令：
+  ```
+  $ sudo rm -f /var/lib/dpkg/info/tdengine*
+  ```
+然后再重新进行安装就可以了。
+- 对于 rpm 包安装后，如果安装目录被手工误删了部分，出现卸载、或重新安装不能成功。此时，需要清除 TDengine 包的安装信息，执行如下命令：
+  ```
+  $ sudo rpm -e --noscripts tdengine
+  ```
+然后再重新进行安装就可以了。
+:::
 ## 卸载和更新文件说明
 卸载安装包的时候，将保留配置文件、数据库文件和日志文件，即 /etc/taos/taos.cfg 、 /var/lib/taos 、 /var/log/taos 。如果用户确认后不需保留，可以手工删除，但一定要慎重，因为删除后，数据将永久丢失，不可以恢复！
@@ -64,4 +136,4 @@ lrwxrwxrwx  1 root root   13 Feb 22 09:34 log -> /var/log/taos/
 :::warning
 TDengine 不保证低版本能够兼容高版本的数据，所以任何时候都不推荐降级
 :::
\ No newline at end of file
--- a/docs/zh/14-reference/03-connector/java.mdx
+++ b/docs/zh/14-reference/03-connector/java.mdx
@@ -93,7 +93,7 @@ Maven 项目中，在 pom.xml 中添加以下依赖：
 可以通过下载 TDengine 的源码，自己编译最新版本的 Java connector
 ```shell
-git clone https://github.com/taosdata/taos-connector-jdbc.git
+git clone https://github.com/taosdata/taos-connector-jdbc.git --branch 2.0
 cd taos-connector-jdbc
 mvn clean install -Dmaven.test.skip=true
 ```

--- a/include/common/taosdef.h
+++ b/include/common/taosdef.h
@@ -34,11 +34,10 @@ typedef enum {
  TSDB_SUPER_TABLE = 1,   // super table
  TSDB_CHILD_TABLE = 2,   // table created from super table
  TSDB_NORMAL_TABLE = 3,  // ordinary table
-  TSDB_STREAM_TABLE = 4,  // table created from stream computing
+  TSDB_TEMP_TABLE = 4,    // temp table created by nest query
-  TSDB_TEMP_TABLE = 5,    // temp table created by nest query
+  TSDB_SYSTEM_TABLE = 5,
-  TSDB_SYSTEM_TABLE = 6,
+  TSDB_TSMA_TABLE = 6,  // time-range-wise sma
-  TSDB_TSMA_TABLE = 7,  // time-range-wise sma
+  TSDB_TABLE_MAX = 7
-  TSDB_TABLE_MAX = 8
 } ETableType;
 typedef enum {

--- a/include/common/tcommon.h
+++ b/include/common/tcommon.h
@@ -103,6 +103,7 @@ typedef struct SDataBlockInfo {
  int16_t     hasVarCol;
  uint32_t    capacity;
  // TODO: optimize and remove following
+  int64_t     version;  // used for stream, and need serialization
  int32_t     childId;  // used for stream, do not serialize
  EStreamType type;     // used for stream, do not serialize
  STimeWindow calWin;   // used for stream, do not serialize

--- a/include/common/tdatablock.h
+++ b/include/common/tdatablock.h
@@ -184,8 +184,8 @@ static FORCE_INLINE void colDataAppendDouble(SColumnInfoData* pColumnInfoData, u
 int32_t getJsonValueLen(const char* data);
 int32_t colDataAppend(SColumnInfoData* pColumnInfoData, uint32_t currentRow, const char* pData, bool isNull);
-int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, uint32_t numOfRow1, uint32_t* capacity,
+int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, int32_t numOfRow1, int32_t* capacity,
-                        const SColumnInfoData* pSource, uint32_t numOfRow2);
+                        const SColumnInfoData* pSource, int32_t numOfRow2);
 int32_t colDataAssign(SColumnInfoData* pColumnInfoData, const SColumnInfoData* pSource, int32_t numOfRows,
                      const SDataBlockInfo* pBlockInfo);
 int32_t blockDataUpdateTsWindow(SSDataBlock* pDataBlock, int32_t tsColumnIndex);

--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@@ -438,7 +438,7 @@ static FORCE_INLINE int32_t tDecodeSSchemaWrapperEx(SDecoder* pDecoder, SSchemaW
  return 0;
 }
-STSchema* tdGetSTSChemaFromSSChema(SSchema** pSchema, int32_t nCols);
+STSchema* tdGetSTSChemaFromSSChema(SSchema* pSchema, int32_t nCols, int32_t sver);
 typedef struct {
  char     name[TSDB_TABLE_FNAME_LEN];
@@ -1359,6 +1359,7 @@ typedef struct {
  int32_t numOfCols;
  int64_t skey;
  int64_t ekey;
+  int64_t version;  // for stream
  char    data[];
 } SRetrieveTableRsp;
@@ -2537,6 +2538,15 @@ static FORCE_INLINE void* tDecodeSMqRebVgReq(const void* buf, SMqRebVgReq* pReq)
  return (void*)buf;
 }
+typedef struct {
+  char    topic[TSDB_TOPIC_FNAME_LEN];
+  int64_t ntbUid;
+  SArray* colIdList;  // SArray<int16_t>
+} SCheckAlterInfo;
+int32_t tEncodeSCheckAlterInfo(SEncoder* pEncoder, const SCheckAlterInfo* pInfo);
+int32_t tDecodeSCheckAlterInfo(SDecoder* pDecoder, SCheckAlterInfo* pInfo);
 typedef struct {
  int32_t vgId;
  int64_t offset;

--- a/include/common/tmsgdef.h
+++ b/include/common/tmsgdef.h
@@ -186,6 +186,7 @@ enum {
  TD_DEF_MSG_TYPE(TDMT_VND_MQ_VG_CHANGE, "vnode-mq-vg-change", SMqRebVgReq, SMqRebVgRsp)
  TD_DEF_MSG_TYPE(TDMT_VND_MQ_VG_DELETE, "vnode-mq-vg-delete", SMqVDeleteReq, SMqVDeleteRsp)
  TD_DEF_MSG_TYPE(TDMT_VND_MQ_COMMIT_OFFSET, "vnode-commit-offset", STqOffset, STqOffset)
+  TD_DEF_MSG_TYPE(TDMT_VND_CHECK_ALTER_INFO, "vnode-alter-check-info", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_VND_CREATE_TOPIC, "vnode-create-topic", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_VND_ALTER_TOPIC, "vnode-alter-topic", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_VND_DROP_TOPIC, "vnode-drop-topic", NULL, NULL)

--- a/include/libs/executor/executor.h
+++ b/include/libs/executor/executor.h
@@ -64,7 +64,8 @@ qTaskInfo_t qCreateStreamExecTaskInfo(void* msg, SReadHandle* readers);
 * @param SReadHandle
 * @return
 */
-qTaskInfo_t qCreateQueueExecTaskInfo(void* msg, SReadHandle* readers, int32_t* numOfCols);
+qTaskInfo_t qCreateQueueExecTaskInfo(void* msg, SReadHandle* readers, int32_t* numOfCols,
+                                     SSchemaWrapper** pSchema);
 /**
 * Set the input data block for the stream scan.
@@ -195,6 +196,8 @@ int32_t qStreamInput(qTaskInfo_t tinfo, void* pItem);
 int32_t qStreamPrepareRecover(qTaskInfo_t tinfo, int64_t startVer, int64_t endVer);
+STimeWindow getAlignQueryTimeWindow(SInterval* pInterval, int32_t precision, int64_t key);
 #ifdef __cplusplus
 }
 #endif

--- a/include/libs/function/functionMgt.h
+++ b/include/libs/function/functionMgt.h
@@ -197,6 +197,7 @@ bool fmIsSystemInfoFunc(int32_t funcId);
 bool fmIsImplicitTsFunc(int32_t funcId);
 bool fmIsClientPseudoColumnFunc(int32_t funcId);
 bool fmIsMultiRowsFunc(int32_t funcId);
+bool fmIsKeepOrderFunc(int32_t funcId);
 int32_t fmGetDistMethod(const SFunctionNode* pFunc, SFunctionNode** pPartialFunc, SFunctionNode** pMergeFunc);

--- a/include/libs/nodes/plannodes.h
+++ b/include/libs/nodes/plannodes.h
@@ -29,9 +29,17 @@ extern "C" {
 typedef enum EDataOrderLevel {
  DATA_ORDER_LEVEL_NONE = 1,
  DATA_ORDER_LEVEL_IN_BLOCK,
-  DATA_ORDER_LEVEL_IN_GROUP
+  DATA_ORDER_LEVEL_IN_GROUP,
+  DATA_ORDER_LEVEL_GLOBAL
 } EDataOrderLevel;
+typedef enum EGroupAction {
+  GROUP_ACTION_NONE = 1,
+  GROUP_ACTION_SET,
+  GROUP_ACTION_KEEP,
+  GROUP_ACTION_CLEAR
+} EGroupAction;
 typedef struct SLogicNode {
  ENodeType          type;
  SNodeList*         pTargets;  // SColumnNode
@@ -44,6 +52,7 @@ typedef struct SLogicNode {
  SNode*             pSlimit;
  EDataOrderLevel    requireDataOrder;  // requirements for input data
  EDataOrderLevel    resultDataOrder;   // properties of the output data
+  EGroupAction       groupAction;
 } SLogicNode;
 typedef enum EScanType {
@@ -102,6 +111,7 @@ typedef struct SAggLogicNode {
  SNodeList* pGroupKeys;
  SNodeList* pAggFuncs;
  bool       hasLastRow;
+  bool       hasTimeLineFunc;
 } SAggLogicNode;
 typedef struct SProjectLogicNode {

--- a/include/libs/stream/tstream.h
+++ b/include/libs/stream/tstream.h
@@ -142,6 +142,7 @@ static FORCE_INLINE void* streamQueueNextItem(SStreamQueue* queue) {
    ASSERT(queue->qItem != NULL);
    return streamQueueCurItem(queue);
  } else {
+    queue->qItem = NULL;
    taosGetQitem(queue->qall, &queue->qItem);
    if (queue->qItem == NULL) {
      taosReadAllQitems(queue->queue, queue->qall);

--- a/include/os/osSignal.h
+++ b/include/os/osSignal.h
@@ -44,7 +44,11 @@ extern "C" {
  #define SIGBREAK 1234
 #endif
+#ifdef WINDOWS
+typedef BOOL (*FSignalHandler)(DWORD fdwCtrlType);
+#else
 typedef void (*FSignalHandler)(int32_t signum, void *sigInfo, void *context);
+#endif
 void taosSetSignal(int32_t signum, FSignalHandler sigfp);
 void taosIgnSignal(int32_t signum);
 void taosDflSignal(int32_t signum);

--- a/include/os/osSystem.h
+++ b/include/os/osSystem.h
@@ -29,9 +29,6 @@ extern "C" {
    #define tcgetattr TCGETATTR_FUNC_TAOS_FORBID
 #endif
-#define TAOS_CONSOLE_PROMPT_HEADER "taos> "
-#define TAOS_CONSOLE_PROMPT_CONTINUE "   -> "
 typedef struct TdCmd *TdCmdPtr;
 TdCmdPtr taosOpenCmd(const char* cmd);

--- a/include/util/taoserror.h
+++ b/include/util/taoserror.h
@@ -332,6 +332,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_VND_INVALID_TABLE_ACTION      TAOS_DEF_ERROR_CODE(0, 0x0519)
 #define TSDB_CODE_VND_COL_ALREADY_EXISTS        TAOS_DEF_ERROR_CODE(0, 0x051a)
 #define TSDB_CODE_VND_TABLE_COL_NOT_EXISTS      TAOS_DEF_ERROR_CODE(0, 0x051b)
+#define TSDB_CODE_VND_COL_SUBSCRIBED            TAOS_DEF_ERROR_CODE(0, 0x051c)
 // tsdb
 #define TSDB_CODE_TDB_INVALID_TABLE_ID          TAOS_DEF_ERROR_CODE(0, 0x0600)

--- a/source/client/test/CMakeLists.txt
+++ b/source/client/test/CMakeLists.txt
@@ -8,7 +8,7 @@ AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SOURCE_LIST)
 ADD_EXECUTABLE(clientTest clientTests.cpp)
 TARGET_LINK_LIBRARIES(
        clientTest
-        PUBLIC os util common transport parser catalog scheduler function gtest taos_static qcom
+        PUBLIC os util common transport parser catalog scheduler function gtest taos_static qcom executor
 )
 ADD_EXECUTABLE(tmqTest tmqTest.cpp)

--- a/source/client/test/clientTests.cpp
+++ b/source/client/test/clientTests.cpp
@@ -27,6 +27,7 @@
 #pragma GCC diagnostic ignored "-Wsign-compare"
 #include "taos.h"
+#include "executor.h"
 namespace {
 void showDB(TAOS* pConn) {
@@ -823,10 +824,21 @@ TEST(testCase, async_api_test) {
 TEST(testCase, update_test) {
+  SInterval interval = {0};
+  interval.offset = 8000;
+  interval.interval = 10000;
+  interval.sliding = 4000;
+  interval.intervalUnit = 's';
+  interval.offsetUnit = 's';
+  interval.slidingUnit = 's';
+// STimeWindow w = getAlignQueryTimeWindow(&interval, 0, 1630000000000);
+ STimeWindow w = getAlignQueryTimeWindow(&interval, 0, 1629999999999);
  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
  ASSERT_NE(pConn, nullptr);
-  TAOS_RES* pRes = taos_query(pConn, "create database if not exists abc1");
+  TAOS_RES* pRes = taos_query(pConn, "select cast(0 as timestamp)-1y");
  if (taos_errno(pRes) != TSDB_CODE_SUCCESS) {
    printf("failed to create database, code:%s", taos_errstr(pRes));
    taos_free_result(pRes);

--- a/source/common/src/tdatablock.c
+++ b/source/common/src/tdatablock.c
@@ -214,8 +214,8 @@ static void doBitmapMerge(SColumnInfoData* pColumnInfoData, int32_t numOfRow1, c
  }
 }
-int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, uint32_t numOfRow1, uint32_t* capacity,
+int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, int32_t numOfRow1, int32_t* capacity,
-                        const SColumnInfoData* pSource, uint32_t numOfRow2) {
+                        const SColumnInfoData* pSource, int32_t numOfRow2) {
  ASSERT(pColumnInfoData != NULL && pSource != NULL && pColumnInfoData->info.type == pSource->info.type);
  if (numOfRow2 == 0) {
    return numOfRow1;
@@ -263,7 +263,8 @@ int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, uint32_t numOfRow1, ui
    pColumnInfoData->varmeta.length = len + oldLen;
  } else {
    if (finalNumOfRows > *capacity || (numOfRow1 == 0 && pColumnInfoData->info.bytes != 0)) {
-      ASSERT(finalNumOfRows * pColumnInfoData->info.bytes);
+      // all data may be null, when the pColumnInfoData->info.type == 0, bytes == 0;
+//      ASSERT(finalNumOfRows * pColumnInfoData->info.bytes);
      char* tmp = taosMemoryRealloc(pColumnInfoData->pData, finalNumOfRows * pColumnInfoData->info.bytes);
      if (tmp == NULL) {
        return TSDB_CODE_VND_OUT_OF_MEMORY;
@@ -1107,6 +1108,11 @@ int32_t blockDataSort_rv(SSDataBlock* pDataBlock, SArray* pOrderInfo, bool nullF
 void blockDataCleanup(SSDataBlock* pDataBlock) {
  pDataBlock->info.rows = 0;
+  pDataBlock->info.groupId = 0;
+  pDataBlock->info.window.ekey = 0;
+  pDataBlock->info.window.skey = 0;
  size_t numOfCols = taosArrayGetSize(pDataBlock->pDataBlock);
  for (int32_t i = 0; i < numOfCols; ++i) {
    SColumnInfoData* p = taosArrayGet(pDataBlock->pDataBlock, i);
@@ -1163,9 +1169,15 @@ static int32_t doEnsureCapacity(SColumnInfoData* pColumn, const SDataBlockInfo*
 void colInfoDataCleanup(SColumnInfoData* pColumn, uint32_t numOfRows) {
  if (IS_VAR_DATA_TYPE(pColumn->info.type)) {
    pColumn->varmeta.length = 0;
+    if (pColumn->varmeta.offset > 0) {
+      memset(pColumn->varmeta.offset, 0, sizeof(int32_t) * numOfRows);
+    }
  } else {
    if (pColumn->nullbitmap != NULL) {
      memset(pColumn->nullbitmap, 0, BitmapLen(numOfRows));
+      if (pColumn->pData != NULL) {
+        memset(pColumn->pData, 0, pColumn->info.bytes * numOfRows);
+      }
    }
  }
 }

--- a/source/common/src/tglobal.c
+++ b/source/common/src/tglobal.c
@@ -226,8 +226,17 @@ static int32_t taosSetTfsCfg(SConfig *pCfg) {
  }
  if (tsDataDir[0] == 0) {
-    uError("datadir not set");
+    if (pItem->str != NULL) {
-    return -1;
+      taosAddDataDir(0, pItem->str, 0, 1);
+      tstrncpy(tsDataDir, pItem->str, PATH_MAX);
+      if (taosMulMkDir(tsDataDir) != 0) {
+        uError("failed to create dataDir:%s since %s", tsDataDir, terrstr());
+        return -1;
+      }
+    } else {
+      uError("datadir not set");
+      return -1;
+    }
  }
  return 0;

--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@@ -4941,14 +4941,14 @@ int tDecodeSVCreateStbReq(SDecoder *pCoder, SVCreateStbReq *pReq) {
  return 0;
 }
-STSchema *tdGetSTSChemaFromSSChema(SSchema **pSchema, int32_t nCols) {
+STSchema *tdGetSTSChemaFromSSChema(SSchema *pSchema, int32_t nCols, int32_t sver) {
  STSchemaBuilder schemaBuilder = {0};
-  if (tdInitTSchemaBuilder(&schemaBuilder, 1) < 0) {
+  if (tdInitTSchemaBuilder(&schemaBuilder, sver) < 0) {
    return NULL;
  }
  for (int i = 0; i < nCols; i++) {
-    SSchema *schema = *pSchema + i;
+    SSchema *schema = pSchema + i;
    if (tdAddColToSchema(&schemaBuilder, schema->type, schema->flags, schema->colId, schema->bytes) < 0) {
      tdDestroyTSchemaBuilder(&schemaBuilder);
      return NULL;
@@ -5625,6 +5625,33 @@ int32_t tDecodeSTqOffset(SDecoder *pDecoder, STqOffset *pOffset) {
  return 0;
 }
+int32_t tEncodeSCheckAlterInfo(SEncoder *pEncoder, const SCheckAlterInfo *pInfo) {
+  if (tEncodeCStr(pEncoder, pInfo->topic) < 0) return -1;
+  if (tEncodeI64(pEncoder, pInfo->ntbUid) < 0) return -1;
+  int32_t sz = taosArrayGetSize(pInfo->colIdList);
+  if (tEncodeI32(pEncoder, sz) < 0) return -1;
+  for (int32_t i = 0; i < sz; i++) {
+    int16_t colId = *(int16_t *)taosArrayGet(pInfo->colIdList, i);
+    if (tEncodeI16(pEncoder, colId) < 0) return -1;
+  }
+  return pEncoder->pos;
+}
+int32_t tDecodeSCheckAlterInfo(SDecoder *pDecoder, SCheckAlterInfo *pInfo) {
+  if (tDecodeCStrTo(pDecoder, pInfo->topic) < 0) return -1;
+  if (tDecodeI64(pDecoder, &pInfo->ntbUid) < 0) return -1;
+  int32_t sz;
+  if (tDecodeI32(pDecoder, &sz) < 0) return -1;
+  pInfo->colIdList = taosArrayInit(sz, sizeof(int16_t));
+  if (pInfo->colIdList == NULL) return -1;
+  for (int32_t i = 0; i < sz; i++) {
+    int16_t colId;
+    if (tDecodeI16(pDecoder, &colId) < 0) return -1;
+    taosArrayPush(pInfo->colIdList, &colId);
+  }
+  return 0;
+}
 int32_t tEncodeDeleteRes(SEncoder *pCoder, const SDeleteRes *pRes) {
  int32_t nUid = taosArrayGetSize(pRes->uidList);

--- a/source/common/src/trow.c
+++ b/source/common/src/trow.c
@@ -568,6 +568,7 @@ int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow) {
  int32_t   maxVarDataLen = 0;
  int32_t   iColVal = 0;
  void     *varBuf = NULL;
+  bool      isAlloc = false;
  ASSERT(nColVal > 1);
@@ -610,8 +611,11 @@ int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow) {
    ++iColVal;
  }
-  *ppRow = (STSRow *)taosMemoryCalloc(
+  if (!(*ppRow)) {
-      1, sizeof(STSRow) + pTSchema->flen + varDataLen + TD_BITMAP_BYTES(pTSchema->numOfCols - 1));
+    *ppRow = (STSRow *)taosMemoryCalloc(
+        1, sizeof(STSRow) + pTSchema->flen + varDataLen + TD_BITMAP_BYTES(pTSchema->numOfCols - 1));
+    isAlloc = true;
+  }
  if (!(*ppRow)) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -621,7 +625,9 @@ int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow) {
  if (maxVarDataLen > 0) {
    varBuf = taosMemoryMalloc(maxVarDataLen);
    if (!varBuf) {
-      taosMemoryFreeClear(*ppRow);
+      if(isAlloc) {
+        taosMemoryFreeClear(*ppRow);
+      }
      terrno = TSDB_CODE_OUT_OF_MEMORY;
      return -1;
    }
@@ -1323,12 +1329,11 @@ void tTSRowGetVal(STSRow *pRow, STSchema *pTSchema, int16_t iCol, SColVal *pColV
  SCellVal  cv;
  SValue    value;
-  ASSERT(iCol > 0);
+  ASSERT((pTColumn->colId == PRIMARYKEY_TIMESTAMP_COL_ID) || (iCol > 0));
  if (TD_IS_TP_ROW(pRow)) {
    tdSTpRowGetVal(pRow, pTColumn->colId, pTColumn->type, pTSchema->flen, pTColumn->offset, iCol - 1, &cv);
  } else if (TD_IS_KV_ROW(pRow)) {
-    ASSERT(iCol > 0);
    tdSKvRowGetVal(pRow, pTColumn->colId, iCol - 1, &cv);
  } else {
    ASSERT(0);

--- a/source/common/src/ttime.c
+++ b/source/common/src/ttime.c
@@ -815,20 +815,17 @@ int64_t taosTimeTruncate(int64_t t, const SInterval* pInterval, int32_t precisio
  if (pInterval->offset > 0) {
    start = taosTimeAdd(start, pInterval->offset, pInterval->offsetUnit, precision);
-    if (start > t) {
-      start = taosTimeAdd(start, -pInterval->interval, pInterval->intervalUnit, precision);
-    } else {
-      // try to move current window to the left-hande-side, due to the offset effect.
-      int64_t end = taosTimeAdd(start, pInterval->interval, pInterval->intervalUnit, precision) - 1;
-      int64_t newEnd = end;
+    // try to move current window to the left-hande-side, due to the offset effect.
-      while(newEnd >= t) {
+    int64_t end = taosTimeAdd(start, pInterval->interval, pInterval->intervalUnit, precision) - 1;
-        end = newEnd;
-        newEnd = taosTimeAdd(newEnd, -pInterval->sliding, pInterval->slidingUnit, precision);
-      }
-      start = taosTimeAdd(end, -pInterval->interval, pInterval->intervalUnit, precision) + 1;
+    int64_t newEnd = end;
+    while (newEnd >= t) {
+      end = newEnd;
+      newEnd = taosTimeAdd(newEnd, -pInterval->sliding, pInterval->slidingUnit, precision);
    }
+    start = taosTimeAdd(end, -pInterval->interval, pInterval->intervalUnit, precision) + 1;
  }
  return start;

--- a/source/common/test/dataformatTest.cpp
+++ b/source/common/test/dataformatTest.cpp
@@ -116,7 +116,7 @@ STSchema *genSTSchema(int16_t nCols) {
  }
  STSchema *pResult = NULL;
-  pResult = tdGetSTSChemaFromSSChema(&pSchema, nCols);
+  pResult = tdGetSTSChemaFromSSChema(pSchema, nCols, 1);
  taosMemoryFree(pSchema);
  return pResult;

--- a/source/dnode/mgmt/mgmt_mnode/src/mmHandle.c
+++ b/source/dnode/mgmt/mgmt_mnode/src/mmHandle.c
@@ -224,6 +224,7 @@ SArray *mmGetMsgHandles() {
  if (dmSetMgmtHandle(pArray, TDMT_VND_DROP_SMA_RSP, mmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_VND_MQ_VG_CHANGE_RSP, mmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_VND_MQ_VG_DELETE_RSP, mmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_CHECK_ALTER_INFO_RSP, mmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_SCH_DROP_TASK, mmPutMsgToFetchQueue, 1) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_DEPLOY_RSP, mmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_DROP_RSP, mmPutMsgToWriteQueue, 0) == NULL) goto _OVER;

--- a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
+++ b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
@@ -352,6 +352,7 @@ SArray *vmGetMsgHandles() {
  if (dmSetMgmtHandle(pArray, TDMT_VND_MQ_VG_CHANGE, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_VND_MQ_VG_DELETE, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_VND_MQ_COMMIT_OFFSET, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
+  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_COMMIT, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER;

--- a/source/dnode/mnode/impl/inc/mndDef.h
+++ b/source/dnode/mnode/impl/inc/mndDef.h
@@ -144,33 +144,33 @@ typedef enum {
 } ECsmUpdateType;
 typedef struct {
-  int32_t        id;
+  int32_t     id;
-  ETrnStage      stage;
+  ETrnStage   stage;
-  ETrnPolicy     policy;
+  ETrnPolicy  policy;
-  ETrnConflct    conflict;
+  ETrnConflct conflict;
-  ETrnExec       exec;
+  ETrnExec    exec;
-  EOperType      oper;
+  EOperType   oper;
-  int32_t        code;
+  int32_t     code;
-  int32_t        failedTimes;
+  int32_t     failedTimes;
-  void*          rpcRsp;
+  void*       rpcRsp;
-  int32_t        rpcRspLen;
+  int32_t     rpcRspLen;
-  int32_t        redoActionPos;
+  int32_t     redoActionPos;
-  SArray*        redoActions;
+  SArray*     redoActions;
-  SArray*        undoActions;
+  SArray*     undoActions;
-  SArray*        commitActions;
+  SArray*     commitActions;
-  int64_t        createdTime;
+  int64_t     createdTime;
-  int64_t        lastExecTime;
+  int64_t     lastExecTime;
-  int32_t        lastAction;
+  int32_t     lastAction;
-  int32_t        lastErrorNo;
+  int32_t     lastErrorNo;
-  tmsg_t         lastMsgType;
+  tmsg_t      lastMsgType;
-  SEpSet         lastEpset;
+  SEpSet      lastEpset;
-  char           dbname1[TSDB_DB_FNAME_LEN];
+  char        dbname1[TSDB_DB_FNAME_LEN];
-  char           dbname2[TSDB_DB_FNAME_LEN];
+  char        dbname2[TSDB_DB_FNAME_LEN];
-  int32_t        startFunc;
+  int32_t     startFunc;
-  int32_t        stopFunc;
+  int32_t     stopFunc;
-  int32_t        paramLen;
+  int32_t     paramLen;
-  void*          param;
+  void*       param;
-  SArray*        pRpcArray;
+  SArray*     pRpcArray;
 } STrans;
 typedef struct {
@@ -477,6 +477,10 @@ typedef struct {
  char*          physicalPlan;
  SSchemaWrapper schema;
  int64_t        stbUid;
+  // forbid condition
+  int64_t ntbUid;
+  SArray* ntbColIds;
+  int64_t ctbStbUid;
 } SMqTopicObj;
 typedef struct {

--- a/source/dnode/mnode/impl/inc/mndTopic.h
+++ b/source/dnode/mnode/impl/inc/mndTopic.h
@@ -37,7 +37,7 @@ const char *mndTopicGetShowName(const char topic[TSDB_TOPIC_FNAME_LEN]);
 int32_t mndSetTopicCommitLogs(SMnode *pMnode, STrans *pTrans, SMqTopicObj *pTopic);
-int32_t mndCheckColAndTagModifiable(SMnode *pMnode, int64_t suid, col_id_t colId);
+int32_t mndCheckColAndTagModifiable(SMnode *pMnode,  const char* stbname, int64_t suid, col_id_t colId);
 #ifdef __cplusplus
 }

--- a/source/dnode/mnode/impl/src/mndStb.c
+++ b/source/dnode/mnode/impl/src/mndStb.c
@@ -1144,7 +1144,7 @@ static int32_t mndDropSuperTableTag(SMnode *pMnode, const SStbObj *pOld, SStbObj
  }
  col_id_t colId = pOld->pTags[tag].colId;
-  if (mndCheckColAndTagModifiable(pMnode, pOld->uid, colId) != 0) {
+  if (mndCheckColAndTagModifiable(pMnode, pOld->name, pOld->uid, colId) != 0) {
    return -1;
  }
@@ -1179,7 +1179,7 @@ static int32_t mndAlterStbTagName(SMnode *pMnode, const SStbObj *pOld, SStbObj *
  }
  col_id_t colId = pOld->pTags[tag].colId;
-  if (mndCheckColAndTagModifiable(pMnode, pOld->uid, colId) != 0) {
+  if (mndCheckColAndTagModifiable(pMnode, pOld->name, pOld->uid, colId) != 0) {
    return -1;
  }
@@ -1213,7 +1213,7 @@ static int32_t mndAlterStbTagBytes(SMnode *pMnode, const SStbObj *pOld, SStbObj
  }
  col_id_t colId = pOld->pTags[tag].colId;
-  if (mndCheckColAndTagModifiable(pMnode, pOld->uid, colId) != 0) {
+  if (mndCheckColAndTagModifiable(pMnode, pOld->name, pOld->uid, colId) != 0) {
    return -1;
  }
@@ -1295,7 +1295,7 @@ static int32_t mndDropSuperTableColumn(SMnode *pMnode, const SStbObj *pOld, SStb
  }
  col_id_t colId = pOld->pColumns[col].colId;
-  if (mndCheckColAndTagModifiable(pMnode, pOld->uid, colId) != 0) {
+  if (mndCheckColAndTagModifiable(pMnode, pOld->name, pOld->uid, colId) != 0) {
    return -1;
  }
@@ -1329,7 +1329,7 @@ static int32_t mndAlterStbColumnBytes(SMnode *pMnode, const SStbObj *pOld, SStbO
  }
  col_id_t colId = pOld->pColumns[col].colId;
-  if (mndCheckColAndTagModifiable(pMnode, pOld->uid, colId) != 0) {
+  if (mndCheckColAndTagModifiable(pMnode, pOld->name, pOld->uid, colId) != 0) {
    return -1;
  }

--- a/source/dnode/mnode/impl/src/mndSubscribe.c
+++ b/source/dnode/mnode/impl/src/mndSubscribe.c
@@ -868,7 +868,10 @@ int32_t mndDropSubByTopic(SMnode *pMnode, STrans *pTrans, const char *topicName)
    }
    // iter all vnode to delete handle
-    ASSERT(taosHashGetSize(pSub->consumerHash) == 0);
+    if (taosHashGetSize(pSub->consumerHash) != 0) {
+      sdbRelease(pSdb, pSub);
+      return -1;
+    }
    int32_t sz = taosArrayGetSize(pSub->unassignedVgs);
    for (int32_t i = 0; i < sz; i++) {
      SMqVgEp       *pVgEp = taosArrayGetP(pSub->unassignedVgs, i);

--- a/source/dnode/mnode/impl/src/mndTopic.c
+++ b/source/dnode/mnode/impl/src/mndTopic.c
@@ -57,6 +57,7 @@ int32_t mndInitTopic(SMnode *pMnode) {
  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_TOPIC, mndProcessCreateTopicReq);
  mndSetMsgHandle(pMnode, TDMT_MND_DROP_TOPIC, mndProcessDropTopicReq);
  mndSetMsgHandle(pMnode, TDMT_VND_DROP_TOPIC_RSP, mndTransProcessRsp);
+  mndSetMsgHandle(pMnode, TDMT_VND_CHECK_ALTER_INFO_RSP, mndTransProcessRsp);
  mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_TOPICS, mndRetrieveTopic);
  mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_TOPICS, mndCancelGetNextTopic);
@@ -71,14 +72,16 @@ const char *mndTopicGetShowName(const char topic[TSDB_TOPIC_FNAME_LEN]) {
  return strchr(topic, '.') + 1;
 }
-int32_t mndCheckColAndTagModifiable(SMnode *pMnode, int64_t suid, col_id_t colId) {
+int32_t mndCheckColAndTagModifiable(SMnode *pMnode, const char* stbname, int64_t suid, col_id_t colId) {
  SSdb *pSdb = pMnode->pSdb;
  void *pIter = NULL;
-  bool  found = false;
  while (1) {
    SMqTopicObj *pTopic = NULL;
    pIter = sdbFetch(pSdb, SDB_TOPIC, pIter, (void **)&pTopic);
    if (pIter == NULL) break;
+    mDebug("topic:%s, check tag and column modifiable, stb:%s suid:%" PRId64 " colId:%d, subType:%d sql:%s", 
+          pTopic->name, stbname, suid, colId, pTopic->subType, pTopic->sql);
    if (pTopic->subType != TOPIC_SUB_TYPE__COLUMN) {
      sdbRelease(pSdb, pTopic);
      continue;
@@ -95,21 +98,25 @@ int32_t mndCheckColAndTagModifiable(SMnode *pMnode, int64_t suid, col_id_t colId
    SNode *pNode = NULL;
    FOREACH(pNode, pNodeList) {
      SColumnNode *pCol = (SColumnNode *)pNode;
-      if (pCol->tableId != suid) goto NEXT;
+      mDebug("topic:%s, check colId:%d tableId:%" PRId64 " ctbStbUid:%" PRId64, pTopic->name, pCol->colId, pCol->tableId, pTopic->ctbStbUid);
-      if (pCol->colId > 0 && pCol->colId == colId) {
-        found = true;
+      if (pCol->tableId != suid && pTopic->ctbStbUid != suid) {
+        mDebug("topic:%s, check colId:%d passed", pTopic->name, pCol->colId);
        goto NEXT;
      }
-      mTrace("topic:%s, colId:%d is used", pTopic->name, pCol->colId);
+      if (pCol->colId > 0 && pCol->colId == colId) {
+        sdbRelease(pSdb, pTopic);
+        nodesDestroyNode(pAst);
+        terrno = TSDB_CODE_MND_FIELD_CONFLICT_WITH_TOPIC;
+        mError("topic:%s, check colId:%d conflicted", pTopic->name, pCol->colId);
+        return -1;
+      }
+      mDebug("topic:%s, check colId:%d passed", pTopic->name, pCol->colId);
    }
  NEXT:
    sdbRelease(pSdb, pTopic);
    nodesDestroyNode(pAst);
-    if (found) {
-      terrno = TSDB_CODE_MND_FIELD_CONFLICT_WITH_TOPIC;
-      return -1;
-    }
  }
  return 0;
@@ -127,8 +134,10 @@ SSdbRaw *mndTopicActionEncode(SMqTopicObj *pTopic) {
  if (pTopic->schema.nCols) {
    schemaLen = taosEncodeSSchemaWrapper(NULL, &pTopic->schema);
  }
-  int32_t size =
+  int32_t ntbColLen = taosArrayGetSize(pTopic->ntbColIds) * sizeof(int16_t);
-      sizeof(SMqTopicObj) + physicalPlanLen + pTopic->sqlLen + pTopic->astLen + schemaLen + MND_TOPIC_RESERVE_SIZE;
+  int32_t size = sizeof(SMqTopicObj) + physicalPlanLen + pTopic->sqlLen + pTopic->astLen + schemaLen + ntbColLen +
+                 MND_TOPIC_RESERVE_SIZE;
  SSdbRaw *pRaw = sdbAllocRaw(SDB_TOPIC, MND_TOPIC_VER_NUMBER, size);
  if (pRaw == NULL) goto TOPIC_ENCODE_OVER;
@@ -164,6 +173,16 @@ SSdbRaw *mndTopicActionEncode(SMqTopicObj *pTopic) {
    taosEncodeSSchemaWrapper(&aswBuf, &pTopic->schema);
    SDB_SET_BINARY(pRaw, dataPos, swBuf, schemaLen, TOPIC_ENCODE_OVER);
  }
+  SDB_SET_INT64(pRaw, dataPos, pTopic->ntbUid, TOPIC_ENCODE_OVER);
+  if (pTopic->ntbUid != 0) {
+    int32_t sz = taosArrayGetSize(pTopic->ntbColIds);
+    SDB_SET_INT32(pRaw, dataPos, sz, TOPIC_ENCODE_OVER);
+    for (int32_t i = 0; i < sz; i++) {
+      int16_t colId = *(int16_t *)taosArrayGet(pTopic->ntbColIds, i);
+      SDB_SET_INT16(pRaw, dataPos, colId, TOPIC_ENCODE_OVER);
+    }
+  }
+  SDB_SET_INT64(pRaw, dataPos, pTopic->ctbStbUid, TOPIC_ENCODE_OVER);
  SDB_SET_RESERVE(pRaw, dataPos, MND_TOPIC_RESERVE_SIZE, TOPIC_ENCODE_OVER);
  SDB_SET_DATALEN(pRaw, dataPos, TOPIC_ENCODE_OVER);
@@ -259,6 +278,20 @@ SSdbRow *mndTopicActionDecode(SSdbRaw *pRaw) {
    pTopic->schema.version = 0;
    pTopic->schema.pSchema = NULL;
  }
+  SDB_GET_INT64(pRaw, dataPos, &pTopic->ntbUid, TOPIC_DECODE_OVER);
+  if (pTopic->ntbUid != 0) {
+    int32_t ntbColNum;
+    SDB_GET_INT32(pRaw, dataPos, &ntbColNum, TOPIC_DECODE_OVER);
+    pTopic->ntbColIds = taosArrayInit(ntbColNum, sizeof(int16_t));
+    if (pTopic->ntbColIds == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      goto TOPIC_DECODE_OVER;
+    }
+    int16_t colId;
+    SDB_GET_INT16(pRaw, dataPos, &colId, TOPIC_DECODE_OVER);
+    taosArrayPush(pTopic->ntbColIds, &colId);
+  }
+  SDB_GET_INT64(pRaw, dataPos, &pTopic->ctbStbUid, TOPIC_DECODE_OVER);
  SDB_GET_RESERVE(pRaw, dataPos, MND_TOPIC_RESERVE_SIZE, TOPIC_DECODE_OVER);
@@ -346,6 +379,26 @@ static int32_t mndCheckCreateTopicReq(SCMCreateTopicReq *pCreate) {
  return 0;
 }
+static int32_t extractTopicTbInfo(SNode *pAst, SMqTopicObj *pTopic) {
+  SNodeList *pNodeList = NULL;
+  nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList);
+  int64_t suid = ((SRealTableNode *)((SSelectStmt *)pAst)->pFromTable)->pMeta->suid;
+  int8_t  tableType = ((SRealTableNode *)((SSelectStmt *)pAst)->pFromTable)->pMeta->tableType;
+  if (tableType == TSDB_CHILD_TABLE) {
+    pTopic->ctbStbUid = suid;
+  } else if (tableType == TSDB_NORMAL_TABLE) {
+    SNode *pNode = NULL;
+    FOREACH(pNode, pNodeList) {
+      SColumnNode *pCol = (SColumnNode *)pNode;
+      if (pCol->tableType == TSDB_NORMAL_TABLE) {
+        pTopic->ntbUid = pCol->tableId;
+        taosArrayPush(pTopic->ntbColIds, &pCol->colId);
+      }
+    }
+  }
+  return 0;
+}
 static int32_t mndCreateTopic(SMnode *pMnode, SRpcMsg *pReq, SCMCreateTopicReq *pCreate, SDbObj *pDb) {
  mDebug("topic:%s to create", pCreate->name);
  SMqTopicObj topicObj = {0};
@@ -386,6 +439,19 @@ static int32_t mndCreateTopic(SMnode *pMnode, SRpcMsg *pReq, SCMCreateTopicReq *
      return -1;
    }
+    int64_t ntbUid;
+    topicObj.ntbColIds = taosArrayInit(0, sizeof(int16_t));
+    if (topicObj.ntbColIds == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      return -1;
+    }
+    extractTopicTbInfo(pAst, &topicObj);
+    if (topicObj.ntbUid == 0) {
+      taosArrayDestroy(topicObj.ntbColIds);
+      topicObj.ntbColIds = NULL;
+    }
    if (qExtractResultSchema(pAst, &topicObj.schema.nCols, &topicObj.schema.pSchema) != 0) {
      mError("topic:%s, failed to create since %s", pCreate->name, terrstr());
      taosMemoryFree(topicObj.ast);
@@ -433,6 +499,60 @@ static int32_t mndCreateTopic(SMnode *pMnode, SRpcMsg *pReq, SCMCreateTopicReq *
  }
  sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
+  if (topicObj.ntbUid != 0) {
+    SCheckAlterInfo info;
+    memcpy(info.topic, topicObj.name, TSDB_TOPIC_FNAME_LEN);
+    info.ntbUid = topicObj.ntbUid;
+    info.colIdList = topicObj.ntbColIds;
+    // broadcast forbid alter info
+    void   *pIter = NULL;
+    SSdb   *pSdb = pMnode->pSdb;
+    SVgObj *pVgroup = NULL;
+    while (1) {
+      // iterate vg
+      pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);
+      if (pIter == NULL) break;
+      if (!mndVgroupInDb(pVgroup, topicObj.dbUid)) {
+        sdbRelease(pSdb, pVgroup);
+        continue;
+      }
+      // encoder check alter info
+      int32_t len;
+      int32_t code;
+      tEncodeSize(tEncodeSCheckAlterInfo, &info, len, code);
+      if (code < 0) {
+        sdbRelease(pSdb, pVgroup);
+        mndTransDrop(pTrans);
+        ASSERT(0);
+        return -1;
+      }
+      void    *buf = taosMemoryCalloc(1, sizeof(SMsgHead) + len);
+      void    *abuf = POINTER_SHIFT(buf, sizeof(SMsgHead));
+      SEncoder encoder;
+      tEncoderInit(&encoder, abuf, len);
+      if (tEncodeSCheckAlterInfo(&encoder, &info) < 0) {
+        sdbRelease(pSdb, pVgroup);
+        mndTransDrop(pTrans);
+        return -1;
+      }
+      tEncoderClear(&encoder);
+      ((SMsgHead *)buf)->vgId = htonl(pVgroup->vgId);
+      // add redo action
+      STransAction action = {0};
+      action.epSet = mndGetVgroupEpset(pMnode, pVgroup);
+      action.pCont = buf;
+      action.contLen = sizeof(SMsgHead) + len;
+      action.msgType = TDMT_VND_CHECK_ALTER_INFO;
+      if (mndTransAppendRedoAction(pTrans, &action) != 0) {
+        taosMemoryFree(buf);
+        sdbRelease(pSdb, pVgroup);
+        mndTransDrop(pTrans);
+        return -1;
+      }
+    }
+  }
  if (mndTransPrepare(pMnode, pTrans) != 0) {
    mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
    taosMemoryFreeClear(topicObj.physicalPlan);
@@ -442,7 +562,7 @@ static int32_t mndCreateTopic(SMnode *pMnode, SRpcMsg *pReq, SCMCreateTopicReq *
  taosMemoryFreeClear(topicObj.physicalPlan);
  mndTransDrop(pTrans);
-  return 0;
+  return TSDB_CODE_ACTION_IN_PROGRESS;
 }
 static int32_t mndProcessCreateTopicReq(SRpcMsg *pReq) {
@@ -583,6 +703,7 @@ static int32_t mndProcessDropTopicReq(SRpcMsg *pReq) {
  mndTransSetDbName(pTrans, pTopic->db, NULL);
  if (pTrans == NULL) {
    mError("topic:%s, failed to drop since %s", pTopic->name, terrstr());
+    mndReleaseTopic(pMnode, pTopic);
    return -1;
  }
@@ -590,11 +711,17 @@ static int32_t mndProcessDropTopicReq(SRpcMsg *pReq) {
  if (mndDropOffsetByTopic(pMnode, pTrans, dropReq.name) < 0) {
    ASSERT(0);
+    mndTransDrop(pTrans);
+    mndReleaseTopic(pMnode, pTopic);
    return -1;
  }
+  // TODO check if rebalancing
  if (mndDropSubByTopic(pMnode, pTrans, dropReq.name) < 0) {
-    ASSERT(0);
+    /*ASSERT(0);*/
+    mError("topic:%s, failed to drop since %s", pTopic->name, terrstr());
+    mndTransDrop(pTrans);
+    mndReleaseTopic(pMnode, pTopic);
    return -1;
  }

--- a/source/dnode/vnode/inc/vnode.h
+++ b/source/dnode/vnode/inc/vnode.h
@@ -89,6 +89,7 @@ void        metaReaderClear(SMetaReader *pReader);
 int32_t     metaGetTableEntryByUid(SMetaReader *pReader, tb_uid_t uid);
 int32_t     metaReadNext(SMetaReader *pReader);
 const void *metaGetTableTagVal(SMetaEntry *pEntry, int16_t type, STagVal *tagVal);
+int         metaGetTableNameByUid(void* meta, uint64_t uid, char* tbName);
 typedef struct SMetaFltParam {
  tb_uid_t suid;

--- a/source/dnode/vnode/src/inc/sma.h
+++ b/source/dnode/vnode/src/inc/sma.h
@@ -67,8 +67,6 @@ struct STSmaStat {
 struct SRSmaStat {
  SSma     *pSma;
  int64_t   commitAppliedVer;  // vnode applied version for async commit
-  int64_t   commitSubmitVer;   // rsma submit version for async commit
-  int64_t   submitVer;         // latest submit version
  int64_t   refId;             // shared by fetch tasks
  int8_t    triggerStat;       // shared by fetch tasks
  int8_t    commitStat;        // 0 not in committing, 1 in committing
@@ -91,7 +89,6 @@ struct SSmaStat {
 #define RSMA_TRIGGER_STAT(r)  (&(r)->triggerStat)
 #define RSMA_COMMIT_STAT(r)   (&(r)->commitStat)
 #define RSMA_REF_ID(r)        ((r)->refId)
-#define RSMA_SUBMIT_VER(r)    ((r)->submitVer)
 struct SRSmaInfoItem {
  void   *taskInfo;  // qTaskInfo_t
@@ -223,13 +220,6 @@ struct STFInfo {
  uint32_t ftype;
  uint32_t fver;
  int64_t  fsize;
-  // specific fields
-  union {
-    struct {
-      int64_t submitVer;
-    } qTaskInfo;
-  };
 };
 enum {

--- a/source/dnode/vnode/src/inc/tq.h
+++ b/source/dnode/vnode/src/inc/tq.h
@@ -68,7 +68,7 @@ typedef struct {
 typedef struct {
  char*       qmsg;
-  qTaskInfo_t task[5];
+  qTaskInfo_t task;
 } STqExecCol;
 typedef struct {
@@ -82,13 +82,14 @@ typedef struct {
 typedef struct {
  int8_t subType;
-  STqReader* pExecReader[5];
+  STqReader* pExecReader;
  union {
    STqExecCol execCol;
    STqExecTb  execTb;
    STqExecDb  execDb;
  };
-  int32_t numOfCols;  // number of out pout column, temporarily used
+  int32_t         numOfCols;       // number of out pout column, temporarily used
+  SSchemaWrapper* pSchemaWrapper;  // columns that are involved in query
 } STqExecHandle;
 typedef struct {
@@ -109,9 +110,6 @@ typedef struct {
  // exec
  STqExecHandle execHandle;
-  // prevent drop
-  int64_t ntbUid;
-  SArray* colIdList;  // SArray<int32_t>
 } STqHandle;
 struct STQ {
@@ -119,9 +117,9 @@ struct STQ {
  SHashObj*       pushMgr;       // consumerId -> STqHandle*
  SHashObj*       handles;       // subKey -> STqHandle
  SHashObj*       pStreamTasks;  // taksId -> SStreamTask
+  SHashObj*       pAlterInfo;    // topic -> SAlterCheckInfo
  STqOffsetStore* pOffsetStore;
  SVnode*         pVnode;
-  SWal*           pWal;
  TDB*            pMetaStore;
  TTB*            pExecStore;
 };
@@ -138,8 +136,7 @@ int64_t tqScan(STQ* pTq, const STqHandle* pHandle, SMqDataRsp* pRsp, STqOffsetVa
 int64_t tqFetchLog(STQ* pTq, STqHandle* pHandle, int64_t* fetchOffset, SWalCkHead** pHeadWithCkSum);
 // tqExec
-int32_t tqLogScanExec(STQ* pTq, STqExecHandle* pExec, SSubmitReq* pReq, SMqDataRsp* pRsp, int32_t workerId);
+int32_t tqLogScanExec(STQ* pTq, STqExecHandle* pExec, SSubmitReq* pReq, SMqDataRsp* pRsp);
-int32_t tqScanSnapshot(STQ* pTq, const STqExecHandle* pExec, SMqDataRsp* pRsp, STqOffsetVal offset, int32_t workerId);
 int32_t tqSendDataRsp(STQ* pTq, const SRpcMsg* pMsg, const SMqPollReq* pReq, const SMqDataRsp* pRsp);
 // tqMeta

--- a/source/dnode/vnode/src/inc/tsdb.h
+++ b/source/dnode/vnode/src/inc/tsdb.h
@@ -40,12 +40,9 @@ typedef struct SDelIdx       SDelIdx;
 typedef struct STbData       STbData;
 typedef struct SMemTable     SMemTable;
 typedef struct STbDataIter   STbDataIter;
-typedef struct STable        STable;
 typedef struct SMapData      SMapData;
 typedef struct SBlockIdx     SBlockIdx;
 typedef struct SBlock        SBlock;
-typedef struct SBlockStatis  SBlockStatis;
-typedef struct SAggrBlkCol   SAggrBlkCol;
 typedef struct SColData      SColData;
 typedef struct SBlockDataHdr SBlockDataHdr;
 typedef struct SBlockData    SBlockData;
@@ -62,8 +59,7 @@ typedef struct SDelFReader   SDelFReader;
 typedef struct SRowIter      SRowIter;
 typedef struct STsdbFS       STsdbFS;
 typedef struct SRowMerger    SRowMerger;
-typedef struct STsdbFSState  STsdbFSState;
+typedef struct STsdbReadSnap STsdbReadSnap;
-typedef struct STsdbSnapHdr  STsdbSnapHdr;
 #define TSDB_MAX_SUBBLOCKS 8
 #define TSDB_FHDR_SIZE     512
@@ -176,8 +172,6 @@ void    tsdbMemTableDestroy(SMemTable *pMemTable);
 void    tsdbGetTbDataFromMemTable(SMemTable *pMemTable, tb_uid_t suid, tb_uid_t uid, STbData **ppTbData);
 void    tsdbRefMemTable(SMemTable *pMemTable);
 void    tsdbUnrefMemTable(SMemTable *pMemTable);
-int32_t tsdbTakeMemSnapshot(STsdb *pTsdb, SMemTable **ppMem, SMemTable **ppIMem);
-void    tsdbUntakeMemSnapshot(STsdb *pTsdb, SMemTable *pMem, SMemTable *pIMem);
 // STbDataIter
 int32_t  tsdbTbDataIterCreate(STbData *pTbData, TSDBKEY *pFrom, int8_t backward, STbDataIter **ppIter);
 void    *tsdbTbDataIterDestroy(STbDataIter *pIter);
@@ -188,30 +182,39 @@ bool     tsdbTbDataIterNext(STbDataIter *pIter);
 int32_t tsdbGetNRowsInTbData(STbData *pTbData);
 // tsdbFile.c ==============================================================================================
 typedef enum { TSDB_HEAD_FILE = 0, TSDB_DATA_FILE, TSDB_LAST_FILE, TSDB_SMA_FILE } EDataFileT;
-void    tsdbDataFileName(STsdb *pTsdb, SDFileSet *pDFileSet, EDataFileT ftype, char fname[]);
-bool    tsdbFileIsSame(SDFileSet *pDFileSet1, SDFileSet *pDFileSet2, EDataFileT ftype);
 bool    tsdbDelFileIsSame(SDelFile *pDelFile1, SDelFile *pDelFile2);
-int32_t tsdbUpdateDFileHdr(TdFilePtr pFD, SDFileSet *pSet, EDataFileT ftype);
 int32_t tsdbDFileRollback(STsdb *pTsdb, SDFileSet *pSet, EDataFileT ftype);
-int32_t tPutDataFileHdr(uint8_t *p, SDFileSet *pSet, EDataFileT ftype);
+int32_t tPutHeadFile(uint8_t *p, SHeadFile *pHeadFile);
+int32_t tPutDataFile(uint8_t *p, SDataFile *pDataFile);
+int32_t tPutLastFile(uint8_t *p, SLastFile *pLastFile);
+int32_t tPutSmaFile(uint8_t *p, SSmaFile *pSmaFile);
 int32_t tPutDelFile(uint8_t *p, SDelFile *pDelFile);
 int32_t tGetDelFile(uint8_t *p, SDelFile *pDelFile);
 int32_t tPutDFileSet(uint8_t *p, SDFileSet *pSet);
 int32_t tGetDFileSet(uint8_t *p, SDFileSet *pSet);
+void tsdbHeadFileName(STsdb *pTsdb, SDiskID did, int32_t fid, SHeadFile *pHeadF, char fname[]);
+void tsdbDataFileName(STsdb *pTsdb, SDiskID did, int32_t fid, SDataFile *pDataF, char fname[]);
+void tsdbLastFileName(STsdb *pTsdb, SDiskID did, int32_t fid, SLastFile *pLastF, char fname[]);
+void tsdbSmaFileName(STsdb *pTsdb, SDiskID did, int32_t fid, SSmaFile *pSmaF, char fname[]);
 // SDelFile
 void tsdbDelFileName(STsdb *pTsdb, SDelFile *pFile, char fname[]);
 // tsdbFS.c ==============================================================================================
-int32_t tsdbFSOpen(STsdb *pTsdb, STsdbFS **ppFS);
+int32_t tsdbFSOpen(STsdb *pTsdb);
-int32_t tsdbFSClose(STsdbFS *pFS);
+int32_t tsdbFSClose(STsdb *pTsdb);
-int32_t tsdbFSBegin(STsdbFS *pFS);
+int32_t tsdbFSCopy(STsdb *pTsdb, STsdbFS *pFS);
-int32_t tsdbFSCommit(STsdbFS *pFS);
+void    tsdbFSDestroy(STsdbFS *pFS);
+int32_t tDFileSetCmprFn(const void *p1, const void *p2);
+int32_t tsdbFSCommit1(STsdb *pTsdb, STsdbFS *pFS);
+int32_t tsdbFSCommit2(STsdb *pTsdb, STsdbFS *pFS);
+int32_t tsdbFSRef(STsdb *pTsdb, STsdbFS *pFS);
+void    tsdbFSUnref(STsdb *pTsdb, STsdbFS *pFS);
 int32_t tsdbFSRollback(STsdbFS *pFS);
-int32_t    tsdbFSStateUpsertDelFile(STsdbFSState *pState, SDelFile *pDelFile);
+int32_t tsdbFSUpsertFSet(STsdbFS *pFS, SDFileSet *pSet);
-int32_t    tsdbFSStateUpsertDFileSet(STsdbFSState *pState, SDFileSet *pSet);
+int32_t tsdbFSUpsertDelFile(STsdbFS *pFS, SDelFile *pDelFile);
-void       tsdbFSStateDeleteDFileSet(STsdbFSState *pState, int32_t fid);
-SDelFile  *tsdbFSStateGetDelFile(STsdbFSState *pState);
-SDFileSet *tsdbFSStateGetDFileSet(STsdbFSState *pState, int32_t fid, int32_t flag);
 // tsdbReaderWriter.c ==============================================================================================
 // SDataFWriter
 int32_t tsdbDataFWriterOpen(SDataFWriter **ppWriter, STsdb *pTsdb, SDFileSet *pSet);
@@ -222,8 +225,7 @@ int32_t tsdbWriteBlock(SDataFWriter *pWriter, SMapData *pMapData, uint8_t **ppBu
 int32_t tsdbWriteBlockData(SDataFWriter *pWriter, SBlockData *pBlockData, uint8_t **ppBuf1, uint8_t **ppBuf2,
                           SBlockIdx *pBlockIdx, SBlock *pBlock, int8_t cmprAlg);
-SDFileSet *tsdbDataFWriterGetWSet(SDataFWriter *pWriter);
+int32_t tsdbDFileSetCopy(STsdb *pTsdb, SDFileSet *pSetFrom, SDFileSet *pSetTo);
-int32_t    tsdbDFileSetCopy(STsdb *pTsdb, SDFileSet *pSetFrom, SDFileSet *pSetTo);
 // SDataFReader
 int32_t tsdbDataFReaderOpen(SDataFReader **ppReader, STsdb *pTsdb, SDFileSet *pSet);
 int32_t tsdbDataFReaderClose(SDataFReader **ppReader);
@@ -245,6 +247,9 @@ int32_t tsdbDelFReaderOpen(SDelFReader **ppReader, SDelFile *pFile, STsdb *pTsdb
 int32_t tsdbDelFReaderClose(SDelFReader **ppReader);
 int32_t tsdbReadDelData(SDelFReader *pReader, SDelIdx *pDelIdx, SArray *aDelData, uint8_t **ppBuf);
 int32_t tsdbReadDelIdx(SDelFReader *pReader, SArray *aDelIdx, uint8_t **ppBuf);
+// tsdbRead.c ==============================================================================================
+int32_t tsdbTakeReadSnap(STsdb *pTsdb, STsdbReadSnap **ppSnap);
+void    tsdbUntakeReadSnap(STsdb *pTsdb, STsdbReadSnap *pSnap);
 #define TSDB_CACHE_NO(c)       ((c).cacheLast == 0)
 #define TSDB_CACHE_LAST_ROW(c) (((c).cacheLast & 1) > 0)
@@ -276,6 +281,11 @@ typedef struct {
  TSKEY minKey;
 } SRtn;
+struct STsdbFS {
+  SDelFile *pDelFile;
+  SArray   *aDFileSet;  // SArray<SDFileSet>
+};
 struct STsdb {
  char          *path;
  SVnode        *pVnode;
@@ -283,7 +293,7 @@ struct STsdb {
  TdThreadRwlock rwLock;
  SMemTable     *mem;
  SMemTable     *imem;
-  STsdbFS       *pFS;
+  STsdbFS        fs;
  SLRUCache     *lruCache;
 };
@@ -402,16 +412,6 @@ struct SBlock {
  SSubBlock aSubBlock[TSDB_MAX_SUBBLOCKS];
 };
-struct SAggrBlkCol {
-  int16_t colId;
-  int16_t maxIndex;
-  int16_t minIndex;
-  int16_t numOfNull;
-  int64_t sum;
-  int64_t max;
-  int64_t min;
-};
 struct SColData {
  int16_t  cid;
  int8_t   type;
@@ -465,12 +465,6 @@ struct SDelIdx {
  int64_t  size;
 };
-struct SDelFile {
-  int64_t commitID;
-  int64_t size;
-  int64_t offset;
-};
 #pragma pack(push, 1)
 struct SBlockDataHdr {
  uint32_t delimiter;
@@ -479,34 +473,50 @@ struct SBlockDataHdr {
 };
 #pragma pack(pop)
+struct SDelFile {
+  volatile int32_t nRef;
+  int64_t commitID;
+  int64_t size;
+  int64_t offset;
+};
 struct SHeadFile {
+  volatile int32_t nRef;
  int64_t commitID;
  int64_t size;
  int64_t offset;
 };
 struct SDataFile {
+  volatile int32_t nRef;
  int64_t commitID;
  int64_t size;
 };
 struct SLastFile {
+  volatile int32_t nRef;
  int64_t commitID;
  int64_t size;
 };
 struct SSmaFile {
+  volatile int32_t nRef;
  int64_t commitID;
  int64_t size;
 };
 struct SDFileSet {
-  SDiskID   diskId;
+  SDiskID    diskId;
-  int32_t   fid;
+  int32_t    fid;
-  SHeadFile fHead;
+  SHeadFile *pHeadF;
-  SDataFile fData;
+  SDataFile *pDataF;
-  SLastFile fLast;
+  SLastFile *pLastF;
-  SSmaFile  fSma;
+  SSmaFile  *pSmaF;
 };
 struct SRowIter {
@@ -521,26 +531,33 @@ struct SRowMerger {
  SArray   *pArray;  // SArray<SColVal>
 };
-struct STsdbFSState {
-  SDelFile *pDelFile;
-  SArray   *aDFileSet;  // SArray<aDFileSet>
-  SDelFile  delFile;
-};
-struct STsdbFS {
-  STsdb         *pTsdb;
-  TdThreadRwlock lock;
-  int8_t         inTxn;
-  STsdbFSState  *cState;
-  STsdbFSState  *nState;
-};
 struct SDelFWriter {
  STsdb    *pTsdb;
  SDelFile  fDel;
  TdFilePtr pWriteH;
 };
+struct SDataFWriter {
+  STsdb    *pTsdb;
+  SDFileSet wSet;
+  TdFilePtr pHeadFD;
+  TdFilePtr pDataFD;
+  TdFilePtr pLastFD;
+  TdFilePtr pSmaFD;
+  SHeadFile fHead;
+  SDataFile fData;
+  SLastFile fLast;
+  SSmaFile  fSma;
+};
+struct STsdbReadSnap {
+  SMemTable *pMem;
+  SMemTable *pIMem;
+  STsdbFS    fs;
+};
 #ifdef __cplusplus
 }
 #endif

--- a/source/dnode/vnode/src/inc/vnodeInt.h
+++ b/source/dnode/vnode/src/inc/vnodeInt.h
@@ -137,16 +137,17 @@ STsdbReader tsdbQueryCacheLastT(STsdb* tsdb, SQueryTableDataCond* pCond, STableL
 // tq
 int     tqInit();
 void    tqCleanUp();
-STQ*    tqOpen(const char* path, SVnode* pVnode, SWal* pWal);
+STQ*    tqOpen(const char* path, SVnode* pVnode);
 void    tqClose(STQ*);
 int     tqPushMsg(STQ*, void* msg, int32_t msgLen, tmsg_t msgType, int64_t ver);
 int     tqCommit(STQ*);
 int32_t tqUpdateTbUidList(STQ* pTq, const SArray* tbUidList, bool isAdd);
-int32_t tqCheckColModifiable(STQ* pTq, int32_t colId);
+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 tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId);
+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);
 int32_t tqProcessStreamTrigger(STQ* pTq, SSubmitReq* data);
@@ -177,7 +178,6 @@ int32_t smaAsyncPostCommit(SSma* pSma);
 int32_t tdProcessTSmaCreate(SSma* pSma, int64_t version, const char* msg);
 int32_t tdProcessTSmaInsert(SSma* pSma, int64_t indexUid, const char* msg);
-int64_t tdRSmaGetMaxSubmitVer(SSma* pSma, int8_t level);
 int32_t tdProcessRSmaCreate(SSma* pSma, SVCreateStbReq* pReq);
 int32_t tdProcessRSmaSubmit(SSma* pSma, void* pMsg, int32_t inputType);

--- a/source/dnode/vnode/src/meta/metaQuery.c
+++ b/source/dnode/vnode/src/meta/metaQuery.c
@@ -98,6 +98,17 @@ tb_uid_t metaGetTableEntryUidByName(SMeta *pMeta, const char *name) {
  return uid;
 }
+int metaGetTableNameByUid(void* meta, uint64_t uid, char* tbName) {
+  SMetaReader mr = {0};
+  metaReaderInit(&mr, (SMeta*)meta, 0);
+  metaGetTableEntryByUid(&mr, uid);
+  STR_TO_VARSTR(tbName, mr.me.name);
+  metaReaderClear(&mr);
+  return 0;
+}
 int metaReadNext(SMetaReader *pReader) {
  SMeta *pMeta = pReader->pMeta;

--- a/source/dnode/vnode/src/meta/metaTable.c
+++ b/source/dnode/vnode/src/meta/metaTable.c
@@ -640,6 +640,10 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl
        terrno = TSDB_CODE_VND_INVALID_TABLE_ACTION;
        goto _err;
      }
+      if (tqCheckColModifiable(pMeta->pVnode->pTq, uid, pColumn->colId) != 0) {
+        terrno = TSDB_CODE_VND_COL_SUBSCRIBED;
+        goto _err;
+      }
      pSchema->version++;
      tlen = (pSchema->nCols - iCol - 1) * sizeof(SSchema);
      if (tlen) {
@@ -656,6 +660,10 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl
        terrno = TSDB_CODE_VND_INVALID_TABLE_ACTION;
        goto _err;
      }
+      if (tqCheckColModifiable(pMeta->pVnode->pTq, uid, pColumn->colId) != 0) {
+        terrno = TSDB_CODE_VND_COL_SUBSCRIBED;
+        goto _err;
+      }
      pSchema->version++;
      pColumn->bytes = pAlterTbReq->colModBytes;
      break;
@@ -664,6 +672,10 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl
        terrno = TSDB_CODE_VND_TABLE_COL_NOT_EXISTS;
        goto _err;
      }
+      if (tqCheckColModifiable(pMeta->pVnode->pTq, uid, pColumn->colId) != 0) {
+        terrno = TSDB_CODE_VND_COL_SUBSCRIBED;
+        goto _err;
+      }
      pSchema->version++;
      strcpy(pColumn->name, pAlterTbReq->colNewName);
      break;

--- a/source/dnode/vnode/src/sma/smaCommit.c
+++ b/source/dnode/vnode/src/sma/smaCommit.c
@@ -146,7 +146,6 @@ static int32_t tdProcessRSmaSyncPreCommitImpl(SSma *pSma) {
  // step 3: perform persist task for qTaskInfo
  pRSmaStat->commitAppliedVer = pSma->pVnode->state.applied;
-  pRSmaStat->commitSubmitVer = pRSmaStat->submitVer;
  tdRSmaPersistExecImpl(pRSmaStat, RSMA_INFO_HASH(pRSmaStat));
  smaDebug("vgId:%d, rsma pre commit success", SMA_VID(pSma));
@@ -317,7 +316,6 @@ static int32_t tdProcessRSmaAsyncPreCommitImpl(SSma *pSma) {
  // step 4: others
  pRSmaStat->commitAppliedVer = pSma->pVnode->state.applied;
-  pRSmaStat->commitSubmitVer = pRSmaStat->submitVer;
  return TSDB_CODE_SUCCESS;
 }

--- a/source/dnode/vnode/src/sma/smaRollup.c
+++ b/source/dnode/vnode/src/sma/smaRollup.c
@@ -560,17 +560,6 @@ static void tdDestroySDataBlockArray(SArray *pArray) {
  taosArrayDestroy(pArray);
 }
-int64_t tdRSmaGetMaxSubmitVer(SSma *pSma, int8_t level) {
-  if (level == TSDB_RETENTION_L0) {
-    return pSma->pVnode->state.applied;
-  }
-  SSmaEnv   *pRSmaEnv = SMA_RSMA_ENV(pSma);
-  SRSmaStat *pRSmaStat = (SRSmaStat *)(SMA_ENV_STAT(pRSmaEnv));
-  return atomic_load_64(&pRSmaStat->submitVer);
-}
 static int32_t tdRSmaFetchAndSubmitResult(SRSmaInfoItem *pItem, STSchema *pTSchema, int64_t suid, SRSmaStat *pStat,
                                          int8_t blkType) {
  SArray *pResult = NULL;
@@ -579,9 +568,11 @@ static int32_t tdRSmaFetchAndSubmitResult(SRSmaInfoItem *pItem, STSchema *pTSche
  while (1) {
    SSDataBlock *output = NULL;
    uint64_t     ts;
-    if (qExecTask(pItem->taskInfo, &output, &ts) < 0) {
-      smaError("vgId:%d, qExecTask for rsma table %" PRIi64 "l evel %" PRIi8 " failed since %s", SMA_VID(pSma), suid,
+    int32_t code = qExecTask(pItem->taskInfo, &output, &ts);
-               pItem->level, terrstr());
+    if (code < 0) {
+      smaError("vgId:%d, qExecTask for rsma table %" PRIi64 " level %" PRIi8 " failed since %s", SMA_VID(pSma), suid,
+               pItem->level, terrstr(code));
      goto _err;
    }
    if (!output) {
@@ -597,35 +588,39 @@ static int32_t tdRSmaFetchAndSubmitResult(SRSmaInfoItem *pItem, STSchema *pTSche
    }
    taosArrayPush(pResult, output);
-  }
-  if (taosArrayGetSize(pResult) > 0) {
+    if (taosArrayGetSize(pResult) > 0) {
 #if 1
-    char flag[10] = {0};
+      char flag[10] = {0};
-    snprintf(flag, 10, "level %" PRIi8, pItem->level);
+      snprintf(flag, 10, "level %" PRIi8, pItem->level);
-    blockDebugShowDataBlocks(pResult, flag);
+      blockDebugShowDataBlocks(pResult, flag);
 #endif
-    STsdb      *sinkTsdb = (pItem->level == TSDB_RETENTION_L1 ? pSma->pRSmaTsdb[0] : pSma->pRSmaTsdb[1]);
+      STsdb      *sinkTsdb = (pItem->level == TSDB_RETENTION_L1 ? pSma->pRSmaTsdb[0] : pSma->pRSmaTsdb[1]);
-    SSubmitReq *pReq = NULL;
+      SSubmitReq *pReq = NULL;
-    // TODO: the schema update should be handled
+      // TODO: the schema update should be handled
-    if (buildSubmitReqFromDataBlock(&pReq, pResult, pTSchema, SMA_VID(pSma), suid) < 0) {
+      if (buildSubmitReqFromDataBlock(&pReq, pResult, pTSchema, SMA_VID(pSma), suid) < 0) {
-      smaError("vgId:%d, build submit req for rsma table %" PRIi64 "l evel %" PRIi8 " failed since %s", SMA_VID(pSma),
+        smaError("vgId:%d, build submit req for rsma table %" PRIi64 "l evel %" PRIi8 " failed since %s", SMA_VID(pSma),
-               suid, pItem->level, terrstr());
+                 suid, pItem->level, terrstr());
-      goto _err;
+        goto _err;
-    }
+      }
+      if (pReq && tdProcessSubmitReq(sinkTsdb, output->info.version, pReq) < 0) {
+        taosMemoryFreeClear(pReq);
+        smaError("vgId:%d, process submit req for rsma table %" PRIi64 " level %" PRIi8 " failed since %s",
+                 SMA_VID(pSma), suid, pItem->level, terrstr());
+        goto _err;
+      }
+      smaDebug("vgId:%d, process submit req for rsma table %" PRIi64 " level %" PRIi8 " version:%"PRIi64, SMA_VID(pSma),
+               suid, pItem->level, output->info.version);
-    if (pReq && tdProcessSubmitReq(sinkTsdb, atomic_add_fetch_64(&pStat->submitVer, 1), pReq) < 0) {
      taosMemoryFreeClear(pReq);
-      smaError("vgId:%d, process submit req for rsma table %" PRIi64 " level %" PRIi8 " failed since %s", SMA_VID(pSma),
+      taosArrayClear(pResult);
-               suid, pItem->level, terrstr());
+    } else if (terrno == 0) {
-      goto _err;
+      smaDebug("vgId:%d, no rsma %" PRIi8 " data fetched yet", SMA_VID(pSma), pItem->level);
+    } else {
+      smaDebug("vgId:%d, no rsma %" PRIi8 " data fetched since %s", SMA_VID(pSma), pItem->level, tstrerror(terrno));
    }
-    taosMemoryFreeClear(pReq);
-  } else if (terrno == 0) {
-    smaDebug("vgId:%d, no rsma %" PRIi8 " data fetched yet", SMA_VID(pSma), pItem->level);
-  } else {
-    smaDebug("vgId:%d, no rsma %" PRIi8 " data fetched since %s", SMA_VID(pSma), pItem->level, tstrerror(terrno));
  }
  tdDestroySDataBlockArray(pResult);
@@ -905,12 +900,8 @@ static int32_t tdRSmaRestoreQTaskInfoReload(SSma *pSma, int64_t *committed) {
    goto _err;
  }
-  ASSERT(tFileInfo.qTaskInfo.submitVer > 0);
  SSmaEnv   *pRSmaEnv = pSma->pRSmaEnv;
  SRSmaStat *pRSmaStat = (SRSmaStat *)SMA_ENV_STAT(pRSmaEnv);
-  atomic_store_64(&pRSmaStat->submitVer, tFileInfo.qTaskInfo.submitVer);
-  smaDebug("%s:%d tFileInfo.qTaskInfo.submitVer = %" PRIi64, __func__, __LINE__, tFileInfo.qTaskInfo.submitVer);
  SRSmaQTaskInfoIter fIter = {0};
  if (tdRSmaQTaskInfoIterInit(&fIter, &tFile) < 0) {
@@ -1263,7 +1254,6 @@ int32_t tdRSmaPersistExecImpl(SRSmaStat *pRSmaStat, SHashObj *pInfoHash) {
  }
  if (isFileCreated) {
-    tFile.info.qTaskInfo.submitVer = atomic_load_64(&pRSmaStat->commitSubmitVer);
    if (tdUpdateTFileHeader(&tFile) < 0) {
      smaError("vgId:%d, rsma, failed to update tfile %s header since %s", vid, TD_TFILE_FULL_NAME(&tFile),
               tstrerror(terrno));
@@ -1343,6 +1333,8 @@ static void tdRSmaFetchTrigger(void *param, void *tmrId) {
      tdRSmaFetchAndSubmitResult(pItem, pRSmaInfo->pTSchema, pRSmaInfo->suid, pStat, STREAM_INPUT__DATA_BLOCK);
      tdUnRefRSmaInfo(pSma, pRSmaInfo);
+      // atomic_store_8(&pItem->triggerStat, TASK_TRIGGER_STAT_ACTIVE);
+      // taosTmrReset(tdRSmaFetchTrigger, 5000, pItem, smaMgmt.tmrHandle, &pItem->tmrId);
    } break;
    case TASK_TRIGGER_STAT_PAUSED: {
      smaDebug("vgId:%d, not fetch rsma level %" PRIi8 " data for table:%" PRIi64 " since stat is paused",
@@ -1364,4 +1356,4 @@ static void tdRSmaFetchTrigger(void *param, void *tmrId) {
 _end:
  tdReleaseSmaRef(smaMgmt.rsetId, pItem->refId, __func__, __LINE__);
 }
\ No newline at end of file
--- a/source/dnode/vnode/src/sma/smaUtil.c
+++ b/source/dnode/vnode/src/sma/smaUtil.c
@@ -32,9 +32,6 @@ static int32_t tdEncodeTFInfo(void **buf, STFInfo *pInfo) {
  tlen += taosEncodeFixedU32(buf, pInfo->ftype);
  tlen += taosEncodeFixedU32(buf, pInfo->fver);
  tlen += taosEncodeFixedI64(buf, pInfo->fsize);
-  if (pInfo->ftype == TD_FTYPE_RSMA_QTASKINFO) {
-    tlen += taosEncodeFixedI64(buf, pInfo->qTaskInfo.submitVer);
-  }
  return tlen;
 }
@@ -44,10 +41,6 @@ static void *tdDecodeTFInfo(void *buf, STFInfo *pInfo) {
  buf = taosDecodeFixedU32(buf, &(pInfo->ftype));
  buf = taosDecodeFixedU32(buf, &(pInfo->fver));
  buf = taosDecodeFixedI64(buf, &(pInfo->fsize));
-  // specific
-  if (pInfo->ftype == TD_FTYPE_RSMA_QTASKINFO) {
-    buf = taosDecodeFixedI64(buf, &(pInfo->qTaskInfo.submitVer));
-  }
  return buf;
 }

--- a/source/dnode/vnode/src/tq/tq.c
+++ b/source/dnode/vnode/src/tq/tq.c
@@ -51,7 +51,7 @@ void tqCleanUp() {
  }
 }
-STQ* tqOpen(const char* path, SVnode* pVnode, SWal* pWal) {
+STQ* tqOpen(const char* path, SVnode* pVnode) {
  STQ* pTq = taosMemoryCalloc(1, sizeof(STQ));
  if (pTq == NULL) {
    terrno = TSDB_CODE_TQ_OUT_OF_MEMORY;
@@ -59,7 +59,6 @@ STQ* tqOpen(const char* path, SVnode* pVnode, SWal* pWal) {
  }
  pTq->path = strdup(path);
  pTq->pVnode = pVnode;
-  pTq->pWal = pWal;
  pTq->handles = taosHashInit(64, MurmurHash3_32, true, HASH_ENTRY_LOCK);
@@ -67,6 +66,8 @@ STQ* tqOpen(const char* path, SVnode* pVnode, SWal* pWal) {
  pTq->pushMgr = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_ENTRY_LOCK);
+  pTq->pAlterInfo = taosHashInit(64, MurmurHash3_32, true, HASH_ENTRY_LOCK);
  if (tqMetaOpen(pTq) < 0) {
    ASSERT(0);
  }
@@ -91,6 +92,7 @@ void tqClose(STQ* pTq) {
    }
    taosHashCleanup(pTq->pStreamTasks);
    taosHashCleanup(pTq->pushMgr);
+    taosHashCleanup(pTq->pAlterInfo);
    taosMemoryFree(pTq->path);
    tqMetaClose(pTq);
    taosMemoryFree(pTq);
@@ -208,18 +210,18 @@ int32_t tqProcessOffsetCommitReq(STQ* pTq, char* msg, int32_t msgLen) {
  return 0;
 }
-int32_t tqCheckColModifiable(STQ* pTq, int32_t colId) {
+int32_t tqCheckColModifiable(STQ* pTq, int64_t tbUid, int32_t colId) {
  void* pIter = NULL;
  while (1) {
-    pIter = taosHashIterate(pTq->handles, pIter);
+    pIter = taosHashIterate(pTq->pAlterInfo, pIter);
    if (pIter == NULL) break;
-    STqHandle* pExec = (STqHandle*)pIter;
+    SCheckAlterInfo* pCheck = (SCheckAlterInfo*)pIter;
-    if (pExec->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
+    if (pCheck->ntbUid == tbUid) {
-      int32_t sz = taosArrayGetSize(pExec->colIdList);
+      int32_t sz = taosArrayGetSize(pCheck->colIdList);
      for (int32_t i = 0; i < sz; i++) {
-        int32_t forbidColId = *(int32_t*)taosArrayGet(pExec->colIdList, i);
+        int16_t forbidColId = *(int16_t*)taosArrayGet(pCheck->colIdList, i);
        if (forbidColId == colId) {
-          taosHashCancelIterate(pTq->handles, pIter);
+          taosHashCancelIterate(pTq->pAlterInfo, pIter);
          return -1;
        }
      }
@@ -262,7 +264,7 @@ static int32_t tqInitDataRsp(SMqDataRsp* pRsp, const SMqPollReq* pReq, int8_t su
 static int32_t tqInitMetaRsp(SMqMetaRsp* pRsp, const SMqPollReq* pReq) { return 0; }
-int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
+int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg) {
  SMqPollReq*  pReq = pMsg->pCont;
  int64_t      consumerId = pReq->consumerId;
  int64_t      timeout = pReq->timeout;
@@ -270,9 +272,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
  int32_t      code = 0;
  STqOffsetVal reqOffset = pReq->reqOffset;
  STqOffsetVal fetchOffsetNew;
+  SWalCkHead*  pCkHead = NULL;
-  // todo
-  workerId = 0;
  // 1.find handle
  STqHandle* pHandle = taosHashGet(pTq->handles, pReq->subKey, strlen(pReq->subKey));
@@ -405,7 +405,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
      if (pHead->msgType == TDMT_VND_SUBMIT) {
        SSubmitReq* pCont = (SSubmitReq*)&pHead->body;
-        if (tqLogScanExec(pTq, &pHandle->execHandle, pCont, &dataRsp, workerId) < 0) {
+        if (tqLogScanExec(pTq, &pHandle->execHandle, pCont, &dataRsp) < 0) {
          /*ASSERT(0);*/
        }
        // TODO batch optimization:
@@ -462,6 +462,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
  }
 OVER:
+  if (pCkHead) taosMemoryFree(pCkHead);
  // TODO wrap in destroy func
  taosArrayDestroy(dataRsp.blockDataLen);
  taosArrayDestroyP(dataRsp.blockData, (FDelete)taosMemoryFree);
@@ -491,6 +492,22 @@ int32_t tqProcessVgDeleteReq(STQ* pTq, char* msg, int32_t msgLen) {
  return 0;
 }
+int32_t tqProcessCheckAlterInfoReq(STQ* pTq, char* msg, int32_t msgLen) {
+  SCheckAlterInfo info = {0};
+  SDecoder        decoder;
+  tDecoderInit(&decoder, msg, msgLen);
+  if (tDecodeSCheckAlterInfo(&decoder, &info) < 0) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
+  tDecoderClear(&decoder);
+  if (taosHashPut(pTq->pAlterInfo, info.topic, strlen(info.topic), &info, sizeof(SCheckAlterInfo)) < 0) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
+  return 0;
+}
 int32_t tqProcessVgChangeReq(STQ* pTq, char* msg, int32_t msgLen) {
  SMqRebVgReq req = {0};
  tDecodeSMqRebVgReq(msg, &req);
@@ -518,27 +535,24 @@ int32_t tqProcessVgChangeReq(STQ* pTq, char* msg, int32_t msgLen) {
      pHandle->execHandle.execCol.qmsg = req.qmsg;
      pHandle->snapshotVer = ver;
      req.qmsg = NULL;
-      for (int32_t i = 0; i < 5; i++) {
+      SReadHandle handle = {
-        SReadHandle handle = {
+          .meta = pTq->pVnode->pMeta,
-            .meta = pTq->pVnode->pMeta,
+          .vnode = pTq->pVnode,
-            .vnode = pTq->pVnode,
+          .initTableReader = true,
-            .initTableReader = true,
+          .initTqReader = true,
-            .initTqReader = true,
+          .version = ver,
-            .version = ver,
+      };
-        };
+      pHandle->execHandle.execCol.task =
-        pHandle->execHandle.execCol.task[i] =
+          qCreateQueueExecTaskInfo(pHandle->execHandle.execCol.qmsg, &handle, &pHandle->execHandle.numOfCols,
-            qCreateQueueExecTaskInfo(pHandle->execHandle.execCol.qmsg, &handle, &pHandle->execHandle.numOfCols);
+                                   &pHandle->execHandle.pSchemaWrapper);
-        ASSERT(pHandle->execHandle.execCol.task[i]);
+      ASSERT(pHandle->execHandle.execCol.task);
-        void* scanner = NULL;
+      void* scanner = NULL;
-        qExtractStreamScanner(pHandle->execHandle.execCol.task[i], &scanner);
+      qExtractStreamScanner(pHandle->execHandle.execCol.task, &scanner);
-        ASSERT(scanner);
+      ASSERT(scanner);
-        pHandle->execHandle.pExecReader[i] = qExtractReaderFromStreamScanner(scanner);
+      pHandle->execHandle.pExecReader = qExtractReaderFromStreamScanner(scanner);
-        ASSERT(pHandle->execHandle.pExecReader[i]);
+      ASSERT(pHandle->execHandle.pExecReader);
-      }
    } else if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__DB) {
-      for (int32_t i = 0; i < 5; i++) {
+      pHandle->execHandle.pExecReader = tqOpenReader(pTq->pVnode);
-        pHandle->execHandle.pExecReader[i] = tqOpenReader(pTq->pVnode);
-      }
      pHandle->execHandle.execDb.pFilterOutTbUid =
          taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
    } else if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__TABLE) {
@@ -550,15 +564,15 @@ int32_t tqProcessVgChangeReq(STQ* pTq, char* msg, int32_t msgLen) {
        int64_t tbUid = *(int64_t*)taosArrayGet(tbUidList, i);
        tqDebug("vgId:%d, idx %d, uid:%" PRId64, TD_VID(pTq->pVnode), i, tbUid);
      }
-      for (int32_t i = 0; i < 5; i++) {
+      pHandle->execHandle.pExecReader = tqOpenReader(pTq->pVnode);
-        pHandle->execHandle.pExecReader[i] = tqOpenReader(pTq->pVnode);
+      tqReaderSetTbUidList(pHandle->execHandle.pExecReader, tbUidList);
-        tqReaderSetTbUidList(pHandle->execHandle.pExecReader[i], tbUidList);
-      }
      taosArrayDestroy(tbUidList);
    }
    taosHashPut(pTq->handles, req.subKey, strlen(req.subKey), pHandle, sizeof(STqHandle));
+    tqDebug("try to persist handle %s consumer %ld", req.subKey, pHandle->consumerId);
    if (tqMetaSaveHandle(pTq, req.subKey, pHandle) < 0) {
      // TODO
+      ASSERT(0);
    }
  } else {
    /*ASSERT(pExec->consumerId == req.oldConsumerId);*/
@@ -634,7 +648,7 @@ int32_t tqProcessTaskDeployReq(STQ* pTq, char* msg, int32_t msgLen) {
    ASSERT(pTask->tbSink.pSchemaWrapper->pSchema);
    pTask->tbSink.pTSchema =
-        tdGetSTSChemaFromSSChema(&pTask->tbSink.pSchemaWrapper->pSchema, pTask->tbSink.pSchemaWrapper->nCols);
+        tdGetSTSChemaFromSSChema(pTask->tbSink.pSchemaWrapper->pSchema, pTask->tbSink.pSchemaWrapper->nCols, 1);
    ASSERT(pTask->tbSink.pTSchema);
  }

--- a/source/dnode/vnode/src/tq/tqExec.c
+++ b/source/dnode/vnode/src/tq/tqExec.c
@@ -37,8 +37,8 @@ static int32_t tqAddBlockDataToRsp(const SSDataBlock* pBlock, SMqDataRsp* pRsp,
  return 0;
 }
-static int32_t tqAddBlockSchemaToRsp(const STqExecHandle* pExec, int32_t workerId, SMqDataRsp* pRsp) {
+static int32_t tqAddBlockSchemaToRsp(const STqExecHandle* pExec, SMqDataRsp* pRsp) {
-  SSchemaWrapper* pSW = tCloneSSchemaWrapper(pExec->pExecReader[workerId]->pSchemaWrapper);
+  SSchemaWrapper* pSW = tCloneSSchemaWrapper(pExec->pExecReader->pSchemaWrapper);
  if (pSW == NULL) {
    return -1;
  }
@@ -51,6 +51,7 @@ static int32_t tqAddTbNameToRsp(const STQ* pTq, int64_t uid, SMqDataRsp* pRsp) {
  metaReaderInit(&mr, pTq->pVnode->pMeta, 0);
  // TODO add reference to gurantee success
  if (metaGetTableEntryByUid(&mr, uid) < 0) {
+    metaReaderClear(&mr);
    return -1;
  }
  char* tbName = strdup(mr.me.name);
@@ -61,7 +62,7 @@ static int32_t tqAddTbNameToRsp(const STQ* pTq, int64_t uid, SMqDataRsp* pRsp) {
 int64_t tqScan(STQ* pTq, const STqHandle* pHandle, SMqDataRsp* pRsp, STqOffsetVal* pOffset) {
  const STqExecHandle* pExec = &pHandle->execHandle;
-  qTaskInfo_t          task = pExec->execCol.task[0];
+  qTaskInfo_t          task = pExec->execCol.task;
  if (qStreamPrepareScan(task, pOffset) < 0) {
    if (pOffset->type == TMQ_OFFSET__LOG) {
@@ -89,7 +90,7 @@ int64_t tqScan(STQ* pTq, const STqHandle* pHandle, SMqDataRsp* pRsp, STqOffsetVa
    if (pDataBlock != NULL) {
      if (pRsp->withTbName) {
        if (pOffset->type == TMQ_OFFSET__LOG) {
-          int64_t uid = pExec->pExecReader[0]->msgIter.uid;
+          int64_t uid = pExec->pExecReader->msgIter.uid;
          if (tqAddTbNameToRsp(pTq, uid, pRsp) < 0) {
            continue;
          }
@@ -108,6 +109,7 @@ int64_t tqScan(STQ* pTq, const STqHandle* pHandle, SMqDataRsp* pRsp, STqOffsetVa
    }
    if (pRsp->blockNum == 0 && pOffset->type == TMQ_OFFSET__SNAPSHOT_DATA) {
+      tqDebug("vgId: %d, tsdb consume over, switch to wal, ver %ld", TD_VID(pTq->pVnode), pHandle->snapshotVer + 1);
      tqOffsetResetToLog(pOffset, pHandle->snapshotVer);
      qStreamPrepareScan(task, pOffset);
      continue;
@@ -184,12 +186,12 @@ int32_t tqScanSnapshot(STQ* pTq, const STqExecHandle* pExec, SMqDataRsp* pRsp, S
 }
 #endif
-int32_t tqLogScanExec(STQ* pTq, STqExecHandle* pExec, SSubmitReq* pReq, SMqDataRsp* pRsp, int32_t workerId) {
+int32_t tqLogScanExec(STQ* pTq, STqExecHandle* pExec, SSubmitReq* pReq, SMqDataRsp* pRsp) {
  ASSERT(pExec->subType != TOPIC_SUB_TYPE__COLUMN);
  if (pExec->subType == TOPIC_SUB_TYPE__TABLE) {
    pRsp->withSchema = 1;
-    STqReader* pReader = pExec->pExecReader[workerId];
+    STqReader* pReader = pExec->pExecReader;
    tqReaderSetDataMsg(pReader, pReq, 0);
    while (tqNextDataBlock(pReader)) {
      SSDataBlock block = {0};
@@ -197,18 +199,20 @@ int32_t tqLogScanExec(STQ* pTq, STqExecHandle* pExec, SSubmitReq* pReq, SMqDataR
        if (terrno == TSDB_CODE_TQ_TABLE_SCHEMA_NOT_FOUND) continue;
      }
      if (pRsp->withTbName) {
-        int64_t uid = pExec->pExecReader[workerId]->msgIter.uid;
+        int64_t uid = pExec->pExecReader->msgIter.uid;
        if (tqAddTbNameToRsp(pTq, uid, pRsp) < 0) {
+          blockDataFreeRes(&block);
          continue;
        }
      }
      tqAddBlockDataToRsp(&block, pRsp, taosArrayGetSize(block.pDataBlock));
-      tqAddBlockSchemaToRsp(pExec, workerId, pRsp);
+      blockDataFreeRes(&block);
+      tqAddBlockSchemaToRsp(pExec, pRsp);
      pRsp->blockNum++;
    }
  } else if (pExec->subType == TOPIC_SUB_TYPE__DB) {
    pRsp->withSchema = 1;
-    STqReader* pReader = pExec->pExecReader[workerId];
+    STqReader* pReader = pExec->pExecReader;
    tqReaderSetDataMsg(pReader, pReq, 0);
    while (tqNextDataBlockFilterOut(pReader, pExec->execDb.pFilterOutTbUid)) {
      SSDataBlock block = {0};
@@ -216,13 +220,15 @@ int32_t tqLogScanExec(STQ* pTq, STqExecHandle* pExec, SSubmitReq* pReq, SMqDataR
        if (terrno == TSDB_CODE_TQ_TABLE_SCHEMA_NOT_FOUND) continue;
      }
      if (pRsp->withTbName) {
-        int64_t uid = pExec->pExecReader[workerId]->msgIter.uid;
+        int64_t uid = pExec->pExecReader->msgIter.uid;
        if (tqAddTbNameToRsp(pTq, uid, pRsp) < 0) {
+          blockDataFreeRes(&block);
          continue;
        }
      }
      tqAddBlockDataToRsp(&block, pRsp, taosArrayGetSize(block.pDataBlock));
-      tqAddBlockSchemaToRsp(pExec, workerId, pRsp);
+      blockDataFreeRes(&block);
+      tqAddBlockSchemaToRsp(pExec, pRsp);
      pRsp->blockNum++;
    }
  }

--- a/source/dnode/vnode/src/tq/tqMeta.c
+++ b/source/dnode/vnode/src/tq/tqMeta.c
@@ -80,31 +80,28 @@ int32_t tqMetaOpen(STQ* pTq) {
    tDecoderInit(&decoder, (uint8_t*)pVal, vLen);
    tDecodeSTqHandle(&decoder, &handle);
    handle.pWalReader = walOpenReader(pTq->pVnode->pWal, NULL);
-    /*for (int32_t i = 0; i < 5; i++) {*/
-    /*handle.execHandle.pExecReader[i] = tqOpenReader(pTq->pVnode);*/
-    /*}*/
    if (handle.execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
-      for (int32_t i = 0; i < 5; i++) {
+      SReadHandle reader = {
-        SReadHandle reader = {
+          .meta = pTq->pVnode->pMeta,
-            .meta = pTq->pVnode->pMeta,
+          .vnode = pTq->pVnode,
-            .vnode = pTq->pVnode,
+          .initTableReader = true,
-            .initTableReader = true,
+          .initTqReader = true,
-            .initTqReader = true,
+          .version = handle.snapshotVer,
-            .version = handle.snapshotVer,
+      };
-        };
+      handle.execHandle.execCol.task = qCreateQueueExecTaskInfo(
-        handle.execHandle.execCol.task[i] = qCreateQueueExecTaskInfo(handle.execHandle.execCol.qmsg, &reader, &handle.execHandle.numOfCols);
+          handle.execHandle.execCol.qmsg, &reader, &handle.execHandle.numOfCols, &handle.execHandle.pSchemaWrapper);
-        ASSERT(handle.execHandle.execCol.task[i]);
+      ASSERT(handle.execHandle.execCol.task);
-        void* scanner = NULL;
+      void* scanner = NULL;
-        qExtractStreamScanner(handle.execHandle.execCol.task[i], &scanner);
+      qExtractStreamScanner(handle.execHandle.execCol.task, &scanner);
-        ASSERT(scanner);
+      ASSERT(scanner);
-        handle.execHandle.pExecReader[i] = qExtractReaderFromStreamScanner(scanner);
+      handle.execHandle.pExecReader = qExtractReaderFromStreamScanner(scanner);
-        ASSERT(handle.execHandle.pExecReader[i]);
+      ASSERT(handle.execHandle.pExecReader);
-      }
    } else {
      handle.execHandle.execDb.pFilterOutTbUid =
          taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
    }
+    tqDebug("tq restore %s consumer %ld", handle.subKey, handle.consumerId);
    taosHashPut(pTq->handles, pKey, kLen, &handle, sizeof(STqHandle));
  }

--- a/source/dnode/vnode/src/tq/tqPush.c
+++ b/source/dnode/vnode/src/tq/tqPush.c
@@ -249,6 +249,8 @@ int tqPushMsg(STQ* pTq, void* msg, int32_t msgLen, tmsg_t msgType, int64_t ver)
      return -1;
    }
    memcpy(data, msg, msgLen);
+    SSubmitReq* pReq = (SSubmitReq*)data;
+    pReq->version = ver;
    tqProcessStreamTrigger(pTq, data);
  }

--- a/source/dnode/vnode/src/tq/tqRead.c
+++ b/source/dnode/vnode/src/tq/tqRead.c
@@ -314,6 +314,7 @@ int32_t tqRetrieveDataBlock(SSDataBlock* pBlock, STqReader* pReader) {
  pBlock->info.uid = pReader->msgIter.uid;
  pBlock->info.rows = pReader->msgIter.numOfRows;
+  pBlock->info.version = pReader->pMsg->version;
  while ((row = tGetSubmitBlkNext(&pReader->blkIter)) != NULL) {
    tdSTSRowIterReset(&iter, row);
@@ -339,29 +340,30 @@ FAIL:
 void tqReaderSetColIdList(STqReader* pReadHandle, SArray* pColIdList) { pReadHandle->pColIdList = pColIdList; }
-int tqReaderSetTbUidList(STqReader* pHandle, const SArray* tbUidList) {
+int tqReaderSetTbUidList(STqReader* pReader, const SArray* tbUidList) {
-  if (pHandle->tbIdHash) {
+  if (pReader->tbIdHash) {
-    taosHashClear(pHandle->tbIdHash);
+    taosHashClear(pReader->tbIdHash);
+  } else {
+    pReader->tbIdHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK);
  }
-  pHandle->tbIdHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK);
+  if (pReader->tbIdHash == NULL) {
-  if (pHandle->tbIdHash == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    return -1;
  }
  for (int i = 0; i < taosArrayGetSize(tbUidList); i++) {
    int64_t* pKey = (int64_t*)taosArrayGet(tbUidList, i);
-    taosHashPut(pHandle->tbIdHash, pKey, sizeof(int64_t), NULL, 0);
+    taosHashPut(pReader->tbIdHash, pKey, sizeof(int64_t), NULL, 0);
  }
  return 0;
 }
-int tqReaderAddTbUidList(STqReader* pHandle, const SArray* tbUidList) {
+int tqReaderAddTbUidList(STqReader* pReader, const SArray* tbUidList) {
-  if (pHandle->tbIdHash == NULL) {
+  if (pReader->tbIdHash == NULL) {
-    pHandle->tbIdHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK);
+    pReader->tbIdHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK);
-    if (pHandle->tbIdHash == NULL) {
+    if (pReader->tbIdHash == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
      return -1;
    }
@@ -369,18 +371,18 @@ int tqReaderAddTbUidList(STqReader* pHandle, const SArray* tbUidList) {
  for (int i = 0; i < taosArrayGetSize(tbUidList); i++) {
    int64_t* pKey = (int64_t*)taosArrayGet(tbUidList, i);
-    taosHashPut(pHandle->tbIdHash, pKey, sizeof(int64_t), NULL, 0);
+    taosHashPut(pReader->tbIdHash, pKey, sizeof(int64_t), NULL, 0);
  }
  return 0;
 }
-int tqReaderRemoveTbUidList(STqReader* pHandle, const SArray* tbUidList) {
+int tqReaderRemoveTbUidList(STqReader* pReader, const SArray* tbUidList) {
-  ASSERT(pHandle->tbIdHash != NULL);
+  ASSERT(pReader->tbIdHash != NULL);
  for (int32_t i = 0; i < taosArrayGetSize(tbUidList); i++) {
    int64_t* pKey = (int64_t*)taosArrayGet(tbUidList, i);
-    taosHashRemove(pHandle->tbIdHash, pKey, sizeof(int64_t));
+    taosHashRemove(pReader->tbIdHash, pKey, sizeof(int64_t));
  }
  return 0;
@@ -393,10 +395,8 @@ int32_t tqUpdateTbUidList(STQ* pTq, const SArray* tbUidList, bool isAdd) {
    if (pIter == NULL) break;
    STqHandle* pExec = (STqHandle*)pIter;
    if (pExec->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
-      for (int32_t i = 0; i < 5; i++) {
+      int32_t code = qUpdateQualifiedTableId(pExec->execHandle.execCol.task, tbUidList, isAdd);
-        int32_t code = qUpdateQualifiedTableId(pExec->execHandle.execCol.task[i], tbUidList, isAdd);
+      ASSERT(code == 0);
-        ASSERT(code == 0);
-      }
    } else if (pExec->execHandle.subType == TOPIC_SUB_TYPE__DB) {
      if (!isAdd) {
        int32_t sz = taosArrayGetSize(tbUidList);

--- a/source/dnode/vnode/src/tq/tqSink.c
+++ b/source/dnode/vnode/src/tq/tqSink.c
@@ -110,7 +110,6 @@ SSubmitReq* tdBlockToSubmit(const SArray* pBlocks, const STSchema* pTSchema, boo
  // TODO
  ret = rpcMallocCont(cap);
  ret->header.vgId = vgId;
-  ret->version = htonl(1);
  ret->length = sizeof(SSubmitReq);
  ret->numOfBlocks = htonl(sz);
@@ -127,6 +126,8 @@ SSubmitReq* tdBlockToSubmit(const SArray* pBlocks, const STSchema* pTSchema, boo
    int32_t rows = pDataBlock->info.rows;
+    tqDebug("tq sink, convert block %d, rows: %d", i, rows);
    int32_t dataLen = 0;
    void* blkSchema = POINTER_SHIFT(blkHead, sizeof(SSubmitBlk));
@@ -178,11 +179,14 @@ void tqTableSink(SStreamTask* pTask, void* vnode, int64_t ver, void* data) {
  const SArray* pRes = (const SArray*)data;
  SVnode*       pVnode = (SVnode*)vnode;
-  tqDebug("task write into table, vgId %d, block num: %d", pVnode->config.vgId, (int32_t)pRes->size);
+  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,
                                     pTask->tbSink.stbFullName, pVnode->config.vgId);
+  tqDebug("vgId:%d, task %d convert blocks over, put into write-queue", TD_VID(pVnode), pTask->taskId);
  /*tPrintFixedSchemaSubmitReq(pReq, pTask->tbSink.pTSchema);*/
  // build write msg
  SRpcMsg msg = {

--- a/source/dnode/vnode/src/tsdb/tsdbCache.c
+++ b/source/dnode/vnode/src/tsdb/tsdbCache.c
--- a/source/dnode/vnode/src/tsdb/tsdbCommit.c
+++ b/source/dnode/vnode/src/tsdb/tsdbCommit.c
@@ -29,6 +29,7 @@ typedef struct {
  int32_t minRow;
  int32_t maxRow;
  int8_t  cmprAlg;
+  STsdbFS fs;
  // --------------
  TSKEY   nextKey;  // reset by each table commit
  int32_t commitFid;
@@ -119,9 +120,6 @@ int32_t tsdbCommit(STsdb *pTsdb) {
  code = tsdbCommitDel(&commith);
  if (code) goto _err;
-  code = tsdbCommitCache(&commith);
-  if (code) goto _err;
  // end commit
  code = tsdbEndCommit(&commith, 0);
  if (code) goto _err;
@@ -158,7 +156,7 @@ static int32_t tsdbCommitDelStart(SCommitter *pCommitter) {
    goto _err;
  }
-  SDelFile *pDelFileR = pTsdb->pFS->nState->pDelFile;
+  SDelFile *pDelFileR = pCommitter->fs.pDelFile;
  if (pDelFileR) {
    code = tsdbDelFReaderOpen(&pCommitter->pDelFReader, pDelFileR, pTsdb, NULL);
    if (code) goto _err;
@@ -247,7 +245,7 @@ static int32_t tsdbCommitDelEnd(SCommitter *pCommitter) {
  code = tsdbUpdateDelFileHdr(pCommitter->pDelFWriter);
  if (code) goto _err;
-  code = tsdbFSStateUpsertDelFile(pTsdb->pFS->nState, &pCommitter->pDelFWriter->fDel);
+  code = tsdbFSUpsertDelFile(&pCommitter->fs, &pCommitter->pDelFWriter->fDel);
  if (code) goto _err;
  code = tsdbDelFWriterClose(&pCommitter->pDelFWriter, 1);
@@ -273,7 +271,6 @@ static int32_t tsdbCommitFileDataStart(SCommitter *pCommitter) {
  int32_t    code = 0;
  STsdb     *pTsdb = pCommitter->pTsdb;
  SDFileSet *pRSet = NULL;
-  SDFileSet  wSet;
  // memory
  pCommitter->nextKey = TSKEY_MAX;
@@ -282,7 +279,8 @@ static int32_t tsdbCommitFileDataStart(SCommitter *pCommitter) {
  taosArrayClear(pCommitter->aBlockIdx);
  tMapDataReset(&pCommitter->oBlockMap);
  tBlockDataReset(&pCommitter->oBlockData);
-  pRSet = tsdbFSStateGetDFileSet(pTsdb->pFS->nState, pCommitter->commitFid, TD_EQ);
+  pRSet = (SDFileSet *)taosArraySearch(pCommitter->fs.aDFileSet, &(SDFileSet){.fid = pCommitter->commitFid},
+                                       tDFileSetCmprFn, TD_EQ);
  if (pRSet) {
    code = tsdbDataFReaderOpen(&pCommitter->pReader, pTsdb, pRSet);
    if (code) goto _err;
@@ -292,23 +290,29 @@ static int32_t tsdbCommitFileDataStart(SCommitter *pCommitter) {
  }
  // new
+  SHeadFile fHead;
+  SDataFile fData;
+  SLastFile fLast;
+  SSmaFile  fSma;
+  SDFileSet wSet = {.pHeadF = &fHead, .pDataF = &fData, .pLastF = &fLast, .pSmaF = &fSma};
  taosArrayClear(pCommitter->aBlockIdxN);
  tMapDataReset(&pCommitter->nBlockMap);
  tBlockDataReset(&pCommitter->nBlockData);
  if (pRSet) {
-    wSet = (SDFileSet){.diskId = pRSet->diskId,
+    wSet.diskId = pRSet->diskId;
-                       .fid = pCommitter->commitFid,
+    wSet.fid = pCommitter->commitFid;
-                       .fHead = {.commitID = pCommitter->commitID, .offset = 0, .size = 0},
+    fHead = (SHeadFile){.commitID = pCommitter->commitID, .offset = 0, .size = 0};
-                       .fData = pRSet->fData,
+    fData = *pRSet->pDataF;
-                       .fLast = {.commitID = pCommitter->commitID, .size = 0},
+    fLast = (SLastFile){.commitID = pCommitter->commitID, .size = 0};
-                       .fSma = pRSet->fSma};
+    fSma = *pRSet->pSmaF;
  } else {
-    wSet = (SDFileSet){.diskId = (SDiskID){.level = 0, .id = 0},
+    wSet.diskId = (SDiskID){.level = 0, .id = 0};
-                       .fid = pCommitter->commitFid,
+    wSet.fid = pCommitter->commitFid;
-                       .fHead = {.commitID = pCommitter->commitID, .offset = 0, .size = 0},
+    fHead = (SHeadFile){.commitID = pCommitter->commitID, .offset = 0, .size = 0};
-                       .fData = {.commitID = pCommitter->commitID, .size = 0},
+    fData = (SDataFile){.commitID = pCommitter->commitID, .size = 0};
-                       .fLast = {.commitID = pCommitter->commitID, .size = 0},
+    fLast = (SLastFile){.commitID = pCommitter->commitID, .size = 0};
-                       .fSma = {.commitID = pCommitter->commitID, .size = 0}};
+    fSma = (SSmaFile){.commitID = pCommitter->commitID, .size = 0};
  }
  code = tsdbDataFWriterOpen(&pCommitter->pWriter, pTsdb, &wSet);
  if (code) goto _err;
@@ -855,7 +859,7 @@ static int32_t tsdbCommitFileDataEnd(SCommitter *pCommitter) {
  if (code) goto _err;
  // upsert SDFileSet
-  code = tsdbFSStateUpsertDFileSet(pCommitter->pTsdb->pFS->nState, tsdbDataFWriterGetWSet(pCommitter->pWriter));
+  code = tsdbFSUpsertFSet(&pCommitter->fs, &pCommitter->pWriter->wSet);
  if (code) goto _err;
  // close and sync
@@ -973,7 +977,7 @@ static int32_t tsdbStartCommit(STsdb *pTsdb, SCommitter *pCommitter) {
  pCommitter->maxRow = pTsdb->pVnode->config.tsdbCfg.maxRows;
  pCommitter->cmprAlg = pTsdb->pVnode->config.tsdbCfg.compression;
-  code = tsdbFSBegin(pTsdb->pFS);
+  code = tsdbFSCopy(pTsdb, &pCommitter->fs);
  if (code) goto _err;
  return code;
@@ -1142,28 +1146,33 @@ _err:
  return code;
 }
-static int32_t tsdbCommitCache(SCommitter *pCommitter) {
-  int32_t code = 0;
-  // TODO
-  return code;
-}
 static int32_t tsdbEndCommit(SCommitter *pCommitter, int32_t eno) {
  int32_t    code = 0;
  STsdb     *pTsdb = pCommitter->pTsdb;
  SMemTable *pMemTable = pTsdb->imem;
-  if (eno == 0) {
+  ASSERT(eno == 0);
-    code = tsdbFSCommit(pTsdb->pFS);
-  } else {
+  code = tsdbFSCommit1(pTsdb, &pCommitter->fs);
-    code = tsdbFSRollback(pTsdb->pFS);
+  if (code) goto _err;
-  }
+  // lock
  taosThreadRwlockWrlock(&pTsdb->rwLock);
+  // commit or rollback
+  code = tsdbFSCommit2(pTsdb, &pCommitter->fs);
+  if (code) {
+    taosThreadRwlockUnlock(&pTsdb->rwLock);
+    goto _err;
+  }
  pTsdb->imem = NULL;
+  // unlock
  taosThreadRwlockUnlock(&pTsdb->rwLock);
  tsdbUnrefMemTable(pMemTable);
+  tsdbFSDestroy(&pCommitter->fs);
  tsdbInfo("vgId:%d tsdb end commit", TD_VID(pTsdb->pVnode));
  return code;

--- a/source/dnode/vnode/src/tsdb/tsdbFS.c
+++ b/source/dnode/vnode/src/tsdb/tsdbFS.c
--- a/source/dnode/vnode/src/tsdb/tsdbFile.c
+++ b/source/dnode/vnode/src/tsdb/tsdbFile.c
@@ -15,7 +15,7 @@
 #include "tsdb.h"
-static int32_t tPutHeadFile(uint8_t *p, SHeadFile *pHeadFile) {
+int32_t tPutHeadFile(uint8_t *p, SHeadFile *pHeadFile) {
  int32_t n = 0;
  n += tPutI64v(p ? p + n : p, pHeadFile->commitID);
@@ -35,7 +35,7 @@ static int32_t tGetHeadFile(uint8_t *p, SHeadFile *pHeadFile) {
  return n;
 }
-static int32_t tPutDataFile(uint8_t *p, SDataFile *pDataFile) {
+int32_t tPutDataFile(uint8_t *p, SDataFile *pDataFile) {
  int32_t n = 0;
  n += tPutI64v(p ? p + n : p, pDataFile->commitID);
@@ -53,7 +53,7 @@ static int32_t tGetDataFile(uint8_t *p, SDataFile *pDataFile) {
  return n;
 }
-static int32_t tPutLastFile(uint8_t *p, SLastFile *pLastFile) {
+int32_t tPutLastFile(uint8_t *p, SLastFile *pLastFile) {
  int32_t n = 0;
  n += tPutI64v(p ? p + n : p, pLastFile->commitID);
@@ -71,7 +71,7 @@ static int32_t tGetLastFile(uint8_t *p, SLastFile *pLastFile) {
  return n;
 }
-static int32_t tPutSmaFile(uint8_t *p, SSmaFile *pSmaFile) {
+int32_t tPutSmaFile(uint8_t *p, SSmaFile *pSmaFile) {
  int32_t n = 0;
  n += tPutI64v(p ? p + n : p, pSmaFile->commitID);
@@ -90,123 +90,79 @@ static int32_t tGetSmaFile(uint8_t *p, SSmaFile *pSmaFile) {
 }
 // EXPOSED APIS ==================================================
-void tsdbDataFileName(STsdb *pTsdb, SDFileSet *pDFileSet, EDataFileT ftype, char fname[]) {
+void tsdbHeadFileName(STsdb *pTsdb, SDiskID did, int32_t fid, SHeadFile *pHeadF, char fname[]) {
-  STfs *pTfs = pTsdb->pVnode->pTfs;
+  snprintf(fname, TSDB_FILENAME_LEN - 1, "%s%s%s%sv%df%dver%" PRId64 "%s", tfsGetDiskPath(pTsdb->pVnode->pTfs, did),
+           TD_DIRSEP, pTsdb->path, TD_DIRSEP, TD_VID(pTsdb->pVnode), fid, pHeadF->commitID, ".head");
+}
-  switch (ftype) {
+void tsdbDataFileName(STsdb *pTsdb, SDiskID did, int32_t fid, SDataFile *pDataF, char fname[]) {
-    case TSDB_HEAD_FILE:
+  snprintf(fname, TSDB_FILENAME_LEN - 1, "%s%s%s%sv%df%dver%" PRId64 "%s", tfsGetDiskPath(pTsdb->pVnode->pTfs, did),
-      snprintf(fname, TSDB_FILENAME_LEN - 1, "%s%s%s%sv%df%dver%" PRId64 "%s", tfsGetDiskPath(pTfs, pDFileSet->diskId),
+           TD_DIRSEP, pTsdb->path, TD_DIRSEP, TD_VID(pTsdb->pVnode), fid, pDataF->commitID, ".data");
-               TD_DIRSEP, pTsdb->path, TD_DIRSEP, TD_VID(pTsdb->pVnode), pDFileSet->fid, pDFileSet->fHead.commitID,
-               ".head");
-      break;
-    case TSDB_DATA_FILE:
-      snprintf(fname, TSDB_FILENAME_LEN - 1, "%s%s%s%sv%df%dver%" PRId64 "%s", tfsGetDiskPath(pTfs, pDFileSet->diskId),
-               TD_DIRSEP, pTsdb->path, TD_DIRSEP, TD_VID(pTsdb->pVnode), pDFileSet->fid, pDFileSet->fData.commitID,
-               ".data");
-      break;
-    case TSDB_LAST_FILE:
-      snprintf(fname, TSDB_FILENAME_LEN - 1, "%s%s%s%sv%df%dver%" PRId64 "%s", tfsGetDiskPath(pTfs, pDFileSet->diskId),
-               TD_DIRSEP, pTsdb->path, TD_DIRSEP, TD_VID(pTsdb->pVnode), pDFileSet->fid, pDFileSet->fLast.commitID,
-               ".last");
-      break;
-    case TSDB_SMA_FILE:
-      snprintf(fname, TSDB_FILENAME_LEN - 1, "%s%s%s%sv%df%dver%" PRId64 "%s", tfsGetDiskPath(pTfs, pDFileSet->diskId),
-               TD_DIRSEP, pTsdb->path, TD_DIRSEP, TD_VID(pTsdb->pVnode), pDFileSet->fid, pDFileSet->fSma.commitID,
-               ".sma");
-      break;
-    default:
-      ASSERT(0);
-      break;
-  }
 }
-bool tsdbFileIsSame(SDFileSet *pDFileSet1, SDFileSet *pDFileSet2, EDataFileT ftype) {
+void tsdbLastFileName(STsdb *pTsdb, SDiskID did, int32_t fid, SLastFile *pLastF, char fname[]) {
-  if (pDFileSet1->diskId.level != pDFileSet2->diskId.level || pDFileSet1->diskId.id != pDFileSet2->diskId.id) {
+  snprintf(fname, TSDB_FILENAME_LEN - 1, "%s%s%s%sv%df%dver%" PRId64 "%s", tfsGetDiskPath(pTsdb->pVnode->pTfs, did),
-    return false;
+           TD_DIRSEP, pTsdb->path, TD_DIRSEP, TD_VID(pTsdb->pVnode), fid, pLastF->commitID, ".last");
-  }
+}
-  switch (ftype) {
+void tsdbSmaFileName(STsdb *pTsdb, SDiskID did, int32_t fid, SSmaFile *pSmaF, char fname[]) {
-    case TSDB_HEAD_FILE:
+  snprintf(fname, TSDB_FILENAME_LEN - 1, "%s%s%s%sv%df%dver%" PRId64 "%s", tfsGetDiskPath(pTsdb->pVnode->pTfs, did),
-      return pDFileSet1->fHead.commitID == pDFileSet2->fHead.commitID;
+           TD_DIRSEP, pTsdb->path, TD_DIRSEP, TD_VID(pTsdb->pVnode), fid, pSmaF->commitID, ".sma");
-    case TSDB_DATA_FILE:
-      return pDFileSet1->fData.commitID == pDFileSet2->fData.commitID;
-    case TSDB_LAST_FILE:
-      return pDFileSet1->fLast.commitID == pDFileSet2->fLast.commitID;
-    case TSDB_SMA_FILE:
-      return pDFileSet1->fSma.commitID == pDFileSet2->fSma.commitID;
-    default:
-      ASSERT(0);
-      break;
-  }
 }
 bool tsdbDelFileIsSame(SDelFile *pDelFile1, SDelFile *pDelFile2) { return pDelFile1->commitID == pDelFile2->commitID; }
-int32_t tsdbUpdateDFileHdr(TdFilePtr pFD, SDFileSet *pSet, EDataFileT ftype) {
-  int32_t code = 0;
-  int64_t n;
-  char    hdr[TSDB_FHDR_SIZE];
-  memset(hdr, 0, TSDB_FHDR_SIZE);
-  tPutDataFileHdr(hdr, pSet, ftype);
-  taosCalcChecksumAppend(0, hdr, TSDB_FHDR_SIZE);
-  n = taosLSeekFile(pFD, 0, SEEK_SET);
-  if (n < 0) {
-    code = TAOS_SYSTEM_ERROR(errno);
-    goto _exit;
-  }
-  n = taosWriteFile(pFD, hdr, TSDB_FHDR_SIZE);
-  if (n < 0) {
-    code = TAOS_SYSTEM_ERROR(errno);
-    goto _exit;
-  }
-_exit:
-  return code;
-}
 int32_t tsdbDFileRollback(STsdb *pTsdb, SDFileSet *pSet, EDataFileT ftype) {
  int32_t   code = 0;
  int64_t   size;
+  int64_t   n;
  TdFilePtr pFD;
  char      fname[TSDB_FILENAME_LEN];
+  char      hdr[TSDB_FHDR_SIZE] = {0};
-  tsdbDataFileName(pTsdb, pSet, ftype, fname);
-  // open
-  pFD = taosOpenFile(fname, TD_FILE_WRITE);
-  if (pFD == NULL) {
-    code = TAOS_SYSTEM_ERROR(errno);
-    goto _err;
-  }
  // truncate
  switch (ftype) {
-    case TSDB_HEAD_FILE:
-      size = pSet->fHead.size;
-      break;
    case TSDB_DATA_FILE:
-      size = pSet->fData.size;
+      size = pSet->pDataF->size;
-      break;
+      tsdbDataFileName(pTsdb, pSet->diskId, pSet->fid, pSet->pDataF, fname);
-    case TSDB_LAST_FILE:
+      tPutDataFile(hdr, pSet->pDataF);
-      size = pSet->fLast.size;
      break;
    case TSDB_SMA_FILE:
-      size = pSet->fSma.size;
+      size = pSet->pSmaF->size;
+      tsdbSmaFileName(pTsdb, pSet->diskId, pSet->fid, pSet->pSmaF, fname);
+      tPutSmaFile(hdr, pSet->pSmaF);
      break;
    default:
      ASSERT(0);
  }
+  taosCalcChecksumAppend(0, hdr, TSDB_FHDR_SIZE);
+  // open
+  pFD = taosOpenFile(fname, TD_FILE_WRITE);
+  if (pFD == NULL) {
+    code = TAOS_SYSTEM_ERROR(errno);
+    goto _err;
+  }
+  // ftruncate
  if (taosFtruncateFile(pFD, size) < 0) {
    code = TAOS_SYSTEM_ERROR(errno);
    goto _err;
  }
  // update header
-  code = tsdbUpdateDFileHdr(pFD, pSet, ftype);
+  n = taosLSeekFile(pFD, 0, SEEK_SET);
-  if (code) goto _err;
+  if (n < 0) {
+    code = TAOS_SYSTEM_ERROR(errno);
+    goto _err;
+  }
+  n = taosWriteFile(pFD, hdr, TSDB_FHDR_SIZE);
+  if (n < 0) {
+    code = TAOS_SYSTEM_ERROR(errno);
+    goto _err;
+  }
  // sync
  if (taosFsyncFile(pFD) < 0) {
@@ -220,42 +176,20 @@ int32_t tsdbDFileRollback(STsdb *pTsdb, SDFileSet *pSet, EDataFileT ftype) {
  return code;
 _err:
+  tsdbError("vgId:%d tsdb rollback file failed since %s", TD_VID(pTsdb->pVnode), tstrerror(code));
  return code;
 }
-int32_t tPutDataFileHdr(uint8_t *p, SDFileSet *pSet, EDataFileT ftype) {
-  int32_t n = 0;
-  switch (ftype) {
-    case TSDB_HEAD_FILE:
-      n += tPutHeadFile(p ? p + n : p, &pSet->fHead);
-      break;
-    case TSDB_DATA_FILE:
-      n += tPutDataFile(p ? p + n : p, &pSet->fData);
-      break;
-    case TSDB_LAST_FILE:
-      n += tPutLastFile(p ? p + n : p, &pSet->fLast);
-      break;
-    case TSDB_SMA_FILE:
-      n += tPutSmaFile(p ? p + n : p, &pSet->fSma);
-      break;
-    default:
-      ASSERT(0);
-  }
-  return n;
-}
 int32_t tPutDFileSet(uint8_t *p, SDFileSet *pSet) {
  int32_t n = 0;
  n += tPutI32v(p ? p + n : p, pSet->diskId.level);
  n += tPutI32v(p ? p + n : p, pSet->diskId.id);
  n += tPutI32v(p ? p + n : p, pSet->fid);
-  n += tPutHeadFile(p ? p + n : p, &pSet->fHead);
+  n += tPutHeadFile(p ? p + n : p, pSet->pHeadF);
-  n += tPutDataFile(p ? p + n : p, &pSet->fData);
+  n += tPutDataFile(p ? p + n : p, pSet->pDataF);
-  n += tPutLastFile(p ? p + n : p, &pSet->fLast);
+  n += tPutLastFile(p ? p + n : p, pSet->pLastF);
-  n += tPutSmaFile(p ? p + n : p, &pSet->fSma);
+  n += tPutSmaFile(p ? p + n : p, pSet->pSmaF);
  return n;
 }
@@ -266,20 +200,18 @@ int32_t tGetDFileSet(uint8_t *p, SDFileSet *pSet) {
  n += tGetI32v(p + n, &pSet->diskId.level);
  n += tGetI32v(p + n, &pSet->diskId.id);
  n += tGetI32v(p + n, &pSet->fid);
-  n += tGetHeadFile(p + n, &pSet->fHead);
+  n += tGetHeadFile(p + n, pSet->pHeadF);
-  n += tGetDataFile(p + n, &pSet->fData);
+  n += tGetDataFile(p + n, pSet->pDataF);
-  n += tGetLastFile(p + n, &pSet->fLast);
+  n += tGetLastFile(p + n, pSet->pLastF);
-  n += tGetSmaFile(p + n, &pSet->fSma);
+  n += tGetSmaFile(p + n, pSet->pSmaF);
  return n;
 }
 // SDelFile ===============================================
 void tsdbDelFileName(STsdb *pTsdb, SDelFile *pFile, char fname[]) {
-  STfs *pTfs = pTsdb->pVnode->pTfs;
+  snprintf(fname, TSDB_FILENAME_LEN - 1, "%s%s%s%sv%dver%" PRId64 "%s", tfsGetPrimaryPath(pTsdb->pVnode->pTfs),
+           TD_DIRSEP, pTsdb->path, TD_DIRSEP, TD_VID(pTsdb->pVnode), pFile->commitID, ".del");
-  snprintf(fname, TSDB_FILENAME_LEN - 1, "%s%s%s%sv%dver%" PRId64 "%s", tfsGetPrimaryPath(pTfs), TD_DIRSEP, pTsdb->path,
-           TD_DIRSEP, TD_VID(pTsdb->pVnode), pFile->commitID, ".del");
 }
 int32_t tPutDelFile(uint8_t *p, SDelFile *pDelFile) {

--- a/source/dnode/vnode/src/tsdb/tsdbMemTable.c
+++ b/source/dnode/vnode/src/tsdb/tsdbMemTable.c
@@ -93,7 +93,11 @@ static int32_t tbDataPCmprFn(const void *p1, const void *p2) {
 }
 void tsdbGetTbDataFromMemTable(SMemTable *pMemTable, tb_uid_t suid, tb_uid_t uid, STbData **ppTbData) {
  STbData *pTbData = &(STbData){.suid = suid, .uid = uid};
-  void    *p = taosArraySearch(pMemTable->aTbData, &pTbData, tbDataPCmprFn, TD_EQ);
+  taosRLockLatch(&pMemTable->latch);
+  void *p = taosArraySearch(pMemTable->aTbData, &pTbData, tbDataPCmprFn, TD_EQ);
+  taosRUnLockLatch(&pMemTable->latch);
  *ppTbData = p ? *(STbData **)p : NULL;
 }
@@ -363,10 +367,13 @@ static int32_t tsdbGetOrCreateTbData(SMemTable *pMemTable, tb_uid_t suid, tb_uid
  void *p;
  if (idx < 0) {
-    p = taosArrayPush(pMemTable->aTbData, &pTbData);
+    idx = taosArrayGetSize(pMemTable->aTbData);
-  } else {
-    p = taosArrayInsert(pMemTable->aTbData, idx, &pTbData);
  }
+  taosWLockLatch(&pMemTable->latch);
+  p = taosArrayInsert(pMemTable->aTbData, idx, &pTbData);
+  taosWUnLockLatch(&pMemTable->latch);
  if (p == NULL) {
    code = TSDB_CODE_OUT_OF_MEMORY;
    goto _err;
@@ -605,46 +612,3 @@ void tsdbUnrefMemTable(SMemTable *pMemTable) {
    tsdbMemTableDestroy(pMemTable);
  }
 }
-int32_t tsdbTakeMemSnapshot(STsdb *pTsdb, SMemTable **ppMem, SMemTable **ppIMem) {
-  int32_t code = 0;
-  // lock
-  code = taosThreadRwlockRdlock(&pTsdb->rwLock);
-  if (code) {
-    code = TAOS_SYSTEM_ERROR(code);
-    goto _exit;
-  }
-  // take snapshot
-  *ppMem = pTsdb->mem;
-  *ppIMem = pTsdb->imem;
-  if (*ppMem) {
-    tsdbRefMemTable(*ppMem);
-  }
-  if (*ppIMem) {
-    tsdbRefMemTable(*ppIMem);
-  }
-  // unlock
-  code = taosThreadRwlockUnlock(&pTsdb->rwLock);
-  if (code) {
-    code = TAOS_SYSTEM_ERROR(code);
-    goto _exit;
-  }
-_exit:
-  return code;
-}
-void tsdbUntakeMemSnapshot(STsdb *pTsdb, SMemTable *pMem, SMemTable *pIMem) {
-  if (pMem) {
-    tsdbUnrefMemTable(pMem);
-  }
-  if (pIMem) {
-    tsdbUnrefMemTable(pIMem);
-  }
-}
\ No newline at end of file
--- a/source/dnode/vnode/src/tsdb/tsdbOpen.c
+++ b/source/dnode/vnode/src/tsdb/tsdbOpen.c
@@ -66,7 +66,7 @@ int tsdbOpen(SVnode *pVnode, STsdb **ppTsdb, const char *dir, STsdbKeepCfg *pKee
  tfsMkdir(pVnode->pTfs, pTsdb->path);
  // open tsdb
-  if (tsdbFSOpen(pTsdb, &pTsdb->pFS) < 0) {
+  if (tsdbFSOpen(pTsdb) < 0) {
    goto _err;
  }
@@ -88,7 +88,7 @@ _err:
 int tsdbClose(STsdb **pTsdb) {
  if (*pTsdb) {
    taosThreadRwlockDestroy(&(*pTsdb)->rwLock);
-    tsdbFSClose((*pTsdb)->pFS);
+    tsdbFSClose(*pTsdb);
    tsdbCloseCache((*pTsdb)->lruCache);
    taosMemoryFreeClear(*pTsdb);
  }

--- a/source/dnode/vnode/src/tsdb/tsdbRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbRead.c
@@ -118,8 +118,7 @@ struct STsdbReader {
  char*              idStr;  // query info handle, for debug purpose
  int32_t            type;   // query type: 1. retrieve all data blocks, 2. retrieve direct prev|next rows
  SBlockLoadSuppInfo suppInfo;
-  SMemTable*         pMem;
+  STsdbReadSnap*     pReadSnap;
-  SMemTable*         pIMem;
  SIOCostSummary cost;
  STSchema*      pSchema;
@@ -275,20 +274,18 @@ static void limitOutputBufferSize(const SQueryTableDataCond* pCond, int32_t* cap
 }
 // init file iterator
-static int32_t initFilesetIterator(SFilesetIter* pIter, const STsdbFSState* pFState, int32_t order, const char* idstr) {
+static int32_t initFilesetIterator(SFilesetIter* pIter, SArray* aDFileSet, int32_t order, const char* idstr) {
-  size_t numOfFileset = taosArrayGetSize(pFState->aDFileSet);
+  size_t numOfFileset = taosArrayGetSize(aDFileSet);
  pIter->index = ASCENDING_TRAVERSE(order) ? -1 : numOfFileset;
  pIter->order = order;
-  pIter->pFileList = taosArrayDup(pFState->aDFileSet);
+  pIter->pFileList = aDFileSet;
  pIter->numOfFiles = numOfFileset;
  tsdbDebug("init fileset iterator, total files:%d %s", pIter->numOfFiles, idstr);
  return TSDB_CODE_SUCCESS;
 }
-static void cleanupFilesetIterator(SFilesetIter* pIter) { taosArrayDestroy(pIter->pFileList); }
 static bool filesetIteratorNext(SFilesetIter* pIter, STsdbReader* pReader) {
  bool    asc = ASCENDING_TRAVERSE(pIter->order);
  int32_t step = asc ? 1 : -1;
@@ -788,11 +785,11 @@ static int32_t copyBlockDataToSDataBlock(STsdbReader* pReader, STableBlockScanIn
        doCopyColVal(pColData, rowIndex++, i, &cv, pSupInfo);
      }
      colIndex += 1;
+      ASSERT(rowIndex == remain);
    } else {  // the specified column does not exist in file block, fill with null data
      colDataAppendNNULL(pColData, 0, remain);
    }
-    ASSERT(rowIndex == remain);
    i += 1;
  }
@@ -1881,8 +1878,8 @@ static int32_t initMemDataIterator(STableBlockScanInfo* pBlockScanInfo, STsdbRea
  int32_t backward = (!ASCENDING_TRAVERSE(pReader->order));
  STbData* d = NULL;
-  if (pReader->pMem != NULL) {
+  if (pReader->pReadSnap->pMem != NULL) {
-    tsdbGetTbDataFromMemTable(pReader->pMem, pReader->suid, pBlockScanInfo->uid, &d);
+    tsdbGetTbDataFromMemTable(pReader->pReadSnap->pMem, pReader->suid, pBlockScanInfo->uid, &d);
    if (d != NULL) {
      code = tsdbTbDataIterCreate(d, &startKey, backward, &pBlockScanInfo->iter.iter);
      if (code == TSDB_CODE_SUCCESS) {
@@ -1902,8 +1899,8 @@ static int32_t initMemDataIterator(STableBlockScanInfo* pBlockScanInfo, STsdbRea
  }
  STbData* di = NULL;
-  if (pReader->pIMem != NULL) {
+  if (pReader->pReadSnap->pIMem != NULL) {
-    tsdbGetTbDataFromMemTable(pReader->pIMem, pReader->suid, pBlockScanInfo->uid, &di);
+    tsdbGetTbDataFromMemTable(pReader->pReadSnap->pIMem, pReader->suid, pBlockScanInfo->uid, &di);
    if (di != NULL) {
      code = tsdbTbDataIterCreate(di, &startKey, backward, &pBlockScanInfo->iiter.iter);
      if (code == TSDB_CODE_SUCCESS) {
@@ -1939,21 +1936,24 @@ int32_t initDelSkylineIterator(STableBlockScanInfo* pBlockScanInfo, STsdbReader*
  SArray* pDelData = taosArrayInit(4, sizeof(SDelData));
-  SDelFile* pDelFile = tsdbFSStateGetDelFile(pTsdb->pFS->cState);
+  SDelFile* pDelFile = pReader->pReadSnap->fs.pDelFile;
  if (pDelFile) {
    SDelFReader* pDelFReader = NULL;
    code = tsdbDelFReaderOpen(&pDelFReader, pDelFile, pTsdb, NULL);
-    if (code) {
+    if (code != TSDB_CODE_SUCCESS) {
      goto _err;
    }
    SArray* aDelIdx = taosArrayInit(4, sizeof(SDelIdx));
    if (aDelIdx == NULL) {
+      tsdbDelFReaderClose(&pDelFReader);
      goto _err;
    }
    code = tsdbReadDelIdx(pDelFReader, aDelIdx, NULL);
-    if (code) {
+    if (code != TSDB_CODE_SUCCESS) {
+      taosArrayDestroy(aDelIdx);
+      tsdbDelFReaderClose(&pDelFReader);
      goto _err;
    }
@@ -1962,9 +1962,13 @@ int32_t initDelSkylineIterator(STableBlockScanInfo* pBlockScanInfo, STsdbReader*
    if (pIdx != NULL) {
      code = tsdbReadDelData(pDelFReader, pIdx, pDelData, NULL);
-      if (code != TSDB_CODE_SUCCESS) {
+    }
-        goto _err;
-      }
+    taosArrayDestroy(aDelIdx);
+    tsdbDelFReaderClose(&pDelFReader);
+    if (code != TSDB_CODE_SUCCESS) {
+      goto _err;
    }
  }
@@ -2261,10 +2265,6 @@ static STsdb* getTsdbByRetentions(SVnode* pVnode, TSKEY winSKey, SRetention* ret
 SVersionRange getQueryVerRange(SVnode* pVnode, SQueryTableDataCond* pCond, int8_t level) {
  int64_t startVer = (pCond->startVersion == -1) ? 0 : pCond->startVersion;
-  if (VND_IS_RSMA(pVnode)) {
-    return (SVersionRange){.minVer = startVer, .maxVer = tdRSmaGetMaxSubmitVer(pVnode->pSma, level)};
-  }
  int64_t endVer = 0;
  if (pCond->endVersion ==
      -1) {  // user not specified end version, set current maximum version of vnode as the endVersion
@@ -2532,8 +2532,7 @@ static int32_t checkForNeighborFileBlock(STsdbReader* pReader, STableBlockScanIn
    pDumpInfo->rowIndex =
        doMergeRowsInFileBlockImpl(pBlockData, pDumpInfo->rowIndex, key, pMerger, &pReader->verRange, step);
+    if (pDumpInfo->rowIndex >= pDumpInfo->totalRows) {
-    if (pDumpInfo->rowIndex >= pBlock->nRow) {
      *state = CHECK_FILEBLOCK_CONT;
    }
  }
@@ -2830,8 +2829,10 @@ int32_t tsdbReaderOpen(SVnode* pVnode, SQueryTableDataCond* pCond, SArray* pTabl
  SDataBlockIter* pBlockIter = &pReader->status.blockIter;
-  STsdbFSState* pFState = pReader->pTsdb->pFS->cState;
+  code = tsdbTakeReadSnap(pReader->pTsdb, &pReader->pReadSnap);
-  initFilesetIterator(&pReader->status.fileIter, pFState, pReader->order, pReader->idStr);
+  if (code) goto _err;
+  initFilesetIterator(&pReader->status.fileIter, (*ppReader)->pReadSnap->fs.aDFileSet, pReader->order, pReader->idStr);
  resetDataBlockIterator(&pReader->status.blockIter, pReader->order);
  // no data in files, let's try buffer in memory
@@ -2844,8 +2845,6 @@ int32_t tsdbReaderOpen(SVnode* pVnode, SQueryTableDataCond* pCond, SArray* pTabl
    }
  }
-  tsdbTakeMemSnapshot(pReader->pTsdb, &pReader->pMem, &pReader->pIMem);
  tsdbDebug("%p total numOfTable:%d in this query %s", pReader, numOfTables, pReader->idStr);
  return code;
@@ -2861,7 +2860,7 @@ void tsdbReaderClose(STsdbReader* pReader) {
  SBlockLoadSuppInfo* pSupInfo = &pReader->suppInfo;
-  tsdbUntakeMemSnapshot(pReader->pTsdb, pReader->pMem, pReader->pIMem);
+  tsdbUntakeReadSnap(pReader->pTsdb, pReader->pReadSnap);
  taosMemoryFreeClear(pSupInfo->plist);
  taosMemoryFree(pSupInfo->colIds);
@@ -2874,7 +2873,6 @@ void tsdbReaderClose(STsdbReader* pReader) {
  }
  taosMemoryFree(pSupInfo->buildBuf);
-  cleanupFilesetIterator(&pReader->status.fileIter);
  cleanupDataBlockIterator(&pReader->status.blockIter);
  destroyBlockScanInfo(pReader->status.pTableMap);
  blockDataDestroy(pReader->pResBlock);
@@ -3081,8 +3079,7 @@ int32_t tsdbReaderReset(STsdbReader* pReader, SQueryTableDataCond* pCond) {
  tsdbDataFReaderClose(&pReader->pFileReader);
-  STsdbFSState* pFState = pReader->pTsdb->pFS->cState;
+  initFilesetIterator(&pReader->status.fileIter, pReader->pReadSnap->fs.aDFileSet, pReader->order, pReader->idStr);
-  initFilesetIterator(&pReader->status.fileIter, pFState, pReader->order, pReader->idStr);
  resetDataBlockIterator(&pReader->status.blockIter, pReader->order);
  resetDataBlockScanInfo(pReader->status.pTableMap);
@@ -3244,3 +3241,68 @@ int32_t tsdbGetTableSchema(SVnode* pVnode, int64_t uid, STSchema** pSchema, int6
  return TSDB_CODE_SUCCESS;
 }
+int32_t tsdbTakeReadSnap(STsdb* pTsdb, STsdbReadSnap** ppSnap) {
+  int32_t code = 0;
+  // alloc
+  *ppSnap = (STsdbReadSnap*)taosMemoryCalloc(1, sizeof(STsdbReadSnap));
+  if (*ppSnap == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _exit;
+  }
+  // lock
+  code = taosThreadRwlockRdlock(&pTsdb->rwLock);
+  if (code) {
+    code = TAOS_SYSTEM_ERROR(code);
+    goto _exit;
+  }
+  // take snapshot
+  (*ppSnap)->pMem = pTsdb->mem;
+  (*ppSnap)->pIMem = pTsdb->imem;
+  if ((*ppSnap)->pMem) {
+    tsdbRefMemTable((*ppSnap)->pMem);
+  }
+  if ((*ppSnap)->pIMem) {
+    tsdbRefMemTable((*ppSnap)->pIMem);
+  }
+  // fs
+  code = tsdbFSRef(pTsdb, &(*ppSnap)->fs);
+  if (code) {
+    taosThreadRwlockUnlock(&pTsdb->rwLock);
+    goto _exit;
+  }
+  // unlock
+  code = taosThreadRwlockUnlock(&pTsdb->rwLock);
+  if (code) {
+    code = TAOS_SYSTEM_ERROR(code);
+    goto _exit;
+  }
+  tsdbTrace("vgId:%d take read snapshot", TD_VID(pTsdb->pVnode));
+_exit:
+  return code;
+}
+void tsdbUntakeReadSnap(STsdb* pTsdb, STsdbReadSnap* pSnap) {
+  if (pSnap) {
+    if (pSnap->pMem) {
+      tsdbUnrefMemTable(pSnap->pMem);
+    }
+    if (pSnap->pIMem) {
+      tsdbUnrefMemTable(pSnap->pIMem);
+    }
+    tsdbFSUnref(pTsdb, &pSnap->fs);
+    taosMemoryFree(pSnap);
+  }
+  tsdbTrace("vgId:%d untake read snapshot", TD_VID(pTsdb->pVnode));
+}
--- a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c
+++ b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c
@@ -459,7 +459,7 @@ int32_t tsdbDataFReaderOpen(SDataFReader **ppReader, STsdb *pTsdb, SDFileSet *pS
  // open impl
  // head
-  tsdbDataFileName(pTsdb, pSet, TSDB_HEAD_FILE, fname);
+  tsdbHeadFileName(pTsdb, pSet->diskId, pSet->fid, pSet->pHeadF, fname);
  pReader->pHeadFD = taosOpenFile(fname, TD_FILE_READ);
  if (pReader->pHeadFD == NULL) {
    code = TAOS_SYSTEM_ERROR(errno);
@@ -467,7 +467,7 @@ int32_t tsdbDataFReaderOpen(SDataFReader **ppReader, STsdb *pTsdb, SDFileSet *pS
  }
  // data
-  tsdbDataFileName(pTsdb, pSet, TSDB_DATA_FILE, fname);
+  tsdbDataFileName(pTsdb, pSet->diskId, pSet->fid, pSet->pDataF, fname);
  pReader->pDataFD = taosOpenFile(fname, TD_FILE_READ);
  if (pReader->pDataFD == NULL) {
    code = TAOS_SYSTEM_ERROR(errno);
@@ -475,7 +475,7 @@ int32_t tsdbDataFReaderOpen(SDataFReader **ppReader, STsdb *pTsdb, SDFileSet *pS
  }
  // last
-  tsdbDataFileName(pTsdb, pSet, TSDB_LAST_FILE, fname);
+  tsdbLastFileName(pTsdb, pSet->diskId, pSet->fid, pSet->pLastF, fname);
  pReader->pLastFD = taosOpenFile(fname, TD_FILE_READ);
  if (pReader->pLastFD == NULL) {
    code = TAOS_SYSTEM_ERROR(errno);
@@ -483,7 +483,7 @@ int32_t tsdbDataFReaderOpen(SDataFReader **ppReader, STsdb *pTsdb, SDFileSet *pS
  }
  // sma
-  tsdbDataFileName(pTsdb, pSet, TSDB_SMA_FILE, fname);
+  tsdbSmaFileName(pTsdb, pSet->diskId, pSet->fid, pSet->pSmaF, fname);
  pReader->pSmaFD = taosOpenFile(fname, TD_FILE_READ);
  if (pReader->pSmaFD == NULL) {
    code = TAOS_SYSTEM_ERROR(errno);
@@ -536,8 +536,8 @@ _err:
 int32_t tsdbReadBlockIdx(SDataFReader *pReader, SArray *aBlockIdx, uint8_t **ppBuf) {
  int32_t   code = 0;
-  int64_t   offset = pReader->pSet->fHead.offset;
+  int64_t   offset = pReader->pSet->pHeadF->offset;
-  int64_t   size = pReader->pSet->fHead.size - offset;
+  int64_t   size = pReader->pSet->pHeadF->size - offset;
  uint8_t  *pBuf = NULL;
  int64_t   n;
  uint32_t  delimiter;
@@ -1211,17 +1211,6 @@ _err:
 }
 // SDataFWriter ====================================================
-struct SDataFWriter {
-  STsdb    *pTsdb;
-  SDFileSet wSet;
-  TdFilePtr pHeadFD;
-  TdFilePtr pDataFD;
-  TdFilePtr pLastFD;
-  TdFilePtr pSmaFD;
-};
-SDFileSet *tsdbDataFWriterGetWSet(SDataFWriter *pWriter) { return &pWriter->wSet; }
 int32_t tsdbDataFWriterOpen(SDataFWriter **ppWriter, STsdb *pTsdb, SDFileSet *pSet) {
  int32_t       code = 0;
  int32_t       flag;
@@ -1237,12 +1226,20 @@ int32_t tsdbDataFWriterOpen(SDataFWriter **ppWriter, STsdb *pTsdb, SDFileSet *pS
    goto _err;
  }
  pWriter->pTsdb = pTsdb;
-  pWriter->wSet = *pSet;
+  pWriter->wSet = (SDFileSet){.diskId = pSet->diskId,
-  pSet = &pWriter->wSet;
+                              .fid = pSet->fid,
+                              .pHeadF = &pWriter->fHead,
+                              .pDataF = &pWriter->fData,
+                              .pLastF = &pWriter->fLast,
+                              .pSmaF = &pWriter->fSma};
+  pWriter->fHead = *pSet->pHeadF;
+  pWriter->fData = *pSet->pDataF;
+  pWriter->fLast = *pSet->pLastF;
+  pWriter->fSma = *pSet->pSmaF;
  // head
  flag = TD_FILE_WRITE | TD_FILE_CREATE | TD_FILE_TRUNC;
-  tsdbDataFileName(pTsdb, pSet, TSDB_HEAD_FILE, fname);
+  tsdbHeadFileName(pTsdb, pWriter->wSet.diskId, pWriter->wSet.fid, &pWriter->fHead, fname);
  pWriter->pHeadFD = taosOpenFile(fname, flag);
  if (pWriter->pHeadFD == NULL) {
    code = TAOS_SYSTEM_ERROR(errno);
@@ -1257,28 +1254,28 @@ int32_t tsdbDataFWriterOpen(SDataFWriter **ppWriter, STsdb *pTsdb, SDFileSet *pS
  ASSERT(n == TSDB_FHDR_SIZE);
-  pSet->fHead.size += TSDB_FHDR_SIZE;
+  pWriter->fHead.size += TSDB_FHDR_SIZE;
  // data
-  if (pSet->fData.size == 0) {
+  if (pWriter->fData.size == 0) {
    flag = TD_FILE_WRITE | TD_FILE_CREATE | TD_FILE_TRUNC;
  } else {
    flag = TD_FILE_WRITE;
  }
-  tsdbDataFileName(pTsdb, pSet, TSDB_DATA_FILE, fname);
+  tsdbDataFileName(pTsdb, pWriter->wSet.diskId, pWriter->wSet.fid, &pWriter->fData, fname);
  pWriter->pDataFD = taosOpenFile(fname, flag);
  if (pWriter->pDataFD == NULL) {
    code = TAOS_SYSTEM_ERROR(errno);
    goto _err;
  }
-  if (pSet->fData.size == 0) {
+  if (pWriter->fData.size == 0) {
    n = taosWriteFile(pWriter->pDataFD, hdr, TSDB_FHDR_SIZE);
    if (n < 0) {
      code = TAOS_SYSTEM_ERROR(errno);
      goto _err;
    }
-    pSet->fData.size += TSDB_FHDR_SIZE;
+    pWriter->fData.size += TSDB_FHDR_SIZE;
  } else {
    n = taosLSeekFile(pWriter->pDataFD, 0, SEEK_END);
    if (n < 0) {
@@ -1286,29 +1283,29 @@ int32_t tsdbDataFWriterOpen(SDataFWriter **ppWriter, STsdb *pTsdb, SDFileSet *pS
      goto _err;
    }
-    ASSERT(n == pSet->fData.size);
+    ASSERT(n == pWriter->fData.size);
  }
  // last
-  if (pSet->fLast.size == 0) {
+  if (pWriter->fLast.size == 0) {
    flag = TD_FILE_WRITE | TD_FILE_CREATE | TD_FILE_TRUNC;
  } else {
    flag = TD_FILE_WRITE;
  }
-  tsdbDataFileName(pTsdb, pSet, TSDB_LAST_FILE, fname);
+  tsdbLastFileName(pTsdb, pWriter->wSet.diskId, pWriter->wSet.fid, &pWriter->fLast, fname);
  pWriter->pLastFD = taosOpenFile(fname, flag);
  if (pWriter->pLastFD == NULL) {
    code = TAOS_SYSTEM_ERROR(errno);
    goto _err;
  }
-  if (pSet->fLast.size == 0) {
+  if (pWriter->fLast.size == 0) {
    n = taosWriteFile(pWriter->pLastFD, hdr, TSDB_FHDR_SIZE);
    if (n < 0) {
      code = TAOS_SYSTEM_ERROR(errno);
      goto _err;
    }
-    pSet->fLast.size += TSDB_FHDR_SIZE;
+    pWriter->fLast.size += TSDB_FHDR_SIZE;
  } else {
    n = taosLSeekFile(pWriter->pLastFD, 0, SEEK_END);
    if (n < 0) {
@@ -1316,29 +1313,29 @@ int32_t tsdbDataFWriterOpen(SDataFWriter **ppWriter, STsdb *pTsdb, SDFileSet *pS
      goto _err;
    }
-    ASSERT(n == pSet->fLast.size);
+    ASSERT(n == pWriter->fLast.size);
  }
  // sma
-  if (pSet->fSma.size == 0) {
+  if (pWriter->fSma.size == 0) {
    flag = TD_FILE_WRITE | TD_FILE_CREATE | TD_FILE_TRUNC;
  } else {
    flag = TD_FILE_WRITE;
  }
-  tsdbDataFileName(pTsdb, pSet, TSDB_SMA_FILE, fname);
+  tsdbSmaFileName(pTsdb, pWriter->wSet.diskId, pWriter->wSet.fid, &pWriter->fSma, fname);
  pWriter->pSmaFD = taosOpenFile(fname, flag);
  if (pWriter->pSmaFD == NULL) {
    code = TAOS_SYSTEM_ERROR(errno);
    goto _err;
  }
-  if (pSet->fSma.size == 0) {
+  if (pWriter->fSma.size == 0) {
    n = taosWriteFile(pWriter->pSmaFD, hdr, TSDB_FHDR_SIZE);
    if (n < 0) {
      code = TAOS_SYSTEM_ERROR(errno);
      goto _err;
    }
-    pSet->fSma.size += TSDB_FHDR_SIZE;
+    pWriter->fSma.size += TSDB_FHDR_SIZE;
  } else {
    n = taosLSeekFile(pWriter->pSmaFD, 0, SEEK_END);
    if (n < 0) {
@@ -1346,7 +1343,7 @@ int32_t tsdbDataFWriterOpen(SDataFWriter **ppWriter, STsdb *pTsdb, SDFileSet *pS
      goto _err;
    }
-    ASSERT(n == pSet->fSma.size);
+    ASSERT(n == pWriter->fSma.size);
  }
  *ppWriter = pWriter;
@@ -1418,22 +1415,76 @@ _err:
 int32_t tsdbUpdateDFileSetHeader(SDataFWriter *pWriter) {
  int32_t code = 0;
+  int64_t n;
+  char    hdr[TSDB_FHDR_SIZE];
  // head ==============
-  code = tsdbUpdateDFileHdr(pWriter->pHeadFD, &pWriter->wSet, TSDB_HEAD_FILE);
+  memset(hdr, 0, TSDB_FHDR_SIZE);
-  if (code) goto _err;
+  tPutHeadFile(hdr, &pWriter->fHead);
+  taosCalcChecksumAppend(0, hdr, TSDB_FHDR_SIZE);
+  n = taosLSeekFile(pWriter->pHeadFD, 0, SEEK_SET);
+  if (n < 0) {
+    code = TAOS_SYSTEM_ERROR(errno);
+    goto _err;
+  }
+  n = taosWriteFile(pWriter->pHeadFD, hdr, TSDB_FHDR_SIZE);
+  if (n < 0) {
+    code = TAOS_SYSTEM_ERROR(errno);
+    goto _err;
+  }
  // data ==============
-  code = tsdbUpdateDFileHdr(pWriter->pHeadFD, &pWriter->wSet, TSDB_DATA_FILE);
+  memset(hdr, 0, TSDB_FHDR_SIZE);
-  if (code) goto _err;
+  tPutDataFile(hdr, &pWriter->fData);
+  taosCalcChecksumAppend(0, hdr, TSDB_FHDR_SIZE);
+  n = taosLSeekFile(pWriter->pDataFD, 0, SEEK_SET);
+  if (n < 0) {
+    code = TAOS_SYSTEM_ERROR(errno);
+    goto _err;
+  }
+  n = taosWriteFile(pWriter->pDataFD, hdr, TSDB_FHDR_SIZE);
+  if (n < 0) {
+    code = TAOS_SYSTEM_ERROR(errno);
+    goto _err;
+  }
  // last ==============
-  code = tsdbUpdateDFileHdr(pWriter->pHeadFD, &pWriter->wSet, TSDB_LAST_FILE);
+  memset(hdr, 0, TSDB_FHDR_SIZE);
-  if (code) goto _err;
+  tPutLastFile(hdr, &pWriter->fLast);
+  taosCalcChecksumAppend(0, hdr, TSDB_FHDR_SIZE);
+  n = taosLSeekFile(pWriter->pLastFD, 0, SEEK_SET);
+  if (n < 0) {
+    code = TAOS_SYSTEM_ERROR(errno);
+    goto _err;
+  }
+  n = taosWriteFile(pWriter->pLastFD, hdr, TSDB_FHDR_SIZE);
+  if (n < 0) {
+    code = TAOS_SYSTEM_ERROR(errno);
+    goto _err;
+  }
  // sma ==============
-  code = tsdbUpdateDFileHdr(pWriter->pHeadFD, &pWriter->wSet, TSDB_SMA_FILE);
+  memset(hdr, 0, TSDB_FHDR_SIZE);
-  if (code) goto _err;
+  tPutSmaFile(hdr, &pWriter->fSma);
+  taosCalcChecksumAppend(0, hdr, TSDB_FHDR_SIZE);
+  n = taosLSeekFile(pWriter->pSmaFD, 0, SEEK_SET);
+  if (n < 0) {
+    code = TAOS_SYSTEM_ERROR(errno);
+    goto _err;
+  }
+  n = taosWriteFile(pWriter->pSmaFD, hdr, TSDB_FHDR_SIZE);
+  if (n < 0) {
+    code = TAOS_SYSTEM_ERROR(errno);
+    goto _err;
+  }
  return code;
@@ -1444,7 +1495,7 @@ _err:
 int32_t tsdbWriteBlockIdx(SDataFWriter *pWriter, SArray *aBlockIdx, uint8_t **ppBuf) {
  int32_t    code = 0;
-  SHeadFile *pHeadFile = &pWriter->wSet.fHead;
+  SHeadFile *pHeadFile = &pWriter->fHead;
  uint8_t   *pBuf = NULL;
  int64_t    size;
  int64_t    n;
@@ -1494,7 +1545,7 @@ _err:
 int32_t tsdbWriteBlock(SDataFWriter *pWriter, SMapData *mBlock, uint8_t **ppBuf, SBlockIdx *pBlockIdx) {
  int32_t       code = 0;
-  SHeadFile    *pHeadFile = &pWriter->wSet.fHead;
+  SHeadFile    *pHeadFile = &pWriter->fHead;
  SBlockDataHdr hdr = {.delimiter = TSDB_FILE_DLMT, .suid = pBlockIdx->suid, .uid = pBlockIdx->uid};
  uint8_t      *pBuf = NULL;
  int64_t       size;
@@ -1831,9 +1882,9 @@ int32_t tsdbWriteBlockData(SDataFWriter *pWriter, SBlockData *pBlockData, uint8_
  pSubBlock->nRow = pBlockData->nRow;
  pSubBlock->cmprAlg = cmprAlg;
  if (pBlock->last) {
-    pSubBlock->offset = pWriter->wSet.fLast.size;
+    pSubBlock->offset = pWriter->fLast.size;
  } else {
-    pSubBlock->offset = pWriter->wSet.fData.size;
+    pSubBlock->offset = pWriter->fData.size;
  }
  // ======================= BLOCK DATA =======================
@@ -1881,9 +1932,9 @@ int32_t tsdbWriteBlockData(SDataFWriter *pWriter, SBlockData *pBlockData, uint8_
  pSubBlock->szBlock = pSubBlock->szBlockCol + sizeof(TSCKSUM) + nData;
  if (pBlock->last) {
-    pWriter->wSet.fLast.size += pSubBlock->szBlock;
+    pWriter->fLast.size += pSubBlock->szBlock;
  } else {
-    pWriter->wSet.fData.size += pSubBlock->szBlock;
+    pWriter->fData.size += pSubBlock->szBlock;
  }
  // ======================= BLOCK SMA =======================
@@ -1896,8 +1947,8 @@ int32_t tsdbWriteBlockData(SDataFWriter *pWriter, SBlockData *pBlockData, uint8_
  if (code) goto _err;
  if (pSubBlock->nSma > 0) {
-    pSubBlock->sOffset = pWriter->wSet.fSma.size;
+    pSubBlock->sOffset = pWriter->fSma.size;
-    pWriter->wSet.fSma.size += (sizeof(SColumnDataAgg) * pSubBlock->nSma + sizeof(TSCKSUM));
+    pWriter->fSma.size += (sizeof(SColumnDataAgg) * pSubBlock->nSma + sizeof(TSCKSUM));
  }
 _exit:
@@ -1924,8 +1975,8 @@ int32_t tsdbDFileSetCopy(STsdb *pTsdb, SDFileSet *pSetFrom, SDFileSet *pSetTo) {
  char      fNameTo[TSDB_FILENAME_LEN];
  // head
-  tsdbDataFileName(pTsdb, pSetFrom, TSDB_HEAD_FILE, fNameFrom);
+  tsdbHeadFileName(pTsdb, pSetFrom->diskId, pSetFrom->fid, pSetFrom->pHeadF, fNameFrom);
-  tsdbDataFileName(pTsdb, pSetTo, TSDB_HEAD_FILE, fNameTo);
+  tsdbHeadFileName(pTsdb, pSetTo->diskId, pSetTo->fid, pSetTo->pHeadF, fNameTo);
  pOutFD = taosOpenFile(fNameTo, TD_FILE_WRITE | TD_FILE_CREATE | TD_FILE_TRUNC);
  if (pOutFD == NULL) {
@@ -1939,7 +1990,7 @@ int32_t tsdbDFileSetCopy(STsdb *pTsdb, SDFileSet *pSetFrom, SDFileSet *pSetTo) {
    goto _err;
  }
-  n = taosFSendFile(pOutFD, PInFD, 0, pSetFrom->fHead.size);
+  n = taosFSendFile(pOutFD, PInFD, 0, pSetFrom->pHeadF->size);
  if (n < 0) {
    code = TAOS_SYSTEM_ERROR(errno);
    goto _err;
@@ -1948,8 +1999,8 @@ int32_t tsdbDFileSetCopy(STsdb *pTsdb, SDFileSet *pSetFrom, SDFileSet *pSetTo) {
  taosCloseFile(&PInFD);
  // data
-  tsdbDataFileName(pTsdb, pSetFrom, TSDB_DATA_FILE, fNameFrom);
+  tsdbDataFileName(pTsdb, pSetFrom->diskId, pSetFrom->fid, pSetFrom->pDataF, fNameFrom);
-  tsdbDataFileName(pTsdb, pSetTo, TSDB_DATA_FILE, fNameTo);
+  tsdbDataFileName(pTsdb, pSetTo->diskId, pSetTo->fid, pSetTo->pDataF, fNameTo);
  pOutFD = taosOpenFile(fNameTo, TD_FILE_WRITE | TD_FILE_CREATE | TD_FILE_TRUNC);
  if (pOutFD == NULL) {
@@ -1963,7 +2014,7 @@ int32_t tsdbDFileSetCopy(STsdb *pTsdb, SDFileSet *pSetFrom, SDFileSet *pSetTo) {
    goto _err;
  }
-  n = taosFSendFile(pOutFD, PInFD, 0, pSetFrom->fData.size);
+  n = taosFSendFile(pOutFD, PInFD, 0, pSetFrom->pDataF->size);
  if (n < 0) {
    code = TAOS_SYSTEM_ERROR(errno);
    goto _err;
@@ -1972,8 +2023,9 @@ int32_t tsdbDFileSetCopy(STsdb *pTsdb, SDFileSet *pSetFrom, SDFileSet *pSetTo) {
  taosCloseFile(&PInFD);
  // last
-  tsdbDataFileName(pTsdb, pSetFrom, TSDB_LAST_FILE, fNameFrom);
+  tsdbLastFileName(pTsdb, pSetFrom->diskId, pSetFrom->fid, pSetFrom->pLastF, fNameFrom);
-  tsdbDataFileName(pTsdb, pSetTo, TSDB_LAST_FILE, fNameTo);
+  tsdbLastFileName(pTsdb, pSetTo->diskId, pSetTo->fid, pSetTo->pLastF, fNameTo);
  pOutFD = taosOpenFile(fNameTo, TD_FILE_WRITE | TD_FILE_CREATE | TD_FILE_TRUNC);
  if (pOutFD == NULL) {
    code = TAOS_SYSTEM_ERROR(errno);
@@ -1986,7 +2038,7 @@ int32_t tsdbDFileSetCopy(STsdb *pTsdb, SDFileSet *pSetFrom, SDFileSet *pSetTo) {
    goto _err;
  }
-  n = taosFSendFile(pOutFD, PInFD, 0, pSetFrom->fLast.size);
+  n = taosFSendFile(pOutFD, PInFD, 0, pSetFrom->pLastF->size);
  if (n < 0) {
    code = TAOS_SYSTEM_ERROR(errno);
    goto _err;
@@ -1995,8 +2047,8 @@ int32_t tsdbDFileSetCopy(STsdb *pTsdb, SDFileSet *pSetFrom, SDFileSet *pSetTo) {
  taosCloseFile(&PInFD);
  // sma
-  tsdbDataFileName(pTsdb, pSetFrom, TSDB_SMA_FILE, fNameFrom);
+  tsdbSmaFileName(pTsdb, pSetFrom->diskId, pSetFrom->fid, pSetFrom->pSmaF, fNameFrom);
-  tsdbDataFileName(pTsdb, pSetTo, TSDB_SMA_FILE, fNameTo);
+  tsdbSmaFileName(pTsdb, pSetTo->diskId, pSetTo->fid, pSetTo->pSmaF, fNameTo);
  pOutFD = taosOpenFile(fNameTo, TD_FILE_WRITE | TD_FILE_CREATE | TD_FILE_TRUNC);
  if (pOutFD == NULL) {
@@ -2010,7 +2062,7 @@ int32_t tsdbDFileSetCopy(STsdb *pTsdb, SDFileSet *pSetFrom, SDFileSet *pSetTo) {
    goto _err;
  }
-  n = taosFSendFile(pOutFD, PInFD, 0, pSetFrom->fSma.size);
+  n = taosFSendFile(pOutFD, PInFD, 0, pSetFrom->pSmaF->size);
  if (n < 0) {
    code = TAOS_SYSTEM_ERROR(errno);
    goto _err;

--- a/source/dnode/vnode/src/tsdb/tsdbRetention.c
+++ b/source/dnode/vnode/src/tsdb/tsdbRetention.c
@@ -15,90 +15,99 @@
 #include "tsdb.h"
-static int32_t tsdbDoRetentionImpl(STsdb *pTsdb, int64_t now, int8_t try, int8_t *canDo) {
+static bool tsdbShouldDoRetention(STsdb *pTsdb, int64_t now) {
-  int32_t       code = 0;
+  for (int32_t iSet = 0; iSet < taosArrayGetSize(pTsdb->fs.aDFileSet); iSet++) {
-  STsdbFSState *pState;
+    SDFileSet *pSet = (SDFileSet *)taosArrayGet(pTsdb->fs.aDFileSet, iSet);
+    int32_t    expLevel = tsdbFidLevel(pSet->fid, &pTsdb->keepCfg, now);
-  if (try) {
-    pState = pTsdb->pFS->cState;
-    *canDo = 0;
-  } else {
-    pState = pTsdb->pFS->nState;
-  }
-  for (int32_t iSet = 0; iSet < taosArrayGetSize(pState->aDFileSet); iSet++) {
-    SDFileSet *pDFileSet = (SDFileSet *)taosArrayGet(pState->aDFileSet, iSet);
-    int32_t    expLevel = tsdbFidLevel(pDFileSet->fid, &pTsdb->keepCfg, now);
    SDiskID    did;
-    // check
+    if (expLevel == pSet->diskId.level) continue;
-    if (expLevel == pDFileSet->diskId.id) continue;
-    // delete or move
    if (expLevel < 0) {
-      if (try) {
+      return true;
-        *canDo = 1;
-      } else {
-        tsdbFSStateDeleteDFileSet(pState, pDFileSet->fid);
-        iSet--;
-      }
    } else {
-      // alloc
      if (tfsAllocDisk(pTsdb->pVnode->pTfs, expLevel, &did) < 0) {
-        code = terrno;
+        return false;
-        goto _exit;
      }
-      if (did.level == pDFileSet->diskId.level) continue;
+      if (did.level == pSet->diskId.level) continue;
-      if (try) {
+      return true;
-        *canDo = 1;
-      } else {
-        // copy the file to new disk
-        SDFileSet nDFileSet = *pDFileSet;
-        nDFileSet.diskId = did;
-        tfsMkdirRecurAt(pTsdb->pVnode->pTfs, pTsdb->path, did);
-        code = tsdbDFileSetCopy(pTsdb, pDFileSet, &nDFileSet);
-        if (code) goto _exit;
-        code = tsdbFSStateUpsertDFileSet(pState, &nDFileSet);
-        if (code) goto _exit;
-      }
    }
  }
-_exit:
+  return false;
-  return code;
 }
 int32_t tsdbDoRetention(STsdb *pTsdb, int64_t now) {
  int32_t code = 0;
-  int8_t  canDo;
-  // try
-  tsdbDoRetentionImpl(pTsdb, now, 1, &canDo);
-  if (!canDo) goto _exit;
-  // begin
+  if (!tsdbShouldDoRetention(pTsdb, now)) {
-  code = tsdbFSBegin(pTsdb->pFS);
+    return code;
-  if (code) goto _err;
+  }
  // do retention
-  code = tsdbDoRetentionImpl(pTsdb, now, 0, NULL);
+  STsdbFS fs;
+  code = tsdbFSCopy(pTsdb, &fs);
  if (code) goto _err;
-  // commit
+  for (int32_t iSet = 0; iSet < taosArrayGetSize(fs.aDFileSet); iSet++) {
-  code = tsdbFSCommit(pTsdb->pFS);
+    SDFileSet *pSet = (SDFileSet *)taosArrayGet(pTsdb->fs.aDFileSet, iSet);
+    int32_t    expLevel = tsdbFidLevel(pSet->fid, &pTsdb->keepCfg, now);
+    SDiskID    did;
+    if (expLevel < 0) {
+      taosMemoryFree(pSet->pHeadF);
+      taosMemoryFree(pSet->pDataF);
+      taosMemoryFree(pSet->pLastF);
+      taosMemoryFree(pSet->pSmaF);
+      taosArrayRemove(fs.aDFileSet, iSet);
+      iSet--;
+    } else {
+      if (tfsAllocDisk(pTsdb->pVnode->pTfs, expLevel, &did) < 0) {
+        code = terrno;
+        goto _exit;
+      }
+      if (did.level == pSet->diskId.level) continue;
+      // copy file to new disk (todo)
+      SDFileSet fSet = *pSet;
+      fSet.diskId = did;
+      code = tsdbDFileSetCopy(pTsdb, pSet, &fSet);
+      if (code) goto _err;
+      code = tsdbFSUpsertFSet(&fs, &fSet);
+      if (code) goto _err;
+    }
+    /* code */
+  }
+  // do change fs
+  code = tsdbFSCommit1(pTsdb, &fs);
  if (code) goto _err;
+  taosThreadRwlockWrlock(&pTsdb->rwLock);
+  code = tsdbFSCommit2(pTsdb, &fs);
+  if (code) {
+    taosThreadRwlockUnlock(&pTsdb->rwLock);
+    goto _err;
+  }
+  taosThreadRwlockUnlock(&pTsdb->rwLock);
+  tsdbFSDestroy(&fs);
 _exit:
  return code;
 _err:
  tsdbError("vgId:%d tsdb do retention failed since %s", TD_VID(pTsdb->pVnode), tstrerror(code));
-  tsdbFSRollback(pTsdb->pFS);
+  ASSERT(0);
+  // tsdbFSRollback(pTsdb->pFS);
  return code;
 }
\ No newline at end of file
--- a/source/dnode/vnode/src/tsdb/tsdbSnapshot.c
+++ b/source/dnode/vnode/src/tsdb/tsdbSnapshot.c
@@ -20,6 +20,7 @@ struct STsdbSnapReader {
  STsdb*  pTsdb;
  int64_t sver;
  int64_t ever;
+  STsdbFS fs;
  // for data file
  int8_t        dataDone;
  int32_t       fid;
@@ -45,7 +46,8 @@ static int32_t tsdbSnapReadData(STsdbSnapReader* pReader, uint8_t** ppData) {
  while (true) {
    if (pReader->pDataFReader == NULL) {
-      SDFileSet* pSet = tsdbFSStateGetDFileSet(pTsdb->pFS->cState, pReader->fid, TD_GT);
+      SDFileSet* pSet =
+          taosArraySearch(pReader->fs.aDFileSet, &(SDFileSet){.fid = pReader->fid}, tDFileSetCmprFn, TD_GT);
      if (pSet == NULL) goto _exit;
@@ -159,7 +161,7 @@ _err:
 static int32_t tsdbSnapReadDel(STsdbSnapReader* pReader, uint8_t** ppData) {
  int32_t   code = 0;
  STsdb*    pTsdb = pReader->pTsdb;
-  SDelFile* pDelFile = pTsdb->pFS->cState->pDelFile;
+  SDelFile* pDelFile = pReader->fs.pDelFile;
  if (pReader->pDelFReader == NULL) {
    if (pDelFile == NULL) {
@@ -254,6 +256,24 @@ int32_t tsdbSnapReaderOpen(STsdb* pTsdb, int64_t sver, int64_t ever, STsdbSnapRe
  pReader->sver = sver;
  pReader->ever = ever;
+  code = taosThreadRwlockRdlock(&pTsdb->rwLock);
+  if (code) {
+    code = TAOS_SYSTEM_ERROR(code);
+    goto _err;
+  }
+  code = tsdbFSRef(pTsdb, &pReader->fs);
+  if (code) {
+    taosThreadRwlockUnlock(&pTsdb->rwLock);
+    goto _err;
+  }
+  code = taosThreadRwlockUnlock(&pTsdb->rwLock);
+  if (code) {
+    code = TAOS_SYSTEM_ERROR(code);
+    goto _err;
+  }
  pReader->fid = INT32_MIN;
  pReader->aBlockIdx = taosArrayInit(0, sizeof(SBlockIdx));
  if (pReader->aBlockIdx == NULL) {
@@ -305,6 +325,8 @@ int32_t tsdbSnapReaderClose(STsdbSnapReader** ppReader) {
  taosArrayDestroy(pReader->aDelIdx);
  taosArrayDestroy(pReader->aDelData);
+  tsdbFSUnref(pReader->pTsdb, &pReader->fs);
  tsdbInfo("vgId:%d vnode snapshot tsdb reader closed", TD_VID(pReader->pTsdb->pVnode));
  taosMemoryFree(pReader);
@@ -358,6 +380,7 @@ struct STsdbSnapWriter {
  STsdb*  pTsdb;
  int64_t sver;
  int64_t ever;
+  STsdbFS fs;
  // config
  int32_t minutes;
@@ -798,7 +821,7 @@ static int32_t tsdbSnapWriteDataEnd(STsdbSnapWriter* pWriter) {
  code = tsdbWriteBlockIdx(pWriter->pDataFWriter, pWriter->aBlockIdxW, NULL);
  if (code) goto _err;
-  code = tsdbFSStateUpsertDFileSet(pTsdb->pFS->nState, tsdbDataFWriterGetWSet(pWriter->pDataFWriter));
+  code = tsdbFSUpsertFSet(&pWriter->fs, &pWriter->pDataFWriter->wSet);
  if (code) goto _err;
  code = tsdbDataFWriterClose(&pWriter->pDataFWriter, 1);
@@ -843,7 +866,7 @@ static int32_t tsdbSnapWriteData(STsdbSnapWriter* pWriter, uint8_t* pData, uint3
    pWriter->fid = fid;
    // read
-    SDFileSet* pSet = tsdbFSStateGetDFileSet(pTsdb->pFS->nState, fid, TD_EQ);
+    SDFileSet* pSet = taosArraySearch(pWriter->fs.aDFileSet, &(SDFileSet){.fid = fid}, tDFileSetCmprFn, TD_EQ);
    if (pSet) {
      code = tsdbDataFReaderOpen(&pWriter->pDataFReader, pTsdb, pSet);
      if (code) goto _err;
@@ -863,22 +886,26 @@ static int32_t tsdbSnapWriteData(STsdbSnapWriter* pWriter, uint8_t* pData, uint3
    tBlockDataReset(&pWriter->bDataR);
    // write
-    SDFileSet wSet;
+    SHeadFile fHead;
+    SDataFile fData;
+    SLastFile fLast;
+    SSmaFile  fSma;
+    SDFileSet wSet = {.pHeadF = &fHead, .pDataF = &fData, .pLastF = &fLast, .pSmaF = &fSma};
    if (pSet) {
-      wSet = (SDFileSet){.diskId = pSet->diskId,
+      wSet.diskId = pSet->diskId;
-                         .fid = fid,
+      wSet.fid = fid;
-                         .fHead = {.commitID = pWriter->commitID, .offset = 0, .size = 0},
+      fHead = (SHeadFile){.commitID = pWriter->commitID, .offset = 0, .size = 0};
-                         .fData = pSet->fData,
+      fData = *pSet->pDataF;
-                         .fLast = {.commitID = pWriter->commitID, .size = 0},
+      fLast = (SLastFile){.commitID = pWriter->commitID, .size = 0};
-                         .fSma = pSet->fSma};
+      fSma = *pSet->pSmaF;
    } else {
-      wSet = (SDFileSet){.diskId = (SDiskID){.level = 0, .id = 0},
+      wSet.diskId = (SDiskID){.level = 0, .id = 0};
-                         .fid = fid,
+      wSet.fid = fid;
-                         .fHead = {.commitID = pWriter->commitID, .offset = 0, .size = 0},
+      fHead = (SHeadFile){.commitID = pWriter->commitID, .offset = 0, .size = 0};
-                         .fData = {.commitID = pWriter->commitID, .size = 0},
+      fData = (SDataFile){.commitID = pWriter->commitID, .size = 0};
-                         .fLast = {.commitID = pWriter->commitID, .size = 0},
+      fLast = (SLastFile){.commitID = pWriter->commitID, .size = 0};
-                         .fSma = {.commitID = pWriter->commitID, .size = 0}};
+      fSma = (SSmaFile){.commitID = pWriter->commitID, .size = 0};
    }
    code = tsdbDataFWriterOpen(&pWriter->pDataFWriter, pTsdb, &wSet);
@@ -907,7 +934,7 @@ static int32_t tsdbSnapWriteDel(STsdbSnapWriter* pWriter, uint8_t* pData, uint32
  STsdb*  pTsdb = pWriter->pTsdb;
  if (pWriter->pDelFWriter == NULL) {
-    SDelFile* pDelFile = tsdbFSStateGetDelFile(pTsdb->pFS->nState);
+    SDelFile* pDelFile = pWriter->fs.pDelFile;
    // reader
    if (pDelFile) {
@@ -1017,7 +1044,7 @@ static int32_t tsdbSnapWriteDelEnd(STsdbSnapWriter* pWriter) {
  code = tsdbUpdateDelFileHdr(pWriter->pDelFWriter);
  if (code) goto _err;
-  code = tsdbFSStateUpsertDelFile(pTsdb->pFS->nState, &pWriter->pDelFWriter->fDel);
+  code = tsdbFSUpsertDelFile(&pWriter->fs, &pWriter->pDelFWriter->fDel);
  if (code) goto _err;
  code = tsdbDelFWriterClose(&pWriter->pDelFWriter, 1);
@@ -1051,6 +1078,9 @@ int32_t tsdbSnapWriterOpen(STsdb* pTsdb, int64_t sver, int64_t ever, STsdbSnapWr
  pWriter->sver = sver;
  pWriter->ever = ever;
+  code = tsdbFSCopy(pTsdb, &pWriter->fs);
+  if (code) goto _err;
  // config
  pWriter->minutes = pTsdb->keepCfg.days;
  pWriter->precision = pTsdb->keepCfg.precision;
@@ -1096,9 +1126,6 @@ int32_t tsdbSnapWriterOpen(STsdb* pTsdb, int64_t sver, int64_t ever, STsdbSnapWr
    goto _err;
  }
-  code = tsdbFSBegin(pTsdb->pFS);
-  if (code) goto _err;
  *ppWriter = pWriter;
  return code;
@@ -1113,8 +1140,9 @@ int32_t tsdbSnapWriterClose(STsdbSnapWriter** ppWriter, int8_t rollback) {
  STsdbSnapWriter* pWriter = *ppWriter;
  if (rollback) {
-    code = tsdbFSRollback(pWriter->pTsdb->pFS);
+    ASSERT(0);
-    if (code) goto _err;
+    // code = tsdbFSRollback(pWriter->pTsdb->pFS);
+    // if (code) goto _err;
  } else {
    code = tsdbSnapWriteDataEnd(pWriter);
    if (code) goto _err;
@@ -1122,7 +1150,10 @@ int32_t tsdbSnapWriterClose(STsdbSnapWriter** ppWriter, int8_t rollback) {
    code = tsdbSnapWriteDelEnd(pWriter);
    if (code) goto _err;
-    code = tsdbFSCommit(pWriter->pTsdb->pFS);
+    code = tsdbFSCommit1(pWriter->pTsdb, &pWriter->fs);
+    if (code) goto _err;
+    code = tsdbFSCommit2(pWriter->pTsdb, &pWriter->fs);
    if (code) goto _err;
  }

--- a/source/dnode/vnode/src/vnd/vnodeCommit.c
+++ b/source/dnode/vnode/src/vnd/vnodeCommit.c
--- a/source/dnode/vnode/src/vnd/vnodeOpen.c
+++ b/source/dnode/vnode/src/vnd/vnodeOpen.c
--- a/source/dnode/vnode/src/vnd/vnodeSvr.c
+++ b/source/dnode/vnode/src/vnd/vnodeSvr.c
--- a/source/libs/executor/inc/executil.h
+++ b/source/libs/executor/inc/executil.h
--- a/source/libs/executor/inc/executorimpl.h
+++ b/source/libs/executor/inc/executorimpl.h
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
--- a/source/libs/executor/src/executor.c
+++ b/source/libs/executor/src/executor.c
--- a/source/libs/executor/src/executorMain.c
+++ b/source/libs/executor/src/executorMain.c
--- a/source/libs/executor/src/executorimpl.c
+++ b/source/libs/executor/src/executorimpl.c
--- a/source/libs/executor/src/groupoperator.c
+++ b/source/libs/executor/src/groupoperator.c
--- a/source/libs/executor/src/joinoperator.c
+++ b/source/libs/executor/src/joinoperator.c
--- a/source/libs/executor/src/scanoperator.c
+++ b/source/libs/executor/src/scanoperator.c
--- a/source/libs/executor/src/sortoperator.c
+++ b/source/libs/executor/src/sortoperator.c
--- a/source/libs/executor/src/tfill.c
+++ b/source/libs/executor/src/tfill.c
--- a/source/libs/executor/src/timewindowoperator.c
+++ b/source/libs/executor/src/timewindowoperator.c
--- a/source/libs/function/inc/functionMgtInt.h
+++ b/source/libs/function/inc/functionMgtInt.h
--- a/source/libs/function/src/builtins.c
+++ b/source/libs/function/src/builtins.c
--- a/source/libs/function/src/builtinsimpl.c
+++ b/source/libs/function/src/builtinsimpl.c
--- a/source/libs/function/src/functionMgt.c
+++ b/source/libs/function/src/functionMgt.c
--- a/source/libs/function/src/tudf.c
+++ b/source/libs/function/src/tudf.c
--- a/source/libs/function/src/udfd.c
+++ b/source/libs/function/src/udfd.c
--- a/source/libs/index/src/indexFilter.c
+++ b/source/libs/index/src/indexFilter.c
--- a/source/libs/nodes/src/nodesCloneFuncs.c
+++ b/source/libs/nodes/src/nodesCloneFuncs.c
--- a/source/libs/nodes/src/nodesCodeFuncs.c
+++ b/source/libs/nodes/src/nodesCodeFuncs.c
--- a/source/libs/parser/src/parInsert.c
+++ b/source/libs/parser/src/parInsert.c
--- a/source/libs/parser/src/parInsertData.c
+++ b/source/libs/parser/src/parInsertData.c
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
--- a/source/libs/parser/src/parser.c
+++ b/source/libs/parser/src/parser.c
--- a/source/libs/parser/test/parSelectTest.cpp
+++ b/source/libs/parser/test/parSelectTest.cpp
--- a/source/libs/planner/inc/planInt.h
+++ b/source/libs/planner/inc/planInt.h
--- a/source/libs/planner/src/planLogicCreater.c
+++ b/source/libs/planner/src/planLogicCreater.c
--- a/source/libs/planner/src/planOptimizer.c
+++ b/source/libs/planner/src/planOptimizer.c
--- a/source/libs/planner/src/planPhysiCreater.c
+++ b/source/libs/planner/src/planPhysiCreater.c
--- a/source/libs/planner/src/planSpliter.c
+++ b/source/libs/planner/src/planSpliter.c
--- a/source/libs/planner/src/planUtil.c
+++ b/source/libs/planner/src/planUtil.c
--- a/source/libs/planner/test/planBasicTest.cpp
+++ b/source/libs/planner/test/planBasicTest.cpp
--- a/source/libs/planner/test/planIntervalTest.cpp
+++ b/source/libs/planner/test/planIntervalTest.cpp
--- a/source/libs/planner/test/planPartByTest.cpp
+++ b/source/libs/planner/test/planPartByTest.cpp
--- a/source/libs/planner/test/planSubqueryTest.cpp
+++ b/source/libs/planner/test/planSubqueryTest.cpp
--- a/source/libs/scalar/CMakeLists.txt
+++ b/source/libs/scalar/CMakeLists.txt
--- a/source/libs/scalar/src/filter.c
+++ b/source/libs/scalar/src/filter.c
--- a/source/libs/scalar/src/sclfunc.c
+++ b/source/libs/scalar/src/sclfunc.c
--- a/source/libs/scalar/test/CMakeLists.txt
+++ b/source/libs/scalar/test/CMakeLists.txt
--- a/source/libs/scalar/test/filter/CMakeLists.txt
+++ b/source/libs/scalar/test/filter/CMakeLists.txt
--- a/source/libs/scalar/test/filter/filterTests.cpp
+++ b/source/libs/scalar/test/filter/filterTests.cpp
--- a/source/libs/stream/src/streamData.c
+++ b/source/libs/stream/src/streamData.c
--- a/source/libs/stream/src/streamDispatch.c
+++ b/source/libs/stream/src/streamDispatch.c
--- a/source/libs/stream/src/streamExec.c
+++ b/source/libs/stream/src/streamExec.c
--- a/source/libs/stream/src/streamUpdate.c
+++ b/source/libs/stream/src/streamUpdate.c
--- a/source/libs/sync/src/syncMain.c
+++ b/source/libs/sync/src/syncMain.c
--- a/source/libs/sync/src/syncRaftCfg.c
+++ b/source/libs/sync/src/syncRaftCfg.c
--- a/source/libs/sync/test/sh/a.sh
+++ b/source/libs/sync/test/sh/a.sh
--- a/source/libs/transport/inc/transComm.h
+++ b/source/libs/transport/inc/transComm.h
--- a/source/libs/transport/src/.transSvr.c.swo
+++ b/source/libs/transport/src/.transSvr.c.swo
--- a/source/libs/transport/src/transCli.c
+++ b/source/libs/transport/src/transCli.c
--- a/source/libs/transport/src/transComm.c
+++ b/source/libs/transport/src/transComm.c
--- a/source/libs/transport/src/transSvr.c
+++ b/source/libs/transport/src/transSvr.c
--- a/source/os/src/osSystem.c
+++ b/source/os/src/osSystem.c
--- a/source/util/src/tcompression.c
+++ b/source/util/src/tcompression.c
--- a/source/util/src/tconfig.c
+++ b/source/util/src/tconfig.c
--- a/source/util/src/terror.c
+++ b/source/util/src/terror.c
--- a/tests/pytest/crash_gen/crash_gen_main.py
+++ b/tests/pytest/crash_gen/crash_gen_main.py
--- a/tests/pytest/topic/topicQuery.py
+++ b/tests/pytest/topic/topicQuery.py
--- a/tests/pytest/util/common.py
+++ b/tests/pytest/util/common.py
--- a/tests/script/jenkins/basic.txt
+++ b/tests/script/jenkins/basic.txt
--- a/tests/script/jenkins/clusterCase.txt
+++ b/tests/script/jenkins/clusterCase.txt
--- a/tests/script/test.sh
+++ b/tests/script/test.sh
--- a/tests/script/tsim/dnode/offline_reason.sim
+++ b/tests/script/tsim/dnode/offline_reason.sim
--- a/tests/script/tsim/insert/basic2.sim
+++ b/tests/script/tsim/insert/basic2.sim
--- a/tests/script/tsim/insert/commit-merge0.sim
+++ b/tests/script/tsim/insert/commit-merge0.sim
--- a/tests/script/tsim/insert/update0.sim
+++ b/tests/script/tsim/insert/update0.sim
--- a/tests/script/tsim/insert/update1_sort_merge.sim
+++ b/tests/script/tsim/insert/update1_sort_merge.sim
--- a/tests/script/tsim/parser/auto_create_tb.sim
+++ b/tests/script/tsim/parser/auto_create_tb.sim
--- a/tests/script/tsim/parser/col_arithmetic_query.sim
+++ b/tests/script/tsim/parser/col_arithmetic_query.sim
--- a/tests/script/tsim/parser/columnValue_bigint.sim
+++ b/tests/script/tsim/parser/columnValue_bigint.sim
--- a/tests/script/tsim/parser/columnValue_bool.sim
+++ b/tests/script/tsim/parser/columnValue_bool.sim
--- a/tests/script/tsim/parser/columnValue_double.sim
+++ b/tests/script/tsim/parser/columnValue_double.sim
--- a/tests/script/tsim/parser/columnValue_float.sim
+++ b/tests/script/tsim/parser/columnValue_float.sim
--- a/tests/script/tsim/parser/columnValue_int.sim
+++ b/tests/script/tsim/parser/columnValue_int.sim
--- a/tests/script/tsim/parser/columnValue_smallint.sim
+++ b/tests/script/tsim/parser/columnValue_smallint.sim
--- a/tests/script/tsim/parser/columnValue_tinyint.sim
+++ b/tests/script/tsim/parser/columnValue_tinyint.sim
--- a/tests/script/tsim/parser/columnValue_unsign.sim
+++ b/tests/script/tsim/parser/columnValue_unsign.sim
--- a/tests/script/tsim/parser/fill.sim
+++ b/tests/script/tsim/parser/fill.sim
--- a/tests/script/tsim/parser/first_last_query.sim
+++ b/tests/script/tsim/parser/first_last_query.sim
--- a/tests/script/tsim/parser/function.sim
+++ b/tests/script/tsim/parser/function.sim
--- a/tests/script/tsim/parser/gendata.sh
+++ b/tests/script/tsim/parser/gendata.sh
--- a/tests/script/tsim/parser/groupby-basic.sim
+++ b/tests/script/tsim/parser/groupby-basic.sim
--- a/tests/script/tsim/parser/import_file.sim
+++ b/tests/script/tsim/parser/import_file.sim
--- a/tests/script/tsim/parser/interp_test.sim
+++ b/tests/script/tsim/parser/interp_test.sim
--- a/tests/script/tsim/parser/join.sim
+++ b/tests/script/tsim/parser/join.sim
--- a/tests/script/tsim/parser/join_manyblocks.sim
+++ b/tests/script/tsim/parser/join_manyblocks.sim
--- a/tests/script/tsim/parser/join_multivnode.sim
+++ b/tests/script/tsim/parser/join_multivnode.sim
--- a/tests/script/tsim/parser/last_groupby.sim
+++ b/tests/script/tsim/parser/last_groupby.sim
--- a/tests/script/tsim/parser/lastrow_query.sim
+++ b/tests/script/tsim/parser/lastrow_query.sim
--- a/tests/script/tsim/parser/like.sim
+++ b/tests/script/tsim/parser/like.sim
--- a/tests/script/tsim/parser/limit.sim
+++ b/tests/script/tsim/parser/limit.sim
--- a/tests/script/tsim/parser/limit1.sim
+++ b/tests/script/tsim/parser/limit1.sim
--- a/tests/script/tsim/parser/limit1_stb.sim
+++ b/tests/script/tsim/parser/limit1_stb.sim
--- a/tests/script/tsim/parser/limit1_tb.sim
+++ b/tests/script/tsim/parser/limit1_tb.sim
--- a/tests/script/tsim/parser/limit1_tblocks100.sim
+++ b/tests/script/tsim/parser/limit1_tblocks100.sim
--- a/tests/script/tsim/parser/limit2.sim
+++ b/tests/script/tsim/parser/limit2.sim
--- a/tests/script/tsim/parser/limit2_query.sim
+++ b/tests/script/tsim/parser/limit2_query.sim
--- a/tests/script/tsim/parser/limit2_tblocks100.sim
+++ b/tests/script/tsim/parser/limit2_tblocks100.sim
--- a/tests/script/tsim/parser/limit_stb.sim
+++ b/tests/script/tsim/parser/limit_stb.sim
--- a/tests/script/tsim/parser/limit_tb.sim
+++ b/tests/script/tsim/parser/limit_tb.sim
--- a/tests/script/tsim/parser/line_insert.sim
+++ b/tests/script/tsim/parser/line_insert.sim
--- a/tests/script/tsim/parser/mixed_blocks.sim
+++ b/tests/script/tsim/parser/mixed_blocks.sim
--- a/tests/script/tsim/parser/nchar.sim
+++ b/tests/script/tsim/parser/nchar.sim
--- a/tests/script/tsim/parser/nestquery.sim
+++ b/tests/script/tsim/parser/nestquery.sim
--- a/tests/script/tsim/parser/null_char.sim
+++ b/tests/script/tsim/parser/null_char.sim
--- a/tests/script/tsim/parser/precision_ns.sim
+++ b/tests/script/tsim/parser/precision_ns.sim
--- a/tests/script/tsim/parser/projection_limit_offset.sim
+++ b/tests/script/tsim/parser/projection_limit_offset.sim
--- a/tests/script/tsim/parser/regex.sim
+++ b/tests/script/tsim/parser/regex.sim
--- a/tests/script/tsim/parser/selectResNum.sim
+++ b/tests/script/tsim/parser/selectResNum.sim
--- a/tests/script/tsim/parser/select_across_vnodes.sim
+++ b/tests/script/tsim/parser/select_across_vnodes.sim
--- a/tests/script/tsim/parser/select_distinct_tag.sim
+++ b/tests/script/tsim/parser/select_distinct_tag.sim
--- a/tests/script/tsim/parser/select_from_cache_disk.sim
+++ b/tests/script/tsim/parser/select_from_cache_disk.sim
--- a/tests/script/tsim/parser/select_with_tags.sim
+++ b/tests/script/tsim/parser/select_with_tags.sim
--- a/tests/script/tsim/parser/set_tag_vals.sim
+++ b/tests/script/tsim/parser/set_tag_vals.sim
--- a/tests/script/tsim/parser/single_row_in_tb.sim
+++ b/tests/script/tsim/parser/single_row_in_tb.sim
--- a/tests/script/tsim/parser/single_row_in_tb_query.sim
+++ b/tests/script/tsim/parser/single_row_in_tb_query.sim
--- a/tests/script/tsim/parser/sliding.sim
+++ b/tests/script/tsim/parser/sliding.sim
--- a/tests/script/tsim/parser/slimit1.sim
+++ b/tests/script/tsim/parser/slimit1.sim
--- a/tests/script/tsim/parser/slimit1_query.sim
+++ b/tests/script/tsim/parser/slimit1_query.sim
--- a/tests/script/tsim/parser/slimit_alter_tags.sim
+++ b/tests/script/tsim/parser/slimit_alter_tags.sim
--- a/tests/script/tsim/parser/slimit_query.sim
+++ b/tests/script/tsim/parser/slimit_query.sim
--- a/tests/script/tsim/parser/udf.sim
+++ b/tests/script/tsim/parser/udf.sim
--- a/tests/script/tsim/parser/udf_dll.sim
+++ b/tests/script/tsim/parser/udf_dll.sim
--- a/tests/script/tsim/parser/udf_dll_stable.sim
+++ b/tests/script/tsim/parser/udf_dll_stable.sim
--- a/tests/script/tsim/parser/union.sim
+++ b/tests/script/tsim/parser/union.sim
--- a/tests/script/tsim/parser/union_sysinfo.sim
+++ b/tests/script/tsim/parser/union_sysinfo.sim
--- a/tests/script/tsim/sma/rsmaCreateInsertQuery.sim
+++ b/tests/script/tsim/sma/rsmaCreateInsertQuery.sim
--- a/tests/script/tsim/sma/tsmaCreateInsertQuery.sim
+++ b/tests/script/tsim/sma/tsmaCreateInsertQuery.sim
--- a/tests/script/tsim/stream/basic1.sim
+++ b/tests/script/tsim/stream/basic1.sim
--- a/tests/script/tsim/stream/sliding.sim
+++ b/tests/script/tsim/stream/sliding.sim
--- a/tests/script/tsim/tag/column.sim
+++ b/tests/script/tsim/tag/column.sim
--- a/tests/script/tsim/tag/commit.sim
+++ b/tests/script/tsim/tag/commit.sim
--- a/tests/script/tsim/valgrind/checkError5.sim
+++ b/tests/script/tsim/valgrind/checkError5.sim
--- a/tests/system-test/1-insert/delete_data.py
+++ b/tests/system-test/1-insert/delete_data.py
--- a/tests/system-test/1-insert/update_data.py
+++ b/tests/system-test/1-insert/update_data.py
--- a/tests/system-test/1-insert/update_data_muti_rows.py
+++ b/tests/system-test/1-insert/update_data_muti_rows.py
--- a/tests/system-test/2-query/Now.py
+++ b/tests/system-test/2-query/Now.py
--- a/tests/system-test/2-query/count.py
+++ b/tests/system-test/2-query/count.py
--- a/tests/system-test/2-query/csum.py
+++ b/tests/system-test/2-query/csum.py
--- a/tests/system-test/2-query/distribute_agg_apercentile.py
+++ b/tests/system-test/2-query/distribute_agg_apercentile.py
--- a/tests/system-test/2-query/distribute_agg_avg.py
+++ b/tests/system-test/2-query/distribute_agg_avg.py
--- a/tests/system-test/2-query/distribute_agg_count.py
+++ b/tests/system-test/2-query/distribute_agg_count.py
--- a/tests/system-test/2-query/distribute_agg_max.py
+++ b/tests/system-test/2-query/distribute_agg_max.py
--- a/tests/system-test/2-query/distribute_agg_min.py
+++ b/tests/system-test/2-query/distribute_agg_min.py
--- a/tests/system-test/2-query/distribute_agg_spread.py
+++ b/tests/system-test/2-query/distribute_agg_spread.py
--- a/tests/system-test/2-query/distribute_agg_sum.py
+++ b/tests/system-test/2-query/distribute_agg_sum.py
--- a/tests/system-test/2-query/irate.py
+++ b/tests/system-test/2-query/irate.py
--- a/tests/system-test/2-query/last.py
+++ b/tests/system-test/2-query/last.py
--- a/tests/system-test/2-query/log.py
+++ b/tests/system-test/2-query/log.py
--- a/tests/system-test/2-query/query_cols_tags_and_or.py
+++ b/tests/system-test/2-query/query_cols_tags_and_or.py
--- a/tests/system-test/2-query/tsbsQuery.py
+++ b/tests/system-test/2-query/tsbsQuery.py
--- a/tests/system-test/6-cluster/5dnode2mnode.py
+++ b/tests/system-test/6-cluster/5dnode2mnode.py
--- a/tests/system-test/6-cluster/5dnode3mnodeSep1VnodeStopDnodeCreateDb.py
+++ b/tests/system-test/6-cluster/5dnode3mnodeSep1VnodeStopDnodeCreateDb.py
--- a/tests/system-test/6-cluster/5dnode3mnodeSep1VnodeStopDnodeCreateStb.py
+++ b/tests/system-test/6-cluster/5dnode3mnodeSep1VnodeStopDnodeCreateStb.py
--- a/tests/system-test/6-cluster/5dnode3mnodeSep1VnodeStopMnodeCreateDb.py
+++ b/tests/system-test/6-cluster/5dnode3mnodeSep1VnodeStopMnodeCreateDb.py
--- a/tests/system-test/6-cluster/5dnode3mnodeSep1VnodeStopMnodeCreateStb.py
+++ b/tests/system-test/6-cluster/5dnode3mnodeSep1VnodeStopMnodeCreateStb.py
--- a/tests/system-test/6-cluster/5dnode3mnodeSep1VnodeStopVnodeCreateDb.py
+++ b/tests/system-test/6-cluster/5dnode3mnodeSep1VnodeStopVnodeCreateDb.py
--- a/tests/system-test/6-cluster/5dnode3mnodeSep1VnodeStopVnodeCreateStb.py
+++ b/tests/system-test/6-cluster/5dnode3mnodeSep1VnodeStopVnodeCreateStb.py
--- a/tests/system-test/6-cluster/5dnode3mnodeStop.py
+++ b/tests/system-test/6-cluster/5dnode3mnodeStop.py
--- a/tests/system-test/6-cluster/5dnode3mnodeStop2Follower.py
+++ b/tests/system-test/6-cluster/5dnode3mnodeStop2Follower.py
--- a/tests/system-test/6-cluster/clusterCommonCheck.py
+++ b/tests/system-test/6-cluster/clusterCommonCheck.py
--- a/tests/system-test/6-cluster/vnode/4dnode1mnode_basic_createDb_replica1.py
+++ b/tests/system-test/6-cluster/vnode/4dnode1mnode_basic_createDb_replica1.py
--- a/tests/system-test/6-cluster/vnode/4dnode1mnode_basic_replica1_insertdatas.py
+++ b/tests/system-test/6-cluster/vnode/4dnode1mnode_basic_replica1_insertdatas.py
--- a/tests/system-test/6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas.py
+++ b/tests/system-test/6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas.py
--- a/tests/system-test/6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_stop_follower_sync.py
+++ b/tests/system-test/6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_stop_follower_sync.py
--- a/tests/system-test/6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_stop_follower_unsync.py
+++ b/tests/system-test/6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_stop_follower_unsync.py
--- a/tests/system-test/6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_stop_follower_unsync_force_stop.py
+++ b/tests/system-test/6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_stop_follower_unsync_force_stop.py
--- a/tests/system-test/6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_stop_leader.py
+++ b/tests/system-test/6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_stop_leader.py
--- a/tests/system-test/6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_stop_leader_forece_stop.py
+++ b/tests/system-test/6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_stop_leader_forece_stop.py
--- a/tests/system-test/6-cluster/vnode/4dnode1mnode_basic_replica3_vgroups.py
+++ b/tests/system-test/6-cluster/vnode/4dnode1mnode_basic_replica3_vgroups.py
--- a/tests/system-test/6-cluster/vnode/4dnode1mnode_basic_replica3_vgroups_stopOne.py
+++ b/tests/system-test/6-cluster/vnode/4dnode1mnode_basic_replica3_vgroups_stopOne.py
--- a/tests/system-test/7-tmq/schema.py
+++ b/tests/system-test/7-tmq/schema.py
--- a/tests/system-test/7-tmq/tmqAutoCreateTbl.py
+++ b/tests/system-test/7-tmq/tmqAutoCreateTbl.py
--- a/tests/system-test/7-tmq/tmqCommon.py
+++ b/tests/system-test/7-tmq/tmqCommon.py
--- a/tests/system-test/7-tmq/tmqDnodeRestart.py
+++ b/tests/system-test/7-tmq/tmqDnodeRestart.py
--- a/tests/system-test/7-tmq/tmqDropNtb.py
+++ b/tests/system-test/7-tmq/tmqDropNtb.py
--- a/tests/system-test/7-tmq/tmqDropStbCtb.py
+++ b/tests/system-test/7-tmq/tmqDropStbCtb.py
--- a/tests/system-test/7-tmq/tmqUpdateWithConsume.py
+++ b/tests/system-test/7-tmq/tmqUpdateWithConsume.py
--- a/tests/system-test/99-TDcase/TD-17699.py
+++ b/tests/system-test/99-TDcase/TD-17699.py
--- a/tests/system-test/clusterCase.sh
+++ b/tests/system-test/clusterCase.sh
--- a/tests/system-test/fulltest.sh
+++ b/tests/system-test/fulltest.sh
--- a/tests/test/c/CMakeLists.txt
+++ b/tests/test/c/CMakeLists.txt
--- a/tests/test/c/tmqSim.c
+++ b/tests/test/c/tmqSim.c
--- a/tools/CMakeLists.txt
+++ b/tools/CMakeLists.txt
--- a/tools/shell/inc/shellInt.h
+++ b/tools/shell/inc/shellInt.h
--- a/tools/shell/src/shellArguments.c
+++ b/tools/shell/src/shellArguments.c
--- a/tools/shell/src/shellCommand.c
+++ b/tools/shell/src/shellCommand.c
--- a/tools/shell/src/shellEngine.c
+++ b/tools/shell/src/shellEngine.c
--- a/tools/shell/src/shellMain.c
+++ b/tools/shell/src/shellMain.c
--- a/tools/shell/src/shellUtil.c
+++ b/tools/shell/src/shellUtil.c
--- a/tools/shell/src/shellWebsocket.c
+++ b/tools/shell/src/shellWebsocket.c
--- a/taos-tools @ 0b8a3373
+++ b/taos-tools @ 0b8a3373
--- a/taosws-rs @ 9de599dc
+++ b/taosws-rs @ 9de599dc