diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8fe6cc69e0..b78b896908 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -35,7 +35,7 @@ endif(${BUILD_TEST})
 add_subdirectory(source)
 add_subdirectory(tools)
 add_subdirectory(tests)
-add_subdirectory(example)
+add_subdirectory(examples/c)
 
 # docs 
 add_subdirectory(docs)
diff --git a/cmake/cmake.define b/cmake/cmake.define
index 5637c666b9..8d71870e7d 100644
--- a/cmake/cmake.define
+++ b/cmake/cmake.define
@@ -46,7 +46,7 @@ ENDIF ()
 
 IF (TD_WINDOWS)
     MESSAGE("${Yellow} set compiler flag for Windows! ${ColourReset}")
-    SET(COMMON_FLAGS "/w /D_WIN32 /Zi")
+    SET(COMMON_FLAGS "/w /D_WIN32 /DWIN32 /Zi")
     SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /MANIFEST:NO")
     # IF (MSVC AND (MSVC_VERSION GREATER_EQUAL 1900))
     #  SET(COMMON_FLAGS "${COMMON_FLAGS} /Wv:18")
diff --git a/docs-cn/12-taos-sql/07-function.md b/docs-cn/12-taos-sql/07-function.md
index d2cd89f152..7674967f09 100644
--- a/docs-cn/12-taos-sql/07-function.md
+++ b/docs-cn/12-taos-sql/07-function.md
@@ -1,6 +1,6 @@
 ---
-sidebar_label: SQL 函数
-title: SQL 函数
+sidebar_label: 函数
+title: 函数
 toc_max_heading_level: 4
 ---
 
@@ -20,7 +20,7 @@ toc_max_heading_level: 4
 
 **返回结果类型**：如果输入值为整数，输出值是 UBIGINT 类型。如果输入值是 FLOAT/DOUBLE 数据类型，输出值是 DOUBLE 数据类型。
 
-**适用数据类型**：不能应用在 timestamp、binary、nchar、bool 类型字段上；在超级表查询中使用时，不能应用在 tag 列
+**适用数据类型**：数值类型。
 
 **嵌套子查询支持**：适用于内层查询和外层查询。
 
@@ -38,7 +38,7 @@ toc_max_heading_level: 4
 
 **返回结果类型**：DOUBLE。如果输入值为 NULL，输出值也为 NULL
 
-**适用数据类型**：不能应用在 timestamp、binary、nchar、bool 类型字段上；在超级表查询中使用时，不能应用在 tag 列
+**适用数据类型**：数值类型。
 
 **嵌套子查询支持**：适用于内层查询和外层查询。
 
@@ -56,7 +56,7 @@ toc_max_heading_level: 4
 
 **返回结果类型**：DOUBLE。如果输入值为 NULL，输出值也为 NULL
 
-**适用数据类型**：不能应用在 timestamp、binary、nchar、bool 类型字段上；在超级表查询中使用时，不能应用在 tag 列
+**适用数据类型**：数值类型。
 
 **嵌套子查询支持**：适用于内层查询和外层查询。
 
@@ -75,7 +75,7 @@ toc_max_heading_level: 4
 
 **返回结果类型**：DOUBLE。如果输入值为 NULL，输出值也为 NULL
 
-**适用数据类型**：不能应用在 timestamp、binary、nchar、bool 类型字段上；在超级表查询中使用时，不能应用在 tag 列
+**适用数据类型**：数值类型。
 
 **嵌套子查询支持**：适用于内层查询和外层查询。
 
@@ -94,7 +94,7 @@ SELECT CEIL(field_name) FROM { tb_name | stb_name } [WHERE clause];
 
 **返回结果类型**：与指定列的原始数据类型一致。例如，如果指定列的原始数据类型为 Float，那么返回的数据类型也为 Float；如果指定列的原始数据类型为 Double，那么返回的数据类型也为 Double。
 
-**适用数据类型**：不能应用在 timestamp、binary、nchar、bool 类型字段上；在超级表查询中使用时，不能应用在 tag 列，无论 tag 列的类型是什么类型。
+**适用数据类型**：数值类型。
 
 **适用于**: 普通表、超级表。
 
@@ -115,7 +115,7 @@ SELECT CEIL(field_name) FROM { tb_name | stb_name } [WHERE clause];
 
 **返回结果类型**：DOUBLE。如果输入值为 NULL，输出值也为 NULL
 
-**适用数据类型**：不能应用在 timestamp、binary、nchar、bool 类型字段上；在超级表查询中使用时，不能应用在 tag 列
+**适用数据类型**：数值类型。
 
 **嵌套子查询支持**：适用于内层查询和外层查询。
 
@@ -142,7 +142,7 @@ SELECT FLOOR(field_name) FROM { tb_name | stb_name } [WHERE clause];
 
 **返回结果类型**：DOUBLE。如果输入值为 NULL，输出值也为 NULL
 
-**适用数据类型**：不能应用在 timestamp、binary、nchar、bool 类型字段上；在超级表查询中使用时，不能应用在 tag 列
+**适用数据类型**：数值类型。
 
 **嵌套子查询支持**：适用于内层查询和外层查询。
 
@@ -161,7 +161,7 @@ SELECT FLOOR(field_name) FROM { tb_name | stb_name } [WHERE clause];
 
 **返回结果类型**：DOUBLE。如果输入值为 NULL，输出值也为 NULL
 
-**适用数据类型**：不能应用在 timestamp、binary、nchar、bool 类型字段上；在超级表查询中使用时，不能应用在 tag 列
+**适用数据类型**：数值类型。
 
 **嵌套子查询支持**：适用于内层查询和外层查询。
 
@@ -190,7 +190,7 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
 
 **返回结果类型**：DOUBLE。如果输入值为 NULL，输出值也为 NULL
 
-**适用数据类型**：不能应用在 timestamp、binary、nchar、bool 类型字段上；在超级表查询中使用时，不能应用在 tag 列
+**适用数据类型**：数值类型。
 
 **嵌套子查询支持**：适用于内层查询和外层查询。
 
@@ -208,7 +208,7 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
 
 **返回结果类型**：DOUBLE。如果输入值为 NULL，输出值也为 NULL
 
-**适用数据类型**：不能应用在 timestamp、binary、nchar、bool 类型字段上；在超级表查询中使用时，不能应用在 tag 列
+**适用数据类型**：数值类型。
 
 **嵌套子查询支持**：适用于内层查询和外层查询。
 
@@ -226,7 +226,7 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
 
 **返回结果类型**：DOUBLE。如果输入值为 NULL，输出值也为 NULL
 
-**适用数据类型**：不能应用在 timestamp、binary、nchar、bool 类型字段上；在超级表查询中使用时，不能应用在 tag 列
+**适用数据类型**：数值类型。
 
 **嵌套子查询支持**：适用于内层查询和外层查询。
 
@@ -248,7 +248,7 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
 
 **返回结果类型**：INT。如果输入值为NULL，输出值为NULL。
 
-**适用数据类型**：输入参数是 BINARY 类型或者 NCHAR 类型的字符串或者列。不能应用在 TAG 列。
+**适用数据类型**：VARCHAR, NCHAR
 
 **嵌套子查询支持**：适用于内层查询和外层查询。
 
@@ -262,9 +262,9 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
 
 **功能说明**：字符串连接函数。
 
-**返回结果类型**：如果所有参数均为BINARY类型，则结果类型为BINARY。如果参数包含NCHAR类型，则结果类型为NCHAR。如果输入值为NULL，输出值为NULL。
+**返回结果类型**：如果所有参数均为 VARCHAR 类型，则结果类型为 VARCHAR。如果参数包含NCHAR类型，则结果类型为NCHAR。如果输入值为NULL，输出值为NULL。
 
-**适用数据类型**：BINARY, NCHAR。不能应用在 TAG 列。 该函数最小参数个数为2个，最大参数个数为8个。
+**适用数据类型**：VARCHAR, NCHAR。 该函数最小参数个数为2个，最大参数个数为8个。
 
 **嵌套子查询支持**：适用于内层查询和外层查询。
 
@@ -279,9 +279,9 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
 
 **功能说明**：带分隔符的字符串连接函数。
 
-**返回结果类型**：如果所有参数均为BINARY类型，则结果类型为BINARY。如果参数包含NCHAR类型，则结果类型为NCHAR。如果输入值为NULL，输出值为NULL。如果separator值不为NULL，其他输入为NULL，输出为空串。
+**返回结果类型**：如果所有参数均为VARCHAR类型，则结果类型为VARCHAR。如果参数包含NCHAR类型，则结果类型为NCHAR。如果输入值为NULL，输出值为NULL。如果separator值不为NULL，其他输入为NULL，输出为空串。
 
-**适用数据类型**：BINARY, NCHAR。不能应用在 TAG 列。 该函数最小参数个数为3个，最大参数个数为9个。
+**适用数据类型**：VARCHAR, NCHAR。 该函数最小参数个数为3个，最大参数个数为9个。
 
 **嵌套子查询支持**：适用于内层查询和外层查询。
 
@@ -298,7 +298,7 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
 
 **返回结果类型**：INT。
 
-**适用数据类型**：输入参数是 BINARY 类型或者 NCHAR 类型的字符串或者列。不能应用在 TAG 列。
+**适用数据类型**：输入参数是 VARCHAR 类型或者 NCHAR 类型的字符串或者列。
 
 **嵌套子查询支持**：适用于内层查询和外层查询。
 
@@ -315,7 +315,7 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
 
 **返回结果类型**：同输入类型。如果输入值为NULL，输出值为NULL。
 
-**适用数据类型**：输入参数是 BINARY 类型或者 NCHAR 类型的字符串或者列。不能应用在 TAG 列。
+**适用数据类型**：输入参数是 VARCHAR 类型或者 NCHAR 类型的字符串或者列。
 
 **嵌套子查询支持**：适用于内层查询和外层查询。
 
@@ -332,7 +332,7 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
 
 **返回结果类型**：同输入类型。如果输入值为NULL，输出值为NULL。
 
-**适用数据类型**：输入参数是 BINARY 类型或者 NCHAR 类型的字符串或者列。不能应用在 TAG 列。
+**适用数据类型**：输入参数是 VARCHAR 类型或者 NCHAR 类型的字符串或者列。
 
 **嵌套子查询支持**：适用于内层查询和外层查询。
 
@@ -349,7 +349,7 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
 
 **返回结果类型**：同输入类型。如果输入值为NULL，输出值为NULL。
 
-**适用数据类型**：输入参数是 BINARY 类型或者 NCHAR 类型的字符串或者列。不能应用在 TAG 列。
+**适用数据类型**：输入参数是 VARCHAR 类型或者 NCHAR 类型的字符串或者列。
 
 **嵌套子查询支持**：适用于内层查询和外层查询。
 
@@ -366,7 +366,7 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
 
 **返回结果类型**：同输入类型。如果输入值为NULL，输出值为NULL。
 
-**适用数据类型**：输入参数是 BINARY 类型或者 NCHAR 类型的字符串或者列。不能应用在 TAG 列。输入参数pos可以为正数，也可以为负数。如果pos是正数，表示开始位置从字符串开头正数计算。如果pos为负数，表示开始位置从字符串结尾倒数计算。如果输入参数len被忽略，返回的子串包含从pos开始的整个字串。
+**适用数据类型**：输入参数是 VARCHAR 类型或者 NCHAR 类型的字符串或者列。输入参数pos可以为正数，也可以为负数。如果pos是正数，表示开始位置从字符串开头正数计算。如果pos为负数，表示开始位置从字符串结尾倒数计算。如果输入参数len被忽略，返回的子串包含从pos开始的整个字串。
 
 **嵌套子查询支持**：适用于内层查询和外层查询。
 
@@ -383,7 +383,7 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
 
 **返回结果类型**：同输入类型。如果输入值为NULL，输出值为NULL。
 
-**适用数据类型**：输入参数是 BINARY 类型或者 NCHAR 类型的字符串或者列。不能应用在 TAG 列。
+**适用数据类型**：输入参数是 VARCHAR 类型或者 NCHAR 类型的字符串或者列。
 
 **嵌套子查询支持**：适用于内层查询和外层查询。
 
@@ -400,7 +400,7 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
   SELECT CAST(expression AS type_name) FROM { tb_name | stb_name } [WHERE clause]
 ```
 
-**功能说明**：数据类型转换函数，输入参数 expression 支持普通列、常量、标量函数及它们之间的四则运算，不支持 tag 列，只适用于 select 子句中。
+**功能说明**：数据类型转换函数，输入参数 expression 支持普通列、常量、标量函数及它们之间的四则运算，只适用于 select 子句中。
 
 **返回结果类型**：CAST 中指定的类型（type_name），可以是 BIGINT、BIGINT UNSIGNED、BINARY、VARCHAR、NCHAR和TIMESTAMP。
 
@@ -423,7 +423,7 @@ SELECT TO_ISO8601(ts_val | ts_col) FROM { tb_name | stb_name } [WHERE clause];
 
 **功能说明**：将 UNIX 时间戳转换成为 ISO8601 标准的日期时间格式，并附加客户端时区信息。
 
-**返回结果数据类型**：BINARY 类型。
+**返回结果数据类型**：VARCHAR 类型。
 
 **适用数据类型**：UNIX 时间戳常量或是 TIMESTAMP 类型的列
 
@@ -462,7 +462,7 @@ SELECT TO_UNIXTIMESTAMP(datetime_string | ts_col) FROM { tb_name | stb_name } [W
 
 **返回结果数据类型**：长整型 INT64。
 
-**应用字段**：字符串常量或是 BINARY/NCHAR 类型的列。
+**应用字段**：字符串常量或是 VARCHAR/NCHAR 类型的列。
 
 **适用于**：表、超级表。
 
@@ -549,7 +549,7 @@ SELECT TIMEZONE() FROM { tb_name | stb_name } [WHERE clause];
 
 **功能说明**：返回客户端当前时区信息。
 
-**返回结果数据类型**：BINARY 类型。
+**返回结果数据类型**：VARCHAR 类型。
 
 **应用字段**：无
 
@@ -668,7 +668,7 @@ SELECT LEASTSQUARES(field_name, start_val, step_val) FROM tb_name [WHERE clause]
 SELECT MODE(field_name) FROM tb_name [WHERE clause];
 ```
 
-**功能说明**：返回出现频率最高的值，若存在多个频率相同的最高值，输出空。不能匹配标签、时间戳输出。
+**功能说明**：返回出现频率最高的值，若存在多个频率相同的最高值，输出空。
 
 **返回数据类型**：同应用的字段。
 
@@ -808,6 +808,25 @@ SELECT BOTTOM(field_name, K) FROM { tb_name | stb_name } [WHERE clause];
 - 系统同时返回该记录关联的时间戳列；
 - 限制：BOTTOM 函数不支持 FILL 子句。
 
+### FIRST
+
+```
+SELECT FIRST(field_name) FROM { tb_name | stb_name } [WHERE clause];
+```
+
+**功能说明**：统计表/超级表中某列的值最先写入的非 NULL 值。
+
+**返回数据类型**：同应用的字段。
+
+**适用数据类型**：所有字段。
+
+**适用于**：表和超级表。
+
+**使用说明**:
+
+- 如果要返回各个列的首个（时间戳最小）非 NULL 值，可以使用 FIRST(\*)；
+- 如果结果集中的某列全部为 NULL 值，则该列的返回结果也是 NULL；
+- 如果结果集中所有列全部为 NULL 值，则不返回结果。
 
 ### INTERP
 
@@ -919,25 +938,6 @@ SELECT PERCENTILE(field_name, P) FROM { tb_name } [WHERE clause];
 
 **使用说明**：*P*值取值范围 0≤*P*≤100，为 0 的时候等同于 MIN，为 100 的时候等同于 MAX。
 
-### FIRST
-
-```
-SELECT FIRST(field_name) FROM { tb_name | stb_name } [WHERE clause];
-```
-
-**功能说明**：统计表/超级表中某列的值最先写入的非 NULL 值。
-
-**返回数据类型**：同应用的字段。
-
-**适用数据类型**：所有字段。
-
-**适用于**：表和超级表。
-
-**使用说明**:
-
-- 如果要返回各个列的首个（时间戳最小）非 NULL 值，可以使用 FIRST(\*)；
-- 如果结果集中的某列全部为 NULL 值，则该列的返回结果也是 NULL；
-- 如果结果集中所有列全部为 NULL 值，则不返回结果。
 
 ### TAIL
 
@@ -1005,7 +1005,7 @@ SELECT UNIQUE(field_name) FROM {tb_name | stb_name} [WHERE clause];
 
 **返回结果类型**： 输入列如果是整数类型返回值为长整型 （int64_t），浮点数返回值为双精度浮点数（Double）。无符号整数类型返回值为无符号长整型（uint64_t）。 返回结果中同时带有每行记录对应的时间戳。
 
-**适用数据类型**：不能应用在 timestamp、binary、nchar、bool 类型字段上；在超级表查询中使用时，不能应用在标签之上。
+**适用数据类型**：数值类型。
 
 **嵌套子查询支持**： 适用于内层查询和外层查询。
 
@@ -1076,7 +1076,7 @@ SELECT IRATE(field_name) FROM tb_name WHERE clause;
 
   **返回结果类型**： 返回双精度浮点数类型。
 
-  **适用数据类型**： 不能应用在 timestamp、binary、nchar、bool 类型上；在超级表查询中使用时，不能应用在标签之上。
+  **适用数据类型**： 数值类型。
 
   **嵌套子查询支持**： 适用于内层查询和外层查询。
 
@@ -1124,7 +1124,7 @@ SELECT STATECOUNT(field_name, oper, val) FROM { tb_name | stb_name } [WHERE clau
 
 **返回结果类型**：整形。
 
-**适用数据类型**：不能应用在 timestamp、binary、nchar、bool 类型字段上。
+**适用数据类型**：数值类型。
 
 **嵌套子查询支持**：不支持应用在子查询上。
 
@@ -1152,7 +1152,7 @@ SELECT stateDuration(field_name, oper, val, unit) FROM { tb_name | stb_name } [W
 
 **返回结果类型**：整形。
 
-**适用数据类型**：不能应用在 timestamp、binary、nchar、bool 类型字段上。
+**适用数据类型**：数值类型。
 
 **嵌套子查询支持**：不支持应用在子查询上。
 
diff --git a/docs-cn/12-taos-sql/13-operators.md b/docs-cn/12-taos-sql/13-operators.md
index 1ffc823044..22b78455fb 100644
--- a/docs-cn/12-taos-sql/13-operators.md
+++ b/docs-cn/12-taos-sql/13-operators.md
@@ -35,8 +35,8 @@ TDengine 支持 `UNION ALL` 和 `UNION` 操作符。UNION ALL 将查询返回的
 | --- | :---------------: | -------------------------------------------------------------------- | -------------------- |
 | 1   |         =         | 除 BLOB、MEDIUMBLOB 和 JSON 外的所有类型                             | 相等                 |
 | 2   |      <\>, !=      | 除 BLOB、MEDIUMBLOB 和 JSON 外的所有类型，且不可以为表的时间戳主键列 | 不相等               |
-| 3   |      \>, \<       | 除 BLOB、MEDIUMBLOB 和 JSON 外的所有类型                             | 大于，小于           |
-| 4   |     \>=, \<=      | 除 BLOB、MEDIUMBLOB 和 JSON 外的所有类型                             | 大于等于，小于等于   |
+| 3   |      \>, <       | 除 BLOB、MEDIUMBLOB 和 JSON 外的所有类型                             | 大于，小于           |
+| 4   |     \>=, <=      | 除 BLOB、MEDIUMBLOB 和 JSON 外的所有类型                             | 大于等于，小于等于   |
 | 5   |   IS [NOT] NULL   | 所有类型                                                             | 是否为空值           |
 | 6   | [NOT] BETWEEN AND | 除 BOOL、BLOB、MEDIUMBLOB 和 JSON 外的所有类型                       | 闭区间比较           |
 | 7   |        IN         | 除 BLOB、MEDIUMBLOB 和 JSON 外的所有类型，且不可以为表的时间戳主键列 | 与列表内的任意值相等 |
diff --git a/docs-en/12-taos-sql/07-function.md b/docs-en/12-taos-sql/07-function.md
index 1a0dc28fa0..129b7eb0c3 100644
--- a/docs-en/12-taos-sql/07-function.md
+++ b/docs-en/12-taos-sql/07-function.md
@@ -1,10 +1,635 @@
 ---
 title: Functions
+toc_max_heading_level: 4
 ---
 
+## Single-Row Functions
+
+Single-Row functions return a result row for each row in the query result.
+
+### Numeric Functions
+
+#### ABS
+
+```sql
+SELECT ABS(field_name) FROM { tb_name | stb_name } [WHERE clause]
+```
+
+**Description**: The absolute of a specific column.
+
+**Return value type**: UBIGINT if the input value is integer; DOUBLE if the input value is FLOAT/DOUBLE.
+
+**Applicable data types**: Numeric types.
+
+**Applicable table types**: table, STable.
+
+**Applicable nested query**: Inner query and Outer query.
+
+**More explanations**:
+- Can't be used with aggregate functions.
+
+#### ACOS
+
+```sql
+SELECT ACOS(field_name) FROM { tb_name | stb_name } [WHERE clause]
+```
+
+**Description**: The anti-cosine of a specific column
+
+**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
+
+**Applicable data types**: Numeric types.
+
+**Applicable table types**: table, STable
+
+**Applicable nested query**: Inner query and Outer query
+
+**More explanations**:
+- Can't be used with aggregate functions
+
+#### ASIN
+
+```sql
+SELECT ASIN(field_name) FROM { tb_name | stb_name } [WHERE clause]
+```
+
+**Description**: The anti-sine of a specific column
+
+**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
+
+**Applicable data types**: Numeric types.
+
+**Applicable table types**: table, STable
+
+**Applicable nested query**: Inner query and Outer query
+
+**More explanations**:
+- Can't be used with aggregate functions
+
+#### ATAN
+
+```sql
+SELECT ATAN(field_name) FROM { tb_name | stb_name } [WHERE clause]
+```
+
+**Description**: anti-tangent of a specific column
+
+**Description**: The anti-cosine of a specific column
+
+**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
+
+**Applicable data types**: Numeric types.
+
+**Applicable table types**: table, STable
+
+**Applicable nested query**: Inner query and Outer query
+
+**More explanations**:
+- Can't be used with aggregate functions
+
+#### CEIL
+
+```
+SELECT CEIL(field_name) FROM { tb_name | stb_name } [WHERE clause];
+```
+
+**Description**: The rounded up value of a specific column
+
+**Return value type**: Same as the column being used
+
+**Applicable data types**: Numeric types.
+
+**Applicable table types**: table, STable
+
+**Applicable nested query**: Inner query and outer query
+
+**More explanations**:
+- Arithmetic operation can be performed on the result of `ceil` function
+- Can't be used with aggregate functions
+
+#### COS
+
+```sql
+SELECT COS(field_name) FROM { tb_name | stb_name } [WHERE clause]
+```
+
+**Description**: The cosine of a specific column
+
+**Description**: The anti-cosine of a specific column
+
+**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
+
+**Applicable data types**: Numeric types.
+
+**Applicable table types**: table, STable
+
+**Applicable nested query**: Inner query and Outer query
+
+**More explanations**:
+- Can't be used with aggregate functions
+
+#### FLOOR
+
+```
+SELECT FLOOR(field_name) FROM { tb_name | stb_name } [WHERE clause];
+```
+
+**Description**: The rounded down value of a specific column
+
+**More explanations**: The restrictions are same as those of the `CEIL` function.
+
+#### LOG
+
+```sql
+SELECT LOG(field_name, base) FROM { tb_name | stb_name } [WHERE clause]
+```
+
+**Description**: The log of a specific with `base` as the radix
+
+**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
+
+**Applicable data types**: Numeric types.
+
+**Applicable table types**: table, STable
+
+**Applicable nested query**: Inner query and Outer query
+
+**More explanations**:
+- Can't be used with aggregate functions
+
+#### POW
+
+```sql
+SELECT POW(field_name, power) FROM { tb_name | stb_name } [WHERE clause]
+```
+
+**Description**: The power of a specific column with `power` as the index
+
+**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
+
+**Applicable data types**: Numeric types.
+
+**Applicable table types**: table, STable
+
+**Applicable nested query**: Inner query and Outer query
+
+**More explanations**:
+- Can't be used with aggregate functions
+
+#### ROUND
+
+```
+SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
+```
+
+**Description**: The rounded value of a specific column.
+
+**More explanations**: The restrictions are same as `CEIL` function.
+
+#### SIN
+
+```sql
+SELECT SIN(field_name) FROM { tb_name | stb_name } [WHERE clause]
+```
+
+**Description**: The sine of a specific column
+
+**Description**: The anti-cosine of a specific column
+
+**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
+
+**Applicable data types**: Numeric types.
+
+**Applicable table types**: table, STable
+
+**Applicable nested query**: Inner query and Outer query
+
+**More explanations**:
+- Can't be used with aggregate functions
+
+#### SQRT
+
+```sql
+SELECT SQRT(field_name) FROM { tb_name | stb_name } [WHERE clause]
+```
+
+**Description**: The square root of a specific column
+
+**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
+
+**Applicable data types**: Numeric types.
+
+**Applicable table types**: table, STable
+
+**Applicable nested query**: Inner query and Outer query
+
+**More explanations**:
+- Can't be used with aggregate functions
+
+#### TAN
+
+```sql
+SELECT TAN(field_name) FROM { tb_name | stb_name } [WHERE clause]
+```
+
+**Description**: The tangent of a specific column
+
+**Description**: The anti-cosine of a specific column
+
+**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
+
+**Applicable data types**: Numeric types.
+
+**Applicable table types**: table, STable
+
+**Applicable nested query**: Inner query and Outer query
+
+**More explanations**:
+- Can't be used with aggregate functions
+
+### String Functions
+
+String functiosn take strings as input and output numbers or strings.
+
+#### CHAR_LENGTH
+
+```
+SELECT CHAR_LENGTH(str|column) FROM { tb_name | stb_name } [WHERE clause]
+```
+
+**Description**: The length in number of characters of a string
+
+**Return value type**: Integer
+
+**Applicable data types**: VARCHAR or NCHAR
+
+**Applicable table types**: table, STable
+
+**Applicable nested query**: Inner query and Outer query
+
+**More explanations**
+
+- If the input value is NULL, the output is NULL too
+
+#### CONCAT
+
+```sql
+SELECT CONCAT(str1|column1, str2|column2, ...) FROM { tb_name | stb_name } [WHERE clause]
+```
+
+**Description**: The concatenation result of two or more strings, the number of strings to be concatenated is at least 2 and at most 8
+
+**Return value type**: If all input strings are VARCHAR type, the result is VARCHAR type too. If any one of input strings is NCHAR type, then the result is NCHAR.
+
+**Applicable data types**: VARCHAR, NCHAR.  At least 2 input strings are requird, and at most 8 input strings are allowed. 
+
+**Applicable table types**: table, STable
+
+**Applicable nested query**: Inner query and Outer query
+
+#### CONCAT_WS
+
+```
+SELECT CONCAT_WS(separator, str1|column1, str2|column2, ...) FROM { tb_name | stb_name } [WHERE clause]
+```
+
+**Description**: The concatenation result of two or more strings with separator, the number of strings to be concatenated is at least 3 and at most 9
+
+**Return value type**: If all input strings are VARCHAR type, the result is VARCHAR type too. If any one of input strings is NCHAR type, then the result is NCHAR.
+
+**Applicable data types**: VARCHAR, NCHAR. At least 3 input strings are requird, and at most 9 input strings are allowed. 
+
+**Applicable table types**: table, STable
+
+**Applicable nested query**: Inner query and Outer query
+
+**More explanations**:
+
+- If the value of `separator` is NULL, the output is NULL. If the value of `separator` is not NULL but other input are all NULL, the output is empty string.
+
+#### LENGTH
+
+```
+SELECT LENGTH(str|column) FROM { tb_name | stb_name } [WHERE clause]
+```
+
+**Description**: The length in bytes of a string
+
+**Return value type**: Integer
+
+**Applicable data types**: VARCHAR or NCHAR
+**Applicable table types**: table, STable
+
+**Applicable nested query**: Inner query and Outer query
+
+**More explanations**
+
+- If the input value is NULL, the output is NULL too
+
+#### LOWER
+
+```
+SELECT LOWER(str|column) FROM { tb_name | stb_name } [WHERE clause]
+```
+
+**Description**: Convert the input string to lower case
+
+**Return value type**: Same as input
+
+**Applicable data types**: VARCHAR or NCHAR
+
+**Applicable table types**: table, STable
+
+**Applicable nested query**: Inner query and Outer query
+
+**More explanations**
+
+- If the input value is NULL, the output is NULL too
+
+#### LTRIM
+
+```
+SELECT LTRIM(str|column) FROM { tb_name | stb_name } [WHERE clause]
+```
+
+**Description**: Remove the left leading blanks of a string
+
+**Return value type**: Same as input
+
+**Applicable data types**: VARCHAR or NCHAR
+
+**Applicable table types**: table, STable
+
+**Applicable nested query**: Inner query and Outer query
+
+**More explanations**
+
+- If the input value is NULL, the output is NULL too
+
+#### RTRIM
+
+```
+SELECT RTRIM(str|column) FROM { tb_name | stb_name } [WHERE clause]
+```
+
+**Description**: Remove the right tailing blanks of a string
+
+**Return value type**: Same as input
+
+**Applicable data types**: VARCHAR or NCHAR
+
+**Applicable table types**: table, STable
+
+**Applicable nested query**: Inner query and Outer query
+
+**More explanations**
+
+- If the input value is NULL, the output is NULL too
+
+#### SUBSTR
+
+```
+SELECT SUBSTR(str,pos[,len]) FROM { tb_name | stb_name } [WHERE clause]
+```
+
+**Description**: The sub-string starting from `pos` with length of `len` from the original string `str`
+
+**Return value type**: Same as input
+
+**Applicable data types**: VARCHAR or NCHAR
+
+**Applicable table types**: table, STable
+
+**Applicable nested query**: Inner query and Outer query
+
+**More explanations**:
+
+- If the input is NULL, the output is NULL
+- Parameter `pos` can be an positive or negative integer; If it's positive, the starting position will be counted from the beginning of the string; if it's negative, the starting position will be counted from the end of the string.
+- If `len` is not specified, it means from `pos` to the end.
+
+#### UPPER
+
+```
+SELECT UPPER(str|column) FROM { tb_name | stb_name } [WHERE clause]
+```
+
+**Description**: Convert the input string to upper case
+
+**Return value type**: Same as input
+
+**Applicable data types**: VARCHAR or NCHAR
+
+**Applicable table types**: table, STable
+
+**Applicable nested query**: Inner query and Outer query
+
+**More explanations**
+
+- If the input value is NULL, the output is NULL too
+
+### Conversion Functions
+
+This kind of functions convert from one data type to another one.
+
+#### CAST
+
+```sql
+SELECT CAST(expression AS type_name) FROM { tb_name | stb_name } [WHERE clause]
+```
+
+**Description**: It's used for type casting. The input parameter `expression` can be data columns, constants, scalar functions or arithmetic between them. 
+
+**Return value type**: The type specified by parameter `type_name`
+
+**Applicable data types**:
+
+- Parameter `expression` can be any data type except for JSON
+- The output data type specified by `type_name` can only be one of BIGINT/VARCHAR(N)/TIMESTAMP/NCHAR(N)/BIGINT UNSIGNED
+
+**More explanations**:
+
+- Error will be reported for unsupported type casting
+- NULL will be returned if the input value is NULL
+- Some values of some supported data types may not be casted, below are known issues:
+  1）When casting VARCHAR/NCHAR to BIGINT/BIGINT UNSIGNED, some characters may be treated as illegal, for example "a" may be converted to 0.
+  2）There may be overflow when casting singed integer or TIMESTAMP to unsigned BIGINT
+  3）There may be overflow when casting unsigned BIGINT to BIGINT
+  4）There may be overflow when casting FLOAT/DOUBLE to BIGINT or UNSIGNED BIGINT
+
+#### TO_ISO8601
+
+```sql
+SELECT TO_ISO8601(ts_val | ts_col) FROM { tb_name | stb_name } [WHERE clause];
+```
+
+**Description**: The ISO8601 date/time format converted from a UNIX timestamp, plus the timezone of the client side system
+
+**Return value type**: VARCHAR
+
+**Applicable column types**: TIMESTAMP, constant or a column
+
+**Applicable table types**: table, STable
+
+**More explanations**:
+
+- If the input is UNIX timestamp constant, the precision of the returned value is determined by the digits of the input timestamp
+- If the input is a column of TIMESTAMP type, The precision of the returned value is same as the precision set for the current data base in use
+
+#### TO_JSON
+
+```sql
+SELECT TO_JSON(str_literal) FROM { tb_name | stb_name } [WHERE clause];
+```
+
+**Description**: Convert a JSON string to a JSON body。
+
+**Return value type**: JSON
+
+**Applicable column types**: JSON string, in the format like '{ "literal" : literal }'. '{}' is NULL value. keys in the string must be string constants, values can be constants of numeric types, bool, string or NULL. Escaping characters are not allowed in the JSON string.
+
+**Applicable table types**: table, STable
+
+**Applicable nested query**: Inner query and Outer query.
+
+#### TO_UNIXTIMESTAMP
+
+```sql
+SELECT TO_UNIXTIMESTAMP(datetime_string | ts_col) FROM { tb_name | stb_name } [WHERE clause];
+```
+
+**Description**: UNIX timestamp converted from a string of date/time format
+
+**Return value type**: Long integer
+
+**Applicable column types**: Constant or column of VARCHAR/NCHAR
+
+**Applicable table types**: table, STable
+
+**More explanations**:
+
+- The input string must be compatible with ISO8601/RFC3339 standard, 0 will be returned if the string can't be converted
+- The precision of the returned timestamp is same as the precision set for the current data base in use
+
+### DateTime Functions
+
+This kind of functiosn oeprate on timestamp data. NOW(), TODAY() and TIMEZONE() are executed only once even though they may occurr multiple times in a single SQL statement.
+
+#### NOW
+
+```sql
+SELECT NOW() FROM { tb_name | stb_name } [WHERE clause];
+SELECT select_expr FROM { tb_name | stb_name } WHERE ts_col cond_operatior NOW();
+INSERT INTO tb_name VALUES (NOW(), ...);
+```
+
+**Description**: The current time of the client side system
+
+**Return value type**: TIMESTAMP
+
+**Applicable column types**: TIMESTAMP only
+
+**Applicable table types**: table, STable
+
+**More explanations**:
+
+- Add and Subtract operation can be performed, for example NOW() + 1s, the time unit can be:
+  b(nanosecond), u(microsecond), a(millisecond)), s(second), m(minute), h(hour), d(day), w(week)
+- The precision of the returned timestamp is same as the precision set for the current data base in use
+
+#### TIMEDIFF
+
+```sql
+SELECT TIMEDIFF(ts_val1 | datetime_string1 | ts_col1, ts_val2 | datetime_string2 | ts_col2 [, time_unit]) FROM { tb_name | stb_name } [WHERE clause];
+```
+
+**Description**: The difference between two timestamps, and rounded to the time unit specified by `time_unit`
+
+**Return value type**: Long Integer
+
+**Applicable column types**: UNIX timestamp constant, string constant of date/time format, or a column of TIMESTAMP type
+
+**Applicable table types**: table, STable
+
+**More explanations**:
+
+- Time unit specified by `time_unit` can be:
+  1u(microsecond),1a(millisecond),1s(second),1m(minute),1h(hour),1d(day).
+- The precision of the returned timestamp is same as the precision set for the current data base in use
+
+#### TIMETRUNCATE
+
+```sql
+SELECT TIMETRUNCATE(ts_val | datetime_string | ts_col, time_unit) FROM { tb_name | stb_name } [WHERE clause];
+```
+
+**Description**: Truncate the input timestamp with unit specified by `time_unit`
+
+**Return value type**: TIMESTAMP
+
+**Applicable column types**: UNIX timestamp constant, string constant of date/time format, or a column of timestamp
+
+**Applicable table types**: table, STable
+
+**More explanations**:
+
+- Time unit specified by `time_unit` can be:
+  1u(microsecond),1a(millisecond),1s(second),1m(minute),1h(hour),1d(day).
+- The precision of the returned timestamp is same as the precision set for the current data base in use
+
+#### TIMEZONE
+
+```sql
+SELECT TIMEZONE() FROM { tb_name | stb_name } [WHERE clause];
+```
+
+**Description**: The timezone of the client side system
+
+**Return value type**: VARCHAR
+
+**Applicable column types**: None
+
+**Applicable table types**: table, STable
+
+#### TODAY
+
+```sql
+SELECT TODAY() FROM { tb_name | stb_name } [WHERE clause];
+SELECT select_expr FROM { tb_name | stb_name } WHERE ts_col cond_operatior TODAY()];
+INSERT INTO tb_name VALUES (TODAY(), ...);
+```
+
+**Description**: The timestamp of 00:00:00 of the client side system
+
+**Return value type**: TIMESTAMP
+
+**Applicable column types**: TIMESTAMP only
+
+**Applicable table types**: table, STable
+
+**More explanations**:
+
+- Add and Subtract operation can be performed, for example NOW() + 1s, the time unit can be:
+  b(nanosecond), u(microsecond), a(millisecond)), s(second), m(minute), h(hour), d(day), w(week)
+- The precision of the returned timestamp is same as the precision set for the current data base in use
+
 ## Aggregate Functions
 
-Aggregate queries are supported in TDengine by the following aggregate functions and selection functions.
+Aggregate functions return single result row for each group in the query result set. Groups are determined by `GROUP BY` clause or time window clause if they are used; or the whole result is considered a group if neither of them is used.
+
+### AVG
+
+```
+SELECT AVG(field_name) FROM tb_name [WHERE clause];
+```
+
+**Description**: Get the average value of a column in a table or STable
+
+**Return value type**: Double precision floating number
+
+**Applicable column types**: Numeric type
+
+**Applicable table types**: table, STable
 
 ### COUNT
 
@@ -25,141 +650,30 @@ SELECT COUNT([*|field_name]) FROM tb_name [WHERE clause];
 - Wildcard (\*) is used to represent all columns. The `COUNT` function is used to get the total number of all rows.
 - The number of non-NULL values will be returned if this function is used on a specific column.
 
-**Examples**:
+### ELAPSED
 
-```
-taos> SELECT COUNT(*), COUNT(voltage) FROM meters;
-    count(*)        |    count(voltage)     |
-================================================
-                    9 |                     9 |
-Query OK, 1 row(s) in set (0.004475s)
-
-taos> SELECT COUNT(*), COUNT(voltage) FROM d1001;
-    count(*)        |    count(voltage)     |
-================================================
-                    3 |                     3 |
-Query OK, 1 row(s) in set (0.001075s)
+```mysql
+SELECT ELAPSED(field_name[, time_unit]) FROM { tb_name | stb_name } [WHERE clause] [INTERVAL(interval [, offset]) [SLIDING sliding]];
 ```
 
-### AVG
+**Description**：`elapsed` function can be used to calculate the continuous time length in which there is valid data. If it's used with `INTERVAL` clause, the returned result is the calcualted time length within each time window. If it's used without `INTERVAL` caluse, the returned result is the calculated time length within the specified time range. Please be noted that the return value of `elapsed` is the number of `time_unit` in the calculated time length.
 
-```
-SELECT AVG(field_name) FROM tb_name [WHERE clause];
-```
+**Return value type**：Double
 
-**Description**: Get the average value of a column in a table or STable
+**Applicable Column type**：Timestamp
 
-**Return value type**: Double precision floating number
+**Applicable tables**: table, STable, outter in nested query
 
-**Applicable column types**: Data types except for timestamp, binary, nchar and bool
+**Explanations**：
 
-**Applicable table types**: table, STable
-
-**Examples**:
-
-```
-taos> SELECT AVG(current), AVG(voltage), AVG(phase) FROM meters;
-    avg(current)        |       avg(voltage)        |        avg(phase)         |
-====================================================================================
-            11.466666751 |             220.444444444 |               0.293333333 |
-Query OK, 1 row(s) in set (0.004135s)
-
-taos> SELECT AVG(current), AVG(voltage), AVG(phase) FROM d1001;
-    avg(current)        |       avg(voltage)        |        avg(phase)         |
-====================================================================================
-            11.733333588 |             219.333333333 |               0.316666673 |
-Query OK, 1 row(s) in set (0.000943s)
-```
-
-### TWA
-
-```
-SELECT TWA(field_name) FROM tb_name WHERE clause;
-```
-
-**Description**: Time weighted average on a specific column within a time range
-
-**Return value type**: Double precision floating number
-
-**Applicable column types**: Data types except for timestamp, binary, nchar and bool
-
-**Applicable table types**: table, STable
-
-**More explanations**:
-
-- Since version 2.1.3.0, function TWA can be used on stable with `GROUP BY`, i.e. timelines generated by `GROUP BY tbname` on a STable.
-
-### IRATE
-
-```
-SELECT IRATE(field_name) FROM tb_name WHERE clause;
-```
-
-**Description**: instantaneous rate on a specific column. The last two samples in the specified time range are used to calculate instantaneous rate. If the last sample value is smaller, then only the last sample value is used instead of the difference between the last two sample values.
-
-**Return value type**: Double precision floating number
-
-**Applicable column types**: Data types except for timestamp, binary, nchar and bool
-
-**Applicable table types**: table, STable
-
-**More explanations**:
-
-- Since version 2.1.3.0, function IRATE can be used on stble with `GROUP BY`, i.e. timelines generated by `GROUP BY tbname` on a STable.
-
-### SUM
-
-```
-SELECT SUM(field_name) FROM tb_name [WHERE clause];
-```
-
-**Description**: The sum of a specific column in a table or STable
-
-**Return value type**: Double precision floating number or long integer
-
-**Applicable column types**: Data types except for timestamp, binary, nchar and bool
-
-**Applicable table types**: table, STable
-
-**Examples**:
-
-```
-taos> SELECT SUM(current), SUM(voltage), SUM(phase) FROM meters;
-    sum(current)        |     sum(voltage)      |        sum(phase)         |
-================================================================================
-            103.200000763 |                  1984 |               2.640000001 |
-Query OK, 1 row(s) in set (0.001702s)
-
-taos> SELECT SUM(current), SUM(voltage), SUM(phase) FROM d1001;
-    sum(current)        |     sum(voltage)      |        sum(phase)         |
-================================================================================
-            35.200000763 |                   658 |               0.950000018 |
-Query OK, 1 row(s) in set (0.000980s)
-```
-
-### STDDEV
-
-```
-SELECT STDDEV(field_name) FROM tb_name [WHERE clause];
-```
-
-**Description**: Standard deviation of a specific column in a table or STable
-
-**Return value type**: Double precision floating number
-
-**Applicable column types**: Data types except for timestamp, binary, nchar and bool
-
-**Applicable table types**: table, STable (since version 2.0.15.1)
-
-**Examples**:
-
-```
-taos> SELECT STDDEV(current) FROM d1001;
-    stddev(current)      |
-============================
-            1.020892909 |
-Query OK, 1 row(s) in set (0.000915s)
-```
+- `field_name` parameter can only be the first column of a table, i.e. timestamp primary key.
+- The minimum value of `time_unit` is the time precision of the database. If `time_unit` is not specified, the time precision of the database is used as the default ime unit.
+- It can be used with `INTERVAL` to get the time valid time length of each time window. Please be noted that the return value is same as the time window for all time windows except for the first and the last time window.
+- `order by asc/desc` has no effect on the result.
+- `group by tbname` must be used together when `elapsed` is used against a STable.
+- `group by` must NOT be used together when `elapsed` is used against a table or sub table.
+- When used in nested query, it's only applicable when the inner query outputs an implicit timestamp column as the primary key. For example, `select elapsed(ts) from (select diff(value) from sub1)` is legal usage while `select elapsed(ts) from (select * from sub1)` is not.
+- It can't be used with `leastsquares`, `diff`, `derivative`, `top`, `bottom`, `last_row`, `interp`.
 
 ### LEASTSQUARES
 
@@ -171,27 +685,17 @@ SELECT LEASTSQUARES(field_name, start_val, step_val) FROM tb_name [WHERE clause]
 
 **Return value type**: A string in the format of "(slope, intercept)"
 
-**Applicable column types**: Data types except for timestamp, binary, nchar and bool
+**Applicable column types**: Numeric types
 
 **Applicable table types**: table only
 
-**Examples**:
-
-```
-taos> SELECT LEASTSQUARES(current, 1, 1) FROM d1001;
-            leastsquares(current, 1, 1)             |
-=====================================================
-{slop:1.000000, intercept:9.733334}                 |
-Query OK, 1 row(s) in set (0.000921s)
-```
-
 ### MODE
 
 ```
 SELECT MODE(field_name) FROM tb_name [WHERE clause];
 ```
 
-**Description**:The value which has the highest frequency of occurrence. NULL is returned if there are multiple values which have highest frequency of occurrence. It can't be used on timestamp column or tags.
+**Description**:The value which has the highest frequency of occurrence. NULL is returned if there are multiple values which have highest frequency of occurrence. It can't be used on timestamp column.
 
 **Return value type**:Same as the data type of the column being operated upon
 
@@ -199,27 +703,50 @@ SELECT MODE(field_name) FROM tb_name [WHERE clause];
 
 **More explanations**:Considering the number of returned result set is unpredictable, it's suggested to limit the number of unique values to 100,000, otherwise error will be returned.
 
-**Applicable version**:Since version 2.6.0.0
-
-**Examples**:
+### SPREAD
 
 ```
-taos> select voltage from d002;
-    voltage        |
-========================
-       1           |
-       1           |
-       2           |
-       19          |
-Query OK, 4 row(s) in set (0.003545s)
-
-taos> select mode(voltage) from d002;
-  mode(voltage)    |
-========================
-       1           |
-Query OK, 1 row(s) in set (0.019393s)
+SELECT SPREAD(field_name) FROM { tb_name | stb_name } [WHERE clause];
 ```
 
+**Description**: The difference between the max and the min of a specific column
+
+**Return value type**: Double precision floating point
+
+**Applicable column types**: Numeric types
+
+**Applicable table types**: table, STable
+
+**More explanations**: Can be used on a column of TIMESTAMP type, the result is the time range size.
+
+### STDDEV
+
+```
+SELECT STDDEV(field_name) FROM tb_name [WHERE clause];
+```
+
+**Description**: Standard deviation of a specific column in a table or STable
+
+**Return value type**: Double precision floating number
+
+**Applicable column types**: Numeric types
+
+**Applicable table types**: table, STable
+
+### SUM
+
+```
+SELECT SUM(field_name) FROM tb_name [WHERE clause];
+```
+
+**Description**: The sum of a specific column in a table or STable
+
+**Return value type**: Double precision floating number or long integer
+
+**Applicable column types**: Numeric types
+
+**Applicable table types**: table, STable
+
 ### HYPERLOGLOG
 
 ```
@@ -234,31 +761,6 @@ SELECT HYPERLOGLOG(field_name) FROM { tb_name | stb_name } [WHERE clause];
 
 **More explanations**: The benefit of using hyperloglog algorithm is that the memory usage is under control when the data volume is huge. However, when the data volume is very small, the result may be not accurate, it's recommented to use `select count(data) from (select unique(col) as data from table)` in this case.
 
-**Applicable versions**:Since version 2.6.0.0
-
-**Examples**:
-
-```
-taos> select dbig from shll;
-     dbig          |
-========================
-       1           |
-       1           |
-       1           |
-       NULL        |
-       2           |
-       19          |
-       NULL        |
-       9           |
-Query OK, 8 row(s) in set (0.003755s)
-
-taos> select hyperloglog(dbig) from shll;
-  hyperloglog(dbig)|
-========================
-       4           |
-Query OK, 1 row(s) in set (0.008388s)
-```
-
 ### HISTOGRAM
 
 ```
@@ -271,151 +773,77 @@ SELECT HISTOGRAM(field_name，bin_type, bin_description, normalized) FROM tb_nam
 
 **Applicable column type**：Numerical types.
 
-**Applicable versions**：Since version 2.6.0.0.
-
 **Applicable table types**: table, STable
 
 **Explanations**：
 
 1. bin_type: parameter to indicate the bucket type, valid inputs are: "user_input", "linear_bin", "log_bin"。
-2. bin_description: parameter to describe how to generate buckets，can be in the following JSON formats for each bin_type respectively: 
+2. bin_description: parameter to describe how to generate buckets，can be in the following JSON formats for each bin_type respectively:
 
-    - "user_input": "[1, 3, 5, 7]":  User specified bin values.
+   - "user_input": "[1, 3, 5, 7]": User specified bin values.
 
-    - "linear_bin": "{"start": 0.0, "width": 5.0, "count": 5, "infinity": true}"
-       "start" - bin starting point.
-       "width" - bin offset.
-       "count" - number of bins generated.
-       "infinity" - whether to add（-inf, inf）as start/end point in generated set of bins.
-       The above "linear_bin" descriptor generates a set of bins: [-inf, 0.0, 5.0, 10.0, 15.0, 20.0, +inf].
+   - "linear_bin": "{"start": 0.0, "width": 5.0, "count": 5, "infinity": true}"
+     "start" - bin starting point.
+     "width" - bin offset.
+     "count" - number of bins generated.
+     "infinity" - whether to add（-inf, inf）as start/end point in generated set of bins.
+     The above "linear_bin" descriptor generates a set of bins: [-inf, 0.0, 5.0, 10.0, 15.0, 20.0, +inf].
 
-    - "log_bin": "{"start":1.0, "factor": 2.0, "count": 5, "infinity": true}"
-       "start" - bin starting point.
-       "factor" - exponential factor of bin offset.
-       "count" - number of bins generated.
-       "infinity" - whether to add（-inf, inf）as start/end point in generated range of bins.
-       The above "log_bin" descriptor generates a set of bins:[-inf, 1.0, 2.0, 4.0, 8.0, 16.0, +inf].
+   - "log_bin": "{"start":1.0, "factor": 2.0, "count": 5, "infinity": true}"
+     "start" - bin starting point.
+     "factor" - exponential factor of bin offset.
+     "count" - number of bins generated.
+     "infinity" - whether to add（-inf, inf）as start/end point in generated range of bins.
+     The above "log_bin" descriptor generates a set of bins:[-inf, 1.0, 2.0, 4.0, 8.0, 16.0, +inf].
 
 3. normalized: setting to 1/0 to turn on/off result normalization.
 
-**Example**：
+## Selector Functions
 
-```mysql
-taos> SELECT HISTOGRAM(voltage, "user_input", "[1,3,5,7]", 1) FROM meters;
-     histogram(voltage, "user_input", "[1,3,5,7]", 1) |
-     =======================================================
-     {"lower_bin":1, "upper_bin":3, "count":0.333333}     |
-     {"lower_bin":3, "upper_bin":5, "count":0.333333}     |
-     {"lower_bin":5, "upper_bin":7, "count":0.333333}     |
-     Query OK, 3 row(s) in set (0.004273s)
+Selector functiosn choose one or more rows in the query result set to retrun according toe the semantics. You can specify to output ts column and other columns including tbname and tags so that you can easily know which rows the selected values belong to.
 
-taos> SELECT HISTOGRAM(voltage, 'linear_bin', '{"start": 1, "width": 3, "count": 3, "infinity": false}', 0) FROM meters;
-         histogram(voltage, 'linear_bin', '{"start": 1, "width": 3, " |
-     ===================================================================
-     {"lower_bin":1, "upper_bin":4, "count":3}                        |
-     {"lower_bin":4, "upper_bin":7, "count":3}                        |
-     {"lower_bin":7, "upper_bin":10, "count":3}                       |
-     Query OK, 3 row(s) in set (0.004887s)
-
-taos> SELECT HISTOGRAM(voltage, 'log_bin', '{"start": 1, "factor": 3, "count": 3, "infinity": true}', 0) FROM meters;
-   histogram(voltage, 'log_bin', '{"start": 1, "factor": 3, "count" |
-   ===================================================================
-   {"lower_bin":-inf, "upper_bin":1, "count":3}                     |
-   {"lower_bin":1, "upper_bin":3, "count":2}                        |
-   {"lower_bin":3, "upper_bin":9, "count":6}                        |
-   {"lower_bin":9, "upper_bin":27, "count":3}                       |
-   {"lower_bin":27, "upper_bin":inf, "count":1}                     |
-```
-
-### ELAPSED
-
-```mysql
-SELECT ELAPSED(field_name[, time_unit]) FROM { tb_name | stb_name } [WHERE clause] [INTERVAL(interval [, offset]) [SLIDING sliding]];
-```
-
-**Description**：`elapsed` function can be used to calculate the continuous time length in which there is valid data. If it's used with `INTERVAL` clause, the returned result is the calcualted time length within each time window. If it's used without `INTERVAL` caluse, the returned result is the calculated time length within the specified time range. Please be noted that the return value of `elapsed` is the number of `time_unit` in the calculated time length.
-
-**Return value type**：Double
-
-**Applicable Column type**：Timestamp
-
-**Applicable versions**：Sicne version 2.6.0.0 
-
-**Applicable tables**: table, STable, outter in nested query
-
-**Explanations**：
-- `field_name` parameter can only be the first column of a table, i.e. timestamp primary key.
-- The minimum value of `time_unit` is the time precision of the database. If `time_unit` is not specified, the time precision of the database is used as the default ime unit.
-- It can be used with `INTERVAL` to get the time valid time length of each time window. Please be noted that the return value is same as the time window for all time windows except for the first and the last time window.
-- `order by asc/desc` has no effect on the result.
-- `group by tbname` must be used together when `elapsed` is used against a STable.
-- `group by` must NOT be used together when `elapsed` is used against a table or sub table.
-- When used in nested query, it's only applicable when the inner query outputs an implicit timestamp column as the primary key. For example, `select elapsed(ts) from (select diff(value) from sub1)` is legal usage while `select elapsed(ts) from (select * from sub1)` is not. 
-- It can't be used with `leastsquares`, `diff`, `derivative`, `top`, `bottom`, `last_row`, `interp`.
-
-## Selection Functions
-
-When any select function is used, timestamp column or tag columns including `tbname` can be specified to show that the selected value are from which rows.
-
-### MIN
+### APERCENTILE
 
 ```
-SELECT MIN(field_name) FROM {tb_name | stb_name} [WHERE clause];
+SELECT APERCENTILE(field_name, P[, algo_type])
+FROM { tb_name | stb_name } [WHERE clause]
 ```
 
-**Description**: The minimum value of a specific column in a table or STable
+**Description**: Similar to `PERCENTILE`, but a simulated result is returned
 
-**Return value type**: Same as the data type of the column being operated upon
+**Return value type**: Double precision floating point
 
-**Applicable column types**: Data types except for timestamp, binary, nchar and bool
+**Applicable column types**: Numeric types
 
 **Applicable table types**: table, STable
 
-**Examples**:
+**More explanations**
+
+- _P_ is in range [0,100], when _P_ is 0, the result is same as using function MIN; when _P_ is 100, the result is same as function MAX.
+- **algo_type** can only be input as `default` or `t-digest`, if it's not specified `default` will be used, i.e. `apercentile(column_name, 50)` is same as `apercentile(column_name, 50, "default")`.
+- When `t-digest` is used, `t-digest` sampling is used to calculate.
+
+**Nested query**: It can be used in both the outer query and inner query in a nested query.
+
+### BOTTOM
 
 ```
-taos> SELECT MIN(current), MIN(voltage) FROM meters;
-    min(current)     | min(voltage) |
-======================================
-            10.20000 |          218 |
-Query OK, 1 row(s) in set (0.001765s)
-
-taos> SELECT MIN(current), MIN(voltage) FROM d1001;
-    min(current)     | min(voltage) |
-======================================
-            10.30000 |          218 |
-Query OK, 1 row(s) in set (0.000950s)
+SELECT BOTTOM(field_name, K) FROM { tb_name | stb_name } [WHERE clause];
 ```
 
-### MAX
+**Description**: The least _k_ values of a specific column in a table or STable. If a value has multiple occurrences in the column but counting all of them in will exceed the upper limit _k_, then a part of them will be returned randomly.
 
-```
-SELECT MAX(field_name) FROM { tb_name | stb_name } [WHERE clause];
-```
+**Return value type**: Same as the column being operated upon
 
-**Description**: The maximum value of a specific column of a table or STable
-
-**Return value type**: Same as the data type of the column being operated upon
-
-**Applicable column types**: Data types except for timestamp, binary, nchar and bool
+**Applicable column types**: Numeric types
 
 **Applicable table types**: table, STable
 
-**Examples**:
+**More explanations**:
 
-```
-taos> SELECT MAX(current), MAX(voltage) FROM meters;
-    max(current)     | max(voltage) |
-======================================
-            13.40000 |          223 |
-Query OK, 1 row(s) in set (0.001123s)
-
-taos> SELECT MAX(current), MAX(voltage) FROM d1001;
-    max(current)     | max(voltage) |
-======================================
-            12.60000 |          221 |
-Query OK, 1 row(s) in set (0.000987s)
-```
+- _k_ must be in range [1,100]
+- The timestamp associated with the selected values are returned too
+- Can't be used with `FILL`
 
 ### FIRST
 
@@ -437,240 +865,7 @@ SELECT FIRST(field_name) FROM { tb_name | stb_name } [WHERE clause];
 - NULL will be returned if all the values of the specified column are all NULL
 - A result will NOT be returned if all the columns in the result set are all NULL
 
-**Examples**:
-
-```
-taos> SELECT FIRST(*) FROM meters;
-        first(ts)        |    first(current)    | first(voltage) |     first(phase)     |
-=========================================================================================
-2018-10-03 14:38:04.000 |             10.20000 |            220 |              0.23000 |
-Query OK, 1 row(s) in set (0.004767s)
-
-taos> SELECT FIRST(current) FROM d1002;
-    first(current)    |
-=======================
-            10.20000 |
-Query OK, 1 row(s) in set (0.001023s)
-```
-
-### LAST
-
-```
-SELECT LAST(field_name) FROM { tb_name | stb_name } [WHERE clause];
-```
-
-**Description**: The last non-NULL value of a specific column in a table or STable
-
-**Return value type**: Same as the column being operated upon
-
-**Applicable column types**: Any data type
-
-**Applicable table types**: table, STable
-
-**More explanations**:
-
-- LAST(\*) can be used to get the last non-NULL value of all columns
-- If the values of a column in the result set are all NULL, NULL is returned for that column; if all columns in the result are all NULL, no result will be returned.
-- When it's used on a STable, if there are multiple values with the timestamp in the result set, one of them will be returned randomly and it's not guaranteed that the same value is returned if the same query is run multiple times.
-
-**Examples**:
-
-```
-taos> SELECT LAST(*) FROM meters;
-        last(ts)         |    last(current)     | last(voltage) |     last(phase)      |
-========================================================================================
-2018-10-03 14:38:16.800 |             12.30000 |           221 |              0.31000 |
-Query OK, 1 row(s) in set (0.001452s)
-
-taos> SELECT LAST(current) FROM d1002;
-    last(current)     |
-=======================
-            10.30000 |
-Query OK, 1 row(s) in set (0.000843s)
-```
-
-### TOP
-
-```
-SELECT TOP(field_name, K) FROM { tb_name | stb_name } [WHERE clause];
-```
-
-**Description**: The greatest _k_ values of a specific column in a table or STable. If a value has multiple occurrences in the column but counting all of them in will exceed the upper limit _k_, then a part of them will be returned randomly.
-
-**Return value type**: Same as the column being operated upon
-
-**Applicable column types**: Data types except for timestamp, binary, nchar and bool
-
-**Applicable table types**: table, STable
-
-**More explanations**:
-
-- _k_ must be in range [1,100]
-- The timestamp associated with the selected values are returned too
-- Can't be used with `FILL`
-
-**Examples**:
-
-```
-taos> SELECT TOP(current, 3) FROM meters;
-        ts            |   top(current, 3)    |
-=================================================
-2018-10-03 14:38:15.000 |             12.60000 |
-2018-10-03 14:38:16.600 |             13.40000 |
-2018-10-03 14:38:16.800 |             12.30000 |
-Query OK, 3 row(s) in set (0.001548s)
-
-taos> SELECT TOP(current, 2) FROM d1001;
-        ts            |   top(current, 2)    |
-=================================================
-2018-10-03 14:38:15.000 |             12.60000 |
-2018-10-03 14:38:16.800 |             12.30000 |
-Query OK, 2 row(s) in set (0.000810s)
-```
-
-### BOTTOM
-
-```
-SELECT BOTTOM(field_name, K) FROM { tb_name | stb_name } [WHERE clause];
-```
-
-**Description**: The least _k_ values of a specific column in a table or STable. If a value has multiple occurrences in the column but counting all of them in will exceed the upper limit _k_, then a part of them will be returned randomly.
-
-**Return value type**: Same as the column being operated upon
-
-**Applicable column types**: Data types except for timestamp, binary, nchar and bool
-
-**Applicable table types**: table, STable
-
-**More explanations**:
-
-- _k_ must be in range [1,100]
-- The timestamp associated with the selected values are returned too
-- Can't be used with `FILL`
-
-**Examples**:
-
-```
-taos> SELECT BOTTOM(voltage, 2) FROM meters;
-        ts            | bottom(voltage, 2) |
-===============================================
-2018-10-03 14:38:15.000 |                218 |
-2018-10-03 14:38:16.650 |                218 |
-Query OK, 2 row(s) in set (0.001332s)
-
-taos> SELECT BOTTOM(current, 2) FROM d1001;
-        ts            |  bottom(current, 2)  |
-=================================================
-2018-10-03 14:38:05.000 |             10.30000 |
-2018-10-03 14:38:16.800 |             12.30000 |
-Query OK, 2 row(s) in set (0.000793s)
-```
-
-### PERCENTILE
-
-```
-SELECT PERCENTILE(field_name, P) FROM { tb_name } [WHERE clause];
-```
-
-**Description**: The value whose rank in a specific column matches the specified percentage. If such a value matching the specified percentage doesn't exist in the column, an interpolation value will be returned.
-
-**Return value type**: Double precision floating point
-
-**Applicable column types**: Data types except for timestamp, binary, nchar and bool
-
-**Applicable table types**: table
-
-**More explanations**: _P_ is in range [0,100], when _P_ is 0, the result is same as using function MIN; when _P_ is 100, the result is same as function MAX.
-
-**Examples**:
-
-```
-taos> SELECT PERCENTILE(current, 20) FROM d1001;
-percentile(current, 20)  |
-============================
-            11.100000191 |
-Query OK, 1 row(s) in set (0.000787s)
-```
-
-### APERCENTILE
-
-```
-SELECT APERCENTILE(field_name, P[, algo_type])
-FROM { tb_name | stb_name } [WHERE clause]
-```
-
-**Description**: Similar to `PERCENTILE`, but a simulated result is returned
-
-**Return value type**: Double precision floating point
-
-**Applicable column types**: Data types except for timestamp, binary, nchar and bool
-
-**Applicable table types**: table, STable
-
-**More explanations**
-
-- _P_ is in range [0,100], when _P_ is 0, the result is same as using function MIN; when _P_ is 100, the result is same as function MAX.
-- **algo_type** can only be input as `default` or `t-digest`, if it's not specified `default` will be used, i.e. `apercentile(column_name, 50)` is same as `apercentile(column_name, 50, "default")`.
-- When `t-digest` is used, `t-digest` sampling is used to calculate. It can be used from version 2.2.0.0.
-
-**Nested query**: It can be used in both the outer query and inner query in a nested query.
-
-```
-taos> SELECT APERCENTILE(current, 20) FROM d1001;
-apercentile(current, 20)  |
-============================
-            10.300000191 |
-Query OK, 1 row(s) in set (0.000645s)
-
-taos> select apercentile (count, 80, 'default') from stb1;
- apercentile (c0, 80, 'default') |
-==================================
-             601920857.210056424 |
-Query OK, 1 row(s) in set (0.012363s)
-
-taos> select apercentile (count, 80, 't-digest') from stb1;
- apercentile (c0, 80, 't-digest') |
-===================================
-              605869120.966666579 |
-Query OK, 1 row(s) in set (0.011639s)
-```
-
-### LAST_ROW
-
-```
-SELECT LAST_ROW(field_name) FROM { tb_name | stb_name };
-```
-
-**Description**: The last row of a table or STable
-
-**Return value type**: Same as the column being operated upon
-
-**Applicable column types**: Any data type
-
-**Applicable table types**: table, STable
-
-**More explanations**:
-
-- When it's used against a STable, multiple rows with the same and largest timestamp may exist, in this case one of them is returned randomly and it's not guaranteed that the result is same if the query is run multiple times.
-- Can't be used with `INTERVAL`.
-
-**Examples**:
-
-```
- taos> SELECT LAST_ROW(current) FROM meters;
- last_row(current)   |
- =======================
-             12.30000 |
- Query OK, 1 row(s) in set (0.001238s)
-
- taos> SELECT LAST_ROW(current) FROM d1002;
- last_row(current)   |
- =======================
-             10.30000 |
- Query OK, 1 row(s) in set (0.001042s)
-```
-
-### INTERP [Since version 2.3.1]
+### INTERP
 
 ```
 SELECT INTERP(field_name) FROM { tb_name | stb_name } [WHERE where_condition] [ RANGE(timestamp1,timestamp2) ] [EVERY(interval)] [FILL ({ VALUE | PREV | NULL | LINEAR | NEXT})];
@@ -694,91 +889,89 @@ SELECT INTERP(field_name) FROM { tb_name | stb_name } [WHERE where_condition] [
 - `INTERP` can only be used to interpolate in single timeline. So it must be used with `group by tbname` when it's used on a STable. It can't be used with `GROUP BY` when it's used in the inner query of a nested query.
 - The result of `INTERP` is not influenced by `ORDER BY TIMESTAMP`, which impacts the output order only..
 
-**Examples**: Based on the `meters` schema used throughout the documents
-
-- Single point linear interpolation between "2017-07-14 18:40:00" and "2017-07-14 18:40:00:
+### LAST
 
 ```
- taos> SELECT INTERP(current) FROM t1 RANGE('2017-7-14 18:40:00','2017-7-14 18:40:00') FILL(LINEAR);
+SELECT LAST(field_name) FROM { tb_name | stb_name } [WHERE clause];
 ```
 
-- Get original data every 5 seconds, no interpolation, between "2017-07-14 18:00:00" and "2017-07-14 19:00:00:
-
-```
- taos> SELECT INTERP(current) FROM t1 RANGE('2017-7-14 18:00:00','2017-7-14 19:00:00') EVERY(5s);
-```
-
-- Linear interpolation every 5 seconds between "2017-07-14 18:00:00" and "2017-07-14 19:00:00:
-
-```
-  taos> SELECT INTERP(current) FROM t1 RANGE('2017-7-14 18:00:00','2017-7-14 19:00:00') EVERY(5s) FILL(LINEAR);
-```
-
-- Backward interpolation every 5 seconds
-
-```
-  taos> SELECT INTERP(current) FROM t1 EVERY(5s) FILL(NEXT);
-```
-
-- Linear interpolation every 5 seconds between "2017-07-14 17:00:00" and "2017-07-14 20:00:00"
-
-```
-  taos> SELECT INTERP(current) FROM t1 where ts >= '2017-07-14 17:00:00' and ts <= '2017-07-14 20:00:00' RANGE('2017-7-14 18:00:00','2017-7-14 19:00:00') EVERY(5s) FILL(LINEAR);
-```
-
-### INTERP [Since version 2.0.15.0]
-
-```
-SELECT INTERP(field_name) FROM { tb_name | stb_name } WHERE ts='timestamp' [FILL ({ VALUE | PREV | NULL | LINEAR | NEXT})];
-```
-
-**Description**: The value of a specific column that matches the specified time slice
+**Description**: The last non-NULL value of a specific column in a table or STable
 
 **Return value type**: Same as the column being operated upon
 
-**Applicable column types**: Numeric data type
+**Applicable column types**: Any data type
 
 **Applicable table types**: table, STable
 
 **More explanations**:
 
-- Time slice must be specified. If there is no data matching the specified time slice, interpolation is performed based on `FILL` parameter. Conditions such as tags or `tbname` can be used `Where` clause can be used to filter data.
-- The timestamp specified must be within the time range of the data rows of the table or STable. If it is beyond the valid time range, nothing is returned even with `FILL` parameter.
-- `INTERP` can be used to query only single time point once. `INTERP` can be used with `EVERY` to get the interpolation value every time interval.
-- **Examples**:
+- LAST(\*) can be used to get the last non-NULL value of all columns
+- If the values of a column in the result set are all NULL, NULL is returned for that column; if all columns in the result are all NULL, no result will be returned.
+- When it's used on a STable, if there are multiple values with the timestamp in the result set, one of them will be returned randomly and it's not guaranteed that the same value is returned if the same query is run multiple times.
+
+### LAST_ROW
 
 ```
- taos> SELECT INTERP(*) FROM meters WHERE ts='2017-7-14 18:40:00.004';
-        interp(ts)        |   interp(current)    | interp(voltage) |    interp(phase)     |
- ==========================================================================================
-  2017-07-14 18:40:00.004 |              9.84020 |             216 |              0.32222 |
- Query OK, 1 row(s) in set (0.002652s)
+SELECT LAST_ROW(field_name) FROM { tb_name | stb_name };
 ```
 
-If there is no data corresponding to the specified timestamp, an interpolation value is returned if interpolation policy is specified by `FILL` parameter; or nothing is returned.
+**Description**: The last row of a table or STable
+
+**Return value type**: Same as the column being operated upon
+
+**Applicable column types**: Any data type
+
+**Applicable table types**: table, STable
+
+**More explanations**:
+
+- When it's used against a STable, multiple rows with the same and largest timestamp may exist, in this case one of them is returned randomly and it's not guaranteed that the result is same if the query is run multiple times.
+- Can't be used with `INTERVAL`.
+
+### MAX
 
 ```
- taos> SELECT INTERP(*) FROM meters WHERE tbname IN ('d636') AND ts='2017-7-14 18:40:00.005';
- Query OK, 0 row(s) in set (0.004022s)
-
- taos> SELECT INTERP(*) FROM meters WHERE tbname IN ('d636') AND ts='2017-7-14 18:40:00.005' FILL(PREV);
-        interp(ts)        |   interp(current)    | interp(voltage) |    interp(phase)     |
- ==========================================================================================
-  2017-07-14 18:40:00.005 |              9.88150 |             217 |              0.32500 |
- Query OK, 1 row(s) in set (0.003056s)
+SELECT MAX(field_name) FROM { tb_name | stb_name } [WHERE clause];
 ```
 
-Interpolation is performed every 5 milliseconds between `['2017-7-14 18:40:00', '2017-7-14 18:40:00.014']`
+**Description**: The maximum value of a specific column of a table or STable
+
+**Return value type**: Same as the data type of the column being operated upon
+
+**Applicable column types**: Numeric types
+
+**Applicable table types**: table, STable
+
+### MIN
 
 ```
- taos> SELECT INTERP(current) FROM d636 WHERE ts>='2017-7-14 18:40:00' AND ts<='2017-7-14 18:40:00.014' EVERY(5a);
-            ts            |   interp(current)    |
- =================================================
-  2017-07-14 18:40:00.000 |             10.04179 |
-  2017-07-14 18:40:00.010 |             10.16123 |
- Query OK, 2 row(s) in set (0.003487s)
+SELECT MIN(field_name) FROM {tb_name | stb_name} [WHERE clause];
 ```
 
+**Description**: The minimum value of a specific column in a table or STable
+
+**Return value type**: Same as the data type of the column being operated upon
+
+**Applicable column types**: Numeric types
+
+**Applicable table types**: table, STable
+
+### PERCENTILE
+
+```
+SELECT PERCENTILE(field_name, P) FROM { tb_name } [WHERE clause];
+```
+
+**Description**: The value whose rank in a specific column matches the specified percentage. If such a value matching the specified percentage doesn't exist in the column, an interpolation value will be returned.
+
+**Return value type**: Double precision floating point
+
+**Applicable column types**: Numeric types
+
+**Applicable table types**: table
+
+**More explanations**: _P_ is in range [0,100], when _P_ is 0, the result is same as using function MIN; when _P_ is 100, the result is same as function MAX.
+
 ### TAIL
 
 ```
@@ -793,30 +986,26 @@ SELECT TAIL(field_name, k, offset_val) FROM {tb_name | stb_name} [WHERE clause];
 
 **Applicable column types**: Any data type except form timestamp, i.e. the primary key
 
-**Applicable versions**: Since version 2.6.0.0
-
-**Examples**:
+### TOP
 
 ```
-taos> select ts,dbig from tail2;
-       ts            |         dbig          |
-==================================================
-2021-10-15 00:31:33.000 |                     1 |
-2021-10-17 00:31:31.000 |                  NULL |
-2021-12-24 00:31:34.000 |                     2 |
-2022-01-01 08:00:05.000 |                    19 |
-2022-01-01 08:00:06.000 |                  NULL |
-2022-01-01 08:00:07.000 |                     9 |
-Query OK, 6 row(s) in set (0.001952s)
-
-taos> select tail(dbig,2,2) from tail2;
-ts                      |    tail(dbig,2,2)     |
-==================================================
-2021-12-24 00:31:34.000 |                     2 |
-2022-01-01 08:00:05.000 |                    19 |
-Query OK, 2 row(s) in set (0.002307s)
+SELECT TOP(field_name, K) FROM { tb_name | stb_name } [WHERE clause];
 ```
 
+**Description**: The greatest _k_ values of a specific column in a table or STable. If a value has multiple occurrences in the column but counting all of them in will exceed the upper limit _k_, then a part of them will be returned randomly.
+
+**Return value type**: Same as the column being operated upon
+
+**Applicable column types**: Numeric types
+
+**Applicable table types**: table, STable
+
+**More explanations**:
+
+- _k_ must be in range [1,100]
+- The timestamp associated with the selected values are returned too
+- Can't be used with `FILL`
+
 ### UNIQUE
 
 ```
@@ -829,179 +1018,14 @@ SELECT UNIQUE(field_name) FROM {tb_name | stb_name} [WHERE clause];
 
 **Applicable column types**: Any data types except for timestamp
 
-**Applicable versions**: Since version 2.6.0.0
-
 **More explanations**:
 
 - It can be used against table or STable, but can't be used together with time window, like `interval`, `state_window` or `session_window` .
 - Considering the number of result sets is unpredictable, it's suggested to limit the distinct values under 100,000 to control the memory usage, otherwise error will be returned.
 
-**Examples**:
+## Time-Series Specific Functions
 
-```
-taos> select ts,voltage from unique1;
-       ts            |        voltage        |
-==================================================
-2021-10-17 00:31:31.000 |                     1 |
-2022-01-24 00:31:31.000 |                     1 |
-2021-10-17 00:31:31.000 |                     1 |
-2021-12-24 00:31:31.000 |                     2 |
-2022-01-01 08:00:01.000 |                    19 |
-2021-10-17 00:31:31.000 |                  NULL |
-2022-01-01 08:00:02.000 |                  NULL |
-2022-01-01 08:00:03.000 |                     9 |
-Query OK, 8 row(s) in set (0.003018s)
-
-taos> select unique(voltage) from unique1;
-ts                      |    unique(voltage)    |
-==================================================
-2021-10-17 00:31:31.000 |                     1 |
-2021-10-17 00:31:31.000 |                  NULL |
-2021-12-24 00:31:31.000 |                     2 |
-2022-01-01 08:00:01.000 |                    19 |
-2022-01-01 08:00:03.000 |                     9 |
-Query OK, 5 row(s) in set (0.108458s)
-```
-
-## Scalar functions
-
-### DIFF
-
-```sql
-SELECT {DIFF(field_name, ignore_negative) | DIFF(field_name)} FROM tb_name [WHERE clause];
-```
-
-**Description**: The different of each row with its previous row for a specific column. `ignore_negative` can be specified as 0 or 1, the default value is 1 if it's not specified. `1` means negative values are ignored.
-
-**Return value type**: Same as the column being operated upon
-
-**Applicable column types**: Data types except for timestamp, binary, nchar and bool
-
-**Applicable table types**: table, STable
-
-**More explanations**:
-
-- The number of result rows is the number of rows subtracted by one, no output for the first row
-- Since version 2.1.30, `DIFF` can be used on STable with `GROUP by tbname`
-- Since version 2.6.0, `ignore_negative` parameter is supported
-
-**Examples**:
-
-```sql
-taos> SELECT DIFF(current) FROM d1001;
-        ts            |    diff(current)     |
-=================================================
-2018-10-03 14:38:15.000 |              2.30000 |
-2018-10-03 14:38:16.800 |             -0.30000 |
-Query OK, 2 row(s) in set (0.001162s)
-```
-
-### DERIVATIVE
-
-```
-SELECT DERIVATIVE(field_name, time_interval, ignore_negative) FROM tb_name [WHERE clause];
-```
-
-**Description**: The derivative of a specific column. The time rage can be specified by parameter `time_interval`, the minimum allowed time range is 1 second (1s); the value of `ignore_negative` can be 0 or 1, 1 means negative values are ignored.
-
-**Return value type**: Double precision floating point
-
-**Applicable column types**: Data types except for timestamp, binary, nchar and bool
-
-**Applicable table types**: table, STable
-
-**More explanations**:
-
-- It is available from version 2.1.3.0, the number of result rows is the number of total rows in the time range subtracted by one, no output for the first row.
-- It can be used together with `GROUP BY tbname` against a STable.
-
-**Examples**:
-
-```
-taos> select derivative(current, 10m, 0) from t1;
-           ts            | derivative(current, 10m, 0) |
-========================================================
- 2021-08-20 10:11:22.790 |                 0.500000000 |
- 2021-08-20 11:11:22.791 |                 0.166666620 |
- 2021-08-20 12:11:22.791 |                 0.000000000 |
- 2021-08-20 13:11:22.792 |                 0.166666620 |
- 2021-08-20 14:11:22.792 |                -0.666666667 |
-Query OK, 5 row(s) in set (0.004883s)
-```
-
-### SPREAD
-
-```
-SELECT SPREAD(field_name) FROM { tb_name | stb_name } [WHERE clause];
-```
-
-**Description**: The difference between the max and the min of a specific column
-
-**Return value type**: Double precision floating point
-
-**Applicable column types**: Data types except for binary, nchar, and bool
-
-**Applicable table types**: table, STable
-
-**More explanations**: Can be used on a column of TIMESTAMP type, the result is the time range size.
-
-**Examples**:
-
-```
-taos> SELECT SPREAD(voltage) FROM meters;
-    spread(voltage)      |
-============================
-            5.000000000 |
-Query OK, 1 row(s) in set (0.001792s)
-
-taos> SELECT SPREAD(voltage) FROM d1001;
-    spread(voltage)      |
-============================
-            3.000000000 |
-Query OK, 1 row(s) in set (0.000836s)
-```
-
-### CEIL
-
-```
-SELECT CEIL(field_name) FROM { tb_name | stb_name } [WHERE clause];
-```
-
-**Description**: The rounded up value of a specific column
-
-**Return value type**: Same as the column being used
-
-**Applicable data types**: Data types except for timestamp, binary, nchar, bool
-
-**Applicable table types**: table, STable
-
-**Applicable nested query**: Inner query and outer query
-
-**More explanations**:
-
-- Can't be used on any tags of any type
-- Arithmetic operation can be performed on the result of `ceil` function
-- Can't be used with aggregate functions
-
-### FLOOR
-
-```
-SELECT FLOOR(field_name) FROM { tb_name | stb_name } [WHERE clause];
-```
-
-**Description**: The rounded down value of a specific column
-
-**More explanations**: The restrictions are same as those of the `CEIL` function.
-
-### ROUND
-
-```
-SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
-```
-
-**Description**: The rounded value of a specific column.
-
-**More explanations**: The restrictions are same as `CEIL` function.
+TDengine provides a set of time-series specific functions to better meet the requirements in querying time-series data. In general databases, similar functionalities can only be achieved with much more complex syntax and much worse performance. TDengine provides these functionalities in builtin functions so that the burden on user side is minimized.
 
 ### CSUM
 
@@ -1013,20 +1037,72 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
 
 **Return value type**: Long integer for integers; Double for floating points. Timestamp is returned for each row.
 
-**Applicable data types**: Data types except for timestamp, binary, nchar, and bool
+**Applicable data types**: Numeric types
 
 **Applicable table types**: table, STable
 
 **Applicable nested query**: Inner query and Outer query
 
 **More explanations**:
-
-- Can't be used on tags when it's used on STable
 - Arithmetic operation can't be performed on the result of `csum` function
 - Can only be used with aggregate functions
 - `Group by tbname` must be used together on a STable to force the result on a single timeline
 
-**Applicable versions**: Since 2.3.0.x
+### DERIVATIVE
+
+```
+SELECT DERIVATIVE(field_name, time_interval, ignore_negative) FROM tb_name [WHERE clause];
+```
+
+**Description**: The derivative of a specific column. The time rage can be specified by parameter `time_interval`, the minimum allowed time range is 1 second (1s); the value of `ignore_negative` can be 0 or 1, 1 means negative values are ignored.
+
+**Return value type**: Double precision floating point
+
+**Applicable column types**: Numeric types
+
+**Applicable table types**: table, STable
+
+**More explanations**:
+
+- The number of result rows is the number of total rows in the time range subtracted by one, no output for the first row.
+- It can be used together with `GROUP BY tbname` against a STable.
+
+### DIFF
+
+```sql
+SELECT {DIFF(field_name, ignore_negative) | DIFF(field_name)} FROM tb_name [WHERE clause];
+```
+
+**Description**: The different of each row with its previous row for a specific column. `ignore_negative` can be specified as 0 or 1, the default value is 1 if it's not specified. `1` means negative values are ignored.
+
+**Return value type**: Same as the column being operated upon
+
+**Applicable column types**: Numeric types
+
+**Applicable table types**: table, STable
+
+**More explanations**:
+
+- The number of result rows is the number of rows subtracted by one, no output for the first row
+- It can be used on STable with `GROUP by tbname`
+
+### IRATE
+
+```
+SELECT IRATE(field_name) FROM tb_name WHERE clause;
+```
+
+**Description**: instantaneous rate on a specific column. The last two samples in the specified time range are used to calculate instantaneous rate. If the last sample value is smaller, then only the last sample value is used instead of the difference between the last two sample values.
+
+**Return value type**: Double precision floating number
+
+**Applicable column types**: Numeric types
+
+**Applicable table types**: table, STable
+
+**More explanations**:
+
+- It can be used on stble with `GROUP BY`, i.e. timelines generated by `GROUP BY tbname` on a STable.
 
 ### MAVG
 
@@ -1034,11 +1110,11 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
     SELECT MAVG(field_name, K) FROM { tb_name | stb_name } [WHERE clause]
 ```
 
-**Description**: The moving average of continuous _k_ values of a specific column. If the number of input rows is less than _k_, nothing is returned. The applicable range is _k_ is [1,1000].
+**Description**: The moving average of continuous _k_ values of a specific column. If the number of input rows is less than _k_, nothing is returned. The applicable range of _k_ is [1,1000].
 
 **Return value type**: Double precision floating point
 
-**Applicable data types**: Data types except for timestamp, binary, nchar, and bool
+**Applicable data types**: Numeric types
 
 **Applicable nested query**: Inner query and Outer query
 
@@ -1047,12 +1123,9 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
 **More explanations**:
 
 - Arithmetic operation can't be performed on the result of `MAVG`.
-- Can only be used with data columns, can't be used with tags.
 - Can't be used with aggregate functions.
 - Must be used with `GROUP BY tbname` when it's used on a STable to force the result on each single timeline.
 
-**Applicable versions**: Since 2.3.0.x
-
 ### SAMPLE
 
 ```sql
@@ -1074,469 +1147,6 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
 - Arithmetic operation can't be operated on the result of `SAMPLE` function
 - Must be used with `Group by tbname` when it's used on a STable to force the result on each single timeline
 
-**Applicable versions**: Since 2.3.0.x
-
-### ASIN
-
-```sql
-SELECT ASIN(field_name) FROM { tb_name | stb_name } [WHERE clause]
-```
-
-**Description**: The anti-sine of a specific column
-
-**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
-
-**Applicable data types**: Data types except for timestamp, binary, nchar, bool
-
-**Applicable table types**: table, STable
-
-**Applicable nested query**: Inner query and Outer query
-
-**Applicable versions**: From 2.6.0.0
-
-**More explanations**:
-
-- Can't be used with tags
-- Can't be used with aggregate functions
-
-### ACOS
-
-```sql
-SELECT ACOS(field_name) FROM { tb_name | stb_name } [WHERE clause]
-```
-
-**Description**: The anti-cosine of a specific column
-
-**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
-
-**Applicable data types**: Data types except for timestamp, binary, nchar, bool
-
-**Applicable table types**: table, STable
-
-**Applicable nested query**: Inner query and Outer query
-
-**Applicable versions**: From 2.6.0.0
-
-**More explanations**:
-
-- Can't be used with tags
-- Can't be used with aggregate functions
-
-### ATAN
-
-```sql
-SELECT ATAN(field_name) FROM { tb_name | stb_name } [WHERE clause]
-```
-
-**Description**: anti-tangent of a specific column
-
-**Description**: The anti-cosine of a specific column
-
-**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
-
-**Applicable data types**: Data types except for timestamp, binary, nchar, bool
-
-**Applicable table types**: table, STable
-
-**Applicable nested query**: Inner query and Outer query
-
-**Applicable versions**: From 2.6.0.0
-
-**More explanations**:
-
-- Can't be used with tags
-- Can't be used with aggregate functions
-
-### SIN
-
-```sql
-SELECT SIN(field_name) FROM { tb_name | stb_name } [WHERE clause]
-```
-
-**Description**: The sine of a specific column
-
-**Description**: The anti-cosine of a specific column
-
-**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
-
-**Applicable data types**: Data types except for timestamp, binary, nchar, bool
-
-**Applicable table types**: table, STable
-
-**Applicable nested query**: Inner query and Outer query
-
-**Applicable versions**: From 2.6.0.0
-
-**More explanations**:
-
-- Can't be used with tags
-- Can't be used with aggregate functions
-
-### COS
-
-```sql
-SELECT COS(field_name) FROM { tb_name | stb_name } [WHERE clause]
-```
-
-**Description**: The cosine of a specific column
-
-**Description**: The anti-cosine of a specific column
-
-**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
-
-**Applicable data types**: Data types except for timestamp, binary, nchar, bool
-
-**Applicable table types**: table, STable
-
-**Applicable nested query**: Inner query and Outer query
-
-**Applicable versions**: From 2.6.0.0
-
-**More explanations**:
-
-- Can't be used with tags
-- Can't be used with aggregate functions
-
-### TAN
-
-```sql
-SELECT TAN(field_name) FROM { tb_name | stb_name } [WHERE clause]
-```
-
-**Description**: The tangent of a specific column
-
-**Description**: The anti-cosine of a specific column
-
-**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
-
-**Applicable data types**: Data types except for timestamp, binary, nchar, bool
-
-**Applicable table types**: table, STable
-
-**Applicable nested query**: Inner query and Outer query
-
-**Applicable versions**: From 2.6.0.0
-
-**More explanations**:
-
-- Can't be used with tags
-- Can't be used with aggregate functions
-
-### POW
-
-```sql
-SELECT POW(field_name, power) FROM { tb_name | stb_name } [WHERE clause]
-```
-
-**Description**: The power of a specific column with `power` as the index
-
-**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
-
-**Applicable data types**: Data types except for timestamp, binary, nchar, bool
-
-**Applicable table types**: table, STable
-
-**Applicable nested query**: Inner query and Outer query
-
-**Applicable versions**: From 2.6.0.0
-
-**More explanations**:
-
-- Can't be used with tags
-- Can't be used with aggregate functions
-
-### LOG
-
-```sql
-SELECT LOG(field_name, base) FROM { tb_name | stb_name } [WHERE clause]
-```
-
-**Description**: The log of a specific with `base` as the radix
-
-**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
-
-**Applicable data types**: Data types except for timestamp, binary, nchar, bool
-
-**Applicable table types**: table, STable
-
-**Applicable nested query**: Inner query and Outer query
-
-**Applicable versions**: From 2.6.0.0
-
-**More explanations**:
-
-- Can't be used with tags
-- Can't be used with aggregate functions
-
-### ABS
-
-```sql
-SELECT ABS(field_name) FROM { tb_name | stb_name } [WHERE clause]
-```
-
-**Description**: The absolute of a specific column
-
-**Return value type**: UBIGINT if the input value is integer; DOUBLE if the input value is FLOAT/DOUBLE
-
-**Applicable data types**: Data types except for timestamp, binary, nchar, bool
-
-**Applicable table types**: table, STable
-
-**Applicable nested query**: Inner query and Outer query
-
-**Applicable versions**: From 2.6.0.0
-
-**More explanations**:
-
-- Can't be used with tags
-- Can't be used with aggregate functions
-
-### SQRT
-
-```sql
-SELECT SQRT(field_name) FROM { tb_name | stb_name } [WHERE clause]
-```
-
-**Description**: The square root of a specific column
-
-**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
-
-**Applicable data types**: Data types except for timestamp, binary, nchar, bool
-
-**Applicable table types**: table, STable
-
-**Applicable nested query**: Inner query and Outer query
-
-**Applicable versions**: From 2.6.0.0
-
-**More explanations**:
-
-- Can't be used with tags
-- Can't be used with aggregate functions
-
-### CAST
-
-```sql
-SELECT CAST(expression AS type_name) FROM { tb_name | stb_name } [WHERE clause]
-```
-
-**Description**: It's used for type casting. The input parameter `expression` can be data columns, constants, scalar functions or arithmetic between them. Can't be used with tags, and can only be used in `select` clause.
-
-**Return value type**: The type specified by parameter `type_name`
-
-**Applicable data types**:
-
-- Parameter `expression` can be any data type except for JSON, more specifically it can be any of BOOL/TINYINT/SMALLINT/INT/BIGINT/FLOAT/DOUBLE/BINARY(M)/TIMESTAMP/NCHAR(M)/TINYINT UNSIGNED/SMALLINT UNSIGNED/INT UNSIGNED/BIGINT UNSIGNED
-- The output data type specified by `type_name` can only be one of BIGINT/BINARY(N)/TIMESTAMP/NCHAR(N)/BIGINT UNSIGNED
-
-**Applicable versions**: From 2.6.0.0
-
-**More explanations**:
-
-- Error will be reported for unsupported type casting
-- NULL will be returned if the input value is NULL
-- Some values of some supported data types may not be casted, below are known issues:
-  1）When casting BINARY/NCHAR to BIGINT/BIGINT UNSIGNED, some characters may be treated as illegal, for example "a" may be converted to 0.
-  2）There may be overflow when casting singed integer or TIMESTAMP to unsigned BIGINT
-  3）There may be overflow when casting unsigned BIGINT to BIGINT
-  4）There may be overflow when casting FLOAT/DOUBLE to BIGINT or UNSIGNED BIGINT
-
-### CONCAT
-
-```sql
-SELECT CONCAT(str1|column1, str2|column2, ...) FROM { tb_name | stb_name } [WHERE clause]
-```
-
-**Description**: The concatenation result of two or more strings, the number of strings to be concatenated is at least 2 and at most 8
-
-**Return value type**: Same as the columns being operated, BINARY or NCHAR; or NULL if all the input are NULL
-
-**Applicable data types**: The input data must be in either all BINARY or in all NCHAR; can't be used on tag columns
-
-**Applicable table types**: table, STable
-
-**Applicable nested query**: Inner query and Outer query
-
-**Applicable versions**: From 2.6.0.0
-
-### CONCAT_WS
-
-```
-SELECT CONCAT_WS(separator, str1|column1, str2|column2, ...) FROM { tb_name | stb_name } [WHERE clause]
-```
-
-**Description**: The concatenation result of two or more strings with separator, the number of strings to be concatenated is at least 3 and at most 9
-
-**Return value type**: Same as the columns being operated, BINARY or NCHAR; or NULL if all the input are NULL
-
-**Applicable data types**: The input data must be in either all BINARY or in all NCHAR; can't be used on tag columns
-
-**Applicable table types**: table, STable
-
-**Applicable nested query**: Inner query and Outer query
-
-**Applicable versions**: From 2.6.0.0
-
-**More explanations**:
-
-- If the value of `separator` is NULL, the output is NULL. If the value of `separator` is not NULL but other input are all NULL, the output is empty string.
-
-### LENGTH
-
-```
-SELECT LENGTH(str|column) FROM { tb_name | stb_name } [WHERE clause]
-```
-
-**Description**: The length in bytes of a string
-
-**Return value type**: Integer
-
-**Applicable data types**: BINARY or NCHAR, can't be used on tags
-
-**Applicable table types**: table, STable
-
-**Applicable nested query**: Inner query and Outer query
-
-**Applicable versions**: From 2.6.0.0
-
-**More explanations**
-
-- If the input value is NULL, the output is NULL too
-
-### CHAR_LENGTH
-
-```
-SELECT CHAR_LENGTH(str|column) FROM { tb_name | stb_name } [WHERE clause]
-```
-
-**Description**: The length in number of characters of a string
-
-**Return value type**: Integer
-
-**Applicable data types**: BINARY or NCHAR, can't be used on tags
-
-**Applicable table types**: table, STable
-
-**Applicable nested query**: Inner query and Outer query
-
-**Applicable versions**: From 2.6.0.0
-
-**More explanations**
-
-- If the input value is NULL, the output is NULL too
-
-### LOWER
-
-```
-SELECT LOWER(str|column) FROM { tb_name | stb_name } [WHERE clause]
-```
-
-**Description**: Convert the input string to lower case
-
-**Return value type**: Same as input
-
-**Applicable data types**: BINARY or NCHAR, can't be used on tags
-
-**Applicable table types**: table, STable
-
-**Applicable nested query**: Inner query and Outer query
-
-**Applicable versions**: From 2.6.0.0
-
-**More explanations**
-
-- If the input value is NULL, the output is NULL too
-
-### UPPER
-
-```
-SELECT UPPER(str|column) FROM { tb_name | stb_name } [WHERE clause]
-```
-
-**Description**: Convert the input string to upper case
-
-**Return value type**: Same as input
-
-**Applicable data types**: BINARY or NCHAR, can't be used on tags
-
-**Applicable table types**: table, STable
-
-**Applicable nested query**: Inner query and Outer query
-
-**Applicable versions**: From 2.6.0.0
-
-**More explanations**
-
-- If the input value is NULL, the output is NULL too
-
-### LTRIM
-
-```
-SELECT LTRIM(str|column) FROM { tb_name | stb_name } [WHERE clause]
-```
-
-**Description**: Remove the left leading blanks of a string
-
-**Return value type**: Same as input
-
-**Applicable data types**: BINARY or NCHAR, can't be used on tags
-
-**Applicable table types**: table, STable
-
-**Applicable nested query**: Inner query and Outer query
-
-**Applicable versions**: From 2.6.0.0
-
-**More explanations**
-
-- If the input value is NULL, the output is NULL too
-
-### RTRIM
-
-```
-SELECT RTRIM(str|column) FROM { tb_name | stb_name } [WHERE clause]
-```
-
-**Description**: Remove the right tailing blanks of a string
-
-**Return value type**: Same as input
-
-**Applicable data types**: BINARY or NCHAR, can't be used on tags
-
-**Applicable table types**: table, STable
-
-**Applicable nested query**: Inner query and Outer query
-
-**Applicable versions**: From 2.6.0.0
-
-**More explanations**
-
-- If the input value is NULL, the output is NULL too
-
-### SUBSTR
-
-```
-SELECT SUBSTR(str,pos[,len]) FROM { tb_name | stb_name } [WHERE clause]
-```
-
-**Description**: The sub-string starting from `pos` with length of `len` from the original string `str`
-
-**Return value type**: Same as input
-
-**Applicable data types**: BINARY or NCHAR, can't be used on tags
-
-**Applicable table types**: table, STable
-
-**Applicable nested query**: Inner query and Outer query
-
-**Applicable versions**: From 2.6.0.0
-
-**More explanations**:
-
-- If the input is NULL, the output is NULL
-- Parameter `pos` can be an positive or negative integer; If it's positive, the starting position will be counted from the beginning of the string; if it's negative, the starting position will be counted from the end of the string.
-- If `len` is not specified, it means from `pos` to the end.
-
 ### STATECOUNT
 
 ```
@@ -1552,45 +1162,17 @@ SELECT STATECOUNT(field_name, oper, val) FROM { tb_name | stb_name } [WHERE clau
 
 **Return value type**: Integer
 
-**Applicable data types**: Data types excpet for timestamp, binary, nchar, bool
+**Applicable data types**: Numeric types
 
 **Applicable table types**: table, STable
 
 **Applicable nested query**: Outer query only
 
-**Applicable versions**: From 2.6.0.0
-
 **More explanations**:
 
 - Must be used together with `GROUP BY tbname` when it's used on a STable to force the result into each single timeline]
 - Can't be used with window operation, like interval/state_window/session_window
 
-**Examples**:
-
-```
-taos> select ts,dbig from statef2;
-          ts               |         dbig          |
-========================================================
-2021-10-15 00:31:33.000000000 |                     1 |
-2021-10-17 00:31:31.000000000 |                  NULL |
-2021-12-24 00:31:34.000000000 |                     2 |
-2022-01-01 08:00:05.000000000 |                    19 |
-2022-01-01 08:00:06.000000000 |                  NULL |
-2022-01-01 08:00:07.000000000 |                     9 |
-Query OK, 6 row(s) in set (0.002977s)
-
-taos> select stateCount(dbig,GT,2) from statef2;
-ts               |         dbig          | statecount(dbig,gt,2) |
-================================================================================
-2021-10-15 00:31:33.000000000 |                     1 |                    -1 |
-2021-10-17 00:31:31.000000000 |                  NULL |                  NULL |
-2021-12-24 00:31:34.000000000 |                     2 |                    -1 |
-2022-01-01 08:00:05.000000000 |                    19 |                     1 |
-2022-01-01 08:00:06.000000000 |                  NULL |                  NULL |
-2022-01-01 08:00:07.000000000 |                     9 |                     2 |
-Query OK, 6 row(s) in set (0.002791s)
-```
-
 ### STATEDURATION
 
 ```
@@ -1607,326 +1189,65 @@ SELECT stateDuration(field_name, oper, val, unit) FROM { tb_name | stb_name } [W
 
 **Return value type**: Integer
 
-**Applicable data types**: Data types excpet for timestamp, binary, nchar, bool
+**Applicable data types**: Numeric types
 
 **Applicable table types**: table, STable
 
 **Applicable nested query**: Outer query only
 
-**Applicable versions**: From 2.6.0.0
-
 **More explanations**:
 
 - Must be used together with `GROUP BY tbname` when it's used on a STable to force the result into each single timeline]
 - Can't be used with window operation, like interval/state_window/session_window
 
-**Examples**:
+### TWA
 
 ```
-taos> select ts,dbig from statef2;
-          ts               |         dbig          |
-========================================================
-2021-10-15 00:31:33.000000000 |                     1 |
-2021-10-17 00:31:31.000000000 |                  NULL |
-2021-12-24 00:31:34.000000000 |                     2 |
-2022-01-01 08:00:05.000000000 |                    19 |
-2022-01-01 08:00:06.000000000 |                  NULL |
-2022-01-01 08:00:07.000000000 |                     9 |
-Query OK, 6 row(s) in set (0.002407s)
-
-taos> select stateDuration(dbig,GT,2) from statef2;
-ts               |         dbig          | stateduration(dbig,gt,2) |
-===================================================================================
-2021-10-15 00:31:33.000000000 |                     1 |                       -1 |
-2021-10-17 00:31:31.000000000 |                  NULL |                     NULL |
-2021-12-24 00:31:34.000000000 |                     2 |                       -1 |
-2022-01-01 08:00:05.000000000 |                    19 |                        0 |
-2022-01-01 08:00:06.000000000 |                  NULL |                     NULL |
-2022-01-01 08:00:07.000000000 |                     9 |                        2 |
-Query OK, 6 row(s) in set (0.002613s)
+SELECT TWA(field_name) FROM tb_name WHERE clause;
 ```
 
-## Time Functions
+**Description**: Time weighted average on a specific column within a time range
 
-Since version 2.6.0.0, below time related functions can be used in TDengine.
+**Return value type**: Double precision floating number
 
-### NOW
-
-```sql
-SELECT NOW() FROM { tb_name | stb_name } [WHERE clause];
-SELECT select_expr FROM { tb_name | stb_name } WHERE ts_col cond_operatior NOW();
-INSERT INTO tb_name VALUES (NOW(), ...);
-```
-
-**Description**: The current time of the client side system
-
-**Return value type**: TIMESTAMP
-
-**Applicable column types**: TIMESTAMP only
+**Applicable column types**: Numeric types
 
 **Applicable table types**: table, STable
 
 **More explanations**:
 
-- Add and Subtract operation can be performed, for example NOW() + 1s, the time unit can be:
-  b(nanosecond), u(microsecond), a(millisecond)), s(second), m(minute), h(hour), d(day), w(week)
-- The precision of the returned timestamp is same as the precision set for the current data base in use
+- It can be used on stable with `GROUP BY`, i.e. timelines generated by `GROUP BY tbname` on a STable.
 
-**Examples**:
+## System Information Functions
 
-```sql
-taos> SELECT NOW() FROM meters;
-          now()          |
-==========================
-  2022-02-02 02:02:02.456 |
-Query OK, 1 row(s) in set (0.002093s)
+### DATABASE
 
-taos> SELECT NOW() + 1h FROM meters;
-       now() + 1h         |
-==========================
-  2022-02-02 03:02:02.456 |
-Query OK, 1 row(s) in set (0.002093s)
-
-taos> SELECT COUNT(voltage) FROM d1001 WHERE ts < NOW();
-        count(voltage)       |
-=============================
-                           5 |
-Query OK, 5 row(s) in set (0.004475s)
-
-taos> INSERT INTO d1001 VALUES (NOW(), 10.2, 219, 0.32);
-Query OK, 1 of 1 row(s) in database (0.002210s)
+```
+SELECT DATABASE();
 ```
 
-### TODAY
+**Description**：Return the current database being used. If the user doesn't specify database when logon and doesn't use `USE` SQL command to switch the datbase, this function returns NULL.
 
-```sql
-SELECT TODAY() FROM { tb_name | stb_name } [WHERE clause];
-SELECT select_expr FROM { tb_name | stb_name } WHERE ts_col cond_operatior TODAY()];
-INSERT INTO tb_name VALUES (TODAY(), ...);
+### CLIENT_VERSION
+
+```
+SELECT CLIENT_VERSION();
 ```
 
-**Description**: The timestamp of 00:00:00 of the client side system
+**Description**：Return the client version.
 
-**Return value type**: TIMESTAMP
+### SERVER_VERSION
 
-**Applicable column types**: TIMESTAMP only
-
-**Applicable table types**: table, STable
-
-**More explanations**:
-
-- Add and Subtract operation can be performed, for example NOW() + 1s, the time unit can be:
-  b(nanosecond), u(microsecond), a(millisecond)), s(second), m(minute), h(hour), d(day), w(week)
-- The precision of the returned timestamp is same as the precision set for the current data base in use
-
-**Examples**:
-
-```sql
-taos> SELECT TODAY() FROM meters;
-         today()          |
-==========================
-  2022-02-02 00:00:00.000 |
-Query OK, 1 row(s) in set (0.002093s)
-
-taos> SELECT TODAY() + 1h FROM meters;
-      today() + 1h        |
-==========================
-  2022-02-02 01:00:00.000 |
-Query OK, 1 row(s) in set (0.002093s)
-
-taos> SELECT COUNT(voltage) FROM d1001 WHERE ts < TODAY();
-        count(voltage)       |
-=============================
-                           5 |
-Query OK, 5 row(s) in set (0.004475s)
-
-taos> INSERT INTO d1001 VALUES (TODAY(), 10.2, 219, 0.32);
-Query OK, 1 of 1 row(s) in database (0.002210s)
+```
+SELECT SERVER_VERSION();
 ```
 
-### TIMEZONE
+**Description**：Returns the server version.
 
-```sql
-SELECT TIMEZONE() FROM { tb_name | stb_name } [WHERE clause];
+### SERVER_STATUS
+
+```
+SELECT SERVER_VERSION();
 ```
 
-**Description**: The timezone of the client side system
-
-**Return value type**: BINARY
-
-**Applicable column types**: None
-
-**Applicable table types**: table, STable
-
-**Examples**:
-
-```sql
-taos> SELECT TIMEZONE() FROM meters;
-           timezone()           |
-=================================
- UTC (UTC, +0000)               |
-Query OK, 1 row(s) in set (0.002093s)
-```
-
-### TO_ISO8601
-
-```sql
-SELECT TO_ISO8601(ts_val | ts_col) FROM { tb_name | stb_name } [WHERE clause];
-```
-
-**Description**: The ISO8601 date/time format converted from a UNIX timestamp, plus the timezone of the client side system
-
-**Return value type**: BINARY
-
-**Applicable column types**: TIMESTAMP, constant or a column
-
-**Applicable table types**: table, STable
-
-**More explanations**:
-
-- If the input is UNIX timestamp constant, the precision of the returned value is determined by the digits of the input timestamp
-- If the input is a column of TIMESTAMP type, The precision of the returned value is same as the precision set for the current data base in use
-
-**Examples**:
-
-```sql
-taos> SELECT TO_ISO8601(1643738400) FROM meters;
-   to_iso8601(1643738400)    |
-==============================
- 2022-02-02T02:00:00+0800    |
-
-taos> SELECT TO_ISO8601(ts) FROM meters;
-       to_iso8601(ts)        |
-==============================
- 2022-02-02T02:00:00+0800    |
- 2022-02-02T02:00:00+0800    |
- 2022-02-02T02:00:00+0800    |
-```
-
-### TO_UNIXTIMESTAMP
-
-```sql
-SELECT TO_UNIXTIMESTAMP(datetime_string | ts_col) FROM { tb_name | stb_name } [WHERE clause];
-```
-
-**Description**: UNIX timestamp converted from a string of date/time format
-
-**Return value type**: Long integer
-
-**Applicable column types**: Constant or column of BINARY/NCHAR
-
-**Applicable table types**: table, STable
-
-**More explanations**:
-
-- The input string must be compatible with ISO8601/RFC3339 standard, 0 will be returned if the string can't be converted
-- The precision of the returned timestamp is same as the precision set for the current data base in use
-
-**Examples**:
-
-```sql
-taos> SELECT TO_UNIXTIMESTAMP("2022-02-02T02:00:00.000Z") FROM meters;
-to_unixtimestamp("2022-02-02T02:00:00.000Z") |
-==============================================
-                               1643767200000 |
-
-taos> SELECT TO_UNIXTIMESTAMP(col_binary) FROM meters;
-      to_unixtimestamp(col_binary)     |
-========================================
-                         1643767200000 |
-                         1643767200000 |
-                         1643767200000 |
-```
-
-### TIMETRUNCATE
-
-```sql
-SELECT TIMETRUNCATE(ts_val | datetime_string | ts_col, time_unit) FROM { tb_name | stb_name } [WHERE clause];
-```
-
-**Description**: Truncate the input timestamp with unit specified by `time_unit`\
-
-**Return value type**: TIMESTAMP\
-
-**Applicable column types**: UNIX timestamp constant, string constant of date/time format, or a column of timestamp
-
-**Applicable table types**: table, STable
-
-**More explanations**:
-
-- Time unit specified by `time_unit` can be:
-  1u(microsecond),1a(millisecond),1s(second),1m(minute),1h(hour),1d(day).
-- The precision of the returned timestamp is same as the precision set for the current data base in use
-
-**Examples**:
-
-```sql
-taos> SELECT TIMETRUNCATE(1643738522000, 1h) FROM meters;
-  timetruncate(1643738522000, 1h) |
-===================================
-      2022-02-02 02:00:00.000     |
-Query OK, 1 row(s) in set (0.001499s)
-
-taos> SELECT TIMETRUNCATE("2022-02-02 02:02:02", 1h) FROM meters;
-  timetruncate("2022-02-02 02:02:02", 1h) |
-===========================================
-      2022-02-02 02:00:00.000             |
-Query OK, 1 row(s) in set (0.003903s)
-
-taos> SELECT TIMETRUNCATE(ts, 1h) FROM meters;
-  timetruncate(ts, 1h)   |
-==========================
- 2022-02-02 02:00:00.000 |
- 2022-02-02 02:00:00.000 |
- 2022-02-02 02:00:00.000 |
-Query OK, 3 row(s) in set (0.003903s)
-```
-
-### TIMEDIFF
-
-```sql
-SELECT TIMEDIFF(ts_val1 | datetime_string1 | ts_col1, ts_val2 | datetime_string2 | ts_col2 [, time_unit]) FROM { tb_name | stb_name } [WHERE clause];
-```
-
-**Description**: The difference between two timestamps, and rounded to the time unit specified by `time_unit`
-
-**Return value type**: Long Integer
-
-**Applicable column types**: UNIX timestamp constant, string constant of date/time format, or a column of TIMESTAMP type
-
-**Applicable table types**: table, STable
-
-**More explanations**:
-
-- Time unit specified by `time_unit` can be:
-  1u(microsecond),1a(millisecond),1s(second),1m(minute),1h(hour),1d(day).
-- The precision of the returned timestamp is same as the precision set for the current data base in use
-
-**Applicable versions**:Since version 2.6.0.0
-
-**Examples**:
-
-```sql
-taos> SELECT TIMEDIFF(1643738400000, 1643742000000) FROM meters;
- timediff(1643738400000, 1643742000000) |
-=========================================
-                                3600000 |
-Query OK, 1 row(s) in set (0.002553s)
-taos> SELECT TIMEDIFF(1643738400000, 1643742000000, 1h) FROM meters;
- timediff(1643738400000, 1643742000000, 1h) |
-=============================================
-                                          1 |
-Query OK, 1 row(s) in set (0.003726s)
-
-taos> SELECT TIMEDIFF("2022-02-02 03:00:00", "2022-02-02 02:00:00", 1h) FROM meters;
- timediff("2022-02-02 03:00:00", "2022-02-02 02:00:00", 1h) |
-=============================================================
-                                                          1 |
-Query OK, 1 row(s) in set (0.001937s)
-
-taos> SELECT TIMEDIFF(ts_col1, ts_col2, 1h) FROM meters;
-   timediff(ts_col1, ts_col2, 1h) |
-===================================
-                                1 |
-Query OK, 1 row(s) in set (0.001937s)
-```
+**Description**：Returns the server's status.
diff --git a/docs-en/12-taos-sql/13-operators.md b/docs-en/12-taos-sql/13-operators.md
index e393c82c76..0ca9ec4943 100644
--- a/docs-en/12-taos-sql/13-operators.md
+++ b/docs-en/12-taos-sql/13-operators.md
@@ -35,8 +35,8 @@ TDengine provides 2 set operators: `UNION ALL` and `UNION`. `UNION ALL` combines
 | --- | :---------------: | ------------------------------------------------------------------- | ----------------------------------------------- |
 | 1   |         =         | Except for BLOB, MEDIUMBLOB and JSON                                | Equal                                           |
 | 2   |      <\>, !=      | Except for BLOB, MEDIUMBLOB, JSON and primary key of timestamp type | Not equal                                       |
-| 3   |      \>, \<       | Except for BLOB, MEDIUMBLOB and JSON                                | Greater than, less than                         |
-| 4   |     \>=, \<=      | Except for BLOB, MEDIUMBLOB and JSON                                | Greater than or equal to, less than or equal to |
+| 3   |      \>, <       | Except for BLOB, MEDIUMBLOB and JSON                                | Greater than, less than                         |
+| 4   |     \>=, <=      | Except for BLOB, MEDIUMBLOB and JSON                                | Greater than or equal to, less than or equal to |
 | 5   |   IS [NOT] NULL   | Any types                                                           | Is NULL or NOT                                  |
 | 6   | [NOT] BETWEEN AND | Except for BLOB, MEDIUMBLOB and JSON                                | In a value range or not                         |
 | 7   |        IN         | Except for BLOB, MEDIUMBLOB, JSON and primary key of timestamp type | In a list of values or not                      |
diff --git a/example/CMakeLists.txt b/example/CMakeLists.txt
deleted file mode 100644
index 365b1b7172..0000000000
--- a/example/CMakeLists.txt
+++ /dev/null
@@ -1,49 +0,0 @@
-add_executable(tmq "")
-add_executable(tstream "")
-add_executable(demoapi "")
-
-target_sources(tmq
-    PRIVATE
-    "src/tmq.c"
-)
-
-target_sources(tstream
-    PRIVATE
-    "src/tstream.c"
-)
-
-target_sources(demoapi
-    PRIVATE
-    "src/demoapi.c"
-)
-
-target_link_libraries(tmq
-    taos_static
-)
-
-target_link_libraries(tstream
-    taos_static
-)
-
-target_link_libraries(demoapi
-    taos_static
-)
-
-target_include_directories(tmq
-    PUBLIC "${TD_SOURCE_DIR}/include/os"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
-)
-
-target_include_directories(tstream
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
-)
-
-target_include_directories(demoapi
-    PUBLIC "${TD_SOURCE_DIR}/include/client"
-    PUBLIC "${TD_SOURCE_DIR}/include/os"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
-)
-
-SET_TARGET_PROPERTIES(tmq PROPERTIES OUTPUT_NAME tmq)
-SET_TARGET_PROPERTIES(tstream PROPERTIES OUTPUT_NAME tstream)
-SET_TARGET_PROPERTIES(demoapi PROPERTIES OUTPUT_NAME demoapi)
diff --git a/examples/c/CMakeLists.txt b/examples/c/CMakeLists.txt
index 17a9257c49..eff492945e 100644
--- a/examples/c/CMakeLists.txt
+++ b/examples/c/CMakeLists.txt
@@ -3,20 +3,70 @@ PROJECT(TDengine)
 IF (TD_LINUX)
   INCLUDE_DIRECTORIES(. ${TD_SOURCE_DIR}/src/inc ${TD_SOURCE_DIR}/src/client/inc  ${TD_SOURCE_DIR}/inc)
   AUX_SOURCE_DIRECTORY(. SRC)
-  ADD_EXECUTABLE(demo apitest.c)
-  TARGET_LINK_LIBRARIES(demo taos_static trpc tutil pthread )
-  ADD_EXECUTABLE(sml schemaless.c)
-  TARGET_LINK_LIBRARIES(sml taos_static trpc tutil pthread )
-  ADD_EXECUTABLE(subscribe subscribe.c)
-  TARGET_LINK_LIBRARIES(subscribe taos_static trpc tutil pthread )
-  ADD_EXECUTABLE(epoll epoll.c)
-  TARGET_LINK_LIBRARIES(epoll taos_static trpc tutil pthread lua)
+  #  ADD_EXECUTABLE(demo apitest.c)
+  #TARGET_LINK_LIBRARIES(demo taos_static trpc tutil pthread )
+  #ADD_EXECUTABLE(sml schemaless.c)
+  #TARGET_LINK_LIBRARIES(sml taos_static trpc tutil pthread )
+  #ADD_EXECUTABLE(subscribe subscribe.c)
+  #TARGET_LINK_LIBRARIES(subscribe taos_static trpc tutil pthread )
+  #ADD_EXECUTABLE(epoll epoll.c)
+  #TARGET_LINK_LIBRARIES(epoll taos_static trpc tutil pthread lua)
+
+  add_executable(tmq "")
+  add_executable(tstream "")
+  add_executable(demoapi "")
+
+  target_sources(tmq
+      PRIVATE
+      "tmq.c"
+      )
+
+  target_sources(tstream
+      PRIVATE
+      "tstream.c"
+      )
+
+  target_sources(demoapi
+      PRIVATE
+      "demoapi.c"
+      )
+
+  target_link_libraries(tmq
+      taos_static
+      )
+
+  target_link_libraries(tstream
+      taos_static
+      )
+
+  target_link_libraries(demoapi
+      taos_static
+      )
+
+  target_include_directories(tmq
+      PUBLIC "${TD_SOURCE_DIR}/include/os"
+      PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+      )
+
+  target_include_directories(tstream
+      PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+      )
+
+  target_include_directories(demoapi
+      PUBLIC "${TD_SOURCE_DIR}/include/client"
+      PUBLIC "${TD_SOURCE_DIR}/include/os"
+      PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+      )
+
+  SET_TARGET_PROPERTIES(tmq PROPERTIES OUTPUT_NAME tmq)
+  SET_TARGET_PROPERTIES(tstream PROPERTIES OUTPUT_NAME tstream)
+  SET_TARGET_PROPERTIES(demoapi PROPERTIES OUTPUT_NAME demoapi)
 ENDIF ()
 IF (TD_DARWIN)
   INCLUDE_DIRECTORIES(. ${TD_SOURCE_DIR}/src/inc ${TD_SOURCE_DIR}/src/client/inc  ${TD_SOURCE_DIR}/inc)
   AUX_SOURCE_DIRECTORY(. SRC)
-  ADD_EXECUTABLE(demo demo.c)
-  TARGET_LINK_LIBRARIES(demo taos_static trpc tutil pthread lua)
-  ADD_EXECUTABLE(epoll epoll.c)
-  TARGET_LINK_LIBRARIES(epoll taos_static trpc tutil pthread lua)
+  #ADD_EXECUTABLE(demo demo.c)
+  #TARGET_LINK_LIBRARIES(demo taos_static trpc tutil pthread lua)
+  #ADD_EXECUTABLE(epoll epoll.c)
+  #TARGET_LINK_LIBRARIES(epoll taos_static trpc tutil pthread lua)
 ENDIF ()
diff --git a/example/src/demoapi.c b/examples/c/demoapi.c
similarity index 100%
rename from example/src/demoapi.c
rename to examples/c/demoapi.c
diff --git a/example/src/tmq.c b/examples/c/tmq.c
similarity index 97%
rename from example/src/tmq.c
rename to examples/c/tmq.c
index 5eecb5e4cc..e61ad69e6b 100644
--- a/example/src/tmq.c
+++ b/examples/c/tmq.c
@@ -165,7 +165,6 @@ tmq_t* build_consumer() {
   tmq_conf_set(conf, "group.id", "tg2");
   tmq_conf_set(conf, "td.connect.user", "root");
   tmq_conf_set(conf, "td.connect.pass", "taosdata");
-  /*tmq_conf_set(conf, "td.connect.db", "abc1");*/
   tmq_conf_set(conf, "msg.with.table.name", "true");
   tmq_conf_set(conf, "enable.auto.commit", "false");
   tmq_conf_set_auto_commit_cb(conf, tmq_commit_cb_print, NULL);
@@ -191,7 +190,6 @@ void basic_consume_loop(tmq_t* tmq, tmq_list_t* topics) {
     return;
   }
   int32_t cnt = 0;
-  /*clock_t startTime = clock();*/
   while (running) {
     TAOS_RES* tmqmessage = tmq_consumer_poll(tmq, 0);
     if (tmqmessage) {
@@ -204,8 +202,6 @@ void basic_consume_loop(tmq_t* tmq, tmq_list_t* topics) {
       /*break;*/
     }
   }
-  /*clock_t endTime = clock();*/
-  /*printf("log cnt: %d %f s\n", cnt, (double)(endTime - startTime) / CLOCKS_PER_SEC);*/
 
   err = tmq_consumer_close(tmq);
   if (err)
diff --git a/example/src/tstream.c b/examples/c/tstream.c
similarity index 100%
rename from example/src/tstream.c
rename to examples/c/tstream.c
diff --git a/include/common/tdataformat.h b/include/common/tdataformat.h
index 53197d2d7b..867115d16d 100644
--- a/include/common/tdataformat.h
+++ b/include/common/tdataformat.h
@@ -30,6 +30,7 @@ extern "C" {
 typedef struct SSchema       SSchema;
 typedef struct STColumn      STColumn;
 typedef struct STSchema      STSchema;
+typedef struct SValue        SValue;
 typedef struct SColVal       SColVal;
 typedef struct STSRow2       STSRow2;
 typedef struct STSRowBuilder STSRowBuilder;
@@ -40,24 +41,26 @@ typedef struct STag          STag;
 int32_t tTSchemaCreate(int32_t sver, SSchema *pSchema, int32_t nCols, STSchema **ppTSchema);
 void    tTSchemaDestroy(STSchema *pTSchema);
 
-// SColVal
-#define ColValNONE               ((SColVal){.type = COL_VAL_NONE, .nData = 0, .pData = NULL})
-#define ColValNULL               ((SColVal){.type = COL_VAL_NULL, .nData = 0, .pData = NULL})
-#define ColValDATA(nData, pData) ((SColVal){.type = COL_VAL_DATA, .nData = (nData), .pData = (pData)})
-
 // STSRow2
+#define COL_VAL_NONE(CID)     ((SColVal){.cid = (CID), .isNone = 1})
+#define COL_VAL_NULL(CID)     ((SColVal){.cid = (CID), .isNull = 1})
+#define COL_VAL_VALUE(CID, V) ((SColVal){.cid = (CID), .value = (V)})
+
+int32_t tTSRowClone(const STSRow2 *pRow, STSRow2 **ppRow);
+void    tTSRowFree(STSRow2 *pRow);
+void    tTSRowGet(STSRow2 *pRow, STSchema *pTSchema, int32_t iCol, SColVal *pColVal);
+int32_t tTSRowToArray(STSRow2 *pRow, STSchema *pTSchema, SArray **ppArray);
 int32_t tPutTSRow(uint8_t *p, STSRow2 *pRow);
 int32_t tGetTSRow(uint8_t *p, STSRow2 *pRow);
-int32_t tTSRowDup(const STSRow2 *pRow, STSRow2 **ppRow);
-void    tTSRowFree(STSRow2 *pRow);
-int32_t tTSRowGet(const STSRow2 *pRow, STSchema *pTSchema, int32_t iCol, SColVal *pColVal);
 
 // STSRowBuilder
+#if 0
 int32_t tTSRowBuilderInit(STSRowBuilder *pBuilder, int32_t sver, int32_t nCols, SSchema *pSchema);
 void    tTSRowBuilderClear(STSRowBuilder *pBuilder);
 void    tTSRowBuilderReset(STSRowBuilder *pBuilder);
 int32_t tTSRowBuilderPut(STSRowBuilder *pBuilder, int32_t cid, uint8_t *pData, uint32_t nData);
 int32_t tTSRowBuilderGetRow(STSRowBuilder *pBuilder, const STSRow2 **ppRow);
+#endif
 
 // STag
 int32_t tTagNew(SArray *pArray, int32_t version, int8_t isJson, STag **ppTag);
@@ -90,7 +93,9 @@ struct STSchema {
 #define TSROW_HAS_NONE ((uint8_t)0x1)
 #define TSROW_HAS_NULL ((uint8_t)0x2U)
 #define TSROW_HAS_VAL  ((uint8_t)0x4U)
-#define TSROW_KV_ROW   ((uint8_t)0x10U)
+#define TSROW_KV_SMALL ((uint8_t)0x10U)
+#define TSROW_KV_MID   ((uint8_t)0x20U)
+#define TSROW_KV_BIG   ((uint8_t)0x40U)
 struct STSRow2 {
   TSKEY    ts;
   uint8_t  flags;
@@ -113,11 +118,31 @@ struct STSRowBuilder {
   STSRow2   row;
 };
 
-typedef enum { COL_VAL_NONE = 0, COL_VAL_NULL = 1, COL_VAL_DATA = 2 } EColValT;
+struct SValue {
+  union {
+    int8_t   i8;   // TSDB_DATA_TYPE_BOOL||TSDB_DATA_TYPE_TINYINT
+    uint8_t  u8;   // TSDB_DATA_TYPE_UTINYINT
+    int16_t  i16;  // TSDB_DATA_TYPE_SMALLINT
+    uint16_t u16;  // TSDB_DATA_TYPE_USMALLINT
+    int32_t  i32;  // TSDB_DATA_TYPE_INT
+    uint32_t u32;  // TSDB_DATA_TYPE_UINT
+    int64_t  i64;  // TSDB_DATA_TYPE_BIGINT
+    uint64_t u64;  // TSDB_DATA_TYPE_UBIGINT
+    TSKEY    ts;   // TSDB_DATA_TYPE_TIMESTAMP
+    float    f;    // TSDB_DATA_TYPE_FLOAT
+    double   d;    // TSDB_DATA_TYPE_DOUBLE
+    struct {
+      uint32_t nData;
+      uint8_t *pData;
+    };
+  };
+};
+
 struct SColVal {
-  EColValT type;
-  uint32_t nData;
-  uint8_t *pData;
+  int16_t cid;
+  int8_t  isNone;
+  int8_t  isNull;
+  SValue  value;
 };
 
 #pragma pack(push, 1)
diff --git a/include/common/tmsg.h b/include/common/tmsg.h
index 5ca83fe825..5cf9e9855d 100644
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@@ -244,7 +244,7 @@ typedef struct {
   const void* pMsg;
 } SSubmitMsgIter;
 
-int32_t tInitSubmitMsgIter(SSubmitReq* pMsg, SSubmitMsgIter* pIter);
+int32_t tInitSubmitMsgIter(const SSubmitReq* pMsg, SSubmitMsgIter* pIter);
 int32_t tGetSubmitMsgNext(SSubmitMsgIter* pIter, SSubmitBlk** pPBlock);
 int32_t tInitSubmitBlkIter(SSubmitMsgIter* pMsgIter, SSubmitBlk* pBlock, SSubmitBlkIter* pIter);
 STSRow* tGetSubmitBlkNext(SSubmitBlkIter* pIter);
@@ -945,7 +945,6 @@ typedef struct {
   int64_t timeInFetchQueue;
 } SQnodeLoad;
 
-
 typedef struct {
   int32_t     sver;      // software version
   int64_t     dnodeVer;  // dnode table version in sdb
@@ -1002,7 +1001,6 @@ typedef struct {
 
 typedef struct {
   int32_t  vgId;
-  int32_t  dnodeId;
   char     db[TSDB_DB_FNAME_LEN];
   int64_t  dbUid;
   int32_t  vgVersion;
@@ -1025,16 +1023,14 @@ typedef struct {
   int8_t   compression;
   int8_t   strict;
   int8_t   cacheLastRow;
+  int8_t   isTsma;
+  int8_t   standby;
   int8_t   replica;
   int8_t   selfIndex;
   SReplica replicas[TSDB_MAX_REPLICA];
   int32_t  numOfRetensions;
   SArray*  pRetensions;  // SRetention
-
-  // for tsma
-  int8_t isTsma;
-  void*  pTsma;
-
+  void*    pTsma;
 } SCreateVnodeReq;
 
 int32_t tSerializeSCreateVnodeReq(void* buf, int32_t bufLen, SCreateVnodeReq* pReq);
@@ -1072,8 +1068,8 @@ typedef struct {
   int8_t   walLevel;
   int8_t   strict;
   int8_t   cacheLastRow;
-  int8_t   replica;
   int8_t   selfIndex;
+  int8_t   replica;
   SReplica replicas[TSDB_MAX_REPLICA];
 } SAlterVnodeReq;
 
@@ -1977,7 +1973,7 @@ typedef struct {
   int8_t   killConnection;
   int8_t   align[3];
   SEpSet   epSet;
-  SArray  *pQnodeList;
+  SArray*  pQnodeList;
 } SQueryHbRspBasic;
 
 typedef struct {
@@ -2305,6 +2301,7 @@ typedef struct {
   int8_t   intervalUnit;  // MACRO: TIME_UNIT_XXX
   int8_t   slidingUnit;   // MACRO: TIME_UNIT_XXX
   int8_t   timezoneInt;   // sma data expired if timezone changes.
+  int32_t  dstVgId;
   char     indexName[TSDB_INDEX_NAME_LEN];
   int32_t  exprLen;
   int32_t  tagsFilterLen;
@@ -2662,6 +2659,23 @@ typedef struct {
 int32_t tEncodeSVSubmitReq(SEncoder* pCoder, const SVSubmitReq* pReq);
 int32_t tDecodeSVSubmitReq(SDecoder* pCoder, SVSubmitReq* pReq);
 
+// TDMT_VND_DELETE
+typedef struct {
+  TSKEY sKey;
+  TSKEY eKey;
+
+  // super table
+  char* stbName;
+
+  // child/normal
+  char* tbName;
+} SVDeleteReq;
+
+typedef struct {
+  int32_t code;
+  // TODO
+} SVDeleteRsp;
+
 #pragma pack(pop)
 
 #ifdef __cplusplus
diff --git a/include/common/tmsgdef.h b/include/common/tmsgdef.h
index d7db2399e8..ba4a221a9f 100644
--- a/include/common/tmsgdef.h
+++ b/include/common/tmsgdef.h
@@ -221,9 +221,11 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_VND_SYNC_APPLY_MSG, "vnode-sync-apply-msg", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_SYNC_CONFIG_CHANGE, "vnode-sync-config-change", NULL, NULL)
   
-  TD_DEF_MSG_TYPE(TDMT_VND_SYNC_VNODE, "vnode-sync-vnode", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_VND_ALTER_VNODE, "vnode-alter-vnode", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_VND_COMPACT_VNODE, "vnode-compact-vnode", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_ALTER_CONFIG, "vnode-alter-config", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_ALTER_REPLICA, "vnode-alter-replica", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_COMPACT, "vnode-compact", NULL, NULL)
+
+  TD_DEF_MSG_TYPE(TDMT_VND_DELETE, "vnode-delete-data", SVDeleteReq, SVDeleteRsp)
 
   // Requests handled by QNODE
   TD_NEW_MSG_SEG(TDMT_QND_MSG)
diff --git a/include/libs/stream/tstream.h b/include/libs/stream/tstream.h
index 8aaf9a79dc..0525cbf367 100644
--- a/include/libs/stream/tstream.h
+++ b/include/libs/stream/tstream.h
@@ -61,11 +61,8 @@ enum {
 };
 
 typedef struct {
-  int8_t type;
-
-  int32_t sourceVg;
-  int64_t sourceVer;
-
+  int8_t      type;
+  int64_t     ver;
   int32_t*    dataRef;
   SSubmitReq* data;
 } SStreamDataSubmit;
@@ -111,6 +108,8 @@ static FORCE_INLINE void streamDataSubmitRefDec(SStreamDataSubmit* pDataSubmit)
   }
 }
 
+SStreamDataSubmit* streamSubmitRefClone(SStreamDataSubmit* pSubmit);
+
 int32_t streamDataBlockEncode(void** buf, const SStreamDataBlock* pOutput);
 void*   streamDataBlockDecode(const void* buf, SStreamDataBlock* pInput);
 
@@ -209,8 +208,6 @@ struct SStreamTask {
   int32_t nodeId;
   SEpSet  epSet;
 
-  // source preprocess
-
   // exec
   STaskExec exec;
 
@@ -318,8 +315,6 @@ int32_t streamDequeueOutput(SStreamTask* pTask, void** output);
 
 int32_t streamTaskRun(SStreamTask* pTask);
 
-int32_t streamTaskHandleInput(SStreamTask* pTask, void* data);
-
 int32_t streamTaskProcessRunReq(SStreamTask* pTask, SMsgCb* pMsgCb);
 int32_t streamProcessDispatchReq(SStreamTask* pTask, SMsgCb* pMsgCb, SStreamDispatchReq* pReq, SRpcMsg* pMsg);
 int32_t streamProcessDispatchRsp(SStreamTask* pTask, SMsgCb* pMsgCb, SStreamDispatchRsp* pRsp);
diff --git a/include/os/osDir.h b/include/os/osDir.h
index a4c686e280..9019d4f802 100644
--- a/include/os/osDir.h
+++ b/include/os/osDir.h
@@ -33,8 +33,19 @@ extern "C" {
 
 #ifdef WINDOWS
 #define TD_TMP_DIR_PATH "C:\\Windows\\Temp\\"
+#define TD_CFG_DIR_PATH "C:\\TDengine\\cfg\\"
+#define TD_DATA_DIR_PATH "C:\\TDengine\\data\\"
+#define TD_LOG_DIR_PATH "C:\\TDengine\\log\\"
+#elif defined(_TD_DARWIN_64)
+#define TD_TMP_DIR_PATH "/tmp/taosd/"
+#define TD_CFG_DIR_PATH "/usr/local/etc/taos/"
+#define TD_DATA_DIR_PATH "/usr/local/var/lib/taos/"
+#define TD_LOG_DIR_PATH "/usr/local/var/log/taos/"
 #else
 #define TD_TMP_DIR_PATH "/tmp/"
+#define TD_CFG_DIR_PATH "/etc/taos/"
+#define TD_DATA_DIR_PATH "/var/lib/taos/"
+#define TD_LOG_DIR_PATH "/var/log/taos/"
 #endif
 
 typedef struct TdDir *TdDirPtr;
diff --git a/include/util/taoserror.h b/include/util/taoserror.h
index be82e14708..c3d2788897 100644
--- a/include/util/taoserror.h
+++ b/include/util/taoserror.h
@@ -70,6 +70,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_NEED_RETRY                    TAOS_DEF_ERROR_CODE(0, 0x0028)
 #define TSDB_CODE_OUT_OF_RPC_MEMORY_QUEUE       TAOS_DEF_ERROR_CODE(0, 0x0029)
 #define TSDB_CODE_INVALID_TIMESTAMP             TAOS_DEF_ERROR_CODE(0, 0x0030)
+#define TSDB_CODE_MSG_DECODE_ERROR              TAOS_DEF_ERROR_CODE(0, 0x0031)
 
 #define TSDB_CODE_REF_NO_MEMORY                 TAOS_DEF_ERROR_CODE(0, 0x0040)
 #define TSDB_CODE_REF_FULL                      TAOS_DEF_ERROR_CODE(0, 0x0041)
diff --git a/include/util/tencode.h b/include/util/tencode.h
index bde2185b02..a13afd4448 100644
--- a/include/util/tencode.h
+++ b/include/util/tencode.h
@@ -461,64 +461,153 @@ static FORCE_INLINE void* tDecoderMalloc(SDecoder* pCoder, int32_t size) {
 }
 
 // ===========================================
-#define tPutV(p, v)                  \
-  int32_t n = 0;                     \
-  for (;;) {                         \
-    if (v <= 0x7f) {                 \
-      if (p) p[n] = v;               \
-      n++;                           \
-      break;                         \
-    }                                \
-    if (p) p[n] = (v & 0x7f) | 0x80; \
-    n++;                             \
-    v >>= 7;                         \
-  }                                  \
-  return n;
+#define tPutV(p, v)                    \
+  do {                                 \
+    int32_t n = 0;                     \
+    for (;;) {                         \
+      if (v <= 0x7f) {                 \
+        if (p) p[n] = v;               \
+        n++;                           \
+        break;                         \
+      }                                \
+      if (p) p[n] = (v & 0x7f) | 0x80; \
+      n++;                             \
+      v >>= 7;                         \
+    }                                  \
+    return n;                          \
+  } while (0)
 
-#define tGetV(p, v)                            \
-  int32_t n = 0;                               \
-  if (v) *v = 0;                               \
-  for (;;) {                                   \
-    if (p[n] <= 0x7f) {                        \
-      if (v) (*v) |= (p[n] << (7 * n));        \
-      n++;                                     \
-      break;                                   \
-    }                                          \
-    if (v) (*v) |= ((p[n] & 0x7f) << (7 * n)); \
-    n++;                                       \
-  }                                            \
-  return n;
+#define tGetV(p, v)                              \
+  do {                                           \
+    int32_t n = 0;                               \
+    if (v) *v = 0;                               \
+    for (;;) {                                   \
+      if (p[n] <= 0x7f) {                        \
+        if (v) (*v) |= (p[n] << (7 * n));        \
+        n++;                                     \
+        break;                                   \
+      }                                          \
+      if (v) (*v) |= ((p[n] & 0x7f) << (7 * n)); \
+      n++;                                       \
+    }                                            \
+    return n;                                    \
+  } while (0)
 
 // PUT
+static FORCE_INLINE int32_t tPutU8(uint8_t* p, uint8_t v) {
+  if (p) ((uint8_t*)p)[0] = v;
+  return sizeof(uint8_t);
+}
+
 static FORCE_INLINE int32_t tPutI8(uint8_t* p, int8_t v) {
   if (p) ((int8_t*)p)[0] = v;
   return sizeof(int8_t);
 }
 
+static FORCE_INLINE int32_t tPutU16(uint8_t* p, uint16_t v) {
+  if (p) ((uint16_t*)p)[0] = v;
+  return sizeof(uint16_t);
+}
+
+static FORCE_INLINE int32_t tPutI16(uint8_t* p, int16_t v) {
+  if (p) ((int16_t*)p)[0] = v;
+  return sizeof(int16_t);
+}
+
+static FORCE_INLINE int32_t tPutU32(uint8_t* p, uint32_t v) {
+  if (p) ((uint32_t*)p)[0] = v;
+  return sizeof(uint32_t);
+}
+
+static FORCE_INLINE int32_t tPutI32(uint8_t* p, int32_t v) {
+  if (p) ((int32_t*)p)[0] = v;
+  return sizeof(int32_t);
+}
+
+static FORCE_INLINE int32_t tPutU64(uint8_t* p, uint64_t v) {
+  if (p) ((uint64_t*)p)[0] = v;
+  return sizeof(uint64_t);
+}
+
 static FORCE_INLINE int32_t tPutI64(uint8_t* p, int64_t v) {
   if (p) ((int64_t*)p)[0] = v;
   return sizeof(int64_t);
 }
 
-static FORCE_INLINE int32_t tPutU16v(uint8_t* p, uint16_t v) { tPutV(p, v) }
+static FORCE_INLINE int32_t tPutFloat(uint8_t* p, float f) {
+  union {
+    uint32_t ui;
+    float    f;
+  } v;
+  v.f = f;
+
+  return tPutU32(p, v.ui);
+}
+
+static FORCE_INLINE int32_t tPutDouble(uint8_t* p, double d) {
+  union {
+    uint64_t ui;
+    double   d;
+  } v;
+  v.d = d;
+
+  return tPutU64(p, v.ui);
+}
+
+static FORCE_INLINE int32_t tPutU16v(uint8_t* p, uint16_t v) { tPutV(p, v); }
 
 static FORCE_INLINE int32_t tPutI16v(uint8_t* p, int16_t v) { return tPutU16v(p, ZIGZAGE(int16_t, v)); }
 
-static FORCE_INLINE int32_t tPutU32v(uint8_t* p, uint32_t v) { tPutV(p, v) }
+static FORCE_INLINE int32_t tPutU32v(uint8_t* p, uint32_t v) { tPutV(p, v); }
 
 static FORCE_INLINE int32_t tPutI32v(uint8_t* p, int32_t v) { return tPutU32v(p, ZIGZAGE(int32_t, v)); }
 
+static FORCE_INLINE int32_t tPutU64v(uint8_t* p, uint64_t v) { tPutV(p, v); }
+
+static FORCE_INLINE int32_t tPutI64v(uint8_t* p, int64_t v) { return tPutU64v(p, ZIGZAGE(int64_t, v)); }
+
+// GET
+static FORCE_INLINE int32_t tGetU8(uint8_t* p, uint8_t* v) {
+  if (v) *v = ((uint8_t*)p)[0];
+  return sizeof(uint8_t);
+}
+
 static FORCE_INLINE int32_t tGetI8(uint8_t* p, int8_t* v) {
   if (v) *v = ((int8_t*)p)[0];
   return sizeof(int8_t);
 }
 
+static FORCE_INLINE int32_t tGetU16(uint8_t* p, uint16_t* v) {
+  if (v) *v = ((uint16_t*)p)[0];
+  return sizeof(uint16_t);
+}
+
+static FORCE_INLINE int32_t tGetI16(uint8_t* p, int16_t* v) {
+  if (v) *v = ((int16_t*)p)[0];
+  return sizeof(int16_t);
+}
+
+static FORCE_INLINE int32_t tGetU32(uint8_t* p, uint32_t* v) {
+  if (v) *v = ((uint32_t*)p)[0];
+  return sizeof(uint32_t);
+}
+
+static FORCE_INLINE int32_t tGetI32(uint8_t* p, int32_t* v) {
+  if (v) *v = ((int32_t*)p)[0];
+  return sizeof(int32_t);
+}
+
+static FORCE_INLINE int32_t tGetU64(uint8_t* p, uint64_t* v) {
+  if (v) *v = ((uint64_t*)p)[0];
+  return sizeof(uint64_t);
+}
+
 static FORCE_INLINE int32_t tGetI64(uint8_t* p, int64_t* v) {
   if (v) *v = ((int64_t*)p)[0];
   return sizeof(int64_t);
 }
 
-static FORCE_INLINE int32_t tGetU16v(uint8_t* p, uint16_t* v) { tGetV(p, v) }
+static FORCE_INLINE int32_t tGetU16v(uint8_t* p, uint16_t* v) { tGetV(p, v); }
 
 static FORCE_INLINE int32_t tGetI16v(uint8_t* p, int16_t* v) {
   int32_t  n;
@@ -530,7 +619,7 @@ static FORCE_INLINE int32_t tGetI16v(uint8_t* p, int16_t* v) {
   return n;
 }
 
-static FORCE_INLINE int32_t tGetU32v(uint8_t* p, uint32_t* v) { tGetV(p, v) }
+static FORCE_INLINE int32_t tGetU32v(uint8_t* p, uint32_t* v) { tGetV(p, v); }
 
 static FORCE_INLINE int32_t tGetI32v(uint8_t* p, int32_t* v) {
   int32_t  n;
@@ -542,6 +631,46 @@ static FORCE_INLINE int32_t tGetI32v(uint8_t* p, int32_t* v) {
   return n;
 }
 
+static FORCE_INLINE int32_t tGetU64v(uint8_t* p, uint64_t* v) { tGetV(p, v); }
+
+static FORCE_INLINE int32_t tGetI64v(uint8_t* p, int64_t* v) {
+  int32_t  n;
+  uint64_t tv;
+
+  n = tGetU64v(p, &tv);
+  if (v) *v = ZIGZAGD(int64_t, tv);
+
+  return n;
+}
+
+static FORCE_INLINE int32_t tGetFloat(uint8_t* p, float* f) {
+  int32_t n = 0;
+
+  union {
+    uint32_t ui;
+    float    f;
+  } v;
+
+  n = tGetU32(p, &v.ui);
+
+  *f = v.f;
+  return n;
+}
+
+static FORCE_INLINE int32_t tGetDouble(uint8_t* p, double* d) {
+  int32_t n = 0;
+
+  union {
+    uint64_t ui;
+    double   d;
+  } v;
+
+  n = tGetU64(p, &v.ui);
+
+  *d = v.d;
+  return n;
+}
+
 // =====================
 static FORCE_INLINE int32_t tPutBinary(uint8_t* p, uint8_t* pData, uint32_t nData) {
   int n = 0;
diff --git a/source/common/src/tdataformat.c b/source/common/src/tdataformat.c
index b8c77cf73e..c66ff290cf 100644
--- a/source/common/src/tdataformat.c
+++ b/source/common/src/tdataformat.c
@@ -21,15 +21,10 @@
 
 static int32_t tGetTagVal(uint8_t *p, STagVal *pTagVal, int8_t isJson);
 
-typedef struct SKVIdx {
-  int32_t cid;
-  int32_t offset;
-} SKVIdx;
-
 #pragma pack(push, 1)
 typedef struct {
   int16_t nCols;
-  SKVIdx  idx[];
+  uint8_t idx[];
 } STSKVRow;
 #pragma pack(pop)
 
@@ -43,7 +38,507 @@ typedef struct {
 
 static FORCE_INLINE int tSKVIdxCmprFn(const void *p1, const void *p2);
 
-// STSRow2
+// SValue
+static FORCE_INLINE int32_t tPutValue(uint8_t *p, SValue *pValue, int8_t type) {
+  int32_t n = 0;
+
+  if (IS_VAR_DATA_TYPE(type)) {
+    n += tPutBinary(p ? p + n : p, pValue->pData, pValue->nData);
+  } else {
+    switch (type) {
+      case TSDB_DATA_TYPE_BOOL:
+        n += tPutI8(p ? p + n : p, pValue->i8 ? 1 : 0);
+        break;
+      case TSDB_DATA_TYPE_TINYINT:
+        n += tPutI8(p ? p + n : p, pValue->i8);
+        break;
+      case TSDB_DATA_TYPE_SMALLINT:
+        n += tPutI16(p ? p + n : p, pValue->i16);
+        break;
+      case TSDB_DATA_TYPE_INT:
+        n += tPutI32(p ? p + n : p, pValue->i32);
+        break;
+      case TSDB_DATA_TYPE_BIGINT:
+        n += tPutI64(p ? p + n : p, pValue->i64);
+        break;
+      case TSDB_DATA_TYPE_FLOAT:
+        n += tPutFloat(p ? p + n : p, pValue->f);
+        break;
+      case TSDB_DATA_TYPE_DOUBLE:
+        n += tPutDouble(p ? p + n : p, pValue->d);
+        break;
+      case TSDB_DATA_TYPE_TIMESTAMP:
+        n += tPutI64(p ? p + n : p, pValue->ts);
+        break;
+      case TSDB_DATA_TYPE_UTINYINT:
+        n += tPutU8(p ? p + n : p, pValue->u8);
+        break;
+      case TSDB_DATA_TYPE_USMALLINT:
+        n += tPutU16(p ? p + n : p, pValue->u16);
+        break;
+      case TSDB_DATA_TYPE_UINT:
+        n += tPutU32(p ? p + n : p, pValue->u32);
+        break;
+      case TSDB_DATA_TYPE_UBIGINT:
+        n += tPutU64(p ? p + n : p, pValue->u64);
+        break;
+      default:
+        ASSERT(0);
+    }
+  }
+
+  return n;
+}
+
+static FORCE_INLINE int32_t tGetValue(uint8_t *p, SValue *pValue, int8_t type) {
+  int32_t n = 0;
+
+  if (IS_VAR_DATA_TYPE(type)) {
+    n += tGetBinary(p, &pValue->pData, pValue ? &pValue->nData : NULL);
+  } else {
+    switch (type) {
+      case TSDB_DATA_TYPE_BOOL:
+        n += tGetI8(p, &pValue->i8);
+        break;
+      case TSDB_DATA_TYPE_TINYINT:
+        n += tGetI8(p, &pValue->i8);
+        break;
+      case TSDB_DATA_TYPE_SMALLINT:
+        n += tGetI16(p, &pValue->i16);
+        break;
+      case TSDB_DATA_TYPE_INT:
+        n += tGetI32(p, &pValue->i32);
+        break;
+      case TSDB_DATA_TYPE_BIGINT:
+        n += tGetI64(p, &pValue->i64);
+        break;
+      case TSDB_DATA_TYPE_FLOAT:
+        n += tGetFloat(p, &pValue->f);
+        break;
+      case TSDB_DATA_TYPE_DOUBLE:
+        n += tGetDouble(p, &pValue->d);
+        break;
+      case TSDB_DATA_TYPE_TIMESTAMP:
+        n += tGetI64(p, &pValue->ts);
+        break;
+      case TSDB_DATA_TYPE_UTINYINT:
+        n += tGetU8(p, &pValue->u8);
+        break;
+      case TSDB_DATA_TYPE_USMALLINT:
+        n += tGetU16(p, &pValue->u16);
+        break;
+      case TSDB_DATA_TYPE_UINT:
+        n += tGetU32(p, &pValue->u32);
+        break;
+      case TSDB_DATA_TYPE_UBIGINT:
+        n += tGetU64(p, &pValue->u64);
+        break;
+      default:
+        ASSERT(0);
+    }
+  }
+
+  return n;
+}
+
+// STSRow2 ========================================================================
+static void tTupleTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow2 *pRow) {
+  int32_t   nColVal = taosArrayGetSize(pArray);
+  STColumn *pTColumn;
+  SColVal  *pColVal;
+
+  ASSERT(nColVal > 0);
+
+  pRow->sver = pTSchema->version;
+
+  // ts
+  pTColumn = &pTSchema->columns[0];
+  pColVal = (SColVal *)taosArrayGet(pArray, 0);
+
+  ASSERT(pTColumn->colId == 0 && pColVal->cid == 0);
+  ASSERT(pTColumn->type == TSDB_DATA_TYPE_TIMESTAMP);
+
+  pRow->ts = pColVal->value.ts;
+
+  // other fields
+  int32_t  iColVal = 1;
+  int32_t  bidx;
+  uint32_t nv = 0;
+  uint8_t *pb = NULL;
+  uint8_t *pf = NULL;
+  uint8_t *pv = NULL;
+  uint8_t  flags = 0;
+  for (int32_t iColumn = 1; iColumn < pTSchema->numOfCols; iColumn++) {
+    bidx = iColumn - 1;
+    pTColumn = &pTSchema->columns[iColumn];
+
+    if (iColVal < nColVal) {
+      pColVal = (SColVal *)taosArrayGet(pArray, iColVal);
+    } else {
+      pColVal = NULL;
+    }
+
+    if (pColVal) {
+      if (pColVal->cid == pTColumn->colId) {
+        iColVal++;
+        if (pColVal->isNone) {
+          goto _set_none;
+        } else if (pColVal->isNull) {
+          goto _set_null;
+        } else {
+          goto _set_value;
+        }
+      } else if (pColVal->cid > pTColumn->colId) {
+        goto _set_none;
+      } else {
+        ASSERT(0);
+      }
+    } else {
+      goto _set_none;
+    }
+
+  _set_none:
+    flags |= TSROW_HAS_NONE;
+    // SET_BIT2(pb, bidx, 0); (todo)
+    continue;
+
+  _set_null:
+    flags != TSROW_HAS_NULL;
+    // SET_BIT2(pb, bidx, 1); (todo)
+    continue;
+
+  _set_value:
+    flags != TSROW_HAS_VAL;
+    // SET_BIT2(pb, bidx, 2); (todo)
+    if (IS_VAR_DATA_TYPE(pTColumn->type)) {
+      // nv += tPutColVal(pv ? pv + nv : pv, pColVal, pTColumn->type, 1);
+    } else {
+      // tPutColVal(pf ? pf + pTColumn->offset : pf, pColVal, pTColumn->type, 1);
+    }
+    continue;
+  }
+
+  ASSERT(flags);
+  switch (flags & 0xf) {
+    case TSROW_HAS_NONE:
+    case TSROW_HAS_NULL:
+      pRow->nData = 0;
+      break;
+    case TSROW_HAS_VAL:
+      pRow->nData = pTSchema->flen + nv;
+      break;
+    case TSROW_HAS_NULL | TSROW_HAS_NONE:
+      pRow->nData = BIT1_SIZE(pTSchema->numOfCols - 1);
+      break;
+    case TSROW_HAS_VAL | TSROW_HAS_NONE:
+    case TSROW_HAS_VAL | TSROW_HAS_NULL:
+      pRow->nData = BIT1_SIZE(pTSchema->numOfCols - 1) + pTSchema->flen + nv;
+      break;
+    case TSROW_HAS_VAL | TSROW_HAS_NULL | TSROW_HAS_NONE:
+      pRow->nData = BIT2_SIZE(pTSchema->numOfCols - 1) + pTSchema->flen + nv;
+      break;
+    default:
+      break;
+  }
+}
+
+static void tMapTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow2 *pRow) {
+  int32_t   nColVal = taosArrayGetSize(pArray);
+  STColumn *pTColumn;
+  SColVal  *pColVal;
+
+  ASSERT(nColVal > 0);
+
+  pRow->sver = pTSchema->version;
+
+  // ts
+  pTColumn = &pTSchema->columns[0];
+  pColVal = (SColVal *)taosArrayGet(pArray, 0);
+
+  ASSERT(pTColumn->colId == 0 && pColVal->cid == 0);
+  ASSERT(pTColumn->type == TSDB_DATA_TYPE_TIMESTAMP);
+
+  pRow->ts = pColVal->value.ts;
+
+  // other fields
+  int32_t  iColVal = 1;
+  uint32_t nv = 0;
+  uint8_t *pv = NULL;
+  uint8_t *pidx = NULL;
+  uint8_t  flags = 0;
+  int16_t  nCol = 0;
+  for (int32_t iColumn = 1; iColumn < pTSchema->numOfCols; iColumn++) {
+    pTColumn = &pTSchema->columns[iColumn];
+
+    if (iColVal < nColVal) {
+      pColVal = (SColVal *)taosArrayGet(pArray, iColVal);
+    } else {
+      pColVal = NULL;
+    }
+
+    if (pColVal) {
+      if (pColVal->cid == pTColumn->colId) {
+        iColVal++;
+        if (pColVal->isNone) {
+          goto _set_none;
+        } else if (pColVal->isNull) {
+          goto _set_null;
+        } else {
+          goto _set_value;
+        }
+      } else if (pColVal->cid > pTColumn->colId) {
+        goto _set_none;
+      } else {
+        ASSERT(0);
+      }
+    } else {
+      goto _set_none;
+    }
+
+  _set_none:
+    flags |= TSROW_HAS_NONE;
+    continue;
+
+  _set_null:
+    flags != TSROW_HAS_NULL;
+    pidx[nCol++] = nv;
+    // nv += tPutColVal(pv ? pv + nv : pv, pColVal, pTColumn->type, 0);
+    continue;
+
+  _set_value:
+    flags != TSROW_HAS_VAL;
+    pidx[nCol++] = nv;
+    // nv += tPutColVal(pv ? pv + nv : pv, pColVal, pTColumn->type, 0);
+    continue;
+  }
+
+  if (nv <= UINT8_MAX) {
+    // small
+  } else if (nv <= UINT16_MAX) {
+    // mid
+  } else {
+    // large
+  }
+}
+
+// try-decide-build
+int32_t tTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow2 **ppRow) {
+  int32_t code = 0;
+  STSRow2 rowT = {0};
+  STSRow2 rowM = {0};
+
+  // try
+  tTupleTSRowNew(pArray, pTSchema, &rowT);
+  tMapTSRowNew(pArray, pTSchema, &rowM);
+
+  // decide & build
+  if (rowT.nData <= rowM.nData) {
+    tTupleTSRowNew(pArray, pTSchema, &rowT);
+  } else {
+    tMapTSRowNew(pArray, pTSchema, &rowM);
+  }
+
+  return code;
+}
+
+int32_t tTSRowClone(const STSRow2 *pRow, STSRow2 **ppRow) {
+  int32_t code = 0;
+
+  (*ppRow) = (STSRow2 *)taosMemoryMalloc(sizeof(**ppRow));
+  if (*ppRow == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _exit;
+  }
+  **ppRow = *pRow;
+  (*ppRow)->pData = NULL;
+
+  if (pRow->nData) {
+    (*ppRow)->pData = taosMemoryMalloc(pRow->nData);
+    if ((*ppRow)->pData == NULL) {
+      taosMemoryFree(*ppRow);
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      goto _exit;
+    }
+    memcpy((*ppRow)->pData, pRow->pData, pRow->nData);
+  }
+
+_exit:
+  return code;
+}
+
+void tTSRowFree(STSRow2 *pRow) {
+  if (pRow) {
+    if (pRow->pData) taosMemoryFree(pRow->pData);
+    taosMemoryFree(pRow);
+  }
+}
+
+void tTSRowGet(STSRow2 *pRow, STSchema *pTSchema, int32_t iCol, SColVal *pColVal) {
+  uint8_t   isTuple = (pRow->flags & 0xf0 == 0) ? 1 : 0;
+  STColumn *pTColumn = &pTSchema->columns[iCol];
+  uint8_t   flags = pRow->flags & (uint8_t)0xf;
+  SValue    value;
+
+  ASSERT(iCol < pTSchema->numOfCols);
+  ASSERT(flags);
+  ASSERT(pRow->sver == pTSchema->version);
+
+  if (iCol == 0) {
+    value.ts = pRow->ts;
+    goto _return_value;
+  }
+
+  if (flags == TSROW_HAS_NONE) {
+    goto _return_none;
+  } else if (flags == TSROW_HAS_NONE) {
+    goto _return_null;
+  }
+
+  ASSERT(pRow->nData && pRow->pData);
+
+  if (isTuple) {
+    uint8_t *pb = pRow->pData;
+    uint8_t *pf = NULL;
+    uint8_t *pv = NULL;
+    uint8_t *p;
+    uint8_t  b;
+
+    // bit
+    switch (flags) {
+      case TSROW_HAS_VAL:
+        pf = pb;
+        break;
+      case TSROW_HAS_NULL | TSROW_HAS_NONE:
+        b = GET_BIT1(pb, iCol - 1);
+        if (b == 0) {
+          goto _return_none;
+        } else {
+          goto _return_null;
+        }
+      case TSROW_HAS_VAL | TSROW_HAS_NONE:
+        b = GET_BIT1(pb, iCol - 1);
+        if (b == 0) {
+          goto _return_none;
+        } else {
+          pf = pb + BIT1_SIZE(pTSchema->numOfCols - 1);
+          break;
+        }
+      case TSROW_HAS_VAL | TSROW_HAS_NULL:
+        b = GET_BIT1(pb, iCol - 1);
+        if (b == 0) {
+          goto _return_null;
+        } else {
+          pf = pb + BIT1_SIZE(pTSchema->numOfCols - 1);
+          break;
+        }
+      case TSROW_HAS_VAL | TSROW_HAS_NULL | TSROW_HAS_NONE:
+        b = GET_BIT2(pb, iCol - 1);
+        if (b == 0) {
+          goto _return_none;
+        } else if (b == 1) {
+          goto _return_null;
+        } else {
+          pf = pb + BIT2_SIZE(pTSchema->numOfCols - 1);
+          break;
+        }
+      default:
+        ASSERT(0);
+    }
+
+    ASSERT(pf);
+
+    p = pf + pTColumn->offset;
+    if (IS_VAR_DATA_TYPE(pTColumn->type)) {
+      pv = pf + pTSchema->flen;
+      p = pv + *(VarDataOffsetT *)p;
+    }
+    tGetValue(p, &value, pTColumn->type);
+    goto _return_value;
+  } else {
+    STSKVRow *pRowK = (STSKVRow *)pRow->pData;
+    int16_t   lidx = 0;
+    int16_t   ridx = pRowK->nCols - 1;
+    uint8_t  *p;
+    int16_t   midx;
+    uint32_t  n;
+    int16_t   cid;
+
+    ASSERT(pRowK->nCols > 0);
+
+    if (pRow->flags & TSROW_KV_SMALL) {
+      p = pRow->pData + sizeof(STSKVRow) + sizeof(uint8_t) * pRowK->nCols;
+    } else if (pRow->flags & TSROW_KV_MID) {
+      p = pRow->pData + sizeof(STSKVRow) + sizeof(uint16_t) * pRowK->nCols;
+    } else if (pRow->flags & TSROW_KV_BIG) {
+      p = pRow->pData + sizeof(STSKVRow) + sizeof(uint32_t) * pRowK->nCols;
+    } else {
+      ASSERT(0);
+    }
+    while (lidx <= ridx) {
+      midx = (lidx + ridx) / 2;
+
+      if (pRow->flags & TSROW_KV_SMALL) {
+        n = ((uint8_t *)pRowK->idx)[midx];
+      } else if (pRow->flags & TSROW_KV_MID) {
+        n = ((uint16_t *)pRowK->idx)[midx];
+      } else {
+        n = ((uint32_t *)pRowK->idx)[midx];
+      }
+
+      n += tGetI16v(p + n, &cid);
+
+      if (TABS(cid) == pTColumn->colId) {
+        if (cid < 0) {
+          goto _return_null;
+        } else {
+          n += tGetValue(p + n, &value, pTColumn->type);
+          goto _return_value;
+        }
+
+        return;
+      } else if (TABS(cid) > pTColumn->colId) {
+        ridx = midx - 1;
+      } else {
+        lidx = midx + 1;
+      }
+    }
+
+    // not found, return NONE
+    goto _return_none;
+  }
+
+_return_none:
+  *pColVal = COL_VAL_NONE(pTColumn->colId);
+  return;
+
+_return_null:
+  *pColVal = COL_VAL_NULL(pTColumn->colId);
+  return;
+
+_return_value:
+  *pColVal = COL_VAL_VALUE(pTColumn->colId, value);
+  return;
+}
+
+int32_t tTSRowToArray(STSRow2 *pRow, STSchema *pTSchema, SArray **ppArray) {
+  int32_t code = 0;
+  SColVal cv;
+
+  (*ppArray) = taosArrayInit(pTSchema->numOfCols, sizeof(SColVal));
+  if (*ppArray == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _exit;
+  }
+
+  for (int32_t iColumn = 0; iColumn < pTSchema->numOfCols; iColumn++) {
+    tTSRowGet(pRow, pTSchema, iColumn, &cv);
+    taosArrayPush(*ppArray, &cv);
+  }
+
+_exit:
+  return code;
+}
+
 int32_t tPutTSRow(uint8_t *p, STSRow2 *pRow) {
   int32_t n = 0;
 
@@ -56,8 +551,11 @@ int32_t tPutTSRow(uint8_t *p, STSRow2 *pRow) {
   switch (pRow->flags & 0xf) {
     case TSROW_HAS_NONE:
     case TSROW_HAS_NULL:
+      ASSERT(pRow->nData == 0);
+      ASSERT(pRow->pData == NULL);
       break;
     default:
+      ASSERT(pRow->nData && pRow->pData);
       n += tPutBinary(p ? p + n : p, pRow->pData, pRow->nData);
       break;
   }
@@ -67,149 +565,26 @@ int32_t tPutTSRow(uint8_t *p, STSRow2 *pRow) {
 
 int32_t tGetTSRow(uint8_t *p, STSRow2 *pRow) {
   int32_t n = 0;
-  uint8_t flags;
 
-  n += tGetI64(p + n, pRow ? &pRow->ts : NULL);
-  n += tGetI8(p + n, pRow ? &pRow->flags : &flags);
-  n += tGetI32v(p + n, pRow ? &pRow->sver : NULL);
+  n += tGetI64(p + n, &pRow->ts);
+  n += tGetI8(p + n, &pRow->flags);
+  n += tGetI32v(p + n, &pRow->sver);
 
-  if (pRow) flags = pRow->flags;
-  switch (flags & 0xf) {
+  ASSERT(pRow->flags);
+  switch (pRow->flags & 0xf) {
     case TSROW_HAS_NONE:
     case TSROW_HAS_NULL:
+      pRow->nData = 0;
+      pRow->pData = NULL;
       break;
     default:
-      n += tGetBinary(p + n, pRow ? &pRow->pData : NULL, pRow ? &pRow->nData : NULL);
+      n += tGetBinary(p + n, &pRow->pData, &pRow->nData);
       break;
   }
 
   return n;
 }
 
-int32_t tTSRowDup(const STSRow2 *pRow, STSRow2 **ppRow) {
-  (*ppRow) = taosMemoryMalloc(sizeof(*pRow) + pRow->nData);
-  if (*ppRow == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  (*ppRow)->ts = pRow->ts;
-  (*ppRow)->flags = pRow->flags;
-  (*ppRow)->sver = pRow->sver;
-  (*ppRow)->nData = pRow->nData;
-  if (pRow->nData) {
-    (*ppRow)->pData = (uint8_t *)(&(*ppRow)[1]);
-    memcpy((*ppRow)->pData, pRow->pData, pRow->nData);
-  } else {
-    (*ppRow)->pData = NULL;
-  }
-
-  return 0;
-}
-
-void tTSRowFree(STSRow2 *pRow) {
-  if (pRow) taosMemoryFree(pRow);
-}
-
-int32_t tTSRowGet(const STSRow2 *pRow, STSchema *pTSchema, int32_t iCol, SColVal *pColVal) {
-  uint32_t  n;
-  uint8_t  *p;
-  uint8_t   v;
-  int32_t   bidx = iCol - 1;
-  STColumn *pTColumn = &pTSchema->columns[iCol];
-  STSKVRow *pTSKVRow;
-  SKVIdx   *pKVIdx;
-
-  ASSERT(iCol != 0);
-  ASSERT(pTColumn->colId != 0);
-
-  ASSERT((pRow->flags & 0xf) != 0);
-  switch (pRow->flags & 0xf) {
-    case TSROW_HAS_NONE:
-      *pColVal = ColValNONE;
-      return 0;
-    case TSROW_HAS_NULL:
-      *pColVal = ColValNULL;
-      return 0;
-  }
-
-  if (TSROW_IS_KV_ROW(pRow)) {
-    ASSERT((pRow->flags & 0xf) != TSROW_HAS_VAL);
-
-    pTSKVRow = (STSKVRow *)pRow->pData;
-    pKVIdx =
-        bsearch(&((SKVIdx){.cid = pTColumn->colId}), pTSKVRow->idx, pTSKVRow->nCols, sizeof(SKVIdx), tSKVIdxCmprFn);
-    if (pKVIdx == NULL) {
-      *pColVal = ColValNONE;
-    } else if (pKVIdx->offset < 0) {
-      *pColVal = ColValNULL;
-    } else {
-      p = pRow->pData + sizeof(STSKVRow) + sizeof(SKVIdx) * pTSKVRow->nCols + pKVIdx->offset;
-      pColVal->type = COL_VAL_DATA;
-      tGetBinary(p, &pColVal->pData, &pColVal->nData);
-    }
-  } else {
-    // get bitmap
-    p = pRow->pData;
-    switch (pRow->flags & 0xf) {
-      case TSROW_HAS_NULL | TSROW_HAS_NONE:
-        v = GET_BIT1(p, bidx);
-        if (v == 0) {
-          *pColVal = ColValNONE;
-        } else {
-          *pColVal = ColValNULL;
-        }
-        return 0;
-      case TSROW_HAS_VAL | TSROW_HAS_NONE:
-        v = GET_BIT1(p, bidx);
-        if (v == 1) {
-          p = p + BIT1_SIZE(pTSchema->numOfCols - 1);
-          break;
-        } else {
-          *pColVal = ColValNONE;
-          return 0;
-        }
-      case TSROW_HAS_VAL | TSROW_HAS_NULL:
-        v = GET_BIT1(p, bidx);
-        if (v == 1) {
-          p = p + BIT1_SIZE(pTSchema->numOfCols - 1);
-          break;
-        } else {
-          *pColVal = ColValNULL;
-          return 0;
-        }
-      case TSROW_HAS_VAL | TSROW_HAS_NULL | TSROW_HAS_NONE:
-        v = GET_BIT2(p, bidx);
-        if (v == 0) {
-          *pColVal = ColValNONE;
-          return 0;
-        } else if (v == 1) {
-          *pColVal = ColValNULL;
-          return 0;
-        } else if (v == 2) {
-          p = p + BIT2_SIZE(pTSchema->numOfCols - 1);
-          break;
-        } else {
-          ASSERT(0);
-        }
-      default:
-        break;
-    }
-
-    // get real value
-    p = p + pTColumn->offset;
-    pColVal->type = COL_VAL_DATA;
-    if (IS_VAR_DATA_TYPE(pTColumn->type)) {
-      tGetBinary(p + pTSchema->flen + *(int32_t *)p, &pColVal->pData, &pColVal->nData);
-    } else {
-      pColVal->pData = p;
-      pColVal->nData = pTColumn->bytes;
-    }
-  }
-
-  return 0;
-}
-
 // STSchema
 int32_t tTSchemaCreate(int32_t sver, SSchema *pSchema, int32_t ncols, STSchema **ppTSchema) {
   *ppTSchema = (STSchema *)taosMemoryMalloc(sizeof(STSchema) + sizeof(STColumn) * ncols);
@@ -251,6 +626,7 @@ void tTSchemaDestroy(STSchema *pTSchema) {
 }
 
 // STSRowBuilder
+#if 0
 int32_t tTSRowBuilderInit(STSRowBuilder *pBuilder, int32_t sver, int32_t nCols, SSchema *pSchema) {
   if (tTSchemaCreate(sver, pSchema, nCols, &pBuilder->pTSchema) < 0) return -1;
 
@@ -508,6 +884,7 @@ int32_t tTSRowBuilderGetRow(STSRowBuilder *pBuilder, const STSRow2 **ppRow) {
 
   return 0;
 }
+#endif
 
 static int tTagValCmprFn(const void *p1, const void *p2) {
   if (((STagVal *)p1)->cid < ((STagVal *)p2)->cid) {
@@ -622,9 +999,9 @@ void debugPrintSTag(STag *pTag, const char *tag, int32_t ln) {
     }
     printf("%s:%d loop[%d-%d] offset=%d\n", __func__, __LINE__, (int32_t)pTag->nTag, (int32_t)n, (int32_t)offset);
     tGetTagVal(p + offset, &tagVal, isJson);
-    if(IS_VAR_DATA_TYPE(tagVal.type)){
+    if (IS_VAR_DATA_TYPE(tagVal.type)) {
       debugPrintTagVal(tagVal.type, tagVal.pData, tagVal.nData, __func__, __LINE__);
-    }else{
+    } else {
       debugPrintTagVal(tagVal.type, &tagVal.i64, tDataTypes[tagVal.type].bytes, __func__, __LINE__);
     }
   }
@@ -650,7 +1027,7 @@ static int32_t tPutTagVal(uint8_t *p, STagVal *pTagVal, int8_t isJson) {
   } else {
     p = p ? p + n : p;
     n += tDataTypes[pTagVal->type].bytes;
-    if(p) memcpy(p, &(pTagVal->i64), tDataTypes[pTagVal->type].bytes);
+    if (p) memcpy(p, &(pTagVal->i64), tDataTypes[pTagVal->type].bytes);
   }
 
   return n;
@@ -750,21 +1127,21 @@ void tTagFree(STag *pTag) {
   if (pTag) taosMemoryFree(pTag);
 }
 
-char *tTagValToData(const STagVal *value, bool isJson){
-  if(!value) return NULL;
-  char *data = NULL;
+char *tTagValToData(const STagVal *value, bool isJson) {
+  if (!value) return NULL;
+  char  *data = NULL;
   int8_t typeBytes = 0;
   if (isJson) {
     typeBytes = CHAR_BYTES;
   }
-  if(IS_VAR_DATA_TYPE(value->type)){
+  if (IS_VAR_DATA_TYPE(value->type)) {
     data = taosMemoryCalloc(1, typeBytes + VARSTR_HEADER_SIZE + value->nData);
-    if(data == NULL) return NULL;
-    if(isJson) *data = value->type;
+    if (data == NULL) return NULL;
+    if (isJson) *data = value->type;
     varDataLen(data + typeBytes) = value->nData;
     memcpy(varDataVal(data + typeBytes), value->pData, value->nData);
-  }else{
-    data = ((char*)&(value->i64)) - typeBytes;  // json with type
+  } else {
+    data = ((char *)&(value->i64)) - typeBytes;  // json with type
   }
 
   return data;
diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c
index c540c0e82d..2962216b0c 100644
--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@@ -28,7 +28,7 @@
 #undef TD_MSG_SEG_CODE_
 #include "tmsgdef.h"
 
-int32_t tInitSubmitMsgIter(SSubmitReq *pMsg, SSubmitMsgIter *pIter) {
+int32_t tInitSubmitMsgIter(const SSubmitReq *pMsg, SSubmitMsgIter *pIter) {
   if (pMsg == NULL) {
     terrno = TSDB_CODE_TDB_SUBMIT_MSG_MSSED_UP;
     return -1;
@@ -165,7 +165,6 @@ int32_t tDecodeSQueryNodeLoad(SDecoder *pDecoder, SQueryNodeLoad *pLoad) {
   return 0;
 }
 
-
 int32_t taosEncodeSEpSet(void **buf, const SEpSet *pEp) {
   int32_t tlen = 0;
   tlen += taosEncodeFixedI8(buf, pEp->inUse);
@@ -2934,7 +2933,6 @@ int32_t tSerializeSCreateVnodeReq(void *buf, int32_t bufLen, SCreateVnodeReq *pR
 
   if (tStartEncode(&encoder) < 0) return -1;
   if (tEncodeI32(&encoder, pReq->vgId) < 0) return -1;
-  if (tEncodeI32(&encoder, pReq->dnodeId) < 0) return -1;
   if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
   if (tEncodeI64(&encoder, pReq->dbUid) < 0) return -1;
   if (tEncodeI32(&encoder, pReq->vgVersion) < 0) return -1;
@@ -2957,6 +2955,7 @@ int32_t tSerializeSCreateVnodeReq(void *buf, int32_t bufLen, SCreateVnodeReq *pR
   if (tEncodeI8(&encoder, pReq->compression) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->strict) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->cacheLastRow) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->standby) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->replica) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->selfIndex) < 0) return -1;
   for (int32_t i = 0; i < TSDB_MAX_REPLICA; ++i) {
@@ -2991,7 +2990,6 @@ int32_t tDeserializeSCreateVnodeReq(void *buf, int32_t bufLen, SCreateVnodeReq *
 
   if (tStartDecode(&decoder) < 0) return -1;
   if (tDecodeI32(&decoder, &pReq->vgId) < 0) return -1;
-  if (tDecodeI32(&decoder, &pReq->dnodeId) < 0) return -1;
   if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
   if (tDecodeI64(&decoder, &pReq->dbUid) < 0) return -1;
   if (tDecodeI32(&decoder, &pReq->vgVersion) < 0) return -1;
@@ -3014,6 +3012,7 @@ int32_t tDeserializeSCreateVnodeReq(void *buf, int32_t bufLen, SCreateVnodeReq *
   if (tDecodeI8(&decoder, &pReq->compression) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->strict) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->cacheLastRow) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->standby) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->replica) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->selfIndex) < 0) return -1;
   for (int32_t i = 0; i < TSDB_MAX_REPLICA; ++i) {
@@ -3053,7 +3052,7 @@ int32_t tDeserializeSCreateVnodeReq(void *buf, int32_t bufLen, SCreateVnodeReq *
 int32_t tFreeSCreateVnodeReq(SCreateVnodeReq *pReq) {
   taosArrayDestroy(pReq->pRetensions);
   pReq->pRetensions = NULL;
-  if(pReq->isTsma) {
+  if (pReq->isTsma) {
     taosMemoryFreeClear(pReq->pTsma);
   }
   return 0;
@@ -3134,8 +3133,8 @@ int32_t tSerializeSAlterVnodeReq(void *buf, int32_t bufLen, SAlterVnodeReq *pReq
   if (tEncodeI8(&encoder, pReq->walLevel) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->strict) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->cacheLastRow) < 0) return -1;
-  if (tEncodeI8(&encoder, pReq->replica) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->selfIndex) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->replica) < 0) return -1;
   for (int32_t i = 0; i < TSDB_MAX_REPLICA; ++i) {
     SReplica *pReplica = &pReq->replicas[i];
     if (tEncodeSReplica(&encoder, pReplica) < 0) return -1;
@@ -3165,8 +3164,8 @@ int32_t tDeserializeSAlterVnodeReq(void *buf, int32_t bufLen, SAlterVnodeReq *pR
   if (tDecodeI8(&decoder, &pReq->walLevel) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->strict) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->cacheLastRow) < 0) return -1;
-  if (tDecodeI8(&decoder, &pReq->replica) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->selfIndex) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->replica) < 0) return -1;
   for (int32_t i = 0; i < TSDB_MAX_REPLICA; ++i) {
     SReplica *pReplica = &pReq->replicas[i];
     if (tDecodeSReplica(&decoder, pReplica) < 0) return -1;
@@ -3654,6 +3653,7 @@ int32_t tEncodeTSma(SEncoder *pCoder, const STSma *pSma) {
   if (tEncodeI8(pCoder, pSma->intervalUnit) < 0) return -1;
   if (tEncodeI8(pCoder, pSma->slidingUnit) < 0) return -1;
   if (tEncodeI8(pCoder, pSma->timezoneInt) < 0) return -1;
+  if (tEncodeI32(pCoder, pSma->dstVgId) < 0) return -1;
   if (tEncodeCStr(pCoder, pSma->indexName) < 0) return -1;
   if (tEncodeI32(pCoder, pSma->exprLen) < 0) return -1;
   if (tEncodeI32(pCoder, pSma->tagsFilterLen) < 0) return -1;
@@ -3676,6 +3676,7 @@ int32_t tDecodeTSma(SDecoder *pCoder, STSma *pSma) {
   if (tDecodeI8(pCoder, &pSma->version) < 0) return -1;
   if (tDecodeI8(pCoder, &pSma->intervalUnit) < 0) return -1;
   if (tDecodeI8(pCoder, &pSma->slidingUnit) < 0) return -1;
+  if (tDecodeI32(pCoder, &pSma->dstVgId) < 0) return -1;
   if (tDecodeI8(pCoder, &pSma->timezoneInt) < 0) return -1;
   if (tDecodeCStrTo(pCoder, pSma->indexName) < 0) return -1;
   if (tDecodeI32(pCoder, &pSma->exprLen) < 0) return -1;
diff --git a/source/dnode/mgmt/mgmt_mnode/src/mmHandle.c b/source/dnode/mgmt/mgmt_mnode/src/mmHandle.c
index 34576d5441..5c5316e3a3 100644
--- a/source/dnode/mgmt/mgmt_mnode/src/mmHandle.c
+++ b/source/dnode/mgmt/mgmt_mnode/src/mmHandle.c
@@ -219,9 +219,9 @@ SArray *mmGetMsgHandles() {
   if (dmSetMgmtHandle(pArray, TDMT_VND_DROP_TASK, mmPutNodeMsgToQueryQueue, 1) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_QUERY_HEARTBEAT, mmPutNodeMsgToQueryQueue, 1) == NULL) goto _OVER;
 
-  if (dmSetMgmtHandle(pArray, TDMT_VND_ALTER_VNODE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_VND_SYNC_VNODE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_VND_COMPACT_VNODE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_ALTER_CONFIG_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_ALTER_REPLICA_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_COMPACT_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
 
   if (dmSetMgmtHandle(pArray, TDMT_VND_SYNC_TIMEOUT, mmPutNodeMsgToSyncQueue, 1) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_SYNC_PING, mmPutNodeMsgToSyncQueue, 1) == NULL) goto _OVER;
diff --git a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
index 27ea19a5dc..018d7a607c 100644
--- a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
+++ b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
@@ -150,20 +150,26 @@ static void vmGenerateVnodeCfg(SCreateVnodeReq *pCreate, SVnodeCfg *pCfg) {
   pCfg->tsdbCfg.minRows = pCreate->minRows;
   pCfg->tsdbCfg.maxRows = pCreate->maxRows;
   for (size_t i = 0; i < taosArrayGetSize(pCreate->pRetensions); ++i) {
-    memcpy(&pCfg->tsdbCfg.retentions[i], taosArrayGet(pCreate->pRetensions, i), sizeof(SRetention));
+    SRetention *pRetention = &pCfg->tsdbCfg.retentions[i];
+    memcpy(pRetention, taosArrayGet(pCreate->pRetensions, i), sizeof(SRetention));
+    if (i == 0) {
+      if ((pRetention->freq > 0 && pRetention->keep > 0)) pCfg->isRsma = 1;
+    }
   }
+
   pCfg->walCfg.vgId = pCreate->vgId;
   pCfg->hashBegin = pCreate->hashBegin;
   pCfg->hashEnd = pCreate->hashEnd;
   pCfg->hashMethod = pCreate->hashMethod;
 
+  pCfg->standby = pCfg->standby;
   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) {
-    pCfg->syncCfg.nodeInfo[i].nodePort = pCreate->replicas[i].port;
-    snprintf(pCfg->syncCfg.nodeInfo[i].nodeFqdn, sizeof(pCfg->syncCfg.nodeInfo[i].nodeFqdn), "%s",
-             pCreate->replicas[i].fqdn);
+    SNodeInfo *pNode = &pCfg->syncCfg.nodeInfo[i];
+    pNode->nodePort = pCreate->replicas[i].port;
+    tstrncpy(pNode->nodeFqdn, pCreate->replicas[i].fqdn, sizeof(pNode->nodeFqdn));
   }
 }
 
@@ -176,6 +182,8 @@ static void vmGenerateWrapperCfg(SVnodeMgmt *pMgmt, SCreateVnodeReq *pCreate, SW
 
 int32_t vmProcessCreateVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   SCreateVnodeReq createReq = {0};
+  SVnodeCfg       vnodeCfg = {0};
+  SWrapperCfg     wrapperCfg = {0};
   int32_t         code = -1;
   char            path[TSDB_FILENAME_LEN] = {0};
 
@@ -184,12 +192,9 @@ int32_t vmProcessCreateVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
     return -1;
   }
 
-  dDebug("vgId:%d, create vnode req is received, tsma:%d", createReq.vgId, createReq.isTsma);
-
-  SVnodeCfg vnodeCfg = {0};
+  dDebug("vgId:%d, create vnode req is received, tsma:%d standby:%d", createReq.vgId, createReq.isTsma,
+         createReq.standby);
   vmGenerateVnodeCfg(&createReq, &vnodeCfg);
-
-  SWrapperCfg wrapperCfg = {0};
   vmGenerateWrapperCfg(pMgmt, &createReq, &wrapperCfg);
 
   SVnodeObj *pVnode = vmAcquireVnode(pMgmt, createReq.vgId);
@@ -218,9 +223,20 @@ int32_t vmProcessCreateVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   code = vmOpenVnode(pMgmt, &wrapperCfg, pImpl);
   if (code != 0) {
     dError("vgId:%d, failed to open vnode since %s", createReq.vgId, terrstr());
+    code = terrno;
     goto _OVER;
   }
 
+  if (createReq.isTsma) {
+    SMsgHead *smaMsg = createReq.pTsma;
+    uint32_t  contLen = (uint32_t)(htonl(smaMsg->contLen) - sizeof(SMsgHead));
+    if (vnodeProcessCreateTSma(pImpl, POINTER_SHIFT(smaMsg, sizeof(SMsgHead)), contLen) < 0) {
+      dError("vgId:%d, failed to create tsma since %s", createReq.vgId, terrstr());
+      code = terrno;
+      goto _OVER;
+    };
+  }
+
   code = vnodeStart(pImpl);
   if (code != 0) {
     dError("vgId:%d, failed to start sync since %s", createReq.vgId, terrstr());
@@ -228,7 +244,10 @@ int32_t vmProcessCreateVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   }
 
   code = vmWriteVnodeListToFile(pMgmt);
-  if (code != 0) goto _OVER;
+  if (code != 0) {
+    code = terrno;
+    goto _OVER;
+  }
 
 _OVER:
   if (code != 0) {
@@ -314,8 +333,9 @@ SArray *vmGetMsgHandles() {
   if (dmSetMgmtHandle(pArray, TDMT_VND_TASK_DISPATCH, vmPutNodeMsgToFetchQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_TASK_RECOVER, vmPutNodeMsgToFetchQueue, 0) == NULL) goto _OVER;
 
-  if (dmSetMgmtHandle(pArray, TDMT_VND_ALTER_VNODE, vmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_VND_COMPACT_VNODE, vmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_ALTER_REPLICA, vmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_ALTER_CONFIG, vmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_COMPACT, vmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_DND_CREATE_VNODE, vmPutNodeMsgToMgmtQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_DND_DROP_VNODE, vmPutNodeMsgToMgmtQueue, 0) == NULL) goto _OVER;
 
diff --git a/source/dnode/mnode/impl/inc/mndTrans.h b/source/dnode/mnode/impl/inc/mndTrans.h
index 9b063fb44f..6d1f371083 100644
--- a/source/dnode/mnode/impl/inc/mndTrans.h
+++ b/source/dnode/mnode/impl/inc/mndTrans.h
@@ -61,7 +61,7 @@ int32_t mndTransAppendRedoAction(STrans *pTrans, STransAction *pAction);
 int32_t mndTransAppendUndoAction(STrans *pTrans, STransAction *pAction);
 void    mndTransSetRpcRsp(STrans *pTrans, void *pCont, int32_t contLen);
 void    mndTransSetCb(STrans *pTrans, ETrnFunc startFunc, ETrnFunc stopFunc, void *param, int32_t paramLen);
-void    mndTransSetDbInfo(STrans *pTrans, SDbObj *pDb);
+void    mndTransSetDbName(STrans *pTrans, const char *dbname);
 void    mndTransSetSerial(STrans *pTrans);
 
 int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans);
diff --git a/source/dnode/mnode/impl/inc/mndVgroup.h b/source/dnode/mnode/impl/inc/mndVgroup.h
index c9099b6b05..3f4f3f2053 100644
--- a/source/dnode/mnode/impl/inc/mndVgroup.h
+++ b/source/dnode/mnode/impl/inc/mndVgroup.h
@@ -36,7 +36,7 @@ SArray *mndBuildDnodesArray(SMnode *pMnode);
 int32_t mndAddVnodeToVgroup(SMnode *pMnode, SVgObj *pVgroup, SArray *pArray);
 int32_t mndRemoveVnodeFromVgroup(SMnode *pMnode, SVgObj *pVgroup, SArray *pArray, SVnodeGid *del1, SVnodeGid *del2);
 
-void *mndBuildCreateVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen);
+void *mndBuildCreateVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen, bool standby);
 void *mndBuildDropVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen);
 void *mndBuildAlterVnodeReq(SMnode *pMnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen);
 
diff --git a/source/dnode/mnode/impl/src/mndDb.c b/source/dnode/mnode/impl/src/mndDb.c
index 5d79708109..c062a2c552 100644
--- a/source/dnode/mnode/impl/src/mndDb.c
+++ b/source/dnode/mnode/impl/src/mndDb.c
@@ -261,7 +261,7 @@ void mndReleaseDb(SMnode *pMnode, SDbObj *pDb) {
   sdbRelease(pSdb, pDb);
 }
 
-static int32_t mndAddCreateVnodeAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, SVnodeGid *pVgid) {
+static int32_t mndAddCreateVnodeAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, SVnodeGid *pVgid, bool standby) {
   STransAction action = {0};
 
   SDnodeObj *pDnode = mndAcquireDnode(pMnode, pVgid->dnodeId);
@@ -270,7 +270,7 @@ static int32_t mndAddCreateVnodeAction(SMnode *pMnode, STrans *pTrans, SDbObj *p
   mndReleaseDnode(pMnode, pDnode);
 
   int32_t contLen = 0;
-  void   *pReq = mndBuildCreateVnodeReq(pMnode, pDnode, pDb, pVgroup, &contLen);
+  void   *pReq = mndBuildCreateVnodeReq(pMnode, pDnode, pDb, pVgroup, &contLen, standby);
   if (pReq == NULL) return -1;
 
   action.pCont = pReq;
@@ -286,7 +286,7 @@ static int32_t mndAddCreateVnodeAction(SMnode *pMnode, STrans *pTrans, SDbObj *p
   return 0;
 }
 
-static int32_t mndAddAlterVnodeAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup) {
+static int32_t mndAddAlterVnodeAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, tmsg_t msgType) {
   STransAction action = {0};
   action.epSet = mndGetVgroupEpset(pMnode, pVgroup);
 
@@ -296,7 +296,7 @@ static int32_t mndAddAlterVnodeAction(SMnode *pMnode, STrans *pTrans, SDbObj *pD
 
   action.pCont = pReq;
   action.contLen = contLen;
-  action.msgType = TDMT_VND_ALTER_VNODE;
+  action.msgType = msgType;
 
   if (mndTransAppendRedoAction(pTrans, &action) != 0) {
     taosMemoryFree(pReq);
@@ -388,7 +388,7 @@ static int32_t mndCheckDbCfg(SMnode *pMnode, SDbCfg *pCfg) {
   }
 
   terrno = 0;
-  return TSDB_CODE_SUCCESS;
+  return terrno;
 }
 
 static void mndSetDefaultDbCfg(SDbCfg *pCfg) {
@@ -467,7 +467,7 @@ static int32_t mndSetCreateDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj
 
     for (int32_t vn = 0; vn < pVgroup->replica; ++vn) {
       SVnodeGid *pVgid = pVgroup->vnodeGid + vn;
-      if (mndAddCreateVnodeAction(pMnode, pTrans, pDb, pVgroup, pVgid) != 0) {
+      if (mndAddCreateVnodeAction(pMnode, pTrans, pDb, pVgroup, pVgid, false) != 0) {
         return -1;
       }
     }
@@ -550,7 +550,7 @@ static int32_t mndCreateDb(SMnode *pMnode, SRpcMsg *pReq, SCreateDbReq *pCreate,
 
   mDebug("trans:%d, used to create db:%s", pTrans->id, pCreate->db);
 
-  mndTransSetDbInfo(pTrans, &dbObj);
+  mndTransSetDbName(pTrans, dbObj.name);
   if (mndSetCreateDbRedoLogs(pMnode, pTrans, &dbObj, pVgroups) != 0) goto _OVER;
   if (mndSetCreateDbUndoLogs(pMnode, pTrans, &dbObj, pVgroups) != 0) goto _OVER;
   if (mndSetCreateDbCommitLogs(pMnode, pTrans, &dbObj, pVgroups) != 0) goto _OVER;
@@ -688,29 +688,37 @@ static int32_t mndSetDbCfgFromAlterDbReq(SDbObj *pDb, SAlterDbReq *pAlter) {
 static int32_t mndSetAlterDbRedoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pOld, SDbObj *pNew) {
   SSdbRaw *pRedoRaw = mndDbActionEncode(pOld);
   if (pRedoRaw == NULL) return -1;
-  if (mndTransAppendRedolog(pTrans, pRedoRaw) != 0) return -1;
-  if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_READY) != 0) return -1;
+  if (mndTransAppendRedolog(pTrans, pRedoRaw) != 0) {
+    sdbFreeRaw(pRedoRaw);
+    return -1;
+  }
 
+  sdbSetRawStatus(pRedoRaw, SDB_STATUS_READY);
   return 0;
 }
 
 static int32_t mndSetAlterDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pOld, SDbObj *pNew) {
   SSdbRaw *pCommitRaw = mndDbActionEncode(pNew);
   if (pCommitRaw == NULL) return -1;
-  if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) return -1;
-  if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY) != 0) return -1;
+  if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
+    sdbFreeRaw(pCommitRaw);
+    return -1;
+  }
 
+  sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
   return 0;
 }
 
 static int32_t mndBuildAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, SArray *pArray) {
   if (pVgroup->replica <= 0 || pVgroup->replica == pDb->cfg.replications) {
-    if (mndAddAlterVnodeAction(pMnode, pTrans, pDb, pVgroup) != 0) {
+    if (mndAddAlterVnodeAction(pMnode, pTrans, pDb, pVgroup, TDMT_VND_ALTER_CONFIG) != 0) {
       return -1;
     }
   } else {
     SVgObj newVgroup = {0};
     memcpy(&newVgroup, pVgroup, sizeof(SVgObj));
+    mndTransSetSerial(pTrans);
+
     if (newVgroup.replica < pDb->cfg.replications) {
       mInfo("db:%s, vgId:%d, will add 2 vnodes, vn:0 dnode:%d", pVgroup->dbName, pVgroup->vgId,
             pVgroup->vnodeGid[0].dnodeId);
@@ -720,9 +728,9 @@ static int32_t mndBuildAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj
         return -1;
       }
       newVgroup.replica = pDb->cfg.replications;
-      if (mndAddAlterVnodeAction(pMnode, pTrans, pDb, &newVgroup) != 0) return -1;
-      if (mndAddCreateVnodeAction(pMnode, pTrans, pDb, &newVgroup, &newVgroup.vnodeGid[1]) != 0) return -1;
-      if (mndAddCreateVnodeAction(pMnode, pTrans, pDb, &newVgroup, &newVgroup.vnodeGid[2]) != 0) return -1;
+      if (mndAddCreateVnodeAction(pMnode, pTrans, pDb, &newVgroup, &newVgroup.vnodeGid[1], true) != 0) return -1;
+      if (mndAddCreateVnodeAction(pMnode, pTrans, pDb, &newVgroup, &newVgroup.vnodeGid[2], true) != 0) return -1;
+      if (mndAddAlterVnodeAction(pMnode, pTrans, pDb, &newVgroup, TDMT_VND_ALTER_REPLICA) != 0) return -1;
     } else {
       mInfo("db:%s, vgId:%d, will remove 2 vnodes", pVgroup->dbName, pVgroup->vgId);
 
@@ -733,15 +741,18 @@ static int32_t mndBuildAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj
         return -1;
       }
       newVgroup.replica = pDb->cfg.replications;
-      if (mndAddAlterVnodeAction(pMnode, pTrans, pDb, &newVgroup) != 0) return -1;
+      if (mndAddAlterVnodeAction(pMnode, pTrans, pDb, &newVgroup, TDMT_VND_ALTER_REPLICA) != 0) return -1;
       if (mndAddDropVnodeAction(pMnode, pTrans, pDb, &newVgroup, &del1, true) != 0) return -1;
       if (mndAddDropVnodeAction(pMnode, pTrans, pDb, &newVgroup, &del2, true) != 0) return -1;
     }
 
     SSdbRaw *pVgRaw = mndVgroupActionEncode(&newVgroup);
     if (pVgRaw == NULL) return -1;
-    if (mndTransAppendCommitlog(pTrans, pVgRaw) != 0) return -1;
-    if (sdbSetRawStatus(pVgRaw, SDB_STATUS_READY) != 0) return -1;
+    if (mndTransAppendCommitlog(pTrans, pVgRaw) != 0) {
+      sdbFreeRaw(pVgRaw);
+      return -1;
+    }
+    sdbSetRawStatus(pVgRaw, SDB_STATUS_READY);
   }
 
   return 0;
@@ -774,18 +785,16 @@ static int32_t mndSetAlterDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *
 }
 
 static int32_t mndAlterDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pOld, SDbObj *pNew) {
-  int32_t code = -1;
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq);
-  if (pTrans == NULL) goto _OVER;
-
+  if (pTrans == NULL) return -1;
   mDebug("trans:%d, used to alter db:%s", pTrans->id, pOld->name);
 
-  mndTransSetDbInfo(pTrans, pOld);
+  int32_t code = -1;
+  mndTransSetDbName(pTrans, pOld->name);
   if (mndSetAlterDbRedoLogs(pMnode, pTrans, pOld, pNew) != 0) goto _OVER;
   if (mndSetAlterDbCommitLogs(pMnode, pTrans, pOld, pNew) != 0) goto _OVER;
   if (mndSetAlterDbRedoActions(pMnode, pTrans, pOld, pNew) != 0) goto _OVER;
   if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
-
   code = 0;
 
 _OVER:
@@ -1040,7 +1049,7 @@ static int32_t mndDropDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb) {
   if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to drop db:%s", pTrans->id, pDb->name);
-  mndTransSetDbInfo(pTrans, pDb);
+  mndTransSetDbName(pTrans, pDb->name);
 
   if (mndSetDropDbRedoLogs(pMnode, pTrans, pDb) != 0) goto _OVER;
   if (mndSetDropDbCommitLogs(pMnode, pTrans, pDb) != 0) goto _OVER;
diff --git a/source/dnode/mnode/impl/src/mndSma.c b/source/dnode/mnode/impl/src/mndSma.c
index 8b09674179..6cb70d1f27 100644
--- a/source/dnode/mnode/impl/src/mndSma.c
+++ b/source/dnode/mnode/impl/src/mndSma.c
@@ -426,7 +426,7 @@ static int32_t mndSetCreateSmaVgroupRedoActions(SMnode *pMnode, STrans *pTrans,
   pVgroup->pTsma = pSmaReq;
 
   int32_t contLen = 0;
-  void   *pReq = mndBuildCreateVnodeReq(pMnode, pDnode, pDb, pVgroup, &contLen);
+  void   *pReq = mndBuildCreateVnodeReq(pMnode, pDnode, pDb, pVgroup, &contLen, false);
   taosMemoryFreeClear(pSmaReq);
   if (pReq == NULL) return -1;
 
@@ -512,7 +512,7 @@ static int32_t mndCreateSma(SMnode *pMnode, SRpcMsg *pReq, SMCreateSmaReq *pCrea
   if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to create sma:%s", pTrans->id, pCreate->name);
-  mndTransSetDbInfo(pTrans, pDb);
+  mndTransSetDbName(pTrans, pDb->name);
   mndTransSetSerial(pTrans);
 
   if (mndSetCreateSmaRedoLogs(pMnode, pTrans, &smaObj) != 0) goto _OVER;
@@ -757,7 +757,7 @@ static int32_t mndDropSma(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SSmaObj *p
   if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to drop sma:%s", pTrans->id, pSma->name);
-  mndTransSetDbInfo(pTrans, pDb);
+  mndTransSetDbName(pTrans, pDb->name);
 
   if (mndSetDropSmaRedoLogs(pMnode, pTrans, pSma) != 0) goto _OVER;
   if (mndSetDropSmaVgroupRedoLogs(pMnode, pTrans, pVgroup) != 0) goto _OVER;
diff --git a/source/dnode/mnode/impl/src/mndStb.c b/source/dnode/mnode/impl/src/mndStb.c
index 9ca7613519..acb344c8a5 100644
--- a/source/dnode/mnode/impl/src/mndStb.c
+++ b/source/dnode/mnode/impl/src/mndStb.c
@@ -754,7 +754,7 @@ _OVER:
 }
 
 int32_t mndAddStbToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *pStb) {
-  mndTransSetDbInfo(pTrans, pDb);
+  mndTransSetDbName(pTrans, pDb->name);
   if (mndSetCreateStbRedoLogs(pMnode, pTrans, pDb, pStb) != 0) return -1;
   if (mndSetCreateStbUndoLogs(pMnode, pTrans, pDb, pStb) != 0) return -1;
   if (mndSetCreateStbCommitLogs(pMnode, pTrans, pDb, pStb) != 0) return -1;
@@ -1261,7 +1261,7 @@ static int32_t mndAlterStb(SMnode *pMnode, SRpcMsg *pReq, const SMAlterStbReq *p
   if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to alter stb:%s", pTrans->id, pAlter->name);
-  mndTransSetDbInfo(pTrans, pDb);
+  mndTransSetDbName(pTrans, pDb->name);
 
   if (mndSetAlterStbRedoLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto _OVER;
   if (mndSetAlterStbCommitLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto _OVER;
@@ -1407,7 +1407,7 @@ static int32_t mndDropStb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SStbObj *p
   if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to drop stb:%s", pTrans->id, pStb->name);
-  mndTransSetDbInfo(pTrans, pDb);
+  mndTransSetDbName(pTrans, pDb->name);
 
   if (mndSetDropStbRedoLogs(pMnode, pTrans, pStb) != 0) goto _OVER;
   if (mndSetDropStbCommitLogs(pMnode, pTrans, pStb) != 0) goto _OVER;
diff --git a/source/dnode/mnode/impl/src/mndTrans.c b/source/dnode/mnode/impl/src/mndTrans.c
index bad513a89d..e191bb9b2a 100644
--- a/source/dnode/mnode/impl/src/mndTrans.c
+++ b/source/dnode/mnode/impl/src/mndTrans.c
@@ -619,8 +619,8 @@ void mndTransSetCb(STrans *pTrans, ETrnFunc startFunc, ETrnFunc stopFunc, void *
   pTrans->paramLen = paramLen;
 }
 
-void mndTransSetDbInfo(STrans *pTrans, SDbObj *pDb) {
-  memcpy(pTrans->dbname, pDb->name, TSDB_DB_FNAME_LEN);
+void mndTransSetDbName(STrans *pTrans, const char *dbname) {
+  memcpy(pTrans->dbname, dbname, TSDB_DB_FNAME_LEN);
 }
 
 void mndTransSetSerial(STrans *pTrans) { pTrans->exec = TRN_EXEC_SERIAL; }
diff --git a/source/dnode/mnode/impl/src/mndVgroup.c b/source/dnode/mnode/impl/src/mndVgroup.c
index b5f308fef2..219e0fa3dc 100644
--- a/source/dnode/mnode/impl/src/mndVgroup.c
+++ b/source/dnode/mnode/impl/src/mndVgroup.c
@@ -51,9 +51,10 @@ int32_t mndInitVgroup(SMnode *pMnode) {
   };
 
   mndSetMsgHandle(pMnode, TDMT_DND_CREATE_VNODE_RSP, mndProcessCreateVnodeRsp);
-  mndSetMsgHandle(pMnode, TDMT_VND_ALTER_VNODE_RSP, mndProcessAlterVnodeRsp);
+  mndSetMsgHandle(pMnode, TDMT_VND_ALTER_REPLICA_RSP, mndProcessAlterVnodeRsp);
+  mndSetMsgHandle(pMnode, TDMT_VND_ALTER_CONFIG_RSP, mndProcessAlterVnodeRsp);
   mndSetMsgHandle(pMnode, TDMT_DND_DROP_VNODE_RSP, mndProcessDropVnodeRsp);
-  mndSetMsgHandle(pMnode, TDMT_VND_COMPACT_VNODE_RSP, mndProcessCompactVnodeRsp);
+  mndSetMsgHandle(pMnode, TDMT_VND_COMPACT_RSP, mndProcessCompactVnodeRsp);
 
   mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_VGROUP, mndRetrieveVgroups);
   mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_VGROUP, mndCancelGetNextVgroup);
@@ -188,10 +189,10 @@ void mndReleaseVgroup(SMnode *pMnode, SVgObj *pVgroup) {
   sdbRelease(pSdb, pVgroup);
 }
 
-void *mndBuildCreateVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen) {
+void *mndBuildCreateVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen,
+                             bool standby) {
   SCreateVnodeReq createReq = {0};
   createReq.vgId = pVgroup->vgId;
-  createReq.dnodeId = pDnode->id;
   memcpy(createReq.db, pDb->name, TSDB_DB_FNAME_LEN);
   createReq.dbUid = pDb->uid;
   createReq.vgVersion = pVgroup->version;
@@ -218,6 +219,7 @@ void *mndBuildCreateVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVg
   createReq.hashMethod = pDb->cfg.hashMethod;
   createReq.numOfRetensions = pDb->cfg.numOfRetensions;
   createReq.pRetensions = pDb->cfg.pRetensions;
+  createReq.standby = standby;
   createReq.isTsma = pVgroup->isTsma;
   createReq.pTsma = pVgroup->pTsma;
 
@@ -276,7 +278,6 @@ void *mndBuildAlterVnodeReq(SMnode *pMnode, SDbObj *pDb, SVgObj *pVgroup, int32_
   alterReq.strict = pDb->cfg.strict;
   alterReq.cacheLastRow = pDb->cfg.cacheLastRow;
   alterReq.replica = pVgroup->replica;
-  alterReq.selfIndex = -1;
 
   for (int32_t v = 0; v < pVgroup->replica; ++v) {
     SReplica  *pReplica = &alterReq.replicas[v];
@@ -292,13 +293,6 @@ void *mndBuildAlterVnodeReq(SMnode *pMnode, SDbObj *pDb, SVgObj *pVgroup, int32_
     mndReleaseDnode(pMnode, pVgidDnode);
   }
 
-#if 0
-  if (alterReq.selfIndex == -1) {
-    terrno = TSDB_CODE_MND_APP_ERROR;
-    return NULL;
-  }
-#endif
-
   int32_t contLen = tSerializeSAlterVnodeReq(NULL, 0, &alterReq);
   if (contLen < 0) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -510,7 +504,7 @@ _OVER:
   taosArrayDestroy(pArray);
   return code;
 }
-
+//--->
 int32_t mndAddVnodeToVgroup(SMnode *pMnode, SVgObj *pVgroup, SArray *pArray) {
   taosArraySort(pArray, (__compar_fn_t)mndCompareDnodeVnodes);
   for (int32_t i = 0; i < taosArrayGetSize(pArray); ++i) {
@@ -538,7 +532,7 @@ int32_t mndAddVnodeToVgroup(SMnode *pMnode, SVgObj *pVgroup, SArray *pArray) {
 
     SVnodeGid *pVgid = &pVgroup->vnodeGid[maxPos];
     pVgid->dnodeId = pDnode->id;
-    pVgid->role = TAOS_SYNC_STATE_FOLLOWER;
+    pVgid->role = TAOS_SYNC_STATE_ERROR;
     pDnode->numOfVnodes++;
 
     mInfo("db:%s, vgId:%d, vnode_index:%d dnode:%d is added", pVgroup->dbName, pVgroup->vgId, maxPos, pVgid->dnodeId);
@@ -549,16 +543,15 @@ int32_t mndAddVnodeToVgroup(SMnode *pMnode, SVgObj *pVgroup, SArray *pArray) {
   terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;
   return -1;
 }
-
+//--->
 int32_t mndRemoveVnodeFromVgroup(SMnode *pMnode, SVgObj *pVgroup, SArray *pArray, SVnodeGid *del1, SVnodeGid *del2) {
-  int32_t removedNum = 0;
-
   taosArraySort(pArray, (__compar_fn_t)mndCompareDnodeVnodes);
   for (int32_t i = 0; i < taosArrayGetSize(pArray); ++i) {
     SDnodeObj *pDnode = taosArrayGet(pArray, i);
     mDebug("dnode:%d, equivalent vnodes:%d", pDnode->id, pDnode->numOfVnodes);
   }
 
+  int32_t removedNum = 0;
   for (int32_t d = taosArrayGetSize(pArray) - 1; d >= 0; --d) {
     SDnodeObj *pDnode = taosArrayGet(pArray, d);
 
@@ -664,6 +657,7 @@ static int32_t mndRetrieveVgroups(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *p
   int32_t numOfRows = 0;
   SVgObj *pVgroup = NULL;
   int32_t cols = 0;
+  int64_t curMs = taosGetTimestampMs();
 
   SDbObj *pDb = NULL;
   if (strlen(pShow->db) > 0) {
@@ -703,12 +697,15 @@ static int32_t mndRetrieveVgroups(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *p
       if (i < pVgroup->replica) {
         colDataAppend(pColInfo, numOfRows, (const char *)&pVgroup->vnodeGid[i].dnodeId, false);
 
+        bool       online = false;
+        SDnodeObj *pDnode = mndAcquireDnode(pMnode, pVgroup->vnodeGid[i].dnodeId);
+        if (pDnode != NULL) {
+          online = mndIsDnodeOnline(pMnode, pDnode, curMs);
+          mndReleaseDnode(pMnode, pDnode);
+        }
+
         char        buf1[20] = {0};
-        SDnodeObj *pDnodeObj = mndAcquireDnode(pMnode, pVgroup->vnodeGid[i].dnodeId);
-        ASSERT(pDnodeObj != NULL);
-        bool isOffLine = !mndIsDnodeOnline(pMnode, pDnodeObj, taosGetTimestampMs());
-        const char *role = isOffLine ? "OFFLINE" : syncStr(pVgroup->vnodeGid[i].role);
-        
+        const char *role = online ? syncStr(pVgroup->vnodeGid[i].role) : "OFFLINE";
         STR_WITH_MAXSIZE_TO_VARSTR(buf1, role, pShow->pMeta->pSchemas[cols].bytes);
 
         pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
diff --git a/source/dnode/mnode/impl/test/trans/trans2.cpp b/source/dnode/mnode/impl/test/trans/trans2.cpp
index d518db2d38..022c82c73d 100644
--- a/source/dnode/mnode/impl/test/trans/trans2.cpp
+++ b/source/dnode/mnode/impl/test/trans/trans2.cpp
@@ -128,7 +128,7 @@ class MndTestTrans2 : public ::testing::Test {
     mndTransSetCb(pTrans, TRANS_START_FUNC_TEST, TRANS_STOP_FUNC_TEST, param, strlen(param) + 1);
 
     if (pDb != NULL) {
-      mndTransSetDbInfo(pTrans, pDb);
+      mndTransSetDbName(pTrans, pDb->name);
     }
 
     int32_t code = mndTransPrepare(pMnode, pTrans);
@@ -201,7 +201,7 @@ class MndTestTrans2 : public ::testing::Test {
     }
 
     if (pDb != NULL) {
-      mndTransSetDbInfo(pTrans, pDb);
+      mndTransSetDbName(pTrans, pDb->name);
     }
 
     int32_t code = mndTransPrepare(pMnode, pTrans);
diff --git a/source/dnode/vnode/CMakeLists.txt b/source/dnode/vnode/CMakeLists.txt
index 17445b7abe..890b8d08ab 100644
--- a/source/dnode/vnode/CMakeLists.txt
+++ b/source/dnode/vnode/CMakeLists.txt
@@ -35,7 +35,6 @@ target_sources(
     "src/sma/smaTimeRange.c"
 
     # tsdb
-    # "src/tsdb/tsdbTDBImpl.c"
     "src/tsdb/tsdbCommit.c"
     "src/tsdb/tsdbCommit2.c"
     "src/tsdb/tsdbFile.c"
@@ -45,17 +44,18 @@ target_sources(
     "src/tsdb/tsdbMemTable2.c"
     "src/tsdb/tsdbRead.c"
     "src/tsdb/tsdbReadImpl.c"
-    # "src/tsdb/tsdbSma.c"
     "src/tsdb/tsdbWrite.c"
     "src/tsdb/tsdbSnapshot.c"
 
     # tq
     "src/tq/tq.c"
     "src/tq/tqExec.c"
-    "src/tq/tqCommit.c"
+    "src/tq/tqMeta.c"
+    "src/tq/tqRead.c"
     "src/tq/tqOffset.c"
     "src/tq/tqPush.c"
-    "src/tq/tqRead.c"
+    "src/tq/tqSink.c"
+    "src/tq/tqCommit.c"
 )
 target_include_directories(
     vnode
diff --git a/source/dnode/vnode/inc/vnode.h b/source/dnode/vnode/inc/vnode.h
index 64c4f24978..3e56ea75ad 100644
--- a/source/dnode/vnode/inc/vnode.h
+++ b/source/dnode/vnode/inc/vnode.h
@@ -68,6 +68,7 @@ void    vnodeGetInfo(SVnode *pVnode, const char **dbname, int32_t *vgId);
 int32_t vnodeSnapshotReaderOpen(SVnode *pVnode, SVSnapshotReader **ppReader, int64_t sver, int64_t ever);
 int32_t vnodeSnapshotReaderClose(SVSnapshotReader *pReader);
 int32_t vnodeSnapshotRead(SVSnapshotReader *pReader, const void **ppData, uint32_t *nData);
+int32_t vnodeProcessCreateTSma(SVnode *pVnode, void *pCont, uint32_t contLen);
 
 // meta
 typedef struct SMeta       SMeta;  // todo: remove
@@ -172,7 +173,9 @@ struct SVnodeCfg {
   bool     isHeap;
   bool     isWeak;
   int8_t   isTsma;
+  int8_t   isRsma;
   int8_t   hashMethod;
+  int8_t   standby;
   STsdbCfg tsdbCfg;
   SWalCfg  walCfg;
   SSyncCfg syncCfg;
diff --git a/source/dnode/vnode/src/inc/sma.h b/source/dnode/vnode/src/inc/sma.h
index 0601df61e7..03dd2ea66c 100644
--- a/source/dnode/vnode/src/inc/sma.h
+++ b/source/dnode/vnode/src/inc/sma.h
@@ -219,7 +219,7 @@ static int32_t  tdInitSmaEnv(SSma *pSma, int8_t smaType, const char *path, SDisk
 void *tdFreeRSmaInfo(SRSmaInfo *pInfo);
 
 int32_t tdProcessTSmaCreateImpl(SSma *pSma, int64_t version, const char *pMsg);
-int32_t tdUpdateExpiredWindowImpl(SSma *pSma, SSubmitReq *pMsg, int64_t version);
+int32_t tdUpdateExpiredWindowImpl(SSma *pSma, const SSubmitReq *pMsg, int64_t version);
 // TODO: This is the basic params, and should wrap the params to a queryHandle.
 int32_t tdGetTSmaDataImpl(SSma *pSma, char *pData, int64_t indexUid, TSKEY querySKey, int32_t nMaxResult);
 
@@ -227,4 +227,4 @@ int32_t tdGetTSmaDataImpl(SSma *pSma, char *pData, int64_t indexUid, TSKEY query
 }
 #endif
 
-#endif /*_TD_VNODE_SMA_H_*/
\ No newline at end of file
+#endif /*_TD_VNODE_SMA_H_*/
diff --git a/source/dnode/vnode/src/inc/tq.h b/source/dnode/vnode/src/inc/tq.h
index 34a7ff823a..56d86c26a0 100644
--- a/source/dnode/vnode/src/inc/tq.h
+++ b/source/dnode/vnode/src/inc/tq.h
@@ -66,33 +66,27 @@ struct STqReadHandle {
 // tqPush
 
 typedef struct {
-  int64_t        consumerId;
-  int32_t        epoch;
-  int32_t        skipLogNum;
-  int64_t        reqOffset;
-  SRpcHandleInfo info;
-  SRWLatch       lock;
-} STqPushHandle;
+  STaosQueue* queue;
+  STaosQall*  qall;
+  void*       qItem;
+} STqInputQ;
 
-#if 0
 typedef struct {
-  char    subKey[TSDB_SUBSCRIBE_KEY_LEN];
+  // msg info
   int64_t consumerId;
+  int64_t reqOffset;
+  int64_t processedVer;
   int32_t epoch;
-  int8_t  subType;
-  // int8_t        withTbName;
-  // int8_t        withSchema;
-  // int8_t        withTag;
-  char*         qmsg;
-  SHashObj*     pDropTbUid;
-  STqPushHandle pushHandle;
-  // SRWLatch        lock;
-  SWalReadHandle* pWalReader;
-  // task number should be the same with fetch thread
-  STqReadHandle* pExecReader[5];
-  qTaskInfo_t    task[5];
-} STqExec;
-#endif
+  int32_t skipLogNum;
+  // rpc info
+  int64_t        reqId;
+  SRpcHandleInfo rpcInfo;
+  // exec
+  int8_t    inputStatus;
+  int8_t    execStatus;
+  STqInputQ inputQ;
+  SRWLatch  lock;
+} STqPushHandle;
 
 // tqExec
 
@@ -154,20 +148,21 @@ typedef struct {
 
 static STqMgmt tqMgmt = {0};
 
-// init once
-int  tqInit();
-void tqCleanUp();
-
-// int32_t tEncodeSTqExec(SEncoder* pEncoder, const STqExec* pExec);
-// int32_t tDecodeSTqExec(SDecoder* pDecoder, STqExec* pExec);
-
-int32_t tEncodeSTqHandle(SEncoder* pEncoder, const STqHandle* pHandle);
-int32_t tDecodeSTqHandle(SDecoder* pDecoder, STqHandle* pHandle);
-
+// tqRead
 int64_t tqFetchLog(STQ* pTq, STqHandle* pHandle, int64_t* fetchOffset, SWalHead** pHeadWithCkSum);
 
+// tqExec
 int32_t tqDataExec(STQ* pTq, STqExecHandle* pExec, SSubmitReq* pReq, SMqDataBlkRsp* pRsp, int32_t workerId);
 
+// tqMeta
+int32_t tqMetaOpen(STQ* pTq);
+int32_t tqMetaClose(STQ* pTq);
+int32_t tqMetaSaveHandle(STQ* pTq, const char* key, const STqHandle* pHandle);
+int32_t tqMetaDeleteHandle(STQ* pTq, const char* key);
+
+// tqSink
+void tqTableSink(SStreamTask* pTask, void* vnode, int64_t ver, void* data);
+
 // tqOffset
 STqOffsetStore* STqOffsetOpen(STqOffsetCfg*);
 void            STqOffsetClose(STqOffsetStore*);
diff --git a/source/dnode/vnode/src/inc/tsdb.h b/source/dnode/vnode/src/inc/tsdb.h
index 2e4ff6a4ab..a62b4c4409 100644
--- a/source/dnode/vnode/src/inc/tsdb.h
+++ b/source/dnode/vnode/src/inc/tsdb.h
@@ -32,14 +32,27 @@ extern "C" {
 #define tsdbTrace(...) do { if (tsdbDebugFlag & DEBUG_TRACE) { taosPrintLog("TSDB ", DEBUG_TRACE, tsdbDebugFlag, __VA_ARGS__); }} while(0)
 // clang-format on
 
+typedef struct TSDBROW TSDBROW;
+typedef struct TSDBKEY TSDBKEY;
+typedef struct SDelOp  SDelOp;
+
+static int tsdbKeyCmprFn(const void *p1, const void *p2);
+
+// tsdbMemTable2.c ==============================================================================================
+typedef struct SMemTable SMemTable;
+
+int32_t tsdbMemTableCreate2(STsdb *pTsdb, SMemTable **ppMemTable);
+void    tsdbMemTableDestroy2(SMemTable *pMemTable);
+
 // tsdbMemTable ================
+typedef struct STsdbRow      STsdbRow;
 typedef struct STbData       STbData;
 typedef struct STsdbMemTable STsdbMemTable;
 typedef struct SMergeInfo    SMergeInfo;
 typedef struct STable        STable;
 
 int  tsdbMemTableCreate(STsdb *pTsdb, STsdbMemTable **ppMemTable);
-void tsdbMemTableDestroy(STsdb *pTsdb, STsdbMemTable *pMemTable);
+void tsdbMemTableDestroy(STsdbMemTable *pMemTable);
 int  tsdbLoadDataFromCache(STsdb *pTsdb, STable *pTable, SSkipListIterator *pIter, TSKEY maxKey, int maxRowsToRead,
                            SDataCols *pCols, TKEY *filterKeys, int nFilterKeys, bool keepDup, SMergeInfo *pMergeInfo);
 
@@ -845,6 +858,42 @@ static FORCE_INLINE int tsdbUnLockFS(STsdbFS *pFs) {
   return 0;
 }
 
+struct TSDBROW {
+  int64_t version;
+  STSRow2 tsRow;
+};
+
+struct TSDBKEY {
+  int64_t version;
+  TSKEY   ts;
+};
+
+struct SDelOp {
+  int64_t version;
+  TSKEY   sKey;  // included
+  TSKEY   eKey;  // included
+  SDelOp *pNext;
+};
+
+static FORCE_INLINE int tsdbKeyCmprFn(const void *p1, const void *p2) {
+  TSDBKEY *pKey1 = (TSDBKEY *)p1;
+  TSDBKEY *pKey2 = (TSDBKEY *)p2;
+
+  if (pKey1->ts < pKey2->ts) {
+    return -1;
+  } else if (pKey1->ts > pKey2->ts) {
+    return 1;
+  }
+
+  if (pKey1->version < pKey2->version) {
+    return -1;
+  } else if (pKey1->version > pKey2->version) {
+    return 1;
+  }
+
+  return 0;
+}
+
 #endif
 
 #ifdef __cplusplus
diff --git a/source/dnode/vnode/src/inc/vnd.h b/source/dnode/vnode/src/inc/vnd.h
index eb3382ac4c..a5907cf991 100644
--- a/source/dnode/vnode/src/inc/vnd.h
+++ b/source/dnode/vnode/src/inc/vnd.h
@@ -81,9 +81,10 @@ int32_t vnodeSyncCommit(SVnode* pVnode);
 int32_t vnodeAsyncCommit(SVnode* pVnode);
 
 // vnodeSync.c
-int32_t   vnodeSyncOpen(SVnode* pVnode, char* path);
-void      vnodeSyncStart(SVnode* pVnode);
-void      vnodeSyncClose(SVnode* pVnode);
+int32_t vnodeSyncOpen(SVnode* pVnode, char* path);
+void    vnodeSyncStart(SVnode* pVnode);
+void    vnodeSyncClose(SVnode* pVnode);
+void    vnodeSyncAlter(SVnode* pVnode, SRpcMsg* pMsg);
 
 #ifdef __cplusplus
 }
diff --git a/source/dnode/vnode/src/inc/vnodeInt.h b/source/dnode/vnode/src/inc/vnodeInt.h
index e3a0c94ccc..03c70b2601 100644
--- a/source/dnode/vnode/src/inc/vnodeInt.h
+++ b/source/dnode/vnode/src/inc/vnodeInt.h
@@ -125,6 +125,8 @@ int32_t      tsdbSnapshotReaderClose(STsdbSnapshotReader* pReader);
 int32_t      tsdbSnapshotRead(STsdbSnapshotReader* pReader, void** ppData, uint32_t* nData);
 
 // tq
+int     tqInit();
+void    tqCleanUp();
 STQ*    tqOpen(const char* path, SVnode* pVnode, SWal* pWal);
 void    tqClose(STQ*);
 int     tqPushMsg(STQ*, void* msg, int32_t msgLen, tmsg_t msgType, int64_t ver);
@@ -145,11 +147,11 @@ int32_t tqProcessTaskRecoverRsp(STQ* pTq, SRpcMsg* pMsg);
 int32_t smaOpen(SVnode* pVnode);
 int32_t smaClose(SSma* pSma);
 
-int32_t tdUpdateExpireWindow(SSma* pSma, SSubmitReq* pMsg, int64_t version);
+int32_t tdUpdateExpireWindow(SSma* pSma, const SSubmitReq* pMsg, int64_t version);
 int32_t tdProcessTSmaCreate(SSma* pSma, int64_t version, const char* msg);
 int32_t tdProcessTSmaInsert(SSma* pSma, int64_t indexUid, const char* msg);
 
-int32_t tdProcessRSmaCreate(SVnode *pVnode, SVCreateStbReq* pReq);
+int32_t tdProcessRSmaCreate(SVnode* pVnode, SVCreateStbReq* pReq);
 int32_t tdProcessRSmaSubmit(SSma* pSma, void* pMsg, int32_t inputType);
 int32_t tdFetchTbUidList(SSma* pSma, STbUidStore** ppStore, tb_uid_t suid, tb_uid_t uid);
 int32_t tdUpdateTbUidList(SSma* pSma, STbUidStore* pUidStore);
@@ -239,6 +241,8 @@ struct SVnode {
 #define VND_RSMA1(vnd)      ((vnd)->pSma->pRSmaTsdb1)
 #define VND_RSMA2(vnd)      ((vnd)->pSma->pRSmaTsdb2)
 #define VND_RETENTIONS(vnd) (&(vnd)->config.tsdbCfg.retentions)
+#define VND_IS_RSMA(v)      ((v)->config.isRsma == 1)
+#define VND_IS_TSMA(v)      ((v)->config.isTsma == 1)
 
 struct STbUidStore {
   tb_uid_t  suid;
@@ -271,11 +275,6 @@ struct SSma {
 #define SMA_RSMA_TSDB1(s) ((s)->pRSmaTsdb1)
 #define SMA_RSMA_TSDB2(s) ((s)->pRSmaTsdb2)
 
-static FORCE_INLINE bool vnodeIsRollup(SVnode* pVnode) {
-  SRetention* pRetention = &(pVnode->config.tsdbCfg.retentions[0]);
-  return (pRetention->freq > 0 && pRetention->keep > 0);
-}
-
 // sma
 void smaHandleRes(void* pVnode, int64_t smaId, const SArray* data);
 
diff --git a/source/dnode/vnode/src/meta/metaTable.c b/source/dnode/vnode/src/meta/metaTable.c
index 9dd1543f9c..a300741942 100644
--- a/source/dnode/vnode/src/meta/metaTable.c
+++ b/source/dnode/vnode/src/meta/metaTable.c
@@ -31,9 +31,9 @@ int metaCreateSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
   int         vLen = 0;
   const void *pKey = NULL;
   const void *pVal = NULL;
-  void *      pBuf = NULL;
+  void       *pBuf = NULL;
   int32_t     szBuf = 0;
-  void *      p = NULL;
+  void       *p = NULL;
   SMetaReader mr = {0};
 
   // validate req
@@ -87,7 +87,7 @@ int metaDropSTable(SMeta *pMeta, int64_t verison, SVDropStbReq *pReq) {
   }
 
   // drop all child tables
-  TBC *   pCtbIdxc = NULL;
+  TBC    *pCtbIdxc = NULL;
   SArray *pArray = taosArrayInit(8, sizeof(tb_uid_t));
 
   tdbTbcOpen(pMeta->pCtbIdx, &pCtbIdxc, &pMeta->txn);
@@ -142,8 +142,8 @@ _exit:
 int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
   SMetaEntry  oStbEntry = {0};
   SMetaEntry  nStbEntry = {0};
-  TBC *       pUidIdxc = NULL;
-  TBC *       pTbDbc = NULL;
+  TBC        *pUidIdxc = NULL;
+  TBC        *pTbDbc = NULL;
   const void *pData;
   int         nData;
   int64_t     oversion;
@@ -262,7 +262,7 @@ _err:
 }
 
 int metaDropTable(SMeta *pMeta, int64_t version, SVDropTbReq *pReq, SArray *tbUids) {
-  void *   pData = NULL;
+  void    *pData = NULL;
   int      nData = 0;
   int      rc = 0;
   tb_uid_t uid;
@@ -288,7 +288,7 @@ int metaDropTable(SMeta *pMeta, int64_t version, SVDropTbReq *pReq, SArray *tbUi
 }
 
 static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type) {
-  void *     pData = NULL;
+  void      *pData = NULL;
   int        nData = 0;
   int        rc = 0;
   int64_t    version;
@@ -324,14 +324,14 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type) {
 }
 
 static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterTbReq) {
-  void *          pVal = NULL;
+  void           *pVal = NULL;
   int             nVal = 0;
-  const void *    pData = NULL;
+  const void     *pData = NULL;
   int             nData = 0;
   int             ret = 0;
   tb_uid_t        uid;
   int64_t         oversion;
-  SSchema *       pColumn = NULL;
+  SSchema        *pColumn = NULL;
   SMetaEntry      entry = {0};
   SSchemaWrapper *pSchema;
   int             c;
@@ -479,7 +479,7 @@ _err:
 static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterTbReq) {
   SMetaEntry  ctbEntry = {0};
   SMetaEntry  stbEntry = {0};
-  void *      pVal = NULL;
+  void       *pVal = NULL;
   int         nVal = 0;
   int         ret;
   int         c;
@@ -510,7 +510,7 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA
   oversion = *(int64_t *)pData;
 
   // search table.db
-  TBC *    pTbDbc = NULL;
+  TBC     *pTbDbc = NULL;
   SDecoder dc1 = {0};
   SDecoder dc2 = {0};
 
@@ -534,7 +534,7 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA
   metaDecodeEntry(&dc2, &stbEntry);
 
   SSchemaWrapper *pTagSchema = &stbEntry.stbEntry.schemaTag;
-  SSchema *       pColumn = NULL;
+  SSchema        *pColumn = NULL;
   int32_t         iCol = 0;
   for (;;) {
     pColumn = NULL;
@@ -579,7 +579,7 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA
         if (IS_VAR_DATA_TYPE(pCol->type)) {
           val.pData = pAlterTbReq->pTagVal;
           val.nData = pAlterTbReq->nTagVal;
-        }else{
+        } else {
           memcpy(&val.i64, pAlterTbReq->pTagVal, pAlterTbReq->nTagVal);
         }
         taosArrayPush(pTagArray, &val);
@@ -649,8 +649,8 @@ int metaAlterTable(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq) {
 
 static int metaSaveToTbDb(SMeta *pMeta, const SMetaEntry *pME) {
   STbDbKey tbDbKey;
-  void *   pKey = NULL;
-  void *   pVal = NULL;
+  void    *pKey = NULL;
+  void    *pVal = NULL;
   int      kLen = 0;
   int      vLen = 0;
   SEncoder coder = {0};
@@ -732,7 +732,7 @@ static int metaUpdateCtbIdx(SMeta *pMeta, const SMetaEntry *pME) {
 }
 
 int metaCreateTagIdxKey(tb_uid_t suid, int32_t cid, const void *pTagData, int32_t nTagData, int8_t type, tb_uid_t uid,
-                               STagIdxKey **ppTagIdxKey, int32_t *nTagIdxKey) {
+                        STagIdxKey **ppTagIdxKey, int32_t *nTagIdxKey) {
   // int32_t nTagData = 0;
 
   // if (pTagData) {
@@ -765,11 +765,11 @@ static void metaDestroyTagIdxKey(STagIdxKey *pTagIdxKey) {
 }
 
 static int metaUpdateTagIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry) {
-  void *         pData = NULL;
+  void          *pData = NULL;
   int            nData = 0;
   STbDbKey       tbDbKey = {0};
   SMetaEntry     stbEntry = {0};
-  STagIdxKey *   pTagIdxKey = NULL;
+  STagIdxKey    *pTagIdxKey = NULL;
   int32_t        nTagIdxKey;
   const SSchema *pTagColumn;       // = &stbEntry.stbEntry.schema.pSchema[0];
   const void    *pTagData = NULL;  //
@@ -788,21 +788,20 @@ static int metaUpdateTagIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry) {
   pTagColumn = &stbEntry.stbEntry.schemaTag.pSchema[0];
 
   STagVal tagVal = {.cid = pTagColumn->colId};
-  if(pTagColumn->type != TSDB_DATA_TYPE_JSON){
+  if (pTagColumn->type != TSDB_DATA_TYPE_JSON) {
     tTagGet((const STag *)pCtbEntry->ctbEntry.pTags, &tagVal);
-    if(IS_VAR_DATA_TYPE(pTagColumn->type)){
+    if (IS_VAR_DATA_TYPE(pTagColumn->type)) {
       pTagData = tagVal.pData;
       nTagData = (int32_t)tagVal.nData;
-    }else{
+    } else {
       pTagData = &(tagVal.i64);
       nTagData = tDataTypes[pTagColumn->type].bytes;
     }
-  }else{
-    //pTagData = pCtbEntry->ctbEntry.pTags;
-    //nTagData = ((const STag *)pCtbEntry->ctbEntry.pTags)->len;
+  } else {
+    // pTagData = pCtbEntry->ctbEntry.pTags;
+    // nTagData = ((const STag *)pCtbEntry->ctbEntry.pTags)->len;
   }
 
-
   // update tag index
 #ifdef USE_INVERTED_INDEX
   tb_uid_t suid = pCtbEntry->ctbEntry.suid;
@@ -816,8 +815,8 @@ static int metaUpdateTagIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry) {
   int ret = indexPut((SIndex *)pMeta->pTagIvtIdx, tmGroup, tuid);
   indexMultiTermDestroy(tmGroup);
 #else
-  if (metaCreateTagIdxKey(pCtbEntry->ctbEntry.suid, pTagColumn->colId, pTagData, nTagData, pTagColumn->type, pCtbEntry->uid,
-                          &pTagIdxKey, &nTagIdxKey) < 0) {
+  if (metaCreateTagIdxKey(pCtbEntry->ctbEntry.suid, pTagColumn->colId, pTagData, nTagData, pTagColumn->type,
+                          pCtbEntry->uid, &pTagIdxKey, &nTagIdxKey) < 0) {
     return -1;
   }
   tdbTbInsert(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, NULL, 0, &pMeta->txn);
@@ -830,7 +829,7 @@ static int metaUpdateTagIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry) {
 
 static int metaSaveToSkmDb(SMeta *pMeta, const SMetaEntry *pME) {
   SEncoder              coder = {0};
-  void *                pVal = NULL;
+  void                 *pVal = NULL;
   int                   vLen = 0;
   int                   rcode = 0;
   SSkmDbKey             skmDbKey = {0};
diff --git a/source/dnode/vnode/src/sma/sma.c b/source/dnode/vnode/src/sma/sma.c
index 0e7ce385a1..7a2b6a2757 100644
--- a/source/dnode/vnode/src/sma/sma.c
+++ b/source/dnode/vnode/src/sma/sma.c
@@ -15,7 +15,6 @@
 
 #include "sma.h"
 
-
 // TODO: Who is responsible for resource allocate and release?
 int32_t tdProcessTSmaInsert(SSma* pSma, int64_t indexUid, const char* msg) {
   int32_t code = TSDB_CODE_SUCCESS;
@@ -37,7 +36,7 @@ int32_t tdProcessTSmaCreate(SSma* pSma, int64_t version, const char* msg) {
   return code;
 }
 
-int32_t tdUpdateExpireWindow(SSma* pSma, SSubmitReq* pMsg, int64_t version) {
+int32_t tdUpdateExpireWindow(SSma* pSma, const SSubmitReq* pMsg, int64_t version) {
   int32_t code = TSDB_CODE_SUCCESS;
   if ((code = tdUpdateExpiredWindowImpl(pSma, pMsg, version)) < 0) {
     smaWarn("vgId:%d update expired sma window failed since %s", SMA_VID(pSma), tstrerror(terrno));
diff --git a/source/dnode/vnode/src/sma/smaOpen.c b/source/dnode/vnode/src/sma/smaOpen.c
index 2a74fe78cb..dde6578054 100644
--- a/source/dnode/vnode/src/sma/smaOpen.c
+++ b/source/dnode/vnode/src/sma/smaOpen.c
@@ -104,7 +104,7 @@ int32_t smaOpen(SVnode *pVnode) {
   taosThreadMutexInit(&pSma->mutex, NULL);
   pSma->locked = false;
 
-  if (vnodeIsRollup(pVnode)) {
+  if (VND_IS_RSMA(pVnode)) {
     STsdbKeepCfg keepCfg = {0};
     for (int i = 0; i < TSDB_RETENTION_MAX; ++i) {
       if (i == TSDB_RETENTION_L0) {
diff --git a/source/dnode/vnode/src/sma/smaTimeRange.c b/source/dnode/vnode/src/sma/smaTimeRange.c
index f771e73c8a..f88afcaddf 100644
--- a/source/dnode/vnode/src/sma/smaTimeRange.c
+++ b/source/dnode/vnode/src/sma/smaTimeRange.c
@@ -932,7 +932,7 @@ static int32_t tdSetExpiredWindow(SSma *pSma, SHashObj *pItemsHash, int64_t inde
  * @param msg SSubmitReq
  * @return int32_t
  */
-int32_t tdUpdateExpiredWindowImpl(SSma *pSma, SSubmitReq *pMsg, int64_t version) {
+int32_t tdUpdateExpiredWindowImpl(SSma *pSma, const SSubmitReq *pMsg, int64_t version) {
   // no time-range-sma, just return success
   if (atomic_load_16(&SMA_TSMA_NUM(pSma)) <= 0) {
     smaTrace("vgId:%d not update expire window since no tSma", SMA_VID(pSma));
diff --git a/source/dnode/vnode/src/tq/tq.c b/source/dnode/vnode/src/tq/tq.c
index 4bce829b10..172caf8724 100644
--- a/source/dnode/vnode/src/tq/tq.c
+++ b/source/dnode/vnode/src/tq/tq.c
@@ -14,7 +14,6 @@
  */
 
 #include "tq.h"
-#include "tdbInt.h"
 
 int32_t tqInit() {
   int8_t old;
@@ -47,51 +46,6 @@ void tqCleanUp() {
   }
 }
 
-int tqExecKeyCompare(const void* pKey1, int32_t kLen1, const void* pKey2, int32_t kLen2) {
-  return strcmp(pKey1, pKey2);
-}
-
-int32_t tqStoreHandle(STQ* pTq, const char* key, const STqHandle* pHandle) {
-  int32_t code;
-  int32_t vlen;
-  tEncodeSize(tEncodeSTqHandle, pHandle, vlen, code);
-  ASSERT(code == 0);
-
-  void* buf = taosMemoryCalloc(1, vlen);
-  if (buf == NULL) {
-    ASSERT(0);
-  }
-
-  SEncoder encoder;
-  tEncoderInit(&encoder, buf, vlen);
-
-  if (tEncodeSTqHandle(&encoder, pHandle) < 0) {
-    ASSERT(0);
-  }
-
-  TXN txn;
-
-  if (tdbTxnOpen(&txn, 0, tdbDefaultMalloc, tdbDefaultFree, NULL, TDB_TXN_WRITE | TDB_TXN_READ_UNCOMMITTED) < 0) {
-    ASSERT(0);
-  }
-
-  if (tdbBegin(pTq->pMetaStore, &txn) < 0) {
-    ASSERT(0);
-  }
-
-  if (tdbTbUpsert(pTq->pExecStore, key, (int)strlen(key), buf, vlen, &txn) < 0) {
-    ASSERT(0);
-  }
-
-  if (tdbCommit(pTq->pMetaStore, &txn) < 0) {
-    ASSERT(0);
-  }
-
-  tEncoderClear(&encoder);
-  taosMemoryFree(buf);
-  return 0;
-}
-
 STQ* tqOpen(const char* path, SVnode* pVnode, SWal* pWal) {
   STQ* pTq = taosMemoryMalloc(sizeof(STQ));
   if (pTq == NULL) {
@@ -108,60 +62,7 @@ STQ* tqOpen(const char* path, SVnode* pVnode, SWal* pWal) {
 
   pTq->pushMgr = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_ENTRY_LOCK);
 
-  if (tdbOpen(path, 16 * 1024, 1, &pTq->pMetaStore) < 0) {
-    ASSERT(0);
-  }
-
-  if (tdbTbOpen("handles", -1, -1, tqExecKeyCompare, pTq->pMetaStore, &pTq->pExecStore) < 0) {
-    ASSERT(0);
-  }
-
-  TXN txn;
-
-  if (tdbTxnOpen(&txn, 0, tdbDefaultMalloc, tdbDefaultFree, NULL, 0) < 0) {
-    ASSERT(0);
-  }
-
-  TBC* pCur;
-  if (tdbTbcOpen(pTq->pExecStore, &pCur, &txn) < 0) {
-    ASSERT(0);
-  }
-
-  void* pKey;
-  int   kLen;
-  void* pVal;
-  int   vLen;
-
-  tdbTbcMoveToFirst(pCur);
-  SDecoder decoder;
-
-  while (tdbTbcNext(pCur, &pKey, &kLen, &pVal, &vLen) == 0) {
-    STqHandle handle;
-    tDecoderInit(&decoder, (uint8_t*)pVal, vLen);
-    tDecodeSTqHandle(&decoder, &handle);
-    handle.pWalReader = walOpenReadHandle(pTq->pVnode->pWal);
-    for (int32_t i = 0; i < 5; i++) {
-      handle.execHandle.pExecReader[i] = tqInitSubmitMsgScanner(pTq->pVnode->pMeta);
-    }
-    if (handle.execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
-      for (int32_t i = 0; i < 5; i++) {
-        SReadHandle reader = {
-            .reader = handle.execHandle.pExecReader[i],
-            .meta = pTq->pVnode->pMeta,
-            .pMsgCb = &pTq->pVnode->msgCb,
-        };
-        handle.execHandle.exec.execCol.task[i] =
-            qCreateStreamExecTaskInfo(handle.execHandle.exec.execCol.qmsg, &reader);
-        ASSERT(handle.execHandle.exec.execCol.task[i]);
-      }
-    } else {
-      handle.execHandle.exec.execDb.pFilterOutTbUid =
-          taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
-    }
-    taosHashPut(pTq->handles, pKey, kLen, &handle, sizeof(STqHandle));
-  }
-
-  if (tdbTxnClose(&txn) < 0) {
+  if (tqMetaOpen(pTq) < 0) {
     ASSERT(0);
   }
 
@@ -174,179 +75,16 @@ void tqClose(STQ* pTq) {
     taosHashCleanup(pTq->handles);
     taosHashCleanup(pTq->pStreamTasks);
     taosHashCleanup(pTq->pushMgr);
-    tdbClose(pTq->pMetaStore);
+    tqMetaClose(pTq);
     taosMemoryFree(pTq);
   }
   // TODO
 }
 
-int32_t tEncodeSTqHandle(SEncoder* pEncoder, const STqHandle* pHandle) {
-  if (tStartEncode(pEncoder) < 0) return -1;
-  if (tEncodeCStr(pEncoder, pHandle->subKey) < 0) return -1;
-  if (tEncodeI64(pEncoder, pHandle->consumerId) < 0) return -1;
-  if (tEncodeI32(pEncoder, pHandle->epoch) < 0) return -1;
-  if (tEncodeI8(pEncoder, pHandle->execHandle.subType) < 0) return -1;
-  if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
-    if (tEncodeCStr(pEncoder, pHandle->execHandle.exec.execCol.qmsg) < 0) return -1;
-  }
-  tEndEncode(pEncoder);
-  return pEncoder->pos;
-}
-
-int32_t tDecodeSTqHandle(SDecoder* pDecoder, STqHandle* pHandle) {
-  if (tStartDecode(pDecoder) < 0) return -1;
-  if (tDecodeCStrTo(pDecoder, pHandle->subKey) < 0) return -1;
-  if (tDecodeI64(pDecoder, &pHandle->consumerId) < 0) return -1;
-  if (tDecodeI32(pDecoder, &pHandle->epoch) < 0) return -1;
-  if (tDecodeI8(pDecoder, &pHandle->execHandle.subType) < 0) return -1;
-  if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
-    if (tDecodeCStrAlloc(pDecoder, &pHandle->execHandle.exec.execCol.qmsg) < 0) return -1;
-  }
-  tEndDecode(pDecoder);
-  return 0;
-}
-
-int32_t tqUpdateTbUidList(STQ* pTq, const SArray* tbUidList, bool isAdd) {
-  void* pIter = NULL;
-  while (1) {
-    pIter = taosHashIterate(pTq->handles, pIter);
-    if (pIter == NULL) break;
-    STqHandle* pExec = (STqHandle*)pIter;
-    if (pExec->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
-      for (int32_t i = 0; i < 5; i++) {
-        int32_t code = qUpdateQualifiedTableId(pExec->execHandle.exec.execCol.task[i], tbUidList, isAdd);
-        ASSERT(code == 0);
-      }
-    } else if (pExec->execHandle.subType == TOPIC_SUB_TYPE__DB) {
-      if (!isAdd) {
-        int32_t sz = taosArrayGetSize(tbUidList);
-        for (int32_t i = 0; i < sz; i++) {
-          int64_t tbUid = *(int64_t*)taosArrayGet(tbUidList, i);
-          taosHashPut(pExec->execHandle.exec.execDb.pFilterOutTbUid, &tbUid, sizeof(int64_t), NULL, 0);
-        }
-      }
-    } else {
-      // tq update id
-    }
-  }
-  while (1) {
-    pIter = taosHashIterate(pTq->pStreamTasks, pIter);
-    if (pIter == NULL) break;
-    SStreamTask* pTask = (SStreamTask*)pIter;
-    if (pTask->inputType == STREAM_INPUT__DATA_SUBMIT) {
-      int32_t code = qUpdateQualifiedTableId(pTask->exec.executor, tbUidList, isAdd);
-      ASSERT(code == 0);
-    }
-  }
-  return 0;
-}
-
-int32_t tqPushMsgNew(STQ* pTq, void* msg, int32_t msgLen, tmsg_t msgType, int64_t ver, SRpcHandleInfo handleInfo) {
-  if (msgType != TDMT_VND_SUBMIT) return 0;
-  void*       pIter = NULL;
-  STqHandle*  pHandle = NULL;
-  SSubmitReq* pReq = (SSubmitReq*)msg;
-  int32_t     workerId = 4;
-  int64_t     fetchOffset = ver;
-
-  while (1) {
-    pIter = taosHashIterate(pTq->pushMgr, pIter);
-    if (pIter == NULL) break;
-    pHandle = *(STqHandle**)pIter;
-
-    taosWLockLatch(&pHandle->pushHandle.lock);
-
-    /*SRpcHandleInfo* pInfo = atomic_load_ptr(&pHandle->pushHandle.pInfo);*/
-    /*ASSERT(pInfo);*/
-
-    SMqDataBlkRsp rsp = {0};
-    rsp.reqOffset = pHandle->pushHandle.reqOffset;
-    rsp.blockData = taosArrayInit(0, sizeof(void*));
-    rsp.blockDataLen = taosArrayInit(0, sizeof(int32_t));
-
-    if (msgType == TDMT_VND_SUBMIT) {
-      tqDataExec(pTq, &pHandle->execHandle, pReq, &rsp, workerId);
-    } else {
-      // TODO
-      ASSERT(0);
-    }
-
-    if (rsp.blockNum == 0) {
-      taosWUnLockLatch(&pHandle->pushHandle.lock);
-      continue;
-    }
-
-    ASSERT(taosArrayGetSize(rsp.blockData) == rsp.blockNum);
-    ASSERT(taosArrayGetSize(rsp.blockDataLen) == rsp.blockNum);
-
-    rsp.rspOffset = fetchOffset;
-
-    int32_t tlen = sizeof(SMqRspHead) + tEncodeSMqDataBlkRsp(NULL, &rsp);
-    void*   buf = rpcMallocCont(tlen);
-    if (buf == NULL) {
-      // todo free
-      return -1;
-    }
-
-    ((SMqRspHead*)buf)->mqMsgType = TMQ_MSG_TYPE__POLL_RSP;
-    ((SMqRspHead*)buf)->epoch = pHandle->pushHandle.epoch;
-    ((SMqRspHead*)buf)->consumerId = pHandle->pushHandle.consumerId;
-
-    void* abuf = POINTER_SHIFT(buf, sizeof(SMqRspHead));
-    tEncodeSMqDataBlkRsp(&abuf, &rsp);
-
-    SRpcMsg resp = {
-        .info = pHandle->pushHandle.info,
-        .pCont = buf,
-        .contLen = tlen,
-        .code = 0,
-    };
-    tmsgSendRsp(&resp);
-
-    /*atomic_store_ptr(&pHandle->pushHandle.pInfo, NULL);*/
-    memset(&pHandle->pushHandle.info, 0, sizeof(SRpcHandleInfo));
-    taosWUnLockLatch(&pHandle->pushHandle.lock);
-
-    tqDebug("vg %d offset %ld from consumer %ld (epoch %d) send rsp, block num: %d, reqOffset: %ld, rspOffset: %ld",
-            TD_VID(pTq->pVnode), fetchOffset, pHandle->pushHandle.consumerId, pHandle->pushHandle.epoch, rsp.blockNum,
-            rsp.reqOffset, rsp.rspOffset);
-
-    // TODO destroy
-    taosArrayDestroy(rsp.blockData);
-    taosArrayDestroy(rsp.blockDataLen);
-  }
-
-  return 0;
-}
-
-int tqPushMsg(STQ* pTq, void* msg, int32_t msgLen, tmsg_t msgType, int64_t ver) {
-  if (msgType == TDMT_VND_SUBMIT) {
-    if (taosHashGetSize(pTq->pStreamTasks) == 0) return 0;
-
-    if (tdUpdateExpireWindow(pTq->pVnode->pSma, msg, ver) != 0) {
-      // TODO handle sma error
-    }
-    void* data = taosMemoryMalloc(msgLen);
-    if (data == NULL) {
-      return -1;
-    }
-    memcpy(data, msg, msgLen);
-
-    tqProcessStreamTrigger(pTq, data);
-  }
-
-  return 0;
-}
-
-int tqCommit(STQ* pTq) {
-  // do nothing
-  return 0;
-}
-
 int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
   SMqPollReq* pReq = pMsg->pCont;
   int64_t     consumerId = pReq->consumerId;
-  int64_t     waitTime = pReq->timeout;
+  int64_t     timeout = pReq->timeout;
   int32_t     reqEpoch = pReq->epoch;
   int64_t     fetchOffset;
 
@@ -389,20 +127,18 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
   }
   if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
     rsp.withSchema = false;
-
     rsp.withTag = false;
   } else {
     rsp.withSchema = true;
-    rsp.blockSchema = taosArrayInit(0, sizeof(void*));
-
     rsp.withTag = false;
+    rsp.blockSchema = taosArrayInit(0, sizeof(void*));
   }
 
   while (1) {
     consumerEpoch = atomic_load_32(&pHandle->epoch);
     if (consumerEpoch > reqEpoch) {
-      tqDebug("tmq poll: consumer %ld (epoch %d) vg %d offset %ld, found new consumer epoch %d discard req epoch %d",
-              consumerId, pReq->epoch, TD_VID(pTq->pVnode), fetchOffset, consumerEpoch, reqEpoch);
+      tqWarn("tmq poll: consumer %ld (epoch %d) vg %d offset %ld, found new consumer epoch %d, discard req epoch %d",
+             consumerId, pReq->epoch, TD_VID(pTq->pVnode), fetchOffset, consumerEpoch, reqEpoch);
       break;
     }
 
@@ -413,27 +149,6 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
 
     SWalReadHead* pHead = &pHeadWithCkSum->head;
 
-#if 0
-      // add to pushMgr
-      taosWLockLatch(&pExec->pushHandle.lock);
-
-      pExec->pushHandle.consumerId = consumerId;
-      pExec->pushHandle.epoch = reqEpoch;
-      pExec->pushHandle.reqOffset = rsp.reqOffset;
-      pExec->pushHandle.skipLogNum = rsp.skipLogNum;
-      pExec->pushHandle.handle = pMsg;
-
-      taosWUnLockLatch(&pExec->pushHandle.lock);
-
-      // TODO add timer
-
-      // TODO: the pointer will always be valid?
-      taosHashPut(pTq->pushMgr, &consumerId, sizeof(int64_t), &pExec, sizeof(void*));
-      taosArrayDestroy(rsp.blockData);
-      taosArrayDestroy(rsp.blockDataLen);
-      return 0;
-#endif
-
     tqDebug("tmq poll: consumer %ld (epoch %d) iter log, vg %d offset %ld msgType %d", consumerId, pReq->epoch,
             TD_VID(pTq->pVnode), fetchOffset, pHead->msgType);
 
@@ -508,24 +223,9 @@ int32_t tqProcessVgDeleteReq(STQ* pTq, char* msg, int32_t msgLen) {
   int32_t code = taosHashRemove(pTq->handles, pReq->subKey, strlen(pReq->subKey));
   ASSERT(code == 0);
 
-  TXN txn;
-
-  if (tdbTxnOpen(&txn, 0, tdbDefaultMalloc, tdbDefaultFree, NULL, TDB_TXN_WRITE | TDB_TXN_READ_UNCOMMITTED) < 0) {
+  if (tqMetaDeleteHandle(pTq, pReq->subKey) < 0) {
     ASSERT(0);
   }
-
-  if (tdbBegin(pTq->pMetaStore, &txn) < 0) {
-    ASSERT(0);
-  }
-
-  if (tdbTbDelete(pTq->pExecStore, pReq->subKey, (int)strlen(pReq->subKey), &txn) < 0) {
-    /*ASSERT(0);*/
-  }
-
-  if (tdbCommit(pTq->pMetaStore, &txn) < 0) {
-    ASSERT(0);
-  }
-
   return 0;
 }
 
@@ -583,30 +283,12 @@ int32_t tqProcessVgChangeReq(STQ* pTq, char* msg, int32_t msgLen) {
     atomic_add_fetch_32(&pHandle->epoch, 1);
   }
 
-  if (tqStoreHandle(pTq, req.subKey, pHandle) < 0) {
+  if (tqMetaSaveHandle(pTq, req.subKey, pHandle) < 0) {
     // TODO
   }
   return 0;
 }
 
-void tqTableSink(SStreamTask* pTask, void* vnode, int64_t ver, void* data) {
-  const SArray* pRes = (const SArray*)data;
-  SVnode*       pVnode = (SVnode*)vnode;
-
-  ASSERT(pTask->tbSink.pTSchema);
-  SSubmitReq* pReq = tdBlockToSubmit(pRes, pTask->tbSink.pTSchema, true, pTask->tbSink.stbUid,
-                                     pTask->tbSink.stbFullName, pVnode->config.vgId);
-  /*tPrintFixedSchemaSubmitReq(pReq, pTask->tbSink.pTSchema);*/
-  // build write msg
-  SRpcMsg msg = {
-      .msgType = TDMT_VND_SUBMIT,
-      .pCont = pReq,
-      .contLen = ntohl(pReq->length),
-  };
-
-  ASSERT(tmsgPutToQueue(&pVnode->msgCb, WRITE_QUEUE, &msg) == 0);
-}
-
 int32_t tqProcessTaskDeploy(STQ* pTq, char* msg, int32_t msgLen) {
   SStreamTask* pTask = taosMemoryCalloc(1, sizeof(SStreamTask));
   if (pTask == NULL) {
@@ -697,9 +379,11 @@ int32_t tqProcessStreamTrigger(STQ* pTq, SSubmitReq* pReq) {
         continue;
       }
 
-      streamDataSubmitRefInc(pSubmit);
-      SStreamDataSubmit* pSubmitClone = taosAllocateQitem(sizeof(SStreamDataSubmit), DEF_QITEM);
-      memcpy(pSubmitClone, pSubmit, sizeof(SStreamDataSubmit));
+      SStreamDataSubmit* pSubmitClone = streamSubmitRefClone(pSubmit);
+      if (pSubmitClone == NULL) {
+        atomic_store_8(&pTask->inputStatus, TASK_INPUT_STATUS__FAILED);
+        continue;
+      }
       taosWriteQitem(pTask->inputQ, pSubmitClone);
 
       int8_t execStatus = atomic_load_8(&pTask->status);
diff --git a/source/dnode/vnode/src/tq/tqCommit.c b/source/dnode/vnode/src/tq/tqCommit.c
index e31566f3fa..7b116bff2e 100644
--- a/source/dnode/vnode/src/tq/tqCommit.c
+++ b/source/dnode/vnode/src/tq/tqCommit.c
@@ -14,3 +14,8 @@
  */
 
 #include "tq.h"
+
+int tqCommit(STQ* pTq) {
+  // do nothing
+  return 0;
+}
diff --git a/source/dnode/vnode/src/tq/tqMeta.c b/source/dnode/vnode/src/tq/tqMeta.c
index f2f48bbc8a..9447c4007b 100644
--- a/source/dnode/vnode/src/tq/tqMeta.c
+++ b/source/dnode/vnode/src/tq/tqMeta.c
@@ -12,3 +12,163 @@
  * 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 "tdbInt.h"
+#include "tq.h"
+
+static int32_t tEncodeSTqHandle(SEncoder* pEncoder, const STqHandle* pHandle) {
+  if (tStartEncode(pEncoder) < 0) return -1;
+  if (tEncodeCStr(pEncoder, pHandle->subKey) < 0) return -1;
+  if (tEncodeI64(pEncoder, pHandle->consumerId) < 0) return -1;
+  if (tEncodeI32(pEncoder, pHandle->epoch) < 0) return -1;
+  if (tEncodeI8(pEncoder, pHandle->execHandle.subType) < 0) return -1;
+  if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
+    if (tEncodeCStr(pEncoder, pHandle->execHandle.exec.execCol.qmsg) < 0) return -1;
+  }
+  tEndEncode(pEncoder);
+  return pEncoder->pos;
+}
+
+static int32_t tDecodeSTqHandle(SDecoder* pDecoder, STqHandle* pHandle) {
+  if (tStartDecode(pDecoder) < 0) return -1;
+  if (tDecodeCStrTo(pDecoder, pHandle->subKey) < 0) return -1;
+  if (tDecodeI64(pDecoder, &pHandle->consumerId) < 0) return -1;
+  if (tDecodeI32(pDecoder, &pHandle->epoch) < 0) return -1;
+  if (tDecodeI8(pDecoder, &pHandle->execHandle.subType) < 0) return -1;
+  if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
+    if (tDecodeCStrAlloc(pDecoder, &pHandle->execHandle.exec.execCol.qmsg) < 0) return -1;
+  }
+  tEndDecode(pDecoder);
+  return 0;
+}
+
+int tqExecKeyCompare(const void* pKey1, int32_t kLen1, const void* pKey2, int32_t kLen2) {
+  return strcmp(pKey1, pKey2);
+}
+
+int32_t tqMetaOpen(STQ* pTq) {
+  if (tdbOpen(pTq->path, 16 * 1024, 1, &pTq->pMetaStore) < 0) {
+    ASSERT(0);
+  }
+
+  if (tdbTbOpen("handles", -1, -1, tqExecKeyCompare, pTq->pMetaStore, &pTq->pExecStore) < 0) {
+    ASSERT(0);
+  }
+
+  TXN txn;
+
+  if (tdbTxnOpen(&txn, 0, tdbDefaultMalloc, tdbDefaultFree, NULL, 0) < 0) {
+    ASSERT(0);
+  }
+
+  TBC* pCur;
+  if (tdbTbcOpen(pTq->pExecStore, &pCur, &txn) < 0) {
+    ASSERT(0);
+  }
+
+  void* pKey;
+  int   kLen;
+  void* pVal;
+  int   vLen;
+
+  tdbTbcMoveToFirst(pCur);
+  SDecoder decoder;
+
+  while (tdbTbcNext(pCur, &pKey, &kLen, &pVal, &vLen) == 0) {
+    STqHandle handle;
+    tDecoderInit(&decoder, (uint8_t*)pVal, vLen);
+    tDecodeSTqHandle(&decoder, &handle);
+    handle.pWalReader = walOpenReadHandle(pTq->pVnode->pWal);
+    for (int32_t i = 0; i < 5; i++) {
+      handle.execHandle.pExecReader[i] = tqInitSubmitMsgScanner(pTq->pVnode->pMeta);
+    }
+    if (handle.execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
+      for (int32_t i = 0; i < 5; i++) {
+        SReadHandle reader = {
+            .reader = handle.execHandle.pExecReader[i],
+            .meta = pTq->pVnode->pMeta,
+            .pMsgCb = &pTq->pVnode->msgCb,
+        };
+        handle.execHandle.exec.execCol.task[i] =
+            qCreateStreamExecTaskInfo(handle.execHandle.exec.execCol.qmsg, &reader);
+        ASSERT(handle.execHandle.exec.execCol.task[i]);
+      }
+    } else {
+      handle.execHandle.exec.execDb.pFilterOutTbUid =
+          taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
+    }
+    taosHashPut(pTq->handles, pKey, kLen, &handle, sizeof(STqHandle));
+  }
+
+  if (tdbTxnClose(&txn) < 0) {
+    ASSERT(0);
+  }
+  return 0;
+}
+
+int32_t tqMetaClose(STQ* pTq) {
+  tdbClose(pTq->pMetaStore);
+  return 0;
+}
+
+int32_t tqMetaSaveHandle(STQ* pTq, const char* key, const STqHandle* pHandle) {
+  int32_t code;
+  int32_t vlen;
+  tEncodeSize(tEncodeSTqHandle, pHandle, vlen, code);
+  ASSERT(code == 0);
+
+  void* buf = taosMemoryCalloc(1, vlen);
+  if (buf == NULL) {
+    ASSERT(0);
+  }
+
+  SEncoder encoder;
+  tEncoderInit(&encoder, buf, vlen);
+
+  if (tEncodeSTqHandle(&encoder, pHandle) < 0) {
+    ASSERT(0);
+  }
+
+  TXN txn;
+
+  if (tdbTxnOpen(&txn, 0, tdbDefaultMalloc, tdbDefaultFree, NULL, TDB_TXN_WRITE | TDB_TXN_READ_UNCOMMITTED) < 0) {
+    ASSERT(0);
+  }
+
+  if (tdbBegin(pTq->pMetaStore, &txn) < 0) {
+    ASSERT(0);
+  }
+
+  if (tdbTbUpsert(pTq->pExecStore, key, (int)strlen(key), buf, vlen, &txn) < 0) {
+    ASSERT(0);
+  }
+
+  if (tdbCommit(pTq->pMetaStore, &txn) < 0) {
+    ASSERT(0);
+  }
+
+  tEncoderClear(&encoder);
+  taosMemoryFree(buf);
+  return 0;
+}
+
+int32_t tqMetaDeleteHandle(STQ* pTq, const char* key) {
+  TXN txn;
+
+  if (tdbTxnOpen(&txn, 0, tdbDefaultMalloc, tdbDefaultFree, NULL, TDB_TXN_WRITE | TDB_TXN_READ_UNCOMMITTED) < 0) {
+    ASSERT(0);
+  }
+
+  if (tdbBegin(pTq->pMetaStore, &txn) < 0) {
+    ASSERT(0);
+  }
+
+  if (tdbTbDelete(pTq->pExecStore, key, (int)strlen(key), &txn) < 0) {
+    /*ASSERT(0);*/
+  }
+
+  if (tdbCommit(pTq->pMetaStore, &txn) < 0) {
+    ASSERT(0);
+  }
+
+  return 0;
+}
diff --git a/source/dnode/vnode/src/tq/tqPush.c b/source/dnode/vnode/src/tq/tqPush.c
index f2f48bbc8a..f23a14472c 100644
--- a/source/dnode/vnode/src/tq/tqPush.c
+++ b/source/dnode/vnode/src/tq/tqPush.c
@@ -12,3 +12,185 @@
  * 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 "tq.h"
+
+int32_t tqExecFromInputQ(STQ* pTq, STqHandle* pHandle) {
+  // 1. guard and set status executing
+  // 2. check processedVer
+  // 2.1. if not missed, get msg from queue
+  // 2.2. if missed, scan wal
+  //
+  // 3. exec, after each success, update processed ver
+  // first run
+  // set exec status closing
+  // second run
+  // set exec status idle
+  //
+  // 4. if get result
+  // 4.1 set exec input status blocked and exec status idle
+  // 4.2 rpc send
+  // 4.3 clear rpc info
+  return 0;
+}
+
+int32_t tqOpenPushHandle(STQ* pTq, STqHandle* pHandle) {
+  memset(&pHandle->pushHandle, 0, sizeof(STqPushHandle));
+  pHandle->pushHandle.inputQ.queue = taosOpenQueue();
+  pHandle->pushHandle.inputQ.qall = taosAllocateQall();
+  if (pHandle->pushHandle.inputQ.queue == NULL || pHandle->pushHandle.inputQ.qall == NULL) {
+    if (pHandle->pushHandle.inputQ.queue) {
+      taosCloseQueue(pHandle->pushHandle.inputQ.queue);
+    }
+    if (pHandle->pushHandle.inputQ.qall) {
+      taosFreeQall(pHandle->pushHandle.inputQ.qall);
+    }
+    return -1;
+  }
+  return 0;
+}
+
+void tqPreparePush(STQ* pTq, STqHandle* pHandle, int64_t reqId, const SRpcHandleInfo* pInfo, int64_t processedVer) {
+  memcpy(&pHandle->pushHandle.rpcInfo, pInfo, sizeof(SRpcHandleInfo));
+  atomic_store_64(&pHandle->pushHandle.reqId, reqId);
+  atomic_store_64(&pHandle->pushHandle.processedVer, processedVer);
+  atomic_store_8(&pHandle->pushHandle.inputStatus, TASK_INPUT_STATUS__NORMAL);
+  // set timeout timer
+}
+
+int32_t tqEnqueue(STqHandle* pHandle, SStreamDataSubmit* pSubmit) {
+  int8_t inputStatus = atomic_load_8(&pHandle->pushHandle.inputStatus);
+  if (inputStatus == TASK_INPUT_STATUS__NORMAL) {
+    SStreamDataSubmit* pSubmitClone = streamSubmitRefClone(pSubmit);
+    if (pSubmitClone == NULL) {
+      return -1;
+    }
+    taosWriteQitem(pHandle->pushHandle.inputQ.queue, pSubmitClone);
+    return 0;
+  }
+  return -1;
+}
+
+int32_t tqSendExecReq(STQ* pTq, STqHandle* pHandle) {
+  //
+  return 0;
+}
+
+int32_t tqEnqueueAll(STQ* pTq, SSubmitReq* pReq) {
+  void*              pIter = NULL;
+  SStreamDataSubmit* pSubmit = streamDataSubmitNew(pReq);
+  if (pSubmit == NULL) {
+    return -1;
+  }
+
+  while (1) {
+    pIter = taosHashIterate(pTq->handles, pIter);
+    if (pIter == NULL) break;
+    STqHandle* pHandle = (STqHandle*)pIter;
+    if (tqEnqueue(pHandle, pSubmit) < 0) {
+      continue;
+    }
+    int8_t execStatus = atomic_load_8(&pHandle->pushHandle.execStatus);
+    if (execStatus == TASK_STATUS__IDLE || execStatus == TASK_STATUS__CLOSING) {
+      tqSendExecReq(pTq, pHandle);
+    }
+  }
+
+  streamDataSubmitRefDec(pSubmit);
+
+  return 0;
+}
+
+int32_t tqPushMsgNew(STQ* pTq, void* msg, int32_t msgLen, tmsg_t msgType, int64_t ver, SRpcHandleInfo handleInfo) {
+  if (msgType != TDMT_VND_SUBMIT) return 0;
+  void*       pIter = NULL;
+  STqHandle*  pHandle = NULL;
+  SSubmitReq* pReq = (SSubmitReq*)msg;
+  int32_t     workerId = 4;
+  int64_t     fetchOffset = ver;
+
+  while (1) {
+    pIter = taosHashIterate(pTq->pushMgr, pIter);
+    if (pIter == NULL) break;
+    pHandle = *(STqHandle**)pIter;
+
+    taosWLockLatch(&pHandle->pushHandle.lock);
+
+    SMqDataBlkRsp rsp = {0};
+    rsp.reqOffset = pHandle->pushHandle.reqOffset;
+    rsp.blockData = taosArrayInit(0, sizeof(void*));
+    rsp.blockDataLen = taosArrayInit(0, sizeof(int32_t));
+
+    if (msgType == TDMT_VND_SUBMIT) {
+      tqDataExec(pTq, &pHandle->execHandle, pReq, &rsp, workerId);
+    } else {
+      // TODO
+      ASSERT(0);
+    }
+
+    if (rsp.blockNum == 0) {
+      taosWUnLockLatch(&pHandle->pushHandle.lock);
+      continue;
+    }
+
+    ASSERT(taosArrayGetSize(rsp.blockData) == rsp.blockNum);
+    ASSERT(taosArrayGetSize(rsp.blockDataLen) == rsp.blockNum);
+
+    rsp.rspOffset = fetchOffset;
+
+    int32_t tlen = sizeof(SMqRspHead) + tEncodeSMqDataBlkRsp(NULL, &rsp);
+    void*   buf = rpcMallocCont(tlen);
+    if (buf == NULL) {
+      // todo free
+      return -1;
+    }
+
+    ((SMqRspHead*)buf)->mqMsgType = TMQ_MSG_TYPE__POLL_RSP;
+    ((SMqRspHead*)buf)->epoch = pHandle->pushHandle.epoch;
+    ((SMqRspHead*)buf)->consumerId = pHandle->pushHandle.consumerId;
+
+    void* abuf = POINTER_SHIFT(buf, sizeof(SMqRspHead));
+    tEncodeSMqDataBlkRsp(&abuf, &rsp);
+
+    SRpcMsg resp = {
+        .info = pHandle->pushHandle.rpcInfo,
+        .pCont = buf,
+        .contLen = tlen,
+        .code = 0,
+    };
+    tmsgSendRsp(&resp);
+
+    memset(&pHandle->pushHandle.rpcInfo, 0, sizeof(SRpcHandleInfo));
+    taosWUnLockLatch(&pHandle->pushHandle.lock);
+
+    tqDebug("vg %d offset %ld from consumer %ld (epoch %d) send rsp, block num: %d, reqOffset: %ld, rspOffset: %ld",
+            TD_VID(pTq->pVnode), fetchOffset, pHandle->pushHandle.consumerId, pHandle->pushHandle.epoch, rsp.blockNum,
+            rsp.reqOffset, rsp.rspOffset);
+
+    // TODO destroy
+    taosArrayDestroy(rsp.blockData);
+    taosArrayDestroy(rsp.blockDataLen);
+  }
+
+  return 0;
+}
+
+int tqPushMsg(STQ* pTq, void* msg, int32_t msgLen, tmsg_t msgType, int64_t ver) {
+  if (msgType == TDMT_VND_SUBMIT) {
+    if (taosHashGetSize(pTq->pStreamTasks) == 0) return 0;
+
+    if (tdUpdateExpireWindow(pTq->pVnode->pSma, msg, ver) != 0) {
+      // TODO handle sma error
+    }
+    void* data = taosMemoryMalloc(msgLen);
+    if (data == NULL) {
+      return -1;
+    }
+    memcpy(data, msg, msgLen);
+
+    tqProcessStreamTrigger(pTq, data);
+  }
+
+  return 0;
+}
+
diff --git a/source/dnode/vnode/src/tq/tqRead.c b/source/dnode/vnode/src/tq/tqRead.c
index 1f5d3b7f53..8909a00c72 100644
--- a/source/dnode/vnode/src/tq/tqRead.c
+++ b/source/dnode/vnode/src/tq/tqRead.c
@@ -298,3 +298,38 @@ int tqReadHandleRemoveTbUidList(STqReadHandle* pHandle, const SArray* tbUidList)
 
   return 0;
 }
+
+int32_t tqUpdateTbUidList(STQ* pTq, const SArray* tbUidList, bool isAdd) {
+  void* pIter = NULL;
+  while (1) {
+    pIter = taosHashIterate(pTq->handles, pIter);
+    if (pIter == NULL) break;
+    STqHandle* pExec = (STqHandle*)pIter;
+    if (pExec->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
+      for (int32_t i = 0; i < 5; i++) {
+        int32_t code = qUpdateQualifiedTableId(pExec->execHandle.exec.execCol.task[i], tbUidList, isAdd);
+        ASSERT(code == 0);
+      }
+    } else if (pExec->execHandle.subType == TOPIC_SUB_TYPE__DB) {
+      if (!isAdd) {
+        int32_t sz = taosArrayGetSize(tbUidList);
+        for (int32_t i = 0; i < sz; i++) {
+          int64_t tbUid = *(int64_t*)taosArrayGet(tbUidList, i);
+          taosHashPut(pExec->execHandle.exec.execDb.pFilterOutTbUid, &tbUid, sizeof(int64_t), NULL, 0);
+        }
+      }
+    } else {
+      // tq update id
+    }
+  }
+  while (1) {
+    pIter = taosHashIterate(pTq->pStreamTasks, pIter);
+    if (pIter == NULL) break;
+    SStreamTask* pTask = (SStreamTask*)pIter;
+    if (pTask->inputType == STREAM_INPUT__DATA_SUBMIT) {
+      int32_t code = qUpdateQualifiedTableId(pTask->exec.executor, tbUidList, isAdd);
+      ASSERT(code == 0);
+    }
+  }
+  return 0;
+}
diff --git a/source/dnode/vnode/src/tq/tqSink.c b/source/dnode/vnode/src/tq/tqSink.c
new file mode 100644
index 0000000000..5c0bf971fb
--- /dev/null
+++ b/source/dnode/vnode/src/tq/tqSink.c
@@ -0,0 +1,34 @@
+/*
+ * 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 "tq.h"
+
+void tqTableSink(SStreamTask* pTask, void* vnode, int64_t ver, void* data) {
+  const SArray* pRes = (const SArray*)data;
+  SVnode*       pVnode = (SVnode*)vnode;
+
+  ASSERT(pTask->tbSink.pTSchema);
+  SSubmitReq* pReq = tdBlockToSubmit(pRes, pTask->tbSink.pTSchema, true, pTask->tbSink.stbUid,
+                                     pTask->tbSink.stbFullName, pVnode->config.vgId);
+  /*tPrintFixedSchemaSubmitReq(pReq, pTask->tbSink.pTSchema);*/
+  // build write msg
+  SRpcMsg msg = {
+      .msgType = TDMT_VND_SUBMIT,
+      .pCont = pReq,
+      .contLen = ntohl(pReq->length),
+  };
+
+  ASSERT(tmsgPutToQueue(&pVnode->msgCb, WRITE_QUEUE, &msg) == 0);
+}
diff --git a/source/dnode/vnode/src/tsdb/tsdbCommit.c b/source/dnode/vnode/src/tsdb/tsdbCommit.c
index 88d8ee9f92..0a85cb4638 100644
--- a/source/dnode/vnode/src/tsdb/tsdbCommit.c
+++ b/source/dnode/vnode/src/tsdb/tsdbCommit.c
@@ -238,7 +238,7 @@ static void tsdbStartCommit(STsdb *pRepo) {
 
 static void tsdbEndCommit(STsdb *pTsdb, int eno) {
   tsdbEndFSTxn(pTsdb);
-  tsdbMemTableDestroy(pTsdb, pTsdb->imem);
+  tsdbMemTableDestroy(pTsdb->imem);
   pTsdb->imem = NULL;
   tsdbInfo("vgId:%d commit over, %s", REPO_ID(pTsdb), (eno == TSDB_CODE_SUCCESS) ? "succeed" : "failed");
 }
diff --git a/source/dnode/vnode/src/tsdb/tsdbDelete.c b/source/dnode/vnode/src/tsdb/tsdbDelete.c
new file mode 100644
index 0000000000..6dea4a4e57
--- /dev/null
+++ b/source/dnode/vnode/src/tsdb/tsdbDelete.c
@@ -0,0 +1,14 @@
+/*
+ * 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/>.
+ */
\ No newline at end of file
diff --git a/source/dnode/vnode/src/tsdb/tsdbMemTable.c b/source/dnode/vnode/src/tsdb/tsdbMemTable.c
index 9b9a431b50..350e723541 100644
--- a/source/dnode/vnode/src/tsdb/tsdbMemTable.c
+++ b/source/dnode/vnode/src/tsdb/tsdbMemTable.c
@@ -60,7 +60,7 @@ int tsdbMemTableCreate(STsdb *pTsdb, STsdbMemTable **ppMemTable) {
   return 0;
 }
 
-void tsdbMemTableDestroy(STsdb *pTsdb, STsdbMemTable *pMemTable) {
+void tsdbMemTableDestroy(STsdbMemTable *pMemTable) {
   if (pMemTable) {
     taosHashCleanup(pMemTable->pHashIdx);
     SSkipListIterator *pIter = tSkipListCreateIter(pMemTable->pSlIdx);
@@ -142,69 +142,6 @@ int tsdbLoadDataFromCache(STsdb *pTsdb, STable *pTable, SSkipListIterator *pIter
       } else {
         fKey = tdGetKey(filterKeys[filterIter]);
       }
-#if 0
-    } else if (fKey > rowKey) {
-      if (isRowDel) {
-        pMergeInfo->rowsDeleteFailed++;
-      } else {
-        if (pMergeInfo->rowsInserted - pMergeInfo->rowsDeleteSucceed >= maxRowsToRead) break;
-        if (pCols && pMergeInfo->nOperations >= pCols->maxPoints) break;
-
-        pMergeInfo->rowsInserted++;
-        pMergeInfo->nOperations++;
-        pMergeInfo->keyFirst = TMIN(pMergeInfo->keyFirst, rowKey);
-        pMergeInfo->keyLast = TMAX(pMergeInfo->keyLast, rowKey);
-        tsdbAppendTableRowToCols(pTable, pCols, &pSchema, row);
-      }
-
-      tSkipListIterNext(pIter);
-      row = tsdbNextIterRow(pIter);
-      if (row == NULL || TD_ROW_KEY(row) > maxKey) {
-        rowKey = INT64_MAX;
-        isRowDel = false;
-      } else {
-        rowKey = TD_ROW_KEY(row);
-        isRowDel = TD_ROW_IS_DELETED(row);
-      }
-    } else {
-      if (isRowDel) {
-        ASSERT(!keepDup);
-        if (pCols && pMergeInfo->nOperations >= pCols->maxPoints) break;
-        pMergeInfo->rowsDeleteSucceed++;
-        pMergeInfo->nOperations++;
-        tsdbAppendTableRowToCols(pTable, pCols, &pSchema, row);
-      } else {
-        if (keepDup) {
-          if (pCols && pMergeInfo->nOperations >= pCols->maxPoints) break;
-          pMergeInfo->rowsUpdated++;
-          pMergeInfo->nOperations++;
-          pMergeInfo->keyFirst = TMIN(pMergeInfo->keyFirst, rowKey);
-          pMergeInfo->keyLast = TMAX(pMergeInfo->keyLast, rowKey);
-          tsdbAppendTableRowToCols(pTable, pCols, &pSchema, row);
-        } else {
-          pMergeInfo->keyFirst = TMIN(pMergeInfo->keyFirst, fKey);
-          pMergeInfo->keyLast = TMAX(pMergeInfo->keyLast, fKey);
-        }
-      }
-
-      tSkipListIterNext(pIter);
-      row = tsdbNextIterRow(pIter);
-      if (row == NULL || TD_ROW_KEY(row) > maxKey) {
-        rowKey = INT64_MAX;
-        isRowDel = false;
-      } else {
-        rowKey = TD_ROW_KEY(row);
-        isRowDel = TD_ROW_IS_DELETED(row);
-      }
-
-      filterIter++;
-      if (filterIter >= nFilterKeys) {
-        fKey = INT64_MAX;
-      } else {
-        fKey = tdGetKey(filterKeys[filterIter]);
-      }
-    }
-#endif
 #if 1
     } else if (fKey > rowKey) {
       if (isRowDel) {
@@ -321,7 +258,7 @@ int tsdbInsertTableData(STsdb *pTsdb, SSubmitMsgIter *pMsgIter, SSubmitBlk *pBlo
     terrno = TSDB_CODE_PAR_TABLE_NOT_EXIST;
     return -1;
   }
-  if(pRsp->tblFName) strcat(pRsp->tblFName, mr.me.name);
+  if (pRsp->tblFName) strcat(pRsp->tblFName, mr.me.name);
 
   if (mr.me.type == TSDB_NORMAL_TABLE) {
     sverNew = mr.me.ntbEntry.schemaRow.version;
diff --git a/source/dnode/vnode/src/tsdb/tsdbMemTable2.c b/source/dnode/vnode/src/tsdb/tsdbMemTable2.c
index 025b2ab580..94c88a14ff 100644
--- a/source/dnode/vnode/src/tsdb/tsdbMemTable2.c
+++ b/source/dnode/vnode/src/tsdb/tsdbMemTable2.c
@@ -15,52 +15,308 @@
 
 #include "tsdb.h"
 
-typedef struct SMemTable          SMemTable;
-typedef struct SMemData           SMemData;
-typedef struct SMemSkipList       SMemSkipList;
-typedef struct SMemSkipListNode   SMemSkipListNode;
-typedef struct SMemSkipListCurosr SMemSkipListCurosr;
-
-#define SL_MAX_LEVEL 5
-
-struct SMemTable {
-  STsdb              *pTsdb;
-  TSKEY               minKey;
-  TSKEY               maxKey;
-  int64_t             minVer;
-  int64_t             maxVer;
-  int64_t             nRows;
-  int32_t             nHash;
-  int32_t             nBucket;
-  SMemData          **pBuckets;
-  SMemSkipListCurosr *pSlc;
-};
+typedef struct SMemData         SMemData;
+typedef struct SMemSkipList     SMemSkipList;
+typedef struct SMemSkipListNode SMemSkipListNode;
 
 struct SMemSkipListNode {
   int8_t            level;
-  SMemSkipListNode *forwards[1];  // Windows does not allow 0
+  SMemSkipListNode *forwards[0];
 };
 
 struct SMemSkipList {
-  uint32_t         seed;
-  int8_t           maxLevel;
-  int8_t           level;
-  int32_t          size;
-  SMemSkipListNode pHead[1];  // Windows does not allow 0
+  uint32_t          seed;
+  int32_t           size;
+  int8_t            maxLevel;
+  int8_t            level;
+  SMemSkipListNode *pHead;
+  SMemSkipListNode *pTail;
 };
 
 struct SMemData {
-  SMemData    *pHashNext;
   tb_uid_t     suid;
   tb_uid_t     uid;
-  TSKEY        minKey;
-  TSKEY        maxKey;
-  int64_t      minVer;
-  int64_t      maxVer;
-  int64_t      nRows;
+  TSDBKEY      minKey;
+  TSDBKEY      maxKey;
+  SDelOp      *delOpHead;
+  SDelOp      *delOpTail;
   SMemSkipList sl;
 };
 
+struct SMemTable {
+  STsdb  *pTsdb;
+  int32_t nRef;
+  TSDBKEY minKey;
+  TSDBKEY maxKey;
+  int64_t nRows;
+  SArray *pArray;  // SArray<SMemData>
+};
+
+#define SL_NODE_SIZE(l)        (sizeof(SMemSkipListNode) + sizeof(SMemSkipListNode *) * (l)*2)
+#define SL_NODE_HALF_SIZE(l)   (sizeof(SMemSkipListNode) + sizeof(SMemSkipListNode *) * (l))
+#define SL_NODE_FORWARD(n, l)  ((n)->forwards[l])
+#define SL_NODE_BACKWARD(n, l) ((n)->forwards[(n)->level + (l)])
+#define SL_NODE_DATA(n)        (&SL_NODE_BACKWARD(n, (n)->level))
+
+#define SL_HEAD_FORWARD(sl, l)  SL_NODE_FORWARD((sl)->pHead, l)
+#define SL_TAIL_BACKWARD(sl, l) SL_NODE_FORWARD((sl)->pTail, l)
+
+static int32_t tsdbGetOrCreateMemData(SMemTable *pMemTable, tb_uid_t suid, tb_uid_t uid, SMemData **ppMemData);
+static int     memDataPCmprFn(const void *p1, const void *p2);
+static int32_t tPutTSDBRow(uint8_t *p, TSDBROW *pRow);
+static int32_t tGetTSDBRow(uint8_t *p, TSDBROW *pRow);
+static int8_t  tsdbMemSkipListRandLevel(SMemSkipList *pSl);
+
+// SMemTable ==============================================
+int32_t tsdbMemTableCreate2(STsdb *pTsdb, SMemTable **ppMemTable) {
+  int32_t    code = 0;
+  SMemTable *pMemTable = NULL;
+
+  pMemTable = (SMemTable *)taosMemoryCalloc(1, sizeof(*pMemTable));
+  if (pMemTable == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _err;
+  }
+  pMemTable->pTsdb = pTsdb;
+  pMemTable->nRef = 1;
+  pMemTable->minKey = (TSDBKEY){.version = INT64_MAX, .ts = TSKEY_MAX};
+  pMemTable->maxKey = (TSDBKEY){.version = -1, .ts = TSKEY_MIN};
+  pMemTable->nRows = 0;
+  pMemTable->pArray = taosArrayInit(512, sizeof(SMemData *));
+  if (pMemTable->pArray == NULL) {
+    taosMemoryFree(pMemTable);
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _err;
+  }
+
+  *ppMemTable = pMemTable;
+  return code;
+
+_err:
+  *ppMemTable = NULL;
+  return code;
+}
+
+void tsdbMemTableDestroy2(SMemTable *pMemTable) {
+  taosArrayDestroyEx(pMemTable->pArray, NULL /*TODO*/);
+  taosMemoryFree(pMemTable);
+}
+
+int32_t tsdbInsertTableData2(STsdb *pTsdb, int64_t version, SVSubmitBlk *pSubmitBlk) {
+  int32_t    code = 0;
+  SMemTable *pMemTable = (SMemTable *)pTsdb->mem;  // TODO
+  SMemData  *pMemData;
+  TSDBROW    row = {.version = version};
+
+  ASSERT(pMemTable);
+
+  {
+    // check if table exists (todo)
+  }
+
+  code = tsdbGetOrCreateMemData(pMemTable, pSubmitBlk->suid, pSubmitBlk->uid, &pMemData);
+  if (code) {
+    tsdbError("vgId:%d failed to create/get table data since %s", TD_VID(pTsdb->pVnode), tstrerror(code));
+    goto _err;
+  }
+
+  // do insert
+  int32_t           nt;
+  uint8_t          *pt;
+  int32_t           n = 0;
+  uint8_t          *p = pSubmitBlk->pData;
+  SVBufPool        *pPool = pTsdb->pVnode->inUse;
+  int8_t            level;
+  SMemSkipListNode *pNode;
+  while (n < pSubmitBlk->nData) {
+    nt = tGetTSRow(p + n, &row.tsRow);
+    n += nt;
+
+    ASSERT(n <= pSubmitBlk->nData);
+
+    // build the node
+    level = tsdbMemSkipListRandLevel(&pMemData->sl);
+    pNode = (SMemSkipListNode *)vnodeBufPoolMalloc(pPool, SL_NODE_SIZE(level) + nt + sizeof(version));
+    if (pNode == NULL) {
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      goto _err;
+    }
+    pNode->level = level;
+    tPutTSDBRow((uint8_t *)SL_NODE_DATA(pNode), &row);
+
+    // put the node (todo)
+
+    // set info
+    if (tsdbKeyCmprFn(&row, &pMemData->minKey) < 0) pMemData->minKey = *(TSDBKEY *)&row;
+    if (tsdbKeyCmprFn(&row, &pMemData->maxKey) > 0) pMemData->maxKey = *(TSDBKEY *)&row;
+  }
+
+  if (tsdbKeyCmprFn(&pMemTable->minKey, &pMemData->minKey) < 0) pMemTable->minKey = pMemData->minKey;
+  if (tsdbKeyCmprFn(&pMemTable->maxKey, &pMemData->maxKey) > 0) pMemTable->maxKey = pMemData->maxKey;
+
+  return code;
+
+_err:
+  return code;
+}
+
+int32_t tsdbDeleteTableData2(STsdb *pTsdb, int64_t version, tb_uid_t suid, tb_uid_t uid, TSKEY sKey, TSKEY eKey) {
+  int32_t    code = 0;
+  SMemTable *pMemTable = (SMemTable *)pTsdb->mem;  // TODO
+  SMemData  *pMemData;
+  SVBufPool *pPool = pTsdb->pVnode->inUse;
+
+  ASSERT(pMemTable);
+
+  {
+    // check if table exists (todo)
+  }
+
+  code = tsdbGetOrCreateMemData(pMemTable, suid, uid, &pMemData);
+  if (code) {
+    goto _err;
+  }
+
+  // do delete
+  SDelOp *pDelOp = (SDelOp *)vnodeBufPoolMalloc(pPool, sizeof(*pDelOp));
+  if (pDelOp == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _err;
+  }
+  pDelOp->version = version;
+  pDelOp->sKey = sKey;
+  pDelOp->eKey = eKey;
+  pDelOp->pNext = NULL;
+  if (pMemData->delOpHead == NULL) {
+    ASSERT(pMemData->delOpTail == NULL);
+    pMemData->delOpHead = pMemData->delOpTail = pDelOp;
+  } else {
+    pMemData->delOpTail->pNext = pDelOp;
+    pMemData->delOpTail = pDelOp;
+  }
+
+  {
+    // update the state of pMemTable, pMemData, last and lastrow (todo)
+  }
+
+  tsdbDebug("vgId:%d delete data from table suid:%" PRId64 " uid:%" PRId64 " sKey:%" PRId64 " eKey:%" PRId64
+            " since %s",
+            TD_VID(pTsdb->pVnode), suid, uid, sKey, eKey, tstrerror(code));
+  return code;
+
+_err:
+  tsdbError("vgId:%d failed to delete data from table suid:%" PRId64 " uid:%" PRId64 " sKey:%" PRId64 " eKey:%" PRId64
+            " since %s",
+            TD_VID(pTsdb->pVnode), suid, uid, sKey, eKey, tstrerror(code));
+  return code;
+}
+
+static int32_t tsdbGetOrCreateMemData(SMemTable *pMemTable, tb_uid_t suid, tb_uid_t uid, SMemData **ppMemData) {
+  int32_t    code = 0;
+  int32_t    idx = 0;
+  SMemData  *pMemDataT = &(SMemData){.suid = suid, .uid = uid};
+  SMemData  *pMemData = NULL;
+  SVBufPool *pPool = pMemTable->pTsdb->pVnode->inUse;
+  int8_t     maxLevel = pMemTable->pTsdb->pVnode->config.tsdbCfg.slLevel;
+
+  // get
+  idx = taosArraySearchIdx(pMemTable->pArray, &pMemDataT, memDataPCmprFn, TD_GE);
+  if (idx >= 0) {
+    pMemData = (SMemData *)taosArrayGet(pMemTable->pArray, idx);
+    if (memDataPCmprFn(&pMemDataT, &pMemData) == 0) goto _exit;
+  }
+
+  // create
+  pMemData = vnodeBufPoolMalloc(pPool, sizeof(*pMemData) + SL_NODE_HALF_SIZE(maxLevel) * 2);
+  if (pMemData == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _err;
+  }
+  pMemData->suid = suid;
+  pMemData->uid = uid;
+  pMemData->minKey = (TSDBKEY){.version = INT64_MAX, .ts = TSKEY_MAX};
+  pMemData->maxKey = (TSDBKEY){.version = -1, .ts = TSKEY_MIN};
+  pMemData->delOpHead = pMemData->delOpTail = NULL;
+  pMemData->sl.seed = taosRand();
+  pMemData->sl.size = 0;
+  pMemData->sl.maxLevel = maxLevel;
+  pMemData->sl.level = 0;
+  pMemData->sl.pHead = (SMemSkipListNode *)&pMemData[1];
+  pMemData->sl.pTail = (SMemSkipListNode *)POINTER_SHIFT(pMemData->sl.pHead, SL_NODE_HALF_SIZE(maxLevel));
+
+  for (int8_t iLevel = 0; iLevel < pMemData->sl.maxLevel; iLevel++) {
+    SL_HEAD_FORWARD(&pMemData->sl, iLevel) = pMemData->sl.pTail;
+    SL_TAIL_BACKWARD(&pMemData->sl, iLevel) = pMemData->sl.pHead;
+  }
+
+  if (idx < 0) idx = 0;
+  if (taosArrayInsert(pMemTable->pArray, idx, &pMemData) == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _err;
+  }
+
+_exit:
+  *ppMemData = pMemData;
+  return code;
+
+_err:
+  *ppMemData = NULL;
+  return code;
+}
+
+static int memDataPCmprFn(const void *p1, const void *p2) {
+  SMemData *pMemData1 = *(SMemData **)p1;
+  SMemData *pMemData2 = *(SMemData **)p2;
+
+  if (pMemData1->suid < pMemData2->suid) {
+    return -1;
+  } else if (pMemData1->suid > pMemData2->suid) {
+    return 1;
+  }
+
+  if (pMemData1->uid < pMemData2->uid) {
+    return -1;
+  } else if (pMemData1->uid > pMemData2->uid) {
+    return 1;
+  }
+
+  return 0;
+}
+
+static int32_t tPutTSDBRow(uint8_t *p, TSDBROW *pRow) {
+  int32_t n = 0;
+
+  n += tPutI64(p ? p + n : p, pRow->version);
+  n += tPutTSRow(p ? p + n : p, &pRow->tsRow);
+
+  return n;
+}
+
+static int32_t tGetTSDBRow(uint8_t *p, TSDBROW *pRow) {
+  int32_t n = 0;
+
+  n += tGetI64(p + n, &pRow->version);
+  n += tGetTSRow(p + n, &pRow->tsRow);
+
+  return n;
+}
+
+static FORCE_INLINE int8_t tsdbMemSkipListRandLevel(SMemSkipList *pSl) {
+  int8_t         level = 1;
+  int8_t         tlevel = TMIN(pSl->maxLevel, pSl->level + 1);
+  const uint32_t factor = 4;
+
+  while ((taosRandR(&pSl->seed) % factor) == 0 && level < tlevel) {
+    level++;
+  }
+
+  return level;
+}
+
+#if 0  //====================================================================================
+
+#define SL_MAX_LEVEL 5
+
 struct SMemSkipListCurosr {
   SMemSkipList     *pSl;
   SMemSkipListNode *pNodes[SL_MAX_LEVEL];
@@ -74,12 +330,6 @@ typedef struct {
 
 #define HASH_BUCKET(SUID, UID, NBUCKET) (TABS((SUID) + (UID)) % (NBUCKET))
 
-#define SL_NODE_SIZE(l)        (sizeof(SMemSkipListNode) + sizeof(SMemSkipListNode *) * (l)*2)
-#define SL_NODE_HALF_SIZE(l)   (sizeof(SMemSkipListNode) + sizeof(SMemSkipListNode *) * (l))
-#define SL_NODE_FORWARD(n, l)  ((n)->forwards[l])
-#define SL_NODE_BACKWARD(n, l) ((n)->forwards[(n)->level + (l)])
-#define SL_NODE_DATA(n)        (&SL_NODE_BACKWARD(n, (n)->level))
-
 #define SL_HEAD_NODE(sl)            ((sl)->pHead)
 #define SL_TAIL_NODE(sl)            ((SMemSkipListNode *)&SL_NODE_FORWARD(SL_HEAD_NODE(sl), (sl)->maxLevel))
 #define SL_HEAD_NODE_FORWARD(n, l)  SL_NODE_FORWARD(n, l)
@@ -99,50 +349,7 @@ static int32_t tsdbMemSkipListCursorMoveToNext(SMemSkipListCurosr *pSlc);
 static int32_t tsdbMemSkipListCursorMoveToPrev(SMemSkipListCurosr *pSlc);
 static SMemSkipListNode *tsdbMemSkipListNodeCreate(SVBufPool *pPool, SMemSkipList *pSl, const STsdbRow *pTRow);
 
-// SMemTable
-int32_t tsdbMemTableCreate2(STsdb *pTsdb, SMemTable **ppMemTb) {
-  SMemTable *pMemTb = NULL;
-
-  pMemTb = taosMemoryCalloc(1, sizeof(*pMemTb));
-  if (pMemTb == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  pMemTb->pTsdb = pTsdb;
-  pMemTb->minKey = TSKEY_MAX;
-  pMemTb->maxKey = TSKEY_MIN;
-  pMemTb->minVer = -1;
-  pMemTb->maxVer = -1;
-  pMemTb->nRows = 0;
-  pMemTb->nHash = 0;
-  pMemTb->nBucket = 1024;
-  pMemTb->pBuckets = taosMemoryCalloc(pMemTb->nBucket, sizeof(*pMemTb->pBuckets));
-  if (pMemTb->pBuckets == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    taosMemoryFree(pMemTb);
-    return -1;
-  }
-  if (tsdbMemSkipListCursorCreate(pTsdb->pVnode->config.tsdbCfg.slLevel, &pMemTb->pSlc) < 0) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    taosMemoryFree(pMemTb->pBuckets);
-    taosMemoryFree(pMemTb);
-  }
-
-  *ppMemTb = pMemTb;
-  return 0;
-}
-
-int32_t tsdbMemTableDestroy2(STsdb *pTsdb, SMemTable *pMemTb) {
-  if (pMemTb) {
-    // loop to destroy the contents (todo)
-    tsdbMemSkipListCursorDestroy(pMemTb->pSlc);
-    taosMemoryFree(pMemTb->pBuckets);
-    taosMemoryFree(pMemTb);
-  }
-  return 0;
-}
-
+// SMemTable ========================
 int32_t tsdbInsertData2(SMemTable *pMemTb, int64_t version, const SVSubmitBlk *pSubmitBlk) {
   SMemData  *pMemData;
   STsdb     *pTsdb = pMemTb->pTsdb;
@@ -253,18 +460,6 @@ int32_t tsdbInsertData2(SMemTable *pMemTb, int64_t version, const SVSubmitBlk *p
   return 0;
 }
 
-static FORCE_INLINE int8_t tsdbMemSkipListRandLevel(SMemSkipList *pSl) {
-  int8_t         level = 1;
-  int8_t         tlevel = TMIN(pSl->maxLevel, pSl->level + 1);
-  const uint32_t factor = 4;
-
-  while ((taosRandR(&pSl->seed) % factor) == 0 && level < tlevel) {
-    level++;
-  }
-
-  return level;
-}
-
 static FORCE_INLINE int32_t tsdbEncodeRow(SEncoder *pEncoder, const STsdbRow *pRow) {
   if (tEncodeI64(pEncoder, pRow->version) < 0) return -1;
   if (tEncodeBinary(pEncoder, (const uint8_t *)pRow->pRow, pRow->szRow) < 0) return -1;
@@ -377,4 +572,5 @@ static SMemSkipListNode *tsdbMemSkipListNodeCreate(SVBufPool *pPool, SMemSkipLis
   }
 
   return pNode;
-}
\ No newline at end of file
+}
+#endif
\ No newline at end of file
diff --git a/source/dnode/vnode/src/tsdb/tsdbRead.c b/source/dnode/vnode/src/tsdb/tsdbRead.c
index 62125b6dc7..f9c5fac536 100644
--- a/source/dnode/vnode/src/tsdb/tsdbRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbRead.c
@@ -333,7 +333,7 @@ static void setQueryTimewindow(STsdbReadHandle* pTsdbReadHandle, SQueryTableData
 }
 
 static STsdb* getTsdbByRetentions(SVnode* pVnode, STsdbReadHandle* pReadHandle, TSKEY winSKey, SRetention* retentions) {
-  if (vnodeIsRollup(pVnode)) {
+  if (VND_IS_RSMA(pVnode)) {
     int     level = 0;
     int64_t now = taosGetTimestamp(pVnode->config.tsdbCfg.precision);
 
diff --git a/source/dnode/vnode/src/tsdb/tsdbSma.c b/source/dnode/vnode/src/tsdb/tsdbSma.c
deleted file mode 100644
index 45b17a0180..0000000000
--- a/source/dnode/vnode/src/tsdb/tsdbSma.c
+++ /dev/null
@@ -1,2203 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "tsdbSma.h"
-#include "tsdb.h"
-
-static const char *TSDB_SMA_DNAME[] = {
-    "",      // TSDB_SMA_TYPE_BLOCK
-    "tsma",  // TSDB_SMA_TYPE_TIME_RANGE
-    "rsma",  // TSDB_SMA_TYPE_ROLLUP
-};
-
-#undef _TEST_SMA_PRINT_DEBUG_LOG_
-#define SMA_STORAGE_TSDB_DAYS   30
-#define SMA_STORAGE_TSDB_TIMES  10
-#define SMA_STORAGE_SPLIT_HOURS 24
-#define SMA_KEY_LEN             16  // TSKEY+groupId 8+8
-#define SMA_DROP_EXPIRED_TIME   10  // default is 10 seconds
-
-#define SMA_STATE_HASH_SLOT      4
-#define SMA_STATE_ITEM_HASH_SLOT 32
-
-#define SMA_TEST_INDEX_NAME "smaTestIndexName"  // TODO: just for test
-#define SMA_TEST_INDEX_UID  2000000001          // TODO: just for test
-
-typedef struct SRSmaInfo SRSmaInfo;
-typedef enum {
-  SMA_STORAGE_LEVEL_TSDB = 0,     // use days of self-defined  e.g. vnode${N}/tsdb/tsma/sma_index_uid/v2f200.tsma
-  SMA_STORAGE_LEVEL_DFILESET = 1  // use days of TS data       e.g. vnode${N}/tsdb/tsma/sma_index_uid/v2f1906.tsma
-} ESmaStorageLevel;
-
-typedef struct SPoolMem {
-  int64_t          size;
-  struct SPoolMem *prev;
-  struct SPoolMem *next;
-} SPoolMem;
-
-struct SSmaEnv {
-  TdThreadRwlock lock;
-  int8_t         type;
-  TXN            txn;
-  SPoolMem      *pPool;
-  SDiskID        did;
-  TDB           *dbEnv;  // TODO: If it's better to put it in smaIndex level?
-  char          *path;   // relative path
-  SSmaStat      *pStat;
-};
-
-#define SMA_ENV_LOCK(env)       ((env)->lock)
-#define SMA_ENV_TYPE(env)       ((env)->type)
-#define SMA_ENV_DID(env)        ((env)->did)
-#define SMA_ENV_ENV(env)        ((env)->dbEnv)
-#define SMA_ENV_PATH(env)       ((env)->path)
-#define SMA_ENV_STAT(env)       ((env)->pStat)
-#define SMA_ENV_STAT_ITEMS(env) ((env)->pStat->smaStatItems)
-
-typedef struct {
-  STsdb        *pTsdb;
-  SDBFile       dFile;
-  const SArray *pDataBlocks;  // sma data
-  int32_t       interval;     // interval with the precision of DB
-} STSmaWriteH;
-
-typedef struct {
-  int32_t iter;
-  int32_t fid;
-} SmaFsIter;
-
-typedef struct {
-  STsdb    *pTsdb;
-  SDBFile   dFile;
-  int32_t   interval;   // interval with the precision of DB
-  int32_t   blockSize;  // size of SMA block item
-  int8_t    storageLevel;
-  int8_t    days;
-  SmaFsIter smaFsIter;
-} STSmaReadH;
-
-typedef struct {
-  /**
-   * @brief The field 'state' is here to demonstrate if one smaIndex is ready to provide service.
-   *    - TSDB_SMA_STAT_OK: 1) The sma calculation of history data is finished; 2) Or recevied information from
-   * Streaming Module or TSDB local persistence.
-   *    - TSDB_SMA_STAT_EXPIRED: 1) If sma calculation of history TS data is not finished; 2) Or if the TSDB is open,
-   * without information about its previous state.
-   *    - TSDB_SMA_STAT_DROPPED: 1)sma dropped
-   * N.B. only applicable to tsma
-   */
-  int8_t    state;           // ETsdbSmaStat
-  SHashObj *expiredWindows;  // key: skey of time window, value: N/A
-  STSma    *pSma;            // cache schema
-} SSmaStatItem;
-
-#define RSMA_TASK_INFO_HASH_SLOT 8
-struct SRSmaInfo {
-  void *taskInfo[TSDB_RETENTION_L2];  // qTaskInfo_t
-};
-
-struct SSmaStat {
-  union {
-    SHashObj *smaStatItems;  // key: indexUid, value: SSmaStatItem for tsma
-    SHashObj *rsmaInfoHash;  // key: stbUid, value: SRSmaInfo;
-  };
-  T_REF_DECLARE()
-};
-#define SMA_STAT_ITEMS(s)     ((s)->smaStatItems)
-#define SMA_STAT_INFO_HASH(s) ((s)->rsmaInfoHash)
-
-static FORCE_INLINE void tsdbFreeTaskHandle(qTaskInfo_t *taskHandle) {
-  // Note: free/kill may in RC
-  qTaskInfo_t otaskHandle = atomic_load_ptr(taskHandle);
-  if (otaskHandle && atomic_val_compare_exchange_ptr(taskHandle, otaskHandle, NULL)) {
-    qDestroyTask(otaskHandle);
-  }
-}
-
-static FORCE_INLINE void *tsdbFreeRSmaInfo(SRSmaInfo *pInfo) {
-  for (int32_t i = 0; i < TSDB_RETENTION_MAX; ++i) {
-    if (pInfo->taskInfo[i]) {
-      tsdbFreeTaskHandle(pInfo->taskInfo[i]);
-    }
-  }
-  return NULL;
-}
-
-// declaration of static functions
-
-// expired window
-static int32_t  tsdbUpdateExpiredWindowImpl(STsdb *pTsdb, SSubmitReq *pMsg, int64_t version);
-static int32_t  tsdbSetExpiredWindow(STsdb *pTsdb, SHashObj *pItemsHash, int64_t indexUid, int64_t winSKey,
-                                     int64_t version);
-static int32_t  tsdbInitSmaStat(SSmaStat **pSmaStat, int8_t smaType);
-static void    *tsdbFreeSmaStatItem(SSmaStatItem *pSmaStatItem);
-static int32_t  tsdbDestroySmaState(SSmaStat *pSmaStat, int8_t smaType);
-static SSmaEnv *tsdbNewSmaEnv(const STsdb *pTsdb, int8_t smaType, const char *path, SDiskID did);
-static int32_t  tsdbInitSmaEnv(STsdb *pTsdb, int8_t smaType, const char *path, SDiskID did, SSmaEnv **pEnv);
-static int32_t  tsdbResetExpiredWindow(STsdb *pTsdb, SSmaStat *pStat, int64_t indexUid, TSKEY skey);
-static int32_t  tsdbRefSmaStat(STsdb *pTsdb, SSmaStat *pStat);
-static int32_t  tsdbUnRefSmaStat(STsdb *pTsdb, SSmaStat *pStat);
-
-// read data
-// TODO: This is the basic params, and should wrap the params to a queryHandle.
-static int32_t tsdbGetTSmaDataImpl(STsdb *pTsdb, char *pData, int64_t indexUid, TSKEY querySKey, int32_t nMaxResult);
-
-// insert data
-static int32_t tsdbInitTSmaWriteH(STSmaWriteH *pSmaH, STsdb *pTsdb, const SArray *pDataBlocks, int64_t interval,
-                                  int8_t intervalUnit);
-static void    tsdbDestroyTSmaWriteH(STSmaWriteH *pSmaH);
-static int32_t tsdbInitTSmaReadH(STSmaReadH *pSmaH, STsdb *pTsdb, int64_t interval, int8_t intervalUnit);
-static int32_t tsdbGetSmaStorageLevel(int64_t interval, int8_t intervalUnit);
-static int32_t tsdbSetRSmaDataFile(STSmaWriteH *pSmaH, int32_t fid);
-static int32_t tsdbInsertTSmaBlocks(STSmaWriteH *pSmaH, void *smaKey, int32_t keyLen, void *pData, int32_t dataLen,
-                                    TXN *txn);
-static int64_t tsdbGetIntervalByPrecision(int64_t interval, uint8_t intervalUnit, int8_t precision, bool adjusted);
-static int32_t tsdbGetTSmaDays(STsdb *pTsdb, int64_t interval, int32_t storageLevel);
-static int32_t tsdbSetTSmaDataFile(STSmaWriteH *pSmaH, int64_t indexUid, int32_t fid);
-static int32_t tsdbInitTSmaFile(STSmaReadH *pSmaH, int64_t indexUid, TSKEY skey);
-static bool    tsdbSetAndOpenTSmaFile(STSmaReadH *pReadH, TSKEY *queryKey);
-static void    tsdbGetSmaDir(int32_t vgId, ETsdbSmaType smaType, char dirName[]);
-static int32_t tsdbInsertTSmaDataImpl(STsdb *pTsdb, int64_t indexUid, const char *msg);
-static int32_t tsdbInsertRSmaDataImpl(STsdb *pTsdb, const char *msg);
-
-static FORCE_INLINE int32_t tsdbUidStorePut(STbUidStore *pStore, tb_uid_t suid, tb_uid_t *uid);
-static FORCE_INLINE int32_t tsdbUpdateTbUidListImpl(STsdb *pTsdb, tb_uid_t *suid, SArray *tbUids);
-static FORCE_INLINE int32_t tsdbExecuteRSmaImpl(STsdb *pTsdb, const void *pMsg, int32_t inputType,
-                                                qTaskInfo_t *taskInfo, STSchema *pTSchema, tb_uid_t suid, tb_uid_t uid,
-                                                int8_t level);
-// mgmt interface
-static int32_t tsdbDropTSmaDataImpl(STsdb *pTsdb, int64_t indexUid);
-
-// Pool Memory
-static SPoolMem *openPool();
-static void      clearPool(SPoolMem *pPool);
-static void      closePool(SPoolMem *pPool);
-static void     *poolMalloc(void *arg, size_t size);
-static void      poolFree(void *arg, void *ptr);
-
-static int tsdbSmaBeginCommit(SSmaEnv *pEnv);
-static int tsdbSmaEndCommit(SSmaEnv *pEnv);
-
-// implementation
-static FORCE_INLINE int16_t tsdbTSmaAdd(STsdb *pTsdb, int16_t n) {
-  return atomic_add_fetch_16(&REPO_TSMA_NUM(pTsdb), n);
-}
-static FORCE_INLINE int16_t tsdbTSmaSub(STsdb *pTsdb, int16_t n) {
-  return atomic_sub_fetch_16(&REPO_TSMA_NUM(pTsdb), n);
-}
-
-static FORCE_INLINE int32_t tsdbRLockSma(SSmaEnv *pEnv) {
-  int code = taosThreadRwlockRdlock(&(pEnv->lock));
-  if (code != 0) {
-    terrno = TAOS_SYSTEM_ERROR(code);
-    return -1;
-  }
-  return 0;
-}
-
-static FORCE_INLINE int32_t tsdbWLockSma(SSmaEnv *pEnv) {
-  int code = taosThreadRwlockWrlock(&(pEnv->lock));
-  if (code != 0) {
-    terrno = TAOS_SYSTEM_ERROR(code);
-    return -1;
-  }
-  return 0;
-}
-
-static FORCE_INLINE int32_t tsdbUnLockSma(SSmaEnv *pEnv) {
-  int code = taosThreadRwlockUnlock(&(pEnv->lock));
-  if (code != 0) {
-    terrno = TAOS_SYSTEM_ERROR(code);
-    return -1;
-  }
-  return 0;
-}
-
-static SPoolMem *openPool() {
-  SPoolMem *pPool = (SPoolMem *)taosMemoryMalloc(sizeof(*pPool));
-
-  pPool->prev = pPool->next = pPool;
-  pPool->size = 0;
-
-  return pPool;
-}
-
-static void clearPool(SPoolMem *pPool) {
-  if (!pPool) return;
-
-  SPoolMem *pMem;
-
-  do {
-    pMem = pPool->next;
-
-    if (pMem == pPool) break;
-
-    pMem->next->prev = pMem->prev;
-    pMem->prev->next = pMem->next;
-    pPool->size -= pMem->size;
-
-    taosMemoryFree(pMem);
-  } while (1);
-
-  assert(pPool->size == 0);
-}
-
-static void closePool(SPoolMem *pPool) {
-  if (pPool) {
-    clearPool(pPool);
-    taosMemoryFree(pPool);
-  }
-}
-
-static void *poolMalloc(void *arg, size_t size) {
-  void     *ptr = NULL;
-  SPoolMem *pPool = (SPoolMem *)arg;
-  SPoolMem *pMem;
-
-  pMem = (SPoolMem *)taosMemoryMalloc(sizeof(*pMem) + size);
-  if (!pMem) {
-    assert(0);
-  }
-
-  pMem->size = sizeof(*pMem) + size;
-  pMem->next = pPool->next;
-  pMem->prev = pPool;
-
-  pPool->next->prev = pMem;
-  pPool->next = pMem;
-  pPool->size += pMem->size;
-
-  ptr = (void *)(&pMem[1]);
-  return ptr;
-}
-
-static void poolFree(void *arg, void *ptr) {
-  SPoolMem *pPool = (SPoolMem *)arg;
-  SPoolMem *pMem;
-
-  pMem = &(((SPoolMem *)ptr)[-1]);
-
-  pMem->next->prev = pMem->prev;
-  pMem->prev->next = pMem->next;
-  pPool->size -= pMem->size;
-
-  taosMemoryFree(pMem);
-}
-
-int32_t tsdbInitSma(STsdb *pTsdb) {
-  // tSma
-  int32_t numOfTSma = taosArrayGetSize(metaGetSmaTbUids(REPO_META(pTsdb), false));
-  if (numOfTSma > 0) {
-    atomic_store_16(&REPO_TSMA_NUM(pTsdb), (int16_t)numOfTSma);
-  }
-  // TODO: rSma
-  return TSDB_CODE_SUCCESS;
-}
-
-static FORCE_INLINE int8_t tsdbSmaStat(SSmaStatItem *pStatItem) {
-  if (pStatItem) {
-    return atomic_load_8(&pStatItem->state);
-  }
-  return TSDB_SMA_STAT_UNKNOWN;
-}
-
-static FORCE_INLINE bool tsdbSmaStatIsOK(SSmaStatItem *pStatItem, int8_t *state) {
-  if (!pStatItem) {
-    return false;
-  }
-
-  if (state) {
-    *state = atomic_load_8(&pStatItem->state);
-    return *state == TSDB_SMA_STAT_OK;
-  }
-  return atomic_load_8(&pStatItem->state) == TSDB_SMA_STAT_OK;
-}
-
-static FORCE_INLINE bool tsdbSmaStatIsExpired(SSmaStatItem *pStatItem) {
-  return pStatItem ? (atomic_load_8(&pStatItem->state) & TSDB_SMA_STAT_EXPIRED) : true;
-}
-
-static FORCE_INLINE bool tsdbSmaStatIsDropped(SSmaStatItem *pStatItem) {
-  return pStatItem ? (atomic_load_8(&pStatItem->state) & TSDB_SMA_STAT_DROPPED) : true;
-}
-
-static FORCE_INLINE void tsdbSmaStatSetOK(SSmaStatItem *pStatItem) {
-  if (pStatItem) {
-    atomic_store_8(&pStatItem->state, TSDB_SMA_STAT_OK);
-  }
-}
-
-static FORCE_INLINE void tsdbSmaStatSetExpired(SSmaStatItem *pStatItem) {
-  if (pStatItem) {
-    atomic_or_fetch_8(&pStatItem->state, TSDB_SMA_STAT_EXPIRED);
-  }
-}
-
-static FORCE_INLINE void tsdbSmaStatSetDropped(SSmaStatItem *pStatItem) {
-  if (pStatItem) {
-    atomic_or_fetch_8(&pStatItem->state, TSDB_SMA_STAT_DROPPED);
-  }
-}
-
-static void tsdbGetSmaDir(int32_t vgId, ETsdbSmaType smaType, char dirName[]) {
-  snprintf(dirName, TSDB_FILENAME_LEN, "vnode%svnode%d%s%s", TD_DIRSEP, vgId, TD_DIRSEP, TSDB_SMA_DNAME[smaType]);
-}
-
-static SSmaEnv *tsdbNewSmaEnv(const STsdb *pTsdb, int8_t smaType, const char *path, SDiskID did) {
-  SSmaEnv *pEnv = NULL;
-
-  pEnv = (SSmaEnv *)taosMemoryCalloc(1, sizeof(SSmaEnv));
-  if (!pEnv) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
-  }
-
-  SMA_ENV_TYPE(pEnv) = smaType;
-
-  int code = taosThreadRwlockInit(&(pEnv->lock), NULL);
-  if (code) {
-    terrno = TAOS_SYSTEM_ERROR(code);
-    taosMemoryFree(pEnv);
-    return NULL;
-  }
-
-  ASSERT(path && (strlen(path) > 0));
-  SMA_ENV_PATH(pEnv) = strdup(path);
-  if (!SMA_ENV_PATH(pEnv)) {
-    tsdbFreeSmaEnv(pEnv);
-    return NULL;
-  }
-
-  SMA_ENV_DID(pEnv) = did;
-
-  if (tsdbInitSmaStat(&SMA_ENV_STAT(pEnv), smaType) != TSDB_CODE_SUCCESS) {
-    tsdbFreeSmaEnv(pEnv);
-    return NULL;
-  }
-
-  char aname[TSDB_FILENAME_LEN] = {0};
-  tfsAbsoluteName(REPO_TFS(pTsdb), did, path, aname);
-  if (tsdbOpenDBEnv(&pEnv->dbEnv, aname) != TSDB_CODE_SUCCESS) {
-    tsdbFreeSmaEnv(pEnv);
-    return NULL;
-  }
-
-  if (!(pEnv->pPool = openPool())) {
-    tsdbFreeSmaEnv(pEnv);
-    return NULL;
-  }
-
-  return pEnv;
-}
-
-static int32_t tsdbInitSmaEnv(STsdb *pTsdb, int8_t smaType, const char *path, SDiskID did, SSmaEnv **pEnv) {
-  if (!pEnv) {
-    terrno = TSDB_CODE_INVALID_PTR;
-    return TSDB_CODE_FAILED;
-  }
-
-  if (!(*pEnv)) {
-    if (!(*pEnv = tsdbNewSmaEnv(pTsdb, smaType, path, did))) {
-      return TSDB_CODE_FAILED;
-    }
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief Release resources allocated for its member fields, not including itself.
- *
- * @param pSmaEnv
- * @return int32_t
- */
-void tsdbDestroySmaEnv(SSmaEnv *pSmaEnv) {
-  if (pSmaEnv) {
-    tsdbDestroySmaState(pSmaEnv->pStat, SMA_ENV_TYPE(pSmaEnv));
-    taosMemoryFreeClear(pSmaEnv->pStat);
-    taosMemoryFreeClear(pSmaEnv->path);
-    taosThreadRwlockDestroy(&(pSmaEnv->lock));
-    tsdbCloseDBEnv(pSmaEnv->dbEnv);
-    closePool(pSmaEnv->pPool);
-  }
-}
-
-void *tsdbFreeSmaEnv(SSmaEnv *pSmaEnv) {
-  tsdbDestroySmaEnv(pSmaEnv);
-  taosMemoryFreeClear(pSmaEnv);
-  return NULL;
-}
-
-static int32_t tsdbRefSmaStat(STsdb *pTsdb, SSmaStat *pStat) {
-  if (!pStat) return 0;
-
-  int ref = T_REF_INC(pStat);
-  tsdbDebug("vgId:%d ref sma stat:%p, val:%d", REPO_ID(pTsdb), pStat, ref);
-  return 0;
-}
-
-static int32_t tsdbUnRefSmaStat(STsdb *pTsdb, SSmaStat *pStat) {
-  if (!pStat) return 0;
-
-  int ref = T_REF_DEC(pStat);
-  tsdbDebug("vgId:%d unref sma stat:%p, val:%d", REPO_ID(pTsdb), pStat, ref);
-  return 0;
-}
-
-static int32_t tsdbInitSmaStat(SSmaStat **pSmaStat, int8_t smaType) {
-  ASSERT(pSmaStat != NULL);
-
-  if (*pSmaStat) {  // no lock
-    return TSDB_CODE_SUCCESS;
-  }
-
-  /**
-   *  1. Lazy mode utilized when init SSmaStat to update expired window(or hungry mode when tsdbNew).
-   *  2. Currently, there is mutex lock when init SSmaEnv, thus no need add lock on SSmaStat, and please add lock if
-   * tsdbInitSmaStat invoked in other multithread environment later.
-   */
-  if (!(*pSmaStat)) {
-    *pSmaStat = (SSmaStat *)taosMemoryCalloc(1, sizeof(SSmaStat));
-    if (!(*pSmaStat)) {
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      return TSDB_CODE_FAILED;
-    }
-
-    if (smaType == TSDB_SMA_TYPE_ROLLUP) {
-      SMA_STAT_INFO_HASH(*pSmaStat) = taosHashInit(
-          RSMA_TASK_INFO_HASH_SLOT, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_ENTRY_LOCK);
-
-      if (!SMA_STAT_INFO_HASH(*pSmaStat)) {
-        taosMemoryFreeClear(*pSmaStat);
-        return TSDB_CODE_FAILED;
-      }
-    } else if (smaType == TSDB_SMA_TYPE_TIME_RANGE) {
-      SMA_STAT_ITEMS(*pSmaStat) =
-          taosHashInit(SMA_STATE_HASH_SLOT, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
-
-      if (!SMA_STAT_ITEMS(*pSmaStat)) {
-        taosMemoryFreeClear(*pSmaStat);
-        return TSDB_CODE_FAILED;
-      }
-    } else {
-      ASSERT(0);
-    }
-  }
-  return TSDB_CODE_SUCCESS;
-}
-
-static SSmaStatItem *tsdbNewSmaStatItem(int8_t state) {
-  SSmaStatItem *pItem = NULL;
-
-  pItem = (SSmaStatItem *)taosMemoryCalloc(1, sizeof(SSmaStatItem));
-  if (pItem) {
-    pItem->state = state;
-    pItem->expiredWindows = taosHashInit(SMA_STATE_ITEM_HASH_SLOT, taosGetDefaultHashFunction(TSDB_DATA_TYPE_TIMESTAMP),
-                                         true, HASH_ENTRY_LOCK);
-    if (!pItem->expiredWindows) {
-      taosMemoryFreeClear(pItem);
-    }
-  }
-  return pItem;
-}
-
-static void *tsdbFreeSmaStatItem(SSmaStatItem *pSmaStatItem) {
-  if (pSmaStatItem) {
-    tdDestroyTSma(pSmaStatItem->pSma);
-    taosMemoryFreeClear(pSmaStatItem->pSma);
-    taosHashCleanup(pSmaStatItem->expiredWindows);
-    taosMemoryFreeClear(pSmaStatItem);
-  }
-  return NULL;
-}
-
-/**
- * @brief Release resources allocated for its member fields, not including itself.
- *
- * @param pSmaStat
- * @return int32_t
- */
-int32_t tsdbDestroySmaState(SSmaStat *pSmaStat, int8_t smaType) {
-  if (pSmaStat) {
-    // TODO: use taosHashSetFreeFp when taosHashSetFreeFp is ready.
-    if (smaType == TSDB_SMA_TYPE_TIME_RANGE) {
-      void *item = taosHashIterate(SMA_STAT_ITEMS(pSmaStat), NULL);
-      while (item) {
-        SSmaStatItem *pItem = *(SSmaStatItem **)item;
-        tsdbFreeSmaStatItem(pItem);
-        item = taosHashIterate(SMA_STAT_ITEMS(pSmaStat), item);
-      }
-      taosHashCleanup(SMA_STAT_ITEMS(pSmaStat));
-    } else if (smaType == TSDB_SMA_TYPE_ROLLUP) {
-      void *infoHash = taosHashIterate(SMA_STAT_INFO_HASH(pSmaStat), NULL);
-      while (infoHash) {
-        SRSmaInfo *pInfoHash = *(SRSmaInfo **)infoHash;
-        tsdbFreeRSmaInfo(pInfoHash);
-        infoHash = taosHashIterate(SMA_STAT_INFO_HASH(pSmaStat), infoHash);
-      }
-      taosHashCleanup(SMA_STAT_INFO_HASH(pSmaStat));
-    } else {
-      ASSERT(0);
-    }
-  }
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t tsdbCheckAndInitSmaEnv(STsdb *pTsdb, int8_t smaType) {
-  SSmaEnv *pEnv = NULL;
-
-  // return if already init
-  switch (smaType) {
-    case TSDB_SMA_TYPE_TIME_RANGE:
-      if ((pEnv = (SSmaEnv *)atomic_load_ptr(&REPO_TSMA_ENV(pTsdb)))) {
-        return TSDB_CODE_SUCCESS;
-      }
-      break;
-    case TSDB_SMA_TYPE_ROLLUP:
-      if ((pEnv = (SSmaEnv *)atomic_load_ptr(&REPO_RSMA_ENV(pTsdb)))) {
-        return TSDB_CODE_SUCCESS;
-      }
-      break;
-    default:
-      terrno = TSDB_CODE_INVALID_PARA;
-      return TSDB_CODE_FAILED;
-  }
-
-  // init sma env
-  tsdbLockRepo(pTsdb);
-  pEnv = (smaType == TSDB_SMA_TYPE_TIME_RANGE) ? atomic_load_ptr(&REPO_TSMA_ENV(pTsdb))
-                                               : atomic_load_ptr(&REPO_RSMA_ENV(pTsdb));
-  if (!pEnv) {
-    char rname[TSDB_FILENAME_LEN] = {0};
-
-    SDiskID did = {0};
-    tfsAllocDisk(REPO_TFS(pTsdb), TFS_PRIMARY_LEVEL, &did);
-    if (did.level < 0 || did.id < 0) {
-      tsdbUnlockRepo(pTsdb);
-      return TSDB_CODE_FAILED;
-    }
-    tsdbGetSmaDir(REPO_ID(pTsdb), smaType, rname);
-
-    if (tfsMkdirRecurAt(REPO_TFS(pTsdb), rname, did) != TSDB_CODE_SUCCESS) {
-      tsdbUnlockRepo(pTsdb);
-      return TSDB_CODE_FAILED;
-    }
-
-    if (tsdbInitSmaEnv(pTsdb, smaType, rname, did, &pEnv) != TSDB_CODE_SUCCESS) {
-      tsdbUnlockRepo(pTsdb);
-      return TSDB_CODE_FAILED;
-    }
-
-    (smaType == TSDB_SMA_TYPE_TIME_RANGE) ? atomic_store_ptr(&REPO_TSMA_ENV(pTsdb), pEnv)
-                                          : atomic_store_ptr(&REPO_RSMA_ENV(pTsdb), pEnv);
-  }
-  tsdbUnlockRepo(pTsdb);
-
-  return TSDB_CODE_SUCCESS;
-};
-
-static int32_t tsdbSetExpiredWindow(STsdb *pTsdb, SHashObj *pItemsHash, int64_t indexUid, int64_t winSKey,
-                                    int64_t version) {
-  SSmaStatItem *pItem = taosHashGet(pItemsHash, &indexUid, sizeof(indexUid));
-  if (!pItem) {
-    // TODO: use TSDB_SMA_STAT_EXPIRED and update by stream computing later
-    pItem = tsdbNewSmaStatItem(TSDB_SMA_STAT_OK);  // TODO use the real state
-    if (!pItem) {
-      // Response to stream computing: OOM
-      // For query, if the indexUid not found, the TSDB should tell query module to query raw TS data.
-      return TSDB_CODE_FAILED;
-    }
-
-    // cache smaMeta
-    STSma *pSma = metaGetSmaInfoByIndex(REPO_META(pTsdb), indexUid, true);
-    if (!pSma) {
-      terrno = TSDB_CODE_TDB_NO_SMA_INDEX_IN_META;
-      taosHashCleanup(pItem->expiredWindows);
-      taosMemoryFree(pItem);
-      tsdbWarn("vgId:%d update expired window failed for smaIndex %" PRIi64 " since %s", REPO_ID(pTsdb), indexUid,
-               tstrerror(terrno));
-      return TSDB_CODE_FAILED;
-    }
-    pItem->pSma = pSma;
-
-    if (taosHashPut(pItemsHash, &indexUid, sizeof(indexUid), &pItem, sizeof(pItem)) != 0) {
-      // If error occurs during put smaStatItem, free the resources of pItem
-      taosHashCleanup(pItem->expiredWindows);
-      taosMemoryFree(pItem);
-      return TSDB_CODE_FAILED;
-    }
-  } else if (!(pItem = *(SSmaStatItem **)pItem)) {
-    terrno = TSDB_CODE_INVALID_PTR;
-    return TSDB_CODE_FAILED;
-  }
-
-  if (taosHashPut(pItem->expiredWindows, &winSKey, sizeof(TSKEY), &version, sizeof(version)) != 0) {
-    // If error occurs during taosHashPut expired windows, remove the smaIndex from pTsdb->pSmaStat, thus TSDB would
-    // tell query module to query raw TS data.
-    // N.B.
-    //  1) It is assumed to be extemely little probability event of fail to taosHashPut.
-    //  2) This would solve the inconsistency to some extent, but not completely, unless we record all expired
-    // windows failed to put into hash table.
-    taosHashCleanup(pItem->expiredWindows);
-    taosMemoryFreeClear(pItem->pSma);
-    taosHashRemove(pItemsHash, &indexUid, sizeof(indexUid));
-    tsdbWarn("vgId:%d smaIndex %" PRIi64 ", put skey %" PRIi64 " to expire window fail", REPO_ID(pTsdb), indexUid,
-             winSKey);
-    return TSDB_CODE_FAILED;
-  }
-
-  tsdbDebug("vgId:%d smaIndex %" PRIi64 ", put skey %" PRIi64 " to expire window succeed", REPO_ID(pTsdb), indexUid,
-            winSKey);
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief Update expired window according to msg from stream computing module.
- *
- * @param pTsdb
- * @param msg SSubmitReq
- * @return int32_t
- */
-int32_t tsdbUpdateExpiredWindowImpl(STsdb *pTsdb, SSubmitReq *pMsg, int64_t version) {
-  // no time-range-sma, just return success
-  if (atomic_load_16(&REPO_TSMA_NUM(pTsdb)) <= 0) {
-    tsdbTrace("vgId:%d not update expire window since no tSma", REPO_ID(pTsdb));
-    return TSDB_CODE_SUCCESS;
-  }
-
-  if (!REPO_META(pTsdb)) {
-    terrno = TSDB_CODE_INVALID_PTR;
-    return TSDB_CODE_FAILED;
-  }
-
-  if (tsdbCheckAndInitSmaEnv(pTsdb, TSDB_SMA_TYPE_TIME_RANGE) != TSDB_CODE_SUCCESS) {
-    terrno = TSDB_CODE_TDB_INIT_FAILED;
-    return TSDB_CODE_FAILED;
-  }
-
-  // Firstly, assume that tSma can only be created on super table/normal table.
-  // getActiveTimeWindow
-
-  SSmaEnv  *pEnv = REPO_TSMA_ENV(pTsdb);
-  SSmaStat *pStat = SMA_ENV_STAT(pEnv);
-  SHashObj *pItemsHash = SMA_ENV_STAT_ITEMS(pEnv);
-
-  TASSERT(pEnv && pStat && pItemsHash);
-
-  // basic procedure
-  // TODO: optimization
-  tsdbRefSmaStat(pTsdb, pStat);
-
-  SSubmitMsgIter msgIter = {0};
-  SSubmitBlk    *pBlock = NULL;
-  SInterval      interval = {0};
-  TSKEY          lastWinSKey = INT64_MIN;
-
-  if (tInitSubmitMsgIter(pMsg, &msgIter) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_FAILED;
-  }
-
-  while (true) {
-    tGetSubmitMsgNext(&msgIter, &pBlock);
-    if (!pBlock) break;
-
-    STSmaWrapper *pSW = NULL;
-    STSma        *pTSma = NULL;
-
-    SSubmitBlkIter blkIter = {0};
-    if (tInitSubmitBlkIter(&msgIter, pBlock, &blkIter) != TSDB_CODE_SUCCESS) {
-      pSW = tdFreeTSmaWrapper(pSW);
-      break;
-    }
-
-    while (true) {
-      STSRow *row = tGetSubmitBlkNext(&blkIter);
-      if (!row) {
-        tdFreeTSmaWrapper(pSW);
-        break;
-      }
-      if (!pSW || (pTSma->tableUid != pBlock->suid)) {
-        if (pSW) {
-          pSW = tdFreeTSmaWrapper(pSW);
-        }
-        if (!(pSW = metaGetSmaInfoByTable(REPO_META(pTsdb), pBlock->suid))) {
-          break;
-        }
-        if ((pSW->number) <= 0 || !pSW->tSma) {
-          pSW = tdFreeTSmaWrapper(pSW);
-          break;
-        }
-
-        pTSma = pSW->tSma;
-
-        interval.interval = pTSma->interval;
-        interval.intervalUnit = pTSma->intervalUnit;
-        interval.offset = pTSma->offset;
-        interval.precision = REPO_CFG(pTsdb)->precision;
-        interval.sliding = pTSma->sliding;
-        interval.slidingUnit = pTSma->slidingUnit;
-      }
-
-      TSKEY winSKey = taosTimeTruncate(TD_ROW_KEY(row), &interval, interval.precision);
-
-      if (lastWinSKey != winSKey) {
-        lastWinSKey = winSKey;
-        tsdbSetExpiredWindow(pTsdb, pItemsHash, pTSma->indexUid, winSKey, version);
-      } else {
-        tsdbDebug("vgId:%d smaIndex %" PRIi64 ", put skey %" PRIi64 " to expire window ignore as duplicated",
-                  REPO_ID(pTsdb), pTSma->indexUid, winSKey);
-      }
-    }
-  }
-
-  tsdbUnRefSmaStat(pTsdb, pStat);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief When sma data received from stream computing, make the relative expired window valid.
- *
- * @param pTsdb
- * @param pStat
- * @param indexUid
- * @param skey
- * @return int32_t
- */
-static int32_t tsdbResetExpiredWindow(STsdb *pTsdb, SSmaStat *pStat, int64_t indexUid, TSKEY skey) {
-  SSmaStatItem *pItem = NULL;
-
-  tsdbRefSmaStat(pTsdb, pStat);
-
-  if (pStat && SMA_STAT_ITEMS(pStat)) {
-    pItem = taosHashGet(SMA_STAT_ITEMS(pStat), &indexUid, sizeof(indexUid));
-  }
-  if ((pItem) && ((pItem = *(SSmaStatItem **)pItem))) {
-    // pItem resides in hash buffer all the time unless drop sma index
-    // TODO: multithread protect
-    if (taosHashRemove(pItem->expiredWindows, &skey, sizeof(TSKEY)) != 0) {
-      // error handling
-      tsdbUnRefSmaStat(pTsdb, pStat);
-      tsdbWarn("vgId:%d remove skey %" PRIi64 " from expired window for sma index %" PRIi64 " fail", REPO_ID(pTsdb),
-               skey, indexUid);
-      return TSDB_CODE_FAILED;
-    }
-    tsdbDebug("vgId:%d remove skey %" PRIi64 " from expired window for sma index %" PRIi64 " succeed", REPO_ID(pTsdb),
-              skey, indexUid);
-    // TODO: use a standalone interface to received state upate notification from stream computing module.
-    /**
-     * @brief state
-     *  - When SMA env init in TSDB, its status is TSDB_SMA_STAT_OK.
-     *  - In startup phase of stream computing module, it should notify the SMA env in TSDB to expired if needed(e.g.
-     * when batch data caculation not finised)
-     *  - When TSDB_SMA_STAT_OK, the stream computing module should also notify that to the SMA env in TSDB.
-     */
-    pItem->state = TSDB_SMA_STAT_OK;
-  } else {
-    // error handling
-    tsdbUnRefSmaStat(pTsdb, pStat);
-    tsdbWarn("vgId:%d expired window %" PRIi64 " not exists for sma index %" PRIi64, REPO_ID(pTsdb), skey, indexUid);
-    return TSDB_CODE_FAILED;
-  }
-
-  tsdbUnRefSmaStat(pTsdb, pStat);
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief Judge the tSma storage level
- *
- * @param interval
- * @param intervalUnit
- * @return int32_t
- */
-static int32_t tsdbGetSmaStorageLevel(int64_t interval, int8_t intervalUnit) {
-  // TODO: configurable for SMA_STORAGE_SPLIT_HOURS?
-  switch (intervalUnit) {
-    case TIME_UNIT_HOUR:
-      if (interval < SMA_STORAGE_SPLIT_HOURS) {
-        return SMA_STORAGE_LEVEL_DFILESET;
-      }
-      break;
-    case TIME_UNIT_MINUTE:
-      if (interval < 60 * SMA_STORAGE_SPLIT_HOURS) {
-        return SMA_STORAGE_LEVEL_DFILESET;
-      }
-      break;
-    case TIME_UNIT_SECOND:
-      if (interval < 3600 * SMA_STORAGE_SPLIT_HOURS) {
-        return SMA_STORAGE_LEVEL_DFILESET;
-      }
-      break;
-    case TIME_UNIT_MILLISECOND:
-      if (interval < 3600 * 1e3 * SMA_STORAGE_SPLIT_HOURS) {
-        return SMA_STORAGE_LEVEL_DFILESET;
-      }
-      break;
-    case TIME_UNIT_MICROSECOND:
-      if (interval < 3600 * 1e6 * SMA_STORAGE_SPLIT_HOURS) {
-        return SMA_STORAGE_LEVEL_DFILESET;
-      }
-      break;
-    case TIME_UNIT_NANOSECOND:
-      if (interval < 3600 * 1e9 * SMA_STORAGE_SPLIT_HOURS) {
-        return SMA_STORAGE_LEVEL_DFILESET;
-      }
-      break;
-    default:
-      break;
-  }
-  return SMA_STORAGE_LEVEL_TSDB;
-}
-
-/**
- * @brief Insert TSma data blocks to DB File build by B+Tree
- *
- * @param pSmaH
- * @param smaKey  tableUid-colId-skeyOfWindow(8-2-8)
- * @param keyLen
- * @param pData
- * @param dataLen
- * @return int32_t
- */
-static int32_t tsdbInsertTSmaBlocks(STSmaWriteH *pSmaH, void *smaKey, int32_t keyLen, void *pData, int32_t dataLen,
-                                    TXN *txn) {
-  SDBFile *pDBFile = &pSmaH->dFile;
-
-  // TODO: insert tsma data blocks into B+Tree(TTB)
-  if (tsdbSaveSmaToDB(pDBFile, smaKey, keyLen, pData, dataLen, txn) != 0) {
-    tsdbWarn("vgId:%d insert tsma data blocks into %s: smaKey %" PRIx64 "-%" PRIx64 ", dataLen %" PRIu32 " fail",
-             REPO_ID(pSmaH->pTsdb), pDBFile->path, *(int64_t *)smaKey, *(int64_t *)POINTER_SHIFT(smaKey, 8), dataLen);
-    return TSDB_CODE_FAILED;
-  }
-  tsdbDebug("vgId:%d insert tsma data blocks into %s: smaKey %" PRIx64 "-%" PRIx64 ", dataLen %" PRIu32 " succeed",
-            REPO_ID(pSmaH->pTsdb), pDBFile->path, *(int64_t *)smaKey, *(int64_t *)POINTER_SHIFT(smaKey, 8), dataLen);
-
-#ifdef _TEST_SMA_PRINT_DEBUG_LOG_
-  uint32_t valueSize = 0;
-  void    *data = tsdbGetSmaDataByKey(pDBFile, smaKey, keyLen, &valueSize);
-  ASSERT(data != NULL);
-  for (uint32_t v = 0; v < valueSize; v += 8) {
-    tsdbWarn("vgId:%d insert sma data val[%d] %" PRIi64, REPO_ID(pSmaH->pTsdb), v, *(int64_t *)POINTER_SHIFT(data, v));
-  }
-#endif
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief Approximate value for week/month/year.
- *
- * @param interval
- * @param intervalUnit
- * @param precision
- * @param adjusted Interval already adjusted according to DB precision
- * @return int64_t
- */
-static int64_t tsdbGetIntervalByPrecision(int64_t interval, uint8_t intervalUnit, int8_t precision, bool adjusted) {
-  if (adjusted) {
-    return interval;
-  }
-
-  switch (intervalUnit) {
-    case TIME_UNIT_YEAR:  // approximate value
-      interval *= 365 * 86400 * 1e3;
-      break;
-    case TIME_UNIT_MONTH:  // approximate value
-      interval *= 30 * 86400 * 1e3;
-      break;
-    case TIME_UNIT_WEEK:  // approximate value
-      interval *= 7 * 86400 * 1e3;
-      break;
-    case TIME_UNIT_DAY:  // the interval for tSma calculation must <= day
-      interval *= 86400 * 1e3;
-      break;
-    case TIME_UNIT_HOUR:
-      interval *= 3600 * 1e3;
-      break;
-    case TIME_UNIT_MINUTE:
-      interval *= 60 * 1e3;
-      break;
-    case TIME_UNIT_SECOND:
-      interval *= 1e3;
-      break;
-    default:
-      break;
-  }
-
-  switch (precision) {
-    case TSDB_TIME_PRECISION_MILLI:
-      if (TIME_UNIT_MICROSECOND == intervalUnit) {  // us
-        return interval / 1e3;
-      } else if (TIME_UNIT_NANOSECOND == intervalUnit) {  //  nano second
-        return interval / 1e6;
-      } else {  // ms
-        return interval;
-      }
-      break;
-    case TSDB_TIME_PRECISION_MICRO:
-      if (TIME_UNIT_MICROSECOND == intervalUnit) {  // us
-        return interval;
-      } else if (TIME_UNIT_NANOSECOND == intervalUnit) {  //  ns
-        return interval / 1e3;
-      } else {  // ms
-        return interval * 1e3;
-      }
-      break;
-    case TSDB_TIME_PRECISION_NANO:
-      if (TIME_UNIT_MICROSECOND == intervalUnit) {  // us
-        return interval * 1e3;
-      } else if (TIME_UNIT_NANOSECOND == intervalUnit) {  // ns
-        return interval;
-      } else {  // ms
-        return interval * 1e6;
-      }
-      break;
-    default:                                        // ms
-      if (TIME_UNIT_MICROSECOND == intervalUnit) {  // us
-        return interval / 1e3;
-      } else if (TIME_UNIT_NANOSECOND == intervalUnit) {  //  ns
-        return interval / 1e6;
-      } else {  // ms
-        return interval;
-      }
-      break;
-  }
-  return interval;
-}
-
-static int32_t tsdbInitTSmaWriteH(STSmaWriteH *pSmaH, STsdb *pTsdb, const SArray *pDataBlocks, int64_t interval,
-                                  int8_t intervalUnit) {
-  pSmaH->pTsdb = pTsdb;
-  pSmaH->interval = tsdbGetIntervalByPrecision(interval, intervalUnit, REPO_CFG(pTsdb)->precision, true);
-  pSmaH->pDataBlocks = pDataBlocks;
-  pSmaH->dFile.fid = TSDB_IVLD_FID;
-  return TSDB_CODE_SUCCESS;
-}
-
-static void tsdbDestroyTSmaWriteH(STSmaWriteH *pSmaH) {
-  if (pSmaH) {
-    tsdbCloseDBF(&pSmaH->dFile);
-  }
-}
-
-static int32_t tsdbSetTSmaDataFile(STSmaWriteH *pSmaH, int64_t indexUid, int32_t fid) {
-  STsdb *pTsdb = pSmaH->pTsdb;
-  ASSERT(!pSmaH->dFile.path && !pSmaH->dFile.pDB);
-
-  pSmaH->dFile.fid = fid;
-  char tSmaFile[TSDB_FILENAME_LEN] = {0};
-  snprintf(tSmaFile, TSDB_FILENAME_LEN, "%" PRIi64 "%sv%df%d.tsma", indexUid, TD_DIRSEP, REPO_ID(pTsdb), fid);
-  pSmaH->dFile.path = strdup(tSmaFile);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief
- *
- * @param pTsdb
- * @param interval Interval calculated by DB's precision
- * @param storageLevel
- * @return int32_t
- */
-static int32_t tsdbGetTSmaDays(STsdb *pTsdb, int64_t interval, int32_t storageLevel) {
-  STsdbKeepCfg *pCfg = REPO_KEEP_CFG(pTsdb);
-  int32_t       daysPerFile = pCfg->days;
-
-  if (storageLevel == SMA_STORAGE_LEVEL_TSDB) {
-    int32_t days = SMA_STORAGE_TSDB_TIMES * (interval / tsTickPerMin[pCfg->precision]);
-    daysPerFile = days > SMA_STORAGE_TSDB_DAYS ? days : SMA_STORAGE_TSDB_DAYS;
-  }
-
-  return daysPerFile;
-}
-
-static int tsdbSmaBeginCommit(SSmaEnv *pEnv) {
-  TXN *pTxn = &pEnv->txn;
-  // start a new txn
-  tdbTxnOpen(pTxn, 0, poolMalloc, poolFree, pEnv->pPool, TDB_TXN_WRITE | TDB_TXN_READ_UNCOMMITTED);
-  if (tdbBegin(pEnv->dbEnv, pTxn) != 0) {
-    tsdbWarn("tsdbSma tdb begin commit fail");
-    return -1;
-  }
-  return 0;
-}
-
-static int tsdbSmaEndCommit(SSmaEnv *pEnv) {
-  TXN *pTxn = &pEnv->txn;
-
-  // Commit current txn
-  if (tdbCommit(pEnv->dbEnv, pTxn) != 0) {
-    tsdbWarn("tsdbSma tdb end commit fail");
-    return -1;
-  }
-  tdbTxnClose(pTxn);
-  clearPool(pEnv->pPool);
-  return 0;
-}
-
-/**
- * @brief Insert/Update Time-range-wise SMA data.
- *  - If interval < SMA_STORAGE_SPLIT_HOURS(e.g. 24), save the SMA data as a part of DFileSet to e.g.
- * v3f1900.tsma.${sma_index_name}. The days is the same with that for TS data files.
- *  - If interval >= SMA_STORAGE_SPLIT_HOURS, save the SMA data to e.g. vnode3/tsma/v3f632.tsma.${sma_index_name}. The
- * days is 30 times of the interval, and the minimum days is SMA_STORAGE_TSDB_DAYS(30d).
- *  - The destination file of one data block for some interval is determined by its start TS key.
- *
- * @param pTsdb
- * @param msg
- * @return int32_t
- */
-static int32_t tsdbInsertTSmaDataImpl(STsdb *pTsdb, int64_t indexUid, const char *msg) {
-  STsdbCfg     *pCfg = REPO_CFG(pTsdb);
-  const SArray *pDataBlocks = (const SArray *)msg;
-
-  // TODO: destroy SSDataBlocks(msg)
-
-  // For super table aggregation, the sma data is stored in vgroup calculated from the hash value of stable name. Thus
-  // the sma data would arrive ahead of the update-expired-window msg.
-  if (tsdbCheckAndInitSmaEnv(pTsdb, TSDB_SMA_TYPE_TIME_RANGE) != TSDB_CODE_SUCCESS) {
-    terrno = TSDB_CODE_TDB_INIT_FAILED;
-    return TSDB_CODE_FAILED;
-  }
-
-  if (!pDataBlocks) {
-    terrno = TSDB_CODE_INVALID_PTR;
-    tsdbWarn("vgId:%d insert tSma data failed since pDataBlocks is NULL", REPO_ID(pTsdb));
-    return terrno;
-  }
-
-  if (taosArrayGetSize(pDataBlocks) <= 0) {
-    terrno = TSDB_CODE_INVALID_PARA;
-    tsdbWarn("vgId:%d insert tSma data failed since pDataBlocks is empty", REPO_ID(pTsdb));
-    return TSDB_CODE_FAILED;
-  }
-
-  SSmaEnv      *pEnv = REPO_TSMA_ENV(pTsdb);
-  SSmaStat     *pStat = SMA_ENV_STAT(pEnv);
-  SSmaStatItem *pItem = NULL;
-
-  tsdbRefSmaStat(pTsdb, pStat);
-
-  if (pStat && SMA_STAT_ITEMS(pStat)) {
-    pItem = taosHashGet(SMA_STAT_ITEMS(pStat), &indexUid, sizeof(indexUid));
-  }
-
-  if (!pItem || !(pItem = *(SSmaStatItem **)pItem) || tsdbSmaStatIsDropped(pItem)) {
-    terrno = TSDB_CODE_TDB_INVALID_SMA_STAT;
-    tsdbUnRefSmaStat(pTsdb, pStat);
-    return TSDB_CODE_FAILED;
-  }
-
-  STSma      *pSma = pItem->pSma;
-  STSmaWriteH tSmaH = {0};
-
-  if (tsdbInitTSmaWriteH(&tSmaH, pTsdb, pDataBlocks, pSma->interval, pSma->intervalUnit) != 0) {
-    return TSDB_CODE_FAILED;
-  }
-
-  char rPath[TSDB_FILENAME_LEN] = {0};
-  char aPath[TSDB_FILENAME_LEN] = {0};
-  snprintf(rPath, TSDB_FILENAME_LEN, "%s%s%" PRIi64, SMA_ENV_PATH(pEnv), TD_DIRSEP, indexUid);
-  tfsAbsoluteName(REPO_TFS(pTsdb), SMA_ENV_DID(pEnv), rPath, aPath);
-  if (!taosCheckExistFile(aPath)) {
-    if (tfsMkdirRecurAt(REPO_TFS(pTsdb), rPath, SMA_ENV_DID(pEnv)) != TSDB_CODE_SUCCESS) {
-      tsdbUnRefSmaStat(pTsdb, pStat);
-      return TSDB_CODE_FAILED;
-    }
-  }
-
-  // Step 1: Judge the storage level and days
-  int32_t storageLevel = tsdbGetSmaStorageLevel(pSma->interval, pSma->intervalUnit);
-  int32_t daysPerFile = tsdbGetTSmaDays(pTsdb, tSmaH.interval, storageLevel);
-
-  char    smaKey[SMA_KEY_LEN] = {0};  // key: skey + groupId
-  char    dataBuf[512] = {0};         // val: aggr data // TODO: handle 512 buffer?
-  void   *pDataBuf = NULL;
-  int32_t sz = taosArrayGetSize(pDataBlocks);
-  for (int32_t i = 0; i < sz; ++i) {
-    SSDataBlock *pDataBlock = taosArrayGet(pDataBlocks, i);
-    int32_t      colNum = pDataBlock->info.numOfCols;
-    int32_t      rows = pDataBlock->info.rows;
-    int32_t      rowSize = pDataBlock->info.rowSize;
-    int64_t      groupId = pDataBlock->info.groupId;
-    for (int32_t j = 0; j < rows; ++j) {
-      printf("|");
-      TSKEY skey = TSKEY_INITIAL_VAL;  //  the start key of TS window by interval
-      void *pSmaKey = &smaKey;
-      bool  isStartKey = false;
-
-      int32_t tlen = 0;     // reset the len
-      pDataBuf = &dataBuf;  // reset the buf
-      for (int32_t k = 0; k < colNum; ++k) {
-        SColumnInfoData *pColInfoData = taosArrayGet(pDataBlock->pDataBlock, k);
-        void            *var = POINTER_SHIFT(pColInfoData->pData, j * pColInfoData->info.bytes);
-        switch (pColInfoData->info.type) {
-          case TSDB_DATA_TYPE_TIMESTAMP:
-            if (!isStartKey) {
-              isStartKey = true;
-              skey = *(TSKEY *)var;
-              printf("= skey %" PRIi64 " groupId = %" PRIi64 "|", skey, groupId);
-              tsdbEncodeTSmaKey(groupId, skey, &pSmaKey);
-            } else {
-              printf(" %" PRIi64 " |", *(int64_t *)var);
-              tlen += taosEncodeFixedI64(&pDataBuf, *(int64_t *)var);
-              break;
-            }
-            break;
-          case TSDB_DATA_TYPE_BOOL:
-          case TSDB_DATA_TYPE_UTINYINT:
-            printf(" %15d |", *(uint8_t *)var);
-            tlen += taosEncodeFixedU8(&pDataBuf, *(uint8_t *)var);
-            break;
-          case TSDB_DATA_TYPE_TINYINT:
-            printf(" %15d |", *(int8_t *)var);
-            tlen += taosEncodeFixedI8(&pDataBuf, *(int8_t *)var);
-            break;
-          case TSDB_DATA_TYPE_SMALLINT:
-            printf(" %15d |", *(int16_t *)var);
-            tlen += taosEncodeFixedI16(&pDataBuf, *(int16_t *)var);
-            break;
-          case TSDB_DATA_TYPE_USMALLINT:
-            printf(" %15d |", *(uint16_t *)var);
-            tlen += taosEncodeFixedU16(&pDataBuf, *(uint16_t *)var);
-            break;
-          case TSDB_DATA_TYPE_INT:
-            printf(" %15d |", *(int32_t *)var);
-            tlen += taosEncodeFixedI32(&pDataBuf, *(int32_t *)var);
-            break;
-          case TSDB_DATA_TYPE_FLOAT:
-            printf(" %15f |", *(float *)var);
-            tlen += taosEncodeBinary(&pDataBuf, var, sizeof(float));
-            break;
-          case TSDB_DATA_TYPE_UINT:
-            printf(" %15u |", *(uint32_t *)var);
-            tlen += taosEncodeFixedU32(&pDataBuf, *(uint32_t *)var);
-            break;
-          case TSDB_DATA_TYPE_BIGINT:
-            printf(" %15ld |", *(int64_t *)var);
-            tlen += taosEncodeFixedI64(&pDataBuf, *(int64_t *)var);
-            break;
-          case TSDB_DATA_TYPE_DOUBLE:
-            printf(" %15lf |", *(double *)var);
-            tlen += taosEncodeBinary(&pDataBuf, var, sizeof(double));
-          case TSDB_DATA_TYPE_UBIGINT:
-            printf(" %15lu |", *(uint64_t *)var);
-            tlen += taosEncodeFixedU64(&pDataBuf, *(uint64_t *)var);
-            break;
-          case TSDB_DATA_TYPE_NCHAR: {
-            char tmpChar[100] = {0};
-            strncpy(tmpChar, varDataVal(var), varDataLen(var));
-            printf(" %s |", tmpChar);
-            tlen += taosEncodeBinary(&pDataBuf, varDataVal(var), varDataLen(var));
-            break;
-          }
-          case TSDB_DATA_TYPE_VARCHAR: {  // TSDB_DATA_TYPE_BINARY
-            char tmpChar[100] = {0};
-            strncpy(tmpChar, varDataVal(var), varDataLen(var));
-            printf(" %s |", tmpChar);
-            tlen += taosEncodeBinary(&pDataBuf, varDataVal(var), varDataLen(var));
-            break;
-          }
-          case TSDB_DATA_TYPE_VARBINARY:
-            // TODO: add binary/varbinary
-            TASSERT(0);
-          default:
-            printf("the column type %" PRIi16 " is undefined\n", pColInfoData->info.type);
-            TASSERT(0);
-            break;
-        }
-      }
-      // if ((tlen > 0) && (skey != TSKEY_INITIAL_VAL)) {
-      if (tlen > 0) {
-        int32_t fid = (int32_t)(TSDB_KEY_FID(skey, daysPerFile, pCfg->precision));
-
-        // Step 2: Set the DFile for storage of SMA index, and iterate/split the TSma data and store to B+Tree index
-        // file
-        //         - Set and open the DFile or the B+Tree file
-        // TODO: tsdbStartTSmaCommit();
-        if (fid != tSmaH.dFile.fid) {
-          if (tSmaH.dFile.fid != TSDB_IVLD_FID) {
-            tsdbSmaEndCommit(pEnv);
-            tsdbCloseDBF(&tSmaH.dFile);
-          }
-          tsdbSetTSmaDataFile(&tSmaH, indexUid, fid);
-          if (tsdbOpenDBF(pEnv->dbEnv, &tSmaH.dFile) != 0) {
-            tsdbWarn("vgId:%d open DB file %s failed since %s", REPO_ID(pTsdb),
-                     tSmaH.dFile.path ? tSmaH.dFile.path : "path is NULL", tstrerror(terrno));
-            tsdbDestroyTSmaWriteH(&tSmaH);
-            tsdbUnRefSmaStat(pTsdb, pStat);
-            return TSDB_CODE_FAILED;
-          }
-          tsdbSmaBeginCommit(pEnv);
-        }
-
-        if (tsdbInsertTSmaBlocks(&tSmaH, &smaKey, SMA_KEY_LEN, dataBuf, tlen, &pEnv->txn) != 0) {
-          tsdbWarn("vgId:%d insert tsma data blocks fail for index %" PRIi64 ", skey %" PRIi64 ", groupId %" PRIi64
-                   " since %s",
-                   REPO_ID(pTsdb), indexUid, skey, groupId, tstrerror(terrno));
-          tsdbSmaEndCommit(pEnv);
-          tsdbDestroyTSmaWriteH(&tSmaH);
-          tsdbUnRefSmaStat(pTsdb, pStat);
-          return TSDB_CODE_FAILED;
-        }
-        tsdbDebug("vgId:%d insert tsma data blocks success for index %" PRIi64 ", skey %" PRIi64 ", groupId %" PRIi64,
-                  REPO_ID(pTsdb), indexUid, skey, groupId);
-        // TODO:tsdbEndTSmaCommit();
-
-        // Step 3: reset the SSmaStat
-        tsdbResetExpiredWindow(pTsdb, pStat, indexUid, skey);
-      } else {
-        tsdbWarn("vgId:%d invalid data skey:%" PRIi64 ", tlen %" PRIi32 " during insert tSma data for %" PRIi64,
-                 REPO_ID(pTsdb), skey, tlen, indexUid);
-      }
-
-      printf("\n");
-    }
-  }
-  tsdbSmaEndCommit(pEnv);  // TODO: not commit for every insert
-  tsdbDestroyTSmaWriteH(&tSmaH);
-  tsdbUnRefSmaStat(pTsdb, pStat);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief Drop tSma data and local cache
- *        - insert/query reference
- * @param pTsdb
- * @param msg
- * @return int32_t
- */
-static int32_t tsdbDropTSmaDataImpl(STsdb *pTsdb, int64_t indexUid) {
-  SSmaEnv *pEnv = atomic_load_ptr(&REPO_TSMA_ENV(pTsdb));
-
-  // clear local cache
-  if (pEnv) {
-    tsdbDebug("vgId:%d drop tSma local cache for %" PRIi64, REPO_ID(pTsdb), indexUid);
-
-    SSmaStatItem *pItem = taosHashGet(SMA_ENV_STAT_ITEMS(pEnv), &indexUid, sizeof(indexUid));
-    if ((pItem) || ((pItem = *(SSmaStatItem **)pItem))) {
-      if (tsdbSmaStatIsDropped(pItem)) {
-        tsdbDebug("vgId:%d tSma stat is already dropped for %" PRIi64, REPO_ID(pTsdb), indexUid);
-        return TSDB_CODE_TDB_INVALID_ACTION;  // TODO: duplicate drop msg would be intercepted by mnode
-      }
-
-      tsdbWLockSma(pEnv);
-      if (tsdbSmaStatIsDropped(pItem)) {
-        tsdbUnLockSma(pEnv);
-        tsdbDebug("vgId:%d tSma stat is already dropped for %" PRIi64, REPO_ID(pTsdb), indexUid);
-        return TSDB_CODE_TDB_INVALID_ACTION;  // TODO: duplicate drop msg would be intercepted by mnode
-      }
-      tsdbSmaStatSetDropped(pItem);
-      tsdbUnLockSma(pEnv);
-
-      int32_t nSleep = 0;
-      int32_t refVal = INT32_MAX;
-      while (true) {
-        if ((refVal = T_REF_VAL_GET(SMA_ENV_STAT(pEnv))) <= 0) {
-          tsdbDebug("vgId:%d drop index %" PRIi64 " since refVal=%d", REPO_ID(pTsdb), indexUid, refVal);
-          break;
-        }
-        tsdbDebug("vgId:%d wait 1s to drop index %" PRIi64 " since refVal=%d", REPO_ID(pTsdb), indexUid, refVal);
-        taosSsleep(1);
-        if (++nSleep > SMA_DROP_EXPIRED_TIME) {
-          tsdbDebug("vgId:%d drop index %" PRIi64 " after wait %d (refVal=%d)", REPO_ID(pTsdb), indexUid, nSleep,
-                    refVal);
-          break;
-        };
-      }
-
-      tsdbFreeSmaStatItem(pItem);
-      tsdbDebug("vgId:%d getTSmaDataImpl failed since no index %" PRIi64 " in local cache", REPO_ID(pTsdb), indexUid);
-    }
-  }
-  // clear sma data files
-  // TODO:
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t tsdbSetRSmaDataFile(STSmaWriteH *pSmaH, int32_t fid) {
-  STsdb *pTsdb = pSmaH->pTsdb;
-
-  char tSmaFile[TSDB_FILENAME_LEN] = {0};
-  snprintf(tSmaFile, TSDB_FILENAME_LEN, "v%df%d.rsma", REPO_ID(pTsdb), fid);
-  pSmaH->dFile.path = strdup(tSmaFile);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t tsdbInsertRSmaDataImpl(STsdb *pTsdb, const char *msg) {
-  STsdbCfg     *pCfg = REPO_CFG(pTsdb);
-  const SArray *pDataBlocks = (const SArray *)msg;
-  SSmaEnv      *pEnv = atomic_load_ptr(&REPO_RSMA_ENV(pTsdb));
-  int64_t       indexUid = SMA_TEST_INDEX_UID;
-
-  if (!pEnv) {
-    terrno = TSDB_CODE_INVALID_PTR;
-    tsdbWarn("vgId:%d insert rSma data failed since pTSmaEnv is NULL", REPO_ID(pTsdb));
-    return terrno;
-  }
-
-  if (!pDataBlocks) {
-    terrno = TSDB_CODE_INVALID_PTR;
-    tsdbWarn("vgId:%d insert rSma data failed since pDataBlocks is NULL", REPO_ID(pTsdb));
-    return terrno;
-  }
-
-  if (taosArrayGetSize(pDataBlocks) <= 0) {
-    terrno = TSDB_CODE_INVALID_PARA;
-    tsdbWarn("vgId:%d insert rSma data failed since pDataBlocks is empty", REPO_ID(pTsdb));
-    return TSDB_CODE_FAILED;
-  }
-
-  SSmaStat     *pStat = SMA_ENV_STAT(pEnv);
-  SSmaStatItem *pItem = NULL;
-
-  tsdbRefSmaStat(pTsdb, pStat);
-
-  if (pStat && SMA_STAT_ITEMS(pStat)) {
-    pItem = taosHashGet(SMA_STAT_ITEMS(pStat), &indexUid, sizeof(indexUid));
-  }
-
-  if (!pItem || !(pItem = *(SSmaStatItem **)pItem) || tsdbSmaStatIsDropped(pItem)) {
-    terrno = TSDB_CODE_TDB_INVALID_SMA_STAT;
-    tsdbUnRefSmaStat(pTsdb, pStat);
-    return TSDB_CODE_FAILED;
-  }
-
-  STSma *pSma = pItem->pSma;
-
-  STSmaWriteH tSmaH = {0};
-
-  if (tsdbInitTSmaWriteH(&tSmaH, pTsdb, pDataBlocks, pSma->interval, pSma->intervalUnit) != 0) {
-    return TSDB_CODE_FAILED;
-  }
-
-  char rPath[TSDB_FILENAME_LEN] = {0};
-  char aPath[TSDB_FILENAME_LEN] = {0};
-  snprintf(rPath, TSDB_FILENAME_LEN, "%s%s%" PRIi64, SMA_ENV_PATH(pEnv), TD_DIRSEP, indexUid);
-  tfsAbsoluteName(REPO_TFS(pTsdb), SMA_ENV_DID(pEnv), rPath, aPath);
-  if (!taosCheckExistFile(aPath)) {
-    if (tfsMkdirRecurAt(REPO_TFS(pTsdb), rPath, SMA_ENV_DID(pEnv)) != TSDB_CODE_SUCCESS) {
-      return TSDB_CODE_FAILED;
-    }
-  }
-
-  // Step 1: Judge the storage level and days
-  int32_t storageLevel = tsdbGetSmaStorageLevel(pSma->interval, pSma->intervalUnit);
-  int32_t daysPerFile = tsdbGetTSmaDays(pTsdb, tSmaH.interval, storageLevel);
-#if 0
-  int32_t fid = (int32_t)(TSDB_KEY_FID(pData->skey, daysPerFile, pCfg->precision));
-
-  // Step 2: Set the DFile for storage of SMA index, and iterate/split the TSma data and store to B+Tree index file
-  //         - Set and open the DFile or the B+Tree file
-  // TODO: tsdbStartTSmaCommit();
-  tsdbSetTSmaDataFile(&tSmaH, pData, indexUid, fid);
-  if (tsdbOpenDBF(pTsdb->pTSmaEnv->dbEnv, &tSmaH.dFile) != 0) {
-    tsdbWarn("vgId:%d open DB file %s failed since %s", REPO_ID(pTsdb),
-             tSmaH.dFile.path ? tSmaH.dFile.path : "path is NULL", tstrerror(terrno));
-    tsdbDestroyTSmaWriteH(&tSmaH);
-    return TSDB_CODE_FAILED;
-  }
-
-  if (tsdbInsertTSmaDataSection(&tSmaH, pData) != 0) {
-    tsdbWarn("vgId:%d insert tSma data section failed since %s", REPO_ID(pTsdb), tstrerror(terrno));
-    tsdbDestroyTSmaWriteH(&tSmaH);
-    return TSDB_CODE_FAILED;
-  }
-  // TODO:tsdbEndTSmaCommit();
-
-  // Step 3: reset the SSmaStat
-  tsdbResetExpiredWindow(pTsdb, SMA_ENV_STAT(pTsdb->pTSmaEnv), pData->indexUid, pData->skey);
-#endif
-
-  tsdbDestroyTSmaWriteH(&tSmaH);
-  tsdbUnRefSmaStat(pTsdb, pStat);
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief
- *
- * @param pSmaH
- * @param pTsdb
- * @param interval
- * @param intervalUnit
- * @return int32_t
- */
-static int32_t tsdbInitTSmaReadH(STSmaReadH *pSmaH, STsdb *pTsdb, int64_t interval, int8_t intervalUnit) {
-  pSmaH->pTsdb = pTsdb;
-  pSmaH->interval = tsdbGetIntervalByPrecision(interval, intervalUnit, REPO_CFG(pTsdb)->precision, true);
-  pSmaH->storageLevel = tsdbGetSmaStorageLevel(interval, intervalUnit);
-  pSmaH->days = tsdbGetTSmaDays(pTsdb, pSmaH->interval, pSmaH->storageLevel);
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief Init of tSma FS
- *
- * @param pReadH
- * @param indexUid
- * @param skey
- * @return int32_t
- */
-static int32_t tsdbInitTSmaFile(STSmaReadH *pSmaH, int64_t indexUid, TSKEY skey) {
-  STsdb *pTsdb = pSmaH->pTsdb;
-
-  int32_t fid = (int32_t)(TSDB_KEY_FID(skey, pSmaH->days, REPO_CFG(pTsdb)->precision));
-  char    tSmaFile[TSDB_FILENAME_LEN] = {0};
-  snprintf(tSmaFile, TSDB_FILENAME_LEN, "%" PRIi64 "%sv%df%d.tsma", indexUid, TD_DIRSEP, REPO_ID(pTsdb), fid);
-  pSmaH->dFile.path = strdup(tSmaFile);
-  pSmaH->smaFsIter.iter = 0;
-  pSmaH->smaFsIter.fid = fid;
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief Set and open tSma file if it has key locates in queryWin.
- *
- * @param pReadH
- * @param param
- * @param queryWin
- * @return true
- * @return false
- */
-static bool tsdbSetAndOpenTSmaFile(STSmaReadH *pReadH, TSKEY *queryKey) {
-  SArray *smaFs = pReadH->pTsdb->fs->cstatus->sf;
-  int32_t nSmaFs = taosArrayGetSize(smaFs);
-
-  tsdbCloseDBF(&pReadH->dFile);
-
-#if 0
-  while (pReadH->smaFsIter.iter < nSmaFs) {
-    void *pSmaFile = taosArrayGet(smaFs, pReadH->smaFsIter.iter);
-    if (pSmaFile) {  // match(indexName, queryWindow)
-      // TODO: select the file by index_name ...
-      pReadH->dFile = pSmaFile;
-      ++pReadH->smaFsIter.iter;
-      break;
-    }
-    ++pReadH->smaFsIter.iter;
-  }
-
-  if (pReadH->pDFile) {
-    tsdbDebug("vg%d: smaFile %s matched", REPO_ID(pReadH->pTsdb), "[pSmaFile dir]");
-    return true;
-  }
-#endif
-
-  return false;
-}
-
-/**
- * @brief
- *
- * @param pTsdb Return the data between queryWin and fill the pData.
- * @param pData
- * @param indexUid
- * @param pQuerySKey
- * @param nMaxResult The query invoker should control the nMaxResult need to return to avoid OOM.
- * @return int32_t
- */
-static int32_t tsdbGetTSmaDataImpl(STsdb *pTsdb, char *pData, int64_t indexUid, TSKEY querySKey, int32_t nMaxResult) {
-  SSmaEnv  *pEnv = atomic_load_ptr(&REPO_TSMA_ENV(pTsdb));
-  SSmaStat *pStat = NULL;
-
-  if (!pEnv) {
-    terrno = TSDB_CODE_INVALID_PTR;
-    tsdbWarn("vgId:%d getTSmaDataImpl failed since pTSmaEnv is NULL", REPO_ID(pTsdb));
-    return TSDB_CODE_FAILED;
-  }
-
-  pStat = SMA_ENV_STAT(pEnv);
-
-  tsdbRefSmaStat(pTsdb, pStat);
-  SSmaStatItem *pItem = taosHashGet(SMA_ENV_STAT_ITEMS(pEnv), &indexUid, sizeof(indexUid));
-  if (!pItem || !(pItem = *(SSmaStatItem **)pItem)) {
-    // Normally pItem should not be NULL, mark all windows as expired and notify query module to fetch raw TS data if
-    // it's NULL.
-    tsdbUnRefSmaStat(pTsdb, pStat);
-    terrno = TSDB_CODE_TDB_INVALID_ACTION;
-    tsdbDebug("vgId:%d getTSmaDataImpl failed since no index %" PRIi64, REPO_ID(pTsdb), indexUid);
-    return TSDB_CODE_FAILED;
-  }
-
-#if 0
-  int32_t nQueryWin = taosArrayGetSize(pQuerySKey);
-  for (int32_t n = 0; n < nQueryWin; ++n) {
-    TSKEY skey = taosArrayGet(pQuerySKey, n);
-    if (taosHashGet(pItem->expiredWindows, &skey, sizeof(TSKEY))) {
-      // TODO: mark this window as expired.
-    }
-  }
-#endif
-
-#if 1
-  int8_t smaStat = 0;
-  if (!tsdbSmaStatIsOK(pItem, &smaStat)) {  // TODO: multiple check for large scale sma query
-    tsdbUnRefSmaStat(pTsdb, pStat);
-    terrno = TSDB_CODE_TDB_INVALID_SMA_STAT;
-    tsdbWarn("vgId:%d getTSmaDataImpl failed from index %" PRIi64 " since %s %" PRIi8, REPO_ID(pTsdb), indexUid,
-             tstrerror(terrno), smaStat);
-    return TSDB_CODE_FAILED;
-  }
-
-  if (taosHashGet(pItem->expiredWindows, &querySKey, sizeof(TSKEY))) {
-    // TODO: mark this window as expired.
-    tsdbDebug("vgId:%d skey %" PRIi64 " of window exists in expired window for index %" PRIi64, REPO_ID(pTsdb),
-              querySKey, indexUid);
-  } else {
-    tsdbDebug("vgId:%d skey %" PRIi64 " of window not in expired window for index %" PRIi64, REPO_ID(pTsdb), querySKey,
-              indexUid);
-  }
-
-  STSma *pTSma = pItem->pSma;
-#endif
-
-  STSmaReadH tReadH = {0};
-  tsdbInitTSmaReadH(&tReadH, pTsdb, pTSma->interval, pTSma->intervalUnit);
-  tsdbCloseDBF(&tReadH.dFile);
-
-  tsdbUnRefSmaStat(pTsdb, pStat);
-
-  tsdbInitTSmaFile(&tReadH, indexUid, querySKey);
-  if (tsdbOpenDBF(pEnv->dbEnv, &tReadH.dFile) != 0) {
-    tsdbWarn("vgId:%d open DBF %s failed since %s", REPO_ID(pTsdb), tReadH.dFile.path, tstrerror(terrno));
-    return TSDB_CODE_FAILED;
-  }
-
-  char    smaKey[SMA_KEY_LEN] = {0};
-  void   *pSmaKey = &smaKey;
-  int64_t queryGroupId = 1;
-  tsdbEncodeTSmaKey(queryGroupId, querySKey, (void **)&pSmaKey);
-
-  tsdbDebug("vgId:%d get sma data from %s: smaKey %" PRIx64 "-%" PRIx64 ", keyLen %d", REPO_ID(pTsdb),
-            tReadH.dFile.path, *(int64_t *)smaKey, *(int64_t *)POINTER_SHIFT(smaKey, 8), SMA_KEY_LEN);
-
-  void   *result = NULL;
-  int32_t valueSize = 0;
-  if (!(result = tsdbGetSmaDataByKey(&tReadH.dFile, smaKey, SMA_KEY_LEN, &valueSize))) {
-    tsdbWarn("vgId:%d get sma data failed from smaIndex %" PRIi64 ", smaKey %" PRIx64 "-%" PRIx64 " since %s",
-             REPO_ID(pTsdb), indexUid, *(int64_t *)smaKey, *(int64_t *)POINTER_SHIFT(smaKey, 8), tstrerror(terrno));
-    tsdbCloseDBF(&tReadH.dFile);
-    return TSDB_CODE_FAILED;
-  }
-
-#ifdef _TEST_SMA_PRINT_DEBUG_LOG_
-  for (uint32_t v = 0; v < valueSize; v += 8) {
-    tsdbWarn("vgId:%d get sma data v[%d]=%" PRIi64, REPO_ID(pTsdb), v, *(int64_t *)POINTER_SHIFT(result, v));
-  }
-#endif
-  taosMemoryFreeClear(result);  // TODO: fill the result to output
-
-#if 0
-  int32_t nResult = 0;
-  int64_t lastKey = 0;
-
-  while (true) {
-    if (nResult >= nMaxResult) {
-      break;
-    }
-
-    // set and open the file according to the STSma param
-    if (tsdbSetAndOpenTSmaFile(&tReadH, queryWin)) {
-      char bTree[100] = "\0";
-      while (strncmp(bTree, "has more nodes", 100) == 0) {
-        if (nResult >= nMaxResult) {
-          break;
-        }
-        // tsdbGetDataFromBTree(bTree, queryWin, lastKey)
-        // fill the pData
-        ++nResult;
-      }
-    }
-  }
-#endif
-  // read data from file and fill the result
-  tsdbCloseDBF(&tReadH.dFile);
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t tsdbCreateTSma(STsdb *pTsdb, char *pMsg) {
-  SSmaCfg vCreateSmaReq = {0};
-  if (!tDeserializeSVCreateTSmaReq(pMsg, &vCreateSmaReq)) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    tsdbWarn("vgId:%d tsma create msg received but deserialize failed since %s", REPO_ID(pTsdb), terrstr(terrno));
-    return -1;
-  }
-
-  tsdbDebug("vgId:%d tsma create msg %s:%" PRIi64 " for table %" PRIi64 " received", REPO_ID(pTsdb),
-            vCreateSmaReq.tSma.indexName, vCreateSmaReq.tSma.indexUid, vCreateSmaReq.tSma.tableUid);
-
-  // record current timezone of server side
-  vCreateSmaReq.tSma.timezoneInt = tsTimezone;
-
-  if (metaCreateTSma(REPO_META(pTsdb), &vCreateSmaReq) < 0) {
-    // TODO: handle error
-    tsdbWarn("vgId:%d tsma %s:%" PRIi64 " create failed for table %" PRIi64 " since %s", REPO_ID(pTsdb),
-             vCreateSmaReq.tSma.indexName, vCreateSmaReq.tSma.indexUid, vCreateSmaReq.tSma.tableUid, terrstr(terrno));
-    tdDestroyTSma(&vCreateSmaReq.tSma);
-    return -1;
-  }
-
-  tsdbTSmaAdd(pTsdb, 1);
-
-  tdDestroyTSma(&vCreateSmaReq.tSma);
-  // TODO: return directly or go on follow steps?
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t tsdbDropTSma(STsdb *pTsdb, char *pMsg) {
-  SVDropTSmaReq vDropSmaReq = {0};
-  if (!tDeserializeSVDropTSmaReq(pMsg, &vDropSmaReq)) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  // TODO: send msg to stream computing to drop tSma
-  // if ((send msg to stream computing) < 0) {
-  //   tdDestroyTSma(&vCreateSmaReq);
-  //   return -1;
-  // }
-  //
-
-  if (metaDropTSma(REPO_META(pTsdb), vDropSmaReq.indexUid) < 0) {
-    // TODO: handle error
-    return -1;
-  }
-
-  if (tsdbDropTSmaData(pTsdb, vDropSmaReq.indexUid) < 0) {
-    // TODO: handle error
-    return -1;
-  }
-
-  tsdbTSmaSub(pTsdb, 1);
-
-  // TODO: return directly or go on follow steps?
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief Check and init qTaskInfo_t, only applicable to stable with SRSmaParam.
- *
- * @param pTsdb
- * @param pMeta
- * @param pReq
- * @return int32_t
- */
-int32_t tsdbRegisterRSma(STsdb *pTsdb, SMeta *pMeta, SVCreateStbReq *pReq, SMsgCb *pMsgCb) {
-  if (!pReq->rollup) {
-    tsdbDebug("vgId:%d return directly since no rollup for stable %s %" PRIi64, REPO_ID(pTsdb), pReq->name, pReq->suid);
-    return TSDB_CODE_SUCCESS;
-  }
-
-  SRSmaParam *param = &pReq->pRSmaParam;
-
-  if ((param->qmsg1Len == 0) && (param->qmsg2Len == 0)) {
-    tsdbWarn("vgId:%d no qmsg1/qmsg2 for rollup stable %s %" PRIi64, REPO_ID(pTsdb), pReq->name, pReq->suid);
-    return TSDB_CODE_SUCCESS;
-  }
-
-  if (tsdbCheckAndInitSmaEnv(pTsdb, TSDB_SMA_TYPE_ROLLUP) != TSDB_CODE_SUCCESS) {
-    terrno = TSDB_CODE_TDB_INIT_FAILED;
-    return TSDB_CODE_FAILED;
-  }
-
-  SSmaEnv   *pEnv = REPO_RSMA_ENV(pTsdb);
-  SSmaStat  *pStat = SMA_ENV_STAT(pEnv);
-  SRSmaInfo *pRSmaInfo = NULL;
-
-  pRSmaInfo = taosHashGet(SMA_STAT_INFO_HASH(pStat), &pReq->suid, sizeof(tb_uid_t));
-  if (pRSmaInfo) {
-    tsdbWarn("vgId:%d rsma info already exists for stb: %s, %" PRIi64, REPO_ID(pTsdb), pReq->name, pReq->suid);
-    return TSDB_CODE_SUCCESS;
-  }
-
-  pRSmaInfo = (SRSmaInfo *)taosMemoryCalloc(1, sizeof(SRSmaInfo));
-  if (!pRSmaInfo) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return TSDB_CODE_FAILED;
-  }
-
-  STqReadHandle *pReadHandle = tqInitSubmitMsgScanner(pMeta);
-  if (!pReadHandle) {
-    taosMemoryFree(pRSmaInfo);
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return TSDB_CODE_FAILED;
-  }
-
-  SReadHandle handle = {
-      .reader = pReadHandle,
-      .meta = pMeta,
-      .pMsgCb = pMsgCb,
-  };
-
-  if (param->qmsg1) {
-    pRSmaInfo->taskInfo[0] = qCreateStreamExecTaskInfo(param->qmsg1, &handle);
-    if (!pRSmaInfo->taskInfo[0]) {
-      taosMemoryFree(pRSmaInfo);
-      taosMemoryFree(pReadHandle);
-      return TSDB_CODE_FAILED;
-    }
-  }
-
-  if (param->qmsg2) {
-    pRSmaInfo->taskInfo[1] = qCreateStreamExecTaskInfo(param->qmsg2, &handle);
-    if (!pRSmaInfo->taskInfo[1]) {
-      taosMemoryFree(pRSmaInfo);
-      taosMemoryFree(pReadHandle);
-      return TSDB_CODE_FAILED;
-    }
-  }
-
-  if (taosHashPut(SMA_STAT_INFO_HASH(pStat), &pReq->suid, sizeof(tb_uid_t), &pRSmaInfo, sizeof(pRSmaInfo)) !=
-      TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_FAILED;
-  } else {
-    tsdbDebug("vgId:%d register rsma info succeed for suid:%" PRIi64, REPO_ID(pTsdb), pReq->suid);
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief store suid/[uids], prefer to use array and then hash
- *
- * @param pStore
- * @param suid
- * @param uid
- * @return int32_t
- */
-static int32_t tsdbUidStorePut(STbUidStore *pStore, tb_uid_t suid, tb_uid_t *uid) {
-  // prefer to store suid/uids in array
-  if ((suid == pStore->suid) || (pStore->suid == 0)) {
-    if (pStore->suid == 0) {
-      pStore->suid = suid;
-    }
-    if (uid) {
-      if (!pStore->tbUids) {
-        if (!(pStore->tbUids = taosArrayInit(1, sizeof(tb_uid_t)))) {
-          terrno = TSDB_CODE_OUT_OF_MEMORY;
-          return TSDB_CODE_FAILED;
-        }
-      }
-      if (!taosArrayPush(pStore->tbUids, uid)) {
-        return TSDB_CODE_FAILED;
-      }
-    }
-  } else {
-    // store other suid/uids in hash when multiple stable/table included in 1 batch of request
-    if (!pStore->uidHash) {
-      pStore->uidHash = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK);
-      if (!pStore->uidHash) {
-        return TSDB_CODE_FAILED;
-      }
-    }
-    if (uid) {
-      SArray *uidArray = taosHashGet(pStore->uidHash, &suid, sizeof(tb_uid_t));
-      if (uidArray && ((uidArray = *(SArray **)uidArray))) {
-        taosArrayPush(uidArray, uid);
-      } else {
-        SArray *pUidArray = taosArrayInit(1, sizeof(tb_uid_t));
-        if (!pUidArray) {
-          terrno = TSDB_CODE_OUT_OF_MEMORY;
-          return TSDB_CODE_FAILED;
-        }
-        if (!taosArrayPush(pUidArray, uid)) {
-          terrno = TSDB_CODE_OUT_OF_MEMORY;
-          return TSDB_CODE_FAILED;
-        }
-        if (taosHashPut(pStore->uidHash, &suid, sizeof(suid), &pUidArray, sizeof(pUidArray)) != 0) {
-          return TSDB_CODE_FAILED;
-        }
-      }
-    } else {
-      if (taosHashPut(pStore->uidHash, &suid, sizeof(suid), NULL, 0) != 0) {
-        return TSDB_CODE_FAILED;
-      }
-    }
-  }
-  return TSDB_CODE_SUCCESS;
-}
-
-void tsdbUidStoreDestory(STbUidStore *pStore) {
-  if (pStore) {
-    if (pStore->uidHash) {
-      if (pStore->tbUids) {
-        // When pStore->tbUids not NULL, the pStore->uidHash has k/v; otherwise pStore->uidHash only has keys.
-        void *pIter = taosHashIterate(pStore->uidHash, NULL);
-        while (pIter) {
-          SArray *arr = *(SArray **)pIter;
-          taosArrayDestroy(arr);
-          pIter = taosHashIterate(pStore->uidHash, pIter);
-        }
-      }
-      taosHashCleanup(pStore->uidHash);
-    }
-    taosArrayDestroy(pStore->tbUids);
-  }
-}
-
-void *tsdbUidStoreFree(STbUidStore *pStore) {
-  if (pStore) {
-    tsdbUidStoreDestory(pStore);
-    taosMemoryFree(pStore);
-  }
-  return NULL;
-}
-
-/**
- * @brief fetch suid/uids when create child tables of rollup SMA
- *
- * @param pTsdb
- * @param ppStore
- * @param suid
- * @param uid
- * @return int32_t
- */
-int32_t tsdbFetchTbUidList(STsdb *pTsdb, STbUidStore **ppStore, tb_uid_t suid, tb_uid_t uid) {
-  SSmaEnv *pEnv = REPO_RSMA_ENV((STsdb *)pTsdb);
-
-  // only applicable to rollup SMA ctables
-  if (!pEnv) {
-    return TSDB_CODE_SUCCESS;
-  }
-
-  SSmaStat *pStat = SMA_ENV_STAT(pEnv);
-  SHashObj *infoHash = NULL;
-  if (!pStat || !(infoHash = SMA_STAT_INFO_HASH(pStat))) {
-    terrno = TSDB_CODE_TDB_INVALID_SMA_STAT;
-    return TSDB_CODE_FAILED;
-  }
-
-  // info cached when create rsma stable and return directly for non-rsma ctables
-  if (!taosHashGet(infoHash, &suid, sizeof(tb_uid_t))) {
-    return TSDB_CODE_SUCCESS;
-  }
-
-  ASSERT(ppStore != NULL);
-
-  if (!(*ppStore)) {
-    if (tsdbUidStoreInit(ppStore) != 0) {
-      return TSDB_CODE_FAILED;
-    }
-  }
-
-  if (tsdbUidStorePut(*ppStore, suid, &uid) != 0) {
-    *ppStore = tsdbUidStoreFree(*ppStore);
-    return TSDB_CODE_FAILED;
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static FORCE_INLINE int32_t tsdbUpdateTbUidListImpl(STsdb *pTsdb, tb_uid_t *suid, SArray *tbUids) {
-  SSmaEnv   *pEnv = REPO_RSMA_ENV(pTsdb);
-  SSmaStat  *pStat = SMA_ENV_STAT(pEnv);
-  SRSmaInfo *pRSmaInfo = NULL;
-
-  if (!suid || !tbUids) {
-    terrno = TSDB_CODE_INVALID_PTR;
-    tsdbError("vgId:%d failed to get rsma info for uid:%" PRIi64 " since %s", REPO_ID(pTsdb), *suid, terrstr(terrno));
-    return TSDB_CODE_FAILED;
-  }
-
-  pRSmaInfo = taosHashGet(SMA_STAT_INFO_HASH(pStat), suid, sizeof(tb_uid_t));
-  if (!pRSmaInfo || !(pRSmaInfo = *(SRSmaInfo **)pRSmaInfo)) {
-    tsdbError("vgId:%d failed to get rsma info for uid:%" PRIi64, REPO_ID(pTsdb), *suid);
-    terrno = TSDB_CODE_TDB_INVALID_SMA_STAT;
-    return TSDB_CODE_FAILED;
-  }
-
-  if (pRSmaInfo->taskInfo[0] && (qUpdateQualifiedTableId(pRSmaInfo->taskInfo[0], tbUids, true) != 0)) {
-    tsdbError("vgId:%d update tbUidList failed for uid:%" PRIi64 " since %s", REPO_ID(pTsdb), *suid, terrstr(terrno));
-    return TSDB_CODE_FAILED;
-  } else {
-    tsdbDebug("vgId:%d update tbUidList succeed for qTaskInfo:%p with suid:%" PRIi64 ", uid:%" PRIi64, REPO_ID(pTsdb),
-              pRSmaInfo->taskInfo[0], *suid, *(int64_t *)taosArrayGet(tbUids, 0));
-  }
-
-  if (pRSmaInfo->taskInfo[1] && (qUpdateQualifiedTableId(pRSmaInfo->taskInfo[1], tbUids, true) != 0)) {
-    tsdbError("vgId:%d update tbUidList failed for uid:%" PRIi64 " since %s", REPO_ID(pTsdb), *suid, terrstr(terrno));
-    return TSDB_CODE_FAILED;
-  } else {
-    tsdbDebug("vgId:%d update tbUidList succeed for qTaskInfo:%p with suid:%" PRIi64 ", uid:%" PRIi64, REPO_ID(pTsdb),
-              pRSmaInfo->taskInfo[1], *suid, *(int64_t *)taosArrayGet(tbUids, 0));
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t tsdbUpdateTbUidList(STsdb *pTsdb, STbUidStore *pStore) {
-  if (!pStore || (taosArrayGetSize(pStore->tbUids) == 0)) {
-    return TSDB_CODE_SUCCESS;
-  }
-
-  if (tsdbUpdateTbUidListImpl(pTsdb, &pStore->suid, pStore->tbUids) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_FAILED;
-  }
-
-  void *pIter = taosHashIterate(pStore->uidHash, NULL);
-  while (pIter) {
-    tb_uid_t *pTbSuid = (tb_uid_t *)taosHashGetKey(pIter, NULL);
-    SArray   *pTbUids = *(SArray **)pIter;
-
-    if (tsdbUpdateTbUidListImpl(pTsdb, pTbSuid, pTbUids) != TSDB_CODE_SUCCESS) {
-      taosHashCancelIterate(pStore->uidHash, pIter);
-      return TSDB_CODE_FAILED;
-    }
-
-    pIter = taosHashIterate(pStore->uidHash, pIter);
-  }
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t tsdbProcessSubmitReq(STsdb *pTsdb, int64_t version, void *pReq) {
-  if (!pReq) {
-    terrno = TSDB_CODE_INVALID_PTR;
-    return TSDB_CODE_FAILED;
-  }
-
-  SSubmitReq *pSubmitReq = (SSubmitReq *)pReq;
-
-  if (tsdbInsertData(pTsdb, version, pSubmitReq, NULL) < 0) {
-    return TSDB_CODE_FAILED;
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t tsdbFetchSubmitReqSuids(SSubmitReq *pMsg, STbUidStore *pStore) {
-  ASSERT(pMsg != NULL);
-  SSubmitMsgIter msgIter = {0};
-  SSubmitBlk    *pBlock = NULL;
-  SSubmitBlkIter blkIter = {0};
-  STSRow        *row = NULL;
-
-  terrno = TSDB_CODE_SUCCESS;
-
-  if (tInitSubmitMsgIter(pMsg, &msgIter) < 0) return -1;
-  while (true) {
-    if (tGetSubmitMsgNext(&msgIter, &pBlock) < 0) return -1;
-
-    if (!pBlock) break;
-    tsdbUidStorePut(pStore, msgIter.suid, NULL);
-    pStore->uid = msgIter.uid;  // TODO: remove, just for debugging
-  }
-
-  if (terrno != TSDB_CODE_SUCCESS) return -1;
-  return 0;
-}
-
-static FORCE_INLINE int32_t tsdbExecuteRSmaImpl(STsdb *pTsdb, const void *pMsg, int32_t inputType,
-                                                qTaskInfo_t *taskInfo, STSchema *pTSchema, tb_uid_t suid, tb_uid_t uid,
-                                                int8_t level) {
-  SArray *pResult = NULL;
-
-  if (!taskInfo) {
-    tsdbDebug("vgId:%d no qTaskInfo to execute rsma %" PRIi8 " task for suid:%" PRIu64, REPO_ID(pTsdb), level, suid);
-    return TSDB_CODE_SUCCESS;
-  }
-
-  tsdbDebug("vgId:%d execute rsma %" PRIi8 " task for qTaskInfo:%p suid:%" PRIu64, REPO_ID(pTsdb), level, taskInfo,
-            suid);
-
-  qSetStreamInput(taskInfo, pMsg, inputType, false);
-  while (1) {
-    SSDataBlock *output = NULL;
-    uint64_t     ts;
-    if (qExecTask(taskInfo, &output, &ts) < 0) {
-      ASSERT(false);
-    }
-    if (!output) {
-      break;
-    }
-    if (!pResult) {
-      pResult = taosArrayInit(0, sizeof(SSDataBlock));
-      if (!pResult) {
-        terrno = TSDB_CODE_OUT_OF_MEMORY;
-        return TSDB_CODE_FAILED;
-      }
-    }
-
-    taosArrayPush(pResult, output);
-  }
-
-  if (taosArrayGetSize(pResult) > 0) {
-    blockDebugShowData(pResult);
-    STsdb      *sinkTsdb = (level == TSDB_RETENTION_L1 ? pTsdb->pVnode->pRSma1 : pTsdb->pVnode->pRSma2);
-    SSubmitReq *pReq = NULL;
-    if (buildSubmitReqFromDataBlock(&pReq, pResult, pTSchema, TD_VID(pTsdb->pVnode), suid) != 0) {
-      taosArrayDestroy(pResult);
-      return TSDB_CODE_FAILED;
-    }
-    if (tsdbProcessSubmitReq(sinkTsdb, INT64_MAX, pReq) != 0) {
-      taosArrayDestroy(pResult);
-      taosMemoryFreeClear(pReq);
-      return TSDB_CODE_FAILED;
-    }
-    taosMemoryFreeClear(pReq);
-  } else {
-    tsdbWarn("vgId:%d no rsma % " PRIi8 " data generated since %s", REPO_ID(pTsdb), level, tstrerror(terrno));
-  }
-
-  taosArrayDestroy(pResult);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t tsdbExecuteRSma(STsdb *pTsdb, const void *pMsg, int32_t inputType, tb_uid_t suid, tb_uid_t uid) {
-  SSmaEnv *pEnv = REPO_RSMA_ENV(pTsdb);
-  if (!pEnv) {
-    // only applicable when rsma env exists
-    return TSDB_CODE_SUCCESS;
-  }
-
-  ASSERT(uid != 0);  // TODO: remove later
-
-  SSmaStat  *pStat = SMA_ENV_STAT(pEnv);
-  SRSmaInfo *pRSmaInfo = NULL;
-
-  pRSmaInfo = taosHashGet(SMA_STAT_INFO_HASH(pStat), &suid, sizeof(tb_uid_t));
-
-  if (!pRSmaInfo || !(pRSmaInfo = *(SRSmaInfo **)pRSmaInfo)) {
-    tsdbDebug("vgId:%d no rsma info for suid:%" PRIu64, REPO_ID(pTsdb), suid);
-    return TSDB_CODE_SUCCESS;
-  }
-  if (!pRSmaInfo->taskInfo[0]) {
-    tsdbDebug("vgId:%d no rsma qTaskInfo for suid:%" PRIu64, REPO_ID(pTsdb), suid);
-    return TSDB_CODE_SUCCESS;
-  }
-
-  if (inputType == STREAM_DATA_TYPE_SUBMIT_BLOCK) {
-    // TODO: use the proper schema instead of 1, and cache STSchema in cache
-    STSchema *pTSchema = metaGetTbTSchema(pTsdb->pVnode->pMeta, suid, 1);
-    if (!pTSchema) {
-      terrno = TSDB_CODE_TDB_IVD_TB_SCHEMA_VERSION;
-      return TSDB_CODE_FAILED;
-    }
-    tsdbExecuteRSmaImpl(pTsdb, pMsg, inputType, pRSmaInfo->taskInfo[0], pTSchema, suid, uid, TSDB_RETENTION_L1);
-    tsdbExecuteRSmaImpl(pTsdb, pMsg, inputType, pRSmaInfo->taskInfo[1], pTSchema, suid, uid, TSDB_RETENTION_L2);
-    taosMemoryFree(pTSchema);
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t tsdbTriggerRSma(STsdb *pTsdb, void *pMsg, int32_t inputType) {
-  SSmaEnv *pEnv = REPO_RSMA_ENV(pTsdb);
-  if (!pEnv) {
-    // only applicable when rsma env exists
-    return TSDB_CODE_SUCCESS;
-  }
-
-  if (inputType == STREAM_DATA_TYPE_SUBMIT_BLOCK) {
-    STbUidStore uidStore = {0};
-    tsdbFetchSubmitReqSuids(pMsg, &uidStore);
-
-    if (uidStore.suid != 0) {
-      tsdbExecuteRSma(pTsdb, pMsg, inputType, uidStore.suid, uidStore.uid);
-
-      void *pIter = taosHashIterate(uidStore.uidHash, NULL);
-      while (pIter) {
-        tb_uid_t *pTbSuid = (tb_uid_t *)taosHashGetKey(pIter, NULL);
-        tsdbExecuteRSma(pTsdb, pMsg, inputType, *pTbSuid, 0);
-        pIter = taosHashIterate(uidStore.uidHash, pIter);
-      }
-
-      tsdbUidStoreDestory(&uidStore);
-    }
-  }
-  return TSDB_CODE_SUCCESS;
-}
-
-#if 0
-/**
- * @brief Get the start TS key of the last data block of one interval/sliding.
- *
- * @param pTsdb
- * @param param
- * @param result
- * @return int32_t
- *         1) Return 0 and fill the result if the check procedure is normal;
- *         2) Return -1 if error occurs during the check procedure.
- */
-int32_t tsdbGetTSmaStatus(STsdb *pTsdb, void *smaIndex, void *result) {
-  const char *procedure = "";
-  if (strncmp(procedure, "get the start TS key of the last data block", 100) != 0) {
-    return -1;
-  }
-  // fill the result
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief Remove the tSma data files related to param between pWin.
- *
- * @param pTsdb
- * @param param
- * @param pWin
- * @return int32_t
- */
-int32_t tsdbRemoveTSmaData(STsdb *pTsdb, void *smaIndex, STimeWindow *pWin) {
-  // for ("tSmaFiles of param-interval-sliding between pWin") {
-  //   // remove the tSmaFile
-  // }
-  return TSDB_CODE_SUCCESS;
-}
-#endif
-
-// TODO: Who is responsible for resource allocate and release?
-int32_t tsdbInsertTSmaData(STsdb *pTsdb, int64_t indexUid, const char *msg) {
-  int32_t code = TSDB_CODE_SUCCESS;
-  if ((code = tsdbInsertTSmaDataImpl(pTsdb, indexUid, msg)) < 0) {
-    tsdbWarn("vgId:%d insert tSma data failed since %s", REPO_ID(pTsdb), tstrerror(terrno));
-  }
-  // TODO: destroy SSDataBlocks(msg)
-  return code;
-}
-
-int32_t tsdbUpdateSmaWindow(STsdb *pTsdb, SSubmitReq *pMsg, int64_t version) {
-  int32_t code = TSDB_CODE_SUCCESS;
-  if ((code = tsdbUpdateExpiredWindowImpl(pTsdb, pMsg, version)) < 0) {
-    tsdbWarn("vgId:%d update expired sma window failed since %s", REPO_ID(pTsdb), tstrerror(terrno));
-  }
-  return code;
-}
-
-int32_t tsdbInsertRSmaData(STsdb *pTsdb, char *msg) {
-  int32_t code = TSDB_CODE_SUCCESS;
-  if ((code = tsdbInsertRSmaDataImpl(pTsdb, msg)) < 0) {
-    tsdbWarn("vgId:%d insert rSma data failed since %s", REPO_ID(pTsdb), tstrerror(terrno));
-  }
-  return code;
-}
-
-int32_t tsdbGetTSmaData(STsdb *pTsdb, char *pData, int64_t indexUid, TSKEY querySKey, int32_t nMaxResult) {
-  int32_t code = TSDB_CODE_SUCCESS;
-  if ((code = tsdbGetTSmaDataImpl(pTsdb, pData, indexUid, querySKey, nMaxResult)) < 0) {
-    tsdbWarn("vgId:%d get tSma data failed since %s", REPO_ID(pTsdb), tstrerror(terrno));
-  }
-  return code;
-}
-
-int32_t tsdbDropTSmaData(STsdb *pTsdb, int64_t indexUid) {
-  int32_t code = TSDB_CODE_SUCCESS;
-  if ((code = tsdbDropTSmaDataImpl(pTsdb, indexUid)) < 0) {
-    tsdbWarn("vgId:%d drop tSma data failed since %s", REPO_ID(pTsdb), tstrerror(terrno));
-  }
-  return code;
-}
\ No newline at end of file
diff --git a/source/dnode/vnode/src/tsdb/tsdbTDBImpl.c b/source/dnode/vnode/src/tsdb/tsdbTDBImpl.c
deleted file mode 100644
index a553f32bee..0000000000
--- a/source/dnode/vnode/src/tsdb/tsdbTDBImpl.c
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define ALLOW_FORBID_FUNC
-
-#include "tsdb.h"
-
-int32_t tsdbOpenDBEnv(TDB **ppEnv, const char *path) {
-  int ret = 0;
-
-  if (path == NULL) return -1;
-
-  ret = tdbOpen(path, 4096, 256, ppEnv);  // use as param
-
-  if (ret != 0) {
-    tsdbError("Failed to create tsdb db env, ret = %d", ret);
-    return -1;
-  }
-
-  return 0;
-}
-
-int32_t tsdbCloseDBEnv(TDB *pEnv) { return tdbClose(pEnv); }
-
-static inline int tsdbSmaKeyCmpr(const void *arg1, int len1, const void *arg2, int len2) {
-  const SSmaKey *pKey1 = (const SSmaKey *)arg1;
-  const SSmaKey *pKey2 = (const SSmaKey *)arg2;
-
-  ASSERT(len1 == len2 && len1 == sizeof(SSmaKey));
-
-  if (pKey1->skey < pKey2->skey) {
-    return -1;
-  } else if (pKey1->skey > pKey2->skey) {
-    return 1;
-  }
-  if (pKey1->groupId < pKey2->groupId) {
-    return -1;
-  } else if (pKey1->groupId > pKey2->groupId) {
-    return 1;
-  }
-
-  return 0;
-}
-
-static int32_t tsdbOpenDBDb(TTB **ppDB, TDB *pEnv, const char *pFName) {
-  int           ret;
-  tdb_cmpr_fn_t compFunc;
-
-  // Create a database
-  compFunc = tsdbSmaKeyCmpr;
-  ret = tdbTbOpen(pFName, -1, -1, compFunc, pEnv, ppDB);
-
-  return 0;
-}
-
-static int32_t tsdbCloseDBDb(TTB *pDB) { return tdbTbClose(pDB); }
-
-int32_t tsdbOpenDBF(TDB *pEnv, SDBFile *pDBF) {
-  // TEnv is shared by a group of SDBFile
-  if (!pEnv || !pDBF) {
-    terrno = TSDB_CODE_INVALID_PTR;
-    return -1;
-  }
-
-  // Open DBF
-  if (tsdbOpenDBDb(&(pDBF->pDB), pEnv, pDBF->path) < 0) {
-    terrno = TSDB_CODE_TDB_INIT_FAILED;
-    tsdbCloseDBDb(pDBF->pDB);
-    return -1;
-  }
-
-  return 0;
-}
-
-int32_t tsdbCloseDBF(SDBFile *pDBF) {
-  int32_t ret = 0;
-  if (pDBF->pDB) {
-    ret = tsdbCloseDBDb(pDBF->pDB);
-    pDBF->pDB = NULL;
-  }
-  taosMemoryFreeClear(pDBF->path);
-  return ret;
-}
-
-int32_t tsdbSaveSmaToDB(SDBFile *pDBF, void *pKey, int32_t keyLen, void *pVal, int32_t valLen, TXN *txn) {
-  int32_t ret;
-
-  ret = tdbTbInsert(pDBF->pDB, pKey, keyLen, pVal, valLen, txn);
-  if (ret < 0) {
-    tsdbError("Failed to create insert sma data into db, ret = %d", ret);
-    return -1;
-  }
-
-  return 0;
-}
-
-void *tsdbGetSmaDataByKey(SDBFile *pDBF, const void *pKey, int32_t keyLen, int32_t *valLen) {
-  void *pVal = NULL;
-  int   ret;
-
-  ret = tdbTbGet(pDBF->pDB, pKey, keyLen, &pVal, valLen);
-
-  if (ret < 0) {
-    tsdbError("Failed to get sma data from db, ret = %d", ret);
-    return NULL;
-  }
-
-  ASSERT(*valLen >= 0);
-
-  // TODO: lock?
-  // TODO: Would the key/value be destoryed during return the data?
-  // TODO: How about the key is updated while value length is changed? The original value buffer would be freed
-  // automatically?
-
-  return pVal;
-}
\ No newline at end of file
diff --git a/source/dnode/vnode/src/vnd/vnodeCfg.c b/source/dnode/vnode/src/vnd/vnodeCfg.c
index 56cc3d6374..e8fa2ed3c1 100644
--- a/source/dnode/vnode/src/vnd/vnodeCfg.c
+++ b/source/dnode/vnode/src/vnd/vnodeCfg.c
@@ -57,6 +57,7 @@ int vnodeEncodeConfig(const void *pObj, SJson *pJson) {
   if (tjsonAddIntegerToObject(pJson, "isHeap", pCfg->isHeap) < 0) return -1;
   if (tjsonAddIntegerToObject(pJson, "isWeak", pCfg->isWeak) < 0) return -1;
   if (tjsonAddIntegerToObject(pJson, "isTsma", pCfg->isTsma) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "isRsma", pCfg->isRsma) < 0) return -1;
   if (tjsonAddIntegerToObject(pJson, "precision", pCfg->tsdbCfg.precision) < 0) return -1;
   if (tjsonAddIntegerToObject(pJson, "update", pCfg->tsdbCfg.update) < 0) return -1;
   if (tjsonAddIntegerToObject(pJson, "compression", pCfg->tsdbCfg.compression) < 0) return -1;
@@ -133,6 +134,8 @@ int vnodeDecodeConfig(const SJson *pJson, void *pObj) {
   if(code < 0) return -1;
   tjsonGetNumberValue(pJson, "isTsma", pCfg->isTsma, code);
   if(code < 0) return -1;
+  tjsonGetNumberValue(pJson, "isRsma", pCfg->isRsma, code);
+  if(code < 0) return -1;
   tjsonGetNumberValue(pJson, "precision", pCfg->tsdbCfg.precision, code);
   if(code < 0) return -1;
   tjsonGetNumberValue(pJson, "update", pCfg->tsdbCfg.update, code);
diff --git a/source/dnode/vnode/src/vnd/vnodeCommit.c b/source/dnode/vnode/src/vnd/vnodeCommit.c
index b4fbd01c63..a0db3cfe2d 100644
--- a/source/dnode/vnode/src/vnd/vnodeCommit.c
+++ b/source/dnode/vnode/src/vnd/vnodeCommit.c
@@ -230,7 +230,7 @@ int vnodeCommit(SVnode *pVnode) {
     return -1;
   }
 
-  if(vnodeIsRollup(pVnode)) {
+  if (VND_IS_RSMA(pVnode)) {
     if (tsdbCommit(VND_RSMA0(pVnode)) < 0) {
       ASSERT(0);
       return -1;
@@ -250,7 +250,6 @@ int vnodeCommit(SVnode *pVnode) {
     }
   }
 
-  
   if (tqCommit(pVnode->pTq) < 0) {
     ASSERT(0);
     return -1;
diff --git a/source/dnode/vnode/src/vnd/vnodeOpen.c b/source/dnode/vnode/src/vnd/vnodeOpen.c
index 178ef28e5d..7a26c16e4b 100644
--- a/source/dnode/vnode/src/vnd/vnodeOpen.c
+++ b/source/dnode/vnode/src/vnd/vnodeOpen.c
@@ -97,7 +97,7 @@ SVnode *vnodeOpen(const char *path, STfs *pTfs, SMsgCb msgCb) {
   }
 
   // open tsdb
-  if (!vnodeIsRollup(pVnode) && tsdbOpen(pVnode, &VND_TSDB(pVnode), VNODE_TSDB_DIR, NULL) < 0) {
+  if (!VND_IS_RSMA(pVnode) && tsdbOpen(pVnode, &VND_TSDB(pVnode), VNODE_TSDB_DIR, NULL) < 0) {
     vError("vgId:%d failed to open vnode tsdb since %s", TD_VID(pVnode), tstrerror(terrno));
     goto _err;
   }
@@ -189,4 +189,4 @@ void vnodeStop(SVnode *pVnode) {}
 
 int64_t vnodeGetSyncHandle(SVnode *pVnode) { return pVnode->sync; }
 
-void vnodeGetSnapshot(SVnode *pVnode, SSnapshot *pSnapshot) { pSnapshot->lastApplyIndex = pVnode->state.committed; }
\ No newline at end of file
+void vnodeGetSnapshot(SVnode *pVnode, SSnapshot *pSnapshot) { pSnapshot->lastApplyIndex = pVnode->state.committed; }
diff --git a/source/dnode/vnode/src/vnd/vnodeSvr.c b/source/dnode/vnode/src/vnd/vnodeSvr.c
index 4b237bc703..b66695f7c2 100644
--- a/source/dnode/vnode/src/vnd/vnodeSvr.c
+++ b/source/dnode/vnode/src/vnd/vnodeSvr.c
@@ -22,7 +22,7 @@ static int vnodeProcessCreateTbReq(SVnode *pVnode, int64_t version, void *pReq,
 static int vnodeProcessAlterTbReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp);
 static int vnodeProcessDropTbReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp);
 static int vnodeProcessSubmitReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp);
-static int vnodeProcessCreateTSmaReq(SVnode *pVnode, int64_t version, void *pReq, int len, SRpcMsg *pRsp);
+static int vnodeProcessCreateTSmaReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp);
 
 int32_t vnodePreprocessReq(SVnode *pVnode, SRpcMsg *pMsg) {
   SDecoder dc = {0};
@@ -88,6 +88,9 @@ int32_t vnodePreprocessReq(SVnode *pVnode, SRpcMsg *pMsg) {
       }
 
     } break;
+    case TDMT_VND_ALTER_REPLICA: {
+      vnodeSyncAlter(pVnode, pMsg);
+    } break;
     default:
       break;
   }
@@ -154,7 +157,7 @@ int vnodeProcessWriteReq(SVnode *pVnode, SRpcMsg *pMsg, int64_t version, SRpcMsg
                               pMsg->contLen - sizeof(SMsgHead)) < 0) {
       }
     } break;
-    case TDMT_VND_ALTER_VNODE:
+    case TDMT_VND_ALTER_CONFIG:
       break;
     default:
       ASSERT(0);
@@ -776,28 +779,30 @@ _exit:
 
   // TODO: the partial success scenario and the error case
   // TODO: refactor
-  if ((terrno == TSDB_CODE_SUCCESS || terrno == TSDB_CODE_TDB_TABLE_ALREADY_EXIST) &&
-      (pRsp->code == TSDB_CODE_SUCCESS)) {
+  if ((terrno == TSDB_CODE_SUCCESS) && (pRsp->code == TSDB_CODE_SUCCESS)) {
     tdProcessRSmaSubmit(pVnode->pSma, pReq, STREAM_DATA_TYPE_SUBMIT_BLOCK);
   }
 
   return 0;
 }
 
-static int vnodeProcessCreateTSmaReq(SVnode *pVnode, int64_t version, void *pReq, int len, SRpcMsg *pRsp) {
+static int vnodeProcessCreateTSmaReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp) {
   SVCreateTSmaReq req = {0};
   SDecoder        coder;
 
-  pRsp->msgType = TDMT_VND_CREATE_SMA_RSP;
-  pRsp->code = TSDB_CODE_SUCCESS;
-  pRsp->pCont = NULL;
-  pRsp->contLen = 0;
+  if (pRsp) {
+    pRsp->msgType = TDMT_VND_CREATE_SMA_RSP;
+    pRsp->code = TSDB_CODE_SUCCESS;
+    pRsp->pCont = NULL;
+    pRsp->contLen = 0;
+  }
 
   // decode and process req
   tDecoderInit(&coder, pReq, len);
 
   if (tDecodeSVCreateTSmaReq(&coder, &req) < 0) {
-    pRsp->code = terrno;
+    terrno = TSDB_CODE_MSG_DECODE_ERROR;
+    if (pRsp) pRsp->code = terrno;
     goto _err;
   }
 
@@ -805,18 +810,30 @@ static int vnodeProcessCreateTSmaReq(SVnode *pVnode, int64_t version, void *pReq
   req.timezoneInt = tsTimezone;
 
   if (tdProcessTSmaCreate(pVnode->pSma, version, (const char *)&req) < 0) {
-    pRsp->code = terrno;
+    if (pRsp) pRsp->code = terrno;
     goto _err;
   }
 
   tDecoderClear(&coder);
-  vDebug("vgId:%d success to create tsma %s:%" PRIi64 " for table %" PRIi64, TD_VID(pVnode), req.indexName,
-         req.indexUid, req.tableUid);
+  vDebug("vgId:%d success to create tsma %s:%" PRIi64 " version %" PRIi64 " for table %" PRIi64, TD_VID(pVnode),
+         req.indexName, req.indexUid, version, req.tableUid);
   return 0;
 
 _err:
   tDecoderClear(&coder);
-  vError("vgId:%d failed to create tsma %s:%" PRIi64 " for table %" PRIi64 " since %s", TD_VID(pVnode), req.indexName,
-         req.indexUid, req.tableUid, terrstr(terrno));
+  vError("vgId:%d failed to create tsma %s:%" PRIi64 " version %" PRIi64 "for table %" PRIi64 " since %s",
+         TD_VID(pVnode), req.indexName, req.indexUid, version, req.tableUid, terrstr(terrno));
   return -1;
 }
+
+/**
+ * @brief specific for smaDstVnode
+ *
+ * @param pVnode
+ * @param pCont
+ * @param contLen
+ * @return int32_t
+ */
+int32_t vnodeProcessCreateTSma(SVnode *pVnode, void *pCont, uint32_t contLen) {
+  return vnodeProcessCreateTSmaReq(pVnode, 1, pCont, contLen, NULL);
+}
diff --git a/source/dnode/vnode/src/vnd/vnodeSync.c b/source/dnode/vnode/src/vnd/vnodeSync.c
index d146877853..8792fbbb0c 100644
--- a/source/dnode/vnode/src/vnd/vnodeSync.c
+++ b/source/dnode/vnode/src/vnd/vnodeSync.c
@@ -27,6 +27,7 @@ static int32_t   vnodeSyncGetSnapshot(SSyncFSM *pFsm, SSnapshot *pSnapshot);
 int32_t vnodeSyncOpen(SVnode *pVnode, char *path) {
   SSyncInfo syncInfo = {
       .vgId = pVnode->config.vgId,
+      .isStandBy = pVnode->config.standby,
       .syncCfg = pVnode->config.syncCfg,
       .pWal = pVnode->pWal,
       .msgcb = NULL,
@@ -49,28 +50,72 @@ int32_t vnodeSyncOpen(SVnode *pVnode, char *path) {
   return 0;
 }
 
+void vnodeSyncAlter(SVnode *pVnode, SRpcMsg *pMsg) {
+  SAlterVnodeReq req = {0};
+  if (tDeserializeSAlterVnodeReq((char *)pMsg->pCont + sizeof(SMsgHead), pMsg->contLen - sizeof(SMsgHead), &req) != 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    vError("vgId:%d, failed to alter replica since %s", TD_VID(pVnode), terrstr());
+    SRpcMsg rsp = {.info = pMsg->info, .code = terrno};
+    tmsgSendRsp(&rsp);
+  }
+
+  vInfo("vgId:%d, start to alter vnode replica to %d", TD_VID(pVnode), req.replica);
+  SSyncCfg cfg = {.replicaNum = req.replica, .myIndex = req.selfIndex};
+  for (int32_t r = 0; r < req.replica; ++r) {
+    SNodeInfo *pNode = &cfg.nodeInfo[r];
+    tstrncpy(pNode->nodeFqdn, req.replicas[r].fqdn, sizeof(pNode->nodeFqdn));
+    pNode->nodePort = req.replicas[r].port;
+    vInfo("vgId:%d, replica:%d %s:%u", TD_VID(pVnode), r, pNode->nodeFqdn, pNode->nodePort);
+  }
+
+  if (syncReconfig(pVnode->sync, &cfg) != 0) {
+    vError("vgId:%d, failed to propose sync reconfig since %s", TD_VID(pVnode), terrstr());
+    SRpcMsg rsp = {.info = pMsg->info, .code = terrno};
+    tmsgSendRsp(&rsp);
+  }
+}
+
 void vnodeSyncStart(SVnode *pVnode) {
   syncSetMsgCb(pVnode->sync, &pVnode->msgCb);
-  syncStart(pVnode->sync);
+  if (pVnode->config.standby) {
+    syncStartStandBy(pVnode->sync);
+  } else {
+    syncStart(pVnode->sync);
+  }
 }
 
 void vnodeSyncClose(SVnode *pVnode) { syncStop(pVnode->sync); }
 
-int32_t vnodeSyncEqMsg(const SMsgCb *msgcb, SRpcMsg *pMsg) { 
+int32_t vnodeSyncEqMsg(const SMsgCb *msgcb, SRpcMsg *pMsg) {
   int32_t code = tmsgPutToQueue(msgcb, SYNC_QUEUE, pMsg);
   if (code != 0) {
     rpcFreeCont(pMsg->pCont);
+    pMsg->pCont = NULL;
   }
   return code;
 }
 
-int32_t vnodeSyncSendMsg(const SEpSet *pEpSet, SRpcMsg *pMsg) { return tmsgSendReq(pEpSet, pMsg); }
+int32_t vnodeSyncSendMsg(const SEpSet *pEpSet, SRpcMsg *pMsg) {
+  int32_t code = tmsgSendReq(pEpSet, pMsg);
+  if (code != 0) {
+    rpcFreeCont(pMsg->pCont);
+    pMsg->pCont = NULL;
+  }
+  return code;
+}
 
 int32_t vnodeSyncGetSnapshot(SSyncFSM *pFsm, SSnapshot *pSnapshot) {
   vnodeGetSnapshot(pFsm->data, pSnapshot);
   return 0;
 }
 
+void vnodeSyncReconfig(struct SSyncFSM *pFsm, SSyncCfg newCfg, SReConfigCbMeta cbMeta) {
+  SVnode *pVnode = pFsm->data;
+  vInfo("vgId:%d, sync reconfig is confirmed", TD_VID(pVnode));
+
+  // todo rpc response here
+}
+
 void vnodeSyncCommitMsg(SSyncFSM *pFsm, const SRpcMsg *pMsg, SFsmCbMeta cbMeta) {
   SyncIndex beginIndex = SYNC_INDEX_INVALID;
   if (pFsm->FpGetSnapshot != NULL) {
@@ -87,20 +132,12 @@ void vnodeSyncCommitMsg(SSyncFSM *pFsm, const SRpcMsg *pMsg, SFsmCbMeta cbMeta)
         pFsm, cbMeta.index, cbMeta.isWeak, cbMeta.code, cbMeta.state, syncUtilState2String(cbMeta.state), beginIndex);
     syncRpcMsgLog2(logBuf, (SRpcMsg *)pMsg);
 
-    SVnode       *pVnode = (SVnode *)(pFsm->data);
+    SVnode       *pVnode = pFsm->data;
     SyncApplyMsg *pSyncApplyMsg = syncApplyMsgBuild2(pMsg, pVnode->config.vgId, &cbMeta);
     SRpcMsg       applyMsg;
     syncApplyMsg2RpcMsg(pSyncApplyMsg, &applyMsg);
     syncApplyMsgDestroy(pSyncApplyMsg);
 
-    /*
-        SRpcMsg applyMsg;
-        applyMsg = *pMsg;
-        applyMsg.pCont = rpcMallocCont(applyMsg.contLen);
-        assert(applyMsg.contLen == pMsg->contLen);
-        memcpy(applyMsg.pCont, pMsg->pCont, applyMsg.contLen);
-    */
-
     // recover handle for response
     SRpcMsg saveRpcMsg;
     int32_t ret = syncGetAndDelRespRpc(pVnode->sync, cbMeta.seqNum, &saveRpcMsg);
@@ -142,14 +179,13 @@ void vnodeSyncRollBackMsg(SSyncFSM *pFsm, const SRpcMsg *pMsg, SFsmCbMeta cbMeta
 
 SSyncFSM *vnodeSyncMakeFsm(SVnode *pVnode) {
   SSyncFSM *pFsm = taosMemoryCalloc(1, sizeof(SSyncFSM));
-  memset(pFsm, 0, sizeof(*pFsm));
   pFsm->data = pVnode;
   pFsm->FpCommitCb = vnodeSyncCommitMsg;
   pFsm->FpPreCommitCb = vnodeSyncPreCommitMsg;
   pFsm->FpRollBackCb = vnodeSyncRollBackMsg;
   pFsm->FpGetSnapshot = vnodeSyncGetSnapshot;
   pFsm->FpRestoreFinishCb = NULL;
-  pFsm->FpReConfigCb = NULL;
+  pFsm->FpReConfigCb = vnodeSyncReconfig;
 
   return pFsm;
 }
\ No newline at end of file
diff --git a/source/dnode/vnode/test/tsdbSmaTest.cpp b/source/dnode/vnode/test/tsdbSmaTest.cpp
index ab617cb186..4d2741f751 100644
--- a/source/dnode/vnode/test/tsdbSmaTest.cpp
+++ b/source/dnode/vnode/test/tsdbSmaTest.cpp
@@ -368,7 +368,7 @@ TEST(testCase, tSma_Data_Insert_Query_Test) {
   SDiskCfg pDisks = {0};
   pDisks.level = 0;
   pDisks.primary = 1;
-  strncpy(pDisks.dir, "/var/lib/taos", TSDB_FILENAME_LEN);
+  strncpy(pDisks.dir, TD_DATA_DIR_PATH, TSDB_FILENAME_LEN);
   int32_t numOfDisks = 1;
   pTsdb->pTfs = tfsOpen(&pDisks, numOfDisks);
   EXPECT_NE(pTsdb->pTfs, nullptr);
diff --git a/source/libs/catalog/test/catalogTests.cpp b/source/libs/catalog/test/catalogTests.cpp
index 81d206a0f3..19c5bb6dcd 100644
--- a/source/libs/catalog/test/catalogTests.cpp
+++ b/source/libs/catalog/test/catalogTests.cpp
@@ -137,7 +137,7 @@ void ctgTestInitLogFile() {
 
   tsAsyncLog = 0;
   qDebugFlag = 159;
-  strcpy(tsLogDir, "/var/log/taos");
+  strcpy(tsLogDir, TD_LOG_DIR_PATH);
 
   ctgdEnableDebug("api");
   ctgdEnableDebug("meta");
diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y
index 75eceedb1b..6c090a0790 100644
--- a/source/libs/parser/inc/sql.y
+++ b/source/libs/parser/inc/sql.y
@@ -15,11 +15,15 @@
 #include <assert.h>
 #include <stdbool.h>
 
+#define ALLOW_FORBID_FUNC
+
 #include "functionMgt.h"
 #include "nodes.h"
 #include "parToken.h"
 #include "ttokendef.h"
 #include "parAst.h"
+
+#define YYSTACKDEPTH 0
 }
 
 %syntax_error {
diff --git a/source/libs/parser/src/parInsert.c b/source/libs/parser/src/parInsert.c
index 31241d2670..5c656b969b 100644
--- a/source/libs/parser/src/parInsert.c
+++ b/source/libs/parser/src/parInsert.c
@@ -780,8 +780,8 @@ static void buildCreateTbReq(SVCreateTbReq* pTbReq, const char* tname, STag* pTa
   return;
 }
 
-static int32_t parseTagToken(char** end, SToken* pToken, SSchema* pSchema,
-                             int16_t timePrec, STagVal *val, SMsgBuf* pMsgBuf) {
+static int32_t parseTagToken(char** end, SToken* pToken, SSchema* pSchema, int16_t timePrec, STagVal* val,
+                             SMsgBuf* pMsgBuf) {
   int64_t  iv;
   uint64_t uv;
   char*    endptr = NULL;
@@ -937,8 +937,8 @@ static int32_t parseTagToken(char** end, SToken* pToken, SSchema* pSchema,
 
     case TSDB_DATA_TYPE_NCHAR: {
       int32_t output = 0;
-      void *p = taosMemoryCalloc(1, pToken->n * TSDB_NCHAR_SIZE);
-      if(p == NULL){
+      void*   p = taosMemoryCalloc(1, pToken->n * TSDB_NCHAR_SIZE);
+      if (p == NULL) {
         return TSDB_CODE_OUT_OF_MEMORY;
       }
       if (!taosMbsToUcs4(pToken->z, pToken->n, (TdUcs4*)(p), pToken->n * TSDB_NCHAR_SIZE, &output)) {
@@ -971,11 +971,11 @@ static int32_t parseTagToken(char** end, SToken* pToken, SSchema* pSchema,
 // pSql -> tag1_value, ...)
 static int32_t parseTagsClause(SInsertParseContext* pCxt, SSchema* pSchema, uint8_t precision, const char* tName) {
   int32_t code = TSDB_CODE_SUCCESS;
-  SArray *pTagVals = taosArrayInit(pCxt->tags.numOfBound, sizeof(STagVal));
-  SToken   sToken;
-  bool     isParseBindParam = false;
-  bool isJson = false;
-  STag* pTag = NULL;
+  SArray* pTagVals = taosArrayInit(pCxt->tags.numOfBound, sizeof(STagVal));
+  SToken  sToken;
+  bool    isParseBindParam = false;
+  bool    isJson = false;
+  STag*   pTag = NULL;
   for (int i = 0; i < pCxt->tags.numOfBound; ++i) {
     NEXT_TOKEN_WITH_PREV(pCxt->pSql, sToken);
 
@@ -995,13 +995,13 @@ static int32_t parseTagsClause(SInsertParseContext* pCxt, SSchema* pSchema, uint
     }
 
     SSchema* pTagSchema = &pSchema[pCxt->tags.boundColumns[i]];
-    char *tmpTokenBuf = taosMemoryCalloc(1, sToken.n); // this can be optimize with parse column
+    char*    tmpTokenBuf = taosMemoryCalloc(1, sToken.n);  // this can be optimize with parse column
     code = checkAndTrimValue(&sToken, tmpTokenBuf, &pCxt->msg);
     if (code != TSDB_CODE_SUCCESS) {
       taosMemoryFree(tmpTokenBuf);
       goto end;
     }
-    if(pTagSchema->type == TSDB_DATA_TYPE_JSON){
+    if (pTagSchema->type == TSDB_DATA_TYPE_JSON) {
       if (sToken.n > (TSDB_MAX_JSON_TAG_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE) {
         code = buildSyntaxErrMsg(&pCxt->msg, "json string too long than 4095", sToken.z);
         taosMemoryFree(tmpTokenBuf);
@@ -1009,18 +1009,18 @@ static int32_t parseTagsClause(SInsertParseContext* pCxt, SSchema* pSchema, uint
       }
       code = parseJsontoTagData(sToken.z, pTagVals, &pTag, &pCxt->msg);
       taosMemoryFree(tmpTokenBuf);
-      if(code != TSDB_CODE_SUCCESS){
+      if (code != TSDB_CODE_SUCCESS) {
         goto end;
       }
       isJson = true;
-    }else{
+    } else {
       STagVal val = {0};
       code = parseTagToken(&pCxt->pSql, &sToken, pTagSchema, precision, &val, &pCxt->msg);
       if (TSDB_CODE_SUCCESS != code) {
         taosMemoryFree(tmpTokenBuf);
         goto end;
       }
-      if (pTagSchema->type != TSDB_DATA_TYPE_BINARY){
+      if (pTagSchema->type != TSDB_DATA_TYPE_BINARY) {
         taosMemoryFree(tmpTokenBuf);
       }
       taosArrayPush(pTagVals, &val);
@@ -1032,7 +1032,7 @@ static int32_t parseTagsClause(SInsertParseContext* pCxt, SSchema* pSchema, uint
     goto end;
   }
 
-  if(!isJson && (code = tTagNew(pTagVals, 1, false, &pTag)) != TSDB_CODE_SUCCESS) {
+  if (!isJson && (code = tTagNew(pTagVals, 1, false, &pTag)) != TSDB_CODE_SUCCESS) {
     goto end;
   }
 
@@ -1040,8 +1040,8 @@ static int32_t parseTagsClause(SInsertParseContext* pCxt, SSchema* pSchema, uint
 
 end:
   for (int i = 0; i < taosArrayGetSize(pTagVals); ++i) {
-    STagVal *p = (STagVal *)taosArrayGet(pTagVals, i);
-    if(IS_VAR_DATA_TYPE(p->type)){
+    STagVal* p = (STagVal*)taosArrayGet(pTagVals, i);
+    if (IS_VAR_DATA_TYPE(p->type)) {
       taosMemoryFree(p->pData);
     }
   }
@@ -1701,10 +1701,10 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, char* tN
     return buildInvalidOperationMsg(&pBuf, "out of memory");
   }
 
-  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t  code = TSDB_CODE_SUCCESS;
   SSchema* pSchema = pDataBlock->pTableMeta->schema;
 
-  bool isJson = false;
+  bool  isJson = false;
   STag* pTag = NULL;
 
   for (int c = 0; c < tags->numOfBound; ++c) {
@@ -1713,7 +1713,7 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, char* tN
     }
 
     SSchema* pTagSchema = &pSchema[tags->boundColumns[c]];
-    int32_t colLen = pTagSchema->bytes;
+    int32_t  colLen = pTagSchema->bytes;
     if (IS_VAR_DATA_TYPE(pTagSchema->type)) {
       colLen = bind[c].length[0];
     }
@@ -1724,22 +1724,22 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, char* tN
       }
 
       isJson = true;
-      char *tmp = taosMemoryCalloc(1, colLen + 1);
+      char* tmp = taosMemoryCalloc(1, colLen + 1);
       memcpy(tmp, bind[c].buffer, colLen);
       code = parseJsontoTagData(tmp, pTagArray, &pTag, &pBuf);
       taosMemoryFree(tmp);
-      if(code != TSDB_CODE_SUCCESS){
+      if (code != TSDB_CODE_SUCCESS) {
         goto end;
       }
-    }else{
+    } else {
       STagVal val = {.cid = pTagSchema->colId, .type = pTagSchema->type};
-      if(pTagSchema->type == TSDB_DATA_TYPE_BINARY){
+      if (pTagSchema->type == TSDB_DATA_TYPE_BINARY) {
         val.pData = (uint8_t*)bind[c].buffer;
         val.nData = colLen;
-      }else if(pTagSchema->type == TSDB_DATA_TYPE_NCHAR){
+      } else if (pTagSchema->type == TSDB_DATA_TYPE_NCHAR) {
         int32_t output = 0;
-        void *p = taosMemoryCalloc(1, colLen * TSDB_NCHAR_SIZE);
-        if(p == NULL){
+        void*   p = taosMemoryCalloc(1, colLen * TSDB_NCHAR_SIZE);
+        if (p == NULL) {
           code = TSDB_CODE_OUT_OF_MEMORY;
           goto end;
         }
@@ -1757,7 +1757,7 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, char* tN
         }
         val.pData = p;
         val.nData = output;
-      }else{
+      } else {
         memcpy(&val.i64, bind[c].buffer, colLen);
       }
       taosArrayPush(pTagArray, &val);
@@ -1775,8 +1775,8 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, char* tN
 
 end:
   for (int i = 0; i < taosArrayGetSize(pTagArray); ++i) {
-    STagVal *p = (STagVal *)taosArrayGet(pTagArray, i);
-    if(p->type == TSDB_DATA_TYPE_NCHAR){
+    STagVal* p = (STagVal*)taosArrayGet(pTagArray, i);
+    if (p->type == TSDB_DATA_TYPE_NCHAR) {
       taosMemoryFree(p->pData);
     }
   }
@@ -1951,7 +1951,8 @@ int32_t qBindStmtSingleColValue(void* pBlock, TAOS_MULTI_BIND* bind, char* msgBu
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t buildBoundFields(SParsedDataColInfo* boundInfo, SSchema* pSchema, int32_t* fieldNum, TAOS_FIELD_E** fields, uint8_t timePrec) {
+int32_t buildBoundFields(SParsedDataColInfo* boundInfo, SSchema* pSchema, int32_t* fieldNum, TAOS_FIELD_E** fields,
+                         uint8_t timePrec) {
   if (fields) {
     *fields = taosMemoryCalloc(boundInfo->numOfBound, sizeof(TAOS_FIELD));
     if (NULL == *fields) {
@@ -1962,7 +1963,7 @@ int32_t buildBoundFields(SParsedDataColInfo* boundInfo, SSchema* pSchema, int32_
     if (TSDB_DATA_TYPE_TIMESTAMP == schema->type) {
       (*fields)[0].precision = timePrec;
     }
-    
+
     for (int32_t i = 0; i < boundInfo->numOfBound; ++i) {
       schema = &pSchema[boundInfo->boundColumns[i]];
       strcpy((*fields)[i].name, schema->name);
@@ -2008,7 +2009,8 @@ int32_t qBuildStmtColFields(void* pBlock, int32_t* fieldNum, TAOS_FIELD_E** fiel
     return TSDB_CODE_SUCCESS;
   }
 
-  CHECK_CODE(buildBoundFields(&pDataBlock->boundColumnInfo, pSchema, fieldNum, fields, pDataBlock->pTableMeta->tableInfo.precision));
+  CHECK_CODE(buildBoundFields(&pDataBlock->boundColumnInfo, pSchema, fieldNum, fields,
+                              pDataBlock->pTableMeta->tableInfo.precision));
 
   return TSDB_CODE_SUCCESS;
 }
@@ -2122,13 +2124,13 @@ static int32_t smlBuildTagRow(SArray* cols, SParsedDataColInfo* tags, SSchema* p
   int32_t code = TSDB_CODE_SUCCESS;
   for (int i = 0; i < tags->numOfBound; ++i) {
     SSchema* pTagSchema = &pSchema[tags->boundColumns[i]];
-    SSmlKv* kv = taosArrayGetP(cols, i);
+    SSmlKv*  kv = taosArrayGetP(cols, i);
 
     STagVal val = {.cid = pTagSchema->colId, .type = pTagSchema->type};
-    if(pTagSchema->type == TSDB_DATA_TYPE_BINARY){
-      val.pData = (uint8_t *)kv->value;
+    if (pTagSchema->type == TSDB_DATA_TYPE_BINARY) {
+      val.pData = (uint8_t*)kv->value;
       val.nData = kv->length;
-    }else if(pTagSchema->type == TSDB_DATA_TYPE_NCHAR){
+    } else if (pTagSchema->type == TSDB_DATA_TYPE_NCHAR) {
       int32_t output = 0;
       void *p = taosMemoryCalloc(1, kv->length * TSDB_NCHAR_SIZE);
       if(p == NULL){
@@ -2149,7 +2151,7 @@ static int32_t smlBuildTagRow(SArray* cols, SParsedDataColInfo* tags, SSchema* p
       }
       val.pData = p;
       val.nData = output;
-    }else{
+    } else {
       memcpy(&val.i64, &(kv->value), kv->length);
     }
     taosArrayPush(pTagArray, &val);
@@ -2158,8 +2160,8 @@ static int32_t smlBuildTagRow(SArray* cols, SParsedDataColInfo* tags, SSchema* p
   code = tTagNew(pTagArray, 1, false, ppTag);
 end:
   for (int i = 0; i < taosArrayGetSize(pTagArray); ++i) {
-    STagVal *p = (STagVal *)taosArrayGet(pTagArray, i);
-    if(p->type == TSDB_DATA_TYPE_NCHAR){
+    STagVal* p = (STagVal*)taosArrayGet(pTagArray, i);
+    if (p->type == TSDB_DATA_TYPE_NCHAR) {
       taosMemoryFree(p->pData);
     }
   }
diff --git a/source/libs/parser/src/parser.c b/source/libs/parser/src/parser.c
index bb70458f98..c2e1eba472 100644
--- a/source/libs/parser/src/parser.c
+++ b/source/libs/parser/src/parser.c
@@ -76,28 +76,8 @@ static int32_t setValueByBindParam(SValueNode* pVal, TAOS_MULTI_BIND* pParam) {
   int32_t inputSize = (NULL != pParam->length ? *(pParam->length) : tDataTypes[pParam->buffer_type].bytes);
   pVal->node.resType.type = pParam->buffer_type;
   pVal->node.resType.bytes = inputSize;
+  
   switch (pParam->buffer_type) {
-    case TSDB_DATA_TYPE_BOOL:
-      pVal->datum.b = *((bool*)pParam->buffer);
-      break;
-    case TSDB_DATA_TYPE_TINYINT:
-      pVal->datum.i = *((int8_t*)pParam->buffer);
-      break;
-    case TSDB_DATA_TYPE_SMALLINT:
-      pVal->datum.i = *((int16_t*)pParam->buffer);
-      break;
-    case TSDB_DATA_TYPE_INT:
-      pVal->datum.i = *((int32_t*)pParam->buffer);
-      break;
-    case TSDB_DATA_TYPE_BIGINT:
-      pVal->datum.i = *((int64_t*)pParam->buffer);
-      break;
-    case TSDB_DATA_TYPE_FLOAT:
-      pVal->datum.d = *((float*)pParam->buffer);
-      break;
-    case TSDB_DATA_TYPE_DOUBLE:
-      pVal->datum.d = *((double*)pParam->buffer);
-      break;
     case TSDB_DATA_TYPE_VARCHAR:
     case TSDB_DATA_TYPE_VARBINARY:
       pVal->datum.p = taosMemoryCalloc(1, pVal->node.resType.bytes + VARSTR_HEADER_SIZE + 1);
@@ -124,28 +104,13 @@ static int32_t setValueByBindParam(SValueNode* pVal, TAOS_MULTI_BIND* pParam) {
       pVal->node.resType.bytes = output + VARSTR_HEADER_SIZE;
       break;
     }
-    case TSDB_DATA_TYPE_TIMESTAMP:
-      pVal->datum.i = *((int64_t*)pParam->buffer);
-      break;
-    case TSDB_DATA_TYPE_UTINYINT:
-      pVal->datum.u = *((uint8_t*)pParam->buffer);
-      break;
-    case TSDB_DATA_TYPE_USMALLINT:
-      pVal->datum.u = *((uint16_t*)pParam->buffer);
-      break;
-    case TSDB_DATA_TYPE_UINT:
-      pVal->datum.u = *((uint32_t*)pParam->buffer);
-      break;
-    case TSDB_DATA_TYPE_UBIGINT:
-      pVal->datum.u = *((uint64_t*)pParam->buffer);
-      break;
-    case TSDB_DATA_TYPE_JSON:
-    case TSDB_DATA_TYPE_DECIMAL:
-    case TSDB_DATA_TYPE_BLOB:
-    case TSDB_DATA_TYPE_MEDIUMBLOB:
-      // todo
-    default:
+    default: {
+      int32_t code = nodesSetValueNodeValue(pVal, pParam->buffer);
+      if (code) {
+        return code;
+      }
       break;
+    }
   }
   pVal->translate = true;
   return TSDB_CODE_SUCCESS;
diff --git a/source/libs/parser/src/sql.c b/source/libs/parser/src/sql.c
index 7fb89bdd7c..ff4fe4032e 100644
--- a/source/libs/parser/src/sql.c
+++ b/source/libs/parser/src/sql.c
@@ -32,11 +32,15 @@
 #include <assert.h>
 #include <stdbool.h>
 
+#define ALLOW_FORBID_FUNC
+
 #include "functionMgt.h"
 #include "nodes.h"
 #include "parToken.h"
 #include "ttokendef.h"
 #include "parAst.h"
+
+#define YYSTACKDEPTH 0
 /**************** End of %include directives **********************************/
 /* These constants specify the various numeric values for terminal symbols
 ** in a format understandable to "makeheaders".  This section is blank unless
@@ -136,6 +140,7 @@ typedef union {
 #define YYFALLBACK 1
 #define YYNSTATE             612
 #define YYNRULE              451
+#define YYNRULE_WITH_ACTION  451
 #define YYNTOKEN             237
 #define YY_MAX_SHIFT         611
 #define YY_MIN_SHIFTREDUCE   898
@@ -640,7 +645,31 @@ static const YYCODETYPE yy_lookahead[] = {
  /*  2090 */   357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
  /*  2100 */   328,  329,  330,  357,  332,  357,  357,  335,  357,  357,
  /*  2110 */   357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
- /*  2120 */   348,  357,  357,  357,  352,
+ /*  2120 */   348,  357,  357,  357,  352,  237,  237,  237,  237,  237,
+ /*  2130 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2140 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2150 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2160 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2170 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2180 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2190 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2200 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2210 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2220 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2230 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2240 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2250 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2260 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2270 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2280 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2290 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2300 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2310 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2320 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2330 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2340 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2350 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2360 */   237,  237,
 };
 #define YY_SHIFT_COUNT    (611)
 #define YY_SHIFT_MIN      (0)
@@ -2382,15 +2411,18 @@ static YYACTIONTYPE yy_find_shift_action(
   do{
     i = yy_shift_ofst[stateno];
     assert( i>=0 );
-    /* assert( i+YYNTOKEN<=(int)YY_NLOOKAHEAD ); */
+    assert( i<=YY_ACTTAB_COUNT );
+    assert( i+YYNTOKEN<=(int)YY_NLOOKAHEAD );
     assert( iLookAhead!=YYNOCODE );
     assert( iLookAhead < YYNTOKEN );
     i += iLookAhead;
-    if( i>=YY_NLOOKAHEAD || yy_lookahead[i]!=iLookAhead ){
+    assert( i<(int)YY_NLOOKAHEAD );
+    if( yy_lookahead[i]!=iLookAhead ){
 #ifdef YYFALLBACK
       YYCODETYPE iFallback;            /* Fallback token */
-      if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
-             && (iFallback = yyFallback[iLookAhead])!=0 ){
+      assert( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0]) );
+      iFallback = yyFallback[iLookAhead];
+      if( iFallback!=0 ){
 #ifndef NDEBUG
         if( yyTraceFILE ){
           fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
@@ -2405,16 +2437,8 @@ static YYACTIONTYPE yy_find_shift_action(
 #ifdef YYWILDCARD
       {
         int j = i - iLookAhead + YYWILDCARD;
-        if( 
-#if YY_SHIFT_MIN+YYWILDCARD<0
-          j>=0 &&
-#endif
-#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT
-          j<YY_ACTTAB_COUNT &&
-#endif
-          j<(int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])) &&
-          yy_lookahead[j]==YYWILDCARD && iLookAhead>0
-        ){
+        assert( j<(int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])) );
+        if( yy_lookahead[j]==YYWILDCARD && iLookAhead>0 ){
 #ifndef NDEBUG
           if( yyTraceFILE ){
             fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
@@ -2428,6 +2452,7 @@ static YYACTIONTYPE yy_find_shift_action(
 #endif /* YYWILDCARD */
       return yy_default[stateno];
     }else{
+      assert( i>=0 && i<sizeof(yy_action)/sizeof(yy_action[0]) );
       return yy_action[i];
     }
   }while(1);
@@ -2546,464 +2571,916 @@ static void yy_shift(
   yyTraceShift(yypParser, yyNewState, "Shift");
 }
 
-/* The following table contains information about every rule that
-** is used during the reduce.
-*/
-static const struct {
-  YYCODETYPE lhs;       /* Symbol on the left-hand side of the rule */
-  signed char nrhs;     /* Negative of the number of RHS symbols in the rule */
-} yyRuleInfo[] = {
-  {  237,   -6 }, /* (0) cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */
-  {  237,   -4 }, /* (1) cmd ::= ALTER ACCOUNT NK_ID alter_account_options */
-  {  238,    0 }, /* (2) account_options ::= */
-  {  238,   -3 }, /* (3) account_options ::= account_options PPS literal */
-  {  238,   -3 }, /* (4) account_options ::= account_options TSERIES literal */
-  {  238,   -3 }, /* (5) account_options ::= account_options STORAGE literal */
-  {  238,   -3 }, /* (6) account_options ::= account_options STREAMS literal */
-  {  238,   -3 }, /* (7) account_options ::= account_options QTIME literal */
-  {  238,   -3 }, /* (8) account_options ::= account_options DBS literal */
-  {  238,   -3 }, /* (9) account_options ::= account_options USERS literal */
-  {  238,   -3 }, /* (10) account_options ::= account_options CONNS literal */
-  {  238,   -3 }, /* (11) account_options ::= account_options STATE literal */
-  {  239,   -1 }, /* (12) alter_account_options ::= alter_account_option */
-  {  239,   -2 }, /* (13) alter_account_options ::= alter_account_options alter_account_option */
-  {  241,   -2 }, /* (14) alter_account_option ::= PASS literal */
-  {  241,   -2 }, /* (15) alter_account_option ::= PPS literal */
-  {  241,   -2 }, /* (16) alter_account_option ::= TSERIES literal */
-  {  241,   -2 }, /* (17) alter_account_option ::= STORAGE literal */
-  {  241,   -2 }, /* (18) alter_account_option ::= STREAMS literal */
-  {  241,   -2 }, /* (19) alter_account_option ::= QTIME literal */
-  {  241,   -2 }, /* (20) alter_account_option ::= DBS literal */
-  {  241,   -2 }, /* (21) alter_account_option ::= USERS literal */
-  {  241,   -2 }, /* (22) alter_account_option ::= CONNS literal */
-  {  241,   -2 }, /* (23) alter_account_option ::= STATE literal */
-  {  237,   -5 }, /* (24) cmd ::= CREATE USER user_name PASS NK_STRING */
-  {  237,   -5 }, /* (25) cmd ::= ALTER USER user_name PASS NK_STRING */
-  {  237,   -5 }, /* (26) cmd ::= ALTER USER user_name PRIVILEGE NK_STRING */
-  {  237,   -3 }, /* (27) cmd ::= DROP USER user_name */
-  {  237,   -6 }, /* (28) cmd ::= GRANT privileges ON priv_level TO user_name */
-  {  237,   -6 }, /* (29) cmd ::= REVOKE privileges ON priv_level FROM user_name */
-  {  243,   -1 }, /* (30) privileges ::= ALL */
-  {  243,   -1 }, /* (31) privileges ::= priv_type_list */
-  {  245,   -1 }, /* (32) priv_type_list ::= priv_type */
-  {  245,   -3 }, /* (33) priv_type_list ::= priv_type_list NK_COMMA priv_type */
-  {  246,   -1 }, /* (34) priv_type ::= READ */
-  {  246,   -1 }, /* (35) priv_type ::= WRITE */
-  {  244,   -3 }, /* (36) priv_level ::= NK_STAR NK_DOT NK_STAR */
-  {  244,   -3 }, /* (37) priv_level ::= db_name NK_DOT NK_STAR */
-  {  237,   -3 }, /* (38) cmd ::= CREATE DNODE dnode_endpoint */
-  {  237,   -5 }, /* (39) cmd ::= CREATE DNODE dnode_host_name PORT NK_INTEGER */
-  {  237,   -3 }, /* (40) cmd ::= DROP DNODE NK_INTEGER */
-  {  237,   -3 }, /* (41) cmd ::= DROP DNODE dnode_endpoint */
-  {  237,   -4 }, /* (42) cmd ::= ALTER DNODE NK_INTEGER NK_STRING */
-  {  237,   -5 }, /* (43) cmd ::= ALTER DNODE NK_INTEGER NK_STRING NK_STRING */
-  {  237,   -4 }, /* (44) cmd ::= ALTER ALL DNODES NK_STRING */
-  {  237,   -5 }, /* (45) cmd ::= ALTER ALL DNODES NK_STRING NK_STRING */
-  {  248,   -1 }, /* (46) dnode_endpoint ::= NK_STRING */
-  {  249,   -1 }, /* (47) dnode_host_name ::= NK_ID */
-  {  249,   -1 }, /* (48) dnode_host_name ::= NK_IPTOKEN */
-  {  237,   -3 }, /* (49) cmd ::= ALTER LOCAL NK_STRING */
-  {  237,   -4 }, /* (50) cmd ::= ALTER LOCAL NK_STRING NK_STRING */
-  {  237,   -5 }, /* (51) cmd ::= CREATE QNODE ON DNODE NK_INTEGER */
-  {  237,   -5 }, /* (52) cmd ::= DROP QNODE ON DNODE NK_INTEGER */
-  {  237,   -5 }, /* (53) cmd ::= CREATE BNODE ON DNODE NK_INTEGER */
-  {  237,   -5 }, /* (54) cmd ::= DROP BNODE ON DNODE NK_INTEGER */
-  {  237,   -5 }, /* (55) cmd ::= CREATE SNODE ON DNODE NK_INTEGER */
-  {  237,   -5 }, /* (56) cmd ::= DROP SNODE ON DNODE NK_INTEGER */
-  {  237,   -5 }, /* (57) cmd ::= CREATE MNODE ON DNODE NK_INTEGER */
-  {  237,   -5 }, /* (58) cmd ::= DROP MNODE ON DNODE NK_INTEGER */
-  {  237,   -5 }, /* (59) cmd ::= CREATE DATABASE not_exists_opt db_name db_options */
-  {  237,   -4 }, /* (60) cmd ::= DROP DATABASE exists_opt db_name */
-  {  237,   -2 }, /* (61) cmd ::= USE db_name */
-  {  237,   -4 }, /* (62) cmd ::= ALTER DATABASE db_name alter_db_options */
-  {  250,   -3 }, /* (63) not_exists_opt ::= IF NOT EXISTS */
-  {  250,    0 }, /* (64) not_exists_opt ::= */
-  {  252,   -2 }, /* (65) exists_opt ::= IF EXISTS */
-  {  252,    0 }, /* (66) exists_opt ::= */
-  {  251,    0 }, /* (67) db_options ::= */
-  {  251,   -3 }, /* (68) db_options ::= db_options BUFFER NK_INTEGER */
-  {  251,   -3 }, /* (69) db_options ::= db_options CACHELAST NK_INTEGER */
-  {  251,   -3 }, /* (70) db_options ::= db_options COMP NK_INTEGER */
-  {  251,   -3 }, /* (71) db_options ::= db_options DAYS NK_INTEGER */
-  {  251,   -3 }, /* (72) db_options ::= db_options DAYS NK_VARIABLE */
-  {  251,   -3 }, /* (73) db_options ::= db_options FSYNC NK_INTEGER */
-  {  251,   -3 }, /* (74) db_options ::= db_options MAXROWS NK_INTEGER */
-  {  251,   -3 }, /* (75) db_options ::= db_options MINROWS NK_INTEGER */
-  {  251,   -3 }, /* (76) db_options ::= db_options KEEP integer_list */
-  {  251,   -3 }, /* (77) db_options ::= db_options KEEP variable_list */
-  {  251,   -3 }, /* (78) db_options ::= db_options PAGES NK_INTEGER */
-  {  251,   -3 }, /* (79) db_options ::= db_options PAGESIZE NK_INTEGER */
-  {  251,   -3 }, /* (80) db_options ::= db_options PRECISION NK_STRING */
-  {  251,   -3 }, /* (81) db_options ::= db_options REPLICA NK_INTEGER */
-  {  251,   -3 }, /* (82) db_options ::= db_options STRICT NK_INTEGER */
-  {  251,   -3 }, /* (83) db_options ::= db_options WAL NK_INTEGER */
-  {  251,   -3 }, /* (84) db_options ::= db_options VGROUPS NK_INTEGER */
-  {  251,   -3 }, /* (85) db_options ::= db_options SINGLE_STABLE NK_INTEGER */
-  {  251,   -3 }, /* (86) db_options ::= db_options RETENTIONS retention_list */
-  {  251,   -3 }, /* (87) db_options ::= db_options SCHEMALESS NK_INTEGER */
-  {  253,   -1 }, /* (88) alter_db_options ::= alter_db_option */
-  {  253,   -2 }, /* (89) alter_db_options ::= alter_db_options alter_db_option */
-  {  257,   -2 }, /* (90) alter_db_option ::= BUFFER NK_INTEGER */
-  {  257,   -2 }, /* (91) alter_db_option ::= CACHELAST NK_INTEGER */
-  {  257,   -2 }, /* (92) alter_db_option ::= FSYNC NK_INTEGER */
-  {  257,   -2 }, /* (93) alter_db_option ::= KEEP integer_list */
-  {  257,   -2 }, /* (94) alter_db_option ::= KEEP variable_list */
-  {  257,   -2 }, /* (95) alter_db_option ::= PAGES NK_INTEGER */
-  {  257,   -2 }, /* (96) alter_db_option ::= REPLICA NK_INTEGER */
-  {  257,   -2 }, /* (97) alter_db_option ::= STRICT NK_INTEGER */
-  {  257,   -2 }, /* (98) alter_db_option ::= WAL NK_INTEGER */
-  {  254,   -1 }, /* (99) integer_list ::= NK_INTEGER */
-  {  254,   -3 }, /* (100) integer_list ::= integer_list NK_COMMA NK_INTEGER */
-  {  255,   -1 }, /* (101) variable_list ::= NK_VARIABLE */
-  {  255,   -3 }, /* (102) variable_list ::= variable_list NK_COMMA NK_VARIABLE */
-  {  256,   -1 }, /* (103) retention_list ::= retention */
-  {  256,   -3 }, /* (104) retention_list ::= retention_list NK_COMMA retention */
-  {  258,   -3 }, /* (105) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */
-  {  237,   -9 }, /* (106) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */
-  {  237,   -3 }, /* (107) cmd ::= CREATE TABLE multi_create_clause */
-  {  237,   -9 }, /* (108) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */
-  {  237,   -3 }, /* (109) cmd ::= DROP TABLE multi_drop_clause */
-  {  237,   -4 }, /* (110) cmd ::= DROP STABLE exists_opt full_table_name */
-  {  237,   -3 }, /* (111) cmd ::= ALTER TABLE alter_table_clause */
-  {  237,   -3 }, /* (112) cmd ::= ALTER STABLE alter_table_clause */
-  {  266,   -2 }, /* (113) alter_table_clause ::= full_table_name alter_table_options */
-  {  266,   -5 }, /* (114) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */
-  {  266,   -4 }, /* (115) alter_table_clause ::= full_table_name DROP COLUMN column_name */
-  {  266,   -5 }, /* (116) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */
-  {  266,   -5 }, /* (117) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */
-  {  266,   -5 }, /* (118) alter_table_clause ::= full_table_name ADD TAG column_name type_name */
-  {  266,   -4 }, /* (119) alter_table_clause ::= full_table_name DROP TAG column_name */
-  {  266,   -5 }, /* (120) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */
-  {  266,   -5 }, /* (121) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */
-  {  266,   -6 }, /* (122) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */
-  {  263,   -1 }, /* (123) multi_create_clause ::= create_subtable_clause */
-  {  263,   -2 }, /* (124) multi_create_clause ::= multi_create_clause create_subtable_clause */
-  {  271,  -10 }, /* (125) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_tags_opt TAGS NK_LP literal_list NK_RP table_options */
-  {  265,   -1 }, /* (126) multi_drop_clause ::= drop_table_clause */
-  {  265,   -2 }, /* (127) multi_drop_clause ::= multi_drop_clause drop_table_clause */
-  {  274,   -2 }, /* (128) drop_table_clause ::= exists_opt full_table_name */
-  {  272,    0 }, /* (129) specific_tags_opt ::= */
-  {  272,   -3 }, /* (130) specific_tags_opt ::= NK_LP col_name_list NK_RP */
-  {  259,   -1 }, /* (131) full_table_name ::= table_name */
-  {  259,   -3 }, /* (132) full_table_name ::= db_name NK_DOT table_name */
-  {  260,   -1 }, /* (133) column_def_list ::= column_def */
-  {  260,   -3 }, /* (134) column_def_list ::= column_def_list NK_COMMA column_def */
-  {  277,   -2 }, /* (135) column_def ::= column_name type_name */
-  {  277,   -4 }, /* (136) column_def ::= column_name type_name COMMENT NK_STRING */
-  {  269,   -1 }, /* (137) type_name ::= BOOL */
-  {  269,   -1 }, /* (138) type_name ::= TINYINT */
-  {  269,   -1 }, /* (139) type_name ::= SMALLINT */
-  {  269,   -1 }, /* (140) type_name ::= INT */
-  {  269,   -1 }, /* (141) type_name ::= INTEGER */
-  {  269,   -1 }, /* (142) type_name ::= BIGINT */
-  {  269,   -1 }, /* (143) type_name ::= FLOAT */
-  {  269,   -1 }, /* (144) type_name ::= DOUBLE */
-  {  269,   -4 }, /* (145) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */
-  {  269,   -1 }, /* (146) type_name ::= TIMESTAMP */
-  {  269,   -4 }, /* (147) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */
-  {  269,   -2 }, /* (148) type_name ::= TINYINT UNSIGNED */
-  {  269,   -2 }, /* (149) type_name ::= SMALLINT UNSIGNED */
-  {  269,   -2 }, /* (150) type_name ::= INT UNSIGNED */
-  {  269,   -2 }, /* (151) type_name ::= BIGINT UNSIGNED */
-  {  269,   -1 }, /* (152) type_name ::= JSON */
-  {  269,   -4 }, /* (153) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */
-  {  269,   -1 }, /* (154) type_name ::= MEDIUMBLOB */
-  {  269,   -1 }, /* (155) type_name ::= BLOB */
-  {  269,   -4 }, /* (156) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */
-  {  269,   -1 }, /* (157) type_name ::= DECIMAL */
-  {  269,   -4 }, /* (158) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */
-  {  269,   -6 }, /* (159) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */
-  {  261,    0 }, /* (160) tags_def_opt ::= */
-  {  261,   -1 }, /* (161) tags_def_opt ::= tags_def */
-  {  264,   -4 }, /* (162) tags_def ::= TAGS NK_LP column_def_list NK_RP */
-  {  262,    0 }, /* (163) table_options ::= */
-  {  262,   -3 }, /* (164) table_options ::= table_options COMMENT NK_STRING */
-  {  262,   -3 }, /* (165) table_options ::= table_options FILE_FACTOR NK_FLOAT */
-  {  262,   -5 }, /* (166) table_options ::= table_options ROLLUP NK_LP func_name_list NK_RP */
-  {  262,   -3 }, /* (167) table_options ::= table_options TTL NK_INTEGER */
-  {  262,   -5 }, /* (168) table_options ::= table_options SMA NK_LP col_name_list NK_RP */
-  {  267,   -1 }, /* (169) alter_table_options ::= alter_table_option */
-  {  267,   -2 }, /* (170) alter_table_options ::= alter_table_options alter_table_option */
-  {  279,   -2 }, /* (171) alter_table_option ::= COMMENT NK_STRING */
-  {  279,   -2 }, /* (172) alter_table_option ::= TTL NK_INTEGER */
-  {  275,   -1 }, /* (173) col_name_list ::= col_name */
-  {  275,   -3 }, /* (174) col_name_list ::= col_name_list NK_COMMA col_name */
-  {  280,   -1 }, /* (175) col_name ::= column_name */
-  {  237,   -2 }, /* (176) cmd ::= SHOW DNODES */
-  {  237,   -2 }, /* (177) cmd ::= SHOW USERS */
-  {  237,   -2 }, /* (178) cmd ::= SHOW DATABASES */
-  {  237,   -4 }, /* (179) cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */
-  {  237,   -4 }, /* (180) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */
-  {  237,   -3 }, /* (181) cmd ::= SHOW db_name_cond_opt VGROUPS */
-  {  237,   -2 }, /* (182) cmd ::= SHOW MNODES */
-  {  237,   -2 }, /* (183) cmd ::= SHOW MODULES */
-  {  237,   -2 }, /* (184) cmd ::= SHOW QNODES */
-  {  237,   -2 }, /* (185) cmd ::= SHOW FUNCTIONS */
-  {  237,   -5 }, /* (186) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */
-  {  237,   -2 }, /* (187) cmd ::= SHOW STREAMS */
-  {  237,   -2 }, /* (188) cmd ::= SHOW ACCOUNTS */
-  {  237,   -2 }, /* (189) cmd ::= SHOW APPS */
-  {  237,   -2 }, /* (190) cmd ::= SHOW CONNECTIONS */
-  {  237,   -2 }, /* (191) cmd ::= SHOW LICENCE */
-  {  237,   -2 }, /* (192) cmd ::= SHOW GRANTS */
-  {  237,   -4 }, /* (193) cmd ::= SHOW CREATE DATABASE db_name */
-  {  237,   -4 }, /* (194) cmd ::= SHOW CREATE TABLE full_table_name */
-  {  237,   -4 }, /* (195) cmd ::= SHOW CREATE STABLE full_table_name */
-  {  237,   -2 }, /* (196) cmd ::= SHOW QUERIES */
-  {  237,   -2 }, /* (197) cmd ::= SHOW SCORES */
-  {  237,   -2 }, /* (198) cmd ::= SHOW TOPICS */
-  {  237,   -2 }, /* (199) cmd ::= SHOW VARIABLES */
-  {  237,   -2 }, /* (200) cmd ::= SHOW BNODES */
-  {  237,   -2 }, /* (201) cmd ::= SHOW SNODES */
-  {  237,   -2 }, /* (202) cmd ::= SHOW CLUSTER */
-  {  237,   -2 }, /* (203) cmd ::= SHOW TRANSACTIONS */
-  {  281,    0 }, /* (204) db_name_cond_opt ::= */
-  {  281,   -2 }, /* (205) db_name_cond_opt ::= db_name NK_DOT */
-  {  282,    0 }, /* (206) like_pattern_opt ::= */
-  {  282,   -2 }, /* (207) like_pattern_opt ::= LIKE NK_STRING */
-  {  283,   -1 }, /* (208) table_name_cond ::= table_name */
-  {  284,    0 }, /* (209) from_db_opt ::= */
-  {  284,   -2 }, /* (210) from_db_opt ::= FROM db_name */
-  {  278,   -1 }, /* (211) func_name_list ::= func_name */
-  {  278,   -3 }, /* (212) func_name_list ::= func_name_list NK_COMMA func_name */
-  {  285,   -1 }, /* (213) func_name ::= function_name */
-  {  237,   -8 }, /* (214) cmd ::= CREATE SMA INDEX not_exists_opt index_name ON table_name index_options */
-  {  237,  -10 }, /* (215) cmd ::= CREATE FULLTEXT INDEX not_exists_opt index_name ON table_name NK_LP col_name_list NK_RP */
-  {  237,   -6 }, /* (216) cmd ::= DROP INDEX exists_opt index_name ON table_name */
-  {  288,    0 }, /* (217) index_options ::= */
-  {  288,   -9 }, /* (218) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt */
-  {  288,  -11 }, /* (219) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt */
-  {  289,   -1 }, /* (220) func_list ::= func */
-  {  289,   -3 }, /* (221) func_list ::= func_list NK_COMMA func */
-  {  292,   -4 }, /* (222) func ::= function_name NK_LP expression_list NK_RP */
-  {  237,   -6 }, /* (223) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_expression */
-  {  237,   -7 }, /* (224) cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name */
-  {  237,   -7 }, /* (225) cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name */
-  {  237,   -4 }, /* (226) cmd ::= DROP TOPIC exists_opt topic_name */
-  {  237,   -7 }, /* (227) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */
-  {  237,   -2 }, /* (228) cmd ::= DESC full_table_name */
-  {  237,   -2 }, /* (229) cmd ::= DESCRIBE full_table_name */
-  {  237,   -3 }, /* (230) cmd ::= RESET QUERY CACHE */
-  {  237,   -4 }, /* (231) cmd ::= EXPLAIN analyze_opt explain_options query_expression */
-  {  297,    0 }, /* (232) analyze_opt ::= */
-  {  297,   -1 }, /* (233) analyze_opt ::= ANALYZE */
-  {  298,    0 }, /* (234) explain_options ::= */
-  {  298,   -3 }, /* (235) explain_options ::= explain_options VERBOSE NK_BOOL */
-  {  298,   -3 }, /* (236) explain_options ::= explain_options RATIO NK_FLOAT */
-  {  237,   -6 }, /* (237) cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP */
-  {  237,  -10 }, /* (238) cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */
-  {  237,   -4 }, /* (239) cmd ::= DROP FUNCTION exists_opt function_name */
-  {  299,    0 }, /* (240) agg_func_opt ::= */
-  {  299,   -1 }, /* (241) agg_func_opt ::= AGGREGATE */
-  {  300,    0 }, /* (242) bufsize_opt ::= */
-  {  300,   -2 }, /* (243) bufsize_opt ::= BUFSIZE NK_INTEGER */
-  {  237,   -8 }, /* (244) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options into_opt AS query_expression */
-  {  237,   -4 }, /* (245) cmd ::= DROP STREAM exists_opt stream_name */
-  {  303,    0 }, /* (246) into_opt ::= */
-  {  303,   -2 }, /* (247) into_opt ::= INTO full_table_name */
-  {  302,    0 }, /* (248) stream_options ::= */
-  {  302,   -3 }, /* (249) stream_options ::= stream_options TRIGGER AT_ONCE */
-  {  302,   -3 }, /* (250) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */
-  {  302,   -3 }, /* (251) stream_options ::= stream_options WATERMARK duration_literal */
-  {  237,   -3 }, /* (252) cmd ::= KILL CONNECTION NK_INTEGER */
-  {  237,   -3 }, /* (253) cmd ::= KILL QUERY NK_INTEGER */
-  {  237,   -3 }, /* (254) cmd ::= KILL TRANSACTION NK_INTEGER */
-  {  237,   -4 }, /* (255) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */
-  {  237,   -4 }, /* (256) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */
-  {  237,   -3 }, /* (257) cmd ::= SPLIT VGROUP NK_INTEGER */
-  {  304,   -2 }, /* (258) dnode_list ::= DNODE NK_INTEGER */
-  {  304,   -3 }, /* (259) dnode_list ::= dnode_list DNODE NK_INTEGER */
-  {  237,   -3 }, /* (260) cmd ::= SYNCDB db_name REPLICA */
-  {  237,   -1 }, /* (261) cmd ::= query_expression */
-  {  240,   -1 }, /* (262) literal ::= NK_INTEGER */
-  {  240,   -1 }, /* (263) literal ::= NK_FLOAT */
-  {  240,   -1 }, /* (264) literal ::= NK_STRING */
-  {  240,   -1 }, /* (265) literal ::= NK_BOOL */
-  {  240,   -2 }, /* (266) literal ::= TIMESTAMP NK_STRING */
-  {  240,   -1 }, /* (267) literal ::= duration_literal */
-  {  240,   -1 }, /* (268) literal ::= NULL */
-  {  240,   -1 }, /* (269) literal ::= NK_QUESTION */
-  {  290,   -1 }, /* (270) duration_literal ::= NK_VARIABLE */
-  {  305,   -1 }, /* (271) signed ::= NK_INTEGER */
-  {  305,   -2 }, /* (272) signed ::= NK_PLUS NK_INTEGER */
-  {  305,   -2 }, /* (273) signed ::= NK_MINUS NK_INTEGER */
-  {  305,   -1 }, /* (274) signed ::= NK_FLOAT */
-  {  305,   -2 }, /* (275) signed ::= NK_PLUS NK_FLOAT */
-  {  305,   -2 }, /* (276) signed ::= NK_MINUS NK_FLOAT */
-  {  270,   -1 }, /* (277) signed_literal ::= signed */
-  {  270,   -1 }, /* (278) signed_literal ::= NK_STRING */
-  {  270,   -1 }, /* (279) signed_literal ::= NK_BOOL */
-  {  270,   -2 }, /* (280) signed_literal ::= TIMESTAMP NK_STRING */
-  {  270,   -1 }, /* (281) signed_literal ::= duration_literal */
-  {  270,   -1 }, /* (282) signed_literal ::= NULL */
-  {  270,   -1 }, /* (283) signed_literal ::= literal_func */
-  {  273,   -1 }, /* (284) literal_list ::= signed_literal */
-  {  273,   -3 }, /* (285) literal_list ::= literal_list NK_COMMA signed_literal */
-  {  247,   -1 }, /* (286) db_name ::= NK_ID */
-  {  276,   -1 }, /* (287) table_name ::= NK_ID */
-  {  268,   -1 }, /* (288) column_name ::= NK_ID */
-  {  286,   -1 }, /* (289) function_name ::= NK_ID */
-  {  307,   -1 }, /* (290) table_alias ::= NK_ID */
-  {  308,   -1 }, /* (291) column_alias ::= NK_ID */
-  {  242,   -1 }, /* (292) user_name ::= NK_ID */
-  {  287,   -1 }, /* (293) index_name ::= NK_ID */
-  {  294,   -1 }, /* (294) topic_name ::= NK_ID */
-  {  301,   -1 }, /* (295) stream_name ::= NK_ID */
-  {  296,   -1 }, /* (296) cgroup_name ::= NK_ID */
-  {  309,   -1 }, /* (297) expression ::= literal */
-  {  309,   -1 }, /* (298) expression ::= pseudo_column */
-  {  309,   -1 }, /* (299) expression ::= column_reference */
-  {  309,   -1 }, /* (300) expression ::= function_expression */
-  {  309,   -1 }, /* (301) expression ::= subquery */
-  {  309,   -3 }, /* (302) expression ::= NK_LP expression NK_RP */
-  {  309,   -2 }, /* (303) expression ::= NK_PLUS expression */
-  {  309,   -2 }, /* (304) expression ::= NK_MINUS expression */
-  {  309,   -3 }, /* (305) expression ::= expression NK_PLUS expression */
-  {  309,   -3 }, /* (306) expression ::= expression NK_MINUS expression */
-  {  309,   -3 }, /* (307) expression ::= expression NK_STAR expression */
-  {  309,   -3 }, /* (308) expression ::= expression NK_SLASH expression */
-  {  309,   -3 }, /* (309) expression ::= expression NK_REM expression */
-  {  309,   -3 }, /* (310) expression ::= column_reference NK_ARROW NK_STRING */
-  {  293,   -1 }, /* (311) expression_list ::= expression */
-  {  293,   -3 }, /* (312) expression_list ::= expression_list NK_COMMA expression */
-  {  311,   -1 }, /* (313) column_reference ::= column_name */
-  {  311,   -3 }, /* (314) column_reference ::= table_name NK_DOT column_name */
-  {  310,   -1 }, /* (315) pseudo_column ::= ROWTS */
-  {  310,   -1 }, /* (316) pseudo_column ::= TBNAME */
-  {  310,   -3 }, /* (317) pseudo_column ::= table_name NK_DOT TBNAME */
-  {  310,   -1 }, /* (318) pseudo_column ::= QSTARTTS */
-  {  310,   -1 }, /* (319) pseudo_column ::= QENDTS */
-  {  310,   -1 }, /* (320) pseudo_column ::= WSTARTTS */
-  {  310,   -1 }, /* (321) pseudo_column ::= WENDTS */
-  {  310,   -1 }, /* (322) pseudo_column ::= WDURATION */
-  {  312,   -4 }, /* (323) function_expression ::= function_name NK_LP expression_list NK_RP */
-  {  312,   -4 }, /* (324) function_expression ::= star_func NK_LP star_func_para_list NK_RP */
-  {  312,   -6 }, /* (325) function_expression ::= CAST NK_LP expression AS type_name NK_RP */
-  {  312,   -1 }, /* (326) function_expression ::= literal_func */
-  {  306,   -3 }, /* (327) literal_func ::= noarg_func NK_LP NK_RP */
-  {  306,   -1 }, /* (328) literal_func ::= NOW */
-  {  316,   -1 }, /* (329) noarg_func ::= NOW */
-  {  316,   -1 }, /* (330) noarg_func ::= TODAY */
-  {  316,   -1 }, /* (331) noarg_func ::= TIMEZONE */
-  {  314,   -1 }, /* (332) star_func ::= COUNT */
-  {  314,   -1 }, /* (333) star_func ::= FIRST */
-  {  314,   -1 }, /* (334) star_func ::= LAST */
-  {  314,   -1 }, /* (335) star_func ::= LAST_ROW */
-  {  315,   -1 }, /* (336) star_func_para_list ::= NK_STAR */
-  {  315,   -1 }, /* (337) star_func_para_list ::= other_para_list */
-  {  317,   -1 }, /* (338) other_para_list ::= star_func_para */
-  {  317,   -3 }, /* (339) other_para_list ::= other_para_list NK_COMMA star_func_para */
-  {  318,   -1 }, /* (340) star_func_para ::= expression */
-  {  318,   -3 }, /* (341) star_func_para ::= table_name NK_DOT NK_STAR */
-  {  319,   -3 }, /* (342) predicate ::= expression compare_op expression */
-  {  319,   -5 }, /* (343) predicate ::= expression BETWEEN expression AND expression */
-  {  319,   -6 }, /* (344) predicate ::= expression NOT BETWEEN expression AND expression */
-  {  319,   -3 }, /* (345) predicate ::= expression IS NULL */
-  {  319,   -4 }, /* (346) predicate ::= expression IS NOT NULL */
-  {  319,   -3 }, /* (347) predicate ::= expression in_op in_predicate_value */
-  {  320,   -1 }, /* (348) compare_op ::= NK_LT */
-  {  320,   -1 }, /* (349) compare_op ::= NK_GT */
-  {  320,   -1 }, /* (350) compare_op ::= NK_LE */
-  {  320,   -1 }, /* (351) compare_op ::= NK_GE */
-  {  320,   -1 }, /* (352) compare_op ::= NK_NE */
-  {  320,   -1 }, /* (353) compare_op ::= NK_EQ */
-  {  320,   -1 }, /* (354) compare_op ::= LIKE */
-  {  320,   -2 }, /* (355) compare_op ::= NOT LIKE */
-  {  320,   -1 }, /* (356) compare_op ::= MATCH */
-  {  320,   -1 }, /* (357) compare_op ::= NMATCH */
-  {  320,   -1 }, /* (358) compare_op ::= CONTAINS */
-  {  321,   -1 }, /* (359) in_op ::= IN */
-  {  321,   -2 }, /* (360) in_op ::= NOT IN */
-  {  322,   -3 }, /* (361) in_predicate_value ::= NK_LP expression_list NK_RP */
-  {  323,   -1 }, /* (362) boolean_value_expression ::= boolean_primary */
-  {  323,   -2 }, /* (363) boolean_value_expression ::= NOT boolean_primary */
-  {  323,   -3 }, /* (364) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
-  {  323,   -3 }, /* (365) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
-  {  324,   -1 }, /* (366) boolean_primary ::= predicate */
-  {  324,   -3 }, /* (367) boolean_primary ::= NK_LP boolean_value_expression NK_RP */
-  {  325,   -1 }, /* (368) common_expression ::= expression */
-  {  325,   -1 }, /* (369) common_expression ::= boolean_value_expression */
-  {  326,   -2 }, /* (370) from_clause ::= FROM table_reference_list */
-  {  327,   -1 }, /* (371) table_reference_list ::= table_reference */
-  {  327,   -3 }, /* (372) table_reference_list ::= table_reference_list NK_COMMA table_reference */
-  {  328,   -1 }, /* (373) table_reference ::= table_primary */
-  {  328,   -1 }, /* (374) table_reference ::= joined_table */
-  {  329,   -2 }, /* (375) table_primary ::= table_name alias_opt */
-  {  329,   -4 }, /* (376) table_primary ::= db_name NK_DOT table_name alias_opt */
-  {  329,   -2 }, /* (377) table_primary ::= subquery alias_opt */
-  {  329,   -1 }, /* (378) table_primary ::= parenthesized_joined_table */
-  {  331,    0 }, /* (379) alias_opt ::= */
-  {  331,   -1 }, /* (380) alias_opt ::= table_alias */
-  {  331,   -2 }, /* (381) alias_opt ::= AS table_alias */
-  {  332,   -3 }, /* (382) parenthesized_joined_table ::= NK_LP joined_table NK_RP */
-  {  332,   -3 }, /* (383) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */
-  {  330,   -6 }, /* (384) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
-  {  333,    0 }, /* (385) join_type ::= */
-  {  333,   -1 }, /* (386) join_type ::= INNER */
-  {  335,   -9 }, /* (387) query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
-  {  336,    0 }, /* (388) set_quantifier_opt ::= */
-  {  336,   -1 }, /* (389) set_quantifier_opt ::= DISTINCT */
-  {  336,   -1 }, /* (390) set_quantifier_opt ::= ALL */
-  {  337,   -1 }, /* (391) select_list ::= NK_STAR */
-  {  337,   -1 }, /* (392) select_list ::= select_sublist */
-  {  343,   -1 }, /* (393) select_sublist ::= select_item */
-  {  343,   -3 }, /* (394) select_sublist ::= select_sublist NK_COMMA select_item */
-  {  344,   -1 }, /* (395) select_item ::= common_expression */
-  {  344,   -2 }, /* (396) select_item ::= common_expression column_alias */
-  {  344,   -3 }, /* (397) select_item ::= common_expression AS column_alias */
-  {  344,   -3 }, /* (398) select_item ::= table_name NK_DOT NK_STAR */
-  {  338,    0 }, /* (399) where_clause_opt ::= */
-  {  338,   -2 }, /* (400) where_clause_opt ::= WHERE search_condition */
-  {  339,    0 }, /* (401) partition_by_clause_opt ::= */
-  {  339,   -3 }, /* (402) partition_by_clause_opt ::= PARTITION BY expression_list */
-  {  340,    0 }, /* (403) twindow_clause_opt ::= */
-  {  340,   -6 }, /* (404) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
-  {  340,   -4 }, /* (405) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */
-  {  340,   -6 }, /* (406) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
-  {  340,   -8 }, /* (407) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
-  {  291,    0 }, /* (408) sliding_opt ::= */
-  {  291,   -4 }, /* (409) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
-  {  345,    0 }, /* (410) fill_opt ::= */
-  {  345,   -4 }, /* (411) fill_opt ::= FILL NK_LP fill_mode NK_RP */
-  {  345,   -6 }, /* (412) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */
-  {  346,   -1 }, /* (413) fill_mode ::= NONE */
-  {  346,   -1 }, /* (414) fill_mode ::= PREV */
-  {  346,   -1 }, /* (415) fill_mode ::= NULL */
-  {  346,   -1 }, /* (416) fill_mode ::= LINEAR */
-  {  346,   -1 }, /* (417) fill_mode ::= NEXT */
-  {  341,    0 }, /* (418) group_by_clause_opt ::= */
-  {  341,   -3 }, /* (419) group_by_clause_opt ::= GROUP BY group_by_list */
-  {  347,   -1 }, /* (420) group_by_list ::= expression */
-  {  347,   -3 }, /* (421) group_by_list ::= group_by_list NK_COMMA expression */
-  {  342,    0 }, /* (422) having_clause_opt ::= */
-  {  342,   -2 }, /* (423) having_clause_opt ::= HAVING search_condition */
-  {  295,   -4 }, /* (424) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
-  {  348,   -1 }, /* (425) query_expression_body ::= query_primary */
-  {  348,   -4 }, /* (426) query_expression_body ::= query_expression_body UNION ALL query_expression_body */
-  {  348,   -3 }, /* (427) query_expression_body ::= query_expression_body UNION query_expression_body */
-  {  352,   -1 }, /* (428) query_primary ::= query_specification */
-  {  352,   -6 }, /* (429) query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */
-  {  349,    0 }, /* (430) order_by_clause_opt ::= */
-  {  349,   -3 }, /* (431) order_by_clause_opt ::= ORDER BY sort_specification_list */
-  {  350,    0 }, /* (432) slimit_clause_opt ::= */
-  {  350,   -2 }, /* (433) slimit_clause_opt ::= SLIMIT NK_INTEGER */
-  {  350,   -4 }, /* (434) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
-  {  350,   -4 }, /* (435) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
-  {  351,    0 }, /* (436) limit_clause_opt ::= */
-  {  351,   -2 }, /* (437) limit_clause_opt ::= LIMIT NK_INTEGER */
-  {  351,   -4 }, /* (438) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */
-  {  351,   -4 }, /* (439) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */
-  {  313,   -3 }, /* (440) subquery ::= NK_LP query_expression NK_RP */
-  {  334,   -1 }, /* (441) search_condition ::= common_expression */
-  {  353,   -1 }, /* (442) sort_specification_list ::= sort_specification */
-  {  353,   -3 }, /* (443) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */
-  {  354,   -3 }, /* (444) sort_specification ::= expression ordering_specification_opt null_ordering_opt */
-  {  355,    0 }, /* (445) ordering_specification_opt ::= */
-  {  355,   -1 }, /* (446) ordering_specification_opt ::= ASC */
-  {  355,   -1 }, /* (447) ordering_specification_opt ::= DESC */
-  {  356,    0 }, /* (448) null_ordering_opt ::= */
-  {  356,   -2 }, /* (449) null_ordering_opt ::= NULLS FIRST */
-  {  356,   -2 }, /* (450) null_ordering_opt ::= NULLS LAST */
+/* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side
+** of that rule */
+static const YYCODETYPE yyRuleInfoLhs[] = {
+   237,  /* (0) cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */
+   237,  /* (1) cmd ::= ALTER ACCOUNT NK_ID alter_account_options */
+   238,  /* (2) account_options ::= */
+   238,  /* (3) account_options ::= account_options PPS literal */
+   238,  /* (4) account_options ::= account_options TSERIES literal */
+   238,  /* (5) account_options ::= account_options STORAGE literal */
+   238,  /* (6) account_options ::= account_options STREAMS literal */
+   238,  /* (7) account_options ::= account_options QTIME literal */
+   238,  /* (8) account_options ::= account_options DBS literal */
+   238,  /* (9) account_options ::= account_options USERS literal */
+   238,  /* (10) account_options ::= account_options CONNS literal */
+   238,  /* (11) account_options ::= account_options STATE literal */
+   239,  /* (12) alter_account_options ::= alter_account_option */
+   239,  /* (13) alter_account_options ::= alter_account_options alter_account_option */
+   241,  /* (14) alter_account_option ::= PASS literal */
+   241,  /* (15) alter_account_option ::= PPS literal */
+   241,  /* (16) alter_account_option ::= TSERIES literal */
+   241,  /* (17) alter_account_option ::= STORAGE literal */
+   241,  /* (18) alter_account_option ::= STREAMS literal */
+   241,  /* (19) alter_account_option ::= QTIME literal */
+   241,  /* (20) alter_account_option ::= DBS literal */
+   241,  /* (21) alter_account_option ::= USERS literal */
+   241,  /* (22) alter_account_option ::= CONNS literal */
+   241,  /* (23) alter_account_option ::= STATE literal */
+   237,  /* (24) cmd ::= CREATE USER user_name PASS NK_STRING */
+   237,  /* (25) cmd ::= ALTER USER user_name PASS NK_STRING */
+   237,  /* (26) cmd ::= ALTER USER user_name PRIVILEGE NK_STRING */
+   237,  /* (27) cmd ::= DROP USER user_name */
+   237,  /* (28) cmd ::= GRANT privileges ON priv_level TO user_name */
+   237,  /* (29) cmd ::= REVOKE privileges ON priv_level FROM user_name */
+   243,  /* (30) privileges ::= ALL */
+   243,  /* (31) privileges ::= priv_type_list */
+   245,  /* (32) priv_type_list ::= priv_type */
+   245,  /* (33) priv_type_list ::= priv_type_list NK_COMMA priv_type */
+   246,  /* (34) priv_type ::= READ */
+   246,  /* (35) priv_type ::= WRITE */
+   244,  /* (36) priv_level ::= NK_STAR NK_DOT NK_STAR */
+   244,  /* (37) priv_level ::= db_name NK_DOT NK_STAR */
+   237,  /* (38) cmd ::= CREATE DNODE dnode_endpoint */
+   237,  /* (39) cmd ::= CREATE DNODE dnode_host_name PORT NK_INTEGER */
+   237,  /* (40) cmd ::= DROP DNODE NK_INTEGER */
+   237,  /* (41) cmd ::= DROP DNODE dnode_endpoint */
+   237,  /* (42) cmd ::= ALTER DNODE NK_INTEGER NK_STRING */
+   237,  /* (43) cmd ::= ALTER DNODE NK_INTEGER NK_STRING NK_STRING */
+   237,  /* (44) cmd ::= ALTER ALL DNODES NK_STRING */
+   237,  /* (45) cmd ::= ALTER ALL DNODES NK_STRING NK_STRING */
+   248,  /* (46) dnode_endpoint ::= NK_STRING */
+   249,  /* (47) dnode_host_name ::= NK_ID */
+   249,  /* (48) dnode_host_name ::= NK_IPTOKEN */
+   237,  /* (49) cmd ::= ALTER LOCAL NK_STRING */
+   237,  /* (50) cmd ::= ALTER LOCAL NK_STRING NK_STRING */
+   237,  /* (51) cmd ::= CREATE QNODE ON DNODE NK_INTEGER */
+   237,  /* (52) cmd ::= DROP QNODE ON DNODE NK_INTEGER */
+   237,  /* (53) cmd ::= CREATE BNODE ON DNODE NK_INTEGER */
+   237,  /* (54) cmd ::= DROP BNODE ON DNODE NK_INTEGER */
+   237,  /* (55) cmd ::= CREATE SNODE ON DNODE NK_INTEGER */
+   237,  /* (56) cmd ::= DROP SNODE ON DNODE NK_INTEGER */
+   237,  /* (57) cmd ::= CREATE MNODE ON DNODE NK_INTEGER */
+   237,  /* (58) cmd ::= DROP MNODE ON DNODE NK_INTEGER */
+   237,  /* (59) cmd ::= CREATE DATABASE not_exists_opt db_name db_options */
+   237,  /* (60) cmd ::= DROP DATABASE exists_opt db_name */
+   237,  /* (61) cmd ::= USE db_name */
+   237,  /* (62) cmd ::= ALTER DATABASE db_name alter_db_options */
+   250,  /* (63) not_exists_opt ::= IF NOT EXISTS */
+   250,  /* (64) not_exists_opt ::= */
+   252,  /* (65) exists_opt ::= IF EXISTS */
+   252,  /* (66) exists_opt ::= */
+   251,  /* (67) db_options ::= */
+   251,  /* (68) db_options ::= db_options BUFFER NK_INTEGER */
+   251,  /* (69) db_options ::= db_options CACHELAST NK_INTEGER */
+   251,  /* (70) db_options ::= db_options COMP NK_INTEGER */
+   251,  /* (71) db_options ::= db_options DAYS NK_INTEGER */
+   251,  /* (72) db_options ::= db_options DAYS NK_VARIABLE */
+   251,  /* (73) db_options ::= db_options FSYNC NK_INTEGER */
+   251,  /* (74) db_options ::= db_options MAXROWS NK_INTEGER */
+   251,  /* (75) db_options ::= db_options MINROWS NK_INTEGER */
+   251,  /* (76) db_options ::= db_options KEEP integer_list */
+   251,  /* (77) db_options ::= db_options KEEP variable_list */
+   251,  /* (78) db_options ::= db_options PAGES NK_INTEGER */
+   251,  /* (79) db_options ::= db_options PAGESIZE NK_INTEGER */
+   251,  /* (80) db_options ::= db_options PRECISION NK_STRING */
+   251,  /* (81) db_options ::= db_options REPLICA NK_INTEGER */
+   251,  /* (82) db_options ::= db_options STRICT NK_INTEGER */
+   251,  /* (83) db_options ::= db_options WAL NK_INTEGER */
+   251,  /* (84) db_options ::= db_options VGROUPS NK_INTEGER */
+   251,  /* (85) db_options ::= db_options SINGLE_STABLE NK_INTEGER */
+   251,  /* (86) db_options ::= db_options RETENTIONS retention_list */
+   251,  /* (87) db_options ::= db_options SCHEMALESS NK_INTEGER */
+   253,  /* (88) alter_db_options ::= alter_db_option */
+   253,  /* (89) alter_db_options ::= alter_db_options alter_db_option */
+   257,  /* (90) alter_db_option ::= BUFFER NK_INTEGER */
+   257,  /* (91) alter_db_option ::= CACHELAST NK_INTEGER */
+   257,  /* (92) alter_db_option ::= FSYNC NK_INTEGER */
+   257,  /* (93) alter_db_option ::= KEEP integer_list */
+   257,  /* (94) alter_db_option ::= KEEP variable_list */
+   257,  /* (95) alter_db_option ::= PAGES NK_INTEGER */
+   257,  /* (96) alter_db_option ::= REPLICA NK_INTEGER */
+   257,  /* (97) alter_db_option ::= STRICT NK_INTEGER */
+   257,  /* (98) alter_db_option ::= WAL NK_INTEGER */
+   254,  /* (99) integer_list ::= NK_INTEGER */
+   254,  /* (100) integer_list ::= integer_list NK_COMMA NK_INTEGER */
+   255,  /* (101) variable_list ::= NK_VARIABLE */
+   255,  /* (102) variable_list ::= variable_list NK_COMMA NK_VARIABLE */
+   256,  /* (103) retention_list ::= retention */
+   256,  /* (104) retention_list ::= retention_list NK_COMMA retention */
+   258,  /* (105) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */
+   237,  /* (106) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */
+   237,  /* (107) cmd ::= CREATE TABLE multi_create_clause */
+   237,  /* (108) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */
+   237,  /* (109) cmd ::= DROP TABLE multi_drop_clause */
+   237,  /* (110) cmd ::= DROP STABLE exists_opt full_table_name */
+   237,  /* (111) cmd ::= ALTER TABLE alter_table_clause */
+   237,  /* (112) cmd ::= ALTER STABLE alter_table_clause */
+   266,  /* (113) alter_table_clause ::= full_table_name alter_table_options */
+   266,  /* (114) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */
+   266,  /* (115) alter_table_clause ::= full_table_name DROP COLUMN column_name */
+   266,  /* (116) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */
+   266,  /* (117) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */
+   266,  /* (118) alter_table_clause ::= full_table_name ADD TAG column_name type_name */
+   266,  /* (119) alter_table_clause ::= full_table_name DROP TAG column_name */
+   266,  /* (120) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */
+   266,  /* (121) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */
+   266,  /* (122) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */
+   263,  /* (123) multi_create_clause ::= create_subtable_clause */
+   263,  /* (124) multi_create_clause ::= multi_create_clause create_subtable_clause */
+   271,  /* (125) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_tags_opt TAGS NK_LP literal_list NK_RP table_options */
+   265,  /* (126) multi_drop_clause ::= drop_table_clause */
+   265,  /* (127) multi_drop_clause ::= multi_drop_clause drop_table_clause */
+   274,  /* (128) drop_table_clause ::= exists_opt full_table_name */
+   272,  /* (129) specific_tags_opt ::= */
+   272,  /* (130) specific_tags_opt ::= NK_LP col_name_list NK_RP */
+   259,  /* (131) full_table_name ::= table_name */
+   259,  /* (132) full_table_name ::= db_name NK_DOT table_name */
+   260,  /* (133) column_def_list ::= column_def */
+   260,  /* (134) column_def_list ::= column_def_list NK_COMMA column_def */
+   277,  /* (135) column_def ::= column_name type_name */
+   277,  /* (136) column_def ::= column_name type_name COMMENT NK_STRING */
+   269,  /* (137) type_name ::= BOOL */
+   269,  /* (138) type_name ::= TINYINT */
+   269,  /* (139) type_name ::= SMALLINT */
+   269,  /* (140) type_name ::= INT */
+   269,  /* (141) type_name ::= INTEGER */
+   269,  /* (142) type_name ::= BIGINT */
+   269,  /* (143) type_name ::= FLOAT */
+   269,  /* (144) type_name ::= DOUBLE */
+   269,  /* (145) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */
+   269,  /* (146) type_name ::= TIMESTAMP */
+   269,  /* (147) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */
+   269,  /* (148) type_name ::= TINYINT UNSIGNED */
+   269,  /* (149) type_name ::= SMALLINT UNSIGNED */
+   269,  /* (150) type_name ::= INT UNSIGNED */
+   269,  /* (151) type_name ::= BIGINT UNSIGNED */
+   269,  /* (152) type_name ::= JSON */
+   269,  /* (153) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */
+   269,  /* (154) type_name ::= MEDIUMBLOB */
+   269,  /* (155) type_name ::= BLOB */
+   269,  /* (156) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */
+   269,  /* (157) type_name ::= DECIMAL */
+   269,  /* (158) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */
+   269,  /* (159) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */
+   261,  /* (160) tags_def_opt ::= */
+   261,  /* (161) tags_def_opt ::= tags_def */
+   264,  /* (162) tags_def ::= TAGS NK_LP column_def_list NK_RP */
+   262,  /* (163) table_options ::= */
+   262,  /* (164) table_options ::= table_options COMMENT NK_STRING */
+   262,  /* (165) table_options ::= table_options FILE_FACTOR NK_FLOAT */
+   262,  /* (166) table_options ::= table_options ROLLUP NK_LP func_name_list NK_RP */
+   262,  /* (167) table_options ::= table_options TTL NK_INTEGER */
+   262,  /* (168) table_options ::= table_options SMA NK_LP col_name_list NK_RP */
+   267,  /* (169) alter_table_options ::= alter_table_option */
+   267,  /* (170) alter_table_options ::= alter_table_options alter_table_option */
+   279,  /* (171) alter_table_option ::= COMMENT NK_STRING */
+   279,  /* (172) alter_table_option ::= TTL NK_INTEGER */
+   275,  /* (173) col_name_list ::= col_name */
+   275,  /* (174) col_name_list ::= col_name_list NK_COMMA col_name */
+   280,  /* (175) col_name ::= column_name */
+   237,  /* (176) cmd ::= SHOW DNODES */
+   237,  /* (177) cmd ::= SHOW USERS */
+   237,  /* (178) cmd ::= SHOW DATABASES */
+   237,  /* (179) cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */
+   237,  /* (180) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */
+   237,  /* (181) cmd ::= SHOW db_name_cond_opt VGROUPS */
+   237,  /* (182) cmd ::= SHOW MNODES */
+   237,  /* (183) cmd ::= SHOW MODULES */
+   237,  /* (184) cmd ::= SHOW QNODES */
+   237,  /* (185) cmd ::= SHOW FUNCTIONS */
+   237,  /* (186) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */
+   237,  /* (187) cmd ::= SHOW STREAMS */
+   237,  /* (188) cmd ::= SHOW ACCOUNTS */
+   237,  /* (189) cmd ::= SHOW APPS */
+   237,  /* (190) cmd ::= SHOW CONNECTIONS */
+   237,  /* (191) cmd ::= SHOW LICENCE */
+   237,  /* (192) cmd ::= SHOW GRANTS */
+   237,  /* (193) cmd ::= SHOW CREATE DATABASE db_name */
+   237,  /* (194) cmd ::= SHOW CREATE TABLE full_table_name */
+   237,  /* (195) cmd ::= SHOW CREATE STABLE full_table_name */
+   237,  /* (196) cmd ::= SHOW QUERIES */
+   237,  /* (197) cmd ::= SHOW SCORES */
+   237,  /* (198) cmd ::= SHOW TOPICS */
+   237,  /* (199) cmd ::= SHOW VARIABLES */
+   237,  /* (200) cmd ::= SHOW BNODES */
+   237,  /* (201) cmd ::= SHOW SNODES */
+   237,  /* (202) cmd ::= SHOW CLUSTER */
+   237,  /* (203) cmd ::= SHOW TRANSACTIONS */
+   281,  /* (204) db_name_cond_opt ::= */
+   281,  /* (205) db_name_cond_opt ::= db_name NK_DOT */
+   282,  /* (206) like_pattern_opt ::= */
+   282,  /* (207) like_pattern_opt ::= LIKE NK_STRING */
+   283,  /* (208) table_name_cond ::= table_name */
+   284,  /* (209) from_db_opt ::= */
+   284,  /* (210) from_db_opt ::= FROM db_name */
+   278,  /* (211) func_name_list ::= func_name */
+   278,  /* (212) func_name_list ::= func_name_list NK_COMMA func_name */
+   285,  /* (213) func_name ::= function_name */
+   237,  /* (214) cmd ::= CREATE SMA INDEX not_exists_opt index_name ON table_name index_options */
+   237,  /* (215) cmd ::= CREATE FULLTEXT INDEX not_exists_opt index_name ON table_name NK_LP col_name_list NK_RP */
+   237,  /* (216) cmd ::= DROP INDEX exists_opt index_name ON table_name */
+   288,  /* (217) index_options ::= */
+   288,  /* (218) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt */
+   288,  /* (219) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt */
+   289,  /* (220) func_list ::= func */
+   289,  /* (221) func_list ::= func_list NK_COMMA func */
+   292,  /* (222) func ::= function_name NK_LP expression_list NK_RP */
+   237,  /* (223) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_expression */
+   237,  /* (224) cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name */
+   237,  /* (225) cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name */
+   237,  /* (226) cmd ::= DROP TOPIC exists_opt topic_name */
+   237,  /* (227) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */
+   237,  /* (228) cmd ::= DESC full_table_name */
+   237,  /* (229) cmd ::= DESCRIBE full_table_name */
+   237,  /* (230) cmd ::= RESET QUERY CACHE */
+   237,  /* (231) cmd ::= EXPLAIN analyze_opt explain_options query_expression */
+   297,  /* (232) analyze_opt ::= */
+   297,  /* (233) analyze_opt ::= ANALYZE */
+   298,  /* (234) explain_options ::= */
+   298,  /* (235) explain_options ::= explain_options VERBOSE NK_BOOL */
+   298,  /* (236) explain_options ::= explain_options RATIO NK_FLOAT */
+   237,  /* (237) cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP */
+   237,  /* (238) cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */
+   237,  /* (239) cmd ::= DROP FUNCTION exists_opt function_name */
+   299,  /* (240) agg_func_opt ::= */
+   299,  /* (241) agg_func_opt ::= AGGREGATE */
+   300,  /* (242) bufsize_opt ::= */
+   300,  /* (243) bufsize_opt ::= BUFSIZE NK_INTEGER */
+   237,  /* (244) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options into_opt AS query_expression */
+   237,  /* (245) cmd ::= DROP STREAM exists_opt stream_name */
+   303,  /* (246) into_opt ::= */
+   303,  /* (247) into_opt ::= INTO full_table_name */
+   302,  /* (248) stream_options ::= */
+   302,  /* (249) stream_options ::= stream_options TRIGGER AT_ONCE */
+   302,  /* (250) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */
+   302,  /* (251) stream_options ::= stream_options WATERMARK duration_literal */
+   237,  /* (252) cmd ::= KILL CONNECTION NK_INTEGER */
+   237,  /* (253) cmd ::= KILL QUERY NK_INTEGER */
+   237,  /* (254) cmd ::= KILL TRANSACTION NK_INTEGER */
+   237,  /* (255) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */
+   237,  /* (256) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */
+   237,  /* (257) cmd ::= SPLIT VGROUP NK_INTEGER */
+   304,  /* (258) dnode_list ::= DNODE NK_INTEGER */
+   304,  /* (259) dnode_list ::= dnode_list DNODE NK_INTEGER */
+   237,  /* (260) cmd ::= SYNCDB db_name REPLICA */
+   237,  /* (261) cmd ::= query_expression */
+   240,  /* (262) literal ::= NK_INTEGER */
+   240,  /* (263) literal ::= NK_FLOAT */
+   240,  /* (264) literal ::= NK_STRING */
+   240,  /* (265) literal ::= NK_BOOL */
+   240,  /* (266) literal ::= TIMESTAMP NK_STRING */
+   240,  /* (267) literal ::= duration_literal */
+   240,  /* (268) literal ::= NULL */
+   240,  /* (269) literal ::= NK_QUESTION */
+   290,  /* (270) duration_literal ::= NK_VARIABLE */
+   305,  /* (271) signed ::= NK_INTEGER */
+   305,  /* (272) signed ::= NK_PLUS NK_INTEGER */
+   305,  /* (273) signed ::= NK_MINUS NK_INTEGER */
+   305,  /* (274) signed ::= NK_FLOAT */
+   305,  /* (275) signed ::= NK_PLUS NK_FLOAT */
+   305,  /* (276) signed ::= NK_MINUS NK_FLOAT */
+   270,  /* (277) signed_literal ::= signed */
+   270,  /* (278) signed_literal ::= NK_STRING */
+   270,  /* (279) signed_literal ::= NK_BOOL */
+   270,  /* (280) signed_literal ::= TIMESTAMP NK_STRING */
+   270,  /* (281) signed_literal ::= duration_literal */
+   270,  /* (282) signed_literal ::= NULL */
+   270,  /* (283) signed_literal ::= literal_func */
+   273,  /* (284) literal_list ::= signed_literal */
+   273,  /* (285) literal_list ::= literal_list NK_COMMA signed_literal */
+   247,  /* (286) db_name ::= NK_ID */
+   276,  /* (287) table_name ::= NK_ID */
+   268,  /* (288) column_name ::= NK_ID */
+   286,  /* (289) function_name ::= NK_ID */
+   307,  /* (290) table_alias ::= NK_ID */
+   308,  /* (291) column_alias ::= NK_ID */
+   242,  /* (292) user_name ::= NK_ID */
+   287,  /* (293) index_name ::= NK_ID */
+   294,  /* (294) topic_name ::= NK_ID */
+   301,  /* (295) stream_name ::= NK_ID */
+   296,  /* (296) cgroup_name ::= NK_ID */
+   309,  /* (297) expression ::= literal */
+   309,  /* (298) expression ::= pseudo_column */
+   309,  /* (299) expression ::= column_reference */
+   309,  /* (300) expression ::= function_expression */
+   309,  /* (301) expression ::= subquery */
+   309,  /* (302) expression ::= NK_LP expression NK_RP */
+   309,  /* (303) expression ::= NK_PLUS expression */
+   309,  /* (304) expression ::= NK_MINUS expression */
+   309,  /* (305) expression ::= expression NK_PLUS expression */
+   309,  /* (306) expression ::= expression NK_MINUS expression */
+   309,  /* (307) expression ::= expression NK_STAR expression */
+   309,  /* (308) expression ::= expression NK_SLASH expression */
+   309,  /* (309) expression ::= expression NK_REM expression */
+   309,  /* (310) expression ::= column_reference NK_ARROW NK_STRING */
+   293,  /* (311) expression_list ::= expression */
+   293,  /* (312) expression_list ::= expression_list NK_COMMA expression */
+   311,  /* (313) column_reference ::= column_name */
+   311,  /* (314) column_reference ::= table_name NK_DOT column_name */
+   310,  /* (315) pseudo_column ::= ROWTS */
+   310,  /* (316) pseudo_column ::= TBNAME */
+   310,  /* (317) pseudo_column ::= table_name NK_DOT TBNAME */
+   310,  /* (318) pseudo_column ::= QSTARTTS */
+   310,  /* (319) pseudo_column ::= QENDTS */
+   310,  /* (320) pseudo_column ::= WSTARTTS */
+   310,  /* (321) pseudo_column ::= WENDTS */
+   310,  /* (322) pseudo_column ::= WDURATION */
+   312,  /* (323) function_expression ::= function_name NK_LP expression_list NK_RP */
+   312,  /* (324) function_expression ::= star_func NK_LP star_func_para_list NK_RP */
+   312,  /* (325) function_expression ::= CAST NK_LP expression AS type_name NK_RP */
+   312,  /* (326) function_expression ::= literal_func */
+   306,  /* (327) literal_func ::= noarg_func NK_LP NK_RP */
+   306,  /* (328) literal_func ::= NOW */
+   316,  /* (329) noarg_func ::= NOW */
+   316,  /* (330) noarg_func ::= TODAY */
+   316,  /* (331) noarg_func ::= TIMEZONE */
+   314,  /* (332) star_func ::= COUNT */
+   314,  /* (333) star_func ::= FIRST */
+   314,  /* (334) star_func ::= LAST */
+   314,  /* (335) star_func ::= LAST_ROW */
+   315,  /* (336) star_func_para_list ::= NK_STAR */
+   315,  /* (337) star_func_para_list ::= other_para_list */
+   317,  /* (338) other_para_list ::= star_func_para */
+   317,  /* (339) other_para_list ::= other_para_list NK_COMMA star_func_para */
+   318,  /* (340) star_func_para ::= expression */
+   318,  /* (341) star_func_para ::= table_name NK_DOT NK_STAR */
+   319,  /* (342) predicate ::= expression compare_op expression */
+   319,  /* (343) predicate ::= expression BETWEEN expression AND expression */
+   319,  /* (344) predicate ::= expression NOT BETWEEN expression AND expression */
+   319,  /* (345) predicate ::= expression IS NULL */
+   319,  /* (346) predicate ::= expression IS NOT NULL */
+   319,  /* (347) predicate ::= expression in_op in_predicate_value */
+   320,  /* (348) compare_op ::= NK_LT */
+   320,  /* (349) compare_op ::= NK_GT */
+   320,  /* (350) compare_op ::= NK_LE */
+   320,  /* (351) compare_op ::= NK_GE */
+   320,  /* (352) compare_op ::= NK_NE */
+   320,  /* (353) compare_op ::= NK_EQ */
+   320,  /* (354) compare_op ::= LIKE */
+   320,  /* (355) compare_op ::= NOT LIKE */
+   320,  /* (356) compare_op ::= MATCH */
+   320,  /* (357) compare_op ::= NMATCH */
+   320,  /* (358) compare_op ::= CONTAINS */
+   321,  /* (359) in_op ::= IN */
+   321,  /* (360) in_op ::= NOT IN */
+   322,  /* (361) in_predicate_value ::= NK_LP expression_list NK_RP */
+   323,  /* (362) boolean_value_expression ::= boolean_primary */
+   323,  /* (363) boolean_value_expression ::= NOT boolean_primary */
+   323,  /* (364) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
+   323,  /* (365) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
+   324,  /* (366) boolean_primary ::= predicate */
+   324,  /* (367) boolean_primary ::= NK_LP boolean_value_expression NK_RP */
+   325,  /* (368) common_expression ::= expression */
+   325,  /* (369) common_expression ::= boolean_value_expression */
+   326,  /* (370) from_clause ::= FROM table_reference_list */
+   327,  /* (371) table_reference_list ::= table_reference */
+   327,  /* (372) table_reference_list ::= table_reference_list NK_COMMA table_reference */
+   328,  /* (373) table_reference ::= table_primary */
+   328,  /* (374) table_reference ::= joined_table */
+   329,  /* (375) table_primary ::= table_name alias_opt */
+   329,  /* (376) table_primary ::= db_name NK_DOT table_name alias_opt */
+   329,  /* (377) table_primary ::= subquery alias_opt */
+   329,  /* (378) table_primary ::= parenthesized_joined_table */
+   331,  /* (379) alias_opt ::= */
+   331,  /* (380) alias_opt ::= table_alias */
+   331,  /* (381) alias_opt ::= AS table_alias */
+   332,  /* (382) parenthesized_joined_table ::= NK_LP joined_table NK_RP */
+   332,  /* (383) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */
+   330,  /* (384) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
+   333,  /* (385) join_type ::= */
+   333,  /* (386) join_type ::= INNER */
+   335,  /* (387) query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
+   336,  /* (388) set_quantifier_opt ::= */
+   336,  /* (389) set_quantifier_opt ::= DISTINCT */
+   336,  /* (390) set_quantifier_opt ::= ALL */
+   337,  /* (391) select_list ::= NK_STAR */
+   337,  /* (392) select_list ::= select_sublist */
+   343,  /* (393) select_sublist ::= select_item */
+   343,  /* (394) select_sublist ::= select_sublist NK_COMMA select_item */
+   344,  /* (395) select_item ::= common_expression */
+   344,  /* (396) select_item ::= common_expression column_alias */
+   344,  /* (397) select_item ::= common_expression AS column_alias */
+   344,  /* (398) select_item ::= table_name NK_DOT NK_STAR */
+   338,  /* (399) where_clause_opt ::= */
+   338,  /* (400) where_clause_opt ::= WHERE search_condition */
+   339,  /* (401) partition_by_clause_opt ::= */
+   339,  /* (402) partition_by_clause_opt ::= PARTITION BY expression_list */
+   340,  /* (403) twindow_clause_opt ::= */
+   340,  /* (404) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
+   340,  /* (405) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */
+   340,  /* (406) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
+   340,  /* (407) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
+   291,  /* (408) sliding_opt ::= */
+   291,  /* (409) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
+   345,  /* (410) fill_opt ::= */
+   345,  /* (411) fill_opt ::= FILL NK_LP fill_mode NK_RP */
+   345,  /* (412) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */
+   346,  /* (413) fill_mode ::= NONE */
+   346,  /* (414) fill_mode ::= PREV */
+   346,  /* (415) fill_mode ::= NULL */
+   346,  /* (416) fill_mode ::= LINEAR */
+   346,  /* (417) fill_mode ::= NEXT */
+   341,  /* (418) group_by_clause_opt ::= */
+   341,  /* (419) group_by_clause_opt ::= GROUP BY group_by_list */
+   347,  /* (420) group_by_list ::= expression */
+   347,  /* (421) group_by_list ::= group_by_list NK_COMMA expression */
+   342,  /* (422) having_clause_opt ::= */
+   342,  /* (423) having_clause_opt ::= HAVING search_condition */
+   295,  /* (424) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
+   348,  /* (425) query_expression_body ::= query_primary */
+   348,  /* (426) query_expression_body ::= query_expression_body UNION ALL query_expression_body */
+   348,  /* (427) query_expression_body ::= query_expression_body UNION query_expression_body */
+   352,  /* (428) query_primary ::= query_specification */
+   352,  /* (429) query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */
+   349,  /* (430) order_by_clause_opt ::= */
+   349,  /* (431) order_by_clause_opt ::= ORDER BY sort_specification_list */
+   350,  /* (432) slimit_clause_opt ::= */
+   350,  /* (433) slimit_clause_opt ::= SLIMIT NK_INTEGER */
+   350,  /* (434) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
+   350,  /* (435) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+   351,  /* (436) limit_clause_opt ::= */
+   351,  /* (437) limit_clause_opt ::= LIMIT NK_INTEGER */
+   351,  /* (438) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */
+   351,  /* (439) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+   313,  /* (440) subquery ::= NK_LP query_expression NK_RP */
+   334,  /* (441) search_condition ::= common_expression */
+   353,  /* (442) sort_specification_list ::= sort_specification */
+   353,  /* (443) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */
+   354,  /* (444) sort_specification ::= expression ordering_specification_opt null_ordering_opt */
+   355,  /* (445) ordering_specification_opt ::= */
+   355,  /* (446) ordering_specification_opt ::= ASC */
+   355,  /* (447) ordering_specification_opt ::= DESC */
+   356,  /* (448) null_ordering_opt ::= */
+   356,  /* (449) null_ordering_opt ::= NULLS FIRST */
+   356,  /* (450) null_ordering_opt ::= NULLS LAST */
+};
+
+/* For rule J, yyRuleInfoNRhs[J] contains the negative of the number
+** of symbols on the right-hand side of that rule. */
+static const signed char yyRuleInfoNRhs[] = {
+   -6,  /* (0) cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */
+   -4,  /* (1) cmd ::= ALTER ACCOUNT NK_ID alter_account_options */
+    0,  /* (2) account_options ::= */
+   -3,  /* (3) account_options ::= account_options PPS literal */
+   -3,  /* (4) account_options ::= account_options TSERIES literal */
+   -3,  /* (5) account_options ::= account_options STORAGE literal */
+   -3,  /* (6) account_options ::= account_options STREAMS literal */
+   -3,  /* (7) account_options ::= account_options QTIME literal */
+   -3,  /* (8) account_options ::= account_options DBS literal */
+   -3,  /* (9) account_options ::= account_options USERS literal */
+   -3,  /* (10) account_options ::= account_options CONNS literal */
+   -3,  /* (11) account_options ::= account_options STATE literal */
+   -1,  /* (12) alter_account_options ::= alter_account_option */
+   -2,  /* (13) alter_account_options ::= alter_account_options alter_account_option */
+   -2,  /* (14) alter_account_option ::= PASS literal */
+   -2,  /* (15) alter_account_option ::= PPS literal */
+   -2,  /* (16) alter_account_option ::= TSERIES literal */
+   -2,  /* (17) alter_account_option ::= STORAGE literal */
+   -2,  /* (18) alter_account_option ::= STREAMS literal */
+   -2,  /* (19) alter_account_option ::= QTIME literal */
+   -2,  /* (20) alter_account_option ::= DBS literal */
+   -2,  /* (21) alter_account_option ::= USERS literal */
+   -2,  /* (22) alter_account_option ::= CONNS literal */
+   -2,  /* (23) alter_account_option ::= STATE literal */
+   -5,  /* (24) cmd ::= CREATE USER user_name PASS NK_STRING */
+   -5,  /* (25) cmd ::= ALTER USER user_name PASS NK_STRING */
+   -5,  /* (26) cmd ::= ALTER USER user_name PRIVILEGE NK_STRING */
+   -3,  /* (27) cmd ::= DROP USER user_name */
+   -6,  /* (28) cmd ::= GRANT privileges ON priv_level TO user_name */
+   -6,  /* (29) cmd ::= REVOKE privileges ON priv_level FROM user_name */
+   -1,  /* (30) privileges ::= ALL */
+   -1,  /* (31) privileges ::= priv_type_list */
+   -1,  /* (32) priv_type_list ::= priv_type */
+   -3,  /* (33) priv_type_list ::= priv_type_list NK_COMMA priv_type */
+   -1,  /* (34) priv_type ::= READ */
+   -1,  /* (35) priv_type ::= WRITE */
+   -3,  /* (36) priv_level ::= NK_STAR NK_DOT NK_STAR */
+   -3,  /* (37) priv_level ::= db_name NK_DOT NK_STAR */
+   -3,  /* (38) cmd ::= CREATE DNODE dnode_endpoint */
+   -5,  /* (39) cmd ::= CREATE DNODE dnode_host_name PORT NK_INTEGER */
+   -3,  /* (40) cmd ::= DROP DNODE NK_INTEGER */
+   -3,  /* (41) cmd ::= DROP DNODE dnode_endpoint */
+   -4,  /* (42) cmd ::= ALTER DNODE NK_INTEGER NK_STRING */
+   -5,  /* (43) cmd ::= ALTER DNODE NK_INTEGER NK_STRING NK_STRING */
+   -4,  /* (44) cmd ::= ALTER ALL DNODES NK_STRING */
+   -5,  /* (45) cmd ::= ALTER ALL DNODES NK_STRING NK_STRING */
+   -1,  /* (46) dnode_endpoint ::= NK_STRING */
+   -1,  /* (47) dnode_host_name ::= NK_ID */
+   -1,  /* (48) dnode_host_name ::= NK_IPTOKEN */
+   -3,  /* (49) cmd ::= ALTER LOCAL NK_STRING */
+   -4,  /* (50) cmd ::= ALTER LOCAL NK_STRING NK_STRING */
+   -5,  /* (51) cmd ::= CREATE QNODE ON DNODE NK_INTEGER */
+   -5,  /* (52) cmd ::= DROP QNODE ON DNODE NK_INTEGER */
+   -5,  /* (53) cmd ::= CREATE BNODE ON DNODE NK_INTEGER */
+   -5,  /* (54) cmd ::= DROP BNODE ON DNODE NK_INTEGER */
+   -5,  /* (55) cmd ::= CREATE SNODE ON DNODE NK_INTEGER */
+   -5,  /* (56) cmd ::= DROP SNODE ON DNODE NK_INTEGER */
+   -5,  /* (57) cmd ::= CREATE MNODE ON DNODE NK_INTEGER */
+   -5,  /* (58) cmd ::= DROP MNODE ON DNODE NK_INTEGER */
+   -5,  /* (59) cmd ::= CREATE DATABASE not_exists_opt db_name db_options */
+   -4,  /* (60) cmd ::= DROP DATABASE exists_opt db_name */
+   -2,  /* (61) cmd ::= USE db_name */
+   -4,  /* (62) cmd ::= ALTER DATABASE db_name alter_db_options */
+   -3,  /* (63) not_exists_opt ::= IF NOT EXISTS */
+    0,  /* (64) not_exists_opt ::= */
+   -2,  /* (65) exists_opt ::= IF EXISTS */
+    0,  /* (66) exists_opt ::= */
+    0,  /* (67) db_options ::= */
+   -3,  /* (68) db_options ::= db_options BUFFER NK_INTEGER */
+   -3,  /* (69) db_options ::= db_options CACHELAST NK_INTEGER */
+   -3,  /* (70) db_options ::= db_options COMP NK_INTEGER */
+   -3,  /* (71) db_options ::= db_options DAYS NK_INTEGER */
+   -3,  /* (72) db_options ::= db_options DAYS NK_VARIABLE */
+   -3,  /* (73) db_options ::= db_options FSYNC NK_INTEGER */
+   -3,  /* (74) db_options ::= db_options MAXROWS NK_INTEGER */
+   -3,  /* (75) db_options ::= db_options MINROWS NK_INTEGER */
+   -3,  /* (76) db_options ::= db_options KEEP integer_list */
+   -3,  /* (77) db_options ::= db_options KEEP variable_list */
+   -3,  /* (78) db_options ::= db_options PAGES NK_INTEGER */
+   -3,  /* (79) db_options ::= db_options PAGESIZE NK_INTEGER */
+   -3,  /* (80) db_options ::= db_options PRECISION NK_STRING */
+   -3,  /* (81) db_options ::= db_options REPLICA NK_INTEGER */
+   -3,  /* (82) db_options ::= db_options STRICT NK_INTEGER */
+   -3,  /* (83) db_options ::= db_options WAL NK_INTEGER */
+   -3,  /* (84) db_options ::= db_options VGROUPS NK_INTEGER */
+   -3,  /* (85) db_options ::= db_options SINGLE_STABLE NK_INTEGER */
+   -3,  /* (86) db_options ::= db_options RETENTIONS retention_list */
+   -3,  /* (87) db_options ::= db_options SCHEMALESS NK_INTEGER */
+   -1,  /* (88) alter_db_options ::= alter_db_option */
+   -2,  /* (89) alter_db_options ::= alter_db_options alter_db_option */
+   -2,  /* (90) alter_db_option ::= BUFFER NK_INTEGER */
+   -2,  /* (91) alter_db_option ::= CACHELAST NK_INTEGER */
+   -2,  /* (92) alter_db_option ::= FSYNC NK_INTEGER */
+   -2,  /* (93) alter_db_option ::= KEEP integer_list */
+   -2,  /* (94) alter_db_option ::= KEEP variable_list */
+   -2,  /* (95) alter_db_option ::= PAGES NK_INTEGER */
+   -2,  /* (96) alter_db_option ::= REPLICA NK_INTEGER */
+   -2,  /* (97) alter_db_option ::= STRICT NK_INTEGER */
+   -2,  /* (98) alter_db_option ::= WAL NK_INTEGER */
+   -1,  /* (99) integer_list ::= NK_INTEGER */
+   -3,  /* (100) integer_list ::= integer_list NK_COMMA NK_INTEGER */
+   -1,  /* (101) variable_list ::= NK_VARIABLE */
+   -3,  /* (102) variable_list ::= variable_list NK_COMMA NK_VARIABLE */
+   -1,  /* (103) retention_list ::= retention */
+   -3,  /* (104) retention_list ::= retention_list NK_COMMA retention */
+   -3,  /* (105) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */
+   -9,  /* (106) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */
+   -3,  /* (107) cmd ::= CREATE TABLE multi_create_clause */
+   -9,  /* (108) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */
+   -3,  /* (109) cmd ::= DROP TABLE multi_drop_clause */
+   -4,  /* (110) cmd ::= DROP STABLE exists_opt full_table_name */
+   -3,  /* (111) cmd ::= ALTER TABLE alter_table_clause */
+   -3,  /* (112) cmd ::= ALTER STABLE alter_table_clause */
+   -2,  /* (113) alter_table_clause ::= full_table_name alter_table_options */
+   -5,  /* (114) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */
+   -4,  /* (115) alter_table_clause ::= full_table_name DROP COLUMN column_name */
+   -5,  /* (116) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */
+   -5,  /* (117) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */
+   -5,  /* (118) alter_table_clause ::= full_table_name ADD TAG column_name type_name */
+   -4,  /* (119) alter_table_clause ::= full_table_name DROP TAG column_name */
+   -5,  /* (120) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */
+   -5,  /* (121) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */
+   -6,  /* (122) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */
+   -1,  /* (123) multi_create_clause ::= create_subtable_clause */
+   -2,  /* (124) multi_create_clause ::= multi_create_clause create_subtable_clause */
+  -10,  /* (125) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_tags_opt TAGS NK_LP literal_list NK_RP table_options */
+   -1,  /* (126) multi_drop_clause ::= drop_table_clause */
+   -2,  /* (127) multi_drop_clause ::= multi_drop_clause drop_table_clause */
+   -2,  /* (128) drop_table_clause ::= exists_opt full_table_name */
+    0,  /* (129) specific_tags_opt ::= */
+   -3,  /* (130) specific_tags_opt ::= NK_LP col_name_list NK_RP */
+   -1,  /* (131) full_table_name ::= table_name */
+   -3,  /* (132) full_table_name ::= db_name NK_DOT table_name */
+   -1,  /* (133) column_def_list ::= column_def */
+   -3,  /* (134) column_def_list ::= column_def_list NK_COMMA column_def */
+   -2,  /* (135) column_def ::= column_name type_name */
+   -4,  /* (136) column_def ::= column_name type_name COMMENT NK_STRING */
+   -1,  /* (137) type_name ::= BOOL */
+   -1,  /* (138) type_name ::= TINYINT */
+   -1,  /* (139) type_name ::= SMALLINT */
+   -1,  /* (140) type_name ::= INT */
+   -1,  /* (141) type_name ::= INTEGER */
+   -1,  /* (142) type_name ::= BIGINT */
+   -1,  /* (143) type_name ::= FLOAT */
+   -1,  /* (144) type_name ::= DOUBLE */
+   -4,  /* (145) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */
+   -1,  /* (146) type_name ::= TIMESTAMP */
+   -4,  /* (147) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */
+   -2,  /* (148) type_name ::= TINYINT UNSIGNED */
+   -2,  /* (149) type_name ::= SMALLINT UNSIGNED */
+   -2,  /* (150) type_name ::= INT UNSIGNED */
+   -2,  /* (151) type_name ::= BIGINT UNSIGNED */
+   -1,  /* (152) type_name ::= JSON */
+   -4,  /* (153) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */
+   -1,  /* (154) type_name ::= MEDIUMBLOB */
+   -1,  /* (155) type_name ::= BLOB */
+   -4,  /* (156) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */
+   -1,  /* (157) type_name ::= DECIMAL */
+   -4,  /* (158) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */
+   -6,  /* (159) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */
+    0,  /* (160) tags_def_opt ::= */
+   -1,  /* (161) tags_def_opt ::= tags_def */
+   -4,  /* (162) tags_def ::= TAGS NK_LP column_def_list NK_RP */
+    0,  /* (163) table_options ::= */
+   -3,  /* (164) table_options ::= table_options COMMENT NK_STRING */
+   -3,  /* (165) table_options ::= table_options FILE_FACTOR NK_FLOAT */
+   -5,  /* (166) table_options ::= table_options ROLLUP NK_LP func_name_list NK_RP */
+   -3,  /* (167) table_options ::= table_options TTL NK_INTEGER */
+   -5,  /* (168) table_options ::= table_options SMA NK_LP col_name_list NK_RP */
+   -1,  /* (169) alter_table_options ::= alter_table_option */
+   -2,  /* (170) alter_table_options ::= alter_table_options alter_table_option */
+   -2,  /* (171) alter_table_option ::= COMMENT NK_STRING */
+   -2,  /* (172) alter_table_option ::= TTL NK_INTEGER */
+   -1,  /* (173) col_name_list ::= col_name */
+   -3,  /* (174) col_name_list ::= col_name_list NK_COMMA col_name */
+   -1,  /* (175) col_name ::= column_name */
+   -2,  /* (176) cmd ::= SHOW DNODES */
+   -2,  /* (177) cmd ::= SHOW USERS */
+   -2,  /* (178) cmd ::= SHOW DATABASES */
+   -4,  /* (179) cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */
+   -4,  /* (180) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */
+   -3,  /* (181) cmd ::= SHOW db_name_cond_opt VGROUPS */
+   -2,  /* (182) cmd ::= SHOW MNODES */
+   -2,  /* (183) cmd ::= SHOW MODULES */
+   -2,  /* (184) cmd ::= SHOW QNODES */
+   -2,  /* (185) cmd ::= SHOW FUNCTIONS */
+   -5,  /* (186) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */
+   -2,  /* (187) cmd ::= SHOW STREAMS */
+   -2,  /* (188) cmd ::= SHOW ACCOUNTS */
+   -2,  /* (189) cmd ::= SHOW APPS */
+   -2,  /* (190) cmd ::= SHOW CONNECTIONS */
+   -2,  /* (191) cmd ::= SHOW LICENCE */
+   -2,  /* (192) cmd ::= SHOW GRANTS */
+   -4,  /* (193) cmd ::= SHOW CREATE DATABASE db_name */
+   -4,  /* (194) cmd ::= SHOW CREATE TABLE full_table_name */
+   -4,  /* (195) cmd ::= SHOW CREATE STABLE full_table_name */
+   -2,  /* (196) cmd ::= SHOW QUERIES */
+   -2,  /* (197) cmd ::= SHOW SCORES */
+   -2,  /* (198) cmd ::= SHOW TOPICS */
+   -2,  /* (199) cmd ::= SHOW VARIABLES */
+   -2,  /* (200) cmd ::= SHOW BNODES */
+   -2,  /* (201) cmd ::= SHOW SNODES */
+   -2,  /* (202) cmd ::= SHOW CLUSTER */
+   -2,  /* (203) cmd ::= SHOW TRANSACTIONS */
+    0,  /* (204) db_name_cond_opt ::= */
+   -2,  /* (205) db_name_cond_opt ::= db_name NK_DOT */
+    0,  /* (206) like_pattern_opt ::= */
+   -2,  /* (207) like_pattern_opt ::= LIKE NK_STRING */
+   -1,  /* (208) table_name_cond ::= table_name */
+    0,  /* (209) from_db_opt ::= */
+   -2,  /* (210) from_db_opt ::= FROM db_name */
+   -1,  /* (211) func_name_list ::= func_name */
+   -3,  /* (212) func_name_list ::= func_name_list NK_COMMA func_name */
+   -1,  /* (213) func_name ::= function_name */
+   -8,  /* (214) cmd ::= CREATE SMA INDEX not_exists_opt index_name ON table_name index_options */
+  -10,  /* (215) cmd ::= CREATE FULLTEXT INDEX not_exists_opt index_name ON table_name NK_LP col_name_list NK_RP */
+   -6,  /* (216) cmd ::= DROP INDEX exists_opt index_name ON table_name */
+    0,  /* (217) index_options ::= */
+   -9,  /* (218) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt */
+  -11,  /* (219) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt */
+   -1,  /* (220) func_list ::= func */
+   -3,  /* (221) func_list ::= func_list NK_COMMA func */
+   -4,  /* (222) func ::= function_name NK_LP expression_list NK_RP */
+   -6,  /* (223) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_expression */
+   -7,  /* (224) cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name */
+   -7,  /* (225) cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name */
+   -4,  /* (226) cmd ::= DROP TOPIC exists_opt topic_name */
+   -7,  /* (227) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */
+   -2,  /* (228) cmd ::= DESC full_table_name */
+   -2,  /* (229) cmd ::= DESCRIBE full_table_name */
+   -3,  /* (230) cmd ::= RESET QUERY CACHE */
+   -4,  /* (231) cmd ::= EXPLAIN analyze_opt explain_options query_expression */
+    0,  /* (232) analyze_opt ::= */
+   -1,  /* (233) analyze_opt ::= ANALYZE */
+    0,  /* (234) explain_options ::= */
+   -3,  /* (235) explain_options ::= explain_options VERBOSE NK_BOOL */
+   -3,  /* (236) explain_options ::= explain_options RATIO NK_FLOAT */
+   -6,  /* (237) cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP */
+  -10,  /* (238) cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */
+   -4,  /* (239) cmd ::= DROP FUNCTION exists_opt function_name */
+    0,  /* (240) agg_func_opt ::= */
+   -1,  /* (241) agg_func_opt ::= AGGREGATE */
+    0,  /* (242) bufsize_opt ::= */
+   -2,  /* (243) bufsize_opt ::= BUFSIZE NK_INTEGER */
+   -8,  /* (244) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options into_opt AS query_expression */
+   -4,  /* (245) cmd ::= DROP STREAM exists_opt stream_name */
+    0,  /* (246) into_opt ::= */
+   -2,  /* (247) into_opt ::= INTO full_table_name */
+    0,  /* (248) stream_options ::= */
+   -3,  /* (249) stream_options ::= stream_options TRIGGER AT_ONCE */
+   -3,  /* (250) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */
+   -3,  /* (251) stream_options ::= stream_options WATERMARK duration_literal */
+   -3,  /* (252) cmd ::= KILL CONNECTION NK_INTEGER */
+   -3,  /* (253) cmd ::= KILL QUERY NK_INTEGER */
+   -3,  /* (254) cmd ::= KILL TRANSACTION NK_INTEGER */
+   -4,  /* (255) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */
+   -4,  /* (256) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */
+   -3,  /* (257) cmd ::= SPLIT VGROUP NK_INTEGER */
+   -2,  /* (258) dnode_list ::= DNODE NK_INTEGER */
+   -3,  /* (259) dnode_list ::= dnode_list DNODE NK_INTEGER */
+   -3,  /* (260) cmd ::= SYNCDB db_name REPLICA */
+   -1,  /* (261) cmd ::= query_expression */
+   -1,  /* (262) literal ::= NK_INTEGER */
+   -1,  /* (263) literal ::= NK_FLOAT */
+   -1,  /* (264) literal ::= NK_STRING */
+   -1,  /* (265) literal ::= NK_BOOL */
+   -2,  /* (266) literal ::= TIMESTAMP NK_STRING */
+   -1,  /* (267) literal ::= duration_literal */
+   -1,  /* (268) literal ::= NULL */
+   -1,  /* (269) literal ::= NK_QUESTION */
+   -1,  /* (270) duration_literal ::= NK_VARIABLE */
+   -1,  /* (271) signed ::= NK_INTEGER */
+   -2,  /* (272) signed ::= NK_PLUS NK_INTEGER */
+   -2,  /* (273) signed ::= NK_MINUS NK_INTEGER */
+   -1,  /* (274) signed ::= NK_FLOAT */
+   -2,  /* (275) signed ::= NK_PLUS NK_FLOAT */
+   -2,  /* (276) signed ::= NK_MINUS NK_FLOAT */
+   -1,  /* (277) signed_literal ::= signed */
+   -1,  /* (278) signed_literal ::= NK_STRING */
+   -1,  /* (279) signed_literal ::= NK_BOOL */
+   -2,  /* (280) signed_literal ::= TIMESTAMP NK_STRING */
+   -1,  /* (281) signed_literal ::= duration_literal */
+   -1,  /* (282) signed_literal ::= NULL */
+   -1,  /* (283) signed_literal ::= literal_func */
+   -1,  /* (284) literal_list ::= signed_literal */
+   -3,  /* (285) literal_list ::= literal_list NK_COMMA signed_literal */
+   -1,  /* (286) db_name ::= NK_ID */
+   -1,  /* (287) table_name ::= NK_ID */
+   -1,  /* (288) column_name ::= NK_ID */
+   -1,  /* (289) function_name ::= NK_ID */
+   -1,  /* (290) table_alias ::= NK_ID */
+   -1,  /* (291) column_alias ::= NK_ID */
+   -1,  /* (292) user_name ::= NK_ID */
+   -1,  /* (293) index_name ::= NK_ID */
+   -1,  /* (294) topic_name ::= NK_ID */
+   -1,  /* (295) stream_name ::= NK_ID */
+   -1,  /* (296) cgroup_name ::= NK_ID */
+   -1,  /* (297) expression ::= literal */
+   -1,  /* (298) expression ::= pseudo_column */
+   -1,  /* (299) expression ::= column_reference */
+   -1,  /* (300) expression ::= function_expression */
+   -1,  /* (301) expression ::= subquery */
+   -3,  /* (302) expression ::= NK_LP expression NK_RP */
+   -2,  /* (303) expression ::= NK_PLUS expression */
+   -2,  /* (304) expression ::= NK_MINUS expression */
+   -3,  /* (305) expression ::= expression NK_PLUS expression */
+   -3,  /* (306) expression ::= expression NK_MINUS expression */
+   -3,  /* (307) expression ::= expression NK_STAR expression */
+   -3,  /* (308) expression ::= expression NK_SLASH expression */
+   -3,  /* (309) expression ::= expression NK_REM expression */
+   -3,  /* (310) expression ::= column_reference NK_ARROW NK_STRING */
+   -1,  /* (311) expression_list ::= expression */
+   -3,  /* (312) expression_list ::= expression_list NK_COMMA expression */
+   -1,  /* (313) column_reference ::= column_name */
+   -3,  /* (314) column_reference ::= table_name NK_DOT column_name */
+   -1,  /* (315) pseudo_column ::= ROWTS */
+   -1,  /* (316) pseudo_column ::= TBNAME */
+   -3,  /* (317) pseudo_column ::= table_name NK_DOT TBNAME */
+   -1,  /* (318) pseudo_column ::= QSTARTTS */
+   -1,  /* (319) pseudo_column ::= QENDTS */
+   -1,  /* (320) pseudo_column ::= WSTARTTS */
+   -1,  /* (321) pseudo_column ::= WENDTS */
+   -1,  /* (322) pseudo_column ::= WDURATION */
+   -4,  /* (323) function_expression ::= function_name NK_LP expression_list NK_RP */
+   -4,  /* (324) function_expression ::= star_func NK_LP star_func_para_list NK_RP */
+   -6,  /* (325) function_expression ::= CAST NK_LP expression AS type_name NK_RP */
+   -1,  /* (326) function_expression ::= literal_func */
+   -3,  /* (327) literal_func ::= noarg_func NK_LP NK_RP */
+   -1,  /* (328) literal_func ::= NOW */
+   -1,  /* (329) noarg_func ::= NOW */
+   -1,  /* (330) noarg_func ::= TODAY */
+   -1,  /* (331) noarg_func ::= TIMEZONE */
+   -1,  /* (332) star_func ::= COUNT */
+   -1,  /* (333) star_func ::= FIRST */
+   -1,  /* (334) star_func ::= LAST */
+   -1,  /* (335) star_func ::= LAST_ROW */
+   -1,  /* (336) star_func_para_list ::= NK_STAR */
+   -1,  /* (337) star_func_para_list ::= other_para_list */
+   -1,  /* (338) other_para_list ::= star_func_para */
+   -3,  /* (339) other_para_list ::= other_para_list NK_COMMA star_func_para */
+   -1,  /* (340) star_func_para ::= expression */
+   -3,  /* (341) star_func_para ::= table_name NK_DOT NK_STAR */
+   -3,  /* (342) predicate ::= expression compare_op expression */
+   -5,  /* (343) predicate ::= expression BETWEEN expression AND expression */
+   -6,  /* (344) predicate ::= expression NOT BETWEEN expression AND expression */
+   -3,  /* (345) predicate ::= expression IS NULL */
+   -4,  /* (346) predicate ::= expression IS NOT NULL */
+   -3,  /* (347) predicate ::= expression in_op in_predicate_value */
+   -1,  /* (348) compare_op ::= NK_LT */
+   -1,  /* (349) compare_op ::= NK_GT */
+   -1,  /* (350) compare_op ::= NK_LE */
+   -1,  /* (351) compare_op ::= NK_GE */
+   -1,  /* (352) compare_op ::= NK_NE */
+   -1,  /* (353) compare_op ::= NK_EQ */
+   -1,  /* (354) compare_op ::= LIKE */
+   -2,  /* (355) compare_op ::= NOT LIKE */
+   -1,  /* (356) compare_op ::= MATCH */
+   -1,  /* (357) compare_op ::= NMATCH */
+   -1,  /* (358) compare_op ::= CONTAINS */
+   -1,  /* (359) in_op ::= IN */
+   -2,  /* (360) in_op ::= NOT IN */
+   -3,  /* (361) in_predicate_value ::= NK_LP expression_list NK_RP */
+   -1,  /* (362) boolean_value_expression ::= boolean_primary */
+   -2,  /* (363) boolean_value_expression ::= NOT boolean_primary */
+   -3,  /* (364) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
+   -3,  /* (365) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
+   -1,  /* (366) boolean_primary ::= predicate */
+   -3,  /* (367) boolean_primary ::= NK_LP boolean_value_expression NK_RP */
+   -1,  /* (368) common_expression ::= expression */
+   -1,  /* (369) common_expression ::= boolean_value_expression */
+   -2,  /* (370) from_clause ::= FROM table_reference_list */
+   -1,  /* (371) table_reference_list ::= table_reference */
+   -3,  /* (372) table_reference_list ::= table_reference_list NK_COMMA table_reference */
+   -1,  /* (373) table_reference ::= table_primary */
+   -1,  /* (374) table_reference ::= joined_table */
+   -2,  /* (375) table_primary ::= table_name alias_opt */
+   -4,  /* (376) table_primary ::= db_name NK_DOT table_name alias_opt */
+   -2,  /* (377) table_primary ::= subquery alias_opt */
+   -1,  /* (378) table_primary ::= parenthesized_joined_table */
+    0,  /* (379) alias_opt ::= */
+   -1,  /* (380) alias_opt ::= table_alias */
+   -2,  /* (381) alias_opt ::= AS table_alias */
+   -3,  /* (382) parenthesized_joined_table ::= NK_LP joined_table NK_RP */
+   -3,  /* (383) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */
+   -6,  /* (384) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
+    0,  /* (385) join_type ::= */
+   -1,  /* (386) join_type ::= INNER */
+   -9,  /* (387) query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
+    0,  /* (388) set_quantifier_opt ::= */
+   -1,  /* (389) set_quantifier_opt ::= DISTINCT */
+   -1,  /* (390) set_quantifier_opt ::= ALL */
+   -1,  /* (391) select_list ::= NK_STAR */
+   -1,  /* (392) select_list ::= select_sublist */
+   -1,  /* (393) select_sublist ::= select_item */
+   -3,  /* (394) select_sublist ::= select_sublist NK_COMMA select_item */
+   -1,  /* (395) select_item ::= common_expression */
+   -2,  /* (396) select_item ::= common_expression column_alias */
+   -3,  /* (397) select_item ::= common_expression AS column_alias */
+   -3,  /* (398) select_item ::= table_name NK_DOT NK_STAR */
+    0,  /* (399) where_clause_opt ::= */
+   -2,  /* (400) where_clause_opt ::= WHERE search_condition */
+    0,  /* (401) partition_by_clause_opt ::= */
+   -3,  /* (402) partition_by_clause_opt ::= PARTITION BY expression_list */
+    0,  /* (403) twindow_clause_opt ::= */
+   -6,  /* (404) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
+   -4,  /* (405) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */
+   -6,  /* (406) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
+   -8,  /* (407) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
+    0,  /* (408) sliding_opt ::= */
+   -4,  /* (409) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
+    0,  /* (410) fill_opt ::= */
+   -4,  /* (411) fill_opt ::= FILL NK_LP fill_mode NK_RP */
+   -6,  /* (412) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */
+   -1,  /* (413) fill_mode ::= NONE */
+   -1,  /* (414) fill_mode ::= PREV */
+   -1,  /* (415) fill_mode ::= NULL */
+   -1,  /* (416) fill_mode ::= LINEAR */
+   -1,  /* (417) fill_mode ::= NEXT */
+    0,  /* (418) group_by_clause_opt ::= */
+   -3,  /* (419) group_by_clause_opt ::= GROUP BY group_by_list */
+   -1,  /* (420) group_by_list ::= expression */
+   -3,  /* (421) group_by_list ::= group_by_list NK_COMMA expression */
+    0,  /* (422) having_clause_opt ::= */
+   -2,  /* (423) having_clause_opt ::= HAVING search_condition */
+   -4,  /* (424) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
+   -1,  /* (425) query_expression_body ::= query_primary */
+   -4,  /* (426) query_expression_body ::= query_expression_body UNION ALL query_expression_body */
+   -3,  /* (427) query_expression_body ::= query_expression_body UNION query_expression_body */
+   -1,  /* (428) query_primary ::= query_specification */
+   -6,  /* (429) query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */
+    0,  /* (430) order_by_clause_opt ::= */
+   -3,  /* (431) order_by_clause_opt ::= ORDER BY sort_specification_list */
+    0,  /* (432) slimit_clause_opt ::= */
+   -2,  /* (433) slimit_clause_opt ::= SLIMIT NK_INTEGER */
+   -4,  /* (434) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
+   -4,  /* (435) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+    0,  /* (436) limit_clause_opt ::= */
+   -2,  /* (437) limit_clause_opt ::= LIMIT NK_INTEGER */
+   -4,  /* (438) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */
+   -4,  /* (439) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+   -3,  /* (440) subquery ::= NK_LP query_expression NK_RP */
+   -1,  /* (441) search_condition ::= common_expression */
+   -1,  /* (442) sort_specification_list ::= sort_specification */
+   -3,  /* (443) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */
+   -3,  /* (444) sort_specification ::= expression ordering_specification_opt null_ordering_opt */
+    0,  /* (445) ordering_specification_opt ::= */
+   -1,  /* (446) ordering_specification_opt ::= ASC */
+   -1,  /* (447) ordering_specification_opt ::= DESC */
+    0,  /* (448) null_ordering_opt ::= */
+   -2,  /* (449) null_ordering_opt ::= NULLS FIRST */
+   -2,  /* (450) null_ordering_opt ::= NULLS LAST */
 };
 
 static void yy_accept(yyParser*);  /* Forward Declaration */
@@ -3035,14 +3512,17 @@ static YYACTIONTYPE yy_reduce(
   yymsp = yypParser->yytos;
 #ifndef NDEBUG
   if( yyTraceFILE && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){
-    yysize = yyRuleInfo[yyruleno].nrhs;
+    yysize = yyRuleInfoNRhs[yyruleno];
     if( yysize ){
-      fprintf(yyTraceFILE, "%sReduce %d [%s], go to state %d.\n",
+      fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n",
         yyTracePrompt,
-        yyruleno, yyRuleName[yyruleno], yymsp[yysize].stateno);
+        yyruleno, yyRuleName[yyruleno],
+        yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action",
+        yymsp[yysize].stateno);
     }else{
-      fprintf(yyTraceFILE, "%sReduce %d [%s].\n",
-        yyTracePrompt, yyruleno, yyRuleName[yyruleno]);
+      fprintf(yyTraceFILE, "%sReduce %d [%s]%s.\n",
+        yyTracePrompt, yyruleno, yyRuleName[yyruleno],
+        yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action");
     }
   }
 #endif /* NDEBUG */
@@ -3050,7 +3530,7 @@ static YYACTIONTYPE yy_reduce(
   /* Check that the stack is large enough to grow by a single entry
   ** if the RHS of the rule is empty.  This ensures that there is room
   ** enough on the stack to push the LHS value */
-  if( yyRuleInfo[yyruleno].nrhs==0 ){
+  if( yyRuleInfoNRhs[yyruleno]==0 ){
 #ifdef YYTRACKMAXSTACKDEPTH
     if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
       yypParser->yyhwm++;
@@ -4406,9 +4886,9 @@ static YYACTIONTYPE yy_reduce(
         break;
 /********** End reduce actions ************************************************/
   };
-  assert( yyruleno<sizeof(yyRuleInfo)/sizeof(yyRuleInfo[0]) );
-  yygoto = yyRuleInfo[yyruleno].lhs;
-  yysize = yyRuleInfo[yyruleno].nrhs;
+  assert( yyruleno<sizeof(yyRuleInfoLhs)/sizeof(yyRuleInfoLhs[0]) );
+  yygoto = yyRuleInfoLhs[yyruleno];
+  yysize = yyRuleInfoNRhs[yyruleno];
   yyact = yy_find_reduce_action(yymsp[yysize].stateno,(YYCODETYPE)yygoto);
 
   /* There are no SHIFTREDUCE actions on nonterminals because the table
@@ -4695,11 +5175,10 @@ void Parse(
 */
 int ParseFallback(int iToken){
 #ifdef YYFALLBACK
-  if( iToken<(int)(sizeof(yyFallback)/sizeof(yyFallback[0])) ){
-    return yyFallback[iToken];
-  }
+  assert( iToken<(int)(sizeof(yyFallback)/sizeof(yyFallback[0])) );
+  return yyFallback[iToken];
 #else
   (void)iToken;
-#endif
   return 0;
+#endif
 }
diff --git a/source/libs/qworker/test/qworkerTests.cpp b/source/libs/qworker/test/qworkerTests.cpp
index 1b959fbe63..16dcd7b6e0 100644
--- a/source/libs/qworker/test/qworkerTests.cpp
+++ b/source/libs/qworker/test/qworkerTests.cpp
@@ -108,7 +108,7 @@ void qwtInitLogFile() {
 
   tsAsyncLog = 0;
   qDebugFlag = 159;
-  strcpy(tsLogDir, "/var/log/taos");
+  strcpy(tsLogDir, TD_LOG_DIR_PATH);
 
   if (taosInitLog(defaultLogFileNamePrefix, maxLogFileNum) < 0) {
     printf("failed to open log file in directory:%s\n", tsLogDir);
diff --git a/source/libs/scalar/test/filter/filterTests.cpp b/source/libs/scalar/test/filter/filterTests.cpp
index 59c3104e96..7fb1ffbd64 100644
--- a/source/libs/scalar/test/filter/filterTests.cpp
+++ b/source/libs/scalar/test/filter/filterTests.cpp
@@ -60,7 +60,7 @@ void flttInitLogFile() {
 
   tsAsyncLog = 0;
   qDebugFlag = 159;
-  strcpy(tsLogDir, "/var/log/taos");
+  strcpy(tsLogDir, TD_LOG_DIR_PATH);
 
   if (taosInitLog(defaultLogFileNamePrefix, maxLogFileNum) < 0) {
     printf("failed to open log file in directory:%s\n", tsLogDir);
diff --git a/source/libs/scalar/test/scalar/CMakeLists.txt b/source/libs/scalar/test/scalar/CMakeLists.txt
index 672cb5a3de..86b936d93a 100644
--- a/source/libs/scalar/test/scalar/CMakeLists.txt
+++ b/source/libs/scalar/test/scalar/CMakeLists.txt
@@ -17,9 +17,7 @@ TARGET_INCLUDE_DIRECTORIES(
         PUBLIC "${TD_SOURCE_DIR}/source/libs/parser/inc"
         PRIVATE "${TD_SOURCE_DIR}/source/libs/scalar/inc"
 )
-if(NOT TD_WINDOWS)
-        add_test(
-                NAME scalarTest
-                COMMAND scalarTest
-        )
-endif(NOT TD_WINDOWS)
+add_test(
+        NAME scalarTest
+        COMMAND scalarTest
+)
diff --git a/source/libs/scalar/test/scalar/scalarTests.cpp b/source/libs/scalar/test/scalar/scalarTests.cpp
index f3012ba627..8a29462a2b 100644
--- a/source/libs/scalar/test/scalar/scalarTests.cpp
+++ b/source/libs/scalar/test/scalar/scalarTests.cpp
@@ -74,7 +74,7 @@ void scltInitLogFile() {
 
   tsAsyncLog = 0;
   qDebugFlag = 159;
-  strcpy(tsLogDir, "/var/log/taos");
+  strcpy(tsLogDir, TD_LOG_DIR_PATH);
 
   if (taosInitLog(defaultLogFileNamePrefix, maxLogFileNum) < 0) {
     printf("failed to open log file in directory:%s\n", tsLogDir);
diff --git a/source/libs/scheduler/test/schedulerTests.cpp b/source/libs/scheduler/test/schedulerTests.cpp
index d5c834e5cf..4bf114ad8f 100644
--- a/source/libs/scheduler/test/schedulerTests.cpp
+++ b/source/libs/scheduler/test/schedulerTests.cpp
@@ -79,7 +79,7 @@ void schtInitLogFile() {
 
   tsAsyncLog = 0;
   qDebugFlag = 159;
-  strcpy(tsLogDir, "/var/log/taos");
+  strcpy(tsLogDir, TD_LOG_DIR_PATH);
 
   if (taosInitLog(defaultLogFileNamePrefix, maxLogFileNum) < 0) {
     printf("failed to open log file in directory:%s\n", tsLogDir);
diff --git a/source/libs/stream/src/tstream.c b/source/libs/stream/src/tstream.c
index e033645667..7d406a7144 100644
--- a/source/libs/stream/src/tstream.c
+++ b/source/libs/stream/src/tstream.c
@@ -35,6 +35,16 @@ void* streamDataBlockDecode(const void* buf, SStreamDataBlock* pInput) {
   return (void*)buf;
 }
 
+SStreamDataSubmit* streamSubmitRefClone(SStreamDataSubmit* pSubmit) {
+  SStreamDataSubmit* pSubmitClone = taosAllocateQitem(sizeof(SStreamDataSubmit), DEF_QITEM);
+  if (pSubmitClone == NULL) {
+    return NULL;
+  }
+  streamDataSubmitRefInc(pSubmit);
+  memcpy(pSubmitClone, pSubmit, sizeof(SStreamDataSubmit));
+  return pSubmitClone;
+}
+
 static int32_t streamBuildDispatchMsg(SStreamTask* pTask, SArray* data, SRpcMsg* pMsg, SEpSet** ppEpSet) {
   SStreamDispatchReq req = {
       .streamId = pTask->streamId,
@@ -207,7 +217,6 @@ int32_t streamExec(SStreamTask* pTask, SMsgCb* pMsgCb) {
   if (pRes == NULL) return -1;
   while (1) {
     int8_t execStatus = atomic_val_compare_exchange_8(&pTask->status, TASK_STATUS__IDLE, TASK_STATUS__EXECUTING);
-    void*  exec = pTask->exec.executor;
     if (execStatus == TASK_STATUS__IDLE) {
       // first run, from qall, handle failure from last exec
       pRes = streamExecForQall(pTask, pRes);
diff --git a/source/os/src/osEnv.c b/source/os/src/osEnv.c
index 6746025f78..6ae3d8a0c0 100644
--- a/source/os/src/osEnv.c
+++ b/source/os/src/osEnv.c
@@ -70,11 +70,11 @@ void osDefaultInit() {
 
 #elif defined(_TD_DARWIN_64)
   if (configDir[0] == 0) {
-    strcpy(configDir, "/tmp/taosd");
+    strcpy(configDir, "/usr/local/etc/taos");
   }
   strcpy(tsDataDir, "/usr/local/var/lib/taos");
   strcpy(tsLogDir, "/usr/local/var/log/taos");
-  strcpy(tsTempDir, "/usr/local/etc/taos");
+  strcpy(tsTempDir, "/tmp/taosd");
   strcpy(tsOsName, "Darwin");
 
 #else
diff --git a/source/util/src/terror.c b/source/util/src/terror.c
index c1f5c92be7..b81d81c736 100644
--- a/source/util/src/terror.c
+++ b/source/util/src/terror.c
@@ -75,6 +75,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_DUP_KEY,                      "Cannot add duplicate
 TAOS_DEFINE_ERROR(TSDB_CODE_NEED_RETRY,                   "Retry needed")
 TAOS_DEFINE_ERROR(TSDB_CODE_OUT_OF_RPC_MEMORY_QUEUE,      "Out of memory in rpc queue")
 TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_TIMESTAMP,            "Invalid timestamp format")
+TAOS_DEFINE_ERROR(TSDB_CODE_MSG_DECODE_ERROR,             "Msg decode error")
 
 TAOS_DEFINE_ERROR(TSDB_CODE_REF_NO_MEMORY,                "Ref out of memory")
 TAOS_DEFINE_ERROR(TSDB_CODE_REF_FULL,                     "too many Ref Objs")
diff --git a/tests/pytest/util/dnodes.py b/tests/pytest/util/dnodes.py
index 2e11b93e5f..21d235ee5c 100644
--- a/tests/pytest/util/dnodes.py
+++ b/tests/pytest/util/dnodes.py
@@ -397,6 +397,7 @@ class TDDnode:
     def stop(self):
         if (not self.remoteIP == ""):
             self.remoteExec(self.cfgDict, "tdDnodes.stop(%d)"%self.index)
+            tdLog.info("stop dnode%d"%self.index)
             return
         if self.valgrind == 0:
             toBeKilled = "taosd"
diff --git a/tests/script/tsim/db/alter_replica_13.sim b/tests/script/tsim/db/alter_replica_13.sim
new file mode 100644
index 0000000000..8ab6eb64fd
--- /dev/null
+++ b/tests/script/tsim/db/alter_replica_13.sim
@@ -0,0 +1,124 @@
+system sh/stop_dnodes.sh
+system sh/deploy.sh -n dnode1 -i 1
+system sh/deploy.sh -n dnode2 -i 2
+system sh/deploy.sh -n dnode3 -i 3
+system sh/deploy.sh -n dnode4 -i 4
+system sh/exec.sh -n dnode1 -s start
+system sh/exec.sh -n dnode2 -s start
+system sh/exec.sh -n dnode3 -s start
+system sh/exec.sh -n dnode4 -s start
+sql connect
+
+print =============== step1: create dnodes
+sql create dnode $hostname port 7200
+
+$loop_cnt = 0
+step1:
+	$loop_cnt = $loop_cnt + 1
+	sleep 1000
+	if $loop_cnt == 10 then
+	  print ====> dnode not ready!
+		return -1
+	endi
+sql show dnodes
+print ===> $data00 $data01 $data02 $data03 $data04 $data05
+print ===> $data10 $data11 $data12 $data13 $data14 $data15
+if $rows != 2 then
+  return -1
+endi
+if $data(1)[4] != ready then
+  goto step1
+endi
+if $data(2)[4] != ready then
+  goto step1
+endi
+
+print =============== step2: create database
+sql create database db vgroups 1
+sql show databases
+if $rows != 3 then 
+  return -1
+endi
+if $data(db)[4] != 1 then 
+  return -1
+endi
+
+sql show dnodes
+if $data(2)[2] != 1 then
+  return -1
+endi
+
+# vnodes
+sql show dnodes
+if $data(2)[2] != 1 then
+  return -1
+endi
+
+# v1_dnode
+sql show db.vgroups
+if $data(2)[3] != 2 then
+  return -1
+endi
+
+sql_error alter database db replica 3
+sql create table db.stb (ts timestamp, c1 int, c2 binary(4)) tags(t1 int, t2 binary(16)) comment "abd"
+sql create table db.ctb using db.stb tags(101, "102")
+sql insert into db.ctb values(now, 1, "2")
+sql select * from db.stb
+if $rows != 1 then
+  return -1
+endi
+
+print =============== step3: create dnodes
+sql create dnode $hostname port 7300
+sql create dnode $hostname port 7400
+
+$loop_cnt = 0
+step3:
+	$loop_cnt = $loop_cnt + 1
+	sleep 1000
+	if $loop_cnt == 10 then
+	  print ====> dnode not ready!
+		return -1
+	endi
+sql show dnodes
+print ===> rows: $rows 
+print ===> $data00 $data01 $data02 $data03 $data04 $data05
+print ===> $data10 $data11 $data12 $data13 $data14 $data15
+print ===> $data20 $data21 $data22 $data23 $data24 $data25
+print ===> $data30 $data31 $data32 $data33 $data24 $data35
+if $rows != 4 then
+  return -1
+endi
+if $data(1)[4] != ready then
+  goto step3
+endi
+if $data(2)[4] != ready then
+  goto step3
+endi
+if $data(3)[4] != ready then
+  goto step3
+endi
+if $data(4)[4] != ready then
+  goto step3
+endi
+
+return
+print ============= step4: alter database
+sql alter database db replica 3
+if $rows != 3 then 
+  return -1
+endi
+if $data(db)[4] != 3 then 
+  return -1
+endi
+
+sql select * from db.stb
+if $rows != 1 then
+  return -1
+endi
+
+
+system sh/exec.sh -n dnode1 -s stop -x SIGINT
+system sh/exec.sh -n dnode2 -s stop -x SIGINT
+system sh/exec.sh -n dnode3 -s stop -x SIGINT
diff --git a/tests/system-test/0-others/taosShell.py b/tests/system-test/0-others/taosShell.py
index 9c8cd85b46..046db93c49 100644
--- a/tests/system-test/0-others/taosShell.py
+++ b/tests/system-test/0-others/taosShell.py
@@ -84,6 +84,12 @@ class TDTestCase:
     #updatecfgDict = {'clientCfg': {'serverPort': 7080, 'firstEp': 'trd02:7080', 'secondEp':'trd02:7080'},\
     #                 'serverPort': 7080, 'firstEp': 'trd02:7080'}
     hostname = socket.gethostname()
+    if (platform.system().lower() == 'windows' and not tdDnodes.dnodes[0].remoteIP == ""):
+        try:
+            config = eval(tdDnodes.dnodes[0].remoteIP)
+            hostname = config["host"]
+        except Exception:
+            hostname = tdDnodes.dnodes[0].remoteIP
     serverPort = '7080'
     rpcDebugFlagVal = '143'
     clientCfgDict = {'serverPort': '', 'firstEp': '', 'secondEp':'', 'rpcDebugFlag':'135', 'fqdn':''}
diff --git a/tests/system-test/0-others/taosShellError.py b/tests/system-test/0-others/taosShellError.py
index e00fe89461..2369e4d580 100644
--- a/tests/system-test/0-others/taosShellError.py
+++ b/tests/system-test/0-others/taosShellError.py
@@ -86,6 +86,12 @@ class TDTestCase:
     #updatecfgDict = {'clientCfg': {'serverPort': 7080, 'firstEp': 'trd02:7080', 'secondEp':'trd02:7080'},\
     #                 'serverPort': 7080, 'firstEp': 'trd02:7080'}
     hostname = socket.gethostname()
+    if (platform.system().lower() == 'windows' and not tdDnodes.dnodes[0].remoteIP == ""):
+        try:
+            config = eval(tdDnodes.dnodes[0].remoteIP)
+            hostname = config["host"]
+        except Exception:
+            hostname = tdDnodes.dnodes[0].remoteIP
     serverPort = '7080'
     rpcDebugFlagVal = '143'
     clientCfgDict = {'serverPort': '', 'firstEp': '', 'secondEp':'', 'rpcDebugFlag':'135', 'fqdn':''}
diff --git a/tests/system-test/0-others/taosShellNetChk.py b/tests/system-test/0-others/taosShellNetChk.py
index c81d4af3c5..3c99ddb8d6 100644
--- a/tests/system-test/0-others/taosShellNetChk.py
+++ b/tests/system-test/0-others/taosShellNetChk.py
@@ -86,6 +86,12 @@ class TDTestCase:
     #updatecfgDict = {'clientCfg': {'serverPort': 7080, 'firstEp': 'trd02:7080', 'secondEp':'trd02:7080'},\
     #                 'serverPort': 7080, 'firstEp': 'trd02:7080'}
     hostname = socket.gethostname()
+    if (platform.system().lower() == 'windows' and not tdDnodes.dnodes[0].remoteIP == ""):
+        try:
+            config = eval(tdDnodes.dnodes[0].remoteIP )
+            hostname = config["host"]
+        except Exception:
+            hostname = tdDnodes.dnodes[0].remoteIP
     serverPort = '7080'
     rpcDebugFlagVal = '143'
     clientCfgDict = {'serverPort': '', 'firstEp': '', 'secondEp':'', 'rpcDebugFlag':'135', 'fqdn':''}
@@ -196,7 +202,7 @@ class TDTestCase:
         pktNum = '10'
         role   = 'client'
         if platform.system().lower() == 'windows':
-            taosCmd = buildPath + '\\build\\bin\\taos.exe -c ' + keyDict['c']
+            taosCmd = buildPath + '\\build\\bin\\taos.exe -h 127.0.0.1 -c ' + keyDict['c']
             taosCmd = taosCmd.replace('\\','\\\\')
         else:
             taosCmd = buildPath + '/build/bin/taos -c ' + keyDict['c']