Merge branch '3.0' into fix/TD-32563

2024-11-08 09:11:55 +08:00 · 2024-11-08 09:11:55 +08:00 · 1960a4fe86
parent 226a766a17 9468216991
commit 1960a4fe86
272 changed files with 35107 additions and 10715 deletions
--- a/.gitignore
+++ b/.gitignore
@ -159,4 +159,6 @@ pcre2.h
 zconf.h
 version.h
 geos_c.h
-
+source/libs/parser/src/sql.c
+include/common/ttokenauto.h
+!packaging/smokeTest/pytest_require.txt
--- a/cmake/lemon_CMakeLists.txt.in
+++ b/cmake/lemon_CMakeLists.txt.in
@ -0,0 +1,11 @@
+# lemon
+
+ExternalProject_Add(
+    lemon
+    SOURCE_DIR ${TD_CONTRIB_DIR}/lemon
+    CONFIGURE_COMMAND ""
+    BUILD_COMMAND "${C_COMPILER_LEMON}" -o ${TD_CONTRIB_DIR}/lemon/lemon ${TD_CONTRIB_DIR}/lemon/lemon.c
+    INSTALL_COMMAND ""
+    BUILD_IN_SOURCE 1
+    BUILD_ALWAYS 1
+)
--- a/contrib/CMakeLists.txt
+++ b/contrib/CMakeLists.txt
@ -184,6 +184,17 @@ if(${BUILD_PCRE2})
    cat("${TD_SUPPORT_DIR}/pcre2_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
 endif()

+find_program(C_COMPILER_LEMON NAMES gcc)
+if(C_COMPILER_LEMON)
+    message(STATUS "LEMON C compiler: ${C_COMPILER_LEMON}")
+else()
+    set(C_COMPILER_LEMON ${CMAKE_C_COMPILER})
+    message(STATUS "LEMON C compiler: ${C_COMPILER_LEMON}")
+endif()
+
+# lemon
+cat("${TD_SUPPORT_DIR}/lemon_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
+
 # download dependencies
 configure_file(${CONTRIB_TMP_FILE} "${TD_CONTRIB_DIR}/deps-download/CMakeLists.txt")
 execute_process(COMMAND "${CMAKE_COMMAND}" -G "${CMAKE_GENERATOR}" .
--- a/contrib/lemon/lemon.c
+++ b/contrib/lemon/lemon.c
--- a/contrib/lemon/lempar.c
+++ b/contrib/lemon/lempar.c
--- a/docs/examples/JDBC/taosdemo/readme.md
+++ b/docs/examples/JDBC/taosdemo/readme.md
@ -7,8 +7,4 @@ java -jar target/taosdemo-2.0.1-jar-with-dependencies.jar -host <hostname> -data
 java -jar target/taosdemo-2.0.1-jar-with-dependencies.jar -host <hostname> -database <db name> -doCreateTable false -superTableSQL "create table weather(ts timestamp, f1 int) tags(t1 nchar(4))" -numOfTables 1000 -numOfRowsPerTable 100000000 -numOfThreadsForInsert 10 -numOfTablesPerSQL 10 -numOfValuesPerSQL 100
 ```

-如果发生错误 Exception in thread "main" java.lang.UnsatisfiedLinkError: no taos in java.library.path
-请检查是否安装 TDengine 客户端安装包或编译 TDengine 安装。如果确定已经安装过还出现这个错误，可以在命令行 java 后加 -Djava.library.path=/usr/lib 来指定寻找共享库的路径。
-
-
 If you encounter the error Exception in thread "main" `java.lang.UnsatisfiedLinkError: no taos in java.library.path`, please check whether the TDengine client package is installed or TDengine is compiled and installed. If you are sure it is installed and still encounter this error, you can add `-Djava.library.path=/usr/lib` after the `java` command to specify the path to the shared library.
--- a/docs/zh/04-get-started/01-docker.md
+++ b/docs/zh/04-get-started/01-docker.md
@ -23,17 +23,18 @@ docker pull tdengine/tdengine:3.3.3.0
 然后只需执行下面的命令：

 ```shell
-docker run -d -p 6030:6030 -p 6041:6041 -p 6043-6060:6043-6060 -p 6043-6060:6043-6060/udp tdengine/tdengine
+docker run -d -p 6030:6030 -p 6041:6041 -p 6043:6043 -p 6044-6049:6044-6049 -p 6044-6045:6044-6045/udp -p 6060:6060 tdengine/tdengine
 ```

-注意：TDengine 3.0 服务端仅使用 6030 TCP 端口。6041 为 taosAdapter 所使用提供 REST 服务端口。6043-6049 为 taosAdapter 提供第三方应用接入所使用端口，可根据需要选择是否打开。
+注意：TDengine 3.0 服务端仅使用 6030 TCP 端口。6041 为 taosAdapter 所使用提供 REST 服务端口。6043 为 taosKeeper 使用端口。6044-6049 TCP 端口为 taosAdapter 提供第三方应用接入所使用端口，可根据需要选择是否打开。
+6044 和 6045 UDP 端口为 statsd 和 collectd 格式写入接口，可根据需要选择是否打开。6060 为 taosExplorer 使用端口。具体端口使用情况请参考[网络端口要求](../../operation/planning#网络端口要求)。

 如果需要将数据持久化到本机的某一个文件夹，则执行下边的命令：

 ```shell
 docker run -d -v ~/data/taos/dnode/data:/var/lib/taos \
  -v ~/data/taos/dnode/log:/var/log/taos \
-  -p 6030:6030 -p 6041:6041 -p 6043-6060:6043-6060 -p 6043-6060:6043-6060/udp tdengine/tdengine
+  -p 6030:6030 -p 6041:6041 -p 6043:6043 -p 6044-6049:6044-6049 -p 6044-6045:6044-6045/udp -p 6060:6060 tdengine/tdengine
 ```

 :::note
--- a/docs/zh/05-basic/01-model.md
+++ b/docs/zh/05-basic/01-model.md
@ -106,7 +106,7 @@ CREATE DATABASE power PRECISION 'ms' KEEP 3650 DURATION 10 BUFFER 16;
 ```
 该 SQL 将创建一个名为 `power` 的数据库，各参数说明如下：
 - `PRECISION 'ms'` ：这个数据库的时序数据使用毫秒（ms）精度的时间戳
- `KEEP 365`：这个库的数据将保留 3650 天，超过 3650 天的数据将被自动删除
+- `KEEP 3650`：这个库的数据将保留 3650 天，超过 3650 天的数据将被自动删除
 - `DURATION 10` ：每 10 天的数据放在一个数据文件中
 - `BUFFER 16` ：写入使用大小为 16MB 的内存池。

--- a/docs/zh/06-advanced/03-stream.md
+++ b/docs/zh/06-advanced/03-stream.md
@ -116,10 +116,11 @@ create stream if not exists count_history_s fill_history 1 into count_history as

 ### 流计算的触发模式

-在创建流时，可以通过 TRIGGER 指令指定流计算的触发模式。对于非窗口计算，流计算的触发是实时的，对于窗口计算，目前提供 3 种触发模式，默认为 WINDOW_CLOSE。
+在创建流时，可以通过 TRIGGER 指令指定流计算的触发模式。对于非窗口计算，流计算的触发是实时的，对于窗口计算，目前提供 4 种触发模式，默认为 WINDOW_CLOSE。
 1. AT_ONCE：写入立即触发。
 2. WINDOW_CLOSE：窗口关闭时触发（窗口关闭由事件时间决定，可配合 watermark 使用）。
 3. MAX_DELAY time：若窗口关闭，则触发计算。若窗口未关闭，且未关闭时长超过 max delay 指定的时间，则触发计算。
+4. FORCE_WINDOW_CLOSE：以操作系统当前时间为准，只计算当前关闭窗口的结果，并推送出去。窗口只会在被关闭的时刻计算一次，后续不会再重复计算。该模式当前只支持 INTERVAL 窗口（不支持滑动）；FILL_HISTORY必须为 0，IGNORE EXPIRED 必须为 1，IGNORE UPDATE 必须为 1；FILL 只支持 PREV 、NULL、 NONE、VALUE。

 窗口关闭是由事件时间决定的，如事件流中断、或持续延迟，此时事件时间无法更新，可能导致无法得到最新的计算结果。

@ -228,3 +229,34 @@ RESUME STREAM [IF EXISTS] [IGNORE UNTREATED] stream_name;
 ```

 没有指定 IF EXISTS，如果该 stream 不存在，则报错。如果存在，则恢复流计算。指定了 IF EXISTS，如果 stream 不存在，则返回成功。如果存在，则恢复流计算。如果指定 IGNORE UNTREATED，则恢复流计算时，忽略流计算暂停期间写入的数据。
+
+### 流计算升级故障恢复
+
+升级 TDengine 后，如果流计算不兼容，需要删除流计算，然后重新创建流计算。步骤如下：
+
+1.修改 taos.cfg，添加 disableStream 1
+
+2.重启 taosd。如果启动失败，修改 stream 目录的名称，避免 taosd 启动的时候尝试加载 stream 目录下的流计算数据信息。不使用删除操作避免误操作导致的风险。需要修改的文件夹：$dataDir/vnode/vnode*/tq/stream，$dataDir 指 TDengine 存储数据的目录，在 $dataDir/vnode/ 目录下会有多个类似 vnode1 、vnode2...vnode* 的目录，全部需要修改里面的 tq/stream 目录的名字，改为 tq/stream.bk
+
+3.启动 taos
+
+```sql
+drop stream xxxx;                ---- xxx 指stream name
+flush database stream_source_db; ---- 流计算读取数据的超级表所在的 database
+flush database stream_dest_db;   ---- 流计算写入数据的超级表所在的 database
+```
+
+举例：
+
+```sql
+create stream streams1 into test1.streamst as select  _wstart, count(a) c1  from test.st interval(1s) ;
+drop database streams1;
+flush database test;
+flush database test1;
+```
+
+4.关闭 taosd
+
+5.修改 taos.cfg，去掉 disableStream 1，或将 disableStream 改为 0
+
+6.启动 taosd
--- a/docs/zh/06-advanced/06-data-analysis/01-arima.md
+++ b/docs/zh/06-advanced/06-data-analysis/01-arima.md
@ -7,12 +7,12 @@ sidebar_label: "ARIMA"

 ## 功能概述

-ARIMA 即自回归移动平均模型(Autoregressive Integrated Moving Average, ARIMA)，也记作 ARIMA(p,d,q)，是统计模型中最常见的一种用来进行时间序列预测的模型。
-ARIMA模型是一种自回归模型，只需要自变量即可预测后续的值。ARIMA模型要求时序数据是**平稳**，或经过差分处理后平稳，如果是不平稳的数据，**无法**获得正确的结果。
+ARIMA 即自回归移动平均模型（Autoregressive Integrated Moving Average, ARIMA），也记作 ARIMA(p,d,q)，是统计模型中最常见的一种用来进行时间序列预测的模型。
+ARIMA 模型是一种自回归模型，只需要自变量即可预测后续的值。ARIMA 模型要求时间序列**平稳**，或经过差分处理后平稳，如果是不平稳的数据，**无法**获得正确的结果。

 >平稳的时间序列：其性质不随观测时间的变化而变化。具有趋势或季节性的时间序列不是平稳时间序列——趋势和季节性使得时间序列在不同时段呈现不同性质。

-以下参数可以动态输入控制预测过程中生成 合适的  ARIMA 的模型。
+以下参数可以动态输入，控制预测过程中生成合适的 ARIMA 模型。

 - p= 自回归模型阶数
 - d= 差分阶数
@ -21,9 +21,9 @@ ARIMA模型是一种自回归模型，只需要自变量即可预测后续的值

 ### 参数
 分析平台中使用自动化的 ARIMA 模型进行计算，因此每次计算的时候会根据输入的数据自动拟合最合适的模型，然后根据该模型进行预测输出结果。
-|参数名称|说明|必填项|
-|---|---|---|
-|period|输入时间序列数据每个周期包含的数据点个数。如果不设置该参数或则该参数设置为 0， 将使用非季节性/周期性的 ARIMA 模型预测。|选填|
+|参数|说明|必填项|
+|---|---|-----|
+|period|输入时间序列每个周期包含的数据点个数，如果不设置该参数或该参数设置为 0，将使用非季节性/周期性的 ARIMA 模型预测|选填|
 |start_p|自回归模型阶数的起始值，0 开始的整数，不推荐大于 10|选填|
 |max_p|自回归模型阶数的结束值，0 开始的整数，不推荐大于 10|选填|
 |start_q|移动平均模型阶数的起始值，0 开始的整数，不推荐大于 10|选填|
@ -40,11 +40,11 @@ FORECAST(i32, "algo=arima,alpha=95,period=10, start_p=1, max_p=5, start_q=1, max

 ```json5
 {
-"rows": fc_rows,  // 预测结果的行数
+"rows": fc_rows,  // 返回结果的行数
 "period": period, // 返回结果的周期性，同输入
 "alpha": alpha,   // 返回结果的置信区间，同输入
 "algo": "arima",  // 返回结果使用的算法
-"mse":mse,        // 拟合输入时序数据时候生成模型的最小均方误差(MSE)
+"mse": mse,       // 拟合输入时间序列时候生成模型的最小均方误差(MSE)
 "res": res        // 列模式的结果
 }
 ```
--- a/docs/zh/06-advanced/06-data-analysis/02-holtwinters.md
+++ b/docs/zh/06-advanced/06-data-analysis/02-holtwinters.md
@ -6,17 +6,17 @@ sidebar_label: "HoltWinters"
 本节讲述 HoltWinters 算法模型的使用方法。

 ## 功能概述
-HoltWinters模型又称为多次指数平滑模型（EMA）。对含有线性趋势和周期波动的非平稳序列适用，利用指数平滑法让模型参数不断适应非平稳序列的变化，并对未来趋势进行**短期**预测。
+HoltWinters 模型又称为多次指数平滑模型（EMA）。适用于含有线性趋势和周期波动的非平稳序列，利用指数平滑法让模型参数不断适应非平稳序列的变化，并对未来趋势进行**短期**预测。
 HoltWinters 有两种不同的季节性组成部分，当季节变化在该时间序列中大致保持不变时，通常选择**加法模型**；而当季节变化与时间序列的水平成比例变化时，通常选择**乘法模型**。
-该模型对于返回数据也不提供计算的置信区间范围结果。在 95% 置信区间的上下界结果与预测结果相同。
+该模型对于返回数据不提供计算的置信区间范围结果，在 95% 置信区间的上下界结果与预测结果相同。


 ### 参数

-分析平台中使用自动化的 ARIMA 模型进行计算，因此每次计算的时候会根据输入的数据自动拟合最合适的模型，然后根据该模型进行预测输出结果。
-|参数名称|说明|必填项|
+分析平台中使用自动化的 HoltWinters 模型进行计算，因此每次计算的时候会根据输入的数据自动拟合最合适的模型，然后根据该模型进行预测输出结果。
+|参数|说明|必填项|
 |---|---|---|
-|period|	输入时间序列数据每个周期包含的数据点个数。如果不设置该参数或则该参数设置为 0， 将使用一次（简单）指数平滑方式进行数据拟合，并据此进行未来数据的预测|选填|
+|period|输入时间序列每个周期包含的数据点个数。如果不设置该参数或该参数设置为 0，将使用一次（简单）指数平滑方式进行数据拟合，并据此进行未来数据的预测|选填|
 |trend|趋势模型使用加法模型还是乘法模型|选填|
 |seasonal|季节性采用加法模型还是乘法模型|选填|

@ -30,7 +30,7 @@ FORECAST(i32, "algo=holtwinters,period=10,trend=mul,seasonal=mul")

 ```json5
 {
-"rows": rows,  //  结果的行数
+"rows": rows,         // 返回结果的行数
 "period": period,     // 返回结果的周期性，该结果与输入的周期性相同，如果没有周期性，该值为 0
 "algo": 'holtwinters' // 返回结果使用的计算模型
 "mse": mse,           // 最小均方误差（minmum square error）
--- a/docs/zh/06-advanced/06-data-analysis/03-anomaly-detection.md
+++ b/docs/zh/06-advanced/06-data-analysis/03-anomaly-detection.md
@ -13,7 +13,7 @@ sidebar_label: "Anomaly-detection"

 - k-sigma<sup>[1]</sup>: 即 ***68–95–99.7 rule*** 。***k***值默认为 3，即序列均值的 3 倍标准差范围为边界，超过边界的是异常值。KSigma 要求数据整体上服从正态分布，如果一个点偏离均值 K 倍标准差，则该点被视为异常点.
  
-|参数名称|说明|是否必选|默认值|
+|参数|说明|是否必选|默认值|
 |---|---|---|---|
 |k|标准差倍数|选填|3|

@ -24,13 +24,13 @@ sidebar_label: "Anomaly-detection"

 - SHESD<sup>[4]</sup>： 带有季节性的 ESD 检测算法。ESD 可以检测时间序列数据的多异常点。需要指定异常点比例的上界***k***，最差的情况是至多 49.9%。数据集的异常比例一般不超过 5%
  
-|参数名称|说明|是否必选|默认值|
+|参数|说明|是否必选|默认值|
 |---|---|---|---|
 |k|异常点在输入数据集中占比，范围是$`1\le K \le 49.9`$ |选填|5|


 ### 基于数据密度的检测方法
-LOF<sup>[5]</sup>: 局部离群因子(LOF，又叫局部异常因子)算法是Breunig于2000年提出的一种基于密度的局部离群点检测算法，该方法适用于不同类簇密度分散情况迥异的数据。根据数据点周围的数据密集情况，首先计算每个数据点的一个局部可达密度，然后通过局部可达密度进一步计算得到每个数据点的一个离群因子，该离群因子即标识了一个数据点的离群程度，因子值越大，表示离群程度越高，因子值越小，表示离群程度越低。最后，输出离群程度最大的top(n)个点。
+LOF<sup>[5]</sup>: 局部离群因子（LOF，又叫局部异常因子）算法是 Breunig 于 2000 年提出的一种基于密度的局部离群点检测算法，该方法适用于不同类簇密度分散情况迥异的数据。根据数据点周围的数据密集情况，首先计算每个数据点的一个局部可达密度，然后通过局部可达密度进一步计算得到每个数据点的一个离群因子，该离群因子即标识了一个数据点的离群程度，因子值越大，表示离群程度越高，因子值越小，表示离群程度越低。最后，输出离群程度最大的 top(n) 个点。


 ### 基于深度学习的检测方法
--- a/docs/zh/06-advanced/06-data-analysis/addins.md
+++ b/docs/zh/06-advanced/06-data-analysis/addins.md
@ -3,7 +3,7 @@ title: "addins"
 sidebar_label: "addins"
 ---

-本节说明如何将自己开发的新预测算法和异常检测算法整合到 TDengine 分析平台， 并能够通过 SQL 语句进行调用。
+本节说明如何将自己开发的预测算法和异常检测算法整合到 TDengine 分析平台，并能够通过 SQL 语句进行调用。

 ## 目录结构

@ -27,33 +27,35 @@ sidebar_label: "addins"

 ### 类继承约定

-异常检测算法需要从 `AbstractAnomalyDetectionService` 继承，并实现其核心抽象方法 `execute`.
-预测算法需要从 `AbstractForecastService` 继承，同样需要实现其核心抽象方法 `execute`。
+- 异常检测算法需要从 `AbstractAnomalyDetectionService` 继承，并实现其核心抽象方法 `execute`
+- 预测算法需要从 `AbstractForecastService` 继承，同样需要实现其核心抽象方法 `execute`

 ### 类属性初始化
-每个算法实现的类需要静态初始化两个类属性，分别是
+每个算法实现的类需要静态初始化两个类属性，分别是：

-`name`: 的触发调用关键词，全小写英文字母。
-`desc`：该算法的描述信息。
+- `name`：触发调用的关键词，全小写英文字母
+- `desc`：算法的描述信息

 ### 核心方法输入与输出约定

 `execute` 是算法处理的核心方法。调用该方法的时候，`self.list` 已经设置好输入数组。
+
 异常检测输出结果

 `execute` 的返回值是长度与 `self.list` 相同的数组，数组位置为 -1 的即为异常值点。例如：输入数组是 [2, 2, 2, 2, 100]， 如果 100 是异常点，那么返回值是 [1, 1, 1, 1, -1]。
+
 预测输出结果

 对于预测算法，`AbstractForecastService` 的对象属性说明如下：

 |属性名称|说明|默认值|
 |---|---|---|
-|period|输入时序数据的周期性，多少个数据点表示一个完整的周期。如果没有周期性，那么设置为 0 即可。|	0|
-|start_ts|预测数据的开始时间|	0|
+|period|输入时间序列的周期性，多少个数据点表示一个完整的周期。如果没有周期性，那么设置为 0 即可|	0|
+|start_ts|预测结果的开始时间|	0|
 |time_step|预测结果的两个数据点之间时间间隔|0	|
-|fc_rows|预测结果数量|	0	|
-|return_conf|返回结果中是否包含执行区间范围，如果算法计算结果不包含置信区间，那么上界和下界与自身相同|	1|	
-|conf|执行区间分位数	0.05|
+|fc_rows|预测结果的数量|	0	|
+|return_conf|预测结果中是否包含置信区间范围，如果不包含置信区间，那么上界和下界与自身相同|	1|	
+|conf|置信区间分位数 0.05|


 预测返回结果如下：
@ -111,6 +113,7 @@ class _IqrService(AbstractAnomalyDetectionService):
 ## 单元测试

 在测试文件目录中的 anomaly_test.py 中增加单元测试用例。
+
 ```python
 def test_iqr(self):
 	""" 测试 _IqrService 类 """
@ -137,7 +140,7 @@ def test_iqr(self):

 ## 需要模型的算法

-针对特定数据集，进行模型训练的算法，在训练完成后。需要将训练得到的模型保存在  model 目录中。需要注意的是，针对每个算法，需要建立独立的文件夹。例如 auto_encoder 的训练算法在 model 目录下建立了， autoencoder的目录，使用该算法针对不同数据集训练得到的模型，均需要放置在该目录下。
+针对特定数据集，进行模型训练的算法，在训练完成后。需要将训练得到的模型保存在 model 目录中。需要注意的是，针对每个算法，需要建立独立的文件夹。例如 auto_encoder 的训练算法在 model 目录下建立 autoencoder 的目录，使用该算法针对不同数据集训练得到的模型，均需要放置在该目录下。

 训练完成后的模型，使用 joblib 进行保存。

--- a/docs/zh/06-advanced/06-data-analysis/index.md
+++ b/docs/zh/06-advanced/06-data-analysis/index.md
@ -5,7 +5,7 @@ title: 数据分析功能

 ## 概述

-TDengine 通过 ANode(AnalysisNode) 是提供数据分析功能的扩展组件，通过 Restful 接口提供分析服务，从而拓展 TDengine 的功能，支持时间序列高级分析功能。
+ANode（Analysis Node）是 TDengine 提供数据分析功能的扩展组件，通过 Restful 接口提供分析服务，拓展 TDengine 的功能，支持时间序列高级分析。
 ANode 是无状态的数据分析节点，集群中可以存在多个 ANode 节点，相互之间没有关联。将 ANode 注册到 TDengine 集群以后，通过 SQL 语句即可调用并完成时序分析任务。
 下图是数据分析的技术架构示意图。

@ -13,10 +13,10 @@ ANode 是无状态的数据分析节点，集群中可以存在多个 ANode节

 ## 安装部署
 ### 环境准备
-ANode 的要求节点上准备有 Python 3.10 及以上版本以及相应的Python包自动安装组件 Pip ，同时请确保能够正常连接互联网。
+ANode 要求节点上准备有 Python 3.10 及以上版本，以及相应的 Python 包自动安装组件 Pip，同时请确保能够正常连接互联网。

 ### 安装及卸载
-使用专门的 ANode 安装包 TDengine-enterprise-anode-1.x.x.tar.gz 进行 ANode 的安装部署工作，安装过程与 TDengien 的安装流程一致。
+使用专门的 ANode 安装包 TDengine-enterprise-anode-1.x.x.tar.gz 进行 ANode 的安装部署工作，安装过程与 TDengine 的安装流程一致。

 ```bash
 tar -xzvf TDengine-enterprise-anode-1.0.0.tar.gz
@ -50,7 +50,7 @@ systemctl status taosanoded

 ### 配置说明

-Anode 提供的 RestFul 服务使用 uWSGI 驱动，因此 ANode 的配置和 uWSGI 的配置在同一个配置文件中，具体如下：
+Anode 提供的 RestFul 服务使用 uWSGI 驱动，因此 ANode 和 uWSGI 的配置信息存放在同一个配置文件中，具体如下：

 ```ini
 [uwsgi]
@ -68,9 +68,9 @@ http = 127.0.0.1:6050
 chdir = /usr/local/taos/taosanode/lib

 # initialize python file
-wsgi-file = /usr/local/taos/taosanode/lib/app.py
+wsgi-file = /usr/local/taos/taosanode/lib/taos/app.py

-# invoke app model
+# call module of uWSGI
 callable = app

 # auto remove unix Socket and pid file when stopping
@ -92,25 +92,27 @@ master = true
 processes = 2

 # pid file
-pidfile = /usr/local/taos/taosanode/uwsgi.pid
+pidfile = /usr/local/taos/taosanode/taosanode.pid

 # enable threads
 enable-threads = true

 # the number of threads for each process
-threads=2
+threads = 4

 # memory useage report
 memory-report = true
+
+# smooth restart
 reload-mercy = 10

 # conflict with systemctl, so do NOT uncomment this
 # daemonize = /var/log/taos/taosanode/taosanode.log

-# set log
+# log directory
 logto = /var/log/taos/taosanode/taosanode.log

-# monitor server
+# wWSGI monitor port
 stats = 127.0.0.1:8387

 # python virtual environment directory
@ -125,6 +127,9 @@ model-dir=/usr/local/taos/taosanode/model/

 # default log level
 log-level = DEBUG
+
+# draw the query results
+draw-result = 0
 ```

 **提示**
@ -137,7 +142,7 @@ log-level = DEBUG
 ```sql 
 CREATE ANODE {node_url}
 ```
-node_url 是提供服务的 ANode 的 IP 和 PORT, 例如：`create anode 'http://localhost:6050'`。启动 ANode 以后如果不注册到 TDengine 集群中，无法提供正常的服务。不建议 ANode 注册到两个或多个集群中。
+node_url 是提供服务的 ANode 的 IP 和 PORT, 例如：`create anode 'http://localhost:6050'`。启动 ANode 以后如果不注册到 TDengine 集群中，则无法提供正常的服务。不建议 ANode 注册到两个或多个集群中。

 #### 查看 ANode
 列出集群中所有的数据分析节点，包括其 `FQDN`, `PORT`, `STATUS`。
@ -151,7 +156,7 @@ SHOW ANODES;
 SHOW ANODES FULL;
 ```

-#### 强制刷新 TDengine 集群中分析算法缓存
+#### 强制刷新集群中的分析算法缓存
 ```SQL
 UPDATE ANODE {node_id}
 UPDATE ALL ANODES
@ -167,24 +172,23 @@ DROP ANODE {anode_id}

 #### 白噪声检查

-平台提供 Restful的服务检测输入时间序列是否是白噪声时间序列（White Noise Data, WND），白噪声时间序列及随机数序列。
-此外，分析平台要求输入的数据不能是 , 因此针对的所有数据均默认进行 白噪声检查。当前白噪声检查采用通行的 `Ljung-Box`检验，`Ljung-Box` 统计量检查过程需要遍历整个输入序列并进行计算。
+分析平台提供的 Restful 服务要求输入的时间序列不能是白噪声时间序列（White Noise Data, WND）和随机数序列 , 因此针对所有数据均默认进行白噪声检查。当前白噪声检查采用通行的 `Ljung-Box` 检验，`Ljung-Box` 统计量检查过程需要遍历整个输入序列并进行计算。
 如果用户能够明确输入序列一定不是白噪声序列，那么可以通过输入参数，指定预测之前忽略该检查，从而节省分析过程的 CPU 计算资源。
 同时支持独立地针对输入序列进行白噪声检测（该检测功能暂不独立对外开放）。


 #### 数据重采样和时间戳对齐

-数据分析平台支持将输入的数据进行重采样的预处理，从而确保输出结果按照用户指定的等间隔进行处理。处理过程分为两种类别：
+分析平台支持将输入数据进行重采样预处理，从而确保输出结果按照用户指定的等间隔进行处理。处理过程分为两种类别：

- 数据时间戳对齐。由于真实数据时间可能并非严格按照查询指定的时间戳输入。此时数据平台将自动将数据的时间间隔按照指定的时间间隔进行对齐。例如有输入时间序列：[11,  22,  29,  41]，用户指定时间间隔为 10，那么该序列将被对齐重整为以下序列 [10, 20, 30, 40]。
- 数据时间重采样。用户输入的时间序列其采样频率超过了指定的查询需要获得结果的时间间隔，例如输入原始数据是 5， 但是输出结果的频率是 10. [0， 5， 10， 15， 20， 25， 30]，那么该输入数据列将重采用为间隔 为 10 的输入序列，其结果如下 [0, 10, 20，30]。[5, 15, 25] 处的数据将被丢弃。
+- 数据时间戳对齐。由于真实数据可能并非严格按照查询指定的时间戳输入。此时分析平台会自动将数据的时间间隔按照指定的时间间隔进行对齐。例如输入时间序列 [11,  22,  29,  41]，用户指定时间间隔为 10，该序列将被对齐重整为以下序列 [10, 20, 30, 40]。
+- 数据时间重采样。用户输入时间序列的采样频率超过了输出结果的频率，例如输入时间序列的采样频率是 5，输出结果的频率是 10，输入时间序列 [0， 5， 10， 15， 20， 25， 30] 将被重采用为间隔 为 10 的序列 [0, 10, 20，30]，[5, 15, 25] 处的数据将被丢弃。

 需要注意的是，数据输入平台不支持缺失数据补齐后进行的预测分析，如果输入时间序列数据 [11, 22, 29, 49]，并且用户要求的时间间隔为 10，重整对齐后的序列是 [10, 20, 30, 50] 那么该序列进行预测分析将返回错误。


 #### 时序数据异常检测
-异常检测是针对输入的时序数据，使用预设或用户指定的算法确定时间序列中**可能**出现异常时间序列点，对于时间序列中若干个连续的异常点，将自动合并成为一个连续的（闭区间）异常窗口。对于只有单个点的场景，异常窗口窗口退化成为一个起始时间和结束时间相同的点。
+异常检测是针对输入的时序数据，使用预设或用户指定的算法确定时间序列中**可能**出现异常的时间序列点，对于时间序列中若干个连续的异常点，将自动合并成为一个连续的（闭区间）异常窗口。对于只有单个点的场景，异常窗口窗口退化成为一个起始时间和结束时间相同的点。
 异常检测生成的异常窗口受检测算法和算法参数的共同影响，对于异常窗口范围内的数据，可以应用 TDengine 提供的聚合和标量函数进行查询或变换处理。
 对于输入时间序列 (1, 20), (2, 22), (3, 91), (4, 120), (5, 18), (6, 19)。系统检测到 (3, 91), (4, 120) 为异常点，那么返回的异常窗口是闭区间 [3, 4]。

@ -201,10 +205,10 @@ algo=expr1
 "}
 ```

-1. `column`：进行时序数据异常检测的输入数据列，当前只支持单列输入，且只能是数值类型，不能是字符类型（例如：`NCHAR` `VARCHAR` `VARBINARY`等类型），**不支持函数表达式**。
-2. `options`：字符串。其中使用 K/V 调用异常检测的算法，及与算法相关的参数。采用 逗号分隔的K/V字符串表示，其中的字符串不需要使用单引号、双引号、或转意号等符号，不能使用中文及其他宽字符。例如：`algo=ksigma, k=2` 表示进行异常检测的算法是 ksigma，该算法接受的输入参数是 2。
+1. `column`：进行时序数据异常检测的输入数据列，当前只支持单列，且只能是数值类型，不能是字符类型（例如：`NCHAR` `VARCHAR` `VARBINARY`等类型），**不支持函数表达式**。
+2. `options`：字符串。其中使用 K=V 调用异常检测算法及与算法相关的参数。采用逗号分隔的 K=V 字符串表示，其中的字符串不需要使用单引号、双引号、或转义号等符号，不能使用中文及其他宽字符。例如：`algo=ksigma,k=2` 表示进行异常检测的算法是 ksigma，该算法接受的输入参数是 2。
 3. 异常检测的结果可以作为外层查询的子查询输入，在 `SELECT` 子句中使用的聚合函数或标量函数与其他类型的窗口查询相同。
-4. 输入数据默认进行白噪声检查，如果检查结果是输入数据是白噪声，将不会有任何（异常）窗口信息返回。
+4. 输入数据默认进行白噪声检查，如果输入数据是白噪声，将不会有任何（异常）窗口信息返回。

 **参数说明**
 |参数|含义|默认值|
@ -212,7 +216,7 @@ algo=expr1
 |algo|异常检测调用的算法|iqr|
 |wncheck|对输入数据列是否进行白噪声检查|取值为 0 或者 1，默认值为 1，表示进行白噪声检查|

-异常检测的返回结果以窗口的形式呈现，因此窗口查询相关的伪列在这种场景下仍然可用。可以使用的伪列如下：
+异常检测的返回结果以窗口形式呈现，因此窗口查询相关的伪列在这种场景下仍然可用。可以使用的伪列如下：
 1. `_WSTART`： 异常窗口开始时间戳
 2. `_WEND`：异常窗口结束时间戳
 3. `_WDURATION`：异常窗口持续时间
@ -233,7 +237,7 @@ ANOMALY_WINDOW(i32, "algo=ksigma,k=2");
 ```
 taos> SELECT _wstart, _wend, count(*) FROM ai.atb ANOMAYL_WINDOW(i32);
         _wstart         |          _wend          |   count(*)    |
-============================================================================
+====================================================================
 2020-01-01 00:00:16.000 | 2020-01-01 00:00:16.001 |             1 |
 Query OK, 1 row(s) in set (0.028946s)
 ```
@ -281,7 +285,7 @@ algo=expr1
 |rows|预测结果的记录数|10|

 1. 预测查询结果新增了三个伪列，具体如下：`_FROWTS`：预测结果的时间戳、`_FLOW`：置信区间下界、`_FHIGH`：置信区间上界, 对于没有置信区间的预测算法，其置信区间同预测结果
-2. 更改参数 `START`：返回预测结果的起始时间，改变这个起始时间不会影响返回的预测数值，只影响起始时间。
+2. 更改参数 `START`：返回预测结果的起始时间，改变起始时间不会影响返回的预测数值，只影响起始时间。
 3. `EVERY`：可以与输入数据的采样频率不同。采样频率只能低于或等于输入数据采样频率，不能**高于**输入数据的采样频率。
 4. 对于某些不需要计算置信区间的算法，即使指定了置信区间，返回的结果中其上下界退化成为一个点。

--- a/docs/zh/08-operation/02-planning.md
+++ b/docs/zh/08-operation/02-planning.md
@ -146,11 +146,17 @@ TDengine 的多级存储功能在使用上还具备以下优点。

 下表列出了 TDengine 的一些接口或组件的常用端口，这些端口均可以通过配置文件中的参数进行修改。

-|    接口或组件     |    端口    |
-| :---------------: | :--------: |
-| 原生接口（taosc） |    6030    |
-|   RESTful 接口    |    6041    |
-|  WebSocket 接口   |    6041    |
-|    taosKeeper     |    6043    |
-|       taosX       | 6050, 6055 |
-|   taosExplorer    |    6060    |
+|               接口或组件名称                 |     端口   |   协议    |
+|:-----------------------------------------:|:----------:|:--------:|
+|             原生接口（taosc）               |    6030    |   TCP   |
+|              RESTful 接口                  |    6041    |   TCP   |
+|             WebSocket 接口                 |    6041    |   TCP   |
+|              taosKeeper                   |    6043    |   TCP   |
+|            statsd 格式写入接口              |    6044    | TCP/UDP |
+|           collectd 格式写入接口             |    6045    | TCP/UDP |
+|        openTSDB Telnet 格式写入接口         |    6046    |   TCP   |
+|  collectd 使用 openTSDB Telnet 格式写入接口  |    6047    |   TCP   |
+|  icinga2 使用 openTSDB Telnet 格式写入接口   |    6048    |   TCP   |
+| tcollector 使用 openTSDB Telnet 格式写入接口 |    6049    |   TCP   |
+|                taosX                      | 6050, 6055 |   TCP   |
+|             taosExplorer                  |    6060    |   TCP   |
--- a/docs/zh/08-operation/12-multi.md
+++ b/docs/zh/08-operation/12-multi.md
@ -163,3 +163,15 @@ s3BucketName td-test
 - 认为全部 S3 服务均指向同一数据源，对各个 S3 服务操作完全等价
 - 在某一 S3 服务上操作失败后会切换至其他服务，全部服务都失败后将返回最后产生的错误码
 - 最大支持的 S3 服务配置数为 10
+
+### 不依赖 Flexify 服务
+
+用户界面同 S3，不同的地方在于下面三个参数的配置：
+
+| #    | 参数         | 示例值                                   | 描述                                                         |
+| :--- | :----------- | :--------------------------------------- | :----------------------------------------------------------- |
+| 1    | s3EndPoint   | https://fd2d01c73.blob.core.windows.net  | Blob URL                                                     |
+| 2    | s3AccessKey  | fd2d01c73:veUy/iRBeWaI2YAerl+AStw6PPqg== | 冒号分隔的用户 accountId:accountKey                          |
+| 3    | s3BucketName | test-container                           | Container name                                               |
+
+其中 fd2d01c73 是账户 ID；微软 Blob 存储服务只支持 Https 协议，不支持 Http。
--- a/docs/zh/14-reference/01-components/06-taoskeeper.md
+++ b/docs/zh/14-reference/01-components/06-taoskeeper.md
@ -22,34 +22,45 @@ taosKeeper 有两种安装方式：
 taosKeeper 需要在操作系统终端执行，该工具支持三种配置方式：命令行参数、环境变量 和 配置文件。优先级为：命令行参数、环境变量、配置文件参数。 一般我们推荐使用配置文件。

 ### 命令行参数和环境变量
+
 命令行参数 和 环境变量说明可以参考命令 `taoskeeper --help` 的输出。下面是一个例子：
+
 ```shell
-Usage of taosKeeper v3.3.2.0:
-      --debug                          enable debug mode. Env "TAOS_KEEPER_DEBUG"
-  -P, --port int                       http port. Env "TAOS_KEEPER_PORT" (default 6043)
-      --logLevel string                log level (panic fatal error warn warning info debug trace). Env "TAOS_KEEPER_LOG_LEVEL" (default "info")
-      --gopoolsize int                 coroutine size. Env "TAOS_KEEPER_POOL_SIZE" (default 50000)
+Usage of taoskeeper v3.3.3.0:
  -R, --RotationInterval string                      interval for refresh metrics, such as "300ms", Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h". Env "TAOS_KEEPER_ROTATION_INTERVAL" (default "15s")
+  -c, --config string                                config path default /etc/taos/taoskeeper.toml
+      --drop string                                  run taoskeeper in command mode, only support old_taosd_metric_stables. 
+      --environment.incgroup                         whether running in cgroup. Env "TAOS_KEEPER_ENVIRONMENT_INCGROUP"
+      --fromTime string                              parameter of transfer, example: 2020-01-01T00:00:00+08:00 (default "2020-01-01T00:00:00+08:00")
+      --gopoolsize int                               coroutine size. Env "TAOS_KEEPER_POOL_SIZE" (default 50000)
+  -h, --help                                         Print this help message and exit
+      --instanceId int                               instance ID. Env "TAOS_KEEPER_INSTANCE_ID" (default 64)
+      --log.compress                                 whether to compress old log. Env "TAOS_KEEPER_LOG_COMPRESS"
+      --log.keepDays uint                            log retention days, must be a positive integer. Env "TAOS_KEEPER_LOG_KEEP_DAYS" (default 30)
+      --log.level string                             log level (trace debug info warning error). Env "TAOS_KEEPER_LOG_LEVEL" (default "info")
+      --log.path string                              log path. Env "TAOS_KEEPER_LOG_PATH" (default "/var/log/taos")
+      --log.reservedDiskSize string                  reserved disk size for log dir (KB MB GB), must be a positive integer. Env "TAOS_KEEPER_LOG_RESERVED_DISK_SIZE" (default "1GB")
+      --log.rotationCount uint                       log rotation count. Env "TAOS_KEEPER_LOG_ROTATION_COUNT" (default 5)
+      --log.rotationSize string                      log rotation size(KB MB GB), must be a positive integer. Env "TAOS_KEEPER_LOG_ROTATION_SIZE" (default "1GB")
+      --log.rotationTime duration                    deprecated: log rotation time always 24 hours. Env "TAOS_KEEPER_LOG_ROTATION_TIME" (default 24h0m0s)
+      --logLevel string                              log level (trace debug info warning error). Env "TAOS_KEEPER_LOG_LEVEL" (default "info")
+      --metrics.database.name string                 database for storing metrics data. Env "TAOS_KEEPER_METRICS_DATABASE" (default "log")
+      --metrics.database.options.buffer int          database option buffer for audit database. Env "TAOS_KEEPER_METRICS_BUFFER" (default 64)
+      --metrics.database.options.cachemodel string   database option cachemodel for audit database. Env "TAOS_KEEPER_METRICS_CACHEMODEL" (default "both")
+      --metrics.database.options.keep int            database option buffer for audit database. Env "TAOS_KEEPER_METRICS_KEEP" (default 90)
+      --metrics.database.options.vgroups int         database option vgroups for audit database. Env "TAOS_KEEPER_METRICS_VGROUPS" (default 1)
+      --metrics.prefix string                        prefix in metrics names. Env "TAOS_KEEPER_METRICS_PREFIX"
+      --metrics.tables stringArray                   export some tables that are not super table, multiple values split with white space. Env "TAOS_KEEPER_METRICS_TABLES"
+  -P, --port int                                     http port. Env "TAOS_KEEPER_PORT" (default 6043)
      --tdengine.host string                         TDengine server's ip. Env "TAOS_KEEPER_TDENGINE_HOST" (default "127.0.0.1")
+      --tdengine.password string                     TDengine server's password. Env "TAOS_KEEPER_TDENGINE_PASSWORD" (default "taosdata")
      --tdengine.port int                            TDengine REST server(taosAdapter)'s port. Env "TAOS_KEEPER_TDENGINE_PORT" (default 6041)
      --tdengine.username string                     TDengine server's username. Env "TAOS_KEEPER_TDENGINE_USERNAME" (default "root")
-      --tdengine.password string       TDengine server's password. Env "TAOS_KEEPER_TDENGINE_PASSWORD" (default "taosdata")
      --tdengine.usessl                              TDengine server use ssl or not. Env "TAOS_KEEPER_TDENGINE_USESSL"
-      --metrics.prefix string          prefix in metrics names. Env "TAOS_KEEPER_METRICS_PREFIX"
-      --metrics.database.name string   database for storing metrics data. Env "TAOS_KEEPER_METRICS_DATABASE" (default "log")
-      --metrics.tables stringArray     export some tables that are not super table, multiple values split with white space. Env "TAOS_KEEPER_METRICS_TABLES"
-      --environment.incgroup           whether running in cgroup. Env "TAOS_KEEPER_ENVIRONMENT_INCGROUP"
-      --log.path string                log path. Env "TAOS_KEEPER_LOG_PATH" (default "/var/log/taos")
-      --log.rotationCount uint         log rotation count. Env "TAOS_KEEPER_LOG_ROTATION_COUNT" (default 5)
-      --log.rotationTime duration      log rotation time. Env "TAOS_KEEPER_LOG_ROTATION_TIME" (default 24h0m0s)
-      --log.rotationSize string        log rotation size(KB MB GB), must be a positive integer. Env "TAOS_KEEPER_LOG_ROTATION_SIZE" (default "100000000")
-  -c, --config string                  config path default /etc/taos/taoskeeper.toml
+      --transfer string                              run taoskeeper in command mode, only support old_taosd_metric. transfer old metrics data to new tables and exit
  -V, --version                                      Print the version and exit
-  -h, --help                           Print this help message and exit
 ```

-
-
 ### 配置文件

 taosKeeper 支持用 `taoskeeper -c <keeper config file>` 命令来指定配置文件。
@ -57,20 +68,18 @@ taosKeeper 支持用 `taoskeeper -c <keeper config file>` 命令来指定配置
 若既不指定 taosKeeper 配置文件，且 `/etc/taos/taoskeeper.toml` 也不存在，将使用默认配置。  

 **下面是配置文件的示例：**
-```toml
-# Start with debug middleware for gin
-debug = false

-# Listen port, default is 6043
+```toml
+# The ID of the currently running taoskeeper instance, default is 64.
+instanceId = 64
+
+# Listening port, default is 6043.
 port = 6043

-# log level
-loglevel = "info"
-
-# go pool size
+# Go pool size
 gopoolsize = 50000

-# interval for metrics
+# Interval for metrics
 RotationInterval = "15s"

 [tdengine]
@ -81,20 +90,21 @@ password = "taosdata"
 usessl = false

 [metrics]
-# metrics prefix in metrics names.
+# Metrics prefix in metrics names.
 prefix = "taos"

-# export some tables that are not super table
+# Export some tables that are not super table.
 tables = []

-# database for storing metrics data
+# Database for storing metrics data.
 [metrics.database]
 name = "log"
-# database options for db storing metrics data
+
+# Database options for db storing metrics data.
 [metrics.database.options]
 vgroups = 1
 buffer = 64
-KEEP = 90
+keep = 90
 cachemodel = "both"

 [environment]
@ -102,9 +112,19 @@ cachemodel = "both"
 incgroup = false

 [log]
-rotationCount = 5
-rotationTime = "24h"
-rotationSize = 100000000
+# The directory where log files are stored.
+# path = "/var/log/taos"
+level = "info"
+# Number of log file rotations before deletion.
+rotationCount = 30
+# The number of days to retain log files.
+keepDays = 30
+# The maximum size of a log file before rotation.
+rotationSize = "1GB"
+# If set to true, log files will be compressed.
+compress = false
+# Minimum disk space to reserve. Log files will not be written if disk space falls below this limit.
+reservedDiskSize = "1GB"
 ```

 ## 启动
@ -118,7 +138,6 @@ monitorFqdn localhost # taoskeeper 服务的 FQDN

 TDengine 监控配置相关，具体请参考：[TDengine 监控配置](../../../operation/monitor)。

-
 <Tabs>
 <TabItem label="Linux" value="linux">

@ -188,7 +207,6 @@ Active: inactive (dead)
 </TabItem>
 </Tabs>

-
 ## 健康检查

 可以访问 taosKeeper 的 `check_health` 接口来判断服务是否存活，如果服务正常则会返回 HTTP 200 状态码：
@ -208,7 +226,6 @@ Content-Length: 21
 {"version":"3.3.2.3"}
 ```

-
 ## 数据收集与监控

 taosKeeper 作为 TDengine 监控指标的导出工具，可以将 TDengine 产生的监控数据记录在指定数据库中（默认的监控数据是 `log`），这些监控数据可以用来配置 TDengine 监控。
@ -216,6 +233,7 @@ taosKeeper 作为 TDengine 监控指标的导出工具，可以将 TDengine 产
 ### 查看监控数据

 可以查看 `log` 库下的超级表，每个超级表都对应一组监控指标，具体指标不再赘述。
+
 ```shell
 taos> use log;
 Database changed.
@ -251,17 +269,14 @@ taos> select last_row(*) from taosd_dnodes_info;
 Query OK, 1 row(s) in set (0.003168s)
 ```

-
 ### 使用 TDInsight 配置监控

-收集到监控数据以后，就可以使用 TDInsight 来配置 TDengine 的监控，具体请参考 [TDinsight 参考手册](../tdinsight/) 
-
+收集到监控数据以后，就可以使用 TDInsight 来配置 TDengine 的监控，具体请参考 [TDinsight 参考手册](../tdinsight/)。

 ## 集成 Prometheus

 taoskeeper 提供了 `/metrics` 接口，返回了 Prometheus 格式的监控数据，Prometheus 可以从 taoskeeper 抽取监控数据，实现通过 Prometheus 监控 TDengine 的目的。

-
 ### 导出监控指标

 下面通过 `curl` 命令展示 `/metrics` 接口返回的数据格式：
@ -298,9 +313,11 @@ taos_cluster_info_first_ep_dnode_id{cluster_id="554014120921134497"} 1
 #### taosd 集群

 ##### 监控信息支持的标签
+
 - `cluster_id`： 集群 id

 ##### 相关指标及其含义
+
 | 指标名称                            | 类型    | 含义                                  |
 | ----------------------------------- | ------- | ------------------------------------- |
 | taos_cluster_info_connections_total | counter | 总连接数                              |
@ -328,11 +345,13 @@ taos_cluster_info_first_ep_dnode_id{cluster_id="554014120921134497"} 1
 #### dnode

 ##### 监控信息支持的标签
+
 - `cluster_id`： 集群 id
 - `dnode_ep`： dnode 端点
 - `dnode_id`：dnode id

 ##### 相关指标及其含义
+
 | 指标名称                       | 类型    | 含义                                                                                     |
 | ------------------------------ | ------- | ---------------------------------------------------------------------------------------- |
 | taos_d_info_status             | gauge   | dnode 状态，标签 value 表示状态， ready 表示正常， offline 表示下线， unknown 表示未知。 |
@ -361,6 +380,7 @@ taos_cluster_info_first_ep_dnode_id{cluster_id="554014120921134497"} 1
 #### 数据目录

 ##### 监控信息支持的标签
+
 - `cluster_id`： 集群 id
 - `dnode_ep`： dnode 端点
 - `dnode_id`：dnode id
@ -368,6 +388,7 @@ taos_cluster_info_first_ep_dnode_id{cluster_id="554014120921134497"} 1
 - `data_dir_level`：数据目录级别

 ##### 相关指标及其含义
+
 | 指标名称                          | 类型  | 含义                 |
 | --------------------------------- | ----- | -------------------- |
 | taos_taosd_dnodes_data_dirs_avail | gauge | 可用空间（单位 Byte) |
@ -377,12 +398,14 @@ taos_cluster_info_first_ep_dnode_id{cluster_id="554014120921134497"} 1
 #### 日志目录

 ##### 监控信息支持的标签
+
 - `cluster_id`： 集群 id
 - `dnode_ep`： dnode 端点
 - `dnode_id`：dnode id
 - `log_dir_name`：日志目录名

 ##### 相关指标及其含义
+
 | 指标名称                         | 类型  | 含义                 |
 | -------------------------------- | ----- | -------------------- |
 | taos_taosd_dnodes_log_dirs_avail | gauge | 可用空间（单位 Byte) |
@ -392,11 +415,13 @@ taos_cluster_info_first_ep_dnode_id{cluster_id="554014120921134497"} 1
 #### 日志数量

 ##### 监控信息支持的标签
+
 - `cluster_id`： 集群 id
 - `dnode_ep`： dnode 端点
 - `dnode_id`：dnode id

 ##### 相关指标及其含义
+
 | 指标名称               | 类型    | 含义         |
 | ---------------------- | ------- | ------------ |
 | taos_log_summary_debug | counter | 调试日志数量 |
@ -404,14 +429,15 @@ taos_cluster_info_first_ep_dnode_id{cluster_id="554014120921134497"} 1
 | taos_log_summary_info  | counter | 信息日志数量 |
 | taos_log_summary_trace | counter | 跟踪日志数量 |

-
 #### taosadapter

 ##### 监控信息支持的标签
+
 - `endpoint`：端点
 - `req_type`：请求类型，0 表示 rest，1 表示 websocket

 ##### 相关指标及其含义
+
 | 指标名称                               | 类型    | 含义                 |
 | -------------------------------------- | ------- | -------------------- |
 | taos_adapter_requests_fail             | counter | 失败的请求数         |
@ -433,9 +459,11 @@ taos_cluster_info_first_ep_dnode_id{cluster_id="554014120921134497"} 1
 #### taoskeeper

 ##### 监控信息支持的标签
+
 - `identify`： 节点 endpoint

 ##### 相关指标及其含义
+
 | 指标名称                | 类型  | 含义                                  |
 | ----------------------- | ----- | ------------------------------------- |
 | taos_keeper_monitor_cpu | gauge | taoskeeper CPU 使用率（取值范围 0~1） |
@ -444,6 +472,7 @@ taos_cluster_info_first_ep_dnode_id{cluster_id="554014120921134497"} 1
 #### 其他 taosd 集群监控项

 ##### taos_m_info_role
+
 - **标签**:
  - `cluster_id`: 集群 id
  - `mnode_ep`: mnode 端点
@ -453,6 +482,7 @@ taos_cluster_info_first_ep_dnode_id{cluster_id="554014120921134497"} 1
 - **含义**: mnode 角色

 ##### taos_taos_sql_req_count
+
 - **标签**:
  - `cluster_id`: 集群 id
  - `result`: 请求结果（取值范围： Success, Failed）
@ -462,6 +492,7 @@ taos_cluster_info_first_ep_dnode_id{cluster_id="554014120921134497"} 1
 - **含义**: SQL 请求数量

 ##### taos_taosd_sql_req_count
+
 - **标签**:
  - `cluster_id`: 集群 id
  - `dnode_ep`: dnode 端点
@ -474,6 +505,7 @@ taos_cluster_info_first_ep_dnode_id{cluster_id="554014120921134497"} 1
 - **含义**: SQL 请求数量

 ##### taos_taosd_vgroups_info_status
+
 - **标签**:
  - `cluster_id`: 集群 id
  - `database_name`: 数据库名称
@ -482,6 +514,7 @@ taos_cluster_info_first_ep_dnode_id{cluster_id="554014120921134497"} 1
 - **含义**: 虚拟组状态。 0 为 unsynced，表示没有leader选出；1 为 ready。

 ##### taos_taosd_vgroups_info_tables_num
+
 - **标签**:
  - `cluster_id`: 集群 id
  - `database_name`: 数据库名称
@ -490,6 +523,7 @@ taos_cluster_info_first_ep_dnode_id{cluster_id="554014120921134497"} 1
 - **含义**: 虚拟组表数量

 ##### taos_taosd_vnodes_info_role
+
 - **标签**:
  - `cluster_id`: 集群 id
  - `database_name`: 数据库名称
@ -499,7 +533,6 @@ taos_cluster_info_first_ep_dnode_id{cluster_id="554014120921134497"} 1
 - **类型**: gauge
 - **含义**: 虚拟节点角色
  
-
 ### 抽取配置

 Prometheus 提供了 `scrape_configs` 配置如何从 endpoint 抽取监控数据，通常只需要修改 `static_configs` 中的 targets 配置为 taoskeeper 的 endpoint 地址，更多配置信息请参考 [Prometheus 配置文档](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config)。
@ -521,8 +554,6 @@ scrape_configs:

 在 Grafana Dashboard 菜单点击 `import`，dashboard ID 填写 `18587`，点击 `Load` 按钮即可导入 `TaosKeeper Prometheus Dashboard for 3.x` dashboard。

-
-
 ## taosKeeper 监控指标

 taosKeeper 也会将自己采集的监控数据写入监控数据库，默认是 `log` 库，可以在 taoskeeper 配置文件中修改。
--- a/docs/zh/14-reference/03-taos-sql/02-database.md
+++ b/docs/zh/14-reference/03-taos-sql/02-database.md
@ -122,6 +122,7 @@ alter_database_option: {
  | KEEP value
  | WAL_RETENTION_PERIOD value
  | WAL_RETENTION_SIZE value
+  | MINROWS value
 }
 ```

--- a/docs/zh/14-reference/03-taos-sql/10-function.md
+++ b/docs/zh/14-reference/03-taos-sql/10-function.md
@ -1569,7 +1569,7 @@ COUNT({* | expr})
 ELAPSED(ts_primary_key [, time_unit])
 ```

-**功能说明**：elapsed函数表达了统计周期内连续的时间长度，和twa函数配合使用可以计算统计曲线下的面积。在通过INTERVAL子句指定窗口的情况下，统计在给定时间范围内的每个窗口内有数据覆盖的时间范围；如果没有INTERVAL子句，则返回整个给定时间范围内的有数据覆盖的时间范围。注意，ELAPSED返回的并不是时间范围的绝对值，而是绝对值除以time_unit所得到的单位个数。
+**功能说明**：elapsed 函数表达了统计周期内连续的时间长度，和 twa 函数配合使用可以计算统计曲线下的面积。在通过 INTERVAL 子句指定窗口的情况下，统计在给定时间范围内的每个窗口内有数据覆盖的时间范围；如果没有 INTERVAL 子句，则返回整个给定时间范围内的有数据覆盖的时间范围。注意，ELAPSED 返回的并不是时间范围的绝对值，而是绝对值除以 time_unit 所得到的单位个数。流计算仅在 FORCE_WINDOW_CLOSE 模式下支持该函数。

 **返回结果类型**：DOUBLE。

@ -1829,7 +1829,7 @@ ignore_null_values: {

 - INTERP 用于在指定时间断面获取指定列的记录值，如果该时间断面不存在符合条件的行数据，那么会根据 FILL 参数的设定进行插值。
 - INTERP 的输入数据为指定列的数据，可以通过条件语句（where 子句）来对原始列数据进行过滤，如果没有指定过滤条件则输入为全部数据。
- INTERP 需要同时与 RANGE，EVERY 和 FILL 关键字一起使用。
+- INTERP SQL 查询需要同时与 RANGE，EVERY 和 FILL 关键字一起使用；流计算不能使用 RANGE，需要 EVERY 和 FILL 关键字一起使用。
 - INTERP 的输出时间范围根据 RANGE(timestamp1, timestamp2) 字段来指定，需满足 timestamp1 \<= timestamp2。其中 timestamp1 为输出时间范围的起始值，即如果 timestamp1 时刻符合插值条件则 timestamp1 为输出的第一条记录，timestamp2 为输出时间范围的结束值，即输出的最后一条记录的 timestamp 不能大于 timestamp2。
 - INTERP 根据 EVERY(time_unit) 字段来确定输出时间范围内的结果条数，即从 timestamp1 开始每隔固定长度的时间（time_unit 值）进行插值，time_unit 可取值时间单位：1a(毫秒)，1s(秒)，1m(分)，1h(小时)，1d(天)，1w(周)。例如 EVERY(500a) 将对于指定数据每500毫秒间隔进行一次插值.
 - INTERP 根据 FILL 字段来决定在每个符合输出条件的时刻如何进行插值。关于 FILL 子句如何使用请参考 [FILL 子句](../distinguished/#fill-子句)
@ -2180,7 +2180,7 @@ STATEDURATION(expr, oper, val, unit)
 TWA(expr)
 ```

-**功能说明**：时间加权平均函数。统计表中某列在一段时间内的时间加权平均。对于存在复合主键的表的查询，若时间戳相同的数据存在多条，则只有对应的复合主键最小的数据参与运算。
+**功能说明**：时间加权平均函数。统计表中某列在一段时间内的时间加权平均。对于存在复合主键的表的查询，若时间戳相同的数据存在多条，则只有对应的复合主键最小的数据参与运算。流计算仅在 FORCE_WINDOW_CLOSE 模式下支持该函数。

 **返回数据类型**：DOUBLE。

--- a/docs/zh/14-reference/03-taos-sql/14-stream.md
+++ b/docs/zh/14-reference/03-taos-sql/14-stream.md
@ -143,13 +143,14 @@ SELECT * from information_schema.`ins_streams`;

 在创建流时，可以通过 TRIGGER 指令指定流式计算的触发模式。

-对于非窗口计算，流式计算的触发是实时的；对于窗口计算，目前提供 3 种触发模式，默认为 WINDOW_CLOSE：
+对于非窗口计算，流式计算的触发是实时的；对于窗口计算，目前提供 4 种触发模式，默认为 WINDOW_CLOSE：

 1. AT_ONCE：写入立即触发

 2. WINDOW_CLOSE：窗口关闭时触发（窗口关闭由事件时间决定，可配合 watermark 使用）

 3. MAX_DELAY time：若窗口关闭，则触发计算。若窗口未关闭，且未关闭时长超过 max delay 指定的时间，则触发计算。
+4. FORCE_WINDOW_CLOSE：以操作系统当前时间为准，只计算当前关闭窗口的结果，并推送出去。窗口只会在被关闭的时刻计算一次，后续不会再重复计算。该模式当前只支持 INTERVAL 窗口（不支持滑动）；FILL_HISTORY 必须为 0，IGNORE EXPIRED 必须为 1，IGNORE UPDATE 必须为 1；FILL 只支持 PREV 、NULL、NONE、VALUE。

 由于窗口关闭是由事件时间决定的，如事件流中断、或持续延迟，则事件时间无法更新，可能导致无法得到最新的计算结果。

--- a/include/client/taos.h
+++ b/include/client/taos.h
@ -81,6 +81,13 @@ typedef enum {
  TSDB_SML_TIMESTAMP_NANO_SECONDS,
 } TSDB_SML_TIMESTAMP_TYPE;

+typedef enum TAOS_FIELD_T {
+  TAOS_FIELD_COL = 1,
+  TAOS_FIELD_TAG,
+  TAOS_FIELD_QUERY,
+  TAOS_FIELD_TBNAME,
+} TAOS_FIELD_T;
+
 typedef struct taosField {
  char    name[65];
  int8_t  type;
@ -95,6 +102,15 @@ typedef struct TAOS_FIELD_E {
  int32_t bytes;
 } TAOS_FIELD_E;

+typedef struct TAOS_FIELD_STB {
+  char         name[65];
+  int8_t       type;
+  uint8_t      precision;
+  uint8_t      scale;
+  int32_t      bytes;
+  TAOS_FIELD_T field_type;
+} TAOS_FIELD_STB;
+
 #ifdef WINDOWS
 #define DLL_EXPORT __declspec(dllexport)
 #else
@ -195,13 +211,6 @@ DLL_EXPORT int       taos_stmt_affected_rows_once(TAOS_STMT *stmt);

 typedef void TAOS_STMT2;

-typedef enum TAOS_FIELD_T {
-  TAOS_FIELD_COL = 1,
-  TAOS_FIELD_TAG,
-  TAOS_FIELD_QUERY,
-  TAOS_FIELD_TBNAME,
-} TAOS_FIELD_T;
-
 typedef struct TAOS_STMT2_OPTION {
  int64_t           reqid;
  bool              singleStbInsert;
@ -232,7 +241,9 @@ DLL_EXPORT int         taos_stmt2_exec(TAOS_STMT2 *stmt, int *affected_rows);
 DLL_EXPORT int         taos_stmt2_close(TAOS_STMT2 *stmt);
 DLL_EXPORT int         taos_stmt2_is_insert(TAOS_STMT2 *stmt, int *insert);
 DLL_EXPORT int  taos_stmt2_get_fields(TAOS_STMT2 *stmt, TAOS_FIELD_T field_type, int *count, TAOS_FIELD_E **fields);
+DLL_EXPORT int  taos_stmt2_get_stb_fields(TAOS_STMT2 *stmt, int *count, TAOS_FIELD_STB **fields);
 DLL_EXPORT void taos_stmt2_free_fields(TAOS_STMT2 *stmt, TAOS_FIELD_E *fields);
+DLL_EXPORT void taos_stmt2_free_stb_fields(TAOS_STMT2 *stmt, TAOS_FIELD_STB *fields);
 DLL_EXPORT TAOS_RES *taos_stmt2_result(TAOS_STMT2 *stmt);
 DLL_EXPORT char     *taos_stmt2_error(TAOS_STMT2 *stmt);

--- a/include/common/tanalytics.h
+++ b/include/common/tanalytics.h
@ -36,7 +36,7 @@ typedef struct {
  int32_t       anode;
  int32_t       urlLen;
  char         *url;
-} SAnalUrl;
+} SAnalyticsUrl;

 typedef enum {
  ANAL_BUF_TYPE_JSON = 0,
@ -53,18 +53,18 @@ typedef struct {
  TdFilePtr filePtr;
  char      fileName[TSDB_FILENAME_LEN + 10];
  int64_t   numOfRows;
-} SAnalColBuf;
+} SAnalyticsColBuf;

 typedef struct {
  EAnalBufType bufType;
  TdFilePtr    filePtr;
  char         fileName[TSDB_FILENAME_LEN];
  int32_t      numOfCols;
-  SAnalColBuf *pCols;
+  SAnalyticsColBuf *pCols;
 } SAnalBuf;

-int32_t taosAnalInit();
-void    taosAnalCleanup();
+int32_t taosAnalyticsInit();
+void    taosAnalyticsCleanup();
 SJson  *taosAnalSendReqRetJson(const char *url, EAnalHttpType type, SAnalBuf *pBuf);

 int32_t taosAnalGetAlgoUrl(const char *algoName, EAnalAlgoType type, char *url, int32_t urlLen);
--- a/include/common/tcommon.h
+++ b/include/common/tcommon.h
@ -154,6 +154,7 @@ typedef enum EStreamType {
  STREAM_TRANS_STATE,
  STREAM_MID_RETRIEVE,
  STREAM_PARTITION_DELETE_DATA,
+  STREAM_GET_RESULT,
 } EStreamType;

 #pragma pack(push, 1)
@ -383,6 +384,10 @@ typedef struct STUidTagInfo {
 #define TABLE_NAME_COLUMN_INDEX         6
 #define PRIMARY_KEY_COLUMN_INDEX        7

+//steam get result block column
+#define DATA_TS_COLUMN_INDEX            0
+#define DATA_VERSION_COLUMN_INDEX       1
+
 // stream create table block column
 #define UD_TABLE_NAME_COLUMN_INDEX 0
 #define UD_GROUPID_COLUMN_INDEX    1
--- a/include/common/tdatablock.h
+++ b/include/common/tdatablock.h
@ -189,7 +189,12 @@ static FORCE_INLINE void colDataSetDouble(SColumnInfoData* pColumnInfoData, uint

 int32_t getJsonValueLen(const char* data);

+// For the VAR_DATA_TYPE type, new data is inserted strictly according to the position of SVarColAttr.length.
+// If the same row is inserted repeatedly, data holes will result.
 int32_t colDataSetVal(SColumnInfoData* pColumnInfoData, uint32_t rowIndex, const char* pData, bool isNull);
+// For the VAR_DATA_TYPE type, if a row already has data before inserting it (judged by offset != -1),
+// it will be inserted at the original position and the old data will be overwritten.
+int32_t colDataSetValOrCover(SColumnInfoData* pColumnInfoData, uint32_t rowIndex, const char* pData, bool isNull);
 int32_t colDataReassignVal(SColumnInfoData* pColumnInfoData, uint32_t dstRowIdx, uint32_t srcRowIdx, const char* pData);
 int32_t colDataSetNItems(SColumnInfoData* pColumnInfoData, uint32_t rowIndex, const char* pData, uint32_t numOfRows,
                         bool trimValue);
@ -233,7 +238,7 @@ int32_t blockDataSort(SSDataBlock* pDataBlock, SArray* pOrderInfo);
 * @brief find how many rows already in order start from first row
 */
 int32_t blockDataGetSortedRows(SSDataBlock* pDataBlock, SArray* pOrderInfo);
-void    blockDataCheck(const SSDataBlock* pDataBlock, bool forceChk);
+int32_t blockDataCheck(const SSDataBlock* pDataBlock);

 int32_t colInfoDataEnsureCapacity(SColumnInfoData* pColumn, uint32_t numOfRows, bool clearPayload);
 int32_t blockDataEnsureCapacity(SSDataBlock* pDataBlock, uint32_t numOfRows);
@ -266,7 +271,7 @@ SColumnInfoData createColumnInfoData(int16_t type, int32_t bytes, int16_t colId)
 int32_t         bdGetColumnInfoData(const SSDataBlock* pBlock, int32_t index, SColumnInfoData** pColInfoData);

 int32_t blockGetEncodeSize(const SSDataBlock* pBlock);
-int32_t blockEncode(const SSDataBlock* pBlock, char* data, int32_t numOfCols);
+int32_t blockEncode(const SSDataBlock* pBlock, char* data, size_t dataLen, int32_t numOfCols);
 int32_t blockDecode(SSDataBlock* pBlock, const char* pData, const char** pEndPos);

 // for debug
--- a/include/common/tglobal.h
+++ b/include/common/tglobal.h
@ -142,6 +142,7 @@ extern bool     tsMonitorForceV2;
 // audit
 extern bool    tsEnableAudit;
 extern bool    tsEnableAuditCreateTable;
+extern bool    tsEnableAuditDelete;
 extern int32_t tsAuditInterval;

 // telem
@ -153,6 +154,12 @@ extern bool     tsEnableCrashReport;
 extern char    *tsTelemUri;
 extern char    *tsClientCrashReportUri;
 extern char    *tsSvrCrashReportUri;
+extern int8_t  tsSafetyCheckLevel;
+enum {
+  TSDB_SAFETY_CHECK_LEVELL_NEVER = 0,
+  TSDB_SAFETY_CHECK_LEVELL_NORMAL = 1,
+  TSDB_SAFETY_CHECK_LEVELL_BYROW = 2,
+};

 // query buffer management
 extern int32_t tsQueryBufferSize;  // maximum allowed usage buffer size in MB for each data node during query processing
@ -193,10 +200,10 @@ extern int32_t tsMinIntervalTime;
 extern int32_t tsMaxInsertBatchRows;

 // build info
-extern char version[];
-extern char compatible_version[];
-extern char gitinfo[];
-extern char buildinfo[];
+extern char td_version[];
+extern char td_compatible_version[];
+extern char td_gitinfo[];
+extern char td_buildinfo[];

 // lossy
 extern char     tsLossyColumns[];
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@ -467,9 +467,11 @@ typedef enum ENodeType {
  QUERY_NODE_PHYSICAL_PLAN_MERGE_COUNT,
  QUERY_NODE_PHYSICAL_PLAN_STREAM_COUNT,
  QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_CONTINUE_INTERVAL,
  QUERY_NODE_PHYSICAL_PLAN_MERGE_ANOMALY,
  QUERY_NODE_PHYSICAL_PLAN_STREAM_ANOMALY,
  QUERY_NODE_PHYSICAL_PLAN_FORECAST_FUNC,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERP_FUNC,
 } ENodeType;

 typedef struct {
@ -1022,6 +1024,7 @@ typedef struct {
  char          sDetailVer[128];
  int64_t       whiteListVer;
  SMonitorParas monitorParas;
+  int8_t        enableAuditDelete;
 } SConnectRsp;

 int32_t tSerializeSConnectRsp(void* buf, int32_t bufLen, SConnectRsp* pRsp);
@ -1215,6 +1218,7 @@ typedef struct {
  int32_t bytes;
  int8_t  type;
  uint8_t pk;
+  bool    noData;
 } SColumnInfo;

 typedef struct STimeWindow {
@ -1826,6 +1830,17 @@ int32_t tSerializeSStatisReq(void* buf, int32_t bufLen, SStatisReq* pReq);
 int32_t tDeserializeSStatisReq(void* buf, int32_t bufLen, SStatisReq* pReq);
 void    tFreeSStatisReq(SStatisReq* pReq);

+typedef struct {
+  char    db[TSDB_DB_FNAME_LEN];
+  char    table[TSDB_TABLE_NAME_LEN];
+  char    operation[AUDIT_OPERATION_LEN];
+  int32_t sqlLen;
+  char*   pSql;
+} SAuditReq;
+int32_t tSerializeSAuditReq(void* buf, int32_t bufLen, SAuditReq* pReq);
+int32_t tDeserializeSAuditReq(void* buf, int32_t bufLen, SAuditReq* pReq);
+void    tFreeSAuditReq(SAuditReq* pReq);
+
 typedef struct {
  int32_t dnodeId;
  int64_t clusterId;
@ -2817,6 +2832,8 @@ typedef struct {
 #define STREAM_TRIGGER_AT_ONCE            1
 #define STREAM_TRIGGER_WINDOW_CLOSE       2
 #define STREAM_TRIGGER_MAX_DELAY          3
+#define STREAM_TRIGGER_FORCE_WINDOW_CLOSE 4
+
 #define STREAM_DEFAULT_IGNORE_EXPIRED 1
 #define STREAM_FILL_HISTORY_ON        1
 #define STREAM_FILL_HISTORY_OFF       0
@ -3414,6 +3431,7 @@ typedef struct {
  int32_t       svrTimestamp;
  SArray*       rsps;  // SArray<SClientHbRsp>
  SMonitorParas monitorParas;
+  int8_t        enableAuditDelete;
 } SClientHbBatchRsp;

 static FORCE_INLINE uint32_t hbKeyHashFunc(const char* key, uint32_t keyLen) { return taosIntHash_64(key, keyLen); }
--- a/include/common/tmsgdef.h
+++ b/include/common/tmsgdef.h
@ -259,6 +259,7 @@
  TD_DEF_MSG_TYPE(TDMT_MND_STREAM_DROP_ORPHANTASKS, "stream-drop-orphan-tasks", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_MND_STREAM_TASK_RESET, "stream-reset-tasks", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_MND_UPDATE_DNODE_INFO, "update-dnode-info", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_AUDIT, "audit", NULL, NULL)
  TD_CLOSE_MSG_SEG(TDMT_END_MND_MSG)

  TD_NEW_MSG_SEG(TDMT_VND_MSG)  // 2<<8
--- a/include/common/ttokendef.h
+++ b/include/common/ttokendef.h
@ -16,394 +16,7 @@
 #ifndef _TD_COMMON_TOKEN_H_
 #define _TD_COMMON_TOKEN_H_

-#define TK_OR                   1
-#define TK_AND                  2
-#define TK_UNION                3
-#define TK_ALL                  4
-#define TK_MINUS                5
-#define TK_EXCEPT               6
-#define TK_INTERSECT            7
-#define TK_NK_BITAND            8
-#define TK_NK_BITOR             9
-#define TK_NK_LSHIFT            10
-#define TK_NK_RSHIFT            11
-#define TK_NK_PLUS              12
-#define TK_NK_MINUS             13
-#define TK_NK_STAR              14
-#define TK_NK_SLASH             15
-#define TK_NK_REM               16
-#define TK_NK_CONCAT            17
-#define TK_CREATE               18
-#define TK_ACCOUNT              19
-#define TK_NK_ID                20
-#define TK_PASS                 21
-#define TK_NK_STRING            22
-#define TK_ALTER                23
-#define TK_PPS                  24
-#define TK_TSERIES              25
-#define TK_STORAGE              26
-#define TK_STREAMS              27
-#define TK_QTIME                28
-#define TK_DBS                  29
-#define TK_USERS                30
-#define TK_CONNS                31
-#define TK_STATE                32
-#define TK_NK_COMMA             33
-#define TK_HOST                 34
-#define TK_IS_IMPORT            35
-#define TK_NK_INTEGER           36
-#define TK_CREATEDB             37
-#define TK_USER                 38
-#define TK_ENABLE               39
-#define TK_SYSINFO              40
-#define TK_ADD                  41
-#define TK_DROP                 42
-#define TK_GRANT                43
-#define TK_ON                   44
-#define TK_TO                   45
-#define TK_REVOKE               46
-#define TK_FROM                 47
-#define TK_SUBSCRIBE            48
-#define TK_READ                 49
-#define TK_WRITE                50
-#define TK_NK_DOT               51
-#define TK_WITH                 52
-#define TK_ENCRYPT_KEY          53
-#define TK_ANODE                54
-#define TK_UPDATE               55
-#define TK_ANODES               56
-#define TK_DNODE                57
-#define TK_PORT                 58
-#define TK_DNODES               59
-#define TK_RESTORE              60
-#define TK_NK_IPTOKEN           61
-#define TK_FORCE                62
-#define TK_UNSAFE               63
-#define TK_CLUSTER              64
-#define TK_LOCAL                65
-#define TK_QNODE                66
-#define TK_BNODE                67
-#define TK_SNODE                68
-#define TK_MNODE                69
-#define TK_VNODE                70
-#define TK_DATABASE             71
-#define TK_USE                  72
-#define TK_FLUSH                73
-#define TK_TRIM                 74
-#define TK_S3MIGRATE            75
-#define TK_COMPACT              76
-#define TK_IF                   77
-#define TK_NOT                  78
-#define TK_EXISTS               79
-#define TK_BUFFER               80
-#define TK_CACHEMODEL           81
-#define TK_CACHESIZE            82
-#define TK_COMP                 83
-#define TK_DURATION             84
-#define TK_NK_VARIABLE          85
-#define TK_MAXROWS              86
-#define TK_MINROWS              87
-#define TK_KEEP                 88
-#define TK_PAGES                89
-#define TK_PAGESIZE             90
-#define TK_TSDB_PAGESIZE        91
-#define TK_PRECISION            92
-#define TK_REPLICA              93
-#define TK_VGROUPS              94
-#define TK_SINGLE_STABLE        95
-#define TK_RETENTIONS           96
-#define TK_SCHEMALESS           97
-#define TK_WAL_LEVEL            98
-#define TK_WAL_FSYNC_PERIOD     99
-#define TK_WAL_RETENTION_PERIOD 100
-#define TK_WAL_RETENTION_SIZE   101
-#define TK_WAL_ROLL_PERIOD      102
-#define TK_WAL_SEGMENT_SIZE     103
-#define TK_STT_TRIGGER          104
-#define TK_TABLE_PREFIX         105
-#define TK_TABLE_SUFFIX         106
-#define TK_S3_CHUNKPAGES        107
-#define TK_S3_KEEPLOCAL         108
-#define TK_S3_COMPACT           109
-#define TK_KEEP_TIME_OFFSET     110
-#define TK_ENCRYPT_ALGORITHM    111
-#define TK_NK_COLON             112
-#define TK_BWLIMIT              113
-#define TK_START                114
-#define TK_TIMESTAMP            115
-#define TK_END                  116
-#define TK_TABLE                117
-#define TK_NK_LP                118
-#define TK_NK_RP                119
-#define TK_USING                120
-#define TK_FILE                 121
-#define TK_STABLE               122
-#define TK_COLUMN               123
-#define TK_MODIFY               124
-#define TK_RENAME               125
-#define TK_TAG                  126
-#define TK_SET                  127
-#define TK_NK_EQ                128
-#define TK_TAGS                 129
-#define TK_BOOL                 130
-#define TK_TINYINT              131
-#define TK_SMALLINT             132
-#define TK_INT                  133
-#define TK_INTEGER              134
-#define TK_BIGINT               135
-#define TK_FLOAT                136
-#define TK_DOUBLE               137
-#define TK_BINARY               138
-#define TK_NCHAR                139
-#define TK_UNSIGNED             140
-#define TK_JSON                 141
-#define TK_VARCHAR              142
-#define TK_MEDIUMBLOB           143
-#define TK_BLOB                 144
-#define TK_VARBINARY            145
-#define TK_GEOMETRY             146
-#define TK_DECIMAL              147
-#define TK_COMMENT              148
-#define TK_MAX_DELAY            149
-#define TK_WATERMARK            150
-#define TK_ROLLUP               151
-#define TK_TTL                  152
-#define TK_SMA                  153
-#define TK_DELETE_MARK          154
-#define TK_FIRST                155
-#define TK_LAST                 156
-#define TK_SHOW                 157
-#define TK_FULL                 158
-#define TK_PRIVILEGES           159
-#define TK_DATABASES            160
-#define TK_TABLES               161
-#define TK_STABLES              162
-#define TK_MNODES               163
-#define TK_QNODES               164
-#define TK_ARBGROUPS            165
-#define TK_FUNCTIONS            166
-#define TK_INDEXES              167
-#define TK_ACCOUNTS             168
-#define TK_APPS                 169
-#define TK_CONNECTIONS          170
-#define TK_LICENCES             171
-#define TK_GRANTS               172
-#define TK_LOGS                 173
-#define TK_MACHINES             174
-#define TK_ENCRYPTIONS          175
-#define TK_QUERIES              176
-#define TK_SCORES               177
-#define TK_TOPICS               178
-#define TK_VARIABLES            179
-#define TK_BNODES               180
-#define TK_SNODES               181
-#define TK_TRANSACTIONS         182
-#define TK_DISTRIBUTED          183
-#define TK_CONSUMERS            184
-#define TK_SUBSCRIPTIONS        185
-#define TK_VNODES               186
-#define TK_ALIVE                187
-#define TK_VIEWS                188
-#define TK_VIEW                 189
-#define TK_COMPACTS             190
-#define TK_NORMAL               191
-#define TK_CHILD                192
-#define TK_LIKE                 193
-#define TK_TBNAME               194
-#define TK_QTAGS                195
-#define TK_AS                   196
-#define TK_SYSTEM               197
-#define TK_TSMA                 198
-#define TK_INTERVAL             199
-#define TK_RECURSIVE            200
-#define TK_TSMAS                201
-#define TK_FUNCTION             202
-#define TK_INDEX                203
-#define TK_COUNT                204
-#define TK_LAST_ROW             205
-#define TK_META                 206
-#define TK_ONLY                 207
-#define TK_TOPIC                208
-#define TK_CONSUMER             209
-#define TK_GROUP                210
-#define TK_DESC                 211
-#define TK_DESCRIBE             212
-#define TK_RESET                213
-#define TK_QUERY                214
-#define TK_CACHE                215
-#define TK_EXPLAIN              216
-#define TK_ANALYZE              217
-#define TK_VERBOSE              218
-#define TK_NK_BOOL              219
-#define TK_RATIO                220
-#define TK_NK_FLOAT             221
-#define TK_OUTPUTTYPE           222
-#define TK_AGGREGATE            223
-#define TK_BUFSIZE              224
-#define TK_LANGUAGE             225
-#define TK_REPLACE              226
-#define TK_STREAM               227
-#define TK_INTO                 228
-#define TK_PAUSE                229
-#define TK_RESUME               230
-#define TK_PRIMARY              231
-#define TK_KEY                  232
-#define TK_TRIGGER              233
-#define TK_AT_ONCE              234
-#define TK_WINDOW_CLOSE         235
-#define TK_IGNORE               236
-#define TK_EXPIRED              237
-#define TK_FILL_HISTORY         238
-#define TK_SUBTABLE             239
-#define TK_UNTREATED            240
-#define TK_KILL                 241
-#define TK_CONNECTION           242
-#define TK_TRANSACTION          243
-#define TK_BALANCE              244
-#define TK_VGROUP               245
-#define TK_LEADER               246
-#define TK_MERGE                247
-#define TK_REDISTRIBUTE         248
-#define TK_SPLIT                249
-#define TK_DELETE               250
-#define TK_INSERT               251
-#define TK_NK_BIN               252
-#define TK_NK_HEX               253
-#define TK_NULL                 254
-#define TK_NK_QUESTION          255
-#define TK_NK_ALIAS             256
-#define TK_NK_ARROW             257
-#define TK_ROWTS                258
-#define TK_QSTART               259
-#define TK_QEND                 260
-#define TK_QDURATION            261
-#define TK_WSTART               262
-#define TK_WEND                 263
-#define TK_WDURATION            264
-#define TK_IROWTS               265
-#define TK_ISFILLED             266
-#define TK_FLOW                 267
-#define TK_FHIGH                268
-#define TK_FROWTS               269
-#define TK_CAST                 270
-#define TK_POSITION             271
-#define TK_IN                   272
-#define TK_FOR                  273
-#define TK_NOW                  274
-#define TK_TODAY                275
-#define TK_RAND                 276
-#define TK_SUBSTR               277
-#define TK_SUBSTRING            278
-#define TK_BOTH                 279
-#define TK_TRAILING             280
-#define TK_LEADING              281
-#define TK_TIMEZONE             282
-#define TK_CLIENT_VERSION       283
-#define TK_SERVER_VERSION       284
-#define TK_SERVER_STATUS        285
-#define TK_CURRENT_USER         286
-#define TK_PI                   287
-#define TK_CASE                 288
-#define TK_WHEN                 289
-#define TK_THEN                 290
-#define TK_ELSE                 291
-#define TK_BETWEEN              292
-#define TK_IS                   293
-#define TK_NK_LT                294
-#define TK_NK_GT                295
-#define TK_NK_LE                296
-#define TK_NK_GE                297
-#define TK_NK_NE                298
-#define TK_MATCH                299
-#define TK_NMATCH               300
-#define TK_CONTAINS             301
-#define TK_JOIN                 302
-#define TK_INNER                303
-#define TK_LEFT                 304
-#define TK_RIGHT                305
-#define TK_OUTER                306
-#define TK_SEMI                 307
-#define TK_ANTI                 308
-#define TK_ASOF                 309
-#define TK_WINDOW               310
-#define TK_WINDOW_OFFSET        311
-#define TK_JLIMIT               312
-#define TK_SELECT               313
-#define TK_NK_HINT              314
-#define TK_DISTINCT             315
-#define TK_WHERE                316
-#define TK_PARTITION            317
-#define TK_BY                   318
-#define TK_SESSION              319
-#define TK_STATE_WINDOW         320
-#define TK_EVENT_WINDOW         321
-#define TK_COUNT_WINDOW         322
-#define TK_ANOMALY_WINDOW       323
-#define TK_SLIDING              324
-#define TK_FILL                 325
-#define TK_VALUE                326
-#define TK_VALUE_F              327
-#define TK_NONE                 328
-#define TK_PREV                 329
-#define TK_NULL_F               330
-#define TK_LINEAR               331
-#define TK_NEXT                 332
-#define TK_HAVING               333
-#define TK_RANGE                334
-#define TK_EVERY                335
-#define TK_ORDER                336
-#define TK_SLIMIT               337
-#define TK_SOFFSET              338
-#define TK_LIMIT                339
-#define TK_OFFSET               340
-#define TK_ASC                  341
-#define TK_NULLS                342
-#define TK_ABORT                343
-#define TK_AFTER                344
-#define TK_ATTACH               345
-#define TK_BEFORE               346
-#define TK_BEGIN                347
-#define TK_BITAND               348
-#define TK_BITNOT               349
-#define TK_BITOR                350
-#define TK_BLOCKS               351
-#define TK_CHANGE               352
-#define TK_COMMA                353
-#define TK_CONCAT               354
-#define TK_CONFLICT             355
-#define TK_COPY                 356
-#define TK_DEFERRED             357
-#define TK_DELIMITERS           358
-#define TK_DETACH               359
-#define TK_DIVIDE               360
-#define TK_DOT                  361
-#define TK_EACH                 362
-#define TK_FAIL                 363
-#define TK_GLOB                 364
-#define TK_ID                   365
-#define TK_IMMEDIATE            366
-#define TK_IMPORT               367
-#define TK_INITIALLY            368
-#define TK_INSTEAD              369
-#define TK_ISNULL               370
-#define TK_MODULES              371
-#define TK_NK_BITNOT            372
-#define TK_NK_SEMI              373
-#define TK_NOTNULL              374
-#define TK_OF                   375
-#define TK_PLUS                 376
-#define TK_PRIVILEGE            377
-#define TK_RAISE                378
-#define TK_RESTRICT             379
-#define TK_ROW                  380
-#define TK_STAR                 381
-#define TK_STATEMENT            382
-#define TK_STRICT               383
-#define TK_STRING               384
-#define TK_TIMES                385
-#define TK_VALUES               386
-#define TK_VARIABLE             387
-#define TK_WAL                  388
+#include "ttokenauto.h"

 #define TK_NK_SPACE   600
 #define TK_NK_COMMENT 601
--- a/include/common/ttypes.h
+++ b/include/common/ttypes.h
@ -298,6 +298,7 @@ typedef struct {
 #define IS_VALID_UINT64(_t)    ((_t) >= 0 && (_t) <= UINT64_MAX)
 #define IS_VALID_FLOAT(_t)     ((_t) >= -FLT_MAX && (_t) <= FLT_MAX)
 #define IS_VALID_DOUBLE(_t)    ((_t) >= -DBL_MAX && (_t) <= DBL_MAX)
+#define IS_INVALID_TYPE(_t)    ((_t) < TSDB_DATA_TYPE_NULL || (_t) >= TSDB_DATA_TYPE_MAX)

 #define IS_CONVERT_AS_SIGNED(_t) \
  (IS_SIGNED_NUMERIC_TYPE(_t) || (_t) == (TSDB_DATA_TYPE_BOOL) || (_t) == (TSDB_DATA_TYPE_TIMESTAMP))
--- a/include/libs/audit/audit.h
+++ b/include/libs/audit/audit.h
@ -29,7 +29,6 @@ extern "C" {
 #endif

 #define AUDIT_DETAIL_MAX 65472
-#define AUDIT_OPERATION_LEN 20

 typedef struct {
  const char *server;
--- a/include/libs/executor/executor.h
+++ b/include/libs/executor/executor.h
@ -222,8 +222,8 @@ int32_t qStreamSourceScanParamForHistoryScanStep2(qTaskInfo_t tinfo, SVersionRan
 int32_t qStreamRecoverFinish(qTaskInfo_t tinfo);
 bool    qStreamScanhistoryFinished(qTaskInfo_t tinfo);
 int32_t qStreamInfoResetTimewindowFilter(qTaskInfo_t tinfo);
-void    resetTaskInfo(qTaskInfo_t tinfo);
-
+void    qResetTaskInfoCode(qTaskInfo_t tinfo);
+int32_t qGetStreamIntervalExecInfo(qTaskInfo_t tinfo, int64_t* pWaterMark, SInterval* pInterval, STimeWindow* pLastWindow);
 int32_t qStreamOperatorReleaseState(qTaskInfo_t tInfo);
 int32_t qStreamOperatorReloadState(qTaskInfo_t tInfo);

--- a/include/libs/executor/storageapi.h
+++ b/include/libs/executor/storageapi.h
@ -41,6 +41,8 @@ extern "C" {

 #define STREAM_STATE_BUFF_HASH        1
 #define STREAM_STATE_BUFF_SORT        2
+#define STREAM_STATE_BUFF_HASH_SORT   3
+#define STREAM_STATE_BUFF_HASH_SEARCH 4

 typedef struct SMeta SMeta;
 typedef TSKEY (*GetTsFun)(void*);
@ -325,6 +327,9 @@ typedef struct {
  int64_t number;
  void*   pStreamFileState;
  int32_t buffIndex;
+  int32_t hashIter;
+  void*   pHashData;
+  int64_t minGpId;
 } SStreamStateCur;

 typedef struct SStateStore {
@ -337,6 +342,8 @@ typedef struct SStateStore {
  void (*streamStateReleaseBuf)(SStreamState* pState, void* pVal, bool used);
  void (*streamStateClearBuff)(SStreamState* pState, void* pVal);
  void (*streamStateFreeVal)(void* val);
+  int32_t (*streamStateGetPrev)(SStreamState* pState, const SWinKey* pKey, SWinKey* pResKey, void** pVal,
+                                int32_t* pVLen, int32_t* pWinCode);

  int32_t (*streamStatePut)(SStreamState* pState, const SWinKey* key, const void* value, int32_t vLen);
  int32_t (*streamStateGet)(SStreamState* pState, const SWinKey* key, void** pVal, int32_t* pVLen, int32_t* pWinCode);
@ -349,8 +356,15 @@ typedef struct SStateStore {
  int32_t (*streamStateGetInfo)(SStreamState* pState, void* pKey, int32_t keyLen, void** pVal, int32_t* pLen);

  int32_t (*streamStateFillPut)(SStreamState* pState, const SWinKey* key, const void* value, int32_t vLen);
-  int32_t (*streamStateFillGet)(SStreamState* pState, const SWinKey* key, void** pVal, int32_t* pVLen);
+  int32_t (*streamStateFillGet)(SStreamState* pState, const SWinKey* key, void** pVal, int32_t* pVLen,
+                                int32_t* pWinCode);
+  int32_t (*streamStateFillAddIfNotExist)(SStreamState* pState, const SWinKey* key, void** pVal, int32_t* pVLen,
+                                          int32_t* pWinCode);
  void (*streamStateFillDel)(SStreamState* pState, const SWinKey* key);
+  int32_t (*streamStateFillGetNext)(SStreamState* pState, const SWinKey* pKey, SWinKey* pResKey, void** pVal,
+                                    int32_t* pVLen, int32_t* pWinCode);
+  int32_t (*streamStateFillGetPrev)(SStreamState* pState, const SWinKey* pKey, SWinKey* pResKey, void** pVal,
+                                    int32_t* pVLen, int32_t* pWinCode);

  void (*streamStateCurNext)(SStreamState* pState, SStreamStateCur* pCur);
  void (*streamStateCurPrev)(SStreamState* pState, SStreamStateCur* pCur);
@ -361,9 +375,12 @@ typedef struct SStateStore {
  SStreamStateCur* (*streamStateFillSeekKeyPrev)(SStreamState* pState, const SWinKey* key);
  void (*streamStateFreeCur)(SStreamStateCur* pCur);

-  int32_t (*streamStateGetGroupKVByCur)(SStreamStateCur* pCur, SWinKey* pKey, const void** pVal, int32_t* pVLen);
+  int32_t (*streamStateFillGetGroupKVByCur)(SStreamStateCur* pCur, SWinKey* pKey, const void** pVal, int32_t* pVLen);
  int32_t (*streamStateGetKVByCur)(SStreamStateCur* pCur, SWinKey* pKey, const void** pVal, int32_t* pVLen);

+  void (*streamStateSetFillInfo)(SStreamState* pState);
+  void (*streamStateClearExpiredState)(SStreamState* pState);
+
  int32_t (*streamStateSessionAddIfNotExist)(SStreamState* pState, SSessionKey* key, TSKEY gap, void** pVal,
                                             int32_t* pVLen, int32_t* pWinCode);
  int32_t (*streamStateSessionPut)(SStreamState* pState, const SSessionKey* key, void* value, int32_t vLen);
@ -400,8 +417,8 @@ typedef struct SStateStore {
                             SUpdateInfo** ppInfo);
  void (*updateInfoAddCloseWindowSBF)(SUpdateInfo* pInfo);
  void (*updateInfoDestoryColseWinSBF)(SUpdateInfo* pInfo);
-  int32_t (*updateInfoSerialize)(void* buf, int32_t bufLen, const SUpdateInfo* pInfo, int32_t* pLen);
-  int32_t (*updateInfoDeserialize)(void* buf, int32_t bufLen, SUpdateInfo* pInfo);
+  int32_t (*updateInfoSerialize)(SEncoder* pEncoder, const SUpdateInfo* pInfo);
+  int32_t (*updateInfoDeserialize)(SDecoder* pDeCoder, SUpdateInfo* pInfo);

  SStreamStateCur* (*streamStateSessionSeekKeyNext)(SStreamState* pState, const SSessionKey* key);
  SStreamStateCur* (*streamStateCountSeekKeyPrev)(SStreamState* pState, const SSessionKey* pKey, COUNT_TYPE count);
@ -412,6 +429,11 @@ typedef struct SStateStore {
                                 GetTsFun fp, void* pFile, TSKEY delMark, const char* id, int64_t ckId, int8_t type,
                                 struct SStreamFileState** ppFileState);
  
+  int32_t (*streamStateGroupPut)(SStreamState* pState, int64_t groupId, void* value, int32_t vLen);
+  SStreamStateCur* (*streamStateGroupGetCur)(SStreamState* pState);
+  void (*streamStateGroupCurNext)(SStreamStateCur* pCur);
+  int32_t (*streamStateGroupGetKVByCur)(SStreamStateCur* pCur, int64_t* pKey, void** pVal, int32_t* pVLen);
+
  void (*streamFileStateDestroy)(struct SStreamFileState* pFileState);
  void (*streamFileStateClear)(struct SStreamFileState* pFileState);
  bool (*needClearDiskBuff)(struct SStreamFileState* pFileState);
--- a/include/libs/function/functionMgt.h
+++ b/include/libs/function/functionMgt.h
@ -292,6 +292,7 @@ bool fmIsElapsedFunc(int32_t funcId);

 void getLastCacheDataType(SDataType* pType, int32_t pkBytes);
 int32_t createFunction(const char* pName, SNodeList* pParameterList, SFunctionNode** pFunc);
+int32_t createFunctionWithSrcFunc(const char* pName, const SFunctionNode* pSrcFunc, SNodeList* pParameterList, SFunctionNode** pFunc);

 int32_t fmGetDistMethod(const SFunctionNode* pFunc, SFunctionNode** pPartialFunc, SFunctionNode** pMidFunc, SFunctionNode** pMergeFunc);

--- a/include/libs/monitor/clientMonitor.h
+++ b/include/libs/monitor/clientMonitor.h
@ -24,6 +24,7 @@ extern "C" {
 #include "thash.h"
 #include "query.h"
 #include "tqueue.h"
+#include "clientInt.h"

 typedef enum {
  SQL_RESULT_SUCCESS = 0,
@ -81,6 +82,8 @@ void            monitorCreateClientCounter(int64_t clusterId, const char* name,
 void            monitorCounterInc(int64_t clusterId, const char* counterName, const char** label_values);
 const char*     monitorResultStr(SQL_RESULT_CODE code);
 int32_t         monitorPutData2MonitorQueue(MonitorSlowLogData data);
+
+void            clientOperateReport(SRequestObj* pRequest);
 #ifdef __cplusplus
 }
 #endif
--- a/include/libs/nodes/plannodes.h
+++ b/include/libs/nodes/plannodes.h
@ -194,14 +194,26 @@ typedef struct SIndefRowsFuncLogicNode {
  bool       isTimeLineFunc;
 } SIndefRowsFuncLogicNode;

+typedef struct SStreamNodeOption {
+  int8_t  triggerType;
+  int64_t watermark;
+  int64_t deleteMark;
+  int8_t  igExpired;
+  int8_t  igCheckUpdate;
+  int8_t  destHasPrimaryKey;
+} SStreamNodeOption;
+
 typedef struct SInterpFuncLogicNode {
  SLogicNode    node;
  SNodeList*    pFuncs;
  STimeWindow   timeRange;
  int64_t       interval;
+  int8_t        intervalUnit;
+  int8_t        precision;
  EFillMode     fillMode;
  SNode*        pFillValues;  // SNodeListNode
  SNode*        pTimeSeries;  // SColumnNode
+  SStreamNodeOption streamNodeOption;
 } SInterpFuncLogicNode;

 typedef struct SForecastFuncLogicNode {
@ -511,11 +523,15 @@ typedef struct SInterpFuncPhysiNode {
  STimeWindow   timeRange;
  int64_t       interval;
  int8_t        intervalUnit;
+  int8_t        precision;
  EFillMode     fillMode;
  SNode*        pFillValues;  // SNodeListNode
  SNode*        pTimeSeries;  // SColumnNode
+  SStreamNodeOption streamNodeOption;
 } SInterpFuncPhysiNode;

+typedef SInterpFuncPhysiNode SStreamInterpFuncPhysiNode;
+
 typedef struct SForecastFuncPhysiNode {
  SPhysiNode node;
  SNodeList* pExprs;
@ -650,7 +666,7 @@ typedef struct SWindowPhysiNode {
  int64_t    watermark;
  int64_t    deleteMark;
  int8_t     igExpired;
-  int8_t     destHasPrimayKey;
+  int8_t     destHasPrimaryKey;
  bool       mergeDataBlock;
 } SWindowPhysiNode;

--- a/include/libs/nodes/querynodes.h
+++ b/include/libs/nodes/querynodes.h
@ -457,6 +457,7 @@ typedef struct SSelectStmt {
  bool          hasCountFunc;
  bool          hasUdaf;
  bool          hasStateKey;
+  bool          hasTwaOrElapsedFunc;
  bool          onlyHasKeepOrderFunc;
  bool          groupSort;
  bool          tagScan;
--- a/include/libs/parser/parser.h
+++ b/include/libs/parser/parser.h
@ -147,6 +147,7 @@ int32_t qBindStmtColsValue(void* pBlock, SArray* pCols, TAOS_MULTI_BIND* bind, c
 int32_t qBindStmtSingleColValue(void* pBlock, SArray* pCols, TAOS_MULTI_BIND* bind, char* msgBuf, int32_t msgBufLen,
                                int32_t colIdx, int32_t rowNum);
 int32_t qBuildStmtColFields(void* pDataBlock, int32_t* fieldNum, TAOS_FIELD_E** fields);
+int32_t qBuildStmtStbColFields(void* pBlock, int32_t* fieldNum, TAOS_FIELD_STB** fields);
 int32_t qBuildStmtTagFields(void* pBlock, void* boundTags, int32_t* fieldNum, TAOS_FIELD_E** fields);
 int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, const char* sTableName, char* tName,
                           TAOS_MULTI_BIND* bind, char* msgBuf, int32_t msgBufLen);
--- a/include/libs/scalar/scalar.h
+++ b/include/libs/scalar/scalar.h
@ -105,6 +105,7 @@ int32_t timeTruncateFunction(SScalarParam *pInput, int32_t inputNum, SScalarPara
 int32_t timeDiffFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 int32_t nowFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 int32_t todayFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t timeZoneStrLen();
 int32_t timezoneFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 int32_t weekdayFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 int32_t dayofweekFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
--- a/include/libs/stream/streamState.h
+++ b/include/libs/stream/streamState.h
@ -49,6 +49,8 @@ void    streamStateClear(SStreamState* pState);
 void    streamStateSetNumber(SStreamState* pState, int32_t number, int32_t tsIdex);
 void    streamStateSaveInfo(SStreamState* pState, void* pKey, int32_t keyLen, void* pVal, int32_t vLen);
 int32_t streamStateGetInfo(SStreamState* pState, void* pKey, int32_t keyLen, void** pVal, int32_t* pLen);
+int32_t streamStateGetPrev(SStreamState* pState, const SWinKey* pKey, SWinKey* pResKey, void** pVal, int32_t* pVLen,
+                           int32_t* pWinCode);

 // session window
 int32_t streamStateSessionAddIfNotExist(SStreamState* pState, SSessionKey* key, TSKEY gap, void** pVal, int32_t* pVLen,
@ -75,8 +77,14 @@ int32_t streamStateStateAddIfNotExist(SStreamState* pState, SSessionKey* key, ch

 // fill
 int32_t streamStateFillPut(SStreamState* pState, const SWinKey* key, const void* value, int32_t vLen);
-int32_t streamStateFillGet(SStreamState* pState, const SWinKey* key, void** pVal, int32_t* pVLen);
+int32_t streamStateFillGet(SStreamState* pState, const SWinKey* key, void** pVal, int32_t* pVLen, int32_t* pWinCode);
+int32_t streamStateFillAddIfNotExist(SStreamState* pState, const SWinKey* key, void** pVal, int32_t* pVLen,
+                                        int32_t* pWinCode);
 void    streamStateFillDel(SStreamState* pState, const SWinKey* key);
+int32_t streamStateFillGetNext(SStreamState* pState, const SWinKey* pKey, SWinKey* pResKey, void** pVal, int32_t* pVLen,
+                               int32_t* pWinCode);
+int32_t streamStateFillGetPrev(SStreamState* pState, const SWinKey* pKey, SWinKey* pResKey, void** pVal, int32_t* pVLen,
+                               int32_t* pWinCode);

 int32_t streamStateAddIfNotExist(SStreamState* pState, const SWinKey* key, void** pVal, int32_t* pVLen,
                                 int32_t* pWinCode);
@ -96,15 +104,25 @@ SStreamStateCur* streamStateFillSeekKeyPrev(SStreamState* pState, const SWinKey*
 void             streamStateFreeCur(SStreamStateCur* pCur);
 void             streamStateResetCur(SStreamStateCur* pCur);

-int32_t streamStateGetGroupKVByCur(SStreamStateCur* pCur, SWinKey* pKey, const void** pVal, int32_t* pVLen);
+int32_t streamStateFillGetGroupKVByCur(SStreamStateCur* pCur, SWinKey* pKey, const void** pVal, int32_t* pVLen);
 int32_t streamStateGetKVByCur(SStreamStateCur* pCur, SWinKey* pKey, const void** pVal, int32_t* pVLen);

+// twa
+void streamStateSetFillInfo(SStreamState* pState);
+void streamStateClearExpiredState(SStreamState* pState);
+
 void streamStateCurNext(SStreamState* pState, SStreamStateCur* pCur);
 void streamStateCurPrev(SStreamState* pState, SStreamStateCur* pCur);

 int32_t streamStatePutParName(SStreamState* pState, int64_t groupId, const char* tbname);
 int32_t streamStateGetParName(SStreamState* pState, int64_t groupId, void** pVal, bool onlyCache, int32_t* pWinCode);

+// group id
+int32_t streamStateGroupPut(SStreamState* pState, int64_t groupId, void* value, int32_t vLen);
+SStreamStateCur* streamStateGroupGetCur(SStreamState* pState);
+void streamStateGroupCurNext(SStreamStateCur* pCur);
+int32_t streamStateGroupGetKVByCur(SStreamStateCur* pCur, int64_t* pKey, void** pVal, int32_t* pVLen);
+
 void streamStateReloadInfo(SStreamState* pState, TSKEY ts);

 void streamStateCopyBackend(SStreamState* src, SStreamState* dst);
--- a/include/libs/stream/tstream.h
+++ b/include/libs/stream/tstream.h
@ -70,7 +70,8 @@ typedef struct SActiveCheckpointInfo SActiveCheckpointInfo;
 #define SSTREAM_TASK_NEED_CONVERT_VER     2
 #define SSTREAM_TASK_SUBTABLE_CHANGED_VER 3

-extern int32_t streamMetaId;
+extern int32_t streamMetaRefPool;
+extern int32_t streamTaskRefPool;

 enum {
  STREAM_STATUS__NORMAL = 0,
@ -113,7 +114,7 @@ enum {

 enum {
  TASK_TRIGGER_STATUS__INACTIVE = 1,
-  TASK_TRIGGER_STATUS__ACTIVE,
+  TASK_TRIGGER_STATUS__MAY_ACTIVE,
 };

 typedef enum {
@ -258,6 +259,7 @@ typedef struct STaskId {
 typedef struct SStreamTaskId {
  int64_t     streamId;
  int32_t     taskId;
+  int64_t     refId;
  const char* idStr;
 } SStreamTaskId;

@ -291,12 +293,12 @@ typedef struct SStreamStatus {
  int8_t           schedStatus;
  int8_t           statusBackup;
  int32_t          schedIdleTime;  // idle time before invoke again
-  int32_t          timerActive;    // timer is active
  int64_t          lastExecTs;     // last exec time stamp
  int32_t          inScanHistorySentinel;
-  bool             appendTranstateBlock;  // has append the transfer state data block already
+  bool             appendTranstateBlock;  // has appended the transfer state data block already
  bool             removeBackendFiles;    // remove backend files on disk when free stream tasks
  SConsenChkptInfo consenChkptInfo;
+  STimeWindow      latestForceWindow;     // latest generated time window, only valid in
 } SStreamStatus;

 typedef struct SDataRange {
@ -309,10 +311,12 @@ typedef struct SSTaskBasicInfo {
  SEpSet    epSet;
  SEpSet    mnodeEpset;  // mnode epset for send heartbeat
  int32_t   selfChildId;
-  int32_t totalLevel;
+  int32_t   trigger;
  int8_t    taskLevel;
  int8_t    fillHistory;      // is fill history task or not
  int64_t   delaySchedParam;  // in msec
+  int64_t   watermark;        // extracted from operators
+  SInterval interval;
 } SSTaskBasicInfo;

 typedef struct SStreamRetrieveReq SStreamRetrieveReq;
@ -454,7 +458,6 @@ struct SStreamTask {

  // the followings attributes don't be serialized
  SScanhistorySchedInfo schedHistoryInfo;
-  int32_t               refCnt;
  int32_t               transferStateAlignCnt;
  struct SStreamMeta*   pMeta;
  SSHashObj*            pNameMap;
@ -544,9 +547,10 @@ typedef struct STaskUpdateEntry {

 typedef int32_t (*__state_trans_user_fn)(SStreamTask*, void* param);

-int32_t tNewStreamTask(int64_t streamId, int8_t taskLevel, SEpSet* pEpset, bool fillHistory, int64_t triggerParam,
-                       SArray* pTaskList, bool hasFillhistory, int8_t subtableWithoutMd5, SStreamTask** pTask);
-void    tFreeStreamTask(SStreamTask* pTask);
+int32_t tNewStreamTask(int64_t streamId, int8_t taskLevel, SEpSet* pEpset, bool fillHistory, int32_t trigger,
+                       int64_t triggerParam, SArray* pTaskList, bool hasFillhistory, int8_t subtableWithoutMd5,
+                       SStreamTask** pTask);
+void    tFreeStreamTask(void* pTask);
 int32_t tEncodeStreamTask(SEncoder* pEncoder, const SStreamTask* pTask);
 int32_t tDecodeStreamTask(SDecoder* pDecoder, SStreamTask* pTask);
 int32_t streamTaskInit(SStreamTask* pTask, SStreamMeta* pMeta, SMsgCb* pMsgCb, int64_t ver);
@ -664,6 +668,8 @@ void             streamTaskResetStatus(SStreamTask* pTask);
 void             streamTaskSetStatusReady(SStreamTask* pTask);
 ETaskStatus      streamTaskGetPrevStatus(const SStreamTask* pTask);
 const char*      streamTaskGetExecType(int32_t type);
+int32_t          streamTaskAllocRefId(SStreamTask* pTask, int64_t** pRefId);
+void             streamTaskFreeRefId(int64_t* pRefId);

 bool streamTaskUpdateEpsetInfo(SStreamTask* pTask, SArray* pNodeList);
 void streamTaskResetUpstreamStageInfo(SStreamTask* pTask);
@ -752,16 +758,15 @@ int32_t streamMetaRegisterTask(SStreamMeta* pMeta, int64_t ver, SStreamTask* pTa
 int32_t streamMetaUnregisterTask(SStreamMeta* pMeta, int64_t streamId, int32_t taskId);
 int32_t streamMetaGetNumOfTasks(SStreamMeta* pMeta);
 int32_t streamMetaAcquireTaskNoLock(SStreamMeta* pMeta, int64_t streamId, int32_t taskId, SStreamTask** pTask);
+int32_t streamMetaAcquireTaskUnsafe(SStreamMeta* pMeta, STaskId* pId, SStreamTask** pTask);
 int32_t streamMetaAcquireTask(SStreamMeta* pMeta, int64_t streamId, int32_t taskId, SStreamTask** pTask);
 void    streamMetaReleaseTask(SStreamMeta* pMeta, SStreamTask* pTask);
-int32_t streamMetaAcquireOneTask(SStreamTask* pTask);
 void    streamMetaClear(SStreamMeta* pMeta);
 void    streamMetaInitBackend(SStreamMeta* pMeta);
 int32_t streamMetaCommit(SStreamMeta* pMeta);
 int64_t streamMetaGetLatestCheckpointId(SStreamMeta* pMeta);
 void    streamMetaNotifyClose(SStreamMeta* pMeta);
 void    streamMetaStartHb(SStreamMeta* pMeta);
-bool    streamMetaTaskInTimer(SStreamMeta* pMeta);
 int32_t streamMetaAddTaskLaunchResult(SStreamMeta* pMeta, int64_t streamId, int32_t taskId, int64_t startTs,
                                      int64_t endTs, bool ready);
 int32_t streamMetaInitStartInfo(STaskStartInfo* pStartInfo);
--- a/include/libs/stream/tstreamFileState.h
+++ b/include/libs/stream/tstreamFileState.h
@ -16,8 +16,6 @@
 #ifndef _STREAM_FILE_STATE_H_
 #define _STREAM_FILE_STATE_H_

-#include "os.h"
-
 #include "storageapi.h"
 #include "tarray.h"
 #include "tdef.h"
@ -37,7 +35,7 @@ typedef void (*_state_buff_cleanup_fn)(void* pRowBuff);
 typedef void* (*_state_buff_create_statekey_fn)(SRowBuffPos* pPos, int64_t num);

 typedef int32_t (*_state_file_remove_fn)(SStreamFileState* pFileState, const void* pKey);
-typedef int32_t (*_state_file_get_fn)(SStreamFileState* pFileState, void* pKey, void* data, int32_t* pDataLen);
+typedef int32_t (*_state_file_get_fn)(SStreamFileState* pFileState, void* pKey, void** data, int32_t* pDataLen);
 typedef int32_t (*_state_file_clear_fn)(SStreamState* pState);

 typedef int32_t (*_state_fun_get_fn)(SStreamFileState* pFileState, void* pKey, int32_t keyLen, void** pVal,
@ -45,6 +43,8 @@ typedef int32_t (*_state_fun_get_fn)(SStreamFileState* pFileState, void* pKey, i

 typedef int32_t (*range_cmpr_fn)(const SSessionKey* pWin1, const SSessionKey* pWin2);

+typedef int (*__session_compare_fn_t)(const void* pWin, const void* pDatas, int pos);
+
 int32_t streamFileStateInit(int64_t memSize, uint32_t keySize, uint32_t rowSize, uint32_t selectRowSize, GetTsFun fp,
                            void* pFile, TSKEY delMark, const char* taskId, int64_t checkpointId, int8_t type,
                            struct SStreamFileState** ppFileState);
@ -54,6 +54,8 @@ bool              needClearDiskBuff(SStreamFileState* pFileState);
 void              streamFileStateReleaseBuff(SStreamFileState* pFileState, SRowBuffPos* pPos, bool used);
 void              streamFileStateClearBuff(SStreamFileState* pFileState, SRowBuffPos* pPos);

+int32_t addRowBuffIfNotExist(SStreamFileState* pFileState, void* pKey, int32_t keyLen, void** pVal, int32_t* pVLen,
+                             int32_t* pWinCode);
 int32_t getRowBuff(SStreamFileState* pFileState, void* pKey, int32_t keyLen, void** pVal, int32_t* pVLen,
                   int32_t* pWinCode);
 void    deleteRowBuff(SStreamFileState* pFileState, const void* pKey, int32_t keyLen);
@ -71,9 +73,11 @@ int32_t streamFileStateGetSelectRowSize(SStreamFileState* pFileState);
 void    streamFileStateReloadInfo(SStreamFileState* pFileState, TSKEY ts);

 void*        getRowStateBuff(SStreamFileState* pFileState);
+void*        getSearchBuff(SStreamFileState* pFileState);
 void*        getStateFileStore(SStreamFileState* pFileState);
 bool         isDeteled(SStreamFileState* pFileState, TSKEY ts);
 bool         isFlushedState(SStreamFileState* pFileState, TSKEY ts, TSKEY gap);
+TSKEY        getFlushMark(SStreamFileState* pFileState);
 SRowBuffPos* getNewRowPosForWrite(SStreamFileState* pFileState);
 int32_t      getRowStateRowSize(SStreamFileState* pFileState);

@ -94,6 +98,7 @@ int32_t      recoverSesssion(SStreamFileState* pFileState, int64_t ckId);
 void sessionWinStateClear(SStreamFileState* pFileState);
 void sessionWinStateCleanup(void* pBuff);

+SStreamStateCur* createStateCursor(SStreamFileState* pFileState);
 SStreamStateCur* sessionWinStateSeekKeyCurrentPrev(SStreamFileState* pFileState, const SSessionKey* pWinKey);
 SStreamStateCur* sessionWinStateSeekKeyCurrentNext(SStreamFileState* pFileState, const SSessionKey* pWinKey);
 SStreamStateCur* sessionWinStateSeekKeyNext(SStreamFileState* pFileState, const SSessionKey* pWinKey);
@ -103,6 +108,8 @@ void             sessionWinStateMoveToNext(SStreamStateCur* pCur);
 int32_t          sessionWinStateGetKeyByRange(SStreamFileState* pFileState, const SSessionKey* key, SSessionKey* curKey,
                                              range_cmpr_fn cmpFn);

+int32_t binarySearch(void* keyList, int num, const void* key, __session_compare_fn_t cmpFn);
+
 // state window
 int32_t getStateWinResultBuff(SStreamFileState* pFileState, SSessionKey* key, char* pKeyData, int32_t keyDataLen,
                              state_key_cmpr_fn fn, void** pVal, int32_t* pVLen, int32_t* pWinCode);
@ -117,6 +124,34 @@ int32_t getSessionRowBuff(SStreamFileState* pFileState, void* pKey, int32_t keyL
                          int32_t* pWinCode);
 int32_t getFunctionRowBuff(SStreamFileState* pFileState, void* pKey, int32_t keyLen, void** pVal, int32_t* pVLen);

+// time slice
+int32_t getHashSortRowBuff(SStreamFileState* pFileState, const SWinKey* pKey, void** pVal, int32_t* pVLen,
+                           int32_t* pWinCode);
+int32_t hashSortFileGetFn(SStreamFileState* pFileState, void* pKey, void** data, int32_t* pDataLen);
+int32_t hashSortFileRemoveFn(SStreamFileState* pFileState, const void* pKey);
+void    clearSearchBuff(SStreamFileState* pFileState);
+int32_t getHashSortNextRow(SStreamFileState* pFileState, const SWinKey* pKey, SWinKey* pResKey, void** pVal,
+                           int32_t* pVLen, int32_t* pWinCode);
+int32_t getHashSortPrevRow(SStreamFileState* pFileState, const SWinKey* pKey, SWinKey* pResKey, void** ppVal,
+                           int32_t* pVLen, int32_t* pWinCode);
+int32_t recoverFillSnapshot(SStreamFileState* pFileState, int64_t ckId);
+void    deleteHashSortRowBuff(SStreamFileState* pFileState, const SWinKey* pKey);
+
+//group
+int32_t streamFileStateGroupPut(SStreamFileState* pFileState, int64_t groupId, void* value, int32_t vLen);
+void streamFileStateGroupCurNext(SStreamStateCur* pCur);
+int32_t streamFileStateGroupGetKVByCur(SStreamStateCur* pCur, int64_t* pKey, void** pVal, int32_t* pVLen);
+SSHashObj* getGroupIdCache(SStreamFileState* pFileState);
+int fillStateKeyCompare(const void* pWin1, const void* pDatas, int pos);
+int32_t getRowStatePrevRow(SStreamFileState* pFileState, const SWinKey* pKey, SWinKey* pResKey, void** ppVal,
+                           int32_t* pVLen, int32_t* pWinCode);
+int32_t addSearchItem(SStreamFileState* pFileState, SArray* pWinStates, const SWinKey* pKey);
+
+//twa
+void setFillInfo(SStreamFileState* pFileState);
+void clearExpiredState(SStreamFileState* pFileState);
+int32_t addArrayBuffIfNotExist(SSHashObj* pSearchBuff, uint64_t groupId, SArray** ppResStates);
+
 #ifdef __cplusplus
 }
 #endif
--- a/include/libs/stream/tstreamUpdate.h
+++ b/include/libs/stream/tstreamUpdate.h
@ -36,8 +36,8 @@ bool    updateInfoIsTableInserted(SUpdateInfo* pInfo, int64_t tbUid);
 void    updateInfoDestroy(SUpdateInfo* pInfo);
 void    updateInfoAddCloseWindowSBF(SUpdateInfo* pInfo);
 void    updateInfoDestoryColseWinSBF(SUpdateInfo* pInfo);
-int32_t updateInfoSerialize(void* buf, int32_t bufLen, const SUpdateInfo* pInfo, int32_t* pLen);
-int32_t updateInfoDeserialize(void* buf, int32_t bufLen, SUpdateInfo* pInfo);
+int32_t updateInfoSerialize(SEncoder* pEncoder, const SUpdateInfo* pInfo);
+int32_t updateInfoDeserialize(SDecoder* pDeCoder, SUpdateInfo* pInfo);
 void    windowSBfDelete(SUpdateInfo* pInfo, uint64_t count);
 int32_t windowSBfAdd(SUpdateInfo* pInfo, uint64_t count);
 bool    isIncrementalTimeStamp(SUpdateInfo* pInfo, uint64_t tableId, TSKEY ts, void* pPkVal, int32_t len);
--- a/include/util/taoserror.h
+++ b/include/util/taoserror.h
@ -208,6 +208,7 @@ int32_t  taosGetErrSize();
 #define TSDB_CODE_TSC_COMPRESS_PARAM_ERROR      TAOS_DEF_ERROR_CODE(0, 0X0233)
 #define TSDB_CODE_TSC_COMPRESS_LEVEL_ERROR      TAOS_DEF_ERROR_CODE(0, 0X0234)
 #define TSDB_CODE_TSC_FAIL_GENERATE_JSON        TAOS_DEF_ERROR_CODE(0, 0X0235)
+#define TSDB_CODE_TSC_STMT_BIND_NUMBER_ERROR    TAOS_DEF_ERROR_CODE(0, 0X0236)
 #define TSDB_CODE_TSC_INTERNAL_ERROR            TAOS_DEF_ERROR_CODE(0, 0X02FF)

 // mnode-common
--- a/include/util/tdef.h
+++ b/include/util/tdef.h
@ -653,6 +653,8 @@ enum { RAND_ERR_MEMORY = 1, RAND_ERR_FILE = 2, RAND_ERR_NETWORK = 4 };
 #define MONITOR_TAG_VALUE_LEN   300
 #define MONITOR_METRIC_NAME_LEN 100

+#define AUDIT_OPERATION_LEN 20
+
 typedef enum {
  ANAL_ALGO_TYPE_ANOMALY_DETECT = 0,
  ANAL_ALGO_TYPE_FORECAST = 1,
--- a/include/util/version.h
+++ b/include/util/version.h
@ -20,11 +20,11 @@
 extern "C" {
 #endif

-extern char version[];
-extern char compatible_version[];
-extern char gitinfo[];
-extern char gitinfoOfInternal[];
-extern char buildinfo[];
+extern char td_version[];
+extern char td_compatible_version[];
+extern char td_gitinfo[];
+extern char td_gitinfoOfInternal[];
+extern char td_buildinfo[];

 #ifdef __cplusplus
 }
--- a/packaging/delete_ref_lock.py
+++ b/packaging/delete_ref_lock.py
@ -0,0 +1,59 @@
+import subprocess
+import re
+
+# 执行 git fetch 命令并捕获输出
+def git_fetch():
+    result = subprocess.run(['git', 'fetch'], capture_output=True, text=True)
+    return result
+
+# 解析分支名称
+def parse_branch_name_type1(error_output):
+    # 使用正则表达式匹配 'is at' 前的分支名称
+    match = re.search(r"error: cannot lock ref '(refs/remotes/origin/[^']+)': is at", error_output)
+    if match:
+        return match.group(1)
+    return None
+
+# 解析第二种错误中的分支名称
+def parse_branch_name_type2(error_output):
+    # 使用正则表达式匹配 'exists' 前的第一个引号内的分支名称
+    match = re.search(r"'(refs/remotes/origin/[^']+)' exists;", error_output)
+    if match:
+        return match.group(1)
+    return None
+
+# 执行 git update-ref -d 命令
+def git_update_ref(branch_name):
+    if branch_name:
+        subprocess.run(['git', 'update-ref', '-d', f'{branch_name}'], check=True)
+
+# 解析错误类型并执行相应的修复操作
+def handle_error(error_output):
+    # 错误类型1：本地引用的提交ID与远程不一致
+    if "is at" in error_output and "but expected" in error_output:
+        branch_name = parse_branch_name_type1(error_output)
+        if branch_name:
+            print(f"Detected error type 1, attempting to delete ref for branch: {branch_name}")
+            git_update_ref(branch_name)
+        else:
+            print("Error parsing branch name for type 1.")
+    # 错误类型2：尝试创建新的远程引用时，本地已经存在同名的引用
+    elif "exists; cannot create" in error_output:
+        branch_name = parse_branch_name_type2(error_output)
+        if branch_name:
+            print(f"Detected error type 2, attempting to delete ref for branch: {branch_name}")
+            git_update_ref(branch_name)
+        else:
+            print("Error parsing branch name for type 2.")
+
+# 主函数
+def main():
+    fetch_result = git_fetch()
+    if fetch_result.returncode != 0:  # 如果 git fetch 命令失败
+        error_output = fetch_result.stderr
+        handle_error(error_output)
+    else:
+        print("Git fetch successful.")
+
+if __name__ == "__main__":
+    main()
--- a/packaging/smokeTest/assets/style.css
+++ b/packaging/smokeTest/assets/style.css
@ -0,0 +1,319 @@
+body {
+    font-family: Helvetica, Arial, sans-serif;
+    font-size: 12px;
+    /* do not increase min-width as some may use split screens */
+    min-width: 800px;
+    color: #999;
+  }
+  
+  h1 {
+    font-size: 24px;
+    color: black;
+  }
+  
+  h2 {
+    font-size: 16px;
+    color: black;
+  }
+  
+  p {
+    color: black;
+  }
+  
+  a {
+    color: #999;
+  }
+  
+  table {
+    border-collapse: collapse;
+  }
+  
+  /******************************
+   * SUMMARY INFORMATION
+   ******************************/
+  #environment td {
+    padding: 5px;
+    border: 1px solid #e6e6e6;
+    vertical-align: top;
+  }
+  #environment tr:nth-child(odd) {
+    background-color: #f6f6f6;
+  }
+  #environment ul {
+    margin: 0;
+    padding: 0 20px;
+  }
+  
+  /******************************
+   * TEST RESULT COLORS
+   ******************************/
+  span.passed,
+  .passed .col-result {
+    color: green;
+  }
+  
+  span.skipped,
+  span.xfailed,
+  span.rerun,
+  .skipped .col-result,
+  .xfailed .col-result,
+  .rerun .col-result {
+    color: orange;
+  }
+  
+  span.error,
+  span.failed,
+  span.xpassed,
+  .error .col-result,
+  .failed .col-result,
+  .xpassed .col-result {
+    color: red;
+  }
+  
+  .col-links__extra {
+    margin-right: 3px;
+  }
+  
+  /******************************
+   * RESULTS TABLE
+   *
+   * 1. Table Layout
+   * 2. Extra
+   * 3. Sorting items
+   *
+   ******************************/
+  /*------------------
+   * 1. Table Layout
+   *------------------*/
+  #results-table {
+    border: 1px solid #e6e6e6;
+    color: #999;
+    font-size: 12px;
+    width: 100%;
+  }
+  #results-table th,
+  #results-table td {
+    padding: 5px;
+    border: 1px solid #e6e6e6;
+    text-align: left;
+  }
+  #results-table th {
+    font-weight: bold;
+  }
+  
+  /*------------------
+   * 2. Extra
+   *------------------*/
+  .logwrapper {
+    max-height: 230px;
+    overflow-y: scroll;
+    background-color: #e6e6e6;
+  }
+  .logwrapper.expanded {
+    max-height: none;
+  }
+  .logwrapper.expanded .logexpander:after {
+    content: "collapse [-]";
+  }
+  .logwrapper .logexpander {
+    z-index: 1;
+    position: sticky;
+    top: 10px;
+    width: max-content;
+    border: 1px solid;
+    border-radius: 3px;
+    padding: 5px 7px;
+    margin: 10px 0 10px calc(100% - 80px);
+    cursor: pointer;
+    background-color: #e6e6e6;
+  }
+  .logwrapper .logexpander:after {
+    content: "expand [+]";
+  }
+  .logwrapper .logexpander:hover {
+    color: #000;
+    border-color: #000;
+  }
+  .logwrapper .log {
+    min-height: 40px;
+    position: relative;
+    top: -50px;
+    height: calc(100% + 50px);
+    border: 1px solid #e6e6e6;
+    color: black;
+    display: block;
+    font-family: "Courier New", Courier, monospace;
+    padding: 5px;
+    padding-right: 80px;
+    white-space: pre-wrap;
+  }
+  
+  div.media {
+    border: 1px solid #e6e6e6;
+    float: right;
+    height: 240px;
+    margin: 0 5px;
+    overflow: hidden;
+    width: 320px;
+  }
+  
+  .media-container {
+    display: grid;
+    grid-template-columns: 25px auto 25px;
+    align-items: center;
+    flex: 1 1;
+    overflow: hidden;
+    height: 200px;
+  }
+  
+  .media-container--fullscreen {
+    grid-template-columns: 0px auto 0px;
+  }
+  
+  .media-container__nav--right,
+  .media-container__nav--left {
+    text-align: center;
+    cursor: pointer;
+  }
+  
+  .media-container__viewport {
+    cursor: pointer;
+    text-align: center;
+    height: inherit;
+  }
+  .media-container__viewport img,
+  .media-container__viewport video {
+    object-fit: cover;
+    width: 100%;
+    max-height: 100%;
+  }
+  
+  .media__name,
+  .media__counter {
+    display: flex;
+    flex-direction: row;
+    justify-content: space-around;
+    flex: 0 0 25px;
+    align-items: center;
+  }
+  
+  .collapsible td:not(.col-links) {
+    cursor: pointer;
+  }
+  .collapsible td:not(.col-links):hover::after {
+    color: #bbb;
+    font-style: italic;
+    cursor: pointer;
+  }
+  
+  .col-result {
+    width: 130px;
+  }
+  .col-result:hover::after {
+    content: " (hide details)";
+  }
+  
+  .col-result.collapsed:hover::after {
+    content: " (show details)";
+  }
+  
+  #environment-header h2:hover::after {
+    content: " (hide details)";
+    color: #bbb;
+    font-style: italic;
+    cursor: pointer;
+    font-size: 12px;
+  }
+  
+  #environment-header.collapsed h2:hover::after {
+    content: " (show details)";
+    color: #bbb;
+    font-style: italic;
+    cursor: pointer;
+    font-size: 12px;
+  }
+  
+  /*------------------
+   * 3. Sorting items
+   *------------------*/
+  .sortable {
+    cursor: pointer;
+  }
+  .sortable.desc:after {
+    content: " ";
+    position: relative;
+    left: 5px;
+    bottom: -12.5px;
+    border: 10px solid #4caf50;
+    border-bottom: 0;
+    border-left-color: transparent;
+    border-right-color: transparent;
+  }
+  .sortable.asc:after {
+    content: " ";
+    position: relative;
+    left: 5px;
+    bottom: 12.5px;
+    border: 10px solid #4caf50;
+    border-top: 0;
+    border-left-color: transparent;
+    border-right-color: transparent;
+  }
+  
+  .hidden, .summary__reload__button.hidden {
+    display: none;
+  }
+  
+  .summary__data {
+    flex: 0 0 550px;
+  }
+  .summary__reload {
+    flex: 1 1;
+    display: flex;
+    justify-content: center;
+  }
+  .summary__reload__button {
+    flex: 0 0 300px;
+    display: flex;
+    color: white;
+    font-weight: bold;
+    background-color: #4caf50;
+    text-align: center;
+    justify-content: center;
+    align-items: center;
+    border-radius: 3px;
+    cursor: pointer;
+  }
+  .summary__reload__button:hover {
+    background-color: #46a049;
+  }
+  .summary__spacer {
+    flex: 0 0 550px;
+  }
+  
+  .controls {
+    display: flex;
+    justify-content: space-between;
+  }
+  
+  .filters,
+  .collapse {
+    display: flex;
+    align-items: center;
+  }
+  .filters button,
+  .collapse button {
+    color: #999;
+    border: none;
+    background: none;
+    cursor: pointer;
+    text-decoration: underline;
+  }
+  .filters button:hover,
+  .collapse button:hover {
+    color: #ccc;
+  }
+  
+  .filter__label {
+    margin-right: 10px;
+  }
--- a/packaging/smokeTest/conftest.py
+++ b/packaging/smokeTest/conftest.py
@ -0,0 +1,115 @@
+# conftest.py
+import pytest
+
+
+def pytest_addoption(parser):
+    parser.addoption(
+        "--verMode", default="enterprise", help="community or enterprise"
+    )
+    parser.addoption(
+        "--tVersion", default="3.3.2.6", help="the version of taos"
+    )
+    parser.addoption(
+        "--baseVersion", default="smoking", help="the path of nas"
+    )
+    parser.addoption(
+        "--sourcePath", default="nas", help="only support nas currently"
+    )
+
+
+
+
+# Collect the setup and teardown of each test case and their std information
+setup_stdout_info = {}
+teardown_stdout_info = {}
+
+
+@pytest.hookimpl(hookwrapper=True)
+def pytest_runtest_makereport(item, call):
+    outcome = yield
+    rep = outcome.get_result()
+
+    # Record the std of setup and teardown
+    if call.when == 'setup':
+        for i in rep.sections:
+            if i[0] == "Captured stdout setup":
+                if not setup_stdout_info:
+                    setup_stdout_info[item.nodeid] = i[1]
+    elif call.when == 'teardown':
+        for i in rep.sections:
+            if i[0] == "Captured stdout teardown":
+                teardown_stdout_info[item.nodeid] = i[1]
+
+
+# Insert setup and teardown's std in the summary section
+def pytest_html_results_summary(prefix, summary, postfix):
+    if setup_stdout_info or teardown_stdout_info:
+        rows = []
+
+        # Insert setup stdout
+        if setup_stdout_info:
+            for nodeid, stdout in setup_stdout_info.items():
+                html_content = '''
+                <tr>
+                    <td><b><span style="font-size: larger; color: black;">Setup:</span></b></td>
+                    <td colspan="4">
+                        <a href="#" id="toggleSetup">Show Setup</a>
+                        <div id="setupContent" class="collapsible-content" style="display: none; white-space: pre-wrap; margin-top: 5px;">
+                            <pre>{}</pre>
+                        </div>
+                    </td>
+                </tr>
+                '''.format(stdout.strip())
+
+                # 如果需要在 Python 脚本中生成 HTML，并使用 JavaScript 控制折叠内容的显示，可以这样做：
+
+                html_script = '''
+                <script>
+                document.getElementById('toggleSetup').addEventListener('click', function(event) {
+                    event.preventDefault();
+                    var setupContentDiv = document.getElementById('setupContent');
+                    setupContentDiv.style.display = setupContentDiv.style.display === 'none' ? 'block' : 'none';
+                    var buttonText = setupContentDiv.style.display === 'none' ? 'Show Setup' : 'Hide Setup';
+                    this.textContent = buttonText;
+                });
+                </script>
+                '''
+
+                # 输出完整的 HTML 代码
+                final_html = html_content + html_script
+                rows.append(final_html)
+                rows.append("<br>")
+        # Insert teardown stdout
+        if teardown_stdout_info:
+            for nodeid, stdout in teardown_stdout_info.items():
+                html_content = '''
+                    <tr>
+                        <td><b><span style="font-size: larger; color: black;">Teardown:</span></b></td>
+                        <td colspan="4">
+                            <a href="#" id="toggleTeardown">Show Teardown</a>
+                            <div id="teardownContent" class="collapsible-content" style="display: none; white-space: pre-wrap; margin-top: 5px;">
+                                <pre>{}</pre>
+                            </div>
+                        </td>
+                    </tr>
+                    '''.format(stdout.strip())
+
+                # 如果需要在 Python 脚本中生成 HTML，并使用 JavaScript 控制折叠内容的显示，可以这样做：
+
+                html_script = '''
+                    <script>
+                    document.getElementById('toggleTeardown').addEventListener('click', function(event) {
+                        event.preventDefault();
+                        var teardownContentDiv = document.getElementById('teardownContent');
+                        teardownContentDiv.style.display = teardownContentDiv.style.display === 'none' ? 'block' : 'none';
+                        var buttonText = teardownContentDiv.style.display === 'none' ? 'Show Teardown' : 'Hide Teardown';
+                        this.textContent = buttonText;
+                    });
+                    </script>
+                    '''
+
+                # 输出完整的 HTML 代码
+                final_html = html_content + html_script
+                rows.append(final_html)
+
+        prefix.extend(rows)
--- a/packaging/smokeTest/debRpmAutoInstall.sh
+++ b/packaging/smokeTest/debRpmAutoInstall.sh
@ -0,0 +1,15 @@
+#!/usr/bin/expect 
+set packageName [lindex $argv 0]
+set packageSuffix [lindex $argv 1]
+set timeout 30 
+if { ${packageSuffix} == "deb" } {
+    spawn  dpkg -i ${packageName}
+} elseif { ${packageSuffix} == "rpm"} {
+    spawn rpm -ivh ${packageName}
+}
+expect "*one:"
+send  "\r"
+expect "*skip:"
+send  "\r" 
+
+expect eof
--- a/packaging/smokeTest/getAndRunInstaller.bat
+++ b/packaging/smokeTest/getAndRunInstaller.bat
@ -0,0 +1,57 @@
+set baseVersion=%1%
+set version=%2%
+set verMode=%3%
+set sType=%4%
+echo %fileType%
+rem stop services
+if EXIST C:\TDengine (
+	if EXIST C:\TDengine\stop-all.bat (
+		call C:\TDengine\stop-all.bat /silent
+		echo "***************Stop taos services***************"
+	)
+	if exist C:\TDengine\unins000.exe (
+		call C:\TDengine\unins000.exe /silent
+		echo "***************uninstall TDengine***************"
+	)
+	rd /S /q C:\TDengine
+)
+if EXIST C:\ProDB (
+	if EXIST C:\ProDB\stop-all.bat (
+		call C:\ProDB\stop-all.bat /silent
+		echo "***************Stop taos services***************"
+	)
+	if exist C:\ProDB\unins000.exe (
+		call C:\ProDB\unins000.exe /silent
+		echo "***************uninstall TDengine***************"
+	)
+	rd /S /q C:\ProDB
+)
+if "%verMode%"=="enterprise" (
+    if "%sType%"=="client" (
+        set fileType=enterprise-client
+    ) else (
+        set fileType=enterprise
+    )
+) else (
+	set fileType=%sType%
+)
+
+if "%baseVersion%"=="ProDB" (
+    echo %fileType%
+    set installer=ProDB-%fileType%-%version%-Windows-x64.exe
+) else (
+    echo %fileType%
+    set installer=TDengine-%fileType%-%version%-Windows-x64.exe
+)
+
+if "%baseVersion%"=="ProDB" (
+    echo %installer%
+    scp root@192.168.1.213:/nas/OEM/ProDB/v%version%/%installer% C:\workspace
+) else (
+    echo %installer%
+    scp root@192.168.1.213:/nas/TDengine/%baseVersion%/v%version%/%verMode%/%installer% C:\workspace
+)
+
+echo "***************Finish installer transfer!***************"
+C:\workspace\%installer% /silent
+echo "***************Finish install!***************"
--- a/packaging/smokeTest/getAndRunInstaller.sh
+++ b/packaging/smokeTest/getAndRunInstaller.sh
@ -0,0 +1,325 @@
+#!/bin/sh
+
+
+function usage() {
+    echo "$0"
+    echo -e "\t -f test file type,server/client/tools/"
+    echo -e "\t -m pacakage version Type,community/enterprise"
+    echo -e "\t -l package type,lite or not"
+    echo -e "\t -c operation type,x64/arm64"
+    echo -e "\t -v pacakage version,3.0.1.7"
+    echo -e "\t -o pacakage version,3.0.1.7"
+    echo -e "\t -s source Path,web/nas"
+    echo -e "\t -t package Type,tar/rpm/deb"
+    echo -e "\t -h help"
+}
+
+
+#parameter
+scriptDir=$(dirname $(readlink -f $0))
+version="3.0.1.7"
+originversion="smoking"
+testFile="server"
+verMode="communtity"
+sourcePath="nas"
+cpuType="x64"
+lite="true"
+packageType="tar"
+subFile="package.tar.gz"
+while getopts "m:c:f:l:s:o:t:v:h" opt; do
+    case $opt in
+        m)
+            verMode=$OPTARG
+            ;;
+        v)
+            version=$OPTARG
+            ;;
+        f)
+            testFile=$OPTARG
+            ;;
+        l)
+            lite=$OPTARG
+            ;;
+        s)
+            sourcePath=$OPTARG
+            ;;
+        o)
+            originversion=$OPTARG
+            ;;
+        c)
+            cpuType=$OPTARG
+            ;;
+        t)
+            packageType=$OPTARG
+            ;;
+        h)
+            usage
+            exit 0
+            ;;
+        ?)
+            echo "Invalid option: -$OPTARG"
+            usage
+            exit 0
+            ;;
+    esac
+done
+
+systemType=`uname`
+if [ ${systemType} == "Darwin" ]; then
+    platform="macOS"
+else
+    platform="Linux"
+fi
+
+echo "testFile:${testFile},verMode:${verMode},lite:${lite},cpuType:${cpuType},packageType:${packageType},version-${version},originversion:${originversion},sourcePath:${sourcePath}"
+# Color setting
+RED='\033[41;30m'
+GREEN='\033[1;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[1;34m'
+GREEN_DARK='\033[0;32m'
+YELLOW_DARK='\033[0;33m'
+BLUE_DARK='\033[0;34m'
+GREEN_UNDERLINE='\033[4;32m'
+NC='\033[0m'
+if [ "${originversion}" = "ProDB" ]; then
+    TDengine="ProDB"
+else
+    TDengine="TDengine"
+fi
+if [[ ${verMode} = "enterprise" ]];then
+    prePackage="${TDengine}-enterprise"
+    if [[ ${testFile} = "client" ]];then
+        prePackage="${TDengine}-enterprise-${testFile}"
+    fi
+elif [ ${verMode} = "community" ];then
+    prePackage="${TDengine}-${testFile}"
+fi
+if [ ${lite} = "true" ];then
+    packageLite="-Lite"
+elif [ ${lite} = "false"  ];then
+    packageLite=""
+fi
+if [[ "$packageType" = "tar" ]] ;then
+    packageType="tar.gz"
+fi
+
+tdPath="${prePackage}-${version}"
+
+packageName="${tdPath}-${platform}-${cpuType}${packageLite}.${packageType}"
+
+if [ "$testFile" == "server" ] ;then
+    installCmd="install.sh"
+elif [ ${testFile} = "client" ];then
+    installCmd="install_client.sh"
+fi
+
+echo "tdPath:${tdPath},packageName:${packageName}}"
+cmdInstall() {
+command=$1
+if command -v ${command} ;then
+    echoColor YD  "${command} is already installed" 
+else 
+    if command -v apt ;then
+        apt-get install ${command} -y 
+    elif command -v yum ;then
+        yum -y install ${command} 
+        echoColor YD "you should install ${command} manually"
+    fi
+fi
+}
+
+echoColor() {
+    color=$1
+    command=$2
+    if [ ${color} = 'Y' ];then
+        echo -e  "${YELLOW}${command}${NC}"
+    elif [ ${color} = 'YD' ];then
+        echo -e  "${YELLOW_DARK}${command}${NC}"
+    elif [ ${color} = 'R' ];then
+        echo -e  "${RED}${command}${NC}"
+    elif [ ${color} = 'G' ];then
+        echo  -e  "${GREEN}${command}${NC}\r\n"
+    elif [ ${color} = 'B' ];then
+        echo  -e  "${BLUE}${command}${NC}"
+    elif [ ${color} = 'BD' ];then
+        echo  -e  "${BLUE_DARK}${command}${NC}"
+    fi
+}
+
+wgetFile() {
+
+    file=$1
+    versionPath=$2
+    sourceP=$3
+    nasServerIP="192.168.1.213"
+    if [ "${originversion}" = "ProDB" ]; then
+        packagePath="/nas/OEM/ProDB/v${versionPath}"
+    else
+        packagePath="/nas/TDengine/${originversion}/v${versionPath}/${verMode}"
+    fi
+    if [ -f  ${file}  ];then
+        echoColor  YD "${file} already exists ,it will delete it and download  it again "
+        # rm -rf ${file}
+    fi
+
+    if [[ ${sourceP} = 'web' ]];then
+        echoColor  BD "====download====:wget https://www.taosdata.com/assets-download/3.0/${file}"
+        wget https://www.taosdata.com/assets-download/3.0/${file}
+    elif [[ ${sourceP} = 'nas' ]];then
+        echoColor  BD "====download====:scp root@${nasServerIP}:${packagePath}/${file} ."
+        scp root@${nasServerIP}:${packagePath}/${file} .
+    fi
+}
+
+function newPath {
+
+buildPath=$1
+
+if [ ! -d ${buildPath} ] ;then
+    echoColor BD "mkdir -p ${buildPath}"
+    mkdir -p ${buildPath}
+else  
+    echoColor YD "${buildPath} already exists"
+fi
+
+}
+
+echoColor G "===== install basesoft ====="
+cmdInstall tree
+cmdInstall wget
+cmdInstall expect
+
+echoColor G "===== Uninstall all components of TDeingne ====="
+
+if command -v rmtaos ;then
+    echoColor YD "uninstall all components of TDeingne:rmtaos"
+    rmtaos
+else 
+     echoColor YD "os doesn't include TDengine"
+fi
+
+if [[ ${packageName} =~ "server" ]] ;then
+    echoColor BD " pkill -9 taosd "
+    pkill -9 taosd
+fi
+
+if command -v rmprodb ;then
+    echoColor YD "uninstall all components of TDeingne:rmprodb"
+    rmprodb
+else
+     echoColor YD "os doesn't include TDengine"
+fi
+
+if [[ ${packageName} =~ "server" ]] ;then
+    echoColor BD " pkill -9 prodbd "
+    pkill -9 prodbd
+fi
+
+echoColor G "===== new workroom path ====="
+installPath="/usr/local/src/packageTest"
+
+if [ ${systemType} == "Darwin" ]; then
+    installPath="${WORK_DIR}/packageTest"
+fi
+
+newPath ${installPath}
+
+#if [ -d ${installPath}/${tdPath} ] ;then
+#    echoColor BD "rm -rf ${installPath}/${tdPath}/*"
+#    rm -rf ${installPath}/${tdPath}/*
+#fi
+
+echoColor G "===== download  installPackage ====="
+cd ${installPath} && wgetFile ${packageName} ${version}  ${sourcePath}
+#cd  ${oriInstallPath}  && wgetFile ${originPackageName} ${originversion}   ${sourcePath}
+
+
+cd ${installPath}
+cp -r ${scriptDir}/debRpmAutoInstall.sh   . 
+
+packageSuffix=$(echo ${packageName}  | awk -F '.' '{print $NF}')
+
+
+if [ ! -f  debRpmAutoInstall.sh  ];then
+    echo '#!/usr/bin/expect ' >  debRpmAutoInstall.sh
+    echo 'set packageName [lindex $argv 0]' >>  debRpmAutoInstall.sh
+    echo 'set packageSuffix [lindex $argv 1]' >>  debRpmAutoInstall.sh
+    echo 'set timeout 30 ' >>  debRpmAutoInstall.sh
+    echo 'if { ${packageSuffix} == "deb" } {' >>  debRpmAutoInstall.sh
+    echo '    spawn  dpkg -i ${packageName} '  >>  debRpmAutoInstall.sh
+    echo '} elseif { ${packageSuffix} == "rpm"} {' >>  debRpmAutoInstall.sh
+    echo '    spawn rpm -ivh ${packageName}'  >>  debRpmAutoInstall.sh
+    echo '}' >>  debRpmAutoInstall.sh
+    echo 'expect "*one:"' >>  debRpmAutoInstall.sh
+    echo 'send  "\r"' >>  debRpmAutoInstall.sh
+    echo 'expect "*skip:"' >>  debRpmAutoInstall.sh
+    echo 'send  "\r" ' >>  debRpmAutoInstall.sh
+fi
+
+
+echoColor G "===== install Package ====="
+
+if [[ ${packageName} =~ "deb" ]];then
+    cd ${installPath}
+    dpkg -r taostools
+    dpkg -r tdengine
+    if [[ ${packageName} =~ "TDengine" ]];then
+        echoColor BD "./debRpmAutoInstall.sh ${packageName}  ${packageSuffix}" &&   chmod 755 debRpmAutoInstall.sh &&  ./debRpmAutoInstall.sh  ${packageName}  ${packageSuffix}
+    else
+        echoColor BD "dpkg  -i ${packageName}" &&   dpkg  -i ${packageName}
+    fi
+elif [[ ${packageName} =~ "rpm" ]];then
+    cd ${installPath}
+    sudo rpm -e tdengine
+    sudo rpm -e taostools
+    if [[ ${packageName} =~ "TDengine" ]];then
+        echoColor BD "./debRpmAutoInstall.sh ${packageName}  ${packageSuffix}" &&   chmod 755 debRpmAutoInstall.sh &&  ./debRpmAutoInstall.sh  ${packageName}  ${packageSuffix}
+    else
+        echoColor BD "rpm  -ivh ${packageName}" &&   rpm  -ivh ${packageName}
+    fi
+elif [[ ${packageName} =~ "tar" ]];then
+    echoColor G "===== check installPackage File of tar ====="
+
+    cd ${installPath} 
+    echoColor YD "unzip the new installation package" 
+    echoColor BD "tar -xf ${packageName}" && tar -xf ${packageName} 
+
+    cd ${installPath}/${tdPath}   && tree -I "driver" > ${installPath}/now_${version}_checkfile
+    
+    cd ${installPath} 
+    diff  ${installPath}/base_${originversion}_checkfile   ${installPath}/now_${version}_checkfile  > ${installPath}/diffFile.log
+    diffNumbers=`cat ${installPath}/diffFile.log |wc -l `
+
+    if [ ${diffNumbers} != 0 ];then
+        echoColor R "The number and names of files is different from the previous installation package"
+        diffLog=`cat ${installPath}/diffFile.log`
+        echoColor Y "${diffLog}"
+        exit -1
+    else 
+        echoColor G "The number and names of files are the same as previous installation packages"
+        rm -rf ${installPath}/diffFile.log
+    fi
+    echoColor YD  "===== install Package of tar ====="
+    cd ${installPath}/${tdPath}
+    if [ ${testFile} = "server" ];then
+        echoColor BD "bash ${installCmd}  -e no  "
+        bash ${installCmd}  -e no  
+    else
+        echoColor BD "bash ${installCmd} "
+        bash ${installCmd} 
+    fi
+elif [[ ${packageName} =~ "pkg" ]];then
+    cd ${installPath}
+    sudo installer -pkg ${packageName} -target /
+    echoColor YD  "===== install Package successfully! ====="
+fi  
+
+#cd ${installPath}
+#
+#rm -rf ${installPath}/${packageName}
+#if [ ${platform} == "Linux" ]; then
+#  rm -rf ${installPath}/${tdPath}/
+#fi
+echoColor YD  "===== end of shell file ====="
+
--- a/packaging/smokeTest/lib.py
+++ b/packaging/smokeTest/lib.py
@ -0,0 +1,12 @@
+
+import subprocess
+
+
+def run_cmd(command):
+    print("CMD:", command)
+    result = subprocess.run(command, capture_output=True, text=True, shell=True)
+    print("STDOUT:", result.stdout)
+    print("STDERR:", result.stderr)
+    print("Return Code:", result.returncode)
+    #assert result.returncode == 0
+    return result
--- a/packaging/smokeTest/main.py
+++ b/packaging/smokeTest/main.py
@ -0,0 +1,21 @@
+import pytest
+
+# python3 -m pytest test_server.py -v --html=/var/www/html/report.html --json-report --json-report-file="/var/www/html/report.json" --timeout=60
+
+# pytest.main(["-s", "-v"])
+import pytest
+
+import subprocess
+
+
+# define cmd function
+
+
+
+
+def main():
+    pytest.main(['--html=report.html'])
+
+
+if __name__ == '__main__':
+    main()
--- a/packaging/smokeTest/pytest_require.txt
+++ b/packaging/smokeTest/pytest_require.txt
@ -0,0 +1,17 @@
+pytest-html
+pytest-json-report
+pytest-timeout
+taospy
+numpy
+fabric2
+psutil
+pandas
+toml
+distro
+requests
+pexpect
+faker
+pyopenssl
+taos-ws-py
+taospy
+tzlocal
--- a/packaging/smokeTest/runCases.bat
+++ b/packaging/smokeTest/runCases.bat
@ -0,0 +1,11 @@
+rm -rf %WIN_TDENGINE_ROOT_DIR%\debug
+mkdir %WIN_TDENGINE_ROOT_DIR%\debug
+mkdir %WIN_TDENGINE_ROOT_DIR%\debug\build
+mkdir %WIN_TDENGINE_ROOT_DIR%\debug\build\bin
+xcopy C:\TDengine\taos*.exe %WIN_TDENGINE_ROOT_DIR%\debug\build\bin
+
+set case_out_file=%cd%\case.out
+
+cd %WIN_TDENGINE_ROOT_DIR%\tests\system-test
+python3 .\test.py -f 0-others\taosShell.py
+python3 .\test.py -f 6-cluster\5dnode3mnodeSep1VnodeStopDnodeModifyMeta.py  -N 6 -M 3
--- a/packaging/smokeTest/runCases.sh
+++ b/packaging/smokeTest/runCases.sh
@ -0,0 +1,29 @@
+#!/bin/bash
+ulimit -c unlimited
+
+rm -rf ${TDENGINE_ROOT_DIR}/debug
+mkdir ${TDENGINE_ROOT_DIR}/debug
+mkdir ${TDENGINE_ROOT_DIR}/debug/build
+mkdir ${TDENGINE_ROOT_DIR}/debug/build/bin
+
+systemType=`uname`
+if [ ${systemType} == "Darwin" ]; then
+    cp /usr/local/bin/taos*  ${TDENGINE_ROOT_DIR}/debug/build/bin/
+else
+    cp /usr/bin/taos*  ${TDENGINE_ROOT_DIR}/debug/build/bin/
+fi
+
+case_out_file=`pwd`/case.out
+python3 -m pip install -r ${TDENGINE_ROOT_DIR}/tests/requirements.txt >> $case_out_file
+python3 -m pip install taos-ws-py taospy >> $case_out_file
+
+cd ${TDENGINE_ROOT_DIR}/tests/army
+python3 ./test.py -f query/query_basic.py -N 3 >> $case_out_file
+
+cd ${TDENGINE_ROOT_DIR}/tests/system-test
+python3 ./test.py -f 1-insert/insert_column_value.py >> $case_out_file
+python3 ./test.py -f 2-query/primary_ts_base_5.py >> $case_out_file
+python3 ./test.py -f 2-query/case_when.py >> $case_out_file
+python3 ./test.py -f 2-query/partition_limit_interval.py >> $case_out_file
+python3 ./test.py -f 2-query/join.py >> $case_out_file
+python3 ./test.py -f 2-query/fill.py >> $case_out_file
--- a/packaging/smokeTest/smokeTestClient.py
+++ b/packaging/smokeTest/smokeTestClient.py
@ -0,0 +1,251 @@
+#!/usr/bin/python
+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+# install pip
+# pip install src/connector/python/
+
+# -*- coding: utf-8 -*-
+import sys, os
+import re
+import platform
+import getopt
+import subprocess
+# from this import d
+import time
+
+# input for server
+
+opts, args = getopt.gnu_getopt(sys.argv[1:], 'h:P:v:u', [
+        'host=', 'Port=', 'version='])
+serverHost = ""
+serverPort = 0
+version = ""
+uninstall = False
+for key, value in opts:
+    if key in ['--help']:
+        print('A collection of test cases written using Python')
+        print('-h serverHost')
+        print('-P serverPort')
+        print('-v test client version')
+        print('-u test uninstall process, will uninstall TDengine')
+        sys.exit(0)
+
+    if key in ['-h']:
+        serverHost = value
+    if key in ['-P']:
+        serverPort = int(value)
+    if key in ['-v']:
+        version = value
+    if key in ['-u']:
+        uninstall = True
+if not serverHost:
+    print("Please input use -h to specify your server host.")
+    sys.exit(0)
+if not version:
+    print("No version specified, will not run version check.")
+if serverPort == 0:
+    serverPort = 6030
+    print("No server port specified, use default 6030.")
+
+
+system = platform.system()
+
+arch = platform.machine()
+
+databaseName = re.sub(r'[^a-zA-Z0-9]', '', subprocess.getoutput("hostname")).lower()
+# install taospy
+taospy_version = ""
+if system == 'Windows':
+    taospy_version = subprocess.getoutput("pip3 show taospy|findstr Version")
+else:
+    taospy_version = subprocess.getoutput("pip3 show taospy|grep Version| awk -F ':' '{print $2}' ")
+
+print("taospy version %s " % taospy_version)
+if taospy_version == "":
+    subprocess.getoutput("pip3 install git+https://github.com/taosdata/taos-connector-python.git")
+    print("install taos python connector")
+else:
+    subprocess.getoutput("pip3 install taospy")
+
+# prepare data by taosBenchmark
+cmd = "taosBenchmark -y -a 3 -n 100 -t 100 -d %s -h %s -P %d &" % (databaseName, serverHost, serverPort)
+process_out = subprocess.getoutput(cmd)
+print(cmd)
+#os.system("taosBenchmark -y -a 3 -n 100 -t 100 -d %s -h %s -P %d" % (databaseName, serverHost, serverPort))
+taosBenchmark_test_result = True
+time.sleep(10)
+import taos
+
+conn = taos.connect(host=serverHost,
+                                         user="root",
+                                         password="taosdata",
+                                         database=databaseName,
+                                         port=serverPort,
+                                         timezone="Asia/Shanghai")  # default your host's timezone
+
+server_version = conn.server_info
+print("server_version", server_version)
+client_version = conn.client_info
+print("client_version", client_version)  # 3.0.0.0
+
+# Execute a sql and get its result set. It's useful for SELECT statement
+result: taos.TaosResult = conn.query("SELECT count(*) from meters")
+
+data = result.fetch_all()
+print(data)
+if data[0][0] !=10000:
+    print(" taosBenchmark work not as expected ")
+    print("!!!!!!!!!!!Test Result: taosBenchmark test failed! !!!!!!!!!!")
+    sys.exit(1)
+#else:
+#    print("**********Test Result: taosBenchmark test passed **********")
+
+
+# drop database of test
+taos_test_result = False
+print("drop database test")
+print("run taos -s 'drop database %s;'  -h %s  -P %d" % (databaseName, serverHost, serverPort))
+taos_cmd_outpur = subprocess.getoutput('taos -s "drop database %s;"  -h %s  -P %d' % (databaseName, serverHost, serverPort))
+print(taos_cmd_outpur)
+if ("Drop OK" in taos_cmd_outpur):
+    taos_test_result = True
+    #print("*******Test Result: taos test passed ************")
+
+version_test_result = False
+if version:
+    print("Client info is: %s"%conn.client_info)
+    taos_V_output = ""
+    if system == "Windows":
+        taos_V_output = subprocess.getoutput("taos -V | findstr version")
+    else:
+        taos_V_output = subprocess.getoutput("taos -V | grep version")
+
+    print("taos -V output is: %s" % taos_V_output)
+    if version in taos_V_output and version in conn.client_info:
+        version_test_result = True
+        #print("*******Test Result: Version check passed ************")
+
+conn.close()
+if uninstall:
+    print("Start to run rmtaos")
+    leftFile = False
+    print("Platform: ", system)
+
+    if system == "Linux":
+        # 创建一个subprocess.Popen对象，并使用stdin和stdout进行交互
+        process = subprocess.Popen(['rmtaos'],
+                                   stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True)
+        # 向子进程发送输入
+        process.stdin.write("y\n")
+        process.stdin.flush()  # 确保输入被发送到子进程
+        process.stdin.write("I confirm that I would like to delete all data, log and configuration files\n")
+        process.stdin.flush()  # 确保输入被发送到子进程
+        # 关闭子进程的stdin，防止它无限期等待更多输入
+        process.stdin.close()
+        # 等待子进程结束
+        process.wait()
+        # 检查目录清除情况
+        out = subprocess.getoutput("ls /etc/systemd/system/taos*")
+        if "No such file or directory" not in out:
+            print("Uninstall left some files: %s" % out)
+            leftFile = True
+        out = subprocess.getoutput("ls /usr/bin/taos*")
+        if "No such file or directory" not in out:
+            print("Uninstall left some files: %s" % out)
+            leftFile = True
+        out = subprocess.getoutput("ls /usr/local/bin/taos*")
+        if "No such file or directory" not in out:
+            print("Uninstall left some files: %s" % out)
+            leftFile = True
+        out = subprocess.getoutput("ls /usr/lib/libtaos*")
+        if "No such file or directory" not in out:
+            print("Uninstall left some files: %s" % out)
+            leftFile = True
+        out = subprocess.getoutput("ls /usr/lib64/libtaos*")
+        if "No such file or directory" not in out:
+            print("Uninstall left some files: %s" % out)
+            leftFile = True
+        out = subprocess.getoutput("ls /usr/include/taos*")
+        if "No such file or directory" not in out:
+            print("Uninstall left some files: %s" % out)
+            leftFile = True
+        out = subprocess.getoutput("ls /usr/local/taos")
+        #print(out)
+        if "No such file or directory" not in out:
+            print("Uninstall left some files in /usr/local/taos：%s" % out)
+            leftFile = True
+        if not leftFile:
+            print("*******Test Result: uninstall test passed ************")
+
+    elif system == "Darwin":
+        # 创建一个subprocess.Popen对象，并使用stdin和stdout进行交互
+        process = subprocess.Popen(['sudo', 'rmtaos'],
+                                   stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True)
+        # 向子进程发送输入
+        process.stdin.write("y\n")
+        process.stdin.flush()  # 确保输入被发送到子进程
+        process.stdin.write("I confirm that I would like to delete all data, log and configuration files\n")
+        process.stdin.flush()  # 确保输入被发送到子进程
+        # 关闭子进程的stdin，防止它无限期等待更多输入
+        process.stdin.close()
+        # 等待子进程结束
+        process.wait()
+        # 检查目录清除情况
+        out = subprocess.getoutput("ls /usr/local/bin/taos*")
+        if "No such file or directory" not in out:
+            print("Uninstall left some files: %s" % out)
+            leftFile = True
+        out = subprocess.getoutput("ls /usr/local/lib/libtaos*")
+        if "No such file or directory" not in out:
+            print("Uninstall left some files: %s" % out)
+            leftFile = True
+        out = subprocess.getoutput("ls /usr/local/include/taos*")
+        if "No such file or directory" not in out:
+            print("Uninstall left some files: %s" % out)
+            leftFile = True
+        #out = subprocess.getoutput("ls /usr/local/Cellar/tdengine/")
+        #print(out)
+        #if out:
+        #    print("Uninstall left some files: /usr/local/Cellar/tdengine/%s" % out)
+        #    leftFile = True
+        #if not leftFile:
+        #    print("*******Test Result: uninstall test passed ************")
+
+    elif system == "Windows":
+        process = subprocess.Popen(['unins000','/silent'],
+                                   stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True)
+        process.wait()
+        time.sleep(10)
+        out = subprocess.getoutput("ls C:\TDengine")
+        print(out)
+        if len(out.split("\n")) > 3:
+            leftFile = True
+            print("Uninstall left some files: %s" % out)
+
+if taosBenchmark_test_result:
+    print("**********Test Result: taosBenchmark test passed! **********")
+if taos_test_result:
+    print("**********Test Result: taos test passed! **********")
+else:
+    print("!!!!!!!!!!!Test Result: taos test failed! !!!!!!!!!!")
+if version_test_result:
+    print("**********Test Result: version test passed! **********")
+else:
+    print("!!!!!!!!!!!Test Result: version test failed! !!!!!!!!!!")
+if not leftFile:
+    print("**********Test Result: uninstall test passed! **********")
+else:
+    print("!!!!!!!!!!!Test Result: uninstall test failed! !!!!!!!!!!")
+if taosBenchmark_test_result and taos_test_result and version_test_result and not leftFile:
+    sys.exit(0)
+else:
+    sys.exit(1)
+
--- a/packaging/smokeTest/smokeTestJenkinsFile
+++ b/packaging/smokeTest/smokeTestJenkinsFile
@ -0,0 +1,380 @@
+def sync_source(branch_name) {
+    sh '''
+        hostname
+        ip addr|grep 192|awk  '{print $2}'|sed "s/\\/.*//"
+        echo ''' + branch_name + '''
+    '''
+    sh '''
+        cd ${TDENGINE_ROOT_DIR}
+        set +e
+        git reset --hard
+        git fetch || git fetch
+        git checkout -f '''+branch_name+'''
+        git reset --hard origin/'''+branch_name+'''
+        git log | head -n 20
+        git clean -fxd
+        set -e
+    '''
+    return 1
+}
+def sync_source_win() {
+    bat '''
+        hostname
+        taskkill /f /t /im taosd.exe
+        ipconfig
+        set
+        date /t
+        time /t
+    '''
+    bat '''
+        echo %branch_name%
+        cd %WIN_TDENGINE_ROOT_DIR%
+        git reset --hard
+        git fetch || git fetch
+        git checkout -f ''' + env.BRANCH_NAME + '''
+        git reset --hard origin/''' + env.BRANCH_NAME + '''
+        git branch
+        git restore .
+        git remote prune origin
+        git pull || git pull
+        git log | head -n 20
+        git clean -fxd
+    '''
+    return 1
+}
+pipeline {
+    agent none
+    parameters {
+        choice(
+            name: 'sourcePath',
+            choices: ['nas','web'],
+            description: 'Choice which way to download the installation pacakge;web is Office Web and nas means taos nas server '
+        )
+        choice(
+            name: 'verMode',
+            choices: ['enterprise','community'],
+            description: 'Choice  which types of package you want do check '
+        )
+        string (
+            name:'version',
+            defaultValue:'3.3.2.0',
+            description: 'Release version number,eg: 3.0.0.1'
+        )
+        string (
+            name:'baseVersion',
+            defaultValue:'smoking',
+            description: 'Tnas root path. eg:smoking, 3.3'
+        )
+        choice (
+            name:'mode',
+            choices: ['server','client'],
+            description: 'Choose which mode of package you want do run '
+        )
+        choice (
+            name:'smoke_branch',
+            choices: ['test/3.0/smokeTest','test/main/smokeTest','test/3.1/smokeTest'],
+            description: 'Choose which mode of package you want do run '
+        )
+        string (
+            name:'runPlatforms',
+            defaultValue:'server_Linux_x64, server_Linux_arm64, server_Windows_x64, server_Mac_x64',
+            description: 'run package list hotfix usually run: server: server_Linux_x64, server_Linux_arm64 client: client_Linux_x64, client_Linux_arm64 release usually run: enterprise server: server_Linux_x64, server_Linux_arm64, server_Windows_x64 enterprise client: client_Linux_x64, client_Linux_arm64, client_Windows_x64 community  server: server_Linux_x64, server_Linux_arm64, server_Mac_x64, server_Mac_arm64(not supported), server_Linux_x64_lite(not supported) community  client: client_Linux_x64, client_Linux_arm64, client_Windows_x64, client_Mac_x64, client_Mac_arm64(not supported), client_Linux_x64_lite(not supported)'
+        )
+    }
+    environment{
+        WORK_DIR = "/var/lib/jenkins/workspace"
+        TDINTERNAL_ROOT_DIR = '/var/lib/jenkins/workspace/TDinternal'
+        TDENGINE_ROOT_DIR = '/var/lib/jenkins/workspace/TDinternal/community'
+        BRANCH_NAME = "${smoke_branch}"
+    }
+    stages {
+        stage ('Start Server for Client Test') {
+            when {
+                beforeAgent true
+                expression { mode == 'client' }
+            }
+            agent{label " ubuntu18 "}
+            steps {
+                timeout(time: 30, unit: 'MINUTES'){
+                    sync_source("${BRANCH_NAME}")
+                    withEnv(['JENKINS_NODE_COOKIE=dontkillme']) {
+                        sh '''
+                            cd ${TDENGINE_ROOT_DIR}/packaging/smokeTest
+                            bash getAndRunInstaller.sh -m ${verMode} -f server -l false -c x64  -v ${version} -o ${baseVersion} -s ${sourcePath}  -t tar
+                            bash start3NodesServer.sh
+                        '''
+                    }
+                }
+            }
+        }
+        stage ('Run SmokeTest') {
+            parallel {
+                stage('server_Linux_x64') {
+                    when {
+                        beforeAgent true
+                        allOf {
+                            expression { mode == 'server' }
+                            expression { runPlatforms.contains('server_Linux_x64') }
+                        }
+                    }
+                    agent{label " ubuntu16 "}
+                    steps {
+                        timeout(time: 30, unit: 'MINUTES'){
+                            sync_source("${BRANCH_NAME}")
+                            sh '''
+                                mkdir -p /var/www/html/${baseVersion}/${version}/${verMode}/json
+                                cd ${TDENGINE_ROOT_DIR}/packaging/smokeTest
+                                bash getAndRunInstaller.sh -m ${verMode} -f server -l false -c x64  -v ${version} -o ${baseVersion} -s ${sourcePath}  -t tar
+                                python3 -m pytest test_server.py -v --html=/var/www/html/${baseVersion}/${version}/${verMode}/${mode}_linux_x64_report.html --json-report --json-report-file=report.json --timeout=300 --verMode=${verMode} --tVersion=${version} --baseVersion=${baseVersion} --sourcePath=${sourcePath} || true
+                                cp report.json /var/www/html/${baseVersion}/${version}/${verMode}/json/${mode}_linux_x64_report.json
+                                curl "http://192.168.0.176/api/addSmoke?version=${version}&tag=${baseVersion}&type=${verMode}&role=server&build=linux_x64"
+                            '''
+                        }
+                    }
+                }
+                stage('server_Linux_arm64') {
+                    when {
+                        beforeAgent true
+                        allOf {
+                            expression { mode == 'server' }
+                            expression { runPlatforms.contains('server_Linux_arm64') }
+                        }
+                    }
+                    agent{label "worker06_arm64"}
+                    steps {
+                        timeout(time: 60, unit: 'MINUTES'){
+                            sync_source("${BRANCH_NAME}")
+                            sh '''
+                                cd ${TDENGINE_ROOT_DIR}/packaging/smokeTest
+                                bash getAndRunInstaller.sh -m ${verMode} -f server -l false -c arm64  -v ${version} -o ${baseVersion} -s ${sourcePath}  -t tar
+                                python3 -m pytest test_server.py -v --html=${mode}_linux_arm64_report.html --json-report --json-report-file=report.json --timeout=600 --verMode=${verMode} --tVersion=${version} --baseVersion=${baseVersion} --sourcePath=${sourcePath} || true
+                                scp ${mode}_linux_arm64_report.html root@192.168.0.21:/var/www/html/${baseVersion}/${version}/${verMode}/
+                                scp report.json root@192.168.0.21:/var/www/html/${baseVersion}/${version}/${verMode}/json/${mode}_linux_arm64_report.json
+                                curl "http://192.168.0.176/api/addSmoke?version=${version}&tag=${baseVersion}&type=${verMode}&role=server&build=linux_arm64"
+                            '''
+                        }
+                    }
+                }
+                stage ('server_Mac_x64') {
+                    when {
+                        beforeAgent true
+                        allOf {
+                            expression { mode == 'server' }
+                            expression { runPlatforms.contains('server_Mac_x64') }
+                        }
+                    }
+                    agent{label " release_Darwin_x64 "}
+                    environment{
+                        WORK_DIR = "/Users/zwen/jenkins/workspace"
+                        TDINTERNAL_ROOT_DIR = '/Users/zwen/jenkins/workspace/TDinternal'
+                        TDENGINE_ROOT_DIR = '/Users/zwen/jenkins/workspace/TDinternal/community'
+                    }
+                    steps {
+                        timeout(time: 30, unit: 'MINUTES'){
+                            sync_source("${BRANCH_NAME}")
+                            sh '''
+                                cd ${TDENGINE_ROOT_DIR}/packaging/smokeTest
+                                bash getAndRunInstaller.sh -m ${verMode} -f server -l false -c x64  -v ${version} -o ${baseVersion} -s ${sourcePath}  -t pkg
+                                python3 -m pytest -v -k linux  --html=${mode}_Mac_x64_report.html --json-report --json-report-file=report.json --timeout=300 --verMode=${verMode} --tVersion=${version} --baseVersion=${baseVersion} --sourcePath=${sourcePath} || true
+                                scp ${mode}_Mac_x64_report.html root@192.168.0.21:/var/www/html/${baseVersion}/${version}/${verMode}/
+                                scp report.json root@192.168.0.21:/var/www/html/${baseVersion}/${version}/${verMode}/json/${mode}_Mac_x64_report.json
+                                curl "http://192.168.0.176/api/addSmoke?version=${version}&tag=${baseVersion}&type=${verMode}&role=server&build=Mac_x64"
+                            '''
+                        }
+                    }
+                }
+                stage ('server_Mac_arm64') {
+                    when {
+                        beforeAgent true
+                        allOf {
+                            expression { mode == 'server' }
+                            expression { runPlatforms.contains('server_Mac_arm64') }
+                        }
+                    }
+                    agent{label " release_Darwin_arm64 "}
+                    environment{
+                        WORK_DIR = "/Users/zwen/jenkins/workspace"
+                        TDINTERNAL_ROOT_DIR = '/Users/zwen/jenkins/workspace/TDinternal'
+                        TDENGINE_ROOT_DIR = '/Users/zwen/jenkins/workspace/TDinternal/community'
+                    }
+                    steps {
+                        timeout(time: 30, unit: 'MINUTES'){
+                            sync_source("${BRANCH_NAME}")
+                            sh '''
+                                cd ${TDENGINE_ROOT_DIR}/packaging/smokeTest
+                                bash getAndRunInstaller.sh -m ${verMode} -f server -l false -c arm64  -v ${version} -o ${baseVersion} -s ${sourcePath}  -t pkg
+                                python3 -m pytest -v -k linux  --html=${mode}_Mac_arm64_report.html --json-report --json-report-file=report.json --timeout=300 --verMode=${verMode} --tVersion=${version} --baseVersion=${baseVersion} --sourcePath=${sourcePath} || true
+                                scp ${mode}_Mac_arm64_report.html root@192.168.0.21:/var/www/html/${baseVersion}/${version}/${verMode}/
+                                scp report.json root@192.168.0.21:/var/www/html/${baseVersion}/${version}/${verMode}/json/${mode}_Mac_arm64_report.json
+                                curl "http://192.168.0.176/api/addSmoke?version=${version}&tag=${baseVersion}&type=${verMode}&role=server&build=Mac_arm64"
+                            '''
+                        }
+                    }
+                }
+                stage('server_Windows_x64') {
+                    when {
+                        beforeAgent true
+                        allOf {
+                            expression { mode == 'server' }
+                            expression { runPlatforms.contains('server_Windows_x64') }
+                        }
+                    }
+                    agent{label " windows11 "}
+                    environment{
+                        WIN_WORK_DIR="C:\\workspace"
+                        WIN_TDINTERNAL_ROOT_DIR="C:\\workspace\\TDinternal"
+                        WIN_TDENGINE_ROOT_DIR="C:\\workspace\\TDinternal\\community"
+                    }
+                    steps {
+                        timeout(time: 30, unit: 'MINUTES'){
+                            sync_source_win()
+                            bat '''
+                                cd %WIN_TDENGINE_ROOT_DIR%\\packaging\\smokeTest
+                                call getAndRunInstaller.bat %baseVersion% %version% %verMode% server
+                                cd %WIN_TDENGINE_ROOT_DIR%\\packaging\\smokeTest
+                                pip3 install -r pytest_require.txt
+                                python3 -m pytest test_server.py -v --html=%mode%_Windows_x64_report.html --json-report --json-report-file=report.json --timeout=300 --verMode=%verMode% --tVersion=%version% --baseVersion=%baseVersion% --sourcePath=%sourcePath%
+                                scp %mode%_Windows_x64_report.html root@192.168.0.21:/var/www/html/%baseVersion%/%version%/%verMode%/
+                                scp report.json root@192.168.0.21:/var/www/html/%baseVersion%/%version%/%verMode%/json/%mode%_Windows_x64_report.json
+                                curl "http://192.168.0.176/api/addSmoke?version=%version%&tag=%baseVersion%&type=%verMode%&role=server&build=Windows_x64"
+                            '''
+                        }
+                    }
+                }
+                stage('client_Linux_x64') {
+                    when {
+                        beforeAgent true
+                        allOf {
+                            expression { mode == 'client' }
+                            expression { runPlatforms.contains('client_Linux_x64') }
+                        }
+                    }
+                    agent{label " ubuntu16 "}
+                    steps {
+                        timeout(time: 30, unit: 'MINUTES'){
+                            sync_source("${BRANCH_NAME}")
+                            sh '''
+                                mkdir -p /var/www/html/${baseVersion}/${version}/${verMode}/json
+                                cd ${TDENGINE_ROOT_DIR}/packaging/smokeTest
+                                bash getAndRunInstaller.sh -m ${verMode} -f client -l false -c x64  -v ${version} -o ${baseVersion} -s ${sourcePath}  -t tar
+                                python3 -m pytest test_client.py -v --html=/var/www/html/${baseVersion}/${version}/${verMode}/${mode}_linux_x64_report.html --json-report --json-report-file=report.json --timeout=300 --verMode=${verMode} --tVersion=${version} --baseVersion=${baseVersion} --sourcePath=${sourcePath} || true
+                                cp report.json /var/www/html/${baseVersion}/${version}/${verMode}/json/${mode}_linux_x64_report.json
+                                curl "http://192.168.0.176/api/addSmoke?version=${version}&tag=${baseVersion}&type=${verMode}&role=client&build=linux_x64"
+                            '''
+                        }
+                    }
+                }
+                stage('client_Linux_arm64') {
+                    when {
+                        beforeAgent true
+                        allOf {
+                            expression { mode == 'client' }
+                            expression { runPlatforms.contains('client_Linux_arm64') }
+                        }
+                    }
+                    agent{label " worker06_arm64 "}
+                    steps {
+                        timeout(time: 30, unit: 'MINUTES'){
+                            sync_source("${BRANCH_NAME}")
+                            sh '''
+                                cd ${TDENGINE_ROOT_DIR}/packaging/smokeTest
+                                bash getAndRunInstaller.sh -m ${verMode} -f client -l false -c arm64  -v ${version} -o ${baseVersion} -s ${sourcePath}  -t tar
+                                python3 -m pytest test_client.py -v --html=${mode}_linux_arm64_report.html --json-report --json-report-file=report.json --timeout=300 --verMode=${verMode} --tVersion=${version} --baseVersion=${baseVersion} --sourcePath=${sourcePath} || true
+                                scp ${mode}_linux_arm64_report.html root@192.168.0.21:/var/www/html/${baseVersion}/${version}/${verMode}/
+                                scp report.json root@192.168.0.21:/var/www/html/${baseVersion}/${version}/${verMode}/json/${mode}_linux_arm64_report.json
+                                curl "http://192.168.0.176/api/addSmoke?version=${version}&tag=${baseVersion}&type=${verMode}&role=client&build=linux_arm64"
+                            '''
+                        }
+                    }
+                }
+                stage ('client_Mac_x64') {
+                    when {
+                        beforeAgent true
+                        allOf {
+                            expression { mode == 'client' }
+                            expression { runPlatforms.contains('client_Mac_x64') }
+                        }
+                    }
+                    agent{label " release_Darwin_x64 "}
+                    environment{
+                        WORK_DIR = "/Users/zwen/jenkins/workspace"
+                        TDINTERNAL_ROOT_DIR = '/Users/zwen/jenkins/workspace/TDinternal'
+                        TDENGINE_ROOT_DIR = '/Users/zwen/jenkins/workspace/TDinternal/community'
+                    }
+                    steps {
+                        timeout(time: 30, unit: 'MINUTES'){
+                            sync_source("${BRANCH_NAME}")
+                            sh '''
+                                cd ${TDENGINE_ROOT_DIR}/packaging/smokeTest
+                                bash getAndRunInstaller.sh -m ${verMode} -f client -l false -c x64  -v ${version} -o ${baseVersion} -s ${sourcePath}  -t pkg
+                                rm -rf /opt/taos/main/TDinternal/debug/* || true
+                                python3 -m pytest test_client.py -v --html=${mode}_Mac_x64_report.html --json-report --json-report-file=report.json --timeout=300 --verMode=${verMode} --tVersion=${version} --baseVersion=${baseVersion} --sourcePath=${sourcePath} || true
+                                scp ${mode}_Mac_x64_report.html root@192.168.0.21:/var/www/html/${baseVersion}/${version}/${verMode}/
+                                scp report.json root@192.168.0.21:/var/www/html/${baseVersion}/${version}/${verMode}/json/${mode}_Mac_x64_report.json
+                                curl "http://192.168.0.176/api/addSmoke?version=${version}&tag=${baseVersion}&type=${verMode}&role=client&build=Mac_x64"
+                            '''
+                        }
+                    }
+                }
+                stage ('client_Mac_arm64') {
+                    when {
+                        beforeAgent true
+                        allOf {
+                            expression { mode == 'client' }
+                            expression { runPlatforms.contains('client_Mac_arm64') }
+                        }
+                    }
+                    agent{label " release_Darwin_arm64 "}
+                    environment{
+                        WORK_DIR = "/Users/zwen/jenkins/workspace"
+                        TDINTERNAL_ROOT_DIR = '/Users/zwen/jenkins/workspace/TDinternal'
+                        TDENGINE_ROOT_DIR = '/Users/zwen/jenkins/workspace/TDinternal/community'
+                    }
+                    steps {
+                        timeout(time: 30, unit: 'MINUTES'){
+                            sync_source("${BRANCH_NAME}")
+                            sh '''
+                                cd ${TDENGINE_ROOT_DIR}/packaging/smokeTest
+                                bash getAndRunInstaller.sh -m ${verMode} -f client -l false -c arm64 -v ${version} -o ${baseVersion} -s ${sourcePath} -t pkg
+                                rm -rf /opt/taos/main/TDinternal/debug/* || true
+                                python3 -m pytest test_client.py -v --html=${mode}_Mac_arm64_report.html --json-report --json-report-file=report.json --timeout=300 --verMode=${verMode} --tVersion=${version} --baseVersion=${baseVersion} --sourcePath=${sourcePath} || true
+                                scp ${mode}_Mac_arm64_report.html root@192.168.0.21:/var/www/html/${baseVersion}/${version}/${verMode}/
+                                scp report.json root@192.168.0.21:/var/www/html/${baseVersion}/${version}/${verMode}/json/${mode}_Mac_arm64_report.json
+                                curl "http://192.168.0.176/api/addSmoke?version=${version}&tag=${baseVersion}&type=${verMode}&role=client&build=Mac_arm64"
+                            '''
+                        }
+                    }
+                }
+                stage('client_Windows_x64') {
+                    when {
+                        beforeAgent true
+                        allOf {
+                            expression { mode == 'client' }
+                            expression { runPlatforms.contains('client_Windows_x64') }
+                        }
+                    }
+                    agent{label " windows71 "}
+                    environment{
+                        WIN_WORK_DIR="C:\\workspace"
+                        WIN_TDINTERNAL_ROOT_DIR="C:\\workspace\\TDinternal"
+                        WIN_TDENGINE_ROOT_DIR="C:\\workspace\\TDinternal\\community"
+                    }
+                    steps {
+                        timeout(time: 30, unit: 'MINUTES'){
+                            sync_source_win()
+                            bat '''
+                                cd %WIN_TDENGINE_ROOT_DIR%\\packaging\\smokeTest
+                                call getAndRunInstaller.bat %baseVersion% %version% %verMode% client
+                                pip3 install -r pytest_require.txt
+                                python3 -m pytest test_client.py -v --html=%mode%_Windows_x64_report.html --json-report --json-report-file=report.json --timeout=300 --verMode=%verMode% --tVersion=%version% --baseVersion=%baseVersion% --sourcePath=%sourcePath%
+                                scp %mode%_Windows_x64_report.html root@192.168.0.21:/var/www/html/%baseVersion%/%version%/%verMode%/
+                                scp report.json root@192.168.0.21:/var/www/html/%baseVersion%/%version%/%verMode%/json/%mode%_Windows_x64_report.json
+                                curl "http://192.168.0.176/api/addSmoke?version=%version%&tag=%baseVersion%&type=%verMode%&role=client&build=Windows_x64"
+                            '''
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
--- a/packaging/smokeTest/start3NodesServer.sh
+++ b/packaging/smokeTest/start3NodesServer.sh
@ -0,0 +1,67 @@
+#!/bin/bash
+BUILD_ID=dontKillMe
+
+#******This script setup 3 nodes env for remote client installer test. Only for Linux *********
+
+pwd=`pwd`
+hostname=`hostname`
+if [ -z $JENKINS_HOME ]; then
+    workdir="${pwd}/cluster"
+    echo $workdir
+else
+    workdir="${JENKINS_HOME}/workspace/cluster"
+    echo $workdir
+fi
+
+name="taos"
+if command -v prodb ;then
+  name="prodb"
+fi
+
+# Stop all taosd processes
+for(( i=0; i<3; i++))
+do
+    pid=$(ps -ef | grep ${name}d | grep -v grep | awk '{print $2}')
+    if [ -n "$pid" ]; then
+        ${csudo}kill -9 $pid || :
+    fi
+done
+
+# Init 3 dnodes workdir and config file
+rm -rf ${workdir}
+mkdir ${workdir}
+mkdir ${workdir}/output
+mkdir ${workdir}/dnode1
+mkdir ${workdir}/dnode1/data
+mkdir ${workdir}/dnode1/log
+mkdir ${workdir}/dnode1/cfg
+touch ${workdir}/dnode1/cfg/${name}.cfg
+echo -e "firstEp ${hostname}:6031\nsecondEp ${hostname}:6032\nfqdn ${hostname}\nserverPort 6031\nlogDir ${workdir}/dnode1/log\ndataDir ${workdir}/dnode1/data\n" >> ${workdir}/dnode1/cfg/${name}.cfg
+
+# Start first node
+nohup ${name}d -c ${workdir}/dnode1/cfg/${name}.cfg & > /dev/null
+sleep 5
+
+${name} -P 6031 -s "CREATE DNODE \`${hostname}:6032\`;CREATE DNODE \`${hostname}:6033\`"
+
+mkdir ${workdir}/dnode2
+mkdir ${workdir}/dnode2/data
+mkdir ${workdir}/dnode2/log
+mkdir ${workdir}/dnode2/cfg
+touch ${workdir}/dnode2/cfg/${name}.cfg
+echo -e "firstEp ${hostname}:6031\nsecondEp ${hostname}:6032\nfqdn ${hostname}\nserverPort 6032\nlogDir ${workdir}/dnode2/log\ndataDir ${workdir}/dnode2/data\n" >> ${workdir}/dnode2/cfg/${name}.cfg
+
+nohup ${name}d -c ${workdir}/dnode2/cfg/${name}.cfg & > /dev/null
+sleep 5
+
+mkdir ${workdir}/dnode3
+mkdir ${workdir}/dnode3/data
+mkdir ${workdir}/dnode3/log
+mkdir ${workdir}/dnode3/cfg
+touch ${workdir}/dnode3/cfg/${name}.cfg
+echo -e "firstEp ${hostname}:6031\nsecondEp ${hostname}:6032\nfqdn ${hostname}\nserverPort 6033\nlogDir ${workdir}/dnode3/log\ndataDir ${workdir}/dnode3/data\n" >> ${workdir}/dnode3/cfg/${name}.cfg
+
+nohup ${name}d -c ${workdir}/dnode3/cfg/${name}.cfg & > /dev/null
+sleep 5
+
+${name} -P 6031 -s "CREATE MNODE ON DNODE 2;CREATE MNODE ON DNODE 3;"
--- a/packaging/smokeTest/test_client.py
+++ b/packaging/smokeTest/test_client.py
@ -0,0 +1,137 @@
+import pytest
+import subprocess
+import os
+import sys
+import platform
+import getopt
+import re
+import time
+import taos
+from versionCheckAndUninstallforPytest import UninstallTaos
+
+# python3 smokeTestClient.py -h 192.168.0.22 -P 6031 -v ${version} -u
+
+OEM = ["ProDB"]
+
+
+@pytest.fixture(scope="module")
+def get_config(request):
+    verMode = request.config.getoption("--verMode")
+    taosVersion = request.config.getoption("--tVersion")
+    baseVersion = request.config.getoption("--baseVersion")
+    sourcePath = request.config.getoption("--sourcePath")
+    config = {
+        "verMode": verMode,
+        "taosVersion": taosVersion,
+        "baseVersion": baseVersion,
+        "sourcePath": sourcePath,
+        "system": platform.system(),
+        "arch": platform.machine(),
+        "serverHost": "192.168.0.22",
+        "serverPort": 6031,
+        "databaseName": re.sub(r'[^a-zA-Z0-9]', '', subprocess.getoutput("hostname")).lower()
+    }
+    return config
+
+
+@pytest.fixture(scope="module")
+def setup_module(get_config):
+    config = get_config
+    # install taospy
+    if config["system"] == 'Windows':
+        taospy_version = subprocess.getoutput("pip3 show taospy|findstr Version")
+    else:
+        taospy_version = subprocess.getoutput("pip3 show taospy|grep Version| awk -F ':' '{print $2}' ")
+
+    print("taospy version %s " % taospy_version)
+    if taospy_version == "":
+        subprocess.getoutput("pip3 install git+https://github.com/taosdata/taos-connector-python.git")
+        print("install taos python connector")
+    else:
+        subprocess.getoutput("pip3 install taospy")
+
+
+def get_connect(host, port, database=None):
+    conn = taos.connect(host=host,
+                        user="root",
+                        password="taosdata",
+                        database=database,
+                        port=port,
+                        timezone="Asia/Shanghai")  # default your host's timezone
+    return conn
+
+
+def run_cmd(command):
+    print("CMD: %s" % command)
+    result = subprocess.run(command, capture_output=True, text=True, shell=True)
+    print("STDOUT:", result.stdout)
+    print("STDERR:", result.stderr)
+    print("Return Code:", result.returncode)
+    assert result.returncode == 0
+    return result
+
+
+class TestClient:
+    @pytest.mark.all
+    def test_basic(self, get_config, setup_module):
+        config = get_config
+        name = "taos"
+
+        if config["baseVersion"] in OEM:
+            name = config["baseVersion"].lower()
+        if config["baseVersion"] in OEM and config["system"] == 'Windows':
+            cmd = f'{name} -s "create database {config["databaseName"]};"  -h {config["serverHost"]}  -P {config["serverPort"]}'
+            run_cmd(cmd)
+            cmd = f'{name} -s "CREATE STABLE {config["databaseName"]}.meters (`ts` TIMESTAMP,`current` FLOAT, `phase` FLOAT) TAGS (`groupid` INT, `location` VARCHAR(24));"  -h {config["serverHost"]}  -P {config["serverPort"]}'
+            run_cmd(cmd)
+        else:
+            cmd = f'{name}Benchmark -y -a 3 -n 100 -t 100 -d {config["databaseName"]} -h {config["serverHost"]} -P {config["serverPort"]} &'
+            run_cmd(cmd)
+        # os.system("taosBenchmark -y -a 3 -n 100 -t 100 -d %s -h %s -P %d" % (databaseName, serverHost, serverPort))
+        time.sleep(5)
+        conn = get_connect(config["serverHost"], config["serverPort"], config["databaseName"])
+        sql = "SELECT count(*) from meters"
+        result: taos.TaosResult = conn.query(sql)
+        data = result.fetch_all()
+        print("SQL: %s" % sql)
+        print("Result: %s" % data)
+        if config["system"] == 'Windows' and config["baseVersion"] in OEM:
+            pass
+        elif data[0][0] != 10000:
+            raise f"{name}Benchmark work not as expected "
+        # drop database of test
+        cmd = f'{name} -s "drop database {config["databaseName"]};"  -h {config["serverHost"]}  -P {config["serverPort"]}'
+        result = run_cmd(cmd)
+        assert "Drop OK" in result.stdout
+        conn.close()
+
+    @pytest.mark.all
+    def test_version(self, get_config, setup_module):
+        config = get_config
+        conn = get_connect(config["serverHost"], config["serverPort"])
+        server_version = conn.server_info
+        print("server_version: ", server_version)
+        client_version = conn.client_info
+        print("client_version: ", client_version)
+        name = "taos"
+        if config["baseVersion"] in OEM:
+            name = config["baseVersion"].lower()
+        if config["system"] == "Windows":
+            taos_V_output = subprocess.getoutput(f"{name} -V | findstr version")
+        else:
+            taos_V_output = subprocess.getoutput(f"{name} -V | grep version")
+        assert config["taosVersion"] in taos_V_output
+        assert config["taosVersion"] in client_version
+        if config["taosVersion"] not in server_version:
+            print("warning: client version is not same as server version")
+        conn.close()
+
+    @pytest.mark.all
+    def test_uninstall(self, get_config, setup_module):
+        config = get_config
+        name = "taos"
+        if config["baseVersion"] in OEM:
+            name = config["baseVersion"].lower()
+            subprocess.getoutput("rm /usr/local/bin/taos")
+            subprocess.getoutput("pkill taosd")
+        UninstallTaos(config["taosVersion"], config["verMode"], True, name)
--- a/packaging/smokeTest/test_server.py
+++ b/packaging/smokeTest/test_server.py
@ -0,0 +1,238 @@
+import pytest
+import subprocess
+import os
+from versionCheckAndUninstallforPytest import UninstallTaos
+import platform
+import re
+import time
+import signal
+
+system = platform.system()
+current_path = os.path.abspath(os.path.dirname(__file__))
+if system == 'Windows':
+    with open(r"%s\test_server_windows_case" % current_path) as f:
+        cases = f.read().splitlines()
+else:
+    with open("%s/test_server_unix_case" % current_path) as f:
+        cases = f.read().splitlines()
+
+OEM = ["ProDB"]
+
+
+@pytest.fixture(scope="module")
+def get_config(request):
+    verMode = request.config.getoption("--verMode")
+    taosVersion = request.config.getoption("--tVersion")
+    baseVersion = request.config.getoption("--baseVersion")
+    sourcePath = request.config.getoption("--sourcePath")
+    config = {
+        "verMode": verMode,
+        "taosVersion": taosVersion,
+        "baseVersion": baseVersion,
+        "sourcePath": sourcePath,
+        "system": platform.system(),
+        "arch": platform.machine()
+    }
+    return config
+
+
+@pytest.fixture(scope="module")
+def setup_module(get_config):
+    def run_cmd(command):
+        print("CMD:", command)
+        result = subprocess.run(command, capture_output=True, text=True, shell=True)
+        print("STDOUT:", result.stdout)
+        print("STDERR:", result.stderr)
+        print("Return Code:", result.returncode)
+        assert result.returncode == 0
+        return result
+
+    # setup before module tests
+    config = get_config
+    # bash getAndRunInstaller.sh -m ${verMode} -f server -l false -c x64  -v ${version} -o ${baseVersion} -s ${sourcePath}  -t tar
+    # t = "tar"
+    # if config["system"] == "Darwin":
+    #     t = "pkg"
+    # cmd = "bash getAndRunInstaller.sh -m %s -f server -l false -c x64 -v %s -o %s -s %s -t %s" % (
+    #     config["verMode"], config["taosVersion"], config["baseVersion"], config["sourcePath"], t)
+    # run_cmd(cmd)
+    if config["system"] == "Windows":
+        cmd = r"mkdir ..\..\debug\build\bin"
+    else:
+        cmd = "mkdir -p ../../debug/build/bin/"
+    subprocess.getoutput(cmd)
+    if config["system"] == "Linux":  # add tmq_sim
+        cmd = "cp -rf ../../../debug/build/bin/tmq_sim ../../debug/build/bin/."
+        subprocess.getoutput(cmd)
+    if config["system"] == "Darwin":
+        cmd = "sudo cp -rf /usr/local/bin/taos*  ../../debug/build/bin/"
+    elif config["system"] == "Windows":
+        cmd = r"xcopy  C:\TDengine\taos*.exe ..\..\debug\build\bin /Y"
+    else:
+        if config["baseVersion"] in OEM:
+            cmd = '''sudo find /usr/bin -name 'prodb*' -exec sh -c 'for file; do cp "$file" "../../debug/build/bin/taos${file##/usr/bin/%s}"; done' sh {} +''' % (
+                config["baseVersion"].lower())
+        else:
+            cmd = "sudo cp /usr/bin/taos*  ../../debug/build/bin/"
+    run_cmd(cmd)
+    if config["baseVersion"] in OEM:  # mock OEM
+        cmd = "sed -i 's/taos.cfg/%s.cfg/g' ../../tests/pytest/util/dnodes.py" % config["baseVersion"].lower()
+        run_cmd(cmd)
+        cmd = "sed -i 's/taosdlog.0/%sdlog.0/g' ../../tests/pytest/util/dnodes.py" % config["baseVersion"].lower()
+        run_cmd(cmd)
+        cmd = "sed -i 's/taos.cfg/%s.cfg/g' ../../tests/army/frame/server/dnode.py" % config["baseVersion"].lower()
+        run_cmd(cmd)
+        cmd = "sed -i 's/taosdlog.0/%sdlog.0/g' ../../tests/army/frame/server/dnode.py" % config["baseVersion"].lower()
+        run_cmd(cmd)
+        cmd = "ln -s /usr/bin/prodb /usr/local/bin/taos"
+        subprocess.getoutput(cmd)
+
+    # yield
+    #
+    # name = "taos"
+    # if config["baseVersion"] in OEM:
+    #     name = config["baseVersion"].lower()
+    #     subprocess.getoutput("rm /usr/local/bin/taos")
+    #     subprocess.getoutput("pkill taosd")
+    # UninstallTaos(config["taosVersion"], config["verMode"], True, name)
+
+
+# use pytest fixture to exec case
+@pytest.fixture(params=cases)
+def run_command(request):
+    commands = request.param
+    if commands.strip().startswith("#"):
+        pytest.skip("This case has been marked as skipped")
+    d, command = commands.strip().split(",")
+    if system == "Windows":
+        cmd = r"cd %s\..\..\tests\%s && %s" % (current_path, d, command)
+    else:
+        cmd = "cd %s/../../tests/%s&&sudo %s" % (current_path, d, command)
+    print(cmd)
+    result = subprocess.run(cmd, capture_output=True, text=True, shell=True)
+    return {
+        "command": command,
+        "stdout": result.stdout,
+        "stderr": result.stderr,
+        "returncode": result.returncode
+    }
+
+
+class TestServer:
+    @pytest.mark.all
+    def test_taosd_up(self, setup_module):
+        # start process
+        if system == 'Windows':
+            subprocess.getoutput("taskkill /IM taosd.exe /F")
+            cmd = "..\\..\\debug\\build\\bin\\taosd.exe"
+        else:
+            subprocess.getoutput("pkill taosd")
+            cmd = "../../debug/build/bin/taosd"
+        process = subprocess.Popen(
+            [cmd],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        # monitor output
+        while True:
+            line = process.stdout.readline()
+            if line:
+                print(line.strip())
+            if "succeed to write dnode" in line:
+                time.sleep(15)
+                # 发送终止信号
+                os.kill(process.pid, signal.SIGTERM)
+                break
+
+    @pytest.mark.all
+    def test_execute_cases(self, setup_module, run_command):
+        # assert the result
+        if run_command['returncode'] != 0:
+            print(f"Running command: {run_command['command']}")
+            print("STDOUT:", run_command['stdout'])
+            print("STDERR:", run_command['stderr'])
+            print("Return Code:", run_command['returncode'])
+        else:
+            print(f"Running command: {run_command['command']}")
+            if len(run_command['stdout']) > 1000:
+                print("STDOUT:", run_command['stdout'][:1000] + "...")
+            else:
+                print("STDOUT:", run_command['stdout'])
+            print("STDERR:", run_command['stderr'])
+            print("Return Code:", run_command['returncode'])
+
+        assert run_command[
+                   'returncode'] == 0, f"Command '{run_command['command']}' failed with return code {run_command['returncode']}"
+
+    @pytest.mark.all
+    @pytest.mark.check_version
+    def test_check_version(self, get_config, setup_module):
+        config = get_config
+        databaseName = re.sub(r'[^a-zA-Z0-9]', '', subprocess.getoutput("hostname")).lower()
+        # install taospy
+        taospy_version = ""
+        system = config["system"]
+        version = config["taosVersion"]
+        verMode = config["verMode"]
+        if system == 'Windows':
+            taospy_version = subprocess.getoutput("pip3 show taospy|findstr Version")
+        else:
+            taospy_version = subprocess.getoutput("pip3 show taospy|grep Version| awk -F ':' '{print $2}' ")
+
+        print("taospy version %s " % taospy_version)
+        if taospy_version == "":
+            subprocess.getoutput("pip3 install git+https://github.com/taosdata/taos-connector-python.git")
+            print("install taos python connector")
+        else:
+            subprocess.getoutput("pip3 install taospy")
+
+        # start taosd server
+        if system == 'Windows':
+            cmd = ["C:\\TDengine\\start-all.bat"]
+        # elif system == 'Linux':
+        #     cmd = "systemctl start taosd".split(' ')
+        else:
+            #    cmd = "sudo launchctl start com.tdengine.taosd".split(' ')
+            cmd = "start-all.sh"
+        process_out = subprocess.Popen(cmd,
+                                       stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True)
+        print(cmd)
+        time.sleep(5)
+
+        import taos
+        conn = taos.connect()
+        check_list = {}
+        check_list["server_version"] = conn.server_info
+        check_list["client_version"] = conn.client_info
+        # Execute sql get version info
+        result: taos.TaosResult = conn.query("SELECT server_version()")
+        check_list["select_server"] = result.fetch_all()[0][0]
+        result: taos.TaosResult = conn.query("SELECT client_version()")
+        check_list["select_client"] = result.fetch_all()[0][0]
+        conn.close()
+
+        binary_files = ["taos", "taosd", "taosadapter", "taoskeeper", "taosBenchmark"]
+        if verMode.lower() == "enterprise":
+            binary_files.append("taosx")
+        if config["baseVersion"] in OEM:
+            binary_files = [i.replace("taos", config["baseVersion"].lower()) for i in binary_files]
+        if system == "Windows":
+            for i in binary_files:
+                check_list[i] = subprocess.getoutput("%s -V | findstr version" % i)
+        else:
+            for i in binary_files:
+                check_list[i] = subprocess.getoutput("%s -V | grep version | awk -F ' ' '{print $3}'" % i)
+        for i in check_list:
+            print("%s version is: %s" % (i, check_list[i]))
+            assert version in check_list[i]
+
+    @pytest.mark.all
+    def test_uninstall(self, get_config, setup_module):
+        config = get_config
+        name = "taos"
+        if config["baseVersion"] in OEM:
+            name = config["baseVersion"].lower()
+            subprocess.getoutput("rm /usr/local/bin/taos")
+            subprocess.getoutput("pkill taosd")
+        UninstallTaos(config["taosVersion"], config["verMode"], True, name)
--- a/packaging/smokeTest/test_server_unix_case
+++ b/packaging/smokeTest/test_server_unix_case
@ -0,0 +1,10 @@
+system-test,python3 ./test.py -f 2-query/join.py
+system-test,python3 ./test.py -f 1-insert/insert_column_value.py
+system-test,python3 ./test.py -f 2-query/primary_ts_base_5.py
+system-test,python3 ./test.py -f 2-query/case_when.py
+system-test,python3 ./test.py -f 2-query/partition_limit_interval.py
+system-test,python3 ./test.py -f 2-query/fill.py
+army,python3 ./test.py -f query/query_basic.py -N 3
+system-test,python3 ./test.py -f 7-tmq/basic5.py
+system-test,python3 ./test.py -f 8-stream/stream_basic.py
+system-test,python3 ./test.py -f 6-cluster/5dnode3mnodeStop.py -N 5 -M 3
--- a/packaging/smokeTest/test_server_windows_case
+++ b/packaging/smokeTest/test_server_windows_case
@ -0,0 +1,2 @@
+system-test,python3 .\test.py -f 0-others\taosShell.py
+system-test,python3 .\test.py -f 6-cluster\5dnode3mnodeSep1VnodeStopDnodeModifyMeta.py  -N 6 -M 3
--- a/packaging/smokeTest/versionCheckAndUninstall.py
+++ b/packaging/smokeTest/versionCheckAndUninstall.py
@ -0,0 +1,260 @@
+#!/usr/bin/python
+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+# install pip
+# pip install src/connector/python/
+
+# -*- coding: utf-8 -*-
+import sys, os
+import re
+import platform
+import getopt
+import subprocess
+# from this import d
+import time
+
+# input for server
+
+opts, args = getopt.gnu_getopt(sys.argv[1:], 'v:m:u', ['version=', 'verMode='])
+serverHost = ""
+serverPort = 0
+version = ""
+uninstall = False
+verMode = ""
+for key, value in opts:
+    if key in ['--help']:
+        print('A collection of test cases written using Python')
+        print('-v test client version')
+        print('-u test uninstall process, will uninstall TDengine')
+        sys.exit(0)
+
+    if key in ['-v']:
+        version = value
+    if key in ['-u']:
+        uninstall = True
+    if key in ['-m']:
+        verMode = value
+if not version:
+    print("No version specified, will not run version check.")
+
+
+system = platform.system()
+arch = platform.machine()
+
+databaseName = re.sub(r'[^a-zA-Z0-9]', '', subprocess.getoutput("hostname")).lower()
+# install taospy
+taospy_version = ""
+if system == 'Windows':
+    taospy_version = subprocess.getoutput("pip3 show taospy|findstr Version")
+else:
+    taospy_version = subprocess.getoutput("pip3 show taospy|grep Version| awk -F ':' '{print $2}' ")
+
+print("taospy version %s " % taospy_version)
+if taospy_version == "":
+    subprocess.getoutput("pip3 install git+https://github.com/taosdata/taos-connector-python.git")
+    print("install taos python connector")
+else:
+    subprocess.getoutput("pip3 install taospy")
+
+# start taosd server
+if system == 'Windows':
+    cmd = ["C:\\TDengine\\start-all.bat"]
+elif system == 'Linux':
+    cmd = "systemctl start taosd".split(' ')
+else:
+    cmd = "sudo launchctl start com.tdengine.taosd".split(' ')
+process_out = subprocess.Popen(cmd,
+                                   stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True)
+print(cmd)
+time.sleep(5)
+
+#get taosc version info
+version_test_result = False
+if version:
+    import taos
+    conn = taos.connect()
+    server_version = conn.server_info
+    print("server_version", server_version)
+    client_version = conn.client_info
+    print("client_version", client_version)
+    # Execute sql get version info
+    result: taos.TaosResult = conn.query("SELECT server_version()")
+    select_server = result.fetch_all()[0][0]
+    print("SELECT server_version():" + select_server)
+    result: taos.TaosResult = conn.query("SELECT client_version()")
+    select_client = result.fetch_all()[0][0]
+    print("SELECT client_version():" + select_client)
+    conn.close()
+
+    taos_V_output = ""
+    taosd_V_output = ""
+    taosadapter_V_output = ""
+    taoskeeper_V_output = ""
+    taosx_V_output = ""
+    taosB_V_output = ""
+    taosxVersion = False
+    if system == "Windows":
+        taos_V_output = subprocess.getoutput("taos -V | findstr version")
+        taosd_V_output = subprocess.getoutput("taosd -V | findstr version")
+        taosadapter_V_output = subprocess.getoutput("taosadapter -V | findstr version")
+        taoskeeper_V_output = subprocess.getoutput("taoskeeper -V | findstr version")
+        taosB_V_output = subprocess.getoutput("taosBenchmark -V | findstr version")
+        if verMode == "Enterprise":
+            taosx_V_output = subprocess.getoutput("taosx -V | findstr version")
+    else:
+        taos_V_output = subprocess.getoutput("taos -V | grep version | awk -F ' ' '{print $3}'")
+        taosd_V_output = subprocess.getoutput("taosd -V | grep version | awk -F ' ' '{print $3}'")
+        taosadapter_V_output = subprocess.getoutput("taosadapter -V | grep version | awk -F ' ' '{print $3}'")
+        taoskeeper_V_output = subprocess.getoutput("taoskeeper -V | grep version | awk -F ' ' '{print $3}'")
+        taosB_V_output = subprocess.getoutput("taosBenchmark -V | grep version | awk -F ' ' '{print $3}'")
+        if verMode == "Enterprise":
+            taosx_V_output = subprocess.getoutput("taosx -V | grep version | awk -F ' ' '{print $3}'")
+
+    print("taos -V output is: %s" % taos_V_output)
+    print("taosd -V output is: %s" % taosd_V_output)
+    print("taosadapter -V output is: %s" % taosadapter_V_output)
+    print("taoskeeper -V output is: %s" % taoskeeper_V_output)
+    print("taosBenchmark -V output is: %s" % taosB_V_output)
+    if verMode == "Enterprise":
+        print("taosx -V output is: %s" % taosx_V_output)
+        taosxVersion = version in taosx_V_output
+    else:
+        taosxVersion = True
+    if (version in client_version
+        and version in server_version
+        and version in select_server
+        and version in select_client
+        and version in taos_V_output
+        and version in taosd_V_output
+        and version in taosadapter_V_output
+        and version in taoskeeper_V_output
+        and version in taosB_V_output
+        and taosxVersion
+    ):
+        version_test_result = True
+leftFile = False
+if uninstall:
+    print("Start to run rmtaos")
+    print("Platform: ", system)
+    # stop taosd server
+    if system == 'Windows':
+        cmd = "C:\\TDengine\\stop_all.bat"
+    elif system == 'Linux':
+        cmd = "systemctl stop taosd"
+    else:
+        cmd = "sudo launchctl stop com.tdengine.taosd"
+    process_out = subprocess.getoutput(cmd)
+    print(cmd)
+    time.sleep(10)
+    if system == "Linux":
+        # 创建一个subprocess.Popen对象，并使用stdin和stdout进行交互
+        process = subprocess.Popen(['rmtaos'],
+                                   stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True)
+        # 向子进程发送输入
+        process.stdin.write("y\n")
+        process.stdin.flush()  # 确保输入被发送到子进程
+        process.stdin.write("I confirm that I would like to delete all data, log and configuration files\n")
+        process.stdin.flush()  # 确保输入被发送到子进程
+        # 关闭子进程的stdin，防止它无限期等待更多输入
+        process.stdin.close()
+        # 等待子进程结束
+        process.wait()
+        # 检查目录清除情况
+        out = subprocess.getoutput("ls /etc/systemd/system/taos*")
+        if "No such file or directory" not in out:
+            print("Uninstall left some files: %s" % out)
+            leftFile = True
+        out = subprocess.getoutput("ls /usr/bin/taos*")
+        if "No such file or directory" not in out:
+            print("Uninstall left some files: %s" % out)
+            leftFile = True
+        out = subprocess.getoutput("ls /usr/local/bin/taos*")
+        if "No such file or directory" not in out:
+            print("Uninstall left some files: %s" % out)
+            leftFile = True
+        out = subprocess.getoutput("ls /usr/lib/libtaos*")
+        if "No such file or directory" not in out:
+            print("Uninstall left some files: %s" % out)
+            leftFile = True
+        out = subprocess.getoutput("ls /usr/lib64/libtaos*")
+        if "No such file or directory" not in out:
+            print("Uninstall left some files: %s" % out)
+            leftFile = True
+        out = subprocess.getoutput("ls /usr/include/taos*")
+        if "No such file or directory" not in out:
+            print("Uninstall left some files: %s" % out)
+            leftFile = True
+        out = subprocess.getoutput("ls /usr/local/taos")
+        #print(out)
+        if "No such file or directory" not in out:
+            print("Uninstall left some files in /usr/local/taos：%s" % out)
+            leftFile = True
+        if not leftFile:
+            print("*******Test Result: uninstall test passed ************")
+
+    elif system == "Darwin":
+        # 创建一个subprocess.Popen对象，并使用stdin和stdout进行交互
+        process = subprocess.Popen(['sudo', 'rmtaos'],
+                                   stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True)
+        # 向子进程发送输入
+        process.stdin.write("y\n")
+        process.stdin.flush()  # 确保输入被发送到子进程
+        process.stdin.write("I confirm that I would like to delete all data, log and configuration files\n")
+        process.stdin.flush()  # 确保输入被发送到子进程
+        # 关闭子进程的stdin，防止它无限期等待更多输入
+        process.stdin.close()
+        # 等待子进程结束
+        process.wait()
+        # 检查目录清除情况
+        out = subprocess.getoutput("ls /usr/local/bin/taos*")
+        if "No such file or directory" not in out:
+            print("Uninstall left some files: %s" % out)
+            leftFile = True
+        out = subprocess.getoutput("ls /usr/local/lib/libtaos*")
+        if "No such file or directory" not in out:
+            print("Uninstall left some files: %s" % out)
+            leftFile = True
+        out = subprocess.getoutput("ls /usr/local/include/taos*")
+        if "No such file or directory" not in out:
+            print("Uninstall left some files: %s" % out)
+            leftFile = True
+        #out = subprocess.getoutput("ls /usr/local/Cellar/tdengine/")
+        #print(out)
+        #if out:
+        #    print("Uninstall left some files: /usr/local/Cellar/tdengine/%s" % out)
+        #    leftFile = True
+        #if not leftFile:
+        #    print("*******Test Result: uninstall test passed ************")
+
+    elif system == "Windows":
+        process = subprocess.Popen(['unins000','/silent'],
+                                   stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True)
+        process.wait()
+        time.sleep(10)
+        out = subprocess.getoutput("ls C:\TDengine")
+        print(out)
+        if len(out.split("\n")) > 3:
+            leftFile = True
+            print("Uninstall left some files: %s" % out)
+
+if version_test_result:
+    print("**********Test Result: version test passed! **********")
+else:
+    print("!!!!!!!!!!!Test Result: version test failed! !!!!!!!!!!")
+if not leftFile:
+    print("**********Test Result: uninstall test passed! **********")
+else:
+    print("!!!!!!!!!!!Test Result: uninstall test failed! !!!!!!!!!!")
+if version_test_result and not leftFile:
+    sys.exit(0)
+else:
+    sys.exit(1)
+
--- a/packaging/smokeTest/versionCheckAndUninstallforPytest.py
+++ b/packaging/smokeTest/versionCheckAndUninstallforPytest.py
@ -0,0 +1,137 @@
+#!/usr/bin/python
+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+# install pip
+# pip install src/connector/python/
+
+# -*- coding: utf-8 -*-
+import sys, os
+import re
+import platform
+import getopt
+import subprocess
+# from this import d
+import time
+from lib import run_cmd
+
+
+# input for server
+def UninstallTaos(version, verMode, uninstall, name):
+    if not version:
+        raise "No version specified, will not run version check."
+
+    system = platform.system()
+    arch = platform.machine()
+    leftFile = False
+    if uninstall:
+        print("Start to run rm%s" % name)
+        print("Platform: ", system)
+        # stop taosd server
+        if system == 'Windows':
+            cmd = "C:\\TDengine\\stop_all.bat"
+        else:
+            cmd = "stop_all.sh"
+        process_out = subprocess.getoutput(cmd)
+        print(cmd)
+        time.sleep(5)
+        print("start to rm%s" % name)
+        if system == "Linux":
+            # 启动命令
+            process = subprocess.Popen(['rm%s' % name], stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+                                       stderr=subprocess.PIPE, text=True)
+
+            # 发送交互输入
+            stdout, stderr = process.communicate(
+                input="y\nI confirm that I would like to delete all data, log and configuration files\n")
+
+            # 打印输出（可选）
+            print(stdout)
+            print(stderr)
+            # 检查目录清除情况
+            out = subprocess.getoutput("ls /etc/systemd/system/%s*" % name)
+            if "No such file or directory" not in out:
+                print("Uninstall left some files: %s" % out)
+                leftFile = True
+            out = subprocess.getoutput("ls /usr/bin/%s*" % name)
+            if "No such file or directory" not in out:
+                print("Uninstall left some files: %s" % out)
+                leftFile = True
+            out = subprocess.getoutput("ls /usr/local/bin/%s*" % name)
+            if "No such file or directory" not in out:
+                print("Uninstall left some files: %s" % out)
+                leftFile = True
+            out = subprocess.getoutput("ls /usr/lib/lib%s*" % name)
+            if "No such file or directory" not in out:
+                print("Uninstall left some files: %s" % out)
+                leftFile = True
+            out = subprocess.getoutput("ls /usr/lib64/lib%s*" % name)
+            if "No such file or directory" not in out:
+                print("Uninstall left some files: %s" % out)
+                leftFile = True
+            out = subprocess.getoutput("ls /usr/include/%s*" % name)
+            if "No such file or directory" not in out:
+                print("Uninstall left some files: %s" % out)
+                leftFile = True
+            out = subprocess.getoutput("ls /usr/local/%s" % name)
+            # print(out)
+            if "No such file or directory" not in out:
+                print("Uninstall left some files in /usr/local/%s：%s" % (name, out))
+                leftFile = True
+            if not leftFile:
+                print("*******Test Result: uninstall test passed ************")
+
+        elif system == "Darwin":
+            # 创建一个subprocess.Popen对象，并使用stdin和stdout进行交互
+            process = subprocess.Popen(['sudo', 'rm%s' % name],
+                                       stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True)
+            # 向子进程发送输入
+            process.stdin.write("y\n")
+            process.stdin.flush()  # 确保输入被发送到子进程
+            process.stdin.write("I confirm that I would like to delete all data, log and configuration files\n")
+            process.stdin.flush()  # 确保输入被发送到子进程
+            # 关闭子进程的stdin，防止它无限期等待更多输入
+            process.stdin.close()
+            # 等待子进程结束
+            process.wait()
+            # 检查目录清除情况
+            out = subprocess.getoutput("ls /usr/local/bin/%s*" % name)
+            if "No such file or directory" not in out:
+                print("Uninstall left some files: %s" % out)
+                leftFile = True
+            out = subprocess.getoutput("ls /usr/local/lib/lib%s*" % name)
+            if "No such file or directory" not in out:
+                print("Uninstall left some files: %s" % out)
+                leftFile = True
+            out = subprocess.getoutput("ls /usr/local/include/%s*" % name)
+            if "No such file or directory" not in out:
+                print("Uninstall left some files: %s" % out)
+                leftFile = True
+            # out = subprocess.getoutput("ls /usr/local/Cellar/tdengine/")
+            # print(out)
+            # if out:
+            #    print("Uninstall left some files: /usr/local/Cellar/tdengine/%s" % out)
+            #    leftFile = True
+            # if not leftFile:
+            #    print("*******Test Result: uninstall test passed ************")
+
+        elif system == "Windows":
+            process = subprocess.Popen(['unins000', '/silent'],
+                                       stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True)
+            process.wait()
+            time.sleep(10)
+            for file in ["C:\TDengine\\taos.exe", "C:\TDengine\\unins000.exe", "C:\ProDB\prodb.exe",
+                         "C:\ProDB\\unins000.exe"]:
+                if os.path.exists(file):
+                    leftFile = True
+    if leftFile:
+        raise "uninstall %s fail, please check" % name
+    else:
+        print("**********Test Result: uninstall test passed! **********")
--- a/packaging/tools/install.sh
+++ b/packaging/tools/install.sh
@ -185,7 +185,14 @@ function kill_process() {

 function install_main_path() {
  #create install main dir and all sub dir
-  ${csudo}rm -rf ${install_main_dir} || :
+  ${csudo}rm -rf ${install_main_dir}/cfg || :
+  ${csudo}rm -rf ${install_main_dir}/bin || :
+  ${csudo}rm -rf ${install_main_dir}/driver || :
+  ${csudo}rm -rf ${install_main_dir}/examples || :
+  ${csudo}rm -rf ${install_main_dir}/include || :
+  ${csudo}rm -rf ${install_main_dir}/share || :
+  ${csudo}rm -rf ${install_main_dir}/log || :
+
  ${csudo}mkdir -p ${install_main_dir}
  ${csudo}mkdir -p ${install_main_dir}/cfg
  ${csudo}mkdir -p ${install_main_dir}/bin
--- a/packaging/tools/mac_install_summary_client.txt
+++ b/packaging/tools/mac_install_summary_client.txt
@ -0,0 +1,4 @@
+TDengine client is installed successfully. Please open a terminal and execute the commands below:
+
+To configure TDengine client, sudo vi /etc/taos/taos.cfg
+To access TDengine command line interface, taos -h YouServerName
--- a/packaging/tools/make_install.sh
+++ b/packaging/tools/make_install.sh
@ -145,7 +145,14 @@ function kill_taosd() {

 function install_main_path() {
  #create install main dir and all sub dir
-  ${csudo}rm -rf ${install_main_dir} || :
+  ${csudo}rm -rf ${install_main_dir}/cfg || :
+  ${csudo}rm -rf ${install_main_dir}/bin || :
+  ${csudo}rm -rf ${install_main_dir}/driver || :
+  ${csudo}rm -rf ${install_main_dir}/examples || :
+  ${csudo}rm -rf ${install_main_dir}/include || :
+  ${csudo}rm -rf ${install_main_dir}/share || :
+  ${csudo}rm -rf ${install_main_dir}/log || :
+
  ${csudo}mkdir -p ${install_main_dir}
  ${csudo}mkdir -p ${install_main_dir}/cfg
  ${csudo}mkdir -p ${install_main_dir}/bin
--- a/source/client/inc/clientInt.h
+++ b/source/client/inc/clientInt.h
@ -108,6 +108,10 @@ typedef struct SQueryExecMetric {
  int64_t execCostUs;
 } SQueryExecMetric;

+typedef struct {
+  SMonitorParas monitorParas;
+  int8_t        enableAuditDelete;
+} SAppInstServerCFG;
 struct SAppInstInfo {
  int64_t            numOfConns;
  SCorEpSet          mgmtEp;
@ -121,7 +125,7 @@ struct SAppInstInfo {
  void*              pTransporter;
  SAppHbMgr*         pAppHbMgr;
  char*              instKey;
-  SMonitorParas      monitorParas;
+  SAppInstServerCFG  serverCfg;
 };

 typedef struct SAppInfo {
@ -297,8 +301,7 @@ void* doFetchRows(SRequestObj* pRequest, bool setupOneRowPtr, bool convertUcs4);
 void    doSetOneRowPtr(SReqResultInfo* pResultInfo);
 void    setResPrecision(SReqResultInfo* pResInfo, int32_t precision);
 int32_t setQueryResultFromRsp(SReqResultInfo* pResultInfo, const SRetrieveTableRsp* pRsp, bool convertUcs4);
-int32_t setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32_t numOfCols, int32_t numOfRows,
-                         bool convertUcs4);
+int32_t setResultDataPtr(SReqResultInfo* pResultInfo, bool convertUcs4);
 int32_t setResSchemaInfo(SReqResultInfo* pResInfo, const SSchema* pSchema, int32_t numOfCols);
 void    doFreeReqResultInfo(SReqResultInfo* pResInfo);
 int32_t transferTableNameList(const char* tbList, int32_t acctId, char* dbName, SArray** pReq);
--- a/source/client/inc/clientStmt2.h
+++ b/source/client/inc/clientStmt2.h
@ -222,6 +222,7 @@ int         stmtSetTbTags2(TAOS_STMT2 *stmt, TAOS_STMT2_BIND *tags);
 int         stmtBindBatch2(TAOS_STMT2 *stmt, TAOS_STMT2_BIND *bind, int32_t colIdx);
 int         stmtGetTagFields2(TAOS_STMT2 *stmt, int *nums, TAOS_FIELD_E **fields);
 int         stmtGetColFields2(TAOS_STMT2 *stmt, int *nums, TAOS_FIELD_E **fields);
+int         stmtGetStbColFields2(TAOS_STMT2 *stmt, int *nums, TAOS_FIELD_STB **fields);
 int         stmtGetParamNum2(TAOS_STMT2 *stmt, int *nums);
 int         stmtGetParamTbName(TAOS_STMT2 *stmt, int *nums);
 int         stmtIsInsert2(TAOS_STMT2 *stmt, int *insert);
--- a/source/client/src/clientEnv.c
+++ b/source/client/src/clientEnv.c
@ -166,11 +166,11 @@ static int32_t generateWriteSlowLog(STscObj *pTscObj, SRequestObj *pRequest, int
  ENV_JSON_FALSE_CHECK(cJSON_AddItemToObject(json, "type", cJSON_CreateNumber(reqType)));
  ENV_JSON_FALSE_CHECK(cJSON_AddItemToObject(
      json, "rows_num", cJSON_CreateNumber(pRequest->body.resInfo.numOfRows + pRequest->body.resInfo.totalRows)));
-  if (pRequest->sqlstr != NULL && strlen(pRequest->sqlstr) > pTscObj->pAppInfo->monitorParas.tsSlowLogMaxLen) {
-    char tmp = pRequest->sqlstr[pTscObj->pAppInfo->monitorParas.tsSlowLogMaxLen];
-    pRequest->sqlstr[pTscObj->pAppInfo->monitorParas.tsSlowLogMaxLen] = '\0';
+  if (pRequest->sqlstr != NULL && strlen(pRequest->sqlstr) > pTscObj->pAppInfo->serverCfg.monitorParas.tsSlowLogMaxLen) {
+    char tmp = pRequest->sqlstr[pTscObj->pAppInfo->serverCfg.monitorParas.tsSlowLogMaxLen];
+    pRequest->sqlstr[pTscObj->pAppInfo->serverCfg.monitorParas.tsSlowLogMaxLen] = '\0';
    ENV_JSON_FALSE_CHECK(cJSON_AddItemToObject(json, "sql", cJSON_CreateString(pRequest->sqlstr)));
-    pRequest->sqlstr[pTscObj->pAppInfo->monitorParas.tsSlowLogMaxLen] = tmp;
+    pRequest->sqlstr[pTscObj->pAppInfo->serverCfg.monitorParas.tsSlowLogMaxLen] = tmp;
  } else {
    ENV_JSON_FALSE_CHECK(cJSON_AddItemToObject(json, "sql", cJSON_CreateString(pRequest->sqlstr)));
  }
@ -284,7 +284,7 @@ static void deregisterRequest(SRequestObj *pRequest) {
    }
  }

-  if (pTscObj->pAppInfo->monitorParas.tsEnableMonitor) {
+  if (pTscObj->pAppInfo->serverCfg.monitorParas.tsEnableMonitor) {
    if (QUERY_NODE_VNODE_MODIFY_STMT == pRequest->stmtType || QUERY_NODE_INSERT_STMT == pRequest->stmtType) {
      sqlReqLog(pTscObj->id, pRequest->killed, pRequest->code, MONITORSQLTYPEINSERT);
    } else if (QUERY_NODE_SELECT_STMT == pRequest->stmtType) {
@ -294,14 +294,14 @@ static void deregisterRequest(SRequestObj *pRequest) {
    }
  }

-  if ((duration >= pTscObj->pAppInfo->monitorParas.tsSlowLogThreshold * 1000000UL) &&
-      checkSlowLogExceptDb(pRequest, pTscObj->pAppInfo->monitorParas.tsSlowLogExceptDb)) {
+  if ((duration >= pTscObj->pAppInfo->serverCfg.monitorParas.tsSlowLogThreshold * 1000000UL) &&
+      checkSlowLogExceptDb(pRequest, pTscObj->pAppInfo->serverCfg.monitorParas.tsSlowLogExceptDb)) {
    (void)atomic_add_fetch_64((int64_t *)&pActivity->numOfSlowQueries, 1);
-    if (pTscObj->pAppInfo->monitorParas.tsSlowLogScope & reqType) {
+    if (pTscObj->pAppInfo->serverCfg.monitorParas.tsSlowLogScope & reqType) {
      taosPrintSlowLog("PID:%d, Conn:%u,QID:0x%" PRIx64 ", Start:%" PRId64 " us, Duration:%" PRId64 "us, SQL:%s",
                       taosGetPId(), pTscObj->connId, pRequest->requestId, pRequest->metric.start, duration,
                       pRequest->sqlstr);
-      if (pTscObj->pAppInfo->monitorParas.tsEnableMonitor) {
+      if (pTscObj->pAppInfo->serverCfg.monitorParas.tsEnableMonitor) {
        slowQueryLog(pTscObj->id, pRequest->killed, pRequest->code, duration);
        if (TSDB_CODE_SUCCESS != generateWriteSlowLog(pTscObj, pRequest, reqType, duration)) {
          tscError("failed to generate write slow log");
@ -374,7 +374,7 @@ int32_t openTransporter(const char *user, const char *auth, int32_t numOfThread,
  rpcInit.startReadTimer = 1;
  rpcInit.readTimeout = tsReadTimeout;

-  int32_t code = taosVersionStrToInt(version, &(rpcInit.compatibilityVer));
+  int32_t code = taosVersionStrToInt(td_version, &rpcInit.compatibilityVer);
  if (TSDB_CODE_SUCCESS != code) {
    tscError("invalid version string.");
    return code;
@ -688,7 +688,7 @@ void doDestroyRequest(void *p) {

  int32_t code = taosHashRemove(pRequest->pTscObj->pRequests, &pRequest->self, sizeof(pRequest->self));
  if (TSDB_CODE_SUCCESS != code) {
-    tscError("failed to remove request from hash, code:%s", tstrerror(code));
+    tscWarn("failed to remove request from hash, code:%s", tstrerror(code));
  }
  schedulerFreeJob(&pRequest->body.queryJob, 0);

--- a/source/client/src/clientHb.c
+++ b/source/client/src/clientHb.c
@ -605,7 +605,8 @@ static int32_t hbAsyncCallBack(void *param, SDataBuf *pMsg, int32_t code) {
    return code;
  }

-  pInst->monitorParas = pRsp.monitorParas;
+  pInst->serverCfg.monitorParas = pRsp.monitorParas;
+  pInst->serverCfg.enableAuditDelete = pRsp.enableAuditDelete;
  tscDebug("[monitor] paras from hb, clusterId:%" PRIx64 " monitorParas threshold:%d scope:%d", pInst->clusterId,
           pRsp.monitorParas.tsSlowLogThreshold, pRsp.monitorParas.tsSlowLogScope);

--- a/source/client/src/clientImpl.c
+++ b/source/client/src/clientImpl.c
@ -1700,7 +1700,7 @@ static int32_t buildConnectMsg(SRequestObj* pRequest, SMsgSendInfo** pMsgSendInf
  tstrncpy(connectReq.app, appInfo.appName, sizeof(connectReq.app));
  tstrncpy(connectReq.user, pObj->user, sizeof(connectReq.user));
  tstrncpy(connectReq.passwd, pObj->pass, sizeof(connectReq.passwd));
-  tstrncpy(connectReq.sVer, version, sizeof(connectReq.sVer));
+  tstrncpy(connectReq.sVer, td_version, sizeof(connectReq.sVer));

  int32_t contLen = tSerializeSConnectReq(NULL, 0, &connectReq);
  void*   pReq = taosMemoryMalloc(contLen);
@ -1770,19 +1770,15 @@ void updateTargetEpSet(SMsgSendInfo* pSendInfo, STscObj* pTscObj, SRpcMsg* pMsg,
  }
 }

-int32_t doProcessMsgFromServer(void* param) {
-  AsyncArg* arg = (AsyncArg*)param;
-  SRpcMsg*  pMsg = &arg->msg;
-  SEpSet*   pEpSet = arg->pEpset;
-
+int32_t doProcessMsgFromServerImpl(SRpcMsg* pMsg, SEpSet* pEpSet) {
  SMsgSendInfo* pSendInfo = (SMsgSendInfo*)pMsg->info.ahandle;
  if (pMsg->info.ahandle == NULL) {
    tscError("doProcessMsgFromServer pMsg->info.ahandle == NULL");
-    taosMemoryFree(arg->pEpset);
    rpcFreeCont(pMsg->pCont);
-    taosMemoryFree(arg);
+    taosMemoryFree(pEpSet);
    return TSDB_CODE_TSC_INTERNAL_ERROR;
  }
+
  STscObj* pTscObj = NULL;

  STraceId* trace = &pMsg->info.traceId;
@ -1802,10 +1798,9 @@ int32_t doProcessMsgFromServer(void* param) {
        if (TSDB_CODE_SUCCESS != taosReleaseRef(clientReqRefPool, pSendInfo->requestObjRefId)) {
          tscError("doProcessMsgFromServer taosReleaseRef failed");
        }
-        taosMemoryFree(arg->pEpset);
        rpcFreeCont(pMsg->pCont);
+        taosMemoryFree(pEpSet);
        destroySendMsgInfo(pSendInfo);
-        taosMemoryFree(arg);
        return TSDB_CODE_TSC_INTERNAL_ERROR;
      }
      pTscObj = pRequest->pTscObj;
@ -1844,20 +1839,24 @@ int32_t doProcessMsgFromServer(void* param) {

  rpcFreeCont(pMsg->pCont);
  destroySendMsgInfo(pSendInfo);
-
-  taosMemoryFree(arg);
  return TSDB_CODE_SUCCESS;
 }
+int32_t doProcessMsgFromServer(void* param) {
+  AsyncArg* arg = (AsyncArg*)param;
+  int32_t   code = doProcessMsgFromServerImpl(&arg->msg, arg->pEpset);
+  taosMemoryFree(arg);
+  return code;
+}

 void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) {
+  int32_t code = 0;
  SEpSet* tEpSet = NULL;
  if (pEpSet != NULL) {
    tEpSet = taosMemoryCalloc(1, sizeof(SEpSet));
    if (NULL == tEpSet) {
-      pMsg->code = TSDB_CODE_OUT_OF_MEMORY;
-      rpcFreeCont(pMsg->pCont);
-      destroySendMsgInfo(pMsg->info.ahandle);
-      return;
+      code = terrno;
+      pMsg->code = terrno;
+      goto _exit;
    }
    (void)memcpy((void*)tEpSet, (void*)pEpSet, sizeof(SEpSet));
  }
@ -1879,21 +1878,25 @@ void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) {

  AsyncArg* arg = taosMemoryCalloc(1, sizeof(AsyncArg));
  if (NULL == arg) {
-    pMsg->code = TSDB_CODE_OUT_OF_MEMORY;
-    taosMemoryFree(tEpSet);
-    rpcFreeCont(pMsg->pCont);
-    destroySendMsgInfo(pMsg->info.ahandle);
-    return;
+    code = terrno;
+    pMsg->code = code;
+    goto _exit;
  }
+
  arg->msg = *pMsg;
  arg->pEpset = tEpSet;

-  if (0 != taosAsyncExec(doProcessMsgFromServer, arg, NULL)) {
-    tscError("failed to sched msg to tsc, tsc ready to quit");
-    rpcFreeCont(pMsg->pCont);
-    taosMemoryFree(arg->pEpset);
-    destroySendMsgInfo(pMsg->info.ahandle);
+  if ((code = taosAsyncExec(doProcessMsgFromServer, arg, NULL)) != 0) {
+    pMsg->code = code;
    taosMemoryFree(arg);
+    goto _exit;
+  }
+  return;
+_exit:
+  tscError("failed to sched msg to tsc since %s", tstrerror(code));
+  code = doProcessMsgFromServerImpl(pMsg, tEpSet);
+  if (code != 0) {
+    tscError("failed to sched msg to tsc, tsc ready quit");
  }
 }

@ -2081,12 +2084,12 @@ static int32_t doPrepareResPtr(SReqResultInfo* pResInfo) {
  return TSDB_CODE_SUCCESS;
 }

-static int32_t doConvertUCS4(SReqResultInfo* pResultInfo, int32_t numOfRows, int32_t numOfCols, int32_t* colLength) {
+static int32_t doConvertUCS4(SReqResultInfo* pResultInfo, int32_t* colLength) {
  int32_t idx = -1;
  iconv_t conv = taosAcquireConv(&idx, C2M);
  if (conv == (iconv_t)-1) return TSDB_CODE_TSC_INTERNAL_ERROR;

-  for (int32_t i = 0; i < numOfCols; ++i) {
+  for (int32_t i = 0; i < pResultInfo->numOfCols; ++i) {
    int32_t type = pResultInfo->fields[i].type;
    int32_t bytes = pResultInfo->fields[i].bytes;

@ -2100,7 +2103,7 @@ static int32_t doConvertUCS4(SReqResultInfo* pResultInfo, int32_t numOfRows, int
      pResultInfo->convertBuf[i] = p;

      SResultColumn* pCol = &pResultInfo->pCol[i];
-      for (int32_t j = 0; j < numOfRows; ++j) {
+      for (int32_t j = 0; j < pResultInfo->numOfRows; ++j) {
        if (pCol->offset[j] != -1) {
          char* pStart = pCol->offset[j] + pCol->pData;

@ -2133,10 +2136,13 @@ int32_t getVersion1BlockMetaSize(const char* p, int32_t numOfCols) {
         numOfCols * (sizeof(int8_t) + sizeof(int32_t));
 }

-static int32_t estimateJsonLen(SReqResultInfo* pResultInfo, int32_t numOfCols, int32_t numOfRows) {
+static int32_t estimateJsonLen(SReqResultInfo* pResultInfo) {
  char*   p = (char*)pResultInfo->pData;
  int32_t blockVersion = *(int32_t*)p;

+  int32_t numOfRows = pResultInfo->numOfRows;
+  int32_t numOfCols = pResultInfo->numOfCols;
+
  // | version | total length | total rows | total columns | flag seg| block group id | column schema | each column
  // length |
  int32_t cols = *(int32_t*)(p + sizeof(int32_t) * 3);
@ -2195,10 +2201,16 @@ static int32_t estimateJsonLen(SReqResultInfo* pResultInfo, int32_t numOfCols, i
    }
    pStart += colLen;
  }
+
+  // Ensure the complete structure of the block, including the blankfill field,
+  // even though it is not used on the client side.
+  len += sizeof(bool);
  return len;
 }

-static int32_t doConvertJson(SReqResultInfo* pResultInfo, int32_t numOfCols, int32_t numOfRows) {
+static int32_t doConvertJson(SReqResultInfo* pResultInfo) {
+  int32_t numOfRows = pResultInfo->numOfRows;
+  int32_t numOfCols = pResultInfo->numOfCols;
  bool needConvert = false;
  for (int32_t i = 0; i < numOfCols; ++i) {
    if (pResultInfo->fields[i].type == TSDB_DATA_TYPE_JSON) {
@ -2215,7 +2227,7 @@ static int32_t doConvertJson(SReqResultInfo* pResultInfo, int32_t numOfCols, int

  char*   p = (char*)pResultInfo->pData;
  int32_t blockVersion = *(int32_t*)p;
-  int32_t dataLen = estimateJsonLen(pResultInfo, numOfCols, numOfRows);
+  int32_t dataLen = estimateJsonLen(pResultInfo);
  if (dataLen <= 0) {
    return TSDB_CODE_TSC_INTERNAL_ERROR;
  }
@ -2338,27 +2350,36 @@ static int32_t doConvertJson(SReqResultInfo* pResultInfo, int32_t numOfCols, int
    pStart1 += colLen1;
  }

+  // Ensure the complete structure of the block, including the blankfill field,
+  // even though it is not used on the client side.
+  // (void)memcpy(pStart1, pStart, sizeof(bool));
+  totalLen += sizeof(bool);
+
  *(int32_t*)(pResultInfo->convertJson + 4) = totalLen;
  pResultInfo->pData = pResultInfo->convertJson;
  return TSDB_CODE_SUCCESS;
 }

-int32_t setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32_t numOfCols, int32_t numOfRows,
-                         bool convertUcs4) {
-  if (numOfCols <= 0 || pFields == NULL || pResultInfo == NULL) {
+int32_t setResultDataPtr(SReqResultInfo* pResultInfo, bool convertUcs4) {
+  if (pResultInfo == NULL || pResultInfo->numOfCols <= 0 || pResultInfo->fields == NULL) {
    tscError("setResultDataPtr paras error");
    return TSDB_CODE_TSC_INTERNAL_ERROR;
  }

-  if (numOfRows == 0) {
+  if (pResultInfo->numOfRows == 0) {
    return TSDB_CODE_SUCCESS;
  }

+  if (pResultInfo->pData == NULL) {
+    tscError("setResultDataPtr error: pData is NULL");
+    return TSDB_CODE_TSC_INTERNAL_ERROR;
+  }
+
  int32_t code = doPrepareResPtr(pResultInfo);
  if (code != TSDB_CODE_SUCCESS) {
    return code;
  }
-  code = doConvertJson(pResultInfo, numOfCols, numOfRows);
+  code = doConvertJson(pResultInfo);
  if (code != TSDB_CODE_SUCCESS) {
    return code;
  }
@ -2378,9 +2399,9 @@ int32_t setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32
  int32_t cols = *(int32_t*)p;
  p += sizeof(int32_t);

-  if (rows != numOfRows || cols != numOfCols) {
-    tscError("setResultDataPtr paras error:rows;%d numOfRows:%d cols:%d numOfCols:%d", rows, numOfRows, cols,
-             numOfCols);
+  if (rows != pResultInfo->numOfRows || cols != pResultInfo->numOfCols) {
+    tscError("setResultDataPtr paras error:rows;%d numOfRows:%" PRId64 " cols:%d numOfCols:%d", rows, pResultInfo->numOfRows, cols,
+             pResultInfo->numOfCols);
    return TSDB_CODE_TSC_INTERNAL_ERROR;
  }

@ -2391,7 +2412,7 @@ int32_t setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32
  p += sizeof(uint64_t);

  // check fields
-  for (int32_t i = 0; i < numOfCols; ++i) {
+  for (int32_t i = 0; i < pResultInfo->numOfCols; ++i) {
    int8_t type = *(int8_t*)p;
    p += sizeof(int8_t);

@ -2400,10 +2421,14 @@ int32_t setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32
  }

  int32_t* colLength = (int32_t*)p;
-  p += sizeof(int32_t) * numOfCols;
+  p += sizeof(int32_t) * pResultInfo->numOfCols;

  char* pStart = p;
-  for (int32_t i = 0; i < numOfCols; ++i) {
+  for (int32_t i = 0; i < pResultInfo->numOfCols; ++i) {
+    if ((pStart - pResultInfo->pData) >= dataLen) {
+      tscError("setResultDataPtr invalid offset over dataLen %d", dataLen);
+      return TSDB_CODE_TSC_INTERNAL_ERROR;
+    }
    if (blockVersion == BLOCK_VERSION_1) {
      colLength[i] = htonl(colLength[i]);
    }
@ -2411,10 +2436,13 @@ int32_t setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32
      tscError("invalid colLength %d, dataLen %d", colLength[i], dataLen);
      return TSDB_CODE_TSC_INTERNAL_ERROR;
    }
-
+    if (IS_INVALID_TYPE(pResultInfo->fields[i].type)) {
+      tscError("invalid type %d", pResultInfo->fields[i].type);
+      return TSDB_CODE_TSC_INTERNAL_ERROR;
+    }
    if (IS_VAR_DATA_TYPE(pResultInfo->fields[i].type)) {
      pResultInfo->pCol[i].offset = (int32_t*)pStart;
-      pStart += numOfRows * sizeof(int32_t);
+      pStart += pResultInfo->numOfRows * sizeof(int32_t);
    } else {
      pResultInfo->pCol[i].nullbitmap = pStart;
      pStart += BitmapLen(pResultInfo->numOfRows);
@ -2427,11 +2455,17 @@ int32_t setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32
    pStart += colLength[i];
  }

+  p = pStart;
  // bool blankFill = *(bool*)p;
  p += sizeof(bool);
+  int32_t offset = p - pResultInfo->pData;
+  if (offset > dataLen) {
+    tscError("invalid offset %d, dataLen %d", offset, dataLen);
+    return TSDB_CODE_TSC_INTERNAL_ERROR;
+  }

  if (convertUcs4) {
-    code = doConvertUCS4(pResultInfo, numOfRows, numOfCols, colLength);
+    code = doConvertUCS4(pResultInfo, colLength);
  }

  return code;
@ -2544,7 +2578,7 @@ int32_t setQueryResultFromRsp(SReqResultInfo* pResultInfo, const SRetrieveTableR
  pResultInfo->totalRows += pResultInfo->numOfRows;

  int32_t code =
-      setResultDataPtr(pResultInfo, pResultInfo->fields, pResultInfo->numOfCols, pResultInfo->numOfRows, convertUcs4);
+      setResultDataPtr(pResultInfo, convertUcs4);
  return code;
 }

@ -2573,7 +2607,7 @@ TSDB_SERVER_STATUS taos_check_server_status(const char* fqdn, int port, char* de
  rpcInit.connLimitNum = connLimitNum;
  rpcInit.timeToGetConn = tsTimeToGetAvailableConn;
  rpcInit.readTimeout = tsReadTimeout;
-  if (TSDB_CODE_SUCCESS != taosVersionStrToInt(version, &(rpcInit.compatibilityVer))) {
+  if (TSDB_CODE_SUCCESS != taosVersionStrToInt(td_version, &rpcInit.compatibilityVer)) {
    tscError("faild to convert taos version from str to int, errcode:%s", terrstr());
    goto _OVER;
  }
@ -2839,6 +2873,7 @@ void syncQueryFn(void* param, void* res, int32_t code) {

  if (pParam->pRequest) {
    pParam->pRequest->code = code;
+    clientOperateReport(pParam->pRequest);
  }

  if (TSDB_CODE_SUCCESS != tsem_post(&pParam->sem)) {
--- a/source/client/src/clientMain.c
+++ b/source/client/src/clientMain.c
@ -388,7 +388,6 @@ void taos_free_result(TAOS_RES *res) {
    tDeleteMqBatchMetaRsp(&pRsp->batchMetaRsp);
  }
  taosMemoryFree(pRsp);
-
 }

 void taos_kill_query(TAOS *taos) {
@ -670,7 +669,7 @@ const char *taos_data_type(int type) {
  }
 }

-const char *taos_get_client_info() { return version; }
+const char *taos_get_client_info() { return td_version; }

 // return int32_t
 int taos_affected_rows(TAOS_RES *res) {
@ -1804,7 +1803,7 @@ int taos_stmt_bind_param(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind) {

  if (bind->num > 1) {
    tscError("invalid bind number %d for %s", bind->num, __FUNCTION__);
-    terrno = TSDB_CODE_INVALID_PARA;
+    terrno = TSDB_CODE_TSC_STMT_BIND_NUMBER_ERROR;
    return terrno;
  }

@ -1820,7 +1819,7 @@ int taos_stmt_bind_param_batch(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind) {

  if (bind->num <= 0 || bind->num > INT16_MAX) {
    tscError("invalid bind num %d", bind->num);
-    terrno = TSDB_CODE_INVALID_PARA;
+    terrno = TSDB_CODE_TSC_STMT_BIND_NUMBER_ERROR;
    return terrno;
  }

@ -1832,7 +1831,7 @@ int taos_stmt_bind_param_batch(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind) {
  }
  if (0 == insert && bind->num > 1) {
    tscError("only one row data allowed for query");
-    terrno = TSDB_CODE_INVALID_PARA;
+    terrno = TSDB_CODE_TSC_STMT_BIND_NUMBER_ERROR;
    return terrno;
  }

@ -1860,7 +1859,7 @@ int taos_stmt_bind_single_param_batch(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind, in
  }
  if (0 == insert && bind->num > 1) {
    tscError("only one row data allowed for query");
-    terrno = TSDB_CODE_INVALID_PARA;
+    terrno = TSDB_CODE_TSC_STMT_BIND_NUMBER_ERROR;
    return terrno;
  }

@ -2020,7 +2019,7 @@ int taos_stmt2_bind_param(TAOS_STMT2 *stmt, TAOS_STMT2_BINDV *bindv, int32_t col

      if (bind->num <= 0 || bind->num > INT16_MAX) {
        tscError("invalid bind num %d", bind->num);
-        terrno = TSDB_CODE_INVALID_PARA;
+        terrno = TSDB_CODE_TSC_STMT_BIND_NUMBER_ERROR;
        return terrno;
      }

@ -2028,7 +2027,7 @@ int taos_stmt2_bind_param(TAOS_STMT2 *stmt, TAOS_STMT2_BINDV *bindv, int32_t col
      (void)stmtIsInsert2(stmt, &insert);
      if (0 == insert && bind->num > 1) {
        tscError("only one row data allowed for query");
-        terrno = TSDB_CODE_INVALID_PARA;
+        terrno = TSDB_CODE_TSC_STMT_BIND_NUMBER_ERROR;
        return terrno;
      }

@ -2082,7 +2081,7 @@ int taos_stmt2_is_insert(TAOS_STMT2 *stmt, int *insert) {
 }

 int taos_stmt2_get_fields(TAOS_STMT2 *stmt, TAOS_FIELD_T field_type, int *count, TAOS_FIELD_E **fields) {
-  if (stmt == NULL || NULL == count) {
+  if (stmt == NULL || count == NULL) {
    tscError("NULL parameter for %s", __FUNCTION__);
    terrno = TSDB_CODE_INVALID_PARA;
    return terrno;
@ -2103,12 +2102,28 @@ int taos_stmt2_get_fields(TAOS_STMT2 *stmt, TAOS_FIELD_T field_type, int *count,
  }
 }

+int taos_stmt2_get_stb_fields(TAOS_STMT2 *stmt, int *count, TAOS_FIELD_STB **fields) {
+  if (stmt == NULL || count == NULL) {
+    tscError("NULL parameter for %s", __FUNCTION__);
+    terrno = TSDB_CODE_INVALID_PARA;
+    return terrno;
+  }
+
+  return stmtGetStbColFields2(stmt, count, fields);
+}
+
 void taos_stmt2_free_fields(TAOS_STMT2 *stmt, TAOS_FIELD_E *fields) {
  (void)stmt;
  if (!fields) return;
  taosMemoryFree(fields);
 }

+DLL_EXPORT void taos_stmt2_free_stb_fields(TAOS_STMT2 *stmt, TAOS_FIELD_STB *fields) {
+  (void)stmt;
+  if (!fields) return;
+  taosMemoryFree(fields);
+}
+
 TAOS_RES *taos_stmt2_result(TAOS_STMT2 *stmt) {
  if (stmt == NULL) {
    tscError("NULL parameter for %s", __FUNCTION__);
@ -2144,4 +2159,4 @@ int taos_set_conn_mode(TAOS *taos, int mode, int value) {
  return 0;
 }

-char *getBuildInfo() { return buildinfo; }
+char *getBuildInfo() { return td_buildinfo; }
--- a/source/client/src/clientMonitor.c
+++ b/source/client/src/clientMonitor.c
@ -2,8 +2,6 @@
 #include "cJSON.h"
 #include "clientInt.h"
 #include "clientLog.h"
-#include "os.h"
-#include "tglobal.h"
 #include "tmisce.h"
 #include "tqueue.h"
 #include "ttime.h"
@ -19,6 +17,7 @@ STaosQueue* monitorQueue;
 SHashObj*   monitorSlowLogHash;
 char        tmpSlowLogPath[PATH_MAX] = {0};
 TdThread    monitorThread;
+extern bool tsEnableAuditDelete;

 static int32_t getSlowLogTmpDir(char* tmpPath, int32_t size) {
  int ret = tsnprintf(tmpPath, size, "%s/tdengine_slow_log/", tsTempDir);
@ -216,7 +215,7 @@ static void reportSendProcess(void* param, void* tmrId) {
  SEpSet ep = getEpSet_s(&pInst->mgmtEp);
  generateClusterReport(pMonitor->registry, pInst->pTransporter, &ep);
  bool reset =
-      taosTmrReset(reportSendProcess, pInst->monitorParas.tsMonitorInterval * 1000, param, monitorTimer, &tmrId);
+      taosTmrReset(reportSendProcess, pInst->serverCfg.monitorParas.tsMonitorInterval * 1000, param, monitorTimer, &tmrId);
  tscDebug("reset timer, pMonitor:%p, %d", pMonitor, reset);
  taosRUnLockLatch(&monitorLock);
 }
@ -289,7 +288,7 @@ void monitorCreateClient(int64_t clusterId) {
      goto fail;
    }
    pMonitor->timer =
-        taosTmrStart(reportSendProcess, pInst->monitorParas.tsMonitorInterval * 1000, (void*)pMonitor, monitorTimer);
+        taosTmrStart(reportSendProcess, pInst->serverCfg.monitorParas.tsMonitorInterval * 1000, (void*)pMonitor, monitorTimer);
    if (pMonitor->timer == NULL) {
      tscError("failed to start timer");
      goto fail;
@ -660,7 +659,7 @@ static void monitorSendAllSlowLog() {
      taosHashCancelIterate(monitorSlowLogHash, pIter);
      return;
    }
-    if (t - pClient->lastCheckTime > pInst->monitorParas.tsMonitorInterval * 1000) {
+    if (t - pClient->lastCheckTime > pInst->serverCfg.monitorParas.tsMonitorInterval * 1000) {
      pClient->lastCheckTime = t;
    } else {
      continue;
@ -686,7 +685,7 @@ static void monitorSendAllSlowLog() {
 static void monitorSendAllSlowLogFromTempDir(int64_t clusterId) {
  SAppInstInfo* pInst = getAppInstByClusterId((int64_t)clusterId);

-  if (pInst == NULL || !pInst->monitorParas.tsEnableMonitor) {
+  if (pInst == NULL || !pInst->serverCfg.monitorParas.tsEnableMonitor) {
    tscInfo("[monitor] monitor is disabled, skip send slow log");
    return;
  }
@ -933,3 +932,100 @@ int32_t monitorPutData2MonitorQueue(MonitorSlowLogData data) {
  }
  return 0;
 }
+
+int32_t reportCB(void* param, SDataBuf* pMsg, int32_t code) {
+  taosMemoryFree(pMsg->pData);
+  taosMemoryFree(pMsg->pEpSet);
+  tscDebug("[del report]delete reportCB code:%d", code);
+  return 0;
+}
+
+int32_t senAuditInfo(STscObj* pTscObj, void* pReq, int32_t len, uint64_t requestId) {
+  SMsgSendInfo* sendInfo = taosMemoryCalloc(1, sizeof(SMsgSendInfo));
+  if (sendInfo == NULL) {
+    tscError("[del report]failed to allocate memory for sendInfo");
+    return terrno;
+  }
+
+  sendInfo->msgInfo = (SDataBuf){.pData = pReq, .len = len, .handle = NULL};
+
+  sendInfo->requestId = requestId;
+  sendInfo->requestObjRefId = 0;
+  sendInfo->param = NULL;
+  sendInfo->fp = reportCB;
+  sendInfo->msgType = TDMT_MND_AUDIT;
+
+  SEpSet epSet = getEpSet_s(&pTscObj->pAppInfo->mgmtEp);
+
+  int32_t code = asyncSendMsgToServer(pTscObj->pAppInfo->pTransporter, &epSet, NULL, sendInfo);
+  if (code != 0) {
+    tscError("[del report]failed to send msg to server, code:%d", code);
+    taosMemoryFree(sendInfo);
+    return code;
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
+static void reportDeleteSql(SRequestObj* pRequest) {
+  SDeleteStmt* pStmt = (SDeleteStmt*)pRequest->pQuery->pRoot;
+  STscObj*     pTscObj = pRequest->pTscObj;
+
+  if (pTscObj == NULL || pTscObj->pAppInfo == NULL) {
+    tscError("[del report]invalid tsc obj");
+    return;
+  }
+
+  if(pTscObj->pAppInfo->serverCfg.enableAuditDelete == 0) {
+    tscDebug("[del report]audit delete is disabled");
+    return;
+  }
+
+  if (pRequest->code != TSDB_CODE_SUCCESS) {
+    tscDebug("[del report]delete request result code:%d", pRequest->code);
+    return;
+  }
+
+  if (nodeType(pStmt->pFromTable) != QUERY_NODE_REAL_TABLE) {
+    tscError("[del report]invalid from table node type:%d", nodeType(pStmt->pFromTable));
+    return;
+  }
+
+  SRealTableNode* pTable = (SRealTableNode*)pStmt->pFromTable;
+  SAuditReq       req;
+  req.pSql = pRequest->sqlstr;
+  req.sqlLen = pRequest->sqlLen;
+  TAOS_UNUSED(tsnprintf(req.table, TSDB_TABLE_NAME_LEN, "%s", pTable->table.tableName));
+  TAOS_UNUSED(tsnprintf(req.db, TSDB_DB_FNAME_LEN, "%s", pTable->table.dbName));
+  TAOS_UNUSED(tsnprintf(req.operation, AUDIT_OPERATION_LEN, "delete"));
+  int32_t tlen = tSerializeSAuditReq(NULL, 0, &req);
+  void*   pReq = taosMemoryCalloc(1, tlen);
+  if (pReq == NULL) {
+    tscError("[del report]failed to allocate memory for req");
+    return;
+  }
+
+  if (tSerializeSAuditReq(pReq, tlen, &req) < 0) {
+    tscError("[del report]failed to serialize req");
+    taosMemoryFree(pReq);
+    return;
+  }
+
+  int32_t code = senAuditInfo(pRequest->pTscObj, pReq, tlen, pRequest->requestId);
+  if (code != 0) {
+    tscError("[del report]failed to send audit info, code:%d", code);
+    taosMemoryFree(pReq);
+    return;
+  }
+  tscDebug("[del report]delete data, sql:%s", req.pSql);
+}
+
+void clientOperateReport(SRequestObj* pRequest) {
+  if (pRequest == NULL || pRequest->pQuery == NULL || pRequest->pQuery->pRoot == NULL) {
+    tscError("[del report]invalid request");
+    return;
+  }
+
+  if (QUERY_NODE_DELETE_STMT == nodeType(pRequest->pQuery->pRoot)) {
+    reportDeleteSql(pRequest);
+  }
+}
--- a/source/client/src/clientMsgHandler.c
+++ b/source/client/src/clientMsgHandler.c
@ -80,8 +80,8 @@ int32_t processConnectRsp(void* param, SDataBuf* pMsg, int32_t code) {
    goto End;
  }

-  if ((code = taosCheckVersionCompatibleFromStr(version, connectRsp.sVer, 3)) != 0) {
-    tscError("version not compatible. client version: %s, server version: %s", version, connectRsp.sVer);
+  if ((code = taosCheckVersionCompatibleFromStr(td_version, connectRsp.sVer, 3)) != 0) {
+    tscError("version not compatible. client version: %s, server version: %s", td_version, connectRsp.sVer);
    goto End;
  }

@ -135,7 +135,8 @@ int32_t processConnectRsp(void* param, SDataBuf* pMsg, int32_t code) {

  // update the appInstInfo
  pTscObj->pAppInfo->clusterId = connectRsp.clusterId;
-  pTscObj->pAppInfo->monitorParas = connectRsp.monitorParas;
+  pTscObj->pAppInfo->serverCfg.monitorParas = connectRsp.monitorParas;
+  pTscObj->pAppInfo->serverCfg.enableAuditDelete = connectRsp.enableAuditDelete;
  tscDebug("[monitor] paras from connect rsp, clusterId:%" PRIx64 " monitorParas threshold:%d scope:%d",
           connectRsp.clusterId, connectRsp.monitorParas.tsSlowLogThreshold, connectRsp.monitorParas.tsSlowLogScope);
  lastClusterId = connectRsp.clusterId;
@ -588,7 +589,8 @@ static int32_t buildShowVariablesRsp(SArray* pVars, SRetrieveTableRsp** pRsp) {
    return code;
  }

-  size_t rspSize = sizeof(SRetrieveTableRsp) + blockGetEncodeSize(pBlock) + PAYLOAD_PREFIX_LEN;
+  size_t dataEncodeBufSize = blockGetEncodeSize(pBlock);
+  size_t rspSize = sizeof(SRetrieveTableRsp) + dataEncodeBufSize + PAYLOAD_PREFIX_LEN;
  *pRsp = taosMemoryCalloc(1, rspSize);
  if (NULL == *pRsp) {
    code = terrno;
@ -603,7 +605,7 @@ static int32_t buildShowVariablesRsp(SArray* pVars, SRetrieveTableRsp** pRsp) {
  (*pRsp)->numOfRows = htobe64((int64_t)pBlock->info.rows);
  (*pRsp)->numOfCols = htonl(SHOW_VARIABLES_RESULT_COLS);

-  int32_t len = blockEncode(pBlock, (*pRsp)->data + PAYLOAD_PREFIX_LEN, SHOW_VARIABLES_RESULT_COLS);
+  int32_t len = blockEncode(pBlock, (*pRsp)->data + PAYLOAD_PREFIX_LEN, dataEncodeBufSize, SHOW_VARIABLES_RESULT_COLS);
  if(len < 0) {
    uError("buildShowVariablesRsp error, len:%d", len);
    code = terrno;
@ -741,7 +743,8 @@ static int32_t buildRetriveTableRspForCompactDb(SCompactDbRsp* pCompactDb, SRetr
    return code;
  }

-  size_t rspSize = sizeof(SRetrieveTableRsp) + blockGetEncodeSize(pBlock) + PAYLOAD_PREFIX_LEN;
+  size_t dataEncodeBufSize = blockGetEncodeSize(pBlock);
+  size_t rspSize = sizeof(SRetrieveTableRsp) + dataEncodeBufSize + PAYLOAD_PREFIX_LEN;
  *pRsp = taosMemoryCalloc(1, rspSize);
  if (NULL == *pRsp) {
    code = terrno;
@ -757,7 +760,7 @@ static int32_t buildRetriveTableRspForCompactDb(SCompactDbRsp* pCompactDb, SRetr
  (*pRsp)->numOfRows = htobe64((int64_t)pBlock->info.rows);
  (*pRsp)->numOfCols = htonl(COMPACT_DB_RESULT_COLS);

-  int32_t len = blockEncode(pBlock, (*pRsp)->data + PAYLOAD_PREFIX_LEN, COMPACT_DB_RESULT_COLS);
+  int32_t len = blockEncode(pBlock, (*pRsp)->data + PAYLOAD_PREFIX_LEN, dataEncodeBufSize, COMPACT_DB_RESULT_COLS);
  if(len < 0) {
    uError("buildRetriveTableRspForCompactDb error, len:%d", len);
    code = terrno;
--- a/source/client/src/clientRawBlockWrite.c
+++ b/source/client/src/clientRawBlockWrite.c
@ -1570,7 +1570,7 @@ int taos_write_raw_block_with_fields_with_reqid(TAOS* taos, int rows, char* pDat
  SHashObj*   pVgHash = NULL;

  SRequestObj* pRequest = NULL;
-  RAW_RETURN_CHECK(createRequest(*(int64_t*)taos, TSDB_SQL_INSERT, reqid, &pRequest));
+  RAW_RETURN_CHECK(buildRequest(*(int64_t*)taos, "", 0, NULL, false, &pRequest, reqid));

  uDebug(LOG_ID_TAG " write raw block with field, rows:%d, pData:%p, tbname:%s, fields:%p, numFields:%d", LOG_ID_VALUE,
         rows, pData, tbname, fields, numFields);
@ -1631,7 +1631,7 @@ int taos_write_raw_block_with_reqid(TAOS* taos, int rows, char* pData, const cha
  SHashObj*   pVgHash = NULL;

  SRequestObj* pRequest = NULL;
-  RAW_RETURN_CHECK(createRequest(*(int64_t*)taos, TSDB_SQL_INSERT, reqid, &pRequest));
+  RAW_RETURN_CHECK(buildRequest(*(int64_t*)taos, "", 0, NULL, false, &pRequest, reqid));

  uDebug(LOG_ID_TAG " write raw block, rows:%d, pData:%p, tbname:%s", LOG_ID_VALUE, rows, pData, tbname);

@ -1835,7 +1835,7 @@ end:

 static int32_t buildRawRequest(TAOS* taos, SRequestObj** pRequest, SCatalog** pCatalog, SRequestConnInfo* conn) {
  int32_t code = 0;
-  RAW_RETURN_CHECK(createRequest(*(int64_t*)taos, TSDB_SQL_INSERT, 0, pRequest));
+  RAW_RETURN_CHECK(buildRequest(*(int64_t*)taos, "", 0, NULL, false, pRequest, 0));
  (*pRequest)->syncQuery = true;
  if (!(*pRequest)->pDb) {
    code = TSDB_CODE_PAR_DB_NOT_SPECIFIED;
--- a/source/client/src/clientSml.c
+++ b/source/client/src/clientSml.c
@ -1695,7 +1695,7 @@ END:
 }

 void smlSetReqSQL(SRequestObj *request, char *lines[], char *rawLine, char *rawLineEnd) {
-  if (request->pTscObj->pAppInfo->monitorParas.tsSlowLogScope & SLOW_LOG_TYPE_INSERT) {
+  if (request->pTscObj->pAppInfo->serverCfg.monitorParas.tsSlowLogScope & SLOW_LOG_TYPE_INSERT) {
    int32_t len = 0;
    int32_t rlen = 0;
    char   *p = NULL;
@ -1740,7 +1740,7 @@ TAOS_RES *taos_schemaless_insert_inner(TAOS *taos, char *lines[], char *rawLine,
  SSmlHandle  *info    = NULL;
  int          cnt     = 0;
  while (1) {
-    SML_CHECK_CODE(createRequest(*(int64_t *)taos, TSDB_SQL_INSERT, reqid, &request));
+    SML_CHECK_CODE(buildRequest(*(int64_t*)taos, "", 0, NULL, false, &request, reqid));
    SSmlMsgBuf msg = {request->msgBufLen, request->msgBuf};
    request->code = smlBuildSmlInfo(taos, &info);
    SML_CHECK_CODE(request->code);
--- a/source/client/src/clientStmt2.c
+++ b/source/client/src/clientStmt2.c
@ -1068,6 +1068,34 @@ static int stmtFetchColFields2(STscStmt2* pStmt, int32_t* fieldNum, TAOS_FIELD_E

  return TSDB_CODE_SUCCESS;
 }
+
+static int stmtFetchStbColFields2(STscStmt2* pStmt, int32_t* fieldNum, TAOS_FIELD_STB** fields) {
+  if (pStmt->errCode != TSDB_CODE_SUCCESS) {
+    return pStmt->errCode;
+  }
+
+  if (STMT_TYPE_QUERY == pStmt->sql.type) {
+    tscError("invalid operation to get query column fileds");
+    STMT_ERR_RET(TSDB_CODE_TSC_STMT_API_ERROR);
+  }
+
+  STableDataCxt** pDataBlock = NULL;
+
+  if (pStmt->sql.stbInterlaceMode) {
+    pDataBlock = &pStmt->sql.siInfo.pDataCtx;
+  } else {
+    pDataBlock =
+        (STableDataCxt**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
+    if (NULL == pDataBlock) {
+      tscError("table %s not found in exec blockHash", pStmt->bInfo.tbFName);
+      STMT_ERR_RET(TSDB_CODE_APP_ERROR);
+    }
+  }
+
+  STMT_ERR_RET(qBuildStmtStbColFields(*pDataBlock, fieldNum, fields));
+
+  return TSDB_CODE_SUCCESS;
+}
 /*
 SArray* stmtGetFreeCol(STscStmt2* pStmt, int32_t* idx) {
  while (true) {
@ -1808,7 +1836,7 @@ _return:
  return code;
 }

-int stmtGetColFields2(TAOS_STMT2* stmt, int* nums, TAOS_FIELD_E** fields) {
+int stmtParseColFields2(TAOS_STMT2* stmt) {
  int32_t    code = 0;
  STscStmt2* pStmt = (STscStmt2*)stmt;
  int32_t    preCode = pStmt->errCode;
@ -1842,8 +1870,6 @@ int stmtGetColFields2(TAOS_STMT2* stmt, int* nums, TAOS_FIELD_E** fields) {
    STMT_ERRI_JRET(stmtParseSql(pStmt));
  }

-  STMT_ERRI_JRET(stmtFetchColFields2(stmt, nums, fields));
-
 _return:

  pStmt->errCode = preCode;
@ -1851,6 +1877,24 @@ _return:
  return code;
 }

+int stmtGetColFields2(TAOS_STMT2* stmt, int* nums, TAOS_FIELD_E** fields) {
+  int32_t code = stmtParseColFields2(stmt);
+  if (code != TSDB_CODE_SUCCESS) {
+    return code;
+  }
+
+  return stmtFetchColFields2(stmt, nums, fields);
+}
+
+int stmtGetStbColFields2(TAOS_STMT2* stmt, int* nums, TAOS_FIELD_STB** fields) {
+  int32_t code = stmtParseColFields2(stmt);
+  if (code != TSDB_CODE_SUCCESS) {
+    return code;
+  }
+
+  return stmtFetchStbColFields2(stmt, nums, fields);
+}
+
 int stmtGetParamNum2(TAOS_STMT2* stmt, int* nums) {
  STscStmt2* pStmt = (STscStmt2*)stmt;

--- a/source/client/src/clientTmq.c
+++ b/source/client/src/clientTmq.c
@ -2869,8 +2869,7 @@ int32_t tmqGetNextResInfo(TAOS_RES* res, bool convertUcs4, SReqResultInfo** pRes
    pRspObj->resInfo.precision = precision;

    pRspObj->resInfo.totalRows += pRspObj->resInfo.numOfRows;
-    int32_t code = setResultDataPtr(&pRspObj->resInfo, pRspObj->resInfo.fields, pRspObj->resInfo.numOfCols,
-                                    pRspObj->resInfo.numOfRows, convertUcs4);
+    int32_t code = setResultDataPtr(&pRspObj->resInfo, convertUcs4);
    if (code != 0) {
      return code;
    }
--- a/source/common/CMakeLists.txt
+++ b/source/common/CMakeLists.txt
@ -6,6 +6,8 @@ endif()

 add_library(common STATIC ${COMMON_SRC})

+add_dependencies(common lemon_sql)
+
 if(DEFINED GRANT_CFG_INCLUDE_DIR)
  add_definitions(-DGRANTS_CFG)
 endif()
--- a/source/common/src/systable.c
+++ b/source/common/src/systable.c
@ -165,8 +165,8 @@ static const SSysDbTableSchema userStbsSchema[] = {
 static const SSysDbTableSchema streamSchema[] = {
    {.name = "stream_name", .bytes = SYSTABLE_SCH_TABLE_NAME_LEN, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
    {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP, .sysInfo = false},
-    {.name = "stream_id", .bytes = 16 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
-    {.name = "history_id", .bytes = 16 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
+    {.name = "stream_id", .bytes = 19 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
+    {.name = "history_id", .bytes = 19 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
    {.name = "sql", .bytes = TSDB_SHOW_SQL_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
    {.name = "status", .bytes = 20 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
    {.name = "source_db", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
@ -190,9 +190,9 @@ static const SSysDbTableSchema streamTaskSchema[] = {
    {.name = "stage", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT, .sysInfo = false},
    {.name = "in_queue", .bytes = 20, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
    {.name = "process_total", .bytes = 14, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
-    {.name = "process_throughput", .bytes = 14, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
-    {.name = "out_total", .bytes = 14, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
-    {.name = "out_throughput", .bytes = 14, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
+    {.name = "process_throughput", .bytes = 15, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
+    {.name = "out_total", .bytes = 15, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
+    {.name = "out_throughput", .bytes = 15, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
 //    {.name = "dispatch_throughput", .bytes = 12, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
 //    {.name = "dispatch_total", .bytes = 12, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
 //    {.name = "out_queue", .bytes = 20, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
@ -437,6 +437,7 @@ static const SSysDbTableSchema userGrantsLogsSchema[] = {
    {.name = "state", .bytes = 1536 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
    {.name = "active", .bytes = 512 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
    {.name = "machine", .bytes = TSDB_GRANT_LOG_COL_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
+    {.name = "active_info", .bytes = 512 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
 };

 static const SSysDbTableSchema userMachinesSchema[] = {
--- a/source/common/src/tdatablock.c
+++ b/source/common/src/tdatablock.c
@ -18,6 +18,7 @@
 #include "tcompare.h"
 #include "tlog.h"
 #include "tname.h"
+#include "tglobal.h"

 #define MALLOC_ALIGN_BYTES 32

@ -86,7 +87,17 @@ int32_t getJsonValueLen(const char* data) {
  return dataLen;
 }

-int32_t colDataSetVal(SColumnInfoData* pColumnInfoData, uint32_t rowIndex, const char* pData, bool isNull) {
+static int32_t getDataLen(int32_t type, const char* pData) {
+  int32_t dataLen = 0;
+  if (type == TSDB_DATA_TYPE_JSON) {
+    dataLen = getJsonValueLen(pData);
+  } else {
+    dataLen = varDataTLen(pData);
+  }
+  return dataLen;
+}
+
+static int32_t colDataSetValHelp(SColumnInfoData* pColumnInfoData, uint32_t rowIndex, const char* pData, bool isNull) {
    if (isNull || pData == NULL) {
    // There is a placehold for each NULL value of binary or nchar type.
    if (IS_VAR_DATA_TYPE(pColumnInfoData->info.type)) {
@ -101,11 +112,9 @@ int32_t colDataSetVal(SColumnInfoData* pColumnInfoData, uint32_t rowIndex, const

  int32_t type = pColumnInfoData->info.type;
  if (IS_VAR_DATA_TYPE(type)) {
-    int32_t dataLen = 0;
-    if (type == TSDB_DATA_TYPE_JSON) {
-      dataLen = getJsonValueLen(pData);
-    } else {
-      dataLen = varDataTLen(pData);
+    int32_t dataLen = getDataLen(type, pData);
+    if (pColumnInfoData->varmeta.offset[rowIndex] > 0) {
+      pColumnInfoData->varmeta.length = pColumnInfoData->varmeta.offset[rowIndex];
    }

    SVarColAttr* pAttr = &pColumnInfoData->varmeta;
@ -144,6 +153,18 @@ int32_t colDataSetVal(SColumnInfoData* pColumnInfoData, uint32_t rowIndex, const
  return 0;
 }

+int32_t colDataSetVal(SColumnInfoData* pColumnInfoData, uint32_t rowIndex, const char* pData, bool isNull) {
+  if (IS_VAR_DATA_TYPE(pColumnInfoData->info.type)) {
+   pColumnInfoData->varmeta.offset[rowIndex] = -1;
+  }
+
+  return colDataSetValHelp(pColumnInfoData, rowIndex, pData, isNull);
+}
+
+int32_t colDataSetValOrCover(SColumnInfoData* pColumnInfoData, uint32_t rowIndex, const char* pData, bool isNull) {
+  return colDataSetValHelp(pColumnInfoData, rowIndex, pData, isNull);
+}
+
 int32_t colDataReassignVal(SColumnInfoData* pColumnInfoData, uint32_t dstRowIdx, uint32_t srcRowIdx,
                           const char* pData) {
  int32_t type = pColumnInfoData->info.type;
@ -3041,8 +3062,12 @@ int32_t buildCtbNameByGroupIdImpl(const char* stbFullName, uint64_t groupId, cha
 }

 // return length of encoded data, return -1 if failed
-int32_t blockEncode(const SSDataBlock* pBlock, char* data, int32_t numOfCols) {
-  blockDataCheck(pBlock, false);
+int32_t blockEncode(const SSDataBlock* pBlock, char* data, size_t dataBuflen, int32_t numOfCols) {
+  int32_t code = blockDataCheck(pBlock);
+  if (code != TSDB_CODE_SUCCESS) {
+    terrno = code;
+    return -1;
+  }

  int32_t dataLen = 0;

@ -3106,9 +3131,11 @@ int32_t blockEncode(const SSDataBlock* pBlock, char* data, int32_t numOfCols) {
    size_t metaSize = 0;
    if (IS_VAR_DATA_TYPE(pColRes->info.type)) {
      metaSize = numOfRows * sizeof(int32_t);
+      if(dataLen + metaSize > dataBuflen) goto _exit;
      memcpy(data, pColRes->varmeta.offset, metaSize);
    } else {
      metaSize = BitmapLen(numOfRows);
+      if(dataLen + metaSize > dataBuflen) goto _exit;
      memcpy(data, pColRes->nullbitmap, metaSize);
    }

@ -3127,12 +3154,14 @@ int32_t blockEncode(const SSDataBlock* pBlock, char* data, int32_t numOfCols) {
        }
        colSizes[col] += colSize;
        dataLen += colSize;
+        if(dataLen > dataBuflen) goto _exit;
        (void) memmove(data, pColData, colSize);
        data += colSize;
      }
    } else {
      colSizes[col] = colDataGetLength(pColRes, numOfRows);
      dataLen += colSizes[col];
+      if(dataLen > dataBuflen) goto _exit;
      if (pColRes->pData != NULL) {
        (void) memmove(data, pColRes->pData, colSizes[col]);
      }
@ -3156,7 +3185,14 @@ int32_t blockEncode(const SSDataBlock* pBlock, char* data, int32_t numOfCols) {

  *actualLen = dataLen;
  *groupId = pBlock->info.id.groupId;
+  if (dataLen > dataBuflen) goto _exit;
+
  return dataLen;
+
+_exit:
+  uError("blockEncode dataLen:%d, dataBuflen:%zu", dataLen, dataBuflen);
+  terrno = TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;
+  return -1;
 }

 int32_t blockDecode(SSDataBlock* pBlock, const char* pData, const char** pEndPos) {
@ -3286,11 +3322,15 @@ int32_t blockDecode(SSDataBlock* pBlock, const char* pData, const char** pEndPos

  *pEndPos = pStart;

-  blockDataCheck(pBlock, false);
-
+  code = blockDataCheck(pBlock);
+  if (code != TSDB_CODE_SUCCESS) {
+    terrno = code;
    return code;
  }

+  return TSDB_CODE_SUCCESS;
+}
+
 int32_t trimDataBlock(SSDataBlock* pBlock, int32_t totalRows, const bool* pBoolList) {
  //  int32_t totalRows = pBlock->info.rows;
  int32_t code = 0;
@ -3498,20 +3538,19 @@ int32_t blockDataGetSortedRows(SSDataBlock* pDataBlock, SArray* pOrderInfo) {
  return nextRowIdx;
 }

-void blockDataCheck(const SSDataBlock* pDataBlock, bool forceChk) {
-  return;
-  
-  if (NULL == pDataBlock || pDataBlock->info.rows == 0) {
-    return;
+#define BLOCK_DATA_CHECK_TRESSA(o)                      \
+  if (!(o)) {                                           \
+    uError("blockDataCheck failed! line:%d", __LINE__); \
+    return TSDB_CODE_INTERNAL_ERROR;                    \
+  }
+int32_t blockDataCheck(const SSDataBlock* pDataBlock) {
+  if (tsSafetyCheckLevel == TSDB_SAFETY_CHECK_LEVELL_NEVER || NULL == pDataBlock || pDataBlock->info.rows == 0) {
+    return TSDB_CODE_SUCCESS;
  }

-#define BLOCK_DATA_CHECK_TRESSA(o) ;
-//#define BLOCK_DATA_CHECK_TRESSA(o) A S S E R T(o)
-
  BLOCK_DATA_CHECK_TRESSA(pDataBlock->info.rows > 0);
-
-  if (!pDataBlock->info.dataLoad && !forceChk) {
-    return;
+  if (!pDataBlock->info.dataLoad) {
+    return TSDB_CODE_SUCCESS;
  }

  bool isVarType = false;
@ -3522,8 +3561,10 @@ void blockDataCheck(const SSDataBlock* pDataBlock, bool forceChk) {
  int32_t colNum = taosArrayGetSize(pDataBlock->pDataBlock);
  for (int32_t i = 0; i < colNum; ++i) {
    SColumnInfoData* pCol = (SColumnInfoData*)taosArrayGet(pDataBlock->pDataBlock, i);
+    BLOCK_DATA_CHECK_TRESSA(pCol != NULL);
    isVarType = IS_VAR_DATA_TYPE(pCol->info.type);
    checkRows = pDataBlock->info.rows;
+    if (pCol->info.noData == true) continue;

    if (isVarType) {
      BLOCK_DATA_CHECK_TRESSA(pCol->varmeta.offset);
@ -3531,25 +3572,37 @@ void blockDataCheck(const SSDataBlock* pDataBlock, bool forceChk) {
      BLOCK_DATA_CHECK_TRESSA(pCol->nullbitmap);
    }

-    nextPos = 0;
+    nextPos = -1;
    for (int64_t r = 0; r < checkRows; ++r) {
+      if (tsSafetyCheckLevel <= TSDB_SAFETY_CHECK_LEVELL_NORMAL) break;
      if (!colDataIsNull_s(pCol, r)) {
        BLOCK_DATA_CHECK_TRESSA(pCol->pData);
        BLOCK_DATA_CHECK_TRESSA(pCol->varmeta.length <= pCol->varmeta.allocLen);

        if (isVarType) {
          BLOCK_DATA_CHECK_TRESSA(pCol->varmeta.allocLen > 0);
-          BLOCK_DATA_CHECK_TRESSA(pCol->varmeta.offset[r] < pCol->varmeta.length);
+          BLOCK_DATA_CHECK_TRESSA(pCol->varmeta.offset[r] <= pCol->varmeta.length);
          if (pCol->reassigned) {
            BLOCK_DATA_CHECK_TRESSA(pCol->varmeta.offset[r] >= 0);
-          } else if (0 == r) {
+          } else if (0 == r || nextPos == -1) {
            nextPos = pCol->varmeta.offset[r];
          } else {
            BLOCK_DATA_CHECK_TRESSA(pCol->varmeta.offset[r] == nextPos);
          }

-          colLen = varDataTLen(pCol->pData + pCol->varmeta.offset[r]);
+          char*   pColData = pCol->pData + pCol->varmeta.offset[r];
+          int32_t colSize = 0;
+          if (pCol->info.type == TSDB_DATA_TYPE_JSON) {
+            colLen = getJsonValueLen(pColData);
+          } else {
+            colLen = varDataTLen(pColData);
+          }
+
+          if (pCol->info.type == TSDB_DATA_TYPE_JSON) {
+            BLOCK_DATA_CHECK_TRESSA(colLen >= CHAR_BYTES);
+          } else {
            BLOCK_DATA_CHECK_TRESSA(colLen >= VARSTR_HEADER_SIZE);
+          }
          BLOCK_DATA_CHECK_TRESSA(colLen <= pCol->info.bytes);

          if (pCol->reassigned) {
@ -3560,14 +3613,22 @@ void blockDataCheck(const SSDataBlock* pDataBlock, bool forceChk) {
          }

          typeValue = *(char*)(pCol->pData + pCol->varmeta.offset[r] + colLen - 1);
+        } else {
+          if (TSDB_DATA_TYPE_FLOAT == pCol->info.type) {
+            float v = 0;
+            GET_TYPED_DATA(v, float, pCol->info.type, colDataGetNumData(pCol, r));
+          } else if (TSDB_DATA_TYPE_DOUBLE == pCol->info.type) {
+            double v = 0;
+            GET_TYPED_DATA(v, double, pCol->info.type, colDataGetNumData(pCol, r));
          } else {
            GET_TYPED_DATA(typeValue, int64_t, pCol->info.type, colDataGetNumData(pCol, r));
          }
        }
      }
    }
+  }

-  return;
+  return TSDB_CODE_SUCCESS;
 }


--- a/source/common/src/tglobal.c
+++ b/source/common/src/tglobal.c
@ -119,6 +119,7 @@ bool     tsMonitorForceV2 = true;
 // audit
 bool    tsEnableAudit = true;
 bool    tsEnableAuditCreateTable = true;
+bool    tsEnableAuditDelete = true;
 int32_t tsAuditInterval = 5000;

 // telem
@ -139,6 +140,7 @@ bool    tsEnableCrashReport = true;
 #endif
 char  *tsClientCrashReportUri = "/ccrashreport";
 char  *tsSvrCrashReportUri = "/dcrashreport";
+int8_t tsSafetyCheckLevel = TSDB_SAFETY_CHECK_LEVELL_NORMAL;

 // schemaless
 bool tsSmlDot2Underline = true;
@ -609,6 +611,7 @@ static int32_t taosAddClientCfg(SConfig *pCfg) {
  TAOS_CHECK_RETURN(
      cfgAddInt64(pCfg, "randErrorDivisor", tsRandErrDivisor, 1, INT64_MAX, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
  TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "randErrorScope", tsRandErrScope, 0, INT64_MAX, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
+  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "safetyCheckLevel", tsSafetyCheckLevel, 0, 5, CFG_SCOPE_BOTH, CFG_DYN_BOTH));

  tsNumOfRpcThreads = tsNumOfCores / 2;
  tsNumOfRpcThreads = TRANGE(tsNumOfRpcThreads, 1, TSDB_MAX_RPC_THREADS);
@ -674,10 +677,10 @@ static int32_t taosAddSystemCfg(SConfig *pCfg) {
  TAOS_CHECK_RETURN(cfgAddString(pCfg, "os version", info.version, CFG_SCOPE_BOTH, CFG_DYN_NONE));
  TAOS_CHECK_RETURN(cfgAddString(pCfg, "os machine", info.machine, CFG_SCOPE_BOTH, CFG_DYN_NONE));

-  TAOS_CHECK_RETURN(cfgAddString(pCfg, "version", version, CFG_SCOPE_BOTH, CFG_DYN_NONE));
-  TAOS_CHECK_RETURN(cfgAddString(pCfg, "compatible_version", compatible_version, CFG_SCOPE_BOTH, CFG_DYN_NONE));
-  TAOS_CHECK_RETURN(cfgAddString(pCfg, "gitinfo", gitinfo, CFG_SCOPE_BOTH, CFG_DYN_NONE));
-  TAOS_CHECK_RETURN(cfgAddString(pCfg, "buildinfo", buildinfo, CFG_SCOPE_BOTH, CFG_DYN_NONE));
+  TAOS_CHECK_RETURN(cfgAddString(pCfg, "version", td_version, CFG_SCOPE_BOTH, CFG_DYN_NONE));
+  TAOS_CHECK_RETURN(cfgAddString(pCfg, "compatible_version", td_compatible_version, CFG_SCOPE_BOTH, CFG_DYN_NONE));
+  TAOS_CHECK_RETURN(cfgAddString(pCfg, "gitinfo", td_gitinfo, CFG_SCOPE_BOTH, CFG_DYN_NONE));
+  TAOS_CHECK_RETURN(cfgAddString(pCfg, "buildinfo", td_buildinfo, CFG_SCOPE_BOTH, CFG_DYN_NONE));
  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }

@ -775,6 +778,7 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "monitorForceV2", tsMonitorForceV2, CFG_SCOPE_SERVER, CFG_DYN_NONE));

  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "audit", tsEnableAudit, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER));
+  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "enableAuditDelete", tsEnableAuditDelete, CFG_SCOPE_SERVER, CFG_DYN_NONE));
  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "auditCreateTable", tsEnableAuditCreateTable, CFG_SCOPE_SERVER, CFG_DYN_NONE));
  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "auditInterval", tsAuditInterval, 500, 200000, CFG_SCOPE_SERVER, CFG_DYN_NONE));

@ -1303,6 +1307,9 @@ static int32_t taosSetClientCfg(SConfig *pCfg) {

  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tsmaDataDeleteMark");
  tsmaDataDeleteMark = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "safetyCheckLevel");
+  tsSafetyCheckLevel = pItem->i32;
  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }

@ -1485,6 +1492,9 @@ static int32_t taosSetServerCfg(SConfig *pCfg) {
  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "auditCreateTable");
  tsEnableAuditCreateTable = pItem->bval;

+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableAuditDelete");
+  tsEnableAuditDelete = pItem->bval;
+
  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "auditInterval");
  tsAuditInterval = pItem->i32;

@ -1641,6 +1651,9 @@ static int32_t taosSetServerCfg(SConfig *pCfg) {
  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "checkpointInterval");
  tsStreamCheckpointInterval = pItem->i32;

+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "concurrentCheckpoint");
+  tsMaxConcurrentCheckpoint = pItem->i32;
+
  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "streamSinkDataRate");
  tsSinkDataRate = pItem->fval;

@ -2040,7 +2053,8 @@ static int32_t taosCfgDynamicOptionsForServer(SConfig *pCfg, const char *name) {
                                         {"s3UploadDelaySec", &tsS3UploadDelaySec},
                                         {"supportVnodes", &tsNumOfSupportVnodes},
                                         {"experimental", &tsExperimental},
-                                         {"maxTsmaNum", &tsMaxTsmaNum}};
+                                         {"maxTsmaNum", &tsMaxTsmaNum},
+                                         {"safetyCheckLevel", &tsSafetyCheckLevel}};

    if ((code = taosCfgSetOption(debugOptions, tListLen(debugOptions), pItem, true)) != TSDB_CODE_SUCCESS) {
      code = taosCfgSetOption(options, tListLen(options), pItem, false);
@ -2296,7 +2310,8 @@ static int32_t taosCfgDynamicOptionsForClient(SConfig *pCfg, const char *name) {
                                         {"experimental", &tsExperimental},
                                         {"multiResultFunctionStarReturnTags", &tsMultiResultFunctionStarReturnTags},
                                         {"maxTsmaCalcDelay", &tsMaxTsmaCalcDelay},
-                                         {"tsmaDataDeleteMark", &tsmaDataDeleteMark}};
+                                         {"tsmaDataDeleteMark", &tsmaDataDeleteMark},
+                                         {"safetyCheckLevel", &tsSafetyCheckLevel}};

    if ((code = taosCfgSetOption(debugOptions, tListLen(debugOptions), pItem, true)) != TSDB_CODE_SUCCESS) {
      code = taosCfgSetOption(options, tListLen(options), pItem, false);
--- a/source/common/src/tmisce.c
+++ b/source/common/src/tmisce.c
@ -221,10 +221,9 @@ int32_t taosGenCrashJsonMsg(int signum, char** pMsg, int64_t clusterId, int64_t
  }
  TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "memory", tmp), NULL, _exit);

-  TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "version", version), NULL, _exit);
-  TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "buildInfo", buildinfo), NULL, _exit);
-
-  TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "gitInfo", gitinfo), NULL, _exit);
+  TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "version", td_version), NULL, _exit);
+  TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "buildInfo", td_buildinfo), NULL, _exit);
+  TAOS_CHECK_GOTO(tjsonAddStringToObject(pJson, "gitInfo", td_gitinfo), NULL, _exit);

  TAOS_CHECK_GOTO(tjsonAddIntegerToObject(pJson, "crashSig", signum), NULL, _exit);
  TAOS_CHECK_GOTO(tjsonAddIntegerToObject(pJson, "crashTs", taosGetTimestampUs()), NULL, _exit);
--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@ -40,7 +40,7 @@
 #define TD_MSG_RANGE_CODE_
 #include "tmsgdef.h"

-#include "tanal.h"
+#include "tanalytics.h"
 #include "tcol.h"
 #include "tlog.h"

@ -567,6 +567,7 @@ int32_t tSerializeSClientHbBatchRsp(void *buf, int32_t bufLen, const SClientHbBa
    TAOS_CHECK_EXIT(tSerializeSClientHbRsp(&encoder, pRsp));
  }
  TAOS_CHECK_EXIT(tSerializeSMonitorParas(&encoder, &pBatchRsp->monitorParas));
+  TAOS_CHECK_EXIT(tEncodeI8(&encoder, pBatchRsp->enableAuditDelete));
  tEndEncode(&encoder);

 _exit:
@ -609,6 +610,12 @@ int32_t tDeserializeSClientHbBatchRsp(void *buf, int32_t bufLen, SClientHbBatchR
    TAOS_CHECK_EXIT(tDeserializeSMonitorParas(&decoder, &pBatchRsp->monitorParas));
  }

+  if (!tDecodeIsEnd(&decoder)) {
+    TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pBatchRsp->enableAuditDelete));
+  } else {
+    pBatchRsp->enableAuditDelete = 0;
+  }
+
  tEndDecode(&decoder);

 _exit:
@ -1813,6 +1820,60 @@ _exit:

 void tFreeSDropUserReq(SDropUserReq *pReq) { FREESQL(); }

+int32_t tSerializeSAuditReq(void *buf, int32_t bufLen, SAuditReq *pReq) {
+  SEncoder encoder = {0};
+  int32_t  code = 0;
+  int32_t  lino;
+  int32_t  tlen;
+  tEncoderInit(&encoder, buf, bufLen);
+
+  TAOS_CHECK_EXIT(tStartEncode(&encoder));
+
+  TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->operation));
+  TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->db));
+  TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->table));
+  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->sqlLen));
+  TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->pSql));
+
+  tEndEncode(&encoder);
+
+_exit:
+  if (code) {
+    tlen = code;
+  } else {
+    tlen = encoder.pos;
+  }
+  tEncoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSAuditReq(void *buf, int32_t bufLen, SAuditReq *pReq) {
+  SDecoder decoder = {0};
+  int32_t  code = 0;
+  int32_t  lino;
+  tDecoderInit(&decoder, buf, bufLen);
+
+  TAOS_CHECK_EXIT(tStartDecode(&decoder));
+
+  TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->operation));
+  TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->db));
+  TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->table));
+  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->sqlLen));
+  if (pReq->sqlLen > 0) {
+    pReq->pSql = taosMemoryMalloc(pReq->sqlLen + 1);
+    if (pReq->pSql == NULL) {
+      TAOS_CHECK_EXIT(terrno);
+    }
+    TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pReq->pSql));
+  }
+  tEndDecode(&decoder);
+_exit:
+  tDecoderClear(&decoder);
+  return code;
+}
+
+void tFreeSAuditReq(SAuditReq *pReq) { taosMemoryFreeClear(pReq->pSql); }
+
 SIpWhiteList *cloneIpWhiteList(SIpWhiteList *pIpWhiteList) {
  if (pIpWhiteList == NULL) return NULL;

@ -2105,7 +2166,7 @@ int32_t tSerializeRetrieveAnalAlgoRsp(void *buf, int32_t bufLen, SRetrieveAnalAl
  int32_t numOfAlgos = 0;
  void   *pIter = taosHashIterate(pRsp->hash, NULL);
  while (pIter != NULL) {
-    SAnalUrl   *pUrl = pIter;
+    SAnalyticsUrl   *pUrl = pIter;
    size_t      nameLen = 0;
    const char *name = taosHashGetKey(pIter, &nameLen);
    if (nameLen > 0 && nameLen <= TSDB_ANAL_ALGO_KEY_LEN && pUrl->urlLen > 0) {
@ -2120,7 +2181,7 @@ int32_t tSerializeRetrieveAnalAlgoRsp(void *buf, int32_t bufLen, SRetrieveAnalAl

  pIter = taosHashIterate(pRsp->hash, NULL);
  while (pIter != NULL) {
-    SAnalUrl   *pUrl = pIter;
+    SAnalyticsUrl   *pUrl = pIter;
    size_t      nameLen = 0;
    const char *name = taosHashGetKey(pIter, &nameLen);
    if (nameLen > 0 && pUrl->urlLen > 0) {
@ -2164,7 +2225,7 @@ int32_t tDeserializeRetrieveAnalAlgoRsp(void *buf, int32_t bufLen, SRetrieveAnal
  int32_t      nameLen;
  int32_t      type;
  char         name[TSDB_ANAL_ALGO_KEY_LEN];
-  SAnalUrl url = {0};
+  SAnalyticsUrl url = {0};

  TAOS_CHECK_EXIT(tStartDecode(&decoder));
  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->ver));
@ -2184,7 +2245,7 @@ int32_t tDeserializeRetrieveAnalAlgoRsp(void *buf, int32_t bufLen, SRetrieveAnal
      TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void **)&url.url, NULL) < 0);
    }

-    TAOS_CHECK_EXIT(taosHashPut(pRsp->hash, name, nameLen, &url, sizeof(SAnalUrl)));
+    TAOS_CHECK_EXIT(taosHashPut(pRsp->hash, name, nameLen, &url, sizeof(SAnalyticsUrl)));
  }

  tEndDecode(&decoder);
@ -2197,7 +2258,7 @@ _exit:
 void tFreeRetrieveAnalAlgoRsp(SRetrieveAnalAlgoRsp *pRsp) {
  void *pIter = taosHashIterate(pRsp->hash, NULL);
  while (pIter != NULL) {
-    SAnalUrl *pUrl = (SAnalUrl *)pIter;
+    SAnalyticsUrl *pUrl = (SAnalyticsUrl *)pIter;
    taosMemoryFree(pUrl->url);
    pIter = taosHashIterate(pRsp->hash, pIter);
  }
@ -6294,6 +6355,7 @@ int32_t tSerializeSConnectRsp(void *buf, int32_t bufLen, SConnectRsp *pRsp) {
  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pRsp->authVer));
  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRsp->whiteListVer));
  TAOS_CHECK_EXIT(tSerializeSMonitorParas(&encoder, &pRsp->monitorParas));
+  TAOS_CHECK_EXIT(tEncodeI8(&encoder, pRsp->enableAuditDelete));
  tEndEncode(&encoder);

 _exit:
@ -6345,6 +6407,11 @@ int32_t tDeserializeSConnectRsp(void *buf, int32_t bufLen, SConnectRsp *pRsp) {
  if (!tDecodeIsEnd(&decoder)) {
    TAOS_CHECK_EXIT(tDeserializeSMonitorParas(&decoder, &pRsp->monitorParas));
  }
+  if (!tDecodeIsEnd(&decoder)) {
+    TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pRsp->enableAuditDelete));
+  } else {
+    pRsp->enableAuditDelete = 0;
+  }
  tEndDecode(&decoder);

 _exit:
--- a/source/dnode/mgmt/exe/dmMain.c
+++ b/source/dnode/mgmt/exe/dmMain.c
@ -297,12 +297,13 @@ static void dmPrintArgs(int32_t argc, char const *argv[]) {
 static void dmGenerateGrant() { mndGenerateMachineCode(); }

 static void dmPrintVersion() {
-  printf("%s\n%sd version: %s compatible_version: %s\n", TD_PRODUCT_NAME, CUS_PROMPT, version, compatible_version);
-  printf("git: %s\n", gitinfo);
+  printf("%s\n%sd version: %s compatible_version: %s\n", TD_PRODUCT_NAME, CUS_PROMPT, td_version,
+         td_compatible_version);
+  printf("git: %s\n", td_gitinfo);
 #ifdef TD_ENTERPRISE
-  printf("gitOfInternal: %s\n", gitinfoOfInternal);
+  printf("gitOfInternal: %s\n", td_gitinfoOfInternal);
 #endif
-  printf("build: %s\n", buildinfo);
+  printf("build: %s\n", td_buildinfo);
 }

 static void dmPrintHelp() {
--- a/source/dnode/mgmt/mgmt_dnode/src/dmHandle.c
+++ b/source/dnode/mgmt/mgmt_dnode/src/dmHandle.c
@ -18,7 +18,7 @@
 #include "dmInt.h"
 #include "monitor.h"
 #include "systable.h"
-#include "tanal.h"
+#include "tanalytics.h"
 #include "tchecksum.h"

 extern SConfig *tsCfg;
@ -547,8 +547,8 @@ int32_t dmProcessRetrieve(SDnodeMgmt *pMgmt, SRpcMsg *pMsg) {
  }

  size_t numOfCols = taosArrayGetSize(pBlock->pDataBlock);
-  size = sizeof(SRetrieveMetaTableRsp) + sizeof(int32_t) + sizeof(SSysTableSchema) * numOfCols +
-         blockDataGetSize(pBlock) + blockDataGetSerialMetaSize(numOfCols);
+  size_t dataEncodeBufSize = blockGetEncodeSize(pBlock);
+  size = sizeof(SRetrieveMetaTableRsp) + sizeof(int32_t) + sizeof(SSysTableSchema) * numOfCols + dataEncodeBufSize;

  SRetrieveMetaTableRsp *pRsp = rpcMallocCont(size);
  if (pRsp == NULL) {
@ -573,7 +573,7 @@ int32_t dmProcessRetrieve(SDnodeMgmt *pMgmt, SRpcMsg *pMsg) {
    pStart += sizeof(SSysTableSchema);
  }

-  int32_t len = blockEncode(pBlock, pStart, numOfCols);
+  int32_t len = blockEncode(pBlock, pStart, dataEncodeBufSize, numOfCols);
  if (len < 0) {
    dError("failed to retrieve data since %s", tstrerror(code));
    blockDataDestroy(pBlock);
--- a/source/dnode/mgmt/mgmt_dnode/src/dmInt.c
+++ b/source/dnode/mgmt/mgmt_dnode/src/dmInt.c
@ -16,7 +16,7 @@
 #define _DEFAULT_SOURCE
 #include "dmInt.h"
 #include "libs/function/tudf.h"
-#include "tanal.h"
+#include "tanalytics.h"

 static int32_t dmStartMgmt(SDnodeMgmt *pMgmt) {
  int32_t code = 0;
@ -85,7 +85,7 @@ static int32_t dmOpenMgmt(SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
    dError("failed to start udfd since %s", tstrerror(code));
  }

-  if ((code = taosAnalInit()) != 0) {
+  if ((code = taosAnalyticsInit()) != 0) {
    dError("failed to init analysis env since %s", tstrerror(code));
  }

--- a/source/dnode/mgmt/mgmt_mnode/src/mmHandle.c
+++ b/source/dnode/mgmt/mgmt_mnode/src/mmHandle.c
@ -212,6 +212,7 @@ SArray *mmGetMsgHandles() {
  if (dmSetMgmtHandle(pArray, TDMT_MND_DROP_VIEW, mmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_MND_VIEW_META, mmPutMsgToReadQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_MND_STATIS, mmPutMsgToReadQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_AUDIT, mmPutMsgToReadQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_MND_KILL_COMPACT, mmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_MND_CONFIG_CLUSTER, mmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_VND_QUERY_COMPACT_PROGRESS_RSP, mmPutMsgToReadQueue, 0) == NULL) goto _OVER;
--- a/source/dnode/mgmt/node_mgmt/src/dmEnv.c
+++ b/source/dnode/mgmt/node_mgmt/src/dmEnv.c
@ -21,7 +21,7 @@
 #include "tgrant.h"
 #include "tcompare.h"
 #include "tcs.h"
-#include "tanal.h"
+#include "tanalytics.h"
 // clang-format on

 #define DM_INIT_AUDIT()                       \
@ -209,7 +209,7 @@ void dmCleanup() {
    dError("failed to close udfc");
  }
  udfStopUdfd();
-  taosAnalCleanup();
+  taosAnalyticsCleanup();
  taosStopCacheRefreshWorker();
  (void)dmDiskClose();
  DestroyRegexCache();
--- a/source/dnode/mgmt/node_mgmt/src/dmTransport.c
+++ b/source/dnode/mgmt/node_mgmt/src/dmTransport.c
@ -16,7 +16,7 @@
 #define _DEFAULT_SOURCE
 #include "dmMgmt.h"
 #include "qworker.h"
-#include "tanal.h"
+#include "tanalytics.h"
 #include "tversion.h"

 static inline void dmSendRsp(SRpcMsg *pMsg) {
@ -138,9 +138,9 @@ static void dmProcessRpcMsg(SDnode *pDnode, SRpcMsg *pRpc, SEpSet *pEpSet) {
          pRpc->info.handle, pRpc->contLen, pRpc->code, pRpc->info.ahandle, pRpc->info.refId);

  int32_t svrVer = 0;
-  code = taosVersionStrToInt(version, &svrVer);
+  code = taosVersionStrToInt(td_version, &svrVer);
  if (code != 0) {
-    dError("failed to convert version string:%s to int, code:%d", version, code);
+    dError("failed to convert version string:%s to int, code:%d", td_version, code);
    goto _OVER;
  }
  if ((code = taosCheckVersionCompatible(pRpc->info.cliVer, svrVer, 3)) != 0) {
@ -434,8 +434,8 @@ int32_t dmInitClient(SDnode *pDnode) {
  rpcInit.startReadTimer = 1;
  rpcInit.readTimeout = tsReadTimeout;

-  if (taosVersionStrToInt(version, &(rpcInit.compatibilityVer)) != 0) {
-    dError("failed to convert version string:%s to int", version);
+  if (taosVersionStrToInt(td_version, &rpcInit.compatibilityVer) != 0) {
+    dError("failed to convert version string:%s to int", td_version);
  }

  pTrans->clientRpc = rpcOpen(&rpcInit);
@ -483,8 +483,8 @@ int32_t dmInitStatusClient(SDnode *pDnode) {
  rpcInit.startReadTimer = 0;
  rpcInit.readTimeout = 0;

-  if (taosVersionStrToInt(version, &(rpcInit.compatibilityVer)) != 0) {
-    dError("failed to convert version string:%s to int", version);
+  if (taosVersionStrToInt(td_version, &rpcInit.compatibilityVer) != 0) {
+    dError("failed to convert version string:%s to int", td_version);
  }

  pTrans->statusRpc = rpcOpen(&rpcInit);
@ -533,8 +533,8 @@ int32_t dmInitSyncClient(SDnode *pDnode) {
  rpcInit.startReadTimer = 1;
  rpcInit.readTimeout = tsReadTimeout;

-  if (taosVersionStrToInt(version, &(rpcInit.compatibilityVer)) != 0) {
-    dError("failed to convert version string:%s to int", version);
+  if (taosVersionStrToInt(td_version, &rpcInit.compatibilityVer) != 0) {
+    dError("failed to convert version string:%s to int", td_version);
  }

  pTrans->syncRpc = rpcOpen(&rpcInit);
@ -588,8 +588,8 @@ int32_t dmInitServer(SDnode *pDnode) {
  rpcInit.compressSize = tsCompressMsgSize;
  rpcInit.shareConnLimit = tsShareConnLimit * 16;

-  if (taosVersionStrToInt(version, &(rpcInit.compatibilityVer)) != 0) {
-    dError("failed to convert version string:%s to int", version);
+  if (taosVersionStrToInt(td_version, &rpcInit.compatibilityVer) != 0) {
+    dError("failed to convert version string:%s to int", td_version);
  }

  pTrans->serverRpc = rpcOpen(&rpcInit);
--- a/source/dnode/mgmt/test/sut/src/client.cpp
+++ b/source/dnode/mgmt/test/sut/src/client.cpp
@ -54,7 +54,7 @@ void TestClient::DoInit() {
  rpcInit.parent = this;
  // rpcInit.secret = (char*)secretEncrypt;
  // rpcInit.spi = 1;
-  taosVersionStrToInt(version, &(rpcInit.compatibilityVer));
+  taosVersionStrToInt(td_version, &rpcInit.compatibilityVer);

  clientRpc = rpcOpen(&rpcInit);
  ASSERT(clientRpc);
--- a/source/dnode/mnode/impl/CMakeLists.txt
+++ b/source/dnode/mnode/impl/CMakeLists.txt
@ -18,7 +18,7 @@ if(TD_ENTERPRISE)
  endif()

  if(${BUILD_WITH_ANALYSIS})
-    add_definitions(-DUSE_ANAL)
+    add_definitions(-DUSE_ANALYTICS)
  endif()
 endif()

--- a/source/dnode/mnode/impl/src/mndAnode.c
+++ b/source/dnode/mnode/impl/src/mndAnode.c
@ -21,10 +21,10 @@
 #include "mndShow.h"
 #include "mndTrans.h"
 #include "mndUser.h"
-#include "tanal.h"
+#include "tanalytics.h"
 #include "tjson.h"

-#ifdef USE_ANAL
+#ifdef USE_ANALYTICS

 #define TSDB_ANODE_VER_NUMBER   1
 #define TSDB_ANODE_RESERVE_SIZE 64
@ -806,7 +806,7 @@ static int32_t mndProcessAnalAlgoReq(SRpcMsg *pReq) {
  SSdb                *pSdb = pMnode->pSdb;
  int32_t              code = -1;
  SAnodeObj           *pObj = NULL;
-  SAnalUrl             url;
+  SAnalyticsUrl             url;
  int32_t              nameLen;
  char                 name[TSDB_ANAL_ALGO_KEY_LEN];
  SRetrieveAnalAlgoReq req = {0};
@ -838,7 +838,7 @@ static int32_t mndProcessAnalAlgoReq(SRpcMsg *pReq) {
          SAnodeAlgo *algo = taosArrayGet(algos, a);
          nameLen = 1 + tsnprintf(name, sizeof(name) - 1, "%d:%s", url.type, algo->name);

-          SAnalUrl *pOldUrl = taosHashAcquire(rsp.hash, name, nameLen);
+          SAnalyticsUrl *pOldUrl = taosHashAcquire(rsp.hash, name, nameLen);
          if (pOldUrl == NULL || (pOldUrl != NULL && pOldUrl->anode < url.anode)) {
            if (pOldUrl != NULL) {
              taosMemoryFreeClear(pOldUrl->url);
@ -855,7 +855,7 @@ static int32_t mndProcessAnalAlgoReq(SRpcMsg *pReq) {

            url.urlLen = 1 + tsnprintf(url.url, TSDB_ANAL_ANODE_URL_LEN + TSDB_ANAL_ALGO_TYPE_LEN, "%s/%s", pAnode->url,
                                      taosAnalAlgoUrlStr(url.type));
-            if (taosHashPut(rsp.hash, name, nameLen, &url, sizeof(SAnalUrl)) != 0) {
+            if (taosHashPut(rsp.hash, name, nameLen, &url, sizeof(SAnalyticsUrl)) != 0) {
              taosMemoryFree(url.url);
              sdbRelease(pSdb, pAnode);
              goto _OVER;
--- a/source/dnode/mnode/impl/src/mndDnode.c
+++ b/source/dnode/mnode/impl/src/mndDnode.c
@ -86,6 +86,7 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq);
 static int32_t mndProcessNotifyReq(SRpcMsg *pReq);
 static int32_t mndProcessRestoreDnodeReq(SRpcMsg *pReq);
 static int32_t mndProcessStatisReq(SRpcMsg *pReq);
+static int32_t mndProcessAuditReq(SRpcMsg *pReq);
 static int32_t mndProcessUpdateDnodeInfoReq(SRpcMsg *pReq);
 static int32_t mndProcessCreateEncryptKeyReq(SRpcMsg *pRsp);
 static int32_t mndProcessCreateEncryptKeyRsp(SRpcMsg *pRsp);
@ -125,6 +126,7 @@ int32_t mndInitDnode(SMnode *pMnode) {
  mndSetMsgHandle(pMnode, TDMT_MND_SHOW_VARIABLES, mndProcessShowVariablesReq);
  mndSetMsgHandle(pMnode, TDMT_MND_RESTORE_DNODE, mndProcessRestoreDnodeReq);
  mndSetMsgHandle(pMnode, TDMT_MND_STATIS, mndProcessStatisReq);
+  mndSetMsgHandle(pMnode, TDMT_MND_AUDIT, mndProcessAuditReq);
  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_ENCRYPT_KEY, mndProcessCreateEncryptKeyReq);
  mndSetMsgHandle(pMnode, TDMT_DND_CREATE_ENCRYPT_KEY_RSP, mndProcessCreateEncryptKeyRsp);
  mndSetMsgHandle(pMnode, TDMT_MND_UPDATE_DNODE_INFO, mndProcessUpdateDnodeInfoReq);
@ -603,6 +605,24 @@ static int32_t mndProcessStatisReq(SRpcMsg *pReq) {
  return 0;
 }

+static int32_t mndProcessAuditReq(SRpcMsg *pReq) {
+  mTrace("process audit req:%p", pReq);
+  if (tsEnableAudit && tsEnableAuditDelete) {
+    SMnode   *pMnode = pReq->info.node;
+    SAuditReq auditReq = {0};
+
+    TAOS_CHECK_RETURN(tDeserializeSAuditReq(pReq->pCont, pReq->contLen, &auditReq));
+
+    mDebug("received audit req:%s, %s, %s, %s", auditReq.operation, auditReq.db, auditReq.table, auditReq.pSql);
+
+    auditAddRecord(pReq, pMnode->clusterId, auditReq.operation, auditReq.db, auditReq.table, auditReq.pSql,
+                   auditReq.sqlLen);
+
+    tFreeSAuditReq(&auditReq);
+  }
+  return 0;
+}
+
 static int32_t mndUpdateDnodeObj(SMnode *pMnode, SDnodeObj *pDnode) {
  int32_t       code = 0, lino = 0;
  SDnodeInfoReq infoReq = {0};
--- a/source/dnode/mnode/impl/src/mndMain.c
+++ b/source/dnode/mnode/impl/src/mndMain.c
@ -1021,7 +1021,7 @@ int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pClusterInfo, SMonVgr
  }

  // cluster info
-  tstrncpy(pClusterInfo->version, version, sizeof(pClusterInfo->version));
+  tstrncpy(pClusterInfo->version, td_version, sizeof(pClusterInfo->version));
  pClusterInfo->monitor_interval = tsMonitorInterval;
  pClusterInfo->connections_total = mndGetNumOfConnections(pMnode);
  pClusterInfo->dbs_total = sdbGetSize(pSdb, SDB_DB);
--- a/source/dnode/mnode/impl/src/mndProfile.c
+++ b/source/dnode/mnode/impl/src/mndProfile.c
@ -239,8 +239,8 @@ static int32_t mndProcessConnectReq(SRpcMsg *pReq) {
    goto _OVER;
  }

-  if ((code = taosCheckVersionCompatibleFromStr(connReq.sVer, version, 3)) != 0) {
-    mGError("version not compatible. client version: %s, server version: %s", connReq.sVer, version);
+  if ((code = taosCheckVersionCompatibleFromStr(connReq.sVer, td_version, 3)) != 0) {
+    mGError("version not compatible. client version: %s, server version: %s", connReq.sVer, td_version);
    goto _OVER;
  }

@ -304,12 +304,13 @@ static int32_t mndProcessConnectReq(SRpcMsg *pReq) {
  connectRsp.monitorParas.tsSlowLogScope = tsSlowLogScope;
  connectRsp.monitorParas.tsSlowLogMaxLen = tsSlowLogMaxLen;
  connectRsp.monitorParas.tsSlowLogThreshold = tsSlowLogThreshold;
+  connectRsp.enableAuditDelete = tsEnableAuditDelete;
  tstrncpy(connectRsp.monitorParas.tsSlowLogExceptDb, tsSlowLogExceptDb, TSDB_DB_NAME_LEN);
  connectRsp.whiteListVer = pUser->ipWhiteListVer;

-  (void)strcpy(connectRsp.sVer, version);
-  (void)snprintf(connectRsp.sDetailVer, sizeof(connectRsp.sDetailVer), "ver:%s\nbuild:%s\ngitinfo:%s", version,
-                 buildinfo, gitinfo);
+  tstrncpy(connectRsp.sVer, td_version, sizeof(connectRsp.sVer));
+  (void)snprintf(connectRsp.sDetailVer, sizeof(connectRsp.sDetailVer), "ver:%s\nbuild:%s\ngitinfo:%s", td_version,
+                 td_buildinfo, td_gitinfo);
  mndGetMnodeEpSet(pMnode, &connectRsp.epSet);

  int32_t contLen = tSerializeSConnectRsp(NULL, 0, &connectRsp);
@ -707,6 +708,7 @@ static int32_t mndProcessHeartBeatReq(SRpcMsg *pReq) {
  tstrncpy(batchRsp.monitorParas.tsSlowLogExceptDb, tsSlowLogExceptDb, TSDB_DB_NAME_LEN);
  batchRsp.monitorParas.tsSlowLogMaxLen = tsSlowLogMaxLen;
  batchRsp.monitorParas.tsSlowLogScope = tsSlowLogScope;
+  batchRsp.enableAuditDelete = tsEnableAuditDelete;

  int32_t sz = taosArrayGetSize(batchReq.reqs);
  for (int i = 0; i < sz; i++) {
@ -811,7 +813,7 @@ static int32_t mndProcessSvrVerReq(SRpcMsg *pReq) {
  int32_t       code = 0;
  int32_t       lino = 0;
  SServerVerRsp rsp = {0};
-  tstrncpy(rsp.ver, version, sizeof(rsp.ver));
+  tstrncpy(rsp.ver, td_version, sizeof(rsp.ver));

  int32_t contLen = tSerializeSServerVerRsp(NULL, 0, &rsp);
  if (contLen < 0) {
--- a/source/dnode/mnode/impl/src/mndScheduler.c
+++ b/source/dnode/mnode/impl/src/mndScheduler.c
@ -242,13 +242,13 @@ static int32_t doAddSinkTask(SStreamObj* pStream, SMnode* pMnode, SVgObj* pVgrou
  SArray** pTaskList = (isFillhistory) ? taosArrayGetLast(pStream->pHTasksList) : taosArrayGetLast(pStream->tasks);

  SStreamTask* pTask = NULL;
-  int32_t code = tNewStreamTask(uid, TASK_LEVEL__SINK, pEpset, isFillhistory, 0, *pTaskList, pStream->conf.fillHistory,
+  int32_t code = tNewStreamTask(uid, TASK_LEVEL__SINK, pEpset, isFillhistory, 0, 0, *pTaskList, pStream->conf.fillHistory,
                                pStream->subTableWithoutMd5, &pTask);
  if (code != 0) {
    return code;
  }

-  mDebug("doAddSinkTask taskId:%s, vgId:%d, isFillHistory:%d", pTask->id.idStr, pVgroup->vgId, isFillhistory);
+  mDebug("doAddSinkTask taskId:%s, %p vgId:%d, isFillHistory:%d", pTask->id.idStr, pTask, pVgroup->vgId, isFillhistory);

  pTask->info.nodeId = pVgroup->vgId;
  pTask->info.epSet = mndGetVgroupEpset(pMnode, pVgroup);
@ -356,20 +356,22 @@ static int32_t buildSourceTask(SStreamObj* pStream, SEpSet* pEpset, bool isFillh
  uint64_t uid = (isFillhistory) ? pStream->hTaskUid : pStream->uid;
  SArray** pTaskList = (isFillhistory) ? taosArrayGetLast(pStream->pHTasksList) : taosArrayGetLast(pStream->tasks);

-  int32_t code = tNewStreamTask(uid, TASK_LEVEL__SOURCE, pEpset, isFillhistory, useTriggerParam ? pStream->conf.triggerParam : 0,
-                     *pTaskList, pStream->conf.fillHistory, pStream->subTableWithoutMd5, pTask);
+  int32_t code = tNewStreamTask(uid, TASK_LEVEL__SOURCE, pEpset, isFillhistory, pStream->conf.trigger,
+                                useTriggerParam ? pStream->conf.triggerParam : 0, *pTaskList, pStream->conf.fillHistory,
+                                pStream->subTableWithoutMd5, pTask);
  return code;
 }

 static void addNewTaskList(SStreamObj* pStream) {
  SArray* pTaskList = taosArrayInit(0, POINTER_BYTES);
  if (taosArrayPush(pStream->tasks, &pTaskList) == NULL) {
-    mError("failed to put array");
+    mError("failed to put into array");
  }
+
  if (pStream->conf.fillHistory) {
    pTaskList = taosArrayInit(0, POINTER_BYTES);
    if (taosArrayPush(pStream->pHTasksList, &pTaskList) == NULL) {
-      mError("failed to put array");
+      mError("failed to put into array");
    }
  }
 }
@ -395,17 +397,18 @@ static void setHTasksId(SStreamObj* pStream) {
 }

 static int32_t doAddSourceTask(SMnode* pMnode, SSubplan* plan, SStreamObj* pStream, SEpSet* pEpset, int64_t skey,
-                               SArray* pVerList, SVgObj* pVgroup, bool isFillhistory, bool useTriggerParam) {
+                               SArray* pVerList, SVgObj* pVgroup, bool isHistoryTask, bool useTriggerParam) {
  SStreamTask* pTask = NULL;
-  int32_t code = buildSourceTask(pStream, pEpset, isFillhistory, useTriggerParam, &pTask);
+  int32_t code = buildSourceTask(pStream, pEpset, isHistoryTask, useTriggerParam, &pTask);
  if (code != TSDB_CODE_SUCCESS) {
    return code;
  }

-  mDebug("doAddSourceTask taskId:%s, vgId:%d, isFillHistory:%d", pTask->id.idStr, pVgroup->vgId, isFillhistory);
+  mDebug("doAddSourceTask taskId:%s, %p vgId:%d, isFillHistory:%d", pTask->id.idStr, pTask, pVgroup->vgId,
+         isHistoryTask);

  if (pStream->conf.fillHistory) {
-    haltInitialTaskStatus(pTask, plan, isFillhistory);
+    haltInitialTaskStatus(pTask, plan, isHistoryTask);
  }

  streamTaskSetDataRange(pTask, skey, pVerList, pVgroup->vgId);
@ -451,10 +454,12 @@ static SSubplan* getAggSubPlan(const SQueryPlan* pPlan, int index) {

 static int32_t addSourceTask(SMnode* pMnode, SSubplan* plan, SStreamObj* pStream, SEpSet* pEpset,
                             int64_t nextWindowSkey, SArray* pVerList, bool useTriggerParam) {
+  void*   pIter = NULL;
+  int32_t code = 0;
+  SSdb*   pSdb = pMnode->pSdb;
+
  addNewTaskList(pStream);

-  void* pIter = NULL;
-  SSdb* pSdb = pMnode->pSdb;
  while (1) {
    SVgObj* pVgroup;
    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void**)&pVgroup);
@ -467,10 +472,9 @@ static int32_t addSourceTask(SMnode* pMnode, SSubplan* plan, SStreamObj* pStream
      continue;
    }

-    int code =
-        doAddSourceTask(pMnode, plan, pStream, pEpset, nextWindowSkey, pVerList, pVgroup, false, useTriggerParam);
+    code = doAddSourceTask(pMnode, plan, pStream, pEpset, nextWindowSkey, pVerList, pVgroup, false, useTriggerParam);
    if (code != 0) {
-      mError("create stream task, code:%s", tstrerror(code));
+      mError("failed to create stream task, code:%s", tstrerror(code));

      // todo drop the added source tasks.
      sdbRelease(pSdb, pVgroup);
@ -502,9 +506,9 @@ static int32_t buildAggTask(SStreamObj* pStream, SEpSet* pEpset, bool isFillhist
  uint64_t uid = (isFillhistory) ? pStream->hTaskUid : pStream->uid;
  SArray** pTaskList = (isFillhistory) ? taosArrayGetLast(pStream->pHTasksList) : taosArrayGetLast(pStream->tasks);

-  int32_t code =
-      tNewStreamTask(uid, TASK_LEVEL__AGG, pEpset, isFillhistory, useTriggerParam ? pStream->conf.triggerParam : 0,
-                     *pTaskList, pStream->conf.fillHistory, pStream->subTableWithoutMd5, pAggTask);
+  int32_t code = tNewStreamTask(uid, TASK_LEVEL__AGG, pEpset, isFillhistory, pStream->conf.trigger,
+                                useTriggerParam ? pStream->conf.triggerParam : 0, *pTaskList, pStream->conf.fillHistory,
+                                pStream->subTableWithoutMd5, pAggTask);
  return code;
 }

@ -512,19 +516,20 @@ static int32_t doAddAggTask(SStreamObj* pStream, SMnode* pMnode, SSubplan* plan,
                            SSnodeObj* pSnode, bool isFillhistory, bool useTriggerParam) {
  int32_t      code = 0;
  SStreamTask* pTask = NULL;
+  const char*  id = NULL;

  code = buildAggTask(pStream, pEpset, isFillhistory, useTriggerParam, &pTask);
  if (code != TSDB_CODE_SUCCESS) {
    return code;
  }

+  id = pTask->id.idStr;
  if (pSnode != NULL) {
    code = mndAssignStreamTaskToSnode(pMnode, pTask, plan, pSnode);
-    mDebug("doAddAggTask taskId:%s, snode id:%d, isFillHistory:%d", pTask->id.idStr, pSnode->id, isFillhistory);
-
+    mDebug("doAddAggTask taskId:%s, %p snode id:%d, isFillHistory:%d", id, pTask, pSnode->id, isFillhistory);
  } else {
    code = mndAssignStreamTaskToVgroup(pMnode, pTask, plan, pVgroup);
-    mDebug("doAddAggTask taskId:%s, vgId:%d, isFillHistory:%d", pTask->id.idStr, pVgroup->vgId, isFillhistory);
+    mDebug("doAddAggTask taskId:%s, %p vgId:%d, isFillHistory:%d", id, pTask, pVgroup->vgId, isFillhistory);
  }
  return code;
 }
@ -678,7 +683,7 @@ static int32_t doScheduleStream(SStreamObj* pStream, SMnode* pMnode, SQueryPlan*
  if (numOfPlanLevel > 1 || externalTargetDB || multiTarget || pStream->fixedSinkVgId) {
    // add extra sink
    hasExtraSink = true;
-    int32_t code = addSinkTask(pMnode, pStream, pEpset);
+    code = addSinkTask(pMnode, pStream, pEpset);
    if (code != TSDB_CODE_SUCCESS) {
      return code;
    }
@ -692,7 +697,8 @@ static int32_t doScheduleStream(SStreamObj* pStream, SMnode* pMnode, SQueryPlan*
    if (terrno != 0) code = terrno;
    TAOS_RETURN(code);
  }
-  code = addSourceTask(pMnode, plan, pStream, pEpset, skey, pVerList, numOfPlanLevel == 1);
+
+  code = addSourceTask(pMnode, plan, pStream, pEpset, skey, pVerList, (numOfPlanLevel == 1));
  if (code != TSDB_CODE_SUCCESS) {
    return code;
  }
--- a/source/dnode/mnode/impl/src/mndShow.c
+++ b/source/dnode/mnode/impl/src/mndShow.c
@ -333,8 +333,8 @@ static int32_t mndProcessRetrieveSysTableReq(SRpcMsg *pReq) {
    mDebug("show:0x%" PRIx64 ", stop retrieve data, rowsRead:%d numOfRows:%d", pShow->id, rowsRead, pShow->numOfRows);
  }

-  size = sizeof(SRetrieveMetaTableRsp) + sizeof(int32_t) + sizeof(SSysTableSchema) * pShow->pMeta->numOfColumns +
-         blockDataGetSize(pBlock) + blockDataGetSerialMetaSize(taosArrayGetSize(pBlock->pDataBlock));
+  size_t dataEncodeBufSize = blockGetEncodeSize(pBlock);
+  size = sizeof(SRetrieveMetaTableRsp) + sizeof(int32_t) + sizeof(SSysTableSchema) * pShow->pMeta->numOfColumns + dataEncodeBufSize;

  SRetrieveMetaTableRsp *pRsp = rpcMallocCont(size);
  if (pRsp == NULL) {
@ -361,7 +361,7 @@ static int32_t mndProcessRetrieveSysTableReq(SRpcMsg *pReq) {
      pStart += sizeof(SSysTableSchema);
    }

-    int32_t len = blockEncode(pBlock, pStart, pShow->pMeta->numOfColumns);
+    int32_t len = blockEncode(pBlock, pStart, dataEncodeBufSize, pShow->pMeta->numOfColumns);
    if(len < 0){
      mError("show:0x%" PRIx64 ", failed to retrieve data since %s", pShow->id, tstrerror(code));
      code =  terrno;
--- a/Show More
+++ b/Show More