fix:merge 3.0 conflict

2023-01-07 22:08:26 +08:00 · 2023-01-07 22:08:26 +08:00 · c4908770f8
parent 6ec16c1a48 295eee4703
commit c4908770f8
437 changed files with 27740 additions and 18871 deletions
--- a/cmake/cmake.define
+++ b/cmake/cmake.define
@ -1,6 +1,7 @@
 cmake_minimum_required(VERSION 3.0)

 set(CMAKE_VERBOSE_MAKEFILE OFF)
+set(TD_BUILD_TAOSA_INTERNAL FALSE)

 #set output directory
 SET(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/build/lib)
@ -117,14 +118,22 @@ ELSE ()
    IF (${BUILD_SANITIZER})
        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}     -Werror -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize=undefined -fsanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=shift-base -fno-sanitize=alignment -g3 -Wformat=0")
        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wno-literal-suffix -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize=undefined -fsanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=shift-base -fno-sanitize=alignment -g3 -Wformat=0")
-	      MESSAGE(STATUS "Will compile with Address Sanitizer!")
+	      MESSAGE(STATUS "Compile with Address Sanitizer!")
    ELSE ()
        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Werror=return-type -fPIC -gdwarf-2 -g3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wno-literal-suffix -Werror=return-type -fPIC -gdwarf-2 -g3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
    ENDIF ()

+    # disable all assert
+    IF ((${DISABLE_ASSERT} MATCHES "true") OR (${DISABLE_ASSERTS} MATCHES "true"))
+        ADD_DEFINITIONS(-DDISABLE_ASSERT)
+        MESSAGE(STATUS "Disable all asserts")
+    ENDIF()
+
    INCLUDE(CheckCCompilerFlag)
-    IF (("${CMAKE_C_COMPILER_ID}" MATCHES "Clang") OR ("${CMAKE_C_COMPILER_ID}" MATCHES "AppleClang"))
+    IF (TD_ARM_64 OR TD_ARM_32)
+        SET(COMPILER_SUPPORT_SSE42 false)
+    ELSEIF (("${CMAKE_C_COMPILER_ID}" MATCHES "Clang") OR ("${CMAKE_C_COMPILER_ID}" MATCHES "AppleClang"))
        SET(COMPILER_SUPPORT_SSE42 true)
        MESSAGE(STATUS "Always enable sse4.2 for Clang/AppleClang")
    ELSE()
@ -139,13 +148,13 @@ ELSE ()
        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -msse4.2")
        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse4.2")
    ENDIF()
-    IF (COMPILER_SUPPORT_FMA)
-        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfma")
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfma")
-    ENDIF()

    IF ("${SIMD_SUPPORT}" MATCHES "true")
-        IF (COMPILER_SUPPORT_AVX)
+       IF (COMPILER_SUPPORT_FMA)
+           SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfma")
+           SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfma")
+       ENDIF()
+       IF (COMPILER_SUPPORT_AVX)
            SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mavx")
            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx")
        ENDIF()
@ -153,7 +162,7 @@ ELSE ()
            SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mavx2")
            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx2")
        ENDIF()
-        MESSAGE(STATUS "SIMD instructions (AVX/AVX2) is ACTIVATED")
+        MESSAGE(STATUS "SIMD instructions (FMA/AVX/AVX2) is ACTIVATED")
    ENDIF()

 ENDIF ()
--- a/cmake/cmake.install
+++ b/cmake/cmake.install
@ -21,7 +21,7 @@ IF (TD_LINUX)
 ELSEIF (TD_WINDOWS)
  SET(TD_MAKE_INSTALL_SH "${TD_SOURCE_DIR}/packaging/tools/make_install.bat")
  INSTALL(CODE "MESSAGE(\"make install script: ${TD_MAKE_INSTALL_SH}\")")
-  INSTALL(CODE "execute_process(COMMAND ${TD_MAKE_INSTALL_SH} :needAdmin ${TD_SOURCE_DIR} ${PROJECT_BINARY_DIR} Windows ${TD_VER_NUMBER})")
+  INSTALL(CODE "execute_process(COMMAND ${TD_MAKE_INSTALL_SH} :needAdmin ${TD_SOURCE_DIR} ${PROJECT_BINARY_DIR} Windows ${TD_VER_NUMBER} ${TD_BUILD_TAOSA_INTERNAL})")
 ELSEIF (TD_DARWIN)
  SET(TD_MAKE_INSTALL_SH "${TD_SOURCE_DIR}/packaging/tools/make_install.sh")
  INSTALL(CODE "MESSAGE(\"make install script: ${TD_MAKE_INSTALL_SH}\")")
--- a/cmake/cmake.version
+++ b/cmake/cmake.version
@ -2,7 +2,7 @@
 IF (DEFINED VERNUMBER)
  SET(TD_VER_NUMBER ${VERNUMBER})
 ELSE ()
-  SET(TD_VER_NUMBER "3.0.2.0")
+  SET(TD_VER_NUMBER "3.0.2.2")
 ENDIF ()

 IF (DEFINED VERCOMPATIBLE)
--- 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 4dfc4d1
+        GIT_TAG a2e9920
        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 261fcca
+        GIT_TAG 4efbc10
        SOURCE_DIR "${TD_SOURCE_DIR}/tools/taos-tools"
        BINARY_DIR ""
        #BUILD_IN_SOURCE TRUE
--- a/docs/en/12-taos-sql/02-database.md
+++ b/docs/en/12-taos-sql/02-database.md
@ -30,6 +30,8 @@ database_option: {
  | WAL_LEVEL {1 | 2}
  | VGROUPS value
  | SINGLE_STABLE {0 | 1}
+  | TABLE_PREFIX value
+  | TABLE_SUFFIX value
  | WAL_RETENTION_PERIOD value
  | WAL_ROLL_PERIOD value
  | WAL_RETENTION_SIZE value
@ -67,6 +69,8 @@ database_option: {
 - SINGLE_STABLE: specifies whether the database can contain more than one supertable.
  - 0: The database can contain multiple supertables.
  - 1: The database can contain only one supertable.
+- TABLE_PREFIX：The prefix length in the table name that is ignored when distributing table to vnode based on table name.
+- TABLE_SUFFIX：The suffix length in the table name that is ignored when distributing table to vnode based on table name.
 - WAL_RETENTION_PERIOD: specifies the time after which WAL files are deleted. This parameter is used for data subscription. Enter a time in seconds. The default value of single copy is 0. A value of 0 indicates that each WAL file is deleted immediately after its contents are written to disk. -1: WAL files are never deleted. The default value of multiple copy is 4 days.
 - WAL_RETENTION_SIZE: specifies the size at which WAL files are deleted. This parameter is used for data subscription. Enter a size in KB. The default value of single copy is 0. A value of 0 indicates that each WAL file is deleted immediately after its contents are written to disk. -1: WAL files are never deleted. The default value of multiple copy is -1.
 - WAL_ROLL_PERIOD: specifies the time after which WAL files are rotated. After this period elapses, a new WAL file is created. The default value of single copy is 0. A value of 0 indicates that a new WAL file is created only after the previous WAL file was written to disk. The default values of multiple copy is 1 day.
--- a/docs/en/12-taos-sql/20-keywords.md
+++ b/docs/en/12-taos-sql/20-keywords.md
@ -17,6 +17,7 @@ The following list shows all reserved keywords:
 - ADD
 - AFTER
 - AGGREGATE
+- ALIVE
 - ALL
 - ALTER
 - ANALYZE
--- a/docs/en/12-taos-sql/24-show.md
+++ b/docs/en/12-taos-sql/24-show.md
@ -178,6 +178,139 @@ SHOW TABLE DISTRIBUTED table_name;

 Shows how table data is distributed.

+Examples： Below is an example of this command to display the block distribution of table `d0` in detailed format.
+
+```sql
+show table distributed d0\G;   
+```
+
+<details>
+ <summary> Show Example </summary>
+ <pre><code>
+*************************** 1.row ***************************
+_block_dist: Total_Blocks=[5] Total_Size=[93.65 Kb] Average_size=[18.73 Kb] Compression_Ratio=[23.98 %]
+
+Total_Blocks :  Table `d0` contains total 5 blocks
+
+Total_Size:  The total size of all the data blocks in table `d0` is 93.65 KB 
+
+Average_size:  The average size of each block is 18.73 KB
+
+Compression_Ratio: The data compression rate is 23.98%
+ 
+*************************** 2.row ***************************
+_block_dist: Total_Rows=[20000] Inmem_Rows=[0] MinRows=[3616] MaxRows=[4096] Average_Rows=[4000]
+
+Total_Rows: Table `d0` contains 20,000 rows
+
+Inmem_Rows： The rows still in memory, i.e. not committed in disk, is 0, i.e. none such rows
+
+MinRows：  The minimum number of rows in a block is 3,616 
+
+MaxRows： The maximum number of rows in a block is 4,096B
+
+Average_Rows： The average number of rows in a block is 4,000
+
+*************************** 3.row ***************************
+_block_dist: Total_Tables=[1] Total_Files=[2]
+
+Total_Tables:  The number of child tables, 1 in this example
+
+Total_Files：   The number of files storing the table's data, 2 in this example
+
+*************************** 4.row ***************************
+
+_block_dist: --------------------------------------------------------------------------------
+
+*************************** 5.row ***************************
+
+_block_dist: 0100 |
+
+*************************** 6.row ***************************
+
+_block_dist: 0299 |
+
+*************************** 7.row ***************************
+
+_block_dist: 0498 |
+
+*************************** 8.row ***************************
+
+_block_dist: 0697 |
+
+*************************** 9.row ***************************
+
+_block_dist: 0896 |
+
+*************************** 10.row ***************************
+
+_block_dist: 1095 |
+
+*************************** 11.row ***************************
+
+_block_dist: 1294 |
+
+*************************** 12.row ***************************
+
+_block_dist: 1493 |
+
+*************************** 13.row ***************************
+
+_block_dist: 1692 |
+
+*************************** 14.row ***************************
+
+_block_dist: 1891 |
+
+*************************** 15.row ***************************
+
+_block_dist: 2090 |
+
+*************************** 16.row ***************************
+
+_block_dist: 2289 |
+
+*************************** 17.row ***************************
+
+_block_dist: 2488 |
+
+*************************** 18.row ***************************
+
+_block_dist: 2687 |
+
+*************************** 19.row ***************************
+
+_block_dist: 2886 |
+
+*************************** 20.row ***************************
+
+_block_dist: 3085 |
+
+*************************** 21.row ***************************
+
+_block_dist: 3284 |
+
+*************************** 22.row ***************************
+
+_block_dist: 3483 |||||||||||||||||  1 (20.00%)
+
+*************************** 23.row ***************************
+
+_block_dist: 3682 |
+
+*************************** 24.row ***************************
+
+_block_dist: 3881 |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||  4 (80.00%)
+
+Query OK, 24 row(s) in set (0.002444s)
+
+</code></pre>
+</details>
+
+  The above show the block distribution percentage according to the number of rows in each block. In the above example, we can get below information:
+  - `_block_dist: 3483 |||||||||||||||||  1 (20.00%)` means there is one block whose rows is between 3,483 and 3,681.
+  -  `_block_dist: 3881 |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||  4 (80.00%)` means there are 4 blocks whose rows is between 3,881 and 4,096.   -  The number of blocks whose rows fall in other range is zero.
+
 ## SHOW TAGS

 ```sql
--- a/docs/en/14-reference/04-taosadapter.md
+++ b/docs/en/14-reference/04-taosadapter.md
@ -21,6 +21,7 @@ taosAdapter provides the following features.
 - Seamless connection to collectd
 - Seamless connection to StatsD
 - Supports Prometheus remote_read and remote_write
+- Get table's VGroup ID

 ## taosAdapter architecture diagram

@ -178,6 +179,7 @@ See [example/config/taosadapter.toml](https://github.com/taosdata/taosadapter/bl
  node_export is an exporter for machine metrics. Please visit [https://github.com/prometheus/node_exporter](https://github.com/prometheus/node_exporter) for more information.
 - Support for Prometheus remote_read and remote_write
  remote_read and remote_write are interfaces for Prometheus data read and write from/to other data storage solution. Please visit [https://prometheus.io/blog/2019/10/10/remote-read-meets-streaming/#remote-apis](https://prometheus.io/blog/2019/10/10/remote-read-meets-streaming/#remote-apis) for more information.
+- Get table's VGroup ID. For more information about VGroup, please refer to [primary-logic-unit](/tdinternal/arch/#primary-logic-unit).

 ## Interfaces

@ -199,7 +201,7 @@ Support InfluxDB query parameters as follows.
 - `precision` The time precision used by TDengine
 - `u` TDengine user name
 - `p` TDengine password
- `ttl` The time to live of automatically created sub-table. This value cannot be updated. TDengine will use the ttl value of the frist data of sub-table to create sub-table. For more information, please refer [Create Table](/taos-sql/table/#create-table)
+- `ttl` The time to live of automatically created sub-table. This value cannot be updated. TDengine will use the ttl value of the first data of sub-table to create sub-table. For more information, please refer [Create Table](/taos-sql/table/#create-table)

 Note:      InfluxDB token authorization is not supported at present. Only Basic authorization and query parameter validation are supported.
 Example:   curl --request POST http://127.0.0.1:6041/influxdb/v1/write?db=test --user "root:taosdata" --data-binary "measurement,host=host1 field1=2i,field2=2.0 1577836800000000000"
@ -241,6 +243,10 @@ node_export is an exporter of hardware and OS metrics exposed by the \*NIX kerne

 <Prometheus />

+### Get table's VGroup ID
+
+You can call `http://<fqdn>:6041/rest/vgid?db=<db>&table=<table>` to get table's VGroup ID. For more information about VGroup, please refer to [primary-logic-unit](/tdinternal/arch/#primary-logic-unit).
+
 ## Memory usage optimization methods

 taosAdapter will monitor its memory usage during operation and adjust it with two thresholds. Valid values are integers between 1 to 100, and represent a percentage of the system's physical memory.
--- a/docs/en/28-releases/01-tdengine.md
+++ b/docs/en/28-releases/01-tdengine.md
@ -10,6 +10,14 @@ For TDengine 2.x installation packages by version, please visit [here](https://w

 import Release from "/components/ReleaseV3";

+## 3.0.2.2
+
+<Release type="tdengine" version="3.0.2.2" />
+
+## 3.0.2.1
+
+<Release type="tdengine" version="3.0.2.1" />
+
 ## 3.0.2.0

 <Release type="tdengine" version="3.0.2.0" />
--- a/docs/en/28-releases/02-tools.md
+++ b/docs/en/28-releases/02-tools.md
@ -10,6 +10,14 @@ For other historical version installers, please visit [here](https://www.taosdat

 import Release from "/components/ReleaseV3";

+## 2.4.0
+
+<Release type="tools" version="2.4.0" />
+
+## 2.3.3
+
+<Release type="tools" version="2.3.3" />
+
 ## 2.3.2

 <Release type="tools" version="2.3.2" />
--- a/docs/examples/go/sub/main.go
+++ b/docs/examples/go/sub/main.go
@ -84,20 +84,6 @@ func main() {
 	if err != nil {
 		panic(err)
 	}
-	for {
-		result, err := consumer.Poll(time.Second)
-		if err != nil {
-			panic(err)
-		}
-		if result.Type != common.TMQ_RES_TABLE_META {
-			panic("want message type 2 got " + strconv.Itoa(int(result.Type)))
-		}
-		data, _ := json.Marshal(result.Meta)
-		fmt.Println(string(data))
-		consumer.Commit(context.Background(), result.Message)
-		consumer.FreeMessage(result.Message)
-		break
-	}
 	_, err = db.Exec("insert into example_tmq.t1 values(now,1)")
 	if err != nil {
 		panic(err)
--- a/docs/zh/12-taos-sql/02-database.md
+++ b/docs/zh/12-taos-sql/02-database.md
@ -30,6 +30,8 @@ database_option: {
  | WAL_LEVEL {1 | 2}
  | VGROUPS value
  | SINGLE_STABLE {0 | 1}
+  | TABLE_PREFIX value
+  | TABLE_SUFFIX value
  | WAL_RETENTION_PERIOD value
  | WAL_ROLL_PERIOD value
  | WAL_RETENTION_SIZE value
@ -67,6 +69,8 @@ database_option: {
 - SINGLE_STABLE：表示此数据库中是否只可以创建一个超级表，用于超级表列非常多的情况。
  - 0：表示可以创建多张超级表。
  - 1：表示只可以创建一张超级表。
+- TABLE_PREFIX：内部存储引擎根据表名分配存储该表数据的 VNODE 时要忽略的前缀的长度。
+- TABLE_SUFFIX：内部存储引擎根据表名分配存储该表数据的 VNODE 时要忽略的后缀的长度。
 - WAL_RETENTION_PERIOD：wal 文件的额外保留策略，用于数据订阅。wal 的保存时长，单位为 s。单副本默认为 0，即落盘后立即删除。-1 表示不删除。多副本默认为 4 天。
 - WAL_RETENTION_SIZE：wal 文件的额外保留策略，用于数据订阅。wal 的保存的最大上限，单位为 KB。单副本默认为 0，即落盘后立即删除。多副本默认为-1，表示不删除。
 - WAL_ROLL_PERIOD：wal 文件切换时长，单位为 s。当 wal 文件创建并写入后，经过该时间，会自动创建一个新的 wal 文件。单副本默认为 0，即仅在落盘时创建新文件。多副本默认为 1 天。
--- a/docs/zh/12-taos-sql/20-keywords.md
+++ b/docs/zh/12-taos-sql/20-keywords.md
@ -18,6 +18,7 @@ description: TDengine 保留关键字的详细列表
 - ADD
 - AFTER
 - AGGREGATE
+- ALIVE
 - ALL
 - ALTER
 - ANALYZE
--- a/docs/zh/12-taos-sql/24-show.md
+++ b/docs/zh/12-taos-sql/24-show.md
@ -179,6 +179,81 @@ SHOW TABLE DISTRIBUTED table_name;

 显示表的数据分布信息。

+示例说明：
+
+语句： show table distributed d0\G;   竖行显示表 d0 的 BLOCK 分布情况
+
+<details>
+ <summary>显示示例</summary>
+ <pre><code>
+
+*************************** 1.row ***************************
+
+_block_dist: Total_Blocks=[5] Total_Size=[93.65 Kb] Average_size=[18.73 Kb] Compression_Ratio=[23.98 %]
+
+Total_Blocks :  表d0 占用的 block 个数为 5 个
+
+Total_Size.    :  表 d0 所有 block 在文件中占用的大小为 93.65 KB 
+
+Average_size:  平均每个 block 在文件中占用的空间大小为 18.73 KB
+
+Compression_Ratio: 数据压缩率为 23.98%
+
+ 
+*************************** 2.row ***************************
+
+_block_dist: Total_Rows=[20000] Inmem_Rows=[0] MinRows=[3616] MaxRows=[4096] Average_Rows=[4000]
+
+Total_Rows: 统计表 d0 的所有行数 为20000 行
+
+Inmem_Rows： 表示仍然还存放在内存中的行数，即没有落盘的行数，为 0行，表示没有
+
+MinRows：  BLOCK 中最小的行数，为 3616 行
+
+MaxRows： BLOCK 中最大的行数，为 4096行
+
+Average_Rows： BLOCK 中的平均行数，为4000 行
+
+
+*************************** 3.row ***************************
+
+_block_dist: Total_Tables=[1] Total_Files=[2]
+
+Total_Tables:  表示子表的个数，这里为1
+
+Total_Files：   表数据保存在几个文件中，这里保存在 2 个文件中
+
+
+*************************** 5.row ***************************
+
+_block_dist: 0100 |
+
+*************************** 6.row ***************************
+
+_block_dist: 0299 |
+
+......
+
+*************************** 22.row ***************************
+
+_block_dist: 3483 |||||||||||||||||  1 (20.00%)
+
+*************************** 23.row ***************************
+
+_block_dist: 3682 |
+
+*************************** 24.row ***************************
+
+_block_dist: 3881 |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||  4 (80.00%)
+
+Query OK, 24 row(s) in set (0.002444s)
+
+</code></pre>
+ </details>
+
+  上面是块中包含数据行数的块儿分布情况图，这里的 0100 0299 0498 … 表示的是每个块中包含的数据行数，上面的意思就是这个表的 5 个块，分布在 3483 ~3681 行的块有 1 个，占整个块的 20%，分布在 3881 ~ 4096（最大行数）的块数为 4 个，占整个块的 80%， 其它区域内分布块数为 0。
+
+
 ## SHOW TAGS

 ```sql
--- a/docs/zh/12-taos-sql/29-changes.md
+++ b/docs/zh/12-taos-sql/29-changes.md
@ -94,6 +94,7 @@ description: "TDengine 3.0 版本的语法变更说明"
 | 9 | SAMPLE | 增强 | 可以直接用于超级表了。没有PARTITION BY时，超级表的数据会被合并成一条时间线。
 | 10 | STATECOUNT | 增强 | 可以直接用于超级表了。没有PARTITION BY时，超级表的数据会被合并成一条时间线。
 | 11 | STATEDURATION | 增强 | 可以直接用于超级表了。没有PARTITION BY时，超级表的数据会被合并成一条时间线。
+| 12 | TIMETRUNCATE | 增强 | 增加ignore_timezone参数，可选是否使用，默认值为1.


 ## SCHEMALESS 变更
--- a/docs/zh/14-reference/04-taosadapter.md
+++ b/docs/zh/14-reference/04-taosadapter.md
@ -21,6 +21,7 @@ taosAdapter 提供以下功能：
 - 无缝连接到 collectd
 - 无缝连接到 StatsD
 - 支持 Prometheus remote_read 和 remote_write
+- 获取 table 所在的虚拟节点组（VGroup）的 VGroup ID

 ## taosAdapter 架构图

@ -178,6 +179,7 @@ AllowWebSockets
  node_export 是一个机器指标的导出器。请访问 [https://github.com/prometheus/node_exporter](https://github.com/prometheus/node_exporter) 了解更多信息。
 - 支持 Prometheus remote_read 和 remote_write
  remote_read 和 remote_write 是 Prometheus 数据读写分离的集群方案。请访问[https://prometheus.io/blog/2019/10/10/remote-read-meets-streaming/#remote-apis](https://prometheus.io/blog/2019/10/10/remote-read-meets-streaming/#remote-apis) 了解更多信息。
+- 获取 table 所在的虚拟节点组（VGroup）的 VGroup ID。关于虚拟节点组（VGroup）的更多信息，请访问[整体架构文档](/tdinternal/arch/#主要逻辑单元) 。

 ## 接口

@ -240,6 +242,10 @@ Prometheus 使用的由 \*NIX 内核暴露的硬件和操作系统指标的输

 <Prometheus />

+### 获取 table 的 VGroup ID
+
+可以访问 http 接口 `http://<fqdn>:6041/rest/vgid?db=<db>&table=<table>` 获取 table 的 VGroup ID。关于虚拟节点组（VGroup）的更多信息，请访问[整体架构文档](/tdinternal/arch/#主要逻辑单元) 。
+
 ## 内存使用优化方法

 taosAdapter 将监测自身运行过程中内存使用率并通过两个阈值进行调节。有效值范围为 -1 到 100 的整数，单位为系统物理内存的百分比。
@ -282,7 +288,7 @@ http 返回内容：

 ## taosAdapter 监控指标

-taosAdapter 采集 http 相关指标、cpu 百分比和内存百分比。
+taosAdapter 采集 http 相关指标、CPU 百分比和内存百分比。

 ### http 接口

@ -294,13 +300,13 @@ http://<fqdn>:6041/metrics

 ### 写入 TDengine

-taosAdapter 支持将 http 监控、cpu 百分比和内存百分比写入 TDengine。
+taosAdapter 支持将 http 监控、CPU 百分比和内存百分比写入 TDengine。

 有关配置参数

 | **配置项**                 | **描述**                                     | **默认值**  |
 |-------------------------|--------------------------------------------|----------|
-| monitor.collectDuration | cpu 和内存采集间隔                                | 3s       |
+| monitor.collectDuration | CPU 和内存采集间隔                                | 3s       |
 | monitor.identity        | 当前taosadapter 的标识符如果不设置将使用 'hostname:port' |          |
 | monitor.incgroup        | 是否是 cgroup 中运行(容器中运行设置为 true)              | false    |
 | monitor.writeToTD       | 是否写入到 TDengine                             | false    |
--- a/docs/zh/28-releases/01-tdengine.md
+++ b/docs/zh/28-releases/01-tdengine.md
@ -10,6 +10,14 @@ TDengine 2.x 各版本安装包请访问[这里](https://www.taosdata.com/all-do

 import Release from "/components/ReleaseV3";

+## 3.0.2.2
+
+<Release type="tdengine" version="3.0.2.2" />
+
+## 3.0.2.1
+
+<Release type="tdengine" version="3.0.2.1" />
+
 ## 3.0.2.0

 <Release type="tdengine" version="3.0.2.0" />
--- a/docs/zh/28-releases/02-tools.md
+++ b/docs/zh/28-releases/02-tools.md
@ -10,6 +10,14 @@ taosTools 各版本安装包下载链接如下：

 import Release from "/components/ReleaseV3";

+## 2.4.0
+
+<Release type="tools" version="2.4.0" />
+
+## 2.3.3
+
+<Release type="tools" version="2.3.3" />
+
 ## 2.3.2

 <Release type="tools" version="2.3.2" />
--- a/include/client/taos.h
+++ b/include/client/taos.h
@ -161,6 +161,8 @@ DLL_EXPORT int        taos_stmt_set_tags(TAOS_STMT *stmt, TAOS_MULTI_BIND *tags)
 DLL_EXPORT int        taos_stmt_set_sub_tbname(TAOS_STMT *stmt, const char *name);
 DLL_EXPORT int        taos_stmt_get_tag_fields(TAOS_STMT *stmt, int *fieldNum, TAOS_FIELD_E **fields);
 DLL_EXPORT int        taos_stmt_get_col_fields(TAOS_STMT *stmt, int *fieldNum, TAOS_FIELD_E **fields);
+// let stmt to reclaim TAOS_FIELD_E that was allocated by `taos_stmt_get_tag_fields`/`taos_stmt_get_col_fields`
+DLL_EXPORT void       taos_stmt_reclaim_fields(TAOS_STMT *stmt, TAOS_FIELD_E *fields);

 DLL_EXPORT int       taos_stmt_is_insert(TAOS_STMT *stmt, int *insert);
 DLL_EXPORT int       taos_stmt_num_params(TAOS_STMT *stmt, int *nums);
@ -218,6 +220,7 @@ DLL_EXPORT const void *taos_get_raw_block(TAOS_RES *res);

 DLL_EXPORT int taos_get_db_route_info(TAOS *taos, const char *db, TAOS_DB_ROUTE_INFO *dbInfo);
 DLL_EXPORT int taos_get_table_vgId(TAOS *taos, const char *db, const char *table, int *vgId);
+DLL_EXPORT int taos_get_tables_vgId(TAOS *taos, const char *db, const char *table[], int tableNum, int *vgId);

 DLL_EXPORT int taos_load_table_info(TAOS *taos, const char *tableNameList);

--- a/include/common/taosdef.h
+++ b/include/common/taosdef.h
@ -30,6 +30,11 @@ typedef int64_t tb_uid_t;
 #define IS_TSWINDOW_SPECIFIED(win) (((win).skey != INT64_MIN) || ((win).ekey != INT64_MAX))
 #define TSWINDOW_IS_EQUAL(t1, t2)  (((t1).skey == (t2).skey) && ((t1).ekey == (t2).ekey))

+//define show cluster alive and show db.alive
+#define SHOW_STATUS_NOT_AVAILABLE  0
+#define SHOW_STATUS_AVAILABLE      1
+#define SHOW_STATUS_HALF_AVAILABLE 2
+
 typedef enum {
  TSDB_SUPER_TABLE = 1,   // super table
  TSDB_CHILD_TABLE = 2,   // table created from super table
--- a/include/common/tcommon.h
+++ b/include/common/tcommon.h
@ -195,7 +195,7 @@ typedef struct SDataBlockInfo {
  uint32_t    capacity;
  SBlockID    id;
  int16_t     hasVarCol;
-  int16_t     dataLoad;   // denote if the data is loaded or not
+  int16_t     dataLoad;  // denote if the data is loaded or not

  // TODO: optimize and remove following
  int64_t     version;    // used for stream, and need serialization
@ -204,8 +204,9 @@ typedef struct SDataBlockInfo {
  STimeWindow calWin;     // used for stream, do not serialize
  TSKEY       watermark;  // used for stream

-  char        parTbName[TSDB_TABLE_NAME_LEN];  // used for stream partition
-  STag*       pTag;                            // used for stream partition
+  char    parTbName[TSDB_TABLE_NAME_LEN];  // used for stream partition
+  int32_t tagLen;
+  void*   pTag;  // used for stream partition
 } SDataBlockInfo;

 typedef struct SSDataBlock {
@ -239,22 +240,22 @@ typedef struct SVarColAttr {
 // pBlockAgg->numOfNull == info.rows, all data are null
 // pBlockAgg->numOfNull == 0, no data are null.
 typedef struct SColumnInfoData {
-  char*         pData;       // the corresponding block data in memory
+  char* pData;  // the corresponding block data in memory
  union {
    char*       nullbitmap;  // bitmap, one bit for each item in the list
    SVarColAttr varmeta;
  };
-  SColumnInfo   info;        // column info
-  bool          hasNull;     // if current column data has null value.
+  SColumnInfo info;     // column info
+  bool        hasNull;  // if current column data has null value.
 } SColumnInfoData;

 typedef struct SQueryTableDataCond {
  uint64_t     suid;
-  int32_t      order;    // desc|asc order to iterate the data block
+  int32_t      order;  // desc|asc order to iterate the data block
  int32_t      numOfCols;
  SColumnInfo* colList;
-  int32_t*     pSlotList; // the column output destation slot, and it may be null
-  int32_t      type;     // data block load type:
+  int32_t*     pSlotList;  // the column output destation slot, and it may be null
+  int32_t      type;       // data block load type:
  STimeWindow  twindows;
  int64_t      startVersion;
  int64_t      endVersion;
@ -291,6 +292,7 @@ typedef struct STableBlockDistInfo {
  uint16_t numOfFiles;
  uint32_t numOfTables;
  uint32_t numOfBlocks;
+  uint32_t numOfVgroups;
  uint64_t totalSize;
  uint64_t totalRows;
  int32_t  maxRows;
@ -340,7 +342,7 @@ typedef struct SExprInfo {

 typedef struct {
  const char* key;
-  int32_t     keyLen;
+  size_t     keyLen;
  uint8_t     type;
  union {
    const char* value;
@ -349,7 +351,7 @@ typedef struct {
    double      d;
    float       f;
  };
-  int32_t length;
+  size_t length;
 } SSmlKv;

 #define QUERY_ASC_FORWARD_STEP  1
--- a/include/common/tdatablock.h
+++ b/include/common/tdatablock.h
@ -265,7 +265,7 @@ void blockDebugShowDataBlocks(const SArray* dataBlocks, const char* flag);
 // for debug
 char* dumpBlockData(SSDataBlock* pDataBlock, const char* flag, char** dumpBuf);

-int32_t buildSubmitReqFromDataBlock(SSubmitReq** pReq, const SSDataBlock* pDataBlocks, STSchema* pTSchema, int32_t vgId,
+int32_t buildSubmitReqFromDataBlock(SSubmitReq2** pReq, const SSDataBlock* pDataBlocks, const STSchema* pTSchema, int64_t uid, int32_t vgId,
                                    tb_uid_t suid);

 char* buildCtbNameByGroupId(const char* stbName, uint64_t groupId);
--- a/include/common/tdataformat.h
+++ b/include/common/tdataformat.h
@ -44,18 +44,38 @@ typedef struct SColData SColData;
 #define HAS_VALUE ((uint8_t)0x4)

 // bitmap ================================
-const static uint8_t BIT2_MAP[4][4] = {{0b00000000, 0b00000001, 0b00000010, 0},
-                                       {0b00000000, 0b00000100, 0b00001000, 2},
-                                       {0b00000000, 0b00010000, 0b00100000, 4},
-                                       {0b00000000, 0b01000000, 0b10000000, 6}};
+const static uint8_t BIT1_MAP[8] = {0b11111110, 0b11111101, 0b11111011, 0b11110111,
+                                    0b11101111, 0b11011111, 0b10111111, 0b01111111};

-#define N1(n)             ((((uint8_t)1) << (n)) - 1)
-#define BIT1_SIZE(n)      ((((n)-1) >> 3) + 1)
-#define BIT2_SIZE(n)      ((((n)-1) >> 2) + 1)
-#define SET_BIT1(p, i, v) ((p)[(i) >> 3] = (p)[(i) >> 3] & N1((i)&7) | (((uint8_t)(v)) << ((i)&7)))
-#define GET_BIT1(p, i)    (((p)[(i) >> 3] >> ((i)&7)) & ((uint8_t)1))
-#define SET_BIT2(p, i, v) ((p)[(i) >> 2] = (p)[(i) >> 2] & N1(BIT2_MAP[(i)&3][3]) | BIT2_MAP[(i)&3][(v)])
-#define GET_BIT2(p, i)    (((p)[(i) >> 2] >> BIT2_MAP[(i)&3][3]) & ((uint8_t)3))
+const static uint8_t BIT2_MAP[4] = {0b11111100, 0b11110011, 0b11001111, 0b00111111};
+
+#define ONE               ((uint8_t)1)
+#define THREE             ((uint8_t)3)
+#define DIV_8(i)          ((i) >> 3)
+#define MOD_8(i)          ((i)&7)
+#define DIV_4(i)          ((i) >> 2)
+#define MOD_4(i)          ((i)&3)
+#define MOD_4_TIME_2(i)   (MOD_4(i) << 1)
+#define BIT1_SIZE(n)      (DIV_8((n)-1) + 1)
+#define BIT2_SIZE(n)      (DIV_4((n)-1) + 1)
+#define SET_BIT1(p, i, v) ((p)[DIV_8(i)] = (p)[DIV_8(i)] & BIT1_MAP[MOD_8(i)] | ((v) << MOD_8(i)))
+#define SET_BIT1_EX(p, i, v) \
+  do {                       \
+    if (MOD_8(i) == 0) {     \
+      (p)[DIV_8(i)] = 0;     \
+    }                        \
+    SET_BIT1(p, i, v);       \
+  } while (0)
+#define GET_BIT1(p, i)    (((p)[DIV_8(i)] >> MOD_8(i)) & ONE)
+#define SET_BIT2(p, i, v) ((p)[DIV_4(i)] = (p)[DIV_4(i)] & BIT2_MAP[MOD_4(i)] | ((v) << MOD_4_TIME_2(i)))
+#define SET_BIT2_EX(p, i, v) \
+  do {                       \
+    if (MOD_4(i) == 0) {     \
+      (p)[DIV_4(i)] = 0;     \
+    }                        \
+    SET_BIT2(p, i, v);       \
+  } while (0)
+#define GET_BIT2(p, i) (((p)[DIV_4(i)] >> MOD_4_TIME_2(i)) & THREE)

 // SBuffer ================================
 struct SBuffer {
@ -70,9 +90,6 @@ int32_t tBufferInit(SBuffer *pBuffer, int64_t size);
 int32_t tBufferPut(SBuffer *pBuffer, const void *pData, int64_t nData);
 int32_t tBufferReserve(SBuffer *pBuffer, int64_t nData, void **ppData);

-// STSchema ================================
-void tDestroyTSchema(STSchema *pTSchema);
-
 // SColVal ================================
 #define CV_FLAG_VALUE ((int8_t)0x0)
 #define CV_FLAG_NONE  ((int8_t)0x1)
@ -87,8 +104,12 @@ void tDestroyTSchema(STSchema *pTSchema);
 #define COL_VAL_IS_VALUE(CV) ((CV)->flag == CV_FLAG_VALUE)

 // SRow ================================
-int32_t tRowBuild(SArray *aColVal, STSchema *pTSchema, SBuffer *pBuffer);
+int32_t tRowBuild(SArray *aColVal, const STSchema *pTSchema, SRow **ppRow);
 void    tRowGet(SRow *pRow, STSchema *pTSchema, int32_t iCol, SColVal *pColVal);
+void    tRowDestroy(SRow *pRow);
+void    tRowSort(SArray *aRowP);
+int32_t tRowMerge(SArray *aRowP, STSchema *pTSchema, int8_t flag);
+int32_t tRowAppendToColData(SRow *pRow, STSchema *pTSchema, SColData *aColData, int32_t nColData);

 // SRowIter ================================
 int32_t  tRowIterOpen(SRow *pRow, STSchema *pTSchema, SRowIter **ppIter);
@ -110,15 +131,28 @@ void    debugPrintSTag(STag *pTag, const char *tag, int32_t ln);  // TODO: remov
 int32_t parseJsontoTagData(const char *json, SArray *pTagVals, STag **ppTag, void *pMsgBuf);

 // SColData ================================
+typedef void *(*xMallocFn)(void *, int32_t);
 void    tColDataDestroy(void *ph);
 void    tColDataInit(SColData *pColData, int16_t cid, int8_t type, int8_t smaOn);
 void    tColDataClear(SColData *pColData);
+void    tColDataDeepClear(SColData *pColData);
 int32_t tColDataAppendValue(SColData *pColData, SColVal *pColVal);
 void    tColDataGetValue(SColData *pColData, int32_t iVal, SColVal *pColVal);
 uint8_t tColDataGetBitValue(const SColData *pColData, int32_t iVal);
-int32_t tColDataCopy(SColData *pColDataSrc, SColData *pColDataDest);
+int32_t tColDataCopy(SColData *pColDataFrom, SColData *pColData, xMallocFn xMalloc, void *arg);
 extern void (*tColDataCalcSMA[])(SColData *pColData, int64_t *sum, int64_t *max, int64_t *min, int16_t *numOfNull);

+// for stmt bind
+int32_t tColDataAddValueByBind(SColData *pColData, TAOS_MULTI_BIND *pBind);
+void    tColDataSortMerge(SArray *colDataArr);
+
+//for raw block
+int32_t tColDataAddValueByDataBlock(SColData *pColData, int8_t type, int32_t bytes,
+                                    int32_t nRows, char* lengthOrbitmap, char *data);
+// for encode/decode
+int32_t tPutColData(uint8_t *pBuf, SColData *pColData);
+int32_t tGetColData(uint8_t *pBuf, SColData *pColData);
+
 // STRUCT ================================
 struct STColumn {
  col_id_t colId;
@ -225,23 +259,9 @@ struct STag {
    memcpy(varDataVal(x), (str), (_size));      \
  } while (0);

-// ----------------- SCHEMA BUILDER DEFINITION
-typedef struct {
-  int32_t      tCols;
-  int32_t      nCols;
-  schema_ver_t version;
-  uint16_t     flen;
-  int32_t      tlen;
-  STColumn    *columns;
-} STSchemaBuilder;
-
-int32_t   tdInitTSchemaBuilder(STSchemaBuilder *pBuilder, schema_ver_t version);
-void      tdDestroyTSchemaBuilder(STSchemaBuilder *pBuilder);
-void      tdResetTSchemaBuilder(STSchemaBuilder *pBuilder, schema_ver_t version);
-int32_t   tdAddColToSchema(STSchemaBuilder *pBuilder, int8_t type, int8_t flags, col_id_t colId, col_bytes_t bytes);
-STSchema *tdGetSchemaFromBuilder(STSchemaBuilder *pBuilder);
-
+// STSchema ================================
 STSchema *tBuildTSchema(SSchema *aSchema, int32_t numOfCols, int32_t version);
+void      tDestroyTSchema(STSchema *pTSchema);

 #endif

--- a/include/common/tglobal.h
+++ b/include/common/tglobal.h
@ -55,7 +55,7 @@ extern int32_t tsNumOfMnodeQueryThreads;
 extern int32_t tsNumOfMnodeFetchThreads;
 extern int32_t tsNumOfMnodeReadThreads;
 extern int32_t tsNumOfVnodeQueryThreads;
-extern int32_t tsNumOfVnodeStreamThreads;
+extern float   tsRatioOfVnodeStreamThreads;
 extern int32_t tsNumOfVnodeFetchThreads;
 extern int32_t tsNumOfVnodeRsmaThreads;
 extern int32_t tsNumOfQnodeQueryThreads;
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@ -482,8 +482,6 @@ static FORCE_INLINE int32_t tDecodeSSchemaWrapperEx(SDecoder* pDecoder, SSchemaW
  return 0;
 }

-STSchema* tdGetSTSChemaFromSSChema(SSchema* pSchema, int32_t nCols, int32_t sver);
-
 typedef struct {
  char     name[TSDB_TABLE_FNAME_LEN];
  int8_t   igExists;
@ -1734,6 +1732,8 @@ typedef struct {
  int32_t  execId;
 } STaskDropReq;

+int32_t tSerializeSTaskDropReq(void* buf, int32_t bufLen, STaskDropReq* pReq);
+int32_t tDeserializeSTaskDropReq(void* buf, int32_t bufLen, STaskDropReq* pReq);
 int32_t tSerializeSTaskDropReq(void* buf, int32_t bufLen, STaskDropReq* pReq);
 int32_t tDeserializeSTaskDropReq(void* buf, int32_t bufLen, STaskDropReq* pReq);

@ -1751,6 +1751,8 @@ typedef struct {
 #define STREAM_FILL_HISTORY_ON        1
 #define STREAM_FILL_HISTORY_OFF       0
 #define STREAM_DEFAULT_FILL_HISTORY   STREAM_FILL_HISTORY_OFF
+#define STREAM_CREATE_STABLE_TRUE     1
+#define STREAM_CREATE_STABLE_FALSE    0

 typedef struct {
  char    name[TSDB_STREAM_FNAME_LEN];
@ -1768,6 +1770,8 @@ typedef struct {
  SArray* pTags;  // array of SField
  // 3.0.20
  int64_t checkpointFreq;  // ms
+  // 3.0.2.3
+  int8_t createStb;
 } SCMCreateStreamReq;

 typedef struct {
@ -2081,10 +2085,15 @@ typedef struct SVCreateTbReq {
  };
 } SVCreateTbReq;

-int tEncodeSVCreateTbReq(SEncoder* pCoder, const SVCreateTbReq* pReq);
-int tDecodeSVCreateTbReq(SDecoder* pCoder, SVCreateTbReq* pReq);
+int  tEncodeSVCreateTbReq(SEncoder* pCoder, const SVCreateTbReq* pReq);
+int  tDecodeSVCreateTbReq(SDecoder* pCoder, SVCreateTbReq* pReq);
+void tDestroySVCreateTbReq(SVCreateTbReq* pReq, int32_t flags);

 static FORCE_INLINE void tdDestroySVCreateTbReq(SVCreateTbReq* req) {
+  if (NULL == req) {
+    return;
+  }
+
  taosMemoryFreeClear(req->name);
  taosMemoryFreeClear(req->comment);
  if (req->type == TSDB_CHILD_TABLE) {
@ -3232,6 +3241,57 @@ int32_t tSerializeSMqAskEpReq(void* buf, int32_t bufLen, SMqAskEpReq* pReq);
 int32_t tDeserializeSMqAskEpReq(void* buf, int32_t bufLen, SMqAskEpReq* pReq);
 int32_t tSerializeSMqHbReq(void* buf, int32_t bufLen, SMqHbReq* pReq);
 int32_t tDeserializeSMqHbReq(void* buf, int32_t bufLen, SMqHbReq* pReq);
+int32_t tSerializeSMqAskEpReq(void* buf, int32_t bufLen, SMqAskEpReq* pReq);
+int32_t tDeserializeSMqAskEpReq(void* buf, int32_t bufLen, SMqAskEpReq* pReq);
+int32_t tSerializeSMqHbReq(void* buf, int32_t bufLen, SMqHbReq* pReq);
+int32_t tDeserializeSMqHbReq(void* buf, int32_t bufLen, SMqHbReq* pReq);
+
+#define SUBMIT_REQ_AUTO_CREATE_TABLE  0x1
+#define SUBMIT_REQ_COLUMN_DATA_FORMAT 0x2
+
+typedef struct {
+  int32_t        flags;
+  SVCreateTbReq* pCreateTbReq;
+  int64_t        suid;
+  int64_t        uid;
+  int32_t        sver;
+  union {
+    SArray* aRowP;
+    SArray* aCol;
+  };
+} SSubmitTbData;
+
+typedef struct {
+  SArray* aSubmitTbData;  // SArray<SSubmitTbData>
+} SSubmitReq2;
+
+int32_t tEncodeSSubmitReq2(SEncoder* pCoder, const SSubmitReq2* pReq);
+int32_t tDecodeSSubmitReq2(SDecoder* pCoder, SSubmitReq2* pReq);
+void    tDestroySSubmitTbData(SSubmitTbData* pTbData, int32_t flag);
+void    tDestroySSubmitReq2(SSubmitReq2* pReq, int32_t flag);
+
+typedef struct {
+  int32_t affectedRows;
+  SArray* aCreateTbRsp;  // SArray<SVCreateTbRsp>
+} SSubmitRsp2;
+
+int32_t tEncodeSSubmitRsp2(SEncoder* pCoder, const SSubmitRsp2* pRsp);
+int32_t tDecodeSSubmitRsp2(SDecoder* pCoder, SSubmitRsp2* pRsp);
+void    tDestroySSubmitRsp2(SSubmitRsp2* pRsp, int32_t flag);
+
+#define TSDB_MSG_FLG_ENCODE 0x1
+#define TSDB_MSG_FLG_DECODE 0x2
+
+typedef struct {
+  union {
+    struct {
+      void*   msgStr;
+      int32_t msgLen;
+      int64_t ver;
+    };
+    void* pDataBlock;
+  };
+} SPackedData;

 #pragma pack(pop)

--- a/include/common/tmsgcb.h
+++ b/include/common/tmsgcb.h
@ -39,6 +39,7 @@ typedef enum {
  QUEUE_MAX,
 } EQueueType;

+typedef int32_t (*UpdateDnodeInfoFp)(void* pData, int32_t* dnodeId, int64_t* clusterId, char* fqdn, uint16_t* port);
 typedef int32_t (*PutToQueueFp)(void* pMgmt, EQueueType qtype, SRpcMsg* pMsg);
 typedef int32_t (*GetQueueSizeFp)(void* pMgmt, int32_t vgId, EQueueType qtype);
 typedef int32_t (*SendReqFp)(const SEpSet* pEpSet, SRpcMsg* pMsg);
@ -48,6 +49,7 @@ typedef void (*ReleaseHandleFp)(SRpcHandleInfo* pHandle, int8_t type);
 typedef void (*ReportStartup)(const char* name, const char* desc);

 typedef struct {
+  void*                   data;
  void*                   mgmt;
  void*                   clientRpc;
  PutToQueueFp            putToQueueFp;
@ -57,6 +59,7 @@ typedef struct {
  RegisterBrokenLinkArgFp registerBrokenLinkArgFp;
  ReleaseHandleFp         releaseHandleFp;
  ReportStartup           reportStartupFp;
+  UpdateDnodeInfoFp       updateDnodeInfoFp;
 } SMsgCb;

 void    tmsgSetDefault(const SMsgCb* msgcb);
@ -67,6 +70,7 @@ void    tmsgSendRsp(SRpcMsg* pMsg);
 void    tmsgRegisterBrokenLinkArg(SRpcMsg* pMsg);
 void    tmsgReleaseHandle(SRpcHandleInfo* pHandle, int8_t type);
 void    tmsgReportStartup(const char* name, const char* desc);
+int32_t tmsgUpdateDnodeInfo(int32_t* dnodeId, int64_t* clusterId, char* fqdn, uint16_t* port);

 #ifdef __cplusplus
 }
--- a/include/common/trow.h
+++ b/include/common/trow.h
@ -20,7 +20,6 @@
 #include "talgo.h"
 #include "taosdef.h"
 #include "taoserror.h"
-#include "tbuffer.h"
 #include "tdataformat.h"
 #include "tdef.h"
 #include "ttypes.h"
--- a/include/common/ttokendef.h
+++ b/include/common/ttokendef.h
@ -175,171 +175,172 @@
 #define TK_CONSUMERS                      157
 #define TK_SUBSCRIPTIONS                  158
 #define TK_VNODES                         159
-#define TK_LIKE                           160
-#define TK_TBNAME                         161
-#define TK_QTAGS                          162
-#define TK_AS                             163
-#define TK_INDEX                          164
-#define TK_FUNCTION                       165
-#define TK_INTERVAL                       166
-#define TK_COUNT                          167
-#define TK_LAST_ROW                       168
-#define TK_TOPIC                          169
-#define TK_WITH                           170
-#define TK_META                           171
-#define TK_CONSUMER                       172
-#define TK_GROUP                          173
-#define TK_DESC                           174
-#define TK_DESCRIBE                       175
-#define TK_RESET                          176
-#define TK_QUERY                          177
-#define TK_CACHE                          178
-#define TK_EXPLAIN                        179
-#define TK_ANALYZE                        180
-#define TK_VERBOSE                        181
-#define TK_NK_BOOL                        182
-#define TK_RATIO                          183
-#define TK_NK_FLOAT                       184
-#define TK_OUTPUTTYPE                     185
-#define TK_AGGREGATE                      186
-#define TK_BUFSIZE                        187
-#define TK_STREAM                         188
-#define TK_INTO                           189
-#define TK_TRIGGER                        190
-#define TK_AT_ONCE                        191
-#define TK_WINDOW_CLOSE                   192
-#define TK_IGNORE                         193
-#define TK_EXPIRED                        194
-#define TK_FILL_HISTORY                   195
-#define TK_SUBTABLE                       196
-#define TK_KILL                           197
-#define TK_CONNECTION                     198
-#define TK_TRANSACTION                    199
-#define TK_BALANCE                        200
-#define TK_VGROUP                         201
-#define TK_MERGE                          202
-#define TK_REDISTRIBUTE                   203
-#define TK_SPLIT                          204
-#define TK_DELETE                         205
-#define TK_INSERT                         206
-#define TK_NULL                           207
-#define TK_NK_QUESTION                    208
-#define TK_NK_ARROW                       209
-#define TK_ROWTS                          210
-#define TK_QSTART                         211
-#define TK_QEND                           212
-#define TK_QDURATION                      213
-#define TK_WSTART                         214
-#define TK_WEND                           215
-#define TK_WDURATION                      216
-#define TK_IROWTS                         217
-#define TK_ISFILLED                       218
-#define TK_CAST                           219
-#define TK_NOW                            220
-#define TK_TODAY                          221
-#define TK_TIMEZONE                       222
-#define TK_CLIENT_VERSION                 223
-#define TK_SERVER_VERSION                 224
-#define TK_SERVER_STATUS                  225
-#define TK_CURRENT_USER                   226
-#define TK_CASE                           227
-#define TK_END                            228
-#define TK_WHEN                           229
-#define TK_THEN                           230
-#define TK_ELSE                           231
-#define TK_BETWEEN                        232
-#define TK_IS                             233
-#define TK_NK_LT                          234
-#define TK_NK_GT                          235
-#define TK_NK_LE                          236
-#define TK_NK_GE                          237
-#define TK_NK_NE                          238
-#define TK_MATCH                          239
-#define TK_NMATCH                         240
-#define TK_CONTAINS                       241
-#define TK_IN                             242
-#define TK_JOIN                           243
-#define TK_INNER                          244
-#define TK_SELECT                         245
-#define TK_DISTINCT                       246
-#define TK_WHERE                          247
-#define TK_PARTITION                      248
-#define TK_BY                             249
-#define TK_SESSION                        250
-#define TK_STATE_WINDOW                   251
-#define TK_EVENT_WINDOW                   252
-#define TK_START                          253
-#define TK_SLIDING                        254
-#define TK_FILL                           255
-#define TK_VALUE                          256
-#define TK_NONE                           257
-#define TK_PREV                           258
-#define TK_LINEAR                         259
-#define TK_NEXT                           260
-#define TK_HAVING                         261
-#define TK_RANGE                          262
-#define TK_EVERY                          263
-#define TK_ORDER                          264
-#define TK_SLIMIT                         265
-#define TK_SOFFSET                        266
-#define TK_LIMIT                          267
-#define TK_OFFSET                         268
-#define TK_ASC                            269
-#define TK_NULLS                          270
-#define TK_ABORT                          271
-#define TK_AFTER                          272
-#define TK_ATTACH                         273
-#define TK_BEFORE                         274
-#define TK_BEGIN                          275
-#define TK_BITAND                         276
-#define TK_BITNOT                         277
-#define TK_BITOR                          278
-#define TK_BLOCKS                         279
-#define TK_CHANGE                         280
-#define TK_COMMA                          281
-#define TK_COMPACT                        282
-#define TK_CONCAT                         283
-#define TK_CONFLICT                       284
-#define TK_COPY                           285
-#define TK_DEFERRED                       286
-#define TK_DELIMITERS                     287
-#define TK_DETACH                         288
-#define TK_DIVIDE                         289
-#define TK_DOT                            290
-#define TK_EACH                           291
-#define TK_FAIL                           292
-#define TK_FILE                           293
-#define TK_FOR                            294
-#define TK_GLOB                           295
-#define TK_ID                             296
-#define TK_IMMEDIATE                      297
-#define TK_IMPORT                         298
-#define TK_INITIALLY                      299
-#define TK_INSTEAD                        300
-#define TK_ISNULL                         301
-#define TK_KEY                            302
-#define TK_MODULES                        303
-#define TK_NK_BITNOT                      304
-#define TK_NK_SEMI                        305
-#define TK_NOTNULL                        306
-#define TK_OF                             307
-#define TK_PLUS                           308
-#define TK_PRIVILEGE                      309
-#define TK_RAISE                          310
-#define TK_REPLACE                        311
-#define TK_RESTRICT                       312
-#define TK_ROW                            313
-#define TK_SEMI                           314
-#define TK_STAR                           315
-#define TK_STATEMENT                      316
-#define TK_STRICT                         317
-#define TK_STRING                         318
-#define TK_TIMES                          319
-#define TK_UPDATE                         320
-#define TK_VALUES                         321
-#define TK_VARIABLE                       322
-#define TK_VIEW                           323
-#define TK_WAL                            324
+#define TK_ALIVE                          160
+#define TK_LIKE                           161
+#define TK_TBNAME                         162
+#define TK_QTAGS                          163
+#define TK_AS                             164
+#define TK_INDEX                          165
+#define TK_FUNCTION                       166
+#define TK_INTERVAL                       167
+#define TK_COUNT                          168
+#define TK_LAST_ROW                       169
+#define TK_TOPIC                          170
+#define TK_WITH                           171
+#define TK_META                           172
+#define TK_CONSUMER                       173
+#define TK_GROUP                          174
+#define TK_DESC                           175
+#define TK_DESCRIBE                       176
+#define TK_RESET                          177
+#define TK_QUERY                          178
+#define TK_CACHE                          179
+#define TK_EXPLAIN                        180
+#define TK_ANALYZE                        181
+#define TK_VERBOSE                        182
+#define TK_NK_BOOL                        183
+#define TK_RATIO                          184
+#define TK_NK_FLOAT                       185
+#define TK_OUTPUTTYPE                     186
+#define TK_AGGREGATE                      187
+#define TK_BUFSIZE                        188
+#define TK_STREAM                         189
+#define TK_INTO                           190
+#define TK_TRIGGER                        191
+#define TK_AT_ONCE                        192
+#define TK_WINDOW_CLOSE                   193
+#define TK_IGNORE                         194
+#define TK_EXPIRED                        195
+#define TK_FILL_HISTORY                   196
+#define TK_SUBTABLE                       197
+#define TK_KILL                           198
+#define TK_CONNECTION                     199
+#define TK_TRANSACTION                    200
+#define TK_BALANCE                        201
+#define TK_VGROUP                         202
+#define TK_MERGE                          203
+#define TK_REDISTRIBUTE                   204
+#define TK_SPLIT                          205
+#define TK_DELETE                         206
+#define TK_INSERT                         207
+#define TK_NULL                           208
+#define TK_NK_QUESTION                    209
+#define TK_NK_ARROW                       210
+#define TK_ROWTS                          211
+#define TK_QSTART                         212
+#define TK_QEND                           213
+#define TK_QDURATION                      214
+#define TK_WSTART                         215
+#define TK_WEND                           216
+#define TK_WDURATION                      217
+#define TK_IROWTS                         218
+#define TK_ISFILLED                       219
+#define TK_CAST                           220
+#define TK_NOW                            221
+#define TK_TODAY                          222
+#define TK_TIMEZONE                       223
+#define TK_CLIENT_VERSION                 224
+#define TK_SERVER_VERSION                 225
+#define TK_SERVER_STATUS                  226
+#define TK_CURRENT_USER                   227
+#define TK_CASE                           228
+#define TK_END                            229
+#define TK_WHEN                           230
+#define TK_THEN                           231
+#define TK_ELSE                           232
+#define TK_BETWEEN                        233
+#define TK_IS                             234
+#define TK_NK_LT                          235
+#define TK_NK_GT                          236
+#define TK_NK_LE                          237
+#define TK_NK_GE                          238
+#define TK_NK_NE                          239
+#define TK_MATCH                          240
+#define TK_NMATCH                         241
+#define TK_CONTAINS                       242
+#define TK_IN                             243
+#define TK_JOIN                           244
+#define TK_INNER                          245
+#define TK_SELECT                         246
+#define TK_DISTINCT                       247
+#define TK_WHERE                          248
+#define TK_PARTITION                      249
+#define TK_BY                             250
+#define TK_SESSION                        251
+#define TK_STATE_WINDOW                   252
+#define TK_EVENT_WINDOW                   253
+#define TK_START                          254
+#define TK_SLIDING                        255
+#define TK_FILL                           256
+#define TK_VALUE                          257
+#define TK_NONE                           258
+#define TK_PREV                           259
+#define TK_LINEAR                         260
+#define TK_NEXT                           261
+#define TK_HAVING                         262
+#define TK_RANGE                          263
+#define TK_EVERY                          264
+#define TK_ORDER                          265
+#define TK_SLIMIT                         266
+#define TK_SOFFSET                        267
+#define TK_LIMIT                          268
+#define TK_OFFSET                         269
+#define TK_ASC                            270
+#define TK_NULLS                          271
+#define TK_ABORT                          272
+#define TK_AFTER                          273
+#define TK_ATTACH                         274
+#define TK_BEFORE                         275
+#define TK_BEGIN                          276
+#define TK_BITAND                         277
+#define TK_BITNOT                         278
+#define TK_BITOR                          279
+#define TK_BLOCKS                         280
+#define TK_CHANGE                         281
+#define TK_COMMA                          282
+#define TK_COMPACT                        283
+#define TK_CONCAT                         284
+#define TK_CONFLICT                       285
+#define TK_COPY                           286
+#define TK_DEFERRED                       287
+#define TK_DELIMITERS                     288
+#define TK_DETACH                         289
+#define TK_DIVIDE                         290
+#define TK_DOT                            291
+#define TK_EACH                           292
+#define TK_FAIL                           293
+#define TK_FILE                           294
+#define TK_FOR                            295
+#define TK_GLOB                           296
+#define TK_ID                             297
+#define TK_IMMEDIATE                      298
+#define TK_IMPORT                         299
+#define TK_INITIALLY                      300
+#define TK_INSTEAD                        301
+#define TK_ISNULL                         302
+#define TK_KEY                            303
+#define TK_MODULES                        304
+#define TK_NK_BITNOT                      305
+#define TK_NK_SEMI                        306
+#define TK_NOTNULL                        307
+#define TK_OF                             308
+#define TK_PLUS                           309
+#define TK_PRIVILEGE                      310
+#define TK_RAISE                          311
+#define TK_REPLACE                        312
+#define TK_RESTRICT                       313
+#define TK_ROW                            314
+#define TK_SEMI                           315
+#define TK_STAR                           316
+#define TK_STATEMENT                      317
+#define TK_STRICT                         318
+#define TK_STRING                         319
+#define TK_TIMES                          320
+#define TK_UPDATE                         321
+#define TK_VALUES                         322
+#define TK_VARIABLE                       323
+#define TK_VIEW                           324
+#define TK_WAL                            325

 #define TK_NK_SPACE   600
 #define TK_NK_COMMENT 601
--- a/include/common/ttypes.h
+++ b/include/common/ttypes.h
@ -343,8 +343,8 @@ typedef struct tDataTypeDescriptor {
 extern tDataTypeDescriptor tDataTypes[TSDB_DATA_TYPE_MAX];
 bool                       isValidDataType(int32_t type);

+int32_t operateVal(void *dst, void *s1, void *s2, int32_t optr, int32_t type);
 void  assignVal(char *val, const char *src, int32_t len, int32_t type);
-void  operateVal(void *dst, void *s1, void *s2, int32_t optr, int32_t type);
 void *getDataMin(int32_t type, void* value);
 void *getDataMax(int32_t type, void* value);

--- a/include/libs/catalog/catalog.h
+++ b/include/libs/catalog/catalog.h
@ -44,6 +44,7 @@ typedef enum {
  AUTH_TYPE_READ = 1,
  AUTH_TYPE_WRITE,
  AUTH_TYPE_OTHER,
+  AUTH_TYPE_READ_OR_WRITE,
 } AUTH_TYPE;

 typedef struct SUserAuthInfo {
@ -209,6 +210,9 @@ int32_t catalogGetCachedTableMeta(SCatalog* pCtg, const SName* pTableName, STabl

 int32_t catalogGetCachedSTableMeta(SCatalog* pCtg, const SName* pTableName, STableMeta** pTableMeta);

+int32_t catalogGetTablesHashVgId(SCatalog* pCtg, SRequestConnInfo* pConn, int32_t acctId, const char* pDb, const char* pTableName[],
+                                  int32_t tableNum, int32_t *vgId);
+
 int32_t catalogGetCachedTableHashVgroup(SCatalog* pCtg, const SName* pTableName, SVgroupInfo* pVgroup, bool* exists);

 int32_t catalogGetCachedTableVgMeta(SCatalog* pCtg, const SName* pTableName,          SVgroupInfo* pVgroup, STableMeta** pTableMeta);
--- a/include/libs/command/command.h
+++ b/include/libs/command/command.h
@ -22,7 +22,7 @@

 typedef struct SExplainCtx SExplainCtx;

-int32_t qExecCommand(bool sysInfoUser, SNode *pStmt, SRetrieveTableRsp **pRsp);
+int32_t qExecCommand(int64_t* pConnId, bool sysInfoUser, SNode *pStmt, SRetrieveTableRsp **pRsp);

 int32_t qExecStaticExplain(SQueryPlan *pDag, SRetrieveTableRsp **pRsp);
 int32_t qExecExplainBegin(SQueryPlan *pDag, SExplainCtx **pCtx, int64_t startTs);
--- a/include/libs/executor/executor.h
+++ b/include/libs/executor/executor.h
@ -154,6 +154,8 @@ void qCleanExecTaskBlockBuf(qTaskInfo_t tinfo);
 */
 int32_t qAsyncKillTask(qTaskInfo_t tinfo, int32_t rspCode);

+bool qTaskIsExecuting(qTaskInfo_t qinfo);
+
 /**
 * destroy query info structure
 * @param qHandle
@ -190,7 +192,9 @@ int32_t qStreamPrepareTsdbScan(qTaskInfo_t tinfo, uint64_t uid, int64_t ts);

 int32_t qStreamPrepareScan(qTaskInfo_t tinfo, STqOffsetVal* pOffset, int8_t subType);

-int32_t qStreamScanMemData(qTaskInfo_t tinfo, const SSubmitReq* pReq);
+// int32_t qStreamScanMemData(qTaskInfo_t tinfo, const SSubmitReq* pReq, int64_t ver);
+//
+int32_t qStreamSetScanMemData(qTaskInfo_t tinfo, SPackedData submit);

 int32_t qStreamExtractOffset(qTaskInfo_t tinfo, STqOffsetVal* pOffset);

@ -213,6 +217,8 @@ 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);
+bool    qStreamRecoverScanFinished(qTaskInfo_t tinfo);
+void    qStreamCloseTsdbReader(void* task);

 #ifdef __cplusplus
 }
--- a/include/libs/function/function.h
+++ b/include/libs/function/function.h
@ -20,7 +20,6 @@
 extern "C" {
 #endif

-#include "tbuffer.h"
 #include "tcommon.h"
 #include "tvariant.h"

@ -138,7 +137,7 @@ typedef struct SqlFunctionCtx {
  char                *pOutput;     // final result output buffer, point to sdata->data
  int32_t              numOfParams;
  // input parameter, e.g., top(k, 20), the number of results of top query is kept in param
-  SFunctParam         *param;
+  SFunctParam *param;
  // corresponding output buffer for timestamp of each result, e.g., diff/csum
  SColumnInfoData     *pTsOutput;
  int32_t              offset;
@ -152,6 +151,7 @@ typedef struct SqlFunctionCtx {
  struct SSDataBlock  *pSrcBlock;
  struct SSDataBlock  *pDstBlock;  // used by indefinite rows function to set selectivity
  SSerializeDataHandle saveHandle;
+  int32_t              exprIdx;
  char                 udfName[TSDB_FUNC_NAME_LEN];
 } SqlFunctionCtx;

@ -182,9 +182,9 @@ struct SScalarParam {
  int32_t          numOfQualified;  // number of qualified elements in the final results
 };

-void    cleanupResultRowEntry(struct SResultRowEntryInfo *pCell);
-bool    isRowEntryCompleted(struct SResultRowEntryInfo *pEntry);
-bool    isRowEntryInitialized(struct SResultRowEntryInfo *pEntry);
+void cleanupResultRowEntry(struct SResultRowEntryInfo *pCell);
+bool isRowEntryCompleted(struct SResultRowEntryInfo *pEntry);
+bool isRowEntryInitialized(struct SResultRowEntryInfo *pEntry);

 typedef struct SPoint {
  int64_t key;
--- a/include/libs/nodes/cmdnodes.h
+++ b/include/libs/nodes/cmdnodes.h
@ -40,6 +40,7 @@ extern "C" {
 #define SHOW_LOCAL_VARIABLES_RESULT_FIELD1_LEN (TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE)
 #define SHOW_LOCAL_VARIABLES_RESULT_FIELD2_LEN (TSDB_CONFIG_VALUE_LEN + VARSTR_HEADER_SIZE)

+#define SHOW_ALIVE_RESULT_COLS 1
 #define PRIVILEGE_TYPE_MASK(n) (1 << n)

 #define PRIVILEGE_TYPE_ALL       PRIVILEGE_TYPE_MASK(0)
@ -171,10 +172,10 @@ typedef struct SCreateSubTableClause {
  STableOptions* pOptions;
 } SCreateSubTableClause;

-typedef struct SCreateMultiTableStmt {
+typedef struct SCreateMultiTablesStmt {
  ENodeType  type;
  SNodeList* pSubTables;
-} SCreateMultiTableStmt;
+} SCreateMultiTablesStmt;

 typedef struct SDropTableClause {
  ENodeType type;
@ -209,14 +210,14 @@ typedef struct SAlterTableStmt {

 typedef struct SCreateUserStmt {
  ENodeType type;
-  char      useName[TSDB_USER_LEN];
+  char      userName[TSDB_USER_LEN];
  char      password[TSDB_USET_PASSWORD_LEN];
  int8_t    sysinfo;
 } SCreateUserStmt;

 typedef struct SAlterUserStmt {
  ENodeType type;
-  char      useName[TSDB_USER_LEN];
+  char      userName[TSDB_USER_LEN];
  int8_t    alterType;
  char      password[TSDB_USET_PASSWORD_LEN];
  int8_t    enable;
@ -262,6 +263,11 @@ typedef struct SShowCreateDatabaseStmt {
  void*     pCfg;  // SDbCfgInfo
 } SShowCreateDatabaseStmt;

+typedef struct SShowAliveStmt {
+  ENodeType type;
+  char      dbName[TSDB_DB_NAME_LEN];
+} SShowAliveStmt;
+
 typedef struct SShowCreateTableStmt {
  ENodeType type;
  char      dbName[TSDB_DB_NAME_LEN];
@ -295,7 +301,7 @@ typedef struct SShowTableTagsStmt {
  SNodeList* pTags;
 } SShowTableTagsStmt;

-typedef enum EIndexType { INDEX_TYPE_SMA = 1, INDEX_TYPE_FULLTEXT } EIndexType;
+typedef enum EIndexType { INDEX_TYPE_SMA = 1, INDEX_TYPE_FULLTEXT, INDEX_TYPE_NORMAL } EIndexType;

 typedef struct SIndexOptions {
  ENodeType  type;
@ -401,6 +407,7 @@ typedef struct SCreateStreamStmt {
  SNode*          pQuery;
  SNodeList*      pTags;
  SNode*          pSubtable;
+  SNodeList*      pCols;
 } SCreateStreamStmt;

 typedef struct SDropStreamStmt {
--- a/include/libs/nodes/nodes.h
+++ b/include/libs/nodes/nodes.h
@ -125,7 +125,7 @@ typedef enum ENodeType {
  QUERY_NODE_TRIM_DATABASE_STMT,
  QUERY_NODE_CREATE_TABLE_STMT,
  QUERY_NODE_CREATE_SUBTABLE_CLAUSE,
-  QUERY_NODE_CREATE_MULTI_TABLE_STMT,
+  QUERY_NODE_CREATE_MULTI_TABLES_STMT,
  QUERY_NODE_DROP_TABLE_CLAUSE,
  QUERY_NODE_DROP_TABLE_STMT,
  QUERY_NODE_DROP_SUPER_TABLE_STMT,
@ -208,6 +208,8 @@ typedef enum ENodeType {
  QUERY_NODE_DELETE_STMT,
  QUERY_NODE_INSERT_STMT,
  QUERY_NODE_QUERY,
+  QUERY_NODE_SHOW_DB_ALIVE_STMT,
+  QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT,  

  // logic plan node
  QUERY_NODE_LOGIC_PLAN_SCAN = 1000,
--- a/include/libs/nodes/plannodes.h
+++ b/include/libs/nodes/plannodes.h
@ -121,6 +121,7 @@ typedef struct SAggLogicNode {
  bool       hasLast;
  bool       hasTimeLineFunc;
  bool       onlyHasKeepOrderFunc;
+  bool       hasGroupKeyOptimized;
 } SAggLogicNode;

 typedef struct SProjectLogicNode {
@ -409,6 +410,7 @@ typedef struct SAggPhysiNode {
  SNodeList* pGroupKeys;
  SNodeList* pAggFuncs;
  bool       mergeDataBlock;
+  bool       groupKeyOptimized;
 } SAggPhysiNode;

 typedef struct SDownstreamSourceNode {
--- a/include/libs/nodes/querynodes.h
+++ b/include/libs/nodes/querynodes.h
@ -51,6 +51,7 @@ typedef struct SExprNode {
  char      userAlias[TSDB_COL_NAME_LEN];
  SArray*   pAssociation;
  bool      orderAlias;
+  bool      asAlias;
 } SExprNode;

 typedef enum EColumnType {
@ -127,8 +128,7 @@ typedef struct SLogicConditionNode {
 } SLogicConditionNode;

 typedef struct SNodeListNode {
-  ENodeType  type;  // QUERY_NODE_NODE_LIST
-  SDataType  dataType;
+  SExprNode  node;  // QUERY_NODE_NODE_LIST
  SNodeList* pNodeList;
 } SNodeListNode;

@ -361,33 +361,33 @@ typedef struct SVgDataBlocks {
  void*       pData;  // SSubmitReq + SSubmitBlk + ...
 } SVgDataBlocks;

-typedef void (*FFreeDataBlockHash)(SHashObj*);
-typedef void (*FFreeDataBlockArray)(SArray*);
+typedef void (*FFreeTableBlockHash)(SHashObj*);
+typedef void (*FFreeVgourpBlockArray)(SArray*);

 typedef struct SVnodeModifyOpStmt {
-  ENodeType           nodeType;
-  ENodeType           sqlNodeType;
-  SArray*             pDataBlocks;  // data block for each vgroup, SArray<SVgDataBlocks*>.
-  uint32_t            insertType;   // insert data from [file|sql statement| bound statement]
-  const char*         pSql;         // current sql statement position
-  int32_t             totalRowsNum;
-  int32_t             totalTbNum;
-  SName               targetTableName;
-  SName               usingTableName;
-  const char*         pBoundCols;
-  struct STableMeta*  pTableMeta;
-  SHashObj*           pVgroupsHashObj;
-  SHashObj*           pTableBlockHashObj;
-  SHashObj*           pSubTableHashObj;
-  SHashObj*           pTableNameHashObj;
-  SHashObj*           pDbFNameHashObj;
-  SArray*             pVgDataBlocks;
-  SVCreateTbReq       createTblReq;
-  TdFilePtr           fp;
-  FFreeDataBlockHash  freeHashFunc;
-  FFreeDataBlockArray freeArrayFunc;
-  bool                usingTableProcessing;
-  bool                fileProcessing;
+  ENodeType             nodeType;
+  ENodeType             sqlNodeType;
+  SArray*               pDataBlocks;  // data block for each vgroup, SArray<SVgDataBlocks*>.
+  uint32_t              insertType;   // insert data from [file|sql statement| bound statement]
+  const char*           pSql;         // current sql statement position
+  int32_t               totalRowsNum;
+  int32_t               totalTbNum;
+  SName                 targetTableName;
+  SName                 usingTableName;
+  const char*           pBoundCols;
+  struct STableMeta*    pTableMeta;
+  SHashObj*             pVgroupsHashObj;
+  SHashObj*             pTableBlockHashObj;  // SHashObj<tuid, STableDataCxt*>
+  SHashObj*             pSubTableHashObj;
+  SHashObj*             pTableNameHashObj;
+  SHashObj*             pDbFNameHashObj;
+  SArray*               pVgDataBlocks;  // SArray<SVgroupDataCxt*>
+  SVCreateTbReq*        pCreateTblReq;
+  TdFilePtr             fp;
+  FFreeTableBlockHash   freeHashFunc;
+  FFreeVgourpBlockArray freeArrayFunc;
+  bool                  usingTableProcessing;
+  bool                  fileProcessing;
 } SVnodeModifyOpStmt;

 typedef struct SExplainOptions {
--- a/include/libs/parser/parser.h
+++ b/include/libs/parser/parser.h
@ -58,7 +58,6 @@ typedef struct SParseContext {
  bool             isSuperUser;
  bool             enableSysInfo;
  bool             async;
-  int8_t           schemalessType;
  const char*      svrVer;
  bool             nodeOffline;
  SArray*          pTableMetaPos;    // sql table pos => catalog data pos
@ -85,12 +84,12 @@ int32_t qSetSTableIdForRsma(SNode* pStmt, int64_t uid);
 void    qCleanupKeywordsTable();

 int32_t     qBuildStmtOutput(SQuery* pQuery, SHashObj* pVgHash, SHashObj* pBlockHash);
-int32_t     qResetStmtDataBlock(void* block, bool keepBuf);
-int32_t     qCloneStmtDataBlock(void** pDst, void* pSrc);
-void        qFreeStmtDataBlock(void* pDataBlock);
-int32_t     qRebuildStmtDataBlock(void** pDst, void* pSrc, uint64_t uid, int32_t vgId);
-void        qDestroyStmtDataBlock(void* pBlock);
-STableMeta* qGetTableMetaInDataBlock(void* pDataBlock);
+int32_t     qResetStmtDataBlock(STableDataCxt* block, bool keepBuf);
+int32_t     qCloneStmtDataBlock(STableDataCxt** pDst, STableDataCxt* pSrc, bool reset);
+int32_t     qRebuildStmtDataBlock(STableDataCxt** pDst, STableDataCxt* pSrc, uint64_t uid, uint64_t suid, int32_t vgId, bool rebuildCreateTb);
+void        qDestroyStmtDataBlock(STableDataCxt* pBlock);
+STableMeta* qGetTableMetaInDataBlock(STableDataCxt* pDataBlock);
+int32_t qCloneCurrentTbData(STableDataCxt*       pDataBlock, SSubmitTbData **pData);

 int32_t qStmtBindParams(SQuery* pQuery, TAOS_MULTI_BIND* pParams, int32_t colIdx);
 int32_t qStmtParseQuerySql(SParseContext* pCxt, SQuery* pQuery);
@ -105,11 +104,18 @@ void    destroyBoundColumnInfo(void* pBoundInfo);
 int32_t qCreateSName(SName* pName, const char* pTableName, int32_t acctId, char* dbName, char* msgBuf,
                     int32_t msgBufLen);

-void*   smlInitHandle(SQuery* pQuery);
-void    smlDestroyHandle(void* pHandle);
-int32_t smlBindData(void* handle, SArray* tags, SArray* colsSchema, SArray* cols, bool format, STableMeta* pTableMeta,
+void    qDestroyBoundColInfo(void* pInfo);
+
+SQuery* smlInitHandle();
+int32_t smlBuildRow(STableDataCxt* pTableCxt);
+int32_t smlBuildCol(STableDataCxt* pTableCxt, SSchema* schema, void *kv, int32_t index);
+STableDataCxt* smlInitTableDataCtx(SQuery* query, STableMeta* pTableMeta);
+
+int32_t smlBindData(SQuery* handle, bool dataFormat, SArray* tags, SArray* colsSchema, SArray* cols, STableMeta* pTableMeta,
                    char* tableName, const char* sTableName, int32_t sTableNameLen, int32_t ttl, char* msgBuf, int16_t msgBufLen);
-int32_t smlBuildOutput(void* handle, SHashObj* pVgHash);
+int32_t smlBuildOutput(SQuery* handle, SHashObj* pVgHash);
+
+int     rawBlockBindData(SQuery *query, STableMeta* pTableMeta, void* data, SVCreateTbReq* pCreateTb, TAOS_FIELD *fields, int numFields);

 int32_t rewriteToVnodeModifyOpStmt(SQuery* pQuery, SArray* pBufArray);
 SArray* serializeVgroupsCreateTableBatch(SHashObj* pVgroupHashmap);
--- a/include/libs/qcom/query.h
+++ b/include/libs/qcom/query.h
@ -163,6 +163,23 @@ typedef struct STargetInfo {
  int32_t     vgId;
 } STargetInfo;

+typedef struct SBoundColInfo {
+  int16_t* pColIndex;  // bound index => schema index
+  int32_t  numOfCols;
+  int32_t  numOfBound;
+} SBoundColInfo;
+
+typedef struct STableDataCxt {
+  STableMeta*    pMeta;
+  STSchema*      pSchema;
+  SBoundColInfo  boundColsInfo;
+  SArray*        pValues;
+  SSubmitTbData* pData;
+  TSKEY          lastTs;
+  bool           ordered;
+  bool           duplicateTs;
+} STableDataCxt;
+
 typedef int32_t (*__async_send_cb_fn_t)(void* param, SDataBuf* pMsg, int32_t code);
 typedef int32_t (*__async_exec_fn_t)(void* param);

@ -238,6 +255,7 @@ int32_t dataConverToStr(char* str, int type, void* buf, int32_t bufSize, int32_t
 char*   parseTagDatatoJson(void* p);
 int32_t cloneTableMeta(STableMeta* pSrc, STableMeta** pDst);
 int32_t cloneDbVgInfo(SDBVgInfo* pSrc, SDBVgInfo** pDst);
+int32_t cloneSVreateTbReq(SVCreateTbReq* pSrc, SVCreateTbReq** pDst);
 void    freeVgInfo(SDBVgInfo* vgInfo);

 extern int32_t (*queryBuildMsg[TDMT_MAX])(void* input, char** msg, int32_t msgSize, int32_t* msgLen,
@ -268,7 +286,7 @@ extern int32_t (*queryProcessMsgRsp[TDMT_MAX])(void* output, char* msg, int32_t
  ((_code) == TSDB_CODE_SYN_NOT_LEADER || (_code) == TSDB_CODE_SYN_RESTORING || (_code) == TSDB_CODE_SYN_INTERNAL_ERROR)
 #define SYNC_OTHER_LEADER_REDIRECT_ERROR(_code) ((_code) == TSDB_CODE_MNODE_NOT_FOUND)

-#define NO_RET_REDIRECT_ERROR(_code) ((_code) == TSDB_CODE_RPC_BROKEN_LINK || (_code) == TSDB_CODE_RPC_NETWORK_UNAVAIL)
+#define NO_RET_REDIRECT_ERROR(_code) ((_code) == TSDB_CODE_RPC_BROKEN_LINK || (_code) == TSDB_CODE_RPC_NETWORK_UNAVAIL || (_code) == TSDB_CODE_RPC_SOMENODE_NOT_CONNECTED)

 #define NEED_REDIRECT_ERROR(_code)                                              \
  (NO_RET_REDIRECT_ERROR(_code) || SYNC_UNKNOWN_LEADER_REDIRECT_ERROR(_code) || \
--- a/include/libs/stream/streamState.h
+++ b/include/libs/stream/streamState.h
@ -35,6 +35,7 @@ typedef struct STdbState {
  TTB*         pFillStateDb;  // todo refactor
  TTB*         pSessionStateDb;
  TTB*         pParNameDb;
+  TTB*         pParTagDb;
  TXN*         txn;
 } STdbState;

@ -108,6 +109,9 @@ int32_t streamStateCurPrev(SStreamState* pState, SStreamStateCur* pCur);
 int32_t streamStatePutParName(SStreamState* pState, int64_t groupId, const char* tbname);
 int32_t streamStateGetParName(SStreamState* pState, int64_t groupId, void** pVal);

+int32_t streamStatePutParTag(SStreamState* pState, int64_t groupId, const void* tag, int32_t tagLen);
+int32_t streamStateGetParTag(SStreamState* pState, int64_t groupId, void** tagVal, int32_t* tagLen);
+
 #if 0
 char* streamStateSessionDump(SStreamState* pState);
 #endif
--- a/include/libs/stream/tstream.h
+++ b/include/libs/stream/tstream.h
@ -103,6 +103,7 @@ typedef struct {
  int8_t type;
 } SStreamQueueItem;

+#if 0
 typedef struct {
  int8_t      type;
  int64_t     ver;
@ -116,6 +117,21 @@ typedef struct {
  SArray* dataRefs;  // SArray<int32_t*>
  SArray* reqs;      // SArray<SSubmitReq*>
 } SStreamMergedSubmit;
+#endif
+
+typedef struct {
+  int8_t      type;
+  int64_t     ver;
+  int32_t*    dataRef;
+  SPackedData submit;
+} SStreamDataSubmit2;
+
+typedef struct {
+  int8_t  type;
+  int64_t ver;
+  SArray* dataRefs;  // SArray<int32_t*>
+  SArray* submits;   // SArray<SPackedSubmit>
+} SStreamMergedSubmit2;

 typedef struct {
  int8_t type;
@ -219,11 +235,11 @@ static FORCE_INLINE void* streamQueueNextItem(SStreamQueue* queue) {
  }
 }

-SStreamDataSubmit* streamDataSubmitNew(SSubmitReq* pReq);
+SStreamDataSubmit2* streamDataSubmitNew(SPackedData submit);

-void streamDataSubmitRefDec(SStreamDataSubmit* pDataSubmit);
+void streamDataSubmitRefDec(SStreamDataSubmit2* pDataSubmit);

-SStreamDataSubmit* streamSubmitRefClone(SStreamDataSubmit* pSubmit);
+SStreamDataSubmit2* streamSubmitRefClone(SStreamDataSubmit2* pSubmit);

 typedef struct {
  char* qmsg;
@ -355,14 +371,15 @@ void         tFreeSStreamTask(SStreamTask* pTask);

 static FORCE_INLINE int32_t streamTaskInput(SStreamTask* pTask, SStreamQueueItem* pItem) {
  if (pItem->type == STREAM_INPUT__DATA_SUBMIT) {
-    SStreamDataSubmit* pSubmitClone = streamSubmitRefClone((SStreamDataSubmit*)pItem);
+    SStreamDataSubmit2* pSubmitClone = streamSubmitRefClone((SStreamDataSubmit2*)pItem);
    if (pSubmitClone == NULL) {
      qDebug("task %d %p submit enqueue failed since out of memory", pTask->taskId, pTask);
      terrno = TSDB_CODE_OUT_OF_MEMORY;
      atomic_store_8(&pTask->inputStatus, TASK_INPUT_STATUS__FAILED);
      return -1;
    }
-    qDebug("task %d %p submit enqueue %p %p %p", pTask->taskId, pTask, pItem, pSubmitClone, pSubmitClone->data);
+    qDebug("task %d %p submit enqueue %p %p %p %d %" PRId64, pTask->taskId, pTask, pItem, pSubmitClone,
+           pSubmitClone->submit.msgStr, pSubmitClone->submit.msgLen, pSubmitClone->submit.ver);
    taosWriteQitem(pTask->inputQueue->queue, pSubmitClone);
    // qStreamInput(pTask->exec.executor, pSubmitClone);
  } else if (pItem->type == STREAM_INPUT__DATA_BLOCK || pItem->type == STREAM_INPUT__DATA_RETRIEVE ||
@ -392,21 +409,6 @@ static FORCE_INLINE void streamTaskInputFail(SStreamTask* pTask) {
  atomic_store_8(&pTask->inputStatus, TASK_INPUT_STATUS__FAILED);
 }

-static FORCE_INLINE int32_t streamTaskOutput(SStreamTask* pTask, SStreamDataBlock* pBlock) {
-  if (pTask->outputType == TASK_OUTPUT__TABLE) {
-    pTask->tbSink.tbSinkFunc(pTask, pTask->tbSink.vnode, 0, pBlock->blocks);
-    taosArrayDestroyEx(pBlock->blocks, (FDelete)blockDataFreeRes);
-    taosFreeQitem(pBlock);
-  } else if (pTask->outputType == TASK_OUTPUT__SMA) {
-    pTask->smaSink.smaSink(pTask->smaSink.vnode, pTask->smaSink.smaId, pBlock->blocks);
-    taosArrayDestroyEx(pBlock->blocks, (FDelete)blockDataFreeRes);
-    taosFreeQitem(pBlock);
-  } else {
-    taosWriteQitem(pTask->outputQueue->queue, pBlock);
-  }
-  return 0;
-}
-
 typedef struct {
  SMsgHead head;
  int64_t  streamId;
@ -584,6 +586,7 @@ int32_t streamProcessRetrieveRsp(SStreamTask* pTask, SStreamRetrieveRsp* pRsp);

 int32_t streamTryExec(SStreamTask* pTask);
 int32_t streamSchedExec(SStreamTask* pTask);
+int32_t streamTaskOutput(SStreamTask* pTask, SStreamDataBlock* pBlock);

 int32_t streamScanExec(SStreamTask* pTask, int32_t batchSz);

--- a/include/libs/sync/sync.h
+++ b/include/libs/sync/sync.h
@ -78,6 +78,8 @@ typedef enum {
 } ESyncState;

 typedef struct SNodeInfo {
+  int64_t  clusterId;
+  int32_t  nodeId;
  uint16_t nodePort;
  char     nodeFqdn[TSDB_FQDN_LEN];
 } SNodeInfo;
@ -153,10 +155,10 @@ typedef struct SSyncFSM {
  void (*FpBecomeFollowerCb)(const struct SSyncFSM* pFsm);

  int32_t (*FpGetSnapshot)(const struct SSyncFSM* pFsm, SSnapshot* pSnapshot, void* pReaderParam, void** ppReader);
-  int32_t (*FpGetSnapshotInfo)(const struct SSyncFSM* pFsm, SSnapshot* pSnapshot);
+  void (*FpGetSnapshotInfo)(const struct SSyncFSM* pFsm, SSnapshot* pSnapshot);

  int32_t (*FpSnapshotStartRead)(const struct SSyncFSM* pFsm, void* pReaderParam, void** ppReader);
-  int32_t (*FpSnapshotStopRead)(const struct SSyncFSM* pFsm, void* pReader);
+  void (*FpSnapshotStopRead)(const struct SSyncFSM* pFsm, void* pReader);
  int32_t (*FpSnapshotDoRead)(const struct SSyncFSM* pFsm, void* pReader, void** ppBuf, int32_t* len);

  int32_t (*FpSnapshotStartWrite)(const struct SSyncFSM* pFsm, void* pWriterParam, void** ppWriter);
@ -230,6 +232,7 @@ int64_t syncOpen(SSyncInfo* pSyncInfo);
 int32_t syncStart(int64_t rid);
 void    syncStop(int64_t rid);
 void    syncPreStop(int64_t rid);
+void    syncPostStop(int64_t rid);
 int32_t syncPropose(int64_t rid, SRpcMsg* pMsg, bool isWeak, int64_t* seq);
 int32_t syncProcessMsg(int64_t rid, SRpcMsg* pMsg);
 int32_t syncReconfig(int64_t rid, SSyncCfg* pCfg);
--- a/include/os/os.h
+++ b/include/os/os.h
@ -116,6 +116,7 @@ extern "C" {
 #include "osTimer.h"
 #include "osTimezone.h"
 #include "taoserror.h"
+#include "tlog.h"

 #ifdef __cplusplus
 }
--- a/include/os/osMemory.h
+++ b/include/os/osMemory.h
@ -22,12 +22,16 @@ extern "C" {

 // If the error is in a third-party library, place this header file under the third-party library header file.
 // When you want to use this feature, you should find or add the same function in the following sectio
+#if !defined(WINDOWS)
+
 #ifndef ALLOW_FORBID_FUNC
 #define malloc  MALLOC_FUNC_TAOS_FORBID
 #define calloc  CALLOC_FUNC_TAOS_FORBID
 #define realloc REALLOC_FUNC_TAOS_FORBID
 #define free    FREE_FUNC_TAOS_FORBID
-#endif
+#endif // ifndef ALLOW_FORBID_FUNC
+
+#endif // if !defined(WINDOWS)

 void   *taosMemoryMalloc(int64_t size);
 void   *taosMemoryCalloc(int64_t num, int64_t size);
--- a/include/os/osSysinfo.h
+++ b/include/os/osSysinfo.h
@ -70,6 +70,7 @@ typedef struct {

 SysNameInfo taosGetSysNameInfo();
 bool        taosCheckCurrentInDll();
+int         taosGetlocalhostname(char *hostname, size_t maxLen);

 #ifdef __cplusplus
 }
--- a/include/os/osSystem.h
+++ b/include/os/osSystem.h
@ -62,11 +62,38 @@ void    taosResetTerminalMode();
    taosMemoryFree(strings);                                               \
  }
 #else
+#include <windows.h>
+#include <dbghelp.h>
+
+#define STACKSIZE 64
 #define taosPrintTrace(flags, level, dflag)                                                                \
  {                                                                                                        \
-    taosPrintLog(flags, level, dflag,                                                                      \
-                 "backtrace not implemented on windows, so detailed stack information cannot be printed"); \
-    }
+    unsigned int   i;                                                                                                 \
+    void*          stack[STACKSIZE];                                                                                  \
+    unsigned short frames;                                                                                            \
+    SYMBOL_INFO*   symbol;                                                                                            \
+    HANDLE         process;                                                                                           \
+                                                                                                                      \
+    process = GetCurrentProcess();                                                                                    \
+                                                                                                                      \
+    SymInitialize(process, NULL, TRUE);                                                                               \
+                                                                                                                      \
+    frames = CaptureStackBackTrace(0, STACKSIZE, stack, NULL);                                                        \
+    symbol = (SYMBOL_INFO*)calloc(sizeof(SYMBOL_INFO) + 256 * sizeof(char), 1);                                       \
+    if (symbol != NULL) {                                                                                             \
+        symbol->MaxNameLen = 255;                                                                                     \
+        symbol->SizeOfStruct = sizeof(SYMBOL_INFO);                                                                   \
+                                                                                                                      \
+        if (frames > 0) {                                                                                             \
+          taosPrintLog(flags, level, dflag, "obtained %d stack frames", frames);                                      \
+          for (i = 0; i < frames; i++) {                                                                              \
+            SymFromAddr(process, (DWORD64)(stack[i]), 0, symbol);                                                     \
+            taosPrintLog(flags, level, dflag, "frame:%i: %s - 0x%0X", frames - i - 1, symbol->Name, symbol->Address); \
+          }                                                                                                           \
+        }                                                                                                             \
+        free(symbol);                                                                                                 \
+    }                                                                                                                 \
+  }
 #endif

 #ifdef __cplusplus
--- a/include/util/tRealloc.h
+++ b/include/util/tRealloc.h
@ -52,11 +52,13 @@ _exit:
  return code;
 }

-static FORCE_INLINE void tFree(uint8_t *pBuf) {
-  if (pBuf) {
-    taosMemoryFree(pBuf - sizeof(int64_t));
-  }
-}
+#define tFree(BUF)                                        \
+  do {                                                    \
+    if (BUF) {                                            \
+      taosMemoryFree((uint8_t *)(BUF) - sizeof(int64_t)); \
+      (BUF) = NULL;                                       \
+    }                                                     \
+  } while (0)

 #ifdef __cplusplus
 }
--- a/include/util/taoserror.h
+++ b/include/util/taoserror.h
@ -65,6 +65,8 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_RPC_PORT_EADDRINUSE           TAOS_DEF_ERROR_CODE(0, 0x0017) //
 #define TSDB_CODE_RPC_BROKEN_LINK               TAOS_DEF_ERROR_CODE(0, 0x0018) //
 #define TSDB_CODE_RPC_TIMEOUT                   TAOS_DEF_ERROR_CODE(0, 0x0019) //
+#define TSDB_CODE_RPC_SOMENODE_NOT_CONNECTED    TAOS_DEF_ERROR_CODE(0, 0x0020) // "Vgroup could not be connected"
+#define TSDB_CODE_RPC_SOMENODE_BROKEN_LINK      TAOS_DEF_ERROR_CODE(0, 0x0021) // 

 //common & util
 #define TSDB_CODE_OPS_NOT_SUPPORT               TAOS_DEF_ERROR_CODE(0, 0x0100) //
@ -156,6 +158,8 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_TSC_QUERY_KILLED              TAOS_DEF_ERROR_CODE(0, 0X022D)
 #define TSDB_CODE_TSC_NO_EXEC_NODE              TAOS_DEF_ERROR_CODE(0, 0X022E)
 #define TSDB_CODE_TSC_NOT_STABLE_ERROR          TAOS_DEF_ERROR_CODE(0, 0X022F)
+#define TSDB_CODE_TSC_STMT_CACHE_ERROR          TAOS_DEF_ERROR_CODE(0, 0X0230)
+#define TSDB_CODE_TSC_INTERNAL_ERROR            TAOS_DEF_ERROR_CODE(0, 0X0231)

 // mnode-common
 // #define TSDB_CODE_MND_MSG_NOT_PROCESSED      TAOS_DEF_ERROR_CODE(0, 0x0300) // 2.x
@ -203,9 +207,15 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_MND_CANT_DROP_LEADER          TAOS_DEF_ERROR_CODE(0, 0x0333)
 #define TSDB_CODE_MND_NO_ENOUGH_DNODES          TAOS_DEF_ERROR_CODE(0, 0x0334)
 #define TSDB_CODE_MND_INVALID_CLUSTER_CFG       TAOS_DEF_ERROR_CODE(0, 0x0335)
+// #define TSDB_CODE_MND_INVALID_DNODE_CFG_...  TAOS_DEF_ERROR_CODE(0, 0x0336)  // 2.x
+// #define TSDB_CODE_MND_BALANCE_ENABLED        TAOS_DEF_ERROR_CODE(0, 0x0337)  // 2.x
 #define TSDB_CODE_MND_VGROUP_NOT_IN_DNODE       TAOS_DEF_ERROR_CODE(0, 0x0338)
 #define TSDB_CODE_MND_VGROUP_ALREADY_IN_DNODE   TAOS_DEF_ERROR_CODE(0, 0x0339)
+// #define TSDB_CODE_MND_DNODE_NOT_FREE         TAOS_DEF_ERROR_CODE(0, 0x033A)  // 2.x
 #define TSDB_CODE_MND_INVALID_CLUSTER_ID        TAOS_DEF_ERROR_CODE(0, 0x033B)
+// #define TSDB_CODE_MND_NOT_READY              TAOS_DEF_ERROR_CODE(0, 0x033C)  // 2.x
+// #define TSDB_CODE_MND_DNODE_ID_NOT_CONFIGUREDTAOS_DEF_ERROR_CODE(0, 0x033D)  // 2.x
+// #define TSDB_CODE_MND_DNODE_EP_NOT_CONFIGUREDTAOS_DEF_ERROR_CODE(0, 0x033E)  // 2.x

 // mnode-acct
 #define TSDB_CODE_MND_ACCT_ALREADY_EXIST        TAOS_DEF_ERROR_CODE(0, 0x0340)
@ -297,6 +307,8 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_MND_VGROUP_UN_CHANGED         TAOS_DEF_ERROR_CODE(0, 0x03B5)
 #define TSDB_CODE_MND_HAS_OFFLINE_DNODE         TAOS_DEF_ERROR_CODE(0, 0x03B6)
 #define TSDB_CODE_MND_INVALID_REPLICA           TAOS_DEF_ERROR_CODE(0, 0x03B7)
+#define TSDB_CODE_MND_DNODE_IN_CREATING         TAOS_DEF_ERROR_CODE(0, 0x03B8)
+#define TSDB_CODE_MND_DNODE_IN_DROPPING         TAOS_DEF_ERROR_CODE(0, 0x03B9)

 // mnode-stable-part2
 #define TSDB_CODE_MND_NAME_CONFLICT_WITH_TOPIC  TAOS_DEF_ERROR_CODE(0, 0x03C0)
@ -317,6 +329,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_MND_TRANS_CLOG_IS_NULL        TAOS_DEF_ERROR_CODE(0, 0x03D4)
 #define TSDB_CODE_MND_TRANS_NETWORK_UNAVAILL    TAOS_DEF_ERROR_CODE(0, 0x03D5)
 #define TSDB_CODE_MND_LAST_TRANS_NOT_FINISHED   TAOS_DEF_ERROR_CODE(0, 0x03D6) //internal
+#define TSDB_CODE_MND_TRNAS_SYNC_TIMEOUT        TAOS_DEF_ERROR_CODE(0, 0x03D7)
 #define TSDB_CODE_MND_TRANS_UNKNOW_ERROR        TAOS_DEF_ERROR_CODE(0, 0x03DF)

 // mnode-mq
@ -334,6 +347,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_MND_TOPIC_SUBSCRIBED          TAOS_DEF_ERROR_CODE(0, 0x03EB)
 #define TSDB_CODE_MND_CGROUP_USED               TAOS_DEF_ERROR_CODE(0, 0x03EC)
 #define TSDB_CODE_MND_TOPIC_MUST_BE_DELETED     TAOS_DEF_ERROR_CODE(0, 0x03ED)
+#define TSDB_CODE_MND_INVALID_SUB_OPTION        TAOS_DEF_ERROR_CODE(0, 0x03EE)
 #define TSDB_CODE_MND_IN_REBALANCE              TAOS_DEF_ERROR_CODE(0, 0x03EF)

 // mnode-stream
@ -508,6 +522,8 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_SYN_STANDBY_NOT_READY         TAOS_DEF_ERROR_CODE(0, 0x0912)
 #define TSDB_CODE_SYN_BATCH_ERROR               TAOS_DEF_ERROR_CODE(0, 0x0913)
 #define TSDB_CODE_SYN_RESTORING                 TAOS_DEF_ERROR_CODE(0, 0x0914)
+#define TSDB_CODE_SYN_INVALID_SNAPSHOT_MSG      TAOS_DEF_ERROR_CODE(0, 0x0915)  // internal
+#define TSDB_CODE_SYN_BUFFER_FULL               TAOS_DEF_ERROR_CODE(0, 0x0916)  //
 #define TSDB_CODE_SYN_INTERNAL_ERROR            TAOS_DEF_ERROR_CODE(0, 0x09FF)

 // tq
@ -685,6 +701,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_SML_INVALID_DATA              TAOS_DEF_ERROR_CODE(0, 0x3002)
 #define TSDB_CODE_SML_INVALID_DB_CONF           TAOS_DEF_ERROR_CODE(0, 0x3003)
 #define TSDB_CODE_SML_NOT_SAME_TYPE             TAOS_DEF_ERROR_CODE(0, 0x3004)
+#define TSDB_CODE_SML_INTERNAL_ERROR            TAOS_DEF_ERROR_CODE(0, 0x3005)

 //tsma
 #define TSDB_CODE_TSMA_INIT_FAILED               TAOS_DEF_ERROR_CODE(0, 0x3100)
@ -700,7 +717,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_RSMA_INVALID_ENV               TAOS_DEF_ERROR_CODE(0, 0x3150)
 #define TSDB_CODE_RSMA_INVALID_STAT              TAOS_DEF_ERROR_CODE(0, 0x3151)
 #define TSDB_CODE_RSMA_QTASKINFO_CREATE          TAOS_DEF_ERROR_CODE(0, 0x3152)
-// #define TSDB_CODE_RSMA_FILE_CORRUPTED         TAOS_DEF_ERROR_CODE(0, 0x3153)
+#define TSDB_CODE_RSMA_FS_COMMIT                 TAOS_DEF_ERROR_CODE(0, 0x3153)
 #define TSDB_CODE_RSMA_REMOVE_EXISTS             TAOS_DEF_ERROR_CODE(0, 0x3154)
 #define TSDB_CODE_RSMA_FETCH_MSG_MSSED_UP        TAOS_DEF_ERROR_CODE(0, 0x3155)
 #define TSDB_CODE_RSMA_EMPTY_INFO                TAOS_DEF_ERROR_CODE(0, 0x3156)
@ -708,6 +725,9 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_RSMA_REGEX_MATCH               TAOS_DEF_ERROR_CODE(0, 0x3158)
 #define TSDB_CODE_RSMA_STREAM_STATE_OPEN         TAOS_DEF_ERROR_CODE(0, 0x3159)
 #define TSDB_CODE_RSMA_STREAM_STATE_COMMIT       TAOS_DEF_ERROR_CODE(0, 0x3160)
+#define TSDB_CODE_RSMA_FS_REF                    TAOS_DEF_ERROR_CODE(0, 0x3161)
+#define TSDB_CODE_RSMA_FS_SYNC                   TAOS_DEF_ERROR_CODE(0, 0x3162)
+#define TSDB_CODE_RSMA_FS_UPDATE                 TAOS_DEF_ERROR_CODE(0, 0x3163)

 //index
 #define TSDB_CODE_INDEX_REBUILDING               TAOS_DEF_ERROR_CODE(0, 0x3200)
--- a/include/util/tarray.h
+++ b/include/util/tarray.h
@ -22,19 +22,6 @@
 extern "C" {
 #endif

-#if 0
-#define TARRAY(TYPE)             \
-  struct {                       \
-    int32_t      tarray_size_;   \
-    int32_t      tarray_neles_;  \
-    struct TYPE* td_array_data_; \
-  }
-
-#define TARRAY_SIZE(ARRAY)        (ARRAY)->tarray_size_
-#define TARRAY_NELES(ARRAY)       (ARRAY)->tarray_neles_
-#define TARRAY_ELE_AT(ARRAY, IDX) ((ARRAY)->td_array_data_ + idx)
-#endif
-
 #define TARRAY_MIN_SIZE               8
 #define TARRAY_GET_ELEM(array, index) ((void*)((char*)((array)->pData) + (index) * (array)->elemSize))
 #define TARRAY_ELEM_IDX(array, ele)   (POINTER_DISTANCE(ele, (array)->pData) / (array)->elemSize)
@ -46,6 +33,9 @@ typedef struct SArray {
  void*    pData;
 } SArray;

+#define TARRAY_SIZE(array) ((array)->size)
+#define TARRAY_DATA(array) ((array)->pData)
+
 /**
 *
 * @param size
@ -194,6 +184,13 @@ void taosArrayPopTailBatch(SArray* pArray, size_t cnt);
 */
 void taosArrayRemove(SArray* pArray, size_t index);

+/**
+ * remove batch entry from the given index
+ * @param pArray
+ * @param index
+ */
+void taosArrayRemoveBatch(SArray* pArray, size_t index, size_t num, FDelete fp);
+
 /**
 * copy the whole array from source to destination
 * @param pDst
--- a/include/util/tbuffer.h
+++ b/include/util/tbuffer.h
@ -1,168 +0,0 @@
-/*
- * Copyright (c) 2020 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_BUFFER_H_
-#define _TD_UTIL_BUFFER_H_
-
-#include "os.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// usage example
-/*
-#include <stdio.h>
-#include "texception.h"
-
-int32_t main( int32_t argc, char** argv ) {
-  SBufferWriter bw = tbufInitWriter( NULL, false );
-
-  TRY( 1 ) {
-    //--------------------- write ------------------------
-    // reserve 1024 bytes for the buffer to improve performance
-    tbufEnsureCapacity( &bw, 1024 );
-
-    // reserve space for the interger count
-    size_t pos = tbufReserve( &bw, sizeof(int32_t) );
-    // write 5 integers to the buffer
-    for( int32_t i = 0; i < 5; i++) {
-      tbufWriteInt32( &bw, i );
-    }
-    // write the integer count to buffer at reserved position
-    tbufWriteInt32At( &bw, pos, 5 );
-
-    // write a string to the buffer
-    tbufWriteString( &bw, "this is a string.\n" );
-    // acquire the result and close the write buffer
-    size_t size = tbufTell( &bw );
-    char*  data = tbufGetData( &bw, false );
-
-    //------------------------ read -----------------------
-    SBufferReader br = tbufInitReader( data, size, false );
-    // read & print out all integers
-    int32_t count = tbufReadInt32( &br );
-    for( int32_t i = 0; i < count; i++ ) {
-      printf( "%d\n", tbufReadInt32(&br) );
-    }
-    // read & print out a string
-    puts( tbufReadString(&br, NULL) );
-    // try read another integer, this result in an error as there no this integer
-    tbufReadInt32( &br );
-    printf( "you should not see this message.\n" );
-  } CATCH( code ) {
-    printf( "exception code is: %d, you will see this message after print out 5 integers and a string.\n", code );
-  } END_TRY
-
-  tbufCloseWriter( &bw );
-  return 0;
-}
-*/
-
-typedef struct SBufferReader {
-  bool        endian;
-  const char* data;
-  size_t      pos;
-  size_t      size;
-} SBufferReader;
-
-typedef struct SBufferWriter {
-  bool   endian;
-  char*  data;
-  size_t pos;
-  size_t size;
-  void* (*allocator)(void*, size_t);
-} SBufferWriter;
-
-// common functions & macros for both reader & writer
-
-#define tbufTell(buf) ((buf)->pos)
-
-/* ------------------------ BUFFER WRITER FUNCTIONS AND MACROS ------------------------ */
-// *Allocator*, function to allocate memory, will use 'realloc' if NULL
-// *Endian*, if true, writer functions of primitive types will do 'hton' automatically
-#define tbufInitWriter(Allocator, Endian) \
-  { .endian = (Endian), .data = NULL, .pos = 0, .size = 0, .allocator = ((Allocator) == NULL ? realloc : (Allocator)) }
-
-void   tbufCloseWriter(SBufferWriter* buf);
-void   tbufEnsureCapacity(SBufferWriter* buf, size_t size);
-size_t tbufReserve(SBufferWriter* buf, size_t size);
-char*  tbufGetData(SBufferWriter* buf, bool takeOver);
-void   tbufWrite(SBufferWriter* buf, const void* data, size_t size);
-void   tbufWriteAt(SBufferWriter* buf, size_t pos, const void* data, size_t size);
-void   tbufWriteStringLen(SBufferWriter* buf, const char* str, size_t len);
-void   tbufWriteString(SBufferWriter* buf, const char* str);
-// the prototype of tbufWriteBinary and tbufWrite are identical
-// the difference is: tbufWriteBinary writes the length of the data to the buffer
-// first, then the actual data, which means the reader don't need to know data
-// size before read. Write only write the data itself, which means the reader
-// need to know data size before read.
-void tbufWriteBinary(SBufferWriter* buf, const void* data, size_t len);
-void tbufWriteBool(SBufferWriter* buf, bool data);
-void tbufWriteBoolAt(SBufferWriter* buf, size_t pos, bool data);
-void tbufWriteChar(SBufferWriter* buf, char data);
-void tbufWriteCharAt(SBufferWriter* buf, size_t pos, char data);
-void tbufWriteInt8(SBufferWriter* buf, int8_t data);
-void tbufWriteInt8At(SBufferWriter* buf, size_t pos, int8_t data);
-void tbufWriteUint8(SBufferWriter* buf, uint8_t data);
-void tbufWriteUint8At(SBufferWriter* buf, size_t pos, uint8_t data);
-void tbufWriteInt16(SBufferWriter* buf, int16_t data);
-void tbufWriteInt16At(SBufferWriter* buf, size_t pos, int16_t data);
-void tbufWriteUint16(SBufferWriter* buf, uint16_t data);
-void tbufWriteUint16At(SBufferWriter* buf, size_t pos, uint16_t data);
-void tbufWriteInt32(SBufferWriter* buf, int32_t data);
-void tbufWriteInt32At(SBufferWriter* buf, size_t pos, int32_t data);
-void tbufWriteUint32(SBufferWriter* buf, uint32_t data);
-void tbufWriteUint32At(SBufferWriter* buf, size_t pos, uint32_t data);
-void tbufWriteInt64(SBufferWriter* buf, int64_t data);
-void tbufWriteInt64At(SBufferWriter* buf, size_t pos, int64_t data);
-void tbufWriteUint64(SBufferWriter* buf, uint64_t data);
-void tbufWriteUint64At(SBufferWriter* buf, size_t pos, uint64_t data);
-void tbufWriteFloat(SBufferWriter* buf, float data);
-void tbufWriteFloatAt(SBufferWriter* buf, size_t pos, float data);
-void tbufWriteDouble(SBufferWriter* buf, double data);
-void tbufWriteDoubleAt(SBufferWriter* buf, size_t pos, double data);
-
-/* ------------------------ BUFFER READER FUNCTIONS AND MACROS ------------------------ */
-// *Endian*, if true, reader functions of primitive types will do 'ntoh' automatically
-#define tbufInitReader(Data, Size, Endian) \
-  { .endian = (Endian), .data = (Data), .pos = 0, .size = ((Data) == NULL ? 0 : (Size)) }
-
-size_t      tbufSkip(SBufferReader* buf, size_t size);
-const char* tbufRead(SBufferReader* buf, size_t size);
-void        tbufReadToBuffer(SBufferReader* buf, void* dst, size_t size);
-const char* tbufReadString(SBufferReader* buf, size_t* len);
-size_t      tbufReadToString(SBufferReader* buf, char* dst, size_t size);
-const char* tbufReadBinary(SBufferReader* buf, size_t* len);
-size_t      tbufReadToBinary(SBufferReader* buf, void* dst, size_t size);
-bool        tbufReadBool(SBufferReader* buf);
-char        tbufReadChar(SBufferReader* buf);
-int8_t      tbufReadInt8(SBufferReader* buf);
-uint8_t     tbufReadUint8(SBufferReader* buf);
-int16_t     tbufReadInt16(SBufferReader* buf);
-uint16_t    tbufReadUint16(SBufferReader* buf);
-int32_t     tbufReadInt32(SBufferReader* buf);
-uint32_t    tbufReadUint32(SBufferReader* buf);
-int64_t     tbufReadInt64(SBufferReader* buf);
-uint64_t    tbufReadUint64(SBufferReader* buf);
-float       tbufReadFloat(SBufferReader* buf);
-double      tbufReadDouble(SBufferReader* buf);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_UTIL_BUFFER_H_*/
--- a/include/util/tcompare.h
+++ b/include/util/tcompare.h
@ -36,17 +36,18 @@ extern "C" {
 #define FLT_GREATEREQUAL(_x, _y) (FLT_EQUAL((_x), (_y)) || ((_x) > (_y)))
 #define FLT_LESSEQUAL(_x, _y)    (FLT_EQUAL((_x), (_y)) || ((_x) < (_y)))

-#define PATTERN_COMPARE_INFO_INITIALIZER \
-  { '%', '_' }
+#define PATTERN_COMPARE_INFO_INITIALIZER { '%', '_', L'%', L'_' }

 typedef struct SPatternCompareInfo {
-  char matchAll;  // symbol for match all wildcard, default: '%'
-  char matchOne;  // symbol for match one wildcard, default: '_'
+  char matchAll;       // symbol for match all wildcard, default: '%'
+  char matchOne;       // symbol for match one wildcard, default: '_'
+  TdUcs4 umatchAll;    // unicode version matchAll
+  TdUcs4 umatchOne;    // unicode version matchOne
 } SPatternCompareInfo;

-int32_t patternMatch(const char *pattern, const char *str, size_t size, const SPatternCompareInfo *pInfo);
+int32_t patternMatch(const char *pattern, size_t psize, const char *str, size_t ssize, const SPatternCompareInfo *pInfo);

-int32_t WCSPatternMatch(const TdUcs4 *pattern, const TdUcs4 *str, size_t size, const SPatternCompareInfo *pInfo);
+int32_t wcsPatternMatch(const TdUcs4 *pattern, size_t psize, const TdUcs4 *str, size_t ssize, const SPatternCompareInfo *pInfo);

 int32_t taosArrayCompareString(const void *a, const void *b);

@ -79,9 +80,11 @@ int32_t compareDoubleVal(const void *pLeft, const void *pRight);
 int32_t compareLenPrefixedStr(const void *pLeft, const void *pRight);
 int32_t compareLenPrefixedWStr(const void *pLeft, const void *pRight);

-int32_t compareStrRegexComp(const void *pLeft, const void *pRight);
-int32_t compareStrRegexCompMatch(const void *pLeft, const void *pRight);
-int32_t compareStrRegexCompNMatch(const void *pLeft, const void *pRight);
+int32_t comparestrRegexMatch(const void *pLeft, const void *pRight);
+int32_t comparestrRegexNMatch(const void *pLeft, const void *pRight);
+
+int32_t comparewcsRegexMatch(const void *pLeft, const void *pRight);
+int32_t comparewcsRegexNMatch(const void *pLeft, const void *pRight);

 int32_t compareInt8ValDesc(const void *pLeft, const void *pRight);
 int32_t compareInt16ValDesc(const void *pLeft, const void *pRight);
@ -99,11 +102,11 @@ int32_t compareUint64ValDesc(const void *pLeft, const void *pRight);
 int32_t compareLenPrefixedStrDesc(const void *pLeft, const void *pRight);
 int32_t compareLenPrefixedWStrDesc(const void *pLeft, const void *pRight);

-int32_t compareStrPatternMatch(const void *pLeft, const void *pRight);
-int32_t compareStrPatternNotMatch(const void *pLeft, const void *pRight);
+int32_t comparestrPatternMatch(const void *pLeft, const void *pRight);
+int32_t comparestrPatternNMatch(const void *pLeft, const void *pRight);

-int32_t compareWStrPatternMatch(const void *pLeft, const void *pRight);
-int32_t compareWStrPatternNotMatch(const void *pLeft, const void *pRight);
+int32_t comparewcsPatternMatch(const void *pLeft, const void *pRight);
+int32_t comparewcsPatternNMatch(const void *pLeft, const void *pRight);

 int32_t compareInt8Int16(const void *pLeft, const void *pRight);
 int32_t compareInt8Int32(const void *pLeft, const void *pRight);
--- a/include/util/tdef.h
+++ b/include/util/tdef.h
@ -189,12 +189,14 @@ typedef enum ELogicConditionType {
 #define TSDB_MAX_COLUMNS 4096
 #define TSDB_MIN_COLUMNS 2  // PRIMARY COLUMN(timestamp) + other columns

-#define TSDB_NODE_NAME_LEN  64
-#define TSDB_TABLE_NAME_LEN 193  // it is a null-terminated string
-#define TSDB_TOPIC_NAME_LEN 193  // it is a null-terminated string
-#define TSDB_CGROUP_LEN     193  // it is a null-terminated string
-#define TSDB_DB_NAME_LEN    65
-#define TSDB_DB_FNAME_LEN   (TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN + TSDB_NAME_DELIMITER_LEN)
+#define TSDB_NODE_NAME_LEN   64
+#define TSDB_TABLE_NAME_LEN  193                                // it is a null-terminated string
+#define TSDB_TOPIC_NAME_LEN  193                                // it is a null-terminated string
+#define TSDB_CGROUP_LEN      193                                // it is a null-terminated string
+#define TSDB_USER_CGROUP_LEN (TSDB_USER_LEN + TSDB_CGROUP_LEN)  // it is a null-terminated string
+#define TSDB_STREAM_NAME_LEN 193                                // it is a null-terminated string
+#define TSDB_DB_NAME_LEN     65
+#define TSDB_DB_FNAME_LEN    (TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN + TSDB_NAME_DELIMITER_LEN)

 #define TSDB_FUNC_NAME_LEN       65
 #define TSDB_FUNC_COMMENT_LEN    1024 * 1024
@ -212,8 +214,8 @@ typedef enum ELogicConditionType {
 #define TSDB_INDEX_FNAME_LEN     (TSDB_DB_FNAME_LEN + TSDB_INDEX_NAME_LEN + TSDB_NAME_DELIMITER_LEN)
 #define TSDB_TYPE_STR_MAX_LEN    32
 #define TSDB_TABLE_FNAME_LEN     (TSDB_DB_FNAME_LEN + TSDB_TABLE_NAME_LEN + TSDB_NAME_DELIMITER_LEN)
-#define TSDB_TOPIC_FNAME_LEN     (TSDB_ACCT_ID_LEN + TSDB_TABLE_NAME_LEN + TSDB_NAME_DELIMITER_LEN)
-#define TSDB_STREAM_FNAME_LEN    (TSDB_ACCT_ID_LEN + TSDB_TABLE_NAME_LEN + TSDB_NAME_DELIMITER_LEN)
+#define TSDB_TOPIC_FNAME_LEN     (TSDB_ACCT_ID_LEN + TSDB_TOPIC_NAME_LEN + TSDB_NAME_DELIMITER_LEN)
+#define TSDB_STREAM_FNAME_LEN    (TSDB_ACCT_ID_LEN + TSDB_STREAM_NAME_LEN + TSDB_NAME_DELIMITER_LEN)
 #define TSDB_SUBSCRIBE_KEY_LEN   (TSDB_CGROUP_LEN + TSDB_TOPIC_FNAME_LEN + 2)
 #define TSDB_PARTITION_KEY_LEN   (TSDB_SUBSCRIBE_KEY_LEN + 20)
 #define TSDB_COL_NAME_LEN        65
@ -254,7 +256,7 @@ typedef enum ELogicConditionType {
 #define TSDB_EP_LEN             (TSDB_FQDN_LEN + 6)
 #define TSDB_IPv4ADDR_LEN       16
 #define TSDB_FILENAME_LEN       128
-#define TSDB_SHOW_SQL_LEN       1024
+#define TSDB_SHOW_SQL_LEN       2048
 #define TSDB_SLOW_QUERY_SQL_LEN 512
 #define TSDB_SHOW_SUBQUERY_LEN  1000

@ -310,7 +312,7 @@ typedef enum ELogicConditionType {
 #define TSDB_MIN_KEEP                   (1 * 1440)          // data in db to be reserved. unit minute
 #define TSDB_MAX_KEEP                   (365000 * 1440)     // data in db to be reserved.
 #define TSDB_MAX_KEEP_NS                (365 * 292 * 1440)  // data in db to be reserved.
-#define TSDB_DEFAULT_KEEP               (3650 * 1440)    // ten years
+#define TSDB_DEFAULT_KEEP               (3650 * 1440)       // ten years
 #define TSDB_MIN_MINROWS_FBLOCK         10
 #define TSDB_MAX_MINROWS_FBLOCK         1000
 #define TSDB_DEFAULT_MINROWS_FBLOCK     100
--- a/include/util/tencode.h
+++ b/include/util/tencode.h
@ -116,6 +116,7 @@ static int32_t tEncodeI64v(SEncoder* pCoder, int64_t val);
 static int32_t tEncodeFloat(SEncoder* pCoder, float val);
 static int32_t tEncodeDouble(SEncoder* pCoder, double val);
 static int32_t tEncodeBinary(SEncoder* pCoder, const uint8_t* val, uint32_t len);
+static int32_t tEncodeBinaryEx(SEncoder* pCoder, const uint8_t* val, uint32_t len);
 static int32_t tEncodeCStrWithLen(SEncoder* pCoder, const char* val, uint32_t len);
 static int32_t tEncodeCStr(SEncoder* pCoder, const char* val);

--- a/include/util/tjson.h
+++ b/include/util/tjson.h
@ -30,6 +30,27 @@ extern "C" {
    val = _tmp;                                      \
  } while (0)

+#define tjsonGetInt32ValueFromDouble(pJson, pName, val, code) \
+  do {                                                        \
+    double _tmp = 0;                                          \
+    code = tjsonGetDoubleValue(pJson, pName, &_tmp);          \
+    val = (int32_t)_tmp;                                      \
+  } while (0)
+
+#define tjsonGetInt8ValueFromDouble(pJson, pName, val, code) \
+  do {                                                       \
+    double _tmp = 0;                                         \
+    code = tjsonGetDoubleValue(pJson, pName, &_tmp);         \
+    val = (int8_t)_tmp;                                      \
+  } while (0)
+
+#define tjsonGetUInt16ValueFromDouble(pJson, pName, val, code) \
+  do {                                                         \
+    double _tmp = 0;                                           \
+    code = tjsonGetDoubleValue(pJson, pName, &_tmp);           \
+    val = (uint16_t)_tmp;                                      \
+  } while (0)
+
 typedef void SJson;

 SJson* tjsonCreateObject();
--- a/include/util/tlog.h
+++ b/include/util/tlog.h
@ -83,9 +83,21 @@ void taosPrintLongString(const char *flags, ELogLevel level, int32_t dflag, cons
 #endif
    ;

-bool taosAssert(bool condition, const char *file, int32_t line, const char *format, ...);
-#define ASSERTS(condition, ...) taosAssert(condition, __FILE__, __LINE__, __VA_ARGS__)
-#define ASSERT(condition)       ASSERTS(condition, "assert info not provided")
+bool taosAssertDebug(bool condition, const char *file, int32_t line, const char *format, ...);
+bool taosAssertRelease(bool condition);
+
+// Disable all asserts that may compromise the performance.
+#if defined DISABLE_ASSERT
+#define ASSERT(condition)
+#define ASSERTS(condition, ...)
+#else
+#define ASSERTS(condition, ...) taosAssertDebug(condition, __FILE__, __LINE__, __VA_ARGS__)
+#ifdef NDEBUG
+#define ASSERT(condition) taosAssertRelease(condition)
+#else
+#define ASSERT(condition) taosAssertDebug(condition, __FILE__, __LINE__, "assert info not provided")
+#endif
+#endif

 // clang-format off
 #define uFatal(...) { if (uDebugFlag & DEBUG_FATAL) { taosPrintLog("UTL FATAL", DEBUG_FATAL, tsLogEmbedded ? 255 : uDebugFlag, __VA_ARGS__); }}
--- a/include/util/tutil.h
+++ b/include/util/tutil.h
@ -29,11 +29,17 @@ extern "C" {
 int32_t strdequote(char *src);
 size_t  strtrim(char *src);
 char   *strnchr(const char *haystack, char needle, int32_t len, bool skipquote);
+TdUcs4* wcsnchr(const TdUcs4* haystack, TdUcs4 needle, size_t len);
+
 char  **strsplit(char *src, const char *delim, int32_t *num);
 char   *strtolower(char *dst, const char *src);
 char   *strntolower(char *dst, const char *src, int32_t n);
 char   *strntolower_s(char *dst, const char *src, int32_t n);
 int64_t strnatoi(char *num, int32_t len);
+
+size_t  tstrncspn(const char *str, size_t ssize, const char *reject, size_t rsize);
+size_t  twcsncspn(const TdUcs4 *wcs, size_t size, const TdUcs4 *reject, size_t rsize);
+
 char   *strbetween(char *string, char *begin, char *end);
 char   *paGetToken(char *src, char **token, int32_t *tokenLen);

--- a/include/util/tworker.h
+++ b/include/util/tworker.h
@ -17,6 +17,7 @@
 #define _TD_UTIL_WORKER_H_

 #include "tqueue.h"
+#include "tarray.h"

 #ifdef __cplusplus
 extern "C" {
@ -26,10 +27,10 @@ typedef struct SQWorkerPool SQWorkerPool;
 typedef struct SWWorkerPool SWWorkerPool;

 typedef struct SQWorker {
-  int32_t       id;      // worker id
-  int64_t       pid;     // thread pid
-  TdThread      thread;  // thread id
-  SQWorkerPool *pool;
+  int32_t  id;      // worker id
+  int64_t  pid;     // thread pid
+  TdThread thread;  // thread id
+  void    *pool;
 } SQWorker;

 typedef struct SQWorkerPool {
@ -42,6 +43,14 @@ typedef struct SQWorkerPool {
  TdThreadMutex mutex;
 } SQWorkerPool;

+typedef struct SAutoQWorkerPool {
+  float         ratio;
+  STaosQset    *qset;
+  const char   *name;
+  SArray       *workers;
+  TdThreadMutex mutex;
+} SAutoQWorkerPool;
+
 typedef struct SWWorker {
  int32_t       id;      // worker id
  int64_t       pid;     // thread pid
@ -65,6 +74,11 @@ void        tQWorkerCleanup(SQWorkerPool *pool);
 STaosQueue *tQWorkerAllocQueue(SQWorkerPool *pool, void *ahandle, FItem fp);
 void        tQWorkerFreeQueue(SQWorkerPool *pool, STaosQueue *queue);

+int32_t     tAutoQWorkerInit(SAutoQWorkerPool *pool);
+void        tAutoQWorkerCleanup(SAutoQWorkerPool *pool);
+STaosQueue *tAutoQWorkerAllocQueue(SAutoQWorkerPool *pool, void *ahandle, FItem fp);
+void        tAutoQWorkerFreeQueue(SAutoQWorkerPool *pool, STaosQueue *queue);
+
 int32_t     tWWorkerInit(SWWorkerPool *pool);
 void        tWWorkerCleanup(SWWorkerPool *pool);
 STaosQueue *tWWorkerAllocQueue(SWWorkerPool *pool, void *ahandle, FItems fp);
--- a/packaging/release.sh
+++ b/packaging/release.sh
@ -1,319 +0,0 @@
-#!/bin/bash
-#
-# Generate the deb package for ubuntu, or rpm package for centos, or tar.gz package for other linux os
-
-set -e
-# set -x
-
-# release.sh  -v [cluster | edge]
-#             -c [aarch32 | aarch64 | x64 | x86 | mips64 | loongarch64...]
-#             -o [Linux | Kylin | Alpine | Raspberrypi | Darwin | Windows | Ningsi60 | Ningsi80 |...]
-#             -V [stable | beta]
-#             -l [full | lite]
-#             -s [static | dynamic]
-#             -d [taos | ...]
-#             -n [2.0.0.3]
-#             -m [2.0.0.0]
-#             -H [ false | true]
-
-# set parameters by default value
-verMode=edge    # [cluster, edge, cloud]
-verType=stable  # [stable, beta]
-cpuType=x64     # [aarch32 | aarch64 | x64 | x86 | mips64 loongarch64...]
-osType=Linux    # [Linux | Kylin | Alpine | Raspberrypi | Darwin | Windows | Ningsi60 | Ningsi80 |...]
-pagMode=full    # [full | lite]
-soMode=dynamic  # [static | dynamic]
-dbName=taos     # [taos | ...]
-allocator=glibc # [glibc | jemalloc]
-verNumber=""
-verNumberComp="3.0.0.0"
-httpdBuild=false
-
-while getopts "hv:V:c:o:l:s:d:a:n:m:H:" arg; do
-  case $arg in
-  v)
-    #echo "verMode=$OPTARG"
-    verMode=$(echo $OPTARG)
-    ;;
-  V)
-    #echo "verType=$OPTARG"
-    verType=$(echo $OPTARG)
-    ;;
-  c)
-    #echo "cpuType=$OPTARG"
-    cpuType=$(echo $OPTARG)
-    ;;
-  l)
-    #echo "pagMode=$OPTARG"
-    pagMode=$(echo $OPTARG)
-    ;;
-  s)
-    #echo "soMode=$OPTARG"
-    soMode=$(echo $OPTARG)
-    ;;
-  d)
-    #echo "dbName=$OPTARG"
-    dbName=$(echo $OPTARG)
-    ;;
-  a)
-    #echo "allocator=$OPTARG"
-    allocator=$(echo $OPTARG)
-    ;;
-  n)
-    #echo "verNumber=$OPTARG"
-    verNumber=$(echo $OPTARG)
-    ;;
-  m)
-    #echo "verNumberComp=$OPTARG"
-    verNumberComp=$(echo $OPTARG)
-    ;;
-  o)
-    #echo "osType=$OPTARG"
-    osType=$(echo $OPTARG)
-    ;;
-  H)
-    #echo "httpdBuild=$OPTARG"
-    httpdBuild=$(echo $OPTARG)
-    ;;
-  h)
-    echo "Usage: $(basename $0) -v [cluster | edge] "
-    echo "                  -c [aarch32 | aarch64 | x64 | x86 | mips64 | loongarch64 ...] "
-    echo "                  -o [Linux | Kylin | Alpine | Raspberrypi | Darwin | Windows | Ningsi60 | Ningsi80 |...] "
-    echo "                  -V [stable | beta] "
-    echo "                  -l [full | lite] "
-    echo "                  -a [glibc | jemalloc] "
-    echo "                  -s [static | dynamic] "
-    echo "                  -d [taos | ...] "
-    echo "                  -n [version number] "
-    echo "                  -m [compatible version number] "
-    echo "                  -H [false | true] "
-    exit 0
-    ;;
-  ?) #unknow option
-    echo "unkonw argument"
-    exit 1
-    ;;
-  esac
-done
-
-osType=$(uname)
-
-echo "verMode=${verMode} verType=${verType} cpuType=${cpuType} osType=${osType} pagMode=${pagMode} soMode=${soMode} dbName=${dbName} allocator=${allocator} verNumber=${verNumber} verNumberComp=${verNumberComp} httpdBuild=${httpdBuild}"
-
-curr_dir=$(pwd)
-
-if [ "$osType" == "Darwin" ]; then
-  script_dir=$(dirname $0)
-  cd ${script_dir}
-  script_dir="$(pwd)"
-  top_dir=${script_dir}/..
-else
-  script_dir="$(dirname $(readlink -f $0))"
-  top_dir="$(readlink -f ${script_dir}/..)"
-fi
-
-csudo=""
-#if command -v sudo > /dev/null; then
-#  csudo="sudo "
-#fi
-
-function is_valid_version() {
-  [ -z $1 ] && return 1 || :
-
-  rx='^([0-9]+\.){3}(\*|[0-9]+)$'
-  if [[ $1 =~ $rx ]]; then
-    return 0
-  fi
-  return 1
-}
-
-function vercomp() {
-  if [[ $1 == $2 ]]; then
-    echo 0
-    exit 0
-  fi
-
-  local IFS=.
-  local i ver1=($1) ver2=($2)
-
-  # fill empty fields in ver1 with zeros
-  for ((i = ${#ver1[@]}; i < ${#ver2[@]}; i++)); do
-    ver1[i]=0
-  done
-
-  for ((i = 0; i < ${#ver1[@]}; i++)); do
-    if [[ -z ${ver2[i]} ]]; then
-      # fill empty fields in ver2 with zeros
-      ver2[i]=0
-    fi
-    if ((10#${ver1[i]} > 10#${ver2[i]})); then
-      echo 1
-      exit 0
-    fi
-    if ((10#${ver1[i]} < 10#${ver2[i]})); then
-      echo 2
-      exit 0
-    fi
-  done
-  echo 0
-}
-
-# 1. check version information
-if ( (! is_valid_version $verNumber) || (! is_valid_version $verNumberComp) || [[ "$(vercomp $verNumber $verNumberComp)" == '2' ]]); then
-  echo "please enter correct version"
-  exit 0
-fi
-
-echo "=======================new version number: ${verNumber}, compatible version: ${verNumberComp}======================================"
-
-build_time=$(date +"%F %R")
-
-# get commint id from git
-gitinfo=$(git rev-parse --verify HEAD)
-
-if [[ "$verMode" == "cluster" ]] || [[ "$verMode" == "cloud" ]]; then
-  enterprise_dir="${top_dir}/../enterprise"
-  cd ${enterprise_dir}
-  gitinfoOfInternal=$(git rev-parse --verify HEAD)
-else
-  gitinfoOfInternal=NULL
-fi
-
-cd "${curr_dir}"
-
-# 2. cmake executable file
-compile_dir="${top_dir}/debug"
-if [ -d ${compile_dir} ]; then
-  rm -rf ${compile_dir}
-fi
-
-mkdir -p ${compile_dir}
-cd ${compile_dir}
-
-if [[ "$allocator" == "jemalloc" ]]; then
-  allocator_macro="-DJEMALLOC_ENABLED=true"
-else
-  allocator_macro=""
-fi
-
-if [[ "$dbName" != "taos" ]]; then
-  source ${enterprise_dir}/packaging/oem/sed_$dbName.sh
-  replace_community_$dbName
-fi
-
-if [[ "$httpdBuild" == "true" ]]; then
-  BUILD_HTTP=true
-else
-  BUILD_HTTP=false
-fi
-
-if [[ "$verMode" == "cluster" ]] || [[ "$verMode" == "cloud" ]]; then
-  BUILD_HTTP=internal
-fi
-
-if [[ "$pagMode" == "full" ]]; then
-  BUILD_TOOLS=true
-else
-  BUILD_TOOLS=false
-fi
-
-# check support cpu type
-if [[ "$cpuType" == "x64" ]] || [[ "$cpuType" == "aarch64" ]] || [[ "$cpuType" == "aarch32" ]] || [[ "$cpuType" == "arm64" ]] || [[ "$cpuType" == "arm32" ]] || [[ "$cpuType" == "mips64" ]] || [[ "$cpuType" == "loongarch64" ]] ; 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}
-  elif [ "$verMode" == "cloud" ]; then
-    cmake ../../ -DCPUTYPE=${cpuType} -DWEBSOCKET=true -DBUILD_TAOSX=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
-    cmake ../../ -DCPUTYPE=${cpuType} -DWEBSOCKET=true -DBUILD_TAOSX=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}
-  fi
-else
-  echo "input cpuType=${cpuType} error!!!"
-  exit 1
-fi
-
-ostype=`uname`
-if [ "${ostype}" == "Darwin" ]; then
-    CORES=$(sysctl -n hw.ncpu)
-else
-    CORES=$(grep -c ^processor /proc/cpuinfo)
-fi
-
-if [[ "$allocator" == "jemalloc" ]]; then
-  # jemalloc need compile first, so disable parallel build
-  make -j ${CORES} && ${csudo}make install
-else
-  make -j ${CORES} && ${csudo}make install
-fi
-
-cd ${curr_dir}
-
-# 3. Call the corresponding script for packaging
-if [ "$osType" != "Darwin" ]; 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
-      echo "====do deb package for the ubuntu system===="
-      output_dir="${top_dir}/debs"
-      if [ -d ${output_dir} ]; then
-        rm -rf ${output_dir}
-      fi
-      mkdir -p ${output_dir}
-      cd ${script_dir}/deb
-      ${csudo}./makedeb.sh ${compile_dir} ${output_dir} ${verNumber} ${cpuType} ${osType} ${verMode} ${verType}
-
-      if [[ "$pagMode" == "full" ]]; then
-        if [ -d ${top_dir}/tools/taos-tools/packaging/deb ]; then
-          cd ${top_dir}/tools/taos-tools/packaging/deb
-          taos_tools_ver=$(git tag |grep -v taos | sort | tail -1)
-          [ -z "$taos_tools_ver" ] && taos_tools_ver="0.1.0"
-
-          ${csudo}./make-taos-tools-deb.sh ${top_dir} \
-            ${compile_dir} ${output_dir} ${taos_tools_ver} ${cpuType} ${osType} ${verMode} ${verType}
-        fi
-      fi
-    else
-      echo "==========dpkg command not exist, so not release deb package!!!"
-    fi
-    ret='0'
-    command -v rpmbuild >/dev/null 2>&1 || { ret='1'; }
-    if [ "$ret" -eq 0 ]; then
-      echo "====do rpm package for the centos system===="
-      output_dir="${top_dir}/rpms"
-      if [ -d ${output_dir} ]; then
-        rm -rf ${output_dir}
-      fi
-      mkdir -p ${output_dir}
-      cd ${script_dir}/rpm
-      ${csudo}./makerpm.sh ${compile_dir} ${output_dir} ${verNumber} ${cpuType} ${osType} ${verMode} ${verType}
-
-      if [[ "$pagMode" == "full" ]]; then
-        if [ -d ${top_dir}/tools/taos-tools/packaging/rpm ]; then
-          cd ${top_dir}/tools/taos-tools/packaging/rpm
-          taos_tools_ver=$(git tag |grep -v taos | sort | tail -1)
-          [ -z "$taos_tools_ver" ] && taos_tools_ver="0.1.0"
-
-          ${csudo}./make-taos-tools-rpm.sh ${top_dir} \
-            ${compile_dir} ${output_dir} ${taos_tools_ver} ${cpuType} ${osType} ${verMode} ${verType}
-        fi
-      fi
-    else
-      echo "==========rpmbuild command not exist, so not release rpm package!!!"
-    fi
-  fi
-
-  echo "====do tar.gz package for all systems===="
-  cd ${script_dir}/tools
-
-  ${csudo}./makepkg.sh ${compile_dir} ${verNumber} "${build_time}" ${cpuType} ${osType} ${verMode} ${verType} ${pagMode} ${verNumberComp} ${dbName}
-  ${csudo}./makeclient.sh ${compile_dir} ${verNumber} "${build_time}" ${cpuType} ${osType} ${verMode} ${verType} ${pagMode} ${dbName}
-
-else
-  cd ${script_dir}/tools
-  # ./makepkg.sh ${compile_dir} ${verNumber} "${build_time}" ${cpuType} ${osType} ${verMode} ${verType} ${pagMode} ${verNumberComp} ${dbName}
-  # ./makeclient.sh ${compile_dir} ${verNumber} "${build_time}" ${cpuType} ${osType} ${verMode} ${verType} ${pagMode} ${dbName}
-fi
--- a/packaging/tools/make_install.bat
+++ b/packaging/tools/make_install.bat
@ -14,6 +14,7 @@ set binary_dir=%3
 set binary_dir=%binary_dir:/=\\%
 set osType=%4
 set verNumber=%5
+set Enterprise=%6
 set target_dir=C:\\TDengine

 if not exist %target_dir% (
@ -57,7 +58,33 @@ if exist %binary_dir%\\build\\lib\\taosws.dll (
 if exist %binary_dir%\\build\\bin\\taosdump.exe (
    copy %binary_dir%\\build\\bin\\taosdump.exe %target_dir% > nul
 )
-
+if %Enterprise% == TRUE (
+    if exist %binary_dir%\\build\\bin\\taosx.exe (
+        copy %binary_dir%\\build\\bin\\taosx.exe %target_dir% > nul
+    )
+    if exist %binary_dir%\\build\\bin\\tmq_sim.exe (
+        copy %binary_dir%\\build\\bin\\tmq_sim.exe %target_dir% > nul
+    )
+    if exist %binary_dir%\\build\\bin\\tsim.exe (
+        copy %binary_dir%\\build\\bin\\tsim.exe %target_dir% > nul
+    )
+    if exist %binary_dir%\\build\\bin\\tmq_taosx_ci.exe (
+        copy %binary_dir%\\build\\bin\\tmq_taosx_ci.exe %target_dir% > nul
+    )
+    if exist %binary_dir%\\build\\bin\\tmq_demo.exe (
+        copy %binary_dir%\\build\\bin\\tmq_demo.exe %target_dir% > nul
+    )
+    if exist %binary_dir%\\build\\bin\\dumper.exe (
+        copy %binary_dir%\\build\\bin\\dumper.exe %target_dir% > nul
+    )
+    if exist %binary_dir%\\build\\bin\\runUdf.exe (
+        copy %binary_dir%\\build\\bin\\runUdf.exe %target_dir% > nul
+    )
+    if exist %binary_dir%\\build\\bin\\create_table.exe (
+        copy %binary_dir%\\build\\bin\\create_table.exe %target_dir% > nul
+    )
+)
+    
 copy %binary_dir%\\build\\bin\\taosd.exe %target_dir% > nul
 copy %binary_dir%\\build\\bin\\udfd.exe %target_dir% > nul

--- a/packaging/tools/makepkg.sh
+++ b/packaging/tools/makepkg.sh
@ -348,7 +348,8 @@ cd ${release_dir}
 #  install_dir has been distinguishes  cluster from  edege, so comments this code
 pkg_name=${install_dir}-${osType}-${cpuType}

-taostools_pkg_name=${taostools_install_dir}-${osType}-${cpuType}
+versionCompFirst=$(echo ${versionComp} | awk -F '.' '{print $1}')
+taostools_pkg_name=${taostools_install_dir}-${osType}-${cpuType}-comp${versionCompFirst}

 # if [ "$verMode" == "cluster" ]; then
 #   pkg_name=${install_dir}-${osType}-${cpuType}
--- a/source/client/inc/clientInt.h
+++ b/source/client/inc/clientInt.h
@ -149,7 +149,6 @@ typedef struct STscObj {
  int32_t       numOfReqs;  // number of sqlObj bound to this connection
  SAppInstInfo* pAppInfo;
  SHashObj*     pRequests;
-  int8_t        schemalessType;  // todo remove it, this attribute should be move to request
 } STscObj;

 typedef struct SResultColumn {
--- 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 { if (cDebugFlag & DEBUG_INFO)  { taosPrintLog("TSC ", DEBUG_INFO, cDebugFlag, __VA_ARGS__); }} while(0)
+#define tscPerf(...)   do { if (cDebugFlag & DEBUG_INFO)  { taosPrintLog("TSC ", 0, cDebugFlag, __VA_ARGS__); }} while(0)
 // clang-format on

 #ifdef __cplusplus
--- a/source/client/inc/clientSml.h
+++ b/source/client/inc/clientSml.h
@ -0,0 +1,245 @@
+/*
+ * 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 TDENGINE_CLIENTSML_H
+#define TDENGINE_CLIENTSML_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "catalog.h"
+#include "clientInt.h"
+#include "osThread.h"
+#include "query.h"
+#include "taos.h"
+#include "taoserror.h"
+#include "tcommon.h"
+#include "tdef.h"
+#include "tglobal.h"
+#include "tlog.h"
+#include "tmsg.h"
+#include "tname.h"
+#include "ttime.h"
+#include "ttypes.h"
+#include "cJSON.h"
+
+#if (defined(__GNUC__) && (__GNUC__ >= 3)) || (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 800)) || defined(__clang__)
+#  define expect(expr,value)    (__builtin_expect ((expr),(value)) )
+#else
+#  define expect(expr,value)    (expr)
+#endif
+
+#ifndef likely
+#define likely(expr)     expect((expr) != 0, 1)
+#endif
+#ifndef unlikely
+#define unlikely(expr)   expect((expr) != 0, 0)
+#endif
+
+#define SPACE ' '
+#define COMMA ','
+#define EQUAL '='
+#define QUOTE '"'
+#define SLASH '\\'
+
+#define JUMP_SPACE(sql, sqlEnd) \
+  while (sql < sqlEnd) {        \
+    if (unlikely(*sql == SPACE))          \
+      sql++;                    \
+    else                        \
+      break;                    \
+  }
+
+#define IS_INVALID_COL_LEN(len)   ((len) <= 0 || (len) >= TSDB_COL_NAME_LEN)
+#define IS_INVALID_TABLE_LEN(len) ((len) <= 0 || (len) >= TSDB_TABLE_NAME_LEN)
+
+#define TS        "_ts"
+#define TS_LEN    3
+#define VALUE     "_value"
+#define VALUE_LEN 6
+
+#define OTD_JSON_FIELDS_NUM     4
+#define MAX_RETRY_TIMES 5
+typedef TSDB_SML_PROTOCOL_TYPE SMLProtocolType;
+
+typedef enum {
+  SCHEMA_ACTION_NULL,
+  SCHEMA_ACTION_CREATE_STABLE,
+  SCHEMA_ACTION_ADD_COLUMN,
+  SCHEMA_ACTION_ADD_TAG,
+  SCHEMA_ACTION_CHANGE_COLUMN_SIZE,
+  SCHEMA_ACTION_CHANGE_TAG_SIZE,
+} ESchemaAction;
+
+typedef struct {
+  const void  *key;
+  int32_t      keyLen;
+  void        *value;
+  bool         used;
+}Node;
+
+typedef struct NodeList{
+  Node             data;
+  struct NodeList* next;
+}NodeList;
+
+typedef struct {
+  char *measure;
+  char *tags;
+  char *cols;
+  char *timestamp;
+
+  int32_t measureLen;
+  int32_t measureTagsLen;
+  int32_t tagsLen;
+  int32_t colsLen;
+  int32_t timestampLen;
+
+  SArray *colArray;
+} SSmlLineInfo;
+
+typedef struct {
+  const char *sTableName;  // super table name
+  int32_t     sTableNameLen;
+  char        childTableName[TSDB_TABLE_NAME_LEN];
+  uint64_t    uid;
+  void       *key;        // for openTsdb
+
+  SArray *tags;
+
+  // elements are SHashObj<cols key string, SSmlKv*> for find by key quickly
+  SArray *cols;
+  STableDataCxt *tableDataCtx;
+} SSmlTableInfo;
+
+typedef struct {
+  SArray   *tags;     // save the origin order to create table
+  SHashObj *tagHash;  // elements are <key, index in tags>
+
+  SArray   *cols;
+  SHashObj *colHash;
+
+  STableMeta *tableMeta;
+} SSmlSTableMeta;
+
+typedef struct {
+  int32_t len;
+  char   *buf;
+} SSmlMsgBuf;
+
+typedef struct {
+  int32_t code;
+  int32_t lineNum;
+
+  int32_t numOfSTables;
+  int32_t numOfCTables;
+  int32_t numOfCreateSTables;
+  int32_t numOfAlterColSTables;
+  int32_t numOfAlterTagSTables;
+
+  int64_t parseTime;
+  int64_t schemaTime;
+  int64_t insertBindTime;
+  int64_t insertRpcTime;
+  int64_t endTime;
+} SSmlCostInfo;
+
+typedef struct {
+  int64_t id;
+
+  SMLProtocolType protocol;
+  int8_t          precision;
+  bool            reRun;
+  bool            dataFormat;  // true means that the name and order of keys in each line are the same(only for influx protocol)
+  bool            isRawLine;
+  int32_t         ttl;
+
+  NodeList *childTables;
+  NodeList *superTables;
+  SHashObj *pVgHash;
+
+  STscObj     *taos;
+  SCatalog    *pCatalog;
+  SRequestObj *pRequest;
+  SQuery      *pQuery;
+
+  SSmlCostInfo cost;
+  int32_t      lineNum;
+  SSmlMsgBuf   msgBuf;
+
+  cJSON       *root;  // for parse json
+  int8_t             offset[OTD_JSON_FIELDS_NUM];
+  SSmlLineInfo      *lines; // element is SSmlLineInfo
+  bool               parseJsonByLib;
+  SArray      *tagJsonArray;
+
+  //
+  SArray      *preLineTagKV;
+  SArray      *maxTagKVs;
+  SArray      *preLineColKV;
+
+  SSmlLineInfo preLine;
+  STableMeta  *currSTableMeta;
+  STableDataCxt *currTableDataCtx;
+  bool         needModifySchema;
+} SSmlHandle;
+
+#define IS_SAME_CHILD_TABLE (elements->measureTagsLen == info->preLine.measureTagsLen \
+&& memcmp(elements->measure, info->preLine.measure, elements->measureTagsLen) == 0)
+
+#define IS_SAME_SUPER_TABLE (elements->measureLen == info->preLine.measureLen \
+&& memcmp(elements->measure, info->preLine.measure, elements->measureLen) == 0)
+
+#define IS_SAME_KEY (maxKV->keyLen == kv.keyLen && memcmp(maxKV->key, kv.key, kv.keyLen) == 0)
+
+extern int64_t smlFactorNS[3];
+extern int64_t smlFactorS[3];
+
+typedef int32_t (*_equal_fn_sml)(const void *, const void *);
+
+SSmlHandle   *smlBuildSmlInfo(TAOS *taos);
+void          smlDestroyInfo(SSmlHandle *info);
+int           smlJsonParseObjFirst(char **start, SSmlLineInfo *element, int8_t *offset);
+int           smlJsonParseObj(char **start, SSmlLineInfo *element, int8_t *offset);
+//SArray       *smlJsonParseTags(char *start, char *end);
+bool          smlParseNumberOld(SSmlKv *kvVal, SSmlMsgBuf *msg);
+void*         nodeListGet(NodeList* list, const void *key, int32_t len, _equal_fn_sml fn);
+int           nodeListSet(NodeList** list, const void *key, int32_t len, void* value, _equal_fn_sml fn);
+int           nodeListSize(NodeList* list);
+bool          smlDoubleToInt64OverFlow(double num);
+int32_t       smlBuildInvalidDataMsg(SSmlMsgBuf *pBuf, const char *msg1, const char *msg2);
+bool          smlParseNumber(SSmlKv *kvVal, SSmlMsgBuf *msg);
+int64_t       smlGetTimeValue(const char *value, int32_t len, uint8_t fromPrecision, uint8_t toPrecision);
+int8_t        smlGetTsTypeByLen(int32_t len);
+SSmlTableInfo*    smlBuildTableInfo(int numRows, const char* measure, int32_t measureLen);
+SSmlSTableMeta*   smlBuildSTableMeta(bool isDataFormat);
+int32_t           smlSetCTableName(SSmlTableInfo *oneTable);
+STableMeta*       smlGetMeta(SSmlHandle *info, const void* measure, int32_t measureLen);
+int32_t           is_same_child_table_telnet(const void *a, const void *b);
+int64_t           smlParseOpenTsdbTime(SSmlHandle *info, const char *data, int32_t len);
+int32_t           smlClearForRerun(SSmlHandle *info);
+int32_t           smlParseValue(SSmlKv *pVal, SSmlMsgBuf *msg);
+uint8_t           smlGetTimestampLen(int64_t num);
+void              clearColValArray(SArray* pCols);
+void              smlDestroyTableInfo(SSmlHandle *info, SSmlTableInfo *tag);
+
+int32_t smlParseInfluxString(SSmlHandle *info, char *sql, char *sqlEnd, SSmlLineInfo *elements);
+int32_t smlParseTelnetString(SSmlHandle *info, char *sql, char *sqlEnd, SSmlLineInfo *elements);
+int32_t smlParseJSON(SSmlHandle *info, char *payload);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TDENGINE_CLIENTSML_H
--- a/source/client/inc/clientStmt.h
+++ b/source/client/inc/clientStmt.h
@ -21,8 +21,6 @@ extern "C" {
 #endif
 #include "catalog.h"

-typedef void STableDataBlocks;
-
 typedef enum {
  STMT_TYPE_INSERT = 1,
  STMT_TYPE_MULTI_INSERT,
@ -43,8 +41,8 @@ typedef enum {
 } STMT_STATUS;

 typedef struct SStmtTableCache {
-  STableDataBlocks *pDataBlock;
-  void             *boundTags;
+  STableDataCxt *pDataCtx;
+  void          *boundTags;
 } SStmtTableCache;

 typedef struct SStmtQueryResInfo {
@ -71,10 +69,11 @@ typedef struct SStmtBindInfo {
 } SStmtBindInfo;

 typedef struct SStmtExecInfo {
-  int32_t      affectedRows;
-  SRequestObj *pRequest;
-  SHashObj    *pBlockHash;
-  bool         autoCreateTbl;
+  int32_t        affectedRows;
+  SRequestObj   *pRequest;
+  SHashObj      *pBlockHash;
+  STableDataCxt *pCurrBlock;
+  SSubmitTbData *pCurrTbData;
 } SStmtExecInfo;

 typedef struct SStmtSQLInfo {
--- a/source/client/src/clientEnv.c
+++ b/source/client/src/clientEnv.c
@ -62,7 +62,10 @@ static int32_t registerRequest(SRequestObj *pRequest, STscObj *pTscObj) {

 static void deregisterRequest(SRequestObj *pRequest) {
  const static int64_t SLOW_QUERY_INTERVAL = 3000000L;  // todo configurable
-  assert(pRequest != NULL);
+  if(pRequest == NULL){
+    tscError("pRequest == NULL");
+    return;
+  }

  STscObj            *pTscObj = pRequest->pTscObj;
  SAppClusterSummary *pActivity = &pTscObj->pAppInfo->summary;
@ -76,13 +79,19 @@ static void deregisterRequest(SRequestObj *pRequest) {
           "current:%d, app current:%d",
           pRequest->self, pTscObj->id, pRequest->requestId, duration / 1000.0, num, currentInst);

+  tscPerf("insert duration %" PRId64 "us: syntax:%" PRId64 "us, ctg:%" PRId64 "us, semantic:%" PRId64
+          "us, exec:%" PRId64 "us, stmtType:%d",
+          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, pRequest->stmtType);
+
  if (QUERY_NODE_VNODE_MODIFY_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);
-    atomic_add_fetch_64((int64_t *)&pActivity->insertElapsedTime, duration);
+    //        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,
@ -264,7 +273,6 @@ void *createTscObj(const char *user, const char *auth, const char *db, int32_t c

  taosThreadMutexInit(&pObj->mutex, NULL);
  pObj->id = taosAddRef(clientConnRefPool, pObj);
-  pObj->schemalessType = 1;

  atomic_add_fetch_64(&pObj->pAppInfo->numOfConns, 1);

@ -407,7 +415,8 @@ void taos_init_imp(void) {
  initQueryModuleMsgHandle();

  if (taosConvInit() != 0) {
-    ASSERTS(0, "failed to init conv");
+    tscError("failed to init conv");
+    return;
  }

  rpcInit();
--- a/source/client/src/clientHb.c
+++ b/source/client/src/clientHb.c
@ -376,7 +376,6 @@ int32_t hbBuildQueryDesc(SQueryHbReqBasic *hbBasic, STscObj *pObj) {
        desc.subPlanNum = 0;
      }
      desc.subPlanNum = taosArrayGetSize(desc.subDesc);
-      ASSERT(desc.subPlanNum == taosArrayGetSize(desc.subDesc));
    } else {
      desc.subDesc = NULL;
    }
@ -813,7 +812,10 @@ static void hbStopThread() {
 }

 SAppHbMgr *appHbMgrInit(SAppInstInfo *pAppInstInfo, char *key) {
-  hbMgrInit();
+  if(hbMgrInit() != 0){
+    terrno = TSDB_CODE_TSC_INTERNAL_ERROR;
+    return NULL;
+  }
  SAppHbMgr *pAppHbMgr = taosMemoryMalloc(sizeof(SAppHbMgr));
  if (pAppHbMgr == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
@ -899,16 +901,28 @@ int hbMgrInit() {
  TdThreadMutexAttr attr = {0};

  int ret = taosThreadMutexAttrInit(&attr);
-  assert(ret == 0);
+  if(ret != 0){
+    uError("hbMgrInit:taosThreadMutexAttrInit error")
+    return ret;
+  }

  ret = taosThreadMutexAttrSetType(&attr, PTHREAD_MUTEX_RECURSIVE);
-  assert(ret == 0);
+  if(ret != 0){
+    uError("hbMgrInit:taosThreadMutexAttrSetType error")
+    return ret;
+  }

  ret = taosThreadMutexInit(&clientHbMgr.lock, &attr);
-  assert(ret == 0);
+  if(ret != 0){
+    uError("hbMgrInit:taosThreadMutexInit error")
+    return ret;
+  }

  ret = taosThreadMutexAttrDestroy(&attr);
-  assert(ret == 0);
+  if(ret != 0){
+    uError("hbMgrInit:taosThreadMutexAttrDestroy error")
+    return ret;
+  }

  // init handle funcs
  hbMgrInitHandle();
--- a/source/client/src/clientImpl.c
+++ b/source/client/src/clientImpl.c
@ -122,6 +122,12 @@ STscObj* taos_connect_internal(const char* ip, const char* user, const char* pas

  char* key = getClusterKey(user, secretEncrypt, ip, port);

+  tscInfo("connecting to server, numOfEps:%d inUse:%d user:%s db:%s key:%s", epSet.epSet.numOfEps, epSet.epSet.inUse,
+          user, db, key);
+  for (int32_t i = 0; i < epSet.epSet.numOfEps; ++i) {
+    tscInfo("ep:%d, %s:%u", i, epSet.epSet.eps[i].fqdn, epSet.epSet.eps[i].port);
+  }
+
  SAppInstInfo** pInst = NULL;
  taosThreadMutexLock(&appInfo.mutex);

@ -142,7 +148,7 @@ STscObj* taos_connect_internal(const char* ip, const char* user, const char* pas
    taosHashPut(appInfo.pInstMap, key, strlen(key), &p, POINTER_BYTES);
    p->instKey = key;
    key = NULL;
-    tscDebug("new app inst mgr %p, user:%s, ip:%s, port:%d", p, user, ip, port);
+    tscDebug("new app inst mgr %p, user:%s, ip:%s, port:%d", p, user, epSet.epSet.eps[0].fqdn, epSet.epSet.eps[0].port);

    pInst = &p;
  }
@ -233,7 +239,6 @@ int32_t parseSql(SRequestObj* pRequest, bool topicQuery, SQuery** pQuery, SStmtC
                       .pTransporter = pTscObj->pAppInfo->pTransporter,
                       .pStmtCb = pStmtCb,
                       .pUser = pTscObj->user,
-                       .schemalessType = pTscObj->schemalessType,
                       .isSuperUser = (0 == strcmp(pTscObj->user, TSDB_DEFAULT_USER)),
                       .enableSysInfo = pTscObj->sysInfo,
                       .svrVer = pTscObj->sVer,
@ -267,7 +272,7 @@ int32_t parseSql(SRequestObj* pRequest, bool topicQuery, SQuery** pQuery, SStmtC

 int32_t execLocalCmd(SRequestObj* pRequest, SQuery* pQuery) {
  SRetrieveTableRsp* pRsp = NULL;
-  int32_t            code = qExecCommand(pRequest->pTscObj->sysInfo, pQuery->pRoot, &pRsp);
+  int32_t            code = qExecCommand(&pRequest->pTscObj->id, pRequest->pTscObj->sysInfo, pQuery->pRoot, &pRsp);
  if (TSDB_CODE_SUCCESS == code && NULL != pRsp) {
    code = setQueryResultFromRsp(&pRequest->body.resInfo, pRsp, false, true);
  }
@ -305,7 +310,7 @@ void asyncExecLocalCmd(SRequestObj* pRequest, SQuery* pQuery) {
    return;
  }

-  int32_t code = qExecCommand(pRequest->pTscObj->sysInfo, pQuery->pRoot, &pRsp);
+  int32_t code = qExecCommand(&pRequest->pTscObj->id ,pRequest->pTscObj->sysInfo, pQuery->pRoot, &pRsp);
  if (TSDB_CODE_SUCCESS == code && NULL != pRsp) {
    code = setQueryResultFromRsp(&pRequest->body.resInfo, pRsp, false, true);
  }
@ -447,7 +452,10 @@ int32_t getPlan(SRequestObj* pRequest, SQuery* pQuery, SQueryPlan** pPlan, SArra
 }

 void setResSchemaInfo(SReqResultInfo* pResInfo, const SSchema* pSchema, int32_t numOfCols) {
-  ASSERT(pSchema != NULL && numOfCols > 0);
+  if(pResInfo == NULL || pSchema == NULL || numOfCols <= 0){
+    tscError("invalid paras, pResInfo == NULL || pSchema == NULL || numOfCols <= 0");
+    return;
+  }

  pResInfo->numOfCols = numOfCols;
  if (pResInfo->fields != NULL) {
@ -458,7 +466,10 @@ void setResSchemaInfo(SReqResultInfo* pResInfo, const SSchema* pSchema, int32_t
  }
  pResInfo->fields = taosMemoryCalloc(numOfCols, sizeof(TAOS_FIELD));
  pResInfo->userFields = taosMemoryCalloc(numOfCols, sizeof(TAOS_FIELD));
-  ASSERT(numOfCols == pResInfo->numOfCols);
+  if(numOfCols != pResInfo->numOfCols){
+    tscError("numOfCols:%d != pResInfo->numOfCols:%d", numOfCols, pResInfo->numOfCols);
+    return;
+  }

  for (int32_t i = 0; i < pResInfo->numOfCols; ++i) {
    pResInfo->fields[i].bytes = pSchema[i].bytes;
@ -735,47 +746,21 @@ int32_t scheduleQuery(SRequestObj* pRequest, SQueryPlan* pDag, SArray* pNodeList
 }

 int32_t handleSubmitExecRes(SRequestObj* pRequest, void* res, SCatalog* pCatalog, SEpSet* epset) {
-  int32_t     code = 0;
-  SArray*     pArray = NULL;
-  SSubmitRsp* pRsp = (SSubmitRsp*)res;
-  if (pRsp->nBlocks <= 0) {
-    taosMemoryFreeClear(pRsp->pBlocks);
+  SArray*      pArray = NULL;
+  SSubmitRsp2* pRsp = (SSubmitRsp2*)res;
+  if (NULL == pRsp->aCreateTbRsp) {
    return TSDB_CODE_SUCCESS;
  }

-  pArray = taosArrayInit(pRsp->nBlocks, sizeof(STbSVersion));
-  if (NULL == pArray) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return TSDB_CODE_OUT_OF_MEMORY;
+  int32_t tbNum = taosArrayGetSize(pRsp->aCreateTbRsp);
+  for (int32_t i = 0; i < tbNum; ++i) {
+    SVCreateTbRsp* pTbRsp = (SVCreateTbRsp*)taosArrayGet(pRsp->aCreateTbRsp, i);
+    if (pTbRsp->pMeta) {
+      handleCreateTbExecRes(pTbRsp->pMeta, pCatalog);
+    }
  }

-  for (int32_t i = 0; i < pRsp->nBlocks; ++i) {
-    SSubmitBlkRsp* blk = pRsp->pBlocks + i;
-    if (blk->pMeta) {
-      handleCreateTbExecRes(blk->pMeta, pCatalog);
-      tFreeSTableMetaRsp(blk->pMeta);
-      taosMemoryFreeClear(blk->pMeta);
-    }
-
-    if (NULL == blk->tblFName || 0 == blk->tblFName[0]) {
-      continue;
-    }
-
-    STbSVersion tbSver = {.tbFName = blk->tblFName, .sver = blk->sver};
-    taosArrayPush(pArray, &tbSver);
-  }
-
-  SRequestConnInfo conn = {.pTrans = pRequest->pTscObj->pAppInfo->pTransporter,
-                           .requestId = pRequest->requestId,
-                           .requestObjRefId = pRequest->self,
-                           .mgmtEps = *epset};
-
-  code = catalogChkTbMetaVersion(pCatalog, &conn, pArray);
-
-_return:
-
-  taosArrayDestroy(pArray);
-  return code;
+  return TSDB_CODE_SUCCESS;
 }

 int32_t handleQueryExecRes(SRequestObj* pRequest, void* res, SCatalog* pCatalog, SEpSet* epset) {
@ -1360,7 +1345,10 @@ int32_t doProcessMsgFromServer(void* param) {
  SEpSet*   pEpSet = arg->pEpset;

  SMsgSendInfo* pSendInfo = (SMsgSendInfo*)pMsg->info.ahandle;
-  assert(pMsg->info.ahandle != NULL);
+  if(pMsg->info.ahandle == NULL){
+    tscError("doProcessMsgFromServer pMsg->info.ahandle == NULL");
+    return TSDB_CODE_TSC_INTERNAL_ERROR;
+  }
  STscObj* pTscObj = NULL;

  STraceId* trace = &pMsg->info.traceId;
@ -1373,8 +1361,10 @@ int32_t doProcessMsgFromServer(void* param) {
  if (pSendInfo->requestObjRefId != 0) {
    SRequestObj* pRequest = (SRequestObj*)taosAcquireRef(clientReqRefPool, pSendInfo->requestObjRefId);
    if (pRequest) {
-      assert(pRequest->self == pSendInfo->requestObjRefId);
-
+      if(pRequest->self != pSendInfo->requestObjRefId){
+        tscError("doProcessMsgFromServer pRequest->self:%"PRId64" != pSendInfo->requestObjRefId:%"PRId64, pRequest->self, pSendInfo->requestObjRefId);
+        return TSDB_CODE_TSC_INTERNAL_ERROR;
+      }
      pRequest->metric.rsp = taosGetTimestampUs();
      pTscObj = pRequest->pTscObj;
      /*
@ -1424,6 +1414,21 @@ void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) {
    memcpy((void*)tEpSet, (void*)pEpSet, sizeof(SEpSet));
  }

+  // pMsg is response msg
+  if (pMsg->msgType == TDMT_MND_CONNECT + 1) {
+    // restore origin code
+    if (pMsg->code == TSDB_CODE_RPC_SOMENODE_NOT_CONNECTED) {
+      pMsg->code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
+    } else if (pMsg->code == TSDB_CODE_RPC_SOMENODE_BROKEN_LINK) {
+      pMsg->code = TSDB_CODE_RPC_BROKEN_LINK;
+    }
+  } else {
+    // uniform to one error code: TSDB_CODE_RPC_SOMENODE_NOT_CONNECTED
+    if (pMsg->code == TSDB_CODE_RPC_SOMENODE_BROKEN_LINK) {
+      pMsg->code = TSDB_CODE_RPC_SOMENODE_NOT_CONNECTED;
+    }
+  }
+
  AsyncArg* arg = taosMemoryCalloc(1, sizeof(AsyncArg));
  arg->msg = *pMsg;
  arg->pEpset = tEpSet;
@ -1501,7 +1506,9 @@ void doSetOneRowPtr(SReqResultInfo* pResultInfo) {
 }

 void* doFetchRows(SRequestObj* pRequest, bool setupOneRowPtr, bool convertUcs4) {
-  assert(pRequest != NULL);
+  if(pRequest == NULL){
+    return NULL;
+  }

  SReqResultInfo* pResultInfo = &pRequest->body.resInfo;
  if (pResultInfo->pData == NULL || pResultInfo->current >= pResultInfo->numOfRows) {
@ -1555,7 +1562,9 @@ static void syncFetchFn(void* param, TAOS_RES* res, int32_t numOfRows) {
 }

 void* doAsyncFetchRows(SRequestObj* pRequest, bool setupOneRowPtr, bool convertUcs4) {
-  assert(pRequest != NULL);
+  if(pRequest == NULL){
+    return NULL;
+  }

  SReqResultInfo* pResultInfo = &pRequest->body.resInfo;
  if (pResultInfo->pData == NULL || pResultInfo->current >= pResultInfo->numOfRows) {
@ -1619,8 +1628,10 @@ static int32_t doConvertUCS4(SReqResultInfo* pResultInfo, int32_t numOfRows, int
          char* pStart = pCol->offset[j] + pCol->pData;

          int32_t len = taosUcs4ToMbs((TdUcs4*)varDataVal(pStart), varDataLen(pStart), varDataVal(p));
-          ASSERT(len <= bytes);
-          ASSERT((p + len) < (pResultInfo->convertBuf[i] + colLength[i]));
+          if(len > bytes || (p + len) >= (pResultInfo->convertBuf[i] + colLength[i])){
+            tscError("doConvertUCS4 error, invalid data. len:%d, bytes:%d, (p + len):%p, (pResultInfo->convertBuf[i] + colLength[i]):%p", len, bytes, (p + len), (pResultInfo->convertBuf[i] + colLength[i]));
+            return TSDB_CODE_TSC_INTERNAL_ERROR;
+          }

          varDataSetLen(p, len);
          pCol->offset[j] = (p - pResultInfo->convertBuf[i]);
@ -1637,9 +1648,6 @@ static int32_t doConvertUCS4(SReqResultInfo* pResultInfo, int32_t numOfRows, int
 }

 int32_t getVersion1BlockMetaSize(const char* p, int32_t numOfCols) {
-  int32_t cols = *(int32_t*)(p + sizeof(int32_t) * 3);
-  ASSERT(numOfCols == cols);
-
  return sizeof(int32_t) + sizeof(int32_t) + sizeof(int32_t) * 3 + sizeof(uint64_t) +
         numOfCols * (sizeof(int8_t) + sizeof(int32_t));
 }
@ -1649,6 +1657,12 @@ static int32_t estimateJsonLen(SReqResultInfo* pResultInfo, int32_t numOfCols, i

  // | version | total length | total rows | total columns | flag seg| block group id | column schema | each column
  // length |
+  int32_t cols = *(int32_t*)(p + sizeof(int32_t) * 3);
+  if(ASSERT(numOfCols == cols)){
+    tscError("estimateJsonLen error: numOfCols:%d != cols:%d", numOfCols, cols);
+    return -1;
+  }
+
  int32_t  len = getVersion1BlockMetaSize(p, numOfCols);
  int32_t* colLength = (int32_t*)(p + len);
  len += sizeof(int32_t) * numOfCols;
@ -1682,7 +1696,8 @@ static int32_t estimateJsonLen(SReqResultInfo* pResultInfo, int32_t numOfCols, i
        } else if (jsonInnerType == TSDB_DATA_TYPE_BOOL) {
          len += (VARSTR_HEADER_SIZE + 5);
        } else {
-          ASSERT(0);
+          tscError("estimateJsonLen error: invalid type:%d", jsonInnerType);
+          return -1;
        }
      }
    } else if (IS_VAR_DATA_TYPE(pResultInfo->fields[i].type)) {
@ -1716,12 +1731,21 @@ static int32_t doConvertJson(SReqResultInfo* pResultInfo, int32_t numOfCols, int

  char*   p = (char*)pResultInfo->pData;
  int32_t dataLen = estimateJsonLen(pResultInfo, numOfCols, numOfRows);
+  if(dataLen <= 0){
+    return TSDB_CODE_TSC_INTERNAL_ERROR;
+  }

  pResultInfo->convertJson = taosMemoryCalloc(1, dataLen);
  if (pResultInfo->convertJson == NULL) return TSDB_CODE_OUT_OF_MEMORY;
  char* p1 = pResultInfo->convertJson;

  int32_t totalLen = 0;
+  int32_t cols = *(int32_t*)(p + sizeof(int32_t) * 3);
+  if(ASSERT(numOfCols == cols)){
+    tscError("doConvertJson error: numOfCols:%d != cols:%d", numOfCols, cols);
+    return TSDB_CODE_TSC_INTERNAL_ERROR;
+  }
+
  int32_t len = getVersion1BlockMetaSize(p, numOfCols);
  memcpy(p1, p, len);

@ -1742,8 +1766,10 @@ static int32_t doConvertJson(SReqResultInfo* pResultInfo, int32_t numOfCols, int
  for (int32_t i = 0; i < numOfCols; ++i) {
    int32_t colLen = htonl(colLength[i]);
    int32_t colLen1 = htonl(colLength1[i]);
-    ASSERT(colLen < dataLen);
-
+    if(ASSERT(colLen < dataLen)){
+      tscError("doConvertJson error: colLen:%d >= dataLen:%d", colLen, dataLen);
+      return TSDB_CODE_TSC_INTERNAL_ERROR;
+    }
    if (pResultInfo->fields[i].type == TSDB_DATA_TYPE_JSON) {
      int32_t* offset = (int32_t*)pStart;
      int32_t* offset1 = (int32_t*)pStart1;
@ -1788,7 +1814,8 @@ static int32_t doConvertJson(SReqResultInfo* pResultInfo, int32_t numOfCols, int
          sprintf(varDataVal(dst), "%s", (*((char*)jsonInnerData) == 1) ? "true" : "false");
          varDataSetLen(dst, strlen(varDataVal(dst)));
        } else {
-          ASSERT(0);
+          tscError("doConvertJson error: invalid type:%d", jsonInnerType);
+          return TSDB_CODE_TSC_INTERNAL_ERROR;
        }

        offset1[j] = len;
@ -1826,7 +1853,10 @@ static int32_t doConvertJson(SReqResultInfo* pResultInfo, int32_t numOfCols, int

 int32_t setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32_t numOfCols, int32_t numOfRows,
                         bool convertUcs4) {
-  assert(numOfCols > 0 && pFields != NULL && pResultInfo != NULL);
+  if(ASSERT(numOfCols > 0 && pFields != NULL && pResultInfo != NULL)){
+    tscError("setResultDataPtr paras error");
+    return TSDB_CODE_TSC_INTERNAL_ERROR;
+  }
  if (numOfRows == 0) {
    return TSDB_CODE_SUCCESS;
  }
@ -1855,7 +1885,10 @@ int32_t setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32
  int32_t cols = *(int32_t*)p;
  p += sizeof(int32_t);

-  ASSERT(rows == numOfRows && cols == numOfCols);
+  if(ASSERT(rows == numOfRows && cols == numOfCols)){
+    tscError("setResultDataPtr paras error:rows;%d numOfRows:%d cols:%d numOfCols:%d", rows, numOfRows, cols, numOfCols);
+    return TSDB_CODE_TSC_INTERNAL_ERROR;
+  }

  int32_t hasColumnSeg = *(int32_t*)p;
  p += sizeof(int32_t);
@ -1882,7 +1915,7 @@ int32_t setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32
    colLength[i] = htonl(colLength[i]);
    if (colLength[i] >= dataLen) {
      tscError("invalid colLength %d, dataLen %d", colLength[i], dataLen);
-      ASSERT(0);
+      return TSDB_CODE_TSC_INTERNAL_ERROR;
    }

    if (IS_VAR_DATA_TYPE(pResultInfo->fields[i].type)) {
@ -1920,7 +1953,11 @@ char* getDbOfConnection(STscObj* pObj) {
 }

 void setConnectionDB(STscObj* pTscObj, const char* db) {
-  assert(db != NULL && pTscObj != NULL);
+  if(db == NULL || pTscObj == NULL){
+    tscError("setConnectionDB para is NULL");
+    return;
+  }
+
  taosThreadMutexLock(&pTscObj->mutex);
  tstrncpy(pTscObj->db, db, tListLen(pTscObj->db));
  taosThreadMutexUnlock(&pTscObj->mutex);
@ -1938,7 +1975,10 @@ void resetConnectDB(STscObj* pTscObj) {

 int32_t setQueryResultFromRsp(SReqResultInfo* pResultInfo, const SRetrieveTableRsp* pRsp, bool convertUcs4,
                              bool freeAfterUse) {
-  assert(pResultInfo != NULL && pRsp != NULL);
+  if(pResultInfo == NULL || pRsp == NULL){
+    tscError("setQueryResultFromRsp paras is null");
+    return TSDB_CODE_TSC_INTERNAL_ERROR;
+  }

  if (freeAfterUse) taosMemoryFreeClear(pResultInfo->pRspMsg);

--- a/source/client/src/clientJniConnector.c
+++ b/source/client/src/clientJniConnector.c
@ -574,7 +574,11 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_fetchBlockImp(JNI
  TAOS_RES *tres = (TAOS_RES *)res;

  int32_t numOfFields = taos_num_fields(tres);
-  assert(numOfFields > 0);
+  if(numOfFields <= 0){
+    jniError("jobj:%p, conn:%p, query interrupted. taos_num_fields error code:%d, msg:%s", jobj, tscon, numOfFields,
+             taos_errstr(tres));
+    return JNI_RESULT_SET_NULL;
+  }

  void   *data;
  int32_t numOfRows;
--- a/source/client/src/clientMain.c
+++ b/source/client/src/clientMain.c
@ -291,7 +291,6 @@ TAOS_ROW taos_fetch_row(TAOS_RES *res) {
    tscError("invalid result passed to taos_fetch_row");
    return NULL;
  }
-  return NULL;
 }

 int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields) {
@ -355,9 +354,13 @@ int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields)
      case TSDB_DATA_TYPE_NCHAR: {
        int32_t charLen = varDataLen((char *)row[i] - VARSTR_HEADER_SIZE);
        if (fields[i].type == TSDB_DATA_TYPE_BINARY) {
-          assert(charLen <= fields[i].bytes && charLen >= 0);
+          if(ASSERT(charLen <= fields[i].bytes && charLen >= 0)){
+            tscError("taos_print_row error binary. charLen:%d, fields[i].bytes:%d", charLen, fields[i].bytes);
+          }
        } else {
-          assert(charLen <= fields[i].bytes * TSDB_NCHAR_SIZE && charLen >= 0);
+          if(ASSERT(charLen <= fields[i].bytes * TSDB_NCHAR_SIZE && charLen >= 0)){
+            tscError("taos_print_row error. charLen:%d, fields[i].bytes:%d", charLen, fields[i].bytes);
+          }
        }

        memcpy(str + len, row[i], charLen);
@ -577,7 +580,7 @@ int taos_fetch_block_s(TAOS_RES *res, int *numOfRows, TAOS_ROW *rows) {
    (*numOfRows) = pResultInfo->numOfRows;
    return 0;
  } else {
-    ASSERT(0);
+    tscError("taos_fetch_block_s invalid res type");
    return -1;
  }
 }
@ -802,7 +805,7 @@ static void doAsyncQueryFromParse(SMetaData *pResultMeta, void *param, int32_t c
         tstrerror(code));

  if (code == TSDB_CODE_SUCCESS) {
-    //pWrapper->pCatalogReq->forceUpdate = false;
+    // pWrapper->pCatalogReq->forceUpdate = false;
    code = qContinueParseSql(pWrapper->pParseCtx, pWrapper->pCatalogReq, pResultMeta, pQuery);
  }

@ -831,8 +834,8 @@ void continueInsertFromCsv(SSqlCallbackWrapper *pWrapper, SRequestObj *pRequest)
             tstrerror(code), pWrapper->pRequest->requestId);
    destorySqlCallbackWrapper(pWrapper);
    terrno = code;
-    pWrapper->pRequest->code = code;
-    pWrapper->pRequest->body.queryFp(pWrapper->pRequest->body.param, pWrapper->pRequest, code);
+    pRequest->code = code;
+    pRequest->body.queryFp(pRequest->body.param, pRequest, code);
  }
 }

@ -866,7 +869,6 @@ int32_t createParseContext(const SRequestObj *pRequest, SParseContext **pCxt) {
                           .pTransporter = pTscObj->pAppInfo->pTransporter,
                           .pStmtCb = NULL,
                           .pUser = pTscObj->user,
-                           .schemalessType = pTscObj->schemalessType,
                           .isSuperUser = (0 == strcmp(pTscObj->user, TSDB_DEFAULT_USER)),
                           .enableSysInfo = pTscObj->sysInfo,
                           .async = true,
@ -1001,8 +1003,14 @@ static void fetchCallback(void *pResult, void *param, int32_t code) {
 }

 void taos_fetch_rows_a(TAOS_RES *res, __taos_async_fn_t fp, void *param) {
-  ASSERT(res != NULL && fp != NULL);
-  ASSERT(TD_RES_QUERY(res));
+  if(ASSERT(res != NULL && fp != NULL)){
+    tscError("taos_fetch_rows_a invalid paras");
+    return;
+  }
+  if(ASSERT(TD_RES_QUERY(res))){
+    tscError("taos_fetch_rows_a res is NULL");
+    return;
+  }

  SRequestObj *pRequest = res;
  pRequest->body.fetchFp = fp;
@ -1045,9 +1053,14 @@ void taos_fetch_rows_a(TAOS_RES *res, __taos_async_fn_t fp, void *param) {
 }

 void taos_fetch_raw_block_a(TAOS_RES *res, __taos_async_fn_t fp, void *param) {
-  ASSERT(res != NULL && fp != NULL);
-  ASSERT(TD_RES_QUERY(res));
-
+  if(ASSERT(res != NULL && fp != NULL)){
+    tscError("taos_fetch_rows_a invalid paras");
+    return;
+  }
+  if(ASSERT(TD_RES_QUERY(res))){
+    tscError("taos_fetch_rows_a res is NULL");
+    return;
+  }
  SRequestObj    *pRequest = res;
  SReqResultInfo *pResultInfo = &pRequest->body.resInfo;

@ -1059,8 +1072,14 @@ void taos_fetch_raw_block_a(TAOS_RES *res, __taos_async_fn_t fp, void *param) {
 }

 const void *taos_get_raw_block(TAOS_RES *res) {
-  ASSERT(res != NULL);
-  ASSERT(TD_RES_QUERY(res));
+  if(ASSERT(res != NULL)){
+    tscError("taos_fetch_rows_a invalid paras");
+    return NULL;
+  }
+  if(ASSERT(TD_RES_QUERY(res))){
+    tscError("taos_fetch_rows_a res is NULL");
+    return NULL;
+  }
  SRequestObj *pRequest = res;

  return pRequest->body.resInfo.pData;
@ -1168,6 +1187,54 @@ _return:
  return code;
 }

+int taos_get_tables_vgId(TAOS *taos, const char *db, const char *table[], int tableNum, int *vgId) {
+  if (NULL == taos) {
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return terrno;
+  }
+
+  if (NULL == db || NULL == table || NULL == vgId || tableNum <= 0) {
+    tscError("invalid input param, db:%p, table:%p, vgId:%p, tbNum:%d", db, table, vgId, tableNum);
+    terrno = TSDB_CODE_TSC_INVALID_INPUT;
+    return terrno;
+  }
+
+  int64_t      connId = *(int64_t *)taos;
+  SRequestObj *pRequest = NULL;
+  char        *sql = "taos_get_table_vgId";
+  int32_t      code = buildRequest(connId, sql, strlen(sql), NULL, false, &pRequest, 0);
+  if (code != TSDB_CODE_SUCCESS) {
+    return terrno;
+  }
+
+  pRequest->syncQuery = true;
+
+  STscObj  *pTscObj = pRequest->pTscObj;
+  SCatalog *pCtg = NULL;
+  code = catalogGetHandle(pTscObj->pAppInfo->clusterId, &pCtg);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _return;
+  }
+
+  SRequestConnInfo conn = {
+      .pTrans = pTscObj->pAppInfo->pTransporter, .requestId = pRequest->requestId, .requestObjRefId = pRequest->self};
+
+  conn.mgmtEps = getEpSet_s(&pTscObj->pAppInfo->mgmtEp);
+
+  code = catalogGetTablesHashVgId(pCtg, &conn, pTscObj->acctId, db, table, tableNum, vgId);
+  if (code) {
+    goto _return;
+  }
+
+_return:
+
+  terrno = code;
+
+  destroyRequest(pRequest);
+  return code;
+}
+
+
 int taos_load_table_info(TAOS *taos, const char *tableNameList) {
  if (NULL == taos) {
    terrno = TSDB_CODE_TSC_DISCONNECTED;
@ -1331,6 +1398,13 @@ int taos_stmt_get_col_fields(TAOS_STMT *stmt, int *fieldNum, TAOS_FIELD_E **fiel
  return stmtGetColFields(stmt, fieldNum, fields);
 }

+// let stmt to reclaim TAOS_FIELD_E that was allocated by `taos_stmt_get_tag_fields`/`taos_stmt_get_col_fields`
+void taos_stmt_reclaim_fields(TAOS_STMT *stmt, TAOS_FIELD_E *fields) {
+  (void)stmt;
+  if (!fields) return;
+  taosMemoryFree(fields);
+}
+
 int taos_stmt_bind_param(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind) {
  if (stmt == NULL || bind == NULL) {
    tscError("NULL parameter for %s", __FUNCTION__);
--- a/source/client/src/clientMsgHandler.c
+++ b/source/client/src/clientMsgHandler.c
@ -149,7 +149,6 @@ SMsgSendInfo* buildMsgInfoImpl(SRequestObj* pRequest) {
  pMsgSendInfo->msgType = pRequest->type;
  pMsgSendInfo->target.type = TARGET_TYPE_MNODE;

-  assert(pRequest != NULL);
  pMsgSendInfo->msgInfo = pRequest->body.requestMsg;
  pMsgSendInfo->fp = getMsgRspHandle(pRequest->type);
  return pMsgSendInfo;
@ -273,7 +272,9 @@ int32_t processUseDbRsp(void* param, SDataBuf* pMsg, int32_t code) {
 }

 int32_t processCreateSTableRsp(void* param, SDataBuf* pMsg, int32_t code) {
-  assert(pMsg != NULL && param != NULL);
+  if(pMsg == NULL || param == NULL){
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
  SRequestObj* pRequest = param;

  if (code != TSDB_CODE_SUCCESS) {
@ -454,7 +455,10 @@ static int32_t buildShowVariablesRsp(SArray* pVars, SRetrieveTableRsp** pRsp) {
  (*pRsp)->numOfCols = htonl(SHOW_VARIABLES_RESULT_COLS);

  int32_t len = blockEncode(pBlock, (*pRsp)->data, SHOW_VARIABLES_RESULT_COLS);
-  ASSERT(len == rspSize - sizeof(SRetrieveTableRsp));
+  if(len != rspSize - sizeof(SRetrieveTableRsp)){
+    uError("buildShowVariablesRsp error, len:%d != rspSize - sizeof(SRetrieveTableRsp):%" PRIu64, len, (uint64_t) (rspSize - sizeof(SRetrieveTableRsp)));
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }

  blockDataDestroy(pBlock);
  return TSDB_CODE_SUCCESS;
--- a/source/client/src/clientRawBlockWrite.c
+++ b/source/client/src/clientRawBlockWrite.c
--- a/source/client/src/clientSml.c
+++ b/source/client/src/clientSml.c
--- a/source/client/src/clientSmlJson.c
+++ b/source/client/src/clientSmlJson.c
--- a/source/client/src/clientSmlLine.c
+++ b/source/client/src/clientSmlLine.c
@ -0,0 +1,663 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "clientSml.h"
+
+// comma ,
+//#define IS_SLASH_COMMA(sql) (*(sql) == COMMA && *((sql)-1) == SLASH)
+#define IS_COMMA(sql)       (*(sql) == COMMA && *((sql)-1) != SLASH)
+// space
+//#define IS_SLASH_SPACE(sql) (*(sql) == SPACE && *((sql)-1) == SLASH)
+#define IS_SPACE(sql)       (*(sql) == SPACE && *((sql)-1) != SLASH)
+// equal =
+//#define IS_SLASH_EQUAL(sql) (*(sql) == EQUAL && *((sql)-1) == SLASH)
+#define IS_EQUAL(sql)       (*(sql) == EQUAL && *((sql)-1) != SLASH)
+// quote "
+//#define IS_SLASH_QUOTE(sql) (*(sql) == QUOTE && *((sql)-1) == SLASH)
+#define IS_QUOTE(sql)       (*(sql) == QUOTE && *((sql)-1) != SLASH)
+// SLASH
+//#define IS_SLASH_SLASH(sql) (*(sql) == SLASH && *((sql)-1) == SLASH)
+
+#define IS_SLASH_LETTER(sql) \
+  (*((sql)-1) == SLASH && (*(sql) == COMMA || *(sql) == SPACE || *(sql) == EQUAL || *(sql) == QUOTE || *(sql) == SLASH))                          \
+//  (IS_SLASH_COMMA(sql) || IS_SLASH_SPACE(sql) || IS_SLASH_EQUAL(sql) || IS_SLASH_QUOTE(sql) || IS_SLASH_SLASH(sql))
+
+#define MOVE_FORWARD_ONE(sql, len) (memmove((void *)((sql)-1), (sql), len))
+
+#define PROCESS_SLASH(key, keyLen)           \
+  for (int i = 1; i < keyLen; ++i) {         \
+    if (IS_SLASH_LETTER(key + i)) {          \
+      MOVE_FORWARD_ONE(key + i, keyLen - i); \
+      i--;                                   \
+      keyLen--;                              \
+    }                                        \
+  }
+
+#define BINARY_ADD_LEN 2  // "binary"   2 means " "
+#define NCHAR_ADD_LEN  3  // L"nchar"   3 means L" "
+
+uint8_t smlPrecisionConvert[7] = {TSDB_TIME_PRECISION_NANO, TSDB_TIME_PRECISION_HOURS, TSDB_TIME_PRECISION_MINUTES,
+                                  TSDB_TIME_PRECISION_SECONDS, TSDB_TIME_PRECISION_MILLI, TSDB_TIME_PRECISION_MICRO,
+                                  TSDB_TIME_PRECISION_NANO};
+
+static int64_t smlParseInfluxTime(SSmlHandle *info, const char *data, int32_t len) {
+  uint8_t toPrecision = info->currSTableMeta ? info->currSTableMeta->tableInfo.precision : TSDB_TIME_PRECISION_NANO;
+
+  if(unlikely(len == 0 || (len == 1 && data[0] == '0'))){
+    return taosGetTimestampNs()/smlFactorNS[toPrecision];
+  }
+
+  uint8_t fromPrecision = smlPrecisionConvert[info->precision];
+
+  int64_t ts = smlGetTimeValue(data, len, fromPrecision, toPrecision);
+  if (unlikely(ts == -1)) {
+    smlBuildInvalidDataMsg(&info->msgBuf, "invalid timestamp", data);
+    return -1;
+  }
+  return ts;
+}
+
+int32_t smlParseValue(SSmlKv *pVal, SSmlMsgBuf *msg) {
+  if (pVal->value[0] == '"'){  // binary
+    if (pVal->length >= 2 && pVal->value[pVal->length - 1] == '"') {
+      pVal->type = TSDB_DATA_TYPE_BINARY;
+      pVal->length -= BINARY_ADD_LEN;
+      if (pVal->length > TSDB_MAX_BINARY_LEN - VARSTR_HEADER_SIZE) {
+        return TSDB_CODE_PAR_INVALID_VAR_COLUMN_LEN;
+      }
+      pVal->value += (BINARY_ADD_LEN - 1);
+      return TSDB_CODE_SUCCESS;
+    }
+    return TSDB_CODE_TSC_INVALID_VALUE;
+  }
+
+  if(pVal->value[0] == 'l' || pVal->value[0] == 'L'){  // nchar
+    if (pVal->value[1] == '"' && pVal->value[pVal->length - 1] == '"' && pVal->length >= 3){
+      pVal->type = TSDB_DATA_TYPE_NCHAR;
+      pVal->length -= NCHAR_ADD_LEN;
+      if (pVal->length > (TSDB_MAX_NCHAR_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE) {
+        return TSDB_CODE_PAR_INVALID_VAR_COLUMN_LEN;
+      }
+      pVal->value += (NCHAR_ADD_LEN - 1);
+      return TSDB_CODE_SUCCESS;
+    }
+    return TSDB_CODE_TSC_INVALID_VALUE;
+  }
+
+  if (pVal->value[0] == 't' || pVal->value[0] == 'T'){
+    if(pVal->length == 1 || (pVal->length == 4 && (pVal->value[1] == 'r' || pVal->value[1] == 'R')
+                              && (pVal->value[2] == 'u' || pVal->value[2] == 'U')
+                              && (pVal->value[3] == 'e' || pVal->value[3] == 'E'))){
+      pVal->i = TSDB_TRUE;
+      pVal->type = TSDB_DATA_TYPE_BOOL;
+      pVal->length = (int16_t)tDataTypes[pVal->type].bytes;
+      return TSDB_CODE_SUCCESS;
+    }
+    return TSDB_CODE_TSC_INVALID_VALUE;
+  }
+
+  if (pVal->value[0] == 'f' || pVal->value[0] == 'F'){
+    if(pVal->length == 1 || (pVal->length == 5 && (pVal->value[1] == 'a' || pVal->value[1] == 'A')
+                             && (pVal->value[2] == 'l' || pVal->value[2] == 'L')
+                             && (pVal->value[3] == 's' || pVal->value[3] == 'S')
+                             && (pVal->value[4] == 'e' || pVal->value[4] == 'E'))){
+      pVal->i = TSDB_FALSE;
+      pVal->type = TSDB_DATA_TYPE_BOOL;
+      pVal->length = (int16_t)tDataTypes[pVal->type].bytes;
+      return TSDB_CODE_SUCCESS;
+    }
+    return TSDB_CODE_TSC_INVALID_VALUE;
+  }
+
+  // number
+  if (smlParseNumber(pVal, msg)) {
+    pVal->length = (int16_t)tDataTypes[pVal->type].bytes;
+    return TSDB_CODE_SUCCESS;
+  }
+
+  return TSDB_CODE_TSC_INVALID_VALUE;
+}
+
+static int32_t smlParseTagKv(SSmlHandle *info, char **sql, char *sqlEnd,
+                          SSmlLineInfo* currElement, bool isSameMeasure, bool isSameCTable){
+  if(isSameCTable){
+    return TSDB_CODE_SUCCESS;
+  }
+
+  int     cnt = 0;
+  SArray *preLineKV = info->preLineTagKV;
+  SArray *maxKVs = info->maxTagKVs;
+  bool    isSuperKVInit = true;
+  SArray *superKV = NULL;
+  if(info->dataFormat){
+    if(unlikely(!isSameMeasure)){
+      SSmlSTableMeta *sMeta = (SSmlSTableMeta *)nodeListGet(info->superTables, currElement->measure, currElement->measureLen, NULL);
+
+      if(unlikely(sMeta == NULL)){
+        STableMeta * pTableMeta = smlGetMeta(info, currElement->measure, currElement->measureLen);
+        if(pTableMeta == NULL){
+          info->dataFormat = false;
+          info->reRun      = true;
+          return TSDB_CODE_SUCCESS;
+        }
+        sMeta = smlBuildSTableMeta(info->dataFormat);
+        sMeta->tableMeta = pTableMeta;
+        nodeListSet(&info->superTables, currElement->measure, currElement->measureLen, sMeta, NULL);
+      }
+      info->currSTableMeta = sMeta->tableMeta;
+      superKV = sMeta->tags;
+
+      if(unlikely(taosArrayGetSize(superKV) == 0)){
+        isSuperKVInit = false;
+      }
+      taosArraySetSize(maxKVs, 0);
+    }
+  }else{
+    taosArraySetSize(maxKVs, 0);
+  }
+  taosArraySetSize(preLineKV, 0);
+
+  while (*sql < sqlEnd) {
+    if (unlikely(IS_SPACE(*sql))) {
+      break;
+    }
+
+    bool hasSlash = false;
+    // parse key
+    const char *key = *sql;
+    size_t     keyLen = 0;
+    while (*sql < sqlEnd) {
+      if (unlikely(IS_COMMA(*sql))) {
+        smlBuildInvalidDataMsg(&info->msgBuf, "invalid data", *sql);
+        return TSDB_CODE_SML_INVALID_DATA;
+      }
+      if (unlikely(IS_EQUAL(*sql))) {
+        keyLen = *sql - key;
+        (*sql)++;
+        break;
+      }
+      if(!hasSlash){
+        hasSlash = (*(*sql) == SLASH);
+      }
+      (*sql)++;
+    }
+    if(unlikely(hasSlash)) {
+      PROCESS_SLASH(key, keyLen)
+    }
+
+    if (unlikely(IS_INVALID_COL_LEN(keyLen))) {
+      smlBuildInvalidDataMsg(&info->msgBuf, "invalid key or key is too long than 64", key);
+      return TSDB_CODE_TSC_INVALID_COLUMN_LENGTH;
+    }
+
+    // parse value
+    const char *value = *sql;
+    size_t     valueLen = 0;
+    hasSlash = false;
+    while (*sql < sqlEnd) {
+      // parse value
+      if (unlikely(IS_SPACE(*sql) || IS_COMMA(*sql))) {
+        break;
+      }else if (unlikely(IS_EQUAL(*sql))) {
+        smlBuildInvalidDataMsg(&info->msgBuf, "invalid data", *sql);
+        return TSDB_CODE_SML_INVALID_DATA;
+      }
+
+      if(!hasSlash){
+        hasSlash = (*(*sql) == SLASH);
+      }
+
+      (*sql)++;
+    }
+    valueLen = *sql - value;
+
+    if (unlikely(valueLen == 0)) {
+      smlBuildInvalidDataMsg(&info->msgBuf, "invalid value", value);
+      return TSDB_CODE_SML_INVALID_DATA;
+    }
+
+    if(unlikely(hasSlash)) {
+      PROCESS_SLASH(value, valueLen)
+    }
+
+    if (unlikely(valueLen > (TSDB_MAX_NCHAR_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE)) {
+      return TSDB_CODE_PAR_INVALID_VAR_COLUMN_LEN;
+    }
+
+    SSmlKv kv = {.key = key, .keyLen = keyLen, .type = TSDB_DATA_TYPE_NCHAR, .value = value, .length = valueLen};
+    if(info->dataFormat){
+      if(unlikely(cnt + 1 > info->currSTableMeta->tableInfo.numOfTags)){
+        info->dataFormat = false;
+        info->reRun      = true;
+        return TSDB_CODE_SUCCESS;
+      }
+
+      if(isSameMeasure){
+        if(unlikely(cnt >= taosArrayGetSize(maxKVs))) {
+          info->dataFormat = false;
+          info->reRun      = true;
+          return TSDB_CODE_SUCCESS;
+        }
+        SSmlKv *maxKV = (SSmlKv *)taosArrayGet(maxKVs, cnt);
+        if(unlikely(kv.length > maxKV->length)){
+          maxKV->length = kv.length;
+          SSmlSTableMeta *tableMeta = (SSmlSTableMeta *)nodeListGet(info->superTables, currElement->measure, currElement->measureLen, NULL);
+          if(unlikely(NULL == tableMeta)){
+            uError("SML:0x%" PRIx64 " NULL == tableMeta", info->id);
+            return TSDB_CODE_SML_INTERNAL_ERROR;
+          }
+
+          SSmlKv *oldKV = (SSmlKv *)taosArrayGet(tableMeta->tags, cnt);
+          oldKV->length = kv.length;
+          info->needModifySchema = true;
+        }
+        if(unlikely(!IS_SAME_KEY)){
+          info->dataFormat = false;
+          info->reRun      = true;
+          return TSDB_CODE_SUCCESS;
+        }
+      }else{
+        if(isSuperKVInit){
+          if(unlikely(cnt >= taosArrayGetSize(superKV))) {
+            info->dataFormat = false;
+            info->reRun      = true;
+            return TSDB_CODE_SUCCESS;
+          }
+          SSmlKv *maxKV = (SSmlKv *)taosArrayGet(superKV, cnt);
+          if(unlikely(kv.length > maxKV->length)) {
+            maxKV->length = kv.length;
+          }else{
+            kv.length = maxKV->length;
+          }
+          info->needModifySchema = true;
+
+          if(unlikely(!IS_SAME_KEY)){
+            info->dataFormat = false;
+            info->reRun      = true;
+            return TSDB_CODE_SUCCESS;
+          }
+        }else{
+          taosArrayPush(superKV, &kv);
+        }
+        taosArrayPush(maxKVs, &kv);
+      }
+    }else{
+      taosArrayPush(maxKVs, &kv);
+    }
+    taosArrayPush(preLineKV, &kv);
+
+    cnt++;
+    if(IS_SPACE(*sql)){
+      break;
+    }
+    (*sql)++;
+  }
+
+  void* oneTable = nodeListGet(info->childTables, currElement->measure, currElement->measureTagsLen, NULL);
+  if ((oneTable != NULL)) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  SSmlTableInfo *tinfo = smlBuildTableInfo(1, currElement->measure, currElement->measureLen);
+  if (unlikely(!tinfo)) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+  tinfo->tags = taosArrayDup(preLineKV, NULL);
+
+  smlSetCTableName(tinfo);
+  if(info->dataFormat) {
+    info->currSTableMeta->uid = tinfo->uid;
+    tinfo->tableDataCtx = smlInitTableDataCtx(info->pQuery, info->currSTableMeta);
+    if(tinfo->tableDataCtx == NULL){
+      smlBuildInvalidDataMsg(&info->msgBuf, "smlInitTableDataCtx error", NULL);
+      return TSDB_CODE_SML_INVALID_DATA;
+    }
+  }
+
+  nodeListSet(&info->childTables, currElement->measure, currElement->measureTagsLen, tinfo, NULL);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t smlParseColKv(SSmlHandle *info, char **sql, char *sqlEnd,
+                          SSmlLineInfo* currElement, bool isSameMeasure, bool isSameCTable){
+  int     cnt = 0;
+  SArray *preLineKV = info->preLineColKV;
+  bool    isSuperKVInit = true;
+  SArray *superKV = NULL;
+  if(info->dataFormat){
+    if(unlikely(!isSameCTable)){
+      SSmlTableInfo *oneTable = (SSmlTableInfo *)nodeListGet(info->childTables, currElement->measure, currElement->measureTagsLen, NULL);
+      if (unlikely(oneTable == NULL)) {
+        smlBuildInvalidDataMsg(&info->msgBuf, "child table should inside", currElement->measure);
+        return TSDB_CODE_SML_INVALID_DATA;
+      }
+      info->currTableDataCtx = oneTable->tableDataCtx;
+    }
+
+    if(unlikely(!isSameMeasure)){
+      SSmlSTableMeta *sMeta = (SSmlSTableMeta *)nodeListGet(info->superTables, currElement->measure, currElement->measureLen, NULL);
+
+      if(unlikely(sMeta == NULL)){
+        STableMeta * pTableMeta = smlGetMeta(info, currElement->measure, currElement->measureLen);
+        if(pTableMeta == NULL){
+          info->dataFormat = false;
+          info->reRun      = true;
+          return TSDB_CODE_SUCCESS;
+        }
+        sMeta = smlBuildSTableMeta(info->dataFormat);
+        sMeta->tableMeta = pTableMeta;
+        nodeListSet(&info->superTables, currElement->measure, currElement->measureLen, sMeta, NULL);
+      }
+      info->currSTableMeta = sMeta->tableMeta;
+      superKV = sMeta->cols;
+      if(unlikely(taosArrayGetSize(superKV) == 0)){
+        isSuperKVInit = false;
+      }
+      taosArraySetSize(preLineKV, 0);
+    }
+  }
+
+  while (*sql < sqlEnd) {
+    if (unlikely(IS_SPACE(*sql))) {
+      break;
+    }
+
+    bool hasSlash = false;
+    // parse key
+    const char *key = *sql;
+    size_t     keyLen = 0;
+    while (*sql < sqlEnd) {
+      if (unlikely(IS_COMMA(*sql))) {
+        smlBuildInvalidDataMsg(&info->msgBuf, "invalid data", *sql);
+        return TSDB_CODE_SML_INVALID_DATA;
+      }
+      if (unlikely(IS_EQUAL(*sql))) {
+        keyLen = *sql - key;
+        (*sql)++;
+        break;
+      }
+      if(!hasSlash){
+        hasSlash = (*(*sql) == SLASH);
+      }
+      (*sql)++;
+    }
+    if(unlikely(hasSlash)) {
+      PROCESS_SLASH(key, keyLen)
+    }
+
+    if (unlikely(IS_INVALID_COL_LEN(keyLen))) {
+      smlBuildInvalidDataMsg(&info->msgBuf, "invalid key or key is too long than 64", key);
+      return TSDB_CODE_TSC_INVALID_COLUMN_LENGTH;
+    }
+
+    // parse value
+    const char *value = *sql;
+    size_t     valueLen = 0;
+    hasSlash              = false;
+    bool        isInQuote = false;
+    while (*sql < sqlEnd) {
+      // parse value
+      if (unlikely(IS_QUOTE(*sql))) {
+        isInQuote = !isInQuote;
+        (*sql)++;
+        continue;
+      }
+      if (!isInQuote){
+        if (unlikely(IS_SPACE(*sql) || IS_COMMA(*sql))) {
+          break;
+        } else if (unlikely(IS_EQUAL(*sql))) {
+          smlBuildInvalidDataMsg(&info->msgBuf, "invalid data", *sql);
+          return TSDB_CODE_SML_INVALID_DATA;
+        }
+      }
+      if(!hasSlash){
+        hasSlash = (*(*sql) == SLASH);
+      }
+
+      (*sql)++;
+    }
+    valueLen = *sql - value;
+
+    if (unlikely(isInQuote)) {
+      smlBuildInvalidDataMsg(&info->msgBuf, "only one quote", value);
+      return TSDB_CODE_SML_INVALID_DATA;
+    }
+    if (unlikely(valueLen == 0)) {
+      smlBuildInvalidDataMsg(&info->msgBuf, "invalid value", value);
+      return TSDB_CODE_SML_INVALID_DATA;
+    }
+    if(unlikely(hasSlash)) {
+      PROCESS_SLASH(value, valueLen)
+    }
+
+    SSmlKv kv = {.key = key, .keyLen = keyLen, .value = value, .length = valueLen};
+    int32_t ret = smlParseValue(&kv, &info->msgBuf);
+    if (ret != TSDB_CODE_SUCCESS) {
+      smlBuildInvalidDataMsg(&info->msgBuf, "smlParseValue error", value);
+      return ret;
+    }
+
+    if(info->dataFormat){
+      //cnt begin 0, add ts so + 2
+      if(unlikely(cnt + 2 > info->currSTableMeta->tableInfo.numOfColumns)){
+        info->dataFormat = false;
+        info->reRun      = true;
+        return TSDB_CODE_SUCCESS;
+      }
+      // bind data
+      ret = smlBuildCol(info->currTableDataCtx, info->currSTableMeta->schema, &kv, cnt + 1);
+      if (unlikely(ret != TSDB_CODE_SUCCESS)) {
+        uError("smlBuildCol error, retry");
+        info->dataFormat = false;
+        info->reRun      = true;
+        return TSDB_CODE_SUCCESS;
+      }
+
+      if(isSameMeasure){
+        if(cnt >= taosArrayGetSize(preLineKV)) {
+          info->dataFormat = false;
+          info->reRun      = true;
+          return TSDB_CODE_SUCCESS;
+        }
+        SSmlKv *maxKV = (SSmlKv *)taosArrayGet(preLineKV, cnt);
+        if(kv.type != maxKV->type){
+          info->dataFormat = false;
+          info->reRun      = true;
+          return TSDB_CODE_SUCCESS;
+        }
+
+        if(unlikely(IS_VAR_DATA_TYPE(kv.type) && kv.length > maxKV->length)){
+          maxKV->length = kv.length;
+          SSmlSTableMeta *tableMeta = (SSmlSTableMeta *)nodeListGet(info->superTables, currElement->measure, currElement->measureLen, NULL);
+          if(unlikely(NULL == tableMeta)){
+            uError("SML:0x%" PRIx64 " NULL == tableMeta", info->id);
+            return TSDB_CODE_SML_INTERNAL_ERROR;
+          }
+
+          SSmlKv *oldKV = (SSmlKv *)taosArrayGet(tableMeta->cols, cnt);
+          oldKV->length = kv.length;
+          info->needModifySchema = true;
+        }
+        if(unlikely(!IS_SAME_KEY)){
+          info->dataFormat = false;
+          info->reRun      = true;
+          return TSDB_CODE_SUCCESS;
+        }
+      }else{
+        if(isSuperKVInit){
+          if(unlikely(cnt >= taosArrayGetSize(superKV))) {
+            info->dataFormat = false;
+            info->reRun      = true;
+            return TSDB_CODE_SUCCESS;
+          }
+          SSmlKv *maxKV = (SSmlKv *)taosArrayGet(superKV, cnt);
+          if(unlikely(kv.type != maxKV->type)){
+            info->dataFormat = false;
+            info->reRun      = true;
+            return TSDB_CODE_SUCCESS;
+          }
+
+          if(IS_VAR_DATA_TYPE(kv.type)){
+            if(kv.length > maxKV->length) {
+              maxKV->length = kv.length;
+            }else{
+              kv.length = maxKV->length;
+            }
+            info->needModifySchema = true;
+          }
+          if(unlikely(!IS_SAME_KEY)){
+            info->dataFormat = false;
+            info->reRun      = true;
+            return TSDB_CODE_SUCCESS;
+          }
+        }else{
+          taosArrayPush(superKV, &kv);
+        }
+        taosArrayPush(preLineKV, &kv);
+      }
+    }else{
+      if(currElement->colArray == NULL){
+        currElement->colArray = taosArrayInit(16, sizeof(SSmlKv));
+        taosArraySetSize(currElement->colArray, 1);
+      }
+      taosArrayPush(currElement->colArray, &kv);   //reserve for timestamp
+    }
+
+    cnt++;
+    if(IS_SPACE(*sql)){
+      break;
+    }
+    (*sql)++;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t smlParseInfluxString(SSmlHandle *info, char *sql, char *sqlEnd, SSmlLineInfo *elements) {
+  if (!sql) return TSDB_CODE_SML_INVALID_DATA;
+  JUMP_SPACE(sql, sqlEnd)
+  if (unlikely(*sql == COMMA)) return TSDB_CODE_SML_INVALID_DATA;
+  elements->measure = sql;
+
+  // parse measure
+  while (sql < sqlEnd) {
+    if (unlikely((sql != elements->measure) && IS_SLASH_LETTER(sql))) {
+      MOVE_FORWARD_ONE(sql, sqlEnd - sql);
+      sqlEnd--;
+      continue;
+    }
+    if (unlikely(IS_COMMA(sql))) {
+      break;
+    }
+
+    if (unlikely(IS_SPACE(sql))) {
+      break;
+    }
+    sql++;
+  }
+  elements->measureLen = sql - elements->measure;
+  if (unlikely(IS_INVALID_TABLE_LEN(elements->measureLen))) {
+    smlBuildInvalidDataMsg(&info->msgBuf, "measure is empty or too large than 192", NULL);
+    return TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
+  }
+
+  // to get measureTagsLen before
+  const char* tmp = sql;
+  while (tmp < sqlEnd){
+    if (unlikely(IS_SPACE(tmp))) {
+      break;
+    }
+    tmp++;
+  }
+  elements->measureTagsLen = tmp - elements->measure;
+
+  bool isSameCTable = false;
+  bool isSameMeasure = false;
+  if(IS_SAME_CHILD_TABLE){
+    isSameCTable = true;
+    isSameMeasure = true;
+  }else if(info->dataFormat) {
+    isSameMeasure = IS_SAME_SUPER_TABLE;
+  }
+  // parse tag
+  if (*sql == COMMA) sql++;
+  elements->tags = sql;
+
+  int ret = smlParseTagKv(info, &sql, sqlEnd, elements, isSameMeasure, isSameCTable);
+  if(unlikely(ret != TSDB_CODE_SUCCESS)){
+    return ret;
+  }
+  if(unlikely(info->reRun)){
+    return TSDB_CODE_SUCCESS;
+  }
+
+  sql = elements->measure + elements->measureTagsLen;
+  elements->tagsLen = sql - elements->tags;
+
+  // parse cols
+  JUMP_SPACE(sql, sqlEnd)
+  elements->cols = sql;
+
+  ret = smlParseColKv(info, &sql, sqlEnd, elements, isSameMeasure, isSameCTable);
+  if(unlikely(ret != TSDB_CODE_SUCCESS)){
+    return ret;
+  }
+
+  if(unlikely(info->reRun)){
+    return TSDB_CODE_SUCCESS;
+  }
+
+  elements->colsLen = sql - elements->cols;
+  if (unlikely(elements->colsLen == 0)) {
+    smlBuildInvalidDataMsg(&info->msgBuf, "cols is empty", NULL);
+    return TSDB_CODE_SML_INVALID_DATA;
+  }
+
+  // parse timestamp
+  JUMP_SPACE(sql, sqlEnd)
+  elements->timestamp = sql;
+  while (sql < sqlEnd) {
+    if (unlikely(isspace(*sql))) {
+      break;
+    }
+    sql++;
+  }
+  elements->timestampLen = sql - elements->timestamp;
+
+  int64_t ts = smlParseInfluxTime(info, elements->timestamp, elements->timestampLen);
+  if (unlikely(ts <= 0)) {
+    uError("SML:0x%" PRIx64 " smlParseTS error:%" PRId64, info->id, ts);
+    return TSDB_CODE_INVALID_TIMESTAMP;
+  }
+  // add ts to
+  SSmlKv kv = { .key = TS, .keyLen = TS_LEN, .type = TSDB_DATA_TYPE_TIMESTAMP, .i = ts, .length = (size_t)tDataTypes[TSDB_DATA_TYPE_TIMESTAMP].bytes};
+  if(info->dataFormat){
+    smlBuildCol(info->currTableDataCtx, info->currSTableMeta->schema, &kv, 0);
+    smlBuildRow(info->currTableDataCtx);
+    clearColValArray(info->currTableDataCtx->pValues);
+  }else{
+    taosArraySet(elements->colArray, 0, &kv);
+  }
+  info->preLine = *elements;
+
+  return ret;
+}
+
--- a/source/client/src/clientSmlTelnet.c
+++ b/source/client/src/clientSmlTelnet.c
@ -0,0 +1,346 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "clientSml.h"
+
+int32_t is_same_child_table_telnet(const void *a, const void *b){
+  SSmlLineInfo *t1 = (SSmlLineInfo *)a;
+  SSmlLineInfo *t2 = (SSmlLineInfo *)b;
+//  uError("is_same_child_table_telnet len:%d,%d %s,%s @@@ len:%d,%d %s,%s", t1->measureLen, t2->measureLen,
+//         t1->measure, t2->measure, t1->tagsLen, t2->tagsLen, t1->tags, t2->tags);
+  if(t1 == NULL || t2 == NULL || t1->measure == NULL || t2->measure == NULL
+      || t1->tags == NULL || t2->tags == NULL)
+    return 1;
+  return (((t1->measureLen == t2->measureLen) && memcmp(t1->measure, t2->measure, t1->measureLen) == 0)
+          && ((t1->tagsLen == t2->tagsLen) && memcmp(t1->tags, t2->tags, t1->tagsLen) == 0)) ? 0 : 1;
+}
+
+int64_t smlParseOpenTsdbTime(SSmlHandle *info, const char *data, int32_t len) {
+  uint8_t toPrecision = info->currSTableMeta ? info->currSTableMeta->tableInfo.precision : TSDB_TIME_PRECISION_NANO;
+
+  if (unlikely(!data)) {
+    smlBuildInvalidDataMsg(&info->msgBuf, "timestamp can not be null", NULL);
+    return -1;
+  }
+  if (unlikely(len == 1 && data[0] == '0')) {
+    return taosGetTimestampNs()/smlFactorNS[toPrecision];
+  }
+  int8_t fromPrecision = smlGetTsTypeByLen(len);
+  if (unlikely(fromPrecision == -1)) {
+    smlBuildInvalidDataMsg(&info->msgBuf,
+                           "timestamp precision can only be seconds(10 digits) or milli seconds(13 digits)", data);
+    return -1;
+  }
+  int64_t ts = smlGetTimeValue(data, len, fromPrecision, toPrecision);
+  if (unlikely(ts == -1)) {
+    smlBuildInvalidDataMsg(&info->msgBuf, "invalid timestamp", data);
+    return -1;
+  }
+  return ts;
+}
+
+
+static void smlParseTelnetElement(char **sql, char *sqlEnd, char **data, int32_t *len) {
+  while (*sql < sqlEnd) {
+    if (unlikely((**sql != SPACE && !(*data)))) {
+      *data = *sql;
+    } else if (unlikely(**sql == SPACE && *data)) {
+      *len = *sql - *data;
+      break;
+    }
+    (*sql)++;
+  }
+}
+
+static int32_t smlParseTelnetTags(SSmlHandle *info, char *data, char *sqlEnd, SSmlLineInfo *elements, SSmlMsgBuf *msg) {
+  if(is_same_child_table_telnet(elements, &info->preLine) == 0){
+    return TSDB_CODE_SUCCESS;
+  }
+
+  bool isSameMeasure = IS_SAME_SUPER_TABLE;
+
+  int     cnt = 0;
+  SArray *preLineKV = info->preLineTagKV;
+  SArray *maxKVs = info->maxTagKVs;
+  bool    isSuperKVInit = true;
+  SArray *superKV = NULL;
+  if(info->dataFormat){
+    if(!isSameMeasure){
+      SSmlSTableMeta *sMeta = (SSmlSTableMeta *)nodeListGet(info->superTables, elements->measure, elements->measureLen, NULL);
+
+      if(unlikely(sMeta == NULL)){
+        STableMeta * pTableMeta = smlGetMeta(info, elements->measure, elements->measureLen);
+        if(pTableMeta == NULL){
+          info->dataFormat = false;
+          info->reRun      = true;
+          return TSDB_CODE_SUCCESS;
+        }
+        sMeta = smlBuildSTableMeta(info->dataFormat);
+        sMeta->tableMeta = pTableMeta;
+        nodeListSet(&info->superTables, elements->measure, elements->measureLen, sMeta, NULL);
+      }
+      info->currSTableMeta = sMeta->tableMeta;
+      superKV = sMeta->tags;
+
+      if(unlikely(taosArrayGetSize(superKV) == 0)){
+        isSuperKVInit = false;
+      }
+      taosArraySetSize(maxKVs, 0);
+    }
+  }else{
+    taosArraySetSize(maxKVs, 0);
+  }
+
+  taosArraySetSize(preLineKV, 0);
+  const char *sql = data;
+  while (sql < sqlEnd) {
+    JUMP_SPACE(sql, sqlEnd)
+    if (unlikely(*sql == '\0')) break;
+
+    const char *key = sql;
+    size_t     keyLen = 0;
+
+    // parse key
+    while (sql < sqlEnd) {
+      if (unlikely(*sql == SPACE)) {
+        smlBuildInvalidDataMsg(msg, "invalid data", sql);
+        return TSDB_CODE_SML_INVALID_DATA;
+      }
+      if (unlikely(*sql == EQUAL)) {
+        keyLen = sql - key;
+        sql++;
+        break;
+      }
+      sql++;
+    }
+
+    if (unlikely(IS_INVALID_COL_LEN(keyLen))) {
+      smlBuildInvalidDataMsg(msg, "invalid key or key is too long than 64", key);
+      return TSDB_CODE_TSC_INVALID_COLUMN_LENGTH;
+    }
+//    if (smlCheckDuplicateKey(key, keyLen, dumplicateKey)) {
+//      smlBuildInvalidDataMsg(msg, "dumplicate key", key);
+//      return TSDB_CODE_TSC_DUP_NAMES;
+//    }
+
+    // parse value
+    const char *value = sql;
+    size_t     valueLen = 0;
+    while (sql < sqlEnd) {
+      // parse value
+      if (unlikely(*sql == SPACE)) {
+        break;
+      }
+      if (unlikely(*sql == EQUAL)) {
+        smlBuildInvalidDataMsg(msg, "invalid data", sql);
+        return TSDB_CODE_SML_INVALID_DATA;
+      }
+      sql++;
+    }
+    valueLen = sql - value;
+
+    if (unlikely(valueLen == 0)) {
+      smlBuildInvalidDataMsg(msg, "invalid value", value);
+      return TSDB_CODE_TSC_INVALID_VALUE;
+    }
+
+    if (unlikely(valueLen > (TSDB_MAX_NCHAR_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE)) {
+      return TSDB_CODE_PAR_INVALID_VAR_COLUMN_LEN;
+    }
+
+    SSmlKv kv = {.key = key, .keyLen = keyLen, .type = TSDB_DATA_TYPE_NCHAR, .value = value, .length = valueLen};
+
+    if(info->dataFormat){
+      if(unlikely(cnt + 1 > info->currSTableMeta->tableInfo.numOfTags)){
+        info->dataFormat = false;
+        info->reRun      = true;
+        return TSDB_CODE_SUCCESS;
+      }
+
+      if(isSameMeasure){
+        if(unlikely(cnt >= taosArrayGetSize(maxKVs))) {
+          info->dataFormat = false;
+          info->reRun      = true;
+          return TSDB_CODE_SUCCESS;
+        }
+        SSmlKv *maxKV = (SSmlKv *)taosArrayGet(maxKVs, cnt);
+        if(unlikely(kv.length > maxKV->length)){
+          maxKV->length = kv.length;
+          SSmlSTableMeta *tableMeta = (SSmlSTableMeta *)nodeListGet(info->superTables, elements->measure, elements->measureLen, NULL);
+          if(unlikely(NULL == tableMeta)){
+            uError("SML:0x%" PRIx64 " NULL == tableMeta", info->id);
+            return TSDB_CODE_SML_INTERNAL_ERROR;
+          }
+
+          SSmlKv *oldKV = (SSmlKv *)taosArrayGet(tableMeta->tags, cnt);
+          oldKV->length = kv.length;
+          info->needModifySchema = true;
+        }
+        if(unlikely(!IS_SAME_KEY)){
+          info->dataFormat = false;
+          info->reRun      = true;
+          return TSDB_CODE_SUCCESS;
+        }
+      }else{
+        if(isSuperKVInit){
+          if(unlikely(cnt >= taosArrayGetSize(superKV))) {
+            info->dataFormat = false;
+            info->reRun      = true;
+            return TSDB_CODE_SUCCESS;
+          }
+          SSmlKv *maxKV = (SSmlKv *)taosArrayGet(superKV, cnt);
+          if(unlikely(kv.length > maxKV->length)) {
+            maxKV->length = kv.length;
+          }else{
+            kv.length = maxKV->length;
+          }
+          info->needModifySchema = true;
+
+          if(unlikely(!IS_SAME_KEY)){
+            info->dataFormat = false;
+            info->reRun      = true;
+            return TSDB_CODE_SUCCESS;
+          }
+        }else{
+          taosArrayPush(superKV, &kv);
+        }
+        taosArrayPush(maxKVs, &kv);
+      }
+    }else{
+      taosArrayPush(maxKVs, &kv);
+    }
+    taosArrayPush(preLineKV, &kv);
+    cnt++;
+  }
+  SSmlTableInfo *tinfo = (SSmlTableInfo *)nodeListGet(info->childTables, elements, POINTER_BYTES, is_same_child_table_telnet);
+  if (unlikely(tinfo == NULL)) {
+    tinfo = smlBuildTableInfo(1, elements->measure, elements->measureLen);
+    if (!tinfo) {
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
+    tinfo->tags = taosArrayDup(preLineKV, NULL);
+
+    smlSetCTableName(tinfo);
+    if (info->dataFormat) {
+      info->currSTableMeta->uid = tinfo->uid;
+      tinfo->tableDataCtx = smlInitTableDataCtx(info->pQuery, info->currSTableMeta);
+      if (tinfo->tableDataCtx == NULL) {
+        smlBuildInvalidDataMsg(&info->msgBuf, "smlInitTableDataCtx error", NULL);
+        smlDestroyTableInfo(info, tinfo);
+        return TSDB_CODE_SML_INVALID_DATA;
+      }
+    }
+
+    SSmlLineInfo *key = (SSmlLineInfo *)taosMemoryMalloc(sizeof(SSmlLineInfo));
+    *key = *elements;
+    tinfo->key = key;
+    nodeListSet(&info->childTables, key, POINTER_BYTES, tinfo, is_same_child_table_telnet);
+  }
+  if (info->dataFormat) info->currTableDataCtx = tinfo->tableDataCtx;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+// format: <metric> <timestamp> <value> <tagk_1>=<tagv_1>[ <tagk_n>=<tagv_n>]
+int32_t smlParseTelnetString(SSmlHandle *info, char *sql, char *sqlEnd, SSmlLineInfo *elements) {
+  if (!sql) return TSDB_CODE_SML_INVALID_DATA;
+
+  // parse metric
+  smlParseTelnetElement(&sql, sqlEnd, &elements->measure, &elements->measureLen);
+  if (unlikely((!(elements->measure) || IS_INVALID_TABLE_LEN(elements->measureLen)))) {
+    smlBuildInvalidDataMsg(&info->msgBuf, "invalid data", sql);
+    return TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
+  }
+
+  // parse timestamp
+  smlParseTelnetElement(&sql, sqlEnd, &elements->timestamp, &elements->timestampLen);
+  if (unlikely(!elements->timestamp || elements->timestampLen == 0)) {
+    smlBuildInvalidDataMsg(&info->msgBuf, "invalid timestamp", sql);
+    return TSDB_CODE_SML_INVALID_DATA;
+  }
+
+  bool needConverTime = false;  // get TS before parse tag(get meta), so need conver time
+  if(info->dataFormat && info->currSTableMeta == NULL){
+    needConverTime = true;
+  }
+  int64_t ts = smlParseOpenTsdbTime(info, elements->timestamp, elements->timestampLen);
+  if (unlikely(ts < 0)) {
+    smlBuildInvalidDataMsg(&info->msgBuf, "invalid timestamp", sql);
+    return TSDB_CODE_INVALID_TIMESTAMP;
+  }
+  SSmlKv kvTs = { .key = TS, .keyLen = TS_LEN, .type = TSDB_DATA_TYPE_TIMESTAMP, .i = ts, .length = (size_t)tDataTypes[TSDB_DATA_TYPE_TIMESTAMP].bytes};
+
+  // parse value
+  smlParseTelnetElement(&sql, sqlEnd, &elements->cols, &elements->colsLen);
+  if (unlikely(!elements->cols || elements->colsLen == 0)) {
+    smlBuildInvalidDataMsg(&info->msgBuf, "invalid value", sql);
+    return TSDB_CODE_TSC_INVALID_VALUE;
+  }
+
+  SSmlKv kv = {.key = VALUE, .keyLen = VALUE_LEN, .value = elements->cols, .length = (size_t)elements->colsLen};
+  if (smlParseValue(&kv, &info->msgBuf) != TSDB_CODE_SUCCESS) {
+    return TSDB_CODE_TSC_INVALID_VALUE;
+  }
+
+  JUMP_SPACE(sql, sqlEnd)
+
+  elements->tags = sql;
+  elements->tagsLen = sqlEnd - sql;
+  if (unlikely(!elements->tags || elements->tagsLen == 0)) {
+    smlBuildInvalidDataMsg(&info->msgBuf, "invalid value", sql);
+    return TSDB_CODE_TSC_INVALID_VALUE;
+  }
+
+  int ret = smlParseTelnetTags(info, sql, sqlEnd, elements, &info->msgBuf);
+  if (unlikely(ret != TSDB_CODE_SUCCESS)) {
+    return ret;
+  }
+
+  if(unlikely(info->reRun)){
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if(info->dataFormat){
+    if(needConverTime) {
+      kvTs.i = convertTimePrecision(kvTs.i, TSDB_TIME_PRECISION_NANO, info->currSTableMeta->tableInfo.precision);
+    }
+    ret = smlBuildCol(info->currTableDataCtx, info->currSTableMeta->schema, &kvTs, 0);
+    if(ret == TSDB_CODE_SUCCESS){
+      ret = smlBuildCol(info->currTableDataCtx, info->currSTableMeta->schema, &kv, 1);
+    }
+    if(ret == TSDB_CODE_SUCCESS){
+      ret = smlBuildRow(info->currTableDataCtx);
+    }
+    clearColValArray(info->currTableDataCtx->pValues);
+    if (unlikely(ret != TSDB_CODE_SUCCESS)) {
+      smlBuildInvalidDataMsg(&info->msgBuf, "smlBuildCol error", NULL);
+      return ret;
+    }
+  }else{
+    if(elements->colArray == NULL){
+      elements->colArray = taosArrayInit(16, sizeof(SSmlKv));
+    }
+    taosArrayPush(elements->colArray, &kvTs);
+    taosArrayPush(elements->colArray, &kv);
+  }
+  info->preLine = *elements;
+
+  return TSDB_CODE_SUCCESS;
+}
--- a/source/client/src/clientStmt.c
+++ b/source/client/src/clientStmt.c
@ -152,9 +152,10 @@ int32_t stmtRestoreQueryFields(STscStmt* pStmt) {
  return TSDB_CODE_SUCCESS;
 }

-int32_t stmtUpdateBindInfo(TAOS_STMT* stmt, STableMeta* pTableMeta, void* tags, SName* tbName, const char* sTableName, bool autoCreateTbl) {
+int32_t stmtUpdateBindInfo(TAOS_STMT* stmt, STableMeta* pTableMeta, void* tags, SName* tbName, const char* sTableName,
+                           bool autoCreateTbl) {
  STscStmt* pStmt = (STscStmt*)stmt;
-  char           tbFName[TSDB_TABLE_FNAME_LEN];
+  char      tbFName[TSDB_TABLE_FNAME_LEN];
  tNameExtractFullName(tbName, tbFName);

  memcpy(&pStmt->bInfo.sname, tbName, sizeof(*tbName));
@ -171,12 +172,11 @@ int32_t stmtUpdateBindInfo(TAOS_STMT* stmt, STableMeta* pTableMeta, void* tags,
  return TSDB_CODE_SUCCESS;
 }

-int32_t stmtUpdateExecInfo(TAOS_STMT* stmt, SHashObj* pVgHash, SHashObj* pBlockHash, bool autoCreateTbl) {
+int32_t stmtUpdateExecInfo(TAOS_STMT* stmt, SHashObj* pVgHash, SHashObj* pBlockHash) {
  STscStmt* pStmt = (STscStmt*)stmt;

  pStmt->sql.pVgHash = pVgHash;
  pStmt->exec.pBlockHash = pBlockHash;
-  pStmt->exec.autoCreateTbl = autoCreateTbl;

  return TSDB_CODE_SUCCESS;
 }
@ -186,7 +186,7 @@ int32_t stmtUpdateInfo(TAOS_STMT* stmt, STableMeta* pTableMeta, void* tags, SNam
  STscStmt* pStmt = (STscStmt*)stmt;

  STMT_ERR_RET(stmtUpdateBindInfo(stmt, pTableMeta, tags, tbName, sTableName, autoCreateTbl));
-  STMT_ERR_RET(stmtUpdateExecInfo(stmt, pVgHash, pBlockHash, autoCreateTbl));
+  STMT_ERR_RET(stmtUpdateExecInfo(stmt, pVgHash, pBlockHash));

  pStmt->sql.autoCreateTbl = autoCreateTbl;

@ -214,16 +214,16 @@ int32_t stmtCacheBlock(STscStmt* pStmt) {
    return TSDB_CODE_SUCCESS;
  }

-  STableDataBlocks** pSrc = taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
+  STableDataCxt** pSrc = taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
  if (!pSrc) {
    return TSDB_CODE_OUT_OF_MEMORY;
  }
-  STableDataBlocks* pDst = NULL;
+  STableDataCxt* pDst = NULL;

-  STMT_ERR_RET(qCloneStmtDataBlock(&pDst, *pSrc));
+  STMT_ERR_RET(qCloneStmtDataBlock(&pDst, *pSrc, true));

  SStmtTableCache cache = {
-      .pDataBlock = pDst,
+      .pDataCtx = pDst,
      .boundTags = pStmt->bInfo.boundTags,
  };

@ -241,6 +241,8 @@ int32_t stmtCacheBlock(STscStmt* pStmt) {
 }

 int32_t stmtParseSql(STscStmt* pStmt) {
+  pStmt->exec.pCurrBlock = NULL;
+
  SStmtCallback stmtCb = {
      .pStmt = pStmt,
      .getTbNameFn = stmtGetTbName,
@ -273,7 +275,7 @@ int32_t stmtCleanBindInfo(STscStmt* pStmt) {
  pStmt->bInfo.tbName[0] = 0;
  pStmt->bInfo.tbFName[0] = 0;
  if (!pStmt->bInfo.tagsCached) {
-    destroyBoundColumnInfo(pStmt->bInfo.boundTags);
+    qDestroyBoundColInfo(pStmt->bInfo.boundTags);
    taosMemoryFreeClear(pStmt->bInfo.boundTags);
  }
  memset(pStmt->bInfo.stbFName, 0, TSDB_TABLE_FNAME_LEN);
@ -289,29 +291,24 @@ int32_t stmtCleanExecInfo(STscStmt* pStmt, bool keepTable, bool deepClean) {
  size_t keyLen = 0;
  void*  pIter = taosHashIterate(pStmt->exec.pBlockHash, NULL);
  while (pIter) {
-    STableDataBlocks* pBlocks = *(STableDataBlocks**)pIter;
-    char*             key = taosHashGetKey(pIter, &keyLen);
-    STableMeta*       pMeta = qGetTableMetaInDataBlock(pBlocks);
+    STableDataCxt* pBlocks = *(STableDataCxt**)pIter;
+    char*          key = taosHashGetKey(pIter, &keyLen);
+    STableMeta*    pMeta = qGetTableMetaInDataBlock(pBlocks);

-    if (keepTable && (strlen(pStmt->bInfo.tbFName) == keyLen) && strncmp(pStmt->bInfo.tbFName, key, keyLen) == 0) {
-      STMT_ERR_RET(qResetStmtDataBlock(pBlocks, true));
+    if (keepTable && pBlocks == pStmt->exec.pCurrBlock) {
+      TSWAP(pBlocks->pData, pStmt->exec.pCurrTbData);
+      STMT_ERR_RET(qResetStmtDataBlock(pBlocks, false));

      pIter = taosHashIterate(pStmt->exec.pBlockHash, pIter);
      continue;
    }

-    if (STMT_TYPE_MULTI_INSERT == pStmt->sql.type) {
-      qFreeStmtDataBlock(pBlocks);
-    } else {
-      qDestroyStmtDataBlock(pBlocks);
-    }
+    qDestroyStmtDataBlock(pBlocks);
    taosHashRemove(pStmt->exec.pBlockHash, key, keyLen);

    pIter = taosHashIterate(pStmt->exec.pBlockHash, pIter);
  }

-  pStmt->exec.autoCreateTbl = false;
-
  if (keepTable) {
    return TSDB_CODE_SUCCESS;
  }
@ -319,6 +316,9 @@ int32_t stmtCleanExecInfo(STscStmt* pStmt, bool keepTable, bool deepClean) {
  taosHashCleanup(pStmt->exec.pBlockHash);
  pStmt->exec.pBlockHash = NULL;

+  tDestroySSubmitTbData(pStmt->exec.pCurrTbData, TSDB_MSG_FLG_ENCODE);
+  taosMemoryFreeClear(pStmt->exec.pCurrTbData);
+
  STMT_ERR_RET(stmtCleanBindInfo(pStmt));

  return TSDB_CODE_SUCCESS;
@ -337,8 +337,8 @@ int32_t stmtCleanSQLInfo(STscStmt* pStmt) {
  while (pIter) {
    SStmtTableCache* pCache = (SStmtTableCache*)pIter;

-    qDestroyStmtDataBlock(pCache->pDataBlock);
-    destroyBoundColumnInfo(pCache->boundTags);
+    qDestroyStmtDataBlock(pCache->pDataCtx);
+    qDestroyBoundColInfo(pCache->boundTags);
    taosMemoryFreeClear(pCache->boundTags);

    pIter = taosHashIterate(pStmt->sql.pTableCache, pIter);
@ -354,7 +354,8 @@ int32_t stmtCleanSQLInfo(STscStmt* pStmt) {
  return TSDB_CODE_SUCCESS;
 }

-int32_t stmtRebuildDataBlock(STscStmt* pStmt, STableDataBlocks* pDataBlock, STableDataBlocks** newBlock, uint64_t uid) {
+int32_t stmtRebuildDataBlock(STscStmt* pStmt, STableDataCxt* pDataBlock, STableDataCxt** newBlock, uint64_t uid,
+                             uint64_t suid) {
  SEpSet           ep = getEpSet_s(&pStmt->taos->pAppInfo->mgmtEp);
  SVgroupInfo      vgInfo = {0};
  SRequestConnInfo conn = {.pTrans = pStmt->taos->pAppInfo->pTransporter,
@ -366,7 +367,9 @@ int32_t stmtRebuildDataBlock(STscStmt* pStmt, STableDataBlocks* pDataBlock, STab
  STMT_ERR_RET(
      taosHashPut(pStmt->sql.pVgHash, (const char*)&vgInfo.vgId, sizeof(vgInfo.vgId), (char*)&vgInfo, sizeof(vgInfo)));

-  STMT_ERR_RET(qRebuildStmtDataBlock(newBlock, pDataBlock, uid, vgInfo.vgId));
+  STMT_ERR_RET(qRebuildStmtDataBlock(newBlock, pDataBlock, uid, suid, vgInfo.vgId, pStmt->sql.autoCreateTbl));
+
+  STMT_DLOG("tableDataCxt rebuilt, uid:%" PRId64 ", vgId:%d", uid, vgInfo.vgId);

  return TSDB_CODE_SUCCESS;
 }
@ -375,12 +378,13 @@ int32_t stmtGetFromCache(STscStmt* pStmt) {
  pStmt->bInfo.needParse = true;
  pStmt->bInfo.inExecCache = false;

-  STableDataBlocks* pBlockInExec =
-      taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
-  if (pBlockInExec) {
+  STableDataCxt** pCxtInExec = taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
+  if (pCxtInExec) {
    pStmt->bInfo.needParse = false;
    pStmt->bInfo.inExecCache = true;

+    pStmt->exec.pCurrBlock = *pCxtInExec;
+
    if (pStmt->sql.autoCreateTbl) {
      tscDebug("reuse stmt block for tb %s in execBlock", pStmt->bInfo.tbFName);
      return TSDB_CODE_SUCCESS;
@ -389,7 +393,10 @@ int32_t stmtGetFromCache(STscStmt* pStmt) {

  if (NULL == pStmt->sql.pTableCache || taosHashGetSize(pStmt->sql.pTableCache) <= 0) {
    if (pStmt->bInfo.inExecCache) {
-      ASSERT(taosHashGetSize(pStmt->exec.pBlockHash) == 1);
+      if(ASSERT(taosHashGetSize(pStmt->exec.pBlockHash) == 1)){
+        tscError("stmtGetFromCache error");
+        return TSDB_CODE_TSC_STMT_CACHE_ERROR;
+      }
      pStmt->bInfo.needParse = false;
      tscDebug("reuse stmt block for tb %s in execBlock", pStmt->bInfo.tbFName);
      return TSDB_CODE_SUCCESS;
@ -407,18 +414,18 @@ int32_t stmtGetFromCache(STscStmt* pStmt) {
    SStmtTableCache* pCache = taosHashGet(pStmt->sql.pTableCache, &pStmt->bInfo.tbSuid, sizeof(pStmt->bInfo.tbSuid));
    if (pCache) {
      pStmt->bInfo.needParse = false;
-      pStmt->exec.autoCreateTbl = true;
-
      pStmt->bInfo.tbUid = 0;

-      STableDataBlocks* pNewBlock = NULL;
-      STMT_ERR_RET(stmtRebuildDataBlock(pStmt, pCache->pDataBlock, &pNewBlock, 0));
+      STableDataCxt* pNewBlock = NULL;
+      STMT_ERR_RET(stmtRebuildDataBlock(pStmt, pCache->pDataCtx, &pNewBlock, 0, pStmt->bInfo.tbSuid));

      if (taosHashPut(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName), &pNewBlock,
                      POINTER_BYTES)) {
        STMT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
      }

+      pStmt->exec.pCurrBlock = pNewBlock;
+
      tscDebug("reuse stmt block for tb %s in sqlBlock, suid:0x%" PRIx64, pStmt->bInfo.tbFName, pStmt->bInfo.tbSuid);

      return TSDB_CODE_SUCCESS;
@ -489,14 +496,16 @@ int32_t stmtGetFromCache(STscStmt* pStmt) {
    pStmt->bInfo.boundTags = pCache->boundTags;
    pStmt->bInfo.tagsCached = true;

-    STableDataBlocks* pNewBlock = NULL;
-    STMT_ERR_RET(stmtRebuildDataBlock(pStmt, pCache->pDataBlock, &pNewBlock, uid));
+    STableDataCxt* pNewBlock = NULL;
+    STMT_ERR_RET(stmtRebuildDataBlock(pStmt, pCache->pDataCtx, &pNewBlock, uid, suid));

    if (taosHashPut(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName), &pNewBlock,
                    POINTER_BYTES)) {
      STMT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
    }

+    pStmt->exec.pCurrBlock = pNewBlock;
+
    tscDebug("tb %s in sqlBlock list, set to current", pStmt->bInfo.tbFName);

    return TSDB_CODE_SUCCESS;
@ -614,8 +623,8 @@ int stmtSetTbTags(TAOS_STMT* stmt, TAOS_MULTI_BIND* tags) {
    return TSDB_CODE_SUCCESS;
  }

-  STableDataBlocks** pDataBlock =
-      (STableDataBlocks**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
+  STableDataCxt** pDataBlock =
+      (STableDataCxt**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
  if (NULL == pDataBlock) {
    tscError("table %s not found in exec blockHash", pStmt->bInfo.tbFName);
    STMT_ERR_RET(TSDB_CODE_APP_ERROR);
@ -626,8 +635,6 @@ int stmtSetTbTags(TAOS_STMT* stmt, TAOS_MULTI_BIND* tags) {
                                  pStmt->bInfo.sname.tname, tags, pStmt->exec.pRequest->msgBuf,
                                  pStmt->exec.pRequest->msgBufLen));

-  pStmt->exec.autoCreateTbl = true;
-
  return TSDB_CODE_SUCCESS;
 }

@ -637,8 +644,8 @@ int stmtFetchTagFields(STscStmt* pStmt, int32_t* fieldNum, TAOS_FIELD_E** fields
    STMT_ERR_RET(TSDB_CODE_TSC_STMT_API_ERROR);
  }

-  STableDataBlocks** pDataBlock =
-      (STableDataBlocks**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
+  STableDataCxt** pDataBlock =
+      (STableDataCxt**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
  if (NULL == pDataBlock) {
    tscError("table %s not found in exec blockHash", pStmt->bInfo.tbFName);
    STMT_ERR_RET(TSDB_CODE_APP_ERROR);
@ -655,8 +662,8 @@ int stmtFetchColFields(STscStmt* pStmt, int32_t* fieldNum, TAOS_FIELD_E** fields
    STMT_ERR_RET(TSDB_CODE_TSC_STMT_API_ERROR);
  }

-  STableDataBlocks** pDataBlock =
-      (STableDataBlocks**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
+  STableDataCxt** pDataBlock =
+      (STableDataCxt**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
  if (NULL == pDataBlock) {
    tscError("table %s not found in exec blockHash", pStmt->bInfo.tbFName);
    STMT_ERR_RET(TSDB_CODE_APP_ERROR);
@ -729,11 +736,18 @@ int stmtBindBatch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind, int32_t colIdx) {
    return TSDB_CODE_SUCCESS;
  }

-  STableDataBlocks** pDataBlock =
-      (STableDataBlocks**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
-  if (NULL == pDataBlock) {
-    tscError("table %s not found in exec blockHash", pStmt->bInfo.tbFName);
-    STMT_ERR_RET(TSDB_CODE_APP_ERROR);
+  STableDataCxt** pDataBlock = NULL;
+
+  if (pStmt->exec.pCurrBlock) {
+    pDataBlock = &pStmt->exec.pCurrBlock;
+  } else {
+    pDataBlock =
+        (STableDataCxt**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
+    if (NULL == pDataBlock) {
+      tscError("table %s not found in exec blockHash", pStmt->bInfo.tbFName);
+      STMT_ERR_RET(TSDB_CODE_TSC_STMT_CACHE_ERROR);
+    }
+    pStmt->exec.pCurrBlock = *pDataBlock;
  }

  if (colIdx < 0) {
@ -779,10 +793,10 @@ int stmtUpdateTableUid(STscStmt* pStmt, SSubmitRsp* pRsp) {
  int32_t code = 0;
  int32_t finalCode = 0;
  size_t  keyLen = 0;
-  STableDataBlocks** pIter = taosHashIterate(pStmt->exec.pBlockHash, NULL);
+  void*   pIter = taosHashIterate(pStmt->exec.pBlockHash, NULL);
  while (pIter) {
-    STableDataBlocks* pBlock = *pIter;
-    char*             key = taosHashGetKey(pIter, &keyLen);
+    STableDataCxt* pBlock = *(STableDataCxt**)pIter;
+    char*          key = taosHashGetKey(pIter, &keyLen);

    STableMeta* pMeta = qGetTableMetaInDataBlock(pBlock);
    if (pMeta->uid) {
@ -848,7 +862,7 @@ int stmtUpdateTableUid(STscStmt* pStmt, SSubmitRsp* pRsp) {

      pMeta->uid = pTableMeta->uid;
      pStmt->bInfo.tbUid = pTableMeta->uid;
-      taosMemoryFree(pTableMeta);      
+      taosMemoryFree(pTableMeta);
    }

    pIter = taosHashIterate(pStmt->exec.pBlockHash, pIter);
@ -861,7 +875,6 @@ int stmtExec(TAOS_STMT* stmt) {
  STscStmt*   pStmt = (STscStmt*)stmt;
  int32_t     code = 0;
  SSubmitRsp* pRsp = NULL;
-  bool        autoCreateTbl = pStmt->exec.autoCreateTbl;

  STMT_DLOG_E("start to exec");

@ -870,8 +883,13 @@ int stmtExec(TAOS_STMT* stmt) {
  if (STMT_TYPE_QUERY == pStmt->sql.type) {
    launchQueryImpl(pStmt->exec.pRequest, pStmt->sql.pQuery, true, NULL);
  } else {
+    tDestroySSubmitTbData(pStmt->exec.pCurrTbData, TSDB_MSG_FLG_ENCODE);
+    taosMemoryFreeClear(pStmt->exec.pCurrTbData);
+
+    STMT_ERR_RET(qCloneCurrentTbData(pStmt->exec.pCurrBlock, &pStmt->exec.pCurrTbData));
+
    STMT_ERR_RET(qBuildStmtOutput(pStmt->sql.pQuery, pStmt->sql.pVgHash, pStmt->exec.pBlockHash));
-    launchQueryImpl(pStmt->exec.pRequest, pStmt->sql.pQuery, true, (autoCreateTbl ? (void**)&pRsp : NULL));
+    launchQueryImpl(pStmt->exec.pRequest, pStmt->sql.pQuery, true, NULL);
  }

  if (pStmt->exec.pRequest->code && NEED_CLIENT_HANDLE_ERROR(pStmt->exec.pRequest->code)) {
@ -894,15 +912,6 @@ _return:

  stmtCleanExecInfo(pStmt, (code ? false : true), false);

-  if (TSDB_CODE_SUCCESS == code && autoCreateTbl) {
-    if (NULL == pRsp) {
-      tscError("no submit resp got for auto create table");
-      code = TSDB_CODE_APP_ERROR;
-    } else {
-      code = stmtUpdateTableUid(pStmt, pRsp);
-    }
-  }
-
  tFreeSSubmitRsp(pRsp);

  ++pStmt->sql.runTimes;
--- a/source/client/src/clientTmq.c
+++ b/source/client/src/clientTmq.c
@ -418,7 +418,10 @@ int32_t tmqCommitDone(SMqCommitCbParamSet* pParamSet) {

 static void tmqCommitRspCountDown(SMqCommitCbParamSet* pParamSet) {
  int32_t waitingRspNum = atomic_sub_fetch_32(&pParamSet->waitingRspNum, 1);
-  ASSERT(waitingRspNum >= 0);
+  if(ASSERT(waitingRspNum >= 0)){
+    tscError("tmqCommitRspCountDown error:%d", waitingRspNum);
+    return;
+  }
  if (waitingRspNum == 0) {
    tmqCommitDone(pParamSet);
  }
@ -530,7 +533,6 @@ static int32_t tmqSendCommitReq(tmq_t* tmq, SMqClientVg* pVg, SMqClientTopic* pT
 int32_t tmqCommitMsgImpl(tmq_t* tmq, const TAOS_RES* msg, int8_t async, tmq_commit_cb* userCb, void* userParam) {
  char*   topic;
  int32_t vgId;
-  ASSERT(msg != NULL);
  if (TD_RES_TMQ(msg)) {
    SMqRspObj* pRspObj = (SMqRspObj*)msg;
    topic = pRspObj->topic;
@ -809,8 +811,6 @@ int32_t tmqHandleAllDelayedTask(tmq_t* tmq) {

      taosTmrReset(tmqAssignDelayedCommitTask, tmq->autoCommitInterval, pRefId, tmqMgmt.timer, &tmq->commitTimer);
    } else if (*pTaskType == TMQ_DELAYED_TASK__REPORT) {
-    } else {
-      ASSERT(0);
    }
    taosFreeQitem(pTaskType);
  }
@ -912,10 +912,12 @@ void tmqFreeImpl(void* handle) {
  tmq_t* tmq = (tmq_t*)handle;

  // TODO stop timer
-  tmqClearUnhandleMsg(tmq);
-  if (tmq->mqueue) taosCloseQueue(tmq->mqueue);
+  if (tmq->mqueue) {
+    tmqClearUnhandleMsg(tmq);
+    taosCloseQueue(tmq->mqueue);
+  }
  if (tmq->delayedTask) taosCloseQueue(tmq->delayedTask);
-  if (tmq->qall) taosFreeQall(tmq->qall);
+  taosFreeQall(tmq->qall);

  tsem_destroy(&tmq->rspSem);

@ -953,10 +955,6 @@ tmq_t* tmq_consumer_new(tmq_conf_t* conf, char* errstr, int32_t errstrLen) {
  const char* user = conf->user == NULL ? TSDB_DEFAULT_USER : conf->user;
  const char* pass = conf->pass == NULL ? TSDB_DEFAULT_PASS : conf->pass;

-  ASSERT(user);
-  ASSERT(pass);
-  ASSERT(conf->groupId[0]);
-
  pTmq->clientTopics = taosArrayInit(0, sizeof(SMqClientTopic));
  pTmq->mqueue = taosOpenQueue();
  pTmq->qall = taosAllocateQall();
@ -1247,8 +1245,6 @@ int32_t tmqPollCb(void* param, SDataBuf* pMsg, int32_t code) {
    tDecodeSTaosxRsp(&decoder, &pRspWrapper->taosxRsp);
    tDecoderClear(&decoder);
    memcpy(&pRspWrapper->taosxRsp, pMsg->pData, sizeof(SMqRspHead));
-  } else {
-    ASSERT(0);
  }

  taosMemoryFree(pMsg->pData);
@ -1911,10 +1907,6 @@ tmq_res_t tmq_get_res_type(TAOS_RES* res) {
  if (TD_RES_TMQ(res)) {
    return TMQ_RES_DATA;
  } else if (TD_RES_TMQ_META(res)) {
-    SMqMetaRspObj* pMetaRspObj = (SMqMetaRspObj*)res;
-    if (pMetaRspObj->metaRsp.resMsgType == TDMT_VND_DELETE) {
-      return TMQ_RES_DATA;
-    }
    return TMQ_RES_TABLE_META;
  } else if (TD_RES_TMQ_METADATA(res)) {
    return TMQ_RES_METADATA;
--- a/source/client/test/smlTest.cpp
+++ b/source/client/test/smlTest.cpp
--- a/source/common/src/tdatablock.c
+++ b/source/common/src/tdatablock.c
@ -19,10 +19,9 @@
 #include "tlog.h"
 #include "tname.h"

-#define MALLOC_ALIGN_BYTES  256
+#define MALLOC_ALIGN_BYTES 32

 int32_t colDataGetLength(const SColumnInfoData* pColumnInfoData, int32_t numOfRows) {
-  ASSERT(pColumnInfoData != NULL);
  if (IS_VAR_DATA_TYPE(pColumnInfoData->info.type)) {
    return pColumnInfoData->varmeta.length;
  } else {
@ -38,7 +37,8 @@ int32_t colDataGetFullLength(const SColumnInfoData* pColumnInfoData, int32_t num
  if (IS_VAR_DATA_TYPE(pColumnInfoData->info.type)) {
    return pColumnInfoData->varmeta.length + sizeof(int32_t) * numOfRows;
  } else {
-    return ((pColumnInfoData->info.type == TSDB_DATA_TYPE_NULL) ? 0 : pColumnInfoData->info.bytes * numOfRows) + BitmapLen(numOfRows);
+    return ((pColumnInfoData->info.type == TSDB_DATA_TYPE_NULL) ? 0 : pColumnInfoData->info.bytes * numOfRows) +
+           BitmapLen(numOfRows);
  }
 }

@ -65,8 +65,6 @@ int32_t getJsonValueLen(const char* data) {
 }

 int32_t colDataAppend(SColumnInfoData* pColumnInfoData, uint32_t currentRow, const char* pData, bool isNull) {
-  ASSERT(pColumnInfoData != NULL);
-
  if (isNull) {
    // There is a placehold for each NULL value of binary or nchar type.
    if (IS_VAR_DATA_TYPE(pColumnInfoData->info.type)) {
@ -111,7 +109,7 @@ int32_t colDataAppend(SColumnInfoData* pColumnInfoData, uint32_t currentRow, con
    uint32_t len = pColumnInfoData->varmeta.length;
    pColumnInfoData->varmeta.offset[currentRow] = len;

-    memcpy(pColumnInfoData->pData + len, pData, dataLen);
+    memmove(pColumnInfoData->pData + len, pData, dataLen);
    pColumnInfoData->varmeta.length += dataLen;
  } else {
    memcpy(pColumnInfoData->pData + pColumnInfoData->info.bytes * currentRow, pData, pColumnInfoData->info.bytes);
@ -177,8 +175,6 @@ static void doCopyNItems(struct SColumnInfoData* pColumnInfoData, int32_t curren

 int32_t colDataAppendNItems(SColumnInfoData* pColumnInfoData, uint32_t currentRow, const char* pData,
                            uint32_t numOfRows) {
-  ASSERT(pData != NULL && pColumnInfoData != NULL);
-
  int32_t len = pColumnInfoData->info.bytes;
  if (IS_VAR_DATA_TYPE(pColumnInfoData->info.type)) {
    len = varDataTLen(pData);
@ -236,7 +232,10 @@ static void doBitmapMerge(SColumnInfoData* pColumnInfoData, int32_t numOfRow1, c

 int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, int32_t numOfRow1, int32_t* capacity,
                        const SColumnInfoData* pSource, int32_t numOfRow2) {
-  ASSERT(pColumnInfoData != NULL && pSource != NULL && pColumnInfoData->info.type == pSource->info.type);
+  if (pColumnInfoData->info.type != pSource->info.type) {
+    return TSDB_CODE_FAILED;
+  }
+
  if (numOfRow2 == 0) {
    return numOfRow1;
  }
@ -279,7 +278,7 @@ int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, int32_t numOfRow1, int
      pColumnInfoData->varmeta.allocLen = len + oldLen;
    }

-    if (pColumnInfoData->pData && pSource->pData) { // TD-20382
+    if (pColumnInfoData->pData && pSource->pData) {  // TD-20382
      memcpy(pColumnInfoData->pData + oldLen, pSource->pData, len);
    }
    pColumnInfoData->varmeta.length = len + oldLen;
@ -316,13 +315,13 @@ int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, int32_t numOfRow1, int

 int32_t colDataAssign(SColumnInfoData* pColumnInfoData, const SColumnInfoData* pSource, int32_t numOfRows,
                      const SDataBlockInfo* pBlockInfo) {
-  ASSERT(pColumnInfoData != NULL && pSource != NULL && pColumnInfoData->info.type == pSource->info.type);
-  if (numOfRows <= 0) {
-    return numOfRows;
+  if (pColumnInfoData->info.type != pSource->info.type ||
+      (pBlockInfo != NULL && pBlockInfo->capacity < numOfRows)) {
+    return TSDB_CODE_FAILED;
  }

-  if (pBlockInfo != NULL) {
-    ASSERT(pBlockInfo->capacity >= numOfRows);
+  if (numOfRows <= 0) {
+    return numOfRows;
  }

  if (IS_VAR_DATA_TYPE(pColumnInfoData->info.type)) {
@ -358,14 +357,14 @@ size_t blockDataGetNumOfCols(const SSDataBlock* pBlock) { return taosArrayGetSiz
 size_t blockDataGetNumOfRows(const SSDataBlock* pBlock) { return pBlock->info.rows; }

 int32_t blockDataUpdateTsWindow(SSDataBlock* pDataBlock, int32_t tsColumnIndex) {
-  if (pDataBlock->info.rows > 0) {
-//    ASSERT(pDataBlock->info.dataLoad == 1);
-  }
-
  if (pDataBlock == NULL || pDataBlock->info.rows <= 0 || pDataBlock->info.dataLoad == 0) {
    return 0;
  }

+  if (pDataBlock->info.rows > 0) {
+    //    ASSERT(pDataBlock->info.dataLoad == 1);
+  }
+
  size_t numOfCols = taosArrayGetSize(pDataBlock->pDataBlock);
  if (numOfCols <= 0) {
    return -1;
@ -388,7 +387,6 @@ int32_t blockDataUpdateTsWindow(SSDataBlock* pDataBlock, int32_t tsColumnIndex)
 }

 int32_t blockDataMerge(SSDataBlock* pDest, const SSDataBlock* pSrc) {
-  assert(pSrc != NULL && pDest != NULL);
  int32_t capacity = pDest->info.capacity;

  size_t numOfCols = taosArrayGetSize(pDest->pDataBlock);
@ -406,8 +404,6 @@ int32_t blockDataMerge(SSDataBlock* pDest, const SSDataBlock* pSrc) {
 }

 size_t blockDataGetSize(const SSDataBlock* pBlock) {
-  assert(pBlock != NULL);
-
  size_t total = 0;
  size_t numOfCols = taosArrayGetSize(pBlock->pDataBlock);
  for (int32_t i = 0; i < numOfCols; ++i) {
@ -422,8 +418,6 @@ size_t blockDataGetSize(const SSDataBlock* pBlock) {
 // Actual data rows pluses the corresponding meta data must fit in one memory buffer of the given page size.
 int32_t blockDataSplitRows(SSDataBlock* pBlock, bool hasVarCol, int32_t startIndex, int32_t* stopIndex,
                           int32_t pageSize) {
-  ASSERT(pBlock != NULL && stopIndex != NULL);
-
  size_t  numOfCols = taosArrayGetSize(pBlock->pDataBlock);
  int32_t numOfRows = pBlock->info.rows;

@ -437,7 +431,9 @@ int32_t blockDataSplitRows(SSDataBlock* pBlock, bool hasVarCol, int32_t startInd
  if (!hasVarCol) {
    size_t  rowSize = blockDataGetRowSize(pBlock);
    int32_t capacity = payloadSize / (rowSize + numOfCols * bitmapChar / 8.0);
-    ASSERT(capacity > 0);
+    if (capacity <= 0) {
+      return TSDB_CODE_FAILED;
+    }

    *stopIndex = startIndex + capacity - 1;
    if (*stopIndex >= numOfRows) {
@ -469,7 +465,9 @@ int32_t blockDataSplitRows(SSDataBlock* pBlock, bool hasVarCol, int32_t startInd

    if (size > pageSize) {  // pageSize must be able to hold one row
      *stopIndex = j - 1;
-      ASSERT(*stopIndex >= startIndex);
+      if (*stopIndex < startIndex) {
+        return TSDB_CODE_FAILED;
+      }

      return TSDB_CODE_SUCCESS;
    }
@ -540,8 +538,6 @@ SSDataBlock* blockDataExtractBlock(SSDataBlock* pBlock, int32_t startIndex, int3
 * @return
 */
 int32_t blockDataToBuf(char* buf, const SSDataBlock* pBlock) {
-  ASSERT(pBlock != NULL);
-
  // write the number of rows
  *(uint32_t*)buf = pBlock->info.rows;

@ -612,7 +608,9 @@ int32_t blockDataFromBuf(SSDataBlock* pBlock, const char* buf) {
      }

      pCol->varmeta.length = colLength;
-      ASSERT(pCol->varmeta.length <= pCol->varmeta.allocLen);
+      if (pCol->varmeta.length > pCol->varmeta.allocLen) {
+        return TSDB_CODE_FAILED;
+      }
    }

    memcpy(pCol->pData, pStart, colLength);
@ -659,7 +657,9 @@ int32_t blockDataFromBuf1(SSDataBlock* pBlock, const char* buf, size_t capacity)
      }

      pCol->varmeta.length = colLength;
-      ASSERT(pCol->varmeta.length <= pCol->varmeta.allocLen);
+      if (pCol->varmeta.length > pCol->varmeta.allocLen) {
+        return TSDB_CODE_FAILED;
+      }
    }

    if (!colDataIsNNull_s(pCol, 0, pBlock->info.rows)) {
@ -673,7 +673,6 @@ int32_t blockDataFromBuf1(SSDataBlock* pBlock, const char* buf, size_t capacity)
 }

 size_t blockDataGetRowSize(SSDataBlock* pBlock) {
-  ASSERT(pBlock != NULL);
  if (pBlock->info.rowSize == 0) {
    size_t rowSize = 0;

@ -702,7 +701,6 @@ size_t blockDataGetSerialMetaSize(uint32_t numOfCols) {
 }

 double blockDataGetSerialRowSize(const SSDataBlock* pBlock) {
-  ASSERT(pBlock != NULL);
  double rowSize = 0;

  size_t numOfCols = taosArrayGetSize(pBlock->pDataBlock);
@ -905,7 +903,6 @@ static int32_t* createTupleIndex(size_t rows) {
 static void destroyTupleIndex(int32_t* index) { taosMemoryFreeClear(index); }

 int32_t blockDataSort(SSDataBlock* pDataBlock, SArray* pOrderInfo) {
-  ASSERT(pDataBlock != NULL && pOrderInfo != NULL);
  if (pDataBlock->info.rows <= 1) {
    return TSDB_CODE_SUCCESS;
  }
@ -1149,8 +1146,7 @@ void blockDataCleanup(SSDataBlock* pDataBlock) {

 void blockDataEmpty(SSDataBlock* pDataBlock) {
  SDataBlockInfo* pInfo = &pDataBlock->info;
-  ASSERT(pInfo->rows <= pDataBlock->info.capacity);
-  if (pInfo->capacity == 0) {
+  if (pInfo->capacity == 0 || pInfo->rows > pDataBlock->info.capacity) {
    return;
  }

@ -1167,9 +1163,9 @@ void blockDataEmpty(SSDataBlock* pDataBlock) {
 }

 // todo temporarily disable it
-static int32_t doEnsureCapacity(SColumnInfoData* pColumn, const SDataBlockInfo* pBlockInfo, uint32_t numOfRows, bool clearPayload) {
-  ASSERT(numOfRows > 0);
-  if (numOfRows <= pBlockInfo->capacity) {
+static int32_t doEnsureCapacity(SColumnInfoData* pColumn, const SDataBlockInfo* pBlockInfo, uint32_t numOfRows,
+                                bool clearPayload) {
+  if (numOfRows <= 0 || numOfRows <= pBlockInfo->capacity) {
    return TSDB_CODE_SUCCESS;
  }

@ -1196,7 +1192,9 @@ static int32_t doEnsureCapacity(SColumnInfoData* pColumn, const SDataBlockInfo*
    int32_t oldLen = BitmapLen(existedRows);
    pColumn->nullbitmap = tmp;
    memset(&pColumn->nullbitmap[oldLen], 0, BitmapLen(numOfRows) - oldLen);
-    ASSERT(pColumn->info.bytes);
+    if (pColumn->info.bytes == 0) {
+      return TSDB_CODE_FAILED;
+    }

    // make sure the allocated memory is MALLOC_ALIGN_BYTES aligned
    tmp = taosMemoryMallocAlign(MALLOC_ALIGN_BYTES, numOfRows * pColumn->info.bytes);
@ -1214,7 +1212,9 @@ static int32_t doEnsureCapacity(SColumnInfoData* pColumn, const SDataBlockInfo*

    // todo remove it soon
 #if defined LINUX
-    ASSERT((((uint64_t)pColumn->pData) & (MALLOC_ALIGN_BYTES - 1)) == 0x0);
+    if ((((uint64_t)pColumn->pData) & (MALLOC_ALIGN_BYTES - 1)) != 0x0) {
+      return TSDB_CODE_FAILED;
+    }
 #endif

    if (clearPayload) {
@ -1225,7 +1225,7 @@ static int32_t doEnsureCapacity(SColumnInfoData* pColumn, const SDataBlockInfo*
  return TSDB_CODE_SUCCESS;
 }

-void  colInfoDataCleanup(SColumnInfoData* pColumn, uint32_t numOfRows) {
+void colInfoDataCleanup(SColumnInfoData* pColumn, uint32_t numOfRows) {
  pColumn->hasNull = false;

  if (IS_VAR_DATA_TYPE(pColumn->info.type)) {
@ -1308,8 +1308,6 @@ void* blockDataDestroy(SSDataBlock* pBlock) {
 }

 int32_t assignOneDataBlock(SSDataBlock* dst, const SSDataBlock* src) {
-  ASSERT(src != NULL);
-
  dst->info = src->info;
  dst->info.rows = 0;
  dst->info.capacity = 0;
@ -1344,8 +1342,6 @@ int32_t assignOneDataBlock(SSDataBlock* dst, const SSDataBlock* src) {
 }

 int32_t copyDataBlock(SSDataBlock* dst, const SSDataBlock* src) {
-  ASSERT(src != NULL && dst != NULL);
-
  blockDataCleanup(dst);
  int32_t code = blockDataEnsureCapacity(dst, src->info.rows);
  if (code != TSDB_CODE_SUCCESS) {
@ -1501,7 +1497,6 @@ SSDataBlock* createDataBlock() {
 }

 int32_t blockDataAppendColInfo(SSDataBlock* pBlock, SColumnInfoData* pColInfoData) {
-  ASSERT(pBlock != NULL && pColInfoData != NULL);
  if (pBlock->pDataBlock == NULL) {
    pBlock->pDataBlock = taosArrayInit(4, sizeof(SColumnInfoData));
    if (pBlock->pDataBlock == NULL) {
@ -1536,7 +1531,6 @@ SColumnInfoData createColumnInfoData(int16_t type, int32_t bytes, int16_t colId)
 }

 SColumnInfoData* bdGetColumnInfoData(const SSDataBlock* pBlock, int32_t index) {
-  ASSERT(pBlock != NULL);
  if (index >= taosArrayGetSize(pBlock->pDataBlock)) {
    return NULL;
  }
@ -1875,7 +1869,7 @@ void blockDebugShowDataBlocks(const SArray* dataBlocks, const char* flag) {
  char    pBuf[128] = {0};
  int32_t sz = taosArrayGetSize(dataBlocks);
  for (int32_t i = 0; i < sz; i++) {
-    SSDataBlock* pDataBlock = taosArrayGetP(dataBlocks, i);
+    SSDataBlock* pDataBlock = taosArrayGet(dataBlocks, i);
    size_t       numOfCols = taosArrayGetSize(pDataBlock->pDataBlock);

    int32_t rows = pDataBlock->info.rows;
@ -1887,21 +1881,37 @@ void blockDebugShowDataBlocks(const SArray* dataBlocks, const char* flag) {
      for (int32_t k = 0; k < numOfCols; k++) {
        SColumnInfoData* pColInfoData = taosArrayGet(pDataBlock->pDataBlock, k);
        void*            var = POINTER_SHIFT(pColInfoData->pData, j * pColInfoData->info.bytes);
+        if (k == 0) {
+          printf("cols:%d |", (int32_t)numOfCols);
+        }
        if (colDataIsNull(pColInfoData, rows, j, NULL)) {
          printf(" %15s |", "NULL");
          continue;
        }
+
        switch (pColInfoData->info.type) {
          case TSDB_DATA_TYPE_TIMESTAMP:
            formatTimestamp(pBuf, *(uint64_t*)var, TSDB_TIME_PRECISION_MILLI);
            printf(" %25s |", pBuf);
            break;
          case TSDB_DATA_TYPE_BOOL:
-            printf(" %15d |", *(int32_t*)var);
+            printf(" %15" PRIi8 " |", *(int8_t*)var);
+            break;
+          case TSDB_DATA_TYPE_TINYINT:
+            printf(" %15" PRIi8 " |", *(int8_t*)var);
+            break;
+          case TSDB_DATA_TYPE_SMALLINT:
+            printf(" %15" PRIi16 " |", *(int16_t*)var);
            break;
          case TSDB_DATA_TYPE_INT:
            printf(" %15d |", *(int32_t*)var);
            break;
+          case TSDB_DATA_TYPE_UTINYINT:
+            printf(" %15" PRIu8 " |", *(uint8_t*)var);
+            break;
+          case TSDB_DATA_TYPE_USMALLINT:
+            printf(" %15" PRIu16 " |", *(uint16_t*)var);
+            break;
          case TSDB_DATA_TYPE_UINT:
            printf(" %15u |", *(uint32_t*)var);
            break;
@ -1953,7 +1963,8 @@ char* dumpBlockData(SSDataBlock* pDataBlock, const char* flag, char** pDataBuf)
                  "===stream===%s|block type %d|child id %d|group id:%" PRIu64 "|uid:%" PRId64
                  "|rows:%d|version:%" PRIu64 "|cal start:%" PRIu64 "|cal end:%" PRIu64 "\n",
                  flag, (int32_t)pDataBlock->info.type, pDataBlock->info.childId, pDataBlock->info.id.groupId,
-                  pDataBlock->info.id.uid, pDataBlock->info.rows, pDataBlock->info.version, pDataBlock->info.calWin.skey, pDataBlock->info.calWin.ekey);
+                  pDataBlock->info.id.uid, pDataBlock->info.rows, pDataBlock->info.version,
+                  pDataBlock->info.calWin.skey, pDataBlock->info.calWin.ekey);
  if (len >= size - 1) return dumpBuf;

  for (int32_t j = 0; j < rows; j++) {
@ -2055,6 +2066,7 @@ char* dumpBlockData(SSDataBlock* pDataBlock, const char* flag, char** pDataBuf)
 * @param suid
 *
 */
+#if 0
 int32_t buildSubmitReqFromDataBlock(SSubmitReq** pReq, const SSDataBlock* pDataBlock, STSchema* pTSchema, int32_t vgId,
                                    tb_uid_t suid) {
  int32_t bufSize = sizeof(SSubmitReq);
@ -2142,7 +2154,6 @@ int32_t buildSubmitReqFromDataBlock(SSubmitReq** pReq, const SSDataBlock* pDataB
          case TSDB_DATA_TYPE_JSON:
          case TSDB_DATA_TYPE_MEDIUMBLOB:
            uError("the column type %" PRIi16 " is defined but not implemented yet", pColInfoData->info.type);
-            ASSERT(0);
            break;
          default:
            if (pColInfoData->info.type < TSDB_DATA_TYPE_MAX && pColInfoData->info.type > TSDB_DATA_TYPE_NULL) {
@ -2176,7 +2187,6 @@ int32_t buildSubmitReqFromDataBlock(SSubmitReq** pReq, const SSDataBlock* pDataB
              }
            } else {
              uError("the column type %" PRIi16 " is undefined\n", pColInfoData->info.type);
-              ASSERT(0);
            }
            break;
        }
@ -2220,32 +2230,189 @@ int32_t buildSubmitReqFromDataBlock(SSubmitReq** pReq, const SSDataBlock* pDataB

  return TSDB_CODE_SUCCESS;
 }
+#endif
+
+int32_t buildSubmitReqFromDataBlock(SSubmitReq2** ppReq, const SSDataBlock* pDataBlock, const STSchema* pTSchema,
+                                    int64_t uid, int32_t vgId, tb_uid_t suid) {
+  SSubmitReq2* pReq = *ppReq;
+  SArray*      pVals = NULL;
+  int32_t      numOfBlks = 0;
+  int32_t      sz = 1;
+
+  terrno = TSDB_CODE_SUCCESS;
+
+  if (NULL == pReq) {
+    if (!(pReq = taosMemoryMalloc(sizeof(SSubmitReq2)))) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      goto _end;
+    }
+
+    if (!(pReq->aSubmitTbData = taosArrayInit(1, sizeof(SSubmitTbData)))) {
+      goto _end;
+    }
+  }
+
+  for (int32_t i = 0; i < sz; ++i) {
+    int32_t colNum = taosArrayGetSize(pDataBlock->pDataBlock);
+    int32_t rows = pDataBlock->info.rows;
+
+    if (colNum <= 1) {  // invalid if only with TS col
+      continue;
+    }
+
+    // the rsma result should has the same column number with schema.
+    ASSERT(colNum == pTSchema->numOfCols);
+
+    SSubmitTbData tbData = {0};
+
+    if (!(tbData.aRowP = taosArrayInit(rows, sizeof(SRow*)))) {
+      goto _end;
+    }
+    tbData.suid = suid;
+    tbData.uid = uid;
+    tbData.sver = pTSchema->version;
+
+    if (!pVals && !(pVals = taosArrayInit(colNum, sizeof(SColVal)))) {
+      taosArrayDestroy(tbData.aRowP);
+      goto _end;
+    }
+
+    for (int32_t j = 0; j < rows; ++j) {  // iterate by row
+
+      taosArrayClear(pVals);
+
+      bool    isStartKey = false;
+      int32_t offset = 0;
+      for (int32_t k = 0; k < colNum; ++k) {  // iterate by column
+        SColumnInfoData* pColInfoData = taosArrayGet(pDataBlock->pDataBlock, k);
+        const STColumn*  pCol = &pTSchema->columns[k];
+        void*            var = POINTER_SHIFT(pColInfoData->pData, j * pColInfoData->info.bytes);
+
+        switch (pColInfoData->info.type) {
+          case TSDB_DATA_TYPE_TIMESTAMP:
+            ASSERT(pColInfoData->info.type == pCol->type);
+            if (!isStartKey) {
+              isStartKey = true;
+              ASSERT(PRIMARYKEY_TIMESTAMP_COL_ID == pCol->colId);
+              SColVal cv = COL_VAL_VALUE(pCol->colId, pCol->type, (SValue){.val = *(TSKEY*)var});
+              taosArrayPush(pVals, &cv);
+            } else if (colDataIsNull_s(pColInfoData, j)) {
+              SColVal cv = COL_VAL_NULL(pCol->colId, pCol->type);
+              taosArrayPush(pVals, &cv);
+            } else {
+              SColVal cv = COL_VAL_VALUE(pCol->colId, pCol->type, (SValue){.val = *(int64_t*)var});
+              taosArrayPush(pVals, &cv);
+            }
+            break;
+          case TSDB_DATA_TYPE_NCHAR:
+          case TSDB_DATA_TYPE_VARCHAR: {  // TSDB_DATA_TYPE_BINARY
+            ASSERT(pColInfoData->info.type == pCol->type);
+            if (colDataIsNull_s(pColInfoData, j)) {
+              SColVal cv = COL_VAL_NULL(pCol->colId, pCol->type);
+              taosArrayPush(pVals, &cv);
+            } else {
+              void*   data = colDataGetVarData(pColInfoData, j);
+              SValue  sv = (SValue){.nData = varDataLen(data), .pData = varDataVal(data)};  // address copy, no value
+              SColVal cv = COL_VAL_VALUE(pCol->colId, pCol->type, sv);
+              taosArrayPush(pVals, &cv);
+            }
+            break;
+          }
+          case TSDB_DATA_TYPE_VARBINARY:
+          case TSDB_DATA_TYPE_DECIMAL:
+          case TSDB_DATA_TYPE_BLOB:
+          case TSDB_DATA_TYPE_JSON:
+          case TSDB_DATA_TYPE_MEDIUMBLOB:
+            uError("the column type %" PRIi16 " is defined but not implemented yet", pColInfoData->info.type);
+            ASSERT(0);
+            break;
+          default:
+            if (pColInfoData->info.type < TSDB_DATA_TYPE_MAX && pColInfoData->info.type > TSDB_DATA_TYPE_NULL) {
+              if (colDataIsNull_s(pColInfoData, j)) {
+                SColVal cv = COL_VAL_NULL(pCol->colId, pCol->type);  // should use pCol->type
+                taosArrayPush(pVals, &cv);
+              } else {
+                SValue sv;
+                if (pCol->type == pColInfoData->info.type) {
+                  memcpy(&sv.val, var, tDataTypes[pCol->type].bytes);
+                } else {
+                  /**
+                   *  1. sum/avg would convert to int64_t/uint64_t/double during aggregation
+                   *  2. below conversion may lead to overflow or loss, the app should select the right data type.
+                   */
+                  char tv[8] = {0};
+                  if (pColInfoData->info.type == TSDB_DATA_TYPE_FLOAT) {
+                    float v = 0;
+                    GET_TYPED_DATA(v, float, pColInfoData->info.type, var);
+                    SET_TYPED_DATA(&tv, pCol->type, v);
+                  } else if (pColInfoData->info.type == TSDB_DATA_TYPE_DOUBLE) {
+                    double v = 0;
+                    GET_TYPED_DATA(v, double, pColInfoData->info.type, var);
+                    SET_TYPED_DATA(&tv, pCol->type, v);
+                  } else if (IS_SIGNED_NUMERIC_TYPE(pColInfoData->info.type)) {
+                    int64_t v = 0;
+                    GET_TYPED_DATA(v, int64_t, pColInfoData->info.type, var);
+                    SET_TYPED_DATA(&tv, pCol->type, v);
+                  } else {
+                    uint64_t v = 0;
+                    GET_TYPED_DATA(v, uint64_t, pColInfoData->info.type, var);
+                    SET_TYPED_DATA(&tv, pCol->type, v);
+                  }
+                  memcpy(&sv.val, tv, tDataTypes[pCol->type].bytes);
+                }
+                SColVal cv = COL_VAL_VALUE(pCol->colId, pColInfoData->info.type, sv);
+                taosArrayPush(pVals, &cv);
+              }
+            } else {
+              uError("the column type %" PRIi16 " is undefined\n", pColInfoData->info.type);
+              ASSERT(0);
+            }
+            break;
+        }
+      }
+      SRow* pRow = NULL;
+      if ((terrno = tRowBuild(pVals, pTSchema, &pRow)) < 0) {
+        tDestroySSubmitTbData(&tbData, TSDB_MSG_FLG_ENCODE);
+        goto _end;
+      }
+      ASSERT(pRow);
+      taosArrayPush(tbData.aRowP, &pRow);
+    }
+
+    taosArrayPush(pReq->aSubmitTbData, &tbData);
+  }
+_end:
+  taosArrayDestroy(pVals);
+  if (terrno != 0) {
+    *ppReq = NULL;
+    if (pReq) tDestroySSubmitReq2(pReq, TSDB_MSG_FLG_ENCODE);
+    return TSDB_CODE_FAILED;
+  }
+  *ppReq = pReq;
+  return TSDB_CODE_SUCCESS;
+}

 char* buildCtbNameByGroupId(const char* stbFullName, uint64_t groupId) {
-  ASSERT(stbFullName[0] != 0);
-  SArray* tags = taosArrayInit(0, sizeof(void*));
-  if (tags == NULL) {
+  if (stbFullName[0] == 0) {
    return NULL;
  }

-  SSmlKv* pTag = taosMemoryCalloc(1, sizeof(SSmlKv));
-  if (pTag == NULL) {
-    taosArrayDestroy(tags);
+  SArray* tags = taosArrayInit(0, sizeof(SSmlKv));
+  if (tags == NULL) {
    return NULL;
  }

  void* cname = taosMemoryCalloc(1, TSDB_TABLE_NAME_LEN + 1);
  if (cname == NULL) {
    taosArrayDestroy(tags);
-    taosMemoryFree(pTag);
    return NULL;
  }

-  pTag->key = "group_id";
-  pTag->keyLen = strlen(pTag->key);
-  pTag->type = TSDB_DATA_TYPE_UBIGINT;
-  pTag->u = groupId;
-  pTag->length = sizeof(uint64_t);
+  SSmlKv pTag = {.key = "group_id",
+                 .keyLen = sizeof("group_id") - 1,
+                 .type = TSDB_DATA_TYPE_UBIGINT,
+                 .u = groupId,
+                 .length = sizeof(uint64_t)};
  taosArrayPush(tags, &pTag);

  RandTableName rname = {
@ -2257,10 +2424,11 @@ char* buildCtbNameByGroupId(const char* stbFullName, uint64_t groupId) {

  buildChildTableName(&rname);

-  taosMemoryFree(pTag);
  taosArrayDestroy(tags);

-  ASSERT(rname.ctbShortName && rname.ctbShortName[0]);
+  if ((rname.ctbShortName && rname.ctbShortName[0]) == 0) {
+    return NULL;
+  }
  return rname.ctbShortName;
 }

--- a/source/common/src/tdataformat.c
+++ b/source/common/src/tdataformat.c
--- a/source/common/src/tglobal.c
+++ b/source/common/src/tglobal.c
@ -47,7 +47,7 @@ int32_t tsNumOfMnodeQueryThreads = 4;
 int32_t tsNumOfMnodeFetchThreads = 1;
 int32_t tsNumOfMnodeReadThreads = 1;
 int32_t tsNumOfVnodeQueryThreads = 4;
-int32_t tsNumOfVnodeStreamThreads = 2;
+float   tsRatioOfVnodeStreamThreads = 1.0;
 int32_t tsNumOfVnodeFetchThreads = 4;
 int32_t tsNumOfVnodeRsmaThreads = 2;
 int32_t tsNumOfQnodeQueryThreads = 4;
@ -392,9 +392,7 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
  tsNumOfVnodeQueryThreads = TMAX(tsNumOfVnodeQueryThreads, 4);
  if (cfgAddInt32(pCfg, "numOfVnodeQueryThreads", tsNumOfVnodeQueryThreads, 4, 1024, 0) != 0) return -1;

-  tsNumOfVnodeStreamThreads = tsNumOfCores / 4;
-  tsNumOfVnodeStreamThreads = TMAX(tsNumOfVnodeStreamThreads, 4);
-  if (cfgAddInt32(pCfg, "numOfVnodeStreamThreads", tsNumOfVnodeStreamThreads, 4, 1024, 0) != 0) return -1;
+  if (cfgAddFloat(pCfg, "ratioOfVnodeStreamThreads", tsRatioOfVnodeStreamThreads, 0.01, 100, 0) != 0) return -1;

  tsNumOfVnodeFetchThreads = tsNumOfCores / 4;
  tsNumOfVnodeFetchThreads = TMAX(tsNumOfVnodeFetchThreads, 4);
@ -513,11 +511,9 @@ static int32_t taosUpdateServerCfg(SConfig *pCfg) {
    pItem->stype = stype;
  }

-  pItem = cfgGetItem(tsCfg, "numOfVnodeStreamThreads");
+  pItem = cfgGetItem(tsCfg, "ratioOfVnodeStreamThreads");
  if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {
-    tsNumOfVnodeStreamThreads = numOfCores / 4;
-    tsNumOfVnodeStreamThreads = TMAX(tsNumOfVnodeStreamThreads, 4);
-    pItem->i32 = tsNumOfVnodeStreamThreads;
+    pItem->fval = tsRatioOfVnodeStreamThreads;
    pItem->stype = stype;
  }

@ -710,7 +706,7 @@ static int32_t taosSetServerCfg(SConfig *pCfg) {
  tsNumOfCommitThreads = cfgGetItem(pCfg, "numOfCommitThreads")->i32;
  tsNumOfMnodeReadThreads = cfgGetItem(pCfg, "numOfMnodeReadThreads")->i32;
  tsNumOfVnodeQueryThreads = cfgGetItem(pCfg, "numOfVnodeQueryThreads")->i32;
-  tsNumOfVnodeStreamThreads = cfgGetItem(pCfg, "numOfVnodeStreamThreads")->i32;
+  tsRatioOfVnodeStreamThreads = cfgGetItem(pCfg, "ratioOfVnodeStreamThreads")->fval;
  tsNumOfVnodeFetchThreads = cfgGetItem(pCfg, "numOfVnodeFetchThreads")->i32;
  tsNumOfVnodeRsmaThreads = cfgGetItem(pCfg, "numOfVnodeRsmaThreads")->i32;
  tsNumOfQnodeQueryThreads = cfgGetItem(pCfg, "numOfQnodeQueryThreads")->i32;
@ -719,6 +715,8 @@ static int32_t taosSetServerCfg(SConfig *pCfg) {
  tsNumOfSnodeWriteThreads = cfgGetItem(pCfg, "numOfSnodeUniqueThreads")->i32;
  tsRpcQueueMemoryAllowed = cfgGetItem(pCfg, "rpcQueueMemoryAllowed")->i64;

+  tsSIMDBuiltins = (bool) cfgGetItem(pCfg, "SIMD-builtins")->bval;
+
  tsEnableMonitor = cfgGetItem(pCfg, "monitor")->bval;
  tsMonitorInterval = cfgGetItem(pCfg, "monitorInterval")->i32;
  tstrncpy(tsMonitorFqdn, cfgGetItem(pCfg, "monitorFqdn")->str, TSDB_FQDN_LEN);
@ -1316,12 +1314,17 @@ void taosSetDebugFlag(int32_t *pFlagPtr, const char *flagName, int32_t flagVal,
  if (pItem != NULL && (rewrite || pItem->i32 == 0)) {
    pItem->i32 = flagVal;
  }
-  *pFlagPtr = flagVal;
+  if (pFlagPtr != NULL) {
+    *pFlagPtr = flagVal;
+  }
 }

 void taosSetAllDebugFlag(int32_t flag, bool rewrite) {
  if (flag <= 0) return;

+  taosSetDebugFlag(NULL, "debugFlag", flag, rewrite);
+  taosSetDebugFlag(NULL, "simDebugFlag", flag, rewrite);
+  taosSetDebugFlag(NULL, "tmrDebugFlag", flag, rewrite);
  taosSetDebugFlag(&uDebugFlag, "uDebugFlag", flag, rewrite);
  taosSetDebugFlag(&rpcDebugFlag, "rpcDebugFlag", flag, rewrite);
  taosSetDebugFlag(&jniDebugFlag, "jniDebugFlag", flag, rewrite);
@ -1340,6 +1343,5 @@ void taosSetAllDebugFlag(int32_t flag, bool rewrite) {
  taosSetDebugFlag(&idxDebugFlag, "idxDebugFlag", flag, rewrite);
  taosSetDebugFlag(&tdbDebugFlag, "tdbDebugFlag", flag, rewrite);
  taosSetDebugFlag(&metaDebugFlag, "metaDebugFlag", flag, rewrite);
-  taosSetDebugFlag(&metaDebugFlag, "tmrDebugFlag", flag, rewrite);
  uInfo("all debug flag are set to %d", flag);
 }
--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@ -5424,6 +5424,7 @@ int32_t tSerializeSCMCreateStreamReq(void *buf, int32_t bufLen, const SCMCreateS
    if (tEncodeI32(&encoder, pField->bytes) < 0) return -1;
    if (tEncodeCStr(&encoder, pField->name) < 0) return -1;
  }
+  if (tEncodeI8(&encoder, pReq->createStb) < 0) return -1;

  tEndEncode(&encoder);

@ -5484,6 +5485,7 @@ int32_t tDeserializeSCMCreateStreamReq(void *buf, int32_t bufLen, SCMCreateStrea
      }
    }
  }
+  if (tDecodeI8(&decoder, &pReq->createStb) < 0) return -1;

  tEndDecode(&decoder);

@ -5627,30 +5629,6 @@ int tDecodeSVCreateStbReq(SDecoder *pCoder, SVCreateStbReq *pReq) {
  return 0;
 }

-STSchema *tdGetSTSChemaFromSSChema(SSchema *pSchema, int32_t nCols, int32_t sver) {
-  STSchemaBuilder schemaBuilder = {0};
-  if (tdInitTSchemaBuilder(&schemaBuilder, sver) < 0) {
-    return NULL;
-  }
-
-  for (int i = 0; i < nCols; i++) {
-    SSchema *schema = pSchema + i;
-    if (tdAddColToSchema(&schemaBuilder, schema->type, schema->flags, schema->colId, schema->bytes) < 0) {
-      tdDestroyTSchemaBuilder(&schemaBuilder);
-      return NULL;
-    }
-  }
-
-  STSchema *pNSchema = tdGetSchemaFromBuilder(&schemaBuilder);
-  if (pNSchema == NULL) {
-    tdDestroyTSchemaBuilder(&schemaBuilder);
-    return NULL;
-  }
-
-  tdDestroyTSchemaBuilder(&schemaBuilder);
-  return pNSchema;
-}
-
 int tEncodeSVCreateTbReq(SEncoder *pCoder, const SVCreateTbReq *pReq) {
  if (tStartEncode(pCoder) < 0) return -1;

@ -5728,6 +5706,25 @@ int tDecodeSVCreateTbReq(SDecoder *pCoder, SVCreateTbReq *pReq) {
  return 0;
 }

+void tDestroySVCreateTbReq(SVCreateTbReq *pReq, int32_t flags) {
+  if (pReq == NULL) return;
+
+  if (flags & TSDB_MSG_FLG_ENCODE) {
+    // TODO
+  } else if (flags & TSDB_MSG_FLG_DECODE) {
+    if (pReq->comment) {
+      pReq->comment = NULL;
+      taosMemoryFree(pReq->comment);
+    }
+
+    if (pReq->type == TSDB_CHILD_TABLE) {
+      if (pReq->ctb.tagName) taosArrayDestroy(pReq->ctb.tagName);
+    } else if (pReq->type == TSDB_NORMAL_TABLE) {
+      if (pReq->ntb.schemaRow.pSchema) taosMemoryFree(pReq->ntb.schemaRow.pSchema);
+    }
+  }
+}
+
 int tEncodeSVCreateTbBatchReq(SEncoder *pCoder, const SVCreateTbBatchReq *pReq) {
  int32_t nReq = taosArrayGetSize(pReq->pArray);

@ -6719,3 +6716,328 @@ int32_t tDecodeSBatchDeleteReq(SDecoder *pDecoder, SBatchDeleteReq *pReq) {
  }
  return 0;
 }
+
+static int32_t tEncodeSSubmitTbData(SEncoder *pCoder, const SSubmitTbData *pSubmitTbData) {
+  if (tStartEncode(pCoder) < 0) return -1;
+
+  if (tEncodeI32v(pCoder, pSubmitTbData->flags) < 0) return -1;
+
+  // auto create table
+  if (pSubmitTbData->flags & SUBMIT_REQ_AUTO_CREATE_TABLE) {
+    ASSERT(pSubmitTbData->pCreateTbReq);
+    if (tEncodeSVCreateTbReq(pCoder, pSubmitTbData->pCreateTbReq) < 0) return -1;
+  }
+
+  // submit data
+  if (tEncodeI64(pCoder, pSubmitTbData->suid) < 0) return -1;
+  if (tEncodeI64(pCoder, pSubmitTbData->uid) < 0) return -1;
+  if (tEncodeI32v(pCoder, pSubmitTbData->sver) < 0) return -1;
+
+  if (pSubmitTbData->flags & SUBMIT_REQ_COLUMN_DATA_FORMAT) {
+    uint64_t  nColData = TARRAY_SIZE(pSubmitTbData->aCol);
+    SColData *aColData = (SColData *)TARRAY_DATA(pSubmitTbData->aCol);
+
+    if (tEncodeU64v(pCoder, nColData) < 0) return -1;
+
+    for (uint64_t i = 0; i < nColData; i++) {
+      pCoder->pos += tPutColData(pCoder->data ? pCoder->data + pCoder->pos : NULL, &aColData[i]);
+    }
+  } else {
+    if (tEncodeU64v(pCoder, TARRAY_SIZE(pSubmitTbData->aRowP)) < 0) return -1;
+
+    SRow **rows = (SRow **)TARRAY_DATA(pSubmitTbData->aRowP);
+    for (int32_t iRow = 0; iRow < TARRAY_SIZE(pSubmitTbData->aRowP); ++iRow) {
+      if (pCoder->data) memcpy(pCoder->data + pCoder->pos, rows[iRow], rows[iRow]->len);
+      pCoder->pos += rows[iRow]->len;
+    }
+  }
+
+  tEndEncode(pCoder);
+  return 0;
+}
+
+static int32_t tDecodeSSubmitTbData(SDecoder *pCoder, SSubmitTbData *pSubmitTbData) {
+  int32_t code = 0;
+
+  if (tStartDecode(pCoder) < 0) {
+    code = TSDB_CODE_INVALID_MSG;
+    goto _exit;
+  }
+
+  if (tDecodeI32v(pCoder, &pSubmitTbData->flags) < 0) return -1;
+
+  if (pSubmitTbData->flags & SUBMIT_REQ_AUTO_CREATE_TABLE) {
+    pSubmitTbData->pCreateTbReq = taosMemoryCalloc(1, sizeof(SVCreateTbReq));
+    if (pSubmitTbData->pCreateTbReq == NULL) {
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      goto _exit;
+    }
+
+    if (tDecodeSVCreateTbReq(pCoder, pSubmitTbData->pCreateTbReq) < 0) {
+      code = TSDB_CODE_INVALID_MSG;
+      goto _exit;
+    }
+  }
+
+  // submit data
+  if (tDecodeI64(pCoder, &pSubmitTbData->suid) < 0) {
+    code = TSDB_CODE_INVALID_MSG;
+    goto _exit;
+  }
+  if (tDecodeI64(pCoder, &pSubmitTbData->uid) < 0) {
+    code = TSDB_CODE_INVALID_MSG;
+    goto _exit;
+  }
+  if (tDecodeI32v(pCoder, &pSubmitTbData->sver) < 0) {
+    code = TSDB_CODE_INVALID_MSG;
+    goto _exit;
+  }
+
+  if (pSubmitTbData->flags & SUBMIT_REQ_COLUMN_DATA_FORMAT) {
+    uint64_t nColData;
+
+    if (tDecodeU64v(pCoder, &nColData) < 0) {
+      code = TSDB_CODE_INVALID_MSG;
+      goto _exit;
+    }
+
+    pSubmitTbData->aCol = taosArrayInit(nColData, sizeof(SColData));
+    if (pSubmitTbData->aCol == NULL) {
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      goto _exit;
+    }
+
+    for (int32_t i = 0; i < nColData; ++i) {
+      pCoder->pos += tGetColData(pCoder->data + pCoder->pos, taosArrayReserve(pSubmitTbData->aCol, 1));
+    }
+  } else {
+    uint64_t nRow;
+    if (tDecodeU64v(pCoder, &nRow) < 0) {
+      code = TSDB_CODE_INVALID_MSG;
+      goto _exit;
+    }
+
+    pSubmitTbData->aRowP = taosArrayInit(nRow, sizeof(SRow *));
+    if (pSubmitTbData->aRowP == NULL) {
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      goto _exit;
+    }
+
+    for (int32_t iRow = 0; iRow < nRow; ++iRow) {
+      SRow **ppRow = taosArrayReserve(pSubmitTbData->aRowP, 1);
+
+      *ppRow = (SRow *)(pCoder->data + pCoder->pos);
+      pCoder->pos += (*ppRow)->len;
+    }
+  }
+
+  tEndDecode(pCoder);
+
+_exit:
+  if (code) {
+    // TODO: clear
+  }
+  return 0;
+}
+
+int32_t tEncodeSSubmitReq2(SEncoder *pCoder, const SSubmitReq2 *pReq) {
+  if (tStartEncode(pCoder) < 0) return -1;
+
+  if (tEncodeU64v(pCoder, taosArrayGetSize(pReq->aSubmitTbData)) < 0) return -1;
+  for (uint64_t i = 0; i < taosArrayGetSize(pReq->aSubmitTbData); i++) {
+    if (tEncodeSSubmitTbData(pCoder, taosArrayGet(pReq->aSubmitTbData, i)) < 0) return -1;
+  }
+
+  tEndEncode(pCoder);
+  return 0;
+}
+
+int32_t tDecodeSSubmitReq2(SDecoder *pCoder, SSubmitReq2 *pReq) {
+  int32_t code = 0;
+
+  memset(pReq, 0, sizeof(*pReq));
+
+  // decode
+  if (tStartDecode(pCoder) < 0) {
+    code = TSDB_CODE_INVALID_MSG;
+    goto _exit;
+  }
+
+  uint64_t nSubmitTbData;
+  if (tDecodeU64v(pCoder, &nSubmitTbData) < 0) {
+    code = TSDB_CODE_INVALID_MSG;
+    goto _exit;
+  }
+
+  pReq->aSubmitTbData = taosArrayInit(nSubmitTbData, sizeof(SSubmitTbData));
+  if (pReq->aSubmitTbData == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _exit;
+  }
+
+  for (uint64_t i = 0; i < nSubmitTbData; i++) {
+    if (tDecodeSSubmitTbData(pCoder, taosArrayReserve(pReq->aSubmitTbData, 1)) < 0) {
+      code = TSDB_CODE_INVALID_MSG;
+      goto _exit;
+    }
+  }
+
+  tEndDecode(pCoder);
+
+_exit:
+  if (code) {
+    if (pReq->aSubmitTbData) {
+      // todo
+      taosArrayDestroy(pReq->aSubmitTbData);
+      pReq->aSubmitTbData = NULL;
+    }
+  }
+  return code;
+}
+
+void tDestroySSubmitTbData(SSubmitTbData *pTbData, int32_t flag) {
+  if (NULL == pTbData) {
+    return;
+  }
+
+  if (flag == TSDB_MSG_FLG_ENCODE) {
+    if (pTbData->pCreateTbReq) {
+      tdDestroySVCreateTbReq(pTbData->pCreateTbReq);
+      taosMemoryFree(pTbData->pCreateTbReq);
+    }
+
+    if (pTbData->flags & SUBMIT_REQ_COLUMN_DATA_FORMAT) {
+      int32_t   nColData = TARRAY_SIZE(pTbData->aCol);
+      SColData *aColData = (SColData *)TARRAY_DATA(pTbData->aCol);
+
+      for (int32_t i = 0; i < nColData; ++i) {
+        tColDataDestroy(&aColData[i]);
+      }
+      taosArrayDestroy(pTbData->aCol);
+    } else {
+      int32_t nRow = TARRAY_SIZE(pTbData->aRowP);
+      SRow  **rows = (SRow **)TARRAY_DATA(pTbData->aRowP);
+
+      for (int32_t i = 0; i < nRow; ++i) {
+        tRowDestroy(rows[i]);
+      }
+      taosArrayDestroy(pTbData->aRowP);
+    }
+  } else if (flag == TSDB_MSG_FLG_DECODE) {
+    if (pTbData->pCreateTbReq) {
+      tDestroySVCreateTbReq(pTbData->pCreateTbReq, TSDB_MSG_FLG_DECODE);
+      taosMemoryFree(pTbData->pCreateTbReq);
+    }
+
+    if (pTbData->flags & SUBMIT_REQ_COLUMN_DATA_FORMAT) {
+      taosArrayDestroy(pTbData->aCol);
+    } else {
+      taosArrayDestroy(pTbData->aRowP);
+    }
+  }
+}
+
+void tDestroySSubmitReq2(SSubmitReq2 *pReq, int32_t flag) {
+  if (pReq->aSubmitTbData == NULL) return;
+
+  int32_t        nSubmitTbData = TARRAY_SIZE(pReq->aSubmitTbData);
+  SSubmitTbData *aSubmitTbData = (SSubmitTbData *)TARRAY_DATA(pReq->aSubmitTbData);
+
+  for (int32_t i = 0; i < nSubmitTbData; i++) {
+    tDestroySSubmitTbData(&aSubmitTbData[i], flag);
+  }
+  taosArrayDestroy(pReq->aSubmitTbData);
+}
+
+int32_t tEncodeSSubmitRsp2(SEncoder *pCoder, const SSubmitRsp2 *pRsp) {
+  if (tStartEncode(pCoder) < 0) return -1;
+
+  if (tEncodeI32v(pCoder, pRsp->affectedRows) < 0) return -1;
+
+  if (tEncodeU64v(pCoder, taosArrayGetSize(pRsp->aCreateTbRsp)) < 0) return -1;
+  for (int32_t i = 0; i < taosArrayGetSize(pRsp->aCreateTbRsp); ++i) {
+    if (tEncodeSVCreateTbRsp(pCoder, taosArrayGet(pRsp->aCreateTbRsp, i)) < 0) return -1;
+  }
+
+  tEndEncode(pCoder);
+  return 0;
+}
+
+int32_t tDecodeSSubmitRsp2(SDecoder *pCoder, SSubmitRsp2 *pRsp) {
+  int32_t code = 0;
+
+  memset(pRsp, 0, sizeof(SSubmitRsp2));
+
+  // decode
+  if (tStartDecode(pCoder) < 0) {
+    code = TSDB_CODE_INVALID_MSG;
+    goto _exit;
+  }
+
+  if (tDecodeI32v(pCoder, &pRsp->affectedRows) < 0) {
+    code = TSDB_CODE_INVALID_MSG;
+    goto _exit;
+  }
+
+  uint64_t nCreateTbRsp;
+  if (tDecodeU64v(pCoder, &nCreateTbRsp) < 0) {
+    code = TSDB_CODE_INVALID_MSG;
+    goto _exit;
+  }
+
+  if (nCreateTbRsp) {
+    pRsp->aCreateTbRsp = taosArrayInit(nCreateTbRsp, sizeof(SVCreateTbRsp));
+    if (pRsp->aCreateTbRsp == NULL) {
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      goto _exit;
+    }
+
+    for (int32_t i = 0; i < nCreateTbRsp; ++i) {
+      SVCreateTbRsp *pCreateTbRsp = taosArrayReserve(pRsp->aCreateTbRsp, 1);
+      if (tDecodeSVCreateTbRsp(pCoder, pCreateTbRsp) < 0) {
+        code = TSDB_CODE_INVALID_MSG;
+        goto _exit;
+      }
+    }
+  }
+
+  tEndDecode(pCoder);
+
+_exit:
+  if (code) {
+    if (pRsp->aCreateTbRsp) {
+      taosArrayDestroyEx(pRsp->aCreateTbRsp, NULL /* todo */);
+    }
+  }
+  return code;
+}
+
+void tDestroySSubmitRsp2(SSubmitRsp2 *pRsp, int32_t flag) {
+  if (NULL == pRsp) {
+    return;
+  }
+
+  if (flag & TSDB_MSG_FLG_ENCODE) {
+    if (pRsp->aCreateTbRsp) {
+      int32_t        nCreateTbRsp = TARRAY_SIZE(pRsp->aCreateTbRsp);
+      SVCreateTbRsp *aCreateTbRsp = TARRAY_DATA(pRsp->aCreateTbRsp);
+      for (int32_t i = 0; i < nCreateTbRsp; ++i) {
+        if (aCreateTbRsp[i].pMeta) {
+          taosMemoryFree(aCreateTbRsp[i].pMeta);
+        }
+      }
+      taosArrayDestroy(pRsp->aCreateTbRsp);
+    }
+  } else if (flag & TSDB_MSG_FLG_DECODE) {
+    if (pRsp->aCreateTbRsp) {
+      int32_t        nCreateTbRsp = TARRAY_SIZE(pRsp->aCreateTbRsp);
+      SVCreateTbRsp *aCreateTbRsp = TARRAY_DATA(pRsp->aCreateTbRsp);
+      for (int32_t i = 0; i < nCreateTbRsp; ++i) {
+        if (aCreateTbRsp[i].pMeta) {
+          taosMemoryFree(aCreateTbRsp[i].pMeta);
+        }
+      }
+      taosArrayDestroy(pRsp->aCreateTbRsp);
+    }
+  }
+}
--- a/source/common/src/tname.c
+++ b/source/common/src/tname.c
@ -90,16 +90,12 @@ int64_t taosGetIntervalStartTimestamp(int64_t startTime, int64_t slidingTime, in
 SName* toName(int32_t acctId, const char* pDbName, const char* pTableName, SName* pName) {
  pName->type = TSDB_TABLE_NAME_T;
  pName->acctId = acctId;
-  memset(pName->dbname, 0, TSDB_DB_NAME_LEN);
-  strncpy(pName->dbname, pDbName, TSDB_DB_NAME_LEN - 1);
-  memset(pName->tname, 0, TSDB_TABLE_NAME_LEN);
-  strncpy(pName->tname, pTableName, TSDB_TABLE_NAME_LEN - 1);
+  snprintf(pName->dbname, sizeof(pName->dbname), "%s", pDbName);
+  snprintf(pName->tname, sizeof(pName->tname), "%s", pTableName);
  return pName;
 }

 int32_t tNameExtractFullName(const SName* name, char* dst) {
-  assert(name != NULL && dst != NULL);
-
  // invalid full name format, abort
  if (!tNameIsValid(name)) {
    return -1;
@ -109,7 +105,7 @@ int32_t tNameExtractFullName(const SName* name, char* dst) {

  size_t tnameLen = strlen(name->tname);
  if (tnameLen > 0) {
-    /*assert(name->type == TSDB_TABLE_NAME_T);*/
+    /*ASSERT(name->type == TSDB_TABLE_NAME_T);*/
    dst[len] = TS_PATH_DELIMITER[0];

    memcpy(dst + len + 1, name->tname, tnameLen);
@ -120,25 +116,21 @@ int32_t tNameExtractFullName(const SName* name, char* dst) {
 }

 int32_t tNameLen(const SName* name) {
-  assert(name != NULL);
-
  char    tmp[12] = {0};
  int32_t len = sprintf(tmp, "%d", name->acctId);
  int32_t len1 = (int32_t)strlen(name->dbname);
  int32_t len2 = (int32_t)strlen(name->tname);

  if (name->type == TSDB_DB_NAME_T) {
-    assert(len2 == 0);
+    ASSERT(len2 == 0);
    return len + len1 + TSDB_NAME_DELIMITER_LEN;
  } else {
-    assert(len2 > 0);
+    ASSERT(len2 > 0);
    return len + len1 + len2 + TSDB_NAME_DELIMITER_LEN * 2;
  }
 }

 bool tNameIsValid(const SName* name) {
-  assert(name != NULL);
-
  if (!VALID_NAME_TYPE(name->type)) {
    return false;
  }
@ -151,15 +143,12 @@ bool tNameIsValid(const SName* name) {
 }

 SName* tNameDup(const SName* name) {
-  assert(name != NULL);
-
  SName* p = taosMemoryMalloc(sizeof(SName));
  memcpy(p, name, sizeof(SName));
  return p;
 }

 int32_t tNameGetDbName(const SName* name, char* dst) {
-  assert(name != NULL && dst != NULL);
  strncpy(dst, name->dbname, tListLen(name->dbname));
  return 0;
 }
@ -167,28 +156,24 @@ int32_t tNameGetDbName(const SName* name, char* dst) {
 const char* tNameGetDbNameP(const SName* name) { return &name->dbname[0]; }

 int32_t tNameGetFullDbName(const SName* name, char* dst) {
-  assert(name != NULL && dst != NULL);
  snprintf(dst, TSDB_DB_FNAME_LEN, "%d.%s", name->acctId, name->dbname);
  return 0;
 }

 bool tNameIsEmpty(const SName* name) {
-  assert(name != NULL);
  return name->type == 0 || name->acctId == 0;
 }

 const char* tNameGetTableName(const SName* name) {
-  assert(name != NULL && name->type == TSDB_TABLE_NAME_T);
+  ASSERT(name != NULL && name->type == TSDB_TABLE_NAME_T);
  return &name->tname[0];
 }

 void tNameAssign(SName* dst, const SName* src) { memcpy(dst, src, sizeof(SName)); }

 int32_t tNameSetDbName(SName* dst, int32_t acct, const char* dbName, size_t nameLen) {
-  assert(dst != NULL && dbName != NULL && nameLen > 0);
-
  // too long account id or too long db name
-  if (nameLen >= tListLen(dst->dbname)) {
+  if (nameLen <= 0 || nameLen >= tListLen(dst->dbname)) {
    return -1;
  }

@ -199,8 +184,6 @@ int32_t tNameSetDbName(SName* dst, int32_t acct, const char* dbName, size_t name
 }

 int32_t tNameAddTbName(SName* dst, const char* tbName, size_t nameLen) {
-  assert(dst != NULL && tbName != NULL && nameLen > 0);
-
  // too long account id or too long db name
  if (nameLen >= tListLen(dst->tname) || nameLen <= 0) {
    return -1;
@ -212,7 +195,6 @@ int32_t tNameAddTbName(SName* dst, const char* tbName, size_t nameLen) {
 }

 int32_t tNameSetAcctId(SName* dst, int32_t acctId) {
-  assert(dst != NULL);
  dst->acctId = acctId;
  return 0;
 }
@ -247,7 +229,9 @@ bool tNameTbNameEqual(SName* left, SName* right) {
 }

 int32_t tNameFromString(SName* dst, const char* str, uint32_t type) {
-  assert(dst != NULL && str != NULL && strlen(str) > 0);
+  if (strlen(str) == 0) {
+    return -1;
+  }

  char* p = NULL;
  if ((type & T_NAME_ACCT) == T_NAME_ACCT) {
@ -298,8 +282,8 @@ int32_t tNameFromString(SName* dst, const char* str, uint32_t type) {
 }

 static int compareKv(const void* p1, const void* p2) {
-  SSmlKv* kv1 = *(SSmlKv**)p1;
-  SSmlKv* kv2 = *(SSmlKv**)p2;
+  SSmlKv* kv1 = (SSmlKv*)p1;
+  SSmlKv* kv2 = (SSmlKv*)p2;
  int32_t kvLen1 = kv1->keyLen;
  int32_t kvLen2 = kv2->keyLen;
  int32_t res = strncasecmp(kv1->key, kv2->key, TMIN(kvLen1, kvLen2));
@ -316,11 +300,11 @@ static int compareKv(const void* p1, const void* p2) {
 void buildChildTableName(RandTableName* rName) {
  SStringBuilder sb = {0};
  taosStringBuilderAppendStringLen(&sb, rName->stbFullName, rName->stbFullNameLen);
-  if(sb.buf == NULL) return;
+  if (sb.buf == NULL) return;
  taosArraySort(rName->tags, compareKv);
  for (int j = 0; j < taosArrayGetSize(rName->tags); ++j) {
    taosStringBuilderAppendChar(&sb, ',');
-    SSmlKv* tagKv = taosArrayGetP(rName->tags, j);
+    SSmlKv* tagKv = taosArrayGet(rName->tags, j);
    taosStringBuilderAppendStringLen(&sb, tagKv->key, tagKv->keyLen);
    taosStringBuilderAppendChar(&sb, '=');
    if (IS_VAR_DATA_TYPE(tagKv->type)) {
--- a/source/common/src/trow.c
+++ b/source/common/src/trow.c
@ -76,7 +76,6 @@ void tdSCellValPrint(SCellVal *pVal, int8_t colType) {
    return;
  }
  if (!pVal->val) {
-    ASSERT(0);
    printf("BadVal ");
    return;
  }
@ -342,7 +341,7 @@ int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow) {
    }

    if (iColumn == 0) {
-      ASSERT(pColVal->cid == pTColumn->colId);
+      ASSERT(pColVal && pColVal->cid == pTColumn->colId);
      ASSERT(pTColumn->type == TSDB_DATA_TYPE_TIMESTAMP);
      ASSERT(pTColumn->colId == PRIMARYKEY_TIMESTAMP_COL_ID);
    } else {
@ -490,7 +489,6 @@ bool tdSTSRowGetVal(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCell

 int32_t tdGetBitmapValTypeII(const void *pBitmap, int16_t colIdx, TDRowValT *pValType) {
  if (!pBitmap || colIdx < 0) {
-    ASSERT(0);
    terrno = TSDB_CODE_INVALID_PARA;
    return terrno;
  }
@ -512,7 +510,6 @@ int32_t tdGetBitmapValTypeII(const void *pBitmap, int16_t colIdx, TDRowValT *pVa
      *pValType = ((*pDestByte) & 0x03);
      break;
    default:
-      ASSERT(0);
      terrno = TSDB_CODE_INVALID_PARA;
      return terrno;
  }
@ -521,7 +518,6 @@ int32_t tdGetBitmapValTypeII(const void *pBitmap, int16_t colIdx, TDRowValT *pVa

 int32_t tdGetBitmapValTypeI(const void *pBitmap, int16_t colIdx, TDRowValT *pValType) {
  if (!pBitmap || colIdx < 0) {
-    ASSERT(0);
    terrno = TSDB_CODE_INVALID_PARA;
    return terrno;
  }
@ -555,7 +551,6 @@ int32_t tdGetBitmapValTypeI(const void *pBitmap, int16_t colIdx, TDRowValT *pVal
      *pValType = ((*pDestByte) & 0x01);
      break;
    default:
-      ASSERT(0);
      terrno = TSDB_CODE_INVALID_PARA;
      return terrno;
  }
@ -564,7 +559,6 @@ int32_t tdGetBitmapValTypeI(const void *pBitmap, int16_t colIdx, TDRowValT *pVal

 int32_t tdSetBitmapValTypeI(void *pBitmap, int16_t colIdx, TDRowValT valType) {
  if (!pBitmap || colIdx < 0) {
-    ASSERT(0);
    terrno = TSDB_CODE_INVALID_PARA;
    return terrno;
  }
@ -607,7 +601,6 @@ int32_t tdSetBitmapValTypeI(void *pBitmap, int16_t colIdx, TDRowValT valType) {
      // *pDestByte |= (valType);
      break;
    default:
-      ASSERT(0);
      terrno = TSDB_CODE_INVALID_PARA;
      return terrno;
  }
@ -630,7 +623,6 @@ int32_t tdGetKvRowValOfCol(SCellVal *output, STSRow *pRow, void *pBitmap, int32_
    output->val = POINTER_SHIFT(pRow, offset);
  }
 #else
-  ASSERT(0);
  if (offset < 0) {
    terrno = TSDB_CODE_INVALID_PARA;
    output->valType = TD_VTYPE_NONE;
@ -680,7 +672,6 @@ int32_t tdAppendColValToRow(SRowBuilder *pBuilder, col_id_t colId, int8_t colTyp
      return terrno;
    }
 #else
-    ASSERT(0);
    terrno = TSDB_CODE_INVALID_PARA;
    return terrno;
 #endif
@ -707,8 +698,8 @@ int32_t tdAppendColValToRow(SRowBuilder *pBuilder, col_id_t colId, int8_t colTyp
      if (!pBuilder->hasNone) pBuilder->hasNone = true;
      return TSDB_CODE_SUCCESS;
    default:
-      ASSERT(0);
-      break;
+      terrno = TSDB_CODE_INVALID_PARA;
+      return terrno;
  }

  if (TD_IS_TP_ROW(pRow)) {
@ -722,7 +713,6 @@ int32_t tdAppendColValToRow(SRowBuilder *pBuilder, col_id_t colId, int8_t colTyp
 int32_t tdAppendColValToKvRow(SRowBuilder *pBuilder, TDRowValT valType, const void *val, bool isCopyVarData,
                              int8_t colType, int16_t colIdx, int32_t offset, col_id_t colId) {
  if ((offset < (int32_t)sizeof(SKvRowIdx)) || (colIdx < 1)) {
-    ASSERT(0);
    terrno = TSDB_CODE_INVALID_PARA;
    return terrno;
  }
@ -810,7 +800,6 @@ int32_t tdSRowSetExtendedInfo(SRowBuilder *pBuilder, int32_t nCols, int32_t nBou
  pBuilder->nCols = nCols;
  pBuilder->nBoundCols = nBoundCols;
  if (pBuilder->flen <= 0 || pBuilder->nCols <= 0) {
-    ASSERT(0);
    terrno = TSDB_CODE_INVALID_PARA;
    return terrno;
  }
@ -832,7 +821,6 @@ int32_t tdSRowSetExtendedInfo(SRowBuilder *pBuilder, int32_t nCols, int32_t nBou
 int32_t tdSRowResetBuf(SRowBuilder *pBuilder, void *pBuf) {
  pBuilder->pBuf = (STSRow *)pBuf;
  if (!pBuilder->pBuf) {
-    ASSERT(0);
    terrno = TSDB_CODE_INVALID_PARA;
    return terrno;
  }
@ -869,7 +857,6 @@ int32_t tdSRowResetBuf(SRowBuilder *pBuilder, void *pBuf) {
      TD_ROW_SET_NCOLS(pBuilder->pBuf, pBuilder->nBoundCols);
      break;
    default:
-      ASSERT(0);
      terrno = TSDB_CODE_INVALID_PARA;
      return terrno;
  }
@ -880,7 +867,6 @@ int32_t tdSRowResetBuf(SRowBuilder *pBuilder, void *pBuf) {
 int32_t tdSRowGetBuf(SRowBuilder *pBuilder, void *pBuf) {
  pBuilder->pBuf = (STSRow *)pBuf;
  if (!pBuilder->pBuf) {
-    ASSERT(0);
    terrno = TSDB_CODE_INVALID_PARA;
    return terrno;
  }
@ -900,7 +886,6 @@ int32_t tdSRowGetBuf(SRowBuilder *pBuilder, void *pBuf) {
 #endif
      break;
    default:
-      ASSERT(0);
      terrno = TSDB_CODE_INVALID_PARA;
      return terrno;
  }
@ -920,7 +905,6 @@ int32_t tdSRowSetTpInfo(SRowBuilder *pBuilder, int32_t nCols, int32_t flen) {
  pBuilder->flen = flen;
  pBuilder->nCols = nCols;
  if (pBuilder->flen <= 0 || pBuilder->nCols <= 0) {
-    ASSERT(0);
    terrno = TSDB_CODE_INVALID_PARA;
    return terrno;
  }
@ -939,7 +923,6 @@ int32_t tdSRowSetInfo(SRowBuilder *pBuilder, int32_t nCols, int32_t nBoundCols,
  pBuilder->nCols = nCols;
  pBuilder->nBoundCols = nBoundCols;
  if (pBuilder->flen <= 0 || pBuilder->nCols <= 0) {
-    ASSERT(0);
    terrno = TSDB_CODE_INVALID_PARA;
    return terrno;
  }
@ -968,7 +951,6 @@ int32_t tdGetBitmapValType(const void *pBitmap, int16_t colIdx, TDRowValT *pValT
      tdGetBitmapValTypeI(pBitmap, colIdx, pValType);
      break;
    default:
-      ASSERT(0);
      terrno = TSDB_CODE_INVALID_PARA;
      return TSDB_CODE_FAILED;
  }
@ -987,7 +969,6 @@ bool tdIsBitmapValTypeNorm(const void *pBitmap, int16_t idx, int8_t bitmapMode)

 int32_t tdSetBitmapValTypeII(void *pBitmap, int16_t colIdx, TDRowValT valType) {
  if (!pBitmap || colIdx < 0) {
-    ASSERT(0);
    terrno = TSDB_CODE_INVALID_PARA;
    return terrno;
  }
@ -1014,7 +995,6 @@ int32_t tdSetBitmapValTypeII(void *pBitmap, int16_t colIdx, TDRowValT valType) {
      // *pDestByte |= (valType);
      break;
    default:
-      ASSERT(0);
      terrno = TSDB_CODE_INVALID_PARA;
      return terrno;
  }
@ -1031,7 +1011,6 @@ int32_t tdSetBitmapValType(void *pBitmap, int16_t colIdx, TDRowValT valType, int
      tdSetBitmapValTypeI(pBitmap, colIdx, valType);
      break;
    default:
-      ASSERT(0);
      terrno = TSDB_CODE_INVALID_PARA;
      return TSDB_CODE_FAILED;
  }
--- a/source/common/src/ttime.c
+++ b/source/common/src/ttime.c
@ -168,12 +168,13 @@ int64_t parseFraction(char* str, char** end, int32_t timePrec) {
      i = MICRO_SEC_FRACTION_LEN;
    }
    times = MICRO_SEC_FRACTION_LEN - i;
-  } else {
-    assert(timePrec == TSDB_TIME_PRECISION_NANO);
+  } else if (timePrec == TSDB_TIME_PRECISION_NANO) {
    if (i >= NANO_SEC_FRACTION_LEN) {
      i = NANO_SEC_FRACTION_LEN;
    }
    times = NANO_SEC_FRACTION_LEN - i;
+  } else {
+    return -1;
  }

  fraction = strnatoi(str, i) * factor[times];
@ -510,8 +511,11 @@ int64_t convertTimePrecision(int64_t utime, int32_t fromPrecision, int32_t toPre
 // !!!!notice: double lose precison if time is too large, for example: 1626006833631000000*1.0 = double =
 // 1626006833631000064
 int64_t convertTimeFromPrecisionToUnit(int64_t time, int32_t fromPrecision, char toUnit) {
-  assert(fromPrecision == TSDB_TIME_PRECISION_MILLI || fromPrecision == TSDB_TIME_PRECISION_MICRO ||
-         fromPrecision == TSDB_TIME_PRECISION_NANO);
+  if (fromPrecision != TSDB_TIME_PRECISION_MILLI && fromPrecision != TSDB_TIME_PRECISION_MICRO &&
+      fromPrecision != TSDB_TIME_PRECISION_NANO) {
+    return -1;
+  }
+
  int64_t factors[3] = {NANOSECOND_PER_MSEC, NANOSECOND_PER_USEC, 1};
  double  tmp = time;
  switch (toUnit) {
@ -761,8 +765,7 @@ int32_t taosTimeCountInterval(int64_t skey, int64_t ekey, int64_t interval, char
 }

 int64_t taosTimeTruncate(int64_t t, const SInterval* pInterval, int32_t precision) {
-  if (pInterval->sliding == 0) {
-    assert(pInterval->interval == 0);
+  if (pInterval->sliding == 0 && pInterval->interval == 0) {
    return t;
  }

@ -931,7 +934,7 @@ void taosFormatUtcTime(char* buf, int32_t bufLen, int64_t t, int32_t precision)

    default:
      fractionLen = 0;
-      assert(false);
+      ASSERT(false);
  }

  taosLocalTime(&quot, &ptm);
--- a/source/common/src/ttszip.c
+++ b/source/common/src/ttszip.c
@ -17,6 +17,7 @@
 #include "ttszip.h"
 #include "taoserror.h"
 #include "tcompression.h"
+#include "tlog.h"

 static int32_t getDataStartOffset();
 static void    TSBufUpdateGroupInfo(STSBuf* pTSBuf, int32_t index, STSGroupBlockInfo* pBlockInfo);
@ -202,14 +203,14 @@ void* tsBufDestroy(STSBuf* pTSBuf) {
 static STSGroupBlockInfoEx* tsBufGetLastGroupInfo(STSBuf* pTSBuf) {
  int32_t last = pTSBuf->numOfGroups - 1;

-  assert(last >= 0);
+  ASSERT(last >= 0);
  return &pTSBuf->pData[last];
 }

 static STSGroupBlockInfoEx* addOneGroupInfo(STSBuf* pTSBuf, int32_t id) {
  if (pTSBuf->numOfAlloc <= pTSBuf->numOfGroups) {
    uint32_t newSize = (uint32_t)(pTSBuf->numOfAlloc * 1.5);
-    assert((int32_t)newSize > pTSBuf->numOfAlloc);
+    ASSERT((int32_t)newSize > pTSBuf->numOfAlloc);

    STSGroupBlockInfoEx* tmp =
        (STSGroupBlockInfoEx*)taosMemoryRealloc(pTSBuf->pData, sizeof(STSGroupBlockInfoEx) * newSize);
@ -233,7 +234,7 @@ static STSGroupBlockInfoEx* addOneGroupInfo(STSBuf* pTSBuf, int32_t id) {
  STSGroupBlockInfo* pBlockInfo = &pTSBuf->pData[pTSBuf->numOfGroups].info;
  pBlockInfo->id = id;
  pBlockInfo->offset = pTSBuf->fileSize;
-  assert(pBlockInfo->offset >= getDataStartOffset());
+  ASSERT(pBlockInfo->offset >= getDataStartOffset());

  // update vnode info in file
  TSBufUpdateGroupInfo(pTSBuf, pTSBuf->numOfGroups, pBlockInfo);
@ -282,7 +283,7 @@ static void writeDataToDisk(STSBuf* pTSBuf) {
                                        pTsData->allocSize, TWO_STAGE_COMP, pTSBuf->assistBuf, pTSBuf->bufSize);

  int64_t r = taosLSeekFile(pTSBuf->pFile, pTSBuf->fileSize, SEEK_SET);
-  assert(r == 0);
+  ASSERT(r == 0);

  /*
   * format for output data:
@ -316,7 +317,7 @@ static void writeDataToDisk(STSBuf* pTSBuf) {
  taosWriteFile(pTSBuf->pFile, &pBlock->compLen, sizeof(pBlock->compLen));

  metaLen += (int32_t)taosWriteFile(pTSBuf->pFile, &trueLen, sizeof(pBlock->tag.nLen));
-  assert(metaLen == getTagAreaLength(&pBlock->tag));
+  ASSERT(metaLen == getTagAreaLength(&pBlock->tag));

  int32_t blockSize = metaLen + sizeof(pBlock->numOfElem) + sizeof(pBlock->compLen) * 2 + pBlock->compLen;
  pTSBuf->fileSize += blockSize;
@ -379,7 +380,7 @@ STSBlock* readDataFromDisk(STSBuf* pTSBuf, int32_t order, bool decomp) {
  size_t sz = 0;
  if (pBlock->tag.nType == TSDB_DATA_TYPE_BINARY || pBlock->tag.nType == TSDB_DATA_TYPE_NCHAR) {
    char* tp = taosMemoryRealloc(pBlock->tag.pz, pBlock->tag.nLen + 1);
-    assert(tp != NULL);
+    ASSERT(tp != NULL);

    memset(tp, 0, pBlock->tag.nLen + 1);
    pBlock->tag.pz = tp;
@ -410,14 +411,14 @@ STSBlock* readDataFromDisk(STSBuf* pTSBuf, int32_t order, bool decomp) {

  // read the comp length at the length of comp block
  sz = taosReadFile(pTSBuf->pFile, &pBlock->padding, sizeof(pBlock->padding));
-  assert(pBlock->padding == pBlock->compLen);
+  ASSERT(pBlock->padding == pBlock->compLen);

  int32_t n = 0;
  sz = taosReadFile(pTSBuf->pFile, &n, sizeof(pBlock->tag.nLen));
  if (pBlock->tag.nType == TSDB_DATA_TYPE_NULL) {
-    assert(n == 0);
+    ASSERT(n == 0);
  } else {
-    assert(n == pBlock->tag.nLen);
+    ASSERT(n == pBlock->tag.nLen);
  }

  UNUSED(sz);
@ -477,7 +478,7 @@ void tsBufAppend(STSBuf* pTSBuf, int32_t id, SVariant* tag, const char* pData, i
    pBlockInfo = tsBufGetLastGroupInfo(pTSBuf);
  }

-  assert(pBlockInfo->info.id == id);
+  ASSERT(pBlockInfo->info.id == id);

  if ((taosVariantCompare(&pTSBuf->block.tag, tag) != 0) && ptsData->len > 0) {
    // new arrived data with different tags value, save current value into disk first
@ -596,7 +597,7 @@ static int32_t tsBufFindBlockByTag(STSBuf* pTSBuf, STSGroupBlockInfo* pBlockInfo
 static void tsBufGetBlock(STSBuf* pTSBuf, int32_t groupIndex, int32_t blockIndex) {
  STSGroupBlockInfo* pBlockInfo = &pTSBuf->pData[groupIndex].info;
  if (pBlockInfo->numOfBlocks <= blockIndex) {
-    assert(false);
+    ASSERT(false);
  }

  STSCursor* pCur = &pTSBuf->cur;
@ -613,7 +614,7 @@ static void tsBufGetBlock(STSBuf* pTSBuf, int32_t groupIndex, int32_t blockIndex
    }
  } else {
    if (tsBufFindBlock(pTSBuf, pBlockInfo, blockIndex) == -1) {
-      assert(false);
+      ASSERT(false);
    }
  }

@ -633,7 +634,7 @@ static void tsBufGetBlock(STSBuf* pTSBuf, int32_t groupIndex, int32_t blockIndex
      tsDecompressTimestamp(pBlock->payload, pBlock->compLen, pBlock->numOfElem, pTSBuf->tsData.rawBuf,
                            pTSBuf->tsData.allocSize, TWO_STAGE_COMP, pTSBuf->assistBuf, pTSBuf->bufSize);

-  assert((pTSBuf->tsData.len / TSDB_KEYSIZE == pBlock->numOfElem) && (pTSBuf->tsData.allocSize >= pTSBuf->tsData.len));
+  ASSERT((pTSBuf->tsData.len / TSDB_KEYSIZE == pBlock->numOfElem) && (pTSBuf->tsData.allocSize >= pTSBuf->tsData.len));

  pCur->vgroupIndex = groupIndex;
  pCur->blockIndex = blockIndex;
@ -668,7 +669,9 @@ int32_t STSBufUpdateHeader(STSBuf* pTSBuf, STSBufFileHeader* pHeader) {
    return -1;
  }

-  assert(pHeader->tsOrder == TSDB_ORDER_ASC || pHeader->tsOrder == TSDB_ORDER_DESC);
+  if (pHeader->tsOrder != TSDB_ORDER_ASC && pHeader->tsOrder != TSDB_ORDER_DESC) {
+    return -1;
+  }

  int32_t r = taosLSeekFile(pTSBuf->pFile, 0, SEEK_SET);
  if (r != 0) {
@ -705,7 +708,7 @@ bool tsBufNextPos(STSBuf* pTSBuf) {
      }

    } else {  // get the last timestamp record in the last block of the last vnode
-      assert(pTSBuf->numOfGroups > 0);
+      ASSERT(pTSBuf->numOfGroups > 0);

      int32_t groupIndex = pTSBuf->numOfGroups - 1;
      pCur->vgroupIndex = groupIndex;
@ -729,7 +732,7 @@ bool tsBufNextPos(STSBuf* pTSBuf) {
  int32_t step = pCur->order == TSDB_ORDER_ASC ? 1 : -1;

  while (1) {
-    assert(pTSBuf->tsData.len == pTSBuf->block.numOfElem * TSDB_KEYSIZE);
+    ASSERT(pTSBuf->tsData.len == pTSBuf->block.numOfElem * TSDB_KEYSIZE);

    if ((pCur->order == TSDB_ORDER_ASC && pCur->tsIndex >= pTSBuf->block.numOfElem - 1) ||
        (pCur->order == TSDB_ORDER_DESC && pCur->tsIndex <= 0)) {
@ -810,7 +813,7 @@ int32_t tsBufMerge(STSBuf* pDestBuf, const STSBuf* pSrcBuf) {
  }

  // src can only have one vnode index
-  assert(pSrcBuf->numOfGroups == 1);
+  ASSERT(pSrcBuf->numOfGroups == 1);

  // there are data in buffer, flush to disk first
  tsBufFlush(pDestBuf);
@ -853,7 +856,7 @@ int32_t tsBufMerge(STSBuf* pDestBuf, const STSBuf* pSrcBuf) {
  }

  int32_t r = taosLSeekFile(pDestBuf->pFile, 0, SEEK_END);
-  assert(r == 0);
+  ASSERT(r == 0);

  int64_t offset = getDataStartOffset();
  int32_t size = (int32_t)pSrcBuf->fileSize - (int32_t)offset;
@ -881,7 +884,7 @@ int32_t tsBufMerge(STSBuf* pDestBuf, const STSBuf* pSrcBuf) {
  }
  pDestBuf->fileSize = (uint32_t)file_size;

-  assert(pDestBuf->fileSize == oldSize + size);
+  ASSERT(pDestBuf->fileSize == oldSize + size);

  return 0;
 }
@ -913,7 +916,10 @@ STSBuf* tsBufCreateFromCompBlocks(const char* pData, int32_t numOfBlocks, int32_
  pTSBuf->fileSize += len;

  pTSBuf->tsOrder = order;
-  assert(order == TSDB_ORDER_ASC || order == TSDB_ORDER_DESC);
+  if (order != TSDB_ORDER_ASC && order != TSDB_ORDER_DESC) {
+    tsBufDestroy(pTSBuf);
+    return NULL;
+  }

  STSBufFileHeader header = {
      .magic = TS_COMP_FILE_MAGIC, .numOfGroup = pTSBuf->numOfGroups, .tsOrder = pTSBuf->tsOrder};
@ -1095,7 +1101,7 @@ void tsBufGetGroupIdList(STSBuf* pTSBuf, int32_t* num, int32_t** id) {
 }

 int32_t dumpFileBlockByGroupId(STSBuf* pTSBuf, int32_t groupIndex, void* buf, int32_t* len, int32_t* numOfBlocks) {
-  assert(groupIndex >= 0 && groupIndex < pTSBuf->numOfGroups);
+  ASSERT(groupIndex >= 0 && groupIndex < pTSBuf->numOfGroups);
  STSGroupBlockInfo* pBlockInfo = &pTSBuf->pData[groupIndex].info;

  *len = 0;
--- a/source/common/src/ttypes.c
+++ b/source/common/src/ttypes.c
@ -131,13 +131,16 @@ void assignVal(char *val, const char *src, int32_t len, int32_t type) {
      varDataCopy(val, src);
      break;
    default: {
-      memcpy(val, src, len);
+      if (len > 0) {
+        memcpy(val, src, len);
+      }
+
      break;
    }
  }
 }

-void operateVal(void *dst, void *s1, void *s2, int32_t optr, int32_t type) {
+int32_t operateVal(void *dst, void *s1, void *s2, int32_t optr, int32_t type) {
  if (optr == OP_TYPE_ADD) {
    switch (type) {
      case TSDB_DATA_TYPE_TINYINT:
@ -174,11 +177,12 @@ void operateVal(void *dst, void *s1, void *s2, int32_t optr, int32_t type) {
        SET_DOUBLE_VAL(dst, GET_DOUBLE_VAL(s1) + GET_DOUBLE_VAL(s2));
        break;
      default: {
-        assert(0);
-        break;
+        return -1;
      }
    }
  } else {
-    assert(0);
+    return -1;
  }
+
+  return 0;
 }
--- a/source/common/src/tvariant.c
+++ b/source/common/src/tvariant.c
@ -168,7 +168,7 @@ void taosVariantAssign(SVariant *pDst, const SVariant *pSrc) {
      pSrc->nType == TSDB_DATA_TYPE_JSON) {
    int32_t len = pSrc->nLen + TSDB_NCHAR_SIZE;
    char   *p = taosMemoryRealloc(pDst->pz, len);
-    assert(p);
+    ASSERT(p);

    memset(p, 0, len);
    pDst->pz = p;
@ -192,7 +192,7 @@ void taosVariantAssign(SVariant *pDst, const SVariant *pSrc) {
    size_t num = taosArrayGetSize(pSrc->arr);
    pDst->arr = taosArrayInit(num, sizeof(int64_t));
    pDst->nLen = pSrc->nLen;
-    assert(pSrc->nLen == num);
+    ASSERT(pSrc->nLen == num);
    for (size_t i = 0; i < num; i++) {
      int64_t *p = taosArrayGet(pSrc->arr, i);
      taosArrayPush(pDst->arr, p);
--- a/source/common/test/dataformatTest.cpp
+++ b/source/common/test/dataformatTest.cpp
@ -117,7 +117,7 @@ STSchema *genSTSchema(int16_t nCols) {
  }

  STSchema *pResult = NULL;
-  pResult = tdGetSTSChemaFromSSChema(pSchema, nCols, 1);
+  pResult = tBuildTSchema(pSchema, nCols, 1);

  taosMemoryFree(pSchema);
  return pResult;
--- a/source/dnode/mgmt/exe/dmMain.c
+++ b/source/dnode/mgmt/exe/dmMain.c
@ -178,7 +178,7 @@ static int32_t dmInitLog() {
 }

 static void taosCleanupArgs() {
-  if (global.envCmd != NULL) taosMemoryFree(global.envCmd);
+  if (global.envCmd != NULL) taosMemoryFreeClear(global.envCmd);
 }

 int main(int argc, char const *argv[]) {
@ -268,6 +268,10 @@ int mainWindows(int argc, char **argv) {

  if (dmInit() != 0) {
    dError("failed to init dnode since %s", terrstr());
+
+    taosCleanupCfg();
+    taosCloseLog();
+    taosConvDestroy();
    return -1;
  }

--- a/source/dnode/mgmt/mgmt_dnode/src/dmHandle.c
+++ b/source/dnode/mgmt/mgmt_dnode/src/dmHandle.c
@ -41,6 +41,8 @@ static void dmProcessStatusRsp(SDnodeMgmt *pMgmt, SRpcMsg *pRsp) {
             pMgmt->statusSeq);
      pMgmt->pData->dropped = 1;
      dmWriteEps(pMgmt->pData);
+      dInfo("dnode will exit since it is in the dropped state");
+      raise(SIGINT);
    }
  } else {
    SStatusRsp statusRsp = {0};
--- a/source/dnode/mgmt/mgmt_mnode/src/mmFile.c
+++ b/source/dnode/mgmt/mgmt_mnode/src/mmFile.c
@ -180,6 +180,6 @@ int32_t mmWriteFile(const char *path, const SMnodeOpt *pOption) {
    return -1;
  }

-  dDebug("successed to write %s, deployed:%d", realfile, pOption->deploy);
+  dDebug("succeed to write %s, deployed:%d", realfile, pOption->deploy);
  return 0;
 }
--- a/source/dnode/mgmt/mgmt_snode/src/smWorker.c
+++ b/source/dnode/mgmt/mgmt_snode/src/smWorker.c
@ -58,11 +58,7 @@ static void smProcessStreamQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
  dTrace("msg:%p, get from snode-stream queue", pMsg);
  int32_t code = sndProcessStreamMsg(pMgmt->pSnode, pMsg);
  if (code < 0) {
-    if (pMsg) {
-      dGError("snd, msg:%p failed to process stream msg %s since %s", pMsg, TMSG_INFO(pMsg->msgType), terrstr(code));
-    } else {
-      dGError("snd, msg:%p failed to process stream empty msg since %s", pMsg, terrstr(code));
-    }
+    dGError("snd, msg:%p failed to process stream msg %s since %s", pMsg, TMSG_INFO(pMsg->msgType), terrstr(code));
    smSendRsp(pMsg, terrno);
  }

@ -161,8 +157,10 @@ int32_t smPutMsgToQueue(SSnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc) {
      smPutNodeMsgToWriteQueue(pMgmt, pMsg);
      break;
    default:
-      ASSERTS(0, "msg:%p failed to put into snode queue since %s, type:%s qtype:%d", pMsg, terrstr(),
-              TMSG_INFO(pMsg->msgType), qtype);
+      terrno = TSDB_CODE_INVALID_PARA;
+      rpcFreeCont(pMsg->pCont);
+      taosFreeQitem(pMsg);
+      return -1;
  }
  return 0;
 }
--- a/source/dnode/mgmt/mgmt_vnode/inc/vmInt.h
+++ b/source/dnode/mgmt/mgmt_vnode/inc/vmInt.h
@ -26,20 +26,20 @@ extern "C" {
 #endif

 typedef struct SVnodeMgmt {
-  SDnodeData    *pData;
-  SMsgCb         msgCb;
-  const char    *path;
-  const char    *name;
-  SQWorkerPool   queryPool;
-  SQWorkerPool   streamPool;
-  SWWorkerPool   fetchPool;
-  SSingleWorker  mgmtWorker;
-  SHashObj      *hash;
-  TdThreadRwlock lock;
-  SVnodesStat    state;
-  STfs          *pTfs;
-  TdThread       thread;
-  bool           stop;
+  SDnodeData      *pData;
+  SMsgCb           msgCb;
+  const char      *path;
+  const char      *name;
+  SQWorkerPool     queryPool;
+  SAutoQWorkerPool streamPool;
+  SWWorkerPool     fetchPool;
+  SSingleWorker    mgmtWorker;
+  SHashObj        *hash;
+  TdThreadRwlock   lock;
+  SVnodesStat      state;
+  STfs            *pTfs;
+  TdThread         thread;
+  bool             stop;
 } SVnodeMgmt;

 typedef struct {
--- a/source/dnode/mgmt/mgmt_vnode/src/vmFile.c
+++ b/source/dnode/mgmt/mgmt_vnode/src/vmFile.c
@ -16,7 +16,7 @@
 #define _DEFAULT_SOURCE
 #include "vmInt.h"

-#define MAX_CONTENT_LEN 1024 * 1024
+#define MAX_CONTENT_LEN 2 * 1024 * 1024

 SVnodeObj **vmGetVnodeListFromHash(SVnodeMgmt *pMgmt, int32_t *numOfVnodes) {
  taosThreadRwlockRdlock(&pMgmt->lock);
@ -60,7 +60,7 @@ int32_t vmGetVnodeListFromFile(SVnodeMgmt *pMgmt, SWrapperCfg **ppCfgs, int32_t

  pFile = taosOpenFile(file, TD_FILE_READ);
  if (pFile == NULL) {
-    dDebug("file %s not exist", file);
+    dInfo("file %s not exist", file);
    code = 0;
    goto _OVER;
  }
@ -133,7 +133,7 @@ int32_t vmGetVnodeListFromFile(SVnodeMgmt *pMgmt, SWrapperCfg **ppCfgs, int32_t

  *numOfVnodes = vnodesNum;
  code = 0;
-  dDebug("succcessed to read file %s, numOfVnodes:%d", file, vnodesNum);
+  dInfo("succcessed to read file %s, numOfVnodes:%d", file, vnodesNum);

 _OVER:
  if (content != NULL) taosMemoryFree(content);
@ -163,6 +163,7 @@ int32_t vmWriteVnodeListToFile(SVnodeMgmt *pMgmt) {
  if (ppVnodes == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    code = -1;
+    dError("failed to write %s while get vnodelist", file);
    goto _OVER;
  }

@ -172,6 +173,7 @@ int32_t vmWriteVnodeListToFile(SVnodeMgmt *pMgmt) {
  if (content == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    code = -1;
+    dError("failed to write %s while malloc content", file);
    goto _OVER;
  }

@ -213,6 +215,12 @@ _OVER:

  if (code != 0) return -1;

-  dDebug("successed to write %s, numOfVnodes:%d", realfile, numOfVnodes);
-  return taosRenameFile(file, realfile);
+  dInfo("succeed to write %s, numOfVnodes:%d", realfile, numOfVnodes);
+  code = taosRenameFile(file, realfile);
+  
+  if (code != 0) {
+    dError("failed to rename %s to %s", file, realfile);
+  }
+
+  return code;
 }
--- a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
+++ b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
@ -132,10 +132,12 @@ static void vmGenerateVnodeCfg(SCreateVnodeReq *pCreate, SVnodeCfg *pCfg) {
  pCfg->syncCfg.myIndex = pCreate->selfIndex;
  pCfg->syncCfg.replicaNum = pCreate->replica;
  memset(&pCfg->syncCfg.nodeInfo, 0, sizeof(pCfg->syncCfg.nodeInfo));
-  for (int i = 0; i < pCreate->replica; ++i) {
+  for (int32_t i = 0; i < pCreate->replica; ++i) {
    SNodeInfo *pNode = &pCfg->syncCfg.nodeInfo[i];
+    pNode->nodeId = pCreate->replicas[i].id;
    pNode->nodePort = pCreate->replicas[i].port;
-    tstrncpy(pNode->nodeFqdn, pCreate->replicas[i].fqdn, sizeof(pNode->nodeFqdn));
+    tstrncpy(pNode->nodeFqdn, pCreate->replicas[i].fqdn, TSDB_FQDN_LEN);
+    (void)tmsgUpdateDnodeInfo(&pNode->nodeId, &pNode->clusterId, pNode->nodeFqdn, &pNode->nodePort);
  }
 }

@ -188,8 +190,8 @@ int32_t vmProcessCreateVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
        req.walRollPeriod, req.walSegmentSize, req.hashMethod, req.hashBegin, req.hashEnd, req.hashPrefix,
        req.hashSuffix, req.replica, req.selfIndex, req.strict);
  for (int32_t i = 0; i < req.replica; ++i) {
-    dInfo("vgId:%d, replica:%d id:%d fqdn:%s port:%u", req.vgId, i, req.replicas[i].id, req.replicas[i].fqdn,
-          req.replicas[i].port);
+    dInfo("vgId:%d, replica:%d ep:%s:%u dnode:%d", req.vgId, i, req.replicas[i].fqdn, req.replicas[i].port,
+          req.replicas[i].id);
  }

  SReplica *pReplica = &req.replicas[req.selfIndex];
@ -213,7 +215,7 @@ int32_t vmProcessCreateVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {

  SVnodeObj *pVnode = vmAcquireVnode(pMgmt, req.vgId);
  if (pVnode != NULL) {
-    dDebug("vgId:%d, already exist", req.vgId);
+    dInfo("vgId:%d, already exist", req.vgId);
    tFreeSCreateVnodeReq(&req);
    vmReleaseVnode(pMgmt, pVnode);
    terrno = TSDB_CODE_VND_ALREADY_EXIST;
@ -286,7 +288,8 @@ int32_t vmProcessAlterVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
  dInfo("vgId:%d, start to alter vnode, replica:%d selfIndex:%d strict:%d", alterReq.vgId, alterReq.replica,
        alterReq.selfIndex, alterReq.strict);
  for (int32_t i = 0; i < alterReq.replica; ++i) {
-    dInfo("vgId:%d, replica:%d ep:%s:%u", alterReq.vgId, i, alterReq.replicas[i].fqdn, alterReq.replicas[i].port);
+    SReplica *pReplica = &alterReq.replicas[i];
+    dInfo("vgId:%d, replica:%d ep:%s:%u dnode:%d", alterReq.vgId, i, pReplica->fqdn, pReplica->port, pReplica->port);
  }

  if (alterReq.replica <= 0 || alterReq.selfIndex < 0 || alterReq.selfIndex >= alterReq.replica) {
@ -358,7 +361,7 @@ int32_t vmProcessDropVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
  }

  int32_t vgId = dropReq.vgId;
-  dDebug("vgId:%d, start to drop vnode", vgId);
+  dInfo("vgId:%d, start to drop vnode", vgId);

  if (dropReq.dnodeId != pMgmt->pData->dnodeId) {
    terrno = TSDB_CODE_INVALID_MSG;
@ -368,7 +371,7 @@ int32_t vmProcessDropVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {

  SVnodeObj *pVnode = vmAcquireVnode(pMgmt, vgId);
  if (pVnode == NULL) {
-    dDebug("vgId:%d, failed to drop since %s", vgId, terrstr());
+    dInfo("vgId:%d, failed to drop since %s", vgId, terrstr());
    terrno = TSDB_CODE_VND_NOT_EXIST;
    return -1;
  }
@ -383,6 +386,7 @@ int32_t vmProcessDropVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
  vmCloseVnode(pMgmt, pVnode);
  vmWriteVnodeListToFile(pMgmt);

+  dInfo("vgId:%d, is dropped", vgId);
  return 0;
 }

--- a/source/dnode/mgmt/mgmt_vnode/src/vmInt.c
+++ b/source/dnode/mgmt/mgmt_vnode/src/vmInt.c
@ -118,6 +118,9 @@ void vmCloseVnode(SVnodeMgmt *pMgmt, SVnodeObj *pVnode) {

  dInfo("vgId:%d, all vnode queues is empty", pVnode->vgId);

+  dInfo("vgId:%d, post close", pVnode->vgId);
+  vnodePostClose(pVnode->pImpl);
+
  vmFreeQueue(pMgmt, pVnode);
  vnodeClose(pVnode->pImpl);
  pVnode->pImpl = NULL;
@ -138,7 +141,7 @@ static void *vmOpenVnodeInThread(void *param) {
  SVnodeMgmt   *pMgmt = pThread->pMgmt;
  char          path[TSDB_FILENAME_LEN];

-  dDebug("thread:%d, start to open %d vnodes", pThread->threadIndex, pThread->vnodeNum);
+  dInfo("thread:%d, start to open %d vnodes", pThread->threadIndex, pThread->vnodeNum);
  setThreadName("open-vnodes");

  for (int32_t v = 0; v < pThread->vnodeNum; ++v) {
@ -156,14 +159,14 @@ static void *vmOpenVnodeInThread(void *param) {
      pThread->failed++;
    } else {
      vmOpenVnode(pMgmt, pCfg, pImpl);
-      dDebug("vgId:%d, is opened by thread:%d", pCfg->vgId, pThread->threadIndex);
+      dInfo("vgId:%d, is opened by thread:%d", pCfg->vgId, pThread->threadIndex);
      pThread->opened++;
      atomic_add_fetch_32(&pMgmt->state.openVnodes, 1);
    }
  }

-  dDebug("thread:%d, numOfVnodes:%d, opened:%d failed:%d", pThread->threadIndex, pThread->vnodeNum, pThread->opened,
-         pThread->failed);
+  dInfo("thread:%d, numOfVnodes:%d, opened:%d failed:%d", pThread->threadIndex, pThread->vnodeNum, pThread->opened,
+        pThread->failed);
  return NULL;
 }

@ -496,7 +499,7 @@ static void *vmRestoreVnodeInThread(void *param) {
      dError("vgId:%d, failed to restore vnode by thread:%d", pVnode->vgId, pThread->threadIndex);
      pThread->failed++;
    } else {
-      dDebug("vgId:%d, is restored by thread:%d", pVnode->vgId, pThread->threadIndex);
+      dInfo("vgId:%d, is restored by thread:%d", pVnode->vgId, pThread->threadIndex);
      pThread->opened++;
      atomic_add_fetch_32(&pMgmt->state.openVnodes, 1);
    }
--- a/source/dnode/mgmt/mgmt_vnode/src/vmWorker.c
+++ b/source/dnode/mgmt/mgmt_vnode/src/vmWorker.c
@ -86,12 +86,8 @@ static void vmProcessStreamQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
  int32_t code = vnodeProcessFetchMsg(pVnode->pImpl, pMsg, pInfo);
  if (code != 0) {
    if (terrno != 0) code = terrno;
-    if (pMsg) {
-      dGError("vgId:%d, msg:%p failed to process stream msg %s since %s", pVnode->vgId, pMsg, TMSG_INFO(pMsg->msgType),
-              terrstr(code));
-    } else {
-      dGError("vgId:%d, msg:%p failed to process stream empty msg since %s", pVnode->vgId, pMsg, terrstr(code));
-    }
+    dGError("vgId:%d, msg:%p failed to process stream msg %s since %s", pVnode->vgId, pMsg, TMSG_INFO(pMsg->msgType),
+            terrstr(code));
    vmSendRsp(pMsg, code);
  }

@ -138,19 +134,34 @@ static void vmProcessSyncQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numOf
  }
 }

+static void vmSendResponse(SRpcMsg *pMsg) {
+  if (pMsg->info.handle) {
+    SRpcMsg rsp = {.info = pMsg->info, .code = terrno};
+    rpcSendResponse(&rsp);
+  }
+}
+
 static int32_t vmPutMsgToQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg, EQueueType qtype) {
  const STraceId *trace = &pMsg->info.traceId;
-  SMsgHead       *pHead = pMsg->pCont;
-  int32_t         code = 0;
+  if (pMsg->contLen < sizeof(SMsgHead)) {
+    dGError("invalid rpc msg with no msg head at pCont. pMsg:%p, type:%s, contLen:%d", pMsg, TMSG_INFO(pMsg->msgType),
+            pMsg->contLen);
+    return -1;
+  }
+
+  SMsgHead *pHead = pMsg->pCont;
+  int32_t   code = 0;

  pHead->contLen = ntohl(pHead->contLen);
  pHead->vgId = ntohl(pHead->vgId);

  SVnodeObj *pVnode = vmAcquireVnode(pMgmt, pHead->vgId);
  if (pVnode == NULL) {
-    dGError("vgId:%d, msg:%p failed to put into vnode queue since %s, type:%s qtype:%d contLen:%d", pHead->vgId, pMsg, terrstr(),
-            TMSG_INFO(pMsg->msgType), qtype, pHead->contLen);
-    return terrno != 0 ? terrno : -1;
+    dGError("vgId:%d, msg:%p failed to put into vnode queue since %s, type:%s qtype:%d contLen:%d", pHead->vgId, pMsg,
+            terrstr(), TMSG_INFO(pMsg->msgType), qtype, pHead->contLen);
+    terrno = (terrno != 0) ? terrno : -1;
+    vmSendResponse(pMsg);
+    return terrno;
  }

  switch (qtype) {
@ -233,6 +244,14 @@ int32_t vmPutMsgToMgmtQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
 }

 int32_t vmPutRpcMsgToQueue(SVnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc) {
+  if (pRpc->contLen < sizeof(SMsgHead)) {
+    dError("invalid rpc msg with no msg head at pCont. pRpc:%p, type:%s, len:%d", pRpc, TMSG_INFO(pRpc->msgType),
+           pRpc->contLen);
+    rpcFreeCont(pRpc->pCont);
+    pRpc->pCont = NULL;
+    return -1;
+  }
+
  SRpcMsg *pMsg = taosAllocateQitem(sizeof(SRpcMsg), RPC_QITEM, pRpc->contLen);
  if (pMsg == NULL) {
    rpcFreeCont(pRpc->pCont);
@ -304,7 +323,7 @@ int32_t vmAllocQueue(SVnodeMgmt *pMgmt, SVnodeObj *pVnode) {
  (void)tMultiWorkerInit(&pVnode->pApplyW, &acfg);

  pVnode->pQueryQ = tQWorkerAllocQueue(&pMgmt->queryPool, pVnode, (FItem)vmProcessQueryQueue);
-  pVnode->pStreamQ = tQWorkerAllocQueue(&pMgmt->streamPool, pVnode, (FItem)vmProcessStreamQueue);
+  pVnode->pStreamQ = tAutoQWorkerAllocQueue(&pMgmt->streamPool, pVnode, (FItem)vmProcessStreamQueue);
  pVnode->pFetchQ = tWWorkerAllocQueue(&pMgmt->fetchPool, pVnode, (FItems)vmProcessFetchQueue);

  if (pVnode->pWriteW.queue == NULL || pVnode->pSyncW.queue == NULL || pVnode->pSyncCtrlW.queue == NULL ||
@ -330,7 +349,7 @@ int32_t vmAllocQueue(SVnodeMgmt *pMgmt, SVnodeObj *pVnode) {

 void vmFreeQueue(SVnodeMgmt *pMgmt, SVnodeObj *pVnode) {
  tQWorkerFreeQueue(&pMgmt->queryPool, pVnode->pQueryQ);
-  tQWorkerFreeQueue(&pMgmt->streamPool, pVnode->pStreamQ);
+  tAutoQWorkerFreeQueue(&pMgmt->streamPool, pVnode->pStreamQ);
  tWWorkerFreeQueue(&pMgmt->fetchPool, pVnode->pFetchQ);
  pVnode->pQueryQ = NULL;
  pVnode->pStreamQ = NULL;
@ -345,11 +364,10 @@ int32_t vmStartWorker(SVnodeMgmt *pMgmt) {
  pQPool->max = tsNumOfVnodeQueryThreads;
  if (tQWorkerInit(pQPool) != 0) return -1;

-  SQWorkerPool *pStreamPool = &pMgmt->streamPool;
+  SAutoQWorkerPool *pStreamPool = &pMgmt->streamPool;
  pStreamPool->name = "vnode-stream";
-  pStreamPool->min = tsNumOfVnodeStreamThreads;
-  pStreamPool->max = tsNumOfVnodeStreamThreads;
-  if (tQWorkerInit(pStreamPool) != 0) return -1;
+  pStreamPool->ratio = tsRatioOfVnodeStreamThreads;
+  if (tAutoQWorkerInit(pStreamPool) != 0) return -1;

  SWWorkerPool *pFPool = &pMgmt->fetchPool;
  pFPool->name = "vnode-fetch";
@ -371,7 +389,7 @@ int32_t vmStartWorker(SVnodeMgmt *pMgmt) {

 void vmStopWorker(SVnodeMgmt *pMgmt) {
  tQWorkerCleanup(&pMgmt->queryPool);
-  tQWorkerCleanup(&pMgmt->streamPool);
+  tAutoQWorkerCleanup(&pMgmt->streamPool);
  tWWorkerCleanup(&pMgmt->fetchPool);
  dDebug("vnode workers are closed");
 }
--- a/source/dnode/mgmt/node_mgmt/src/dmNodes.c
+++ b/source/dnode/mgmt/node_mgmt/src/dmNodes.c
@ -109,8 +109,8 @@ static int32_t dmStartNodes(SDnode *pDnode) {
    }
  }

-  dInfo("TDengine initialized successfully");
-  dmReportStartup("TDengine", "initialized successfully");
+  dInfo("The daemon initialized successfully");
+  dmReportStartup("The daemon", "initialized successfully");
  return 0;
 }

@ -142,7 +142,7 @@ int32_t dmRunDnode(SDnode *pDnode) {

  while (1) {
    if (pDnode->stop) {
-      dInfo("TDengine is about to stop");
+      dInfo("The daemon is about to stop");
      dmSetStatus(pDnode, DND_STAT_STOPPED);
      dmStopNodes(pDnode);
      dmCloseNodes(pDnode);
--- a/Show More
+++ b/Show More