Merge branch '3.0' into platform/3.0/smoketest

2024-11-10 18:40:33 +08:00 · 2024-11-10 18:40:33 +08:00 · e583079fb2
parent 50e1f40f0f f46cf6044d
commit e583079fb2
125 changed files with 1965 additions and 786 deletions
--- a/docs/examples/JDBC/SpringJdbcTemplate/pom.xml
+++ b/docs/examples/JDBC/SpringJdbcTemplate/pom.xml
@ -22,19 +22,19 @@
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
-            <version>5.2.8.RELEASE</version>
+            <version>5.3.39</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
-            <version>5.1.9.RELEASE</version>
+            <version>5.3.39</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
-            <version>5.1.9.RELEASE</version>
+            <version>5.3.39</version>
        </dependency>

        <dependency>
@ -47,7 +47,7 @@
        <dependency>
            <groupId>com.taosdata.jdbc</groupId>
            <artifactId>taos-jdbcdriver</artifactId>
-            <version>3.0.0</version>
+            <version>3.4.0</version>
        </dependency>

    </dependencies>
--- a/docs/examples/JDBC/springbootdemo/pom.xml
+++ b/docs/examples/JDBC/springbootdemo/pom.xml
@ -5,7 +5,7 @@
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
-        <version>2.2.1.RELEASE</version>
+        <version>2.6.15</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.taosdata.example</groupId>
@ -65,6 +65,8 @@
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

+
+
        <dependency>
            <groupId>com.taosdata.jdbc</groupId>
            <artifactId>taos-jdbcdriver</artifactId>
--- a/docs/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/SpringbootdemoApplication.java
+++ b/docs/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/SpringbootdemoApplication.java
@ -3,9 +3,10 @@ package com.taosdata.example.springbootdemo;
 import org.mybatis.spring.annotation.MapperScan;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.autoconfigure.data.jdbc.JdbcRepositoriesAutoConfiguration;

@MapperScan(basePackages = {"com.taosdata.example.springbootdemo"})
-@SpringBootApplication
+@SpringBootApplication(exclude = {JdbcRepositoriesAutoConfiguration.class})
 public class SpringbootdemoApplication {

    public static void main(String[] args) {
--- a/docs/examples/JDBC/springbootdemo/src/main/resources/application.properties
+++ b/docs/examples/JDBC/springbootdemo/src/main/resources/application.properties
@ -15,6 +15,8 @@ spring.datasource.druid.max-wait=30000
 spring.datasource.druid.validation-query=select SERVER_VERSION();
 spring.aop.auto=true
 spring.aop.proxy-target-class=true
+
+spring.jooq.sql-dialect=
 #mybatis
 mybatis.mapper-locations=classpath:mapper/*.xml
 logging.level.com.taosdata.jdbc.springbootdemo.dao=debug
--- a/docs/examples/JDBC/taosdemo/pom.xml
+++ b/docs/examples/JDBC/taosdemo/pom.xml
@ -10,7 +10,7 @@
    <description>Demo project for TDengine</description>

    <properties>
-        <spring.version>5.3.27</spring.version>
+        <spring.version>5.3.39</spring.version>
    </properties>

    <dependencies>
@ -130,6 +130,7 @@
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.13.0</version>
                <configuration>
                    <source>8</source>
                    <target>8</target>
--- a/docs/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/QueryService.java
+++ b/docs/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/QueryService.java
@ -37,7 +37,7 @@ public class QueryService {
            stmt.execute("use " + dbName);
            ResultSet rs = stmt.executeQuery("show stables");
            while (rs.next()) {
-                String name = rs.getString("name");
+                String name = rs.getString("stable_name");
                sqls.add("select count(*) from " + dbName + "." + name);
                sqls.add("select first(*) from " + dbName + "." + name);
                sqls.add("select last(*) from " + dbName + "." + name);
--- a/docs/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/DatabaseServiceTest.java
+++ b/docs/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/DatabaseServiceTest.java
@ -1,10 +1,14 @@
 package com.taosdata.taosdemo.service;

+import com.zaxxer.hikari.HikariConfig;
+import com.zaxxer.hikari.HikariDataSource;
+import org.junit.BeforeClass;
 import org.junit.Test;
 import org.springframework.beans.factory.annotation.Autowired;

 public class DatabaseServiceTest {
-    private DatabaseService service;
+
+    private static DatabaseService service;

    @Test
    public void testCreateDatabase1() {
@ -20,4 +24,16 @@ public class DatabaseServiceTest {
    public void useDatabase() {
        service.useDatabase("test");
    }
+
+    @BeforeClass
+    public static void beforeClass() throws ClassNotFoundException {
+        Class.forName("com.taosdata.jdbc.TSDBDriver");
+        HikariConfig config = new HikariConfig();
+        config.setJdbcUrl("jdbc:TAOS://127.0.0.1:6030/?charset=UTF-8&locale=en_US.UTF-8&timezone=UTC-8");
+        config.setUsername("root");
+        config.setPassword("taosdata");
+        HikariDataSource dataSource = new HikariDataSource(config);
+        service = new DatabaseService(dataSource);
+    }
+
 }
--- a/docs/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/QueryServiceTest.java
+++ b/docs/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/QueryServiceTest.java
@ -15,7 +15,7 @@ public class QueryServiceTest {

    @Test
    public void generateSuperTableQueries() {
-        String[] sqls = queryService.generateSuperTableQueries("restful_test");
+        String[] sqls = queryService.generateSuperTableQueries("test");
        for (String sql : sqls) {
            System.out.println(sql);
        }
@ -23,8 +23,8 @@ public class QueryServiceTest {

    @Test
    public void querySuperTable() {
-        String[] sqls = queryService.generateSuperTableQueries("restful_test");
-        queryService.querySuperTable(sqls, 1000, 10, 10);
+        String[] sqls = queryService.generateSuperTableQueries("test");
+        queryService.querySuperTable(sqls, 100, 3, 3);
    }

    @BeforeClass
--- a/docs/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/SuperTableServiceTest.java
+++ b/docs/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/SuperTableServiceTest.java
@ -3,6 +3,9 @@ package com.taosdata.taosdemo.service;
 import com.taosdata.taosdemo.domain.FieldMeta;
 import com.taosdata.taosdemo.domain.SuperTableMeta;
 import com.taosdata.taosdemo.domain.TagMeta;
+import com.zaxxer.hikari.HikariConfig;
+import com.zaxxer.hikari.HikariDataSource;
+import org.junit.BeforeClass;
 import org.junit.Test;

 import java.util.ArrayList;
@ -10,7 +13,7 @@ import java.util.List;

 public class SuperTableServiceTest {

-    private SuperTableService service;
+    private static SuperTableService service;

    @Test
    public void testCreate() {
@ -29,4 +32,15 @@ public class SuperTableServiceTest {
        service.create(superTableMeta);
    }

+    @BeforeClass
+    public static void beforeClass() throws ClassNotFoundException {
+        Class.forName("com.taosdata.jdbc.TSDBDriver");
+        HikariConfig config = new HikariConfig();
+        config.setJdbcUrl("jdbc:TAOS://127.0.0.1:6030/?charset=UTF-8&locale=en_US.UTF-8&timezone=UTC-8");
+        config.setUsername("root");
+        config.setPassword("taosdata");
+        HikariDataSource dataSource = new HikariDataSource(config);
+        service = new SuperTableService(dataSource);
+    }
+
 }
--- a/docs/examples/java/src/main/java/com/taos/example/DruidDemo.java
+++ b/docs/examples/java/src/main/java/com/taos/example/DruidDemo.java
@ -1,4 +1,4 @@
-package com.taosdata.example;
+package com.taos.example;

 import com.alibaba.druid.pool.DruidDataSource;

@ -8,11 +8,11 @@ import java.sql.Statement;
 public class DruidDemo {
    // ANCHOR: connection_pool
    public static void main(String[] args) throws Exception {
-        String url = "jdbc:TAOS://127.0.0.1:6030/log";
+        String url = "jdbc:TAOS-WS://127.0.0.1:6041/log";

        DruidDataSource dataSource = new DruidDataSource();
        // jdbc properties
-        dataSource.setDriverClassName("com.taosdata.jdbc.TSDBDriver");
+        dataSource.setDriverClassName("com.taosdata.jdbc.ws.WebSocketDriver");
        dataSource.setUrl(url);
        dataSource.setUsername("root");
        dataSource.setPassword("taosdata");
--- a/docs/examples/java/src/main/java/com/taos/example/GeometryDemo.java
+++ b/docs/examples/java/src/main/java/com/taos/example/GeometryDemo.java
@ -144,8 +144,9 @@ public class GeometryDemo {

    private void executeQuery(String sql) {
        long start = System.currentTimeMillis();
-        try (Statement statement = connection.createStatement()) {
-            ResultSet resultSet = statement.executeQuery(sql);
+        try (Statement statement = connection.createStatement();
+             ResultSet resultSet = statement.executeQuery(sql)) {
+
            long end = System.currentTimeMillis();
            printSql(sql, true, (end - start));

--- a/docs/examples/java/src/main/java/com/taos/example/HikariDemo.java
+++ b/docs/examples/java/src/main/java/com/taos/example/HikariDemo.java
@ -1,4 +1,4 @@
-package com.taosdata.example;
+package com.taos.example;

 import com.zaxxer.hikari.HikariConfig;
 import com.zaxxer.hikari.HikariDataSource;
@ -11,7 +11,7 @@ public class HikariDemo {
    public static void main(String[] args) throws Exception {
        HikariConfig config = new HikariConfig();
        // jdbc properties
-        config.setJdbcUrl("jdbc:TAOS://127.0.0.1:6030/log");
+        config.setJdbcUrl("jdbc:TAOS-WS://127.0.0.1:6041/log");
        config.setUsername("root");
        config.setPassword("taosdata");
        // connection pool configurations
--- a/docs/examples/java/src/main/java/com/taos/example/TelnetLineProtocolExample.java
+++ b/docs/examples/java/src/main/java/com/taos/example/TelnetLineProtocolExample.java
@ -39,6 +39,7 @@ public class TelnetLineProtocolExample {
            createDatabase(conn);
            SchemalessWriter writer = new SchemalessWriter(conn);
            writer.write(lines, SchemalessProtocolType.TELNET, SchemalessTimestampType.NOT_CONFIGURED);
+            writer.close();
        }
    }

--- a/docs/zh/06-advanced/03-stream.md
+++ b/docs/zh/06-advanced/03-stream.md
@ -228,4 +228,35 @@ PAUSE STREAM [IF EXISTS] stream_name;
 RESUME STREAM [IF EXISTS] [IGNORE UNTREATED] stream_name; 
 ```

-没有指定 IF EXISTS，如果该 stream 不存在，则报错。如果存在，则恢复流计算。指定了 IF EXISTS，如果 stream 不存在，则返回成功。如果存在，则恢复流计算。如果指定 IGNORE UNTREATED，则恢复流计算时，忽略流计算暂停期间写入的数据。
+没有指定 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/03-anomaly-detection.md
+++ b/docs/zh/06-advanced/06-data-analysis/03-anomaly-detection.md
@ -1,6 +1,6 @@
 ---
-title: "Anomaly-detection"
-sidebar_label: "Anomaly-detection"
+title: "异常检测算法"
+sidebar_label: "异常检测算法"
 ---

 本节讲述异常检测算法模型的使用方法。
--- a/docs/zh/06-advanced/06-data-analysis/addins.md
+++ b/docs/zh/06-advanced/06-data-analysis/addins.md
@ -1,13 +1,27 @@
 ---
-title: "addins"
-sidebar_label: "addins"
+title: "算法开发者指南"
+sidebar_label: "算法开发者指南"
 ---

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

 ## 目录结构

-![数据分析功能架构图](./pic/dir.png)
+```bash
+.
+├── cfg
+├── model
+│   └── ac_detection
+├── release
+├── script
+└── taosanalytics
+    ├── algo
+    │   ├── ad
+    │   └── fc
+    ├── misc
+    └── test
+
+```

 |目录|说明|
 |---|---|
--- a/docs/zh/06-advanced/06-data-analysis/analysis-preprocess.md
+++ b/docs/zh/06-advanced/06-data-analysis/analysis-preprocess.md
@ -0,0 +1,23 @@
+---
+title: "数据分析预处理"
+sidebar_label: "数据分析预处理"
+---
+
+## 时序数据分析功能
+
+### 白噪声检查
+
+分析平台提供的 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, 49]，并且用户要求的时间间隔为 10，重整对齐后的序列是 [10, 20, 30, 50] 那么该序列进行预测分析将返回错误。
+
--- a/docs/zh/06-advanced/06-data-analysis/index.md
+++ b/docs/zh/06-advanced/06-data-analysis/index.md
@ -1,190 +1,21 @@
 ---
-sidebar_label: 数据分析
-title: 数据分析功能
+sidebar_label: TDgpt
+title: TDgpt
 ---

 ## 概述

-ANode（Analysis Node）是 TDengine 提供数据分析功能的扩展组件，通过 Restful 接口提供分析服务，拓展 TDengine 的功能，支持时间序列高级分析。
-ANode 是无状态的数据分析节点，集群中可以存在多个 ANode 节点，相互之间没有关联。将 ANode 注册到 TDengine 集群以后，通过 SQL 语句即可调用并完成时序分析任务。
-下图是数据分析的技术架构示意图。
+TDgpt 是 TDengine Enterprise 中针对时序数据提供高级分析功能的企业级组件，能够独立于 TDengine 主进程部署和运行，不消耗和占用 TDengine 主进程的资源，通过内置接口向 TDengine 提供运行时动态扩展的高级时序数据分析功能。TDgpt 具有服务无状态、功能易扩展、快速弹性部署、应用轻量化、高安全性等特点。
+TDgpt 运行在部署于 TDengine 集群中的 Analysis Node (ANode)中。每个 TDengine 集群中可以部署一个或若干个 ANode 节点，不同的 ANode 节点之间不相关，无同步或协同的要求。ANode 注册到 TDengine 集群以后，就可以通过内部接口提供服务。TDgpt 提供的高级时序数据分析服务可分为时序数据异常检测和时序数据预测分析两个类别。

-![数据分析功能架构图](./pic/data-analysis.png)
+如下是数据分析的技术架构示意图。

-## 安装部署
-### 环境准备
-ANode 要求节点上准备有 Python 3.10 及以上版本，以及相应的 Python 包自动安装组件 Pip，同时请确保能够正常连接互联网。
+<img src="./pic/data-analysis.png" width="560" alt="TDgpt架构图" />

-### 安装及卸载
-使用专门的 ANode 安装包 TDengine-enterprise-anode-1.x.x.tar.gz 进行 ANode 的安装部署工作，安装过程与 TDengine 的安装流程一致。
-
-```bash
-tar -xzvf TDengine-enterprise-anode-1.0.0.tar.gz
-cd TDengine-enterprise-anode-1.0.0
-sudo ./install.sh
-```
-
-卸载 ANode，执行命令 `rmtaosanode` 即可。
-
-### 其他
-为了避免 ANode 安装后影响目标节点现有的 Python 库。 ANode 使用 Python 虚拟环境运行，安装后的默认 Python 目录处于 `/var/lib/taos/taosanode/venv/`。为了避免反复安装虚拟环境带来的开销，卸载 ANode 并不会自动删除该虚拟环境，如果您确认不需要 Python 的虚拟环境，可以手动删除。
-
-## 启动及停止服务
-安装 ANode 以后，可以使用 `systemctl` 来管理 ANode 的服务。使用如下命令可以启动/停止/检查状态。
-
-```bash
-systemctl start  taosanoded
-systemctl stop   taosanoded
-systemctl status taosanoded
-```
-
-## 目录及配置说明
-|目录/文件|说明|
-|---------------|------|
-|/usr/local/taos/taosanode/bin|可执行文件目录|
-|/usr/local/taos/taosanode/resource|资源文件目录，链接到文件夹 /var/lib/taos/taosanode/resource/|
-|/usr/local/taos/taosanode/lib|库文件目录|
-|/var/lib/taos/taosanode/model/|模型文件目录，链接到文件夹 /var/lib/taos/taosanode/model|
-|/var/log/taos/taosanode/|日志文件目录|
-|/etc/taos/taosanode.ini|配置文件|
-
-### 配置说明
-
-Anode 提供的 RestFul 服务使用 uWSGI 驱动，因此 ANode 和 uWSGI 的配置信息存放在同一个配置文件中，具体如下：
-
-```ini
-[uwsgi]
-# charset
-env = LC_ALL = en_US.UTF-8
-
-# ip:port
-http = 127.0.0.1:6050
-
-# the local unix socket file than communicate to Nginx
-#socket = 127.0.0.1:8001
-#socket-timeout = 10
-
-# base directory
-chdir = /usr/local/taos/taosanode/lib
-
-# initialize python file
-wsgi-file = /usr/local/taos/taosanode/lib/taos/app.py
-
-# call module of uWSGI
-callable = app
-
-# auto remove unix Socket and pid file when stopping
-vacuum = true
-
-# socket exec model
-#chmod-socket = 664
-
-# uWSGI pid
-uid = root
-
-# uWSGI gid
-gid = root
-
-# main process
-master = true
-
-# the number of worker processes
-processes = 2
-
-# pid file
-pidfile = /usr/local/taos/taosanode/taosanode.pid
-
-# enable threads
-enable-threads = true
-
-# the number of threads for each process
-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
-
-# log directory
-logto = /var/log/taos/taosanode/taosanode.log
-
-# wWSGI monitor port
-stats = 127.0.0.1:8387
-
-# python virtual environment directory
-virtualenv = /usr/local/taos/taosanode/venv/
-
-[taosanode]
-# default app log file
-app-log = /var/log/taos/taosanode/taosanode.app.log
-
-# model storage directory
-model-dir = /usr/local/taos/taosanode/model/
-
-# default log level
-log-level = DEBUG
-
-# draw the query results
-draw-result = 0
-```
-
-**提示**
-请勿设置 `daemonize` 参数，该参数会导致 uWSGI 与 systemctl 冲突，从而无法正常启动。
+通过注册指令语句，将 ANode 注册到 MNode 中就加入到 TDengine 集群，查询会按需向其请求数据分析服务。请求服务通过 VNode 直接向 ANode 发起，用户则可以通过 SQL 语句直接调用 ANode 提供的服务。


-## ANode 基本操作
-### 管理 ANode
-#### 创建 ANode 
-```sql 
-CREATE ANODE {node_url}
-```
-node_url 是提供服务的 ANode 的 IP 和 PORT, 例如：`create anode 'http://localhost:6050'`。启动 ANode 以后如果不注册到 TDengine 集群中，则无法提供正常的服务。不建议 ANode 注册到两个或多个集群中。

-#### 查看 ANode
-列出集群中所有的数据分析节点，包括其 `FQDN`, `PORT`, `STATUS`。
-```sql
-SHOW ANODES;
-```
-
-#### 查看提供的时序数据分析服务
-
-```SQL
-SHOW ANODES FULL;
-```
-
-#### 强制刷新集群中的分析算法缓存
-```SQL
-UPDATE ANODE {node_id}
-UPDATE ALL ANODES
-```
-
-#### 删除 ANode 
-```sql
-DROP ANODE {anode_id}
-```
-删除 ANode 只是将 ANode 从 TDengine 集群中删除，管理 ANode 的启停仍然需要使用`systemctl`命令。
-
-### 时序数据分析功能
-
-#### 白噪声检查
-
-分析平台提供的 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, 49]，并且用户要求的时间间隔为 10，重整对齐后的序列是 [10, 20, 30, 50] 那么该序列进行预测分析将返回错误。


 #### 时序数据异常检测
--- a/docs/zh/06-advanced/06-data-analysis/management.md
+++ b/docs/zh/06-advanced/06-data-analysis/management.md
@ -0,0 +1,161 @@
+---
+title: "安装部署"
+sidebar_label: "安装部署"
+---
+
+## 安装部署
+### 环境准备
+ANode 要求节点上准备有 Python 3.10 及以上版本，以及相应的 Python 包自动安装组件 Pip，同时请确保能够正常连接互联网。
+
+### 安装及卸载
+使用专门的 ANode 安装包 TDengine-enterprise-anode-1.x.x.tar.gz 进行 ANode 的安装部署工作，安装过程与 TDengine 的安装流程一致。
+
+```bash
+tar -xzvf TDengine-enterprise-anode-1.0.0.tar.gz
+cd TDengine-enterprise-anode-1.0.0
+sudo ./install.sh
+```
+
+卸载 ANode，执行命令 `rmtaosanode` 即可。
+
+### 其他
+为了避免 ANode 安装后影响目标节点现有的 Python 库。 ANode 使用 Python 虚拟环境运行，安装后的默认 Python 目录处于 `/var/lib/taos/taosanode/venv/`。为了避免反复安装虚拟环境带来的开销，卸载 ANode 并不会自动删除该虚拟环境，如果您确认不需要 Python 的虚拟环境，可以手动删除。
+
+## 启动及停止服务
+安装 ANode 以后，可以使用 `systemctl` 来管理 ANode 的服务。使用如下命令可以启动/停止/检查状态。
+
+```bash
+systemctl start  taosanoded
+systemctl stop   taosanoded
+systemctl status taosanoded
+```
+
+## 目录及配置说明
+|目录/文件|说明|
+|---------------|------|
+|/usr/local/taos/taosanode/bin|可执行文件目录|
+|/usr/local/taos/taosanode/resource|资源文件目录，链接到文件夹 /var/lib/taos/taosanode/resource/|
+|/usr/local/taos/taosanode/lib|库文件目录|
+|/var/lib/taos/taosanode/model/|模型文件目录，链接到文件夹 /var/lib/taos/taosanode/model|
+|/var/log/taos/taosanode/|日志文件目录|
+|/etc/taos/taosanode.ini|配置文件|
+
+### 配置说明
+
+Anode 提供的 RestFul 服务使用 uWSGI 驱动，因此 ANode 和 uWSGI 的配置信息存放在同一个配置文件中，具体如下：
+
+```ini
+[uwsgi]
+# charset
+env = LC_ALL = en_US.UTF-8
+
+# ip:port
+http = 127.0.0.1:6050
+
+# the local unix socket file than communicate to Nginx
+#socket = 127.0.0.1:8001
+#socket-timeout = 10
+
+# base directory
+chdir = /usr/local/taos/taosanode/lib
+
+# initialize python file
+wsgi-file = /usr/local/taos/taosanode/lib/taos/app.py
+
+# call module of uWSGI
+callable = app
+
+# auto remove unix Socket and pid file when stopping
+vacuum = true
+
+# socket exec model
+#chmod-socket = 664
+
+# uWSGI pid
+uid = root
+
+# uWSGI gid
+gid = root
+
+# main process
+master = true
+
+# the number of worker processes
+processes = 2
+
+# pid file
+pidfile = /usr/local/taos/taosanode/taosanode.pid
+
+# enable threads
+enable-threads = true
+
+# the number of threads for each process
+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
+
+# log directory
+logto = /var/log/taos/taosanode/taosanode.log
+
+# wWSGI monitor port
+stats = 127.0.0.1:8387
+
+# python virtual environment directory
+virtualenv = /usr/local/taos/taosanode/venv/
+
+[taosanode]
+# default app log file
+app-log = /var/log/taos/taosanode/taosanode.app.log
+
+# model storage directory
+model-dir = /usr/local/taos/taosanode/model/
+
+# default log level
+log-level = DEBUG
+
+# draw the query results
+draw-result = 0
+```
+
+**提示**
+请勿设置 `daemonize` 参数，该参数会导致 uWSGI 与 systemctl 冲突，从而无法正常启动。
+
+
+
+## ANode 基本操作
+#### 创建 ANode
+```sql 
+CREATE ANODE {node_url}
+```
+node_url 是提供服务的 ANode 的 IP 和 PORT, 例如：`create anode 'http://localhost:6050'`。启动 ANode 以后如果不注册到 TDengine 集群中，则无法提供正常的服务。不建议 ANode 注册到两个或多个集群中。
+
+#### 查看 ANode
+列出集群中所有的数据分析节点，包括其 `FQDN`, `PORT`, `STATUS`。
+```sql
+SHOW ANODES;
+```
+
+#### 查看提供的时序数据分析服务
+
+```SQL
+SHOW ANODES FULL;
+```
+
+#### 强制刷新集群中的分析算法缓存
+```SQL
+UPDATE ANODE {node_id}
+UPDATE ALL ANODES
+```
+
+#### 删除 ANode
+```sql
+DROP ANODE {anode_id}
+```
+删除 ANode 只是将 ANode 从 TDengine 集群中删除，管理 ANode 的启停仍然需要使用`systemctl`命令。
--- a/docs/zh/06-advanced/06-data-analysis/pic/data-analysis.png
+++ b/docs/zh/06-advanced/06-data-analysis/pic/data-analysis.png
--- a/docs/zh/06-advanced/06-data-analysis/pic/dir.png
+++ b/docs/zh/06-advanced/06-data-analysis/pic/dir.png
--- a/docs/zh/08-operation/16-security.md
+++ b/docs/zh/08-operation/16-security.md
@ -26,6 +26,22 @@ SHOW USERS;
 ```sql
 ALTER USER TEST DROP HOST HOST_NAME1
 ```
+说明 
+- 开源版和企业版本都能添加成功，且可以查询到，但是开源版本不会对 IP 做任何限制。
+- create user u_write pass 'taosdata1' host 'iprange1','iprange2', 可以一次添加多个 iprange,  服务端会做去重，去重的逻辑是需要 iprange 完全一样
+- 默认会把 127.0.0.1 添加到白名单列表，且在白名单列表可以查询
+- 集群的节点 IP 集合会自动添加到白名单列表，但是查询不到。 
+- taosadaper 和 taosd 不在一个机器的时候，需要把 taosadaper IP 手动添加到 taosd 白名单列表中
+- 集群情况下，各个节点 enableWhiteList 成一样，或者全为 false,或者全为 true, 要不然集群无法启动
+- 白名单变更生效时间 1s，不超过 2s, 每次变更对收发性能有些微影响（多一次判断，可以忽略），变更完之后、影响忽略不计, 变更过程中对集群没有影响，对正在访问客户端也没有影响（假设这些客户端的 IP 包含在 white list 内）
+- 如果添加两个 ip range,  192.168.1.1/16(假设为 A), 192.168.1.1/24(假设为 B), 严格来说，A 包含了 B，但是考虑情况太复杂，并不会对 A 和 B 做合并
+- 要删除的时候，必须严格匹配。 也就是如果添加的是 192.168.1.1/24, 要删除也是 192.168.1.1/24 
+- 只有 root 才有权限对其他用户增删 ip white list
+- 兼容之前的版本，但是不支持从当前版本回退到之前版本
+- x.x.x.x/32 和 x.x.x.x 属于同一个 iprange, 显示为 x.x.x.x
+- 如果客户端拿到的 0.0.0.0/0, 说明没有开启白名单
+- 如果白名单发生了改变， 客户端会在 heartbeat 里检测到。
+- 针对一个 user, 添加的 IP 个数上限是 2048

 ## 审计日志

--- 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/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
@ -155,6 +155,7 @@ typedef enum EStreamType {
  STREAM_MID_RETRIEVE,
  STREAM_PARTITION_DELETE_DATA,
  STREAM_GET_RESULT,
+  STREAM_DROP_CHILD_TABLE,
 } EStreamType;

 #pragma pack(push, 1)
@ -401,6 +402,8 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol);
 #define TSMA_RES_STB_EXTRA_COLUMN_NUM 4 // 3 columns: _wstart, _wend, _wduration, 1 tag: tbname

 static inline bool isTsmaResSTb(const char* stbName) {
+  static bool showTsmaTables = false;
+  if (showTsmaTables) return false;
  const char* pos = strstr(stbName, TSMA_RES_STB_POSTFIX);
  if (pos && strlen(stbName) == (pos - stbName) + strlen(TSMA_RES_STB_POSTFIX)) {
    return true;
--- a/include/common/tglobal.h
+++ b/include/common/tglobal.h
@ -188,7 +188,6 @@ extern int32_t tsMaxRetryWaitTime;
 extern bool    tsUseAdapter;
 extern int32_t tsMetaCacheMaxSize;
 extern int32_t tsSlowLogThreshold;
-extern int32_t tsSlowLogThresholdTest;
 extern char    tsSlowLogExceptDb[];
 extern int32_t tsSlowLogScope;
 extern int32_t tsSlowLogMaxLen;
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@ -676,7 +676,7 @@ typedef struct {
  int32_t tsSlowLogThreshold;
  int32_t tsSlowLogMaxLen;
  int32_t tsSlowLogScope;
-  int32_t tsSlowLogThresholdTest;
+  int32_t tsSlowLogThresholdTest;   //Obsolete
  char    tsSlowLogExceptDb[TSDB_DB_NAME_LEN];
 } SMonitorParas;

@ -2307,6 +2307,7 @@ typedef struct {
 typedef struct {
  SExplainRsp rsp;
  uint64_t    qId;
+  uint64_t    cId;
  uint64_t    tId;
  int64_t     rId;
  int32_t     eId;
@ -2660,6 +2661,7 @@ typedef struct SSubQueryMsg {
  SMsgHead header;
  uint64_t sId;
  uint64_t queryId;
+  uint64_t clientId;
  uint64_t taskId;
  int64_t  refId;
  int32_t  execId;
@ -2689,6 +2691,7 @@ typedef struct {
  SMsgHead header;
  uint64_t sId;
  uint64_t queryId;
+  uint64_t clientId;
  uint64_t taskId;
  int32_t  execId;
 } SQueryContinueReq;
@ -2723,6 +2726,7 @@ typedef struct {
  SMsgHead        header;
  uint64_t        sId;
  uint64_t        queryId;
+  uint64_t        clientId;
  uint64_t        taskId;
  int32_t         execId;
  SOperatorParam* pOpParam;
@ -2738,6 +2742,7 @@ typedef struct {

 typedef struct {
  uint64_t queryId;
+  uint64_t clientId;
  uint64_t taskId;
  int64_t  refId;
  int32_t  execId;
@ -2784,6 +2789,7 @@ typedef struct {
  SMsgHead header;
  uint64_t sId;
  uint64_t queryId;
+  uint64_t clientId;
  uint64_t taskId;
  int64_t  refId;
  int32_t  execId;
@ -2797,6 +2803,7 @@ typedef struct {
  SMsgHead header;
  uint64_t sId;
  uint64_t queryId;
+  uint64_t clientId;
  uint64_t taskId;
  int64_t  refId;
  int32_t  execId;
@ -2813,6 +2820,7 @@ typedef struct {
  SMsgHead        header;
  uint64_t        sId;
  uint64_t        queryId;
+  uint64_t        clientId;
  uint64_t        taskId;
  int64_t         refId;
  int32_t         execId;
@ -3220,6 +3228,7 @@ int tDecodeSVCreateTbBatchRsp(SDecoder* pCoder, SVCreateTbBatchRsp* pRsp);
 typedef struct {
  char*    name;
  uint64_t suid;  // for tmq in wal format
+  int64_t  uid;
  int8_t   igNotExists;
 } SVDropTbReq;

@ -4261,6 +4270,7 @@ typedef struct {
  SMsgHead header;
  uint64_t sId;
  uint64_t queryId;
+  uint64_t clientId;
  uint64_t taskId;
  uint32_t sqlLen;
  uint32_t phyLen;
--- a/include/common/ttime.h
+++ b/include/common/ttime.h
@ -62,7 +62,8 @@ static FORCE_INLINE int64_t taosGetTimestampToday(int32_t precision) {
  int64_t   factor = (precision == TSDB_TIME_PRECISION_MILLI)   ? 1000
                     : (precision == TSDB_TIME_PRECISION_MICRO) ? 1000000
                                                                : 1000000000;
-  time_t    t = taosTime(NULL);
+  time_t    t;
+  (void) taosTime(&t);
  struct tm tm;
  (void) taosLocalTime(&t, &tm, NULL, 0);
  tm.tm_hour = 0;
--- a/include/libs/executor/executor.h
+++ b/include/libs/executor/executor.h
@ -31,7 +31,7 @@ typedef void* DataSinkHandle;
 struct SRpcMsg;
 struct SSubplan;

-typedef int32_t (*localFetchFp)(void*, uint64_t, uint64_t, uint64_t, int64_t, int32_t, void**, SArray*);
+typedef int32_t (*localFetchFp)(void*, uint64_t, uint64_t, uint64_t, uint64_t, int64_t, int32_t, void**, SArray*);

 typedef struct {
  void*        handle;
--- a/include/libs/executor/storageapi.h
+++ b/include/libs/executor/storageapi.h
@ -336,6 +336,7 @@ typedef struct SStateStore {
  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);
+  int32_t (*streamStateDeleteParName)(SStreamState* pState, int64_t groupId);

  int32_t (*streamStateAddIfNotExist)(SStreamState* pState, const SWinKey* key, void** pVal, int32_t* pVLen,
                                      int32_t* pWinCode);
--- a/include/libs/nodes/plannodes.h
+++ b/include/libs/nodes/plannodes.h
@ -624,6 +624,7 @@ typedef struct SAggPhysiNode {
 typedef struct SDownstreamSourceNode {
  ENodeType      type;
  SQueryNodeAddr addr;
+  uint64_t       clientId;
  uint64_t       taskId;
  uint64_t       schedId;
  int32_t        execId;
--- a/include/libs/qworker/qworker.h
+++ b/include/libs/qworker/qworker.h
@ -105,11 +105,11 @@ void qWorkerDestroy(void **qWorkerMgmt);

 int32_t qWorkerGetStat(SReadHandle *handle, void *qWorkerMgmt, SQWorkerStat *pStat);

-int32_t qWorkerProcessLocalQuery(void *pMgmt, uint64_t sId, uint64_t qId, uint64_t tId, int64_t rId, int32_t eId,
-                                 SQWMsg *qwMsg, SArray *explainRes);
+int32_t qWorkerProcessLocalQuery(void *pMgmt, uint64_t sId, uint64_t qId, uint64_t cId, uint64_t tId, int64_t rId,
+                                 int32_t eId, SQWMsg *qwMsg, SArray *explainRes);

-int32_t qWorkerProcessLocalFetch(void *pMgmt, uint64_t sId, uint64_t qId, uint64_t tId, int64_t rId, int32_t eId,
-                                 void **pRsp, SArray *explainRes);
+int32_t qWorkerProcessLocalFetch(void *pMgmt, uint64_t sId, uint64_t qId, uint64_t cId, uint64_t tId, int64_t rId,
+                                 int32_t eId, void **pRsp, SArray *explainRes);

 int32_t qWorkerDbgEnableDebug(char *option);

--- a/include/libs/scheduler/scheduler.h
+++ b/include/libs/scheduler/scheduler.h
@ -83,6 +83,9 @@ void schedulerStopQueryHb(void* pTrans);
 int32_t schedulerUpdatePolicy(int32_t policy);
 int32_t schedulerEnableReSchedule(bool enableResche);

+int32_t initClientId(void);
+uint64_t getClientId(void);
+
 /**
 * Cancel query job
 * @param pJob
--- a/include/libs/stream/streamState.h
+++ b/include/libs/stream/streamState.h
@ -116,6 +116,7 @@ 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);
+int32_t streamStateDeleteParName(SStreamState* pState, int64_t groupId);

 // group id
 int32_t streamStateGroupPut(SStreamState* pState, int64_t groupId, void* value, int32_t vLen);
--- a/include/libs/stream/tstream.h
+++ b/include/libs/stream/tstream.h
@ -462,7 +462,7 @@ struct SStreamTask {
  struct SStreamMeta*   pMeta;
  SSHashObj*            pNameMap;
  void*                 pBackend;
-  int8_t                subtableWithoutMd5;
+  int8_t                subtableWithoutMd5; // only for tsma stream tasks
  char                  reserve[256];
  char*                 backendPath;
 };
--- a/include/libs/wal/wal.h
+++ b/include/libs/wal/wal.h
@ -138,6 +138,7 @@ typedef struct {
  int8_t scanMeta;
  int8_t deleteMsg;
  int8_t enableRef;
+  int8_t scanDropCtb;
 } SWalFilterCond;

 // todo hide this struct
--- a/include/os/osTime.h
+++ b/include/os/osTime.h
@ -93,7 +93,7 @@ static FORCE_INLINE int64_t taosGetMonoTimestampMs() {
 char      *taosStrpTime(const char *buf, const char *fmt, struct tm *tm);
 struct tm *taosLocalTime(const time_t *timep, struct tm *result, char *buf, int32_t bufSize);
 struct tm *taosLocalTimeNolock(struct tm *result, const time_t *timep, int dst);
-time_t     taosTime(time_t *t);
+int32_t    taosTime(time_t *t);
 time_t     taosMktime(struct tm *timep);
 int64_t    user_mktime64(const uint32_t year, const uint32_t mon, const uint32_t day, const uint32_t hour,
                         const uint32_t min, const uint32_t sec, int64_t time_zone);
--- 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/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/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/src/clientEnv.c
+++ b/source/client/src/clientEnv.c
@ -294,8 +294,7 @@ static void deregisterRequest(SRequestObj *pRequest) {
    }
  }

-  if ((duration >= pTscObj->pAppInfo->serverCfg.monitorParas.tsSlowLogThreshold * 1000000UL ||
-       duration >= pTscObj->pAppInfo->serverCfg.monitorParas.tsSlowLogThresholdTest * 1000000UL) &&
+  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->serverCfg.monitorParas.tsSlowLogScope & reqType) {
@ -983,6 +982,7 @@ void taos_init_imp(void) {
  SCatalogCfg cfg = {.maxDBCacheNum = 100, .maxTblCacheNum = 100};
  ENV_ERR_RET(catalogInit(&cfg), "failed to init catalog");
  ENV_ERR_RET(schedulerInit(), "failed to init scheduler");
+  ENV_ERR_RET(initClientId(), "failed to init clientId");

  tscDebug("starting to initialize TAOS driver");

--- a/source/client/src/clientMain.c
+++ b/source/client/src/clientMain.c
@ -1803,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;
  }

@ -1819,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;
  }

@ -1831,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;
  }

@ -1859,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;
  }

@ -2019,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;
      }

@ -2027,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;
      }

--- a/source/client/test/CMakeLists.txt
+++ b/source/client/test/CMakeLists.txt
@ -29,6 +29,12 @@ TARGET_LINK_LIBRARIES(
 #        PUBLIC os util common transport monitor parser catalog scheduler function gtest taos_static qcom executor
 #)

+ADD_EXECUTABLE(userOperTest ../../../tests/script/api/passwdTest.c)
+TARGET_LINK_LIBRARIES(
+        userOperTest
+        PUBLIC taos
+)
+
 TARGET_INCLUDE_DIRECTORIES(
        clientTest
        PUBLIC "${TD_SOURCE_DIR}/include/client/"
@ -69,3 +75,8 @@ add_test(
 #         NAME clientMonitorTest
 #         COMMAND clientMonitorTest
 # )
+
+add_test(
+        NAME userOperTest
+        COMMAND userOperTest
+)
--- a/source/common/src/systable.c
+++ b/source/common/src/systable.c
@ -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/tcol.c
+++ b/source/common/src/tcol.c
@ -166,6 +166,7 @@ const char* columnCompressStr(uint16_t type) {
 }

 uint8_t columnLevelVal(const char* level) {
+  if (level == NULL) return TSDB_COLVAL_LEVEL_NOCHANGE;
  uint8_t l = TSDB_COLVAL_LEVEL_MEDIUM;
  if (0 == strcmp(level, "h") || 0 == strcmp(level, TSDB_COLUMN_LEVEL_HIGH)) {
    l = TSDB_COLVAL_LEVEL_HIGH;
@ -180,6 +181,7 @@ uint8_t columnLevelVal(const char* level) {
 }

 uint16_t columnCompressVal(const char* compress) {
+  if (compress == NULL) return TSDB_COLVAL_COMPRESS_NOCHANGE;
  uint16_t c = TSDB_COLVAL_COMPRESS_LZ4;
  if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_LZ4)) {
    c = TSDB_COLVAL_COMPRESS_LZ4;
@ -200,6 +202,7 @@ uint16_t columnCompressVal(const char* compress) {
 }

 uint8_t columnEncodeVal(const char* encode) {
+  if (encode == NULL) return TSDB_COLVAL_ENCODE_NOCHANGE;
  uint8_t e = TSDB_COLVAL_ENCODE_SIMPLE8B;
  if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_SIMPLE8B)) {
    e = TSDB_COLVAL_ENCODE_SIMPLE8B;
@ -311,6 +314,7 @@ void setColLevel(uint32_t* compress, uint8_t level) {

 int32_t setColCompressByOption(uint8_t type, uint8_t encode, uint16_t compressType, uint8_t level, bool check,
                               uint32_t* compress) {
+  if(compress == NULL) return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;
  if (check && !validColEncode(type, encode)) return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;
  setColEncode(compress, encode);

--- a/source/common/src/tglobal.c
+++ b/source/common/src/tglobal.c
@ -185,7 +185,6 @@ int32_t tsMaxRetryWaitTime = 10000;
 bool    tsUseAdapter = false;
 int32_t tsMetaCacheMaxSize = -1;                   // MB
 int32_t tsSlowLogThreshold = 10;                   // seconds
-int32_t tsSlowLogThresholdTest = INT32_MAX;        // seconds
 char    tsSlowLogExceptDb[TSDB_DB_NAME_LEN] = "";  // seconds
 int32_t tsSlowLogScope = SLOW_LOG_TYPE_QUERY;
 char   *tsSlowLogScopeString = "query";
@ -766,7 +765,6 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "monitor", tsEnableMonitor, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "monitorInterval", tsMonitorInterval, 1, 86400, CFG_SCOPE_SERVER, CFG_DYN_SERVER));

-  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "slowLogThresholdTest", tsSlowLogThresholdTest, 0, INT32_MAX, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "slowLogThreshold", tsSlowLogThreshold, 1, INT32_MAX, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "slowLogMaxLen", tsSlowLogMaxLen, 1, 16384, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
  TAOS_CHECK_RETURN(cfgAddString(pCfg, "slowLogScope", tsSlowLogScopeString, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
@ -1450,9 +1448,6 @@ static int32_t taosSetServerCfg(SConfig *pCfg) {
  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "slowLogExceptDb");
  tstrncpy(tsSlowLogExceptDb, pItem->str, TSDB_DB_NAME_LEN);

-  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "slowLogThresholdTest");
-  tsSlowLogThresholdTest = pItem->i32;
-
  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "slowLogThreshold");
  tsSlowLogThreshold = pItem->i32;

@ -2024,7 +2019,6 @@ static int32_t taosCfgDynamicOptionsForServer(SConfig *pCfg, const char *name) {
                                         {"monitor", &tsEnableMonitor},
                                         {"monitorInterval", &tsMonitorInterval},
                                         {"slowLogThreshold", &tsSlowLogThreshold},
-                                         {"slowLogThresholdTest", &tsSlowLogThresholdTest},
                                         {"slowLogMaxLen", &tsSlowLogMaxLen},

                                         {"mndSdbWriteDelta", &tsMndSdbWriteDelta},
--- 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"

@ -76,7 +76,7 @@ static int32_t tSerializeSMonitorParas(SEncoder *encoder, const SMonitorParas *p
  TAOS_CHECK_RETURN(tEncodeI32(encoder, pMonitorParas->tsSlowLogScope));
  TAOS_CHECK_RETURN(tEncodeI32(encoder, pMonitorParas->tsSlowLogMaxLen));
  TAOS_CHECK_RETURN(tEncodeI32(encoder, pMonitorParas->tsSlowLogThreshold));
-  TAOS_CHECK_RETURN(tEncodeI32(encoder, pMonitorParas->tsSlowLogThresholdTest));
+  TAOS_CHECK_RETURN(tEncodeI32(encoder, pMonitorParas->tsSlowLogThresholdTest)); //Obsolete
  TAOS_CHECK_RETURN(tEncodeCStr(encoder, pMonitorParas->tsSlowLogExceptDb));
  return 0;
 }
@ -87,7 +87,7 @@ static int32_t tDeserializeSMonitorParas(SDecoder *decoder, SMonitorParas *pMoni
  TAOS_CHECK_RETURN(tDecodeI32(decoder, &pMonitorParas->tsSlowLogScope));
  TAOS_CHECK_RETURN(tDecodeI32(decoder, &pMonitorParas->tsSlowLogMaxLen));
  TAOS_CHECK_RETURN(tDecodeI32(decoder, &pMonitorParas->tsSlowLogThreshold));
-  TAOS_CHECK_RETURN(tDecodeI32(decoder, &pMonitorParas->tsSlowLogThresholdTest));
+  TAOS_CHECK_RETURN(tDecodeI32(decoder, &pMonitorParas->tsSlowLogThresholdTest)); //Obsolete
  TAOS_CHECK_RETURN(tDecodeCStrTo(decoder, pMonitorParas->tsSlowLogExceptDb));
  return 0;
 }
@ -2166,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) {
@ -2181,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) {
@ -2225,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));
@ -2245,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);
@ -2258,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);
  }
@ -8717,6 +8717,7 @@ int32_t tSerializeSSubQueryMsg(void *buf, int32_t bufLen, SSubQueryMsg *pReq) {
  TAOS_CHECK_EXIT(tEncodeCStrWithLen(&encoder, pReq->sql, pReq->sqlLen));
  TAOS_CHECK_EXIT(tEncodeU32(&encoder, pReq->msgLen));
  TAOS_CHECK_EXIT(tEncodeBinary(&encoder, (uint8_t *)pReq->msg, pReq->msgLen));
+  TAOS_CHECK_EXIT(tEncodeU64(&encoder, pReq->clientId));

  tEndEncode(&encoder);

@ -8765,6 +8766,11 @@ int32_t tDeserializeSSubQueryMsg(void *buf, int32_t bufLen, SSubQueryMsg *pReq)
  TAOS_CHECK_EXIT(tDecodeCStrAlloc(&decoder, &pReq->sql));
  TAOS_CHECK_EXIT(tDecodeU32(&decoder, &pReq->msgLen));
  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void **)&pReq->msg, NULL));
+  if (!tDecodeIsEnd(&decoder)) {
+    TAOS_CHECK_EXIT(tDecodeU64(&decoder, &pReq->clientId));
+  } else {
+    pReq->clientId = 0;
+  }

  tEndDecode(&decoder);

@ -8894,6 +8900,7 @@ int32_t tSerializeSResFetchReq(void *buf, int32_t bufLen, SResFetchReq *pReq) {
  } else {
    TAOS_CHECK_EXIT(tEncodeI32(&encoder, 0));
  }
+  TAOS_CHECK_EXIT(tEncodeU64(&encoder, pReq->clientId));

  tEndEncode(&encoder);

@ -8943,6 +8950,11 @@ int32_t tDeserializeSResFetchReq(void *buf, int32_t bufLen, SResFetchReq *pReq)
    }
    TAOS_CHECK_EXIT(tDeserializeSOperatorParam(&decoder, pReq->pOpParam));
  }
+  if (!tDecodeIsEnd(&decoder)) {
+    TAOS_CHECK_EXIT(tDecodeU64(&decoder, &pReq->clientId));
+  } else {
+    pReq->clientId = 0;
+  }

  tEndDecode(&decoder);

@ -9055,6 +9067,7 @@ int32_t tSerializeSTaskDropReq(void *buf, int32_t bufLen, STaskDropReq *pReq) {
  TAOS_CHECK_EXIT(tEncodeU64(&encoder, pReq->taskId));
  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->refId));
  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->execId));
+  TAOS_CHECK_EXIT(tEncodeU64(&encoder, pReq->clientId));

  tEndEncode(&encoder);

@ -9095,6 +9108,11 @@ int32_t tDeserializeSTaskDropReq(void *buf, int32_t bufLen, STaskDropReq *pReq)
  TAOS_CHECK_EXIT(tDecodeU64(&decoder, &pReq->taskId));
  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->refId));
  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->execId));
+  if (!tDecodeIsEnd(&decoder)) {
+    TAOS_CHECK_EXIT(tDecodeU64(&decoder, &pReq->clientId));
+  } else {
+    pReq->clientId = 0;
+  }

  tEndDecode(&decoder);

@ -9123,6 +9141,7 @@ int32_t tSerializeSTaskNotifyReq(void *buf, int32_t bufLen, STaskNotifyReq *pReq
  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->refId));
  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->execId));
  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->type));
+  TAOS_CHECK_EXIT(tEncodeU64(&encoder, pReq->clientId));

  tEndEncode(&encoder);

@ -9164,6 +9183,11 @@ int32_t tDeserializeSTaskNotifyReq(void *buf, int32_t bufLen, STaskNotifyReq *pR
  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->refId));
  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->execId));
  TAOS_CHECK_EXIT(tDecodeI32(&decoder, (int32_t *)&pReq->type));
+  if (!tDecodeIsEnd(&decoder)) {
+    TAOS_CHECK_EXIT(tDecodeU64(&decoder, &pReq->clientId));
+  } else {
+    pReq->clientId = 0;
+  }

  tEndDecode(&decoder);

@ -9353,6 +9377,10 @@ int32_t tSerializeSSchedulerHbRsp(void *buf, int32_t bufLen, SSchedulerHbRsp *pR
      TAOS_CHECK_EXIT(tEncodeI32(&encoder, status->execId));
      TAOS_CHECK_EXIT(tEncodeI8(&encoder, status->status));
    }
+    for (int32_t i = 0; i < num; ++i) {
+      STaskStatus *status = taosArrayGet(pRsp->taskStatus, i);
+      TAOS_CHECK_EXIT(tEncodeU64(&encoder, status->clientId));
+    }
  } else {
    TAOS_CHECK_EXIT(tEncodeI32(&encoder, 0));
  }
@ -9396,6 +9424,12 @@ int32_t tDeserializeSSchedulerHbRsp(void *buf, int32_t bufLen, SSchedulerHbRsp *
        TAOS_CHECK_EXIT(terrno);
      }
    }
+    if (!tDecodeIsEnd(&decoder)) {
+      for (int32_t i = 0; i < num; ++i) {
+        STaskStatus *status = taosArrayGet(pRsp->taskStatus, i);
+        TAOS_CHECK_EXIT(tDecodeU64(&decoder, &status->clientId));
+      }
+    }
  } else {
    pRsp->taskStatus = NULL;
  }
@ -9560,6 +9594,7 @@ int32_t tSerializeSVDeleteReq(void *buf, int32_t bufLen, SVDeleteReq *pReq) {
  TAOS_CHECK_EXIT(tEncodeCStr(&encoder, pReq->sql));
  TAOS_CHECK_EXIT(tEncodeBinary(&encoder, pReq->msg, pReq->phyLen));
  TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->source));
+  TAOS_CHECK_EXIT(tEncodeU64(&encoder, pReq->clientId));
  tEndEncode(&encoder);

 _exit:
@ -9608,6 +9643,11 @@ int32_t tDeserializeSVDeleteReq(void *buf, int32_t bufLen, SVDeleteReq *pReq) {
  if (!tDecodeIsEnd(&decoder)) {
    TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->source));
  }
+  if (!tDecodeIsEnd(&decoder)) {
+    TAOS_CHECK_EXIT(tDecodeU64(&decoder, &pReq->clientId));
+  } else {
+    pReq->clientId = 0;
+  }
  tEndDecode(&decoder);

 _exit:
@ -10277,6 +10317,7 @@ static int32_t tEncodeSVDropTbReq(SEncoder *pCoder, const SVDropTbReq *pReq) {
  TAOS_CHECK_RETURN(tStartEncode(pCoder));
  TAOS_CHECK_RETURN(tEncodeCStr(pCoder, pReq->name));
  TAOS_CHECK_RETURN(tEncodeU64(pCoder, pReq->suid));
+  TAOS_CHECK_RETURN(tEncodeI64(pCoder, pReq->uid));
  TAOS_CHECK_RETURN(tEncodeI8(pCoder, pReq->igNotExists));

  tEndEncode(pCoder);
@ -10287,6 +10328,7 @@ static int32_t tDecodeSVDropTbReq(SDecoder *pCoder, SVDropTbReq *pReq) {
  TAOS_CHECK_RETURN(tStartDecode(pCoder));
  TAOS_CHECK_RETURN(tDecodeCStr(pCoder, &pReq->name));
  TAOS_CHECK_RETURN(tDecodeU64(pCoder, &pReq->suid));
+  TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pReq->uid));
  TAOS_CHECK_RETURN(tDecodeI8(pCoder, &pReq->igNotExists));

  tEndDecode(pCoder);
--- a/source/common/src/ttime.c
+++ b/source/common/src/ttime.c
@ -30,7 +30,7 @@ static int64_t m_deltaUtc = 0;

 void deltaToUtcInitOnce() {
  struct tm tm = {0};
-  if (taosStrpTime("1970-01-01 00:00:00", (const char*)("%Y-%m-%d %H:%M:%S"), &tm) != 0) {
+  if (taosStrpTime("1970-01-01 00:00:00", (const char*)("%Y-%m-%d %H:%M:%S"), &tm) == NULL) {
    uError("failed to parse time string");
  }
  m_deltaUtc = (int64_t)taosMktime(&tm);
--- 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;
@ -195,7 +195,6 @@ void dmSendStatusReq(SDnodeMgmt *pMgmt) {
  req.clusterCfg.monitorParas.tsSlowLogScope = tsSlowLogScope;
  req.clusterCfg.monitorParas.tsSlowLogMaxLen = tsSlowLogMaxLen;
  req.clusterCfg.monitorParas.tsSlowLogThreshold = tsSlowLogThreshold;
-  req.clusterCfg.monitorParas.tsSlowLogThresholdTest = tsSlowLogThresholdTest;
  tstrncpy(req.clusterCfg.monitorParas.tsSlowLogExceptDb, tsSlowLogExceptDb, TSDB_DB_NAME_LEN);
  char timestr[32] = "1970-01-01 00:00:00.00";
  if (taosParseTime(timestr, &req.clusterCfg.checkTime, (int32_t)strlen(timestr), TSDB_TIME_PRECISION_MILLI, 0) != 0) {
--- 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/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) {
--- 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
@ -482,7 +482,6 @@ static int32_t mndCheckClusterCfgPara(SMnode *pMnode, SDnodeObj *pDnode, const S
  CHECK_MONITOR_PARA(tsEnableMonitor, DND_REASON_STATUS_MONITOR_SWITCH_NOT_MATCH);
  CHECK_MONITOR_PARA(tsMonitorInterval, DND_REASON_STATUS_MONITOR_INTERVAL_NOT_MATCH);
  CHECK_MONITOR_PARA(tsSlowLogThreshold, DND_REASON_STATUS_MONITOR_SLOW_LOG_THRESHOLD_NOT_MATCH);
-  CHECK_MONITOR_PARA(tsSlowLogThresholdTest, DND_REASON_STATUS_MONITOR_NOT_MATCH);
  CHECK_MONITOR_PARA(tsSlowLogMaxLen, DND_REASON_STATUS_MONITOR_SLOW_LOG_SQL_MAX_LEN_NOT_MATCH);
  CHECK_MONITOR_PARA(tsSlowLogScope, DND_REASON_STATUS_MONITOR_SLOW_LOG_SCOPE_NOT_MATCH);

--- a/source/dnode/mnode/impl/src/mndProfile.c
+++ b/source/dnode/mnode/impl/src/mndProfile.c
@ -304,7 +304,6 @@ static int32_t mndProcessConnectReq(SRpcMsg *pReq) {
  connectRsp.monitorParas.tsSlowLogScope = tsSlowLogScope;
  connectRsp.monitorParas.tsSlowLogMaxLen = tsSlowLogMaxLen;
  connectRsp.monitorParas.tsSlowLogThreshold = tsSlowLogThreshold;
-  connectRsp.monitorParas.tsSlowLogThresholdTest = tsSlowLogThresholdTest;
  connectRsp.enableAuditDelete = tsEnableAuditDelete;
  tstrncpy(connectRsp.monitorParas.tsSlowLogExceptDb, tsSlowLogExceptDb, TSDB_DB_NAME_LEN);
  connectRsp.whiteListVer = pUser->ipWhiteListVer;
@ -706,7 +705,6 @@ static int32_t mndProcessHeartBeatReq(SRpcMsg *pReq) {
  batchRsp.monitorParas.tsEnableMonitor = tsEnableMonitor;
  batchRsp.monitorParas.tsMonitorInterval = tsMonitorInterval;
  batchRsp.monitorParas.tsSlowLogThreshold = tsSlowLogThreshold;
-  batchRsp.monitorParas.tsSlowLogThresholdTest = tsSlowLogThresholdTest;
  tstrncpy(batchRsp.monitorParas.tsSlowLogExceptDb, tsSlowLogExceptDb, TSDB_DB_NAME_LEN);
  batchRsp.monitorParas.tsSlowLogMaxLen = tsSlowLogMaxLen;
  batchRsp.monitorParas.tsSlowLogScope = tsSlowLogScope;
--- a/source/dnode/mnode/impl/src/mndStb.c
+++ b/source/dnode/mnode/impl/src/mndStb.c
@ -4063,8 +4063,8 @@ static int32_t mndProcessDropStbReqFromMNode(SRpcMsg *pReq) {
 }

 typedef struct SVDropTbVgReqs {
-  SVDropTbBatchReq req;
-  SVgroupInfo      info;
+  SArray     *pBatchReqs;
+  SVgroupInfo info;
 } SVDropTbVgReqs;

 typedef struct SMDropTbDbInfo {
@ -4086,45 +4086,21 @@ typedef struct SMDropTbTsmaInfos {
 } SMDropTbTsmaInfos;

 typedef struct SMndDropTbsWithTsmaCtx {
-  SHashObj *pTsmaMap;     // <suid, SMDropTbTsmaInfos>
-  SHashObj *pDbMap;       // <dbuid, SMDropTbDbInfo>
-  SHashObj *pVgMap;       // <vgId, SVDropTbVgReqs>
-  SArray   *pResTbNames;  // SArray<char*>
+  SHashObj *pVgMap; // <vgId, SVDropTbVgReqs>
 } SMndDropTbsWithTsmaCtx;

-static int32_t mndDropTbAddTsmaResTbsForSingleVg(SMnode *pMnode, SMndDropTbsWithTsmaCtx *pCtx, SArray *pTbs,
+static int32_t mndDropTbForSingleVg(SMnode *pMnode, SMndDropTbsWithTsmaCtx *pCtx, SArray *pTbs,
                                                 int32_t vgId);

+static void destroySVDropTbBatchReqs(void *p);
 static void mndDestroyDropTbsWithTsmaCtx(SMndDropTbsWithTsmaCtx *p) {
  if (!p) return;

-  if (p->pDbMap) {
-    void *pIter = taosHashIterate(p->pDbMap, NULL);
-    while (pIter) {
-      SMDropTbDbInfo *pInfo = pIter;
-      taosArrayDestroy(pInfo->dbVgInfos);
-      pIter = taosHashIterate(p->pDbMap, pIter);
-    }
-    taosHashCleanup(p->pDbMap);
-  }
-  if (p->pResTbNames) {
-    taosArrayDestroyP(p->pResTbNames, taosMemoryFree);
-  }
-  if (p->pTsmaMap) {
-    void *pIter = taosHashIterate(p->pTsmaMap, NULL);
-    while (pIter) {
-      SMDropTbTsmaInfos *pInfos = pIter;
-      taosArrayDestroy(pInfos->pTsmaInfos);
-      pIter = taosHashIterate(p->pTsmaMap, pIter);
-    }
-    taosHashCleanup(p->pTsmaMap);
-  }
-
  if (p->pVgMap) {
    void *pIter = taosHashIterate(p->pVgMap, NULL);
    while (pIter) {
      SVDropTbVgReqs *pReqs = pIter;
-      taosArrayDestroy(pReqs->req.pArray);
+      taosArrayDestroyEx(pReqs->pBatchReqs, destroySVDropTbBatchReqs);
      pIter = taosHashIterate(p->pVgMap, pIter);
    }
    taosHashCleanup(p->pVgMap);
@ -4136,24 +4112,13 @@ static int32_t mndInitDropTbsWithTsmaCtx(SMndDropTbsWithTsmaCtx **ppCtx) {
  int32_t                 code = 0;
  SMndDropTbsWithTsmaCtx *pCtx = taosMemoryCalloc(1, sizeof(SMndDropTbsWithTsmaCtx));
  if (!pCtx) return terrno;
-  pCtx->pTsmaMap = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK);
-  if (!pCtx->pTsmaMap) {
-    code = terrno;
-    goto _end;
-  }
-
-  pCtx->pDbMap = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
-  if (!pCtx->pDbMap) {
-    code = terrno;
-    goto _end;
-  }
-  pCtx->pResTbNames = taosArrayInit(TARRAY_MIN_SIZE, POINTER_BYTES);

  pCtx->pVgMap = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_NO_LOCK);
  if (!pCtx->pVgMap) {
    code = terrno;
    goto _end;
  }
+
  *ppCtx = pCtx;
 _end:
  if (code) mndDestroyDropTbsWithTsmaCtx(pCtx);
@ -4192,16 +4157,43 @@ static void *mndBuildVDropTbsReq(SMnode *pMnode, const SVgroupInfo *pVgInfo, con
 }

 static int32_t mndSetDropTbsRedoActions(SMnode *pMnode, STrans *pTrans, const SVDropTbVgReqs *pVgReqs, void *pCont,
-                                        int32_t contLen) {
+                                        int32_t contLen, tmsg_t msgType) {
  STransAction action = {0};
  action.epSet = pVgReqs->info.epSet;
  action.pCont = pCont;
  action.contLen = contLen;
-  action.msgType = TDMT_VND_DROP_TABLE;
+  action.msgType = msgType;
  action.acceptableCode = TSDB_CODE_TDB_TABLE_NOT_EXIST;
  return mndTransAppendRedoAction(pTrans, &action);
 }

+static int32_t mndBuildDropTbRedoActions(SMnode *pMnode, STrans *pTrans, SHashObj *pVgMap, tmsg_t msgType) {
+  int32_t code = 0;
+  void   *pIter = taosHashIterate(pVgMap, NULL);
+  while (pIter) {
+    const SVDropTbVgReqs *pVgReqs = pIter;
+    int32_t               len = 0;
+    for (int32_t i = 0; i < taosArrayGetSize(pVgReqs->pBatchReqs) && code == TSDB_CODE_SUCCESS; ++i) {
+      SVDropTbBatchReq *pBatchReq = taosArrayGet(pVgReqs->pBatchReqs, i);
+      void             *p = mndBuildVDropTbsReq(pMnode, &pVgReqs->info, pBatchReq, &len);
+      if (!p) {
+        code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+        if (terrno != 0) code = terrno;
+        break;
+      }
+      if ((code = mndSetDropTbsRedoActions(pMnode, pTrans, pVgReqs, p, len, msgType)) != 0) {
+        break;
+      }
+    }
+    if (TSDB_CODE_SUCCESS != code) {
+      taosHashCancelIterate(pVgMap, pIter);
+      break;
+    }
+    pIter = taosHashIterate(pVgMap, pIter);
+  }
+  return code;
+}
+
 static int32_t mndCreateDropTbsTxnPrepare(SRpcMsg *pRsp, SMndDropTbsWithTsmaCtx *pCtx) {
  int32_t code = 0;
  SMnode *pMnode = pRsp->info.node;
@ -4216,23 +4208,7 @@ static int32_t mndCreateDropTbsTxnPrepare(SRpcMsg *pRsp, SMndDropTbsWithTsmaCtx

  TAOS_CHECK_GOTO(mndTransCheckConflict(pMnode, pTrans), NULL, _OVER);

-  void *pIter = taosHashIterate(pCtx->pVgMap, NULL);
-  while (pIter) {
-    const SVDropTbVgReqs *pVgReqs = pIter;
-    int32_t               len = 0;
-    void                 *p = mndBuildVDropTbsReq(pMnode, &pVgReqs->info, &pVgReqs->req, &len);
-    if (!p) {
-      taosHashCancelIterate(pCtx->pVgMap, pIter);
-      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
-      if (terrno != 0) code = terrno;
-      goto _OVER;
-    }
-    if ((code = mndSetDropTbsRedoActions(pMnode, pTrans, pVgReqs, p, len)) != 0) {
-      taosHashCancelIterate(pCtx->pVgMap, pIter);
-      goto _OVER;
-    }
-    pIter = taosHashIterate(pCtx->pVgMap, pIter);
-  }
+  if ((code = mndBuildDropTbRedoActions(pMnode, pTrans, pCtx->pVgMap, TDMT_VND_DROP_TABLE)) != 0) goto _OVER;
  if ((code = mndTransPrepare(pMnode, pTrans)) != 0) goto _OVER;

 _OVER:
@ -4257,10 +4233,11 @@ static int32_t mndProcessDropTbWithTsma(SRpcMsg *pReq) {
  if (code) goto _OVER;
  for (int32_t i = 0; i < dropReq.pVgReqs->size; ++i) {
    SMDropTbReqsOnSingleVg *pReq = taosArrayGet(dropReq.pVgReqs, i);
-    code = mndDropTbAddTsmaResTbsForSingleVg(pMnode, pCtx, pReq->pTbs, pReq->vgInfo.vgId);
+    code = mndDropTbForSingleVg(pMnode, pCtx, pReq->pTbs, pReq->vgInfo.vgId);
    if (code) goto _OVER;
  }
-  if (mndCreateDropTbsTxnPrepare(pReq, pCtx) == 0) {
+  code = mndCreateDropTbsTxnPrepare(pReq, pCtx);
+  if (code == 0) {
    code = TSDB_CODE_ACTION_IN_PROGRESS;
  }
 _OVER:
@ -4269,87 +4246,58 @@ _OVER:
  TAOS_RETURN(code);
 }

+static int32_t createDropTbBatchReq(const SVDropTbReq *pReq, SVDropTbBatchReq *pBatchReq) {
+  pBatchReq->nReqs = 1;
+  pBatchReq->pArray = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SVDropTbReq));
+  if (!pBatchReq->pArray) return terrno;
+  if (taosArrayPush(pBatchReq->pArray, pReq) == NULL) {
+    taosArrayDestroy(pBatchReq->pArray);
+    pBatchReq->pArray = NULL;
+    return terrno;
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
+static void destroySVDropTbBatchReqs(void *p) {
+  SVDropTbBatchReq *pReq = p;
+  taosArrayDestroy(pReq->pArray);
+  pReq->pArray = NULL;
+}
+
 static int32_t mndDropTbAdd(SMnode *pMnode, SHashObj *pVgHashMap, const SVgroupInfo *pVgInfo, char *name, tb_uid_t suid,
                            bool ignoreNotExists) {
-  SVDropTbReq req = {.name = name, .suid = suid, .igNotExists = ignoreNotExists};
+  SVDropTbReq req = {.name = name, .suid = suid, .igNotExists = ignoreNotExists, .uid = 0};

-  SVDropTbVgReqs *pReqs = taosHashGet(pVgHashMap, &pVgInfo->vgId, sizeof(pVgInfo->vgId));
-  SVDropTbVgReqs  reqs = {0};
-  if (pReqs == NULL) {
-    reqs.info = *pVgInfo;
-    reqs.req.pArray = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SVDropTbReq));
-    if (reqs.req.pArray == NULL) {
+  SVDropTbVgReqs *pVgReqs = taosHashGet(pVgHashMap, &pVgInfo->vgId, sizeof(pVgInfo->vgId));
+  SVDropTbVgReqs  vgReqs = {0};
+  if (pVgReqs == NULL) {
+    vgReqs.info = *pVgInfo;
+    vgReqs.pBatchReqs = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SVDropTbBatchReq));
+    if (!vgReqs.pBatchReqs) return terrno;
+    SVDropTbBatchReq batchReq = {0};
+    int32_t          code = createDropTbBatchReq(&req, &batchReq);
+    if (TSDB_CODE_SUCCESS != code) return code;
+    if (taosArrayPush(vgReqs.pBatchReqs, &batchReq) == NULL) {
+      taosArrayDestroy(batchReq.pArray);
      return terrno;
    }
-    if (taosArrayPush(reqs.req.pArray, &req) == NULL) {
-      return terrno;
-    }
-    if (taosHashPut(pVgHashMap, &pVgInfo->vgId, sizeof(pVgInfo->vgId), &reqs, sizeof(reqs)) != 0) {
+    if (taosHashPut(pVgHashMap, &pVgInfo->vgId, sizeof(pVgInfo->vgId), &vgReqs, sizeof(vgReqs)) != 0) {
+      taosArrayDestroyEx(vgReqs.pBatchReqs, destroySVDropTbBatchReqs);
      return terrno;
    }
  } else {
-    if (taosArrayPush(pReqs->req.pArray, &req) == NULL) {
+    SVDropTbBatchReq batchReq = {0};
+    int32_t          code = createDropTbBatchReq(&req, &batchReq);
+    if (TSDB_CODE_SUCCESS != code) return code;
+    if (taosArrayPush(pVgReqs->pBatchReqs, &batchReq) == NULL) {
+      taosArrayDestroy(batchReq.pArray);
      return terrno;
    }
  }
  return 0;
 }

-int vgInfoCmp(const void *lp, const void *rp) {
-  SVgroupInfo *pLeft = (SVgroupInfo *)lp;
-  SVgroupInfo *pRight = (SVgroupInfo *)rp;
-  if (pLeft->hashBegin < pRight->hashBegin) {
-    return -1;
-  } else if (pLeft->hashBegin > pRight->hashBegin) {
-    return 1;
-  }
-
-  return 0;
-}
-
-static int32_t mndGetDbVgInfoForTsma(SMnode *pMnode, const char *dbname, SMDropTbTsmaInfo *pInfo) {
-  int32_t code = 0;
-  SDbObj *pDb = mndAcquireDb(pMnode, dbname);
-  if (!pDb) {
-    code = TSDB_CODE_MND_DB_NOT_EXIST;
-    goto _end;
-  }
-
-  pInfo->dbInfo.dbVgInfos = taosArrayInit(pDb->cfg.numOfVgroups, sizeof(SVgroupInfo));
-  if (!pInfo->dbInfo.dbVgInfos) {
-    code = terrno;
-    goto _end;
-  }
-  mndBuildDBVgroupInfo(pDb, pMnode, pInfo->dbInfo.dbVgInfos);
-  taosArraySort(pInfo->dbInfo.dbVgInfos, vgInfoCmp);
-
-  pInfo->dbInfo.hashPrefix = pDb->cfg.hashPrefix;
-  pInfo->dbInfo.hashSuffix = pDb->cfg.hashSuffix;
-  pInfo->dbInfo.hashMethod = pDb->cfg.hashMethod;
-
-_end:
-  if (pDb) mndReleaseDb(pMnode, pDb);
-  if (code && pInfo->dbInfo.dbVgInfos) {
-    taosArrayDestroy(pInfo->dbInfo.dbVgInfos);
-    pInfo->dbInfo.dbVgInfos = NULL;
-  }
-  TAOS_RETURN(code);
-}
-
-int32_t vgHashValCmp(const void *lp, const void *rp) {
-  uint32_t    *key = (uint32_t *)lp;
-  SVgroupInfo *pVg = (SVgroupInfo *)rp;
-
-  if (*key < pVg->hashBegin) {
-    return -1;
-  } else if (*key > pVg->hashEnd) {
-    return 1;
-  }
-
-  return 0;
-}
-
-static int32_t mndDropTbAddTsmaResTbsForSingleVg(SMnode *pMnode, SMndDropTbsWithTsmaCtx *pCtx, SArray *pTbs,
+static int32_t mndDropTbForSingleVg(SMnode *pMnode, SMndDropTbsWithTsmaCtx *pCtx, SArray *pTbs,
                                                 int32_t vgId) {
  int32_t code = 0;

@ -4365,88 +4313,9 @@ static int32_t mndDropTbAddTsmaResTbsForSingleVg(SMnode *pMnode, SMndDropTbsWith
  vgInfo.epSet = mndGetVgroupEpset(pMnode, pVgObj);
  mndReleaseVgroup(pMnode, pVgObj);

-  // get all stb uids
-  for (int32_t i = 0; i < pTbs->size; ++i) {
-    const SVDropTbReq *pTb = taosArrayGet(pTbs, i);
-    if (taosHashGet(pCtx->pTsmaMap, &pTb->suid, sizeof(pTb->suid))) {
-    } else {
-      SMDropTbTsmaInfos infos = {0};
-      infos.pTsmaInfos = taosArrayInit(2, sizeof(SMDropTbTsmaInfo));
-      if (!infos.pTsmaInfos) {
-        code = terrno;
-        goto _end;
-      }
-      if (taosHashPut(pCtx->pTsmaMap, &pTb->suid, sizeof(pTb->suid), &infos, sizeof(infos)) != 0) {
-        code = terrno;
-        goto _end;
-      }
-    }
-  }
-
-  void    *pIter = NULL;
-  SSmaObj *pSma = NULL;
-  char     buf[TSDB_TABLE_FNAME_LEN] = {0};
-  // get used tsmas and it's dbs
-  while (1) {
-    pIter = sdbFetch(pMnode->pSdb, SDB_SMA, pIter, (void **)&pSma);
-    if (!pIter) break;
-    SMDropTbTsmaInfos *pInfos = taosHashGet(pCtx->pTsmaMap, &pSma->stbUid, sizeof(pSma->stbUid));
-    if (pInfos) {
-      SMDropTbTsmaInfo info = {0};
-      int32_t          len = sprintf(buf, "%s", pSma->name);
-      sprintf(info.tsmaResTbDbFName, "%s", pSma->db);
-      snprintf(info.tsmaResTbNamePrefix, TSDB_TABLE_FNAME_LEN, "%s", buf);
-      SMDropTbDbInfo *pDbInfo = taosHashGet(pCtx->pDbMap, pSma->db, TSDB_DB_FNAME_LEN);
-      info.suid = pSma->dstTbUid;
-      if (!pDbInfo) {
-        code = mndGetDbVgInfoForTsma(pMnode, pSma->db, &info);
-        if (code != TSDB_CODE_SUCCESS) {
-          sdbCancelFetch(pMnode->pSdb, pIter);
-          sdbRelease(pMnode->pSdb, pSma);
-          goto _end;
-        }
-        if (taosHashPut(pCtx->pDbMap, pSma->db, TSDB_DB_FNAME_LEN, &info.dbInfo, sizeof(SMDropTbDbInfo)) != 0) {
-          sdbCancelFetch(pMnode->pSdb, pIter);
-          sdbRelease(pMnode->pSdb, pSma);
-          goto _end;
-        }
-      } else {
-        info.dbInfo = *pDbInfo;
-      }
-      if (taosArrayPush(pInfos->pTsmaInfos, &info) == NULL) {
-        code = terrno;
-        sdbCancelFetch(pMnode->pSdb, pIter);
-        sdbRelease(pMnode->pSdb, pSma);
-        goto _end;
-      }
-    }
-    sdbRelease(pMnode->pSdb, pSma);
-  }
-
-  // generate vg req map
  for (int32_t i = 0; i < pTbs->size; ++i) {
    SVDropTbReq *pTb = taosArrayGet(pTbs, i);
    TAOS_CHECK_GOTO(mndDropTbAdd(pMnode, pCtx->pVgMap, &vgInfo, pTb->name, pTb->suid, pTb->igNotExists), NULL, _end);
-
-    SMDropTbTsmaInfos *pInfos = taosHashGet(pCtx->pTsmaMap, &pTb->suid, sizeof(pTb->suid));
-    SArray            *pVgInfos = NULL;
-    char               buf[TSDB_TABLE_FNAME_LEN + TSDB_TABLE_NAME_LEN + 1];
-    char               resTbFullName[TSDB_TABLE_FNAME_LEN + 1] = {0};
-    for (int32_t j = 0; j < pInfos->pTsmaInfos->size; ++j) {
-      SMDropTbTsmaInfo *pInfo = taosArrayGet(pInfos->pTsmaInfos, j);
-      int32_t           len = sprintf(buf, "%s_%s", pInfo->tsmaResTbNamePrefix, pTb->name);
-      len = taosCreateMD5Hash(buf, len);
-      len = snprintf(resTbFullName, TSDB_TABLE_FNAME_LEN + 1, "%s.%s", pInfo->tsmaResTbDbFName, buf);
-      uint32_t hashVal = taosGetTbHashVal(resTbFullName, len, pInfo->dbInfo.hashMethod, pInfo->dbInfo.hashPrefix,
-                                          pInfo->dbInfo.hashSuffix);
-      const SVgroupInfo *pVgInfo = taosArraySearch(pInfo->dbInfo.dbVgInfos, &hashVal, vgHashValCmp, TD_EQ);
-      void              *p = taosStrdup(resTbFullName + strlen(pInfo->tsmaResTbDbFName) + TSDB_NAME_DELIMITER_LEN);
-      if (taosArrayPush(pCtx->pResTbNames, &p) == NULL) {
-        code = terrno;
-        goto _end;
-      }
-      TAOS_CHECK_GOTO(mndDropTbAdd(pMnode, pCtx->pVgMap, pVgInfo, p, pInfo->suid, true), NULL, _end);
-    }
  }
 _end:
  return code;
@ -4474,9 +4343,10 @@ static int32_t mndProcessFetchTtlExpiredTbs(SRpcMsg *pRsp) {
  code = mndInitDropTbsWithTsmaCtx(&pCtx);
  if (code) goto _end;

-  code = mndDropTbAddTsmaResTbsForSingleVg(pMnode, pCtx, rsp.pExpiredTbs, rsp.vgId);
+  code = mndDropTbForSingleVg(pMnode, pCtx, rsp.pExpiredTbs, rsp.vgId);
  if (code) goto _end;
-  if (mndCreateDropTbsTxnPrepare(pRsp, pCtx) == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;
+  code = mndCreateDropTbsTxnPrepare(pRsp, pCtx);
+  if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;
 _end:
  if (pCtx) mndDestroyDropTbsWithTsmaCtx(pCtx);
  tDecoderClear(&decoder);
--- a/source/dnode/snode/src/snodeInitApi.c
+++ b/source/dnode/snode/src/snodeInitApi.c
@ -31,6 +31,7 @@ void initStateStoreAPI(SStateStore* pStore) {

  pStore->streamStatePutParName = streamStatePutParName;
  pStore->streamStateGetParName = streamStateGetParName;
+  pStore->streamStateDeleteParName = streamStateDeleteParName;

  pStore->streamStateAddIfNotExist = streamStateAddIfNotExist;
  pStore->streamStateReleaseBuf = streamStateReleaseBuf;
--- a/source/dnode/vnode/src/inc/tq.h
+++ b/source/dnode/vnode/src/inc/tq.h
@ -146,7 +146,7 @@ int32_t tqBuildFName(char** data, const char* path, char* name);
 int32_t tqOffsetRestoreFromFile(STQ* pTq, char* name);

 // tq util
-int32_t tqExtractDelDataBlock(const void* pData, int32_t len, int64_t ver, void** pRefBlock, int32_t type);
+int32_t tqExtractDelDataBlock(const void* pData, int32_t len, int64_t ver, void** pRefBlock, int32_t type, EStreamType blockType);
 int32_t tqExtractDataForMq(STQ* pTq, STqHandle* pHandle, const SMqPollReq* pRequest, SRpcMsg* pMsg);
 int32_t tqDoSendDataRsp(const SRpcHandleInfo* pRpcHandleInfo, const SMqDataRsp* pRsp, int32_t epoch, int64_t consumerId,
                        int32_t type, int64_t sver, int64_t ever);
@ -158,6 +158,7 @@ int32_t doMergeExistedRows(SSubmitTbData* pExisted, const SSubmitTbData* pNew, c

 int32_t buildAutoCreateTableReq(const char* stbFullName, int64_t suid, int32_t numOfCols, SSDataBlock* pDataBlock,
                                SArray* pTagArray, bool newSubTableRule, SVCreateTbReq** pReq);
+int32_t tqExtractDropCtbDataBlock(const void* data, int32_t len, int64_t ver, void** pRefBlock, int32_t type);

 #define TQ_ERR_GO_TO_END(c)          \
  do {                               \
--- a/source/dnode/vnode/src/sma/smaRollup.c
+++ b/source/dnode/vnode/src/sma/smaRollup.c
@ -1551,7 +1551,7 @@ static int32_t tdRSmaBatchExec(SSma *pSma, SRSmaInfo *pInfo, STaosQall *qall, SA
      _resume_delete:
        version = RSMA_EXEC_MSG_VER(msg);
        if ((code = tqExtractDelDataBlock(RSMA_EXEC_MSG_BODY(msg), RSMA_EXEC_MSG_LEN(msg), version,
-                                          &packData.pDataBlock, 1))) {
+                                          &packData.pDataBlock, 1, STREAM_DELETE_DATA))) {
          taosFreeQitem(msg);
          TAOS_CHECK_EXIT(code);
        }
--- a/source/dnode/vnode/src/tq/tq.c
+++ b/source/dnode/vnode/src/tq/tq.c
@ -758,7 +758,8 @@ int32_t tqBuildStreamTask(void* pTqObj, SStreamTask* pTask, int64_t nextProcessV
  }

  if (pTask->info.taskLevel == TASK_LEVEL__SOURCE) {
-    SWalFilterCond cond = {.deleteMsg = 1};  // delete msg also extract from wal files
+    bool scanDropCtb = pTask->subtableWithoutMd5 ? true : false;
+    SWalFilterCond cond = {.deleteMsg = 1, .scanDropCtb = scanDropCtb};  // delete msg also extract from wal files
    pTask->exec.pWalReader = walOpenReader(pTq->pVnode->pWal, &cond, pTask->id.taskId);
    if (pTask->exec.pWalReader == NULL) {
      tqError("vgId:%d failed init wal reader, code:%s", vgId, tstrerror(terrno));
--- a/source/dnode/vnode/src/tq/tqRead.c
+++ b/source/dnode/vnode/src/tq/tqRead.c
@ -366,8 +366,8 @@ int32_t extractMsgFromWal(SWalReader* pReader, void** pItem, int64_t maxVer, con
    } else if (pCont->msgType == TDMT_VND_DELETE) {
      void*   pBody = POINTER_SHIFT(pCont->body, sizeof(SMsgHead));
      int32_t len = pCont->bodyLen - sizeof(SMsgHead);
-
-      code = tqExtractDelDataBlock(pBody, len, ver, (void**)pItem, 0);
+      EStreamType blockType = STREAM_DELETE_DATA;
+      code = tqExtractDelDataBlock(pBody, len, ver, (void**)pItem, 0, blockType);
      if (code == TSDB_CODE_SUCCESS) {
        if (*pItem == NULL) {
          tqDebug("s-task:%s empty delete msg, discard it, len:%d, ver:%" PRId64, id, len, ver);
@ -382,6 +382,20 @@ int32_t extractMsgFromWal(SWalReader* pReader, void** pItem, int64_t maxVer, con
        return code;
      }

+    } else if (pCont->msgType == TDMT_VND_DROP_TABLE && pReader->cond.scanDropCtb) {
+      void* pBody = POINTER_SHIFT(pCont->body, sizeof(SMsgHead));
+      int32_t len = pCont->bodyLen - sizeof(SMsgHead);
+      code = tqExtractDropCtbDataBlock(pBody, len, ver, (void**)pItem, 0);
+      if (TSDB_CODE_SUCCESS == code) {
+        if (!*pItem) {
+          continue;
+        } else {
+          tqDebug("s-task:%s drop ctb msg extract from WAL, len:%d, ver:%"PRId64, id, len, ver);
+        }
+      } else {
+        terrno = code;
+        return code;
+      }
    } else {
      tqError("s-task:%s invalid msg type:%d, ver:%" PRId64, id, pCont->msgType, ver);
      return TSDB_CODE_STREAM_INTERNAL_ERROR;
--- a/source/dnode/vnode/src/tq/tqSink.c
+++ b/source/dnode/vnode/src/tq/tqSink.c
@ -53,6 +53,7 @@ static int32_t checkTagSchema(SStreamTask* pTask, SVnode* pVnode);
 static void reubuildAndSendMultiResBlock(SStreamTask* pTask, const SArray* pBlocks, SVnode* pVnode, int64_t earlyTs);
 static int32_t handleResultBlockMsg(SStreamTask* pTask, SSDataBlock* pDataBlock, int32_t index, SVnode* pVnode,
                                    int64_t earlyTs);
+static int32_t doWaitForDstTableDropped(SVnode* pVnode, SStreamTask* pTask, const char* dstTableName);

 int32_t tqBuildDeleteReq(STQ* pTq, const char* stbFullName, const SSDataBlock* pDataBlock, SBatchDeleteReq* deleteReq,
                         const char* pIdStr, bool newSubTableRule) {
@ -138,7 +139,7 @@ int32_t tqBuildDeleteReq(STQ* pTq, const char* stbFullName, const SSDataBlock* p
  return 0;
 }

-static int32_t encodeCreateChildTableForRPC(SVCreateTbBatchReq* pReqs, int32_t vgId, void** pBuf, int32_t* contLen) {
+static int32_t encodeCreateChildTableForRPC(void* pReqs, int32_t vgId, void** pBuf, int32_t* contLen) {
  int32_t ret = 0;

  tEncodeSize(tEncodeSVCreateTbBatchReq, pReqs, *contLen, ret);
@ -170,17 +171,50 @@ end:
  return ret;
 }

-static int32_t tqPutReqToQueue(SVnode* pVnode, SVCreateTbBatchReq* pReqs) {
+static int32_t encodeDropChildTableForRPC(void* pReqs, int32_t vgId, void** ppBuf, int32_t *contLen) {
+  int32_t  code = 0;
+  SEncoder ec = {0};
+  tEncodeSize(tEncodeSVDropTbBatchReq, pReqs, *contLen, code);
+  if (code < 0) {
+    code = TSDB_CODE_INVALID_MSG;
+    goto end;
+  }
+  *contLen += sizeof(SMsgHead);
+  *ppBuf = rpcMallocCont(*contLen);
+
+  if (!*ppBuf) {
+    code = terrno;
+    goto end;
+  }
+
+  ((SMsgHead*)(*ppBuf))->vgId = vgId;
+  ((SMsgHead*)(*ppBuf))->contLen = htonl(*contLen);
+
+  tEncoderInit(&ec, POINTER_SHIFT(*ppBuf, sizeof(SMsgHead)), (*contLen) - sizeof(SMsgHead));
+  code = tEncodeSVDropTbBatchReq(&ec, pReqs);
+  tEncoderClear(&ec);
+  if (code < 0) {
+    rpcFreeCont(*ppBuf);
+    *ppBuf = NULL;
+    *contLen = 0;
+    code = TSDB_CODE_INVALID_MSG;
+    goto end;
+  }
+end:
+  return code;
+}
+
+static int32_t tqPutReqToQueue(SVnode* pVnode, void* pReqs, int32_t(*encoder)(void* pReqs, int32_t vgId, void** ppBuf, int32_t *contLen), tmsg_t msgType) {
  void*   buf = NULL;
  int32_t tlen = 0;

-  int32_t code = encodeCreateChildTableForRPC(pReqs, TD_VID(pVnode), &buf, &tlen);
+  int32_t code = encoder(pReqs, TD_VID(pVnode), &buf, &tlen);
  if (code) {
    tqError("vgId:%d failed to encode create table msg, create table failed, code:%s", TD_VID(pVnode), tstrerror(code));
    return code;
  }

-  SRpcMsg msg = {.msgType = TDMT_VND_CREATE_TABLE, .pCont = buf, .contLen = tlen};
+  SRpcMsg msg = {.msgType = msgType, .pCont = buf, .contLen = tlen};
  code = tmsgPutToQueue(&pVnode->msgCb, WRITE_QUEUE, &msg);
  if (code) {
    tqError("failed to put into write-queue since %s", terrstr());
@ -388,7 +422,7 @@ static int32_t doBuildAndSendCreateTableMsg(SVnode* pVnode, char* stbFullName, S
  }

  reqs.nReqs = taosArrayGetSize(reqs.pArray);
-  code = tqPutReqToQueue(pVnode, &reqs);
+  code = tqPutReqToQueue(pVnode, &reqs, encodeCreateChildTableForRPC, TDMT_VND_CREATE_TABLE);
  if (code != TSDB_CODE_SUCCESS) {
    tqError("s-task:%s failed to send create table msg", id);
  }
@ -399,6 +433,61 @@ _end:
  return code;
 }

+static int32_t doBuildAndSendDropTableMsg(SVnode* pVnode, char* pStbFullname, SSDataBlock* pDataBlock,
+                                          SStreamTask* pTask, int64_t suid) {
+  int32_t          lino = 0;
+  int32_t          code = 0;
+  int32_t          rows = pDataBlock->info.rows;
+  const char*      id = pTask->id.idStr;
+  SVDropTbBatchReq batchReq = {0};
+  SVDropTbReq      req = {0};
+
+  if (rows <= 0 || rows > 1 || pTask->subtableWithoutMd5 == 0) return TSDB_CODE_SUCCESS;
+
+  batchReq.pArray = taosArrayInit(rows, sizeof(SVDropTbReq));
+  if (!batchReq.pArray) return terrno;
+  batchReq.nReqs = rows;
+  req.suid = suid;
+  req.igNotExists = true;
+
+  SColumnInfoData* pTbNameCol = taosArrayGet(pDataBlock->pDataBlock, TABLE_NAME_COLUMN_INDEX);
+  char             tbName[TSDB_TABLE_NAME_LEN + 1] = {0};
+  int32_t          i = 0;
+  void*            pData = colDataGetVarData(pTbNameCol, i);
+  memcpy(tbName, varDataVal(pData), varDataLen(pData));
+  tbName[varDataLen(pData) + 1] = 0;
+  req.name = tbName;
+  if (taosArrayPush(batchReq.pArray, &req) == NULL) {
+    TSDB_CHECK_CODE(terrno, lino, _exit);
+  }
+
+  SMetaReader mr = {0};
+  metaReaderDoInit(&mr, pVnode->pMeta, META_READER_LOCK);
+
+  code = metaGetTableEntryByName(&mr, tbName);
+  if (TSDB_CODE_SUCCESS == code && isValidDstChildTable(&mr, TD_VID(pVnode), tbName, pTask->outputInfo.tbSink.stbUid)) {
+    STableSinkInfo* pTableSinkInfo = NULL;
+    bool alreadyCached = doGetSinkTableInfoFromCache(pTask->outputInfo.tbSink.pTbInfo, pDataBlock->info.id.groupId, &pTableSinkInfo);
+    if (alreadyCached) {
+      pTableSinkInfo->uid = mr.me.uid;
+    }
+  }
+  metaReaderClear(&mr);
+  tqDebug("s-task:%s build drop %d table(s) msg", id, rows);
+  code = tqPutReqToQueue(pVnode, &batchReq, encodeDropChildTableForRPC, TDMT_VND_DROP_TABLE);
+  TSDB_CHECK_CODE(code, lino, _exit);
+
+
+  code = doWaitForDstTableDropped(pVnode, pTask, tbName);
+  TSDB_CHECK_CODE(code, lino, _exit);
+
+_exit:
+  if (batchReq.pArray) {
+    taosArrayDestroy(batchReq.pArray);
+  }
+  return code;
+}
+
 int32_t doBuildAndSendSubmitMsg(SVnode* pVnode, SStreamTask* pTask, SSubmitReq2* pReq, int32_t numOfBlocks) {
  const char* id = pTask->id.idStr;
  int32_t     vgId = TD_VID(pVnode);
@ -807,6 +896,40 @@ int32_t doWaitForDstTableCreated(SVnode* pVnode, SStreamTask* pTask, STableSinkI
  return TSDB_CODE_SUCCESS;
 }

+static int32_t doWaitForDstTableDropped(SVnode* pVnode, SStreamTask* pTask, const char* dstTableName) {
+  int32_t vgId = TD_VID(pVnode);
+  int64_t suid = pTask->outputInfo.tbSink.stbUid;
+  const char* id = pTask->id.idStr;
+
+  while (1) {
+    if (streamTaskShouldStop(pTask)) {
+      tqDebug("s-task:%s task will stop, quit from waiting for table:%s drop", id, dstTableName);
+      return TSDB_CODE_STREAM_EXEC_CANCELLED;
+    }
+    SMetaReader mr = {0};
+    metaReaderDoInit(&mr, pVnode->pMeta, META_READER_LOCK);
+    int32_t code = metaGetTableEntryByName(&mr, dstTableName);
+    if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {
+      metaReaderClear(&mr);
+      break;
+    } else if (TSDB_CODE_SUCCESS == code) {
+      if (isValidDstChildTable(&mr, vgId, dstTableName, suid)) {
+        metaReaderClear(&mr);
+        taosMsleep(100);
+        tqDebug("s-task:%s wait 100ms for table:%s drop", id, dstTableName);
+      } else {
+        metaReaderClear(&mr);
+        break;
+      }
+    } else {
+      tqError("s-task:%s failed to wait for table:%s drop", id, dstTableName);
+      metaReaderClear(&mr);
+      return terrno;
+    }
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
 int32_t doCreateSinkTableInfo(const char* pDstTableName, STableSinkInfo** pInfo) {
  int32_t nameLen = strlen(pDstTableName);
  (*pInfo) = taosMemoryCalloc(1, sizeof(STableSinkInfo) + nameLen + 1);
@ -1032,7 +1155,7 @@ void tqSinkDataIntoDstTable(SStreamTask* pTask, void* vnode, void* data) {
  }

  bool onlySubmitData = hasOnlySubmitData(pBlocks, numOfBlocks);
-  if (!onlySubmitData) {
+  if (!onlySubmitData || pTask->subtableWithoutMd5 == 1) {
    tqDebug("vgId:%d, s-task:%s write %d stream resBlock(s) into table, has delete block, submit one-by-one", vgId, id,
            numOfBlocks);

@ -1052,6 +1175,8 @@ void tqSinkDataIntoDstTable(SStreamTask* pTask, void* vnode, void* data) {
        code = doBuildAndSendCreateTableMsg(pVnode, stbFullName, pDataBlock, pTask, suid);
      } else if (pDataBlock->info.type == STREAM_CHECKPOINT) {
        continue;
+      } else if (pDataBlock->info.type == STREAM_DROP_CHILD_TABLE && pTask->subtableWithoutMd5) {
+        code = doBuildAndSendDropTableMsg(pVnode, stbFullName, pDataBlock, pTask, suid);
      } else {
        code = handleResultBlockMsg(pTask, pDataBlock, i, pVnode, earlyTs);
      }
--- a/source/dnode/vnode/src/tq/tqUtil.c
+++ b/source/dnode/vnode/src/tq/tqUtil.c
@ -572,7 +572,7 @@ int32_t tqDoSendDataRsp(const SRpcHandleInfo* pRpcHandleInfo, const SMqDataRsp*
  return 0;
 }

-int32_t tqExtractDelDataBlock(const void* pData, int32_t len, int64_t ver, void** pRefBlock, int32_t type) {
+int32_t tqExtractDelDataBlock(const void* pData, int32_t len, int64_t ver, void** pRefBlock, int32_t type, EStreamType blockType) {
  int32_t     code = 0;
  int32_t     line = 0;
  SDecoder*   pCoder = &(SDecoder){0};
@ -593,7 +593,7 @@ int32_t tqExtractDelDataBlock(const void* pData, int32_t len, int64_t ver, void*
  }

  SSDataBlock* pDelBlock = NULL;
-  code = createSpecialDataBlock(STREAM_DELETE_DATA, &pDelBlock);
+  code = createSpecialDataBlock(blockType, &pDelBlock);
  TSDB_CHECK_CODE(code, line, END);

  code = blockDataEnsureCapacity(pDelBlock, numOfTables);
@ -751,3 +751,45 @@ int32_t tqGetStreamExecInfo(SVnode* pVnode, int64_t streamId, int64_t* pDelay, b

  return TSDB_CODE_SUCCESS;
 }
+
+int32_t tqExtractDropCtbDataBlock(const void* data, int32_t len, int64_t ver, void** pRefBlock, int32_t type) {
+  int32_t          code = 0;
+  int32_t          lino = 0;
+  SDecoder         dc = {0};
+  SVDropTbBatchReq batchReq = {0};
+  tDecoderInit(&dc, (uint8_t*)data, len);
+  code = tDecodeSVDropTbBatchReq(&dc, &batchReq);
+  TSDB_CHECK_CODE(code, lino, _exit);
+  if (batchReq.nReqs <= 0) goto _exit;
+
+  SSDataBlock* pBlock = NULL;
+  code = createSpecialDataBlock(STREAM_DROP_CHILD_TABLE, &pBlock);
+  TSDB_CHECK_CODE(code, lino, _exit);
+
+  code = blockDataEnsureCapacity(pBlock, batchReq.nReqs);
+  TSDB_CHECK_CODE(code, lino, _exit);
+
+  pBlock->info.rows = batchReq.nReqs;
+  pBlock->info.version = ver;
+  for (int32_t i = 0; i < batchReq.nReqs; ++i) {
+    SVDropTbReq* pReq = batchReq.pReqs + i;
+    SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, UID_COLUMN_INDEX);
+    TSDB_CHECK_NULL(pCol, code, lino, _exit, terrno);
+    code = colDataSetVal(pCol, i, (const char* )&pReq->uid, false);
+    TSDB_CHECK_CODE(code, lino, _exit);
+  }
+
+  code = taosAllocateQitem(sizeof(SStreamRefDataBlock), DEF_QITEM, 0, pRefBlock);
+  TSDB_CHECK_CODE(code, lino, _exit);
+  ((SStreamRefDataBlock*)(*pRefBlock))->type = STREAM_INPUT__REF_DATA_BLOCK;
+  ((SStreamRefDataBlock*)(*pRefBlock))->pBlock = pBlock;
+
+_exit:
+  tDecoderClear(&dc);
+  if (TSDB_CODE_SUCCESS != code) {
+    tqError("faled to extract drop ctb data block, line:%d code:%s", lino, tstrerror(code));
+    blockDataCleanup(pBlock);
+    taosMemoryFree(pBlock);
+  }
+  return code;
+}
--- a/source/dnode/vnode/src/tsdb/tsdbCacheRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbCacheRead.c
@ -613,6 +613,16 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
              singleTableLastTs = pColVal->rowKey.ts;
            }

+            if (p->colVal.value.type != pColVal->colVal.value.type) {
+              // check for type/cid mismatch
+              tsdbError("last cache type mismatch, uid:%" PRIu64
+                        ", schema-type:%d, slotId:%d, cache-type:%d, cache-col:%d",
+                        uid, p->colVal.value.type, slotIds[k], pColVal->colVal.value.type, pColVal->colVal.cid);
+              taosArrayClearEx(pRow, tsdbCacheFreeSLastColItem);
+              code = TSDB_CODE_INVALID_PARA;
+              goto _end;
+            }
+
            if (!IS_VAR_DATA_TYPE(pColVal->colVal.value.type)) {
              p->colVal = pColVal->colVal;
            } else {
--- a/source/dnode/vnode/src/vnd/vnodeInitApi.c
+++ b/source/dnode/vnode/src/vnd/vnodeInitApi.c
@ -147,6 +147,7 @@ void initStateStoreAPI(SStateStore* pStore) {

  pStore->streamStatePutParName = streamStatePutParName;
  pStore->streamStateGetParName = streamStateGetParName;
+  pStore->streamStateDeleteParName = streamStateDeleteParName;

  pStore->streamStateAddIfNotExist = streamStateAddIfNotExist;
  pStore->streamStateReleaseBuf = streamStateReleaseBuf;
--- a/source/dnode/vnode/src/vnd/vnodeSvr.c
+++ b/source/dnode/vnode/src/vnd/vnodeSvr.c
@ -50,6 +50,8 @@ static int32_t vnodeProcessDropIndexReq(SVnode *pVnode, int64_t ver, void *pReq,
 static int32_t vnodeProcessCompactVnodeReq(SVnode *pVnode, int64_t ver, void *pReq, int32_t len, SRpcMsg *pRsp);
 static int32_t vnodeProcessConfigChangeReq(SVnode *pVnode, int64_t ver, void *pReq, int32_t len, SRpcMsg *pRsp);
 static int32_t vnodeProcessArbCheckSyncReq(SVnode *pVnode, void *pReq, int32_t len, SRpcMsg *pRsp);
+static int32_t vnodeProcessDropTSmaCtbReq(SVnode *pVnode, int64_t ver, void *pReq, int32_t len, SRpcMsg *pRsp,
+                                          SRpcMsg *pOriginRpc);

 static int32_t vnodePreCheckAssignedLogSyncd(SVnode *pVnode, char *member0Token, char *member1Token);
 static int32_t vnodeCheckAssignedLogSyncd(SVnode *pVnode, char *member0Token, char *member1Token);
@ -481,6 +483,61 @@ static int32_t vnodePreProcessArbCheckSyncMsg(SVnode *pVnode, SRpcMsg *pMsg) {
  return code;
 }

+int32_t vnodePreProcessDropTbMsg(SVnode* pVnode, SRpcMsg* pMsg) {
+  int32_t          code = TSDB_CODE_SUCCESS;
+  int32_t          lino = 0;
+  int32_t          size = 0;
+  SDecoder         dc = {0};
+  SEncoder         ec = {0};
+  SVDropTbBatchReq receivedBatchReqs = {0};
+  SVDropTbBatchReq sentBatchReqs = {0};
+
+  tDecoderInit(&dc, POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead)), pMsg->contLen - sizeof(SMsgHead));
+
+  code = tDecodeSVDropTbBatchReq(&dc, &receivedBatchReqs);
+  if (code < 0) {
+    terrno = code;
+    TSDB_CHECK_CODE(code, lino, _exit);
+  }
+  sentBatchReqs.pArray = taosArrayInit(receivedBatchReqs.nReqs, sizeof(SVDropTbReq));
+  if (!sentBatchReqs.pArray) {
+    code = terrno;
+    goto _exit;
+  }
+
+  for (int32_t i = 0; i < receivedBatchReqs.nReqs; ++i) {
+    SVDropTbReq* pReq = receivedBatchReqs.pReqs + i;
+    tb_uid_t uid = metaGetTableEntryUidByName(pVnode->pMeta, pReq->name);
+    if (uid == 0) {
+      vWarn("vgId:%d, preprocess drop ctb: %s not found", TD_VID(pVnode), pReq->name);
+      continue;
+    }
+    pReq->uid = uid;
+    vDebug("vgId:%d %s for: %s, uid: %"PRId64, TD_VID(pVnode), __func__, pReq->name, pReq->uid);
+    if (taosArrayPush(sentBatchReqs.pArray, pReq) == NULL) {
+      code = terrno;
+      goto _exit;
+    }
+  }
+  sentBatchReqs.nReqs = sentBatchReqs.pArray->size;
+
+  tEncodeSize(tEncodeSVDropTbBatchReq, &sentBatchReqs, size, code);
+  tEncoderInit(&ec, POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead)), size);
+  code = tEncodeSVDropTbBatchReq(&ec, &sentBatchReqs);
+  tEncoderClear(&ec);
+  if (code != TSDB_CODE_SUCCESS) {
+    vError("vgId:%d %s failed to encode drop tb batch req: %s", TD_VID(pVnode), __func__, tstrerror(code));
+    TSDB_CHECK_CODE(code, lino, _exit);
+  }
+
+_exit:
+  tDecoderClear(&dc);
+  if (sentBatchReqs.pArray) {
+    taosArrayDestroy(sentBatchReqs.pArray);
+  }
+  return code;
+}
+
 int32_t vnodePreProcessWriteMsg(SVnode *pVnode, SRpcMsg *pMsg) {
  int32_t code = 0;

@ -507,6 +564,9 @@ int32_t vnodePreProcessWriteMsg(SVnode *pVnode, SRpcMsg *pMsg) {
    case TDMT_VND_ARB_CHECK_SYNC: {
      code = vnodePreProcessArbCheckSyncMsg(pVnode, pMsg);
    } break;
+    case TDMT_VND_DROP_TABLE: {
+      code = vnodePreProcessDropTbMsg(pVnode, pMsg);
+    } break;
    default:
      break;
  }
@ -1110,7 +1170,6 @@ static int32_t vnodeProcessCreateTbReq(SVnode *pVnode, int64_t ver, void *pReq,
  STbUidStore       *pStore = NULL;
  SArray            *tbUids = NULL;
  SArray            *tbNames = NULL;
-
  pRsp->msgType = TDMT_VND_CREATE_TABLE_RSP;
  pRsp->code = TSDB_CODE_SUCCESS;
  pRsp->pCont = NULL;
@ -2512,3 +2571,4 @@ _OVER:
 int32_t vnodeAsyncCompact(SVnode *pVnode, int64_t ver, void *pReq, int32_t len, SRpcMsg *pRsp) { return 0; }
 int32_t tsdbAsyncCompact(STsdb *tsdb, const STimeWindow *tw, bool sync) { return 0; }
 #endif
+
--- a/source/libs/command/src/command.c
+++ b/source/libs/command/src/command.c
@ -35,6 +35,9 @@
 extern SConfig* tsCfg;

 static int32_t buildRetrieveTableRsp(SSDataBlock* pBlock, int32_t numOfCols, SRetrieveTableRsp** pRsp) {
+  if (NULL == pBlock || NULL == pRsp) {
+    return TSDB_CODE_INVALID_PARA;
+  }
  size_t dataEncodeBufSize = blockGetEncodeSize(pBlock);
  size_t rspSize = sizeof(SRetrieveTableRsp) + dataEncodeBufSize + PAYLOAD_PREFIX_LEN;
  *pRsp = taosMemoryCalloc(1, rspSize);
@ -216,6 +219,9 @@ static int32_t setDescResultIntoDataBlock(bool sysInfoUser, SSDataBlock* pBlock,

 static int32_t execDescribe(bool sysInfoUser, SNode* pStmt, SRetrieveTableRsp** pRsp, int8_t biMode) {
  SDescribeStmt* pDesc = (SDescribeStmt*)pStmt;
+  if (NULL == pDesc || NULL == pDesc->pMeta) {
+    return TSDB_CODE_INVALID_PARA;
+  }
  int32_t        numOfRows = TABLE_TOTAL_COL_NUM(pDesc->pMeta);

  SSDataBlock* pBlock = NULL;
@ -505,7 +511,7 @@ static int32_t buildCreateViewResultDataBlock(SSDataBlock** pOutput) {
  return code;
 }

-void appendColumnFields(char* buf, int32_t* len, STableCfg* pCfg) {
+static void appendColumnFields(char* buf, int32_t* len, STableCfg* pCfg) {
  for (int32_t i = 0; i < pCfg->numOfColumns; ++i) {
    SSchema* pSchema = pCfg->pSchemas + i;
 #define LTYPE_LEN (32 + 60)  // 60 byte for compress info
@ -539,7 +545,7 @@ void appendColumnFields(char* buf, int32_t* len, STableCfg* pCfg) {
  }
 }

-void appendTagFields(char* buf, int32_t* len, STableCfg* pCfg) {
+static void appendTagFields(char* buf, int32_t* len, STableCfg* pCfg) {
  for (int32_t i = 0; i < pCfg->numOfTags; ++i) {
    SSchema* pSchema = pCfg->pSchemas + pCfg->numOfColumns + i;
    char     type[32];
@ -558,7 +564,7 @@ void appendTagFields(char* buf, int32_t* len, STableCfg* pCfg) {
  }
 }

-void appendTagNameFields(char* buf, int32_t* len, STableCfg* pCfg) {
+static void appendTagNameFields(char* buf, int32_t* len, STableCfg* pCfg) {
  for (int32_t i = 0; i < pCfg->numOfTags; ++i) {
    SSchema* pSchema = pCfg->pSchemas + pCfg->numOfColumns + i;
    *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),
@ -566,7 +572,7 @@ void appendTagNameFields(char* buf, int32_t* len, STableCfg* pCfg) {
  }
 }

-int32_t appendTagValues(char* buf, int32_t* len, STableCfg* pCfg) {
+static int32_t appendTagValues(char* buf, int32_t* len, STableCfg* pCfg) {
  int32_t code = TSDB_CODE_SUCCESS;
  SArray* pTagVals = NULL;
  STag*   pTag = (STag*)pCfg->pTags;
@ -643,7 +649,7 @@ _exit:
  return code;
 }

-void appendTableOptions(char* buf, int32_t* len, SDbCfgInfo* pDbCfg, STableCfg* pCfg) {
+static void appendTableOptions(char* buf, int32_t* len, SDbCfgInfo* pDbCfg, STableCfg* pCfg) {
  if (pCfg->commentLen > 0) {
    *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),
                      " COMMENT '%s'", pCfg->pComment);
@ -997,7 +1003,7 @@ static int32_t createSelectResultDataBlock(SNodeList* pProjects, SSDataBlock** p
  return code;
 }

-int32_t buildSelectResultDataBlock(SNodeList* pProjects, SSDataBlock* pBlock) {
+static int32_t buildSelectResultDataBlock(SNodeList* pProjects, SSDataBlock* pBlock) {
  QRY_ERR_RET(blockDataEnsureCapacity(pBlock, 1));

  int32_t index = 0;
--- a/source/libs/command/src/explain.c
+++ b/source/libs/command/src/explain.c
@ -30,8 +30,8 @@ char *gJoinTypeStr[JOIN_TYPE_MAX_VALUE][JOIN_STYPE_MAX_VALUE] = {
 /*FULL*/   {"Full Join",          "Full Join",           NULL,                 NULL,                  NULL,                  NULL},
 };

-int32_t qExplainGenerateResNode(SPhysiNode *pNode, SExplainGroup *group, SExplainResNode **pRes);
-int32_t qExplainAppendGroupResRows(void *pCtx, int32_t groupId, int32_t level, bool singleChannel);
+static int32_t qExplainGenerateResNode(SPhysiNode *pNode, SExplainGroup *group, SExplainResNode **pRes);
+static int32_t qExplainAppendGroupResRows(void *pCtx, int32_t groupId, int32_t level, bool singleChannel);

 char *qExplainGetDynQryCtrlType(EDynQueryType type) {
  switch (type) {
@ -118,7 +118,7 @@ void qExplainFreeCtx(SExplainCtx *pCtx) {
  taosMemoryFree(pCtx);
 }

-int32_t qExplainInitCtx(SExplainCtx **pCtx, SHashObj *groupHash, bool verbose, double ratio, EExplainMode mode) {
+static int32_t qExplainInitCtx(SExplainCtx **pCtx, SHashObj *groupHash, bool verbose, double ratio, EExplainMode mode) {
  int32_t      code = 0;
  SExplainCtx *ctx = taosMemoryCalloc(1, sizeof(SExplainCtx));
  if (NULL == ctx) {
@ -158,7 +158,7 @@ _return:
  QRY_RET(code);
 }

-int32_t qExplainGenerateResChildren(SPhysiNode *pNode, SExplainGroup *group, SNodeList **pChildren) {
+static int32_t qExplainGenerateResChildren(SPhysiNode *pNode, SExplainGroup *group, SNodeList **pChildren) {
  int32_t    tlen = 0;
  SNodeList *pPhysiChildren = pNode->pChildren;

@ -180,7 +180,7 @@ int32_t qExplainGenerateResChildren(SPhysiNode *pNode, SExplainGroup *group, SNo
  return TSDB_CODE_SUCCESS;
 }

-int32_t qExplainGenerateResNodeExecInfo(SPhysiNode *pNode, SArray **pExecInfo, SExplainGroup *group) {
+static int32_t qExplainGenerateResNodeExecInfo(SPhysiNode *pNode, SArray **pExecInfo, SExplainGroup *group) {
  *pExecInfo = taosArrayInit(group->nodeNum, sizeof(SExplainExecInfo));
  if (NULL == (*pExecInfo)) {
    qError("taosArrayInit %d explainExecInfo failed", group->nodeNum);
@ -217,7 +217,7 @@ int32_t qExplainGenerateResNodeExecInfo(SPhysiNode *pNode, SArray **pExecInfo, S
  return TSDB_CODE_SUCCESS;
 }

-int32_t qExplainGenerateResNode(SPhysiNode *pNode, SExplainGroup *group, SExplainResNode **pResNode) {
+static int32_t qExplainGenerateResNode(SPhysiNode *pNode, SExplainGroup *group, SExplainResNode **pResNode) {
  if (NULL == pNode) {
    *pResNode = NULL;
    qError("physical node is NULL");
@ -250,7 +250,7 @@ _return:
  QRY_RET(code);
 }

-int32_t qExplainBufAppendExecInfo(SArray *pExecInfo, char *tbuf, int32_t *len) {
+static int32_t qExplainBufAppendExecInfo(SArray *pExecInfo, char *tbuf, int32_t *len) {
  int32_t          tlen = *len;
  int32_t          nodeNum = taosArrayGetSize(pExecInfo);
  SExplainExecInfo maxExecInfo = {0};
@ -275,7 +275,7 @@ int32_t qExplainBufAppendExecInfo(SArray *pExecInfo, char *tbuf, int32_t *len) {
  return TSDB_CODE_SUCCESS;
 }

-int32_t qExplainBufAppendVerboseExecInfo(SArray *pExecInfo, char *tbuf, int32_t *len) {
+static int32_t qExplainBufAppendVerboseExecInfo(SArray *pExecInfo, char *tbuf, int32_t *len) {
  int32_t          tlen = 0;
  bool             gotVerbose = false;
  int32_t          nodeNum = taosArrayGetSize(pExecInfo);
@ -297,7 +297,7 @@ int32_t qExplainBufAppendVerboseExecInfo(SArray *pExecInfo, char *tbuf, int32_t
  return TSDB_CODE_SUCCESS;
 }

-int32_t qExplainResAppendRow(SExplainCtx *ctx, char *tbuf, int32_t len, int32_t level) {
+static int32_t qExplainResAppendRow(SExplainCtx *ctx, char *tbuf, int32_t len, int32_t level) {
  SQueryExplainRowInfo row = {0};
  row.buf = taosMemoryMalloc(len);
  if (NULL == row.buf) {
@ -362,7 +362,7 @@ static char* qExplainGetScanDataLoad(STableScanPhysiNode* pScan) {
  return "unknown";
 }

-int32_t qExplainResNodeToRowsImpl(SExplainResNode *pResNode, SExplainCtx *ctx, int32_t level) {
+static int32_t qExplainResNodeToRowsImpl(SExplainResNode *pResNode, SExplainCtx *ctx, int32_t level) {
  int32_t     tlen = 0;
  bool        isVerboseLine = false;
  char       *tbuf = ctx->tbuf;
@ -1900,7 +1900,7 @@ int32_t qExplainResNodeToRowsImpl(SExplainResNode *pResNode, SExplainCtx *ctx, i
  return TSDB_CODE_SUCCESS;
 }

-int32_t qExplainResNodeToRows(SExplainResNode *pResNode, SExplainCtx *ctx, int32_t level) {
+static int32_t qExplainResNodeToRows(SExplainResNode *pResNode, SExplainCtx *ctx, int32_t level) {
  if (NULL == pResNode) {
    qError("explain res node is NULL");
    QRY_ERR_RET(TSDB_CODE_APP_ERROR);
@ -1915,7 +1915,7 @@ int32_t qExplainResNodeToRows(SExplainResNode *pResNode, SExplainCtx *ctx, int32
  return TSDB_CODE_SUCCESS;
 }

-int32_t qExplainAppendGroupResRows(void *pCtx, int32_t groupId, int32_t level, bool singleChannel) {
+static int32_t qExplainAppendGroupResRows(void *pCtx, int32_t groupId, int32_t level, bool singleChannel) {
  SExplainResNode *node = NULL;
  int32_t          code = 0;
  SExplainCtx     *ctx = (SExplainCtx *)pCtx;
@ -1940,7 +1940,7 @@ _return:
  QRY_RET(code);
 }

-int32_t qExplainGetRspFromCtx(void *ctx, SRetrieveTableRsp **pRsp) {
+static int32_t qExplainGetRspFromCtx(void *ctx, SRetrieveTableRsp **pRsp) {
  int32_t      code = 0;
  SSDataBlock *pBlock = NULL;
  SExplainCtx *pCtx = (SExplainCtx *)ctx;
@ -1997,7 +1997,7 @@ _return:
  QRY_RET(code);
 }

-int32_t qExplainPrepareCtx(SQueryPlan *pDag, SExplainCtx **pCtx) {
+static int32_t qExplainPrepareCtx(SQueryPlan *pDag, SExplainCtx **pCtx) {
  int32_t        code = 0;
  SNodeListNode *plans = NULL;
  int32_t        taskNum = 0;
@ -2080,7 +2080,7 @@ _return:
  QRY_RET(code);
 }

-int32_t qExplainAppendPlanRows(SExplainCtx *pCtx) {
+static int32_t qExplainAppendPlanRows(SExplainCtx *pCtx) {
  if (EXPLAIN_MODE_ANALYZE != pCtx->mode) {
    return TSDB_CODE_SUCCESS;
  }
@ -2103,7 +2103,7 @@ int32_t qExplainAppendPlanRows(SExplainCtx *pCtx) {
  return TSDB_CODE_SUCCESS;
 }

-int32_t qExplainGenerateRsp(SExplainCtx *pCtx, SRetrieveTableRsp **pRsp) {
+static int32_t qExplainGenerateRsp(SExplainCtx *pCtx, SRetrieveTableRsp **pRsp) {
  QRY_ERR_RET(qExplainAppendGroupResRows(pCtx, pCtx->rootGroupId, 0, false));
  QRY_ERR_RET(qExplainAppendPlanRows(pCtx));
  QRY_ERR_RET(qExplainGetRspFromCtx(pCtx, pRsp));
--- a/source/libs/executor/CMakeLists.txt
+++ b/source/libs/executor/CMakeLists.txt
@ -7,7 +7,7 @@ if(${TD_DARWIN})
 endif(${TD_DARWIN})

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

 target_link_libraries(executor
--- a/source/libs/executor/src/anomalywindowoperator.c
+++ b/source/libs/executor/src/anomalywindowoperator.c
@ -19,14 +19,14 @@
 #include "functionMgt.h"
 #include "operator.h"
 #include "querytask.h"
-#include "tanal.h"
+#include "tanalytics.h"
 #include "tcommon.h"
 #include "tcompare.h"
 #include "tdatablock.h"
 #include "tjson.h"
 #include "ttime.h"

-#ifdef USE_ANAL
+#ifdef USE_ANALYTICS

 typedef struct {
  SArray*     blocks;   // SSDataBlock*
@ -55,7 +55,7 @@ typedef struct {

 static void    anomalyDestroyOperatorInfo(void* param);
 static int32_t anomalyAggregateNext(SOperatorInfo* pOperator, SSDataBlock** ppRes);
-static void    anomalyAggregateBlocks(SOperatorInfo* pOperator);
+static int32_t anomalyAggregateBlocks(SOperatorInfo* pOperator);
 static int32_t anomalyCacheBlock(SAnomalyWindowOperatorInfo* pInfo, SSDataBlock* pBlock);

 int32_t createAnomalywindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* physiNode, SExecTaskInfo* pTaskInfo,
@ -78,6 +78,7 @@ int32_t createAnomalywindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* p
    code = TSDB_CODE_ANAL_ALGO_NOT_FOUND;
    goto _error;
  }
+
  if (taosAnalGetAlgoUrl(pInfo->algoName, ANAL_ALGO_TYPE_ANOMALY_DETECT, pInfo->algoUrl, sizeof(pInfo->algoUrl)) != 0) {
    qError("failed to get anomaly_window algorithm url from %s", pInfo->algoName);
    code = TSDB_CODE_ANAL_ALGO_NOT_LOAD;
@ -198,7 +199,9 @@ static int32_t anomalyAggregateNext(SOperatorInfo* pOperator, SSDataBlock** ppRe
      QUERY_CHECK_CODE(code, lino, _end);
    } else {
      qDebug("group:%" PRId64 ", read finish for new group coming, blocks:%d", pSupp->groupId, numOfBlocks);
-      anomalyAggregateBlocks(pOperator);
+      code = anomalyAggregateBlocks(pOperator);
+      QUERY_CHECK_CODE(code, lino, _end);
+
      pSupp->groupId = pBlock->info.id.groupId;
      numOfBlocks = 1;
      pSupp->cachedRows = pBlock->info.rows;
@ -217,7 +220,7 @@ static int32_t anomalyAggregateNext(SOperatorInfo* pOperator, SSDataBlock** ppRe

  if (numOfBlocks > 0) {
    qDebug("group:%" PRId64 ", read finish, blocks:%d", pInfo->anomalySup.groupId, numOfBlocks);
-    anomalyAggregateBlocks(pOperator);
+    code = anomalyAggregateBlocks(pOperator);
  }

  int64_t cost = taosGetTimestampUs() - st;
@ -229,6 +232,7 @@ _end:
    pTaskInfo->code = code;
    T_LONG_JMP(pTaskInfo->env, code);
  }
+
  (*ppRes) = (pBInfo->pRes->info.rows == 0) ? NULL : pBInfo->pRes;
  return code;
 }
@ -338,8 +342,8 @@ static int32_t anomalyAnalysisWindow(SOperatorInfo* pOperator) {
  SAnalBuf                    analBuf = {.bufType = ANAL_BUF_TYPE_JSON};
  char                        dataBuf[64] = {0};
  int32_t                     code = 0;
+  int64_t                     ts = 0;

-  int64_t ts = 0;
  // int64_t ts = taosGetTimestampMs();
  snprintf(analBuf.fileName, sizeof(analBuf.fileName), "%s/tdengine-anomaly-%" PRId64 "-%" PRId64, tsTempDir, ts,
           pSupp->groupId);
@ -431,6 +435,7 @@ _OVER:
  if (code != 0) {
    qError("failed to analysis window since %s", tstrerror(code));
  }
+
  taosAnalBufDestroy(&analBuf);
  if (pJson != NULL) tjsonDelete(pJson);
  return code;
@ -473,7 +478,7 @@ static int32_t anomalyBuildResult(SOperatorInfo* pOperator) {
  return code;
 }

-static void anomalyAggregateBlocks(SOperatorInfo* pOperator) {
+static int32_t anomalyAggregateBlocks(SOperatorInfo* pOperator) {
  int32_t                     code = TSDB_CODE_SUCCESS;
  int32_t                     lino = 0;
  SAnomalyWindowOperatorInfo* pInfo = pOperator->info;
@ -623,6 +628,8 @@ _OVER:
  pSupp->curWin.ekey = 0;
  pSupp->curWin.skey = 0;
  pSupp->curWinIndex = 0;
+
+  return code;
 }

 #else
--- a/source/libs/executor/src/exchangeoperator.c
+++ b/source/libs/executor/src/exchangeoperator.c
@ -121,10 +121,10 @@ static void concurrentlyLoadRemoteDataImpl(SOperatorInfo* pOperator, SExchangeIn
          }
        } else {
          pDataInfo->status = EX_SOURCE_DATA_EXHAUSTED;
-          qDebug("%s vgId:%d, taskId:0x%" PRIx64 " execId:%d index:%d completed, rowsOfSource:%" PRIu64
-                 ", totalRows:%" PRIu64 ", try next %d/%" PRIzu,
-                 GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pSource->execId, i, pDataInfo->totalRows,
-                 pExchangeInfo->loadInfo.totalRows, i + 1, totalSources);
+          qDebug("%s vgId:%d, clientId:0x%" PRIx64 " taskId:0x%" PRIx64
+                 " execId:%d index:%d completed, rowsOfSource:%" PRIu64 ", totalRows:%" PRIu64 ", try next %d/%" PRIzu,
+                 GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->clientId, pSource->taskId, pSource->execId, i,
+                 pDataInfo->totalRows, pExchangeInfo->loadInfo.totalRows, i + 1, totalSources);
          taosMemoryFreeClear(pDataInfo->pRsp);
        }
        break;
@ -141,17 +141,17 @@ static void concurrentlyLoadRemoteDataImpl(SOperatorInfo* pOperator, SExchangeIn

      if (pRsp->completed == 1) {
        pDataInfo->status = EX_SOURCE_DATA_EXHAUSTED;
-        qDebug("%s fetch msg rsp from vgId:%d, taskId:0x%" PRIx64
+        qDebug("%s fetch msg rsp from vgId:%d, clientId:0x%" PRIx64 " taskId:0x%" PRIx64
               " execId:%d index:%d completed, blocks:%d, numOfRows:%" PRId64 ", rowsOfSource:%" PRIu64
               ", totalRows:%" PRIu64 ", total:%.2f Kb, try next %d/%" PRIzu,
-               GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pSource->execId, i, pRsp->numOfBlocks,
-               pRsp->numOfRows, pDataInfo->totalRows, pLoadInfo->totalRows, pLoadInfo->totalSize / 1024.0, i + 1,
-               totalSources);
+               GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->clientId, pSource->taskId, pSource->execId, i,
+               pRsp->numOfBlocks, pRsp->numOfRows, pDataInfo->totalRows, pLoadInfo->totalRows,
+               pLoadInfo->totalSize / 1024.0, i + 1, totalSources);
      } else {
-        qDebug("%s fetch msg rsp from vgId:%d, taskId:0x%" PRIx64 " execId:%d blocks:%d, numOfRows:%" PRId64
-               ", totalRows:%" PRIu64 ", total:%.2f Kb",
-               GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pSource->execId, pRsp->numOfBlocks,
-               pRsp->numOfRows, pLoadInfo->totalRows, pLoadInfo->totalSize / 1024.0);
+        qDebug("%s fetch msg rsp from vgId:%d, clientId:0x%" PRIx64 " taskId:0x%" PRIx64
+               " execId:%d blocks:%d, numOfRows:%" PRId64 ", totalRows:%" PRIu64 ", total:%.2f Kb",
+               GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->clientId, pSource->taskId, pSource->execId,
+               pRsp->numOfBlocks, pRsp->numOfRows, pLoadInfo->totalRows, pLoadInfo->totalSize / 1024.0);
      }

      taosMemoryFreeClear(pDataInfo->pRsp);
@ -640,9 +640,9 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas

  if (pSource->localExec) {
    SDataBuf pBuf = {0};
-    int32_t  code =
-        (*pTaskInfo->localFetch.fp)(pTaskInfo->localFetch.handle, pSource->schedId, pTaskInfo->id.queryId,
-                                    pSource->taskId, 0, pSource->execId, &pBuf.pData, pTaskInfo->localFetch.explainRes);
+    int32_t  code = (*pTaskInfo->localFetch.fp)(pTaskInfo->localFetch.handle, pSource->schedId, pTaskInfo->id.queryId,
+                                               pSource->clientId, pSource->taskId, 0, pSource->execId, &pBuf.pData,
+                                               pTaskInfo->localFetch.explainRes);
    code = loadRemoteDataCallback(pWrapper, &pBuf, code);
    QUERY_CHECK_CODE(code, lino, _end);
    taosMemoryFree(pWrapper);
@ -650,6 +650,7 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas
    SResFetchReq req = {0};
    req.header.vgId = pSource->addr.nodeId;
    req.sId = pSource->schedId;
+    req.clientId = pSource->clientId;
    req.taskId = pSource->taskId;
    req.queryId = pTaskInfo->id.queryId;
    req.execId = pSource->execId;
@ -691,9 +692,10 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas

    freeOperatorParam(req.pOpParam, OP_GET_PARAM);

-    qDebug("%s build fetch msg and send to vgId:%d, ep:%s, taskId:0x%" PRIx64 ", execId:%d, %p, %d/%" PRIzu,
-           GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->addr.epSet.eps[0].fqdn, pSource->taskId,
-           pSource->execId, pExchangeInfo, sourceIndex, totalSources);
+    qDebug("%s build fetch msg and send to vgId:%d, ep:%s, clientId:0x%" PRIx64 " taskId:0x%" PRIx64
+           ", execId:%d, %p, %d/%" PRIzu,
+           GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->addr.epSet.eps[0].fqdn, pSource->clientId,
+           pSource->taskId, pSource->execId, pExchangeInfo, sourceIndex, totalSources);

    // send the fetch remote task result reques
    SMsgSendInfo* pMsgSendInfo = taosMemoryCalloc(1, sizeof(SMsgSendInfo));
@ -974,8 +976,9 @@ int32_t seqLoadRemoteData(SOperatorInfo* pOperator) {
    }

    if (pDataInfo->code != TSDB_CODE_SUCCESS) {
-      qError("%s vgId:%d, taskID:0x%" PRIx64 " execId:%d error happens, code:%s", GET_TASKID(pTaskInfo),
-             pSource->addr.nodeId, pSource->taskId, pSource->execId, tstrerror(pDataInfo->code));
+      qError("%s vgId:%d, clientId:0x%" PRIx64 " taskID:0x%" PRIx64 " execId:%d error happens, code:%s",
+             GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->clientId, pSource->taskId, pSource->execId,
+             tstrerror(pDataInfo->code));
      pOperator->pTaskInfo->code = pDataInfo->code;
      return pOperator->pTaskInfo->code;
    }
@ -984,10 +987,10 @@ int32_t seqLoadRemoteData(SOperatorInfo* pOperator) {
    SLoadRemoteDataInfo* pLoadInfo = &pExchangeInfo->loadInfo;

    if (pRsp->numOfRows == 0) {
-      qDebug("%s vgId:%d, taskID:0x%" PRIx64 " execId:%d %d of total completed, rowsOfSource:%" PRIu64
-             ", totalRows:%" PRIu64 " try next",
-             GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pSource->execId, pExchangeInfo->current + 1,
-             pDataInfo->totalRows, pLoadInfo->totalRows);
+      qDebug("%s vgId:%d, clientId:0x%" PRIx64 " taskID:0x%" PRIx64
+             " execId:%d %d of total completed, rowsOfSource:%" PRIu64 ", totalRows:%" PRIu64 " try next",
+             GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->clientId, pSource->taskId, pSource->execId,
+             pExchangeInfo->current + 1, pDataInfo->totalRows, pLoadInfo->totalRows);

      pDataInfo->status = EX_SOURCE_DATA_EXHAUSTED;
      pExchangeInfo->current += 1;
@ -1002,19 +1005,19 @@ int32_t seqLoadRemoteData(SOperatorInfo* pOperator) {

    SRetrieveTableRsp* pRetrieveRsp = pDataInfo->pRsp;
    if (pRsp->completed == 1) {
-      qDebug("%s fetch msg rsp from vgId:%d, taskId:0x%" PRIx64 " execId:%d numOfRows:%" PRId64
+      qDebug("%s fetch msg rsp from vgId:%d, clientId:0x%" PRIx64 " taskId:0x%" PRIx64 " execId:%d numOfRows:%" PRId64
             ", rowsOfSource:%" PRIu64 ", totalRows:%" PRIu64 ", totalBytes:%" PRIu64 " try next %d/%" PRIzu,
-             GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pSource->execId, pRetrieveRsp->numOfRows,
-             pDataInfo->totalRows, pLoadInfo->totalRows, pLoadInfo->totalSize, pExchangeInfo->current + 1,
-             totalSources);
+             GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->clientId, pSource->taskId, pSource->execId,
+             pRetrieveRsp->numOfRows, pDataInfo->totalRows, pLoadInfo->totalRows, pLoadInfo->totalSize,
+             pExchangeInfo->current + 1, totalSources);

      pDataInfo->status = EX_SOURCE_DATA_EXHAUSTED;
      pExchangeInfo->current += 1;
    } else {
-      qDebug("%s fetch msg rsp from vgId:%d, taskId:0x%" PRIx64 " execId:%d numOfRows:%" PRId64 ", totalRows:%" PRIu64
-             ", totalBytes:%" PRIu64,
-             GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pSource->execId, pRetrieveRsp->numOfRows,
-             pLoadInfo->totalRows, pLoadInfo->totalSize);
+      qDebug("%s fetch msg rsp from vgId:%d, clientId:0x%" PRIx64 " taskId:0x%" PRIx64 " execId:%d numOfRows:%" PRId64
+             ", totalRows:%" PRIu64 ", totalBytes:%" PRIu64,
+             GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->clientId, pSource->taskId, pSource->execId,
+             pRetrieveRsp->numOfRows, pLoadInfo->totalRows, pLoadInfo->totalSize);
    }

    updateLoadRemoteInfo(pLoadInfo, pRetrieveRsp->numOfRows, pRetrieveRsp->compLen, startTs, pOperator);
--- a/source/libs/executor/src/executorInt.c
+++ b/source/libs/executor/src/executorInt.c
@ -1083,18 +1083,13 @@ void cleanupBasicInfo(SOptrBasicInfo* pInfo) {

 bool groupbyTbname(SNodeList* pGroupList) {
  bool bytbname = false;
-  if (LIST_LENGTH(pGroupList) == 1) {
-    SNode* p = nodesListGetNode(pGroupList, 0);
-    if (!p) {
-      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));
-      return false;
-    }
-    if (p->type == QUERY_NODE_FUNCTION) {
-      // partition by tbname/group by tbname
-      bytbname = (strcmp(((struct SFunctionNode*)p)->functionName, "tbname") == 0);
+  SNode*pNode = NULL;
+  FOREACH(pNode, pGroupList) {
+    if (pNode->type == QUERY_NODE_FUNCTION) {
+      bytbname = (strcmp(((struct SFunctionNode*)pNode)->functionName, "tbname") == 0);
+      break;
    }
  }
-
  return bytbname;
 }

--- a/source/libs/executor/src/forecastoperator.c
+++ b/source/libs/executor/src/forecastoperator.c
@ -19,14 +19,14 @@
 #include "operator.h"
 #include "querytask.h"
 #include "storageapi.h"
-#include "tanal.h"
+#include "tanalytics.h"
 #include "tcommon.h"
 #include "tcompare.h"
 #include "tdatablock.h"
 #include "tfill.h"
 #include "ttime.h"

-#ifdef USE_ANAL
+#ifdef USE_ANALYTICS

 typedef struct {
  char     algoName[TSDB_ANAL_ALGO_NAME_LEN];
--- a/source/libs/executor/src/groupoperator.c
+++ b/source/libs/executor/src/groupoperator.c
@ -1326,7 +1326,6 @@ int32_t appendCreateTableRow(void* pState, SExprSupp* pTableSup, SExprSupp* pTag
  int32_t winCode = TSDB_CODE_SUCCESS;
  code = pAPI->streamStateGetParName(pState, groupId, &pValue, true, &winCode);
  QUERY_CHECK_CODE(code, lino, _end);
-
  if (winCode != TSDB_CODE_SUCCESS) {
    SSDataBlock* pTmpBlock = NULL;
    code = blockCopyOneRow(pSrcBlock, rowId, &pTmpBlock);
--- a/source/libs/executor/src/scanoperator.c
+++ b/source/libs/executor/src/scanoperator.c
@ -289,6 +289,7 @@ static int32_t doSetTagColumnData(STableScanBase* pTableScanInfo, SSDataBlock* p
                                  pTaskInfo, &pTableScanInfo->metaCache);
    // ignore the table not exists error, since this table may have been dropped during the scan procedure.
    if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {
+      if (pTaskInfo->streamInfo.pState) blockDataCleanup(pBlock);
      code = 0;
    }
  }
@ -3038,10 +3039,6 @@ static int32_t setBlockIntoRes(SStreamScanInfo* pInfo, const SSDataBlock* pBlock
    code = addTagPseudoColumnData(&pInfo->readHandle, pInfo->pPseudoExpr, pInfo->numOfPseudoExpr, pInfo->pRes,
                                  pBlockInfo->rows, pTaskInfo, &pTableScanInfo->base.metaCache);
    // ignore the table not exists error, since this table may have been dropped during the scan procedure.
-    if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {
-      code = 0;
-    }
-
    if (code) {
      blockDataFreeRes((SSDataBlock*)pBlock);
      QUERY_CHECK_CODE(code, lino, _end);
@ -3535,6 +3532,46 @@ static int32_t copyGetResultBlock(SSDataBlock* dest, TSKEY start, TSKEY end) {
  return appendDataToSpecialBlock(dest, &start, &end, NULL, NULL, NULL);
 }

+static int32_t deletePartName(SStreamScanInfo* pInfo, SSDataBlock* pBlock, int32_t *deleteNum) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
+  for (int32_t i = 0; i < pBlock->info.rows; i++) {
+    // uid is the same as gid
+    SColumnInfoData* pGpIdCol = taosArrayGet(pBlock->pDataBlock, UID_COLUMN_INDEX);
+    SColumnInfoData* pTbnameCol = taosArrayGet(pBlock->pDataBlock, TABLE_NAME_COLUMN_INDEX);
+    int64_t*         gpIdCol = (int64_t*)pGpIdCol->pData;
+    void*            pParName = NULL;
+    int32_t          winCode = 0;
+    code = pInfo->stateStore.streamStateGetParName(pInfo->pStreamScanOp->pTaskInfo->streamInfo.pState, gpIdCol[i],
+                                                   &pParName, false, &winCode);
+    if (TSDB_CODE_SUCCESS == code && winCode != 0) {
+      qDebug("delete stream part Name for:%"PRId64 " not found", gpIdCol[i]);
+      colDataSetNULL(pTbnameCol, i);
+      continue;
+    }
+    (*deleteNum)++;
+    QUERY_CHECK_CODE(code, lino, _end);
+    char varTbName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE + 1] = {0};
+    varDataSetLen(varTbName, strlen(pParName));
+    int64_t len = tsnprintf(varTbName + VARSTR_HEADER_SIZE, TSDB_TABLE_NAME_LEN + 1, "%s", pParName);
+    code = colDataSetVal(pTbnameCol, i, varTbName, false);
+    qDebug("delete stream part for:%"PRId64 " res tb: %s", gpIdCol[i], (char*)pParName);
+    pInfo->stateStore.streamStateFreeVal(pParName);
+    QUERY_CHECK_CODE(code, lino, _end);
+    code = pInfo->stateStore.streamStateDeleteParName(pInfo->pStreamScanOp->pTaskInfo->streamInfo.pState, gpIdCol[i]);
+    QUERY_CHECK_CODE(code, lino, _end);
+    pBlock->info.id.groupId = gpIdCol[i];
+    // currently, only one valid row in pBlock
+    memcpy(pBlock->info.parTbName, varTbName + VARSTR_HEADER_SIZE, TSDB_TABLE_NAME_LEN + 1);
+  }
+
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
+  return code;
+}
+
 static int32_t doStreamScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {
  // NOTE: this operator does never check if current status is done or not
  int32_t        code = TSDB_CODE_SUCCESS;
@ -3774,6 +3811,12 @@ FETCH_NEXT_BLOCK:
        prepareRangeScan(pInfo, pInfo->pUpdateRes, &pInfo->updateResIndex, NULL);
        pInfo->scanMode = STREAM_SCAN_FROM_DATAREADER_RANGE;
      } break;
+      case STREAM_DROP_CHILD_TABLE: {
+        int32_t deleteNum = 0;
+        code = deletePartName(pInfo, pBlock, &deleteNum);
+        QUERY_CHECK_CODE(code, lino, _end);
+        if (deleteNum == 0) goto FETCH_NEXT_BLOCK;
+      } break;
      case STREAM_CHECKPOINT: {
        qError("stream check point error. msg type: STREAM_INPUT__DATA_BLOCK");
      } break;
@ -3915,7 +3958,13 @@ FETCH_NEXT_BLOCK:
        }

        code = setBlockIntoRes(pInfo, pRes, &pStreamInfo->fillHistoryWindow, false);
-        QUERY_CHECK_CODE(code, lino, _end);
+        if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {
+          pInfo->pRes->info.rows = 0;
+          code = TSDB_CODE_SUCCESS;
+        } else {
+          QUERY_CHECK_CODE(code, lino, _end);
+        }
+
        if (pInfo->pRes->info.rows == 0) {
          continue;
        }
--- a/source/libs/executor/src/streamtimewindowoperator.c
+++ b/source/libs/executor/src/streamtimewindowoperator.c
@ -5215,7 +5215,7 @@ static int32_t doStreamIntervalAggNext(SOperatorInfo* pOperator, SSDataBlock** p
      code = getAllIntervalWindow(pInfo->aggSup.pResultRowHashTable, pInfo->pUpdatedMap);
      QUERY_CHECK_CODE(code, lino, _end);
      continue;
-    } else if (pBlock->info.type == STREAM_CREATE_CHILD_TABLE) {
+    } else if (pBlock->info.type == STREAM_CREATE_CHILD_TABLE || pBlock->info.type == STREAM_DROP_CHILD_TABLE) {
      printDataBlock(pBlock, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo));
      (*ppRes) = pBlock;
      return code;
--- a/source/libs/function/src/builtins.c
+++ b/source/libs/function/src/builtins.c
@ -19,7 +19,7 @@
 #include "geomFunc.h"
 #include "querynodes.h"
 #include "scalar.h"
-#include "tanal.h"
+#include "tanalytics.h"
 #include "taoserror.h"
 #include "ttime.h"

@ -188,7 +188,11 @@ static int32_t countTrailingSpaces(const SValueNode* pVal, bool isLtrim) {

 static int32_t addTimezoneParam(SNodeList* pList) {
  char      buf[TD_TIME_STR_LEN] = {0};
-  time_t    t = taosTime(NULL);
+  time_t    t;
+  int32_t code = taosTime(&t);
+  if (code != 0) {
+    return code;
+  }
  struct tm tmInfo;
  if (taosLocalTime(&t, &tmInfo, buf, sizeof(buf)) != NULL) {
    (void)strftime(buf, sizeof(buf), "%z", &tmInfo);
@ -196,7 +200,7 @@ static int32_t addTimezoneParam(SNodeList* pList) {
  int32_t len = (int32_t)strlen(buf);

  SValueNode* pVal = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pVal);
+  code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pVal);
  if (pVal == NULL) {
    return code;
  }
--- a/source/libs/function/src/builtinsimpl.c
+++ b/source/libs/function/src/builtinsimpl.c
@ -19,7 +19,7 @@
 #include "functionResInfoInt.h"
 #include "query.h"
 #include "querynodes.h"
-#include "tanal.h"
+#include "tanalytics.h"
 #include "tcompare.h"
 #include "tdatablock.h"
 #include "tdigest.h"
--- a/source/libs/function/src/tudf.c
+++ b/source/libs/function/src/tudf.c
@ -64,6 +64,10 @@ static void    udfWatchUdfd(void *args);
 void udfUdfdExit(uv_process_t *process, int64_t exitStatus, int32_t termSignal) {
  fnInfo("udfd process exited with status %" PRId64 ", signal %d", exitStatus, termSignal);
  SUdfdData *pData = process->data;
+  if(pData == NULL) {
+    fnError("udfd process data is NULL");
+    return;
+  }
  if (exitStatus == 0 && termSignal == 0 || atomic_load_32(&pData->stopCalled)) {
    fnInfo("udfd process exit due to SIGINT or dnode-mgmt called stop");
  } else {
--- a/source/libs/function/src/udfd.c
+++ b/source/libs/function/src/udfd.c
@ -1507,7 +1507,7 @@ static void removeListeningPipe() {
  int     err = uv_fs_unlink(global.loop, &req, global.listenPipeName, NULL);
  uv_fs_req_cleanup(&req);
  if(err) {
-    fnError("remove listening pipe %s failed, reason:%s, lino:%d", global.listenPipeName, uv_strerror(err), __LINE__);
+    fnInfo("remove listening pipe %s : %s, lino:%d", global.listenPipeName, uv_strerror(err), __LINE__);
  }
 }

--- a/source/libs/nodes/src/nodesCloneFuncs.c
+++ b/source/libs/nodes/src/nodesCloneFuncs.c
@ -851,6 +851,7 @@ static int32_t slotDescCopy(const SSlotDescNode* pSrc, SSlotDescNode* pDst) {

 static int32_t downstreamSourceCopy(const SDownstreamSourceNode* pSrc, SDownstreamSourceNode* pDst) {
  COPY_OBJECT_FIELD(addr, sizeof(SQueryNodeAddr));
+  COPY_SCALAR_FIELD(clientId);
  COPY_SCALAR_FIELD(taskId);
  COPY_SCALAR_FIELD(schedId);
  COPY_SCALAR_FIELD(execId);
--- a/source/libs/nodes/src/nodesCodeFuncs.c
+++ b/source/libs/nodes/src/nodesCodeFuncs.c
@ -5259,6 +5259,7 @@ static int32_t jsonToColumnDefNode(const SJson* pJson, void* pObj) {
 }

 static const char* jkDownstreamSourceAddr = "Addr";
+static const char* jkDownstreamSourceClientId = "ClientId";
 static const char* jkDownstreamSourceTaskId = "TaskId";
 static const char* jkDownstreamSourceSchedId = "SchedId";
 static const char* jkDownstreamSourceExecId = "ExecId";
@ -5268,6 +5269,9 @@ static int32_t downstreamSourceNodeToJson(const void* pObj, SJson* pJson) {
  const SDownstreamSourceNode* pNode = (const SDownstreamSourceNode*)pObj;

  int32_t code = tjsonAddObject(pJson, jkDownstreamSourceAddr, queryNodeAddrToJson, &pNode->addr);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonAddIntegerToObject(pJson, jkDownstreamSourceClientId, pNode->clientId);
+  }
  if (TSDB_CODE_SUCCESS == code) {
    code = tjsonAddIntegerToObject(pJson, jkDownstreamSourceTaskId, pNode->taskId);
  }
@ -5288,6 +5292,9 @@ static int32_t jsonToDownstreamSourceNode(const SJson* pJson, void* pObj) {
  SDownstreamSourceNode* pNode = (SDownstreamSourceNode*)pObj;

  int32_t code = tjsonToObject(pJson, jkDownstreamSourceAddr, jsonToQueryNodeAddr, &pNode->addr);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonGetUBigIntValue(pJson, jkDownstreamSourceClientId, &pNode->clientId);
+  }
  if (TSDB_CODE_SUCCESS == code) {
    code = tjsonGetUBigIntValue(pJson, jkDownstreamSourceTaskId, &pNode->taskId);
  }
--- a/source/libs/nodes/src/nodesMsgFuncs.c
+++ b/source/libs/nodes/src/nodesMsgFuncs.c
@ -1769,6 +1769,9 @@ static int32_t downstreamSourceNodeInlineToMsg(const void* pObj, STlvEncoder* pE
  if (TSDB_CODE_SUCCESS == code) {
    code = tlvEncodeValueI32(pEncoder, pNode->fetchMsgType);
  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tlvEncodeValueU64(pEncoder, pNode->clientId);
+  }

  return code;
 }
@ -1793,6 +1796,9 @@ static int32_t msgToDownstreamSourceNodeInlineToMsg(STlvDecoder* pDecoder, void*
  if (TSDB_CODE_SUCCESS == code) {
    code = tlvDecodeValueI32(pDecoder, &pNode->fetchMsgType);
  }
+  if (TSDB_CODE_SUCCESS == code && !tlvDecodeEnd(pDecoder)) {
+    code = tlvDecodeValueU64(pDecoder, &pNode->clientId);
+  }

  return code;
 }
--- a/source/libs/parser/src/parInsertSql.c
+++ b/source/libs/parser/src/parInsertSql.c
@ -246,7 +246,7 @@ static int32_t parseBoundColumns(SInsertParseContext* pCxt, const char** pSql, E
  return code;
 }

-static int parseTimestampOrInterval(const char** end, SToken* pToken, int16_t timePrec, int64_t* ts, int64_t* interval,
+static int32_t parseTimestampOrInterval(const char** end, SToken* pToken, int16_t timePrec, int64_t* ts, int64_t* interval,
                                    SMsgBuf* pMsgBuf, bool* isTs) {
  if (pToken->type == TK_NOW) {
    *isTs = true;
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@ -24,7 +24,7 @@
 #include "parUtil.h"
 #include "scalar.h"
 #include "systable.h"
-#include "tanal.h"
+#include "tanalytics.h"
 #include "tcol.h"
 #include "tglobal.h"
 #include "ttime.h"
--- a/source/libs/parser/src/parser.c
+++ b/source/libs/parser/src/parser.c
@ -433,9 +433,6 @@ int32_t qStmtBindParams(SQuery* pQuery, TAOS_MULTI_BIND* pParams, int32_t colIdx
    nodesDestroyNode(pQuery->pRoot);
    pQuery->pRoot = NULL;
    code = nodesCloneNode(pQuery->pPrepareRoot, &pQuery->pRoot);
-    if (NULL == pQuery->pRoot) {
-      code = code;
-    }
  }
  if (TSDB_CODE_SUCCESS == code) {
    rewriteExprAlias(pQuery->pRoot);
--- a/source/libs/planner/src/planLogicCreater.c
+++ b/source/libs/planner/src/planLogicCreater.c
@ -1534,21 +1534,20 @@ static int32_t createSortLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
  if (TSDB_CODE_SUCCESS == code) {
    pSort->pSortKeys = NULL;
    code = nodesCloneList(pSelect->pOrderByList, &pSort->pSortKeys);
-    if (NULL == pSort->pSortKeys) {
-      code = code;
-    }
-    SNode*            pNode = NULL;
-    SOrderByExprNode* firstSortKey = (SOrderByExprNode*)nodesListGetNode(pSort->pSortKeys, 0);
-    if (isPrimaryKeySort(pSelect->pOrderByList)) pSort->node.outputTsOrder = firstSortKey->order;
-    if (firstSortKey->pExpr->type == QUERY_NODE_COLUMN) {
-      SColumnNode* pCol = (SColumnNode*)firstSortKey->pExpr;
-      int16_t      projIdx = 1;
-      FOREACH(pNode, pSelect->pProjectionList) {
-        SExprNode* pExpr = (SExprNode*)pNode;
-        if (0 == strcmp(pCol->node.aliasName, pExpr->aliasName)) {
-          pCol->projIdx = projIdx; break;
+    if (NULL != pSort->pSortKeys) {
+      SNode*            pNode = NULL;
+      SOrderByExprNode* firstSortKey = (SOrderByExprNode*)nodesListGetNode(pSort->pSortKeys, 0);
+      if (isPrimaryKeySort(pSelect->pOrderByList)) pSort->node.outputTsOrder = firstSortKey->order;
+      if (firstSortKey->pExpr->type == QUERY_NODE_COLUMN) {
+        SColumnNode* pCol = (SColumnNode*)firstSortKey->pExpr;
+        int16_t      projIdx = 1;
+        FOREACH(pNode, pSelect->pProjectionList) {
+          SExprNode* pExpr = (SExprNode*)pNode;
+          if (0 == strcmp(pCol->node.aliasName, pExpr->aliasName)) {
+            pCol->projIdx = projIdx; break;
+          }
+          projIdx++;
        }
-        projIdx++;
      }
    }
  }
--- a/source/libs/planner/src/planSpliter.c
+++ b/source/libs/planner/src/planSpliter.c
@ -836,11 +836,9 @@ static int32_t stbSplSplitSessionForStream(SSplitContext* pCxt, SStableSplitInfo
      nodesDestroyNode(pMergeWin->pTsEnd);
      pMergeWin->pTsEnd = NULL;
      code = nodesCloneNode(nodesListGetNode(pPartWin->node.pTargets, index), &pMergeWin->pTsEnd);
-      if (NULL == pMergeWin->pTsEnd) {
-        code = code;
-      }
    }
-    code = stbSplCreateExchangeNode(pCxt, pInfo->pSplitNode, pPartWindow);
+    if (TSDB_CODE_SUCCESS == code)
+      code = stbSplCreateExchangeNode(pCxt, pInfo->pSplitNode, pPartWindow);
  }
  if (TSDB_CODE_SUCCESS == code) {
    code = nodesListMakeStrictAppend(&pInfo->pSubplan->pChildren,
--- a/source/libs/qworker/inc/qwInt.h
+++ b/source/libs/qworker/inc/qwInt.h
@ -215,8 +215,8 @@ typedef struct SQWorkerMgmt {
 #define QW_CTX_NOT_EXISTS_ERR_CODE(mgmt) \
  (atomic_load_8(&(mgmt)->nodeStopped) ? TSDB_CODE_VND_STOPPED : TSDB_CODE_QRY_TASK_CTX_NOT_EXIST)

-#define QW_FPARAMS_DEF SQWorker *mgmt, uint64_t sId, uint64_t qId, uint64_t tId, int64_t rId, int32_t eId
-#define QW_IDS()       sId, qId, tId, rId, eId
+#define QW_FPARAMS_DEF SQWorker *mgmt, uint64_t sId, uint64_t qId, uint64_t cId, uint64_t tId, int64_t rId, int32_t eId
+#define QW_IDS()       sId, qId, cId, tId, rId, eId
 #define QW_FPARAMS()   mgmt, QW_IDS()

 #define QW_STAT_INC(_item, _n) (void)atomic_add_fetch_64(&(_item), _n)
@ -257,18 +257,20 @@ typedef struct SQWorkerMgmt {
 #define QW_FETCH_RUNNING(ctx)     ((ctx)->inFetch)
 #define QW_QUERY_NOT_STARTED(ctx) (QW_GET_PHASE(ctx) == -1)

-#define QW_SET_QTID(id, qId, tId, eId)                              \
-  do {                                                              \
-    *(uint64_t *)(id) = (qId);                                      \
-    *(uint64_t *)((char *)(id) + sizeof(qId)) = (tId);              \
-    *(int32_t *)((char *)(id) + sizeof(qId) + sizeof(tId)) = (eId); \
+#define QW_SET_QTID(id, qId, cId, tId, eId)                                       \
+  do {                                                                            \
+    *(uint64_t *)(id) = (qId);                                                    \
+    *(uint64_t *)((char *)(id) + sizeof(qId)) = (cId);                            \
+    *(uint64_t *)((char *)(id) + sizeof(qId) + sizeof(cId)) = (tId);              \
+    *(int32_t *)((char *)(id) + sizeof(qId) + sizeof(cId) + sizeof(tId)) = (eId); \
  } while (0)

-#define QW_GET_QTID(id, qId, tId, eId)                              \
-  do {                                                              \
-    (qId) = *(uint64_t *)(id);                                      \
-    (tId) = *(uint64_t *)((char *)(id) + sizeof(qId));              \
-    (eId) = *(int32_t *)((char *)(id) + sizeof(qId) + sizeof(tId)); \
+#define QW_GET_QTID(id, qId, cId, tId, eId)                                       \
+  do {                                                                            \
+    (qId) = *(uint64_t *)(id);                                                    \
+    (cId) = *(uint64_t *)((char *)(id) + sizeof(qId));                            \
+    (tId) = *(uint64_t *)((char *)(id) + sizeof(qId) + sizeof(cId));              \
+    (eId) = *(int32_t *)((char *)(id) + sizeof(qId) + sizeof(cId) + sizeof(tId)); \
  } while (0)

 #define QW_ERR_RET(c)                 \
@ -310,25 +312,31 @@ typedef struct SQWorkerMgmt {
 #define QW_SCH_ELOG(param, ...) qError("QW:%p SID:%" PRIx64 " " param, mgmt, sId, __VA_ARGS__)
 #define QW_SCH_DLOG(param, ...) qDebug("QW:%p SID:%" PRIx64 " " param, mgmt, sId, __VA_ARGS__)

-#define QW_TASK_ELOG(param, ...) qError("qid:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, qId, tId, eId, __VA_ARGS__)
-#define QW_TASK_WLOG(param, ...) qWarn("qid:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, qId, tId, eId, __VA_ARGS__)
-#define QW_TASK_DLOG(param, ...) qDebug("qid:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, qId, tId, eId, __VA_ARGS__)
+#define QW_TASK_ELOG(param, ...) \
+  qError("qid:0x%" PRIx64 ",CID:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, qId, cId, tId, eId, __VA_ARGS__)
+#define QW_TASK_WLOG(param, ...) \
+  qWarn("qid:0x%" PRIx64 ",CID:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, qId, cId, tId, eId, __VA_ARGS__)
+#define QW_TASK_DLOG(param, ...) \
+  qDebug("qid:0x%" PRIx64 ",CID:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, qId, cId, tId, eId, __VA_ARGS__)
 #define QW_TASK_DLOGL(param, ...) \
-  qDebugL("qid:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, qId, tId, eId, __VA_ARGS__)
+  qDebugL("qid:0x%" PRIx64 ",CID:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, qId, cId, tId, eId, __VA_ARGS__)

-#define QW_TASK_ELOG_E(param) qError("qid:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, qId, tId, eId)
-#define QW_TASK_WLOG_E(param) qWarn("qid:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, qId, tId, eId)
-#define QW_TASK_DLOG_E(param) qDebug("qid:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, qId, tId, eId)
+#define QW_TASK_ELOG_E(param) \
+  qError("qid:0x%" PRIx64 ",CID:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, qId, cId, tId, eId)
+#define QW_TASK_WLOG_E(param) \
+  qWarn("qid:0x%" PRIx64 ",CID:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, qId, cId, tId, eId)
+#define QW_TASK_DLOG_E(param) \
+  qDebug("qid:0x%" PRIx64 ",CID:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, qId, cId, tId, eId)

-#define QW_SCH_TASK_ELOG(param, ...)                                                                            \
-  qError("QW:%p SID:0x%" PRIx64 ",qid:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, mgmt, sId, qId, tId, eId, \
-         __VA_ARGS__)
-#define QW_SCH_TASK_WLOG(param, ...)                                                                           \
-  qWarn("QW:%p SID:0x%" PRIx64 ",qid:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, mgmt, sId, qId, tId, eId, \
-        __VA_ARGS__)
-#define QW_SCH_TASK_DLOG(param, ...)                                                                            \
-  qDebug("QW:%p SID:0x%" PRIx64 ",qid:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, mgmt, sId, qId, tId, eId, \
-         __VA_ARGS__)
+#define QW_SCH_TASK_ELOG(param, ...)                                                                               \
+  qError("QW:%p SID:0x%" PRIx64 ",qid:0x%" PRIx64 ",CID:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, mgmt, sId, \
+         qId, cId, tId, eId, __VA_ARGS__)
+#define QW_SCH_TASK_WLOG(param, ...)                                                                                   \
+  qWarn("QW:%p SID:0x%" PRIx64 ",qid:0x%" PRIx64 ",CID:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, mgmt, sId, qId, \
+        cId, tId, eId, __VA_ARGS__)
+#define QW_SCH_TASK_DLOG(param, ...)                                                                               \
+  qDebug("QW:%p SID:0x%" PRIx64 ",qid:0x%" PRIx64 ",CID:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, mgmt, sId, \
+         qId, cId, tId, eId, __VA_ARGS__)

 #define QW_LOCK_DEBUG(...)     \
  do {                         \
--- a/source/libs/qworker/src/qwDbg.c
+++ b/source/libs/qworker/src/qwDbg.c
@ -96,14 +96,14 @@ void qwDbgDumpSchInfo(SQWorker *mgmt, SQWSchStatus *sch, int32_t i) {
  int32_t taskNum = taosHashGetSize(sch->tasksHash);
  QW_DLOG("***The %dth scheduler status, hbBrokenTs:%" PRId64 ",taskNum:%d", i, sch->hbBrokenTs, taskNum);

-  uint64_t qId, tId;
+  uint64_t qId, cId, tId;
  int32_t  eId;
  SQWTaskStatus *pTask = NULL;
  void *pIter = taosHashIterate(sch->tasksHash, NULL);
  while (pIter) {
    pTask = (SQWTaskStatus *)pIter;
    void       *key = taosHashGetKey(pIter, NULL);
-    QW_GET_QTID(key, qId, tId, eId);
+    QW_GET_QTID(key, qId, cId, tId, eId);

    QW_TASK_DLOG("job refId:%" PRIx64 ", code:%x, task status:%d", pTask->refId, pTask->code, pTask->status);

@ -118,13 +118,13 @@ void qwDbgDumpTasksInfo(SQWorker *mgmt) {

  int32_t i = 0;
  SQWTaskCtx *ctx = NULL;
-  uint64_t qId, tId;
+  uint64_t qId, cId, tId;
  int32_t  eId;
  void *pIter = taosHashIterate(mgmt->ctxHash, NULL);
  while (pIter) {
    ctx = (SQWTaskCtx *)pIter;
    void       *key = taosHashGetKey(pIter, NULL);
-    QW_GET_QTID(key, qId, tId, eId);
+    QW_GET_QTID(key, qId, cId, tId, eId);
    
    QW_TASK_DLOG("%p lock:%x, phase:%d, type:%d, explain:%d, needFetch:%d, localExec:%d, queryMsgType:%d, "
      "sId:%" PRId64 ", level:%d, queryGotData:%d, queryRsped:%d, queryEnd:%d, queryContinue:%d, queryInQueue:%d, "
--- a/source/libs/qworker/src/qwMsg.c
+++ b/source/libs/qworker/src/qwMsg.c
@ -233,6 +233,7 @@ int32_t qwBuildAndSendDropMsg(QW_FPARAMS_DEF, SRpcHandleInfo *pConn) {
  qMsg.header.contLen = 0;
  qMsg.sId = sId;
  qMsg.queryId = qId;
+  qMsg.clientId = cId;
  qMsg.taskId = tId;
  qMsg.refId = rId;
  qMsg.execId = eId;
@ -284,6 +285,7 @@ int32_t qwBuildAndSendCQueryMsg(QW_FPARAMS_DEF, SRpcHandleInfo *pConn) {
  req->header.vgId = mgmt->nodeId;
  req->sId = sId;
  req->queryId = qId;
+  req->clientId = cId;
  req->taskId = tId;
  req->execId = eId;

@ -312,6 +314,7 @@ int32_t qwRegisterQueryBrokenLinkArg(QW_FPARAMS_DEF, SRpcHandleInfo *pConn) {
  qMsg.header.contLen = 0;
  qMsg.sId = sId;
  qMsg.queryId = qId;
+  qMsg.clientId = cId;
  qMsg.taskId = tId;
  qMsg.refId = rId;
  qMsg.execId = eId;
@ -416,6 +419,7 @@ int32_t qWorkerPreprocessQueryMsg(void *qWorkerMgmt, SRpcMsg *pMsg, bool chkGran

  uint64_t sId = msg.sId;
  uint64_t qId = msg.queryId;
+  uint64_t cId = msg.clientId;
  uint64_t tId = msg.taskId;
  int64_t  rId = msg.refId;
  int32_t  eId = msg.execId;
@ -447,6 +451,7 @@ int32_t qWorkerAbortPreprocessQueryMsg(void *qWorkerMgmt, SRpcMsg *pMsg) {

  uint64_t sId = msg.sId;
  uint64_t qId = msg.queryId;
+  uint64_t cId = msg.clientId;
  uint64_t tId = msg.taskId;
  int64_t  rId = msg.refId;
  int32_t  eId = msg.execId;
@ -479,6 +484,7 @@ int32_t qWorkerProcessQueryMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int

  uint64_t sId = msg.sId;
  uint64_t qId = msg.queryId;
+  uint64_t cId = msg.clientId;
  uint64_t tId = msg.taskId;
  int64_t  rId = msg.refId;
  int32_t  eId = msg.execId;
@ -524,6 +530,7 @@ int32_t qWorkerProcessCQueryMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, in

  uint64_t sId = msg->sId;
  uint64_t qId = msg->queryId;
+  uint64_t cId = msg->clientId;
  uint64_t tId = msg->taskId;
  int64_t  rId = 0;
  int32_t  eId = msg->execId;
@ -557,6 +564,7 @@ int32_t qWorkerProcessFetchMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int

  uint64_t sId = req.sId;
  uint64_t qId = req.queryId;
+  uint64_t cId = req.clientId;
  uint64_t tId = req.taskId;
  int64_t  rId = 0;
  int32_t  eId = req.execId;
@ -604,12 +612,14 @@ int32_t qWorkerProcessCancelMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, in

  msg->sId = be64toh(msg->sId);
  msg->queryId = be64toh(msg->queryId);
+  msg->clientId = be64toh(msg->clientId);
  msg->taskId = be64toh(msg->taskId);
  msg->refId = be64toh(msg->refId);
  msg->execId = ntohl(msg->execId);

  uint64_t sId = msg->sId;
  uint64_t qId = msg->queryId;
+  uint64_t cId = msg->clientId;
  uint64_t tId = msg->taskId;
  int64_t  rId = msg->refId;
  int32_t  eId = msg->execId;
@ -646,6 +656,7 @@ int32_t qWorkerProcessDropMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int6

  uint64_t sId = msg.sId;
  uint64_t qId = msg.queryId;
+  uint64_t cId = msg.clientId;
  uint64_t tId = msg.taskId;
  int64_t  rId = msg.refId;
  int32_t  eId = msg.execId;
@ -684,6 +695,7 @@ int32_t qWorkerProcessNotifyMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, in

  uint64_t sId = msg.sId;
  uint64_t qId = msg.queryId;
+  uint64_t cId = msg.clientId;
  uint64_t tId = msg.taskId;
  int64_t  rId = msg.refId;
  int32_t  eId = msg.execId;
@ -753,6 +765,7 @@ int32_t qWorkerProcessDeleteMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, SD

  uint64_t sId = req.sId;
  uint64_t qId = req.queryId;
+  uint64_t cId = req.clientId;
  uint64_t tId = req.taskId;
  int64_t  rId = 0;
  int32_t  eId = -1;
--- a/source/libs/qworker/src/qwUtil.c
+++ b/source/libs/qworker/src/qwUtil.c
@ -137,8 +137,8 @@ int32_t qwAcquireScheduler(SQWorker *mgmt, uint64_t sId, int32_t rwType, SQWSchS
 void qwReleaseScheduler(int32_t rwType, SQWorker *mgmt) { QW_UNLOCK(rwType, &mgmt->schLock); }

 int32_t qwAcquireTaskStatus(QW_FPARAMS_DEF, int32_t rwType, SQWSchStatus *sch, SQWTaskStatus **task) {
-  char id[sizeof(qId) + sizeof(tId) + sizeof(eId)] = {0};
-  QW_SET_QTID(id, qId, tId, eId);
+  char id[sizeof(qId) + sizeof(cId) + sizeof(tId) + sizeof(eId)] = {0};
+  QW_SET_QTID(id, qId, cId, tId, eId);

  QW_LOCK(rwType, &sch->tasksLock);
  *task = taosHashGet(sch->tasksHash, id, sizeof(id));
@ -153,8 +153,8 @@ int32_t qwAcquireTaskStatus(QW_FPARAMS_DEF, int32_t rwType, SQWSchStatus *sch, S
 int32_t qwAddTaskStatusImpl(QW_FPARAMS_DEF, SQWSchStatus *sch, int32_t rwType, int32_t status, SQWTaskStatus **task) {
  int32_t code = 0;

-  char id[sizeof(qId) + sizeof(tId) + sizeof(eId)] = {0};
-  QW_SET_QTID(id, qId, tId, eId);
+  char id[sizeof(qId) + sizeof(cId) + sizeof(tId) + sizeof(eId)] = {0};
+  QW_SET_QTID(id, qId, cId, tId, eId);

  SQWTaskStatus ntask = {0};
  ntask.status = status;
@ -209,8 +209,8 @@ int32_t qwAddAcquireTaskStatus(QW_FPARAMS_DEF, int32_t rwType, SQWSchStatus *sch
 void qwReleaseTaskStatus(int32_t rwType, SQWSchStatus *sch) { QW_UNLOCK(rwType, &sch->tasksLock); }

 int32_t qwAcquireTaskCtx(QW_FPARAMS_DEF, SQWTaskCtx **ctx) {
-  char id[sizeof(qId) + sizeof(tId) + sizeof(eId)] = {0};
-  QW_SET_QTID(id, qId, tId, eId);
+  char id[sizeof(qId) + sizeof(cId) + sizeof(tId) + sizeof(eId)] = {0};
+  QW_SET_QTID(id, qId, cId, tId, eId);

  *ctx = taosHashAcquire(mgmt->ctxHash, id, sizeof(id));
  if (NULL == (*ctx)) {
@ -222,8 +222,8 @@ int32_t qwAcquireTaskCtx(QW_FPARAMS_DEF, SQWTaskCtx **ctx) {
 }

 int32_t qwGetTaskCtx(QW_FPARAMS_DEF, SQWTaskCtx **ctx) {
-  char id[sizeof(qId) + sizeof(tId) + sizeof(eId)] = {0};
-  QW_SET_QTID(id, qId, tId, eId);
+  char id[sizeof(qId) + sizeof(cId) + sizeof(tId) + sizeof(eId)] = {0};
+  QW_SET_QTID(id, qId, cId, tId, eId);

  *ctx = taosHashGet(mgmt->ctxHash, id, sizeof(id));
  if (NULL == (*ctx)) {
@ -235,8 +235,8 @@ int32_t qwGetTaskCtx(QW_FPARAMS_DEF, SQWTaskCtx **ctx) {
 }

 int32_t qwAddTaskCtxImpl(QW_FPARAMS_DEF, bool acquire, SQWTaskCtx **ctx) {
-  char id[sizeof(qId) + sizeof(tId) + sizeof(eId)] = {0};
-  QW_SET_QTID(id, qId, tId, eId);
+  char id[sizeof(qId) + sizeof(cId) + sizeof(tId) + sizeof(eId)] = {0};
+  QW_SET_QTID(id, qId, cId, tId, eId);

  SQWTaskCtx nctx = {0};

@ -347,6 +347,7 @@ int32_t qwSendExplainResponse(QW_FPARAMS_DEF, SQWTaskCtx *ctx) {
    (void)memcpy(pExec, taosArrayGet(execInfoList, 0), localRsp.rsp.numOfPlans * sizeof(SExplainExecInfo));
    localRsp.rsp.subplanInfo = pExec;
    localRsp.qId = qId;
+    localRsp.cId = cId;
    localRsp.tId = tId;
    localRsp.rId = rId;
    localRsp.eId = eId;
@ -376,8 +377,8 @@ _return:


 int32_t qwDropTaskCtx(QW_FPARAMS_DEF) {
-  char id[sizeof(qId) + sizeof(tId) + sizeof(eId)] = {0};
-  QW_SET_QTID(id, qId, tId, eId);
+  char id[sizeof(qId) + sizeof(cId) + sizeof(tId) + sizeof(eId)] = {0};
+  QW_SET_QTID(id, qId, cId, tId, eId);
  SQWTaskCtx octx;

  SQWTaskCtx *ctx = taosHashGet(mgmt->ctxHash, id, sizeof(id));
@ -411,8 +412,8 @@ int32_t qwDropTaskStatus(QW_FPARAMS_DEF) {
  SQWTaskStatus *task = NULL;
  int32_t        code = 0;

-  char id[sizeof(qId) + sizeof(tId) + sizeof(eId)] = {0};
-  QW_SET_QTID(id, qId, tId, eId);
+  char id[sizeof(qId) + sizeof(cId) + sizeof(tId) + sizeof(eId)] = {0};
+  QW_SET_QTID(id, qId, cId, tId, eId);

  if (qwAcquireScheduler(mgmt, sId, QW_WRITE, &sch)) {
    QW_TASK_WLOG_E("scheduler does not exist");
@ -465,8 +466,8 @@ _return:


 int32_t qwHandleDynamicTaskEnd(QW_FPARAMS_DEF) {
-  char id[sizeof(qId) + sizeof(tId) + sizeof(eId)] = {0};
-  QW_SET_QTID(id, qId, tId, eId);
+  char id[sizeof(qId) + sizeof(cId) + sizeof(tId) + sizeof(eId)] = {0};
+  QW_SET_QTID(id, qId, cId, tId, eId);
  SQWTaskCtx octx;

  SQWTaskCtx *ctx = taosHashGet(mgmt->ctxHash, id, sizeof(id));
@ -588,14 +589,14 @@ void qwDestroyImpl(void *pMgmt) {
  mgmt->hbTimer = NULL;
  taosTmrCleanUp(mgmt->timer);

-  uint64_t qId, tId;
+  uint64_t qId, cId, tId;
  int32_t  eId;
  void    *pIter = taosHashIterate(mgmt->ctxHash, NULL);

  while (pIter) {
    SQWTaskCtx *ctx = (SQWTaskCtx *)pIter;
    void       *key = taosHashGetKey(pIter, NULL);
-    QW_GET_QTID(key, qId, tId, eId);
+    QW_GET_QTID(key, qId, cId, tId, eId);

    qwFreeTaskCtx(ctx);
    QW_TASK_DLOG_E("task ctx freed");
--- a/source/libs/qworker/src/qworker.c
+++ b/source/libs/qworker/src/qworker.c
@ -19,7 +19,7 @@ SQWorkerMgmt gQwMgmt = {
 };

 void qwStopAllTasks(SQWorker *mgmt) {
-  uint64_t qId, tId, sId;
+  uint64_t qId, cId, tId, sId;
  int32_t  eId;
  int64_t  rId = 0;
  int32_t  code = TSDB_CODE_SUCCESS;
@ -28,7 +28,7 @@ void qwStopAllTasks(SQWorker *mgmt) {
  while (pIter) {
    SQWTaskCtx *ctx = (SQWTaskCtx *)pIter;
    void       *key = taosHashGetKey(pIter, NULL);
-    QW_GET_QTID(key, qId, tId, eId);
+    QW_GET_QTID(key, qId, cId, tId, eId);

    QW_LOCK(QW_WRITE, &ctx->lock);

@ -288,7 +288,7 @@ int32_t qwGenerateSchHbRsp(SQWorker *mgmt, SQWSchStatus *sch, SQWHbInfo *hbInfo)

    // TODO GET EXECUTOR API TO GET MORE INFO

-    QW_GET_QTID(key, status.queryId, status.taskId, status.execId);
+    QW_GET_QTID(key, status.queryId, status.clientId, status.taskId, status.execId);
    status.status = taskStatus->status;
    status.refId = taskStatus->refId;

@ -1473,8 +1473,8 @@ int32_t qWorkerGetStat(SReadHandle *handle, void *qWorkerMgmt, SQWorkerStat *pSt
  return TSDB_CODE_SUCCESS;
 }

-int32_t qWorkerProcessLocalQuery(void *pMgmt, uint64_t sId, uint64_t qId, uint64_t tId, int64_t rId, int32_t eId,
-                                 SQWMsg *qwMsg, SArray *explainRes) {
+int32_t qWorkerProcessLocalQuery(void *pMgmt, uint64_t sId, uint64_t qId, uint64_t cId, uint64_t tId, int64_t rId,
+                                 int32_t eId, SQWMsg *qwMsg, SArray *explainRes) {
  SQWorker      *mgmt = (SQWorker *)pMgmt;
  int32_t        code = 0;
  SQWTaskCtx    *ctx = NULL;
@ -1538,8 +1538,8 @@ _return:
  QW_RET(code);
 }

-int32_t qWorkerProcessLocalFetch(void *pMgmt, uint64_t sId, uint64_t qId, uint64_t tId, int64_t rId, int32_t eId,
-                                 void **pRsp, SArray *explainRes) {
+int32_t qWorkerProcessLocalFetch(void *pMgmt, uint64_t sId, uint64_t qId, uint64_t cId, uint64_t tId, int64_t rId,
+                                 int32_t eId, void **pRsp, SArray *explainRes) {
  SQWorker   *mgmt = (SQWorker *)pMgmt;
  int32_t     code = 0;
  int32_t     dataLen = 0;
--- a/source/libs/scheduler/inc/schInt.h
+++ b/source/libs/scheduler/inc/schInt.h
@ -142,8 +142,9 @@ typedef struct SSchedulerCfg {
 } SSchedulerCfg;

 typedef struct SSchedulerMgmt {
-  uint64_t      taskId;  // sequential taksId
-  uint64_t      sId;     // schedulerId
+  uint64_t      clientId;  // unique clientId
+  uint64_t      taskId;    // sequential taksId
+  uint64_t      sId;       // schedulerId
  SSchedulerCfg cfg;
  bool          exit;
  int32_t       jobRef;
@ -163,6 +164,7 @@ typedef struct SSchTaskCallbackParam {
  SSchCallbackParamHeader head;
  uint64_t                queryId;
  int64_t                 refId;
+  uint64_t                clientId;
  uint64_t                taskId;
  int32_t                 execId;
  void                   *pTrans;
@ -222,6 +224,7 @@ typedef struct SSchTimerParam {
 } SSchTimerParam;

 typedef struct SSchTask {
+  uint64_t        clientId;        // current client id
  uint64_t        taskId;          // task id
  SRWLatch        lock;            // task reentrant lock
  int32_t         maxExecTimes;    // task max exec times
@ -329,6 +332,7 @@ extern SSchedulerMgmt schMgmt;
 #define SCH_LOCK_TASK(_task)   SCH_LOCK(SCH_WRITE, &(_task)->lock)
 #define SCH_UNLOCK_TASK(_task) SCH_UNLOCK(SCH_WRITE, &(_task)->lock)

+#define SCH_CLIENT_ID(_task) ((_task) ? (_task)->clientId : -1)
 #define SCH_TASK_ID(_task)  ((_task) ? (_task)->taskId : -1)
 #define SCH_TASK_EID(_task) ((_task) ? (_task)->execId : -1)

@ -449,21 +453,21 @@ extern SSchedulerMgmt schMgmt;
 #define SCH_JOB_ELOG(param, ...) qError("qid:0x%" PRIx64 " " param, pJob->queryId, __VA_ARGS__)
 #define SCH_JOB_DLOG(param, ...) qDebug("qid:0x%" PRIx64 " " param, pJob->queryId, __VA_ARGS__)

-#define SCH_TASK_ELOG(param, ...)                                                                                     \
-  qError("qid:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, pJob->queryId, SCH_TASK_ID(pTask), SCH_TASK_EID(pTask), \
-         __VA_ARGS__)
-#define SCH_TASK_DLOG(param, ...)                                                                                     \
-  qDebug("qid:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, pJob->queryId, SCH_TASK_ID(pTask), SCH_TASK_EID(pTask), \
-         __VA_ARGS__)
-#define SCH_TASK_TLOG(param, ...)                                                                                     \
-  qTrace("qid:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, pJob->queryId, SCH_TASK_ID(pTask), SCH_TASK_EID(pTask), \
-         __VA_ARGS__)
-#define SCH_TASK_DLOGL(param, ...)                                                                                     \
-  qDebugL("qid:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, pJob->queryId, SCH_TASK_ID(pTask), SCH_TASK_EID(pTask), \
-          __VA_ARGS__)
-#define SCH_TASK_WLOG(param, ...)                                                                                    \
-  qWarn("qid:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, pJob->queryId, SCH_TASK_ID(pTask), SCH_TASK_EID(pTask), \
-        __VA_ARGS__)
+#define SCH_TASK_ELOG(param, ...)                                                                                    \
+  qError("qid:0x%" PRIx64 ",CID:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, pJob->queryId, SCH_CLIENT_ID(pTask), \
+         SCH_TASK_ID(pTask), SCH_TASK_EID(pTask), __VA_ARGS__)
+#define SCH_TASK_DLOG(param, ...)                                                                                    \
+  qDebug("qid:0x%" PRIx64 ",CID:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, pJob->queryId, SCH_CLIENT_ID(pTask), \
+         SCH_TASK_ID(pTask), SCH_TASK_EID(pTask), __VA_ARGS__)
+#define SCH_TASK_TLOG(param, ...)                                                                                    \
+  qTrace("qid:0x%" PRIx64 ",CID:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, pJob->queryId, SCH_CLIENT_ID(pTask), \
+         SCH_TASK_ID(pTask), SCH_TASK_EID(pTask), __VA_ARGS__)
+#define SCH_TASK_DLOGL(param, ...)                                                                                    \
+  qDebugL("qid:0x%" PRIx64 ",CID:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, pJob->queryId, SCH_CLIENT_ID(pTask), \
+          SCH_TASK_ID(pTask), SCH_TASK_EID(pTask), __VA_ARGS__)
+#define SCH_TASK_WLOG(param, ...)                                                                                   \
+  qWarn("qid:0x%" PRIx64 ",CID:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d " param, pJob->queryId, SCH_CLIENT_ID(pTask), \
+        SCH_TASK_ID(pTask), SCH_TASK_EID(pTask), __VA_ARGS__)

 #define SCH_SET_ERRNO(_err)                     \
  do {                                          \
--- a/source/libs/scheduler/src/schRemote.c
+++ b/source/libs/scheduler/src/schRemote.c
@ -500,8 +500,8 @@ _return:

 int32_t schHandleDropCallback(void *param, SDataBuf *pMsg, int32_t code) {
  SSchTaskCallbackParam *pParam = (SSchTaskCallbackParam *)param;
-  qDebug("QID:0x%" PRIx64 ",TID:0x%" PRIx64 " drop task rsp received, code:0x%x", pParam->queryId, pParam->taskId,
-         code);
+  qDebug("QID:0x%" PRIx64 ",CID:0x%" PRIx64 ",TID:0x%" PRIx64 " drop task rsp received, code:0x%x", pParam->queryId,
+         pParam->clientId, pParam->taskId, code);
  // called if drop task rsp received code
  (void)rpcReleaseHandle(pMsg->handle, TAOS_CONN_CLIENT); // ignore error

@ -517,8 +517,8 @@ int32_t schHandleDropCallback(void *param, SDataBuf *pMsg, int32_t code) {

 int32_t schHandleNotifyCallback(void *param, SDataBuf *pMsg, int32_t code) {
  SSchTaskCallbackParam *pParam = (SSchTaskCallbackParam *)param;
-  qDebug("QID:0x%" PRIx64 ",TID:0x%" PRIx64 " task notify rsp received, code:0x%x", pParam->queryId, pParam->taskId,
-         code);
+  qDebug("QID:0x%" PRIx64 ",CID:0x%" PRIx64 ",TID:0x%" PRIx64 " task notify rsp received, code:0x%x", pParam->queryId,
+         pParam->clientId, pParam->taskId, code);
  if (pMsg) {
    taosMemoryFree(pMsg->pData);
    taosMemoryFree(pMsg->pEpSet);
@ -595,6 +595,7 @@ int32_t schMakeCallbackParam(SSchJob *pJob, SSchTask *pTask, int32_t msgType, bo

    param->queryId = pJob->queryId;
    param->refId = pJob->refId;
+    param->clientId = SCH_CLIENT_ID(pTask);
    param->taskId = SCH_TASK_ID(pTask);
    param->pTrans = pJob->conn.pTrans;
    param->execId = pTask->execId;
@ -1138,6 +1139,7 @@ int32_t schBuildAndSendMsg(SSchJob *pJob, SSchTask *pTask, SQueryNodeAddr *addr,
      req.header.vgId = addr->nodeId;
      req.sId = schMgmt.sId;
      req.queryId = pJob->queryId;
+      req.clientId = pTask->clientId;
      req.taskId = pTask->taskId;
      req.phyLen = pTask->msgLen;
      req.sqlLen = strlen(pJob->sql);
@ -1171,6 +1173,7 @@ int32_t schBuildAndSendMsg(SSchJob *pJob, SSchTask *pTask, SQueryNodeAddr *addr,
      qMsg.header.contLen = 0;
      qMsg.sId = schMgmt.sId;
      qMsg.queryId = pJob->queryId;
+      qMsg.clientId = pTask->clientId;
      qMsg.taskId = pTask->taskId;
      qMsg.refId = pJob->refId;
      qMsg.execId = pTask->execId;
@ -1226,6 +1229,7 @@ int32_t schBuildAndSendMsg(SSchJob *pJob, SSchTask *pTask, SQueryNodeAddr *addr,
      req.header.vgId = addr->nodeId;
      req.sId = schMgmt.sId;
      req.queryId = pJob->queryId;
+      req.clientId = pTask->clientId;
      req.taskId = pTask->taskId;
      req.execId = pTask->execId;

@ -1253,6 +1257,7 @@ int32_t schBuildAndSendMsg(SSchJob *pJob, SSchTask *pTask, SQueryNodeAddr *addr,
      qMsg.header.contLen = 0;
      qMsg.sId = schMgmt.sId;
      qMsg.queryId = pJob->queryId;
+      qMsg.clientId = pTask->clientId;
      qMsg.taskId = pTask->taskId;
      qMsg.refId = pJob->refId;
      qMsg.execId = *(int32_t*)param;
@ -1310,6 +1315,7 @@ int32_t schBuildAndSendMsg(SSchJob *pJob, SSchTask *pTask, SQueryNodeAddr *addr,
      qMsg.header.contLen = 0;
      qMsg.sId = schMgmt.sId;
      qMsg.queryId = pJob->queryId;
+      qMsg.clientId = pTask->clientId;
      qMsg.taskId = pTask->taskId;
      qMsg.refId = pJob->refId;
      qMsg.execId = pTask->execId;
--- a/source/libs/scheduler/src/schTask.c
+++ b/source/libs/scheduler/src/schTask.c
@ -66,6 +66,7 @@ int32_t schInitTask(SSchJob *pJob, SSchTask *pTask, SSubplan *pPlan, SSchLevel *
  pTask->execId = -1;
  pTask->failedExecId = -2;
  pTask->timeoutUsec = SCH_DEFAULT_TASK_TIMEOUT_USEC;
+  pTask->clientId = getClientId();
  pTask->taskId = schGenTaskId();

  schInitTaskRetryTimes(pJob, pTask, pLevel);
@ -305,6 +306,7 @@ int32_t schProcessOnTaskSuccess(SSchJob *pJob, SSchTask *pTask) {
    SCH_LOCK(SCH_WRITE, &parent->planLock);
    SDownstreamSourceNode source = {
        .type = QUERY_NODE_DOWNSTREAM_SOURCE,
+        .clientId = pTask->clientId,
        .taskId = pTask->taskId,
        .schedId = schMgmt.sId,
        .execId = pTask->execId,
@ -996,8 +998,8 @@ int32_t schProcessOnTaskStatusRsp(SQueryNodeEpId *pEpId, SArray *pStatusList) {

    int32_t code = 0;

-    qDebug("QID:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d task status in server: %s", pStatus->queryId, pStatus->taskId,
-           pStatus->execId, jobTaskStatusStr(pStatus->status));
+    qDebug("QID:0x%" PRIx64 ",CID:0x%" PRIx64 ",TID:0x%" PRIx64 ",EID:%d task status in server: %s", pStatus->queryId,
+           pStatus->clientId, pStatus->taskId, pStatus->execId, jobTaskStatusStr(pStatus->status));

    if (schProcessOnCbBegin(&pJob, &pTask, pStatus->queryId, pStatus->refId, pStatus->taskId)) {
      continue;
@ -1043,13 +1045,14 @@ int32_t schHandleExplainRes(SArray *pExplainRes) {
      continue;
    }

-    qDebug("QID:0x%" PRIx64 ",TID:0x%" PRIx64 ", begin to handle LOCAL explain rsp msg", localRsp->qId, localRsp->tId);
+    qDebug("QID:0x%" PRIx64 ",CID:0x%" PRIx64 ",TID:0x%" PRIx64 ", begin to handle LOCAL explain rsp msg",
+           localRsp->qId, localRsp->cId, localRsp->tId);

    pJob = NULL;
    (void)schAcquireJob(localRsp->rId, &pJob);
    if (NULL == pJob) {
-      qWarn("QID:0x%" PRIx64 ",TID:0x%" PRIx64 "job no exist, may be dropped, refId:0x%" PRIx64, localRsp->qId,
-            localRsp->tId, localRsp->rId);
+      qWarn("QID:0x%" PRIx64 ",CID:0x%" PRIx64 ",TID:0x%" PRIx64 "job no exist, may be dropped, refId:0x%" PRIx64,
+            localRsp->qId, localRsp->cId, localRsp->tId, localRsp->rId);
      SCH_ERR_JRET(TSDB_CODE_QRY_JOB_NOT_EXIST);
    }

@ -1068,8 +1071,8 @@ int32_t schHandleExplainRes(SArray *pExplainRes) {

    (void)schReleaseJob(pJob->refId);

-    qDebug("QID:0x%" PRIx64 ",TID:0x%" PRIx64 ", end to handle LOCAL explain rsp msg, code:%x", localRsp->qId,
-           localRsp->tId, code);
+    qDebug("QID:0x%" PRIx64 ",CID:0x%" PRIx64 ",TID:0x%" PRIx64 ", end to handle LOCAL explain rsp msg, code:%x",
+           localRsp->qId, localRsp->cId, localRsp->tId, code);

    SCH_ERR_JRET(code);

@ -1147,8 +1150,8 @@ int32_t schLaunchLocalTask(SSchJob *pJob, SSchTask *pTask) {
    }
  }

-  SCH_ERR_JRET(qWorkerProcessLocalQuery(schMgmt.queryMgmt, schMgmt.sId, pJob->queryId, pTask->taskId, pJob->refId,
-                                        pTask->execId, &qwMsg, explainRes));
+  SCH_ERR_JRET(qWorkerProcessLocalQuery(schMgmt.queryMgmt, schMgmt.sId, pJob->queryId, pTask->clientId, pTask->taskId,
+                                        pJob->refId, pTask->execId, &qwMsg, explainRes));

  if (SCH_IS_EXPLAIN_JOB(pJob)) {
    SCH_ERR_RET(schHandleExplainRes(explainRes));
@ -1407,8 +1410,8 @@ int32_t schExecLocalFetch(SSchJob *pJob, SSchTask *pTask) {
    }
  }

-  SCH_ERR_JRET(qWorkerProcessLocalFetch(schMgmt.queryMgmt, schMgmt.sId, pJob->queryId, pTask->taskId, pJob->refId,
-                                        pTask->execId, &pRsp, explainRes));
+  SCH_ERR_JRET(qWorkerProcessLocalFetch(schMgmt.queryMgmt, schMgmt.sId, pJob->queryId, pTask->clientId, pTask->taskId,
+                                        pJob->refId, pTask->execId, &pRsp, explainRes));

  if (SCH_IS_EXPLAIN_JOB(pJob)) {
    SCH_ERR_RET(schHandleExplainRes(explainRes));
--- a/source/libs/scheduler/src/schUtil.c
+++ b/source/libs/scheduler/src/schUtil.c
@ -293,6 +293,18 @@ void schCloseJobRef(void) {
  }
 }

+int32_t initClientId(void) {
+  int32_t code = taosGetSystemUUIDU64(&schMgmt.clientId);
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("failed to generate clientId since %s", tstrerror(code));
+    SCH_ERR_RET(code);
+  }
+  qInfo("initialize");
+  return TSDB_CODE_SUCCESS;
+}
+
+uint64_t getClientId(void) { return schMgmt.clientId; }
+
 uint64_t schGenTaskId(void) { return atomic_add_fetch_64(&schMgmt.taskId, 1); }

 #ifdef BUILD_NO_CALL
--- a/source/libs/stream/inc/streamBackendRocksdb.h
+++ b/source/libs/stream/inc/streamBackendRocksdb.h
@ -223,6 +223,7 @@ int32_t streamStateParTagGetKVByCur_rocksdb(SStreamStateCur* pCur, int64_t* pGro
 // parname cf
 int32_t streamStatePutParName_rocksdb(SStreamState* pState, int64_t groupId, const char tbname[TSDB_TABLE_NAME_LEN]);
 int32_t streamStateGetParName_rocksdb(SStreamState* pState, int64_t groupId, void** pVal);
+int32_t streamStateDeleteParName_rocksdb(SStreamState* pState, int64_t groupId);

 void streamStateDestroy_rocksdb(SStreamState* pState, bool remove);

--- a/source/libs/stream/src/streamBackendRocksdb.c
+++ b/source/libs/stream/src/streamBackendRocksdb.c
@ -4432,6 +4432,12 @@ int32_t streamStateGetParName_rocksdb(SStreamState* pState, int64_t groupId, voi
  return code;
 }

+int32_t streamStateDeleteParName_rocksdb(SStreamState* pState, int64_t groupId) {
+  int    code = 0;
+  STREAM_STATE_DEL_ROCKSDB(pState, "parname", &groupId);
+  return code;
+}
+
 int32_t streamDefaultPut_rocksdb(SStreamState* pState, const void* key, void* pVal, int32_t pVLen) {
  int code = 0;
  STREAM_STATE_PUT_ROCKSDB(pState, "default", key, pVal, pVLen);
--- a/Show More
+++ b/Show More