Merge branch '3.0' into fix/TD-22664-3.0

cmake/cmake.version

@@ -2,7 +2,7 @@
 IF (DEFINED VERNUMBER)
   SET(TD_VER_NUMBER ${VERNUMBER})
 ELSE ()
-  SET(TD_VER_NUMBER "3.0.2.5")
+  SET(TD_VER_NUMBER "3.0.2.6")
 ENDIF ()
 
 IF (DEFINED VERCOMPATIBLE)

cmake/taostools_CMakeLists.txt.in

@@ -2,7 +2,7 @@
 # taos-tools
 ExternalProject_Add(taos-tools
         GIT_REPOSITORY https://github.com/taosdata/taos-tools.git
-        GIT_TAG 61cbfd2
+        GIT_TAG 1e15545
         SOURCE_DIR "${TD_SOURCE_DIR}/tools/taos-tools"
         BINARY_DIR ""
         #BUILD_IN_SOURCE TRUE

docs/en/07-develop/07-tmq.mdx

@@ -222,7 +222,7 @@ A database including one supertable and two subtables is created as follows:
 ```sql
 DROP DATABASE IF EXISTS tmqdb;
 CREATE DATABASE tmqdb;
-CREATE TABLE tmqdb.stb (ts TIMESTAMP, c1 INT, c2 FLOAT, c3 VARCHAR(16) TAGS(t1 INT, t3 VARCHAR(16));
+CREATE TABLE tmqdb.stb (ts TIMESTAMP, c1 INT, c2 FLOAT, c3 VARCHAR(16)) TAGS(t1 INT, t3 VARCHAR(16));
 CREATE TABLE tmqdb.ctb0 USING tmqdb.stb TAGS(0, "subtable0");
 CREATE TABLE tmqdb.ctb1 USING tmqdb.stb TAGS(1, "subtable1");       
 INSERT INTO tmqdb.ctb0 VALUES(now, 0, 0, 'a0')(now+1s, 0, 0, 'a00');

docs/en/07-develop/_sub_java.mdx

@@ -1,11 +1,28 @@
-```java
+<Tabs defaultValue="native">
-{{#include docs/examples/java/src/main/java/com/taos/example/SubscribeDemo.java}}
+  <TabItem value="native" label="native connection">
-{{#include docs/examples/java/src/main/java/com/taos/example/MetersDeserializer.java}}
+
-{{#include docs/examples/java/src/main/java/com/taos/example/Meters.java}}
+    ```java
-```
+    {{#include docs/examples/java/src/main/java/com/taos/example/SubscribeDemo.java}}
-```java
+    ```
-{{#include docs/examples/java/src/main/java/com/taos/example/MetersDeserializer.java}}
+    ```java
-```
+    {{#include docs/examples/java/src/main/java/com/taos/example/MetersDeserializer.java}}
-```java
+    ```
-{{#include docs/examples/java/src/main/java/com/taos/example/Meters.java}}
+    ```java
-```
+    {{#include docs/examples/java/src/main/java/com/taos/example/Meters.java}}
+    ```
+
+  </TabItem>
+  <TabItem value="ws" label="WebSocket connection">
+
+    ```java
+    {{#include docs/examples/java/src/main/java/com/taos/example/WebsocketSubscribeDemo.java}}
+    ```
+    ```java
+    {{#include docs/examples/java/src/main/java/com/taos/example/MetersDeserializer.java}}
+    ```
+    ```java
+    {{#include docs/examples/java/src/main/java/com/taos/example/Meters.java}}
+    ```
+
+  </TabItem>
+</Tabs>

docs/en/14-reference/03-connector/04-java.mdx

@@ -696,6 +696,9 @@ TaosConsumer consumer = new TaosConsumer<>(config);
 - enable.auto.commit: Specifies whether to commit automatically.
 - group.id: consumer: Specifies the group that the consumer is in.
 - value.deserializer: To deserialize the results, you can inherit `com.taosdata.jdbc.tmq.ReferenceDeserializer` and specify the result set bean. You can also inherit `com.taosdata.jdbc.tmq.Deserializer` and perform custom deserialization based on the SQL result set.
+- td.connect.type: Specifies the type connect with TDengine, `jni` or `WebSocket`. default is `jni`
+- httpConnectTimeout：WebSocket connection timeout in milliseconds, the default value is 5000 ms. It only takes effect when using WebSocket type.
+- messageWaitTimeout：socket timeout in milliseconds, the default value is 10000 ms. It only takes effect when using WebSocket type.
 - For more information, see [Consumer Parameters](../../../develop/tmq).
 
 #### Subscribe to consume data
@@ -724,6 +727,11 @@ For more information, see [Data Subscription](../../../develop/tmq).
 
 ### Usage examples
 
+<Tabs defaultValue="native">
+<TabItem value="native" label="native connection">
+
+In addition to the native connection, the Java Connector also supports subscribing via websocket.
+
 ```java
 public abstract class ConsumerLoop {
     private final TaosConsumer<ResultBean> consumer;
@@ -795,6 +803,87 @@ public abstract class ConsumerLoop {
 }
 ```
 
+</TabItem>
+<TabItem value="ws" label="WebSocket connection">
+
+```java
+public abstract class ConsumerLoop {
+    private final TaosConsumer<ResultBean> consumer;
+    private final List<String> topics;
+    private final AtomicBoolean shutdown;
+    private final CountDownLatch shutdownLatch;
+
+    public ConsumerLoop() throws SQLException {
+        Properties config = new Properties();
+        config.setProperty("bootstrap.servers", "localhost:6041");
+        config.setProperty("td.connect.type", "ws");
+        config.setProperty("msg.with.table.name", "true");
+        config.setProperty("enable.auto.commit", "true");
+        config.setProperty("group.id", "group2");
+        config.setProperty("value.deserializer", "com.taosdata.jdbc.tmq.ConsumerTest.ConsumerLoop$ResultDeserializer");
+
+        this.consumer = new TaosConsumer<>(config);
+        this.topics = Collections.singletonList("topic_speed");
+        this.shutdown = new AtomicBoolean(false);
+        this.shutdownLatch = new CountDownLatch(1);
+    }
+
+    public abstract void process(ResultBean result);
+
+    public void pollData() throws SQLException {
+        try {
+            consumer.subscribe(topics);
+
+            while (!shutdown.get()) {
+                ConsumerRecords<ResultBean> records = consumer.poll(Duration.ofMillis(100));
+                for (ResultBean record : records) {
+                    process(record);
+                }
+            }
+            consumer.unsubscribe();
+        } finally {
+            consumer.close();
+            shutdownLatch.countDown();
+        }
+    }
+
+    public void shutdown() throws InterruptedException {
+        shutdown.set(true);
+        shutdownLatch.await();
+    }
+
+    public static class ResultDeserializer extends ReferenceDeserializer<ResultBean> {
+
+    }
+
+    public static class ResultBean {
+        private Timestamp ts;
+        private int speed;
+
+        public Timestamp getTs() {
+            return ts;
+        }
+
+        public void setTs(Timestamp ts) {
+            this.ts = ts;
+        }
+
+        public int getSpeed() {
+            return speed;
+        }
+
+        public void setSpeed(int speed) {
+            this.speed = speed;
+        }
+    }
+}
+```
+
+</TabItem>
+</Tabs>
+
+> **Note**: The value of value.deserializer should be adjusted based on the package path of the test environment.
+
 ### Use with connection pool
 
 #### HikariCP
@@ -878,8 +967,8 @@ The source code of the sample application is under `TDengine/examples/JDBC`:
 
 | taos-jdbcdriver version |                 major changes                  |
 | :---------------------: | :--------------------------------------------: |
-|       3.0.3        |  fix timestamp resolution error for REST connection in jdk17+ version    |
+|       3.1.0       |       JDBC REST connection supports subscription over WebSocket |
-|       3.0.1 - 3.0.2        |  fix the resultSet data is parsed incorrectly sometimes. 3.0.1 is compiled on JDK 11, you are advised to use 3.0.2 in the JDK 8 environment    |
+|       3.0.1 - 3.0.4        |  fix the resultSet data is parsed incorrectly sometimes. 3.0.1 is compiled on JDK 11, you are advised to use other version in the JDK 8 environment    |
 |       3.0.0        |   Support for TDengine 3.0    |
 |       2.0.42        |   fix wasNull interface return value in WebSocket connection  |
 |       2.0.41        |   fix decode method of username and password in REST connection |

docs/en/28-releases/01-tdengine.md

@@ -10,6 +10,10 @@ For TDengine 2.x installation packages by version, please visit [here](https://w
 
 import Release from "/components/ReleaseV3";
 
+## 3.0.2.6
+
+<Release type="tdengine" version="3.0.2.6" />
+
 ## 3.0.2.5
 
 <Release type="tdengine" version="3.0.2.5" />

docs/en/28-releases/02-tools.md

@@ -10,6 +10,10 @@ For other historical version installers, please visit [here](https://www.taosdat
 
 import Release from "/components/ReleaseV3";
 
+## 2.4.6
+
+<Release type="tools" version="2.4.6" />
+
 ## 2.4.3
 
 <Release type="tools" version="2.4.3" />

docs/examples/java/pom.xml

@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
 
@@ -17,13 +18,13 @@
   </properties>
 
   <dependencies>
-<!--    ANCHOR: dep-->
+    <!--    ANCHOR: dep-->
     <dependency>
       <groupId>com.taosdata.jdbc</groupId>
       <artifactId>taos-jdbcdriver</artifactId>
-      <version>3.0.0</version>
+      <version>3.1.0</version>
     </dependency>
-<!--    ANCHOR_END: dep-->
+    <!--    ANCHOR_END: dep-->
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>

docs/examples/java/src/main/java/com/taos/example/WebsocketSubscribeDemo.java

@@ -0,0 +1,79 @@
+package com.taos.example;
+
+import com.taosdata.jdbc.tmq.ConsumerRecords;
+import com.taosdata.jdbc.tmq.TMQConstants;
+import com.taosdata.jdbc.tmq.TaosConsumer;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.time.Duration;
+import java.util.Collections;
+import java.util.Properties;
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class WebsocketSubscribeDemo {
+    private static final String TOPIC = "tmq_topic_ws";
+    private static final String DB_NAME = "meters_ws";
+    private static final AtomicBoolean shutdown = new AtomicBoolean(false);
+
+    public static void main(String[] args) {
+        Timer timer = new Timer();
+        timer.schedule(new TimerTask() {
+            public void run() {
+                shutdown.set(true);
+            }
+        }, 3_000);
+        try {
+            // prepare
+            Class.forName("com.taosdata.jdbc.rs.RestfulDriver");
+            String jdbcUrl = "jdbc:TAOS-RS://127.0.0.1:6041/?user=root&password=taosdata&batchfetch=true";
+            try (Connection connection = DriverManager.getConnection(jdbcUrl);
+                    Statement statement = connection.createStatement()) {
+                statement.executeUpdate("drop topic if exists " + TOPIC);
+                statement.executeUpdate("drop database if exists " + DB_NAME);
+                statement.executeUpdate("create database " + DB_NAME);
+                statement.executeUpdate("use " + DB_NAME);
+                statement.executeUpdate(
+                        "CREATE TABLE `meters` (`ts` TIMESTAMP, `current` FLOAT, `voltage` INT) TAGS (`groupid` INT, `location` BINARY(24))");
+                statement.executeUpdate("CREATE TABLE `d0` USING `meters` TAGS(0, 'California.LosAngles')");
+                statement.executeUpdate("INSERT INTO `d0` values(now - 10s, 0.32, 116)");
+                statement.executeUpdate("INSERT INTO `d0` values(now - 8s, NULL, NULL)");
+                statement.executeUpdate(
+                        "INSERT INTO `d1` USING `meters` TAGS(1, 'California.SanFrancisco') values(now - 9s, 10.1, 119)");
+                statement.executeUpdate(
+                        "INSERT INTO `d1` values (now-8s, 10, 120) (now - 6s, 10, 119) (now - 4s, 11.2, 118)");
+                // create topic
+                statement.executeUpdate("create topic " + TOPIC + " as select * from meters");
+            }
+
+            // create consumer
+            Properties properties = new Properties();
+            properties.setProperty(TMQConstants.BOOTSTRAP_SERVERS, "127.0.0.1:6041");
+            properties.setProperty(TMQConstants.CONNECT_TYPE, "ws");
+            properties.setProperty(TMQConstants.MSG_WITH_TABLE_NAME, "true");
+            properties.setProperty(TMQConstants.ENABLE_AUTO_COMMIT, "true");
+            properties.setProperty(TMQConstants.GROUP_ID, "test");
+            properties.setProperty(TMQConstants.VALUE_DESERIALIZER,
+                    "com.taos.example.MetersDeserializer");
+
+            // poll data
+            try (TaosConsumer<Meters> consumer = new TaosConsumer<>(properties)) {
+                consumer.subscribe(Collections.singletonList(TOPIC));
+                while (!shutdown.get()) {
+                    ConsumerRecords<Meters> meters = consumer.poll(Duration.ofMillis(100));
+                    for (Meters meter : meters) {
+                        System.out.println(meter);
+                    }
+                }
+                consumer.unsubscribe();
+            }
+        } catch (ClassNotFoundException | SQLException e) {
+            e.printStackTrace();
+        }
+        timer.cancel();
+    }
+}

docs/examples/java/src/test/java/com/taos/test/TestAll.java

@@ -64,21 +64,15 @@ public class TestAll {
 
     @Test
     public void testSubscribe() {
-
-        Thread thread = new Thread(() -> {
-            try {
-                Thread.sleep(1000);
-                insertData();
-            } catch (SQLException e) {
-                e.printStackTrace();
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-        });
-        thread.start();
         SubscribeDemo.main(args);
     }
 
+
+    @Test
+    public void testSubscribeOverWebsocket() {
+        WebsocketSubscribeDemo.main(args);
+    }
+
     @Test
     public void testSchemaless() throws SQLException {
         LineProtocolExample.main(args);

docs/zh/07-develop/_sub_java.mdx

@@ -1,3 +1,6 @@
+<Tabs defaultValue="native">
+<TabItem value="native" label="本地连接">
+
 ```java
 {{#include docs/examples/java/src/main/java/com/taos/example/SubscribeDemo.java}}
 ```
@@ -7,3 +10,19 @@
 ```java
 {{#include docs/examples/java/src/main/java/com/taos/example/Meters.java}}
 ```
+
+</TabItem>
+<TabItem value="ws" label="WebSocket 连接">
+
+```java
+{{#include docs/examples/java/src/main/java/com/taos/example/WebsocketSubscribeDemo.java}}
+```
+```java
+{{#include docs/examples/java/src/main/java/com/taos/example/MetersDeserializer.java}}
+```
+```java
+{{#include docs/examples/java/src/main/java/com/taos/example/Meters.java}}
+```
+
+</TabItem>
+</Tabs>

docs/zh/08-connector/14-java.mdx

@@ -699,7 +699,10 @@ TaosConsumer consumer = new TaosConsumer<>(config);
 - enable.auto.commit: 是否允许自动提交。
 - group.id: consumer: 所在的 group。
 - value.deserializer: 结果集反序列化方法，可以继承 `com.taosdata.jdbc.tmq.ReferenceDeserializer`，并指定结果集 bean，实现反序列化。也可以继承 `com.taosdata.jdbc.tmq.Deserializer`，根据 SQL 的 resultSet 自定义反序列化方式。
-- 其他参数请参考：[Consumer 参数列表](../../../develop/tmq#创建-consumer-以及consumer-group)
+- td.connect.type: 连接方式。jni：表示使用动态库连接的方式，ws/WebSocket：表示使用 WebSocket 进行数据通信。默认为 jni 方式。
+- httpConnectTimeout：创建连接超时参数，单位 ms，默认为 5000 ms。仅在 WebSocket 连接下有效。
+- messageWaitTimeout：数据传输超时参数，单位 ms，默认为 10000 ms。仅在 WebSocket 连接下有效。
+其他参数请参考：[Consumer 参数列表](../../../develop/tmq#创建-consumer-以及consumer-group)
 
 #### 订阅消费数据
 
@@ -727,6 +730,9 @@ consumer.close()
 
 ### 使用示例如下：
 
+<Tabs defaultValue="native">
+<TabItem value="native" label="原生连接">
+
 ```java
 public abstract class ConsumerLoop {
     private final TaosConsumer<ResultBean> consumer;
@@ -798,6 +804,89 @@ public abstract class ConsumerLoop {
 }
 ```
 
+</TabItem>
+<TabItem value="ws" label="WebSocket 连接">
+
+除了原生的连接方式，Java 连接器还支持通过 WebSocket 订阅数据。
+
+```java
+public abstract class ConsumerLoop {
+    private final TaosConsumer<ResultBean> consumer;
+    private final List<String> topics;
+    private final AtomicBoolean shutdown;
+    private final CountDownLatch shutdownLatch;
+
+    public ConsumerLoop() throws SQLException {
+        Properties config = new Properties();
+        config.setProperty("bootstrap.servers", "localhost:6041");
+        config.setProperty("td.connect.type", "ws");
+        config.setProperty("msg.with.table.name", "true");
+        config.setProperty("enable.auto.commit", "true");
+        config.setProperty("group.id", "group2");
+        config.setProperty("value.deserializer", "com.taosdata.jdbc.tmq.ConsumerTest.ConsumerLoop$ResultDeserializer");
+
+        this.consumer = new TaosConsumer<>(config);
+        this.topics = Collections.singletonList("topic_speed");
+        this.shutdown = new AtomicBoolean(false);
+        this.shutdownLatch = new CountDownLatch(1);
+    }
+
+    public abstract void process(ResultBean result);
+
+    public void pollData() throws SQLException {
+        try {
+            consumer.subscribe(topics);
+
+            while (!shutdown.get()) {
+                ConsumerRecords<ResultBean> records = consumer.poll(Duration.ofMillis(100));
+                for (ResultBean record : records) {
+                    process(record);
+                }
+            }
+            consumer.unsubscribe();
+        } finally {
+            consumer.close();
+            shutdownLatch.countDown();
+        }
+    }
+
+    public void shutdown() throws InterruptedException {
+        shutdown.set(true);
+        shutdownLatch.await();
+    }
+
+    public static class ResultDeserializer extends ReferenceDeserializer<ResultBean> {
+
+    }
+
+    public static class ResultBean {
+        private Timestamp ts;
+        private int speed;
+
+        public Timestamp getTs() {
+            return ts;
+        }
+
+        public void setTs(Timestamp ts) {
+            this.ts = ts;
+        }
+
+        public int getSpeed() {
+            return speed;
+        }
+
+        public void setSpeed(int speed) {
+            this.speed = speed;
+        }
+    }
+}
+```
+
+</TabItem>
+</Tabs>
+
+> **注意**：这里的 value.deserializer 配置参数值应该根据测试环境的包路径做相应的调整。
+
 ### 与连接池使用
 
 #### HikariCP
@@ -881,8 +970,8 @@ public static void main(String[] args) throws Exception {
 
 | taos-jdbcdriver 版本 |            主要变化            |
 | :------------------: | :----------------------------: |
-|       3.0.3        |  修复 REST 连接在 jdk17+ 版本时间戳解析错误问题    |
+|       3.1.0           |   WebSocket 连接支持订阅功能      |
-|       3.0.1 - 3.0.2        |  修复一些情况下结果集数据解析错误的问题。3.0.1 在 JDK 11 环境编译，JDK 8 环境下建议使用 3.0.2 版本    |
+|       3.0.1 - 3.0.4        |  修复一些情况下结果集数据解析错误的问题。3.0.1 在 JDK 11 环境编译，JDK 8 环境下建议使用其他版本    |
 |       3.0.0        |   支持 TDengine 3.0    |
 |       2.0.42        |   修在 WebSocket 连接中 wasNull 接口返回值  |
 |       2.0.41        |   修正 REST 连接中用户名和密码转码方式    |

docs/zh/28-releases/01-tdengine.md

@@ -10,6 +10,10 @@ TDengine 2.x 各版本安装包请访问[这里](https://www.taosdata.com/all-do
 
 import Release from "/components/ReleaseV3";
 
+## 3.0.2.6
+
+<Release type="tdengine" version="3.0.2.6" />
+
 ## 3.0.2.5
 
 <Release type="tdengine" version="3.0.2.5" />

docs/zh/28-releases/02-tools.md

@@ -10,6 +10,10 @@ taosTools 各版本安装包下载链接如下：
 
 import Release from "/components/ReleaseV3";
 
+## 2.4.6
+
+<Release type="tools" version="2.4.6" />
+
 ## 2.4.3
 
 <Release type="tools" version="2.4.3" />

examples/c/tmq.c

@@ -191,21 +191,45 @@ tmq_t* build_consumer() {
   tmq_conf_res_t code;
   tmq_conf_t*    conf = tmq_conf_new();
   code = tmq_conf_set(conf, "enable.auto.commit", "true");
-  if (TMQ_CONF_OK != code) return NULL;
+  if (TMQ_CONF_OK != code) {
+    tmq_conf_destroy(conf);
+    return NULL;
+  }
   code = tmq_conf_set(conf, "auto.commit.interval.ms", "1000");
-  if (TMQ_CONF_OK != code) return NULL;
+  if (TMQ_CONF_OK != code) {
+    tmq_conf_destroy(conf);
+    return NULL;
+  }
   code = tmq_conf_set(conf, "group.id", "cgrpName");
-  if (TMQ_CONF_OK != code) return NULL;
+  if (TMQ_CONF_OK != code) {
+    tmq_conf_destroy(conf);
+    return NULL;
+  }
   code = tmq_conf_set(conf, "client.id", "user defined name");
-  if (TMQ_CONF_OK != code) return NULL;
+  if (TMQ_CONF_OK != code) {
+    tmq_conf_destroy(conf);
+    return NULL;
+  }
   code = tmq_conf_set(conf, "td.connect.user", "root");
-  if (TMQ_CONF_OK != code) return NULL;
+  if (TMQ_CONF_OK != code) {
+    tmq_conf_destroy(conf);
+    return NULL;
+  }
   code = tmq_conf_set(conf, "td.connect.pass", "taosdata");
-  if (TMQ_CONF_OK != code) return NULL;
+  if (TMQ_CONF_OK != code) {
+    tmq_conf_destroy(conf);
+    return NULL;
+  }
   code = tmq_conf_set(conf, "auto.offset.reset", "earliest");
-  if (TMQ_CONF_OK != code) return NULL;
+  if (TMQ_CONF_OK != code) {
+    tmq_conf_destroy(conf);
+    return NULL;
+  }
   code = tmq_conf_set(conf, "experimental.snapshot.enable", "false");
-  if (TMQ_CONF_OK != code) return NULL;
+  if (TMQ_CONF_OK != code) {
+    tmq_conf_destroy(conf);
+    return NULL;
+  }
 
   tmq_conf_set_auto_commit_cb(conf, tmq_commit_cb_print, NULL);
 

include/common/tcommon.h

@@ -205,7 +205,7 @@ typedef struct SDataBlockInfo {
   STimeWindow calWin;     // used for stream, do not serialize
   TSKEY       watermark;  // used for stream
 
-  char    parTbName[TSDB_TABLE_NAME_LEN];  // used for stream partition
+  char parTbName[TSDB_TABLE_NAME_LEN];  // used for stream partition
 } SDataBlockInfo;
 
 typedef struct SSDataBlock {
@@ -291,7 +291,6 @@ typedef struct STableBlockDistInfo {
   uint16_t numOfFiles;
   uint32_t numOfTables;
   uint32_t numOfBlocks;
-  uint32_t numOfVgroups;
   uint64_t totalSize;
   uint64_t totalRows;
   int32_t  maxRows;
@@ -301,6 +300,7 @@ typedef struct STableBlockDistInfo {
   int32_t  firstSeekTimeUs;
   uint32_t numOfInmemRows;
   uint32_t numOfSmallBlocks;
+  uint32_t numOfVgroups;
   int32_t  blockRowsHisto[20];
 } STableBlockDistInfo;
 
@@ -341,7 +341,7 @@ typedef struct SExprInfo {
 
 typedef struct {
   const char* key;
-  size_t     keyLen;
+  size_t      keyLen;
   uint8_t     type;
   union {
     const char* value;
@@ -385,9 +385,9 @@ typedef struct STUidTagInfo {
 #define TABLE_NAME_COLUMN_INDEX         6
 
 // stream create table block column
-#define UD_TABLE_NAME_COLUMN_INDEX     0
+#define UD_TABLE_NAME_COLUMN_INDEX 0
-#define UD_GROUPID_COLUMN_INDEX        1
+#define UD_GROUPID_COLUMN_INDEX    1
-#define UD_TAG_COLUMN_INDEX            2
+#define UD_TAG_COLUMN_INDEX        2
 
 #ifdef __cplusplus
 }

include/common/tmsg.h

@@ -2850,7 +2850,7 @@ typedef struct {
   char   dbFName[TSDB_DB_FNAME_LEN];
   char   stbName[TSDB_TABLE_NAME_LEN];
   char   colName[TSDB_COL_NAME_LEN];
-  char   idxName[TSDB_COL_NAME_LEN];
+  char   idxName[TSDB_INDEX_FNAME_LEN];
   int8_t idxType;
 } SCreateTagIndexReq;
 

include/os/osMemory.h

@@ -29,6 +29,7 @@ extern "C" {
 #define calloc  CALLOC_FUNC_TAOS_FORBID
 #define realloc REALLOC_FUNC_TAOS_FORBID
 #define free    FREE_FUNC_TAOS_FORBID
+#define strdup  STRDUP_FUNC_TAOS_FORBID
 #endif // ifndef ALLOW_FORBID_FUNC
 
 #endif // if !defined(WINDOWS)
@@ -38,7 +39,7 @@ int32_t taosMemoryDbgInitRestore();
 void   *taosMemoryMalloc(int64_t size);
 void   *taosMemoryCalloc(int64_t num, int64_t size);
 void   *taosMemoryRealloc(void *ptr, int64_t size);
-void   *taosMemoryStrDup(const char *ptr);
+char   *taosStrdup(const char *ptr);
 void    taosMemoryFree(void *ptr);
 int64_t taosMemorySize(void *ptr);
 void    taosPrintBackTrace();

packaging/docker/DockerfileCloud

@@ -1,30 +0,0 @@
-FROM ubuntu:18.04
-
-WORKDIR /root
-
-ARG pkgFile
-ARG dirName
-ARG cpuType
-RUN echo ${pkgFile} && echo ${dirName}
-
-RUN apt update
-RUN apt install -y curl
-
-COPY ${pkgFile} /root/
-ENV TINI_VERSION v0.19.0
-ENV TAOS_DISABLE_ADAPTER 1
-ADD https://github.com/krallin/tini/releases/download/${TINI_VERSION}/tini-${cpuType} /tini
-ENV DEBIAN_FRONTEND=noninteractive
-WORKDIR /root/
-RUN tar -zxf ${pkgFile} && cd /root/${dirName}/ && /bin/bash install.sh -e no && cd /root && rm /root/${pkgFile} && rm -rf /root/${dirName} && apt-get update && apt-get install -y locales tzdata netcat && locale-gen en_US.UTF-8 && apt-get clean && rm -rf /var/lib/apt/lists/ && chmod +x /tini
-
-ENV LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/usr/lib" \
-    LC_CTYPE=en_US.UTF-8 \
-    LANG=en_US.UTF-8 \
-    LC_ALL=en_US.UTF-8
-COPY ./run.sh /usr/bin/
-COPY ./bin/* /usr/bin/
-
-ENTRYPOINT ["/tini", "--", "/usr/bin/entrypoint.sh"]
-CMD ["bash", "-c", "/usr/bin/run.sh"]
-VOLUME [ "/var/lib/taos", "/var/log/taos" ]

source/client/src/clientHb.c

@@ -758,7 +758,7 @@ static void *hbThreadFunc(void *param) {
       pInfo->msgInfo.pData = buf;
       pInfo->msgInfo.len = tlen;
       pInfo->msgType = TDMT_MND_HEARTBEAT;
-      pInfo->param = strdup(pAppHbMgr->key);
+      pInfo->param = taosStrdup(pAppHbMgr->key);
       pInfo->paramFreeFp = taosMemoryFree;
       pInfo->requestId = generateRequestId();
       pInfo->requestObjRefId = 0;
@@ -826,7 +826,7 @@ SAppHbMgr *appHbMgrInit(SAppInstInfo *pAppInstInfo, char *key) {
   pAppHbMgr->connKeyCnt = 0;
   pAppHbMgr->reportCnt = 0;
   pAppHbMgr->reportBytes = 0;
-  pAppHbMgr->key = strdup(key);
+  pAppHbMgr->key = taosStrdup(key);
 
   // init app info
   pAppHbMgr->pAppInstInfo = pAppInstInfo;

source/client/src/clientImpl.c

@@ -52,7 +52,7 @@ static bool validateDbName(const char* db) { return stringLengthCheck(db, TSDB_D
 static char* getClusterKey(const char* user, const char* auth, const char* ip, int32_t port) {
   char key[512] = {0};
   snprintf(key, sizeof(key), "%s:%s:%s:%d", user, auth, ip, port);
-  return strdup(key);
+  return taosStrdup(key);
 }
 
 bool chkRequestKilled(void* param) {

source/client/src/clientTmq.c

@@ -330,15 +330,15 @@ tmq_conf_res_t tmq_conf_set(tmq_conf_t* conf, const char* key, const char* value
   }
 
   if (strcmp(key, "td.connect.ip") == 0) {
-    conf->ip = strdup(value);
+    conf->ip = taosStrdup(value);
     return TMQ_CONF_OK;
   }
   if (strcmp(key, "td.connect.user") == 0) {
-    conf->user = strdup(value);
+    conf->user = taosStrdup(value);
     return TMQ_CONF_OK;
   }
   if (strcmp(key, "td.connect.pass") == 0) {
-    conf->pass = strdup(value);
+    conf->pass = taosStrdup(value);
     return TMQ_CONF_OK;
   }
   if (strcmp(key, "td.connect.port") == 0) {
@@ -346,7 +346,7 @@ tmq_conf_res_t tmq_conf_set(tmq_conf_t* conf, const char* key, const char* value
     return TMQ_CONF_OK;
   }
   if (strcmp(key, "td.connect.db") == 0) {
-    /*conf->db = strdup(value);*/
+    /*conf->db = taosStrdup(value);*/
     return TMQ_CONF_OK;
   }
 
@@ -361,7 +361,7 @@ tmq_list_t* tmq_list_new() {
 int32_t tmq_list_append(tmq_list_t* list, const char* src) {
   SArray* container = &list->container;
   if (src == NULL || src[0] == 0) return -1;
-  char* topic = strdup(src);
+  char* topic = taosStrdup(src);
   if (topic[0] != '`') {
     strtolower(topic, src);
   }

source/common/src/tdatablock.c

@@ -1033,6 +1033,7 @@ SHelper* createTupleIndex_rv(int32_t numOfRows, SArray* pOrderInfo, SSDataBlock*
     offset += pInfo->pColData->info.bytes;
   }
 
+  taosMemoryFree(buf);
   return phelper;
 }
 
@@ -2370,7 +2371,11 @@ _end:
   taosArrayDestroy(pVals);
   if (terrno != 0) {
     *ppReq = NULL;
-    if (pReq) tDestroySSubmitReq2(pReq, TSDB_MSG_FLG_ENCODE);
+    if (pReq) {
+      tDestroySSubmitReq2(pReq, TSDB_MSG_FLG_ENCODE);
+      taosMemoryFreeClear(pReq);
+    }
+
     return TSDB_CODE_FAILED;
   }
   *ppReq = pReq;

source/dnode/mgmt/mgmt_vnode/src/vmInt.c

@@ -53,7 +53,7 @@ int32_t vmOpenVnode(SVnodeMgmt *pMgmt, SWrapperCfg *pCfg, SVnode *pImpl) {
   pVnode->vgVersion = pCfg->vgVersion;
   pVnode->refCount = 0;
   pVnode->dropped = 0;
-  pVnode->path = tstrdup(pCfg->path);
+  pVnode->path = taosStrdup(pCfg->path);
   pVnode->pImpl = pImpl;
 
   if (pVnode->path == NULL) {

source/dnode/mgmt/node_mgmt/src/dmMgmt.c

@@ -124,7 +124,7 @@ int32_t dmInitDnode(SDnode *pDnode) {
     taosThreadRwlockInit(&pWrapper->lock, NULL);
 
     snprintf(path, sizeof(path), "%s%s%s", tsDataDir, TD_DIRSEP, pWrapper->name);
-    pWrapper->path = strdup(path);
+    pWrapper->path = taosStrdup(path);
     if (pWrapper->path == NULL) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       goto _OVER;

source/dnode/mgmt/node_mgmt/src/dmTransport.c

@@ -93,18 +93,30 @@ static void dmProcessRpcMsg(SDnode *pDnode, SRpcMsg *pRpc, SEpSet *pEpSet) {
       break;
   }
 
-  if (pDnode->status != DND_STAT_RUNNING) {
+/*
-    if (pRpc->msgType == TDMT_DND_SERVER_STATUS) {
+pDnode is null, TD-22618
-      dmProcessServerStartupStatus(pDnode, pRpc);
+at trans.c line 91
-      return;
+before this line, dmProcessRpcMsg callback is set
-    } else {
+after this line, parent is set
-      if (pDnode->status == DND_STAT_INIT) {
+so when dmProcessRpcMsg is called, pDonde is still null.
-        terrno = TSDB_CODE_APP_IS_STARTING;
+*/
+  if (pDnode != NULL){
+    if(pDnode->status != DND_STAT_RUNNING) {
+      if (pRpc->msgType == TDMT_DND_SERVER_STATUS) {
+        dmProcessServerStartupStatus(pDnode, pRpc);
+        return;
       } else {
-        terrno = TSDB_CODE_APP_IS_STOPPING;
+        if (pDnode->status == DND_STAT_INIT) {
+          terrno = TSDB_CODE_APP_IS_STARTING;
+        } else {
+          terrno = TSDB_CODE_APP_IS_STOPPING;
+        }
+        goto _OVER;
       }
-      goto _OVER;
     }   
+  } else {
+    terrno = TSDB_CODE_APP_IS_STARTING;
+    goto _OVER;
   }
 
   if (pRpc->pCont == NULL && (IsReq(pRpc) || pRpc->contLen != 0)) {

source/dnode/mnode/impl/src/mndConsumer.c

@@ -577,7 +577,7 @@ static int32_t mndProcessSubscribeReq(SRpcMsg *pMsg) {
     subscribe.topicNames = NULL;
 
     for (int32_t i = 0; i < newTopicNum; i++) {
-      char *newTopicCopy = strdup(taosArrayGetP(newSub, i));
+      char *newTopicCopy = taosStrdup(taosArrayGetP(newSub, i));
       taosArrayPush(pConsumerNew->assignedTopics, &newTopicCopy);
     }
 
@@ -605,7 +605,7 @@ static int32_t mndProcessSubscribeReq(SRpcMsg *pMsg) {
     pConsumerNew->updateType = CONSUMER_UPDATE__MODIFY;
 
     for (int32_t i = 0; i < newTopicNum; i++) {
-      char *newTopicCopy = strdup(taosArrayGetP(newSub, i));
+      char *newTopicCopy = taosStrdup(taosArrayGetP(newSub, i));
       taosArrayPush(pConsumerNew->assignedTopics, &newTopicCopy);
     }
 
@@ -617,12 +617,12 @@ static int32_t mndProcessSubscribeReq(SRpcMsg *pMsg) {
     int32_t i = 0, j = 0;
     while (i < oldTopicNum || j < newTopicNum) {
       if (i >= oldTopicNum) {
-        char *newTopicCopy = strdup(taosArrayGetP(newSub, j));
+        char *newTopicCopy = taosStrdup(taosArrayGetP(newSub, j));
         taosArrayPush(pConsumerNew->rebNewTopics, &newTopicCopy);
         j++;
         continue;
       } else if (j >= newTopicNum) {
-        char *oldTopicCopy = strdup(taosArrayGetP(pConsumerOld->currentTopics, i));
+        char *oldTopicCopy = taosStrdup(taosArrayGetP(pConsumerOld->currentTopics, i));
         taosArrayPush(pConsumerNew->rebRemovedTopics, &oldTopicCopy);
         i++;
         continue;
@@ -635,12 +635,12 @@ static int32_t mndProcessSubscribeReq(SRpcMsg *pMsg) {
           j++;
           continue;
         } else if (comp < 0) {
-          char *oldTopicCopy = strdup(oldTopic);
+          char *oldTopicCopy = taosStrdup(oldTopic);
           taosArrayPush(pConsumerNew->rebRemovedTopics, &oldTopicCopy);
           i++;
           continue;
         } else {
-          char *newTopicCopy = strdup(newTopic);
+          char *newTopicCopy = taosStrdup(newTopic);
           taosArrayPush(pConsumerNew->rebNewTopics, &newTopicCopy);
           j++;
           continue;
@@ -808,7 +808,7 @@ static int32_t mndConsumerActionUpdate(SSdb *pSdb, SMqConsumerObj *pOldConsumer,
     int32_t sz = taosArrayGetSize(pOldConsumer->currentTopics);
     /*pOldConsumer->rebRemovedTopics = taosArrayInit(sz, sizeof(void *));*/
     for (int32_t i = 0; i < sz; i++) {
-      char *topic = strdup(taosArrayGetP(pOldConsumer->currentTopics, i));
+      char *topic = taosStrdup(taosArrayGetP(pOldConsumer->currentTopics, i));
       taosArrayPush(pOldConsumer->rebRemovedTopics, &topic);
     }
 
@@ -821,7 +821,7 @@ static int32_t mndConsumerActionUpdate(SSdb *pSdb, SMqConsumerObj *pOldConsumer,
 
     int32_t sz = taosArrayGetSize(pOldConsumer->assignedTopics);
     for (int32_t i = 0; i < sz; i++) {
-      char *topic = strdup(taosArrayGetP(pOldConsumer->assignedTopics, i));
+      char *topic = taosStrdup(taosArrayGetP(pOldConsumer->assignedTopics, i));
       taosArrayPush(pOldConsumer->rebNewTopics, &topic);
     }
 
@@ -837,7 +837,7 @@ static int32_t mndConsumerActionUpdate(SSdb *pSdb, SMqConsumerObj *pOldConsumer,
     /*A(taosArrayGetSize(pNewConsumer->rebNewTopics) == 1);*/
     /*A(taosArrayGetSize(pNewConsumer->rebRemovedTopics) == 0);*/
 
-    char *addedTopic = strdup(taosArrayGetP(pNewConsumer->rebNewTopics, 0));
+    char *addedTopic = taosStrdup(taosArrayGetP(pNewConsumer->rebNewTopics, 0));
     // not exist in current topic
 
     bool existing = false;
@@ -864,6 +864,8 @@ static int32_t mndConsumerActionUpdate(SSdb *pSdb, SMqConsumerObj *pOldConsumer,
     if (!existing) {
       taosArrayPush(pOldConsumer->currentTopics, &addedTopic);
       taosArraySort(pOldConsumer->currentTopics, taosArrayCompareString);
+    } else {
+      taosMemoryFree(addedTopic);
     }
 
     // set status

source/dnode/mnode/impl/src/mndDef.c

@@ -181,7 +181,7 @@ SMqVgEp *tCloneSMqVgEp(const SMqVgEp *pVgEp) {
   SMqVgEp *pVgEpNew = taosMemoryMalloc(sizeof(SMqVgEp));
   if (pVgEpNew == NULL) return NULL;
   pVgEpNew->vgId = pVgEp->vgId;
-  pVgEpNew->qmsg = strdup(pVgEp->qmsg);
+  pVgEpNew->qmsg = taosStrdup(pVgEp->qmsg);
   pVgEpNew->epSet = pVgEp->epSet;
   return pVgEpNew;
 }

source/dnode/mnode/impl/src/mndDump.c

@@ -629,7 +629,7 @@ void mndDumpSdb() {
   }
   taosWriteFile(pFile, pCont, contLen);
   taosWriteFile(pFile, "\n", 1);
-  taosFsyncFile(pFile);
+  UNUSED(taosFsyncFile(pFile));
   taosCloseFile(&pFile);
   tjsonDelete(json);
   taosMemoryFree(pCont);

source/dnode/mnode/impl/src/mndMain.c

@@ -322,7 +322,7 @@ static void mndCleanupTimer(SMnode *pMnode) {
 }
 
 static int32_t mndCreateDir(SMnode *pMnode, const char *path) {
-  pMnode->path = strdup(path);
+  pMnode->path = taosStrdup(path);
   if (pMnode->path == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -716,7 +716,7 @@ int32_t mndProcessRpcMsg(SRpcMsg *pMsg) {
   } else if (code == 0) {
     mGTrace("msg:%p, successfully processed", pMsg);
   } else {
-    mGError("msg:%p, failed to process since %s, app:%p type:%s", pMsg, terrstr(), pMsg->info.ahandle,
+    mGError("msg:%p, failed to process since %s, app:%p type:%s", pMsg, tstrerror(code), pMsg->info.ahandle,
             TMSG_INFO(pMsg->msgType));
   }
 

source/dnode/mnode/impl/src/mndScheduler.c

@@ -587,7 +587,7 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib
         return -1;
       }
     } else {
-      pVgEp->qmsg = strdup("");
+      pVgEp->qmsg = taosStrdup("");
     }
 
     sdbRelease(pSdb, pVgroup);

source/dnode/mnode/impl/src/mndSma.c

@@ -552,14 +552,14 @@ static int32_t mndCreateSma(SMnode *pMnode, SRpcMsg *pReq, SMCreateSmaReq *pCrea
   streamObj.sourceDbUid = pDb->uid;
   streamObj.targetDbUid = pDb->uid;
   streamObj.version = 1;
-  streamObj.sql = strdup(pCreate->sql);
+  streamObj.sql = taosStrdup(pCreate->sql);
   streamObj.smaId = smaObj.uid;
   streamObj.watermark = pCreate->watermark;
   streamObj.deleteMark = pCreate->deleteMark;
   streamObj.fillHistory = STREAM_FILL_HISTORY_ON;
   streamObj.trigger = STREAM_TRIGGER_WINDOW_CLOSE;
   streamObj.triggerParam = pCreate->maxDelay;
-  streamObj.ast = strdup(smaObj.ast);
+  streamObj.ast = taosStrdup(smaObj.ast);
 
   // check the maxDelay
   if (streamObj.triggerParam < TSDB_MIN_ROLLUP_MAX_DELAY) {

source/dnode/mnode/impl/src/mndStb.c

@@ -893,7 +893,7 @@ static int32_t mndProcessTtlTimer(SRpcMsg *pReq) {
 
 static int32_t mndFindSuperTableTagIndex(const SStbObj *pStb, const char *tagName) {
   for (int32_t tag = 0; tag < pStb->numOfTags; tag++) {
-    if (strcasecmp(pStb->pTags[tag].name, tagName) == 0) {
+    if (strcmp(pStb->pTags[tag].name, tagName) == 0) {
       return tag;
     }
   }
@@ -903,7 +903,7 @@ static int32_t mndFindSuperTableTagIndex(const SStbObj *pStb, const char *tagNam
 
 static int32_t mndFindSuperTableColumnIndex(const SStbObj *pStb, const char *colName) {
   for (int32_t col = 0; col < pStb->numOfColumns; col++) {
-    if (strcasecmp(pStb->pColumns[col].name, colName) == 0) {
+    if (strcmp(pStb->pColumns[col].name, colName) == 0) {
       return col;
     }
   }
@@ -1734,7 +1734,7 @@ static int32_t mndBuildStbCfgImp(SDbObj *pDb, SStbObj *pStb, const char *tbName,
   pRsp->ttl = pStb->ttl;
   pRsp->commentLen = pStb->commentLen;
   if (pStb->commentLen > 0) {
-    pRsp->pComment = strdup(pStb->comment);
+    pRsp->pComment = taosStrdup(pStb->comment);
   }
 
   for (int32_t i = 0; i < pStb->numOfColumns; ++i) {

source/dnode/mnode/impl/src/mndStream.c

@@ -354,7 +354,7 @@ static int32_t mndBuildStreamObjFromCreateReq(SMnode *pMnode, SStreamObj *pObj,
     int32_t dataIndex = 0;
     for (int16_t i = 0; i < pObj->outputSchema.nCols; i++) {
       SColLocation *pos = taosArrayGet(pCreate->fillNullCols, nullIndex);
-      if (i < pos->slotId) {
+      if (nullIndex >= numOfNULL || i < pos->slotId) {
         pFullSchema[i].bytes = pObj->outputSchema.pSchema[dataIndex].bytes;
         pFullSchema[i].colId = i + 1;  // pObj->outputSchema.pSchema[dataIndex].colId;
         pFullSchema[i].flags = pObj->outputSchema.pSchema[dataIndex].flags;
@@ -722,8 +722,10 @@ static int32_t mndProcessCreateStreamReq(SRpcMsg *pReq) {
   mInfo("trans:%d, used to create stream:%s", pTrans->id, createStreamReq.name);
 
   mndTransSetDbName(pTrans, createStreamReq.sourceDB, streamObj.targetDb);
-  if (mndTrancCheckConflict(pMnode, pTrans) != 0) goto _OVER;
+  if (mndTrancCheckConflict(pMnode, pTrans) != 0) {
-
+    mndTransDrop(pTrans);
+    goto _OVER;
+  }
   // create stb for stream
   if (createStreamReq.createStb == STREAM_CREATE_STABLE_TRUE &&
       mndCreateStbForStream(pMnode, pTrans, &streamObj, pReq->info.conn.user) < 0) {

source/dnode/mnode/impl/src/mndTopic.c

@@ -379,7 +379,7 @@ static int32_t mndCreateTopic(SMnode *pMnode, SRpcMsg *pReq, SCMCreateTopicReq *
   topicObj.uid = mndGenerateUid(pCreate->name, strlen(pCreate->name));
   topicObj.dbUid = pDb->uid;
   topicObj.version = 1;
-  topicObj.sql = strdup(pCreate->sql);
+  topicObj.sql = taosStrdup(pCreate->sql);
   topicObj.sqlLen = strlen(pCreate->sql) + 1;
   topicObj.subType = pCreate->subType;
   topicObj.withMeta = pCreate->withMeta;
@@ -392,7 +392,7 @@ static int32_t mndCreateTopic(SMnode *pMnode, SRpcMsg *pReq, SCMCreateTopicReq *
   }
 
   if (pCreate->subType == TOPIC_SUB_TYPE__COLUMN) {
-    topicObj.ast = strdup(pCreate->ast);
+    topicObj.ast = taosStrdup(pCreate->ast);
     topicObj.astLen = strlen(pCreate->ast) + 1;
 
     qDebugL("ast %s", topicObj.ast);

source/dnode/mnode/impl/test/trans/trans2.cpp

@@ -124,7 +124,7 @@ class MndTestTrans2 : public ::testing::Test {
     mndTransAppendUndolog(pTrans, pUndoRaw);
     sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED);
 
-    char *param = strdup("====> test log <=====");
+    char *param = taosStrdup("====> test log <=====");
     mndTransSetCb(pTrans, TRANS_START_FUNC_TEST, TRANS_STOP_FUNC_TEST, param, strlen(param) + 1);
 
     if (pDb != NULL) {
@@ -157,7 +157,7 @@ class MndTestTrans2 : public ::testing::Test {
     mndTransAppendUndolog(pTrans, pUndoRaw);
     sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED);
 
-    char *param = strdup("====> test action <=====");
+    char *param = taosStrdup("====> test action <=====");
     mndTransSetCb(pTrans, TRANS_START_FUNC_TEST, TRANS_STOP_FUNC_TEST, param, strlen(param) + 1);
 
     {
@@ -229,7 +229,7 @@ class MndTestTrans2 : public ::testing::Test {
     mndTransAppendUndolog(pTrans, pUndoRaw);
     sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED);
 
-    char *param = strdup("====> test log <=====");
+    char *param = taosStrdup("====> test log <=====");
     mndTransSetCb(pTrans, TRANS_START_FUNC_TEST, TRANS_STOP_FUNC_TEST, param, strlen(param) + 1);
 
     int32_t code = mndTransPrepare(pMnode, pTrans);

source/dnode/mnode/sdb/src/sdb.c

@@ -30,9 +30,9 @@ SSdb *sdbInit(SSdbOpt *pOption) {
 
   char path[PATH_MAX + 100] = {0};
   snprintf(path, sizeof(path), "%s%sdata", pOption->path, TD_DIRSEP);
-  pSdb->currDir = strdup(path);
+  pSdb->currDir = taosStrdup(path);
   snprintf(path, sizeof(path), "%s%stmp", pOption->path, TD_DIRSEP);
-  pSdb->tmpDir = strdup(path);
+  pSdb->tmpDir = taosStrdup(path);
   if (pSdb->currDir == NULL || pSdb->tmpDir == NULL) {
     sdbCleanup(pSdb);
     terrno = TSDB_CODE_OUT_OF_MEMORY;

source/dnode/mnode/sdb/src/sdbFile.c

@@ -521,7 +521,7 @@ static SSdbIter *sdbCreateIter(SSdb *pSdb) {
 
   char name[PATH_MAX + 100] = {0};
   snprintf(name, sizeof(name), "%s%ssdb.data.%" PRIu64, pSdb->tmpDir, TD_DIRSEP, (uint64_t)pIter);
-  pIter->name = strdup(name);
+  pIter->name = taosStrdup(name);
   if (pIter->name == NULL) {
     taosMemoryFree(pIter);
     terrno = TSDB_CODE_OUT_OF_MEMORY;

source/dnode/snode/src/snode.c

@@ -104,7 +104,7 @@ SSnode *sndOpen(const char *path, const SSnodeOpt *pOption) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
   }
-  pSnode->path = strdup(path);
+  pSnode->path = taosStrdup(path);
   if (pSnode->path == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     goto FAIL;

source/dnode/vnode/src/meta/metaQuery.c

@@ -706,7 +706,7 @@ int32_t metaGetTbTSchemaEx(SMeta *pMeta, tb_uid_t suid, tb_uid_t uid, int32_t sv
     }
   }
 
-  if (ASSERTS(sver > 0, __FILE__, __LINE__, "failed to get table schema version: %d", sver)) {
+  if (ASSERTS(sver > 0, "failed to get table schema version: %d", sver)) {
     code = TSDB_CODE_NOT_FOUND;
     goto _exit;
   }

source/dnode/vnode/src/meta/metaSnapshot.c

@@ -252,7 +252,7 @@ static void saveSuperTableInfoForChildTable(SMetaEntry* me, SHashObj* suidInfo)
     return;
   }
   STableInfoForChildTable dataTmp = {0};
-  dataTmp.tableName = strdup(me->name);
+  dataTmp.tableName = taosStrdup(me->name);
 
   dataTmp.schemaRow = tCloneSSchemaWrapper(&me->stbEntry.schemaRow);
   dataTmp.tagRow = tCloneSSchemaWrapper(&me->stbEntry.schemaTag);

source/dnode/vnode/src/sma/smaRollup.c

@@ -262,7 +262,7 @@ static int32_t tdSetRSmaInfoItemParams(SSma *pSma, SRSmaParam *param, SRSmaStat
     // set the backend of stream state
     tdRSmaQTaskInfoGetFullPathEx(TD_VID(pVnode), pRSmaInfo->suid, idx + 1, tfsGetPrimaryPath(pVnode->pTfs), taskInfDir);
     if (!taosCheckExistFile(taskInfDir)) {
-      char *s = strdup(taskInfDir);
+      char *s = taosStrdup(taskInfDir);
       if (taosMulMkDir(taosDirName(s)) != 0) {
         terrno = TAOS_SYSTEM_ERROR(errno);
         taosMemoryFree(s);

source/dnode/vnode/src/sma/smaTimeRange.c

@@ -208,7 +208,7 @@ int32_t smaBlockToSubmit(SVnode *pVnode, const SArray *pBlocks, const STSchema *
       // set super table name
       SName name = {0};
       tNameFromString(&name, stbFullName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
-      pCreateTbReq->ctb.stbName = strdup((char *)tNameGetTableName(&name));  // strdup(stbFullName);
+      pCreateTbReq->ctb.stbName = taosStrdup((char *)tNameGetTableName(&name));  // taosStrdup(stbFullName);
 
       // set tag content
       taosArrayClear(tagArray);
@@ -237,7 +237,7 @@ int32_t smaBlockToSubmit(SVnode *pVnode, const SArray *pBlocks, const STSchema *
 
       // set table name
       if (pDataBlock->info.parTbName[0]) {
-        pCreateTbReq->name = strdup(pDataBlock->info.parTbName);
+        pCreateTbReq->name = taosStrdup(pDataBlock->info.parTbName);
       } else {
         pCreateTbReq->name = buildCtbNameByGroupId(stbFullName, pDataBlock->info.id.groupId);
       }

source/dnode/vnode/src/tq/tq.c

@@ -78,7 +78,7 @@ STQ* tqOpen(const char* path, SVnode* pVnode) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
   }
-  pTq->path = strdup(path);
+  pTq->path = taosStrdup(path);
   pTq->pVnode = pVnode;
   pTq->walLogLastVer = pVnode->pWal->vers.lastVer;
 

source/dnode/vnode/src/tq/tqExec.c

@@ -52,7 +52,7 @@ static int32_t tqAddTbNameToRsp(const STQ* pTq, int64_t uid, STaosxRsp* pRsp, in
     return -1;
   }
   for (int32_t i = 0; i < n; i++) {
-    char* tbName = strdup(mr.me.name);
+    char* tbName = taosStrdup(mr.me.name);
     taosArrayPush(pRsp->blockTbName, &tbName);
   }
   metaReaderClear(&mr);
@@ -157,7 +157,7 @@ int32_t tqScanTaosx(STQ* pTq, const STqHandle* pHandle, STaosxRsp* pRsp, SMqMeta
             continue;
           }
         } else {
-          char* tbName = strdup(qExtractTbnameFromTask(task));
+          char* tbName = taosStrdup(qExtractTbnameFromTask(task));
           taosArrayPush(pRsp->blockTbName, &tbName);
         }
       }

source/dnode/vnode/src/tq/tqSink.c

@@ -130,7 +130,7 @@ void tqSinkToTablePipeline(SStreamTask* pTask, void* vnode, int64_t ver, void* d
       char* ctbName = NULL;
       // set child table name
       if (pDataBlock->info.parTbName[0]) {
-        ctbName = strdup(pDataBlock->info.parTbName);
+        ctbName = taosStrdup(pDataBlock->info.parTbName);
       } else {
         ctbName = buildCtbNameByGroupId(stbFullName, pDataBlock->info.id.groupId);
       }
@@ -155,7 +155,7 @@ void tqSinkToTablePipeline(SStreamTask* pTask, void* vnode, int64_t ver, void* d
         // set super table name
         SName name = {0};
         tNameFromString(&name, stbFullName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
-        createTbReq.ctb.stbName = strdup((char*)tNameGetTableName(&name));  // strdup(stbFullName);
+        createTbReq.ctb.stbName = taosStrdup((char*)tNameGetTableName(&name));  // taosStrdup(stbFullName);
         createTbReq.name = ctbName;
         ctbName = NULL;
 
@@ -453,7 +453,7 @@ void tqSinkToTablePipeline2(SStreamTask* pTask, void* vnode, int64_t ver, void*
         // set super table name
         SName name = {0};
         tNameFromString(&name, stbFullName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
-        pCreateTbReq->ctb.stbName = strdup((char*)tNameGetTableName(&name));  // strdup(stbFullName);
+        pCreateTbReq->ctb.stbName = taosStrdup((char*)tNameGetTableName(&name));  // taosStrdup(stbFullName);
 
         // set tag content
         int32_t size = taosArrayGetSize(pDataBlock->pDataBlock);
@@ -497,7 +497,7 @@ void tqSinkToTablePipeline2(SStreamTask* pTask, void* vnode, int64_t ver, void*
             taosArrayPush(tagArray, &tagVal);
           }
         }
-        pCreateTbReq->ctb.tagNum = size;
+        pCreateTbReq->ctb.tagNum = TMAX(size - UD_TAG_COLUMN_INDEX, 1);
 
         STag* pTag = NULL;
         tTagNew(tagArray, 1, false, &pTag);
@@ -507,18 +507,16 @@ void tqSinkToTablePipeline2(SStreamTask* pTask, void* vnode, int64_t ver, void*
           goto _end;
         }
 
+
         pCreateTbReq->ctb.pTag = (uint8_t*)pTag;
 
         // set table name
-        SColumnInfoData* pTbColInfo = taosArrayGet(pDataBlock->pDataBlock, UD_TABLE_NAME_COLUMN_INDEX);
+        if (!pDataBlock->info.parTbName[0]) {
-        if (colDataIsNull_s(pTbColInfo, rowId)) {
           SColumnInfoData* pGpIdColInfo = taosArrayGet(pDataBlock->pDataBlock, UD_GROUPID_COLUMN_INDEX);
           void*            pGpIdData = colDataGetData(pGpIdColInfo, rowId);
           pCreateTbReq->name = buildCtbNameByGroupId(stbFullName, *(uint64_t*)pGpIdData);
         } else {
-          void* pTbData = colDataGetData(pTbColInfo, rowId);
+          pCreateTbReq->name = taosStrdup(pDataBlock->info.parTbName);
-          pCreateTbReq->name = taosMemoryCalloc(1, varDataLen(pTbData) + 1);
-          memcpy(pCreateTbReq->name, varDataVal(pTbData), varDataLen(pTbData));
         }
         taosArrayPush(reqs.pArray, pCreateTbReq);
       }
@@ -544,7 +542,7 @@ void tqSinkToTablePipeline2(SStreamTask* pTask, void* vnode, int64_t ver, void*
       char* ctbName = NULL;
       tqDebug("vgId:%d, stream write into %s, table auto created", TD_VID(pVnode), pDataBlock->info.parTbName);
       if (pDataBlock->info.parTbName[0]) {
-        ctbName = strdup(pDataBlock->info.parTbName);
+        ctbName = taosStrdup(pDataBlock->info.parTbName);
       } else {
         ctbName = buildCtbNameByGroupId(stbFullName, pDataBlock->info.id.groupId);
       }
@@ -569,7 +567,7 @@ void tqSinkToTablePipeline2(SStreamTask* pTask, void* vnode, int64_t ver, void*
         // set super table name
         SName name = {0};
         tNameFromString(&name, stbFullName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
-        pCreateTbReq->ctb.stbName = strdup((char*)tNameGetTableName(&name));  // strdup(stbFullName);
+        pCreateTbReq->ctb.stbName = taosStrdup((char*)tNameGetTableName(&name));  // taosStrdup(stbFullName);
 
         // set tag content
         tagArray = taosArrayInit(1, sizeof(STagVal));

source/dnode/vnode/src/tsdb/tsdbCache.c

@@ -813,7 +813,8 @@ static int32_t getNextRowFromFS(void *iter, TSDBROW **ppRow) {
       if (!state->pBlockData) {
         state->pBlockData = &state->blockData;
 
-        tBlockDataCreate(&state->blockData);
+        code = tBlockDataCreate(&state->blockData);
+        if (code) goto _err;
       }
     }
     case SFSNEXTROW_BLOCKDATA:

source/dnode/vnode/src/tsdb/tsdbCacheRead.c

@@ -190,7 +190,7 @@ int32_t tsdbCacherowsReaderOpen(void* pVnode, int32_t type, void* pTableIdList,
     return TSDB_CODE_OUT_OF_MEMORY;
   }
 
-  p->idstr = taosMemoryStrDup(idstr);
+  p->idstr = taosStrdup(idstr);
   taosThreadMutexInit(&p->readerMutex, NULL);
 
   *pReader = p;
@@ -433,8 +433,10 @@ _end:
   tsdbUntakeReadSnap((STsdbReader*)pr, pr->pReadSnap, true);
   taosThreadMutexUnlock(&pr->readerMutex);
 
-  for (int32_t j = 0; j < pr->numOfCols; ++j) {
+  if (pRes != NULL) {
-    taosMemoryFree(pRes[j]);
+    for (int32_t j = 0; j < pr->numOfCols; ++j) {
+      taosMemoryFree(pRes[j]);
+    }
   }
 
   taosMemoryFree(pRes);

source/dnode/vnode/src/tsdb/tsdbDataIter.c

@@ -219,7 +219,7 @@ static int32_t tsdbDataFileDataIterNext(STsdbDataIter2* pIter, STsdbFilterInfo*
       }
 
       ASSERT(pIter->rowInfo.suid == pIter->dIter.bData.suid);
-      ASSERT(pIter->rowInfo.uid = pIter->dIter.bData.uid);
+      ASSERT(pIter->rowInfo.uid == pIter->dIter.bData.uid);
       pIter->rowInfo.row = tsdbRowFromBlockData(&pIter->dIter.bData, pIter->dIter.iRow);
       pIter->dIter.iRow++;
       goto _exit;

source/dnode/vnode/src/tsdb/tsdbFile.c

@@ -148,10 +148,10 @@ bool tsdbDelFileIsSame(SDelFile *pDelFile1, SDelFile *pDelFile2) { return pDelFi
 
 int32_t tsdbDFileRollback(STsdb *pTsdb, SDFileSet *pSet, EDataFileT ftype) {
   int32_t   code = 0;
-  int64_t   size;
+  int64_t   size = 0;
   int64_t   n;
   TdFilePtr pFD;
-  char      fname[TSDB_FILENAME_LEN];
+  char      fname[TSDB_FILENAME_LEN] = {0};
   char      hdr[TSDB_FHDR_SIZE] = {0};
 
   // truncate

source/dnode/vnode/src/tsdb/tsdbMemTable.c

@@ -473,7 +473,7 @@ static int32_t tbDataDoPut(SMemTable *pMemTable, STbData *pTbData, SMemSkipListN
                            int8_t forward) {
   int32_t           code = 0;
   int8_t            level;
-  SMemSkipListNode *pNode;
+  SMemSkipListNode *pNode = NULL;
   SVBufPool        *pPool = pMemTable->pTsdb->pVnode->inUse;
   int64_t           nSize;
 
@@ -591,7 +591,9 @@ static int32_t tsdbInsertColDataToTable(SMemTable *pMemTable, STbData *pTbData,
   pBlockData->aColData = vnodeBufPoolMalloc(pPool, sizeof(SColData) * pBlockData->nColData);
   if (pBlockData->aColData == NULL) {
     code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _exit;
   }
+
   for (int32_t iColData = 0; iColData < pBlockData->nColData; ++iColData) {
     code = tColDataCopy(&aColData[iColData + 1], &pBlockData->aColData[iColData], (xMallocFn)vnodeBufPoolMalloc, pPool);
     if (code) goto _exit;

source/dnode/vnode/src/tsdb/tsdbRead.c

@@ -488,7 +488,7 @@ static int32_t initFilesetIterator(SFilesetIter* pIter, SArray* aDFileSet, STsdb
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t filesetIteratorNext(SFilesetIter* pIter, STsdbReader* pReader, bool *hasNext) {
+static int32_t filesetIteratorNext(SFilesetIter* pIter, STsdbReader* pReader, bool* hasNext) {
   bool    asc = ASCENDING_TRAVERSE(pIter->order);
   int32_t step = asc ? 1 : -1;
   pIter->index += step;
@@ -677,7 +677,7 @@ static int32_t tsdbReaderCreate(SVnode* pVnode, SQueryTableDataCond* pCond, STsd
   pReader->order = pCond->order;
   pReader->capacity = capacity;
   pReader->pResBlock = pResBlock;
-  pReader->idStr = (idstr != NULL) ? strdup(idstr) : NULL;
+  pReader->idStr = (idstr != NULL) ? taosStrdup(idstr) : NULL;
   pReader->verRange = getQueryVerRange(pVnode, pCond, level);
   pReader->type = pCond->type;
   pReader->window = updateQueryTimeWindow(pReader->pTsdb, &pCond->twindows);
@@ -874,7 +874,7 @@ static int32_t doLoadFileBlock(STsdbReader* pReader, SArray* pIndexList, SBlockN
       pBlockNum->numOfBlocks += 1;
     }
 
-    if (pScanInfo->pBlockList != NULL && taosArrayGetSize(pScanInfo->pBlockList) > 0) {
+    if ((pScanInfo->pBlockList != NULL )&& (taosArrayGetSize(pScanInfo->pBlockList) > 0)) {
       numOfQTable += 1;
     }
   }
@@ -2802,7 +2802,7 @@ static int32_t moveToNextFile(STsdbReader* pReader, SBlockNumber* pBlockNum) {
   SArray* pIndexList = taosArrayInit(numOfTables, sizeof(SBlockIdx));
 
   while (1) {
-    bool hasNext = false;
+    bool    hasNext = false;
     int32_t code = filesetIteratorNext(&pStatus->fileIter, pReader, &hasNext);
     if (code) {
       taosArrayDestroy(pIndexList);
@@ -4532,7 +4532,7 @@ int32_t tsdbRetrieveDatablockSMA(STsdbReader* pReader, SSDataBlock* pDataBlock,
   SSDataBlock* pResBlock = pReader->pResBlock;
   if (pResBlock->pBlockAgg == NULL) {
     size_t num = taosArrayGetSize(pResBlock->pDataBlock);
-    pResBlock->pBlockAgg = taosMemoryCalloc(num, sizeof(SColumnDataAgg));
+    pResBlock->pBlockAgg = taosMemoryCalloc(num, POINTER_BYTES);
   }
 
   // do fill all null column value SMA info
@@ -4688,6 +4688,11 @@ int32_t tsdbGetFileBlocksDistInfo(STsdbReader* pReader, STableBlockDistInfo* pTa
   pTableBlockInfo->numOfVgroups = 1;
 
   // find the start data block in file
+
+  tsdbAcquireReader(pReader);
+  if (pReader->suspended) {
+    tsdbReaderResume(pReader);
+  }
   SReaderStatus* pStatus = &pReader->status;
 
   STsdbCfg* pc = &pReader->pTsdb->pVnode->config.tsdbCfg;
@@ -4749,7 +4754,7 @@ int32_t tsdbGetFileBlocksDistInfo(STsdbReader* pReader, STableBlockDistInfo* pTa
     //    tsdbDebug("%p %d blocks found in file for %d table(s), fid:%d, %s", pReader, numOfBlocks, numOfTables,
     //              pReader->pFileGroup->fid, pReader->idStr);
   }
-
+  tsdbReleaseReader(pReader);
   return code;
 }
 

source/dnode/vnode/src/vnd/vnodeQuery.c

@@ -197,7 +197,7 @@ int vnodeGetTableCfg(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
     cfgRsp.ttl = mer1.me.ctbEntry.ttlDays;
     cfgRsp.commentLen = mer1.me.ctbEntry.commentLen;
     if (mer1.me.ctbEntry.commentLen > 0) {
-      cfgRsp.pComment = strdup(mer1.me.ctbEntry.comment);
+      cfgRsp.pComment = taosStrdup(mer1.me.ctbEntry.comment);
     }
     STag *pTag = (STag *)mer1.me.ctbEntry.pTags;
     cfgRsp.tagsLen = pTag->len;
@@ -208,7 +208,7 @@ int vnodeGetTableCfg(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
     cfgRsp.ttl = mer1.me.ntbEntry.ttlDays;
     cfgRsp.commentLen = mer1.me.ntbEntry.commentLen;
     if (mer1.me.ntbEntry.commentLen > 0) {
-      cfgRsp.pComment = strdup(mer1.me.ntbEntry.comment);
+      cfgRsp.pComment = taosStrdup(mer1.me.ntbEntry.comment);
     }
   } else {
     ASSERT(0);

source/libs/catalog/src/ctgDbg.c

@@ -281,7 +281,7 @@ int32_t ctgdHandleDbgCommand(char *command) {
     CTG_RET(TSDB_CODE_INVALID_PARA);
   }
 
-  char *dup = strdup(command);
+  char *dup = taosStrdup(command);
   char *option = NULL;
   char *param = NULL;
   

source/libs/catalog/src/ctgUtil.c

@@ -742,7 +742,7 @@ int32_t ctgUpdateMsgCtx(SCtgMsgCtx* pCtx, int32_t reqType, void* out, char* targ
   pCtx->reqType = reqType;
   pCtx->out = out;
   if (target) {
-    pCtx->target = strdup(target);
+    pCtx->target = taosStrdup(target);
     if (NULL == pCtx->target) {
       CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
     }
@@ -759,7 +759,7 @@ int32_t ctgAddMsgCtx(SArray* pCtxs, int32_t reqType, void* out, char* target) {
   ctx.reqType = reqType;
   ctx.out = out;
   if (target) {
-    ctx.target = strdup(target);
+    ctx.target = taosStrdup(target);
     if (NULL == ctx.target) {
       CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
     }
@@ -1169,7 +1169,7 @@ int32_t ctgCloneTableIndex(SArray* pIndex, SArray** pRes) {
   for (int32_t i = 0; i < num; ++i) {
     STableIndexInfo* pInfo = taosArrayGet(pIndex, i);
     pInfo = taosArrayPush(*pRes, pInfo);
-    pInfo->expr = strdup(pInfo->expr);
+    pInfo->expr = taosStrdup(pInfo->expr);
   }
 
   return TSDB_CODE_SUCCESS;
@@ -1179,7 +1179,7 @@ int32_t ctgUpdateSendTargetInfo(SMsgSendInfo* pMsgSendInfo, int32_t msgType, cha
   if (msgType == TDMT_VND_TABLE_META || msgType == TDMT_VND_TABLE_CFG || msgType == TDMT_VND_BATCH_META) {
     pMsgSendInfo->target.type = TARGET_TYPE_VNODE;
     pMsgSendInfo->target.vgId = vgId;
-    pMsgSendInfo->target.dbFName = strdup(dbFName);
+    pMsgSendInfo->target.dbFName = taosStrdup(dbFName);
   } else {
     pMsgSendInfo->target.type = TARGET_TYPE_MNODE;
   }

source/libs/executor/src/dataInserter.c

@@ -230,12 +230,19 @@ int32_t buildSubmitReqFromBlock(SDataInserterHandle* pInserter, SSubmitReq2** pp
         case TSDB_DATA_TYPE_BLOB:
         case TSDB_DATA_TYPE_JSON:
         case TSDB_DATA_TYPE_MEDIUMBLOB:
-          uError("the column type %" PRIi16 " is defined but not implemented yet", pColInfoData->info.type);
+          qError("the column type %" PRIi16 " is defined but not implemented yet", pColInfoData->info.type);
-          ASSERT(0);
+          terrno = TSDB_CODE_APP_ERROR;
+          goto _end;
           break;
         default:
           if (pColInfoData->info.type < TSDB_DATA_TYPE_MAX && pColInfoData->info.type > TSDB_DATA_TYPE_NULL) {
             if (colDataIsNull_s(pColInfoData, j)) {
+              if (PRIMARYKEY_TIMESTAMP_COL_ID == pCol->colId) {
+                qError("NULL value for primary key");
+                terrno = TSDB_CODE_PAR_INCORRECT_TIMESTAMP_VAL;
+                goto _end;
+              }
+              
               SColVal cv = COL_VAL_NULL(pCol->colId, pCol->type);  // should use pCol->type
               taosArrayPush(pVals, &cv);
             } else {
@@ -256,7 +263,8 @@ int32_t buildSubmitReqFromBlock(SDataInserterHandle* pInserter, SSubmitReq2** pp
             }
           } else {
             uError("the column type %" PRIi16 " is undefined\n", pColInfoData->info.type);
-            ASSERT(0);
+            terrno = TSDB_CODE_APP_ERROR;
+            goto _end;
           }
           break;
       }
@@ -296,7 +304,7 @@ _end:
       tDestroySSubmitReq2(pReq, TSDB_MSG_FLG_ENCODE);
       taosMemoryFree(pReq);
     }
-    return TSDB_CODE_FAILED;
+    return terrno;
   }
   *ppReq = pReq;
   return TSDB_CODE_SUCCESS;

source/libs/executor/src/executil.c

@@ -1148,7 +1148,6 @@ int32_t getGroupIdFromTagsVal(void* pMeta, uint64_t uid, SNodeList* pGroupNode,
     if (TSDB_CODE_SUCCESS == code) {
       REPLACE_NODE(pNew);
     } else {
-      taosMemoryFree(keyBuf);
       nodesDestroyList(groupNew);
       metaReaderClear(&mr);
       return code;
@@ -1166,7 +1165,6 @@ int32_t getGroupIdFromTagsVal(void* pMeta, uint64_t uid, SNodeList* pGroupNode,
       if (pValue->node.resType.type == TSDB_DATA_TYPE_JSON) {
         if (tTagIsJson(data)) {
           terrno = TSDB_CODE_QRY_JSON_IN_GROUP_ERROR;
-          taosMemoryFree(keyBuf);
           nodesDestroyList(groupNew);
           metaReaderClear(&mr);
           return terrno;
@@ -1531,7 +1529,7 @@ SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput,
           fmGetFuncExecFuncs(pCtx->functionId, &pCtx->fpSet);
         } else {
           char* udfName = pExpr->pExpr->_function.pFunctNode->functionName;
-          pCtx->udfName = strdup(udfName);
+          pCtx->udfName = taosStrdup(udfName);
           fmGetUdafExecFuncs(pCtx->functionId, &pCtx->fpSet);
         }
         pCtx->fpSet.getEnv(pExpr->pExpr->_function.pFunctNode, &env);

source/libs/executor/src/executorimpl.c

@@ -2000,7 +2000,7 @@ static SExecTaskInfo* createExecTaskInfo(uint64_t queryId, uint64_t taskId, EOPT
 
   setTaskStatus(pTaskInfo, TASK_NOT_COMPLETED);
 
-  pTaskInfo->schemaInfo.dbname = strdup(dbFName);
+  pTaskInfo->schemaInfo.dbname = taosStrdup(dbFName);
   pTaskInfo->execModel = model;
   pTaskInfo->pTableInfoList = tableListCreate();
   pTaskInfo->stopInfo.pStopInfo = taosArrayInit(4, sizeof(SExchangeOpStopInfo));
@@ -2026,7 +2026,7 @@ int32_t extractTableSchemaInfo(SReadHandle* pHandle, SScanPhysiNode* pScanNode,
   }
 
   SSchemaInfo* pSchemaInfo = &pTaskInfo->schemaInfo;
-  pSchemaInfo->tablename = strdup(mr.me.name);
+  pSchemaInfo->tablename = taosStrdup(mr.me.name);
 
   if (mr.me.type == TSDB_SUPER_TABLE) {
     pSchemaInfo->sw = tCloneSSchemaWrapper(&mr.me.stbEntry.schemaRow);
@@ -2035,7 +2035,11 @@ int32_t extractTableSchemaInfo(SReadHandle* pHandle, SScanPhysiNode* pScanNode,
     tDecoderClear(&mr.coder);
 
     tb_uid_t suid = mr.me.ctbEntry.suid;
-    metaGetTableEntryByUidCache(&mr, suid);
+    code = metaGetTableEntryByUidCache(&mr, suid);
+    if (code != TSDB_CODE_SUCCESS) {
+      return terrno;
+    }
+
     pSchemaInfo->sw = tCloneSSchemaWrapper(&mr.me.stbEntry.schemaRow);
     pSchemaInfo->tversion = mr.me.stbEntry.schemaTag.version;
   } else {

source/libs/executor/src/groupoperator.c

@@ -992,32 +992,42 @@ void appendCreateTableRow(SStreamState* pState, SExprSupp* pTableSup, SExprSupp*
     SSDataBlock* pTmpBlock = blockCopyOneRow(pSrcBlock, rowId);
     memset(pTmpBlock->info.parTbName, 0, TSDB_TABLE_NAME_LEN);
     pTmpBlock->info.id.groupId = groupId;
+    char* tbName = pSrcBlock->info.parTbName;
     if (pTableSup->numOfExprs > 0) {
       projectApplyFunctions(pTableSup->pExprInfo, pDestBlock, pTmpBlock, pTableSup->pCtx, pTableSup->numOfExprs, NULL);
       SColumnInfoData* pTbCol = taosArrayGet(pDestBlock->pDataBlock, UD_TABLE_NAME_COLUMN_INDEX);
-      void*            pData = colDataGetVarData(pTbCol, pDestBlock->info.rows - 1);
-      char*            tbName = pSrcBlock->info.parTbName;
       memset(tbName, 0, TSDB_TABLE_NAME_LEN);
-      int32_t len = TMIN(varDataLen(pData), TSDB_TABLE_NAME_LEN - 1);
+      int32_t len = 0;
-      memcpy(tbName, varDataVal(pData), len);
+      if (colDataIsNull_s(pTbCol, pDestBlock->info.rows - 1)) {
+        len = TMIN(sizeof(TSDB_DATA_NULL_STR), TSDB_TABLE_NAME_LEN - 1);
+        memcpy(tbName, TSDB_DATA_NULL_STR, len);
+      } else {
+        void* pData = colDataGetData(pTbCol, pDestBlock->info.rows - 1);
+        len = TMIN(varDataLen(pData), TSDB_TABLE_NAME_LEN - 1);
+        memcpy(tbName, varDataVal(pData), len);
+      }
       streamStatePutParName(pState, groupId, tbName);
       memcpy(pTmpBlock->info.parTbName, tbName, len);
       pDestBlock->info.rows--;
     } else {
       void* pTbNameCol = taosArrayGet(pDestBlock->pDataBlock, UD_TABLE_NAME_COLUMN_INDEX);
       colDataAppendNULL(pTbNameCol, pDestBlock->info.rows);
-      pSrcBlock->info.parTbName[0] = 0;
+      tbName[0] = 0;
     }
 
     if (pTagSup->numOfExprs > 0) {
       projectApplyFunctions(pTagSup->pExprInfo, pDestBlock, pTmpBlock, pTagSup->pCtx, pTagSup->numOfExprs, NULL);
       pDestBlock->info.rows--;
+    } else {
+      memcpy(pDestBlock->info.parTbName, pTmpBlock->info.parTbName, TSDB_TABLE_NAME_LEN);
     }
 
     void* pGpIdCol = taosArrayGet(pDestBlock->pDataBlock, UD_GROUPID_COLUMN_INDEX);
     colDataAppend(pGpIdCol, pDestBlock->info.rows, (const char*)&groupId, false);
     pDestBlock->info.rows++;
     blockDataDestroy(pTmpBlock);
+  } else {
+    memcpy(pSrcBlock->info.parTbName, pValue, TSDB_TABLE_NAME_LEN);
   }
   streamStateReleaseBuf(pState, NULL, pValue);
 }

source/libs/executor/src/projectoperator.c

@@ -275,7 +275,6 @@ SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) {
       // for stream interval
       if (pBlock->info.type == STREAM_RETRIEVE || pBlock->info.type == STREAM_DELETE_RESULT ||
           pBlock->info.type == STREAM_DELETE_DATA || pBlock->info.type == STREAM_CREATE_CHILD_TABLE) {
-        // printDataBlock1(pBlock, "project1");
         return pBlock;
       }
 

source/libs/executor/src/scanoperator.c

@@ -434,7 +434,7 @@ static void freeTableCachedVal(void* param) {
 
 static STableCachedVal* createTableCacheVal(const SMetaReader* pMetaReader) {
   STableCachedVal* pVal = taosMemoryMalloc(sizeof(STableCachedVal));
-  pVal->pName = strdup(pMetaReader->me.name);
+  pVal->pName = taosStrdup(pMetaReader->me.name);
   pVal->pTags = NULL;
 
   // only child table has tag value
@@ -3050,8 +3050,8 @@ int32_t tblCountScanGetInputs(SNodeList* groupTags, SName* tableName, STableCoun
       }
     }
   } else {
-    strncpy(supp->dbNameFilter, tNameGetDbNameP(tableName), TSDB_DB_NAME_LEN);
+    tstrncpy(supp->dbNameFilter, tNameGetDbNameP(tableName), TSDB_DB_NAME_LEN);
-    strncpy(supp->stbNameFilter, tNameGetTableName(tableName), TSDB_TABLE_NAME_LEN);
+    tstrncpy(supp->stbNameFilter, tNameGetTableName(tableName), TSDB_TABLE_NAME_LEN);
   }
   return TSDB_CODE_SUCCESS;
 }

source/libs/executor/src/sortoperator.c

@@ -46,8 +46,9 @@ SOperatorInfo* createSortOperatorInfo(SOperatorInfo* downstream, SSortPhysiNode*
   pOperator->pTaskInfo = pTaskInfo;
   SDataBlockDescNode* pDescNode = pSortNode->node.pOutputDataBlockDesc;
 
-  int32_t    numOfCols = 0;
+  int32_t numOfCols = 0;
-  SExprInfo* pExprInfo = createExprInfo(pSortNode->pExprs, NULL, &numOfCols);
+  pOperator->exprSupp.pExprInfo = createExprInfo(pSortNode->pExprs, NULL, &numOfCols);
+  pOperator->exprSupp.numOfExprs = numOfCols;
 
   int32_t numOfOutputCols = 0;
   int32_t code =
@@ -56,7 +57,8 @@ SOperatorInfo* createSortOperatorInfo(SOperatorInfo* downstream, SSortPhysiNode*
     goto _error;
   }
 
-  pOperator->exprSupp.pCtx = createSqlFunctionCtx(pExprInfo, numOfCols, &pOperator->exprSupp.rowEntryInfoOffset);
+  pOperator->exprSupp.pCtx =
+      createSqlFunctionCtx(pOperator->exprSupp.pExprInfo, numOfCols, &pOperator->exprSupp.rowEntryInfoOffset);
   initResultSizeInfo(&pOperator->resultInfo, 1024);
   code = filterInitFromNode((SNode*)pSortNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
   if (code != TSDB_CODE_SUCCESS) {
@@ -68,8 +70,7 @@ SOperatorInfo* createSortOperatorInfo(SOperatorInfo* downstream, SSortPhysiNode*
   initLimitInfo(pSortNode->node.pLimit, pSortNode->node.pSlimit, &pInfo->limitInfo);
 
   setOperatorInfo(pOperator, "SortOperator", QUERY_NODE_PHYSICAL_PLAN_SORT, true, OP_NOT_OPENED, pInfo, pTaskInfo);
-  pOperator->exprSupp.pExprInfo = pExprInfo;
+
-  pOperator->exprSupp.numOfExprs = numOfCols;
 
   // lazy evaluation for the following parameter since the input datablock is not known till now.
   //  pInfo->bufPageSize  = rowSize < 1024 ? 1024 * 2 : rowSize * 2;

source/libs/executor/src/sysscanoperator.c

@@ -1608,9 +1608,7 @@ static void sysTableScanFillTbName(SOperatorInfo* pOperator, const SSysTableScan
   if (pInfo->tbnameSlotId != -1) {
     SColumnInfoData* pColumnInfoData = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, pInfo->tbnameSlotId);
     char             varTbName[TSDB_TABLE_FNAME_LEN - 1 + VARSTR_HEADER_SIZE] = {0};
-    memcpy(varDataVal(varTbName), name, strlen(name));
+    STR_TO_VARSTR(varTbName, name);
-    varDataSetLen(varTbName, strlen(name));
-
     colDataAppendNItems(pColumnInfoData, 0, varTbName, pBlock->info.rows);
   }
 
@@ -1711,7 +1709,7 @@ SOperatorInfo* createSysTableScanOperatorInfo(void* readHandle, SSystemTableScan
   extractTbnameSlotId(pInfo, pScanNode);
 
   pInfo->accountId = pScanPhyNode->accountId;
-  pInfo->pUser = taosMemoryStrDup((void*)pUser);
+  pInfo->pUser = taosStrdup((void*)pUser);
   pInfo->sysInfo = pScanPhyNode->sysInfo;
   pInfo->showRewrite = pScanPhyNode->showRewrite;
   pInfo->pRes = createDataBlockFromDescNode(pDescNode);

source/libs/executor/src/tsort.c

@@ -90,7 +90,7 @@ SSortHandle* tsortCreateSortHandle(SArray* pSortInfo, int32_t type, int32_t page
   tsortSetComparFp(pSortHandle, msortComparFn);
 
   if (idstr != NULL) {
-    pSortHandle->idStr = strdup(idstr);
+    pSortHandle->idStr = taosStrdup(idstr);
   }
 
   return pSortHandle;
@@ -212,6 +212,7 @@ static int32_t doAddToBuf(SSDataBlock* pDataBlock, SSortHandle* pHandle) {
     int32_t pageId = -1;
     void*   pPage = getNewBufPage(pHandle->pBuf, &pageId);
     if (pPage == NULL) {
+      taosArrayDestroy(pPageIdList);
       blockDataDestroy(p);
       return terrno;
     }

source/libs/function/src/builtinsimpl.c

@@ -775,13 +775,13 @@ int32_t maxFunction(SqlFunctionCtx* pCtx) {
 
 static int32_t setNullSelectivityValue(SqlFunctionCtx* pCtx, SSDataBlock* pBlock, int32_t rowIndex);
 static int32_t setSelectivityValue(SqlFunctionCtx* pCtx, SSDataBlock* pBlock, const STuplePos* pTuplePos,
-                                int32_t rowIndex);
+                                   int32_t rowIndex);
 
 int32_t minmaxFunctionFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
   int32_t code = TSDB_CODE_SUCCESS;
 
   SResultRowEntryInfo* pEntryInfo = GET_RES_INFO(pCtx);
-  SMinmaxResInfo* pRes = GET_ROWCELL_INTERBUF(pEntryInfo);
+  SMinmaxResInfo*      pRes = GET_ROWCELL_INTERBUF(pEntryInfo);
 
   int32_t slotId = pCtx->pExpr->base.resSchema.slotId;
   int32_t currentRow = pBlock->info.rows;
@@ -795,7 +795,7 @@ int32_t minmaxFunctionFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
       case TSDB_DATA_TYPE_UBIGINT:
       case TSDB_DATA_TYPE_BIGINT:
         ((int64_t*)pCol->pData)[currentRow] = pRes->v;
-//        colDataAppendInt64(pCol, currentRow, &pRes->v);
+        //        colDataAppendInt64(pCol, currentRow, &pRes->v);
         break;
       case TSDB_DATA_TYPE_UINT:
       case TSDB_DATA_TYPE_INT:
@@ -920,9 +920,7 @@ void appendSelectivityValue(SqlFunctionCtx* pCtx, int32_t rowIndex, int32_t pos)
   }
 }
 
-void replaceTupleData(STuplePos* pDestPos, STuplePos* pSourcePos) {
+void replaceTupleData(STuplePos* pDestPos, STuplePos* pSourcePos) { *pDestPos = *pSourcePos; }
-  *pDestPos = *pSourcePos;
-}
 
 int32_t minMaxCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx, int32_t isMinFunc) {
   SResultRowEntryInfo* pDResInfo = GET_RES_INFO(pDestCtx);
@@ -1686,63 +1684,59 @@ int32_t percentileFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
   SPercentileInfo*     ppInfo = (SPercentileInfo*)GET_ROWCELL_INTERBUF(pResInfo);
 
   int32_t code = 0;
-  double     v = 0;
+  double  v = 0;
 
   tMemBucket* pMemBucket = ppInfo->pMemBucket;
-  if (pMemBucket == NULL || pMemBucket->total == 0) {  // check for null
+  if (pMemBucket != NULL && pMemBucket->total > 0) {  // check for null
-    code = TSDB_CODE_FAILED;
+    if (pCtx->numOfParams > 2) {
-    goto _fin_error;
+      char   buf[512] = {0};
-  }
+      size_t len = 1;
 
-  if (pCtx->numOfParams > 2) {
+      varDataVal(buf)[0] = '[';
-    char   buf[512] = {0};
+      for (int32_t i = 1; i < pCtx->numOfParams; ++i) {
-    size_t len = 1;
+        SVariant* pVal = &pCtx->param[i].param;
 
-    varDataVal(buf)[0] = '[';
+        GET_TYPED_DATA(v, double, pVal->nType, &pVal->i);
-    for (int32_t i = 1; i < pCtx->numOfParams; ++i) {
+
-      SVariant* pVal = &pCtx->param[i].param;
+        int32_t code = getPercentile(pMemBucket, v, &ppInfo->result);
+        if (code != TSDB_CODE_SUCCESS) {
+          goto _fin_error;
+        }
+
+        if (i == pCtx->numOfParams - 1) {
+          len += snprintf(varDataVal(buf) + len, sizeof(buf) - VARSTR_HEADER_SIZE - len, "%.6lf]", ppInfo->result);
+        } else {
+          len += snprintf(varDataVal(buf) + len, sizeof(buf) - VARSTR_HEADER_SIZE - len, "%.6lf, ", ppInfo->result);
+        }
+      }
+
+      int32_t          slotId = pCtx->pExpr->base.resSchema.slotId;
+      SColumnInfoData* pCol   = taosArrayGet(pBlock->pDataBlock, slotId);
+      
+      varDataSetLen(buf, len);
+      colDataAppend(pCol, pBlock->info.rows, buf, false);
+
+      tMemBucketDestroy(pMemBucket);
+      return pResInfo->numOfRes;
+    } else {
+      SVariant* pVal = &pCtx->param[1].param;
 
       GET_TYPED_DATA(v, double, pVal->nType, &pVal->i);
 
-      int32_t code = getPercentile(pMemBucket, v, &ppInfo->result);
+      code = getPercentile(pMemBucket, v, &ppInfo->result);
       if (code != TSDB_CODE_SUCCESS) {
         goto _fin_error;
       }
 
-      if (i == pCtx->numOfParams - 1) {
+      tMemBucketDestroy(pMemBucket);
-        len += snprintf(varDataVal(buf) + len, sizeof(buf) - VARSTR_HEADER_SIZE - len, "%.6lf]", ppInfo->result);
+      return functionFinalize(pCtx, pBlock);
-      } else {
-        len += snprintf(varDataVal(buf) + len, sizeof(buf) - VARSTR_HEADER_SIZE - len, "%.6lf, ", ppInfo->result);
-      }
     }
-
-    int32_t          slotId = pCtx->pExpr->base.resSchema.slotId;
-    SColumnInfoData* pCol   = taosArrayGet(pBlock->pDataBlock, slotId);
-
-    varDataSetLen(buf, len);
-    colDataAppend(pCol, pBlock->info.rows, buf, false);
-
-    tMemBucketDestroy(pMemBucket);
-    return pResInfo->numOfRes;
-  } else {
-    SVariant* pVal = &pCtx->param[1].param;
-
-    GET_TYPED_DATA(v, double, pVal->nType, &pVal->i);
-
-    code = getPercentile(pMemBucket, v, &ppInfo->result);
-    if (code != TSDB_CODE_SUCCESS) {
-      goto _fin_error;
-    }
-
-    tMemBucketDestroy(pMemBucket);
-    return functionFinalize(pCtx, pBlock);
   }
 
 _fin_error:
 
   tMemBucketDestroy(pMemBucket);
   return code;
-
 }
 
 bool getApercentileFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
@@ -2103,7 +2097,7 @@ static void prepareBuf(SqlFunctionCtx* pCtx) {
 }
 
 static int32_t firstlastSaveTupleData(const SSDataBlock* pSrcBlock, int32_t rowIndex, SqlFunctionCtx* pCtx,
-                                   SFirstLastRes* pInfo) {
+                                      SFirstLastRes* pInfo) {
   int32_t code = TSDB_CODE_SUCCESS;
 
   if (pCtx->subsidiaries.num <= 0) {
@@ -2156,7 +2150,8 @@ int32_t firstFunction(SqlFunctionCtx* pCtx) {
   }
 
   // All null data column, return directly.
-  if (pInput->colDataSMAIsSet && (pInput->pColumnDataAgg[0]->numOfNull == pInput->totalRows) && pInputCol->hasNull == true) {
+  if (pInput->colDataSMAIsSet && (pInput->pColumnDataAgg[0]->numOfNull == pInput->totalRows) &&
+      pInputCol->hasNull == true) {
     // save selectivity value for column consisted of all null values
     int32_t code = firstlastSaveTupleData(pCtx->pSrcBlock, pInput->startRowIndex, pCtx, pInfo);
     if (code != TSDB_CODE_SUCCESS) {
@@ -2272,7 +2267,8 @@ int32_t lastFunction(SqlFunctionCtx* pCtx) {
   }
 
   // All null data column, return directly.
-  if (pInput->colDataSMAIsSet && (pInput->pColumnDataAgg[0]->numOfNull == pInput->totalRows) && pInputCol->hasNull == true) {
+  if (pInput->colDataSMAIsSet && (pInput->pColumnDataAgg[0]->numOfNull == pInput->totalRows) &&
+      pInputCol->hasNull == true) {
     // save selectivity value for column consisted of all null values
     int32_t code = firstlastSaveTupleData(pCtx->pSrcBlock, pInput->startRowIndex, pCtx, pInfo);
     if (code != TSDB_CODE_SUCCESS) {
@@ -2366,7 +2362,7 @@ int32_t lastFunction(SqlFunctionCtx* pCtx) {
       }
 
       if (pResInfo->numOfRes == 0 || pInfo->ts < cts) {
-        char* data = colDataGetData(pInputCol, chosen);
+        char*   data = colDataGetData(pInputCol, chosen);
         int32_t code = doSaveCurrentVal(pCtx, i, cts, type, data);
         if (code != TSDB_CODE_SUCCESS) {
           return code;
@@ -2377,7 +2373,7 @@ int32_t lastFunction(SqlFunctionCtx* pCtx) {
 
     for (int32_t i = pInput->startRowIndex + round * 4; i < pInput->startRowIndex + pInput->numOfRows; ++i) {
       if (pResInfo->numOfRes == 0 || pInfo->ts < pts[i]) {
-        char* data = colDataGetData(pInputCol, i);
+        char*   data = colDataGetData(pInputCol, i);
         int32_t code = doSaveCurrentVal(pCtx, i, pts[i], type, data);
         if (code != TSDB_CODE_SUCCESS) {
           return code;
@@ -2394,7 +2390,7 @@ int32_t lastFunction(SqlFunctionCtx* pCtx) {
       numOfElems++;
 
       if (pResInfo->numOfRes == 0 || pInfo->ts < pts[i]) {
-        char* data = colDataGetData(pInputCol, i);
+        char*   data = colDataGetData(pInputCol, i);
         int32_t code = doSaveCurrentVal(pCtx, i, pts[i], type, data);
         if (code != TSDB_CODE_SUCCESS) {
           return code;
@@ -2441,7 +2437,7 @@ static int32_t firstLastTransferInfoImpl(SFirstLastRes* pInput, SFirstLastRes* p
 }
 
 static int32_t firstLastTransferInfo(SqlFunctionCtx* pCtx, SFirstLastRes* pInput, SFirstLastRes* pOutput, bool isFirst,
-                                  int32_t rowIndex) {
+                                     int32_t rowIndex) {
   if (TSDB_CODE_SUCCESS == firstLastTransferInfoImpl(pInput, pOutput, isFirst)) {
     int32_t code = firstlastSaveTupleData(pCtx->pSrcBlock, rowIndex, pCtx, pOutput);
     if (code != TSDB_CODE_SUCCESS) {
@@ -2468,7 +2464,7 @@ static int32_t firstLastFunctionMergeImpl(SqlFunctionCtx* pCtx, bool isFirstQuer
   for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
     char*          data = colDataGetData(pCol, i);
     SFirstLastRes* pInputInfo = (SFirstLastRes*)varDataVal(data);
-    int32_t code = firstLastTransferInfo(pCtx, pInputInfo, pInfo, isFirstQuery, i);
+    int32_t        code = firstLastTransferInfo(pCtx, pInputInfo, pInfo, isFirstQuery, i);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
     }
@@ -2700,7 +2696,7 @@ static int32_t doSetPrevVal(SDiffInfo* pDiffInfo, int32_t type, const char* pv,
 }
 
 static int32_t doHandleDiff(SDiffInfo* pDiffInfo, int32_t type, const char* pv, SColumnInfoData* pOutput, int32_t pos,
-                         int32_t order, int64_t ts) {
+                            int32_t order, int64_t ts) {
   int32_t factor = (order == TSDB_ORDER_ASC) ? 1 : -1;
   pDiffInfo->prevTs = ts;
   switch (type) {
@@ -2908,8 +2904,8 @@ static STopBotRes* getTopBotOutputInfo(SqlFunctionCtx* pCtx) {
   return pRes;
 }
 
-static int32_t doAddIntoResult(SqlFunctionCtx* pCtx, void* pData, int32_t rowIndex, SSDataBlock* pSrcBlock, uint16_t type,
+static int32_t doAddIntoResult(SqlFunctionCtx* pCtx, void* pData, int32_t rowIndex, SSDataBlock* pSrcBlock,
-                               uint64_t uid, SResultRowEntryInfo* pEntryInfo, bool isTopQuery);
+                               uint16_t type, uint64_t uid, SResultRowEntryInfo* pEntryInfo, bool isTopQuery);
 
 static void addResult(SqlFunctionCtx* pCtx, STopBotResItem* pSourceItem, int16_t type, bool isTopQuery);
 
@@ -2930,7 +2926,7 @@ int32_t topFunction(SqlFunctionCtx* pCtx) {
     }
 
     numOfElems++;
-    char* data = colDataGetData(pCol, i);
+    char*   data = colDataGetData(pCol, i);
     int32_t code = doAddIntoResult(pCtx, data, i, pCtx->pSrcBlock, pRes->type, pInput->uid, pResInfo, true);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
@@ -2964,7 +2960,7 @@ int32_t bottomFunction(SqlFunctionCtx* pCtx) {
     }
 
     numOfElems++;
-    char* data = colDataGetData(pCol, i);
+    char*   data = colDataGetData(pCol, i);
     int32_t code = doAddIntoResult(pCtx, data, i, pCtx->pSrcBlock, pRes->type, pInput->uid, pResInfo, false);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
@@ -3016,7 +3012,7 @@ static int32_t topBotResComparFn(const void* p1, const void* p2, const void* par
 }
 
 int32_t doAddIntoResult(SqlFunctionCtx* pCtx, void* pData, int32_t rowIndex, SSDataBlock* pSrcBlock, uint16_t type,
-                     uint64_t uid, SResultRowEntryInfo* pEntryInfo, bool isTopQuery) {
+                        uint64_t uid, SResultRowEntryInfo* pEntryInfo, bool isTopQuery) {
   STopBotRes* pRes = getTopBotOutputInfo(pCtx);
 
   SVariant val = {0};
@@ -3207,7 +3203,7 @@ static char* doLoadTupleData(SSerializeDataHandle* pHandle, const STuplePos* pPo
     if (pPage == NULL) {
       return NULL;
     }
-    char*      p = pPage->data + pPos->offset;
+    char* p = pPage->data + pPos->offset;
     releaseBufPage(pHandle->pBuf, pPage);
     return p;
   } else {
@@ -4668,7 +4664,7 @@ int32_t sampleFunction(SqlFunctionCtx* pCtx) {
       continue;
     }
 
-    char* data = colDataGetData(pInputCol, i);
+    char*   data = colDataGetData(pInputCol, i);
     int32_t code = doReservoirSample(pCtx, pInfo, data, i);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
@@ -4688,7 +4684,7 @@ int32_t sampleFunction(SqlFunctionCtx* pCtx) {
 }
 
 int32_t sampleFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
-  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t              code = TSDB_CODE_SUCCESS;
   SResultRowEntryInfo* pEntryInfo = GET_RES_INFO(pCtx);
 
   SSampleInfo* pInfo = getSampleOutputInfo(pCtx);
@@ -5022,7 +5018,7 @@ int32_t modeFunction(SqlFunctionCtx* pCtx) {
     }
     numOfElems++;
 
-    char* data = colDataGetData(pInputCol, i);
+    char*   data = colDataGetData(pInputCol, i);
     int32_t code = doModeAdd(pInfo, i, pCtx, data);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
@@ -5428,7 +5424,6 @@ int32_t blockDistFunction(SqlFunctionCtx* pCtx) {
   pDistInfo->numOfBlocks += p1.numOfBlocks;
   pDistInfo->numOfTables += p1.numOfTables;
   pDistInfo->numOfInmemRows += p1.numOfInmemRows;
-  pDistInfo->numOfVgroups += p1.numOfVgroups;
   pDistInfo->totalSize += p1.totalSize;
   pDistInfo->totalRows += p1.totalRows;
   pDistInfo->numOfFiles += p1.numOfFiles;
@@ -5445,6 +5440,7 @@ int32_t blockDistFunction(SqlFunctionCtx* pCtx) {
     pDistInfo->maxRows = p1.maxRows;
   }
 
+  pDistInfo->numOfVgroups += (p1.numOfTables != 0 ? 1 : 0);
   for (int32_t i = 0; i < tListLen(pDistInfo->blockRowsHisto); ++i) {
     pDistInfo->blockRowsHisto[i] += p1.blockRowsHisto[i];
   }
@@ -5463,7 +5459,6 @@ int32_t tSerializeBlockDistInfo(void* buf, int32_t bufLen, const STableBlockDist
   if (tEncodeU16(&encoder, pInfo->numOfFiles) < 0) return -1;
   if (tEncodeU32(&encoder, pInfo->numOfBlocks) < 0) return -1;
   if (tEncodeU32(&encoder, pInfo->numOfTables) < 0) return -1;
-  if (tEncodeU32(&encoder, pInfo->numOfVgroups) < 0) return -1;
 
   if (tEncodeU64(&encoder, pInfo->totalSize) < 0) return -1;
   if (tEncodeU64(&encoder, pInfo->totalRows) < 0) return -1;
@@ -5473,6 +5468,7 @@ int32_t tSerializeBlockDistInfo(void* buf, int32_t bufLen, const STableBlockDist
   if (tEncodeI32(&encoder, pInfo->defMinRows) < 0) return -1;
   if (tEncodeU32(&encoder, pInfo->numOfInmemRows) < 0) return -1;
   if (tEncodeU32(&encoder, pInfo->numOfSmallBlocks) < 0) return -1;
+  if (tEncodeU32(&encoder, pInfo->numOfVgroups) < 0) return -1;
 
   for (int32_t i = 0; i < tListLen(pInfo->blockRowsHisto); ++i) {
     if (tEncodeI32(&encoder, pInfo->blockRowsHisto[i]) < 0) return -1;
@@ -5495,7 +5491,6 @@ int32_t tDeserializeBlockDistInfo(void* buf, int32_t bufLen, STableBlockDistInfo
   if (tDecodeU16(&decoder, &pInfo->numOfFiles) < 0) return -1;
   if (tDecodeU32(&decoder, &pInfo->numOfBlocks) < 0) return -1;
   if (tDecodeU32(&decoder, &pInfo->numOfTables) < 0) return -1;
-  if (tDecodeU32(&decoder, &pInfo->numOfVgroups) < 0) return -1;
 
   if (tDecodeU64(&decoder, &pInfo->totalSize) < 0) return -1;
   if (tDecodeU64(&decoder, &pInfo->totalRows) < 0) return -1;
@@ -5505,6 +5500,7 @@ int32_t tDeserializeBlockDistInfo(void* buf, int32_t bufLen, STableBlockDistInfo
   if (tDecodeI32(&decoder, &pInfo->defMinRows) < 0) return -1;
   if (tDecodeU32(&decoder, &pInfo->numOfInmemRows) < 0) return -1;
   if (tDecodeU32(&decoder, &pInfo->numOfSmallBlocks) < 0) return -1;
+  if (tDecodeU32(&decoder, &pInfo->numOfVgroups) < 0) return -1;
 
   for (int32_t i = 0; i < tListLen(pInfo->blockRowsHisto); ++i) {
     if (tDecodeI32(&decoder, &pInfo->blockRowsHisto[i]) < 0) return -1;

source/libs/index/src/index.c

@@ -126,7 +126,7 @@ int indexOpen(SIndexOpts* opts, const char* path, SIndex** index) {
 
   idx->colObj = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
   idx->version = 1;
-  idx->path = tstrdup(path);
+  idx->path = taosStrdup(path);
   taosThreadMutexInit(&idx->mtx, NULL);
   tsem_init(&idx->sem, 0, 0);
 

source/libs/index/src/indexCache.c

@@ -340,7 +340,7 @@ IndexCache* idxCacheCreate(SIndex* idx, uint64_t suid, const char* colName, int8
 
   cache->mem = idxInternalCacheCreate(type);
   cache->mem->pCache = cache;
-  cache->colName = IDX_TYPE_CONTAIN_EXTERN_TYPE(type, TSDB_DATA_TYPE_JSON) ? tstrdup(JSON_COLUMN) : tstrdup(colName);
+  cache->colName = IDX_TYPE_CONTAIN_EXTERN_TYPE(type, TSDB_DATA_TYPE_JSON) ? taosStrdup(JSON_COLUMN) : taosStrdup(colName);
   cache->type = type;
   cache->index = idx;
   cache->version = 0;
@@ -767,7 +767,7 @@ static bool idxCacheIteratorNext(Iterate* itera) {
 
     iv->type = ct->operaType;
     iv->ver = ct->version;
-    iv->colVal = tstrdup(ct->colVal);
+    iv->colVal = taosStrdup(ct->colVal);
     taosArrayPush(iv->val, &ct->uid);
   }
   return next;

source/libs/index/src/indexFstAutomation.c

@@ -164,7 +164,7 @@ FAutoCtx* automCtxCreate(void* data, AutomationType atype) {
     // add more search type
   }
 
-  ctx->data = (data != NULL ? strdup((char*)data) : NULL);
+  ctx->data = (data != NULL ? taosStrdup((char*)data) : NULL);
   ctx->type = atype;
   ctx->stdata = (void*)sv;
   return ctx;

source/libs/index/src/indexFstRegex.c

@@ -23,7 +23,7 @@ FstRegex *regexCreate(const char *str) {
     return NULL;
   }
 
-  regex->orig = tstrdup(str);
+  regex->orig = taosStrdup(str);
 
   // construct insts based on str
   SArray *insts = taosArrayInit(256, sizeof(uint8_t));

source/libs/index/src/indexTfile.c

@@ -804,7 +804,7 @@ TFileValue* tfileValueCreate(char* val) {
   if (tf == NULL) {
     return NULL;
   }
-  tf->colVal = tstrdup(val);
+  tf->colVal = taosStrdup(val);
   tf->tableId = taosArrayInit(32, sizeof(uint64_t));
   return tf;
 }

source/libs/index/test/fstTest.cc

@@ -599,7 +599,7 @@ void validateTFile(char* arg) {
   std::thread threads[NUM_OF_THREAD];
   // std::vector<std::thread> threads;
   SIndex* index = (SIndex*)taosMemoryCalloc(1, sizeof(SIndex));
-  index->path = strdup(arg);
+  index->path = taosStrdup(arg);
   TFileReader* reader = tfileReaderOpen(index, 0, 20000000, "tag1");
 
   for (int i = 0; i < NUM_OF_THREAD; i++) {

source/libs/nodes/src/nodesCloneFuncs.c

@@ -40,7 +40,7 @@
     if (NULL == (pSrc)->fldname) {             \
       break;                                   \
     }                                          \
-    (pDst)->fldname = strdup((pSrc)->fldname); \
+    (pDst)->fldname = taosStrdup((pSrc)->fldname); \
     if (NULL == (pDst)->fldname) {             \
       return TSDB_CODE_OUT_OF_MEMORY;          \
     }                                          \

source/libs/nodes/test/nodesTestMain.cpp

@@ -28,7 +28,7 @@ static EDealRes rewriterTest(SNode** pNode, void* pContext) {
     }
     SValueNode* pVal = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
     string tmp = to_string(stoi(((SValueNode*)(pOp->pLeft))->literal) + stoi(((SValueNode*)(pOp->pRight))->literal));
-    pVal->literal = strdup(tmp.c_str());
+    pVal->literal = taosStrdup(tmp.c_str());
     nodesDestroyNode(*pNode);
     *pNode = (SNode*)pVal;
   }
@@ -40,12 +40,12 @@ TEST(NodesTest, traverseTest) {
   SOperatorNode* pOp = (SOperatorNode*)pRoot;
   SOperatorNode* pLeft = (SOperatorNode*)nodesMakeNode(QUERY_NODE_OPERATOR);
   pLeft->pLeft = (SNode*)nodesMakeNode(QUERY_NODE_VALUE);
-  ((SValueNode*)(pLeft->pLeft))->literal = strdup("10");
+  ((SValueNode*)(pLeft->pLeft))->literal = taosStrdup("10");
   pLeft->pRight = (SNode*)nodesMakeNode(QUERY_NODE_VALUE);
-  ((SValueNode*)(pLeft->pRight))->literal = strdup("5");
+  ((SValueNode*)(pLeft->pRight))->literal = taosStrdup("5");
   pOp->pLeft = (SNode*)pLeft;
   pOp->pRight = (SNode*)nodesMakeNode(QUERY_NODE_VALUE);
-  ((SValueNode*)(pOp->pRight))->literal = strdup("3");
+  ((SValueNode*)(pOp->pRight))->literal = taosStrdup("3");
 
   EXPECT_EQ(nodeType(pRoot), QUERY_NODE_OPERATOR);
   EDealRes res = DEAL_RES_CONTINUE;

source/libs/parser/inc/sql.y

@@ -301,7 +301,7 @@ create_subtable_clause(A) ::=
 %type multi_drop_clause                                                           { SNodeList* }
 %destructor multi_drop_clause                                                     { nodesDestroyList($$); }
 multi_drop_clause(A) ::= drop_table_clause(B).                                    { A = createNodeList(pCxt, B); }
-multi_drop_clause(A) ::= multi_drop_clause(B) drop_table_clause(C).               { A = addNodeToList(pCxt, B, C); }
+multi_drop_clause(A) ::= multi_drop_clause(B) NK_COMMA drop_table_clause(C).      { A = addNodeToList(pCxt, B, C); }
 
 drop_table_clause(A) ::= exists_opt(B) full_table_name(C).                        { A = createDropTableClause(pCxt, B, C); }
 

source/libs/parser/src/parAstCreater.c

@@ -355,7 +355,7 @@ SNode* createDefaultDatabaseCondValue(SAstCreateContext* pCxt) {
 
   SValueNode* val = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
   CHECK_OUT_OF_MEM(val);
-  val->literal = strdup(pCxt->pQueryCxt->db);
+  val->literal = taosStrdup(pCxt->pQueryCxt->db);
   CHECK_OUT_OF_MEM(val->literal);
   val->isDuration = false;
   val->translate = false;

source/libs/parser/src/parInsertSql.c

@@ -449,7 +449,7 @@ static int32_t parseTagToken(const char** end, SToken* pToken, SSchema* pSchema,
       if (pToken->n + VARSTR_HEADER_SIZE > pSchema->bytes) {
         return generateSyntaxErrMsg(pMsgBuf, TSDB_CODE_PAR_VALUE_TOO_LONG, pSchema->name);
       }
-      val->pData = strdup(pToken->z);
+      val->pData = taosStrdup(pToken->z);
       val->nData = pToken->n;
       break;
     }

source/libs/parser/src/parInsertUtil.c

@@ -144,10 +144,10 @@ int16_t insFindCol(SToken* pColname, int16_t start, int16_t end, SSchema* pSchem
 void insBuildCreateTbReq(SVCreateTbReq* pTbReq, const char* tname, STag* pTag, int64_t suid, const char* sname,
                          SArray* tagName, uint8_t tagNum, int32_t ttl) {
   pTbReq->type = TD_CHILD_TABLE;
-  pTbReq->name = strdup(tname);
+  pTbReq->name = taosStrdup(tname);
   pTbReq->ctb.suid = suid;
   pTbReq->ctb.tagNum = tagNum;
-  if (sname) pTbReq->ctb.stbName = strdup(sname);
+  if (sname) pTbReq->ctb.stbName = taosStrdup(sname);
   pTbReq->ctb.pTag = (uint8_t*)pTag;
   pTbReq->ctb.tagName = taosArrayDup(tagName, NULL);
   pTbReq->ttl = ttl;

source/libs/parser/src/parTranslater.c

@@ -1692,7 +1692,7 @@ static int32_t rewriteFuncToValue(STranslateContext* pCxt, char* pLiteral, SNode
 static int32_t rewriteDatabaseFunc(STranslateContext* pCxt, SNode** pNode) {
   char* pCurrDb = NULL;
   if (NULL != pCxt->pParseCxt->db) {
-    pCurrDb = taosMemoryStrDup((void*)pCxt->pParseCxt->db);
+    pCurrDb = taosStrdup((void*)pCxt->pParseCxt->db);
     if (NULL == pCurrDb) {
       return TSDB_CODE_OUT_OF_MEMORY;
     }
@@ -1701,7 +1701,7 @@ static int32_t rewriteDatabaseFunc(STranslateContext* pCxt, SNode** pNode) {
 }
 
 static int32_t rewriteClentVersionFunc(STranslateContext* pCxt, SNode** pNode) {
-  char* pVer = taosMemoryStrDup((void*)version);
+  char* pVer = taosStrdup((void*)version);
   if (NULL == pVer) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }
@@ -1709,7 +1709,7 @@ static int32_t rewriteClentVersionFunc(STranslateContext* pCxt, SNode** pNode) {
 }
 
 static int32_t rewriteServerVersionFunc(STranslateContext* pCxt, SNode** pNode) {
-  char* pVer = taosMemoryStrDup((void*)pCxt->pParseCxt->svrVer);
+  char* pVer = taosStrdup((void*)pCxt->pParseCxt->svrVer);
   if (NULL == pVer) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }
@@ -1720,7 +1720,7 @@ static int32_t rewriteServerStatusFunc(STranslateContext* pCxt, SNode** pNode) {
   if (pCxt->pParseCxt->nodeOffline) {
     return TSDB_CODE_RPC_NETWORK_UNAVAIL;
   }
-  char* pStatus = taosMemoryStrDup((void*)"1");
+  char* pStatus = taosStrdup((void*)"1");
   return rewriteFuncToValue(pCxt, pStatus, pNode);
 }
 
@@ -1728,7 +1728,7 @@ static int32_t rewriteUserFunc(STranslateContext* pCxt, SNode** pNode) {
   char    userConn[TSDB_USER_LEN + 1 + TSDB_FQDN_LEN] = {0};  // format 'user@host'
   int32_t len = snprintf(userConn, sizeof(userConn), "%s@", pCxt->pParseCxt->pUser);
   taosGetFqdn(userConn + len);
-  char* pUserConn = taosMemoryStrDup((void*)userConn);
+  char* pUserConn = taosStrdup((void*)userConn);
   if (NULL == pUserConn) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }
@@ -4910,7 +4910,7 @@ static int32_t buildCreateStbReq(STranslateContext* pCxt, SCreateTableStmt* pStm
   pReq->numOfColumns = LIST_LENGTH(pStmt->pCols);
   pReq->numOfTags = LIST_LENGTH(pStmt->pTags);
   if (pStmt->pOptions->commentNull == false) {
-    pReq->pComment = strdup(pStmt->pOptions->comment);
+    pReq->pComment = taosStrdup(pStmt->pOptions->comment);
     if (NULL == pReq->pComment) {
       return TSDB_CODE_OUT_OF_MEMORY;
     }
@@ -4978,7 +4978,7 @@ static int32_t buildAlterSuperTableReq(STranslateContext* pCxt, SAlterTableStmt*
   if (TSDB_ALTER_TABLE_UPDATE_OPTIONS == pStmt->alterType) {
     //    pAlterReq->ttl = pStmt->pOptions->ttl;
     if (pStmt->pOptions->commentNull == false) {
-      pAlterReq->comment = strdup(pStmt->pOptions->comment);
+      pAlterReq->comment = taosStrdup(pStmt->pOptions->comment);
       if (NULL == pAlterReq->comment) {
         return TSDB_CODE_OUT_OF_MEMORY;
       }
@@ -5267,7 +5267,7 @@ static int32_t getSmaIndexDstVgId(STranslateContext* pCxt, const char* pDbName,
 }
 
 static int32_t getSmaIndexSql(STranslateContext* pCxt, char** pSql, int32_t* pLen) {
-  *pSql = strdup(pCxt->pParseCxt->pSql);
+  *pSql = taosStrdup(pCxt->pParseCxt->pSql);
   if (NULL == *pSql) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }
@@ -5505,7 +5505,7 @@ static int32_t buildCreateTopicReq(STranslateContext* pCxt, SCreateTopicStmt* pS
   pReq->igExists = pStmt->ignoreExists;
   pReq->withMeta = pStmt->withMeta;
 
-  pReq->sql = strdup(pCxt->pParseCxt->pSql);
+  pReq->sql = taosStrdup(pCxt->pParseCxt->pSql);
   if (NULL == pReq->sql) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }
@@ -6252,7 +6252,7 @@ static int32_t buildCreateStreamReq(STranslateContext* pCxt, SCreateStreamStmt*
 
   int32_t code = buildCreateStreamQuery(pCxt, pStmt, pReq);
   if (TSDB_CODE_SUCCESS == code) {
-    pReq->sql = strdup(pCxt->pParseCxt->pSql);
+    pReq->sql = taosStrdup(pCxt->pParseCxt->pSql);
     if (NULL == pReq->sql) {
       code = TSDB_CODE_OUT_OF_MEMORY;
     }
@@ -7144,10 +7144,10 @@ static int32_t buildNormalTableBatchReq(int32_t acctId, const SCreateTableStmt*
 
   SVCreateTbReq req = {0};
   req.type = TD_NORMAL_TABLE;
-  req.name = strdup(pStmt->tableName);
+  req.name = taosStrdup(pStmt->tableName);
   req.ttl = pStmt->pOptions->ttl;
   if (pStmt->pOptions->commentNull == false) {
-    req.comment = strdup(pStmt->pOptions->comment);
+    req.comment = taosStrdup(pStmt->pOptions->comment);
     if (NULL == req.comment) {
       tdDestroySVCreateTbReq(&req);
       return TSDB_CODE_OUT_OF_MEMORY;
@@ -7306,17 +7306,17 @@ static void addCreateTbReqIntoVgroup(int32_t acctId, SHashObj* pVgroupHashmap, S
 
   struct SVCreateTbReq req = {0};
   req.type = TD_CHILD_TABLE;
-  req.name = strdup(pStmt->tableName);
+  req.name = taosStrdup(pStmt->tableName);
   req.ttl = pStmt->pOptions->ttl;
   if (pStmt->pOptions->commentNull == false) {
-    req.comment = strdup(pStmt->pOptions->comment);
+    req.comment = taosStrdup(pStmt->pOptions->comment);
     req.commentLen = strlen(pStmt->pOptions->comment);
   } else {
     req.commentLen = -1;
   }
   req.ctb.suid = suid;
   req.ctb.tagNum = tagNum;
-  req.ctb.stbName = strdup(sTableNmae);
+  req.ctb.stbName = taosStrdup(sTableNmae);
   req.ctb.pTag = (uint8_t*)pTag;
   req.ctb.tagName = taosArrayDup(tagName, NULL);
   if (pStmt->ignoreExists) {
@@ -7798,7 +7798,7 @@ static int32_t buildUpdateTagValReq(STranslateContext* pCxt, SAlterTableStmt* pS
                                    pStmt->colName);
   }
 
-  pReq->tagName = strdup(pStmt->colName);
+  pReq->tagName = taosStrdup(pStmt->colName);
   if (NULL == pReq->tagName) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }
@@ -7871,7 +7871,7 @@ static int32_t buildAddColReq(STranslateContext* pCxt, SAlterTableStmt* pStmt, S
     return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_ROW_LENGTH, TSDB_MAX_BYTES_PER_ROW);
   }
 
-  pReq->colName = strdup(pStmt->colName);
+  pReq->colName = taosStrdup(pStmt->colName);
   if (NULL == pReq->colName) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }
@@ -7894,7 +7894,7 @@ static int32_t buildDropColReq(STranslateContext* pCxt, SAlterTableStmt* pStmt,
     return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_CANNOT_DROP_PRIMARY_KEY);
   }
 
-  pReq->colName = strdup(pStmt->colName);
+  pReq->colName = taosStrdup(pStmt->colName);
   if (NULL == pReq->colName) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }
@@ -7919,7 +7919,7 @@ static int32_t buildUpdateColReq(STranslateContext* pCxt, SAlterTableStmt* pStmt
     return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_ROW_LENGTH, TSDB_MAX_BYTES_PER_ROW);
   }
 
-  pReq->colName = strdup(pStmt->colName);
+  pReq->colName = taosStrdup(pStmt->colName);
   if (NULL == pReq->colName) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }
@@ -7937,8 +7937,8 @@ static int32_t buildRenameColReq(STranslateContext* pCxt, SAlterTableStmt* pStmt
     return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_DUPLICATED_COLUMN);
   }
 
-  pReq->colName = strdup(pStmt->colName);
+  pReq->colName = taosStrdup(pStmt->colName);
-  pReq->colNewName = strdup(pStmt->newColName);
+  pReq->colNewName = taosStrdup(pStmt->newColName);
   if (NULL == pReq->colName || NULL == pReq->colNewName) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }
@@ -7955,7 +7955,7 @@ static int32_t buildUpdateOptionsReq(STranslateContext* pCxt, SAlterTableStmt* p
 
   if (TSDB_CODE_SUCCESS == code) {
     if (pStmt->pOptions->commentNull == false) {
-      pReq->newComment = strdup(pStmt->pOptions->comment);
+      pReq->newComment = taosStrdup(pStmt->pOptions->comment);
       if (NULL == pReq->newComment) {
         code = TSDB_CODE_OUT_OF_MEMORY;
       } else {
@@ -7971,7 +7971,7 @@ static int32_t buildUpdateOptionsReq(STranslateContext* pCxt, SAlterTableStmt* p
 
 static int32_t buildAlterTbReq(STranslateContext* pCxt, SAlterTableStmt* pStmt, STableMeta* pTableMeta,
                                SVAlterTbReq* pReq) {
-  pReq->tbName = strdup(pStmt->tableName);
+  pReq->tbName = taosStrdup(pStmt->tableName);
   if (NULL == pReq->tbName) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }

source/libs/parser/src/parUtil.c

@@ -971,7 +971,7 @@ static SArray* smaIndexesDup(SArray* pSrc) {
   }
   for (int32_t i = 0; i < size; ++i) {
     STableIndexInfo* pIndex = taosArrayGet(pDst, i);
-    pIndex->expr = taosMemoryStrDup(((STableIndexInfo*)taosArrayGet(pSrc, i))->expr);
+    pIndex->expr = taosStrdup(((STableIndexInfo*)taosArrayGet(pSrc, i))->expr);
     if (NULL == pIndex->expr) {
       taosArrayDestroyEx(pDst, destroySmaIndex);
       return NULL;

source/libs/parser/test/mockCatalogService.cpp

@@ -331,7 +331,7 @@ class MockCatalogServiceImpl {
     info.dstTbUid = getNextId();
     info.dstVgId = pReq->dstVgId;
     genEpSet(&info.epSet);
-    info.expr = strdup(pReq->expr);
+    info.expr = taosStrdup(pReq->expr);
     auto it = index_.find(pReq->stb);
     if (index_.end() == it) {
       index_.insert(std::make_pair(string(pReq->stb), std::vector<STableIndexInfo>{info}));
@@ -374,7 +374,7 @@ class MockCatalogServiceImpl {
 
   STableIndexInfo* copyTableIndexInfo(STableIndexInfo* pDst, const STableIndexInfo* pSrc) const {
     memcpy(pDst, pSrc, sizeof(STableIndexInfo));
-    pDst->expr = strdup(pSrc->expr);
+    pDst->expr = taosStrdup(pSrc->expr);
     return pDst;
   }
 

source/libs/parser/test/parAlterToBalanceTest.cpp

@@ -382,7 +382,7 @@ TEST_F(ParserInitialATest, alterSTable) {
     expect.name[len] = '\0';
     expect.alterType = alterType;
     if (nullptr != pComment) {
-      expect.comment = strdup(pComment);
+      expect.comment = taosStrdup(pComment);
       expect.commentLen = strlen(pComment);
     }
 

source/libs/parser/test/parInitialCTest.cpp

@@ -603,7 +603,7 @@ TEST_F(ParserInitialCTest, createStable) {
         expect.deleteMark2 = deleteMark2;
         // expect.ttl = ttl;
         if (nullptr != pComment) {
-          expect.pComment = strdup(pComment);
+          expect.pComment = taosStrdup(pComment);
           expect.commentLen = strlen(pComment);
         }
       };
@@ -780,7 +780,7 @@ TEST_F(ParserInitialCTest, createStream) {
     snprintf(expect.sourceDB, sizeof(expect.sourceDB), "0.%s", pSrcDb);
     snprintf(expect.targetStbFullName, sizeof(expect.targetStbFullName), "0.test.%s", pDstStb);
     expect.igExists = igExists;
-    expect.sql = strdup(pSql);
+    expect.sql = taosStrdup(pSql);
     expect.createStb = STREAM_CREATE_STABLE_TRUE;
     expect.triggerType = STREAM_TRIGGER_AT_ONCE;
     expect.maxDelay = 0;
@@ -934,13 +934,13 @@ TEST_F(ParserInitialCTest, createTable) {
   auto addCreateTbReq = [&](const char* pName, bool ignoreExists = false, int32_t ttl = TSDB_DEFAULT_TABLE_TTL,
                             const char* pComment = nullptr) {
     SVCreateTbReq req = {0};
-    req.name = strdup(pName);
+    req.name = taosStrdup(pName);
     if (ignoreExists) {
       req.flags |= TD_CREATE_IF_NOT_EXISTS;
     }
     req.ttl = ttl;
     if (nullptr != pComment) {
-      req.comment = strdup(pComment);
+      req.comment = taosStrdup(pComment);
       req.commentLen = strlen(pComment);
     }
     ++expect.nReqs;

source/libs/parser/test/parInitialDTest.cpp

@@ -245,6 +245,7 @@ TEST_F(ParserInitialDTest, dropTable) {
   useDb("root", "test");
 
   run("DROP TABLE t1");
+  run("DROP TABLE t1, st1s1, st1s2");
 }
 
 TEST_F(ParserInitialDTest, dropTopic) {

source/libs/qcom/src/queryUtil.c

@@ -420,7 +420,7 @@ end:
   cJSON_Delete(json);
   taosArrayDestroy(pTagVals);
   if (string == NULL) {
-    string = strdup(TSDB_DATA_NULL_STR_L);
+    string = taosStrdup(TSDB_DATA_NULL_STR_L);
   }
   return string;
 }
@@ -510,20 +510,20 @@ int32_t cloneSVreateTbReq(SVCreateTbReq* pSrc, SVCreateTbReq** pDst) {
 
   (*pDst)->flags = pSrc->flags;
   if (pSrc->name) {
-    (*pDst)->name = strdup(pSrc->name);
+    (*pDst)->name = taosStrdup(pSrc->name);
   }
   (*pDst)->uid = pSrc->uid;
   (*pDst)->ctime = pSrc->ctime;
   (*pDst)->ttl = pSrc->ttl;
   (*pDst)->commentLen = pSrc->commentLen;
   if (pSrc->comment) {
-    (*pDst)->comment = strdup(pSrc->comment);
+    (*pDst)->comment = taosStrdup(pSrc->comment);
   }
   (*pDst)->type = pSrc->type;
 
   if (pSrc->type == TSDB_CHILD_TABLE) {
     if (pSrc->ctb.stbName) {
-      (*pDst)->ctb.stbName = strdup(pSrc->ctb.stbName);
+      (*pDst)->ctb.stbName = taosStrdup(pSrc->ctb.stbName);
     }
     (*pDst)->ctb.tagNum = pSrc->ctb.tagNum;
     (*pDst)->ctb.suid = pSrc->ctb.suid;

source/libs/qcom/src/querymsg.c

@@ -527,7 +527,7 @@ int32_t queryProcessGetSerVerRsp(void *output, char *msg, int32_t msgSize) {
     return code;
   }
 
-  *(char **)output = strdup(out.ver);
+  *(char **)output = taosStrdup(out.ver);
 
   return code;
 }

source/libs/scalar/src/filter.c

@@ -3104,9 +3104,8 @@ static FORCE_INLINE bool filterExecuteImplIsNull(void *pinfo, int32_t numOfRows,
 
   for (int32_t i = 0; i < numOfRows; ++i) {
     uint32_t uidx = info->groups[0].unitIdxs[0];
-    void    *colData = colDataGetData((SColumnInfoData *)info->cunits[uidx].colData, i);
-    p[i] = ((colData == NULL) || colDataIsNull((SColumnInfoData *)info->cunits[uidx].colData, 0, i, NULL));
 
+    p[i] = colDataIsNull((SColumnInfoData *)info->cunits[uidx].colData, 0, i, NULL);
     if (p[i] == 0) {
       all = false;
     } else {
@@ -3130,9 +3129,8 @@ static FORCE_INLINE bool filterExecuteImplNotNull(void *pinfo, int32_t numOfRows
 
   for (int32_t i = 0; i < numOfRows; ++i) {
     uint32_t uidx = info->groups[0].unitIdxs[0];
-    void    *colData = colDataGetData((SColumnInfoData *)info->cunits[uidx].colData, i);
 
-    p[i] = ((colData != NULL) && !colDataIsNull((SColumnInfoData *)info->cunits[uidx].colData, 0, i, NULL));
+    p[i] = !colDataIsNull((SColumnInfoData *)info->cunits[uidx].colData, 0, i, NULL);
     if (p[i] == 0) {
       all = false;
     } else {
@@ -3162,13 +3160,13 @@ bool filterExecuteImplRange(void *pinfo, int32_t numOfRows, SColumnInfoData *pRe
   for (int32_t i = 0; i < numOfRows; ++i) {
     SColumnInfoData *pData = info->cunits[0].colData;
 
-    void *colData = colDataGetData(pData, i);
+    if (colDataIsNull_s(pData, i)) {
-    if (colData == NULL || colDataIsNull_s(pData, i)) {
       all = false;
       p[i] = 0;
       continue;
     }
 
+    void *colData = colDataGetData(pData, i);
     p[i] = (*rfunc)(colData, colData, valData, valData2, func);
 
     if (p[i] == 0) {
@@ -3194,13 +3192,13 @@ bool filterExecuteImplMisc(void *pinfo, int32_t numOfRows, SColumnInfoData *pRes
 
   for (int32_t i = 0; i < numOfRows; ++i) {
     uint32_t uidx = info->groups[0].unitIdxs[0];
-    void    *colData = colDataGetData((SColumnInfoData *)info->cunits[uidx].colData, i);
+    if (colDataIsNull_s((SColumnInfoData *)info->cunits[uidx].colData, i)) {
-    if (colData == NULL || colDataIsNull_s((SColumnInfoData *)info->cunits[uidx].colData, i)) {
       p[i] = 0;
       all = false;
       continue;
     }
 
+    void *colData = colDataGetData((SColumnInfoData *)info->cunits[uidx].colData, i);
     // match/nmatch for nchar type need convert from ucs4 to mbs
     if (info->cunits[uidx].dataType == TSDB_DATA_TYPE_NCHAR &&
         (info->cunits[uidx].optr == OP_TYPE_MATCH || info->cunits[uidx].optr == OP_TYPE_NMATCH)) {

source/libs/scheduler/src/schJob.c

@@ -716,7 +716,7 @@ int32_t schInitJob(int64_t *pJobId, SSchedulerReq *pReq) {
   pJob->attr.localExec = pReq->localReq;
   pJob->conn = *pReq->pConn;
   if (pReq->sql) {
-    pJob->sql = strdup(pReq->sql);
+    pJob->sql = taosStrdup(pReq->sql);
   }
   pJob->pDag = pReq->pDag;
   pJob->allocatorRefId = nodesMakeAllocatorWeakRef(pReq->allocatorRefId);

source/libs/scheduler/src/schRemote.c

@@ -887,7 +887,7 @@ int32_t schUpdateSendTargetInfo(SMsgSendInfo *pMsgSendInfo, SQueryNodeAddr *addr
   } else {
     pMsgSendInfo->target.type = TARGET_TYPE_VNODE;
     pMsgSendInfo->target.vgId = addr->nodeId;
-    pMsgSendInfo->target.dbFName = strdup(pTask->plan->dbFName);
+    pMsgSendInfo->target.dbFName = taosStrdup(pTask->plan->dbFName);
   }
 
   return TSDB_CODE_SUCCESS;

source/libs/stream/src/streamMeta.c

@@ -26,7 +26,7 @@ SStreamMeta* streamMetaOpen(const char* path, void* ahandle, FTaskExpand expandF
   int32_t len = strlen(path) + 20;
   char*   streamPath = taosMemoryCalloc(1, len);
   sprintf(streamPath, "%s/%s", path, "stream");
-  pMeta->path = strdup(streamPath);
+  pMeta->path = taosStrdup(streamPath);
   if (tdbOpen(pMeta->path, 16 * 1024, 1, &pMeta->db, 0) < 0) {
     taosMemoryFree(streamPath);
     goto _err;

source/libs/sync/inc/syncPipeline.h

@@ -68,7 +68,7 @@ void             syncNodeLogReplMgrDestroy(SSyncNode* pNode);
 
 // access
 static FORCE_INLINE int64_t syncLogGetRetryBackoffTimeMs(SSyncLogReplMgr* pMgr) {
-  return (1 << pMgr->retryBackoff) * SYNC_LOG_REPL_RETRY_WAIT_MS;
+  return ((int64_t)1 << pMgr->retryBackoff) * SYNC_LOG_REPL_RETRY_WAIT_MS;
 }
 
 static FORCE_INLINE int32_t syncLogGetNextRetryBackoff(SSyncLogReplMgr* pMgr) {

source/libs/sync/inc/syncRaftEntry.h

@@ -49,39 +49,6 @@ static FORCE_INLINE bool syncLogIsReplicationBarrier(SSyncRaftEntry* pEntry) {
   return pEntry->originalRpcType == TDMT_SYNC_NOOP;
 }
 
-typedef struct SRaftEntryHashCache {
-  SHashObj*     pEntryHash;
-  int32_t       maxCount;
-  int32_t       currentCount;
-  TdThreadMutex mutex;
-  SSyncNode*    pSyncNode;
-} SRaftEntryHashCache;
-
-SRaftEntryHashCache* raftCacheCreate(SSyncNode* pSyncNode, int32_t maxCount);
-void                 raftCacheDestroy(SRaftEntryHashCache* pCache);
-int32_t              raftCachePutEntry(struct SRaftEntryHashCache* pCache, SSyncRaftEntry* pEntry);
-int32_t              raftCacheGetEntry(struct SRaftEntryHashCache* pCache, SyncIndex index, SSyncRaftEntry** ppEntry);
-int32_t              raftCacheGetEntryP(struct SRaftEntryHashCache* pCache, SyncIndex index, SSyncRaftEntry** ppEntry);
-int32_t              raftCacheDelEntry(struct SRaftEntryHashCache* pCache, SyncIndex index);
-int32_t              raftCacheGetAndDel(struct SRaftEntryHashCache* pCache, SyncIndex index, SSyncRaftEntry** ppEntry);
-int32_t              raftCacheClear(struct SRaftEntryHashCache* pCache);
-
-typedef struct SRaftEntryCache {
-  SSkipList*    pSkipList;
-  int32_t       maxCount;
-  int32_t       currentCount;
-  int32_t       refMgr;
-  TdThreadMutex mutex;
-  SSyncNode*    pSyncNode;
-} SRaftEntryCache;
-
-SRaftEntryCache* raftEntryCacheCreate(SSyncNode* pSyncNode, int32_t maxCount);
-void             raftEntryCacheDestroy(SRaftEntryCache* pCache);
-int32_t          raftEntryCachePutEntry(struct SRaftEntryCache* pCache, SSyncRaftEntry* pEntry);
-int32_t          raftEntryCacheGetEntry(struct SRaftEntryCache* pCache, SyncIndex index, SSyncRaftEntry** ppEntry);
-int32_t          raftEntryCacheGetEntryP(struct SRaftEntryCache* pCache, SyncIndex index, SSyncRaftEntry** ppEntry);
-int32_t          raftEntryCacheClear(struct SRaftEntryCache* pCache, int32_t count);
-
 #ifdef __cplusplus
 }
 #endif

source/libs/sync/src/syncAppendEntries.c

@@ -104,6 +104,8 @@ int32_t syncNodeOnAppendEntries(SSyncNode* ths, const SRpcMsg* pRpcMsg) {
   SyncAppendEntries* pMsg = pRpcMsg->pCont;
   SRpcMsg            rpcRsp = {0};
   bool               accepted = false;
+  SSyncRaftEntry*    pEntry = NULL;
+
   // if already drop replica, do not process
   if (!syncNodeInRaftGroup(ths, &(pMsg->srcId))) {
     syncLogRecvAppendEntries(ths, pMsg, "not in my config");
@@ -137,14 +139,13 @@ int32_t syncNodeOnAppendEntries(SSyncNode* ths, const SRpcMsg* pRpcMsg) {
   syncNodeStepDown(ths, pMsg->term);
   syncNodeResetElectTimer(ths);
 
-  if (pMsg->dataLen < (int32_t)sizeof(SSyncRaftEntry)) {
+  if (pMsg->dataLen < sizeof(SSyncRaftEntry)) {
     sError("vgId:%d, incomplete append entries received. prev index:%" PRId64 ", term:%" PRId64 ", datalen:%d",
            ths->vgId, pMsg->prevLogIndex, pMsg->prevLogTerm, pMsg->dataLen);
     goto _IGNORE;
   }
 
-  SSyncRaftEntry* pEntry = syncBuildRaftEntryFromAppendEntries(pMsg);
+  pEntry = syncBuildRaftEntryFromAppendEntries(pMsg);
-
   if (pEntry == NULL) {
     sError("vgId:%d, failed to get raft entry from append entries since %s", ths->vgId, terrstr());
     goto _IGNORE;
@@ -191,5 +192,6 @@ _out:
 
 _IGNORE:
   rpcFreeCont(rpcRsp.pCont);
+  syncEntryDestroy(pEntry);
   return 0;
 }

source/libs/sync/src/syncAppendEntriesReply.c

@@ -40,7 +40,7 @@
 //
 
 int32_t syncNodeOnAppendEntriesReply(SSyncNode* ths, const SRpcMsg* pRpcMsg) {
-  SyncAppendEntriesReply* pMsg = pRpcMsg->pCont;
+  SyncAppendEntriesReply* pMsg = (SyncAppendEntriesReply*)pRpcMsg->pCont;
   int32_t ret = 0;
 
   // if already drop replica, do not process

source/libs/sync/src/syncMain.c

@@ -1126,29 +1126,18 @@ int32_t syncNodeStartStandBy(SSyncNode* pSyncNode) {
 }
 
 void syncNodePreClose(SSyncNode* pSyncNode) {
-  if (pSyncNode != NULL && pSyncNode->pFsm != NULL && pSyncNode->pFsm->FpApplyQueueItems != NULL) {
+  ASSERT(pSyncNode != NULL);
-    while (1) {
+  ASSERT(pSyncNode->pFsm != NULL);
-      int32_t aqItems = pSyncNode->pFsm->FpApplyQueueItems(pSyncNode->pFsm);
+  ASSERT(pSyncNode->pFsm->FpApplyQueueItems != NULL);
-      sTrace("vgId:%d, pre close, %d items in apply queue", pSyncNode->vgId, aqItems);
-      if (aqItems == 0 || aqItems == -1) {
-        break;
-      }
-      taosMsleep(20);
-    }
-  }
 
-#if 0
+  while (1) {
-  if (pSyncNode->pNewNodeReceiver != NULL) {
+    int32_t aqItems = pSyncNode->pFsm->FpApplyQueueItems(pSyncNode->pFsm);
-    if (snapshotReceiverIsStart(pSyncNode->pNewNodeReceiver)) {
+    sTrace("vgId:%d, pre close, %d items in apply queue", pSyncNode->vgId, aqItems);
-      snapshotReceiverStop(pSyncNode->pNewNodeReceiver);
+    if (aqItems == 0 || aqItems == -1) {
+      break;
     }
-
+    taosMsleep(20);
-    sDebug("vgId:%d, snapshot receiver destroy while preclose sync node, data:%p", pSyncNode->vgId,
-           pSyncNode->pNewNodeReceiver);
-    snapshotReceiverDestroy(pSyncNode->pNewNodeReceiver);
-    pSyncNode->pNewNodeReceiver = NULL;
   }
-#endif
 
   // stop elect timer
   syncNodeStopElectTimer(pSyncNode);
@@ -1461,7 +1450,7 @@ void syncNodeDoConfigChange(SSyncNode* pSyncNode, SSyncCfg* pNewConfig, SyncInde
   }
 
   // log begin config change
-  sNInfo(pSyncNode, "begin do config change, from %d to %d", pSyncNode->vgId, oldConfig.replicaNum,
+  sNInfo(pSyncNode, "begin do config change, from %d to %d, replicas:%d", pSyncNode->vgId, oldConfig.replicaNum,
          pNewConfig->replicaNum);
 
   if (IamInNew) {
@@ -1742,8 +1731,7 @@ void syncNodeBecomeLeader(SSyncNode* pSyncNode, const char* debugStr) {
 #endif
 
   // close receiver
-  if (pSyncNode != NULL && pSyncNode->pNewNodeReceiver != NULL &&
+  if (snapshotReceiverIsStart(pSyncNode->pNewNodeReceiver)) {
-      snapshotReceiverIsStart(pSyncNode->pNewNodeReceiver)) {
     snapshotReceiverStop(pSyncNode->pNewNodeReceiver);
   }
 

source/libs/sync/src/syncPipeline.c

@@ -901,7 +901,7 @@ int32_t syncLogReplMgrProcessReplyAsNormal(SSyncLogReplMgr* pMgr, SSyncNode* pNo
       int64_t firstSentMs = pMgr->states[pMgr->startIndex % pMgr->size].timeMs;
       int64_t lastSentMs = pMgr->states[(pMgr->endIndex - 1) % pMgr->size].timeMs;
       int64_t timeDiffMs = lastSentMs - firstSentMs;
-      if (timeDiffMs > 0 && timeDiffMs < (SYNC_LOG_REPL_RETRY_WAIT_MS << (pMgr->retryBackoff - 1))) {
+      if (timeDiffMs > 0 && timeDiffMs < ((int64_t)SYNC_LOG_REPL_RETRY_WAIT_MS << (pMgr->retryBackoff - 1))) {
         pMgr->retryBackoff -= 1;
       }
     }
@@ -928,10 +928,6 @@ SSyncLogReplMgr* syncLogReplMgrCreate() {
   ASSERT(pMgr->size == TSDB_SYNC_LOG_BUFFER_SIZE);
 
   return pMgr;
-
-_err:
-  taosMemoryFree(pMgr);
-  return NULL;
 }
 
 void syncLogReplMgrDestroy(SSyncLogReplMgr* pMgr) {

source/libs/sync/src/syncRaftCfg.c

@@ -224,7 +224,7 @@ _OVER:
 
 int32_t syncAddCfgIndex(SSyncNode *pNode, SyncIndex cfgIndex) {
   SRaftCfg *pCfg = &pNode->raftCfg;
-  if (pCfg->configIndexCount <= MAX_CONFIG_INDEX_COUNT) {
+  if (pCfg->configIndexCount < MAX_CONFIG_INDEX_COUNT) {
     return -1;
   }
 

source/libs/sync/src/syncRaftEntry.c

@@ -102,344 +102,3 @@ void syncEntry2OriginalRpc(const SSyncRaftEntry* pEntry, SRpcMsg* pRpcMsg) {
   pRpcMsg->pCont = rpcMallocCont(pRpcMsg->contLen);
   memcpy(pRpcMsg->pCont, pEntry->data, pRpcMsg->contLen);
 }
-
-SRaftEntryHashCache* raftCacheCreate(SSyncNode* pSyncNode, int32_t maxCount) {
-  SRaftEntryHashCache* pCache = taosMemoryMalloc(sizeof(SRaftEntryHashCache));
-  if (pCache == NULL) {
-    sError("vgId:%d, raft cache create error", pSyncNode->vgId);
-    return NULL;
-  }
-
-  pCache->pEntryHash =
-      taosHashInit(sizeof(SyncIndex), taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
-  if (pCache->pEntryHash == NULL) {
-    sError("vgId:%d, raft cache create hash error", pSyncNode->vgId);
-    return NULL;
-  }
-
-  taosThreadMutexInit(&(pCache->mutex), NULL);
-  pCache->maxCount = maxCount;
-  pCache->currentCount = 0;
-  pCache->pSyncNode = pSyncNode;
-
-  return pCache;
-}
-
-void raftCacheDestroy(SRaftEntryHashCache* pCache) {
-  if (pCache != NULL) {
-    taosThreadMutexLock(&pCache->mutex);
-    taosHashCleanup(pCache->pEntryHash);
-    taosThreadMutexUnlock(&pCache->mutex);
-    taosThreadMutexDestroy(&(pCache->mutex));
-    taosMemoryFree(pCache);
-  }
-}
-
-// success, return 1
-// max count, return 0
-// error, return -1
-int32_t raftCachePutEntry(struct SRaftEntryHashCache* pCache, SSyncRaftEntry* pEntry) {
-  taosThreadMutexLock(&pCache->mutex);
-
-  if (pCache->currentCount >= pCache->maxCount) {
-    taosThreadMutexUnlock(&pCache->mutex);
-    return 0;
-  }
-
-  taosHashPut(pCache->pEntryHash, &(pEntry->index), sizeof(pEntry->index), pEntry, pEntry->bytes);
-  ++(pCache->currentCount);
-
-  sNTrace(pCache->pSyncNode, "raft cache add, type:%s,%d, type2:%s,%d, index:%" PRId64 ", bytes:%d",
-          TMSG_INFO(pEntry->msgType), pEntry->msgType, TMSG_INFO(pEntry->originalRpcType), pEntry->originalRpcType,
-          pEntry->index, pEntry->bytes);
-  taosThreadMutexUnlock(&pCache->mutex);
-  return 1;
-}
-
-// success, return 0
-// error, return -1
-// not exist, return -1, terrno = TSDB_CODE_WAL_LOG_NOT_EXIST
-int32_t raftCacheGetEntry(struct SRaftEntryHashCache* pCache, SyncIndex index, SSyncRaftEntry** ppEntry) {
-  if (ppEntry == NULL) {
-    return -1;
-  }
-  *ppEntry = NULL;
-
-  taosThreadMutexLock(&pCache->mutex);
-  void* pTmp = taosHashGet(pCache->pEntryHash, &index, sizeof(index));
-  if (pTmp != NULL) {
-    SSyncRaftEntry* pEntry = pTmp;
-    *ppEntry = taosMemoryMalloc(pEntry->bytes);
-    memcpy(*ppEntry, pTmp, pEntry->bytes);
-
-    sNTrace(pCache->pSyncNode, "raft cache get, type:%s,%d, type2:%s,%d, index:%" PRId64,
-            TMSG_INFO((*ppEntry)->msgType), (*ppEntry)->msgType, TMSG_INFO((*ppEntry)->originalRpcType),
-            (*ppEntry)->originalRpcType, (*ppEntry)->index);
-    taosThreadMutexUnlock(&pCache->mutex);
-    return 0;
-  }
-
-  taosThreadMutexUnlock(&pCache->mutex);
-  terrno = TSDB_CODE_WAL_LOG_NOT_EXIST;
-  return -1;
-}
-
-// success, return 0
-// error, return -1
-// not exist, return -1, terrno = TSDB_CODE_WAL_LOG_NOT_EXIST
-int32_t raftCacheGetEntryP(struct SRaftEntryHashCache* pCache, SyncIndex index, SSyncRaftEntry** ppEntry) {
-  if (ppEntry == NULL) {
-    return -1;
-  }
-  *ppEntry = NULL;
-
-  taosThreadMutexLock(&pCache->mutex);
-  void* pTmp = taosHashGet(pCache->pEntryHash, &index, sizeof(index));
-  if (pTmp != NULL) {
-    SSyncRaftEntry* pEntry = pTmp;
-    *ppEntry = pEntry;
-
-    sNTrace(pCache->pSyncNode, "raft cache get, type:%s,%d, type2:%s,%d, index:%" PRId64,
-            TMSG_INFO((*ppEntry)->msgType), (*ppEntry)->msgType, TMSG_INFO((*ppEntry)->originalRpcType),
-            (*ppEntry)->originalRpcType, (*ppEntry)->index);
-    taosThreadMutexUnlock(&pCache->mutex);
-    return 0;
-  }
-
-  taosThreadMutexUnlock(&pCache->mutex);
-  terrno = TSDB_CODE_WAL_LOG_NOT_EXIST;
-  return -1;
-}
-
-int32_t raftCacheDelEntry(struct SRaftEntryHashCache* pCache, SyncIndex index) {
-  taosThreadMutexLock(&pCache->mutex);
-  taosHashRemove(pCache->pEntryHash, &index, sizeof(index));
-  --(pCache->currentCount);
-  taosThreadMutexUnlock(&pCache->mutex);
-  return 0;
-}
-
-int32_t raftCacheGetAndDel(struct SRaftEntryHashCache* pCache, SyncIndex index, SSyncRaftEntry** ppEntry) {
-  if (ppEntry == NULL) {
-    return -1;
-  }
-  *ppEntry = NULL;
-
-  taosThreadMutexLock(&pCache->mutex);
-  void* pTmp = taosHashGet(pCache->pEntryHash, &index, sizeof(index));
-  if (pTmp != NULL) {
-    SSyncRaftEntry* pEntry = pTmp;
-    *ppEntry = taosMemoryMalloc(pEntry->bytes);
-    memcpy(*ppEntry, pTmp, pEntry->bytes);
-
-    sNTrace(pCache->pSyncNode, "raft cache get-and-del, type:%s,%d, type2:%s,%d, index:%" PRId64,
-            TMSG_INFO((*ppEntry)->msgType), (*ppEntry)->msgType, TMSG_INFO((*ppEntry)->originalRpcType),
-            (*ppEntry)->originalRpcType, (*ppEntry)->index);
-
-    taosHashRemove(pCache->pEntryHash, &index, sizeof(index));
-    --(pCache->currentCount);
-
-    taosThreadMutexUnlock(&pCache->mutex);
-    return 0;
-  }
-
-  taosThreadMutexUnlock(&pCache->mutex);
-  terrno = TSDB_CODE_WAL_LOG_NOT_EXIST;
-  return -1;
-}
-
-int32_t raftCacheClear(struct SRaftEntryHashCache* pCache) {
-  taosThreadMutexLock(&pCache->mutex);
-  taosHashClear(pCache->pEntryHash);
-  pCache->currentCount = 0;
-  taosThreadMutexUnlock(&pCache->mutex);
-  return 0;
-}
-
-static char* keyFn(const void* pData) {
-  SSyncRaftEntry* pEntry = (SSyncRaftEntry*)pData;
-  return (char*)(&(pEntry->index));
-}
-
-static int cmpFn(const void* p1, const void* p2) { return memcmp(p1, p2, sizeof(SyncIndex)); }
-
-static void freeRaftEntry(void* param) {
-  SSyncRaftEntry* pEntry = (SSyncRaftEntry*)param;
-  syncEntryDestroy(pEntry);
-}
-
-SRaftEntryCache* raftEntryCacheCreate(SSyncNode* pSyncNode, int32_t maxCount) {
-  SRaftEntryCache* pCache = taosMemoryMalloc(sizeof(SRaftEntryCache));
-  if (pCache == NULL) {
-    sError("vgId:%d, raft cache create error", pSyncNode->vgId);
-    return NULL;
-  }
-
-  pCache->pSkipList =
-      tSkipListCreate(MAX_SKIP_LIST_LEVEL, TSDB_DATA_TYPE_BINARY, sizeof(SyncIndex), cmpFn, SL_ALLOW_DUP_KEY, keyFn);
-  if (pCache->pSkipList == NULL) {
-    sError("vgId:%d, raft cache create hash error", pSyncNode->vgId);
-    return NULL;
-  }
-
-  taosThreadMutexInit(&(pCache->mutex), NULL);
-  pCache->refMgr = taosOpenRef(10, freeRaftEntry);
-  pCache->maxCount = maxCount;
-  pCache->currentCount = 0;
-  pCache->pSyncNode = pSyncNode;
-
-  return pCache;
-}
-
-void raftEntryCacheDestroy(SRaftEntryCache* pCache) {
-  if (pCache != NULL) {
-    taosThreadMutexLock(&pCache->mutex);
-    tSkipListDestroy(pCache->pSkipList);
-    if (pCache->refMgr != -1) {
-      taosCloseRef(pCache->refMgr);
-      pCache->refMgr = -1;
-    }
-    taosThreadMutexUnlock(&pCache->mutex);
-    taosThreadMutexDestroy(&(pCache->mutex));
-    taosMemoryFree(pCache);
-  }
-}
-
-// success, return 1
-// max count, return 0
-// error, return -1
-int32_t raftEntryCachePutEntry(struct SRaftEntryCache* pCache, SSyncRaftEntry* pEntry) {
-  taosThreadMutexLock(&pCache->mutex);
-
-  if (pCache->currentCount >= pCache->maxCount) {
-    taosThreadMutexUnlock(&pCache->mutex);
-    return 0;
-  }
-
-  SSkipListNode* pSkipListNode = tSkipListPut(pCache->pSkipList, pEntry);
-  ASSERT(pSkipListNode != NULL);
-  ++(pCache->currentCount);
-
-  pEntry->rid = taosAddRef(pCache->refMgr, pEntry);
-  ASSERT(pEntry->rid >= 0);
-
-  sNTrace(pCache->pSyncNode, "raft cache add, type:%s,%d, type2:%s,%d, index:%" PRId64 ", bytes:%d",
-          TMSG_INFO(pEntry->msgType), pEntry->msgType, TMSG_INFO(pEntry->originalRpcType), pEntry->originalRpcType,
-          pEntry->index, pEntry->bytes);
-  taosThreadMutexUnlock(&pCache->mutex);
-  return 1;
-}
-
-// find one, return 1
-// not found, return 0
-// error, return -1
-int32_t raftEntryCacheGetEntry(struct SRaftEntryCache* pCache, SyncIndex index, SSyncRaftEntry** ppEntry) {
-  ASSERT(ppEntry != NULL);
-  SSyncRaftEntry* pEntry = NULL;
-  int32_t         code = raftEntryCacheGetEntryP(pCache, index, &pEntry);
-  if (code == 1) {
-    int32_t bytes = (int32_t)pEntry->bytes;
-    *ppEntry = taosMemoryMalloc((int64_t)bytes);
-    memcpy(*ppEntry, pEntry, pEntry->bytes);
-    (*ppEntry)->rid = -1;
-  } else {
-    *ppEntry = NULL;
-  }
-  return code;
-}
-
-// find one, return 1
-// not found, return 0
-// error, return -1
-int32_t raftEntryCacheGetEntryP(struct SRaftEntryCache* pCache, SyncIndex index, SSyncRaftEntry** ppEntry) {
-  taosThreadMutexLock(&pCache->mutex);
-
-  SyncIndex index2 = index;
-  int32_t   code = 0;
-
-  SArray* entryPArray = tSkipListGet(pCache->pSkipList, (char*)(&index2));
-  int32_t arraySize = taosArrayGetSize(entryPArray);
-  if (arraySize == 1) {
-    SSkipListNode** ppNode = (SSkipListNode**)taosArrayGet(entryPArray, 0);
-    ASSERT(*ppNode != NULL);
-    *ppEntry = (SSyncRaftEntry*)SL_GET_NODE_DATA(*ppNode);
-    taosAcquireRef(pCache->refMgr, (*ppEntry)->rid);
-    code = 1;
-
-  } else if (arraySize == 0) {
-    code = 0;
-
-  } else {
-    ASSERT(0);
-
-    code = -1;
-  }
-  taosArrayDestroy(entryPArray);
-
-  taosThreadMutexUnlock(&pCache->mutex);
-  return code;
-}
-
-// count = -1, clear all
-// count >= 0, clear count
-// return -1, error
-// return delete count
-int32_t raftEntryCacheClear(struct SRaftEntryCache* pCache, int32_t count) {
-  taosThreadMutexLock(&pCache->mutex);
-  int32_t returnCnt = 0;
-
-  if (count == -1) {
-    // clear all
-    SSkipListIterator* pIter = tSkipListCreateIter(pCache->pSkipList);
-    while (tSkipListIterNext(pIter)) {
-      SSkipListNode* pNode = tSkipListIterGet(pIter);
-      ASSERT(pNode != NULL);
-      SSyncRaftEntry* pEntry = (SSyncRaftEntry*)SL_GET_NODE_DATA(pNode);
-      syncEntryDestroy(pEntry);
-      ++returnCnt;
-    }
-    tSkipListDestroyIter(pIter);
-
-    tSkipListDestroy(pCache->pSkipList);
-    pCache->pSkipList =
-        tSkipListCreate(MAX_SKIP_LIST_LEVEL, TSDB_DATA_TYPE_BINARY, sizeof(SyncIndex), cmpFn, SL_ALLOW_DUP_KEY, keyFn);
-    ASSERT(pCache->pSkipList != NULL);
-
-  } else {
-    // clear count
-    int                i = 0;
-    SSkipListIterator* pIter = tSkipListCreateIter(pCache->pSkipList);
-    SArray*            delNodeArray = taosArrayInit(0, sizeof(SSkipListNode*));
-
-    // free entry
-    while (tSkipListIterNext(pIter)) {
-      SSkipListNode* pNode = tSkipListIterGet(pIter);
-      ASSERT(pNode != NULL);
-      if (i++ >= count) {
-        break;
-      }
-
-      // sDebug("push pNode:%p", pNode);
-      taosArrayPush(delNodeArray, &pNode);
-      ++returnCnt;
-      SSyncRaftEntry* pEntry = (SSyncRaftEntry*)SL_GET_NODE_DATA(pNode);
-
-      // syncEntryDestroy(pEntry);
-      taosRemoveRef(pCache->refMgr, pEntry->rid);
-    }
-    tSkipListDestroyIter(pIter);
-
-    // delete skiplist node
-    int32_t arraySize = taosArrayGetSize(delNodeArray);
-    for (int32_t i = 0; i < arraySize; ++i) {
-      SSkipListNode** ppNode = taosArrayGet(delNodeArray, i);
-      // sDebug("get pNode:%p", *ppNode);
-      tSkipListRemoveNode(pCache->pSkipList, *ppNode);
-    }
-    taosArrayDestroy(delNodeArray);
-  }
-
-  pCache->currentCount -= returnCnt;
-  taosThreadMutexUnlock(&pCache->mutex);
-  return returnCnt;
-}

source/libs/sync/src/syncSnapshot.c

@@ -168,17 +168,19 @@ static int32_t snapshotSend(SSyncSnapshotSender *pSender) {
 
   if (pSender->blockLen > 0) {
     // has read data
-    sSDebug(pSender, "snapshot sender continue to read, blockLen:%d seq:%d", pSender->blockLen, pSender->seq);
+    sSDebug(pSender, "vgId:%d, snapshot sender continue to read, blockLen:%d seq:%d", pSender->pSyncNode->vgId,
+            pSender->blockLen, pSender->seq);
   } else {
     // read finish, update seq to end
     pSender->seq = SYNC_SNAPSHOT_SEQ_END;
-    sSInfo(pSender, "snapshot sender read to the end, blockLen:%d seq:%d", pSender->blockLen, pSender->seq);
+    sSInfo(pSender, "vgId:%d, snapshot sender read to the end, blockLen:%d seq:%d", pSender->pSyncNode->vgId,
+           pSender->blockLen, pSender->seq);
   }
 
   // build msg
   SRpcMsg rpcMsg = {0};
   if (syncBuildSnapshotSend(&rpcMsg, pSender->blockLen, pSender->pSyncNode->vgId) != 0) {
-    sSError(pSender, "snapshot sender build msg failed since %s", pSender->pSyncNode->vgId, terrstr());
+    sSError(pSender, "vgId:%d, snapshot sender build msg failed since %s", pSender->pSyncNode->vgId, terrstr());
     return -1;
   }
 
@@ -340,11 +342,13 @@ void snapshotReceiverDestroy(SSyncSnapshotReceiver *pReceiver) {
   taosMemoryFree(pReceiver);
 }
 
-bool snapshotReceiverIsStart(SSyncSnapshotReceiver *pReceiver) { return pReceiver->start; }
+bool snapshotReceiverIsStart(SSyncSnapshotReceiver *pReceiver) {
+  return (pReceiver != NULL ? pReceiver->start : false);
+}
 
 static int32_t snapshotReceiverStartWriter(SSyncSnapshotReceiver *pReceiver, SyncSnapshotSend *pBeginMsg) {
   if (pReceiver->pWriter != NULL) {
-    sRError(pReceiver, "vgId:%d, snapshot receiver writer is not null");
+    sRError(pReceiver, "vgId:%d, snapshot receiver writer is not null", pReceiver->pSyncNode->vgId);
     terrno = TSDB_CODE_SYN_INTERNAL_ERROR;
     return -1;
   }
@@ -851,8 +855,8 @@ static int32_t syncNodeOnSnapshotPrepRsp(SSyncNode *pSyncNode, SSyncSnapshotSend
          pMsg->snapBeginIndex, snapshot.lastApplyIndex, snapshot.lastApplyTerm);
 
   if (pMsg->snapBeginIndex > snapshot.lastApplyIndex) {
-    sSError(pSender, "prepare snapshot failed since beginIndex:%d larger than applyIndex:%d", pMsg->snapBeginIndex,
+    sSError(pSender, "prepare snapshot failed since beginIndex:%" PRId64 " larger than applyIndex:%" PRId64,
-            snapshot.lastApplyIndex);
+            pMsg->snapBeginIndex, snapshot.lastApplyIndex);
     terrno = TSDB_CODE_SYN_INTERNAL_ERROR;
     return -1;
   }
@@ -966,7 +970,8 @@ int32_t syncNodeOnSnapshotRsp(SSyncNode *pSyncNode, const SRpcMsg *pRpcMsg) {
 
   if (pSender->pReader == NULL || pSender->finish) {
     syncLogRecvSyncSnapshotRsp(pSyncNode, pMsg, "snapshot sender invalid");
-    sSError(pSender, "snapshot sender invalid, pReader:%p finish:%d", pMsg->code, pSender->pReader, pSender->finish);
+    sSError(pSender, "snapshot sender invalid error:%s 0x%x, pReader:%p finish:%d", tstrerror(pMsg->code), pMsg->code,
+            pSender->pReader, pSender->finish);
     terrno = pMsg->code;
     goto _ERROR;
   }

source/libs/tfs/src/tfs.c

@@ -240,7 +240,7 @@ int32_t tfsMkdirRecurAt(STfs *pTfs, const char *rname, SDiskID diskId) {
   if (tfsMkdirAt(pTfs, rname, diskId) < 0) {
     if (errno == ENOENT) {
       // Try to create upper
-      char *s = strdup(rname);
+      char *s = taosStrdup(rname);
 
       // Make a copy of dirname(s) because the implementation of 'dirname' differs on different platforms.
       // Some platform may modify the contents of the string passed into dirname(). Others may return a pointer to
@@ -248,7 +248,7 @@ int32_t tfsMkdirRecurAt(STfs *pTfs, const char *rname, SDiskID diskId) {
       // the pointer directly in this recursion.
       // See
       // https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/dirname.3.html
-      char *dir = strdup(taosDirName(s));
+      char *dir = taosStrdup(taosDirName(s));
 
       if (tfsMkdirRecurAt(pTfs, dir, diskId) < 0) {
         taosMemoryFree(s);