Merge branch '3.0' of github.com:taosdata/TDengine into szhou/fixbugs

2022-10-31 15:11:58 +08:00 · 2022-10-31 15:11:58 +08:00 · 13a13bf06d
parent dc15fe4f78 bfb92713b4
commit 13a13bf06d
253 changed files with 10338 additions and 6204 deletions
--- a/6
+++ b/6
@ -173,8 +173,8 @@ def pre_test_build_mac() {
    '''
    sh '''
        cd ${WK}/debug
-        cmake .. -DBUILD_TEST=true
-        make -j8
+        cmake .. -DBUILD_TEST=true -DBUILD_HTTPS=false
+        make -j10
    '''
    sh '''
        date
@ -428,7 +428,7 @@ pipeline {
                                        date
                                        rm -rf ${WKC}/debug
                                        cd ${WKC}/tests/parallel_test
-                                        time ./container_build.sh -w ${WKDIR} -t 8 -e
+                                        time ./container_build.sh -w ${WKDIR} -t 10 -e
                                        rm -f /tmp/cases.task
                                        ./collect_cases.sh -e
                                    '''
--- a/cmake/cmake.define
+++ b/cmake/cmake.define
@ -100,6 +100,8 @@ IF (TD_WINDOWS)
    SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COMMON_FLAGS}")
    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COMMON_FLAGS}")

+    SET(JEMALLOC_ENABLED OFF)
+
 ELSE ()
    IF (${TD_DARWIN})
        set(CMAKE_MACOSX_RPATH 0)
--- a/cmake/taosadapter_CMakeLists.txt.in
+++ b/cmake/taosadapter_CMakeLists.txt.in
@ -2,7 +2,7 @@
 # taosadapter
 ExternalProject_Add(taosadapter
        GIT_REPOSITORY https://github.com/taosdata/taosadapter.git
-        GIT_TAG cc43ef0
+        GIT_TAG a11131c
        SOURCE_DIR "${TD_SOURCE_DIR}/tools/taosadapter"
        BINARY_DIR ""
        #BUILD_IN_SOURCE TRUE
--- a/cmake/taostools_CMakeLists.txt.in
+++ b/cmake/taostools_CMakeLists.txt.in
@ -2,7 +2,7 @@
 # taos-tools
 ExternalProject_Add(taos-tools
        GIT_REPOSITORY https://github.com/taosdata/taos-tools.git
-        GIT_TAG f9c1d32
+        GIT_TAG 7321fbb
        SOURCE_DIR "${TD_SOURCE_DIR}/tools/taos-tools"
        BINARY_DIR ""
        #BUILD_IN_SOURCE TRUE
--- a/contrib/CMakeLists.txt
+++ b/contrib/CMakeLists.txt
@ -270,7 +270,7 @@ if(${JEMALLOC_ENABLED})
        PREFIX        "jemalloc"
        SOURCE_DIR    ${CMAKE_CURRENT_SOURCE_DIR}/jemalloc
        BUILD_IN_SOURCE     1
-        CONFIGURE_COMMAND   ./autogen.sh COMMAND ./configure --prefix=${CMAKE_BINARY_DIR}/build/ --disable-initial-exec-tls --with-malloc-conf='background_thread:true,metadata_thp:auto'
+        CONFIGURE_COMMAND  ./autogen.sh COMMAND ./configure --prefix=${CMAKE_BINARY_DIR}/build/ --disable-initial-exec-tls
        BUILD_COMMAND       ${MAKE}
    )
    INCLUDE_DIRECTORIES(${CMAKE_BINARY_DIR}/build/include)
--- a/docs/en/14-reference/03-connector/04-java.mdx
+++ b/docs/en/14-reference/03-connector/04-java.mdx
@ -201,7 +201,7 @@ The configuration parameters in the URL are as follows:
 - httpConnectTimeout: REST connection timeout in milliseconds, the default value is 5000 ms.
 - httpSocketTimeout: socket timeout in milliseconds, the default value is 5000 ms. It only takes effect when batchfetch is false.
 - messageWaitTimeout: message transmission timeout in milliseconds, the default value is 3000 ms. It only takes effect when batchfetch is true.
- useSSL: connecting Securely Using SSL. true: using SSL conneciton, false: not using SSL connection.
+- useSSL: connecting Securely Using SSL. true: using SSL connection, false: not using SSL connection.

 **Note**: Some configuration items (e.g., locale, timezone) do not work in the REST connection.

@ -268,7 +268,7 @@ The configuration parameters in properties are as follows.
 - TSDBDriver.HTTP_CONNECT_TIMEOUT: REST connection timeout in milliseconds, the default value is 5000 ms. It only takes effect when using JDBC REST connection.
 - TSDBDriver.HTTP_SOCKET_TIMEOUT: socket timeout in milliseconds, the default value is 5000 ms. It only takes effect when using JDBC REST connection and batchfetch is false.
 - TSDBDriver.PROPERTY_KEY_MESSAGE_WAIT_TIMEOUT: message transmission timeout in milliseconds, the default value is 3000 ms. It only takes effect when using JDBC REST connection and batchfetch is true.
- TSDBDriver.PROPERTY_KEY_USE_SSL: connecting Securely Using SSL. true: using SSL conneciton, false: not using SSL connection. It only takes effect when using JDBC REST connection.
+- TSDBDriver.PROPERTY_KEY_USE_SSL: connecting Securely Using SSL. true: using SSL connection, false: not using SSL connection. It only takes effect when using JDBC REST connection.
  For JDBC native connections, you can specify other parameters, such as log level, SQL length, etc., by specifying URL and Properties. For more detailed configuration, please refer to [Client Configuration](/reference/config/#Client-Only).

 ### Priority of configuration parameters
@ -824,7 +824,7 @@ Example usage is as follows.
    //query or insert
    // ...

-    connection.close(); // put back to conneciton pool
+    connection.close(); // put back to connection pool
 }
 ```

@ -856,7 +856,7 @@ public static void main(String[] args) throws Exception {
    //query or insert
    // ...

-    connection.close(); // put back to conneciton pool
+    connection.close(); // put back to connection pool
 }
 ```

@ -878,7 +878,9 @@ The source code of the sample application is under `TDengine/examples/JDBC`:

 | taos-jdbcdriver version |                 major changes                  |
 | :---------------------: | :--------------------------------------------: |
+|       3.0.1 - 3.0.2        |  fix the resultSet data is parsed incorrectly sometimes. 3.0.1 is compiled on JDK 11, you are advised to use 3.0.2 in the JDK 8 environment    |
 |       3.0.0        |   Support for TDengine 3.0    |
+|       2.0.41        |   fix decode method of username and password in REST connection |
 |     2.0.39 - 2.0.40     | Add REST connection/request timeout parameters |
 |         2.0.38          |  JDBC REST connections add bulk pull function  |
 |         2.0.37          |               Support json tags                |
@ -910,6 +912,12 @@ The source code of the sample application is under `TDengine/examples/JDBC`:

  **Solution**: Use taos-jdbcdriver 2.* with your TDengine 2.* deployment.

+5. java.lang.NoSuchMethodError: java.nio.ByteBuffer.position(I)Ljava/nio/ByteBuffer; ... taos-jdbcdriver-3.0.1.jar
+
+**Cause**：taos-jdbcdriver 3.0.1 is compiled on JDK 11.
+
+**Solution**： Use taos-jdbcdriver 3.0.2.
+
 For additional troubleshooting, see [FAQ](../../../train-faq/faq).

 ## API Reference
--- a/docs/en/14-reference/03-connector/05-go.mdx
+++ b/docs/en/14-reference/03-connector/05-go.mdx
@ -353,7 +353,7 @@ The `af` package encapsulates TDengine advanced functions such as connection man

  Closes the connection.

-#### Subscribe to
+#### Subscribe

 * `func NewConsumer(conf *Config) (*Consumer, error)`

@ -387,7 +387,7 @@ Close consumer.

 * `func (conn *Connector) InfluxDBInsertLines(lines []string, precision string) error`

-  Write to influxDB line protocol.
+  Write to InfluxDB line protocol.

 * `func (conn *Connector) OpenTSDBInsertTelnetLines(lines []string) error`

@ -413,7 +413,7 @@ Close consumer.

 * `func (stmt *InsertStmt) SetTableName(name string) error`

-  Bind the set table name parameter.
+  Bind the table name parameter.

 * `func (stmt *InsertStmt) SetSubTableName(name string) error`

@ -463,6 +463,54 @@ Close consumer.

 For a complete example see [GitHub sample file](https://github.com/taosdata/driver-go/blob/3.0/examples/tmqoverws/main.go)

+### parameter binding via WebSocket
+
+* `func NewConnector(config *Config) (*Connector, error)`
+
+  Create a connection.
+
+* `func (c *Connector) Init() (*Stmt, error)`
+
+  Initialize the parameters.
+
+* `func (c *Connector) Close() error`
+
+  Close the connection.
+
+* `func (s *Stmt) Prepare(sql string) error`
+
+  Parameter binding preprocessing SQL statement.
+
+* `func (s *Stmt) SetTableName(name string) error`
+
+  Bind the table name parameter.
+
+* `func (s *Stmt) SetTags(tags *param.Param, bindType *param.ColumnType) error`
+
+  Set tags.
+
+* `func (s *Stmt) BindParam(params []*param.Param, bindType *param.ColumnType) error`
+
+  Parameter bind multiple rows of data.
+
+* `func (s *Stmt) AddBatch() error`
+
+  Add to a parameter-bound batch.
+
+* `func (s *Stmt) Exec() error`
+
+  Execute a parameter binding.
+
+* `func (s *Stmt) GetAffectedRows() int`
+
+  Gets the number of affected rows inserted by the parameter binding.
+
+* `func (s *Stmt) Close() error`
+
+  Closes the parameter binding.
+
+For a complete example see [GitHub sample file](https://github.com/taosdata/driver-go/blob/3.0/examples/stmtoverws/main.go)
+
 ## API Reference

 Full API see [driver-go documentation](https://pkg.go.dev/github.com/taosdata/driver-go/v3)
--- a/docs/en/28-releases/index.md
+++ b/docs/en/28-releases/index.md
@ -0,0 +1,10 @@
+---
+title: Releases
+---
+
+```mdx-code-block
+import DocCardList from '@theme/DocCardList';
+import {useCurrentSidebarCategory} from '@docusaurus/theme-common';
+
+<DocCardList items={useCurrentSidebarCategory().items}/>
+```
--- a/docs/examples/c/insert_example.c
+++ b/docs/examples/c/insert_example.c
@ -36,10 +36,10 @@ int main() {
  executeSQL(taos, "CREATE DATABASE power");
  executeSQL(taos, "USE power");
  executeSQL(taos, "CREATE STABLE meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT)");
-  executeSQL(taos, "INSERT INTO d1001 USING meters TAGS(California.SanFrancisco, 2) VALUES ('2018-10-03 14:38:05.000', 10.30000, 219, 0.31000) ('2018-10-03 14:38:15.000', 12.60000, 218, 0.33000) ('2018-10-03 14:38:16.800', 12.30000, 221, 0.31000)"
-                "d1002 USING meters TAGS(California.SanFrancisco, 3) VALUES ('2018-10-03 14:38:16.650', 10.30000, 218, 0.25000)"
-                "d1003 USING meters TAGS(California.LosAngeles, 2) VALUES ('2018-10-03 14:38:05.500', 11.80000, 221, 0.28000) ('2018-10-03 14:38:16.600', 13.40000, 223, 0.29000)"
-                "d1004 USING meters TAGS(California.LosAngeles, 3) VALUES ('2018-10-03 14:38:05.000', 10.80000, 223, 0.29000) ('2018-10-03 14:38:06.500', 11.50000, 221, 0.35000)");
+  executeSQL(taos, "INSERT INTO d1001 USING meters TAGS('California.SanFrancisco', 2) VALUES ('2018-10-03 14:38:05.000', 10.30000, 219, 0.31000) ('2018-10-03 14:38:15.000', 12.60000, 218, 0.33000) ('2018-10-03 14:38:16.800', 12.30000, 221, 0.31000)"
+                "d1002 USING meters TAGS('California.SanFrancisco', 3) VALUES ('2018-10-03 14:38:16.650', 10.30000, 218, 0.25000)"
+                "d1003 USING meters TAGS('California.LosAngeles', 2) VALUES ('2018-10-03 14:38:05.500', 11.80000, 221, 0.28000) ('2018-10-03 14:38:16.600', 13.40000, 223, 0.29000)"
+                "d1004 USING meters TAGS('California.LosAngeles', 3) VALUES ('2018-10-03 14:38:05.000', 10.80000, 223, 0.29000) ('2018-10-03 14:38:06.500', 11.50000, 221, 0.35000)");
  taos_close(taos);
  taos_cleanup();
 }
@ -48,4 +48,4 @@ int main() {
 // affected rows 0
 // affected rows 0
 // affected rows 0
-// affected rows 8
+// affected rows 8
--- a/docs/zh/08-connector/14-java.mdx
+++ b/docs/zh/08-connector/14-java.mdx
@ -68,38 +68,39 @@ TDengine 目前支持时间戳、数字、字符、布尔类型，与 Java 对
 ### 安装连接器

 <Tabs defaultValue="maven">
-<TabItem value="maven" label="使用 Maven 安装">
+  <TabItem value="maven" label="使用 Maven 安装">

-目前 taos-jdbcdriver 已经发布到 [Sonatype Repository](https://search.maven.org/artifact/com.taosdata.jdbc/taos-jdbcdriver) 仓库，且各大仓库都已同步。
+    目前 taos-jdbcdriver 已经发布到 [Sonatype Repository](https://search.maven.org/artifact/com.taosdata.jdbc/taos-jdbcdriver)
+    仓库，且各大仓库都已同步。

- [sonatype](https://search.maven.org/artifact/com.taosdata.jdbc/taos-jdbcdriver)
- [mvnrepository](https://mvnrepository.com/artifact/com.taosdata.jdbc/taos-jdbcdriver)
- [maven.aliyun](https://maven.aliyun.com/mvn/search)
+    - [sonatype](https://search.maven.org/artifact/com.taosdata.jdbc/taos-jdbcdriver)
+    - [mvnrepository](https://mvnrepository.com/artifact/com.taosdata.jdbc/taos-jdbcdriver)
+    - [maven.aliyun](https://maven.aliyun.com/mvn/search)

-Maven 项目中，在 pom.xml 中添加以下依赖：
+    Maven 项目中，在 pom.xml 中添加以下依赖：

-```xml-dtd
-<dependency>
- <groupId>com.taosdata.jdbc</groupId>
- <artifactId>taos-jdbcdriver</artifactId>
- <version>3.0.0</version>
-</dependency>
-```
+    ```xml-dtd
+    <dependency>
+      <groupId>com.taosdata.jdbc</groupId>
+      <artifactId>taos-jdbcdriver</artifactId>
+      <version>3.0.0</version>
+    </dependency>
+    ```

-</TabItem>
-<TabItem value="source" label="使用源码编译安装">
+  </TabItem>
+  <TabItem value="source" label="使用源码编译安装">

-可以通过下载 TDengine 的源码，自己编译最新版本的 Java connector
+    可以通过下载 TDengine 的源码，自己编译最新版本的 Java connector

-```shell
-git clone https://github.com/taosdata/taos-connector-jdbc.git
-cd taos-connector-jdbc
-mvn clean install -Dmaven.test.skip=true
-```
+    ```shell
+    git clone https://github.com/taosdata/taos-connector-jdbc.git
+    cd taos-connector-jdbc
+    mvn clean install -Dmaven.test.skip=true
+    ```

-编译后，在 target 目录下会产生 taos-jdbcdriver-3.0.*-dist.jar 的 jar 包，并自动将编译的 jar 文件放在本地的 Maven 仓库中。
+    编译后，在 target 目录下会产生 taos-jdbcdriver-3.0.*-dist.jar 的 jar 包，并自动将编译的 jar 文件放在本地的 Maven 仓库中。

-</TabItem>
+  </TabItem>
 </Tabs>

 ## 建立连接
@ -110,116 +111,125 @@ TDengine 的 JDBC URL 规范格式为：
 对于建立连接，原生连接与 REST 连接有细微不同。

 <Tabs defaultValue="rest">
-<TabItem value="native" label="原生连接">
+  <TabItem value="native" label="原生连接">

-```java
-Class.forName("com.taosdata.jdbc.TSDBDriver");
-String jdbcUrl = "jdbc:TAOS://taosdemo.com:6030/test?user=root&password=taosdata";
-Connection conn = DriverManager.getConnection(jdbcUrl);
-```
+    ```java
+    Class.forName("com.taosdata.jdbc.TSDBDriver");
+    String jdbcUrl = "jdbc:TAOS://taosdemo.com:6030/test?user=root&password=taosdata";
+    Connection conn = DriverManager.getConnection(jdbcUrl);
+    ```

-以上示例，使用了 JDBC 原生连接的 TSDBDriver，建立了到 hostname 为 taosdemo.com，端口为 6030（TDengine 的默认端口），数据库名为 test 的连接。这个 URL 中指定用户名（user）为 root，密码（password）为 taosdata。
+    以上示例，使用了 JDBC 原生连接的 TSDBDriver，建立了到 hostname 为 taosdemo.com，端口为 6030（TDengine 的默认端口），数据库名为 test 的连接。这个 URL
+    中指定用户名（user）为 root，密码（password）为 taosdata。

-**注意**：使用 JDBC 原生连接，taos-jdbcdriver 需要依赖客户端驱动（Linux 下是 libtaos.so；Windows 下是 taos.dll；macOS 下是 libtaos.dylib）。
+    **注意**：使用 JDBC 原生连接，taos-jdbcdriver 需要依赖客户端驱动（Linux 下是 libtaos.so；Windows 下是 taos.dll；macOS 下是 libtaos.dylib）。

-url 中的配置参数如下：
+    url 中的配置参数如下：

- user：登录 TDengine 用户名，默认值 'root'。
- password：用户登录密码，默认值 'taosdata'。
- cfgdir：客户端配置文件目录路径，Linux OS 上默认值 `/etc/taos`，Windows OS 上默认值 `C:/TDengine/cfg`。
- charset：客户端使用的字符集，默认值为系统字符集。
- locale：客户端语言环境，默认值系统当前 locale。
- timezone：客户端使用的时区，默认值为系统当前时区。
- batchfetch: true：在执行查询时批量拉取结果集；false：逐行拉取结果集。默认值为：true。开启批量拉取同时获取一批数据在查询数据量较大时批量拉取可以有效的提升查询性能。
- batchErrorIgnore：true：在执行 Statement 的 executeBatch 时，如果中间有一条 SQL 执行失败将继续执行下面的 SQL。false：不再执行失败 SQL 后的任何语句。默认值为：false。
+    - user：登录 TDengine 用户名，默认值 'root'。
+    - password：用户登录密码，默认值 'taosdata'。
+    - cfgdir：客户端配置文件目录路径，Linux OS 上默认值 `/etc/taos`，Windows OS 上默认值 `C:/TDengine/cfg`。
+    - charset：客户端使用的字符集，默认值为系统字符集。
+    - locale：客户端语言环境，默认值系统当前 locale。
+    - timezone：客户端使用的时区，默认值为系统当前时区。
+    - batchfetch: true：在执行查询时批量拉取结果集；false：逐行拉取结果集。默认值为：true。开启批量拉取同时获取一批数据在查询数据量较大时批量拉取可以有效的提升查询性能。
+    - batchErrorIgnore：true：在执行 Statement 的 executeBatch 时，如果中间有一条 SQL 执行失败将继续执行下面的 SQL。false：不再执行失败 SQL
+    后的任何语句。默认值为：false。

-JDBC 原生连接的使用请参见[视频教程](https://www.taosdata.com/blog/2020/11/11/1955.html)。
+    JDBC 原生连接的使用请参见[视频教程](https://www.taosdata.com/blog/2020/11/11/1955.html)。

-**使用 TDengine 客户端驱动配置文件建立连接 **
+    **使用 TDengine 客户端驱动配置文件建立连接 **

-当使用 JDBC 原生连接连接 TDengine 集群时，可以使用 TDengine 客户端驱动配置文件，在配置文件中指定集群的 firstEp、secondEp 等参数。如下所示：
+    当使用 JDBC 原生连接连接 TDengine 集群时，可以使用 TDengine 客户端驱动配置文件，在配置文件中指定集群的 firstEp、secondEp 等参数。如下所示：

-1. 在 Java 应用中不指定 hostname 和 port
+    1. 在 Java 应用中不指定 hostname 和 port

-```java
-public Connection getConn() throws Exception{
-  Class.forName("com.taosdata.jdbc.TSDBDriver");
-  String jdbcUrl = "jdbc:TAOS://:/test?user=root&password=taosdata";
-  Properties connProps = new Properties();
-  connProps.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
-  connProps.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
-  connProps.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
-  Connection conn = DriverManager.getConnection(jdbcUrl, connProps);
-  return conn;
-}
-```
+    ```java
+    public Connection getConn() throws Exception{
+    Class.forName("com.taosdata.jdbc.TSDBDriver");
+    String jdbcUrl = "jdbc:TAOS://:/test?user=root&password=taosdata";
+    Properties connProps = new Properties();
+    connProps.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
+    connProps.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
+    connProps.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
+    Connection conn = DriverManager.getConnection(jdbcUrl, connProps);
+    return conn;
+  }
+    ```

-2. 在配置文件中指定 firstEp 和 secondEp
+    2. 在配置文件中指定 firstEp 和 secondEp

-```shell
-# first fully qualified domain name (FQDN) for TDengine system
-firstEp               cluster_node1:6030
+    ```shell
+    # first fully qualified domain name (FQDN) for TDengine system
+    firstEp cluster_node1:6030

-# second fully qualified domain name (FQDN) for TDengine system, for cluster only
-secondEp              cluster_node2:6030
+    # second fully qualified domain name (FQDN) for TDengine system, for cluster only
+    secondEp cluster_node2:6030

-# default system charset
-# charset               UTF-8
+    # default system charset
+    # charset UTF-8

-# system locale
-# locale                en_US.UTF-8
-```
+    # system locale
+    # locale en_US.UTF-8
+    ```

-以上示例，jdbc 会使用客户端的配置文件，建立到 hostname 为 cluster_node1、端口为 6030、数据库名为 test 的连接。当集群中 firstEp 节点失效时，JDBC 会尝试使用 secondEp 连接集群。
+    以上示例，jdbc 会使用客户端的配置文件，建立到 hostname 为 cluster_node1、端口为 6030、数据库名为 test 的连接。当集群中 firstEp 节点失效时，JDBC 会尝试使用 secondEp
+    连接集群。

-TDengine 中，只要保证 firstEp 和 secondEp 中一个节点有效，就可以正常建立到集群的连接。
+    TDengine 中，只要保证 firstEp 和 secondEp 中一个节点有效，就可以正常建立到集群的连接。

-> **注意**：这里的配置文件指的是调用 JDBC Connector 的应用程序所在机器上的配置文件，Linux OS 上默认值 /etc/taos/taos.cfg ，Windows OS 上默认值 C://TDengine/cfg/taos.cfg。
+    > **注意**：这里的配置文件指的是调用 JDBC Connector 的应用程序所在机器上的配置文件，Linux OS 上默认值 /etc/taos/taos.cfg ，Windows OS 上默认值
+    C://TDengine/cfg/taos.cfg。

-</TabItem>
-<TabItem value="rest" label="REST 连接">
+  </TabItem>
+  <TabItem value="rest" label="REST 连接">

-```java
-Class.forName("com.taosdata.jdbc.rs.RestfulDriver");
-String jdbcUrl = "jdbc:TAOS-RS://taosdemo.com:6041/test?user=root&password=taosdata";
-Connection conn = DriverManager.getConnection(jdbcUrl);
-```
+    ```java
+    Class.forName("com.taosdata.jdbc.rs.RestfulDriver");
+    String jdbcUrl = "jdbc:TAOS-RS://taosdemo.com:6041/test?user=root&password=taosdata";
+    Connection conn = DriverManager.getConnection(jdbcUrl);
+    ```

-以上示例，使用了 JDBC REST 连接的 RestfulDriver，建立了到 hostname 为 taosdemo.com，端口为 6041，数据库名为 test 的连接。这个 URL 中指定用户名（user）为 root，密码（password）为 taosdata。
+    以上示例，使用了 JDBC REST 连接的 RestfulDriver，建立了到 hostname 为 taosdemo.com，端口为 6041，数据库名为 test 的连接。这个 URL 中指定用户名（user）为
+    root，密码（password）为 taosdata。

-使用 JDBC REST 连接，不需要依赖客户端驱动。与 JDBC 原生连接相比，仅需要：
+    使用 JDBC REST 连接，不需要依赖客户端驱动。与 JDBC 原生连接相比，仅需要：

-1. driverClass 指定为“com.taosdata.jdbc.rs.RestfulDriver”；
-2. jdbcUrl 以“jdbc:TAOS-RS://”开头；
-3. 使用 6041 作为连接端口。
+    1. driverClass 指定为“com.taosdata.jdbc.rs.RestfulDriver”；
+    2. jdbcUrl 以“jdbc:TAOS-RS://”开头；
+    3. 使用 6041 作为连接端口。

-url 中的配置参数如下：
+    url 中的配置参数如下：

- user：登录 TDengine 用户名，默认值 'root'。
- password：用户登录密码，默认值 'taosdata'。
- batchfetch: true：在执行查询时批量拉取结果集；false：逐行拉取结果集。默认值为：false。逐行拉取结果集使用 HTTP 方式进行数据传输。JDBC REST 连接支持批量拉取数据功能。taos-jdbcdriver 与 TDengine 之间通过 WebSocket 连接进行数据传输。相较于 HTTP，WebSocket 可以使 JDBC REST 连接支持大数据量查询，并提升查询性能。
- charset: 当开启批量拉取数据时，指定解析字符串数据的字符集。
- batchErrorIgnore：true：在执行 Statement 的 executeBatch 时，如果中间有一条 SQL 执行失败，继续执行下面的 SQL 了。false：不再执行失败 SQL 后的任何语句。默认值为：false。
- httpConnectTimeout: 连接超时时间，单位 ms， 默认值为 5000。
- httpSocketTimeout: socket 超时时间，单位 ms，默认值为 5000。仅在 batchfetch 设置为 false 时生效。
- messageWaitTimeout: 消息超时时间, 单位 ms， 默认值为 3000。 仅在 batchfetch 设置为 true 时生效。
- useSSL: 连接中是否使用 SSL。
+    - user：登录 TDengine 用户名，默认值 'root'。
+    - password：用户登录密码，默认值 'taosdata'。
+    - batchfetch: true：在执行查询时批量拉取结果集；false：逐行拉取结果集。默认值为：false。逐行拉取结果集使用 HTTP 方式进行数据传输。JDBC REST
+    连接支持批量拉取数据功能。taos-jdbcdriver 与 TDengine 之间通过 WebSocket 连接进行数据传输。相较于 HTTP，WebSocket 可以使 JDBC REST 连接支持大数据量查询，并提升查询性能。
+    - charset: 当开启批量拉取数据时，指定解析字符串数据的字符集。
+    - batchErrorIgnore：true：在执行 Statement 的 executeBatch 时，如果中间有一条 SQL 执行失败，继续执行下面的 SQL 了。false：不再执行失败 SQL
+    后的任何语句。默认值为：false。
+    - httpConnectTimeout: 连接超时时间，单位 ms， 默认值为 5000。
+    - httpSocketTimeout: socket 超时时间，单位 ms，默认值为 5000。仅在 batchfetch 设置为 false 时生效。
+    - messageWaitTimeout: 消息超时时间, 单位 ms， 默认值为 3000。 仅在 batchfetch 设置为 true 时生效。
+    - useSSL: 连接中是否使用 SSL。

-**注意**：部分配置项（比如：locale、timezone）在 REST 连接中不生效。
+    **注意**：部分配置项（比如：locale、timezone）在 REST 连接中不生效。

-:::note
+    :::note

- 与原生连接方式不同，REST 接口是无状态的。在使用 JDBC REST 连接时，需要在 SQL 中指定表、超级表的数据库名称。例如：
+    - 与原生连接方式不同，REST 接口是无状态的。在使用 JDBC REST 连接时，需要在 SQL 中指定表、超级表的数据库名称。例如：

-```sql
-INSERT INTO test.t1 USING test.weather (ts, temperature) TAGS('California.SanFrancisco') VALUES(now, 24.6);
-```
+    ```sql
+    INSERT INTO test.t1 USING test.weather (ts, temperature) TAGS('California.SanFrancisco') VALUES(now, 24.6);
+    ```

- 如果在 url 中指定了 dbname，那么，JDBC REST 连接会默认使用/rest/sql/dbname 作为 restful 请求的 url，在 SQL 中不需要指定 dbname。例如：url 为 jdbc:TAOS-RS://127.0.0.1:6041/test，那么，可以执行 sql：insert into t1 using weather(ts, temperature) tags('California.SanFrancisco') values(now, 24.6);
+    - 如果在 url 中指定了 dbname，那么，JDBC REST 连接会默认使用/rest/sql/dbname 作为 restful 请求的 url，在 SQL 中不需要指定 dbname。例如：url 为
+    jdbc:TAOS-RS://127.0.0.1:6041/test，那么，可以执行 sql：insert into t1 using weather(ts, temperature)
+    tags('California.SanFrancisco') values(now, 24.6);

-:::
+    :::

-</TabItem>
+  </TabItem>
 </Tabs>

 ### 指定 URL 和 Properties 获取连接
@ -271,7 +281,7 @@ properties 中的配置参数如下：
 - TSDBDriver.HTTP_SOCKET_TIMEOUT: socket 超时时间，单位 ms，默认值为 5000。仅在 REST 连接且 batchfetch 设置为 false 时生效。
 - TSDBDriver.PROPERTY_KEY_MESSAGE_WAIT_TIMEOUT: 消息超时时间, 单位 ms， 默认值为 3000。 仅在 REST 连接且 batchfetch 设置为 true 时生效。
 - TSDBDriver.PROPERTY_KEY_USE_SSL: 连接中是否使用 SSL。仅在 REST 连接时生效。
-  此外对 JDBC 原生连接，通过指定 URL 和 Properties 还可以指定其他参数，比如日志级别、SQL 长度等。更多详细配置请参考[客户端配置](/reference/config/#仅客户端适用)。
+此外对 JDBC 原生连接，通过指定 URL 和 Properties 还可以指定其他参数，比如日志级别、SQL 长度等。更多详细配置请参考[客户端配置](/reference/config/#仅客户端适用)。

 ### 配置参数的优先级

@ -826,7 +836,7 @@ public abstract class ConsumerLoop {
    //query or insert
    // ...

-    connection.close(); // put back to conneciton pool
+    connection.close(); // put back to connection pool
 }
 ```

@ -858,7 +868,7 @@ public static void main(String[] args) throws Exception {
    //query or insert
    // ...

-    connection.close(); // put back to conneciton pool
+    connection.close(); // put back to connection pool
 }
 ```

@ -880,7 +890,9 @@ public static void main(String[] args) throws Exception {

 | taos-jdbcdriver 版本 |            主要变化            |
 | :------------------: | :----------------------------: |
+|       3.0.1 - 3.0.2        |  修复一些情况下结果集数据解析错误的问题。3.0.1 在 JDK 11 环境编译，JDK 8 环境下建议使用 3.0.2 版本    |
 |       3.0.0        |   支持 TDengine 3.0    |
+|       2.0.41        |   修正 REST 连接中用户名和密码转码方式    |
 |   2.0.39 - 2.0.40    |  增加 REST 连接/请求 超时设置  |
 |        2.0.38        | JDBC REST 连接增加批量拉取功能 |
 |        2.0.37        |      增加对 json tag 支持      |
@ -890,27 +902,33 @@ public static void main(String[] args) throws Exception {

 1. 使用 Statement 的 `addBatch()` 和 `executeBatch()` 来执行“批量写入/更新”，为什么没有带来性能上的提升？

-   **原因**：TDengine 的 JDBC 实现中，通过 `addBatch` 方法提交的 SQL 语句，会按照添加的顺序，依次执行，这种方式没有减少与服务端的交互次数，不会带来性能上的提升。
+**原因**：TDengine 的 JDBC 实现中，通过 `addBatch` 方法提交的 SQL 语句，会按照添加的顺序，依次执行，这种方式没有减少与服务端的交互次数，不会带来性能上的提升。

-   **解决方法**：1. 在一条 insert 语句中拼接多个 values 值；2. 使用多线程的方式并发插入；3. 使用参数绑定的写入方式
+**解决方法**：1. 在一条 insert 语句中拼接多个 values 值；2. 使用多线程的方式并发插入；3. 使用参数绑定的写入方式

 2. java.lang.UnsatisfiedLinkError: no taos in java.library.path

-   **原因**：程序没有找到依赖的本地函数库 taos。
+**原因**：程序没有找到依赖的本地函数库 taos。

-   **解决方法**：Windows 下可以将 C:\TDengine\driver\taos.dll 拷贝到 C:\Windows\System32\ 目录下，Linux 下将建立如下软链 `ln -s /usr/local/taos/driver/libtaos.so.x.x.x.x /usr/lib/libtaos.so` 即可，macOS 下需要建立软链 `ln -s /usr/local/lib/libtaos.dylib`。
+**解决方法**：Windows 下可以将 C:\TDengine\driver\taos.dll 拷贝到 C:\Windows\System32\ 目录下，Linux 下将建立如下软链 `ln -s /usr/local/taos/driver/libtaos.so.x.x.x.x /usr/lib/libtaos.so` 即可，macOS 下需要建立软链 `ln -s /usr/local/lib/libtaos.dylib`。

 3. java.lang.UnsatisfiedLinkError: taos.dll Can't load AMD 64 bit on a IA 32-bit platform

-   **原因**：目前 TDengine 只支持 64 位 JDK。
+**原因**：目前 TDengine 只支持 64 位 JDK。

-   **解决方法**：重新安装 64 位 JDK。
+**解决方法**：重新安装 64 位 JDK。

 4. java.lang.NoSuchMethodError: setByteArray

-  **原因**：taos-jdbcdriver 3.* 版本仅支持 TDengine 3.0 及以上版本。
+**原因**：taos-jdbcdriver 3.* 版本仅支持 TDengine 3.0 及以上版本。

-  **解决方法**： 使用 taos-jdbcdriver 2.* 版本连接 TDengine 2.* 版本。
+**解决方法**： 使用 taos-jdbcdriver 2.* 版本连接 TDengine 2.* 版本。
+
+5. java.lang.NoSuchMethodError: java.nio.ByteBuffer.position(I)Ljava/nio/ByteBuffer; ... taos-jdbcdriver-3.0.1.jar
+
+**原因**：taos-jdbcdriver 3.0.1 版本需要在 JDK 11+ 环境使用。
+
+**解决方法**： 更换 taos-jdbcdriver 3.0.2 版本。

 其它问题请参考 [FAQ](../../../train-faq/faq)

--- a/docs/zh/08-connector/20-go.mdx
+++ b/docs/zh/08-connector/20-go.mdx
@ -8,7 +8,7 @@ title: TDengine Go Connector
 import Tabs from '@theme/Tabs';
 import TabItem from '@theme/TabItem';

-import Preparition from "./_preparition.mdx"
+import Preparation from "./_preparation.mdx"
 import GoInsert from "../07-develop/03-insert-data/_go_sql.mdx"
 import GoInfluxLine from "../07-develop/03-insert-data/_go_line.mdx"
 import GoOpenTSDBTelnet from "../07-develop/03-insert-data/_go_opts_telnet.mdx"
@ -389,7 +389,7 @@ func main() {

 * `func (conn *Connector) InfluxDBInsertLines(lines []string, precision string) error`

-  写入 influxDB 行协议。
+  写入 InfluxDB 行协议。

 * `func (conn *Connector) OpenTSDBInsertTelnetLines(lines []string) error`

@ -465,6 +465,54 @@ func main() {

 完整订阅示例参见 [GitHub 示例文件](https://github.com/taosdata/driver-go/blob/3.0/examples/tmqoverws/main.go)

+### 通过 WebSocket 进行参数绑定
+
+* `func NewConnector(config *Config) (*Connector, error)`
+
+  创建连接。
+
+* `func (c *Connector) Init() (*Stmt, error)`
+
+  初始化参数。
+
+* `func (c *Connector) Close() error`
+
+  关闭连接。
+
+* `func (s *Stmt) Prepare(sql string) error`
+
+  参数绑定预处理 SQL 语句。
+
+* `func (s *Stmt) SetTableName(name string) error`
+
+  参数绑定设置表名。
+
+* `func (s *Stmt) SetTags(tags *param.Param, bindType *param.ColumnType) error`
+
+  参数绑定设置标签。
+
+* `func (s *Stmt) BindParam(params []*param.Param, bindType *param.ColumnType) error`
+
+  参数绑定多行数据。
+
+* `func (s *Stmt) AddBatch() error`
+
+  添加到参数绑定批处理。
+
+* `func (s *Stmt) Exec() error`
+
+  执行参数绑定。
+
+* `func (s *Stmt) GetAffectedRows() int`
+
+  获取参数绑定插入受影响行数。
+
+* `func (s *Stmt) Close() error`
+
+  结束参数绑定。
+
+完整参数绑定示例参见 [GitHub 示例文件](https://github.com/taosdata/driver-go/blob/3.0/examples/stmtoverws/main.go)
+
 ## API 参考

 全部 API 见 [driver-go 文档](https://pkg.go.dev/github.com/taosdata/driver-go/v3)
--- a/docs/zh/08-connector/26-rust.mdx
+++ b/docs/zh/08-connector/26-rust.mdx
@ -7,7 +7,7 @@ title: TDengine Rust Connector
 import Tabs from '@theme/Tabs';
 import TabItem from '@theme/TabItem';

-import Preparition from "./_preparition.mdx"
+import Preparation from "./_preparation.mdx"
 import RustInsert from "../07-develop/03-insert-data/_rust_sql.mdx"
 import RustBind from "../07-develop/03-insert-data/_rust_stmt.mdx"
 import RustQuery from "../07-develop/04-query-data/_rust.mdx"
--- a/docs/zh/08-connector/35-node.mdx
+++ b/docs/zh/08-connector/35-node.mdx
@ -7,7 +7,7 @@ title: TDengine Node.js Connector
 import Tabs from "@theme/Tabs";
 import TabItem from "@theme/TabItem";

-import Preparition from "./_preparition.mdx";
+import Preparation from "./_preparation.mdx";
 import NodeInsert from "../07-develop/03-insert-data/_js_sql.mdx";
 import NodeInfluxLine from "../07-develop/03-insert-data/_js_line.mdx";
 import NodeOpenTSDBTelnet from "../07-develop/03-insert-data/_js_opts_telnet.mdx";
@ -249,4 +249,4 @@ Node.js 连接器的使用参见[视频教程](https://www.taosdata.com/blog/202

 ## API 参考

-[API 参考](https://docs.taosdata.com/api/td2.0-connector/)
+[API 参考](https://docs.taosdata.com/api/td2.0-connector/)
--- a/docs/zh/08-connector/40-csharp.mdx
+++ b/docs/zh/08-connector/40-csharp.mdx
@ -7,7 +7,7 @@ title: C# Connector
 import Tabs from '@theme/Tabs';
 import TabItem from '@theme/TabItem';

-import Preparition from "./_preparition.mdx"
+import Preparation from "./_preparation.mdx"
 import CSInsert from "../07-develop/03-insert-data/_cs_sql.mdx"
 import CSInfluxLine from "../07-develop/03-insert-data/_cs_line.mdx"
 import CSOpenTSDBTelnet from "../07-develop/03-insert-data/_cs_opts_telnet.mdx"
--- a/docs/zh/08-connector/_preparation.mdx
+++ b/docs/zh/08-connector/_preparation.mdx
--- a/docs/zh/12-taos-sql/24-show.md
+++ b/docs/zh/12-taos-sql/24-show.md
@ -201,7 +201,7 @@ SHOW TOPICS;
 SHOW TRANSACTIONS;
 ```

-显示当前系统中正在执行的事务的信息
+显示当前系统中正在执行的事务的信息(该事务仅针对除普通表以外的元数据级别)

 ## SHOW USERS

--- a/examples/c/tmq.c
+++ b/examples/c/tmq.c
@ -47,7 +47,7 @@ static int32_t msg_process(TAOS_RES* msg) {
    int32_t     precision = taos_result_precision(msg);
    rows++;
    taos_print_row(buf, row, fields, numOfFields);
-    printf("row content: %s\n", buf);
+    printf("precision: %d, row content: %s\n", precision, buf);
  }

  return rows;
@ -70,7 +70,7 @@ static int32_t init_env() {
  taos_free_result(pRes);

  // create database
-  pRes = taos_query(pConn, "create database tmqdb");
+  pRes = taos_query(pConn, "create database tmqdb precision 'ns'");
  if (taos_errno(pRes) != 0) {
    printf("error in create tmqdb, reason:%s\n", taos_errstr(pRes));
    return -1;
--- a/include/common/tcommon.h
+++ b/include/common/tcommon.h
@ -161,16 +161,9 @@ typedef enum EStreamType {
  STREAM_RETRIEVE,
  STREAM_PULL_DATA,
  STREAM_PULL_OVER,
+  STREAM_FILL_OVER,
 } EStreamType;

-typedef struct {
-  SArray*   pGroupList;
-  SArray*   pTableList;
-  SHashObj* map;  // speedup acquire the tableQueryInfo by table uid
-  bool      needSortTableByGroupId;
-  uint64_t  suid;
-} STableListInfo;
-
 #pragma pack(push, 1)
 typedef struct SColumnDataAgg {
  int16_t colId;
--- a/include/common/tglobal.h
+++ b/include/common/tglobal.h
@ -60,8 +60,8 @@ extern int32_t tsNumOfVnodeSyncThreads;
 extern int32_t tsNumOfVnodeRsmaThreads;
 extern int32_t tsNumOfQnodeQueryThreads;
 extern int32_t tsNumOfQnodeFetchThreads;
-extern int32_t tsNumOfSnodeSharedThreads;
-extern int32_t tsNumOfSnodeUniqueThreads;
+extern int32_t tsNumOfSnodeStreamThreads;
+extern int32_t tsNumOfSnodeWriteThreads;
 extern int64_t tsRpcQueueMemoryAllowed;

 // monitor
@ -91,6 +91,7 @@ extern bool    tsQueryPlannerTrace;
 extern int32_t tsQueryNodeChunkSize;
 extern bool    tsQueryUseNodeAllocator;
 extern bool    tsKeepColumnName;
+extern bool    tsEnableQueryHb;

 // client
 extern int32_t tsMinSlidingTime;
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@ -1726,6 +1726,9 @@ typedef struct {
 #define STREAM_TRIGGER_WINDOW_CLOSE   2
 #define STREAM_TRIGGER_MAX_DELAY      3
 #define STREAM_DEFAULT_IGNORE_EXPIRED 0
+#define STREAM_FILL_HISTORY_ON        1
+#define STREAM_FILL_HISTORY_OFF       0
+#define STREAM_DEFAULT_FILL_HISTORY   STREAM_FILL_HISTORY_OFF

 typedef struct {
  char    name[TSDB_STREAM_FNAME_LEN];
--- a/include/common/tmsgdef.h
+++ b/include/common/tmsgdef.h
@ -198,6 +198,9 @@ enum {
  TD_DEF_MSG_TYPE(TDMT_VND_CONSUME, "vnode-consume", SMqPollReq, SMqDataBlkRsp)
  TD_DEF_MSG_TYPE(TDMT_VND_STREAM_TRIGGER, "vnode-stream-trigger", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_VND_STREAM_DISPATCH_WRITE, "vnode-stream-task-dispatch-write", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_STREAM_RECOVER_STEP1, "vnode-stream-recover1", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_STREAM_RECOVER_STEP2, "vnode-stream-recover2", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_STREAM_RECOVER_FINISH, "vnode-stream-finish", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_VND_CREATE_SMA, "vnode-create-sma", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_VND_CANCEL_SMA, "vnode-cancel-sma", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_VND_DROP_SMA, "vnode-drop-sma", NULL, NULL)
@ -266,6 +269,7 @@ enum {
  TD_DEF_MSG_TYPE(TDMT_SYNC_SET_VNODE_STANDBY, "set-vnode-standby", NULL, NULL) // no longer used
  TD_DEF_MSG_TYPE(TDMT_SYNC_HEARTBEAT, "sync-heartbeat", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_SYNC_HEARTBEAT_REPLY, "sync-heartbeat-reply", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_SYNC_LOCAL_CMD, "sync-local-cmd", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_SYNC_MAX_MSG, "sync-max", NULL, NULL)
  
 #if defined(TD_MSG_NUMBER_)
--- a/include/common/ttokendef.h
+++ b/include/common/ttokendef.h
@ -203,135 +203,136 @@
 #define TK_WINDOW_CLOSE         185
 #define TK_IGNORE               186
 #define TK_EXPIRED              187
-#define TK_SUBTABLE             188
-#define TK_KILL                 189
-#define TK_CONNECTION           190
-#define TK_TRANSACTION          191
-#define TK_BALANCE              192
-#define TK_VGROUP               193
-#define TK_MERGE                194
-#define TK_REDISTRIBUTE         195
-#define TK_SPLIT                196
-#define TK_DELETE               197
-#define TK_INSERT               198
-#define TK_NULL                 199
-#define TK_NK_QUESTION          200
-#define TK_NK_ARROW             201
-#define TK_ROWTS                202
-#define TK_TBNAME               203
-#define TK_QSTART               204
-#define TK_QEND                 205
-#define TK_QDURATION            206
-#define TK_WSTART               207
-#define TK_WEND                 208
-#define TK_WDURATION            209
-#define TK_IROWTS               210
-#define TK_QTAGS                211
-#define TK_CAST                 212
-#define TK_NOW                  213
-#define TK_TODAY                214
-#define TK_TIMEZONE             215
-#define TK_CLIENT_VERSION       216
-#define TK_SERVER_VERSION       217
-#define TK_SERVER_STATUS        218
-#define TK_CURRENT_USER         219
-#define TK_COUNT                220
-#define TK_LAST_ROW             221
-#define TK_CASE                 222
-#define TK_END                  223
-#define TK_WHEN                 224
-#define TK_THEN                 225
-#define TK_ELSE                 226
-#define TK_BETWEEN              227
-#define TK_IS                   228
-#define TK_NK_LT                229
-#define TK_NK_GT                230
-#define TK_NK_LE                231
-#define TK_NK_GE                232
-#define TK_NK_NE                233
-#define TK_MATCH                234
-#define TK_NMATCH               235
-#define TK_CONTAINS             236
-#define TK_IN                   237
-#define TK_JOIN                 238
-#define TK_INNER                239
-#define TK_SELECT               240
-#define TK_DISTINCT             241
-#define TK_WHERE                242
-#define TK_PARTITION            243
-#define TK_BY                   244
-#define TK_SESSION              245
-#define TK_STATE_WINDOW         246
-#define TK_SLIDING              247
-#define TK_FILL                 248
-#define TK_VALUE                249
-#define TK_NONE                 250
-#define TK_PREV                 251
-#define TK_LINEAR               252
-#define TK_NEXT                 253
-#define TK_HAVING               254
-#define TK_RANGE                255
-#define TK_EVERY                256
-#define TK_ORDER                257
-#define TK_SLIMIT               258
-#define TK_SOFFSET              259
-#define TK_LIMIT                260
-#define TK_OFFSET               261
-#define TK_ASC                  262
-#define TK_NULLS                263
-#define TK_ABORT                264
-#define TK_AFTER                265
-#define TK_ATTACH               266
-#define TK_BEFORE               267
-#define TK_BEGIN                268
-#define TK_BITAND               269
-#define TK_BITNOT               270
-#define TK_BITOR                271
-#define TK_BLOCKS               272
-#define TK_CHANGE               273
-#define TK_COMMA                274
-#define TK_COMPACT              275
-#define TK_CONCAT               276
-#define TK_CONFLICT             277
-#define TK_COPY                 278
-#define TK_DEFERRED             279
-#define TK_DELIMITERS           280
-#define TK_DETACH               281
-#define TK_DIVIDE               282
-#define TK_DOT                  283
-#define TK_EACH                 284
-#define TK_FAIL                 285
-#define TK_FILE                 286
-#define TK_FOR                  287
-#define TK_GLOB                 288
-#define TK_ID                   289
-#define TK_IMMEDIATE            290
-#define TK_IMPORT               291
-#define TK_INITIALLY            292
-#define TK_INSTEAD              293
-#define TK_ISNULL               294
-#define TK_KEY                  295
-#define TK_MODULES              296
-#define TK_NK_BITNOT            297
-#define TK_NK_SEMI              298
-#define TK_NOTNULL              299
-#define TK_OF                   300
-#define TK_PLUS                 301
-#define TK_PRIVILEGE            302
-#define TK_RAISE                303
-#define TK_REPLACE              304
-#define TK_RESTRICT             305
-#define TK_ROW                  306
-#define TK_SEMI                 307
-#define TK_STAR                 308
-#define TK_STATEMENT            309
-#define TK_STRING               310
-#define TK_TIMES                311
-#define TK_UPDATE               312
-#define TK_VALUES               313
-#define TK_VARIABLE             314
-#define TK_VIEW                 315
-#define TK_WAL                  316
+#define TK_FILL_HISTORY         188
+#define TK_SUBTABLE             189
+#define TK_KILL                 190
+#define TK_CONNECTION           191
+#define TK_TRANSACTION          192
+#define TK_BALANCE              193
+#define TK_VGROUP               194
+#define TK_MERGE                195
+#define TK_REDISTRIBUTE         196
+#define TK_SPLIT                197
+#define TK_DELETE               198
+#define TK_INSERT               199
+#define TK_NULL                 200
+#define TK_NK_QUESTION          201
+#define TK_NK_ARROW             202
+#define TK_ROWTS                203
+#define TK_TBNAME               204
+#define TK_QSTART               205
+#define TK_QEND                 206
+#define TK_QDURATION            207
+#define TK_WSTART               208
+#define TK_WEND                 209
+#define TK_WDURATION            210
+#define TK_IROWTS               211
+#define TK_QTAGS                212
+#define TK_CAST                 213
+#define TK_NOW                  214
+#define TK_TODAY                215
+#define TK_TIMEZONE             216
+#define TK_CLIENT_VERSION       217
+#define TK_SERVER_VERSION       218
+#define TK_SERVER_STATUS        219
+#define TK_CURRENT_USER         220
+#define TK_COUNT                221
+#define TK_LAST_ROW             222
+#define TK_CASE                 223
+#define TK_END                  224
+#define TK_WHEN                 225
+#define TK_THEN                 226
+#define TK_ELSE                 227
+#define TK_BETWEEN              228
+#define TK_IS                   229
+#define TK_NK_LT                230
+#define TK_NK_GT                231
+#define TK_NK_LE                232
+#define TK_NK_GE                233
+#define TK_NK_NE                234
+#define TK_MATCH                235
+#define TK_NMATCH               236
+#define TK_CONTAINS             237
+#define TK_IN                   238
+#define TK_JOIN                 239
+#define TK_INNER                240
+#define TK_SELECT               241
+#define TK_DISTINCT             242
+#define TK_WHERE                243
+#define TK_PARTITION            244
+#define TK_BY                   245
+#define TK_SESSION              246
+#define TK_STATE_WINDOW         247
+#define TK_SLIDING              248
+#define TK_FILL                 249
+#define TK_VALUE                250
+#define TK_NONE                 251
+#define TK_PREV                 252
+#define TK_LINEAR               253
+#define TK_NEXT                 254
+#define TK_HAVING               255
+#define TK_RANGE                256
+#define TK_EVERY                257
+#define TK_ORDER                258
+#define TK_SLIMIT               259
+#define TK_SOFFSET              260
+#define TK_LIMIT                261
+#define TK_OFFSET               262
+#define TK_ASC                  263
+#define TK_NULLS                264
+#define TK_ABORT                265
+#define TK_AFTER                266
+#define TK_ATTACH               267
+#define TK_BEFORE               268
+#define TK_BEGIN                269
+#define TK_BITAND               270
+#define TK_BITNOT               271
+#define TK_BITOR                272
+#define TK_BLOCKS               273
+#define TK_CHANGE               274
+#define TK_COMMA                275
+#define TK_COMPACT              276
+#define TK_CONCAT               277
+#define TK_CONFLICT             278
+#define TK_COPY                 279
+#define TK_DEFERRED             280
+#define TK_DELIMITERS           281
+#define TK_DETACH               282
+#define TK_DIVIDE               283
+#define TK_DOT                  284
+#define TK_EACH                 285
+#define TK_FAIL                 286
+#define TK_FILE                 287
+#define TK_FOR                  288
+#define TK_GLOB                 289
+#define TK_ID                   290
+#define TK_IMMEDIATE            291
+#define TK_IMPORT               292
+#define TK_INITIALLY            293
+#define TK_INSTEAD              294
+#define TK_ISNULL               295
+#define TK_KEY                  296
+#define TK_MODULES              297
+#define TK_NK_BITNOT            298
+#define TK_NK_SEMI              299
+#define TK_NOTNULL              300
+#define TK_OF                   301
+#define TK_PLUS                 302
+#define TK_PRIVILEGE            303
+#define TK_RAISE                304
+#define TK_REPLACE              305
+#define TK_RESTRICT             306
+#define TK_ROW                  307
+#define TK_SEMI                 308
+#define TK_STAR                 309
+#define TK_STATEMENT            310
+#define TK_STRING               311
+#define TK_TIMES                312
+#define TK_UPDATE               313
+#define TK_VALUES               314
+#define TK_VARIABLE             315
+#define TK_VIEW                 316
+#define TK_WAL                  317

 #define TK_NK_SPACE   300
 #define TK_NK_COMMENT 301
--- a/include/dnode/snode/snode.h
+++ b/include/dnode/snode/snode.h
@ -68,8 +68,8 @@ int32_t sndGetLoad(SSnode *pSnode, SSnodeLoad *pLoad);
 * @param pMsg The request message
 * @param pRsp The response message
 */
-int32_t sndProcessUMsg(SSnode *pSnode, SRpcMsg *pMsg);
-int32_t sndProcessSMsg(SSnode *pSnode, SRpcMsg *pMsg);
+int32_t sndProcessWriteMsg(SSnode *pSnode, SRpcMsg *pMsg, SRpcMsg *pRsp);
+int32_t sndProcessStreamMsg(SSnode *pSnode, SRpcMsg *pMsg);

 #ifdef __cplusplus
 }
--- a/include/libs/catalog/catalog.h
+++ b/include/libs/catalog/catalog.h
@ -203,6 +203,14 @@ int32_t catalogUpdateTableMeta(SCatalog* pCatalog, STableMetaRsp* rspMsg);

 int32_t catalogUpdateTableMeta(SCatalog* pCatalog, STableMetaRsp* rspMsg);

+int32_t catalogGetCachedTableMeta(SCatalog* pCtg, SRequestConnInfo* pConn, const SName* pTableName, STableMeta** pTableMeta);
+
+int32_t catalogGetCachedSTableMeta(SCatalog* pCtg, SRequestConnInfo* pConn, const SName* pTableName,
+                            STableMeta** pTableMeta);
+
+int32_t catalogGetCachedTableHashVgroup(SCatalog* pCtg, SRequestConnInfo* pConn, const SName* pTableName,
+                                  SVgroupInfo* pVgroup, bool* exists);
+
 /**
 * Force refresh DB's local cached vgroup info.
 * @param pCtg (input, got with catalogGetHandle)
--- a/include/libs/executor/executor.h
+++ b/include/libs/executor/executor.h
@ -89,6 +89,16 @@ qTaskInfo_t qCreateQueueExecTaskInfo(void* msg, SReadHandle* readers, int32_t* n
 */
 int32_t qSetMultiStreamInput(qTaskInfo_t tinfo, const void* pBlocks, size_t numOfBlocks, int32_t type);

+/**
+ * Set block for sma
+ * @param tinfo
+ * @param pBlocks
+ * @param numOfInputBlock
+ * @param type
+ * @return
+ */
+int32_t qSetSMAInput(qTaskInfo_t tinfo, const void* pBlocks, size_t numOfBlocks, int32_t type);
+
 /**
 * Update the table id list, add or remove.
 *
@ -169,6 +179,7 @@ int32_t qSerializeTaskStatus(qTaskInfo_t tinfo, char** pOutput, int32_t* len);

 int32_t qDeserializeTaskStatus(qTaskInfo_t tinfo, const char* pInput, int32_t len);

+STimeWindow getAlignQueryTimeWindow(SInterval* pInterval, int32_t precision, int64_t key);
 /**
 * return the scan info, in the form of tuple of two items, including table uid and current timestamp
 * @param tinfo
@ -200,9 +211,11 @@ int32_t qExtractStreamScanner(qTaskInfo_t tinfo, void** scanner);

 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);
+int32_t qStreamSetParamForRecover(qTaskInfo_t tinfo);
+int32_t qStreamSourceRecoverStep1(qTaskInfo_t tinfo, int64_t ver);
+int32_t qStreamSourceRecoverStep2(qTaskInfo_t tinfo, int64_t ver);
+int32_t qStreamRecoverFinish(qTaskInfo_t tinfo);
+int32_t qStreamRestoreParam(qTaskInfo_t tinfo);

 #ifdef __cplusplus
 }
--- a/include/libs/nodes/cmdnodes.h
+++ b/include/libs/nodes/cmdnodes.h
@ -374,6 +374,7 @@ typedef struct SStreamOptions {
  int8_t    triggerType;
  SNode*    pDelay;
  SNode*    pWatermark;
+  int8_t    fillHistory;
  int8_t    ignoreExpired;
 } SStreamOptions;

--- a/include/libs/nodes/plannodes.h
+++ b/include/libs/nodes/plannodes.h
@ -567,6 +567,7 @@ typedef struct SSubplan {
  SDataSinkNode* pDataSink;     // data of the subplan flow into the datasink
  SNode*         pTagCond;
  SNode*         pTagIndexCond;
+  bool           showRewrite;
 } SSubplan;

 typedef enum EExplainMode { EXPLAIN_MODE_DISABLE = 1, EXPLAIN_MODE_STATIC, EXPLAIN_MODE_ANALYZE } EExplainMode;
@ -585,8 +586,6 @@ typedef struct SQueryPlan {
  SExplainInfo explainInfo;
 } SQueryPlan;

-void nodesWalkPhysiPlan(SNode* pNode, FNodeWalker walker, void* pContext);
-
 const char* dataOrderStr(EDataOrderLevel order);

 #ifdef __cplusplus
--- a/include/libs/planner/planner.h
+++ b/include/libs/planner/planner.h
@ -61,7 +61,6 @@ int32_t qStringToSubplan(const char* pStr, SSubplan** pSubplan);
 int32_t qSubPlanToMsg(const SSubplan* pSubplan, char** pStr, int32_t* pLen);
 int32_t qMsgToSubplan(const char* pStr, int32_t len, SSubplan** pSubplan);

-char*       qQueryPlanToString(const SQueryPlan* pPlan);
 SQueryPlan* qStringToQueryPlan(const char* pStr);

 void qDestroyQueryPlan(SQueryPlan* pPlan);
--- a/include/libs/stream/streamState.h
+++ b/include/libs/stream/streamState.h
@ -99,6 +99,8 @@ int32_t streamStateSeekLast(SStreamState* pState, SStreamStateCur* pCur);
 int32_t streamStateCurNext(SStreamState* pState, SStreamStateCur* pCur);
 int32_t streamStateCurPrev(SStreamState* pState, SStreamStateCur* pCur);

+// char* streamStateSessionDump(SStreamState* pState);
+
 #ifdef __cplusplus
 }
 #endif
--- a/include/libs/stream/tstream.h
+++ b/include/libs/stream/tstream.h
@ -47,7 +47,9 @@ enum {
  TASK_STATUS__FAIL,
  TASK_STATUS__STOP,
  TASK_STATUS__RECOVER_DOWNSTREAM,
-  TASK_STATUS__RECOVER_SELF,
+  TASK_STATUS__RECOVER_PREPARE,
+  TASK_STATUS__RECOVER1,
+  TASK_STATUS__RECOVER2,
 };

 enum {
@ -329,6 +331,9 @@ typedef struct SStreamTask {
  // state backend
  SStreamState* pState;

+  // do not serialize
+  int32_t recoverWaitingChild;
+
 } SStreamTask;

 int32_t tEncodeStreamEpInfo(SEncoder* pEncoder, const SStreamChildEpInfo* pInfo);
@ -435,6 +440,20 @@ typedef struct {
  int32_t rspToTaskId;
 } SStreamRetrieveRsp;

+typedef struct {
+  int64_t streamId;
+  int32_t taskId;
+} SStreamRecoverStep1Req, SStreamRecoverStep2Req;
+
+typedef struct {
+  int64_t streamId;
+  int32_t taskId;
+  int32_t childId;
+} SStreamRecoverFinishReq;
+
+int32_t tEncodeSStreamRecoverFinishReq(SEncoder* pEncoder, const SStreamRecoverFinishReq* pReq);
+int32_t tDecodeSStreamRecoverFinishReq(SDecoder* pDecoder, SStreamRecoverFinishReq* pReq);
+
 #if 0
 typedef struct {
  int64_t streamId;
@ -521,8 +540,29 @@ int32_t streamProcessRetrieveRsp(SStreamTask* pTask, SStreamRetrieveRsp* pRsp);
 int32_t streamTryExec(SStreamTask* pTask);
 int32_t streamSchedExec(SStreamTask* pTask);

-typedef int32_t FTaskExpand(void* ahandle, SStreamTask* pTask);
+int32_t streamScanExec(SStreamTask* pTask, int32_t batchSz);

+// recover and fill history
+// common
+int32_t streamSetParamForRecover(SStreamTask* pTask);
+int32_t streamRestoreParam(SStreamTask* pTask);
+int32_t streamSetStatusNormal(SStreamTask* pTask);
+// source level
+int32_t streamSourceRecoverPrepareStep1(SStreamTask* pTask, int64_t ver);
+int32_t streamBuildSourceRecover1Req(SStreamTask* pTask, SStreamRecoverStep1Req* pReq);
+int32_t streamSourceRecoverScanStep1(SStreamTask* pTask);
+int32_t streamBuildSourceRecover2Req(SStreamTask* pTask, SStreamRecoverStep2Req* pReq);
+int32_t streamSourceRecoverScanStep2(SStreamTask* pTask, int64_t ver);
+int32_t streamDispatchRecoverFinishReq(SStreamTask* pTask);
+// agg level
+int32_t streamAggRecoverPrepare(SStreamTask* pTask);
+// int32_t streamAggChildrenRecoverFinish(SStreamTask* pTask);
+int32_t streamProcessRecoverFinishReq(SStreamTask* pTask, int32_t childId);
+
+// expand and deploy
+typedef int32_t FTaskExpand(void* ahandle, SStreamTask* pTask, int64_t ver);
+
+// meta
 typedef struct SStreamMeta {
  char*        path;
  TDB*         db;
@ -533,12 +573,13 @@ typedef struct SStreamMeta {
  void*        ahandle;
  TXN          txn;
  FTaskExpand* expandFunc;
+  int32_t      vgId;
 } SStreamMeta;

-SStreamMeta* streamMetaOpen(const char* path, void* ahandle, FTaskExpand expandFunc);
+SStreamMeta* streamMetaOpen(const char* path, void* ahandle, FTaskExpand expandFunc, int32_t vgId);
 void         streamMetaClose(SStreamMeta* streamMeta);

-// int32_t      streamMetaAddTask(SStreamMeta* pMeta, SStreamTask* pTask);
+int32_t      streamMetaAddTask(SStreamMeta* pMeta, int64_t ver, SStreamTask* pTask);
 int32_t      streamMetaAddSerializedTask(SStreamMeta* pMeta, int64_t startVer, char* msg, int32_t msgLen);
 int32_t      streamMetaRemoveTask(SStreamMeta* pMeta, int32_t taskId);
 SStreamTask* streamMetaGetTask(SStreamMeta* pMeta, int32_t taskId);
--- a/include/libs/sync/sync.h
+++ b/include/libs/sync/sync.h
@ -38,7 +38,7 @@ extern bool gRaftDetailLog;
 #define SYNC_DEL_WAL_MS              (1000 * 60)
 #define SYNC_ADD_QUORUM_COUNT        3
 #define SYNC_MNODE_LOG_RETENTION     10000
-#define SYNC_VNODE_LOG_RETENTION     500
+#define SYNC_VNODE_LOG_RETENTION     100

 #define SYNC_APPEND_ENTRIES_TIMEOUT_MS 10000

--- a/include/libs/sync/syncTools.h
+++ b/include/libs/sync/syncTools.h
@ -678,24 +678,61 @@ void syncReconfigFinishPrint2(char* s, const SyncReconfigFinish* pMsg);
 void syncReconfigFinishLog(const SyncReconfigFinish* pMsg);
 void syncReconfigFinishLog2(char* s, const SyncReconfigFinish* pMsg);

-// on message ----------------------
-int32_t syncNodeOnPingCb(SSyncNode* ths, SyncPing* pMsg);
-int32_t syncNodeOnPingReplyCb(SSyncNode* ths, SyncPingReply* pMsg);
-int32_t syncNodeOnTimer(SSyncNode* ths, SyncTimeout* pMsg);
+// ---------------------------------------------
+typedef enum {
+  SYNC_LOCAL_CMD_STEP_DOWN = 100,
+} ESyncLocalCmd;
+
+typedef struct SyncLocalCmd {
+  uint32_t bytes;
+  int32_t  vgId;
+  uint32_t msgType;
+  SRaftId  srcId;
+  SRaftId  destId;
+
+  int32_t  cmd;
+  SyncTerm sdNewTerm;  // step down new term
+
+} SyncLocalCmd;
+
+SyncLocalCmd* syncLocalCmdBuild(int32_t vgId);
+void          syncLocalCmdDestroy(SyncLocalCmd* pMsg);
+void          syncLocalCmdSerialize(const SyncLocalCmd* pMsg, char* buf, uint32_t bufLen);
+void          syncLocalCmdDeserialize(const char* buf, uint32_t len, SyncLocalCmd* pMsg);
+char*         syncLocalCmdSerialize2(const SyncLocalCmd* pMsg, uint32_t* len);
+SyncLocalCmd* syncLocalCmdDeserialize2(const char* buf, uint32_t len);
+void          syncLocalCmd2RpcMsg(const SyncLocalCmd* pMsg, SRpcMsg* pRpcMsg);
+void          syncLocalCmdFromRpcMsg(const SRpcMsg* pRpcMsg, SyncLocalCmd* pMsg);
+SyncLocalCmd* syncLocalCmdFromRpcMsg2(const SRpcMsg* pRpcMsg);
+cJSON*        syncLocalCmd2Json(const SyncLocalCmd* pMsg);
+char*         syncLocalCmd2Str(const SyncLocalCmd* pMsg);
+
+// for debug ----------------------
+void syncLocalCmdPrint(const SyncLocalCmd* pMsg);
+void syncLocalCmdPrint2(char* s, const SyncLocalCmd* pMsg);
+void syncLocalCmdLog(const SyncLocalCmd* pMsg);
+void syncLocalCmdLog2(char* s, const SyncLocalCmd* pMsg);
+
+// on message ----------------------
+int32_t syncNodeOnPing(SSyncNode* ths, SyncPing* pMsg);
+int32_t syncNodeOnPingReply(SSyncNode* ths, SyncPingReply* pMsg);

-int32_t syncNodeOnHeartbeat(SSyncNode* ths, SyncHeartbeat* pMsg);
-int32_t syncNodeOnHeartbeatReply(SSyncNode* ths, SyncHeartbeatReply* pMsg);
-int32_t syncNodeOnClientRequest(SSyncNode* ths, SyncClientRequest* pMsg, SyncIndex* pRetIndex);
 int32_t syncNodeOnRequestVote(SSyncNode* ths, SyncRequestVote* pMsg);
 int32_t syncNodeOnRequestVoteReply(SSyncNode* ths, SyncRequestVoteReply* pMsg);
+
 int32_t syncNodeOnAppendEntries(SSyncNode* ths, SyncAppendEntries* pMsg);
 int32_t syncNodeOnAppendEntriesReply(SSyncNode* ths, SyncAppendEntriesReply* pMsg);
+
 int32_t syncNodeOnSnapshot(SSyncNode* ths, SyncSnapshotSend* pMsg);
 int32_t syncNodeOnSnapshotReply(SSyncNode* ths, SyncSnapshotRsp* pMsg);

 int32_t syncNodeOnHeartbeat(SSyncNode* ths, SyncHeartbeat* pMsg);
 int32_t syncNodeOnHeartbeatReply(SSyncNode* ths, SyncHeartbeatReply* pMsg);

+int32_t syncNodeOnClientRequest(SSyncNode* ths, SyncClientRequest* pMsg, SyncIndex* pRetIndex);
+int32_t syncNodeOnTimer(SSyncNode* ths, SyncTimeout* pMsg);
+int32_t syncNodeOnLocalCmd(SSyncNode* ths, SyncLocalCmd* pMsg);
+
 // -----------------------------------------
 typedef int32_t (*FpOnPingCb)(SSyncNode* ths, SyncPing* pMsg);
 typedef int32_t (*FpOnPingReplyCb)(SSyncNode* ths, SyncPingReply* pMsg);
--- a/include/libs/wal/wal.h
+++ b/include/libs/wal/wal.h
@ -33,16 +33,16 @@ extern "C" {
 #define wTrace(...) { if (wDebugFlag & DEBUG_TRACE) { taosPrintLog("WAL ",       DEBUG_TRACE, wDebugFlag, __VA_ARGS__); }}
 // clang-format on

-#define WAL_PROTO_VER     0
-#define WAL_NOSUFFIX_LEN  20
-#define WAL_SUFFIX_AT     (WAL_NOSUFFIX_LEN + 1)
-#define WAL_LOG_SUFFIX    "log"
-#define WAL_INDEX_SUFFIX  "idx"
-#define WAL_REFRESH_MS    1000
-#define WAL_PATH_LEN      (TSDB_FILENAME_LEN + 12)
-#define WAL_FILE_LEN      (WAL_PATH_LEN + 32)
-#define WAL_MAGIC         0xFAFBFCFDF4F3F2F1ULL
-#define WAL_SCAN_BUF_SIZE (1024 * 1024 * 3)
+#define WAL_PROTO_VER        0
+#define WAL_NOSUFFIX_LEN     20
+#define WAL_SUFFIX_AT        (WAL_NOSUFFIX_LEN + 1)
+#define WAL_LOG_SUFFIX       "log"
+#define WAL_INDEX_SUFFIX     "idx"
+#define WAL_REFRESH_MS       1000
+#define WAL_PATH_LEN         (TSDB_FILENAME_LEN + 12)
+#define WAL_FILE_LEN         (WAL_PATH_LEN + 32)
+#define WAL_MAGIC            0xFAFBFCFDF4F3F2F1ULL
+#define WAL_SCAN_BUF_SIZE    (1024 * 1024 * 3)
 #define WAL_RECOV_SIZE_LIMIT (100 * WAL_SCAN_BUF_SIZE)

 typedef enum {
@ -204,7 +204,6 @@ SWalRef *walRefCommittedVer(SWal *);
 SWalRef *walOpenRef(SWal *);
 void     walCloseRef(SWal *pWal, int64_t refId);
 int32_t  walRefVer(SWalRef *, int64_t ver);
-int32_t  walPreRefVer(SWalRef *pRef, int64_t ver);
 void     walUnrefVer(SWalRef *);

 // helper function for raft
--- a/include/util/tdef.h
+++ b/include/util/tdef.h
@ -234,9 +234,9 @@ typedef enum ELogicConditionType {
 *  - Secondly, if all cols are VarDataT type except primary key, we need 4 bits to store the offset, thus
 *    the final value is 65531-(4096-1)*4 = 49151.
 */
-#define TSDB_MAX_BYTES_PER_ROW  49151
-#define TSDB_MAX_TAGS_LEN       16384
-#define TSDB_MAX_TAGS           128
+#define TSDB_MAX_BYTES_PER_ROW 49151
+#define TSDB_MAX_TAGS_LEN      16384
+#define TSDB_MAX_TAGS          128

 #define TSDB_MAX_COL_TAG_NUM  (TSDB_MAX_COLUMNS + TSDB_MAX_TAGS)
 #define TSDB_MAX_JSON_TAG_LEN 16384
@ -360,7 +360,7 @@ typedef enum ELogicConditionType {
 #define TSDB_DEFAULT_DB_SCHEMALESS      TSDB_DB_SCHEMALESS_OFF
 #define TSDB_MIN_STT_TRIGGER            1
 #define TSDB_MAX_STT_TRIGGER            16
-#define TSDB_DEFAULT_SST_TRIGGER        8
+#define TSDB_DEFAULT_SST_TRIGGER        1
 #define TSDB_MIN_HASH_PREFIX            0
 #define TSDB_MAX_HASH_PREFIX            128
 #define TSDB_DEFAULT_HASH_PREFIX        0
@ -370,13 +370,13 @@ typedef enum ELogicConditionType {

 #define TSDB_DB_MIN_WAL_RETENTION_PERIOD -1
 #define TSDB_REP_DEF_DB_WAL_RET_PERIOD   0
-#define TSDB_REPS_DEF_DB_WAL_RET_PERIOD  (24 * 60 * 60 * 4)
+#define TSDB_REPS_DEF_DB_WAL_RET_PERIOD  0
 #define TSDB_DB_MIN_WAL_RETENTION_SIZE   -1
 #define TSDB_REP_DEF_DB_WAL_RET_SIZE     0
-#define TSDB_REPS_DEF_DB_WAL_RET_SIZE    -1
+#define TSDB_REPS_DEF_DB_WAL_RET_SIZE    0
 #define TSDB_DB_MIN_WAL_ROLL_PERIOD      0
 #define TSDB_REP_DEF_DB_WAL_ROLL_PERIOD  0
-#define TSDB_REPS_DEF_DB_WAL_ROLL_PERIOD (24 * 60 * 60 * 1)
+#define TSDB_REPS_DEF_DB_WAL_ROLL_PERIOD 0
 #define TSDB_DB_MIN_WAL_SEGMENT_SIZE     0
 #define TSDB_DEFAULT_DB_WAL_SEGMENT_SIZE 0

@ -409,7 +409,7 @@ typedef enum ELogicConditionType {
 #define TSDB_MAX_RPC_THREADS 10
 #endif

-#define TSDB_QUERY_TYPE_NON_TYPE      0x00u  // none type
+#define TSDB_QUERY_TYPE_NON_TYPE 0x00u  // none type

 #define TSDB_META_COMPACT_RATIO 0  // disable tsdb meta compact by default

@ -486,7 +486,7 @@ enum {

 #define MAX_NUM_STR_SIZE 40

-#define MAX_META_MSG_IN_BATCH 1048576
+#define MAX_META_MSG_IN_BATCH   1048576
 #define MAX_META_BATCH_RSP_SIZE (1 * 1048576 * 1024)

 #ifdef __cplusplus
--- a/include/util/tfunctional.h
+++ b/include/util/tfunctional.h
@ -1,56 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-#ifndef _TD_UTIL_FUNCTIONAL_H_
-#define _TD_UTIL_FUNCTIONAL_H_
-
-#include "os.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// TODO: hard to use, trying to rewrite it using va_list
-
-typedef void* (*GenericVaFunc)(void* args[]);
-typedef int32_t (*I32VaFunc)(void* args[]);
-typedef void (*VoidVaFunc)(void* args[]);
-
-typedef struct GenericSavedFunc {
-  GenericVaFunc func;
-  void*         args[];
-} tGenericSavedFunc;
-
-typedef struct I32SavedFunc {
-  I32VaFunc func;
-  void*     args[];
-} tI32SavedFunc;
-
-typedef struct VoidSavedFunc {
-  VoidVaFunc func;
-  void*      args[];
-} tVoidSavedFunc;
-
-tGenericSavedFunc* genericSavedFuncInit(GenericVaFunc func, int32_t numOfArgs);
-tI32SavedFunc*     i32SavedFuncInit(I32VaFunc func, int32_t numOfArgs);
-tVoidSavedFunc*    voidSavedFuncInit(VoidVaFunc func, int32_t numOfArgs);
-void*              genericInvoke(tGenericSavedFunc* const pSavedFunc);
-int32_t            i32Invoke(tI32SavedFunc* const pSavedFunc);
-void               voidInvoke(tVoidSavedFunc* const pSavedFunc);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_UTIL_FUNCTIONAL_H_*/
--- a/include/util/tskiplist.h
+++ b/include/util/tskiplist.h
@ -19,7 +19,6 @@
 #include "os.h"
 #include "taos.h"
 #include "tarray.h"
-#include "tfunctional.h"

 #ifdef __cplusplus
 extern "C" {
@ -67,7 +66,6 @@ typedef struct SSkipList {
  uint32_t           size;
  SSkipListNode     *pHead;  // point to the first element
  SSkipListNode     *pTail;  // point to the last element
-  tGenericSavedFunc *insertHandleFn;
 } SSkipList;

 typedef struct SSkipListIterator {
--- a/packaging/cfg/taos.cfg
+++ b/packaging/cfg/taos.cfg
@ -5,42 +5,50 @@
 #                                                      #
 ########################################################

-# The end point of the first dnode in the cluster to be connected to when `taosd` or `taos` is started
+######### 0. Client only configurations #############
+
+# The interval for TDengine CLI to send heartbeat to mnode
+# shellActivityTimer        3
+
+
+############### 1. Cluster End point ############################
+
+# The end point of the first dnode in the cluster to be connected to when this dnode or a TDengine CLI `taos` is started
 # firstEp                   hostname:6030

-# The end point of the second dnode to be connected to if the firstEp is not available when `taosd` or `taos` is started
+# The end point of the second dnode to be connected to if the firstEp is not available
 # secondEp

-# The FQDN of the host where `taosd` will be started. It can be IP address
+
+############### 2. Configuration Parameters of current dnode #####
+
+# The FQDN of the host on which this dnode will be started. It can be IP address
 # fqdn                      hostname

-# The port for external access after `taosd` is started     
+# The port for external access after this dnode is started     
 # serverPort                6030

 # The maximum number of connections a dnode can accept
-# maxShellConns         5000
+# maxShellConns             5000

-# The directory for writing log files
+# The directory for writing log files, if you are using Windows platform please change to Windows path
 # logDir                    /var/log/taos

-# All data files are stored in this directory
+# All data files are stored in this directory, if you are using Windows platform please change to Windows path
 # dataDir                   /var/lib/taos

-# temporary file's directory
+# temporary file's directory, if you are using Windows platform please change to Windows path
 # tempDir                   /tmp/

 # Switch for allowing TDengine to collect and report service usage information
 # telemetryReporting        1

-# The maximum number of vnodes supported by dnode
+# The maximum number of vnodes supported by this dnode
 # supportVnodes             0

-# The interval of dnode reporting status to mnode
+# The interval of this dnode reporting status to mnode, [1..10] seconds
 # statusInterval            1

-# The interval for TDengine CLI to send heartbeat to mnode
-# shellActivityTimer        3
-
 # The minimum sliding window time, milli-second
 # minSlidingTime            10

@ -66,13 +74,14 @@

 # system time zone
 # timezone              Asia/Shanghai (CST, +0800)
+
 # system time zone (for windows 10)
 # timezone                  UTC-8

 # system locale
 # locale                    en_US.UTF-8

-# default system charset
+# system charset
 # charset                   UTF-8

 # stop writing logs when the disk size of the log folder is less than this value
@ -81,7 +90,7 @@
 # stop writing temporary files when the disk size of the tmp folder is less than this value
 # minimalTmpDirGB           1.0

-# if disk free space is less than this value, taosd service exit directly within startup process
+# if free disk space is less than this value, this dnode will fail to start
 # minimalDataDirGB          2.0

 # enable/disable system monitor 
@ -91,14 +100,18 @@
 # max number of lines per log filters
 # numOfLogLines             10000000

-# enable/disable async log
+# write log in async way: 1 - async, 0 - sync
 # asyncLog                  1

-# time of keeping log files, days
+# time period of keeping log files, in days
 # logKeepDays               0

-# The following parameters are used for debug purpose only.
-# debugFlag 8 bits mask: FILE-SCREEN-UNUSED-HeartBeat-DUMP-TRACE_WARN-ERROR
+
+############ 3. Debug Flag and levels #############################################
+
+# The following parameters are used for debug purpose only by this dnode.
+# debugFlag is a 8 bits mask: FILE-SCREEN-UNUSED-HeartBeat-DUMP-TRACE_WARN-ERROR
+# Available debug levels are: 
 # 131: output warning and error 
 # 135: output debug, warning and error
 # 143: output trace, debug, warning and error to log
@ -166,4 +179,4 @@
 # metaDebugFlag             131

 # generate core file when service crash
-# enableCoreFile            1
+# enableCoreFile            1
--- a/packaging/docker/DockerfileCloud
+++ b/packaging/docker/DockerfileCloud
@ -0,0 +1,26 @@
+FROM ubuntu:18.04
+
+WORKDIR /root
+
+ARG pkgFile
+ARG dirName
+ARG cpuType
+RUN echo ${pkgFile} && echo ${dirName}
+
+COPY ${pkgFile} /root/
+ENV TINI_VERSION v0.19.0
+ADD https://github.com/krallin/tini/releases/download/${TINI_VERSION}/tini-${cpuType} /tini
+ENV DEBIAN_FRONTEND=noninteractive
+WORKDIR /root/
+RUN tar -zxf ${pkgFile} && cd /root/${dirName}/ && /bin/bash install.sh -e no && cd /root && rm /root/${pkgFile} && rm -rf /root/${dirName} && apt-get update && apt-get install -y locales tzdata netcat && locale-gen en_US.UTF-8 && apt-get clean && rm -rf /var/lib/apt/lists/ && chmod +x /tini
+
+ENV LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/usr/lib" \
+    LC_CTYPE=en_US.UTF-8 \
+    LANG=en_US.UTF-8 \
+    LC_ALL=en_US.UTF-8
+COPY ./run.sh /usr/bin/
+COPY ./bin/* /usr/bin/
+
+ENTRYPOINT ["/tini", "--", "/usr/bin/entrypoint.sh"]
+CMD ["bash", "-c", "/usr/bin/run.sh"]
+VOLUME [ "/var/lib/taos", "/var/log/taos", "/corefile" ]
--- a/packaging/docker/dockerbuild.sh
+++ b/packaging/docker/dockerbuild.sh
@ -19,8 +19,9 @@ passWord=""
 pkgFile=""
 verType="stable"
 dockerLatest="n"
+cloudBuild="n"

-while getopts "hc:n:p:f:V:a:b:" arg
+while getopts "hc:n:p:f:V:a:b:d:" arg
 do
  case $arg in
    c)
@ -47,6 +48,10 @@ do
      #echo "verType=$OPTARG"
      verType=$(echo $OPTARG)
      ;;
+    d)
+      #echo "cloudBuild=$OPTARG"
+      cloudBuild=$(echo $OPTARG)
+      ;;
    a)
      #echo "dockerLatest=$OPTARG"
      dockerLatest=$(echo $OPTARG)
@ -58,6 +63,7 @@ do
      echo "                      -V [stable | beta] "
      echo "                      -f [pkg file] "
      echo "                      -a [y | n ]   "
+      echo "                      -d [cloud build ] "
      exit 0
      ;;
    ?) #unknow option 
@ -83,6 +89,9 @@ else
  echo "unknow verType, nor stabel or beta"
  exit 1
 fi
+if [ "$cloudBuild" == "y" ]; then
+  dockername=cloud-${dockername}
+fi


 echo "cpuType=${cpuType} version=${version} pkgFile=${pkgFile} verType=${verType} "
@ -90,10 +99,15 @@ echo "$(pwd)"
 echo "====NOTES: ${pkgFile} must be in the same directory as dockerbuild.sh===="

 scriptDir=$(dirname $(readlink -f $0))
-comunityArchiveDir=/nas/TDengine/v$version/community   # community version’package directory
 communityDir=${scriptDir}/../../../community
 DockerfilePath=${communityDir}/packaging/docker/
-Dockerfile=${communityDir}/packaging/docker/Dockerfile
+if [ "$cloudBuild" == "y" ]; then
+  comunityArchiveDir=/nas/TDengine/v$version/cloud
+  Dockerfile=${communityDir}/packaging/docker/DockerfileCloud
+else
+  comunityArchiveDir=/nas/TDengine/v$version/community
+  Dockerfile=${communityDir}/packaging/docker/Dockerfile
+fi
 cd ${scriptDir}
 cp -f ${comunityArchiveDir}/${pkgFile}  .

@ -111,42 +125,15 @@ else
 fi

 docker build --rm -f "${Dockerfile}"  --network=host -t tdengine/tdengine-${dockername}:${version} "." --build-arg pkgFile=${pkgFile} --build-arg dirName=${dirName} --build-arg cpuType=${cpuTypeAlias}
-docker login -u tdengine -p ${passWord}  #replace the docker registry username and password
-docker push tdengine/tdengine-${dockername}:${version}
-
-if [ -n "$(docker ps -aq)" ] ;then 
-  echo "delete docker process"
-  docker stop $(docker ps -aq)
-  docker rm $(docker ps -aq)
+if [ "$cloudBuild" != "y" ]; then
+  docker login -u tdengine -p ${passWord}  #replace the docker registry username and password
+  docker push tdengine/tdengine-${dockername}:${version}
 fi

-if [  -n "$(pidof taosd)" ] ;then
-   echo "kill taosd "
-   kill -9 $(pidof taosd)
-fi
-
-if [ -n "$(pidof power)" ]  ;then
-  echo "kill power "
-  kill -9 $(pidof power)
-fi
-
-
-echo ">>>>>>>>>>>>> check whether  tdengine/tdengine-${dockername}:${version}  has been published"
-docker run -d --name doctest -p 6030-6049:6030-6049 -p 6030-6049:6030-6049/udp  tdengine/tdengine-${dockername}:${version}
-sleep 2
-curl -u root:taosdata -d 'show variables;'  127.0.0.1:6041/rest/sql > temp1.data
-data_version=$( cat temp1.data |jq .data| jq '.[]' |grep "version" -A 2 -B 1  | jq ".[1]")
-echo "${data_version}" 
-if [ "${data_version}" == "\"${version}\"" ] ; then
-    echo  "docker version is right "
-else
-    echo  "docker version is wrong "
-    exit 1
-fi
-rm -rf  temp1.data
-
 # set this version to latest version 
-if  [ ${dockerLatest} == 'y' ]  ;then
+if  [ "$cloudBuild" != "y" ] && [ ${dockerLatest} == 'y' ]  ;then
  docker tag tdengine/tdengine-${dockername}:${version} tdengine/tdengine-${dockername}:latest
  docker push tdengine/tdengine-${dockername}:latest
 fi
+
+rm -f ${pkgFile}
--- a/packaging/docker/run.sh
+++ b/packaging/docker/run.sh
@ -0,0 +1,36 @@
+#!/bin/bash
+TAOS_RUN_TAOSBENCHMARK_TEST_ONCE=0
+while ((1))
+do
+    # echo "outer loop: $a"
+    sleep 10
+    output=`taos -k`
+    status=${output:0:1}
+    # echo $output
+    # echo $status
+    if [ "$status"x = "0"x ]
+    then
+        taosd &
+    fi
+    # echo "$status"x "$TAOS_RUN_TAOSBENCHMARK_TEST"x "$TAOS_RUN_TAOSBENCHMARK_TEST_ONCE"x
+    if [ "$status"x = "2"x ] && [ "$TAOS_RUN_TAOSBENCHMARK_TEST"x = "1"x ] && [ "$TAOS_RUN_TAOSBENCHMARK_TEST_ONCE"x = "0"x ]
+    then
+        TAOS_RUN_TAOSBENCHMARK_TEST_ONCE=1
+        # result=`taos -s "show databases;" | grep " test "`
+        # if [ "${result:0:5}"x != " test"x ]
+        # then
+        #     taosBenchmark -y -t 1000 -n 1000 -S 900000
+        # fi
+        taos -s "select stable_name from information_schema.ins_stables where db_name = 'test';"|grep -q -w meters
+        if [ $? -ne 0 ]; then
+            taosBenchmark -y -t 1000 -n 1000 -S 900000
+	    taos -s "create user admin_user pass 'NDS65R6t' sysinfo 0;"
+	    taos -s "GRANT ALL on test.* to admin_user;"
+        fi
+    fi
+    # check taosadapter
+    nc -z localhost 6041
+    if [ $? -ne 0 ]; then
+	taosadapter &
+    fi
+done
--- a/packaging/release.sh
+++ b/packaging/release.sh
@ -17,7 +17,7 @@ set -e
 #             -H [ false | true]

 # set parameters by default value
-verMode=edge    # [cluster, edge]
+verMode=edge    # [cluster, edge, cloud]
 verType=stable  # [stable, beta]
 cpuType=x64     # [aarch32 | aarch64 | x64 | x86 | mips64 ...]
 osType=Linux    # [Linux | Kylin | Alpine | Raspberrypi | Darwin | Windows | Ningsi60 | Ningsi80 |...]
@ -169,7 +169,7 @@ build_time=$(date +"%F %R")
 # get commint id from git
 gitinfo=$(git rev-parse --verify HEAD)

-if [[ "$verMode" == "cluster" ]]; then
+if [[ "$verMode" == "cluster" ]] || [[ "$verMode" == "cloud" ]]; then
  enterprise_dir="${top_dir}/../enterprise"
  cd ${enterprise_dir}
  gitinfoOfInternal=$(git rev-parse --verify HEAD)
@ -205,7 +205,7 @@ else
  BUILD_HTTP=false
 fi

-if [[ "$verMode" == "cluster" ]]; then
+if [[ "$verMode" == "cluster" ]] || [[ "$verMode" == "cloud" ]]; then
  BUILD_HTTP=internal
 fi

@ -217,10 +217,12 @@ fi

 # check support cpu type
 if [[ "$cpuType" == "x64" ]] || [[ "$cpuType" == "aarch64" ]] || [[ "$cpuType" == "aarch32" ]] || [[ "$cpuType" == "arm64" ]] || [[ "$cpuType" == "arm32" ]] || [[ "$cpuType" == "mips64" ]]; then
-  if [ "$verMode" != "cluster" ]; then
+  if [ "$verMode" == "edge" ]; then
    # community-version compile
    cmake ../ -DCPUTYPE=${cpuType} -DWEBSOCKET=true -DOSTYPE=${osType} -DSOMODE=${soMode} -DDBNAME=${dbName} -DVERTYPE=${verType} -DVERDATE="${build_time}" -DGITINFO=${gitinfo} -DGITINFOI=${gitinfoOfInternal} -DVERNUMBER=${verNumber} -DVERCOMPATIBLE=${verNumberComp} -DPAGMODE=${pagMode} -DBUILD_HTTP=${BUILD_HTTP} -DBUILD_TOOLS=${BUILD_TOOLS} ${allocator_macro}
-  else
+  elif [ "$verMode" == "cloud" ]; then
+    cmake ../../ -DCPUTYPE=${cpuType} -DWEBSOCKET=true -DBUILD_CLOUD=true -DOSTYPE=${osType} -DSOMODE=${soMode} -DDBNAME=${dbName} -DVERTYPE=${verType} -DVERDATE="${build_time}" -DGITINFO=${gitinfo} -DGITINFOI=${gitinfoOfInternal} -DVERNUMBER=${verNumber} -DVERCOMPATIBLE=${verNumberComp} -DBUILD_HTTP=${BUILD_HTTP} -DBUILD_TOOLS=${BUILD_TOOLS} ${allocator_macro}
+  elif [ "$verMode" == "cluster" ]; then
    if [[ "$dbName" != "taos" ]]; then
      replace_enterprise_$dbName
    fi
@ -244,7 +246,7 @@ cd ${curr_dir}

 # 3. Call the corresponding script for packaging
 if [ "$osType" != "Darwin" ]; then
-  if [[ "$verMode" != "cluster" ]] && [[ "$pagMode" == "full" ]] && [[ "$cpuType" == "x64" ]] && [[ "$dbName" == "taos" ]]; then
+  if [[ "$verMode" != "cluster" ]] && [[ "$verMode" != "cloud" ]] && [[ "$pagMode" == "full" ]] && [[ "$cpuType" == "x64" ]] && [[ "$dbName" == "taos" ]]; then
    ret='0'
    command -v dpkg >/dev/null 2>&1 || { ret='1'; }
    if [ "$ret" -eq 0 ]; then
--- a/packaging/tools/make_install.bat
+++ b/packaging/tools/make_install.bat
@ -47,6 +47,15 @@ copy %binary_dir%\\build\\bin\\udfd.exe %tagert_dir% > nul
 if exist %binary_dir%\\build\\bin\\taosBenchmark.exe (
    copy %binary_dir%\\build\\bin\\taosBenchmark.exe %tagert_dir% > nul
 )
+if exist %binary_dir%\\build\\lib\\taosws.dll.lib (
+    copy %binary_dir%\\build\\lib\\taosws.dll.lib %tagert_dir%\\driver  > nul
+)
+if exist %binary_dir%\\build\\lib\\taosws.dll (
+    copy %binary_dir%\\build\\lib\\taosws.dll %tagert_dir%\\driver  > nul
+)
+if exist %binary_dir%\\build\\bin\\taosdump.exe (
+    copy %binary_dir%\\build\\bin\\taosdump.exe %tagert_dir% > nul
+)
 if exist %binary_dir%\\build\\bin\\taosadapter.exe (
    copy %binary_dir%\\build\\bin\\taosadapter.exe %tagert_dir% > nul
 )
@ -54,4 +63,7 @@ if exist %binary_dir%\\build\\bin\\taosadapter.exe (
 mshta vbscript:createobject("shell.application").shellexecute("%~s0",":hasAdmin","","runas",1)(window.close)&& echo To start/stop TDengine with administrator privileges: sc start/stop taosd &goto :eof
 :hasAdmin
 copy /y C:\\TDengine\\driver\\taos.dll C:\\Windows\\System32 > nul
+if exist C:\\TDengine\\driver\\taosws.dll (
+    copy /y C:\\TDengine\\driver\\taosws.dll C:\\Windows\\System32 > nul
+)
 sc query "taosd" >nul || sc create "taosd" binPath= "C:\\TDengine\\taosd.exe --win_service" start= DEMAND
--- a/packaging/tools/makeclient.sh
+++ b/packaging/tools/makeclient.sh
@ -39,6 +39,8 @@ release_dir="${top_dir}/release"

 if [ "$verMode" == "cluster" ]; then
  install_dir="${release_dir}/${productName}-enterprise-client-${version}"
+elif [ "$verMode" == "cloud" ]; then
+  install_dir="${release_dir}/${productName}-cloud-client-${version}"
 else
  install_dir="${release_dir}/${productName}-client-${version}"
 fi
@ -138,6 +140,10 @@ if [ "$verMode" == "cluster" ]; then
  sed 's/verMode=edge/verMode=cluster/g' ${install_dir}/install_client.sh >>install_client_temp.sh
  mv install_client_temp.sh ${install_dir}/install_client.sh
 fi
+if [ "$verMode" == "cloud" ]; then
+  sed 's/verMode=edge/verMode=cloud/g' ${install_dir}/install_client.sh >>install_client_temp.sh
+  mv install_client_temp.sh ${install_dir}/install_client.sh
+fi

 if [ "$pagMode" == "lite" ]; then
  sed 's/pagMode=full/pagMode=lite/g' ${install_dir}/install_client.sh >>install_client_temp.sh
@ -161,7 +167,7 @@ if [[ $productName == "TDengine" ]]; then
    mkdir -p ${install_dir}/examples/taosbenchmark-json && cp ${examples_dir}/../tools/taos-tools/example/* ${install_dir}/examples/taosbenchmark-json
  fi

-  if [ "$verMode" == "cluster" ]; then
+  if [ "$verMode" == "cluster" ] || [ "$verMode" == "cloud" ]; then
      # Copy connector
      connector_dir="${code_dir}/connector"
      mkdir -p ${install_dir}/connector
--- a/packaging/tools/makepkg.sh
+++ b/packaging/tools/makepkg.sh
@ -39,6 +39,8 @@ release_dir="${top_dir}/release"
 #package_name='linux'
 if [ "$verMode" == "cluster" ]; then
  install_dir="${release_dir}/${productName}-enterprise-server-${version}"
+elif [ "$verMode" == "cloud" ]; then
+  install_dir="${release_dir}/${productName}-cloud-server-${version}"
 else
  install_dir="${release_dir}/${productName}-server-${version}"
 fi
@ -217,7 +219,10 @@ fi
 if [ "$verMode" == "cluster" ]; then
  sed 's/verMode=edge/verMode=cluster/g' ${install_dir}/bin/remove.sh >>remove_temp.sh
  mv remove_temp.sh ${install_dir}/bin/remove.sh
-
+fi
+if [ "$verMode" == "cloud" ]; then
+  sed 's/verMode=edge/verMode=cloud/g' ${install_dir}/bin/remove.sh >>remove_temp.sh
+  mv remove_temp.sh ${install_dir}/bin/remove.sh
 fi

 cd ${install_dir}
@ -234,6 +239,10 @@ if [ "$verMode" == "cluster" ]; then
  sed 's/verMode=edge/verMode=cluster/g' ${install_dir}/install.sh >>install_temp.sh
  mv install_temp.sh ${install_dir}/install.sh
 fi
+if [ "$verMode" == "cloud" ]; then
+  sed 's/verMode=edge/verMode=cloud/g' ${install_dir}/install.sh >>install_temp.sh
+  mv install_temp.sh ${install_dir}/install.sh
+fi
 if [ "$pagMode" == "lite" ]; then
  sed 's/pagMode=full/pagMode=lite/g' ${install_dir}/install.sh >>install_temp.sh
  mv install_temp.sh ${install_dir}/install.sh
@ -288,7 +297,7 @@ mkdir -p ${install_dir}/driver && cp ${lib_files} ${install_dir}/driver && echo
 [ -f ${wslib_files} ] && cp ${wslib_files} ${install_dir}/driver || :

 # Copy connector
-if [ "$verMode" == "cluster" ]; then
+if [ "$verMode" == "cluster" ] || [ "$verMode" == "cloud" ]; then
    connector_dir="${code_dir}/connector"
    mkdir -p ${install_dir}/connector
    if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
--- a/source/client/inc/clientLog.h
+++ b/source/client/inc/clientLog.h
@ -30,7 +30,7 @@ extern "C" {
 #define tscDebug(...)  do { if (cDebugFlag & DEBUG_DEBUG) { taosPrintLog("TSC ", DEBUG_DEBUG, cDebugFlag, __VA_ARGS__); }} while(0)
 #define tscTrace(...)  do { if (cDebugFlag & DEBUG_TRACE) { taosPrintLog("TSC ", DEBUG_TRACE, cDebugFlag, __VA_ARGS__); }} while(0)
 #define tscDebugL(...) do { if (cDebugFlag & DEBUG_DEBUG) { taosPrintLongString("TSC ", DEBUG_DEBUG, cDebugFlag, __VA_ARGS__); }} while(0)
-#define tscPerf(...)   do { taosPrintLog("TSC ", 0, cDebugFlag, __VA_ARGS__); } while(0)
+//#define tscPerf(...)   do { if (cDebugFlag & DEBUG_INFO)  { taosPrintLog("TSC ", DEBUG_INFO, cDebugFlag, __VA_ARGS__); }} while(0)
 // clang-format on

 #ifdef __cplusplus
--- a/source/client/src/clientEnv.c
+++ b/source/client/src/clientEnv.c
@ -77,19 +77,19 @@ static void deregisterRequest(SRequestObj *pRequest) {
           pRequest->self, pTscObj->id, pRequest->requestId, duration / 1000.0, num, currentInst);

  if (QUERY_NODE_VNODE_MODIF_STMT == pRequest->stmtType) {
-    tscPerf("insert duration %" PRId64 "us: syntax:%" PRId64 "us, ctg:%" PRId64 "us, semantic:%" PRId64
-            "us, exec:%" PRId64 "us",
-            duration, pRequest->metric.syntaxEnd - pRequest->metric.syntaxStart,
-            pRequest->metric.ctgEnd - pRequest->metric.ctgStart, pRequest->metric.semanticEnd - pRequest->metric.ctgEnd,
-            pRequest->metric.execEnd - pRequest->metric.semanticEnd);
+//    tscPerf("insert duration %" PRId64 "us: syntax:%" PRId64 "us, ctg:%" PRId64 "us, semantic:%" PRId64
+//            "us, exec:%" PRId64 "us",
+//            duration, pRequest->metric.syntaxEnd - pRequest->metric.syntaxStart,
+//            pRequest->metric.ctgEnd - pRequest->metric.ctgStart, pRequest->metric.semanticEnd - pRequest->metric.ctgEnd,
+//            pRequest->metric.execEnd - pRequest->metric.semanticEnd);
    atomic_add_fetch_64((int64_t *)&pActivity->insertElapsedTime, duration);
  } else if (QUERY_NODE_SELECT_STMT == pRequest->stmtType) {
-    tscPerf("select duration %" PRId64 "us: syntax:%" PRId64 "us, ctg:%" PRId64 "us, semantic:%" PRId64
-            "us, planner:%" PRId64 "us, exec:%" PRId64 "us, reqId:0x%" PRIx64,
-            duration, pRequest->metric.syntaxEnd - pRequest->metric.syntaxStart,
-            pRequest->metric.ctgEnd - pRequest->metric.ctgStart, pRequest->metric.semanticEnd - pRequest->metric.ctgEnd,
-            pRequest->metric.planEnd - pRequest->metric.semanticEnd,
-            pRequest->metric.resultReady - pRequest->metric.planEnd, pRequest->requestId);
+//    tscPerf("select duration %" PRId64 "us: syntax:%" PRId64 "us, ctg:%" PRId64 "us, semantic:%" PRId64
+//            "us, planner:%" PRId64 "us, exec:%" PRId64 "us, reqId:0x%" PRIx64,
+//            duration, pRequest->metric.syntaxEnd - pRequest->metric.syntaxStart,
+//            pRequest->metric.ctgEnd - pRequest->metric.ctgStart, pRequest->metric.semanticEnd - pRequest->metric.ctgEnd,
+//            pRequest->metric.planEnd - pRequest->metric.semanticEnd,
+//            pRequest->metric.resultReady - pRequest->metric.planEnd, pRequest->requestId);

    atomic_add_fetch_64((int64_t *)&pActivity->queryElapsedTime, duration);
  }
--- a/source/client/src/clientTmq.c
+++ b/source/client/src/clientTmq.c
@ -1619,7 +1619,7 @@ void* tmqHandleAllRsp(tmq_t* tmq, int64_t timeout, bool pollIfReset) {
      taosGetQitem(tmq->qall, (void**)&rspWrapper);

      if (rspWrapper == NULL) {
-        tscDebug("consumer %" PRId64 " mqueue empty", tmq->consumerId);
+        /*tscDebug("consumer %" PRId64 " mqueue empty", tmq->consumerId);*/
        return NULL;
      }
    }
@ -1732,6 +1732,7 @@ TAOS_RES* tmq_consumer_poll(tmq_t* tmq, int64_t timeout) {

  // in no topic status, delayed task also need to be processed
  if (atomic_load_8(&tmq->status) == TMQ_CONSUMER_STATUS__INIT) {
+    tscDebug("consumer:%" PRId64 ", poll return since consumer status is init", tmq->consumerId);
    return NULL;
  }

--- a/source/common/src/systable.c
+++ b/source/common/src/systable.c
@ -270,7 +270,7 @@ static const SSysTableMeta infosMeta[] = {
    {TSDB_INS_TABLE_MNODES, mnodesSchema, tListLen(mnodesSchema), true},
    {TSDB_INS_TABLE_MODULES, modulesSchema, tListLen(modulesSchema), true},
    {TSDB_INS_TABLE_QNODES, qnodesSchema, tListLen(qnodesSchema), true},
-    //    {TSDB_INS_TABLE_SNODES, snodesSchema, tListLen(snodesSchema)},
+    {TSDB_INS_TABLE_SNODES, snodesSchema, tListLen(snodesSchema)},
    {TSDB_INS_TABLE_CLUSTER, clusterSchema, tListLen(clusterSchema), true},
    {TSDB_INS_TABLE_DATABASES, userDBSchema, tListLen(userDBSchema), false},
    {TSDB_INS_TABLE_FUNCTIONS, userFuncSchema, tListLen(userFuncSchema), false},
--- a/source/common/src/tglobal.c
+++ b/source/common/src/tglobal.c
@ -55,8 +55,8 @@ int32_t tsNumOfVnodeSyncThreads = 2;
 int32_t tsNumOfVnodeRsmaThreads = 2;
 int32_t tsNumOfQnodeQueryThreads = 4;
 int32_t tsNumOfQnodeFetchThreads = 1;
-int32_t tsNumOfSnodeSharedThreads = 2;
-int32_t tsNumOfSnodeUniqueThreads = 2;
+int32_t tsNumOfSnodeStreamThreads = 4;
+int32_t tsNumOfSnodeWriteThreads = 1;

 // monitor
 bool     tsEnableMonitor = true;
@ -82,6 +82,7 @@ bool tsSmlDataFormat = false;
 // query
 int32_t tsQueryPolicy = 1;
 int32_t tsQueryRspPolicy = 0;
+bool    tsEnableQueryHb = false;
 int32_t tsQuerySmaOptimize = 0;
 int32_t tsQueryRsmaTolerance = 1000;  // the tolerance time (ms) to judge from which level to query rsma data.
 bool    tsQueryPlannerTrace = false;
@ -132,7 +133,7 @@ int32_t  tsDiskCfgNum = 0;
 SDiskCfg tsDiskCfg[TFS_MAX_DISKS] = {0};

 // stream scheduler
-bool tsSchedStreamToSnode = true;
+bool tsDeployOnSnode = true;

 /*
 * minimum scale for whole system, millisecond by default
@ -284,6 +285,7 @@ static int32_t taosAddClientCfg(SConfig *pCfg) {
  if (cfgAddInt32(pCfg, "compressMsgSize", tsCompressMsgSize, -1, 100000000, 1) != 0) return -1;
  if (cfgAddInt32(pCfg, "compressColData", tsCompressColData, -1, 100000000, 1) != 0) return -1;
  if (cfgAddInt32(pCfg, "queryPolicy", tsQueryPolicy, 1, 4, 1) != 0) return -1;
+  if (cfgAddBool(pCfg, "enableQueryHb", tsEnableQueryHb, false) != 0) return -1;
  if (cfgAddInt32(pCfg, "querySmaOptimize", tsQuerySmaOptimize, 0, 1, 1) != 0) return -1;
  if (cfgAddBool(pCfg, "queryPlannerTrace", tsQueryPlannerTrace, true) != 0) return -1;
  if (cfgAddInt32(pCfg, "queryNodeChunkSize", tsQueryNodeChunkSize, 1024, 128 * 1024, true) != 0) return -1;
@ -388,13 +390,13 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
  //  tsNumOfQnodeFetchThreads = TMAX(tsNumOfQnodeFetchThreads, 4);
  //  if (cfgAddInt32(pCfg, "numOfQnodeFetchThreads", tsNumOfQnodeFetchThreads, 1, 1024, 0) != 0) return -1;

-  tsNumOfSnodeSharedThreads = tsNumOfCores / 4;
-  tsNumOfSnodeSharedThreads = TRANGE(tsNumOfSnodeSharedThreads, 2, 4);
-  if (cfgAddInt32(pCfg, "numOfSnodeSharedThreads", tsNumOfSnodeSharedThreads, 2, 1024, 0) != 0) return -1;
+  tsNumOfSnodeStreamThreads = tsNumOfCores / 4;
+  tsNumOfSnodeStreamThreads = TRANGE(tsNumOfSnodeStreamThreads, 2, 4);
+  if (cfgAddInt32(pCfg, "numOfSnodeSharedThreads", tsNumOfSnodeStreamThreads, 2, 1024, 0) != 0) return -1;

-  tsNumOfSnodeUniqueThreads = tsNumOfCores / 4;
-  tsNumOfSnodeUniqueThreads = TRANGE(tsNumOfSnodeUniqueThreads, 2, 4);
-  if (cfgAddInt32(pCfg, "numOfSnodeUniqueThreads", tsNumOfSnodeUniqueThreads, 2, 1024, 0) != 0) return -1;
+  tsNumOfSnodeWriteThreads = tsNumOfCores / 4;
+  tsNumOfSnodeWriteThreads = TRANGE(tsNumOfSnodeWriteThreads, 2, 4);
+  if (cfgAddInt32(pCfg, "numOfSnodeUniqueThreads", tsNumOfSnodeWriteThreads, 2, 1024, 0) != 0) return -1;

  tsRpcQueueMemoryAllowed = tsTotalMemoryKB * 1024 * 0.1;
  tsRpcQueueMemoryAllowed = TRANGE(tsRpcQueueMemoryAllowed, TSDB_MAX_MSG_SIZE * 10LL, TSDB_MAX_MSG_SIZE * 10000LL);
@ -540,17 +542,17 @@ static int32_t taosUpdateServerCfg(SConfig *pCfg) {

  pItem = cfgGetItem(tsCfg, "numOfSnodeSharedThreads");
  if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {
-    tsNumOfSnodeSharedThreads = numOfCores / 4;
-    tsNumOfSnodeSharedThreads = TRANGE(tsNumOfSnodeSharedThreads, 2, 4);
-    pItem->i32 = tsNumOfSnodeSharedThreads;
+    tsNumOfSnodeStreamThreads = numOfCores / 4;
+    tsNumOfSnodeStreamThreads = TRANGE(tsNumOfSnodeStreamThreads, 2, 4);
+    pItem->i32 = tsNumOfSnodeStreamThreads;
    pItem->stype = stype;
  }

  pItem = cfgGetItem(tsCfg, "numOfSnodeUniqueThreads");
  if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {
-    tsNumOfSnodeUniqueThreads = numOfCores / 4;
-    tsNumOfSnodeUniqueThreads = TRANGE(tsNumOfSnodeUniqueThreads, 2, 4);
-    pItem->i32 = tsNumOfSnodeUniqueThreads;
+    tsNumOfSnodeWriteThreads = numOfCores / 4;
+    tsNumOfSnodeWriteThreads = TRANGE(tsNumOfSnodeWriteThreads, 2, 4);
+    pItem->i32 = tsNumOfSnodeWriteThreads;
    pItem->stype = stype;
  }

@ -644,6 +646,7 @@ static int32_t taosSetClientCfg(SConfig *pCfg) {
  tsCompressColData = cfgGetItem(pCfg, "compressColData")->i32;
  tsNumOfTaskQueueThreads = cfgGetItem(pCfg, "numOfTaskQueueThreads")->i32;
  tsQueryPolicy = cfgGetItem(pCfg, "queryPolicy")->i32;
+  tsEnableQueryHb = cfgGetItem(pCfg, "enableQueryHb")->bval;
  tsQuerySmaOptimize = cfgGetItem(pCfg, "querySmaOptimize")->i32;
  tsQueryPlannerTrace = cfgGetItem(pCfg, "queryPlannerTrace")->bval;
  tsQueryNodeChunkSize = cfgGetItem(pCfg, "queryNodeChunkSize")->i32;
@ -693,8 +696,8 @@ static int32_t taosSetServerCfg(SConfig *pCfg) {
  tsNumOfVnodeRsmaThreads = cfgGetItem(pCfg, "numOfVnodeRsmaThreads")->i32;
  tsNumOfQnodeQueryThreads = cfgGetItem(pCfg, "numOfQnodeQueryThreads")->i32;
  //  tsNumOfQnodeFetchThreads = cfgGetItem(pCfg, "numOfQnodeFetchThreads")->i32;
-  tsNumOfSnodeSharedThreads = cfgGetItem(pCfg, "numOfSnodeSharedThreads")->i32;
-  tsNumOfSnodeUniqueThreads = cfgGetItem(pCfg, "numOfSnodeUniqueThreads")->i32;
+  tsNumOfSnodeStreamThreads = cfgGetItem(pCfg, "numOfSnodeSharedThreads")->i32;
+  tsNumOfSnodeWriteThreads = cfgGetItem(pCfg, "numOfSnodeUniqueThreads")->i32;
  tsRpcQueueMemoryAllowed = cfgGetItem(pCfg, "rpcQueueMemoryAllowed")->i64;

  tsEnableMonitor = cfgGetItem(pCfg, "monitor")->bval;
@ -780,6 +783,8 @@ int32_t taosSetCfg(SConfig *pCfg, char *name) {
      if (strcasecmp("enableCoreFile", name) == 0) {
        bool enableCore = cfgGetItem(pCfg, "enableCoreFile")->bval;
        taosSetCoreDump(enableCore);
+      } else if (strcasecmp("enableQueryHb", name) == 0) {
+        tsEnableQueryHb = cfgGetItem(pCfg, "enableQueryHb")->bval;
      }
      break;
    }
@ -941,9 +946,9 @@ int32_t taosSetCfg(SConfig *pCfg, char *name) {
                tsNumOfQnodeFetchThreads = cfgGetItem(pCfg, "numOfQnodeFetchThreads")->i32;
        */
      } else if (strcasecmp("numOfSnodeSharedThreads", name) == 0) {
-        tsNumOfSnodeSharedThreads = cfgGetItem(pCfg, "numOfSnodeSharedThreads")->i32;
+        tsNumOfSnodeStreamThreads = cfgGetItem(pCfg, "numOfSnodeSharedThreads")->i32;
      } else if (strcasecmp("numOfSnodeUniqueThreads", name) == 0) {
-        tsNumOfSnodeUniqueThreads = cfgGetItem(pCfg, "numOfSnodeUniqueThreads")->i32;
+        tsNumOfSnodeWriteThreads = cfgGetItem(pCfg, "numOfSnodeUniqueThreads")->i32;
      } else if (strcasecmp("numOfLogLines", name) == 0) {
        tsNumOfLogLines = cfgGetItem(pCfg, "numOfLogLines")->i32;
      }
--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@ -4853,6 +4853,7 @@ int32_t tSerializeSCMCreateStreamReq(void *buf, int32_t bufLen, const SCMCreateS
  if (tEncodeCStr(&encoder, pReq->sourceDB) < 0) return -1;
  if (tEncodeCStr(&encoder, pReq->targetStbFullName) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->igExists) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->fillHistory) < 0) return -1;
  if (tEncodeI32(&encoder, sqlLen) < 0) return -1;
  if (tEncodeI32(&encoder, astLen) < 0) return -1;
  if (tEncodeI8(&encoder, pReq->triggerType) < 0) return -1;
@ -4889,6 +4890,7 @@ int32_t tDeserializeSCMCreateStreamReq(void *buf, int32_t bufLen, SCMCreateStrea
  if (tDecodeCStrTo(&decoder, pReq->sourceDB) < 0) return -1;
  if (tDecodeCStrTo(&decoder, pReq->targetStbFullName) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->igExists) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->fillHistory) < 0) return -1;
  if (tDecodeI32(&decoder, &sqlLen) < 0) return -1;
  if (tDecodeI32(&decoder, &astLen) < 0) return -1;
  if (tDecodeI8(&decoder, &pReq->triggerType) < 0) return -1;
@ -4994,6 +4996,7 @@ int32_t tDeserializeSMRecoverStreamReq(void *buf, int32_t bufLen, SMRecoverStrea
 }

 void tFreeSCMCreateStreamReq(SCMCreateStreamReq *pReq) {
+  taosArrayDestroy(pReq->pTags);
  taosMemoryFreeClear(pReq->sql);
  taosMemoryFreeClear(pReq->ast);
 }
@ -5986,7 +5989,11 @@ int32_t tDecodeSMqDataRsp(SDecoder *pDecoder, SMqDataRsp *pRsp) {
      if (pRsp->withSchema) {
        SSchemaWrapper *pSW = (SSchemaWrapper *)taosMemoryCalloc(1, sizeof(SSchemaWrapper));
        if (pSW == NULL) return -1;
-        if (tDecodeSSchemaWrapper(pDecoder, pSW) < 0) return -1;
+        if (tDecodeSSchemaWrapper(pDecoder, pSW) < 0) {
+          taosMemoryFree(pSW);
+          return -1;
+        }
+
        taosArrayPush(pRsp->blockSchema, &pSW);
      }

@ -6067,7 +6074,10 @@ int32_t tDecodeSTaosxRsp(SDecoder *pDecoder, STaosxRsp *pRsp) {
      if (pRsp->withSchema) {
        SSchemaWrapper *pSW = (SSchemaWrapper *)taosMemoryCalloc(1, sizeof(SSchemaWrapper));
        if (pSW == NULL) return -1;
-        if (tDecodeSSchemaWrapper(pDecoder, pSW) < 0) return -1;
+        if (tDecodeSSchemaWrapper(pDecoder, pSW) < 0) {
+          taosMemoryFree(pSW);
+          return -1;
+        }
        taosArrayPush(pRsp->blockSchema, &pSW);
      }

--- a/source/common/src/trow.c
+++ b/source/common/src/trow.c
@ -73,7 +73,13 @@ void tdSCellValPrint(SCellVal *pVal, int8_t colType) {
  } else if (tdValTypeIsNone(pVal->valType)) {
    printf("NONE ");
    return;
+  } 
+  if(!pVal->val) {
+    ASSERT(0);
+    printf("BadVal ");
+    return;
  }
+
  switch (colType) {
    case TSDB_DATA_TYPE_BOOL:
      printf("%s ", (*(int8_t *)pVal->val) == 0 ? "false" : "true");
@ -678,6 +684,10 @@ int32_t tdAppendColValToRow(SRowBuilder *pBuilder, col_id_t colId, int8_t colTyp
  }
  // TS KEY is stored in STSRow.ts and not included in STSRow.data field.
  if (colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
+    if (!val) {
+      terrno = TSDB_CODE_INVALID_PARA;
+      return terrno;
+    }
    TD_ROW_KEY(pRow) = *(TSKEY *)val;
    // The primary TS key is Norm all the time, thus its valType is not stored in bitmap.
    return TSDB_CODE_SUCCESS;
--- a/source/common/src/ttime.c
+++ b/source/common/src/ttime.c
@ -507,29 +507,29 @@ int64_t convertTimeFromPrecisionToUnit(int64_t time, int32_t fromPrecision, char
  double  tmp = time;
  switch (toUnit) {
    case 's': {
-      tmp /= (NANOSECOND_PER_SEC / factors[fromPrecision]);  // the result of division is an integer
      time /= (NANOSECOND_PER_SEC / factors[fromPrecision]);
+      tmp = (double)time;
      break;
    }
    case 'm':
-      tmp /= (NANOSECOND_PER_MINUTE / factors[fromPrecision]);  // the result of division is an integer
      time /= (NANOSECOND_PER_MINUTE / factors[fromPrecision]);
+      tmp = (double)time;
      break;
    case 'h':
-      tmp /= (NANOSECOND_PER_HOUR / factors[fromPrecision]);  // the result of division is an integer
      time /= (NANOSECOND_PER_HOUR / factors[fromPrecision]);
+      tmp = (double)time;
      break;
    case 'd':
-      tmp /= (NANOSECOND_PER_DAY / factors[fromPrecision]);  // the result of division is an integer
      time /= (NANOSECOND_PER_DAY / factors[fromPrecision]);
+      tmp = (double)time;
      break;
    case 'w':
-      tmp /= (NANOSECOND_PER_WEEK / factors[fromPrecision]);  // the result of division is an integer
      time /= (NANOSECOND_PER_WEEK / factors[fromPrecision]);
+      tmp = (double)time;
      break;
    case 'a':
-      tmp /= (NANOSECOND_PER_MSEC / factors[fromPrecision]);  // the result of division is an integer
      time /= (NANOSECOND_PER_MSEC / factors[fromPrecision]);
+      tmp = (double)time;
      break;
    case 'u':
      // the result of (NANOSECOND_PER_USEC/(double)factors[fromPrecision]) maybe a double
@ -540,13 +540,13 @@ int64_t convertTimeFromPrecisionToUnit(int64_t time, int32_t fromPrecision, char
          break;
        }
        case TSDB_TIME_PRECISION_MICRO: {
-          tmp /= 1;
          time /= 1;
+          tmp = (double)time;
          break;
        }
        case TSDB_TIME_PRECISION_NANO: {
-          tmp /= 1000;
          time /= 1000;
+          tmp = (double)time;
          break;
        }
      }
--- a/source/dnode/mgmt/mgmt_dnode/src/dmHandle.c
+++ b/source/dnode/mgmt/mgmt_dnode/src/dmHandle.c
@ -332,7 +332,6 @@ SArray *dmGetMsgHandles() {

  // Requests handled by MNODE
  if (dmSetMgmtHandle(pArray, TDMT_MND_GRANT, dmPutNodeMsgToMgmtQueue, 0) == NULL) goto _OVER;
-  // if (dmSetMgmtHandle(pArray, TDMT_MND_GRANT_RSP, dmPutNodeMsgToMgmtQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_MND_AUTH_RSP, dmPutNodeMsgToMgmtQueue, 0) == NULL) goto _OVER;

  code = 0;
--- a/source/dnode/mgmt/mgmt_mnode/src/mmHandle.c
+++ b/source/dnode/mgmt/mgmt_mnode/src/mmHandle.c
@ -124,6 +124,7 @@ SArray *mmGetMsgHandles() {
  if (dmSetMgmtHandle(pArray, TDMT_MND_VGROUP_LIST, mmPutMsgToReadQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_MND_REDISTRIBUTE_VGROUP, mmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_MND_MERGE_VGROUP, mmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_SPLIT_VGROUP, mmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_MND_BALANCE_VGROUP, mmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_MND_CREATE_FUNC, mmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_MND_RETRIEVE_FUNC, mmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
--- a/source/dnode/mgmt/mgmt_snode/inc/smInt.h
+++ b/source/dnode/mgmt/mgmt_snode/inc/smInt.h
@ -30,9 +30,9 @@ typedef struct SSnodeMgmt {
  SMsgCb        msgCb;
  const char   *path;
  const char   *name;
-  int8_t        uniqueWorkerInUse;
-  SArray       *uniqueWorkers;  // SArray<SMultiWorker*>
-  SSingleWorker sharedWorker;
+  int8_t        writeWorkerInUse;
+  SArray       *writeWroker;  // SArray<SMultiWorker*>
+  SSingleWorker streamWorker;
 } SSnodeMgmt;

 // smHandle.c
@ -43,13 +43,14 @@ int32_t smProcessDropReq(const SMgmtInputOpt *pInput, SRpcMsg *pMsg);
 // smWorker.c
 int32_t smStartWorker(SSnodeMgmt *pMgmt);
 void    smStopWorker(SSnodeMgmt *pMgmt);
+int32_t smPutMsgToQueue(SSnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pMsg);
 int32_t smPutNodeMsgToMgmtQueue(SSnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t smPutNodeMsgToUniqueQueue(SSnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t smPutNodeMsgToSharedQueue(SSnodeMgmt *pMgmt, SRpcMsg *pMsg);
-int32_t smPutNodeMsgToExecQueue(SSnodeMgmt *pMgmt, SRpcMsg *pMsg);
+int32_t smPutNodeMsgToWriteQueue(SSnodeMgmt *pMgmt, SRpcMsg *pMsg);
+int32_t smPutNodeMsgToStreamQueue(SSnodeMgmt *pMgmt, SRpcMsg *pMsg);
+void    sndEnqueueStreamDispatch(SSnode *pSnode, SRpcMsg *pMsg);

 #ifdef __cplusplus
 }
 #endif

-#endif /*_TD_DND_SNODE_INT_H_*/
+#endif /*_TD_DND_SNODE_INT_H_*/
--- a/source/dnode/mgmt/mgmt_snode/src/smHandle.c
+++ b/source/dnode/mgmt/mgmt_snode/src/smHandle.c
@ -69,13 +69,13 @@ SArray *smGetMsgHandles() {

  if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_DEPLOY, smPutNodeMsgToMgmtQueue, 1) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_DROP, smPutNodeMsgToMgmtQueue, 1) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_RUN, smPutNodeMsgToSharedQueue, 1) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_DISPATCH, smPutNodeMsgToSharedQueue, 1) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_DISPATCH_RSP, smPutNodeMsgToSharedQueue, 1) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_RECOVER, smPutNodeMsgToSharedQueue, 1) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_RECOVER_RSP, smPutNodeMsgToSharedQueue, 1) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_STREAM_RETRIEVE, smPutNodeMsgToSharedQueue, 1) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_STREAM_RETRIEVE_RSP, smPutNodeMsgToSharedQueue, 1) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_RUN, smPutNodeMsgToStreamQueue, 1) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_DISPATCH, smPutNodeMsgToStreamQueue, 1) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_DISPATCH_RSP, smPutNodeMsgToStreamQueue, 1) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_RECOVER, smPutNodeMsgToStreamQueue, 1) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_STREAM_TASK_RECOVER_RSP, smPutNodeMsgToStreamQueue, 1) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_STREAM_RETRIEVE, smPutNodeMsgToStreamQueue, 1) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_STREAM_RETRIEVE_RSP, smPutNodeMsgToStreamQueue, 1) == NULL) goto _OVER;

  code = 0;
 _OVER:
--- a/source/dnode/mgmt/mgmt_snode/src/smInt.c
+++ b/source/dnode/mgmt/mgmt_snode/src/smInt.c
@ -45,6 +45,7 @@ int32_t smOpen(SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
  pMgmt->name = pInput->name;
  pMgmt->msgCb = pInput->msgCb;
  pMgmt->msgCb.mgmt = pMgmt;
+  pMgmt->msgCb.putToQueueFp = (PutToQueueFp)smPutMsgToQueue;

  SSnodeOpt option = {0};
  smInitOption(pMgmt, &option);
--- a/source/dnode/mgmt/mgmt_snode/src/smWorker.c
+++ b/source/dnode/mgmt/mgmt_snode/src/smWorker.c
@ -26,18 +26,24 @@ static inline void smSendRsp(SRpcMsg *pMsg, int32_t code) {
  tmsgSendRsp(&rsp);
 }

-static void smProcessUniqueQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numOfMsgs) {
+static void smProcessWriteQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numOfMsgs) {
  SSnodeMgmt *pMgmt = pInfo->ahandle;

  for (int32_t i = 0; i < numOfMsgs; i++) {
    SRpcMsg *pMsg = NULL;
    taosGetQitem(qall, (void **)&pMsg);
+    const STraceId *trace = &pMsg->info.traceId;

-    dTrace("msg:%p, get from snode-unique queue", pMsg);
-    if (sndProcessUMsg(pMgmt->pSnode, pMsg) < 0) {
-      ASSERT(0);
+    dTrace("msg:%p, get from snode-write queue", pMsg);
+    int32_t code = sndProcessWriteMsg(pMgmt->pSnode, pMsg, NULL);
+    if (code < 0) {
+      dGError("snd, msg:%p failed to process write since %s", pMsg, terrstr(code));
+      if (pMsg->info.handle != NULL) {
+        tmsgSendRsp(pMsg);
+      }
+    } else {
+      smSendRsp(pMsg, 0);
    }
-    smSendRsp(pMsg, 0);

    dTrace("msg:%p, is freed", pMsg);
    rpcFreeCont(pMsg->pCont);
@ -45,13 +51,15 @@ static void smProcessUniqueQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t num
  }
 }

-static void smProcessSharedQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
-  SSnodeMgmt *pMgmt = pInfo->ahandle;
+static void smProcessStreamQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
+  SSnodeMgmt     *pMgmt = pInfo->ahandle;
+  const STraceId *trace = &pMsg->info.traceId;

-  dTrace("msg:%p, get from snode-shared queue", pMsg);
-  if (sndProcessSMsg(pMgmt->pSnode, pMsg) < 0) {
+  dTrace("msg:%p, get from snode-stream queue", pMsg);
+  int32_t code = sndProcessStreamMsg(pMgmt->pSnode, pMsg);
+  if (code < 0) {
+    dGError("snd, msg:%p failed to process stream since %s", pMsg, terrstr(code));
    smSendRsp(pMsg, terrno);
-    ASSERT(0);
  }

  dTrace("msg:%p, is freed", pMsg);
@ -60,44 +68,44 @@ static void smProcessSharedQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
 }

 int32_t smStartWorker(SSnodeMgmt *pMgmt) {
-  pMgmt->uniqueWorkers = taosArrayInit(0, sizeof(SMultiWorker *));
-  if (pMgmt->uniqueWorkers == NULL) {
+  pMgmt->writeWroker = taosArrayInit(0, sizeof(SMultiWorker *));
+  if (pMgmt->writeWroker == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    return -1;
  }

-  for (int32_t i = 0; i < tsNumOfSnodeUniqueThreads; i++) {
-    SMultiWorker *pUniqueWorker = taosMemoryMalloc(sizeof(SMultiWorker));
-    if (pUniqueWorker == NULL) {
+  for (int32_t i = 0; i < tsNumOfSnodeWriteThreads; i++) {
+    SMultiWorker *pWriteWorker = taosMemoryMalloc(sizeof(SMultiWorker));
+    if (pWriteWorker == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
      return -1;
    }

    SMultiWorkerCfg cfg = {
        .max = 1,
-        .name = "snode-unique",
-        .fp = smProcessUniqueQueue,
+        .name = "snode-write",
+        .fp = smProcessWriteQueue,
        .param = pMgmt,
    };
-    if (tMultiWorkerInit(pUniqueWorker, &cfg) != 0) {
+    if (tMultiWorkerInit(pWriteWorker, &cfg) != 0) {
      dError("failed to start snode-unique worker since %s", terrstr());
      return -1;
    }
-    if (taosArrayPush(pMgmt->uniqueWorkers, &pUniqueWorker) == NULL) {
+    if (taosArrayPush(pMgmt->writeWroker, &pWriteWorker) == NULL) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
      return -1;
    }
  }

  SSingleWorkerCfg cfg = {
-      .min = tsNumOfSnodeSharedThreads,
-      .max = tsNumOfSnodeSharedThreads,
-      .name = "snode-shared",
-      .fp = (FItem)smProcessSharedQueue,
+      .min = tsNumOfSnodeStreamThreads,
+      .max = tsNumOfSnodeStreamThreads,
+      .name = "snode-stream",
+      .fp = (FItem)smProcessStreamQueue,
      .param = pMgmt,
  };

-  if (tSingleWorkerInit(&pMgmt->sharedWorker, &cfg)) {
+  if (tSingleWorkerInit(&pMgmt->streamWorker, &cfg)) {
    dError("failed to start snode shared-worker since %s", terrstr());
    return -1;
  }
@ -107,30 +115,50 @@ int32_t smStartWorker(SSnodeMgmt *pMgmt) {
 }

 void smStopWorker(SSnodeMgmt *pMgmt) {
-  for (int32_t i = 0; i < taosArrayGetSize(pMgmt->uniqueWorkers); i++) {
-    SMultiWorker *pWorker = taosArrayGetP(pMgmt->uniqueWorkers, i);
+  for (int32_t i = 0; i < taosArrayGetSize(pMgmt->writeWroker); i++) {
+    SMultiWorker *pWorker = taosArrayGetP(pMgmt->writeWroker, i);
    tMultiWorkerCleanup(pWorker);
  }
-  taosArrayDestroy(pMgmt->uniqueWorkers);
-  tSingleWorkerCleanup(&pMgmt->sharedWorker);
+  taosArrayDestroy(pMgmt->writeWroker);
+  tSingleWorkerCleanup(&pMgmt->streamWorker);
  dDebug("snode workers are closed");
 }

-static FORCE_INLINE int32_t smGetSWIdFromMsg(SRpcMsg *pMsg) {
-  SMsgHead *pHead = pMsg->pCont;
-  pHead->vgId = htonl(pHead->vgId);
-  return pHead->vgId % tsNumOfSnodeUniqueThreads;
-}
+int32_t smPutMsgToQueue(SSnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc) {
+  SRpcMsg *pMsg = taosAllocateQitem(sizeof(SRpcMsg), RPC_QITEM);
+  if (pMsg == NULL) {
+    rpcFreeCont(pRpc->pCont);
+    pRpc->pCont = NULL;
+    return -1;
+  }

-static FORCE_INLINE int32_t smGetSWTypeFromMsg(SRpcMsg *pMsg) {
-  /*SMsgHead *pHead = pMsg->pCont;*/
-  /*pHead->workerType = htonl(pHead->workerType);*/
-  /*return pHead->workerType;*/
+  SSnode *pSnode = pMgmt->pSnode;
+  if (pSnode == NULL) {
+    dError("snode: msg:%p failed to put into vnode queue since %s, type:%s qtype:%d", pMsg, terrstr(),
+           TMSG_INFO(pMsg->msgType), qtype);
+    return -1;
+  }
+
+  SMsgHead *pHead = pRpc->pCont;
+  pHead->contLen = htonl(pHead->contLen);
+  pHead->vgId = SNODE_HANDLE;
+  memcpy(pMsg, pRpc, sizeof(SRpcMsg));
+
+  switch (qtype) {
+    case STREAM_QUEUE:
+      smPutNodeMsgToStreamQueue(pMgmt, pMsg);
+      break;
+    case WRITE_QUEUE:
+      smPutNodeMsgToWriteQueue(pMgmt, pMsg);
+      break;
+    default:
+      ASSERT(0);
+  }
  return 0;
 }

 int32_t smPutNodeMsgToMgmtQueue(SSnodeMgmt *pMgmt, SRpcMsg *pMsg) {
-  SMultiWorker *pWorker = taosArrayGetP(pMgmt->uniqueWorkers, 0);
+  SMultiWorker *pWorker = taosArrayGetP(pMgmt->writeWroker, 0);
  if (pWorker == NULL) {
    terrno = TSDB_CODE_INVALID_MSG;
    return -1;
@ -141,9 +169,8 @@ int32_t smPutNodeMsgToMgmtQueue(SSnodeMgmt *pMgmt, SRpcMsg *pMsg) {
  return 0;
 }

-int32_t smPutNodeMsgToUniqueQueue(SSnodeMgmt *pMgmt, SRpcMsg *pMsg) {
-  int32_t       index = smGetSWIdFromMsg(pMsg);
-  SMultiWorker *pWorker = taosArrayGetP(pMgmt->uniqueWorkers, index);
+int32_t smPutNodeMsgToWriteQueue(SSnodeMgmt *pMgmt, SRpcMsg *pMsg) {
+  SMultiWorker *pWorker = taosArrayGetP(pMgmt->writeWroker, 0);
  if (pWorker == NULL) {
    terrno = TSDB_CODE_INVALID_MSG;
    return -1;
@ -154,19 +181,14 @@ int32_t smPutNodeMsgToUniqueQueue(SSnodeMgmt *pMgmt, SRpcMsg *pMsg) {
  return 0;
 }

-int32_t smPutNodeMsgToSharedQueue(SSnodeMgmt *pMgmt, SRpcMsg *pMsg) {
-  SSingleWorker *pWorker = &pMgmt->sharedWorker;
+int32_t smPutNodeMsgToStreamQueue(SSnodeMgmt *pMgmt, SRpcMsg *pMsg) {
+  SSingleWorker *pWorker = &pMgmt->streamWorker;

  dTrace("msg:%p, put into worker %s", pMsg, pWorker->name);
-  taosWriteQitem(pWorker->queue, pMsg);
-  return 0;
-}
-
-int32_t smPutNodeMsgToExecQueue(SSnodeMgmt *pMgmt, SRpcMsg *pMsg) {
-  int32_t workerType = smGetSWTypeFromMsg(pMsg);
-  if (workerType == SND_WORKER_TYPE__SHARED) {
-    return smPutNodeMsgToSharedQueue(pMgmt, pMsg);
+  if (pMsg->msgType == TDMT_STREAM_TASK_DISPATCH) {
+    sndEnqueueStreamDispatch(pMgmt->pSnode, pMsg);
  } else {
-    return smPutNodeMsgToUniqueQueue(pMgmt, pMsg);
+    taosWriteQitem(pWorker->queue, pMsg);
  }
+  return 0;
 }
--- a/source/dnode/mgmt/test/sut/inc/server.h
+++ b/source/dnode/mgmt/test/sut/inc/server.h
@ -20,7 +20,8 @@ class TestServer {
 public:
  bool Start();
  void Stop();
-
+bool runnning;
+  
 private:
  TdThread threadId;
 };
--- a/source/dnode/mgmt/test/sut/src/server.cpp
+++ b/source/dnode/mgmt/test/sut/src/server.cpp
@ -16,8 +16,18 @@
 #include "sut.h"

 void* serverLoop(void* param) {
-  dmInit();
-  dmRun();
+  TestServer* server = (TestServer*)param;
+  server->runnning = false;
+
+  if (dmInit() != 0) {
+    return NULL;
+  }
+
+  server->runnning = true;
+  if (dmRun() != 0) {
+    return NULL;
+  }
+
  dmCleanup();
  return NULL;
 }
@ -26,10 +36,10 @@ bool TestServer::Start() {
  TdThreadAttr thAttr;
  taosThreadAttrInit(&thAttr);
  taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE);
-  taosThreadCreate(&threadId, &thAttr, serverLoop, NULL);
+  taosThreadCreate(&threadId, &thAttr, serverLoop, this);
  taosThreadAttrDestroy(&thAttr);
  taosMsleep(2100);
-  return true;
+  return runnning;
 }

 void TestServer::Stop() {
--- a/source/dnode/mgmt/test/sut/src/sut.cpp
+++ b/source/dnode/mgmt/test/sut/src/sut.cpp
@ -53,7 +53,10 @@ void Testbase::Init(const char* path, int16_t port) {
  taosMkDir(path);
  InitLog(TD_TMP_DIR_PATH "td");

-  server.Start();
+  if (!server.Start()) {
+    printf("failed to start server, exit\n");
+    exit(0);
+  };
  client.Init("root", "taosdata");
  showRsp = NULL;
 }
--- a/source/dnode/mnode/impl/inc/mndInt.h
+++ b/source/dnode/mnode/impl/inc/mndInt.h
@ -80,8 +80,8 @@ typedef struct {
 } SProfileMgmt;

 typedef struct {
-  SRWLatch lock;
-  char     email[TSDB_FQDN_LEN];
+  TdThreadMutex lock;
+  char           email[TSDB_FQDN_LEN];
 } STelemMgmt;

 typedef struct {
--- a/source/dnode/mnode/impl/inc/mndOffset.h
+++ b/source/dnode/mnode/impl/inc/mndOffset.h
@ -1,50 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _TD_MND_OFFSET_H_
-#define _TD_MND_OFFSET_H_
-
-#include "mndInt.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-int32_t mndInitOffset(SMnode *pMnode);
-void    mndCleanupOffset(SMnode *pMnode);
-
-SMqOffsetObj *mndAcquireOffset(SMnode *pMnode, const char *key);
-void          mndReleaseOffset(SMnode *pMnode, SMqOffsetObj *pOffset);
-
-SSdbRaw *mndOffsetActionEncode(SMqOffsetObj *pOffset);
-SSdbRow *mndOffsetActionDecode(SSdbRaw *pRaw);
-
-int32_t mndCreateOffsets(STrans *pTrans, const char *cgroup, const char *topicName, const SArray *vgs);
-
-static FORCE_INLINE int32_t mndMakePartitionKey(char *key, const char *cgroup, const char *topicName, int32_t vgId) {
-  return snprintf(key, TSDB_PARTITION_KEY_LEN, "%d:%s:%s", vgId, cgroup, topicName);
-}
-
-int32_t mndDropOffsetByDB(SMnode *pMnode, STrans *pTrans, SDbObj *pDb);
-int32_t mndDropOffsetByTopic(SMnode *pMnode, STrans *pTrans, const char *topic);
-int32_t mndDropOffsetBySubKey(SMnode *pMnode, STrans *pTrans, const char *subKey);
-
-bool mndOffsetFromTopic(SMqOffsetObj *pOffset, const char *topic);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_MND_OFFSET_H_*/
--- a/source/dnode/mnode/impl/inc/mndSubscribe.h
+++ b/source/dnode/mnode/impl/inc/mndSubscribe.h
@ -31,6 +31,10 @@ void             mndReleaseSubscribe(SMnode *pMnode, SMqSubscribeObj *pSub);

 int32_t mndMakeSubscribeKey(char *key, const char *cgroup, const char *topicName);

+static FORCE_INLINE int32_t mndMakePartitionKey(char *key, const char *cgroup, const char *topicName, int32_t vgId) {
+  return snprintf(key, TSDB_PARTITION_KEY_LEN, "%d:%s:%s", vgId, cgroup, topicName);
+}
+
 int32_t mndDropSubByDB(SMnode *pMnode, STrans *pTrans, SDbObj *pDb);
 int32_t mndDropSubByTopic(SMnode *pMnode, STrans *pTrans, const char *topic);
 int32_t mndSetDropSubCommitLogs(SMnode *pMnode, STrans *pTrans, SMqSubscribeObj *pSub);
--- a/source/dnode/mnode/impl/src/mndConsumer.c
+++ b/source/dnode/mnode/impl/src/mndConsumer.c
@ -18,7 +18,6 @@
 #include "mndDb.h"
 #include "mndDnode.h"
 #include "mndMnode.h"
-#include "mndOffset.h"
 #include "mndPrivilege.h"
 #include "mndShow.h"
 #include "mndStb.h"
@ -408,12 +407,6 @@ static int32_t mndProcessAskEpReq(SRpcMsg *pMsg) {
            .offset = -1,
        };

-        // 2.2.2 fetch vg offset
-        SMqOffsetObj *pOffsetObj = mndAcquireOffset(pMnode, offsetKey);
-        if (pOffsetObj != NULL) {
-          vgEp.offset = atomic_load_64(&pOffsetObj->offset);
-          mndReleaseOffset(pMnode, pOffsetObj);
-        }
        taosArrayPush(topicEp.vgs, &vgEp);
      }
      taosArrayPush(rsp.topics, &topicEp);
--- a/source/dnode/mnode/impl/src/mndDb.c
+++ b/source/dnode/mnode/impl/src/mndDb.c
@ -17,7 +17,6 @@
 #include "mndDb.h"
 #include "mndCluster.h"
 #include "mndDnode.h"
-#include "mndOffset.h"
 #include "mndPrivilege.h"
 #include "mndShow.h"
 #include "mndSma.h"
@ -641,12 +640,8 @@ static int32_t mndSetDbCfgFromAlterDbReq(SDbObj *pDb, SAlterDbReq *pAlter) {
  }

  if (pAlter->pageSize > 0 && pAlter->pageSize != pDb->cfg.pageSize) {
-#if 1
-    terrno = TSDB_CODE_OPS_NOT_SUPPORT;
-#else
    pDb->cfg.pageSize = pAlter->pageSize;
    terrno = 0;
-#endif
  }

  if (pAlter->daysPerFile > 0 && pAlter->daysPerFile != pDb->cfg.daysPerFile) {
--- a/source/dnode/mnode/impl/src/mndDnode.c
+++ b/source/dnode/mnode/impl/src/mndDnode.c
@ -776,11 +776,6 @@ static int32_t mndProcessDropDnodeReq(SRpcMsg *pReq) {
    }
  }

-  if (numOfVnodes > 0) {
-    terrno = TSDB_CODE_OPS_NOT_SUPPORT;
-    goto _OVER;
-  }
-
  code = mndDropDnode(pMnode, pReq, pDnode, pMObj, pQObj, pSObj, numOfVnodes);
  if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;

--- a/source/dnode/mnode/impl/src/mndMain.c
+++ b/source/dnode/mnode/impl/src/mndMain.c
@ -23,7 +23,6 @@
 #include "mndGrant.h"
 #include "mndInfoSchema.h"
 #include "mndMnode.h"
-#include "mndOffset.h"
 #include "mndPerfSchema.h"
 #include "mndPrivilege.h"
 #include "mndProfile.h"
@ -305,7 +304,6 @@ static int32_t mndInitSteps(SMnode *pMnode) {
  if (mndAllocStep(pMnode, "mnode-topic", mndInitTopic, mndCleanupTopic) != 0) return -1;
  if (mndAllocStep(pMnode, "mnode-consumer", mndInitConsumer, mndCleanupConsumer) != 0) return -1;
  if (mndAllocStep(pMnode, "mnode-subscribe", mndInitSubscribe, mndCleanupSubscribe) != 0) return -1;
-  if (mndAllocStep(pMnode, "mnode-offset", mndInitOffset, mndCleanupOffset) != 0) return -1;
  if (mndAllocStep(pMnode, "mnode-vgroup", mndInitVgroup, mndCleanupVgroup) != 0) return -1;
  if (mndAllocStep(pMnode, "mnode-stb", mndInitStb, mndCleanupStb) != 0) return -1;
  if (mndAllocStep(pMnode, "mnode-sma", mndInitSma, mndCleanupSma) != 0) return -1;
@ -424,7 +422,7 @@ SMnode *mndOpen(const char *path, const SMnodeOpt *pOption) {
    return NULL;
  }

-  mInfo("mnode open successfully ");
+  mInfo("mnode open successfully");
  return pMnode;
 }

@ -540,12 +538,12 @@ int32_t mndProcessSyncMsg(SRpcMsg *pMsg) {

  } else if (pMsg->msgType == TDMT_SYNC_PING) {
    SyncPing *pSyncMsg = syncPingFromRpcMsg2(pMsg);
-    code = syncNodeOnPingCb(pSyncNode, pSyncMsg);
+    code = syncNodeOnPing(pSyncNode, pSyncMsg);
    syncPingDestroy(pSyncMsg);

  } else if (pMsg->msgType == TDMT_SYNC_PING_REPLY) {
    SyncPingReply *pSyncMsg = syncPingReplyFromRpcMsg2(pMsg);
-    code = syncNodeOnPingReplyCb(pSyncNode, pSyncMsg);
+    code = syncNodeOnPingReply(pSyncNode, pSyncMsg);
    syncPingReplyDestroy(pSyncMsg);

  } else if (pMsg->msgType == TDMT_SYNC_CLIENT_REQUEST) {
--- a/source/dnode/mnode/impl/src/mndOffset.c
+++ b/source/dnode/mnode/impl/src/mndOffset.c
@ -1,370 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "mndOffset.h"
-#include "mndDb.h"
-#include "mndDnode.h"
-#include "mndMnode.h"
-#include "mndPrivilege.h"
-#include "mndShow.h"
-#include "mndStb.h"
-#include "mndTopic.h"
-#include "mndTrans.h"
-#include "mndUser.h"
-#include "mndVgroup.h"
-#include "tname.h"
-
-#define MND_OFFSET_VER_NUMBER   1
-#define MND_OFFSET_RESERVE_SIZE 64
-
-static int32_t mndOffsetActionInsert(SSdb *pSdb, SMqOffsetObj *pOffset);
-static int32_t mndOffsetActionDelete(SSdb *pSdb, SMqOffsetObj *pOffset);
-static int32_t mndOffsetActionUpdate(SSdb *pSdb, SMqOffsetObj *pOffset, SMqOffsetObj *pNewOffset);
-static int32_t mndProcessCommitOffsetReq(SRpcMsg *pReq);
-
-int32_t mndInitOffset(SMnode *pMnode) {
-  SSdbTable table = {
-      .sdbType = SDB_OFFSET,
-      .keyType = SDB_KEY_BINARY,
-      .encodeFp = (SdbEncodeFp)mndOffsetActionEncode,
-      .decodeFp = (SdbDecodeFp)mndOffsetActionDecode,
-      .insertFp = (SdbInsertFp)mndOffsetActionInsert,
-      .updateFp = (SdbUpdateFp)mndOffsetActionUpdate,
-      .deleteFp = (SdbDeleteFp)mndOffsetActionDelete,
-  };
-
-  mndSetMsgHandle(pMnode, TDMT_MND_MQ_COMMIT_OFFSET, mndProcessCommitOffsetReq);
-
-  return sdbSetTable(pMnode->pSdb, table);
-}
-
-void mndCleanupOffset(SMnode *pMnode) {}
-
-bool mndOffsetFromTopic(SMqOffsetObj *pOffset, const char *topic) {
-  int32_t i = 0;
-  while (pOffset->key[i] != ':') i++;
-  while (pOffset->key[i] != ':') i++;
-  if (strcmp(&pOffset->key[i + 1], topic) == 0) return true;
-  return false;
-}
-
-bool mndOffsetFromSubKey(SMqOffsetObj *pOffset, const char *subKey) {
-  int32_t i = 0;
-  while (pOffset->key[i] != ':') i++;
-  if (strcmp(&pOffset->key[i + 1], subKey) == 0) return true;
-  return false;
-}
-SSdbRaw *mndOffsetActionEncode(SMqOffsetObj *pOffset) {
-  terrno = TSDB_CODE_OUT_OF_MEMORY;
-  void   *buf = NULL;
-  int32_t tlen = tEncodeSMqOffsetObj(NULL, pOffset);
-  int32_t size = sizeof(int32_t) + tlen + MND_OFFSET_RESERVE_SIZE;
-
-  SSdbRaw *pRaw = sdbAllocRaw(SDB_OFFSET, MND_OFFSET_VER_NUMBER, size);
-  if (pRaw == NULL) goto OFFSET_ENCODE_OVER;
-
-  buf = taosMemoryMalloc(tlen);
-  if (buf == NULL) goto OFFSET_ENCODE_OVER;
-
-  void *abuf = buf;
-  tEncodeSMqOffsetObj(&abuf, pOffset);
-
-  int32_t dataPos = 0;
-  SDB_SET_INT32(pRaw, dataPos, tlen, OFFSET_ENCODE_OVER);
-  SDB_SET_BINARY(pRaw, dataPos, buf, tlen, OFFSET_ENCODE_OVER);
-  SDB_SET_RESERVE(pRaw, dataPos, MND_OFFSET_RESERVE_SIZE, OFFSET_ENCODE_OVER);
-  SDB_SET_DATALEN(pRaw, dataPos, OFFSET_ENCODE_OVER);
-
-  terrno = TSDB_CODE_SUCCESS;
-
-OFFSET_ENCODE_OVER:
-  taosMemoryFreeClear(buf);
-  if (terrno != TSDB_CODE_SUCCESS) {
-    mError("offset:%s, failed to encode to raw:%p since %s", pOffset->key, pRaw, terrstr());
-    sdbFreeRaw(pRaw);
-    return NULL;
-  }
-
-  mTrace("offset:%s, encode to raw:%p, row:%p", pOffset->key, pRaw, pOffset);
-  return pRaw;
-}
-
-SSdbRow *mndOffsetActionDecode(SSdbRaw *pRaw) {
-  terrno = TSDB_CODE_OUT_OF_MEMORY;
-  void *buf = NULL;
-
-  int8_t sver = 0;
-  if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto OFFSET_DECODE_OVER;
-
-  if (sver != MND_OFFSET_VER_NUMBER) {
-    terrno = TSDB_CODE_SDB_INVALID_DATA_VER;
-    goto OFFSET_DECODE_OVER;
-  }
-
-  int32_t  size = sizeof(SMqOffsetObj);
-  SSdbRow *pRow = sdbAllocRow(size);
-  if (pRow == NULL) goto OFFSET_DECODE_OVER;
-
-  SMqOffsetObj *pOffset = sdbGetRowObj(pRow);
-  if (pOffset == NULL) goto OFFSET_DECODE_OVER;
-
-  int32_t dataPos = 0;
-  int32_t tlen;
-  SDB_GET_INT32(pRaw, dataPos, &tlen, OFFSET_DECODE_OVER);
-  buf = taosMemoryMalloc(tlen + 1);
-  if (buf == NULL) goto OFFSET_DECODE_OVER;
-  SDB_GET_BINARY(pRaw, dataPos, buf, tlen, OFFSET_DECODE_OVER);
-  SDB_GET_RESERVE(pRaw, dataPos, MND_OFFSET_RESERVE_SIZE, OFFSET_DECODE_OVER);
-
-  if (tDecodeSMqOffsetObj(buf, pOffset) == NULL) {
-    goto OFFSET_DECODE_OVER;
-  }
-
-  terrno = TSDB_CODE_SUCCESS;
-
-OFFSET_DECODE_OVER:
-  taosMemoryFreeClear(buf);
-  if (terrno != TSDB_CODE_SUCCESS) {
-    mError("offset:%s, failed to decode from raw:%p since %s", pOffset->key, pRaw, terrstr());
-    taosMemoryFreeClear(pRow);
-    return NULL;
-  }
-
-  mTrace("offset:%s, decode from raw:%p, row:%p", pOffset->key, pRaw, pOffset);
-  return pRow;
-}
-
-int32_t mndCreateOffsets(STrans *pTrans, const char *cgroup, const char *topicName, const SArray *vgs) {
-  int32_t sz = taosArrayGetSize(vgs);
-  for (int32_t i = 0; i < sz; i++) {
-    int32_t      vgId = *(int32_t *)taosArrayGet(vgs, i);
-    SMqOffsetObj offsetObj = {0};
-    if (mndMakePartitionKey(offsetObj.key, cgroup, topicName, vgId) < 0) {
-      return -1;
-    }
-    // TODO assign db
-    offsetObj.offset = -1;
-    SSdbRaw *pOffsetRaw = mndOffsetActionEncode(&offsetObj);
-    if (pOffsetRaw == NULL) {
-      return -1;
-    }
-    (void)sdbSetRawStatus(pOffsetRaw, SDB_STATUS_READY);
-    // commit log or redo log?
-    if (mndTransAppendRedolog(pTrans, pOffsetRaw) < 0) {
-      return -1;
-    }
-  }
-  return 0;
-}
-
-static int32_t mndProcessCommitOffsetReq(SRpcMsg *pMsg) {
-  char key[TSDB_PARTITION_KEY_LEN];
-
-  SMnode              *pMnode = pMsg->info.node;
-  char                *msgStr = pMsg->pCont;
-  SMqCMCommitOffsetReq commitOffsetReq;
-  SDecoder             decoder;
-  tDecoderInit(&decoder, msgStr, pMsg->contLen);
-
-  tDecodeSMqCMCommitOffsetReq(&decoder, &commitOffsetReq);
-
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_NOTHING, pMsg, "commit-offset");
-  if (pTrans == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    tDecoderClear(&decoder);
-    return -1;
-  }
-
-  for (int32_t i = 0; i < commitOffsetReq.num; i++) {
-    SMqOffset *pOffset = &commitOffsetReq.offsets[i];
-    mInfo("commit offset %" PRId64 " to vgId:%d of consumer group %s on topic %s", pOffset->offset, pOffset->vgId,
-          pOffset->cgroup, pOffset->topicName);
-    if (mndMakePartitionKey(key, pOffset->cgroup, pOffset->topicName, pOffset->vgId) < 0) {
-      mError("submit offset to topic %s failed", pOffset->topicName);
-      return -1;
-    }
-    bool          create = false;
-    SMqOffsetObj *pOffsetObj = mndAcquireOffset(pMnode, key);
-    if (pOffsetObj == NULL) {
-      SMqTopicObj *pTopic = mndAcquireTopic(pMnode, pOffset->topicName);
-      if (pTopic == NULL) {
-        terrno = TSDB_CODE_MND_TOPIC_NOT_EXIST;
-        mError("submit offset to topic %s failed since %s", pOffset->topicName, terrstr());
-        continue;
-      }
-      pOffsetObj = taosMemoryMalloc(sizeof(SMqOffsetObj));
-      pOffsetObj->dbUid = pTopic->dbUid;
-      mndReleaseTopic(pMnode, pTopic);
-      memcpy(pOffsetObj->key, key, TSDB_PARTITION_KEY_LEN);
-      create = true;
-    }
-    pOffsetObj->offset = pOffset->offset;
-    SSdbRaw *pOffsetRaw = mndOffsetActionEncode(pOffsetObj);
-    (void)sdbSetRawStatus(pOffsetRaw, SDB_STATUS_READY);
-    mndTransAppendCommitlog(pTrans, pOffsetRaw);
-    if (create) {
-      taosMemoryFree(pOffsetObj);
-    } else {
-      mndReleaseOffset(pMnode, pOffsetObj);
-    }
-  }
-
-  tDecoderClear(&decoder);
-
-  if (mndTransPrepare(pMnode, pTrans) != 0) {
-    mError("mq-commit-offset-trans:%d, failed to prepare since %s", pTrans->id, terrstr());
-    mndTransDrop(pTrans);
-    return -1;
-  }
-
-  mndTransDrop(pTrans);
-  return TSDB_CODE_ACTION_IN_PROGRESS;
-}
-
-static int32_t mndOffsetActionInsert(SSdb *pSdb, SMqOffsetObj *pOffset) {
-  mTrace("offset:%s, perform insert action", pOffset->key);
-  return 0;
-}
-
-static int32_t mndOffsetActionDelete(SSdb *pSdb, SMqOffsetObj *pOffset) {
-  mTrace("offset:%s, perform delete action", pOffset->key);
-  return 0;
-}
-
-static int32_t mndOffsetActionUpdate(SSdb *pSdb, SMqOffsetObj *pOldOffset, SMqOffsetObj *pNewOffset) {
-  mTrace("offset:%s, perform update action", pOldOffset->key);
-  atomic_store_64(&pOldOffset->offset, pNewOffset->offset);
-  return 0;
-}
-
-SMqOffsetObj *mndAcquireOffset(SMnode *pMnode, const char *key) {
-  SSdb         *pSdb = pMnode->pSdb;
-  SMqOffsetObj *pOffset = sdbAcquire(pSdb, SDB_OFFSET, key);
-  if (pOffset == NULL && terrno == TSDB_CODE_SDB_OBJ_NOT_THERE) {
-    terrno = TSDB_CODE_MND_OFFSET_NOT_EXIST;
-  }
-  return pOffset;
-}
-
-void mndReleaseOffset(SMnode *pMnode, SMqOffsetObj *pOffset) {
-  SSdb *pSdb = pMnode->pSdb;
-  sdbRelease(pSdb, pOffset);
-}
-
-static void mndCancelGetNextOffset(SMnode *pMnode, void *pIter) {
-  SSdb *pSdb = pMnode->pSdb;
-  sdbCancelFetch(pSdb, pIter);
-}
-
-static int32_t mndSetDropOffsetCommitLogs(SMnode *pMnode, STrans *pTrans, SMqOffsetObj *pOffset) {
-  SSdbRaw *pCommitRaw = mndOffsetActionEncode(pOffset);
-  if (pCommitRaw == NULL) return -1;
-  if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) return -1;
-  if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED) != 0) return -1;
-  return 0;
-}
-
-static int32_t mndSetDropOffsetRedoLogs(SMnode *pMnode, STrans *pTrans, SMqOffsetObj *pOffset) {
-  SSdbRaw *pRedoRaw = mndOffsetActionEncode(pOffset);
-  if (pRedoRaw == NULL) return -1;
-  if (mndTransAppendRedolog(pTrans, pRedoRaw) != 0) return -1;
-  if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPED) != 0) return -1;
-  return 0;
-}
-
-int32_t mndDropOffsetByDB(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {
-  int32_t code = 0;
-  SSdb   *pSdb = pMnode->pSdb;
-
-  void         *pIter = NULL;
-  SMqOffsetObj *pOffset = NULL;
-  while (1) {
-    pIter = sdbFetch(pSdb, SDB_OFFSET, pIter, (void **)&pOffset);
-    if (pIter == NULL) break;
-
-    if (pOffset->dbUid != pDb->uid) {
-      sdbRelease(pSdb, pOffset);
-      continue;
-    }
-
-    if (mndSetDropOffsetCommitLogs(pMnode, pTrans, pOffset) < 0) {
-      sdbRelease(pSdb, pOffset);
-      sdbCancelFetch(pSdb, pIter);
-      code = -1;
-      break;
-    }
-
-    sdbRelease(pSdb, pOffset);
-  }
-
-  return code;
-}
-
-int32_t mndDropOffsetByTopic(SMnode *pMnode, STrans *pTrans, const char *topic) {
-  int32_t code = -1;
-  SSdb   *pSdb = pMnode->pSdb;
-
-  void         *pIter = NULL;
-  SMqOffsetObj *pOffset = NULL;
-  while (1) {
-    pIter = sdbFetch(pSdb, SDB_OFFSET, pIter, (void **)&pOffset);
-    if (pIter == NULL) break;
-
-    if (!mndOffsetFromTopic(pOffset, topic)) {
-      sdbRelease(pSdb, pOffset);
-      continue;
-    }
-
-    if (mndSetDropOffsetCommitLogs(pMnode, pTrans, pOffset) < 0) {
-      sdbRelease(pSdb, pOffset);
-      goto END;
-    }
-
-    sdbRelease(pSdb, pOffset);
-  }
-
-  code = 0;
-END:
-  return code;
-}
-
-int32_t mndDropOffsetBySubKey(SMnode *pMnode, STrans *pTrans, const char *subKey) {
-  int32_t code = -1;
-  SSdb   *pSdb = pMnode->pSdb;
-
-  void         *pIter = NULL;
-  SMqOffsetObj *pOffset = NULL;
-  while (1) {
-    pIter = sdbFetch(pSdb, SDB_OFFSET, pIter, (void **)&pOffset);
-    if (pIter == NULL) break;
-
-    if (!mndOffsetFromSubKey(pOffset, subKey)) {
-      sdbRelease(pSdb, pOffset);
-      continue;
-    }
-
-    if (mndSetDropOffsetCommitLogs(pMnode, pTrans, pOffset) < 0) {
-      sdbRelease(pSdb, pOffset);
-      goto END;
-    }
-
-    sdbRelease(pSdb, pOffset);
-  }
-
-  code = 0;
-END:
-  return code;
-}
--- a/source/dnode/mnode/impl/src/mndScheduler.c
+++ b/source/dnode/mnode/impl/src/mndScheduler.c
@ -18,7 +18,6 @@
 #include "mndDb.h"
 #include "mndDnode.h"
 #include "mndMnode.h"
-#include "mndOffset.h"
 #include "mndShow.h"
 #include "mndSnode.h"
 #include "mndStb.h"
@ -33,7 +32,7 @@
 #include "tname.h"
 #include "tuuid.h"

-extern bool tsSchedStreamToSnode;
+extern bool tsDeployOnSnode;

 static int32_t mndAddTaskToTaskSet(SArray* pArray, SStreamTask* pTask) {
  int32_t childId = taosArrayGetSize(pArray);
@ -191,7 +190,7 @@ int32_t mndAssignTaskToSnode(SMnode* pMnode, SStreamTask* pTask, SSubplan* plan,
  pTask->nodeId = SNODE_HANDLE;
  pTask->epSet = mndAcquireEpFromSnode(pMnode, pSnode);

-  plan->execNode.nodeId = 0;
+  plan->execNode.nodeId = SNODE_HANDLE;
  plan->execNode.epSet = pTask->epSet;

  if (qSubPlanToString(plan, &pTask->exec.qmsg, &msgLen) < 0) {
@ -374,7 +373,7 @@ int32_t mndScheduleStream(SMnode* pMnode, SStreamObj* pStream) {
        return -1;
      }

-      if (tsSchedStreamToSnode) {
+      if (tsDeployOnSnode) {
        SSnodeObj* pSnode = mndSchedFetchOneSnode(pMnode);
        if (pSnode == NULL) {
          SVgObj* pVgroup = mndSchedFetchOneVg(pMnode, pStream->sourceDbUid);
--- a/source/dnode/mnode/impl/src/mndSnode.c
+++ b/source/dnode/mnode/impl/src/mndSnode.c
@ -273,9 +273,6 @@ _OVER:
 }

 static int32_t mndProcessCreateSnodeReq(SRpcMsg *pReq) {
-#if 1
-  return TSDB_CODE_OPS_NOT_SUPPORT;
-#else
  SMnode          *pMnode = pReq->info.node;
  int32_t          code = -1;
  SSnodeObj       *pObj = NULL;
@ -318,7 +315,6 @@ _OVER:
  mndReleaseSnode(pMnode, pObj);
  mndReleaseDnode(pMnode, pDnode);
  return code;
-#endif
 }

 static int32_t mndSetDropSnodeRedoLogs(STrans *pTrans, SSnodeObj *pObj) {
@ -390,9 +386,6 @@ _OVER:
 }

 static int32_t mndProcessDropSnodeReq(SRpcMsg *pReq) {
-#if 1
-  return TSDB_CODE_OPS_NOT_SUPPORT;
-#else
  SMnode *pMnode = pReq->info.node;
  int32_t code = -1;
  SSnodeObj *pObj = NULL;
@ -429,7 +422,6 @@ _OVER:

  mndReleaseSnode(pMnode, pObj);
  return code;
-#endif
 }

 static int32_t mndRetrieveSnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
--- a/source/dnode/mnode/impl/src/mndSubscribe.c
+++ b/source/dnode/mnode/impl/src/mndSubscribe.c
@ -19,7 +19,6 @@
 #include "mndDb.h"
 #include "mndDnode.h"
 #include "mndMnode.h"
-#include "mndOffset.h"
 #include "mndScheduler.h"
 #include "mndShow.h"
 #include "mndStb.h"
@ -77,7 +76,6 @@ int32_t mndInitSubscribe(SMnode *pMnode) {
  mndSetMsgHandle(pMnode, TDMT_VND_MQ_VG_CHANGE_RSP, mndTransProcessRsp);
  mndSetMsgHandle(pMnode, TDMT_VND_MQ_VG_DELETE_RSP, mndTransProcessRsp);
  mndSetMsgHandle(pMnode, TDMT_MND_MQ_DO_REBALANCE, mndProcessRebalanceReq);
-  mndSetMsgHandle(pMnode, TDMT_MND_MQ_DO_REBALANCE, mndProcessRebalanceReq);
  mndSetMsgHandle(pMnode, TDMT_MND_MQ_DROP_CGROUP, mndProcessDropCgroupReq);
  mndSetMsgHandle(pMnode, TDMT_MND_MQ_DROP_CGROUP_RSP, mndTransProcessRsp);

@ -684,12 +682,6 @@ static int32_t mndProcessDropCgroupReq(SRpcMsg *pReq) {

  mInfo("trans:%d, used to drop cgroup:%s on topic %s", pTrans->id, dropReq.cgroup, dropReq.topic);

-  if (mndDropOffsetBySubKey(pMnode, pTrans, pSub->key) < 0) {
-    mndReleaseSubscribe(pMnode, pSub);
-    mndTransDrop(pTrans);
-    return -1;
-  }
-
  if (mndSetDropSubCommitLogs(pMnode, pTrans, pSub) < 0) {
    mError("cgroup %s on topic:%s, failed to drop since %s", dropReq.cgroup, dropReq.topic, terrstr());
    mndReleaseSubscribe(pMnode, pSub);
--- a/source/dnode/mnode/impl/src/mndTelem.c
+++ b/source/dnode/mnode/impl/src/mndTelem.c
@ -127,8 +127,10 @@ static int32_t mndProcessTelemTimer(SRpcMsg* pReq) {
  STelemMgmt* pMgmt = &pMnode->telemMgmt;
  if (!tsEnableTelem) return 0;

-  taosWLockLatch(&pMgmt->lock);
+  taosThreadMutexLock(&pMgmt->lock);
  char* pCont = mndBuildTelemetryReport(pMnode);
+  taosThreadMutexUnlock(&pMgmt->lock);
+
  if (pCont != NULL) {
    if (taosSendHttpReport(tsTelemServer, tsTelemPort, pCont, strlen(pCont), HTTP_FLAT) != 0) {
      mError("failed to send telemetry report");
@ -137,18 +139,20 @@ static int32_t mndProcessTelemTimer(SRpcMsg* pReq) {
    }
    taosMemoryFree(pCont);
  }
-  taosWUnLockLatch(&pMgmt->lock);
  return 0;
 }

 int32_t mndInitTelem(SMnode* pMnode) {
  STelemMgmt* pMgmt = &pMnode->telemMgmt;

-  taosInitRWLatch(&pMgmt->lock);
+  taosThreadMutexInit(&pMgmt->lock, NULL);
  taosGetEmail(pMgmt->email, sizeof(pMgmt->email));
  mndSetMsgHandle(pMnode, TDMT_MND_TELEM_TIMER, mndProcessTelemTimer);

  return 0;
 }

-void mndCleanupTelem(SMnode* pMnode) {}
+void mndCleanupTelem(SMnode* pMnode) {
+  STelemMgmt* pMgmt = &pMnode->telemMgmt;
+  taosThreadMutexDestroy(&pMgmt->lock);
+}
--- a/source/dnode/mnode/impl/src/mndTopic.c
+++ b/source/dnode/mnode/impl/src/mndTopic.c
@ -18,7 +18,6 @@
 #include "mndDb.h"
 #include "mndDnode.h"
 #include "mndMnode.h"
-#include "mndOffset.h"
 #include "mndPrivilege.h"
 #include "mndShow.h"
 #include "mndStb.h"
--- a/source/dnode/mnode/impl/src/mndVgroup.c
+++ b/source/dnode/mnode/impl/src/mndVgroup.c
@ -60,7 +60,7 @@ int32_t mndInitVgroup(SMnode *pMnode) {
  mndSetMsgHandle(pMnode, TDMT_VND_COMPACT_RSP, mndTransProcessRsp);

  mndSetMsgHandle(pMnode, TDMT_MND_REDISTRIBUTE_VGROUP, mndProcessRedistributeVgroupMsg);
-  mndSetMsgHandle(pMnode, TDMT_MND_MERGE_VGROUP, mndProcessSplitVgroupMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_SPLIT_VGROUP, mndProcessSplitVgroupMsg);
  mndSetMsgHandle(pMnode, TDMT_MND_BALANCE_VGROUP, mndProcessBalanceVgroupMsg);

  mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_VGROUP, mndRetrieveVgroups);
@ -617,35 +617,6 @@ SEpSet mndGetVgroupEpset(SMnode *pMnode, const SVgObj *pVgroup) {
  return epset;
 }

-static bool mndGetVgroupMaxReplicaFp(SMnode *pMnode, void *pObj, void *p1, void *p2, void *p3) {
-  SVgObj  *pVgroup = pObj;
-  int64_t  uid = *(int64_t *)p1;
-  int8_t  *pReplica = p2;
-  int32_t *pNumOfVgroups = p3;
-
-  if (pVgroup->dbUid == uid) {
-    *pReplica = TMAX(*pReplica, pVgroup->replica);
-    (*pNumOfVgroups)++;
-  }
-
-  return true;
-}
-
-static int32_t mndGetVgroupMaxReplica(SMnode *pMnode, char *dbName, int8_t *pReplica, int32_t *pNumOfVgroups) {
-  SSdb   *pSdb = pMnode->pSdb;
-  SDbObj *pDb = mndAcquireDb(pMnode, dbName);
-  if (pDb == NULL) {
-    terrno = TSDB_CODE_MND_DB_NOT_SELECTED;
-    return -1;
-  }
-
-  *pReplica = 1;
-  *pNumOfVgroups = 0;
-  sdbTraverse(pSdb, SDB_VGROUP, mndGetVgroupMaxReplicaFp, &pDb->uid, pReplica, pNumOfVgroups);
-  mndReleaseDb(pMnode, pDb);
-  return 0;
-}
-
 static int32_t mndRetrieveVgroups(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
  SMnode *pMnode = pReq->info.node;
  SSdb   *pSdb = pMnode->pSdb;
@ -1112,7 +1083,9 @@ int32_t mndSetMoveVgroupInfoToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb,
  mInfo("vgId:%d, will add 1 vnodes", pVgroup->vgId);
  if (mndAddVnodeToVgroup(pMnode, &newVg, pArray) != 0) return -1;
  if (mndAddCreateVnodeAction(pMnode, pTrans, pDb, &newVg, &newVg.vnodeGid[newVg.replica - 1]) != 0) return -1;
-  if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg, -1) != 0) return -1;
+  for (int32_t i = 0; i < newVg.replica - 1; ++i) {
+    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg, newVg.vnodeGid[i].dnodeId) != 0) return -1;
+  }
  if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, &newVg) != 0) return -1;

  mInfo("vgId:%d, will remove 1 vnodes", pVgroup->vgId);
@ -1120,8 +1093,10 @@ int32_t mndSetMoveVgroupInfoToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb,
  SVnodeGid del = newVg.vnodeGid[vnIndex];
  newVg.vnodeGid[vnIndex] = newVg.vnodeGid[newVg.replica];
  memset(&newVg.vnodeGid[newVg.replica], 0, sizeof(SVnodeGid));
-  if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg, -1) != 0) return -1;
  if (mndAddDropVnodeAction(pMnode, pTrans, pDb, &newVg, &del, true) != 0) return -1;
+  for (int32_t i = 0; i < newVg.replica; ++i) {
+    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg, newVg.vnodeGid[i].dnodeId) != 0) return -1;
+  }
  if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, &newVg) != 0) return -1;

  {
@ -1193,21 +1168,11 @@ static int32_t mndAddIncVgroupReplicaToTrans(SMnode *pMnode, STrans *pTrans, SDb
  pGid->dnodeId = newDnodeId;
  pGid->syncState = TAOS_SYNC_STATE_ERROR;

-  if (pVgroup->replica == 2) {
-    if (mndAddCreateVnodeAction(pMnode, pTrans, pDb, pVgroup, pGid) != 0) return -1;
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, pVgroup, pVgroup->vnodeGid[0].dnodeId) != 0) return -1;
-    if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, pVgroup) != 0) return -1;
-  } else if (pVgroup->replica == 4) {
-    if (mndAddCreateVnodeAction(pMnode, pTrans, pDb, pVgroup, pGid) != 0) return -1;
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, pVgroup, pVgroup->vnodeGid[0].dnodeId) != 0) return -1;
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, pVgroup, pVgroup->vnodeGid[1].dnodeId) != 0) return -1;
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, pVgroup, pVgroup->vnodeGid[2].dnodeId) != 0) return -1;
-    if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, pVgroup) != 0) return -1;
-  } else {
-    mError("vgId:%d, failed to add 1 vnode since invalid replica:%d", pVgroup->vgId, pVgroup->replica);
-    terrno = TSDB_CODE_MND_APP_ERROR;
-    return -1;
+  if (mndAddCreateVnodeAction(pMnode, pTrans, pDb, pVgroup, pGid) != 0) return -1;
+  for (int32_t i = 0; i < pVgroup->replica - 1; ++i) {
+    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, pVgroup, pVgroup->vnodeGid[i].dnodeId) != 0) return -1;
  }
+  if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, pVgroup) != 0) return -1;

  return 0;
 }
@ -1232,21 +1197,11 @@ static int32_t mndAddDecVgroupReplicaFromTrans(SMnode *pMnode, STrans *pTrans, S
  memcpy(pGid, &pVgroup->vnodeGid[pVgroup->replica], sizeof(SVnodeGid));
  memset(&pVgroup->vnodeGid[pVgroup->replica], 0, sizeof(SVnodeGid));

-  if (pVgroup->replica == 1) {
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, pVgroup, pVgroup->vnodeGid[0].dnodeId) != 0) return -1;
-    if (mndAddDropVnodeAction(pMnode, pTrans, pDb, pVgroup, &delGid, true) != 0) return -1;
-    if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, pVgroup) != 0) return -1;
-  } else if (pVgroup->replica == 3) {
-    if (mndAddDropVnodeAction(pMnode, pTrans, pDb, pVgroup, &delGid, true) != 0) return -1;
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, pVgroup, pVgroup->vnodeGid[0].dnodeId) != 0) return -1;
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, pVgroup, pVgroup->vnodeGid[1].dnodeId) != 0) return -1;
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, pVgroup, pVgroup->vnodeGid[2].dnodeId) != 0) return -1;
-    if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, pVgroup) != 0) return -1;
-  } else {
-    mError("vgId:%d, failed to remove 1 vnode since invalid replica:%d", pVgroup->vgId, pVgroup->replica);
-    terrno = TSDB_CODE_MND_APP_ERROR;
-    return -1;
+  if (mndAddDropVnodeAction(pMnode, pTrans, pDb, pVgroup, &delGid, true) != 0) return -1;
+  for (int32_t i = 0; i < pVgroup->replica; ++i) {
+    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, pVgroup, pVgroup->vnodeGid[i].dnodeId) != 0) return -1;
  }
+  if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, pVgroup) != 0) return -1;

  return 0;
 }
@ -1686,35 +1641,81 @@ static int32_t mndSplitVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SVgObj
  if (newVg1.replica == 1) {
    if (mndAddVnodeToVgroup(pMnode, &newVg1, pArray) != 0) goto _OVER;
    if (mndAddCreateVnodeAction(pMnode, pTrans, pDb, &newVg1, &newVg1.vnodeGid[1]) != 0) goto _OVER;
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg1, -1) != 0) goto _OVER;
+    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg1, newVg1.vnodeGid[0].dnodeId) != 0) goto _OVER;
    if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, &newVg1) != 0) goto _OVER;
  } else if (newVg1.replica == 3) {
    SVnodeGid del1 = {0};
    if (mndRemoveVnodeFromVgroup(pMnode, &newVg1, pArray, &del1) != 0) goto _OVER;
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg1, -1) != 0) goto _OVER;
+    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg1, newVg1.vnodeGid[0].dnodeId) != 0) goto _OVER;
+    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg1, newVg1.vnodeGid[1].dnodeId) != 0) goto _OVER;
    if (mndAddDropVnodeAction(pMnode, pTrans, pDb, &newVg1, &del1, true) != 0) goto _OVER;
    if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, &newVg1) != 0) goto _OVER;
  } else {
    goto _OVER;
  }

+  mInfo("vgId:%d, vgroup info after adjust replica, replica:%d hashBegin:%u hashEnd:%u vnode:0 dnode:%d", newVg1.vgId,
+        newVg1.replica, newVg1.hashBegin, newVg1.hashEnd, newVg1.vnodeGid[0].dnodeId);
+  for (int32_t i = 0; i < newVg1.replica; ++i) {
+    mInfo("vgId:%d, vnode:%d dnode:%d", newVg1.vgId, i, newVg1.vnodeGid[i].dnodeId);
+  }
+
  SVgObj newVg2 = {0};
-  memcpy(&newVg1, &newVg2, sizeof(SVgObj));
+  memcpy(&newVg2, &newVg1, sizeof(SVgObj));
  newVg1.replica = 1;
-  newVg1.hashEnd = (newVg1.hashBegin + newVg1.hashEnd) / 2;
+  newVg1.hashEnd = newVg1.hashBegin / 2 + newVg1.hashEnd / 2;
  memset(&newVg1.vnodeGid[1], 0, sizeof(SVnodeGid));

  newVg2.replica = 1;
  newVg2.hashBegin = newVg1.hashEnd + 1;
  memcpy(&newVg2.vnodeGid[0], &newVg2.vnodeGid[1], sizeof(SVnodeGid));
-  memset(&newVg1.vnodeGid[1], 0, sizeof(SVnodeGid));
+  memset(&newVg2.vnodeGid[1], 0, sizeof(SVnodeGid));
+
+  mInfo("vgId:%d, vgroup info after adjust hash, replica:%d hashBegin:%u hashEnd:%u vnode:0 dnode:%d", newVg1.vgId,
+        newVg1.replica, newVg1.hashBegin, newVg1.hashEnd, newVg1.vnodeGid[0].dnodeId);
+  mInfo("vgId:%d, vgroup info after adjust hash, replica:%d hashBegin:%u hashEnd:%u vnode:0 dnode:%d", newVg2.vgId,
+        newVg2.replica, newVg2.hashBegin, newVg2.hashEnd, newVg2.vnodeGid[0].dnodeId);

  if (mndAddAlterVnodeHashRangeAction(pMnode, pTrans, pDb, &newVg1) != 0) goto _OVER;
  if (mndAddAlterVnodeHashRangeAction(pMnode, pTrans, pDb, &newVg2) != 0) goto _OVER;

-  // adjust vgroup
-  if (mndBuildAlterVgroupAction(pMnode, pTrans, pDb, pDb, &newVg1, pArray) != 0) goto _OVER;
-  if (mndBuildAlterVgroupAction(pMnode, pTrans, pDb, pDb, &newVg2, pArray) != 0) goto _OVER;
+#if 0
+  // adjust vgroup replica
+  if (pDb->cfg.replications != newVg1.replica) {
+    if (mndBuildAlterVgroupAction(pMnode, pTrans, pDb, pDb, &newVg1, pArray) != 0) goto _OVER;
+  }
+  if (pDb->cfg.replications != newVg2.replica) {
+    if (mndBuildAlterVgroupAction(pMnode, pTrans, pDb, pDb, &newVg2, pArray) != 0) goto _OVER;
+  }
+#endif
+
+  {
+    pRaw = mndVgroupActionEncode(&newVg1);
+    if (pRaw == NULL || mndTransAppendCommitlog(pTrans, pRaw) != 0) goto _OVER;
+    (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY);
+    pRaw = NULL;
+  }
+
+  {
+    pRaw = mndVgroupActionEncode(&newVg2);
+    if (pRaw == NULL || mndTransAppendCommitlog(pTrans, pRaw) != 0) goto _OVER;
+    (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY);
+    pRaw = NULL;
+  }
+
+  mInfo("vgId:%d, vgroup info after adjust hash, replica:%d hashBegin:%u hashEnd:%u vnode:0 dnode:%d", newVg1.vgId,
+        newVg1.replica, newVg1.hashBegin, newVg1.hashEnd, newVg1.vnodeGid[0].dnodeId);
+  for (int32_t i = 0; i < newVg1.replica; ++i) {
+    mInfo("vgId:%d, vnode:%d dnode:%d", newVg1.vgId, i, newVg1.vnodeGid[i].dnodeId);
+  }
+  mInfo("vgId:%d, vgroup info after adjust hash, replica:%d hashBegin:%u hashEnd:%u vnode:0 dnode:%d", newVg2.vgId,
+        newVg2.replica, newVg2.hashBegin, newVg2.hashEnd, newVg2.vnodeGid[0].dnodeId);
+  for (int32_t i = 0; i < newVg1.replica; ++i) {
+    mInfo("vgId:%d, vnode:%d dnode:%d", newVg2.vgId, i, newVg2.vnodeGid[i].dnodeId);
+  }
+
+  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
+  code = 0;

 _OVER:
  mndTransDrop(pTrans);
@ -1890,9 +1891,6 @@ _OVER:
 }

 static int32_t mndProcessBalanceVgroupMsg(SRpcMsg *pReq) {
-#if 1
-  return TSDB_CODE_OPS_NOT_SUPPORT;
-#else
  SMnode *pMnode = pReq->info.node;
  int32_t code = -1;
  SArray *pArray = NULL;
@ -1941,7 +1939,6 @@ _OVER:

  taosArrayDestroy(pArray);
  return code;
-#endif
 }

 bool mndVgroupInDb(SVgObj *pVgroup, int64_t dbUid) { return !pVgroup->isTsma && pVgroup->dbUid == dbUid; }
--- a/source/dnode/mnode/impl/test/sdb/sdbTest.cpp
+++ b/source/dnode/mnode/impl/test/sdb/sdbTest.cpp
@ -367,6 +367,80 @@ bool sdbTraverseFail(SMnode *pMnode, SStrObj *pObj, int32_t *p1, int32_t *p2, in
  return false;
 }

+#ifndef WINDOWS
+
+TEST_F(MndTestSdb, 00_API) {
+  SMnode  mnode = {0};
+  SSdbOpt opt = {0};
+  opt.pMnode = &mnode;
+  opt.path = TD_TMP_DIR_PATH "mnode_test_sdb";
+  taosRemoveDir(opt.path);
+  SSdb *pSdb = sdbInit(&opt);
+
+  SSdbTable table = {.sdbType = SDB_USER, .keyType = SDB_KEY_BINARY};
+  sdbSetTable(pSdb, table);
+
+  // sdbRow.c
+  SSdbRow *pRow1 = sdbAllocRow(-128);
+  ASSERT_EQ(pRow1 == NULL, 1);
+
+  void *pRow2 = sdbGetRowObj(NULL);
+  ASSERT_EQ(pRow2 == NULL, 1);
+
+  //sdbRaw.c
+  SStrObj  strObj;
+  SSdbRaw *pRaw1 = NULL;
+  strSetDefault(&strObj, 1);
+  
+  pRaw1 = strEncode(&strObj);
+  int32_t id = sdbGetIdFromRaw(pSdb, pRaw1);
+  ASSERT_EQ(id, -2);
+
+  SSdbRaw *pRaw2 = sdbAllocRaw(SDB_USER, 1, -128);
+  ASSERT_EQ(pRaw2 == NULL, 1);
+
+  ASSERT_EQ(sdbSetRawInt8(NULL, 0, 0), -1);
+  ASSERT_EQ(sdbSetRawInt8(pRaw1, -128, 0), -1);
+  ASSERT_EQ(sdbSetRawInt32(NULL, 0, 0), -1);
+  ASSERT_EQ(sdbSetRawInt32(pRaw1, -128, 0), -1);
+  ASSERT_EQ(sdbSetRawInt16(NULL, 0, 0), -1);
+  ASSERT_EQ(sdbSetRawInt16(pRaw1, -128, 0), -1);
+  ASSERT_EQ(sdbSetRawInt64(NULL, 0, 0), -1);
+  ASSERT_EQ(sdbSetRawInt64(pRaw1, -128, 0), -1);
+  ASSERT_EQ(sdbSetRawBinary(NULL, 0, "12", 3), -1);
+  ASSERT_EQ(sdbSetRawBinary(pRaw1, 9028, "12", 3), -1);
+  ASSERT_EQ(sdbSetRawDataLen(NULL, 0), -1);
+  ASSERT_EQ(sdbSetRawDataLen(pRaw1, 9000), -1);
+  ASSERT_EQ(sdbSetRawStatus(NULL, SDB_STATUS_READY), -1);
+  ASSERT_EQ(sdbSetRawStatus(pRaw1, SDB_STATUS_INIT), -1);
+
+  ASSERT_EQ(sdbGetRawInt8(NULL, 0, 0), -1);
+  ASSERT_EQ(sdbGetRawInt8(pRaw1, 9000, 0), -1);
+  ASSERT_EQ(sdbGetRawInt32(NULL, 0, 0), -1);
+  ASSERT_EQ(sdbGetRawInt32(pRaw1, 9000, 0), -1);
+  ASSERT_EQ(sdbGetRawInt16(NULL, 0, 0), -1);
+  ASSERT_EQ(sdbGetRawInt16(pRaw1, 9000, 0), -1);
+  ASSERT_EQ(sdbGetRawInt64(NULL, 0, 0), -1);
+  ASSERT_EQ(sdbGetRawInt64(pRaw1, 9000, 0), -1);
+  ASSERT_EQ(sdbGetRawBinary(NULL, 0, 0, 4096), -1);
+  ASSERT_EQ(sdbGetRawBinary(pRaw1, 9000, 0, 112), -1);
+  ASSERT_EQ(sdbGetRawSoftVer(NULL, 0), -1);
+  ASSERT_EQ(sdbGetRawTotalSize(NULL), -1);
+
+  // sdbHash.c
+  EXPECT_STREQ(sdbTableName((ESdbType)100), "undefine");
+  EXPECT_STREQ(sdbStatusName((ESdbStatus)100), "undefine");
+  ASSERT_EQ(sdbGetTableVer(pSdb, (ESdbType)100), -1);
+
+  SSdbRaw *pRaw3 = sdbAllocRaw((ESdbType)-12, 1, 128);
+  ASSERT_NE(sdbWriteWithoutFree(pSdb, pRaw3), 0);
+  pSdb->hashObjs[1] = NULL;
+  SSdbRaw *pRaw4 = sdbAllocRaw((ESdbType)1, 1, 128);
+  ASSERT_NE(sdbWriteWithoutFree(pSdb, pRaw4), 0);
+}
+
+#endif
+
 TEST_F(MndTestSdb, 01_Write_Str) {
  void    *pIter = NULL;
  int32_t  num = 0;
@ -885,8 +959,8 @@ TEST_F(MndTestSdb, 01_Read_Str) {
    ASSERT_EQ(sdbWrite(pSdb, pRaw), 0);
    pI32Obj = (SI32Obj *)sdbAcquire(pSdb, SDB_VGROUP, &key);
    ASSERT_EQ(pI32Obj, nullptr);
-    int32_t code = terrno;
-    ASSERT_EQ(code, TSDB_CODE_SDB_OBJ_DROPPING);
+    // int32_t code = terrno;
+    // ASSERT_EQ(code, TSDB_CODE_SDB_OBJ_DROPPING);
  }

  {
@ -899,8 +973,8 @@ TEST_F(MndTestSdb, 01_Read_Str) {
    ASSERT_EQ(sdbWrite(pSdb, pRaw), 0);
    pI32Obj = (SI32Obj *)sdbAcquire(pSdb, SDB_VGROUP, &key);
    ASSERT_EQ(pI32Obj, nullptr);
-    int32_t code = terrno;
-    ASSERT_EQ(code, TSDB_CODE_SDB_OBJ_CREATING);
+    // int32_t code = terrno;
+    // ASSERT_EQ(code, TSDB_CODE_SDB_OBJ_CREATING);
  }

  {
@ -934,4 +1008,4 @@ TEST_F(MndTestSdb, 01_Read_Str) {
  sdbCleanup(pSdb);
  ASSERT_EQ(mnode.insertTimes, 9);
  ASSERT_EQ(mnode.deleteTimes, 9);
-}
+}
--- a/source/dnode/mnode/sdb/src/sdbFile.c
+++ b/source/dnode/mnode/sdb/src/sdbFile.c
@ -654,15 +654,12 @@ int32_t sdbStopWrite(SSdb *pSdb, SSdbIter *pIter, bool isApply, int64_t index, i
  }

  if (config > 0) {
-    ASSERT(pSdb->commitConfig == config);
    pSdb->commitConfig = config;
  }
  if (term > 0) {
-    ASSERT(pSdb->commitTerm == term);
    pSdb->commitTerm = term;
  }
  if (index > 0) {
-    ASSERT(pSdb->commitIndex == index);
    pSdb->commitIndex = index;
  }

--- a/source/dnode/mnode/sdb/src/sdbHash.c
+++ b/source/dnode/mnode/sdb/src/sdbHash.c
@ -241,9 +241,7 @@ int32_t sdbWriteWithoutFree(SSdb *pSdb, SSdbRaw *pRaw) {

  SdbDecodeFp decodeFp = pSdb->decodeFps[pRaw->type];
  SSdbRow    *pRow = (*decodeFp)(pRaw);
-  if (pRow == NULL) {
-    return terrno;
-  }
+  if (pRow == NULL) return terrno;

  pRow->type = pRaw->type;

--- a/source/dnode/qnode/src/qnode.c
+++ b/source/dnode/qnode/src/qnode.c
@ -90,7 +90,7 @@ int32_t qndProcessQueryMsg(SQnode *pQnode, int64_t ts, SRpcMsg *pMsg) {
      code = qWorkerProcessFetchMsg(pQnode, pQnode->pQuery, pMsg, ts);
      break;
    case TDMT_SCH_CANCEL_TASK:
-      code = qWorkerProcessCancelMsg(pQnode, pQnode->pQuery, pMsg, ts);
+      //code = qWorkerProcessCancelMsg(pQnode, pQnode->pQuery, pMsg, ts);
      break;
    case TDMT_SCH_DROP_TASK:
      code = qWorkerProcessDropMsg(pQnode, pQnode->pQuery, pMsg, ts);
--- a/source/dnode/snode/inc/sndInt.h
+++ b/source/dnode/snode/inc/sndInt.h
@ -31,7 +31,9 @@ extern "C" {
 #endif

 typedef struct SSnode {
-  SMsgCb msgCb;
+  char*        path;
+  SStreamMeta* pMeta;
+  SMsgCb       msgCb;
 } SSnode;

 #if 0
--- a/source/dnode/snode/src/snode.c
+++ b/source/dnode/snode/src/snode.c
@ -15,197 +15,197 @@

 #include "executor.h"
 #include "sndInt.h"
+#include "tstream.h"
 #include "tuuid.h"
-/*SSnode *sndOpen(const char *path, const SSnodeOpt *pOption) { return NULL; }*/
-/*void    sndClose(SSnode *pSnode) {}*/
-int32_t sndProcessUMsg(SSnode *pSnode, SRpcMsg *pMsg) { return 0; }
-int32_t sndProcessSMsg(SSnode *pSnode, SRpcMsg *pMsg) { return 0; }
+
+void sndEnqueueStreamDispatch(SSnode *pSnode, SRpcMsg *pMsg) {
+  char   *msgStr = pMsg->pCont;
+  char   *msgBody = POINTER_SHIFT(msgStr, sizeof(SMsgHead));
+  int32_t msgLen = pMsg->contLen - sizeof(SMsgHead);
+  int32_t code = 0;
+
+  SStreamDispatchReq req;
+  SDecoder           decoder;
+  tDecoderInit(&decoder, msgBody, msgLen);
+  if (tDecodeStreamDispatchReq(&decoder, &req) < 0) {
+    code = TSDB_CODE_MSG_DECODE_ERROR;
+    tDecoderClear(&decoder);
+    goto FAIL;
+  }
+  tDecoderClear(&decoder);
+
+  int32_t taskId = req.taskId;
+
+  SStreamTask *pTask = streamMetaGetTask(pSnode->pMeta, taskId);
+  if (pTask) {
+    SRpcMsg rsp = {
+        .info = pMsg->info,
+        .code = 0,
+    };
+    streamProcessDispatchReq(pTask, &req, &rsp, false);
+    rpcFreeCont(pMsg->pCont);
+    taosFreeQitem(pMsg);
+    return;
+  }
+
+FAIL:
+  if (pMsg->info.handle == NULL) return;
+  SRpcMsg rsp = {
+      .code = code,
+      .info = pMsg->info,
+  };
+  tmsgSendRsp(&rsp);
+  rpcFreeCont(pMsg->pCont);
+  taosFreeQitem(pMsg);
+}
+
+int32_t sndExpandTask(SSnode *pSnode, SStreamTask *pTask, int64_t ver) {
+  ASSERT(pTask->taskLevel == TASK_LEVEL__AGG);
+  ASSERT(taosArrayGetSize(pTask->childEpInfo) != 0);
+
+  pTask->schedStatus = TASK_SCHED_STATUS__INACTIVE;
+  pTask->inputQueue = streamQueueOpen();
+  pTask->outputQueue = streamQueueOpen();
+
+  if (pTask->inputQueue == NULL || pTask->outputQueue == NULL) {
+    return -1;
+  }
+
+  pTask->inputStatus = TASK_INPUT_STATUS__NORMAL;
+  pTask->outputStatus = TASK_OUTPUT_STATUS__NORMAL;
+
+  pTask->pMsgCb = &pSnode->msgCb;
+
+  pTask->startVer = ver;
+
+  pTask->pState = streamStateOpen(pSnode->path, pTask, false, -1, -1);
+  if (pTask->pState == NULL) {
+    return -1;
+  }
+
+  SReadHandle mgHandle = {
+      .vnode = NULL,
+      .numOfVgroups = (int32_t)taosArrayGetSize(pTask->childEpInfo),
+      .pStateBackend = pTask->pState,
+  };
+  pTask->exec.executor = qCreateStreamExecTaskInfo(pTask->exec.qmsg, &mgHandle);
+  ASSERT(pTask->exec.executor);
+
+  return 0;
+}

 SSnode *sndOpen(const char *path, const SSnodeOpt *pOption) {
  SSnode *pSnode = taosMemoryCalloc(1, sizeof(SSnode));
  if (pSnode == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
    return NULL;
  }
+  pSnode->path = strdup(path);
+  if (pSnode->path == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    goto FAIL;
+  }
  pSnode->msgCb = pOption->msgCb;
-#if 0
-  pSnode->pMeta = sndMetaNew();
+
+  pSnode->pMeta = streamMetaOpen(path, pSnode, (FTaskExpand *)sndExpandTask, SNODE_HANDLE);
  if (pSnode->pMeta == NULL) {
-    taosMemoryFree(pSnode);
-    return NULL;
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    goto FAIL;
  }
-#endif
+
  return pSnode;
+
+FAIL:
+  taosMemoryFree(pSnode->path);
+  taosMemoryFree(pSnode);
+  return NULL;
 }

 void sndClose(SSnode *pSnode) {
-  /*sndMetaDelete(pSnode->pMeta);*/
+  streamMetaClose(pSnode->pMeta);
+  taosMemoryFree(pSnode->path);
  taosMemoryFree(pSnode);
 }

 int32_t sndGetLoad(SSnode *pSnode, SSnodeLoad *pLoad) { return 0; }

-#if 0
-SStreamMeta *sndMetaNew() {
-  SStreamMeta *pMeta = taosMemoryCalloc(1, sizeof(SStreamMeta));
-  if (pMeta == NULL) {
-    return NULL;
-  }
-  pMeta->pHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_NO_LOCK);
-  if (pMeta->pHash == NULL) {
-    taosMemoryFree(pMeta);
-    return NULL;
-  }
-  return pMeta;
-}
-
-void sndMetaDelete(SStreamMeta *pMeta) {
-  taosHashCleanup(pMeta->pHash);
-  taosMemoryFree(pMeta);
-}
-
-int32_t sndMetaDeployTask(SStreamMeta *pMeta, SStreamTask *pTask) {
-  pTask->exec.executor = qCreateStreamExecTaskInfo(pTask->exec.qmsg, NULL);
-  return taosHashPut(pMeta->pHash, &pTask->taskId, sizeof(int32_t), pTask, sizeof(void *));
-}
-
-SStreamTask *sndMetaGetTask(SStreamMeta *pMeta, int32_t taskId) {
-  return taosHashGet(pMeta->pHash, &taskId, sizeof(int32_t));
-}
-
-int32_t sndMetaRemoveTask(SStreamMeta *pMeta, int32_t taskId) {
-  SStreamTask *pTask = taosHashGet(pMeta->pHash, &taskId, sizeof(int32_t));
-  if (pTask == NULL) {
-    return -1;
-  }
-  taosMemoryFree(pTask->exec.qmsg);
-  // TODO:free executor
-  taosMemoryFree(pTask);
-  return taosHashRemove(pMeta->pHash, &taskId, sizeof(int32_t));
-}
-
-static int32_t sndProcessTaskDeployReq(SSnode *pNode, SRpcMsg *pMsg) {
-  SStreamMeta *pMeta = pNode->pMeta;
-  char        *msg = POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead));
-  int32_t      msgLen = pMsg->contLen - sizeof(SMsgHead);
+int32_t sndProcessTaskDeployReq(SSnode *pSnode, char *msg, int32_t msgLen) {
+  int32_t code;

+  // 1.deserialize msg and build task
  SStreamTask *pTask = taosMemoryCalloc(1, sizeof(SStreamTask));
  if (pTask == NULL) {
    return -1;
  }
  SDecoder decoder;
  tDecoderInit(&decoder, (uint8_t *)msg, msgLen);
-  if (tDecodeSStreamTask(&decoder, pTask) < 0) {
-    ASSERT(0);
+  code = tDecodeSStreamTask(&decoder, pTask);
+  if (code < 0) {
+    tDecoderClear(&decoder);
+    taosMemoryFree(pTask);
+    return -1;
  }
  tDecoderClear(&decoder);

-  pTask->execStatus = TASK_EXEC_STATUS__IDLE;
+  ASSERT(pTask->taskLevel == TASK_LEVEL__AGG);

-  pTask->inputQueue = streamQueueOpen();
-  pTask->outputQueue = streamQueueOpen();
-  pTask->inputStatus = TASK_INPUT_STATUS__NORMAL;
-  pTask->outputStatus = TASK_INPUT_STATUS__NORMAL;
+  // 2.save task
+  code = streamMetaAddTask(pSnode->pMeta, -1, pTask);
+  if (code < 0) {
+    return -1;
+  }

-  if (pTask->inputQueue == NULL || pTask->outputQueue == NULL) goto FAIL;
-
-  pTask->pMsgCb = &pNode->msgCb;
-
-  pTask->exec.executor = qCreateStreamExecTaskInfo(pTask->exec.qmsg, NULL);
-  ASSERT(pTask->exec.executor);
-
-  streamSetupTrigger(pTask);
-
-  qInfo("deploy stream: stream id %" PRId64 " task id %d child id %d on snode", pTask->streamId, pTask->taskId,
-        pTask->selfChildId);
-
-  taosHashPut(pMeta->pHash, &pTask->taskId, sizeof(int32_t), &pTask, sizeof(void *));
+  // 3.go through recover steps to fill history
+  if (pTask->fillHistory) {
+    streamSetParamForRecover(pTask);
+    streamAggRecoverPrepare(pTask);
+  }

  return 0;
-
-FAIL:
-  if (pTask->inputQueue) streamQueueClose(pTask->inputQueue);
-  if (pTask->outputQueue) streamQueueClose(pTask->outputQueue);
-  if (pTask) taosMemoryFree(pTask);
-  return -1;
 }

-static int32_t sndProcessTaskRunReq(SSnode *pNode, SRpcMsg *pMsg) {
-  SStreamMeta       *pMeta = pNode->pMeta;
+int32_t sndProcessTaskDropReq(SSnode *pSnode, char *msg, int32_t msgLen) {
+  SVDropStreamTaskReq *pReq = (SVDropStreamTaskReq *)msg;
+  return streamMetaRemoveTask(pSnode->pMeta, pReq->taskId);
+}
+
+int32_t sndProcessTaskRunReq(SSnode *pSnode, SRpcMsg *pMsg) {
  SStreamTaskRunReq *pReq = pMsg->pCont;
  int32_t            taskId = pReq->taskId;
-  SStreamTask       *pTask = *(SStreamTask **)taosHashGet(pMeta->pHash, &taskId, sizeof(int32_t));
-  streamProcessRunReq(pTask);
-  return 0;
+  SStreamTask       *pTask = streamMetaGetTask(pSnode->pMeta, taskId);
+  if (pTask) {
+    streamProcessRunReq(pTask);
+    return 0;
+  } else {
+    return -1;
+  }
 }

-static int32_t sndProcessTaskDispatchReq(SSnode *pNode, SRpcMsg *pMsg) {
-  SStreamMeta *pMeta = pNode->pMeta;
-
-  char   *msgStr = pMsg->pCont;
-  char   *msgBody = POINTER_SHIFT(msgStr, sizeof(SMsgHead));
-  int32_t msgLen = pMsg->contLen - sizeof(SMsgHead);
-
+int32_t sndProcessTaskDispatchReq(SSnode *pSnode, SRpcMsg *pMsg, bool exec) {
+  char              *msgStr = pMsg->pCont;
+  char              *msgBody = POINTER_SHIFT(msgStr, sizeof(SMsgHead));
+  int32_t            msgLen = pMsg->contLen - sizeof(SMsgHead);
  SStreamDispatchReq req;
  SDecoder           decoder;
-  tDecoderInit(&decoder, msgBody, msgLen);
+  tDecoderInit(&decoder, (uint8_t *)msgBody, msgLen);
  tDecodeStreamDispatchReq(&decoder, &req);
-  int32_t      taskId = req.taskId;
-  SStreamTask *pTask = *(SStreamTask **)taosHashGet(pMeta->pHash, &taskId, sizeof(int32_t));
-  SRpcMsg      rsp = {
-           .info = pMsg->info,
-           .code = 0,
-  };
-  streamProcessDispatchReq(pTask, &req, &rsp, true);
-  return 0;
-}
+  int32_t taskId = req.taskId;

-static int32_t sndProcessTaskRecoverReq(SSnode *pNode, SRpcMsg *pMsg) {
-  SStreamMeta *pMeta = pNode->pMeta;
-
-  SStreamTaskRecoverReq *pReq = pMsg->pCont;
-  int32_t                taskId = pReq->taskId;
-  SStreamTask           *pTask = *(SStreamTask **)taosHashGet(pMeta->pHash, &taskId, sizeof(int32_t));
-  streamProcessRecoverReq(pTask, pReq, pMsg);
-  return 0;
-}
-
-static int32_t sndProcessTaskDispatchRsp(SSnode *pNode, SRpcMsg *pMsg) {
-  SStreamMeta *pMeta = pNode->pMeta;
-
-  SStreamDispatchRsp *pRsp = POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead));
-  int32_t             taskId = pRsp->taskId;
-  SStreamTask        *pTask = *(SStreamTask **)taosHashGet(pMeta->pHash, &taskId, sizeof(int32_t));
-  streamProcessDispatchRsp(pTask, pRsp);
-  return 0;
-}
-
-static int32_t sndProcessTaskRecoverRsp(SSnode *pNode, SRpcMsg *pMsg) {
-  SStreamMeta *pMeta = pNode->pMeta;
-
-  SStreamTaskRecoverRsp *pRsp = pMsg->pCont;
-  int32_t                taskId = pRsp->rspTaskId;
-  SStreamTask           *pTask = *(SStreamTask **)taosHashGet(pMeta->pHash, &taskId, sizeof(int32_t));
-  streamProcessRecoverRsp(pTask, pRsp);
-  return 0;
-}
-
-static int32_t sndProcessTaskDropReq(SSnode *pNode, SRpcMsg *pMsg) {
-  SStreamMeta *pMeta = pNode->pMeta;
-
-  char                *msg = pMsg->pCont;
-  int32_t              msgLen = pMsg->contLen;
-  SVDropStreamTaskReq *pReq = (SVDropStreamTaskReq *)msg;
-  int32_t              code = taosHashRemove(pMeta->pHash, &pReq->taskId, sizeof(int32_t));
-  ASSERT(code == 0);
-  if (code == 0) {
-    // sendrsp
+  SStreamTask *pTask = streamMetaGetTask(pSnode->pMeta, taskId);
+  if (pTask) {
+    SRpcMsg rsp = {
+        .info = pMsg->info,
+        .code = 0,
+    };
+    streamProcessDispatchReq(pTask, &req, &rsp, exec);
+    return 0;
+  } else {
+    return -1;
  }
-  return code;
+  return 0;
 }

-static int32_t sndProcessTaskRetrieveReq(SSnode *pNode, SRpcMsg *pMsg) {
-  SStreamMeta *pMeta = pNode->pMeta;
-
+int32_t sndProcessTaskRetrieveReq(SSnode *pSnode, SRpcMsg *pMsg) {
  char              *msgStr = pMsg->pCont;
  char              *msgBody = POINTER_SHIFT(msgStr, sizeof(SMsgHead));
  int32_t            msgLen = pMsg->contLen - sizeof(SMsgHead);
@ -213,53 +213,64 @@ static int32_t sndProcessTaskRetrieveReq(SSnode *pNode, SRpcMsg *pMsg) {
  SDecoder           decoder;
  tDecoderInit(&decoder, msgBody, msgLen);
  tDecodeStreamRetrieveReq(&decoder, &req);
+  tDecoderClear(&decoder);
  int32_t      taskId = req.dstTaskId;
-  SStreamTask *pTask = *(SStreamTask **)taosHashGet(pMeta->pHash, &taskId, sizeof(int32_t));
-  if (atomic_load_8(&pTask->taskStatus) != TASK_STATUS__NORMAL) {
+  SStreamTask *pTask = streamMetaGetTask(pSnode->pMeta, taskId);
+  if (pTask) {
+    SRpcMsg rsp = {
+        .info = pMsg->info,
+        .code = 0,
+    };
+    streamProcessRetrieveReq(pTask, &req, &rsp);
+    tDeleteStreamRetrieveReq(&req);
    return 0;
+  } else {
+    return -1;
+  }
+}
+
+int32_t sndProcessTaskDispatchRsp(SSnode *pSnode, SRpcMsg *pMsg) {
+  SStreamDispatchRsp *pRsp = POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead));
+  int32_t             taskId = pRsp->taskId;
+  SStreamTask        *pTask = streamMetaGetTask(pSnode->pMeta, taskId);
+  if (pTask) {
+    streamProcessDispatchRsp(pTask, pRsp);
+    return 0;
+  } else {
+    return -1;
  }
-  SRpcMsg rsp = {
-      .info = pMsg->info,
-      .code = 0,
-  };
-  streamProcessRetrieveReq(pTask, &req, &rsp);
  return 0;
 }

-static int32_t sndProcessTaskRetrieveRsp(SSnode *pNode, SRpcMsg *pMsg) {
+int32_t sndProcessTaskRetrieveRsp(SSnode *pSnode, SRpcMsg *pMsg) {
  //
  return 0;
 }

-int32_t sndProcessUMsg(SSnode *pSnode, SRpcMsg *pMsg) {
-  // stream deploy
-  // stream stop/resume
-  // operator exec
+int32_t sndProcessWriteMsg(SSnode *pSnode, SRpcMsg *pMsg, SRpcMsg *pRsp) {
+  void   *pReq = POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead));
+  int32_t len = pMsg->contLen - sizeof(SMsgHead);
  switch (pMsg->msgType) {
    case TDMT_STREAM_TASK_DEPLOY:
-      return sndProcessTaskDeployReq(pSnode, pMsg);
+      return sndProcessTaskDeployReq(pSnode, pReq, len);
    case TDMT_STREAM_TASK_DROP:
-      return sndProcessTaskDropReq(pSnode, pMsg);
+      return sndProcessTaskDropReq(pSnode, pReq, len);
    default:
      ASSERT(0);
  }
  return 0;
 }

-int32_t sndProcessSMsg(SSnode *pSnode, SRpcMsg *pMsg) {
+int32_t sndProcessStreamMsg(SSnode *pSnode, SRpcMsg *pMsg) {
  switch (pMsg->msgType) {
    case TDMT_STREAM_TASK_RUN:
      return sndProcessTaskRunReq(pSnode, pMsg);
    case TDMT_STREAM_TASK_DISPATCH:
-      return sndProcessTaskDispatchReq(pSnode, pMsg);
-    case TDMT_STREAM_TASK_RECOVER:
-      return sndProcessTaskRecoverReq(pSnode, pMsg);
+      return sndProcessTaskDispatchReq(pSnode, pMsg, true);
    case TDMT_STREAM_RETRIEVE:
-      return sndProcessTaskRecoverReq(pSnode, pMsg);
+      return sndProcessTaskRetrieveReq(pSnode, pMsg);
    case TDMT_STREAM_TASK_DISPATCH_RSP:
      return sndProcessTaskDispatchRsp(pSnode, pMsg);
-    case TDMT_STREAM_TASK_RECOVER_RSP:
-      return sndProcessTaskRecoverRsp(pSnode, pMsg);
    case TDMT_STREAM_RETRIEVE_RSP:
      return sndProcessTaskRetrieveRsp(pSnode, pMsg);
    default:
@ -267,4 +278,3 @@ int32_t sndProcessSMsg(SSnode *pSnode, SRpcMsg *pMsg) {
  }
  return 0;
 }
-#endif
--- a/source/dnode/vnode/inc/vnode.h
+++ b/source/dnode/vnode/inc/vnode.h
@ -152,11 +152,13 @@ typedef struct STsdbReader STsdbReader;
 #define CACHESCAN_RETRIEVE_LAST_ROW    0x4
 #define CACHESCAN_RETRIEVE_LAST        0x8

-int32_t  tsdbSetTableId(STsdbReader *pReader, int64_t uid);
-int32_t  tsdbReaderOpen(SVnode *pVnode, SQueryTableDataCond *pCond, SArray *pTableList, STsdbReader **ppReader,
-                        const char *idstr);
+int32_t tsdbSetTableList(STsdbReader *pReader, const void *pTableList, int32_t num);
+int32_t tsdbReaderOpen(SVnode *pVnode, SQueryTableDataCond *pCond, void *pTableList, int32_t numOfTables,
+                       STsdbReader **ppReader, const char *idstr);
+
 void     tsdbReaderClose(STsdbReader *pReader);
 bool     tsdbNextDataBlock(STsdbReader *pReader);
+bool     tsdbTableNextDataBlock(STsdbReader *pReader, uint64_t uid);
 void     tsdbRetrieveDataBlockInfo(STsdbReader *pReader, SDataBlockInfo *pDataBlockInfo);
 int32_t  tsdbRetrieveDatablockSMA(STsdbReader *pReader, SColumnDataAgg ***pBlockStatis, bool *allHave);
 SArray  *tsdbRetrieveDataBlock(STsdbReader *pTsdbReadHandle, SArray *pColumnIdList);
@ -167,8 +169,8 @@ void    *tsdbGetIdx(SMeta *pMeta);
 void    *tsdbGetIvtIdx(SMeta *pMeta);
 uint64_t getReaderMaxVersion(STsdbReader *pReader);

-int32_t tsdbCacherowsReaderOpen(void *pVnode, int32_t type, SArray *pTableIdList, int32_t numOfCols, uint64_t suid,
-                                void **pReader);
+int32_t tsdbCacherowsReaderOpen(void *pVnode, int32_t type, void *pTableIdList, int32_t numOfTables, int32_t numOfCols,
+                                uint64_t suid, void **pReader);
 int32_t tsdbRetrieveCacheRows(void *pReader, SSDataBlock *pResBlock, const int32_t *slotIds, SArray *pTableUids);
 void   *tsdbCacherowsReaderClose(void *pReader);
 int32_t tsdbGetTableSchema(SVnode *pVnode, int64_t uid, STSchema **pSchema, int64_t *suid);
--- a/source/dnode/vnode/src/inc/tq.h
+++ b/source/dnode/vnode/src/inc/tq.h
@ -155,7 +155,7 @@ int64_t tqFetchLog(STQ* pTq, STqHandle* pHandle, int64_t* fetchOffset, SWalCkHea

 // tqExec
 int32_t tqTaosxScanLog(STQ* pTq, STqHandle* pHandle, SSubmitReq* pReq, STaosxRsp* pRsp);
-int32_t tqAddBlockDataToRsp(const SSDataBlock* pBlock, SMqDataRsp* pRsp, int32_t numOfCols);
+int32_t tqAddBlockDataToRsp(const SSDataBlock* pBlock, SMqDataRsp* pRsp, int32_t numOfCols, int8_t precision);
 int32_t tqSendDataRsp(STQ* pTq, const SRpcMsg* pMsg, const SMqPollReq* pReq, const SMqDataRsp* pRsp);
 int32_t tqPushDataRsp(STQ* pTq, STqPushEntry* pPushEntry);

@ -181,15 +181,15 @@ int32_t         tqOffsetDelete(STqOffsetStore* pStore, const char* subscribeKey)
 int32_t         tqOffsetCommitFile(STqOffsetStore* pStore);

 // tqSink
-void tqSinkToTableMerge(SStreamTask* pTask, void* vnode, int64_t ver, void* data);
+// void tqSinkToTableMerge(SStreamTask* pTask, void* vnode, int64_t ver, void* data);
 void tqSinkToTablePipeline(SStreamTask* pTask, void* vnode, int64_t ver, void* data);

 // tqOffset
-char*   tqOffsetBuildFName(const char* path, int32_t ver);
+char*   tqOffsetBuildFName(const char* path, int32_t fVer);
 int32_t tqOffsetRestoreFromFile(STqOffsetStore* pStore, const char* fname);

 // tqStream
-int32_t tqExpandTask(STQ* pTq, SStreamTask* pTask);
+int32_t tqExpandTask(STQ* pTq, SStreamTask* pTask, int64_t ver);

 #ifdef __cplusplus
 }
--- a/source/dnode/vnode/src/inc/tsdb.h
+++ b/source/dnode/vnode/src/inc/tsdb.h
@ -716,7 +716,9 @@ typedef struct SCacheRowsReader {
  int32_t            numOfCols;
  int32_t            type;
  int32_t            tableIndex;  // currently returned result tables
-  SArray            *pTableList;  // table id list
+
+  STableKeyInfo     *pTableList;  // table id list
+  int32_t            numOfTables;
  SSttBlockLoadInfo *pLoadInfo;
  STsdbReadSnap     *pReadSnap;
  SDataFReader      *pDataFReader;
--- a/source/dnode/vnode/src/inc/vnodeInt.h
+++ b/source/dnode/vnode/src/inc/vnodeInt.h
@ -162,10 +162,7 @@ int         tsdbInsertData(STsdb* pTsdb, int64_t version, SSubmitReq* pMsg, SSub
 int32_t     tsdbInsertTableData(STsdb* pTsdb, int64_t version, SSubmitMsgIter* pMsgIter, SSubmitBlk* pBlock,
                                SSubmitBlkRsp* pRsp);
 int32_t     tsdbDeleteTableData(STsdb* pTsdb, int64_t version, tb_uid_t suid, tb_uid_t uid, TSKEY sKey, TSKEY eKey);
-STsdbReader tsdbQueryCacheLastT(STsdb* tsdb, SQueryTableDataCond* pCond, STableListInfo* tableList, uint64_t qId,
-                                void* pMemRef);
 int32_t     tsdbSetKeepCfg(STsdb* pTsdb, STsdbCfg* pCfg);
-int32_t     tsdbGetStbIdList(SMeta* pMeta, int64_t suid, SArray* list);

 // tq
 int     tqInit();
--- a/source/dnode/vnode/src/sma/smaRollup.c
+++ b/source/dnode/vnode/src/sma/smaRollup.c
@ -15,11 +15,11 @@

 #include "sma.h"

-#define RSMA_QTASKEXEC_SMOOTH_SIZE (100)                                                 // cnt
-#define RSMA_SUBMIT_BATCH_SIZE     (1024)                                                // cnt
-#define RSMA_FETCH_DELAY_MAX       (120000)                                              // ms
-#define RSMA_FETCH_ACTIVE_MAX      (1000)                                                // ms
-#define RSMA_FETCH_INTERVAL        (5000)                                                // ms
+#define RSMA_QTASKEXEC_SMOOTH_SIZE (100)     // cnt
+#define RSMA_SUBMIT_BATCH_SIZE     (1024)    // cnt
+#define RSMA_FETCH_DELAY_MAX       (120000)  // ms
+#define RSMA_FETCH_ACTIVE_MAX      (1000)    // ms
+#define RSMA_FETCH_INTERVAL        (5000)    // ms

 SSmaMgmt smaMgmt = {
    .inited = 0,
@ -701,25 +701,28 @@ static int32_t tdRSmaExecAndSubmitResult(SSma *pSma, qTaskInfo_t taskInfo, SRSma
 #endif
    for (int32_t i = 0; i < taosArrayGetSize(pResList); ++i) {
      SSDataBlock *output = taosArrayGetP(pResList, i);
+      smaDebug("result block, uid:%"PRIu64", groupid:%"PRIu64", rows:%d", output->info.uid, output->info.groupId,
+              output->info.rows);
+
      STsdb       *sinkTsdb = (pItem->level == TSDB_RETENTION_L1 ? pSma->pRSmaTsdb[0] : pSma->pRSmaTsdb[1]);
      SSubmitReq  *pReq = NULL;

      // TODO: the schema update should be handled later(TD-17965)
      if (buildSubmitReqFromDataBlock(&pReq, output, pTSchema, SMA_VID(pSma), suid) < 0) {
-        smaError("vgId:%d, build submit req for rsma table %" PRIi64 " level %" PRIi8 " failed since %s", SMA_VID(pSma),
-                 suid, pItem->level, terrstr());
+        smaError("vgId:%d, build submit req for rsma table suid:%" PRIu64 ", uid:%"PRIu64", level %" PRIi8 " failed since %s", SMA_VID(pSma),
+                 suid, output->info.groupId, pItem->level, terrstr());
        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());
+        smaError("vgId:%d, process submit req for rsma suid:%"PRIu64", uid:%" PRIu64 " level %" PRIi8 " failed since %s",
+                 SMA_VID(pSma), suid, output->info.groupId, pItem->level, terrstr());
        goto _err;
      }

-      smaDebug("vgId:%d, process submit req for rsma table %" PRIi64 " level %" PRIi8 " ver %" PRIi64 " len %" PRIu32,
-               SMA_VID(pSma), suid, pItem->level, output->info.version, htonl(pReq->header.contLen));
+      smaDebug("vgId:%d, process submit req for rsma suid:%" PRIu64 ",uid:%"PRIu64", level %" PRIi8 " ver %" PRIi64 " len %" PRIu32,
+               SMA_VID(pSma), suid, output->info.groupId, pItem->level, output->info.version, htonl(pReq->header.contLen));

      taosMemoryFreeClear(pReq);
    }
@ -839,7 +842,7 @@ static int32_t tdExecuteRSmaImpl(SSma *pSma, const void *pMsg, int32_t msgSize,
    tdRsmaPrintSubmitReq(pSma, pReq);
  }
 #endif
-  if (qSetMultiStreamInput(qTaskInfo, pMsg, msgSize, inputType) < 0) {
+  if (qSetSMAInput(qTaskInfo, pMsg, msgSize, inputType) < 0) {
    smaError("vgId:%d, rsma %" PRIi8 " qSetStreamInput failed since %s", SMA_VID(pSma), level, tstrerror(terrno));
    return TSDB_CODE_FAILED;
  }
@ -1404,7 +1407,7 @@ static int32_t tdRSmaFetchAllResult(SSma *pSma, SRSmaInfo *pInfo) {

      pItem->nScanned = 0;

-      if ((terrno = qSetMultiStreamInput(taskInfo, &dataBlock, 1, STREAM_INPUT__DATA_BLOCK)) < 0) {
+      if ((terrno = qSetSMAInput(taskInfo, &dataBlock, 1, STREAM_INPUT__DATA_BLOCK)) < 0) {
        goto _err;
      }
      if (tdRSmaExecAndSubmitResult(pSma, taskInfo, pItem, pInfo->pTSchema, pInfo->suid) < 0) {
--- a/source/dnode/vnode/src/tq/tq.c
+++ b/source/dnode/vnode/src/tq/tq.c
@ -98,7 +98,7 @@ STQ* tqOpen(const char* path, SVnode* pVnode) {
    ASSERT(0);
  }

-  pTq->pStreamMeta = streamMetaOpen(path, pTq, (FTaskExpand*)tqExpandTask);
+  pTq->pStreamMeta = streamMetaOpen(path, pTq, (FTaskExpand*)tqExpandTask, pTq->pVnode->config.vgId);
  if (pTq->pStreamMeta == NULL) {
    ASSERT(0);
  }
@ -433,16 +433,9 @@ static int32_t tqInitDataRsp(SMqDataRsp* pRsp, const SMqPollReq* pReq, int8_t su
  }
 #endif

-  if (subType == TOPIC_SUB_TYPE__COLUMN) {
-    pRsp->withSchema = false;
-  } else {
-    pRsp->withSchema = true;
-    pRsp->blockSchema = taosArrayInit(0, sizeof(void*));
-    if (pRsp->blockSchema == NULL) {
-      // TODO free
-      return -1;
-    }
-  }
+  ASSERT(subType == TOPIC_SUB_TYPE__COLUMN);
+  pRsp->withSchema = false;
+
  return 0;
 }

@ -523,17 +516,28 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg) {
          tqOffsetResetToLog(&fetchOffsetNew, walGetFirstVer(pTq->pVnode->pWal));
        }
      } else if (reqOffset.type == TMQ_OFFSET__RESET_LATEST) {
-        SMqDataRsp dataRsp = {0};
-        tqInitDataRsp(&dataRsp, pReq, pHandle->execHandle.subType);
+        if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
+          SMqDataRsp dataRsp = {0};
+          tqInitDataRsp(&dataRsp, pReq, pHandle->execHandle.subType);

-        tqOffsetResetToLog(&dataRsp.rspOffset, walGetLastVer(pTq->pVnode->pWal));
-        tqDebug("tmq poll: consumer %" PRId64 ", subkey %s, vg %d, offset reset to %" PRId64, consumerId,
-                pHandle->subKey, TD_VID(pTq->pVnode), dataRsp.rspOffset.version);
-        if (tqSendDataRsp(pTq, pMsg, pReq, &dataRsp) < 0) {
-          code = -1;
+          tqOffsetResetToLog(&dataRsp.rspOffset, walGetLastVer(pTq->pVnode->pWal));
+          tqDebug("tmq poll: consumer %" PRId64 ", subkey %s, vg %d, offset reset to %" PRId64, consumerId,
+                  pHandle->subKey, TD_VID(pTq->pVnode), dataRsp.rspOffset.version);
+          if (tqSendDataRsp(pTq, pMsg, pReq, &dataRsp) < 0) {
+            code = -1;
+          }
+          tDeleteSMqDataRsp(&dataRsp);
+          return code;
+        } else {
+          STaosxRsp taosxRsp = {0};
+          tqInitTaosxRsp(&taosxRsp, pReq);
+          tqOffsetResetToLog(&taosxRsp.rspOffset, walGetLastVer(pTq->pVnode->pWal));
+          if (tqSendTaosxRsp(pTq, pMsg, pReq, &taosxRsp) < 0) {
+            code = -1;
+          }
+          tDeleteSTaosxRsp(&taosxRsp);
+          return code;
        }
-        tDeleteSMqDataRsp(&dataRsp);
-        return code;
      } else if (reqOffset.type == TMQ_OFFSET__RESET_NONE) {
        tqError("tmq poll: subkey %s, no offset committed for consumer %" PRId64
                " in vg %d, subkey %s, reset none failed",
@ -667,8 +671,6 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg) {
        if (tqTaosxScanLog(pTq, pHandle, pCont, &taosxRsp) < 0) {
          /*ASSERT(0);*/
        }
-        // TODO batch optimization:
-        // TODO continue scan until meeting batch requirement
        if (taosxRsp.blockNum > 0 /* threshold */) {
          tqOffsetResetToLog(&taosxRsp.rspOffset, fetchVer);
          if (tqSendTaosxRsp(pTq, pMsg, pReq, &taosxRsp) < 0) {
@ -872,7 +874,7 @@ int32_t tqProcessVgChangeReq(STQ* pTq, int64_t version, char* msg, int32_t msgLe
  return 0;
 }

-int32_t tqExpandTask(STQ* pTq, SStreamTask* pTask) {
+int32_t tqExpandTask(STQ* pTq, SStreamTask* pTask, int64_t ver) {
  if (pTask->taskLevel == TASK_LEVEL__AGG) {
    ASSERT(taosArrayGetSize(pTask->childEpInfo) != 0);
  }
@ -891,6 +893,8 @@ int32_t tqExpandTask(STQ* pTq, SStreamTask* pTask) {

  pTask->pMsgCb = &pTq->pVnode->msgCb;

+  pTask->startVer = ver;
+
  // expand executor
  if (pTask->taskLevel == TASK_LEVEL__SOURCE) {
    pTask->pState = streamStateOpen(pTq->pStreamMeta->path, pTask, false, -1, -1);
@ -906,6 +910,10 @@ int32_t tqExpandTask(STQ* pTq, SStreamTask* pTask) {
    };
    pTask->exec.executor = qCreateStreamExecTaskInfo(pTask->exec.qmsg, &handle);
    ASSERT(pTask->exec.executor);
+
+    if (pTask->fillHistory) {
+      pTask->taskStatus = TASK_STATUS__RECOVER_PREPARE;
+    }
  } else if (pTask->taskLevel == TASK_LEVEL__AGG) {
    pTask->pState = streamStateOpen(pTq->pStreamMeta->path, pTask, false, -1, -1);
    if (pTask->pState == NULL) {
@ -945,8 +953,163 @@ int32_t tqExpandTask(STQ* pTq, SStreamTask* pTask) {
 }

 int32_t tqProcessTaskDeployReq(STQ* pTq, int64_t version, char* msg, int32_t msgLen) {
-  //
-  return streamMetaAddSerializedTask(pTq->pStreamMeta, version, msg, msgLen);
+  int32_t code;
+#if 0
+  code = streamMetaAddSerializedTask(pTq->pStreamMeta, version, msg, msgLen);
+  if (code < 0) return code;
+#endif
+
+  // 1.deserialize msg and build task
+  SStreamTask* pTask = taosMemoryCalloc(1, sizeof(SStreamTask));
+  if (pTask == NULL) {
+    return -1;
+  }
+  SDecoder decoder;
+  tDecoderInit(&decoder, (uint8_t*)msg, msgLen);
+  code = tDecodeSStreamTask(&decoder, pTask);
+  if (code < 0) {
+    tDecoderClear(&decoder);
+    taosMemoryFree(pTask);
+    return -1;
+  }
+  tDecoderClear(&decoder);
+
+  // 2.save task
+  code = streamMetaAddTask(pTq->pStreamMeta, version, pTask);
+  if (code < 0) {
+    return -1;
+  }
+
+  // 3.go through recover steps to fill history
+  if (pTask->fillHistory) {
+    streamSetParamForRecover(pTask);
+    if (pTask->taskLevel == TASK_LEVEL__SOURCE) {
+      streamSourceRecoverPrepareStep1(pTask, version);
+
+      SStreamRecoverStep1Req req;
+      streamBuildSourceRecover1Req(pTask, &req);
+
+      void*   serialziedReq = (void*)&req;
+      int32_t len = sizeof(SStreamRecoverStep1Req);
+
+      SRpcMsg rpcMsg = {
+          .contLen = len,
+          .pCont = serialziedReq,
+          .msgType = TDMT_VND_STREAM_RECOVER_STEP1,
+      };
+
+      tmsgPutToQueue(&pTq->pVnode->msgCb, STREAM_QUEUE, &rpcMsg);
+
+    } else if (pTask->taskLevel == TASK_LEVEL__AGG) {
+      streamAggRecoverPrepare(pTask);
+    } else if (pTask->taskLevel == TASK_LEVEL__SINK) {
+      // do nothing
+    }
+  }
+
+  return 0;
+}
+
+int32_t tqProcessTaskRecover1Req(STQ* pTq, char* msg, int32_t msgLen) {
+  int32_t                 code;
+  SStreamRecoverStep1Req* pReq = (SStreamRecoverStep1Req*)msg;
+  SStreamTask*            pTask = streamMetaGetTask(pTq->pStreamMeta, pReq->taskId);
+  if (pTask == NULL) {
+    return -1;
+  }
+
+  // check param
+  int64_t fillVer1 = pTask->startVer;
+  if (fillVer1 <= 0) {
+    ASSERT(0);
+    return -1;
+  }
+
+  // do recovery step 1
+  streamSourceRecoverScanStep1(pTask);
+
+  // build msg to launch next step
+  SStreamRecoverStep2Req req;
+  code = streamBuildSourceRecover2Req(pTask, &req);
+  if (code < 0) {
+    return -1;
+  }
+
+  // serialize msg
+  int32_t len = sizeof(SStreamRecoverStep2Req);
+  void*   serializedReq = (void*)&req;
+
+  // dispatch msg
+  SRpcMsg rpcMsg = {
+      .code = 0,
+      .contLen = len,
+      .msgType = TDMT_VND_STREAM_RECOVER_STEP2,
+      .pCont = (void*)serializedReq,
+  };
+
+  tmsgPutToQueue(&pTq->pVnode->msgCb, WRITE_QUEUE, &rpcMsg);
+
+  return 0;
+}
+
+int32_t tqProcessTaskRecover2Req(STQ* pTq, int64_t version, char* msg, int32_t msgLen) {
+  int32_t                 code;
+  SStreamRecoverStep2Req* pReq = (SStreamRecoverStep2Req*)msg;
+  SStreamTask*            pTask = streamMetaGetTask(pTq->pStreamMeta, pReq->taskId);
+  if (pTask == NULL) {
+    return -1;
+  }
+
+  // do recovery step 2
+  code = streamSourceRecoverScanStep2(pTask, version);
+  if (code < 0) {
+    return -1;
+  }
+
+  // restore param
+  code = streamRestoreParam(pTask);
+  if (code < 0) {
+    return -1;
+  }
+
+  // set status normal
+  code = streamSetStatusNormal(pTask);
+  if (code < 0) {
+    return -1;
+  }
+
+  // dispatch recover finish req to all related downstream task
+  code = streamDispatchRecoverFinishReq(pTask);
+  if (code < 0) {
+    return -1;
+  }
+
+  return 0;
+}
+
+int32_t tqProcessTaskRecoverFinishReq(STQ* pTq, char* msg, int32_t msgLen) {
+  int32_t code;
+
+  // deserialize
+  int32_t                 len;
+  SStreamRecoverFinishReq req;
+
+  SDecoder decoder;
+  tDecoderInit(&decoder, msg, sizeof(SStreamRecoverFinishReq));
+  tDecodeSStreamRecoverFinishReq(&decoder, &req);
+  tDecoderClear(&decoder);
+
+  // find task
+  SStreamTask* pTask = streamMetaGetTask(pTq->pStreamMeta, req.taskId);
+  if (pTask == NULL) {
+    return -1;
+  }
+  // do process request
+  if (streamProcessRecoverFinishReq(pTask, req.childId) < 0) {
+    return -1;
+  }
+
+  return 0;
 }

 int32_t tqProcessDelReq(STQ* pTq, void* pReq, int32_t len, int64_t ver) {
@ -1081,6 +1244,7 @@ int32_t tqProcessSubmitReq(STQ* pTq, SSubmitReq* pReq, int64_t ver) {
    if (pIter == NULL) break;
    SStreamTask* pTask = *(SStreamTask**)pIter;
    if (pTask->taskLevel != TASK_LEVEL__SOURCE) continue;
+    if (pTask->taskStatus == TASK_STATUS__RECOVER_PREPARE || pTask->taskStatus == TASK_STATUS__RECOVER1) continue;

    qDebug("data submit enqueue stream task: %d, ver: %" PRId64, pTask->taskId, ver);

@ -1108,7 +1272,6 @@ int32_t tqProcessSubmitReq(STQ* pTq, SSubmitReq* pReq, int64_t ver) {
 }

 int32_t tqProcessTaskRunReq(STQ* pTq, SRpcMsg* pMsg) {
-  //
  SStreamTaskRunReq* pReq = pMsg->pCont;
  int32_t            taskId = pReq->taskId;
  SStreamTask*       pTask = streamMetaGetTask(pTq->pStreamMeta, taskId);
@ -1121,7 +1284,6 @@ int32_t tqProcessTaskRunReq(STQ* pTq, SRpcMsg* pMsg) {
 }

 int32_t tqProcessTaskDispatchReq(STQ* pTq, SRpcMsg* pMsg, bool exec) {
-  ASSERT(0);
  char*              msgStr = pMsg->pCont;
  char*              msgBody = POINTER_SHIFT(msgStr, sizeof(SMsgHead));
  int32_t            msgLen = pMsg->contLen - sizeof(SMsgHead);
@ -1185,7 +1347,6 @@ int32_t tqProcessTaskDispatchRsp(STQ* pTq, SRpcMsg* pMsg) {

 int32_t tqProcessTaskDropReq(STQ* pTq, int64_t version, char* msg, int32_t msgLen) {
  SVDropStreamTaskReq* pReq = (SVDropStreamTaskReq*)msg;
-
  return streamMetaRemoveTask(pTq->pStreamMeta, pReq->taskId);
 }

--- a/source/dnode/vnode/src/tq/tqExec.c
+++ b/source/dnode/vnode/src/tq/tqExec.c
@ -15,14 +15,14 @@

 #include "tq.h"

-int32_t tqAddBlockDataToRsp(const SSDataBlock* pBlock, SMqDataRsp* pRsp, int32_t numOfCols) {
+int32_t tqAddBlockDataToRsp(const SSDataBlock* pBlock, SMqDataRsp* pRsp, int32_t numOfCols, int8_t precision) {
  int32_t dataStrLen = sizeof(SRetrieveTableRsp) + blockGetEncodeSize(pBlock);
  void*   buf = taosMemoryCalloc(1, dataStrLen);
  if (buf == NULL) return -1;

  SRetrieveTableRsp* pRetrieve = (SRetrieveTableRsp*)buf;
  pRetrieve->useconds = 0;
-  pRetrieve->precision = TSDB_DEFAULT_PRECISION;
+  pRetrieve->precision = precision;
  pRetrieve->compressed = 0;
  pRetrieve->completed = 1;
  pRetrieve->numOfRows = htonl(pBlock->info.rows);
@ -85,17 +85,17 @@ int32_t tqScanData(STQ* pTq, const STqHandle* pHandle, SMqDataRsp* pRsp, STqOffs
  while (1) {
    SSDataBlock* pDataBlock = NULL;
    uint64_t     ts = 0;
-    tqDebug("tmq task start to execute");
+    tqDebug("vgId:%d, tmq task start to execute", pTq->pVnode->config.vgId);
    if (qExecTask(task, &pDataBlock, &ts) < 0) {
      ASSERT(0);
    }
-    tqDebug("tmq task executed, get %p", pDataBlock);
+    tqDebug("vgId:%d, tmq task executed, get %p", pTq->pVnode->config.vgId, pDataBlock);

    if (pDataBlock == NULL) {
      break;
    }

-    tqAddBlockDataToRsp(pDataBlock, pRsp, pExec->numOfCols);
+    tqAddBlockDataToRsp(pDataBlock, pRsp, pExec->numOfCols, pTq->pVnode->config.tsdbCfg.precision);
    pRsp->blockNum++;

    if (pOffset->type == TMQ_OFFSET__SNAPSHOT_DATA) {
@ -174,7 +174,8 @@ int32_t tqScanTaosx(STQ* pTq, const STqHandle* pHandle, STaosxRsp* pRsp, SMqMeta
        }
      }

-      tqAddBlockDataToRsp(pDataBlock, (SMqDataRsp*)pRsp, taosArrayGetSize(pDataBlock->pDataBlock));
+      tqAddBlockDataToRsp(pDataBlock, (SMqDataRsp*)pRsp, taosArrayGetSize(pDataBlock->pDataBlock),
+                          pTq->pVnode->config.tsdbCfg.precision);
      pRsp->blockNum++;
      if (pOffset->type == TMQ_OFFSET__LOG) {
        continue;
@ -256,7 +257,8 @@ int32_t tqTaosxScanLog(STQ* pTq, STqHandle* pHandle, SSubmitReq* pReq, STaosxRsp
          pRsp->createTableNum++;
        }
      }
-      tqAddBlockDataToRsp(&block, (SMqDataRsp*)pRsp, taosArrayGetSize(block.pDataBlock));
+      tqAddBlockDataToRsp(&block, (SMqDataRsp*)pRsp, taosArrayGetSize(block.pDataBlock),
+                          pTq->pVnode->config.tsdbCfg.precision);
      blockDataFreeRes(&block);
      tqAddBlockSchemaToRsp(pExec, (SMqDataRsp*)pRsp);
      pRsp->blockNum++;
@ -291,7 +293,8 @@ int32_t tqTaosxScanLog(STQ* pTq, STqHandle* pHandle, SSubmitReq* pReq, STaosxRsp
          pRsp->createTableNum++;
        }
      }
-      tqAddBlockDataToRsp(&block, (SMqDataRsp*)pRsp, taosArrayGetSize(block.pDataBlock));
+      tqAddBlockDataToRsp(&block, (SMqDataRsp*)pRsp, taosArrayGetSize(block.pDataBlock),
+                          pTq->pVnode->config.tsdbCfg.precision);
      blockDataFreeRes(&block);
      tqAddBlockSchemaToRsp(pExec, (SMqDataRsp*)pRsp);
      pRsp->blockNum++;
--- a/source/dnode/vnode/src/tq/tqOffset.c
+++ b/source/dnode/vnode/src/tq/tqOffset.c
@ -22,10 +22,10 @@ struct STqOffsetStore {
  SHashObj* pHash;  // SHashObj<subscribeKey, offset>
 };

-char* tqOffsetBuildFName(const char* path, int32_t ver) {
+char* tqOffsetBuildFName(const char* path, int32_t fVer) {
  int32_t len = strlen(path);
  char*   fname = taosMemoryCalloc(1, len + 40);
-  snprintf(fname, len + 40, "%s/offset-ver%d", path, ver);
+  snprintf(fname, len + 40, "%s/offset-ver%d", path, fVer);
  return fname;
 }

--- a/source/dnode/vnode/src/tq/tqPush.c
+++ b/source/dnode/vnode/src/tq/tqPush.c
@ -270,7 +270,7 @@ int tqPushMsg(STQ* pTq, void* msg, int32_t msgLen, tmsg_t msgType, int64_t ver)
            break;
          }

-          tqAddBlockDataToRsp(pDataBlock, pRsp, pExec->numOfCols);
+          tqAddBlockDataToRsp(pDataBlock, pRsp, pExec->numOfCols, pTq->pVnode->config.tsdbCfg.precision);
          pRsp->blockNum++;
        }

--- a/source/dnode/vnode/src/tq/tqSink.c
+++ b/source/dnode/vnode/src/tq/tqSink.c
@ -42,7 +42,7 @@ int32_t tqBuildDeleteReq(SVnode* pVnode, const char* stbFullName, const SSDataBl
    if (metaGetTableEntryByName(&mr, name) < 0) {
      metaReaderClear(&mr);
      taosMemoryFree(name);
-      return -1;
+      continue;
    }

    int64_t uid = mr.me.uid;
@ -530,6 +530,7 @@ void tqSinkToTablePipeline(SStreamTask* pTask, void* vnode, int64_t ver, void* d
  taosArrayDestroy(tagArray);
 }

+#if 0
 void tqSinkToTableMerge(SStreamTask* pTask, void* vnode, int64_t ver, void* data) {
  const SArray*   pRes = (const SArray*)data;
  SVnode*         pVnode = (SVnode*)vnode;
@ -585,3 +586,4 @@ void tqSinkToTableMerge(SStreamTask* pTask, void* vnode, int64_t ver, void* data
    tqDebug("failed to put into write-queue since %s", terrstr());
  }
 }
+#endif
--- a/source/dnode/vnode/src/tsdb/tsdbCache.c
+++ b/source/dnode/vnode/src/tsdb/tsdbCache.c
@ -230,7 +230,21 @@ int32_t tsdbCacheInsertLastrow(SLRUCache *pCache, STsdb *pTsdb, tb_uid_t uid, ST
            break;
          }
        } else {
-          taosArraySet(pLast, iCol, &(SLastCol){.ts = keyTs, .colVal = colVal});
+          SLastCol lastCol = {.ts = keyTs, .colVal = colVal};
+          if (IS_VAR_DATA_TYPE(colVal.type) && colVal.value.nData > 0) {
+            SLastCol *pLastCol = (SLastCol *)taosArrayGet(pLast, iCol);
+            taosMemoryFree(pLastCol->colVal.value.pData);
+
+            lastCol.colVal.value.pData = taosMemoryMalloc(colVal.value.nData);
+            if (lastCol.colVal.value.pData == NULL) {
+              terrno = TSDB_CODE_OUT_OF_MEMORY;
+              code = TSDB_CODE_OUT_OF_MEMORY;
+              goto _invalidate;
+            }
+            memcpy(lastCol.colVal.value.pData, colVal.value.pData, colVal.value.nData);
+          }
+
+          taosArraySet(pLast, iCol, &lastCol);
        }
      }
    }
@ -342,7 +356,21 @@ int32_t tsdbCacheInsertLast(SLRUCache *pCache, tb_uid_t uid, STSRow *row, STsdb
            break;
          }
        } else {
-          taosArraySet(pLast, iCol, &(SLastCol){.ts = keyTs, .colVal = colVal});
+          SLastCol lastCol = {.ts = keyTs, .colVal = colVal};
+          if (IS_VAR_DATA_TYPE(colVal.type) && colVal.value.nData > 0) {
+            SLastCol *pLastCol = (SLastCol *)taosArrayGet(pLast, iCol);
+            taosMemoryFree(pLastCol->colVal.value.pData);
+
+            lastCol.colVal.value.pData = taosMemoryMalloc(colVal.value.nData);
+            if (lastCol.colVal.value.pData == NULL) {
+              terrno = TSDB_CODE_OUT_OF_MEMORY;
+              code = TSDB_CODE_OUT_OF_MEMORY;
+              goto _invalidate;
+            }
+            memcpy(lastCol.colVal.value.pData, colVal.value.pData, colVal.value.nData);
+          }
+
+          taosArraySet(pLast, iCol, &lastCol);
        }
      }
    }
@ -1065,72 +1093,71 @@ _err:
 // iterate next row non deleted backward ts, version (from high to low)
 static int32_t nextRowIterGet(CacheNextRowIter *pIter, TSDBROW **ppRow) {
  int code = 0;
+  for (;;) {
+    for (int i = 0; i < 4; ++i) {
+      if (pIter->input[i].next && !pIter->input[i].stop) {
+        code = pIter->input[i].nextRowFn(pIter->input[i].iter, &pIter->input[i].pRow);
+        if (code) goto _err;

-  for (int i = 0; i < 4; ++i) {
-    if (pIter->input[i].next && !pIter->input[i].stop) {
-      code = pIter->input[i].nextRowFn(pIter->input[i].iter, &pIter->input[i].pRow);
-      if (code) goto _err;
-
-      if (pIter->input[i].pRow == NULL) {
-        pIter->input[i].stop = true;
-        pIter->input[i].next = false;
-      }
-    }
-  }
-
-  if (pIter->input[0].stop && pIter->input[1].stop && pIter->input[2].stop && pIter->input[3].stop) {
-    *ppRow = NULL;
-    return code;
-  }
-
-  // select maxpoint(s) from mem, imem, fs and last
-  TSDBROW *max[4] = {0};
-  int      iMax[4] = {-1, -1, -1, -1};
-  int      nMax = 0;
-  TSKEY    maxKey = TSKEY_MIN;
-
-  for (int i = 0; i < 4; ++i) {
-    if (!pIter->input[i].stop && pIter->input[i].pRow != NULL) {
-      TSDBKEY key = TSDBROW_KEY(pIter->input[i].pRow);
-
-      // merging & deduplicating on client side
-      if (maxKey <= key.ts) {
-        if (maxKey < key.ts) {
-          nMax = 0;
-          maxKey = key.ts;
+        if (pIter->input[i].pRow == NULL) {
+          pIter->input[i].stop = true;
+          pIter->input[i].next = false;
        }
-
-        iMax[nMax] = i;
-        max[nMax++] = pIter->input[i].pRow;
      }
    }
-  }

-  // delete detection
-  TSDBROW *merge[4] = {0};
-  int      iMerge[4] = {-1, -1, -1, -1};
-  int      nMerge = 0;
-  for (int i = 0; i < nMax; ++i) {
-    TSDBKEY maxKey1 = TSDBROW_KEY(max[i]);
-
-    bool deleted = tsdbKeyDeleted(&maxKey1, pIter->pSkyline, &pIter->iSkyline);
-    if (!deleted) {
-      iMerge[nMerge] = iMax[i];
-      merge[nMerge++] = max[i];
+    if (pIter->input[0].stop && pIter->input[1].stop && pIter->input[2].stop && pIter->input[3].stop) {
+      *ppRow = NULL;
+      return code;
    }

-    pIter->input[iMax[i]].next = deleted;
+    // select maxpoint(s) from mem, imem, fs and last
+    TSDBROW *max[4] = {0};
+    int      iMax[4] = {-1, -1, -1, -1};
+    int      nMax = 0;
+    TSKEY    maxKey = TSKEY_MIN;
+
+    for (int i = 0; i < 4; ++i) {
+      if (!pIter->input[i].stop && pIter->input[i].pRow != NULL) {
+        TSDBKEY key = TSDBROW_KEY(pIter->input[i].pRow);
+
+        // merging & deduplicating on client side
+        if (maxKey <= key.ts) {
+          if (maxKey < key.ts) {
+            nMax = 0;
+            maxKey = key.ts;
+          }
+
+          iMax[nMax] = i;
+          max[nMax++] = pIter->input[i].pRow;
+        }
+      }
+    }
+
+    // delete detection
+    TSDBROW *merge[4] = {0};
+    int      iMerge[4] = {-1, -1, -1, -1};
+    int      nMerge = 0;
+    for (int i = 0; i < nMax; ++i) {
+      TSDBKEY maxKey1 = TSDBROW_KEY(max[i]);
+
+      bool deleted = tsdbKeyDeleted(&maxKey1, pIter->pSkyline, &pIter->iSkyline);
+      if (!deleted) {
+        iMerge[nMerge] = iMax[i];
+        merge[nMerge++] = max[i];
+      }
+
+      pIter->input[iMax[i]].next = deleted;
+    }
+
+    if (nMerge > 0) {
+      pIter->input[iMerge[0]].next = true;
+
+      *ppRow = merge[0];
+      return code;
+    }
  }

-  if (nMerge > 0) {
-    pIter->input[iMerge[0]].next = true;
-
-    *ppRow = merge[0];
-  } else {
-    *ppRow = NULL;
-  }
-
-  return code;
 _err:
  return code;
 }
--- a/source/dnode/vnode/src/tsdb/tsdbCacheRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbCacheRead.c
@ -97,10 +97,9 @@ static void saveOneRow(SArray* pRow, SSDataBlock* pBlock, SCacheRowsReader* pRea
  }
 }

-int32_t tsdbCacherowsReaderOpen(void* pVnode, int32_t type, SArray* pTableIdList, int32_t numOfCols, uint64_t suid,
-                                void** pReader) {
+int32_t tsdbCacherowsReaderOpen(void* pVnode, int32_t type, void* pTableIdList, int32_t numOfTables, int32_t numOfCols,
+                                uint64_t suid, void** pReader) {
  *pReader = NULL;
-
  SCacheRowsReader* p = taosMemoryCalloc(1, sizeof(SCacheRowsReader));
  if (p == NULL) {
    return TSDB_CODE_OUT_OF_MEMORY;
@ -111,14 +110,15 @@ int32_t tsdbCacherowsReaderOpen(void* pVnode, int32_t type, SArray* pTableIdList
  p->numOfCols = numOfCols;
  p->suid = suid;

-  if (taosArrayGetSize(pTableIdList) == 0) {
+  if (numOfTables == 0) {
    *pReader = p;
    return TSDB_CODE_SUCCESS;
  }

-  STableKeyInfo* pKeyInfo = taosArrayGet(pTableIdList, 0);
+  STableKeyInfo* pKeyInfo = &((STableKeyInfo*)pTableIdList)[0];
  p->pSchema = metaGetTbTSchema(p->pVnode->pMeta, pKeyInfo->uid, -1, 1);
  p->pTableList = pTableIdList;
+  p->numOfTables = numOfTables;

  p->transferBuf = taosMemoryCalloc(p->pSchema->numOfCols, POINTER_BYTES);
  if (p->transferBuf == NULL) {
@ -205,7 +205,6 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
  SLRUCache* lruCache = pr->pVnode->pTsdb->lruCache;
  LRUHandle* h = NULL;
  SArray*    pRow = NULL;
-  size_t     numOfTables = taosArrayGetSize(pr->pTableList);
  bool       hasRes = false;
  SArray*    pLastCols = NULL;

@ -243,8 +242,8 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32

  // retrieve the only one last row of all tables in the uid list.
  if (HASTYPE(pr->type, CACHESCAN_RETRIEVE_TYPE_SINGLE)) {
-    for (int32_t i = 0; i < numOfTables; ++i) {
-      STableKeyInfo* pKeyInfo = taosArrayGet(pr->pTableList, i);
+    for (int32_t i = 0; i < pr->numOfTables; ++i) {
+      STableKeyInfo* pKeyInfo = &pr->pTableList[i];

      code = doExtractCacheRow(pr, lruCache, pKeyInfo->uid, &pRow, &h);
      if (code != TSDB_CODE_SUCCESS) {
@ -308,8 +307,8 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
    }

  } else if (HASTYPE(pr->type, CACHESCAN_RETRIEVE_TYPE_ALL)) {
-    for (int32_t i = pr->tableIndex; i < numOfTables; ++i) {
-      STableKeyInfo* pKeyInfo = (STableKeyInfo*)taosArrayGet(pr->pTableList, i);
+    for (int32_t i = pr->tableIndex; i < pr->numOfTables; ++i) {
+      STableKeyInfo* pKeyInfo = &pr->pTableList[i];
      code = doExtractCacheRow(pr, lruCache, pKeyInfo->uid, &pRow, &h);
      if (code != TSDB_CODE_SUCCESS) {
        return code;
@ -334,7 +333,7 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
    code = TSDB_CODE_INVALID_PARA;
  }

-_end:
+  _end:
  tsdbDataFReaderClose(&pr->pDataFReaderLast);
  tsdbDataFReaderClose(&pr->pDataFReader);

--- a/source/dnode/vnode/src/tsdb/tsdbMergeTree.c
+++ b/source/dnode/vnode/src/tsdb/tsdbMergeTree.c
@ -290,7 +290,7 @@ int32_t tLDataIterOpen(struct SLDataIter **pIter, SDataFReader *pReader, int32_t
    // only apply to the child tables, ordinary tables will not incur this filter procedure.
    size = taosArrayGetSize(pBlockLoadInfo->aSttBlk);

-    if (size > 1) {
+    if (size >= 1) {
      SSttBlk *pStart = taosArrayGet(pBlockLoadInfo->aSttBlk, 0);
      SSttBlk *pEnd = taosArrayGet(pBlockLoadInfo->aSttBlk, size - 1);

--- a/source/dnode/vnode/src/tsdb/tsdbRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbRead.c
@ -111,7 +111,7 @@ typedef struct SDataBlockIter {
  int32_t   index;
  SArray*   blockList;  // SArray<SFileDataBlockInfo>
  int32_t   order;
-  SDataBlk  block;      // current SDataBlk data
+  SDataBlk  block;  // current SDataBlk data
  SHashObj* pTableMap;
 } SDataBlockIter;

@ -169,14 +169,14 @@ static TSDBROW* getValidMemRow(SIterInfo* pIter, const SArray* pDelList, STsdbRe
 static int32_t  doMergeRowsInFileBlocks(SBlockData* pBlockData, STableBlockScanInfo* pScanInfo, STsdbReader* pReader,
                                        SRowMerger* pMerger);
 static int32_t  doMergeRowsInLastBlock(SLastBlockReader* pLastBlockReader, STableBlockScanInfo* pScanInfo, int64_t ts,
-                                       SRowMerger* pMerger);
+                                       SRowMerger* pMerger, SVersionRange* pVerRange);
 static int32_t  doMergeRowsInBuf(SIterInfo* pIter, uint64_t uid, int64_t ts, SArray* pDelList, SRowMerger* pMerger,
                                 STsdbReader* pReader);
 static int32_t  doAppendRowFromTSRow(SSDataBlock* pBlock, STsdbReader* pReader, STSRow* pTSRow, uint64_t uid);
 static int32_t  doAppendRowFromFileBlock(SSDataBlock* pResBlock, STsdbReader* pReader, SBlockData* pBlockData,
                                         int32_t rowIndex);
 static void     setComposedBlockFlag(STsdbReader* pReader, bool composed);
-static bool     hasBeenDropped(const SArray* pDelList, int32_t* index, TSDBKEY* pKey, int32_t order);
+static bool hasBeenDropped(const SArray* pDelList, int32_t* index, TSDBKEY* pKey, int32_t order, SVersionRange* pRange);

 static int32_t doMergeMemTableMultiRows(TSDBROW* pRow, uint64_t uid, SIterInfo* pIter, SArray* pDelList,
                                        STSRow** pTSRow, STsdbReader* pReader, bool* freeTSRow);
@ -270,24 +270,27 @@ static void resetDataBlockScanInfo(SHashObj* pTableMap, int64_t ts) {
  }
 }

+static void clearBlockScanInfo(STableBlockScanInfo* p) {
+  p->iterInit = false;
+  p->iiter.hasVal = false;
+
+  if (p->iter.iter != NULL) {
+    p->iter.iter = tsdbTbDataIterDestroy(p->iter.iter);
+  }
+
+  if (p->iiter.iter != NULL) {
+    p->iiter.iter = tsdbTbDataIterDestroy(p->iiter.iter);
+  }
+
+  p->delSkyline = taosArrayDestroy(p->delSkyline);
+  p->pBlockList = taosArrayDestroy(p->pBlockList);
+  tMapDataClear(&p->mapData);
+}
+
 static void destroyBlockScanInfo(SHashObj* pTableMap) {
  STableBlockScanInfo* p = NULL;
-
  while ((p = taosHashIterate(pTableMap, p)) != NULL) {
-    p->iterInit = false;
-    p->iiter.hasVal = false;
-
-    if (p->iter.iter != NULL) {
-      p->iter.iter = tsdbTbDataIterDestroy(p->iter.iter);
-    }
-
-    if (p->iiter.iter != NULL) {
-      p->iiter.iter = tsdbTbDataIterDestroy(p->iiter.iter);
-    }
-
-    p->delSkyline = taosArrayDestroy(p->delSkyline);
-    p->pBlockList = taosArrayDestroy(p->pBlockList);
-    tMapDataClear(&p->mapData);
+    clearBlockScanInfo(p);
  }

  taosHashCleanup(pTableMap);
@ -951,7 +954,7 @@ static int32_t copyBlockDataToSDataBlock(STsdbReader* pReader, STableBlockScanIn

  int32_t unDumpedRows = asc ? pBlock->nRow - pDumpInfo->rowIndex : pDumpInfo->rowIndex + 1;
  tsdbDebug("%p copy file block to sdatablock, global index:%d, table index:%d, brange:%" PRId64 "-%" PRId64
-            ", rows:%d, remain:%d, minVer:%" PRId64 ", maxVer:%" PRId64 ", elapsed time:%.2f ms, %s",
+                ", rows:%d, remain:%d, minVer:%" PRId64 ", maxVer:%" PRId64 ", elapsed time:%.2f ms, %s",
            pReader, pBlockIter->index, pBlockInfo->tbBlockIdx, pBlock->minKey.ts, pBlock->maxKey.ts, remain,
            unDumpedRows, pBlock->minVer, pBlock->maxVer, elapsedTime, pReader->idStr);

@ -978,7 +981,7 @@ static int32_t doLoadFileBlockData(STsdbReader* pReader, SDataBlockIter* pBlockI
  code = tsdbReadDataBlock(pReader->pFileReader, pBlock, pBlockData);
  if (code != TSDB_CODE_SUCCESS) {
    tsdbError("%p error occurs in loading file block, global index:%d, table index:%d, brange:%" PRId64 "-%" PRId64
-              ", rows:%d, code:%s %s",
+                  ", rows:%d, code:%s %s",
              pReader, pBlockIter->index, pBlockInfo->tbBlockIdx, pBlock->minKey.ts, pBlock->maxKey.ts, pBlock->nRow,
              tstrerror(code), pReader->idStr);
    return code;
@ -987,7 +990,7 @@ static int32_t doLoadFileBlockData(STsdbReader* pReader, SDataBlockIter* pBlockI
  double elapsedTime = (taosGetTimestampUs() - st) / 1000.0;

  tsdbDebug("%p load file block into buffer, global index:%d, index in table block list:%d, brange:%" PRId64 "-%" PRId64
-            ", rows:%d, minVer:%" PRId64 ", maxVer:%" PRId64 ", elapsed time:%.2f ms, %s",
+                ", rows:%d, minVer:%" PRId64 ", maxVer:%" PRId64 ", elapsed time:%.2f ms, %s",
            pReader, pBlockIter->index, pBlockInfo->tbBlockIdx, pBlock->minKey.ts, pBlock->maxKey.ts, pBlock->nRow,
            pBlock->minVer, pBlock->maxVer, elapsedTime, pReader->idStr);

@ -1052,7 +1055,7 @@ static int32_t doSetCurrentBlock(SDataBlockIter* pBlockIter, const char* idStr)
  if (pBlockInfo != NULL) {
    STableBlockScanInfo* pScanInfo = taosHashGet(pBlockIter->pTableMap, &pBlockInfo->uid, sizeof(pBlockInfo->uid));
    if (pScanInfo == NULL) {
-      tsdbError("failed to locate the uid:%"PRIu64" in query table uid list, %s", pBlockInfo->uid, idStr);
+      tsdbError("failed to locate the uid:%" PRIu64 " in query table uid list, %s", pBlockInfo->uid, idStr);
      return TSDB_CODE_INVALID_PARA;
    }

@ -1438,7 +1441,7 @@ static int32_t buildDataBlockFromBuf(STsdbReader* pReader, STableBlockScanInfo*

  double elapsedTime = (taosGetTimestampUs() - st) / 1000.0;
  tsdbDebug("%p build data block from cache completed, elapsed time:%.2f ms, numOfRows:%d, brange:%" PRId64
-            " - %" PRId64 " %s",
+                " - %" PRId64 " %s",
            pReader, elapsedTime, pBlock->info.rows, pBlock->info.window.skey, pBlock->info.window.ekey,
            pReader->idStr);

@ -1466,7 +1469,8 @@ static bool tryCopyDistinctRowFromFileBlock(STsdbReader* pReader, SBlockData* pB
  return false;
 }

-static bool nextRowFromLastBlocks(SLastBlockReader* pLastBlockReader, STableBlockScanInfo* pBlockScanInfo) {
+static bool nextRowFromLastBlocks(SLastBlockReader* pLastBlockReader, STableBlockScanInfo* pBlockScanInfo,
+                                  SVersionRange* pVerRange) {
  while (1) {
    bool hasVal = tMergeTreeNext(&pLastBlockReader->mergeTree);
    if (!hasVal) {
@ -1475,7 +1479,8 @@ static bool nextRowFromLastBlocks(SLastBlockReader* pLastBlockReader, STableBloc

    TSDBROW row = tMergeTreeGetRow(&pLastBlockReader->mergeTree);
    TSDBKEY k = TSDBROW_KEY(&row);
-    if (!hasBeenDropped(pBlockScanInfo->delSkyline, &pBlockScanInfo->lastBlockDelIndex, &k, pLastBlockReader->order)) {
+    if (!hasBeenDropped(pBlockScanInfo->delSkyline, &pBlockScanInfo->lastBlockDelIndex, &k, pLastBlockReader->order,
+                        pVerRange)) {
      return true;
    }
  }
@ -1483,7 +1488,7 @@ static bool nextRowFromLastBlocks(SLastBlockReader* pLastBlockReader, STableBloc

 static bool tryCopyDistinctRowFromSttBlock(TSDBROW* fRow, SLastBlockReader* pLastBlockReader,
                                           STableBlockScanInfo* pScanInfo, int64_t ts, STsdbReader* pReader) {
-  bool hasVal = nextRowFromLastBlocks(pLastBlockReader, pScanInfo);
+  bool hasVal = nextRowFromLastBlocks(pLastBlockReader, pScanInfo, &pReader->verRange);
  if (hasVal) {
    int64_t next1 = getCurrentKeyInLastBlock(pLastBlockReader);
    if (next1 != ts) {
@ -1602,7 +1607,7 @@ static int32_t doMergeBufAndFileRows(STsdbReader* pReader, STableBlockScanInfo*
          return code;
        }
      }
-      doMergeRowsInLastBlock(pLastBlockReader, pBlockScanInfo, tsLast, &merge);
+      doMergeRowsInLastBlock(pLastBlockReader, pBlockScanInfo, tsLast, &merge, &pReader->verRange);
    }

    if (minKey == k.ts) {
@ -1647,7 +1652,7 @@ static int32_t doMergeBufAndFileRows(STsdbReader* pReader, STableBlockScanInfo*
          return code;
        }
      }
-      doMergeRowsInLastBlock(pLastBlockReader, pBlockScanInfo, tsLast, &merge);
+      doMergeRowsInLastBlock(pLastBlockReader, pBlockScanInfo, tsLast, &merge, &pReader->verRange);
    }

    if (minKey == key) {
@ -1699,7 +1704,7 @@ static int32_t doMergeFileBlockAndLastBlock(SLastBlockReader* pLastBlockReader,

      TSDBROW fRow1 = tMergeTreeGetRow(&pLastBlockReader->mergeTree);
      tRowMerge(&merge, &fRow1);
-      doMergeRowsInLastBlock(pLastBlockReader, pBlockScanInfo, tsLastBlock, &merge);
+      doMergeRowsInLastBlock(pLastBlockReader, pBlockScanInfo, tsLastBlock, &merge, &pReader->verRange);

      code = tRowMergerGetRow(&merge, &pTSRow);
      if (code != TSDB_CODE_SUCCESS) {
@ -1717,7 +1722,7 @@ static int32_t doMergeFileBlockAndLastBlock(SLastBlockReader* pLastBlockReader,
      return code;
    }

-    doMergeRowsInLastBlock(pLastBlockReader, pBlockScanInfo, tsLastBlock, &merge);
+    doMergeRowsInLastBlock(pLastBlockReader, pBlockScanInfo, tsLastBlock, &merge, &pReader->verRange);
    ASSERT(mergeBlockData);

    // merge with block data if ts == key
@ -1771,7 +1776,7 @@ static int32_t mergeFileBlockAndLastBlock(STsdbReader* pReader, SLastBlockReader
        TSDBROW fRow1 = tMergeTreeGetRow(&pLastBlockReader->mergeTree);
        tRowMerge(&merge, &fRow1);

-        doMergeRowsInLastBlock(pLastBlockReader, pBlockScanInfo, ts, &merge);
+        doMergeRowsInLastBlock(pLastBlockReader, pBlockScanInfo, ts, &merge, &pReader->verRange);

        code = tRowMergerGetRow(&merge, &pTSRow);
        if (code != TSDB_CODE_SUCCESS) {
@ -1882,7 +1887,7 @@ static int32_t doMergeMultiLevelRows(STsdbReader* pReader, STableBlockScanInfo*
        }
      }

-      doMergeRowsInLastBlock(pLastBlockReader, pBlockScanInfo, tsLast, &merge);
+      doMergeRowsInLastBlock(pLastBlockReader, pBlockScanInfo, tsLast, &merge, &pReader->verRange);
    }

    if (minKey == ik.ts) {
@ -1901,8 +1906,8 @@ static int32_t doMergeMultiLevelRows(STsdbReader* pReader, STableBlockScanInfo*
        }
      }

-      code = doMergeRowsInBuf(&pBlockScanInfo->iiter, pBlockScanInfo->uid, ik.ts, pBlockScanInfo->delSkyline,
-                                      &merge, pReader);
+      code = doMergeRowsInBuf(&pBlockScanInfo->iiter, pBlockScanInfo->uid, ik.ts, pBlockScanInfo->delSkyline, &merge,
+                              pReader);
      if (code != TSDB_CODE_SUCCESS) {
        return code;
      }
@ -1973,7 +1978,7 @@ static int32_t doMergeMultiLevelRows(STsdbReader* pReader, STableBlockScanInfo*
          return code;
        }
      }
-      doMergeRowsInLastBlock(pLastBlockReader, pBlockScanInfo, tsLast, &merge);
+      doMergeRowsInLastBlock(pLastBlockReader, pBlockScanInfo, tsLast, &merge, &pReader->verRange);
    }

    if (minKey == key) {
@ -1993,7 +1998,7 @@ static int32_t doMergeMultiLevelRows(STsdbReader* pReader, STableBlockScanInfo*
    }
  }

-  if (merge.pTSchema == NULL)  {
+  if (merge.pTSchema == NULL) {
    return code;
  }

@ -2095,7 +2100,8 @@ static bool isValidFileBlockRow(SBlockData* pBlockData, SFileBlockDumpInfo* pDum
  }

  TSDBKEY k = {.ts = ts, .version = ver};
-  if (hasBeenDropped(pBlockScanInfo->delSkyline, &pBlockScanInfo->fileDelIndex, &k, pReader->order)) {
+  if (hasBeenDropped(pBlockScanInfo->delSkyline, &pBlockScanInfo->fileDelIndex, &k, pReader->order,
+                     &pReader->verRange)) {
    return false;
  }

@ -2130,7 +2136,7 @@ static bool initLastBlockReader(SLastBlockReader* pLBlockReader, STableBlockScan
    return false;
  }

-  return nextRowFromLastBlocks(pLBlockReader, pScanInfo);
+  return nextRowFromLastBlocks(pLBlockReader, pScanInfo, &pReader->verRange);
 }

 static int64_t getCurrentKeyInLastBlock(SLastBlockReader* pLastBlockReader) {
@ -2225,8 +2231,8 @@ static int32_t buildComposedDataBlock(STsdbReader* pReader) {
    pBlockScanInfo = taosHashGet(pReader->status.pTableMap, &pBlockInfo->uid, sizeof(pBlockInfo->uid));
    if (pBlockScanInfo == NULL) {
      code = TSDB_CODE_INVALID_PARA;
-      tsdbError("failed to locate the uid:%"PRIu64" in query table uid list, total tables:%d, %s",
-          pBlockInfo->uid, taosHashGetSize(pReader->status.pTableMap), pReader->idStr);
+      tsdbError("failed to locate the uid:%" PRIu64 " in query table uid list, total tables:%d, %s", pBlockInfo->uid,
+                taosHashGetSize(pReader->status.pTableMap), pReader->idStr);
      goto _end;
    }

@ -2290,7 +2296,7 @@ static int32_t buildComposedDataBlock(STsdbReader* pReader) {
  }

 _end:
-  pResBlock->info.uid = (pBlockScanInfo != NULL)? pBlockScanInfo->uid:0;
+  pResBlock->info.uid = (pBlockScanInfo != NULL) ? pBlockScanInfo->uid : 0;
  blockDataUpdateTsWindow(pResBlock, 0);

  setComposedBlockFlag(pReader, true);
@ -2301,7 +2307,7 @@ _end:

  if (pResBlock->info.rows > 0) {
    tsdbDebug("%p uid:%" PRIu64 ", composed data block created, brange:%" PRIu64 "-%" PRIu64
-              " rows:%d, elapsed time:%.2f ms %s",
+                  " rows:%d, elapsed time:%.2f ms %s",
              pReader, pResBlock->info.uid, pResBlock->info.window.skey, pResBlock->info.window.ekey,
              pResBlock->info.rows, el, pReader->idStr);
  }
@ -2808,8 +2814,8 @@ static STsdb* getTsdbByRetentions(SVnode* pVnode, TSKEY winSKey, SRetention* ret
    int8_t  precision = pVnode->config.tsdbCfg.precision;
    int64_t now = taosGetTimestamp(precision);
    int64_t offset = tsQueryRsmaTolerance * ((precision == TSDB_TIME_PRECISION_MILLI)   ? 1L
-                                             : (precision == TSDB_TIME_PRECISION_MICRO) ? 1000L
-                                                                                        : 1000000L);
+                                                                                        : (precision == TSDB_TIME_PRECISION_MICRO) ? 1000L
+                                                                                                                                   : 1000000L);

    for (int8_t i = 0; i < TSDB_RETENTION_MAX; ++i) {
      SRetention* pRetention = retentions + level;
@ -2859,7 +2865,7 @@ SVersionRange getQueryVerRange(SVnode* pVnode, SQueryTableDataCond* pCond, int8_
  return (SVersionRange){.minVer = startVer, .maxVer = endVer};
 }

-bool hasBeenDropped(const SArray* pDelList, int32_t* index, TSDBKEY* pKey, int32_t order) {
+bool hasBeenDropped(const SArray* pDelList, int32_t* index, TSDBKEY* pKey, int32_t order, SVersionRange* pVerRange) {
  ASSERT(pKey != NULL);
  if (pDelList == NULL) {
    return false;
@ -2887,7 +2893,8 @@ bool hasBeenDropped(const SArray* pDelList, int32_t* index, TSDBKEY* pKey, int32
        return false;
      }

-      if (pCurrent->ts <= pKey->ts && pNext->ts >= pKey->ts && pCurrent->version >= pKey->version) {
+      if (pCurrent->ts <= pKey->ts && pNext->ts >= pKey->ts && pCurrent->version >= pKey->version &&
+          pVerRange->maxVer >= pCurrent->version) {
        return true;
      }

@ -2903,7 +2910,8 @@ bool hasBeenDropped(const SArray* pDelList, int32_t* index, TSDBKEY* pKey, int32
            continue;
          }

-          if (pCurrent->ts <= pKey->ts && pNext->ts >= pKey->ts && pCurrent->version >= pKey->version) {
+          if (pCurrent->ts <= pKey->ts && pNext->ts >= pKey->ts && pCurrent->version >= pKey->version &&
+              pVerRange->maxVer >= pCurrent->version) {
            return true;
          }
        }
@ -2973,7 +2981,7 @@ TSDBROW* getValidMemRow(SIterInfo* pIter, const SArray* pDelList, STsdbReader* p

  // it is a valid data version
  if ((key.version <= pReader->verRange.maxVer && key.version >= pReader->verRange.minVer) &&
-      (!hasBeenDropped(pDelList, &pIter->index, &key, pReader->order))) {
+      (!hasBeenDropped(pDelList, &pIter->index, &key, pReader->order, &pReader->verRange))) {
    return pRow;
  }

@ -2992,7 +3000,7 @@ TSDBROW* getValidMemRow(SIterInfo* pIter, const SArray* pDelList, STsdbReader* p
    }

    if (key.version <= pReader->verRange.maxVer && key.version >= pReader->verRange.minVer &&
-        (!hasBeenDropped(pDelList, &pIter->index, &key, pReader->order))) {
+        (!hasBeenDropped(pDelList, &pIter->index, &key, pReader->order, &pReader->verRange))) {
      return pRow;
    }
  }
@ -3130,9 +3138,9 @@ int32_t doMergeRowsInFileBlocks(SBlockData* pBlockData, STableBlockScanInfo* pSc
 }

 int32_t doMergeRowsInLastBlock(SLastBlockReader* pLastBlockReader, STableBlockScanInfo* pScanInfo, int64_t ts,
-                               SRowMerger* pMerger) {
+                               SRowMerger* pMerger, SVersionRange* pVerRange) {
  pScanInfo->lastKey = ts;
-  while (nextRowFromLastBlocks(pLastBlockReader, pScanInfo)) {
+  while (nextRowFromLastBlocks(pLastBlockReader, pScanInfo, pVerRange)) {
    int64_t next1 = getCurrentKeyInLastBlock(pLastBlockReader);
    if (next1 == ts) {
      TSDBROW fRow1 = tMergeTreeGetRow(&pLastBlockReader->mergeTree);
@ -3447,13 +3455,23 @@ int32_t buildDataBlockFromBufImpl(STableBlockScanInfo* pBlockScanInfo, int64_t e
  return TSDB_CODE_SUCCESS;
 }

-// todo refactor, use arraylist instead
-int32_t tsdbSetTableId(STsdbReader* pReader, int64_t uid) {
+// TODO refactor: with createDataBlockScanInfo
+int32_t tsdbSetTableList(STsdbReader* pReader, const void* pTableList, int32_t num) {
  ASSERT(pReader != NULL);
+
+  STableBlockScanInfo* p = NULL;
+  while ((p = taosHashIterate(pReader->status.pTableMap, p)) != NULL) {
+    clearBlockScanInfo(p);
+  }
+
  taosHashClear(pReader->status.pTableMap);

-  STableBlockScanInfo info = {.lastKey = 0, .uid = uid};
-  taosHashPut(pReader->status.pTableMap, &info.uid, sizeof(uint64_t), &info, sizeof(info));
+  STableKeyInfo* pList = (STableKeyInfo*) pTableList;
+  for(int32_t i = 0; i < num; ++i) {
+    STableBlockScanInfo info = {.lastKey = 0, .uid = pList[i].uid};
+    taosHashPut(pReader->status.pTableMap, &info.uid, sizeof(uint64_t), &info, sizeof(info));
+  }
+
  return TDB_CODE_SUCCESS;
 }

@ -3478,6 +3496,7 @@ static int32_t doOpenReaderImpl(STsdbReader* pReader) {

  initFilesetIterator(&pReader->status.fileIter, pReader->pReadSnap->fs.aDFileSet, pReader);
  resetDataBlockIterator(&pReader->status.blockIter, pReader->order);
+//  resetDataBlockScanInfo(pReader->status.pTableMap, pReader->window.skey);

  // no data in files, let's try buffer in memory
  if (pReader->status.fileIter.numOfFiles == 0) {
@ -3489,8 +3508,8 @@ static int32_t doOpenReaderImpl(STsdbReader* pReader) {
 }

 // ====================================== EXPOSED APIs ======================================
-int32_t tsdbReaderOpen(SVnode* pVnode, SQueryTableDataCond* pCond, SArray* pTableList, STsdbReader** ppReader,
-                       const char* idstr) {
+int32_t tsdbReaderOpen(SVnode* pVnode, SQueryTableDataCond* pCond, void* pTableList, int32_t numOfTables,
+                       STsdbReader** ppReader, const char* idstr) {
  STimeWindow window = pCond->twindows;
  if (pCond->type == TIMEWINDOW_RANGE_EXTERNAL) {
    pCond->twindows.skey += 1;
@ -3549,8 +3568,8 @@ int32_t tsdbReaderOpen(SVnode* pVnode, SQueryTableDataCond* pCond, SArray* pTabl
    if (pReader->pSchema == NULL) {
      tsdbError("failed to get table schema, suid:%" PRIu64 ", ver:-1, %s", pReader->suid, pReader->idStr);
    }
-  } else if (taosArrayGetSize(pTableList) > 0) {
-    STableKeyInfo* pKey = taosArrayGet(pTableList, 0);
+  } else if (numOfTables > 0) {
+    STableKeyInfo* pKey = pTableList;
    pReader->pSchema = metaGetTbTSchema(pReader->pTsdb->pVnode->pMeta, pKey->uid, -1, 1);
    if (pReader->pSchema == NULL) {
      tsdbError("failed to get table schema, uid:%" PRIu64 ", ver:-1, %s", pKey->uid, pReader->idStr);
@ -3559,8 +3578,7 @@ int32_t tsdbReaderOpen(SVnode* pVnode, SQueryTableDataCond* pCond, SArray* pTabl

  STsdbReader* p = pReader->innerReader[0] != NULL ? pReader->innerReader[0] : pReader;

-  int32_t numOfTables = taosArrayGetSize(pTableList);
-  pReader->status.pTableMap = createDataBlockScanInfo(p, pTableList->pData, numOfTables);
+  pReader->status.pTableMap = createDataBlockScanInfo(p, pTableList, numOfTables);
  if (pReader->status.pTableMap == NULL) {
    tsdbReaderClose(pReader);
    *ppReader = NULL;
@ -3601,23 +3619,13 @@ int32_t tsdbReaderOpen(SVnode* pVnode, SQueryTableDataCond* pCond, SArray* pTabl
      if (code != TSDB_CODE_SUCCESS) {
        return code;
      }
-
-      code = doOpenReaderImpl(pNextReader);
-      if (code != TSDB_CODE_SUCCESS) {
-        return code;
-      }
-
-      code = doOpenReaderImpl(pReader);
-      if (code != TSDB_CODE_SUCCESS) {
-        return code;
-      }
    }
  }

  tsdbDebug("%p total numOfTable:%d in this query %s", pReader, numOfTables, pReader->idStr);
  return code;

-_err:
+  _err:
  tsdbError("failed to create data reader, code:%s %s", tstrerror(code), idstr);
  return code;
 }
@ -3741,15 +3749,21 @@ bool tsdbNextDataBlock(STsdbReader* pReader) {

  if (pReader->innerReader[0] != NULL && pReader->step == 0) {
    bool ret = doTsdbNextDataBlock(pReader->innerReader[0]);
-    resetDataBlockScanInfo(pReader->innerReader[0]->status.pTableMap, pReader->innerReader[0]->window.ekey);
    pReader->step = EXTERNAL_ROWS_PREV;
-
    if (ret) {
      return ret;
    }
  }

  if (pReader->step == EXTERNAL_ROWS_PREV) {
+    // prepare for the main scan
+    int32_t code = doOpenReaderImpl(pReader);
+    resetDataBlockScanInfo(pReader->status.pTableMap, pReader->innerReader[0]->window.ekey);
+
+    if (code != TSDB_CODE_SUCCESS) {
+      return code;
+    }
+
    pReader->step = EXTERNAL_ROWS_MAIN;
  }

@ -3759,7 +3773,13 @@ bool tsdbNextDataBlock(STsdbReader* pReader) {
  }

  if (pReader->innerReader[1] != NULL && pReader->step == EXTERNAL_ROWS_MAIN) {
+    // prepare for the next row scan
+    int32_t code = doOpenReaderImpl(pReader->innerReader[1]);
    resetDataBlockScanInfo(pReader->innerReader[1]->status.pTableMap, pReader->window.ekey);
+    if (code != TSDB_CODE_SUCCESS) {
+      return code;
+    }
+
    bool ret1 = doTsdbNextDataBlock(pReader->innerReader[1]);
    pReader->step = EXTERNAL_ROWS_NEXT;
    if (ret1) {
@ -3772,7 +3792,7 @@ bool tsdbNextDataBlock(STsdbReader* pReader) {

 bool tsdbTableNextDataBlock(STsdbReader* pReader, uint64_t uid) {
  STableBlockScanInfo* pBlockScanInfo = taosHashGet(pReader->status.pTableMap, &uid, sizeof(uid));
-  if (pBlockScanInfo == NULL) { // no data block for the table of given uid
+  if (pBlockScanInfo == NULL) {  // no data block for the table of given uid
    return false;
  }

@ -3959,7 +3979,7 @@ int32_t tsdbReaderReset(STsdbReader* pReader, SQueryTableDataCond* pCond) {
  }

  tsdbDebug("%p reset reader, suid:%" PRIu64 ", numOfTables:%d, skey:%" PRId64 ", query range:%" PRId64 " - %" PRId64
-            " in query %s",
+                " in query %s",
            pReader, pReader->suid, numOfTables, pCond->twindows.skey, pReader->window.skey, pReader->window.ekey,
            pReader->idStr);

@ -4150,7 +4170,7 @@ int32_t tsdbTakeReadSnap(STsdb* pTsdb, STsdbReadSnap** ppSnap, const char* idStr
  }

  tsdbTrace("vgId:%d, take read snapshot, %s", TD_VID(pTsdb->pVnode), idStr);
-_exit:
+  _exit:
  return code;
 }

--- a/source/dnode/vnode/src/vnd/vnodeSvr.c
+++ b/source/dnode/vnode/src/vnd/vnodeSvr.c
@ -369,8 +369,8 @@ int32_t vnodeProcessFetchMsg(SVnode *pVnode, SRpcMsg *pMsg, SQueueInfo *pInfo) {
      return qWorkerProcessFetchMsg(pVnode, pVnode->pQuery, pMsg, 0);
    case TDMT_SCH_FETCH_RSP:
      return qWorkerProcessRspMsg(pVnode, pVnode->pQuery, pMsg, 0);
-    case TDMT_SCH_CANCEL_TASK:
-      return qWorkerProcessCancelMsg(pVnode, pVnode->pQuery, pMsg, 0);
+    // case TDMT_SCH_CANCEL_TASK:
+    //   return qWorkerProcessCancelMsg(pVnode, pVnode->pQuery, pMsg, 0);
    case TDMT_SCH_DROP_TASK:
      return qWorkerProcessDropMsg(pVnode, pVnode->pQuery, pMsg, 0);
    case TDMT_SCH_QUERY_HEARTBEAT:
@ -385,9 +385,10 @@ int32_t vnodeProcessFetchMsg(SVnode *pVnode, SRpcMsg *pMsg, SQueueInfo *pInfo) {
      return tqProcessPollReq(pVnode->pTq, pMsg);
    case TDMT_STREAM_TASK_RUN:
      return tqProcessTaskRunReq(pVnode->pTq, pMsg);
+#if 0
    case TDMT_STREAM_TASK_DISPATCH:
-      //      return tqProcessTaskDispatchReq(pVnode->pTq, pMsg, pInfo->workerId != 0);
      return tqProcessTaskDispatchReq(pVnode->pTq, pMsg, true);
+#endif
      /*case TDMT_STREAM_TASK_RECOVER:*/
      /*return tqProcessTaskRecoverReq(pVnode->pTq, pMsg);*/
    case TDMT_STREAM_RETRIEVE:
@ -1163,8 +1164,10 @@ static int32_t vnodeProcessBatchDeleteReq(SVnode *pVnode, int64_t version, void
  for (int32_t i = 0; i < sz; i++) {
    SSingleDeleteReq *pOneReq = taosArrayGet(deleteReq.deleteReqs, i);
    int32_t code = tsdbDeleteTableData(pVnode->pTsdb, version, deleteReq.suid, pOneReq->uid, pOneReq->ts, pOneReq->ts);
-    if (code) {
-      // TODO
+    if (code < 0) {
+      terrno = code;
+      vError("vgId:%d, delete error since %s, suid:%" PRId64 ", uid:%" PRId64 ", start ts:%" PRId64 ", end ts:%" PRId64,
+             TD_VID(pVnode), terrstr(), deleteReq.suid, pOneReq->uid, pOneReq->ts, pOneReq->ts);
    }
  }
  taosArrayDestroy(deleteReq.deleteReqs);
--- a/source/dnode/vnode/src/vnd/vnodeSync.c
+++ b/source/dnode/vnode/src/vnd/vnodeSync.c
@ -301,13 +301,13 @@ int32_t vnodeProcessSyncMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
  } else if (pMsg->msgType == TDMT_SYNC_PING) {
    SyncPing *pSyncMsg = syncPingFromRpcMsg2(pMsg);
    ASSERT(pSyncMsg != NULL);
-    code = syncNodeOnPingCb(pSyncNode, pSyncMsg);
+    code = syncNodeOnPing(pSyncNode, pSyncMsg);
    syncPingDestroy(pSyncMsg);

  } else if (pMsg->msgType == TDMT_SYNC_PING_REPLY) {
    SyncPingReply *pSyncMsg = syncPingReplyFromRpcMsg2(pMsg);
    ASSERT(pSyncMsg != NULL);
-    code = syncNodeOnPingReplyCb(pSyncNode, pSyncMsg);
+    code = syncNodeOnPingReply(pSyncNode, pSyncMsg);
    syncPingReplyDestroy(pSyncMsg);

  } else if (pMsg->msgType == TDMT_SYNC_CLIENT_REQUEST) {
--- a/source/libs/catalog/src/catalog.c
+++ b/source/libs/catalog/src/catalog.c
@ -570,7 +570,7 @@ int32_t catalogInit(SCatalogCfg* cfg) {
    CTG_ERR_RET(TSDB_CODE_CTG_INVALID_INPUT);
  }

-  atomic_store_8((int8_t*)&gCtgMgmt.exit, false);
+  memset(&gCtgMgmt, 0, sizeof(gCtgMgmt));

  if (cfg) {
    memcpy(&gCtgMgmt.cfg, cfg, sizeof(*cfg));
@ -1114,6 +1114,7 @@ int32_t catalogGetCachedTableHashVgroup(SCatalog* pCtg, SRequestConnInfo* pConn,
  CTG_API_LEAVE(ctgGetTbHashVgroup(pCtg, pConn, pTableName, pVgroup, exists));
 }

+#if 0
 int32_t catalogGetAllMeta(SCatalog* pCtg, SRequestConnInfo* pConn, const SCatalogReq* pReq, SMetaData* pRsp) {
  CTG_API_ENTER();

@ -1176,6 +1177,7 @@ _return:

  CTG_API_LEAVE(code);
 }
+#endif

 int32_t catalogAsyncGetAllMeta(SCatalog* pCtg, SRequestConnInfo* pConn, const SCatalogReq* pReq, catalogCallback fp,
                               void* param, int64_t* jobId) {
--- a/source/libs/catalog/src/ctgCache.c
+++ b/source/libs/catalog/src/ctgCache.c
@ -72,7 +72,10 @@ void ctgRUnlockVgInfo(SCtgDBCache *dbCache) { CTG_UNLOCK(CTG_READ, &dbCache->vgC

 void ctgWUnlockVgInfo(SCtgDBCache *dbCache) { CTG_UNLOCK(CTG_WRITE, &dbCache->vgCache.vgLock); }

-void ctgReleaseDBCache(SCatalog *pCtg, SCtgDBCache *dbCache) { CTG_UNLOCK(CTG_READ, &dbCache->dbLock); }
+void ctgReleaseDBCache(SCatalog *pCtg, SCtgDBCache *dbCache) { 
+  CTG_UNLOCK(CTG_READ, &dbCache->dbLock); 
+  taosHashRelease(pCtg->dbCache, dbCache);
+}

 int32_t ctgAcquireDBCacheImpl(SCatalog *pCtg, const char *dbFName, SCtgDBCache **pCache, bool acquire) {
  char *p = strchr(dbFName, '.');
@ -80,7 +83,14 @@ int32_t ctgAcquireDBCacheImpl(SCatalog *pCtg, const char *dbFName, SCtgDBCache *
    dbFName = p + 1;
  }

-  SCtgDBCache *dbCache = (SCtgDBCache *)taosHashGet(pCtg->dbCache, dbFName, strlen(dbFName));
+  SCtgDBCache *dbCache = NULL;
+
+  if (acquire) {
+    dbCache = (SCtgDBCache *)taosHashAcquire(pCtg->dbCache, dbFName, strlen(dbFName));
+  } else {
+    dbCache = (SCtgDBCache *)taosHashGet(pCtg->dbCache, dbFName, strlen(dbFName));
+  }
+  
  if (NULL == dbCache) {
    *pCache = NULL;
    ctgDebug("db not in cache, dbFName:%s", dbFName);
@ -611,14 +621,18 @@ int32_t ctgEnqueue(SCatalog *pCtg, SCtgCacheOperation *operation) {
  node->op = operation;

  CTG_LOCK(CTG_WRITE, &gCtgMgmt.queue.qlock);
+
  if (gCtgMgmt.queue.stopQueue) {
    ctgFreeQNode(node);
    CTG_UNLOCK(CTG_WRITE, &gCtgMgmt.queue.qlock);
    CTG_RET(TSDB_CODE_CTG_EXIT);
  }
-  gCtgMgmt.queue.stopQueue = operation->stopQueue;
+
  gCtgMgmt.queue.tail->next = node;
  gCtgMgmt.queue.tail = node;
+
+  gCtgMgmt.queue.stopQueue = operation->stopQueue;
+
  CTG_UNLOCK(CTG_WRITE, &gCtgMgmt.queue.qlock);

  ctgDebug("action [%s] added into queue", opName);
@ -1356,7 +1370,6 @@ int32_t ctgWriteTbMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFNam
  SCtgTbCache *pCache = taosHashGet(dbCache->tbCache, tbName, strlen(tbName));
  STableMeta  *orig = (pCache ? pCache->pMeta : NULL);
  int8_t       origType = 0;
-  uint64_t     origSuid = 0;

  if (orig) {
    origType = orig->tableType;
@ -1375,8 +1388,6 @@ int32_t ctgWriteTbMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFNam
        CTG_CACHE_STAT_DEC(numOfStb, 1);
        ctgDebug("stb removed from stbCache, dbFName:%s, stb:%s, suid:0x%" PRIx64, dbFName, tbName, orig->suid);
      }
-
-      origSuid = orig->suid;
    }
  }

@ -1408,8 +1419,7 @@ int32_t ctgWriteTbMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFNam
    return TSDB_CODE_SUCCESS;
  }

-  if (origSuid != meta->suid &&
-      taosHashPut(dbCache->stbCache, &meta->suid, sizeof(meta->suid), tbName, strlen(tbName) + 1) != 0) {
+  if (taosHashPut(dbCache->stbCache, &meta->suid, sizeof(meta->suid), tbName, strlen(tbName) + 1) != 0) {
    ctgError("taosHashPut to stable cache failed, suid:0x%" PRIx64, meta->suid);
    CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
  }
@ -1991,6 +2001,59 @@ _return:
  CTG_RET(code);
 }

+void ctgFreeCacheOperationData(SCtgCacheOperation *op) {
+  if (NULL == op || NULL == op->data) {
+    return;
+  }
+
+  switch (op->opId) {
+    case CTG_OP_UPDATE_VGROUP: {
+      SCtgUpdateVgMsg *msg = op->data;
+      ctgFreeVgInfo(msg->dbInfo);
+      taosMemoryFreeClear(op->data);
+      break;
+    }
+    case CTG_OP_UPDATE_TB_META: {
+      SCtgUpdateTbMetaMsg *msg = op->data;
+      taosMemoryFreeClear(msg->pMeta->tbMeta);
+      taosMemoryFreeClear(msg->pMeta);
+      taosMemoryFreeClear(op->data);
+      break;
+    }
+    case CTG_OP_DROP_DB_CACHE:
+    case CTG_OP_DROP_DB_VGROUP:
+    case CTG_OP_DROP_STB_META:
+    case CTG_OP_DROP_TB_META:
+    case CTG_OP_UPDATE_VG_EPSET:
+    case CTG_OP_DROP_TB_INDEX:
+    case CTG_OP_CLEAR_CACHE: {
+      taosMemoryFreeClear(op->data);
+      break;
+    }
+    case CTG_OP_UPDATE_USER: {
+      SCtgUpdateUserMsg *msg = op->data;
+      taosHashCleanup(msg->userAuth.createdDbs);
+      taosHashCleanup(msg->userAuth.readDbs);
+      taosHashCleanup(msg->userAuth.writeDbs);
+      taosMemoryFreeClear(op->data);
+      break;
+    }
+    case CTG_OP_UPDATE_TB_INDEX: {
+      SCtgUpdateTbIndexMsg *msg = op->data;
+      if (msg->pIndex) {
+        taosArrayDestroyEx(msg->pIndex->pIndex, tFreeSTableIndexInfo);
+        taosMemoryFreeClear(msg->pIndex);
+      }
+      taosMemoryFreeClear(op->data);
+      break;
+    }
+    default: {
+      qError("invalid cache op id:%d", op->opId);
+      break;
+    }
+  }
+}
+
 void ctgCleanupCacheQueue(void) {
  SCtgQNode          *node = NULL;
  SCtgQNode          *nodeNext = NULL;
@ -2009,7 +2072,7 @@ void ctgCleanupCacheQueue(void) {
          stopQueue = true;
          CTG_RT_STAT_INC(numOfOpDequeue, 1);
        } else {
-          taosMemoryFree(op->data);
+          ctgFreeCacheOperationData(op);
          CTG_RT_STAT_INC(numOfOpAbort, 1);
        }

@ -2047,7 +2110,7 @@ void *ctgUpdateThreadFunc(void *param) {
      qError("ctg tsem_wait failed, error:%s", tstrerror(TAOS_SYSTEM_ERROR(errno)));
    }

-    if (atomic_load_8((int8_t *)&gCtgMgmt.exit)) {
+    if (atomic_load_8((int8_t *)&gCtgMgmt.queue.stopQueue)) {
      ctgCleanupCacheQueue();
      break;
    }
--- a/source/libs/catalog/test/CMakeLists.txt
+++ b/source/libs/catalog/test/CMakeLists.txt
@ -18,8 +18,8 @@ IF(NOT TD_DARWIN)
                PRIVATE "${TD_SOURCE_DIR}/source/libs/catalog/inc"
        )

-        # add_test(
-        #     NAME catalogTest
-        #     COMMAND catalogTest
-        # )
+        add_test(
+            NAME catalogTest
+            COMMAND catalogTest
+        )
 ENDIF()
--- a/Show More
+++ b/Show More