other: merge 3.0

2022-08-15 16:25:39 +08:00 · 2022-08-15 16:25:39 +08:00 · 313a546b85
parent 34e14f770f e7051d7117
commit 313a546b85
113 changed files with 4943 additions and 5094 deletions
--- a/cmake/taostools_CMakeLists.txt.in
+++ b/cmake/taostools_CMakeLists.txt.in
@ -2,7 +2,7 @@
 # taos-tools
 ExternalProject_Add(taos-tools
        GIT_REPOSITORY https://github.com/taosdata/taos-tools.git
-        GIT_TAG 53a0103
+        GIT_TAG d237772
        SOURCE_DIR "${TD_SOURCE_DIR}/tools/taos-tools"
        BINARY_DIR ""
        #BUILD_IN_SOURCE TRUE
--- a/docs/en/07-develop/_sub_java.mdx
+++ b/docs/en/07-develop/_sub_java.mdx
@ -1,7 +1,9 @@
 ```java
 {{#include docs/examples/java/src/main/java/com/taos/example/SubscribeDemo.java}}
 ```
-:::note
-For now Java connector doesn't provide asynchronous subscription, but `TimerTask` can be used to achieve similar purpose.
-
-:::
+```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}}
+```
--- a/docs/en/07-develop/_sub_rust.mdx
+++ b/docs/en/07-develop/_sub_rust.mdx
@ -1,3 +1,3 @@
-```rs
+```rust
 {{#include docs/examples/rust/nativeexample/examples/subscribe_demo.rs}}
 ```
--- a/docs/en/14-reference/03-connector/java.mdx
+++ b/docs/en/14-reference/03-connector/java.mdx
@ -41,19 +41,20 @@ Please refer to [Version Support List](/reference/connector#version-support).

 TDengine currently supports timestamp, number, character, Boolean type, and the corresponding type conversion with Java is as follows:

-| TDengine DataType | JDBCType (driver version < 2.0.24) | JDBCType (driver version > = 2.0.24) |
-| ----------------- | ---------------------------------- | ------------------------------------ |
-| TIMESTAMP         | java.lang.Long                     | java.sql.Timestamp                   |
-| INT               | java.lang.Integer                  | java.lang.Integer                    |
-| BIGINT            | java.lang.Long                     | java.lang.Long                       |
-| FLOAT             | java.lang.Float                    | java.lang.Float                      |
-| DOUBLE            | java.lang.Double                   | java.lang.Double                     |
-| SMALLINT          | java.lang.Short                    | java.lang.Short                      |
-| TINYINT           | java.lang.Byte                     | java.lang.Byte                       |
-| BOOL              | java.lang.Boolean                  | java.lang.Boolean                    |
-| BINARY            | java.lang.String                   | byte array                           |
-| NCHAR             | java.lang.String                   | java.lang.String                     |
-| JSON              | -                                  | java.lang.String                     |
+
+| TDengine DataType | JDBCType  |
+| ----------------- | ---------------------------------- |
+| TIMESTAMP         | java.sql.Timestamp                 |
+| INT               | java.lang.Integer                  |
+| BIGINT            | java.lang.Long                     |
+| FLOAT             | java.lang.Float                    |
+| DOUBLE            | java.lang.Double                   |
+| SMALLINT          | java.lang.Short                    |
+| TINYINT           | java.lang.Byte                     |
+| BOOL              | java.lang.Boolean                  |
+| BINARY            | byte array                         |
+| NCHAR             | java.lang.String                   |
+| JSON              | java.lang.String                   |

 **Note**: Only TAG supports JSON types

@ -81,7 +82,7 @@ Add following dependency in the `pom.xml` file of your Maven project:
 <dependency>
 <groupId>com.taosdata.jdbc</groupId>
 <artifactId>taos-jdbcdriver</artifactId>
- <version>2.0.**</version>
+ <version>3.0.0</version>
 </dependency>
 ```

@ -845,7 +846,13 @@ Please refer to: [JDBC example](https://github.com/taosdata/TDengine/tree/develo

   **Cause**: Currently, TDengine only supports 64-bit JDK.

-   **Solution**: Reinstall the 64-bit JDK. 4.
+   **Solution**: Reinstall the 64-bit JDK.
+
+4. java.lang.NoSuchMethodError: setByteArray
+
+  **Cause**: taos-jdbcdriver version 3.* only supports TDengine 3.0 or above.
+
+  **Solution**: connect TDengine 2.* using taos-jdbcdriver 2.* version.

 For other questions, please refer to [FAQ](/train-faq/faq)

--- a/docs/examples/java/pom.xml
+++ b/docs/examples/java/pom.xml
@ -21,7 +21,7 @@
    <dependency>
      <groupId>com.taosdata.jdbc</groupId>
      <artifactId>taos-jdbcdriver</artifactId>
-      <version>2.0.38</version>
+      <version>3.0.0</version>
    </dependency>
 <!--    ANCHOR_END: dep-->
    <dependency>
--- a/docs/examples/java/src/main/java/com/taos/example/Meters.java
+++ b/docs/examples/java/src/main/java/com/taos/example/Meters.java
@ -0,0 +1,62 @@
+package com.taos.example;
+
+import java.sql.Timestamp;
+
+public class Meters {
+    private Timestamp ts;
+    private float current;
+    private int voltage;
+    private int groupid;
+    private String location;
+
+    public Timestamp getTs() {
+        return ts;
+    }
+
+    public void setTs(Timestamp ts) {
+        this.ts = ts;
+    }
+
+    public float getCurrent() {
+        return current;
+    }
+
+    public void setCurrent(float current) {
+        this.current = current;
+    }
+
+    public int getVoltage() {
+        return voltage;
+    }
+
+    public void setVoltage(int voltage) {
+        this.voltage = voltage;
+    }
+
+    public int getGroupid() {
+        return groupid;
+    }
+
+    public void setGroupid(int groupid) {
+        this.groupid = groupid;
+    }
+
+    public String getLocation() {
+        return location;
+    }
+
+    public void setLocation(String location) {
+        this.location = location;
+    }
+
+    @Override
+    public String toString() {
+        return "Meters{" +
+                "ts=" + ts +
+                ", current=" + current +
+                ", voltage=" + voltage +
+                ", groupid=" + groupid +
+                ", location='" + location + '\'' +
+                '}';
+    }
+}
--- a/docs/examples/java/src/main/java/com/taos/example/MetersDeserializer.java
+++ b/docs/examples/java/src/main/java/com/taos/example/MetersDeserializer.java
@ -0,0 +1,6 @@
+package com.taos.example;
+
+import com.taosdata.jdbc.tmq.ReferenceDeserializer;
+
+public class MetersDeserializer extends ReferenceDeserializer<Meters> {
+}
--- a/docs/examples/java/src/main/java/com/taos/example/SubscribeDemo.java
+++ b/docs/examples/java/src/main/java/com/taos/example/SubscribeDemo.java
@ -1,65 +1,77 @@
 package com.taos.example;

-import com.taosdata.jdbc.TSDBConnection;
-import com.taosdata.jdbc.TSDBDriver;
-import com.taosdata.jdbc.TSDBResultSet;
-import com.taosdata.jdbc.TSDBSubscribe;
+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.ResultSetMetaData;
 import java.sql.SQLException;
+import java.sql.Statement;
+import java.time.Duration;
+import java.util.Collections;
 import java.util.Properties;
-import java.util.concurrent.TimeUnit;
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.concurrent.atomic.AtomicBoolean;

 public class SubscribeDemo {
-    private static final String topic = "topic-meter-current-bg-10";
-    private static final String sql = "select * from meters where current > 10";
+    private static final String TOPIC = "tmq_topic";
+    private static final String DB_NAME = "meters";
+    private static final AtomicBoolean shutdown = new AtomicBoolean(false);

    public static void main(String[] args) {
-        Connection connection = null;
-        TSDBSubscribe subscribe = null;
-
+        Timer timer = new Timer();
+        timer.schedule(new TimerTask() {
+            public void run() {
+                shutdown.set(true);
+            }
+        }, 3_000);
        try {
+            // prepare
            Class.forName("com.taosdata.jdbc.TSDBDriver");
+            String jdbcUrl = "jdbc:TAOS://127.0.0.1:6030/?user=root&password=taosdata";
+            Connection connection = DriverManager.getConnection(jdbcUrl);
+            try (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(16))");
+                statement.executeUpdate("CREATE TABLE `d0` USING `meters` TAGS(0, 'Los Angles')");
+                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, 'San Francisco') 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(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
-            properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
-            String jdbcUrl = "jdbc:TAOS://127.0.0.1:6030/power?user=root&password=taosdata";
-            connection = DriverManager.getConnection(jdbcUrl, properties);
-            // create subscribe
-            subscribe = ((TSDBConnection) connection).subscribe(topic, sql, true); 
-            int count = 0;
-            while (count < 10) {
-                // wait 1 second to avoid frequent calls to consume
-                TimeUnit.SECONDS.sleep(1); 
-                // consume
-                TSDBResultSet resultSet = subscribe.consume();
-                if (resultSet == null) {
-                    continue;
-                }
-                ResultSetMetaData metaData = resultSet.getMetaData();
-                while (resultSet.next()) {
-                    int columnCount = metaData.getColumnCount();
-                    for (int i = 1; i <= columnCount; i++) {
-                        System.out.print(metaData.getColumnLabel(i) + ": " + resultSet.getString(i) + "\t");
+            properties.setProperty(TMQConstants.BOOTSTRAP_SERVERS, "127.0.0.1:6030");
+            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.taosdata.jdbc.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);
                    }
-                    System.out.println();
-                    count++;
                }
            }
-        } catch (Exception e) {
+        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
-        } finally {
-            try {
-                if (null != subscribe)
-                    // close subscribe
-                    subscribe.close(true);
-                if (connection != null)
-                    connection.close();
-            } catch (SQLException throwable) {
-                throwable.printStackTrace();
-            }
        }
+        timer.cancel();
    }
 }
--- a/docs/zh/01-index.md
+++ b/docs/zh/01-index.md
@ -4,7 +4,7 @@ sidebar_label: 文档首页
 slug: /
 ---

-TDengine是一款[开源](https://www.taosdata.com/tdengine/open_source_time-series_database)、[高性能](https://www.taosdata.com/fast)、[云原生](https://www.taosdata.com/tdengine/cloud_native_time-series_database)的时序数据库(Time-Series Database, TSDB), 它专为物联网、工业互联网、金融等场景优化设计。同时它还带有内建的缓存、流式计算、数据订阅等系统功能，能大幅减少系统设计的复杂度，降低研发和运营成本，是一极简的时序数据处理平台。本文档是 TDengine 用户手册，主要是介绍 TDengine 的基本概念、安装、使用、功能、开发接口、运营维护、TDengine 内核设计等等，它主要是面向架构师、开发者与系统管理员的。
+TDengine是一款[开源](https://www.taosdata.com/tdengine/open_source_time-series_database)、[高性能](https://www.taosdata.com/fast)、[云原生](https://www.taosdata.com/tdengine/cloud_native_time-series_database)的<a href="https://www.taosdata.com/" data-internallinksmanager029f6b8e52c="2" title="时序数据库" target="_blank" rel="noopener">时序数据库</a>（<a href="https://www.taosdata.com/time-series-database" data-internallinksmanager029f6b8e52c="9" title="Time Series DataBase" target="_blank" rel="noopener">Time Series Database</a>, <a href="https://www.taosdata.com/tsdb" data-internallinksmanager029f6b8e52c="8" title="TSDB" target="_blank" rel="noopener">TSDB</a>）, 它专为物联网、工业互联网、金融等场景优化设计。同时它还带有内建的缓存、流式计算、数据订阅等系统功能，能大幅减少系统设计的复杂度，降低研发和运营成本，是一极简的时序数据处理平台。本文档是 TDengine 用户手册，主要是介绍 TDengine 的基本概念、安装、使用、功能、开发接口、运营维护、TDengine 内核设计等等，它主要是面向架构师、开发者与系统管理员的。

 TDengine 充分利用了时序数据的特点，提出了“一个数据采集点一张表”与“超级表”的概念，设计了创新的存储引擎，让数据的写入、查询和存储效率都得到极大的提升。为正确理解并使用TDengine, 无论如何，请您仔细阅读[基本概念](./concept)一章。

--- a/docs/zh/02-intro.md
+++ b/docs/zh/02-intro.md
@ -3,7 +3,7 @@ title: 产品简介
 toc_max_heading_level: 2
 ---

-TDengine 是一款[开源](https://www.taosdata.com/tdengine/open_source_time-series_database)、[高性能](https://www.taosdata.com/tdengine/fast)、[云原生](https://www.taosdata.com/tdengine/cloud_native_time-series_database)的时序数据库 (Time-Series Database, TSDB)。TDengine 能被广泛运用于物联网、工业互联网、车联网、IT 运维、金融等领域。除核心的时序数据库功能外，TDengine 还提供[缓存](../develop/cache/)、[数据订阅](../develop/tmq)、[流式计算](../develop/stream)等功能，是一极简的时序数据处理平台，最大程度的减小系统设计的复杂度，降低研发和运营成本。
+TDengine 是一款[开源](https://www.taosdata.com/tdengine/open_source_time-series_database)、[高性能](https://www.taosdata.com/tdengine/fast)、[云原生](https://www.taosdata.com/tdengine/cloud_native_time-series_database)的<a href="https://www.taosdata.com/" data-internallinksmanager029f6b8e52c="2" title="时序数据库" target="_blank" rel="noopener">时序数据库</a>（<a href="https://www.taosdata.com/time-series-database" data-internallinksmanager029f6b8e52c="9" title="Time Series DataBase" target="_blank" rel="noopener">Time Series Database</a>, <a href="https://www.taosdata.com/tsdb" data-internallinksmanager029f6b8e52c="8" title="TSDB" target="_blank" rel="noopener">TSDB</a>）。TDengine 能被广泛运用于物联网、工业互联网、车联网、IT 运维、金融等领域。除核心的时序数据库功能外，TDengine 还提供[缓存](../develop/cache/)、[数据订阅](../develop/tmq)、[流式计算](../develop/stream)等功能，是一极简的时序数据处理平台，最大程度的减小系统设计的复杂度，降低研发和运营成本。

 本章节介绍TDengine的主要功能、竞争优势、适用场景、与其他数据库的对比测试等等，让大家对TDengine有个整体的了解。

--- a/docs/zh/05-get-started/01-docker.md
+++ b/docs/zh/05-get-started/01-docker.md
@ -13,7 +13,7 @@ title: 通过 Docker 快速体验 TDengine
 如果已经安装了 docker， 只需执行下面的命令。

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

 注意：TDengine 3.0 服务端仅使用 6030 TCP 端口。6041 为 taosAdapter 所使用提供 REST 服务端口。6043-6049 为 taosAdapter 提供第三方应用接入所使用端口，可根据需要选择是否打开。
--- a/docs/zh/05-get-started/03-package.md
+++ b/docs/zh/05-get-started/03-package.md
@ -29,6 +29,7 @@ echo "deb [arch=amd64] http://repos.taosdata.com/tdengine-stable stable main" |
 如果安装 Beta 版需要安装包仓库

 ```bash
+wget -qO - http://repos.taosdata.com/tdengine.key | sudo apt-key add -
 echo "deb [arch=amd64] http://repos.taosdata.com/tdengine-beta beta main" | sudo tee /etc/apt/sources.list.d/tdengine-beta.list
 ```

--- a/docs/zh/07-develop/06-stream.md
+++ b/docs/zh/07-develop/06-stream.md
@ -4,8 +4,16 @@ description: "TDengine 流式计算将数据的写入、预处理、复杂分析
 title: 流式计算
 ---

-在时序数据的处理中，经常要对原始数据进行清洗、预处理，再使用时序数据库进行长久的储存。用户通常需要在时序数据库之外再搭建 Kafka、Flink、Spark 等流计算处理引擎，增加了用户的开发成本和维护成本。
-使用 TDengine 3.0 的流式计算引擎能够最大限度的减少对这些额外中间件的依赖，真正将数据的写入、预处理、长期存储、复杂分析、实时计算、实时报警触发等功能融为一体，并且，所有这些任务只需要使用 SQL 完成，极大降低了用户的学习成本、使用成本。
+在时序数据的处理中，经常要对原始数据进行清洗、预处理，再使用时序数据库进行长久的储存。在传统的时序数据解决方案中，常常需要部署 Kafka、Flink 等流处理系统。而流处理系统的复杂性，带来了高昂的开发与运维成本。
+
+TDengine 3.0 的流式计算引擎提供了实时处理写入的数据流的能力，使用 SQL 定义实时流变换，当数据被写入流的源表后，数据会被以定义的方式自动处理，并根据定义的触发模式向目的表推送结果。它提供了替代复杂流处理系统的轻量级解决方案，并能够在高吞吐的数据写入的情况下，提供毫秒级的计算结果延迟。
+
+流式计算可以包含数据过滤，标量函数计算（含UDF），以及窗口聚合（支持滑动窗口、会话窗口与状态窗口），可以以超级表、子表、普通表为源表，写入到目的超级表。在创建流时，目的超级表将被自动创建，随后新插入的数据会被流定义的方式处理并写入其中，通过 partition by 子句，可以以表名或标签划分 partition，不同的 partition 将写入到目的超级表的不同子表。
+
+TDengine 的流式计算能够支持分布在多个 vnode 中的超级表聚合；还能够处理乱序数据的写入：它提供了 watermark 机制以度量容忍数据乱序的程度，并提供了 ignore expired 配置项以决定乱序数据的处理策略——丢弃或者重新计算。
+
+详见 [流式计算](../../taos-sql/stream)
+

 ## 流式计算的创建

@ -14,7 +22,7 @@ CREATE STREAM [IF NOT EXISTS] stream_name [stream_options] INTO stb_name AS subq
 stream_options: {
 TRIGGER    [AT_ONCE | WINDOW_CLOSE | MAX_DELAY time]
 WATERMARK   time
- IGNORE EXPIRED
+ IGNORE EXPIRED [0 | 1]
 }
 ```

@ -59,7 +67,7 @@ insert into d1004 values("2018-10-03 14:38:05.000", 10.80000, 223, 0.29000);
 insert into d1004 values("2018-10-03 14:38:06.500", 11.50000, 221, 0.35000);
 ```

-### 查询以观查结果
+### 查询以观察结果

 ```sql
 taos> select start, end, max_current from current_stream_output_stb;
@ -88,7 +96,7 @@ create stream power_stream into power_stream_output_stb as select ts, concat_ws(

 参考示例一 [写入数据](#写入数据)

-### 查询以观查结果
+### 查询以观察结果
 ```sql
 taos> select ts, meter_location, active_power, reactive_power from power_stream_output_stb;
           ts            |         meter_location         |       active_power        |      reactive_power       |
--- a/docs/zh/07-develop/_sub_java.mdx
+++ b/docs/zh/07-develop/_sub_java.mdx
@ -1,7 +1,9 @@
 ```java
 {{#include docs/examples/java/src/main/java/com/taos/example/SubscribeDemo.java}}
 ```
-:::note
-目前 Java 接口没有提供异步订阅模式，但用户程序可以通过创建 `TimerTask` 等方式达到同样的效果。
-
-:::
+```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}}
+```
--- a/docs/zh/07-develop/_sub_rust.mdx
+++ b/docs/zh/07-develop/_sub_rust.mdx
@ -1,3 +1,3 @@
-```rs
+```rust
 {{#include docs/examples/rust/nativeexample/examples/subscribe_demo.rs}}
 ```
--- a/docs/zh/12-taos-sql/01-data-type.md
+++ b/docs/zh/12-taos-sql/01-data-type.md
@ -34,7 +34,7 @@ CREATE DATABASE db_name PRECISION 'ns';
 | 7   |  DOUBLE   | 8         | 双精度浮点型，有效位数 15-16，范围 [-1.7E308, 1.7E308]      |
 | 8   |  BINARY   | 自定义    | 记录单字节字符串，建议只用于处理 ASCII 可见字符，中文等多字节字符需使用 nchar。 |
 | 9   | SMALLINT  | 2         | 短整型， 范围 [-32768, 32767]         |
-| 10 | SMALLINT UNSIGNED | 2| 无符号短整型，范围 [0, 655357] |
+| 10 | SMALLINT UNSIGNED | 2| 无符号短整型，范围 [0, 65535] |
 | 11   |  TINYINT  | 1         | 单字节整型，范围 [-128, 127]   |
 | 12 | TINYINT UNSIGNED | 1 | 无符号单字节整型，范围 [0, 255] |
 | 13   |   BOOL    | 1         | 布尔型，{true, false}     |
--- a/docs/zh/12-taos-sql/13-tmq.md
+++ b/docs/zh/12-taos-sql/13-tmq.md
@ -1,6 +1,6 @@
 ---
-sidebar_label: 消息队列
-title: 消息队列
+sidebar_label: 数据订阅
+title: 数据订阅
 ---

 TDengine 3.0.0.0 开始对消息队列做了大幅的优化和增强以简化用户的解决方案。
@ -8,24 +8,17 @@ TDengine 3.0.0.0 开始对消息队列做了大幅的优化和增强以简化用
 ## 创建订阅主题

 ```sql
-CREATE TOPIC [IF NOT EXISTS] topic_name AS {subquery | DATABASE db_name | STABLE stb_name };
+CREATE TOPIC [IF NOT EXISTS] topic_name AS subquery;
 ```

-订阅主题包括三种：列订阅、超级表订阅和数据库订阅。

-**列订阅是**用 subquery 描述，支持过滤和标量函数和 UDF 标量函数，不支持 JOIN、GROUP BY、窗口切分子句、聚合函数和 UDF 聚合函数。列订阅规则如下：
+TOPIC 支持过滤和标量函数和 UDF 标量函数，不支持 JOIN、GROUP BY、窗口切分子句、聚合函数和 UDF 聚合函数。列订阅规则如下：

 1. TOPIC 一旦创建则返回结果的字段确定
 2. 被订阅或用于计算的列不可被删除、修改
 3. 列可以新增，但新增的列不出现在订阅结果字段中
 4. 对于 select \*，则订阅展开为创建时所有的列（子表、普通表为数据列，超级表为数据列加标签列）

-**超级表订阅和数据库订阅**规则如下：
-
-1. 被订阅主体的 schema 变更不受限
-2. 返回消息中 schema 是块级别的，每块的 schema 可能不一样
-3. 列变更后写入的数据若未落盘，将以写入时的 schema 返回
-4. 列变更后写入的数据若未已落盘，将以落盘时的 schema 返回

 ## 删除订阅主题

--- a/docs/zh/14-reference/02-rest-api/02-rest-api.mdx
+++ b/docs/zh/14-reference/02-rest-api/02-rest-api.mdx
@ -2,7 +2,7 @@
 title: REST API
 ---

-为支持各种不同类型平台的开发，TDengine 提供符合 REST 设计标准的 API，即 REST API。为最大程度降低学习成本，不同于其他数据库 REST API 的设计方法，TDengine 直接通过 HTTP POST 请求 BODY 中包含的 SQL 语句来操作数据库，仅需要一个 URL。REST 连接器的使用参见[视频教程](https://www.taosdata.com/blog/2020/11/11/1965.html)。
+为支持各种不同类型平台的开发，TDengine 提供符合 REST 设计标准的 API，即 REST API。为最大程度降低学习成本，不同于其他数据库 REST API 的设计方法，TDengine 直接通过 HTTP POST 请求 BODY 中包含的 SQL 语句来操作数据库，仅需要一个 URL。REST 连接器的使用参见 [视频教程](https://www.taosdata.com/blog/2020/11/11/1965.html)。

 :::note
 与原生连接器的一个区别是，RESTful 接口是无状态的，因此 `USE db_name` 指令没有效果，所有对表名、超级表名的引用都需要指定数据库名前缀。支持在 RESTful URL 中指定 db_name，这时如果 SQL 语句中没有指定数据库名前缀的话，会使用 URL 中指定的这个 db_name。
@ -20,8 +20,10 @@ RESTful 接口不依赖于任何 TDengine 的库，因此客户端不需要安

 下面示例是列出所有的数据库，请把 h1.taosdata.com 和 6041（缺省值）替换为实际运行的 TDengine 服务 FQDN 和端口号：

-```html
-curl -L -H "Authorization: Basic cm9vdDp0YW9zZGF0YQ==" -d "show databases;" h1.taosdata.com:6041/rest/sql
+```bash
+curl -L -H "Authorization: Basic cm9vdDp0YW9zZGF0YQ==" \
+  -d "select name, ntables, status from information_schema.ins_databases;" \
+  h1.taosdata.com:6041/rest/sql
 ```

 返回值结果如下表示验证通过：
@ -35,188 +37,27 @@ curl -L -H "Authorization: Basic cm9vdDp0YW9zZGF0YQ==" -d "show databases;" h1.t
            "VARCHAR",
            64
        ],
-        [
-            "create_time",
-            "TIMESTAMP",
-            8
-        ],
-        [
-            "vgroups",
-            "SMALLINT",
-            2
-        ],
        [
            "ntables",
            "BIGINT",
            8
        ],
-        [
-            "replica",
-            "TINYINT",
-            1
-        ],
-        [
-            "strict",
-            "VARCHAR",
-            4
-        ],
-        [
-            "duration",
-            "VARCHAR",
-            10
-        ],
-        [
-            "keep",
-            "VARCHAR",
-            32
-        ],
-        [
-            "buffer",
-            "INT",
-            4
-        ],
-        [
-            "pagesize",
-            "INT",
-            4
-        ],
-        [
-            "pages",
-            "INT",
-            4
-        ],
-        [
-            "minrows",
-            "INT",
-            4
-        ],
-        [
-            "maxrows",
-            "INT",
-            4
-        ],
-        [
-            "comp",
-            "TINYINT",
-            1
-        ],
-        [
-            "precision",
-            "VARCHAR",
-            2
-        ],
        [
            "status",
            "VARCHAR",
            10
-        ],
-        [
-            "retention",
-            "VARCHAR",
-            60
-        ],
-        [
-            "single_stable",
-            "BOOL",
-            1
-        ],
-        [
-            "cachemodel",
-            "VARCHAR",
-            11
-        ],
-        [
-            "cachesize",
-            "INT",
-            4
-        ],
-        [
-            "wal_level",
-            "TINYINT",
-            1
-        ],
-        [
-            "wal_fsync_period",
-            "INT",
-            4
-        ],
-        [
-            "wal_retention_period",
-            "INT",
-            4
-        ],
-        [
-            "wal_retention_size",
-            "BIGINT",
-            8
-        ],
-        [
-            "wal_roll_period",
-            "INT",
-            4
-        ],
-        [
-            "wal_seg_size",
-            "BIGINT",
-            8
        ]
    ],
    "data": [
        [
            "information_schema",
-            null,
-            null,
-            14,
-            null,
-            null,
-            null,
-            null,
-            null,
-            null,
-            null,
-            null,
-            null,
-            null,
-            null,
-            "ready",
-            null,
-            null,
-            null,
-            null,
-            null,
-            null,
-            null,
-            null,
-            null,
-            null
+            16,
+            "ready"
        ],
        [
            "performance_schema",
-            null,
-            null,
-            3,
-            null,
-            null,
-            null,
-            null,
-            null,
-            null,
-            null,
-            null,
-            null,
-            null,
-            null,
-            "ready",
-            null,
-            null,
-            null,
-            null,
-            null,
-            null,
-            null,
-            null,
-            null,
-            null
+            9,
+            "ready"
        ]
    ],
    "rows": 2
@ -231,21 +72,21 @@ http://<fqdn>:<port>/rest/sql/[db_name]

 参数说明：

- fqnd: 集群中的任一台主机 FQDN 或 IP 地址
- port: 配置文件中 httpPort 配置项，缺省为 6041
+- fqnd: 集群中的任一台主机 FQDN 或 IP 地址。
+- port: 配置文件中 httpPort 配置项，缺省为 6041。
 - db_name: 可选参数，指定本次所执行的 SQL 语句的默认数据库库名。

 例如：`http://h1.taos.com:6041/rest/sql/test` 是指向地址为 `h1.taos.com:6041` 的 URL，并将默认使用的数据库库名设置为 `test`。

 HTTP 请求的 Header 里需带有身份认证信息，TDengine 支持 Basic 认证与自定义认证两种机制，后续版本将提供标准安全的数字签名机制来做身份验证。

- [自定义身份认证信息](#自定义授权码)如下所示
+- [自定义身份认证信息](#自定义授权码)如下所示：

  ```text
  Authorization: Taosd <TOKEN>
  ```

- Basic 身份认证信息如下所示
+- Basic 身份认证信息如下所示：

  ```text
  Authorization: Basic <TOKEN>
@ -259,13 +100,13 @@ HTTP 请求的 BODY 里就是一个完整的 SQL 语句，SQL 语句中的数据
 curl -L -H "Authorization: Basic <TOKEN>" -d "<SQL>" <ip>:<PORT>/rest/sql/[db_name]
 ```

-或者
+或者，

 ```bash
 curl -L -u username:password -d "<SQL>" <ip>:<PORT>/rest/sql/[db_name]
 ```

-其中，`TOKEN` 为 `{username}:{password}` 经过 Base64 编码之后的字符串，例如 `root:taosdata` 编码后为 `cm9vdDp0YW9zZGF0YQ==`
+其中，`TOKEN` 为 `{username}:{password}` 经过 Base64 编码之后的字符串，例如 `root:taosdata` 编码后为 `cm9vdDp0YW9zZGF0YQ==`。

 ## HTTP 返回格式

@ -282,27 +123,9 @@ curl -L -u username:password -d "<SQL>" <ip>:<PORT>/rest/sql/[db_name]

 ### HTTP body 结构

-<table>
-<tr>
-  <th>执行结果</th>
-  <th>说明</th>
-  <th>样例</th>
-</tr>
-<tr>
-  <td>正确执行</td>
-  <td>
-  code：（int）0 代表成功
-  <br/>
-  <br/>
-  column_meta：（[][3]any）列信息，每个列会用三个值来说明，分别为：列名(string)、列类型(string)、类型长度(int)
-  <br/>
-  <br/>
-  rows：（int）数据返回行数
-  <br/>
-  <br/>
-  data：（[][]any）具体数据内容
-  </td>
-  <td>
+#### 正确执行
+
+样例：

 ```json
 {
@ -313,23 +136,16 @@ curl -L -u username:password -d "<SQL>" <ip>:<PORT>/rest/sql/[db_name]
 }
 ```

-  </td>
-</tr>
-<tr>
-    <td>正确查询</td>
-    <td>
-    code：（int）0 代表成功
-    <br/>
-    <br/>
-    column_meta：（[][3]any） 列信息，每个列会用三个值来说明，分别为：列名（string）、列类型（string）、类型长度（int）
-    <br/>
-    <br/>
-    rows：（int）数据返回行数
-    <br/>
-    <br/>
-    data：（[][]any）具体数据内容
-  </td>
-  <td>
+说明：
+
+- code：（`int`）0 代表成功。
+- column_meta：（`[1][3]any`）只返回 `[["affected_rows", "INT", 4]]`。
+- rows：（`int`）只返回 `1`。
+- data：（`[][]any`）返回受影响行数。
+
+#### 正确查询
+
+样例：

 ```json
 {
@ -385,17 +201,35 @@ curl -L -u username:password -d "<SQL>" <ip>:<PORT>/rest/sql/[db_name]
 }
 ```

-  </td>
-</tr>
-<tr>
-  <td>错误</td>
-  <td>
-  code：（int）错误码
-  <br/>
-  <br/>
-  desc：（string）错误描述
-  </td>
-  <td>
+说明：
+
+- code：（`int`）0 代表成功。
+- column_meta：（`[][3]any`） 列信息，每个列会用三个值来说明，分别为：列名（string）、列类型（string）、类型长度（int）。
+- rows：（`int`）数据返回行数。
+- data：（`[][]any`）具体数据内容（时间格式仅支持 RFC3339，结果集为 0 时区）。
+
+列类型使用如下字符串：
+
+- "NULL"
+- "BOOL"
+- "TINYINT"
+- "SMALLINT"
+- "INT"
+- "BIGINT"
+- "FLOAT"
+- "DOUBLE"
+- "VARCHAR"
+- "TIMESTAMP"
+- "NCHAR"
+- "TINYINT UNSIGNED"
+- "SMALLINT UNSIGNED"
+- "INT UNSIGNED"
+- "BIGINT UNSIGNED"
+- "JSON"
+
+#### 错误
+
+样例：

 ```json
 {
@ -404,30 +238,10 @@ curl -L -u username:password -d "<SQL>" <ip>:<PORT>/rest/sql/[db_name]
 }
 ```

-  </td>
-</tr>
-</table>
+说明：

-### 说明
-
- 时间格式仅支持 RFC3339，结果集为 0 时区
- 列类型使用如下字符串:
-    > "NULL"
-    > "BOOL"
-    > "TINYINT"
-    > "SMALLINT"
-    > "INT"
-    > "BIGINT"
-    > "FLOAT"
-    > "DOUBLE"
-    > "VARCHAR"
-    > "TIMESTAMP"
-    > "NCHAR"
-    > "TINYINT UNSIGNED"
-    > "SMALLINT UNSIGNED"
-    > "INT UNSIGNED"
-    > "BIGINT UNSIGNED"
-    > "JSON"
+- code：（`int`）错误码。
+- desc：（`string`）错误描述。

 ## 自定义授权码

@ -439,11 +253,9 @@ curl http://<fqnd>:<port>/rest/login/<username>/<password>

 其中，`fqdn` 是 TDengine 数据库的 FQDN 或 IP 地址，`port` 是 TDengine 服务的端口号，`username` 为数据库用户名，`password` 为数据库密码，返回值为 JSON 格式，各字段含义如下：

- status：请求结果的标志位
-
- code：返回值代码
-
- desc：授权码
+- status：请求结果的标志位。
+- code：返回值代码。
+- desc：授权码。

 获取授权码示例：

--- a/docs/zh/14-reference/03-connector/cpp.mdx
+++ b/docs/zh/14-reference/03-connector/cpp.mdx
@ -404,47 +404,3 @@ TDengine 的异步 API 均采用非阻塞调用模式。应用程序可以用多

  **支持版本**
  该功能接口从 2.3.0.0 版本开始支持。
-
-### 订阅和消费 API
-
-订阅 API 目前支持订阅一张或多张表，并通过定期轮询的方式不断获取写入表中的最新数据。
-
- `TAOS_SUB *taos_subscribe(TAOS* taos, int restart, const char* topic, const char *sql, TAOS_SUBSCRIBE_CALLBACK fp, void *param, int interval)`
-
-  该函数负责启动订阅服务，成功时返回订阅对象，失败时返回 `NULL`，其参数为：
-
-  - taos：已经建立好的数据库连接
-  - restart：如果订阅已经存在，是重新开始，还是继续之前的订阅
-  - topic：订阅的主题（即名称），此参数是订阅的唯一标识
-  - sql：订阅的查询语句，此语句只能是 `select` 语句，只应查询原始数据，只能按时间正序查询数据
-  - fp：收到查询结果时的回调函数（稍后介绍函数原型），只在异步调用时使用，同步调用时此参数应该传 `NULL`
-  - param：调用回调函数时的附加参数，系统 API 将其原样传递到回调函数，不进行任何处理
-  - interval：轮询周期，单位为毫秒。异步调用时，将根据此参数周期性的调用回调函数，为避免对系统性能造成影响，不建议将此参数设置的过小；同步调用时，如两次调用 `taos_consume()` 的间隔小于此周期，API 将会阻塞，直到时间间隔超过此周期。
-
- `typedef void (*TAOS_SUBSCRIBE_CALLBACK)(TAOS_SUB* tsub, TAOS_RES *res, void* param, int code)`
-
-  异步模式下，回调函数的原型，其参数为：
-
-  - tsub：订阅对象
-  - res：查询结果集，注意结果集中可能没有记录
-  - param：调用 `taos_subscribe()` 时客户程序提供的附加参数
-  - code：错误码
-
-  :::note
-  在这个回调函数里不可以做耗时过长的处理，尤其是对于返回的结果集中数据较多的情况，否则有可能导致客户端阻塞等异常状态。如果必须进行复杂计算，则建议在另外的线程中进行处理。
-
-  :::
-
- `TAOS_RES *taos_consume(TAOS_SUB *tsub)`
-
-  同步模式下，该函数用来获取订阅的结果。 用户应用程序将其置于一个循环之中。 如两次调用 `taos_consume()` 的间隔小于订阅的轮询周期，API 将会阻塞，直到时间间隔超过此周期。如果数据库有新记录到达，该 API 将返回该最新的记录，否则返回一个没有记录的空结果集。 如果返回值为 `NULL`，说明系统出错。 异步模式下，用户程序不应调用此 API。
-
-  :::note
-  在调用 `taos_consume()` 之后，用户应用应确保尽快调用 `taos_fetch_row()` 或 `taos_fetch_block()` 来处理订阅结果，否则服务端会持续缓存查询结果数据等待客户端读取，极端情况下会导致服务端内存消耗殆尽，影响服务稳定性。
-
-  :::
-
- `void taos_unsubscribe(TAOS_SUB *tsub, int keepProgress)`
-
-  取消订阅。 如参数 `keepProgress` 不为 0，API 会保留订阅的进度信息，后续调用 `taos_subscribe()` 时可以基于此进度继续；否则将删除进度信息，后续只能重新开始读取数据。
-
--- a/docs/zh/14-reference/03-connector/java.mdx
+++ b/docs/zh/14-reference/03-connector/java.mdx
@ -83,7 +83,7 @@ Maven 项目中，在 pom.xml 中添加以下依赖：
 <dependency>
 <groupId>com.taosdata.jdbc</groupId>
 <artifactId>taos-jdbcdriver</artifactId>
- <version>2.0.**</version>
+ <version>3.0.0</version>
 </dependency>
 ```

@ -712,7 +712,7 @@ while(true) {
 }
 ```

-`poll` 方法返回一个结果集，其中包含从上次 `poll` 到目前为止的所有新数据。请务必按需选择合理的调用 `poll` 的频率（如例子中的 `Duration.ofMillis(100)`），否则会给服务端造成不必要的压力。
+`poll` 每次调用获取一个消息。

 #### 关闭订阅

@ -900,7 +900,13 @@ public static void main(String[] args) throws Exception {

   **解决方法**：重新安装 64 位 JDK。

-4. 其它问题请参考 [FAQ](../../../train-faq/faq)
+4. java.lang.NoSuchMethodError: setByteArray
+
+  **原因**：taos-jdbcdriver 3.* 版本仅支持 TDengine 3.0 及以上版本。
+
+  **解决方法**： 使用 taos-jdbcdriver 2.* 版本连接 TDengine 2.* 版本。
+
+其它问题请参考 [FAQ](../../../train-faq/faq)

 ## API 参考

--- a/include/libs/stream/tstream.h
+++ b/include/libs/stream/tstream.h
@ -275,12 +275,8 @@ typedef struct SStreamTask {
  int32_t nodeId;
  SEpSet  epSet;

-  // used for task source and sink,
-  // while task agg should have processedVer for each child
  int64_t recoverSnapVer;
  int64_t startVer;
-  int64_t checkpointVer;
-  int64_t processedVer;

  // children info
  SArray* childEpInfo;  // SArray<SStreamChildEpInfo*>
--- a/source/client/src/tmq.c
+++ b/source/client/src/tmq.c
@ -381,6 +381,9 @@ int32_t tmqCommitCb(void* param, SDataBuf* pBuf, int32_t code) {
  }
 #endif

+  taosMemoryFree(pParam->pOffset);
+  if (pBuf->pData) taosMemoryFree(pBuf->pData);
+
  /*tscDebug("receive offset commit cb of %s on vgId:%d, offset is %" PRId64, pParam->pOffset->subKey, pParam->->vgId,
   * pOffset->version);*/

@ -402,6 +405,8 @@ int32_t tmqCommitCb(void* param, SDataBuf* pBuf, int32_t code) {
      tsem_post(&pParamSet->rspSem);
    }

+    taosMemoryFree(pParamSet);
+
 #if 0
    taosArrayDestroyP(pParamSet->successfulOffsets, taosMemoryFree);
    taosArrayDestroyP(pParamSet->failedOffsets, taosMemoryFree);
@ -611,12 +616,12 @@ int32_t tmqCommitInner(tmq_t* tmq, const TAOS_RES* msg, int8_t automatic, int8_t
    }
  }

-#if 0
  if (!async) {
+#if 0
    taosArrayDestroyP(pParamSet->successfulOffsets, taosMemoryFree);
    taosArrayDestroyP(pParamSet->failedOffsets, taosMemoryFree);
-  }
 #endif
+  }

  return 0;
 }
@ -1216,6 +1221,7 @@ END:
  } else {
    taosMemoryFree(pParam);
  }
+  taosMemoryFree(pMsg->pData);
  return code;
 }

--- a/source/dnode/vnode/inc/vnode.h
+++ b/source/dnode/vnode/inc/vnode.h
@ -129,19 +129,19 @@ typedef struct STsdbReader STsdbReader;
 #define LASTROW_RETRIEVE_TYPE_ALL    0x1
 #define LASTROW_RETRIEVE_TYPE_SINGLE 0x2

-int32_t tsdbSetTableId(STsdbReader *pReader, int64_t uid);
-int32_t tsdbReaderOpen(SVnode *pVnode, SQueryTableDataCond *pCond, SArray *pTableList, STsdbReader **ppReader,
-                       const char *idstr);
-void    tsdbReaderClose(STsdbReader *pReader);
-bool    tsdbNextDataBlock(STsdbReader *pReader);
-void    tsdbRetrieveDataBlockInfo(STsdbReader *pReader, SDataBlockInfo *pDataBlockInfo);
-int32_t tsdbRetrieveDatablockSMA(STsdbReader *pReader, SColumnDataAgg ***pBlockStatis, bool *allHave);
-SArray *tsdbRetrieveDataBlock(STsdbReader *pTsdbReadHandle, SArray *pColumnIdList);
-int32_t tsdbReaderReset(STsdbReader *pReader, SQueryTableDataCond *pCond);
-int32_t tsdbGetFileBlocksDistInfo(STsdbReader *pReader, STableBlockDistInfo *pTableBlockInfo);
-int64_t tsdbGetNumOfRowsInMemTable(STsdbReader *pHandle);
-void   *tsdbGetIdx(SMeta *pMeta);
-void   *tsdbGetIvtIdx(SMeta *pMeta);
+int32_t  tsdbSetTableId(STsdbReader *pReader, int64_t uid);
+int32_t  tsdbReaderOpen(SVnode *pVnode, SQueryTableDataCond *pCond, SArray *pTableList, STsdbReader **ppReader,
+                        const char *idstr);
+void     tsdbReaderClose(STsdbReader *pReader);
+bool     tsdbNextDataBlock(STsdbReader *pReader);
+void     tsdbRetrieveDataBlockInfo(STsdbReader *pReader, SDataBlockInfo *pDataBlockInfo);
+int32_t  tsdbRetrieveDatablockSMA(STsdbReader *pReader, SColumnDataAgg ***pBlockStatis, bool *allHave);
+SArray  *tsdbRetrieveDataBlock(STsdbReader *pTsdbReadHandle, SArray *pColumnIdList);
+int32_t  tsdbReaderReset(STsdbReader *pReader, SQueryTableDataCond *pCond);
+int32_t  tsdbGetFileBlocksDistInfo(STsdbReader *pReader, STableBlockDistInfo *pTableBlockInfo);
+int64_t  tsdbGetNumOfRowsInMemTable(STsdbReader *pHandle);
+void    *tsdbGetIdx(SMeta *pMeta);
+void    *tsdbGetIvtIdx(SMeta *pMeta);
 uint64_t getReaderMaxVersion(STsdbReader *pReader);

 int32_t tsdbLastRowReaderOpen(void *pVnode, int32_t type, SArray *pTableIdList, int32_t numOfCols, void **pReader);
--- a/source/dnode/vnode/src/inc/vnd.h
+++ b/source/dnode/vnode/src/inc/vnd.h
@ -80,7 +80,7 @@ int32_t vnodeQueryOpen(SVnode* pVnode);
 void    vnodeQueryClose(SVnode* pVnode);
 int32_t vnodeGetTableMeta(SVnode* pVnode, SRpcMsg* pMsg, bool direct);
 int     vnodeGetTableCfg(SVnode* pVnode, SRpcMsg* pMsg, bool direct);
-int32_t vnodeGetBatchMeta(SVnode *pVnode, SRpcMsg *pMsg);
+int32_t vnodeGetBatchMeta(SVnode* pVnode, SRpcMsg* pMsg);

 // vnodeCommit.c
 int32_t vnodeBegin(SVnode* pVnode);
@ -98,6 +98,7 @@ void    vnodeSyncStart(SVnode* pVnode);
 void    vnodeSyncClose(SVnode* pVnode);
 void    vnodeRedirectRpcMsg(SVnode* pVnode, SRpcMsg* pMsg);
 bool    vnodeIsLeader(SVnode* pVnode);
+bool    vnodeIsRoleLeader(SVnode* pVnode);

 #ifdef __cplusplus
 }
--- a/source/dnode/vnode/src/inc/vnodeInt.h
+++ b/source/dnode/vnode/src/inc/vnodeInt.h
@ -144,6 +144,7 @@ int32_t     tsdbDeleteTableData(STsdb* pTsdb, int64_t version, tb_uid_t suid, tb
 STsdbReader tsdbQueryCacheLastT(STsdb* tsdb, SQueryTableDataCond* pCond, STableListInfo* tableList, uint64_t qId,
                                void* pMemRef);
 int32_t     tsdbSetKeepCfg(STsdb* pTsdb, STsdbCfg* pCfg);
+int32_t     tsdbGetStbIdList(SMeta* pMeta, int64_t suid, SArray* list);

 // tq
 int     tqInit();
@ -170,9 +171,8 @@ int32_t tqProcessTaskRecoverRsp(STQ* pTq, SRpcMsg* pMsg);
 int32_t tqProcessTaskRetrieveReq(STQ* pTq, SRpcMsg* pMsg);
 int32_t tqProcessTaskRetrieveRsp(STQ* pTq, SRpcMsg* pMsg);

-
-SSubmitReq* tdBlockToSubmit(SVnode* pVnode, const SArray* pBlocks, const STSchema* pSchema, bool createTb, int64_t suid,
-                            const char* stbFullName, int32_t vgId, SBatchDeleteReq* pDeleteReq);
+SSubmitReq* tqBlockToSubmit(SVnode* pVnode, const SArray* pBlocks, const STSchema* pSchema, bool createTb, int64_t suid,
+                            const char* stbFullName, SBatchDeleteReq* pDeleteReq);

 // sma
 int32_t smaInit();
--- a/source/dnode/vnode/src/meta/metaTable.c
+++ b/source/dnode/vnode/src/meta/metaTable.c
@ -298,14 +298,14 @@ int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
    tdbTbcClose(pUidIdxc);

    terrno = TSDB_CODE_TDB_STB_NOT_EXIST;
-    // ASSERT(0);
    return -1;
  }

  ret = tdbTbcGet(pUidIdxc, NULL, NULL, &pData, &nData);
  if (ret < 0) {
+    tdbTbcClose(pUidIdxc);
+
    terrno = TSDB_CODE_TDB_STB_NOT_EXIST;
-    // ASSERT(0);
    return -1;
  }

--- a/source/dnode/vnode/src/sma/smaTimeRange.c
+++ b/source/dnode/vnode/src/sma/smaTimeRange.c
@ -201,9 +201,8 @@ int32_t tdProcessTSmaInsertImpl(SSma *pSma, int64_t indexUid, const char *msg) {
  }

  SBatchDeleteReq deleteReq;
-  SSubmitReq     *pSubmitReq =
-      tdBlockToSubmit(pSma->pVnode, (const SArray *)msg, pTsmaStat->pTSchema, true, pTsmaStat->pTSma->dstTbUid,
-                      pTsmaStat->pTSma->dstTbName, pTsmaStat->pTSma->dstVgId, &deleteReq);
+  SSubmitReq     *pSubmitReq = tqBlockToSubmit(pSma->pVnode, (const SArray *)msg, pTsmaStat->pTSchema, true,
+                                               pTsmaStat->pTSma->dstTbUid, pTsmaStat->pTSma->dstTbName, &deleteReq);

  if (!pSubmitReq) {
    smaError("vgId:%d, failed to gen submit blk while tsma insert for smaIndex %" PRIi64 " since %s", SMA_VID(pSma),
--- a/source/dnode/vnode/src/tq/tqPush.c
+++ b/source/dnode/vnode/src/tq/tqPush.c
@ -14,6 +14,7 @@
 */

 #include "tq.h"
+#include "vnd.h"

 #if 0
 void tqTmrRspFunc(void* param, void* tmrId) {
@ -212,9 +213,7 @@ int32_t tqPushMsgNew(STQ* pTq, void* msg, int32_t msgLen, tmsg_t msgType, int64_
 #endif

 int tqPushMsg(STQ* pTq, void* msg, int32_t msgLen, tmsg_t msgType, int64_t ver) {
-  walApplyVer(pTq->pVnode->pWal, ver);
-
-  if (msgType == TDMT_VND_SUBMIT) {
+  if (vnodeIsRoleLeader(pTq->pVnode) && msgType == TDMT_VND_SUBMIT) {
    if (taosHashGetSize(pTq->pStreamMeta->pTasks) == 0) return 0;

    void* data = taosMemoryMalloc(msgLen);
--- a/source/dnode/vnode/src/tq/tqSink.c
+++ b/source/dnode/vnode/src/tq/tqSink.c
@ -25,8 +25,7 @@ int32_t tdBuildDeleteReq(SVnode* pVnode, const char* stbFullName, const SSDataBl
  SColumnInfoData* pGidCol = taosArrayGet(pDataBlock->pDataBlock, GROUPID_COLUMN_INDEX);
  for (int32_t row = 0; row < totRow; row++) {
    int64_t ts = *(int64_t*)colDataGetData(pTsCol, row);
-    /*int64_t     groupId = *(int64_t*)colDataGetData(pGidCol, row);*/
-    int64_t groupId = 0;
+    int64_t groupId = *(int64_t*)colDataGetData(pGidCol, row);
    char*   name = buildCtbNameByGroupId(stbFullName, groupId);
    tqDebug("stream delete msg: groupId :%ld, name: %s", groupId, name);
    SMetaReader mr = {0};
@ -49,8 +48,8 @@ int32_t tdBuildDeleteReq(SVnode* pVnode, const char* stbFullName, const SSDataBl
  return 0;
 }

-SSubmitReq* tdBlockToSubmit(SVnode* pVnode, const SArray* pBlocks, const STSchema* pTSchema, bool createTb,
-                            int64_t suid, const char* stbFullName, int32_t vgId, SBatchDeleteReq* pDeleteReq) {
+SSubmitReq* tqBlockToSubmit(SVnode* pVnode, const SArray* pBlocks, const STSchema* pTSchema, bool createTb,
+                            int64_t suid, const char* stbFullName, SBatchDeleteReq* pDeleteReq) {
  SSubmitReq* ret = NULL;
  SArray*     schemaReqs = NULL;
  SArray*     schemaReqSz = NULL;
@ -153,7 +152,7 @@ SSubmitReq* tdBlockToSubmit(SVnode* pVnode, const SArray* pBlocks, const STSchem
  // assign data
  // TODO
  ret = rpcMallocCont(cap);
-  ret->header.vgId = vgId;
+  ret->header.vgId = pVnode->config.vgId;
  ret->length = sizeof(SSubmitReq);
  ret->numOfBlocks = htonl(sz);

@ -234,8 +233,8 @@ void tqTableSink(SStreamTask* pTask, void* vnode, int64_t ver, void* data) {

  ASSERT(pTask->tbSink.pTSchema);
  deleteReq.deleteReqs = taosArrayInit(0, sizeof(SSingleDeleteReq));
-  SSubmitReq* pReq = tdBlockToSubmit(pVnode, pRes, pTask->tbSink.pTSchema, true, pTask->tbSink.stbUid,
-                                     pTask->tbSink.stbFullName, pVnode->config.vgId, &deleteReq);
+  SSubmitReq* pReq = tqBlockToSubmit(pVnode, pRes, pTask->tbSink.pTSchema, true, pTask->tbSink.stbUid,
+                                     pTask->tbSink.stbFullName, &deleteReq);

  tqDebug("vgId:%d, task %d convert blocks over, put into write-queue", TD_VID(pVnode), pTask->taskId);

--- a/source/dnode/vnode/src/vnd/vnodeSvr.c
+++ b/source/dnode/vnode/src/vnd/vnodeSvr.c
@ -247,6 +247,8 @@ int32_t vnodeProcessWriteMsg(SVnode *pVnode, SRpcMsg *pMsg, int64_t version, SRp

  vTrace("vgId:%d, process %s request success, index:%" PRId64, TD_VID(pVnode), TMSG_INFO(pMsg->msgType), version);

+  walApplyVer(pVnode->pWal, version);
+
  if (tqPushMsg(pVnode->pTq, pMsg->pCont, pMsg->contLen, pMsg->msgType, version) < 0) {
    vError("vgId:%d, failed to push msg to TQ since %s", TD_VID(pVnode), tstrerror(terrno));
    return -1;
--- a/source/dnode/vnode/src/vnd/vnodeSync.c
+++ b/source/dnode/vnode/src/vnd/vnodeSync.c
@ -764,6 +764,8 @@ void vnodeSyncStart(SVnode *pVnode) {

 void vnodeSyncClose(SVnode *pVnode) { syncStop(pVnode->sync); }

+bool vnodeIsRoleLeader(SVnode *pVnode) { return syncGetMyRole(pVnode->sync) == TAOS_SYNC_STATE_LEADER; }
+
 bool vnodeIsLeader(SVnode *pVnode) {
  if (!syncIsReady(pVnode->sync)) {
    vDebug("vgId:%d, vnode not ready, state:%s, restore:%d", pVnode->config.vgId, syncGetMyRoleStr(pVnode->sync),
--- a/source/libs/qworker/src/qworker.c
+++ b/source/libs/qworker/src/qworker.c
@ -1,3 +1,5 @@
+#include "qworker.h"
+
 #include "dataSinkMgt.h"
 #include "executor.h"
 #include "planner.h"
@ -7,7 +9,6 @@
 #include "tcommon.h"
 #include "tmsg.h"
 #include "tname.h"
-#include "qworker.h"

 SQWorkerMgmt gQwMgmt = {
    .lock = 0,
@ -15,7 +16,6 @@ SQWorkerMgmt gQwMgmt = {
    .qwNum = 0,
 };

-
 int32_t qwProcessHbLinkBroken(SQWorker *mgmt, SQWMsg *qwMsg, SSchedulerHbReq *req) {
  int32_t         code = 0;
  SSchedulerHbRsp rsp = {0};
@ -44,8 +44,8 @@ int32_t qwProcessHbLinkBroken(SQWorker *mgmt, SQWMsg *qwMsg, SSchedulerHbReq *re
  QW_RET(TSDB_CODE_SUCCESS);
 }

-static void freeItem(void* param) {
-  SExplainExecInfo* pInfo = param;
+static void freeItem(void *param) {
+  SExplainExecInfo *pInfo = param;
  taosMemoryFree(pInfo->verboseInfo);
 }

@ -54,7 +54,7 @@ int32_t qwHandleTaskComplete(QW_FPARAMS_DEF, SQWTaskCtx *ctx) {

  if (TASK_TYPE_TEMP == ctx->taskType && taskHandle) {
    if (ctx->explain) {
-      SArray* execInfoList = taosArrayInit(4, sizeof(SExplainExecInfo));
+      SArray *execInfoList = taosArrayInit(4, sizeof(SExplainExecInfo));
      QW_ERR_RET(qGetExplainExecInfo(taskHandle, execInfoList));

      SRpcHandleInfo connInfo = ctx->ctrlConnInfo;
@ -81,7 +81,7 @@ int32_t qwExecTask(QW_FPARAMS_DEF, SQWTaskCtx *ctx, bool *queryStop) {
  qTaskInfo_t    taskHandle = ctx->taskHandle;
  DataSinkHandle sinkHandle = ctx->sinkHandle;

-  SArray* pResList = taosArrayInit(4, POINTER_BYTES);
+  SArray *pResList = taosArrayInit(4, POINTER_BYTES);
  while (true) {
    QW_TASK_DLOG("start to execTask, loopIdx:%d", i++);

@ -95,7 +95,7 @@ int32_t qwExecTask(QW_FPARAMS_DEF, SQWTaskCtx *ctx, bool *queryStop) {
        } else {
          QW_TASK_DLOG("qExecTask failed, code:%x - %s", code, tstrerror(code));
        }
-        QW_ERR_RET(code);
+        QW_ERR_JRET(code);
      }
    }

@ -105,7 +105,7 @@ int32_t qwExecTask(QW_FPARAMS_DEF, SQWTaskCtx *ctx, bool *queryStop) {
      QW_TASK_DLOG("qExecTask end with empty res, useconds:%" PRIu64, useconds);
      dsEndPut(sinkHandle, useconds);

-      QW_ERR_RET(qwHandleTaskComplete(QW_FPARAMS(), ctx));
+      QW_ERR_JRET(qwHandleTaskComplete(QW_FPARAMS(), ctx));

      if (queryStop) {
        *queryStop = true;
@ -114,7 +114,7 @@ int32_t qwExecTask(QW_FPARAMS_DEF, SQWTaskCtx *ctx, bool *queryStop) {
      break;
    }

-    for(int32_t j = 0; j < taosArrayGetSize(pResList); ++j) {
+    for (int32_t j = 0; j < taosArrayGetSize(pResList); ++j) {
      SSDataBlock *pRes = taosArrayGetP(pResList, j);
      ASSERT(pRes->info.rows > 0);

@ -122,7 +122,7 @@ int32_t qwExecTask(QW_FPARAMS_DEF, SQWTaskCtx *ctx, bool *queryStop) {
      code = dsPutDataBlock(sinkHandle, &inputData, &qcontinue);
      if (code) {
        QW_TASK_ELOG("dsPutDataBlock failed, code:%x - %s", code, tstrerror(code));
-        QW_ERR_RET(code);
+        QW_ERR_JRET(code);
      }

      QW_TASK_DLOG("data put into sink, rows:%d, continueExecTask:%d", pRes->info.rows, qcontinue);
@ -151,6 +151,11 @@ int32_t qwExecTask(QW_FPARAMS_DEF, SQWTaskCtx *ctx, bool *queryStop) {

  taosArrayDestroy(pResList);
  QW_RET(code);
+
+_return:
+  taosArrayDestroy(pResList);
+
+  return code;
 }

 int32_t qwGenerateSchHbRsp(SQWorker *mgmt, SQWSchStatus *sch, SQWHbInfo *hbInfo) {
@ -222,7 +227,8 @@ int32_t qwGetQueryResFromSink(QW_FPARAMS_DEF, SQWTaskCtx *ctx, int32_t *dataLen,
          QW_ERR_RET(code);
        }

-        QW_TASK_DLOG("no more data in sink and query end, fetched blocks %d rows %d", pOutput->numOfBlocks, pOutput->numOfRows);
+        QW_TASK_DLOG("no more data in sink and query end, fetched blocks %d rows %d", pOutput->numOfBlocks,
+                     pOutput->numOfRows);

        qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_SUCC);
        if (NULL == rsp) {
@ -266,7 +272,8 @@ int32_t qwGetQueryResFromSink(QW_FPARAMS_DEF, SQWTaskCtx *ctx, int32_t *dataLen,
    pOutput->numOfBlocks++;

    if (DS_BUF_EMPTY == pOutput->bufStatus && pOutput->queryEnd) {
-      QW_TASK_DLOG("task all data fetched and done, fetched blocks %d rows %d", pOutput->numOfBlocks, pOutput->numOfRows);
+      QW_TASK_DLOG("task all data fetched and done, fetched blocks %d rows %d", pOutput->numOfBlocks,
+                   pOutput->numOfRows);
      qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_SUCC);
      break;
    }
@ -288,10 +295,10 @@ int32_t qwGetQueryResFromSink(QW_FPARAMS_DEF, SQWTaskCtx *ctx, int32_t *dataLen,
 }

 int32_t qwGetDeleteResFromSink(QW_FPARAMS_DEF, SQWTaskCtx *ctx, SDeleteRes *pRes) {
-  int64_t            len = 0;
-  bool               queryEnd = false;
-  int32_t            code = 0;
-  SOutputData        output = {0};
+  int64_t     len = 0;
+  bool        queryEnd = false;
+  int32_t     code = 0;
+  SOutputData output = {0};

  dsGetDataLength(ctx->sinkHandle, &len, &queryEnd);

@ -312,7 +319,7 @@ int32_t qwGetDeleteResFromSink(QW_FPARAMS_DEF, SQWTaskCtx *ctx, SDeleteRes *pRes
    QW_ERR_RET(code);
  }

-  SDeleterRes* pDelRes = (SDeleterRes*)output.pData;
+  SDeleterRes *pDelRes = (SDeleterRes *)output.pData;

  pRes->suid = pDelRes->suid;
  pRes->uidList = pDelRes->uidList;
@ -326,10 +333,9 @@ int32_t qwGetDeleteResFromSink(QW_FPARAMS_DEF, SQWTaskCtx *ctx, SDeleteRes *pRes
  return TSDB_CODE_SUCCESS;
 }

-
 int32_t qwHandlePrePhaseEvents(QW_FPARAMS_DEF, int8_t phase, SQWPhaseInput *input, SQWPhaseOutput *output) {
-  int32_t         code = 0;
-  SQWTaskCtx     *ctx = NULL;
+  int32_t     code = 0;
+  SQWTaskCtx *ctx = NULL;

  QW_TASK_DLOG("start to handle event at phase %s", qwPhaseStr(phase));

@ -355,8 +361,8 @@ int32_t qwHandlePrePhaseEvents(QW_FPARAMS_DEF, int8_t phase, SQWPhaseInput *inpu
      if (QW_EVENT_RECEIVED(ctx, QW_EVENT_DROP)) {
        QW_ERR_JRET(qwDropTask(QW_FPARAMS()));

-        //qwBuildAndSendDropRsp(&ctx->ctrlConnInfo, code);
-        //QW_TASK_DLOG("drop rsp send, handle:%p, code:%x - %s", ctx->ctrlConnInfo.handle, code, tstrerror(code));
+        // qwBuildAndSendDropRsp(&ctx->ctrlConnInfo, code);
+        // QW_TASK_DLOG("drop rsp send, handle:%p, code:%x - %s", ctx->ctrlConnInfo.handle, code, tstrerror(code));

        QW_ERR_JRET(TSDB_CODE_QRY_TASK_DROPPED);
        break;
@ -391,8 +397,8 @@ int32_t qwHandlePrePhaseEvents(QW_FPARAMS_DEF, int8_t phase, SQWPhaseInput *inpu
      if (QW_EVENT_RECEIVED(ctx, QW_EVENT_DROP)) {
        QW_ERR_JRET(qwDropTask(QW_FPARAMS()));

-        //qwBuildAndSendDropRsp(&ctx->ctrlConnInfo, code);
-        //QW_TASK_DLOG("drop rsp send, handle:%p, code:%x - %s", ctx->ctrlConnInfo.handle, code, tstrerror(code));
+        // qwBuildAndSendDropRsp(&ctx->ctrlConnInfo, code);
+        // QW_TASK_DLOG("drop rsp send, handle:%p, code:%x - %s", ctx->ctrlConnInfo.handle, code, tstrerror(code));

        QW_ERR_JRET(TSDB_CODE_QRY_TASK_DROPPED);
      }
@ -428,9 +434,9 @@ _return:
 }

 int32_t qwHandlePostPhaseEvents(QW_FPARAMS_DEF, int8_t phase, SQWPhaseInput *input, SQWPhaseOutput *output) {
-  int32_t         code = 0;
-  SQWTaskCtx     *ctx = NULL;
-  SRpcHandleInfo  connInfo = {0};
+  int32_t        code = 0;
+  SQWTaskCtx    *ctx = NULL;
+  SRpcHandleInfo connInfo = {0};

  QW_TASK_DLOG("start to handle event at phase %s", qwPhaseStr(phase));

@ -449,8 +455,8 @@ int32_t qwHandlePostPhaseEvents(QW_FPARAMS_DEF, int8_t phase, SQWPhaseInput *inp
      QW_ERR_JRET(TSDB_CODE_QRY_APP_ERROR);
    }

-    //qwBuildAndSendDropRsp(&ctx->ctrlConnInfo, code);
-    //QW_TASK_DLOG("drop rsp send, handle:%p, code:%x - %s", ctx->ctrlConnInfo.handle, code, tstrerror(code));
+    // qwBuildAndSendDropRsp(&ctx->ctrlConnInfo, code);
+    // QW_TASK_DLOG("drop rsp send, handle:%p, code:%x - %s", ctx->ctrlConnInfo.handle, code, tstrerror(code));

    QW_ERR_JRET(qwDropTask(QW_FPARAMS()));
    QW_ERR_JRET(TSDB_CODE_QRY_TASK_DROPPED);
@ -473,7 +479,7 @@ _return:
  if (QW_PHASE_POST_QUERY == phase && ctx) {
    ctx->queryRsped = true;

-    bool rsped = false;
+    bool   rsped = false;
    SQWMsg qwMsg = {.msgType = ctx->msgType, .connInfo = ctx->ctrlConnInfo};
    qwDbgSimulateRedirect(&qwMsg, ctx, &rsped);
    qwDbgSimulateDead(QW_FPARAMS(), ctx, &rsped);
@ -507,7 +513,6 @@ int32_t qwAbortPrerocessQuery(QW_FPARAMS_DEF) {
  QW_RET(TSDB_CODE_SUCCESS);
 }

-
 int32_t qwPreprocessQuery(QW_FPARAMS_DEF, SQWMsg *qwMsg) {
  int32_t        code = 0;
  bool           queryRsped = false;
@ -537,8 +542,7 @@ _return:
  QW_RET(TSDB_CODE_SUCCESS);
 }

-
-int32_t qwProcessQuery(QW_FPARAMS_DEF, SQWMsg *qwMsg, char* sql) {
+int32_t qwProcessQuery(QW_FPARAMS_DEF, SQWMsg *qwMsg, char *sql) {
  int32_t        code = 0;
  bool           queryRsped = false;
  SSubplan      *plan = NULL;
@ -556,7 +560,7 @@ int32_t qwProcessQuery(QW_FPARAMS_DEF, SQWMsg *qwMsg, char* sql) {
  ctx->needFetch = qwMsg->msgInfo.needFetch;
  ctx->msgType = qwMsg->msgType;

-  //QW_TASK_DLOGL("subplan json string, len:%d, %s", qwMsg->msgLen, qwMsg->msg);
+  // QW_TASK_DLOGL("subplan json string, len:%d, %s", qwMsg->msgLen, qwMsg->msg);

  code = qStringToSubplan(qwMsg->msg, &plan);
  if (TSDB_CODE_SUCCESS != code) {
@ -759,8 +763,8 @@ _return:
    }
    if (!rsped) {
      qwBuildAndSendFetchRsp(qwMsg->msgType + 1, &qwMsg->connInfo, rsp, dataLen, code);
-      QW_TASK_DLOG("%s send, handle:%p, code:%x - %s, dataLen:%d", TMSG_INFO(qwMsg->msgType + 1), qwMsg->connInfo.handle, code, tstrerror(code),
-                   dataLen);
+      QW_TASK_DLOG("%s send, handle:%p, code:%x - %s, dataLen:%d", TMSG_INFO(qwMsg->msgType + 1),
+                   qwMsg->connInfo.handle, code, tstrerror(code), dataLen);
    }
  }

@ -919,7 +923,8 @@ void qwProcessHbTimerEvent(void *param, void *tmrId) {
      uint64_t *sId = taosHashGetKey(pIter, NULL);
      QW_TLOG("cancel send hb to sch %" PRIx64 " cause of no connection handle", *sId);

-      if (sch->hbBrokenTs > 0 && ((currentMs - sch->hbBrokenTs) > QW_SCH_TIMEOUT_MSEC) && taosHashGetSize(sch->tasksHash) <= 0) {
+      if (sch->hbBrokenTs > 0 && ((currentMs - sch->hbBrokenTs) > QW_SCH_TIMEOUT_MSEC) &&
+          taosHashGetSize(sch->tasksHash) <= 0) {
        taosArrayPush(pExpiredSch, sId);
      }

@ -998,7 +1003,6 @@ _return:
  QW_RET(TSDB_CODE_SUCCESS);
 }

-
 int32_t qWorkerInit(int8_t nodeType, int32_t nodeId, SQWorkerCfg *cfg, void **qWorkerMgmt, const SMsgCb *pMsgCb) {
  if (NULL == qWorkerMgmt || pMsgCb->mgmt == NULL) {
    qError("invalid param to init qworker");
@ -1119,7 +1123,7 @@ int32_t qWorkerGetStat(SReadHandle *handle, void *qWorkerMgmt, SQWorkerStat *pSt
    QW_RET(TSDB_CODE_QRY_INVALID_INPUT);
  }

-  SQWorker *mgmt = (SQWorker *)qWorkerMgmt;
+  SQWorker     *mgmt = (SQWorker *)qWorkerMgmt;
  SDataSinkStat sinkStat = {0};

  dsDataSinkGetCacheSize(&sinkStat);
@ -1139,6 +1143,3 @@ int32_t qWorkerGetStat(SReadHandle *handle, void *qWorkerMgmt, SQWorkerStat *pSt

  return TSDB_CODE_SUCCESS;
 }
-
-
-
--- a/source/libs/scalar/src/sclfunc.c
+++ b/source/libs/scalar/src/sclfunc.c
@ -642,7 +642,6 @@ static int32_t doTrimFunction(SScalarParam *pInput, int32_t inputNum, SScalarPar
    int32_t charLen = (type == TSDB_DATA_TYPE_VARCHAR) ? len : len / TSDB_NCHAR_SIZE;
    trimFn(input, output, type, charLen);

-    varDataSetLen(output, len);
    colDataAppend(pOutputData, i, output, false);
    output += varDataTLen(output);
  }
--- a/source/libs/transport/inc/transComm.h
+++ b/source/libs/transport/inc/transComm.h
@ -293,7 +293,7 @@ int transSendResponse(const STransMsg* msg);
 int transRegisterMsg(const STransMsg* msg);
 int transSetDefaultAddr(void* shandle, const char* ip, const char* fqdn);

-int transGetSockDebugInfo(struct sockaddr* sockname, char* dst);
+int transSockInfo2Str(struct sockaddr* sockname, char* dst);

 int64_t transAllocHandle();

--- a/source/libs/transport/src/transCli.c
+++ b/source/libs/transport/src/transCli.c
@ -103,14 +103,6 @@ static SCliConn* getConnFromPool(void* pool, char* ip, uint32_t port);
 static void      addConnToPool(void* pool, SCliConn* conn);
 static void      doCloseIdleConn(void* param);

-static int sockDebugInfo(struct sockaddr* sockname, char* dst) {
-  struct sockaddr_in addr = *(struct sockaddr_in*)sockname;
-
-  char buf[16] = {0};
-  int  r = uv_ip4_name(&addr, (char*)buf, sizeof(buf));
-  sprintf(dst, "%s:%d", buf, ntohs(addr.sin_port));
-  return r;
-}
 // register timer for read
 static void cliReadTimeoutCb(uv_timer_t* handle);
 // register timer in each thread to clear expire conn
@ -121,12 +113,14 @@ static void cliAllocRecvBufferCb(uv_handle_t* handle, size_t suggested_size, uv_
 static void cliRecvCb(uv_stream_t* cli, ssize_t nread, const uv_buf_t* buf);
 // callback after write data to socket
 static void cliSendCb(uv_write_t* req, int status);
-// callback after conn  to server
+// callback after conn to server
 static void cliConnCb(uv_connect_t* req, int status);
 static void cliAsyncCb(uv_async_t* handle);
 static void cliIdleCb(uv_idle_t* handle);
 static void cliPrepareCb(uv_prepare_t* handle);

+static bool cliRecvReleaseReq(SCliConn* conn, STransMsgHead* pHead);
+
 static int32_t allocConnRef(SCliConn* conn, bool update);

 static int cliAppCb(SCliConn* pConn, STransMsg* pResp, SCliMsg* pMsg);
@ -361,6 +355,9 @@ void cliHandleResp(SCliConn* conn) {

  SCliMsg*       pMsg = NULL;
  STransConnCtx* pCtx = NULL;
+  if (cliRecvReleaseReq(conn, pHead)) {
+    return;
+  }
  CONN_SHOULD_RELEASE(conn, pHead);

  if (CONN_NO_PERSIST_BY_APP(conn)) {
@ -383,7 +380,7 @@ void cliHandleResp(SCliConn* conn) {
               transMsg.info.ahandle);
      }
    } else {
-      pCtx = pMsg ? pMsg->ctx : NULL;
+      pCtx = pMsg->ctx;
      transMsg.info.ahandle = pCtx ? pCtx->ahandle : NULL;
      tDebug("%s conn %p get ahandle %p, persist: 1", CONN_GET_INST_LABEL(conn), conn, transMsg.info.ahandle);
    }
@ -395,7 +392,6 @@ void cliHandleResp(SCliConn* conn) {
  }

  STraceId* trace = &transMsg.info.traceId;
-
  tGDebug("%s conn %p %s received from %s, local info:%s, len:%d, code str:%s", CONN_GET_INST_LABEL(conn), conn,
          TMSG_INFO(pHead->msgType), conn->dst, conn->src, transMsg.contLen, tstrerror(transMsg.code));

@ -830,11 +826,11 @@ void cliConnCb(uv_connect_t* req, int status) {

  int addrlen = sizeof(peername);
  uv_tcp_getpeername((uv_tcp_t*)pConn->stream, &peername, &addrlen);
-  transGetSockDebugInfo(&peername, pConn->dst);
+  transSockInfo2Str(&peername, pConn->dst);

  addrlen = sizeof(sockname);
  uv_tcp_getsockname((uv_tcp_t*)pConn->stream, &sockname, &addrlen);
-  transGetSockDebugInfo(&sockname, pConn->src);
+  transSockInfo2Str(&sockname, pConn->src);

  tTrace("%s conn %p connect to server successfully", CONN_GET_INST_LABEL(pConn), pConn);
  assert(pConn->stream == req->handle);
@ -1053,6 +1049,30 @@ static void cliPrepareCb(uv_prepare_t* handle) {
  if (thrd->stopMsg != NULL) cliHandleQuit(thrd->stopMsg, thrd);
 }

+bool cliRecvReleaseReq(SCliConn* conn, STransMsgHead* pHead) {
+  if (pHead->release == 1 && (pHead->msgLen) == sizeof(*pHead)) {
+    uint64_t ahandle = pHead->ahandle;
+    SCliMsg* pMsg = NULL;
+    CONN_GET_MSGCTX_BY_AHANDLE(conn, ahandle);
+    transClearBuffer(&conn->readBuf);
+    transFreeMsg(transContFromHead((char*)pHead));
+    if (transQueueSize(&conn->cliMsgs) > 0 && ahandle == 0) {
+      SCliMsg* cliMsg = transQueueGet(&conn->cliMsgs, 0);
+      if (cliMsg->type == Release) return true;
+    }
+    tDebug("%s conn %p receive release request, refId:%" PRId64 "", CONN_GET_INST_LABEL(conn), conn, conn->refId);
+    if (T_REF_VAL_GET(conn) > 1) {
+      transUnrefCliHandle(conn);
+    }
+    destroyCmsg(pMsg);
+    cliReleaseUnfinishedMsg(conn);
+    transQueueClear(&conn->cliMsgs);
+    addConnToPool(((SCliThrd*)conn->hostThrd)->pool, conn);
+    return true;
+  }
+  return false;
+}
+
 static void* cliWorkThread(void* arg) {
  SCliThrd* pThrd = (SCliThrd*)arg;
  pThrd->pid = taosGetSelfPthreadId();
--- a/source/libs/transport/src/transComm.c
+++ b/source/libs/transport/src/transComm.c
@ -77,7 +77,7 @@ void transFreeMsg(void* msg) {
  }
  taosMemoryFree((char*)msg - sizeof(STransMsgHead));
 }
-int transGetSockDebugInfo(struct sockaddr* sockname, char* dst) {
+int transSockInfo2Str(struct sockaddr* sockname, char* dst) {
  struct sockaddr_in addr = *(struct sockaddr_in*)sockname;

  char buf[20] = {0};
--- a/source/libs/transport/src/transSvr.c
+++ b/source/libs/transport/src/transSvr.c
@ -114,6 +114,8 @@ static void uvAcceptAsyncCb(uv_async_t* handle);
 static void uvShutDownCb(uv_shutdown_t* req, int status);
 static void uvPrepareCb(uv_prepare_t* handle);

+static bool uvRecvReleaseReq(SSvrConn* conn, STransMsgHead* pHead);
+
 /*
 * time-consuming task throwed into BG work thread
 */
@ -123,7 +125,7 @@ static void uvWorkAfterTask(uv_work_t* req, int status);
 static void uvWalkCb(uv_handle_t* handle, void* arg);
 static void uvFreeCb(uv_handle_t* handle);

-static void uvStartSendRespInternal(SSvrMsg* smsg);
+static void uvStartSendRespImpl(SSvrMsg* smsg);
 static void uvPrepareSendData(SSvrMsg* msg, uv_buf_t* wb);
 static void uvStartSendResp(SSvrMsg* msg);

@ -154,37 +156,6 @@ static void* transAcceptThread(void* arg);
 static bool addHandleToWorkloop(SWorkThrd* pThrd, char* pipeName);
 static bool addHandleToAcceptloop(void* arg);

-#define CONN_SHOULD_RELEASE(conn, head)                                                                   \
-  do {                                                                                                    \
-    if ((head)->release == 1 && (head->msgLen) == sizeof(*head)) {                                        \
-      reallocConnRef(conn);                                                                               \
-      tTrace("conn %p received release request", conn);                                                   \
-                                                                                                          \
-      STraceId traceId = head->traceId;                                                                   \
-      conn->status = ConnRelease;                                                                         \
-      transClearBuffer(&conn->readBuf);                                                                   \
-      transFreeMsg(transContFromHead((char*)head));                                                       \
-                                                                                                          \
-      STransMsg tmsg = {                                                                                  \
-          .code = 0, .info.handle = (void*)conn, .info.traceId = traceId, .info.ahandle = (void*)0x9527}; \
-      SSvrMsg* srvMsg = taosMemoryCalloc(1, sizeof(SSvrMsg));                                             \
-      srvMsg->msg = tmsg;                                                                                 \
-      srvMsg->type = Release;                                                                             \
-      srvMsg->pConn = conn;                                                                               \
-      if (!transQueuePush(&conn->srvMsgs, srvMsg)) {                                                      \
-        return;                                                                                           \
-      }                                                                                                   \
-      if (conn->regArg.init) {                                                                            \
-        tTrace("conn %p release, notify server app", conn);                                               \
-        STrans* pTransInst = conn->pTransInst;                                                            \
-        (*pTransInst->cfp)(pTransInst->parent, &(conn->regArg.msg), NULL);                                \
-        memset(&conn->regArg, 0, sizeof(conn->regArg));                                                   \
-      }                                                                                                   \
-      uvStartSendRespInternal(srvMsg);                                                                    \
-      return;                                                                                             \
-    }                                                                                                     \
-  } while (0)
-
 #define SRV_RELEASE_UV(loop)       \
  do {                             \
    uv_walk(loop, uvWalkCb, NULL); \
@ -230,7 +201,9 @@ static void uvHandleReq(SSvrConn* pConn) {
  //  transRefSrvHandle(pConn);
  //  uv_queue_work(((SWorkThrd*)pConn->hostThrd)->loop, wreq, uvWorkDoTask, uvWorkAfterTask);

-  CONN_SHOULD_RELEASE(pConn, pHead);
+  if (uvRecvReleaseReq(pConn, pHead)) {
+    return;
+  }

  STransMsg transMsg;
  memset(&transMsg, 0, sizeof(transMsg));
@ -356,10 +329,10 @@ void uvOnSendCb(uv_write_t* req, int status) {

          msg = (SSvrMsg*)transQueueGet(&conn->srvMsgs, 0);
          if (msg != NULL) {
-            uvStartSendRespInternal(msg);
+            uvStartSendRespImpl(msg);
          }
        } else {
-          uvStartSendRespInternal(msg);
+          uvStartSendRespImpl(msg);
        }
      }
    }
@ -423,7 +396,7 @@ static void uvPrepareSendData(SSvrMsg* smsg, uv_buf_t* wb) {
  wb->len = len;
 }

-static void uvStartSendRespInternal(SSvrMsg* smsg) {
+static void uvStartSendRespImpl(SSvrMsg* smsg) {
  SSvrConn* pConn = smsg->pConn;
  if (pConn->broken) {
    return;
@ -453,7 +426,7 @@ static void uvStartSendResp(SSvrMsg* smsg) {
  if (!transQueuePush(&pConn->srvMsgs, smsg)) {
    return;
  }
-  uvStartSendRespInternal(smsg);
+  uvStartSendRespImpl(smsg);
  return;
 }

@ -544,6 +517,35 @@ static void uvShutDownCb(uv_shutdown_t* req, int status) {
  uv_close((uv_handle_t*)req->handle, uvDestroyConn);
  taosMemoryFree(req);
 }
+static bool uvRecvReleaseReq(SSvrConn* pConn, STransMsgHead* pHead) {
+  if ((pHead)->release == 1 && (pHead->msgLen) == sizeof(*pHead)) {
+    reallocConnRef(pConn);
+    tTrace("conn %p received release request", pConn);
+
+    STraceId traceId = pHead->traceId;
+    pConn->status = ConnRelease;
+    transClearBuffer(&pConn->readBuf);
+    transFreeMsg(transContFromHead((char*)pHead));
+
+    STransMsg tmsg = {.code = 0, .info.handle = (void*)pConn, .info.traceId = traceId, .info.ahandle = (void*)0x9527};
+    SSvrMsg*  srvMsg = taosMemoryCalloc(1, sizeof(SSvrMsg));
+    srvMsg->msg = tmsg;
+    srvMsg->type = Release;
+    srvMsg->pConn = pConn;
+    if (!transQueuePush(&pConn->srvMsgs, srvMsg)) {
+      return true;
+    }
+    if (pConn->regArg.init) {
+      tTrace("conn %p release, notify server app", pConn);
+      STrans* pTransInst = pConn->pTransInst;
+      (*pTransInst->cfp)(pTransInst->parent, &(pConn->regArg.msg), NULL);
+      memset(&pConn->regArg, 0, sizeof(pConn->regArg));
+    }
+    uvStartSendRespImpl(srvMsg);
+    return true;
+  }
+  return false;
+}
 static void uvPrepareCb(uv_prepare_t* handle) {
  // prepare callback
  SWorkThrd*  pThrd = handle->data;
@ -696,7 +698,7 @@ void uvOnConnectionCb(uv_stream_t* q, ssize_t nread, const uv_buf_t* buf) {
      transUnrefSrvHandle(pConn);
      return;
    }
-    transGetSockDebugInfo(&peername, pConn->dst);
+    transSockInfo2Str(&peername, pConn->dst);

    addrlen = sizeof(sockname);
    if (0 != uv_tcp_getsockname(pConn->pTcp, (struct sockaddr*)&sockname, &addrlen)) {
@ -704,7 +706,7 @@ void uvOnConnectionCb(uv_stream_t* q, ssize_t nread, const uv_buf_t* buf) {
      transUnrefSrvHandle(pConn);
      return;
    }
-    transGetSockDebugInfo(&sockname, pConn->src);
+    transSockInfo2Str(&sockname, pConn->src);
    struct sockaddr_in addr = *(struct sockaddr_in*)&sockname;

    pConn->clientIp = addr.sin_addr.s_addr;
@ -992,7 +994,7 @@ void uvHandleRelease(SSvrMsg* msg, SWorkThrd* thrd) {
    if (!transQueuePush(&conn->srvMsgs, msg)) {
      return;
    }
-    uvStartSendRespInternal(msg);
+    uvStartSendRespImpl(msg);
    return;
  } else if (conn->status == ConnRelease || conn->status == ConnNormal) {
    tDebug("%s conn %p already released, ignore release-msg", transLabel(thrd->pTransInst), conn);
--- a/tests/pytest/util/taosadapter.py
+++ b/tests/pytest/util/taosadapter.py
@ -238,19 +238,23 @@ class TAdapter:

        if self.running != 0:
            psCmd = f"ps -ef|grep -w {toBeKilled}| grep -v grep | awk '{{print $2}}'"
+            # psCmd = f"pgrep {toBeKilled}"
            processID = subprocess.check_output(
-                psCmd, shell=True).decode("utf-8")
+                psCmd, shell=True)

            while(processID):
-                killCmd = f"kill {signal} {processID} > /dev/null 2>&1"
+                killCmd = f"pkill {signal} {processID} > /dev/null 2>&1"
                os.system(killCmd)
                time.sleep(1)
                processID = subprocess.check_output(
                    psCmd, shell=True).decode("utf-8")
            if not platform.system().lower() == 'windows':
-                for port in range(6030, 6041):
-                    fuserCmd = f"fuser -k -n tcp {port} > /dev/null"
-                    os.system(fuserCmd)
+                port = 6041
+                fuserCmd = f"fuser -k -n tcp {port} > /dev/null"
+                os.system(fuserCmd)
+                # for port in range(6030, 6041):
+                    # fuserCmd = f"fuser -k -n tcp {port} > /dev/null"
+                    # os.system(fuserCmd)

        self.running = 0
        tdLog.debug(f"taosadapter is stopped by kill {signal}")
--- a/tests/system-test/2-query/json_tag.py
+++ b/tests/system-test/2-query/json_tag.py
@ -1,25 +1,8 @@
-###################################################################
-#           Copyright (c) 2016 by TAOS Technologies, Inc.
-#                     All rights reserved.
-#
-#  This file is proprietary and confidential to TAOS Technologies.
-#  No part of this file may be reproduced, db_test.stored, transmitted,
-#  disclosed or used in any form or by any means other than as
-#  expressly provided by the written permission from Jianhui Tao
-#
-###################################################################
-
 # -*- coding: utf-8 -*-

-import imp
-import sys
-import taos
 from util.log import tdLog
 from util.cases import tdCases
 from util.sql import tdSql
-import json
-import os
-

 class TDTestCase:
    def caseDescription(self):
@ -31,35 +14,33 @@ class TDTestCase:
        return

    def init(self, conn, logSql):
-        self.testcasePath = os.path.split(__file__)[0]
-        self.testcaseFilename = os.path.split(__file__)[-1]
-        # os.system("rm -rf %s/%s.sql" % (self.testcasePath,self.testcaseFilename))
        tdLog.debug("start to execute %s" % __file__)
-        tdSql.init(conn.cursor(), True)
+        tdSql.init(conn.cursor(), False)

    def run(self):
        # tdSql.prepare()
-        tdSql.execute('drop database if exists db')
-        tdSql.execute('create database db vgroups 1')
-        tdSql.execute('use db')
+        dbname = "db"
+        tdSql.execute(f'drop database if exists {dbname}')
+        tdSql.execute(f'create database {dbname} vgroups 1')
+        tdSql.execute(f'use {dbname}')
        print("============== STEP 1 ===== prepare data & validate json string")
-        tdSql.error("create table if not exists jsons1(ts timestamp, dataInt int, dataBool bool, dataStr nchar(50), dataStrBin binary(150)) tags(jtag json, tagint int)")
-        tdSql.error("create table if not exists jsons1(ts timestamp, data json) tags(tagint int)")
-        tdSql.execute("create table if not exists jsons1(ts timestamp, dataInt int, dataBool bool, dataStr nchar(50), dataStrBin binary(150)) tags(jtag json)")
-        tdSql.execute("insert into jsons1_1 using jsons1 tags('{\"tag1\":\"fff\",\"tag2\":5, \"tag3\":true}') values(1591060618000, 1, false, 'json1', '你是') (1591060608000, 23, true, '等等', 'json')")
-        tdSql.execute("insert into jsons1_2 using jsons1 tags('{\"tag1\":5,\"tag2\":\"beijing\"}') values (1591060628000, 2, true, 'json2', 'sss')")
-        tdSql.execute("insert into jsons1_3 using jsons1 tags('{\"tag1\":false,\"tag2\":\"beijing\"}') values (1591060668000, 3, false, 'json3', 'efwe')")
-        tdSql.execute("insert into jsons1_4 using jsons1 tags('{\"tag1\":null,\"tag2\":\"shanghai\",\"tag3\":\"hello\"}') values (1591060728000, 4, true, 'json4', '323sd')")
-        tdSql.execute("insert into jsons1_5 using jsons1 tags('{\"tag1\":1.232, \"tag2\":null}') values(1591060928000, 1, false, '你就会', 'ewe')")
-        tdSql.execute("insert into jsons1_6 using jsons1 tags('{\"tag1\":11,\"tag2\":\"\",\"tag2\":null}') values(1591061628000, 11, false, '你就会','')")
-        tdSql.execute("insert into jsons1_7 using jsons1 tags('{\"tag1\":\"收到货\",\"tag2\":\"\",\"tag3\":null}') values(1591062628000, 2, NULL, '你就会', 'dws')")
+        tdSql.error(f"create table if not exists {dbname}.jsons1(ts timestamp, dataInt int, dataBool bool, dataStr nchar(50), dataStrBin binary(150)) tags(jtag json, tagint int)")
+        tdSql.error(f"create table if not exists {dbname}.jsons1(ts timestamp, data json) tags(tagint int)")
+        tdSql.execute(f"create table if not exists {dbname}.jsons1(ts timestamp, dataInt int, dataBool bool, dataStr nchar(50), dataStrBin binary(150)) tags(jtag json)")
+        tdSql.execute(f"insert into {dbname}.jsons1_1 using {dbname}.jsons1 tags('{{\"tag1\":\"fff\",\"tag2\":5, \"tag3\":true}}') values(1591060618000, 1, false, 'json1', '你是') (1591060608000, 23, true, '等等', 'json')")
+        tdSql.execute(f"insert into {dbname}.jsons1_2 using {dbname}.jsons1 tags('{{\"tag1\":5,\"tag2\":\"beijing\"}}') values (1591060628000, 2, true, 'json2', 'sss')")
+        tdSql.execute(f"insert into {dbname}.jsons1_3 using {dbname}.jsons1 tags('{{\"tag1\":false,\"tag2\":\"beijing\"}}') values (1591060668000, 3, false, 'json3', 'efwe')")
+        tdSql.execute(f"insert into {dbname}.jsons1_4 using {dbname}.jsons1 tags('{{\"tag1\":null,\"tag2\":\"shanghai\",\"tag3\":\"hello\"}}') values (1591060728000, 4, true, 'json4', '323sd')")
+        tdSql.execute(f"insert into {dbname}.jsons1_5 using {dbname}.jsons1 tags('{{\"tag1\":1.232, \"tag2\":null}}') values(1591060928000, 1, false, '你就会', 'ewe')")
+        tdSql.execute(f"insert into {dbname}.jsons1_6 using {dbname}.jsons1 tags('{{\"tag1\":11,\"tag2\":\"\",\"tag2\":null}}') values(1591061628000, 11, false, '你就会','')")
+        tdSql.execute(f"insert into {dbname}.jsons1_7 using {dbname}.jsons1 tags('{{\"tag1\":\"收到货\",\"tag2\":\"\",\"tag3\":null}}') values(1591062628000, 2, NULL, '你就会', 'dws')")

        # test duplicate key using the first one. elimate empty key
-        tdSql.execute("CREATE TABLE if not exists jsons1_8 using jsons1 tags('{\"tag1\":null, \"tag1\":true, \"tag1\":45, \"1tag$\":2, \" \":90, \"\":32}')")
-        tdSql.query("select jtag from jsons1_8")
-        tdSql.checkRows(0);
+        tdSql.execute(f"create TABLE if not exists {dbname}.jsons1_8 using {dbname}.jsons1 tags('{{\"tag1\":null, \"tag1\":true, \"tag1\":45, \"1tag$\":2, \" \":90, \"\":32}}')")
+        tdSql.query(f"select jtag from {dbname}.jsons1_8")
+        tdSql.checkRows(0)

-        tdSql.query("select ts,jtag from jsons1 order by ts limit 2,3")
+        tdSql.query(f"select ts,jtag from {dbname}.jsons1 order by ts limit 2,3")
        tdSql.checkData(0, 0, '2020-06-02 09:17:08.000')
        tdSql.checkData(0, 1, '{"tag1":5,"tag2":"beijing"}')
        tdSql.checkData(1, 0, '2020-06-02 09:17:48.000')
@ -67,7 +48,7 @@ class TDTestCase:
        tdSql.checkData(2, 0, '2020-06-02 09:18:48.000')
        tdSql.checkData(2, 1, '{"tag1":null,"tag2":"shanghai","tag3":"hello"}')

-        tdSql.query("select ts,jtag->'tag1' from jsons1 order by ts limit 2,3")
+        tdSql.query(f"select ts,jtag->'tag1' from {dbname}.jsons1 order by ts limit 2,3")
        tdSql.checkData(0, 0, '2020-06-02 09:17:08.000')
        tdSql.checkData(0, 1, '5.000000000')
        tdSql.checkData(1, 0, '2020-06-02 09:17:48.000')
@ -76,163 +57,163 @@ class TDTestCase:
        tdSql.checkData(2, 1, 'null')

        # test empty json string, save as jtag is NULL
-        tdSql.execute("insert into jsons1_9  using jsons1 tags('\t') values (1591062328000, 24, NULL, '你就会', '2sdw')")
-        tdSql.execute("CREATE TABLE if not exists jsons1_10 using jsons1 tags('')")
-        tdSql.execute("CREATE TABLE if not exists jsons1_11 using jsons1 tags(' ')")
-        tdSql.execute("CREATE TABLE if not exists jsons1_12 using jsons1 tags('{}')")
-        tdSql.execute("CREATE TABLE if not exists jsons1_13 using jsons1 tags('null')")
+        tdSql.execute(f"insert into {dbname}.jsons1_9  using {dbname}.jsons1 tags('\t') values (1591062328000, 24, NULL, '你就会', '2sdw')")
+        tdSql.execute(f"create TABLE if not exists {dbname}.jsons1_10 using {dbname}.jsons1 tags('')")
+        tdSql.execute(f"create TABLE if not exists {dbname}.jsons1_11 using {dbname}.jsons1 tags(' ')")
+        tdSql.execute(f"create TABLE if not exists {dbname}.jsons1_12 using {dbname}.jsons1 tags('{{}}')")
+        tdSql.execute(f"create TABLE if not exists {dbname}.jsons1_13 using {dbname}.jsons1 tags('null')")

        # test invalidate json
-        tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('\"efwewf\"')")
-        tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('3333')")
-        tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags(76)")
-        tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags(hell)")
-        tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('33.33')")
-        tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('false')")
-        tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('[1,true]')")
-        tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('{222}')")
-        tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('{\"fe\"}')")
+        tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('\"efwewf\"')")
+        tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('3333')")
+        tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags(76)")
+        tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags(hell)")
+        tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('33.33')")
+        tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('false')")
+        tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('[1,true]')")
+        tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('{{222}}')")
+        tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('{{\"fe\"}}')")

        # test invalidate json key, key must can be printed assic char
-        tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('{\"tag1\":[1,true]}')")
-        tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('{\"tag1\":{}}')")
-        tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('{\"。loc\":\"fff\"}')")
-        tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('{\"\t\":\"fff\"}')")
-        tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('{\"试试\":\"fff\"}')")
+        tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('{{\"tag1\":[1,true]}}')")
+        tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('{{\"tag1\":{{}}}}')")
+        tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('{{\"。loc\":\"fff\"}}')")
+        tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('{{\"\t\":\"fff\"}}')")
+        tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('{{\"试试\":\"fff\"}}')")

        # test invalidate json value, value number can not be inf,nan TD-12166
-        tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('{\"k\":1.8e308}')")
-        tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('{\"k\":-1.8e308}')")
+        tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('{{\"k\":1.8e308}}')")
+        tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('{{\"k\":-1.8e308}}')")

        #test length limit
        char1= ''.join(['abcd']*64)
        char3= ''.join(['abcd']*1021)
        print(len(char3))   # 4084
-        tdSql.error("CREATE TABLE if not exists  jsons1_15 using  jsons1 tags('{\"%s1\":5}')" % char1)   # len(key)=257
-        tdSql.execute("CREATE TABLE if not exists  jsons1_15 using  jsons1 tags('{\"%s\":5}')" % char1)  # len(key)=256
-        tdSql.error("CREATE TABLE if not exists  jsons1_16 using  jsons1 tags('{\"TSSSS\":\"%s\"}')" % char3)   # len(object)=4096
-        tdSql.execute("CREATE TABLE if not exists  jsons1_16 using  jsons1 tags('{\"TSSS\":\"%s\"}')" % char3)  # len(object)=4095
-        tdSql.execute("drop table if exists jsons1_15")
-        tdSql.execute("drop table if exists jsons1_16")
+        tdSql.error(f"create TABLE if not exists {dbname}.jsons1_15 using {dbname}.jsons1 tags('{{\"%s1\":5}}')" % char1)   # len(key)=257
+        tdSql.execute(f"create TABLE if not exists {dbname}.jsons1_15 using {dbname}.jsons1 tags('{{\"%s\":5}}')" % char1)  # len(key)=256
+        tdSql.error(f"create TABLE if not exists {dbname}.jsons1_16 using {dbname}.jsons1 tags('{{\"TSSSS\":\"%s\"}}')" % char3)   # len(object)=4096
+        tdSql.execute(f"create TABLE if not exists {dbname}.jsons1_16 using {dbname}.jsons1 tags('{{\"TSSS\":\"%s\"}}')" % char3)  # len(object)=4095
+        tdSql.execute(f"drop table if exists {dbname}.jsons1_15")
+        tdSql.execute(f"drop table if exists {dbname}.jsons1_16")

        print("============== STEP 2 ===== alter table json tag")
-        tdSql.error("ALTER STABLE jsons1 add tag tag2 nchar(20)")
-        tdSql.error("ALTER STABLE jsons1 drop tag jtag")
-        tdSql.error("ALTER TABLE jsons1 MODIFY TAG jtag nchar(128)")
+        tdSql.error(f"ALTER stable {dbname}.jsons1 add tag tag2 nchar(20)")
+        tdSql.error(f"ALTER stable {dbname}.jsons1 drop tag jtag")
+        tdSql.error(f"ALTER table {dbname}.jsons1 MODIFY TAG jtag nchar(128)")

-        tdSql.execute("ALTER TABLE jsons1_1 SET TAG jtag='{\"tag1\":\"femail\",\"tag2\":35,\"tag3\":true}'")
-        tdSql.query("select jtag from jsons1_1")
+        tdSql.execute(f"ALTER table {dbname}.jsons1_1 SET TAG jtag='{{\"tag1\":\"femail\",\"tag2\":35,\"tag3\":true}}'")
+        tdSql.query(f"select jtag from {dbname}.jsons1_1")
        tdSql.checkData(0, 0, '{"tag1":"femail","tag2":35,"tag3":true}')
-        tdSql.execute("ALTER TABLE jsons1 rename TAG jtag jtag_new")
-        tdSql.execute("ALTER TABLE jsons1 rename TAG jtag_new jtag")
+        tdSql.execute(f"ALTER table {dbname}.jsons1 rename TAG jtag jtag_new")
+        tdSql.execute(f"ALTER table {dbname}.jsons1 rename TAG jtag_new jtag")

-        tdSql.execute("create table st(ts timestamp, i int) tags(t int)")
-        tdSql.error("ALTER STABLE st add tag jtag json")
-        tdSql.error("ALTER STABLE st add column jtag json")
+        tdSql.execute(f"create table {dbname}.st(ts timestamp, i int) tags(t int)")
+        tdSql.error(f"ALTER stable {dbname}.st add tag jtag json")
+        tdSql.error(f"ALTER stable {dbname}.st add column jtag json")

        print("============== STEP 3 ===== query table")
        # test error syntax
-        tdSql.error("select * from jsons1 where jtag->tag1='beijing'")
-        tdSql.error("select -> from jsons1")
-        tdSql.error("select * from jsons1 where contains")
-        tdSql.error("select * from jsons1 where jtag->")
-        tdSql.error("select jtag->location from jsons1")
-        tdSql.error("select jtag contains location from jsons1")
-        tdSql.error("select * from jsons1 where jtag contains location")
-        tdSql.query("select * from jsons1 where jtag contains''")
-        tdSql.error("select * from jsons1 where jtag contains 'location'='beijing'")
+        tdSql.error(f"select * from {dbname}.jsons1 where jtag->tag1='beijing'")
+        tdSql.error(f"select -> from {dbname}.jsons1")
+        tdSql.error(f"select * from {dbname}.jsons1 where contains")
+        tdSql.error(f"select * from {dbname}.jsons1 where jtag->")
+        tdSql.error(f"select jtag->location from {dbname}.jsons1")
+        tdSql.error(f"select jtag contains location from {dbname}.jsons1")
+        tdSql.error(f"select * from {dbname}.jsons1 where jtag contains location")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag contains''")
+        tdSql.error(f"select * from {dbname}.jsons1 where jtag contains 'location'='beijing'")

        # test function error
-        tdSql.error("select avg(jtag->'tag1') from jsons1")
-        tdSql.error("select avg(jtag) from jsons1")
-        tdSql.error("select min(jtag->'tag1') from jsons1")
-        tdSql.error("select min(jtag) from jsons1")
-        tdSql.error("select ceil(jtag->'tag1') from jsons1")
-        tdSql.error("select ceil(jtag) from jsons1")
+        tdSql.error(f"select avg(jtag->'tag1') from {dbname}.jsons1")
+        tdSql.error(f"select avg(jtag) from {dbname}.jsons1")
+        tdSql.error(f"select min(jtag->'tag1') from {dbname}.jsons1")
+        tdSql.error(f"select min(jtag) from {dbname}.jsons1")
+        tdSql.error(f"select ceil(jtag->'tag1') from {dbname}.jsons1")
+        tdSql.error(f"select ceil(jtag) from {dbname}.jsons1")


        #test scalar operation
-        tdSql.query("select jtag contains 'tag1',jtag->'tag1' from jsons1 order by jtag->'tag1'")
+        tdSql.query(f"select jtag contains 'tag1',jtag->'tag1' from {dbname}.jsons1 order by jtag->'tag1'")
        tdSql.checkRows(9)
-        tdSql.query("select jtag->'tag1' like 'fe%',jtag->'tag1' from jsons1 order by jtag->'tag1'")
+        tdSql.query(f"select jtag->'tag1' like 'fe%',jtag->'tag1' from {dbname}.jsons1 order by jtag->'tag1'")
        tdSql.checkRows(9)
-        tdSql.query("select jtag->'tag1' not like 'fe%',jtag->'tag1' from jsons1 order by jtag->'tag1'")
+        tdSql.query(f"select jtag->'tag1' not like 'fe%',jtag->'tag1' from {dbname}.jsons1 order by jtag->'tag1'")
        tdSql.checkRows(9)
-        tdSql.query("select jtag->'tag1' match 'fe',jtag->'tag1' from jsons1 order by jtag->'tag1'")
+        tdSql.query(f"select jtag->'tag1' match 'fe',jtag->'tag1' from {dbname}.jsons1 order by jtag->'tag1'")
        tdSql.checkRows(9)
-        tdSql.query("select jtag->'tag1' nmatch 'fe',jtag->'tag1' from jsons1 order by jtag->'tag1'")
+        tdSql.query(f"select jtag->'tag1' nmatch 'fe',jtag->'tag1' from {dbname}.jsons1 order by jtag->'tag1'")
        tdSql.checkRows(9)
-        tdSql.query("select jtag->'tag1',jtag->'tag1'>='a' from jsons1 order by jtag->'tag1'")
+        tdSql.query(f"select jtag->'tag1',jtag->'tag1'>='a' from {dbname}.jsons1 order by jtag->'tag1'")
        tdSql.checkRows(9)

        # test select normal column
-        tdSql.query("select dataint from jsons1 order by dataint")
+        tdSql.query(f"select dataint from {dbname}.jsons1 order by dataint")
        tdSql.checkRows(9)
        tdSql.checkData(1, 0, 1)

        # test select json tag
-        tdSql.query("select * from jsons1")
+        tdSql.query(f"select * from {dbname}.jsons1")
        tdSql.checkRows(9)
-        tdSql.query("select jtag from jsons1")
+        tdSql.query(f"select jtag from {dbname}.jsons1")
        tdSql.checkRows(9)
-        tdSql.query("select * from jsons1 where jtag is null")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag is null")
        tdSql.checkRows(1)
-        tdSql.query("select * from jsons1 where jtag is not null")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag is not null")
        tdSql.checkRows(8)

        # test jtag is NULL
-        tdSql.query("select jtag from jsons1_9")
+        tdSql.query(f"select jtag from {dbname}.jsons1_9")
        tdSql.checkData(0, 0, None)

        # test select json tag->'key', value is string
-        tdSql.query("select jtag->'tag1' from jsons1_1")
+        tdSql.query(f"select jtag->'tag1' from {dbname}.jsons1_1")
        tdSql.checkData(0, 0, '"femail"')
-        tdSql.query("select jtag->'tag2' from jsons1_6")
+        tdSql.query(f"select jtag->'tag2' from {dbname}.jsons1_6")
        tdSql.checkData(0, 0, '""')
        # test select json tag->'key', value is int
-        tdSql.query("select jtag->'tag2' from jsons1_1")
+        tdSql.query(f"select jtag->'tag2' from {dbname}.jsons1_1")
        tdSql.checkData(0, 0, "35.000000000")
        # test select json tag->'key', value is bool
-        tdSql.query("select jtag->'tag3' from jsons1_1")
+        tdSql.query(f"select jtag->'tag3' from {dbname}.jsons1_1")
        tdSql.checkData(0, 0, "true")
        # test select json tag->'key', value is null
-        tdSql.query("select jtag->'tag1' from jsons1_4")
+        tdSql.query(f"select jtag->'tag1' from {dbname}.jsons1_4")
        tdSql.checkData(0, 0, "null")
        # test select json tag->'key', value is double
-        tdSql.query("select jtag->'tag1' from jsons1_5")
+        tdSql.query(f"select jtag->'tag1' from {dbname}.jsons1_5")
        tdSql.checkData(0, 0, "1.232000000")
        # test select json tag->'key', key is not exist
-        tdSql.query("select jtag->'tag10' from jsons1_4")
+        tdSql.query(f"select jtag->'tag10' from {dbname}.jsons1_4")
        tdSql.checkData(0, 0, None)

-        tdSql.query("select jtag->'tag1' from jsons1")
+        tdSql.query(f"select jtag->'tag1' from {dbname}.jsons1")
        tdSql.checkRows(9)
        # test header name
-        res = tdSql.getColNameList("select jtag->'tag1' from jsons1")
+        res = tdSql.getColNameList(f"select jtag->'tag1' from {dbname}.jsons1")
        cname_list = []
        cname_list.append("jtag->'tag1'")
        tdSql.checkColNameList(res, cname_list)


        # test where with json tag
-        tdSql.query("select * from jsons1_1 where jtag is not null")
-        tdSql.query("select * from jsons1 where jtag='{\"tag1\":11,\"tag2\":\"\"}'")
-        tdSql.error("select * from jsons1 where jtag->'tag1'={}")
+        tdSql.query(f"select * from {dbname}.jsons1_1 where jtag is not null")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag='{{\"tag1\":11,\"tag2\":\"\"}}'")
+        tdSql.error(f"select * from {dbname}.jsons1 where jtag->'tag1'={{}}")

        # test json error
-        tdSql.error("select jtag + 1 from jsons1")
-        tdSql.error("select jtag > 1 from jsons1")
-        tdSql.error("select jtag like \"1\" from jsons1")
-        tdSql.error("select jtag in  (\"1\") from jsons1")
-        #tdSql.error("select jtag from jsons1 where jtag > 1")
-        #tdSql.error("select jtag from jsons1 where jtag like 'fsss'")
-        #tdSql.error("select jtag from jsons1 where jtag in (1)")
+        tdSql.error(f"select jtag + 1 from {dbname}.jsons1")
+        tdSql.error(f"select jtag > 1 from {dbname}.jsons1")
+        tdSql.error(f"select jtag like \"1\" from {dbname}.jsons1")
+        tdSql.error(f"select jtag in  (\"1\") from {dbname}.jsons1")
+        #tdSql.error(f"select jtag from {dbname}.jsons1 where jtag > 1")
+        #tdSql.error(f"select jtag from {dbname}.jsons1 where jtag like 'fsss'")
+        #tdSql.error(f"select jtag from {dbname}.jsons1 where jtag in (1)")


        # where json value is string
-        tdSql.query("select * from jsons1 where jtag->'tag2'='beijing'")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag2'='beijing'")
        tdSql.checkRows(2)
-        tdSql.query("select dataint,tbname,jtag->'tag1',jtag from jsons1 where jtag->'tag2'='beijing' order by dataint")
+        tdSql.query(f"select dataint,tbname,jtag->'tag1',jtag from {dbname}.jsons1 where jtag->'tag2'='beijing' order by dataint")
        tdSql.checkRows(2)
        tdSql.checkData(0, 0, 2)
        tdSql.checkData(0, 1, 'jsons1_2')
@ -243,180 +224,180 @@ class TDTestCase:
        tdSql.checkData(1, 2, 'false')


-        tdSql.query("select * from jsons1 where jtag->'tag1'='beijing'")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'='beijing'")
        tdSql.checkRows(0)
-        tdSql.query("select * from jsons1 where jtag->'tag1'='收到货'")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'='收到货'")
        tdSql.checkRows(1)
-        tdSql.query("select * from jsons1 where jtag->'tag2'>'beijing'")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag2'>'beijing'")
        tdSql.checkRows(1)
-        tdSql.query("select * from jsons1 where jtag->'tag2'>='beijing'")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag2'>='beijing'")
        tdSql.checkRows(3)
-        tdSql.query("select * from jsons1 where jtag->'tag2'<'beijing'")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag2'<'beijing'")
        tdSql.checkRows(2)
-        tdSql.query("select * from jsons1 where jtag->'tag2'<='beijing'")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag2'<='beijing'")
        tdSql.checkRows(4)
-        tdSql.query("select * from jsons1 where jtag->'tag2'!='beijing'")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag2'!='beijing'")
        tdSql.checkRows(3)
-        tdSql.query("select * from jsons1 where jtag->'tag2'=''")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag2'=''")
        tdSql.checkRows(2)

        # where json value is int
-        tdSql.query("select * from jsons1 where jtag->'tag1'=5")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'=5")
        tdSql.checkRows(1)
        tdSql.checkData(0, 1, 2)
-        tdSql.query("select * from jsons1 where jtag->'tag1'=10")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'=10")
        tdSql.checkRows(0)
-        tdSql.query("select * from jsons1 where jtag->'tag1'<54")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'<54")
        tdSql.checkRows(3)
-        tdSql.query("select * from jsons1 where jtag->'tag1'<=11")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'<=11")
        tdSql.checkRows(3)
-        tdSql.query("select * from jsons1 where jtag->'tag1'>4")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'>4")
        tdSql.checkRows(2)
-        tdSql.query("select * from jsons1 where jtag->'tag1'>=5")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'>=5")
        tdSql.checkRows(2)
-        tdSql.query("select * from jsons1 where jtag->'tag1'!=5")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'!=5")
        tdSql.checkRows(2)
-        tdSql.query("select * from jsons1 where jtag->'tag1'!=55")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'!=55")
        tdSql.checkRows(3)

        # where json value is double
-        tdSql.query("select * from jsons1 where jtag->'tag1'=1.232")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'=1.232")
        tdSql.checkRows(1)
-        tdSql.query("select * from jsons1 where jtag->'tag1'<1.232")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'<1.232")
        tdSql.checkRows(0)
-        tdSql.query("select * from jsons1 where jtag->'tag1'<=1.232")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'<=1.232")
        tdSql.checkRows(1)
-        tdSql.query("select * from jsons1 where jtag->'tag1'>1.23")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'>1.23")
        tdSql.checkRows(3)
-        tdSql.query("select * from jsons1 where jtag->'tag1'>=1.232")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'>=1.232")
        tdSql.checkRows(3)
-        tdSql.query("select * from jsons1 where jtag->'tag1'!=1.232")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'!=1.232")
        tdSql.checkRows(2)
-        tdSql.query("select * from jsons1 where jtag->'tag1'!=3.232")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'!=3.232")
        tdSql.checkRows(3)
-        tdSql.query("select * from jsons1 where jtag->'tag1'/0=3")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'/0=3")
        tdSql.checkRows(0)
-        tdSql.query("select * from jsons1 where jtag->'tag1'/5=1")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'/5=1")
        tdSql.checkRows(1)

        # where json value is bool
-        tdSql.query("select * from jsons1 where jtag->'tag1'=true")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'=true")
        tdSql.checkRows(0)
-        tdSql.query("select * from jsons1 where jtag->'tag1'=false")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'=false")
        tdSql.checkRows(1)
-        tdSql.query("select * from jsons1 where jtag->'tag1'!=false")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'!=false")
        tdSql.checkRows(0)
-        tdSql.query("select * from jsons1 where jtag->'tag1'>false")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'>false")
        tdSql.checkRows(0)

        # where json value is null
-        tdSql.query("select * from jsons1 where jtag->'tag1'=null")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'=null")
        tdSql.checkRows(0)

        # where json key is null
-        tdSql.query("select * from jsons1 where jtag->'tag_no_exist'=3")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag_no_exist'=3")
        tdSql.checkRows(0)

        # where json value is not exist
-        tdSql.query("select * from jsons1 where jtag->'tag1' is null")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1' is null")
        tdSql.checkData(0, 0, 'jsons1_9')
        tdSql.checkRows(2)
-        tdSql.query("select * from jsons1 where jtag->'tag4' is null")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag4' is null")
        tdSql.checkRows(9)
-        tdSql.query("select * from jsons1 where jtag->'tag3' is not null")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag3' is not null")
        tdSql.checkRows(3)

        # test contains
-        tdSql.query("select * from jsons1 where jtag contains 'tag1'")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag contains 'tag1'")
        tdSql.checkRows(8)
-        tdSql.query("select * from jsons1 where jtag contains 'tag3'")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag contains 'tag3'")
        tdSql.checkRows(4)
-        tdSql.query("select * from jsons1 where jtag contains 'tag_no_exist'")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag contains 'tag_no_exist'")
        tdSql.checkRows(0)

        # test json tag in where condition with and/or
-        tdSql.query("select * from jsons1 where jtag->'tag1'=false and jtag->'tag2'='beijing'")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'=false and jtag->'tag2'='beijing'")
        tdSql.checkRows(1)
-        tdSql.query("select * from jsons1 where jtag->'tag1'=false or jtag->'tag2'='beijing'")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'=false or jtag->'tag2'='beijing'")
        tdSql.checkRows(2)
-        tdSql.query("select * from jsons1 where jtag->'tag1'=false and jtag->'tag2'='shanghai'")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'=false and jtag->'tag2'='shanghai'")
        tdSql.checkRows(0)
-        tdSql.query("select * from jsons1 where jtag->'tag1'=false and jtag->'tag2'='shanghai'")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'=false and jtag->'tag2'='shanghai'")
        tdSql.checkRows(0)
-        tdSql.query("select * from jsons1 where jtag->'tag1'=13 or jtag->'tag2'>35")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'=13 or jtag->'tag2'>35")
        tdSql.checkRows(0)
-        tdSql.query("select * from jsons1 where jtag->'tag1'=13 or jtag->'tag2'>35")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'=13 or jtag->'tag2'>35")
        tdSql.checkRows(0)
-        tdSql.query("select * from jsons1 where jtag->'tag1' is not null and jtag contains 'tag3'")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1' is not null and jtag contains 'tag3'")
        tdSql.checkRows(3)
-        tdSql.query("select * from jsons1 where jtag->'tag1'='femail' and jtag contains 'tag3'")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'='femail' and jtag contains 'tag3'")
        tdSql.checkRows(2)


        # test with between and
-        tdSql.query("select * from jsons1 where jtag->'tag1' between 1 and 30")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1' between 1 and 30")
        tdSql.checkRows(3)
-        tdSql.query("select * from jsons1 where jtag->'tag1' between 'femail' and 'beijing'")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1' between 'femail' and 'beijing'")
        tdSql.checkRows(2)

        # test with tbname/normal column
-        tdSql.query("select * from jsons1 where tbname = 'jsons1_1'")
+        tdSql.query(f"select * from {dbname}.jsons1 where tbname = 'jsons1_1'")
        tdSql.checkRows(2)
-        tdSql.query("select * from jsons1 where tbname = 'jsons1_1' and jtag contains 'tag3'")
+        tdSql.query(f"select * from {dbname}.jsons1 where tbname = 'jsons1_1' and jtag contains 'tag3'")
        tdSql.checkRows(2)
-        tdSql.query("select * from jsons1 where tbname = 'jsons1_1' and jtag contains 'tag3' and dataint=3")
+        tdSql.query(f"select * from {dbname}.jsons1 where tbname = 'jsons1_1' and jtag contains 'tag3' and dataint=3")
        tdSql.checkRows(0)
-        tdSql.query("select * from jsons1 where tbname = 'jsons1_1' and jtag contains 'tag3' and dataint=23")
+        tdSql.query(f"select * from {dbname}.jsons1 where tbname = 'jsons1_1' and jtag contains 'tag3' and dataint=23")
        tdSql.checkRows(1)


        # test where condition like
-        tdSql.query("select * from jsons1 where jtag->'tag2' like 'bei%'")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag2' like 'bei%'")
        tdSql.checkRows(2)
-        tdSql.query("select * from jsons1 where jtag->'tag1' like 'fe%' and jtag->'tag2' is not null")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1' like 'fe%' and jtag->'tag2' is not null")
        tdSql.checkRows(2)

        # test where condition in  no support in
-        tdSql.error("select * from jsons1 where jtag->'tag1' in ('beijing')")
+        tdSql.error(f"select * from {dbname}.jsons1 where jtag->'tag1' in ('beijing')")

        # test where condition match/nmath
-        tdSql.query("select * from jsons1 where jtag->'tag1' match 'ma'")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1' match 'ma'")
        tdSql.checkRows(2)
-        tdSql.query("select * from jsons1 where jtag->'tag1' match 'ma$'")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1' match 'ma$'")
        tdSql.checkRows(0)
-        tdSql.query("select * from jsons1 where jtag->'tag2' match 'jing$'")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag2' match 'jing$'")
        tdSql.checkRows(2)
-        tdSql.query("select * from jsons1 where jtag->'tag1' match '收到'")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1' match '收到'")
        tdSql.checkRows(1)
-        tdSql.query("select * from jsons1 where jtag->'tag1' nmatch 'ma'")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1' nmatch 'ma'")
        tdSql.checkRows(1)

        # test distinct
-        tdSql.execute("insert into jsons1_14 using jsons1 tags('{\"tag1\":\"收到货\",\"tag2\":\"\",\"tag3\":null}') values(1591062628000, 2, NULL, '你就会', 'dws')")
-        tdSql.query("select distinct jtag->'tag1' from jsons1")
+        tdSql.execute(f"insert into {dbname}.jsons1_14 using {dbname}.jsons1 tags('{{\"tag1\":\"收到货\",\"tag2\":\"\",\"tag3\":null}}') values(1591062628000, 2, NULL, '你就会', 'dws')")
+        tdSql.query(f"select distinct jtag->'tag1' from {dbname}.jsons1")
        tdSql.checkRows(8)
-        tdSql.error("select distinct jtag from jsons1")
+        tdSql.error(f"select distinct jtag from {dbname}.jsons1")

        #test dumplicate key with normal colomn
-        tdSql.execute("INSERT INTO jsons1_15 using jsons1 tags('{\"tbname\":\"tt\",\"databool\":true,\"datastr\":\"是是是\"}') values(1591060828000, 4, false, 'jjsf', \"你就会\")")
-        tdSql.query("select * from jsons1 where jtag->'datastr' match '是' and datastr match 'js'")
+        tdSql.execute(f"insert into {dbname}.jsons1_15 using {dbname}.jsons1 tags('{{\"tbname\":\"tt\",\"databool\":true,\"datastr\":\"是是是\"}}') values(1591060828000, 4, false, 'jjsf', \"你就会\")")
+        tdSql.query(f"select * from {dbname}.jsons1 where jtag->'datastr' match '是' and datastr match 'js'")
        tdSql.checkRows(1)
-        tdSql.query("select tbname,jtag->'tbname' from jsons1 where jtag->'tbname'='tt' and tbname='jsons1_15'")
+        tdSql.query(f"select tbname,jtag->'tbname' from {dbname}.jsons1 where jtag->'tbname'='tt' and tbname='jsons1_15'")
        tdSql.checkRows(1)

        # test join
-        tdSql.execute("create table if not exists jsons2(ts timestamp, dataInt int, dataBool bool, dataStr nchar(50), dataStrBin binary(150)) tags(jtag json)")
-        tdSql.execute("insert into jsons2_1 using jsons2 tags('{\"tag1\":\"fff\",\"tag2\":5, \"tag3\":true}') values(1591060618000, 2, false, 'json2', '你是2')")
-        tdSql.execute("insert into jsons2_2 using jsons2 tags('{\"tag1\":5,\"tag2\":null}') values (1591060628000, 2, true, 'json2', 'sss')")
+        tdSql.execute(f"create table if not exists {dbname}.jsons2(ts timestamp, dataInt int, dataBool bool, dataStr nchar(50), dataStrBin binary(150)) tags(jtag json)")
+        tdSql.execute(f"insert into {dbname}.jsons2_1 using {dbname}.jsons2 tags('{{\"tag1\":\"fff\",\"tag2\":5, \"tag3\":true}}') values(1591060618000, 2, false, 'json2', '你是2')")
+        tdSql.execute(f"insert into {dbname}.jsons2_2 using {dbname}.jsons2 tags('{{\"tag1\":5,\"tag2\":null}}') values (1591060628000, 2, true, 'json2', 'sss')")

-        tdSql.execute("create table if not exists jsons3(ts timestamp, dataInt int, dataBool bool, dataStr nchar(50), dataStrBin binary(150)) tags(jtag json)")
-        tdSql.execute("insert into jsons3_1 using jsons3 tags('{\"tag1\":\"fff\",\"tag2\":5, \"tag3\":true}') values(1591060618000, 3, false, 'json3', '你是3')")
-        tdSql.execute("insert into jsons3_2 using jsons3 tags('{\"tag1\":5,\"tag2\":\"beijing\"}') values (1591060638000, 2, true, 'json3', 'sss')")
-        tdSql.query("select 'sss',33,a.jtag->'tag3' from jsons2 a,jsons3 b where a.ts=b.ts and a.jtag->'tag1'=b.jtag->'tag1'")
+        tdSql.execute(f"create table if not exists {dbname}.jsons3(ts timestamp, dataInt int, dataBool bool, dataStr nchar(50), dataStrBin binary(150)) tags(jtag json)")
+        tdSql.execute(f"insert into {dbname}.jsons3_1 using {dbname}.jsons3 tags('{{\"tag1\":\"fff\",\"tag2\":5, \"tag3\":true}}') values(1591060618000, 3, false, 'json3', '你是3')")
+        tdSql.execute(f"insert into {dbname}.jsons3_2 using {dbname}.jsons3 tags('{{\"tag1\":5,\"tag2\":\"beijing\"}}') values (1591060638000, 2, true, 'json3', 'sss')")
+        tdSql.query(f"select 'sss',33,a.jtag->'tag3' from {dbname}.jsons2 a,jsons3 b where a.ts=b.ts and a.jtag->'tag1'=b.jtag->'tag1'")
        tdSql.checkData(0, 0, "sss")
        tdSql.checkData(0, 2, "true")

-        res = tdSql.getColNameList("select 'sss',33,a.jtag->'tag3' from jsons2 a,jsons3 b where a.ts=b.ts and a.jtag->'tag1'=b.jtag->'tag1'")
+        res = tdSql.getColNameList(f"select 'sss',33,a.jtag->'tag3' from {dbname}.jsons2 a,jsons3 b where a.ts=b.ts and a.jtag->'tag1'=b.jtag->'tag1'")
        cname_list = []
        cname_list.append("'sss'")
        cname_list.append("33")
@ -424,19 +405,19 @@ class TDTestCase:
        tdSql.checkColNameList(res, cname_list)
        #
        # test group by & order by  json tag
-        tdSql.query("select ts,jtag->'tag1' from jsons1 partition by jtag->'tag1' order by jtag->'tag1' desc")
+        tdSql.query(f"select ts,jtag->'tag1' from {dbname}.jsons1 partition by jtag->'tag1' order by jtag->'tag1' desc")
        tdSql.checkRows(11)
        tdSql.checkData(0, 1, '"femail"')
        tdSql.checkData(2, 1, '"收到货"')
        tdSql.checkData(7, 1, "false")


-        tdSql.error("select count(*) from jsons1 group by jtag")
-        tdSql.error("select count(*) from jsons1 partition by jtag")
-        tdSql.error("select count(*) from jsons1 group by jtag order by jtag")
-        tdSql.error("select count(*) from jsons1 group by jtag->'tag1' order by jtag->'tag2'")
-        tdSql.error("select count(*) from jsons1 group by jtag->'tag1' order by jtag")
-        tdSql.query("select count(*),jtag->'tag1' from jsons1 group by jtag->'tag1' order by jtag->'tag1' desc")
+        tdSql.error(f"select count(*) from {dbname}.jsons1 group by jtag")
+        tdSql.error(f"select count(*) from {dbname}.jsons1 partition by jtag")
+        tdSql.error(f"select count(*) from {dbname}.jsons1 group by jtag order by jtag")
+        tdSql.error(f"select count(*) from {dbname}.jsons1 group by jtag->'tag1' order by jtag->'tag2'")
+        tdSql.error(f"select count(*) from {dbname}.jsons1 group by jtag->'tag1' order by jtag")
+        tdSql.query(f"select count(*),jtag->'tag1' from {dbname}.jsons1 group by jtag->'tag1' order by jtag->'tag1' desc")
        tdSql.checkRows(8)
        tdSql.checkData(0, 0, 2)
        tdSql.checkData(0, 1, '"femail"')
@ -447,7 +428,7 @@ class TDTestCase:
        tdSql.checkData(5, 0, 1)
        tdSql.checkData(5, 1, "false")

-        tdSql.query("select count(*),jtag->'tag1' from jsons1 group by jtag->'tag1' order by jtag->'tag1' asc")
+        tdSql.query(f"select count(*),jtag->'tag1' from {dbname}.jsons1 group by jtag->'tag1' order by jtag->'tag1' asc")
        tdSql.checkRows(8)
        tdSql.checkData(0, 1, None)
        tdSql.checkData(2, 0, 1)
@ -458,7 +439,7 @@ class TDTestCase:
        tdSql.checkData(7, 1, '"femail"')

        # test stddev with group by json tag
-        tdSql.query("select stddev(dataint),jtag->'tag1' from jsons1 group by jtag->'tag1' order by jtag->'tag1'")
+        tdSql.query(f"select stddev(dataint),jtag->'tag1' from {dbname}.jsons1 group by jtag->'tag1' order by jtag->'tag1'")
        tdSql.checkRows(8)
        tdSql.checkData(0, 1, None)
        tdSql.checkData(4, 0, 0)
@ -466,222 +447,222 @@ class TDTestCase:
        tdSql.checkData(7, 0, 11)
        tdSql.checkData(7, 1, '"femail"')

-        res = tdSql.getColNameList("select stddev(dataint),jsons1.jtag->'tag1' from jsons1 group by jsons1.jtag->'tag1' order by jtag->'tag1'")
+        res = tdSql.getColNameList(f"select stddev(dataint),jsons1.jtag->'tag1' from {dbname}.jsons1 group by jsons1.jtag->'tag1' order by jtag->'tag1'")
        cname_list = []
        cname_list.append("stddev(dataint)")
        cname_list.append("jsons1.jtag->'tag1'")
        tdSql.checkColNameList(res, cname_list)

        # test top/bottom with group by json tag
-        tdSql.query("select top(dataint,2),jtag->'tag1' from jsons1 group by jtag->'tag1' order by jtag->'tag1'")
+        tdSql.query(f"select top(dataint,2),jtag->'tag1' from {dbname}.jsons1 group by jtag->'tag1' order by jtag->'tag1'")
        tdSql.checkRows(11)
        tdSql.checkData(0, 1, None)

        # test having
-        tdSql.query("select count(*),jtag->'tag1' from jsons1 group by jtag->'tag1' having count(*) > 1")
+        tdSql.query(f"select count(*),jtag->'tag1' from {dbname}.jsons1 group by jtag->'tag1' having count(*) > 1")
        tdSql.checkRows(3)

        # subquery with json tag
-        tdSql.query("select * from (select jtag, dataint from jsons1) order by dataint")
+        tdSql.query(f"select * from (select jtag, dataint from {dbname}.jsons1) order by dataint")
        tdSql.checkRows(11)
        tdSql.checkData(1, 1, 1)
        tdSql.checkData(5, 0, '{"tag1":false,"tag2":"beijing"}')

-        tdSql.error("select jtag->'tag1' from (select jtag->'tag1', dataint from jsons1)")
-        tdSql.error("select t->'tag1' from (select jtag->'tag1' as t, dataint from jsons1)")
-        tdSql.error("select ts,jtag->'tag1' from (select jtag->'tag1',tbname,ts from jsons1 order by ts)")
+        tdSql.error(f"select jtag->'tag1' from (select jtag->'tag1', dataint from {dbname}.jsons1)")
+        tdSql.error(f"select t->'tag1' from (select jtag->'tag1' as t, dataint from {dbname}.jsons1)")
+        tdSql.error(f"select ts,jtag->'tag1' from (select jtag->'tag1',tbname,ts from {dbname}.jsons1 order by ts)")

        # union all
-        tdSql.query("select jtag->'tag1' from jsons1 union all select jtag->'tag2' from jsons2")
+        tdSql.query(f"select jtag->'tag1' from {dbname}.jsons1 union all select jtag->'tag2' from {dbname}.jsons2")
        tdSql.checkRows(13)
-        tdSql.query("select jtag->'tag1' from jsons1_1 union all select jtag->'tag2' from jsons2_1")
+        tdSql.query(f"select jtag->'tag1' from {dbname}.jsons1_1 union all select jtag->'tag2' from {dbname}.jsons2_1")
        tdSql.checkRows(3)

-        tdSql.query("select jtag->'tag1' from jsons1_1 union all select jtag->'tag1' from jsons2_1")
+        tdSql.query(f"select jtag->'tag1' from {dbname}.jsons1_1 union all select jtag->'tag1' from {dbname}.jsons2_1")
        tdSql.checkRows(3)
-        tdSql.query("select dataint,jtag->'tag1',tbname from jsons1 union all select dataint,jtag->'tag1',tbname from jsons2")
+        tdSql.query(f"select dataint,jtag->'tag1',tbname from {dbname}.jsons1 union all select dataint,jtag->'tag1',tbname from {dbname}.jsons2")
        tdSql.checkRows(13)
-        tdSql.query("select dataint,jtag,tbname from jsons1 union all select dataint,jtag,tbname from jsons2")
+        tdSql.query(f"select dataint,jtag,tbname from {dbname}.jsons1 union all select dataint,jtag,tbname from {dbname}.jsons2")
        tdSql.checkRows(13)

        #show create table
-        tdSql.query("show create table jsons1")
+        tdSql.query(f"show create table {dbname}.jsons1")
        tdSql.checkData(0, 1, 'CREATE STABLE `jsons1` (`ts` TIMESTAMP, `dataint` INT, `databool` BOOL, `datastr` NCHAR(50), `datastrbin` VARCHAR(150)) TAGS (`jtag` JSON)')

        #test aggregate function:count/avg/twa/irate/sum/stddev/leastsquares
-        tdSql.query("select count(*) from jsons1 where jtag is not null")
+        tdSql.query(f"select count(*) from {dbname}.jsons1 where jtag is not null")
        tdSql.checkData(0, 0, 10)
-        tdSql.query("select avg(dataint) from jsons1 where jtag is not null")
+        tdSql.query(f"select avg(dataint) from {dbname}.jsons1 where jtag is not null")
        tdSql.checkData(0, 0, 5.3)
-        # tdSql.query("select twa(dataint) from jsons1 where jtag is not null")
+        # tdSql.query(f"select twa(dataint) from {dbname}.jsons1 where jtag is not null")
        # tdSql.checkData(0, 0, 28.386363636363637)
-        # tdSql.query("select irate(dataint) from jsons1 where jtag is not null")
+        # tdSql.query(f"select irate(dataint) from {dbname}.jsons1 where jtag is not null")

-        tdSql.query("select sum(dataint) from jsons1 where jtag->'tag1' is not null")
+        tdSql.query(f"select sum(dataint) from {dbname}.jsons1 where jtag->'tag1' is not null")
        tdSql.checkData(0, 0, 45)
-        tdSql.query("select stddev(dataint) from jsons1 where jtag->'tag1'>1")
+        tdSql.query(f"select stddev(dataint) from {dbname}.jsons1 where jtag->'tag1'>1")
        tdSql.checkData(0, 0, 4.496912521)
-        tdSql.query("SELECT LEASTSQUARES(dataint, 1, 1) from jsons1 where jtag is not null")
+        tdSql.query(f"select LEASTSQUARES(dataint, 1, 1) from {dbname}.jsons1 where jtag is not null")

        #test selection function:min/max/first/last/top/bottom/percentile/apercentile/last_row/interp
-        tdSql.query("select min(dataint) from jsons1 where jtag->'tag1'>1")
+        tdSql.query(f"select min(dataint) from {dbname}.jsons1 where jtag->'tag1'>1")
        tdSql.checkData(0, 0, 1)
-        tdSql.query("select max(dataint) from jsons1 where jtag->'tag1'>1")
+        tdSql.query(f"select max(dataint) from {dbname}.jsons1 where jtag->'tag1'>1")
        tdSql.checkData(0, 0, 11)
-        tdSql.query("select first(dataint) from jsons1 where jtag->'tag1'>1")
+        tdSql.query(f"select first(dataint) from {dbname}.jsons1 where jtag->'tag1'>1")
        tdSql.checkData(0, 0, 2)
-        tdSql.query("select last(dataint) from jsons1 where jtag->'tag1'>1")
+        tdSql.query(f"select last(dataint) from {dbname}.jsons1 where jtag->'tag1'>1")
        tdSql.checkData(0, 0, 11)
-        tdSql.query("select top(dataint,100) from jsons1 where jtag->'tag1'>1")
+        tdSql.query(f"select top(dataint,100) from {dbname}.jsons1 where jtag->'tag1'>1")
        tdSql.checkRows(3)
-        tdSql.query("select bottom(dataint,100) from jsons1 where jtag->'tag1'>1")
+        tdSql.query(f"select bottom(dataint,100) from {dbname}.jsons1 where jtag->'tag1'>1")
        tdSql.checkRows(3)
-        #tdSql.query("select percentile(dataint,20) from jsons1 where jtag->'tag1'>1")
-        tdSql.query("select apercentile(dataint, 50) from jsons1 where jtag->'tag1'>1")
+        #tdSql.query(f"select percentile(dataint,20) from {dbname}.jsons1 where jtag->'tag1'>1")
+        tdSql.query(f"select apercentile(dataint, 50) from {dbname}.jsons1 where jtag->'tag1'>1")
        tdSql.checkData(0, 0, 1.5)
-        # tdSql.query("select last_row(dataint) from jsons1 where jtag->'tag1'>1")
-        # tdSql.query("select interp(dataint) from jsons1 where ts = '2020-06-02 09:17:08.000' and jtag->'tag1'>1")
+        # tdSql.query(f"select last_row(dataint) from {dbname}.jsons1 where jtag->'tag1'>1")
+        # tdSql.query(f"select interp(dataint) from {dbname}.jsons1 where ts = '2020-06-02 09:17:08.000' and jtag->'tag1'>1")

        #test calculation function:diff/derivative/spread/ceil/floor/round/
-        tdSql.query("select diff(dataint) from jsons1 where jtag->'tag1'>1")
+        tdSql.query(f"select diff(dataint) from {dbname}.jsons1 where jtag->'tag1'>1")
        tdSql.checkRows(2)
        # tdSql.checkData(0, 0, -1)
        # tdSql.checkData(1, 0, 10)
-        tdSql.query("select derivative(dataint, 10m, 0) from jsons1 where jtag->'tag1'>1")
+        tdSql.query(f"select derivative(dataint, 10m, 0) from {dbname}.jsons1 where jtag->'tag1'>1")
        # tdSql.checkData(0, 0, -2)
-        tdSql.query("select spread(dataint) from jsons1 where jtag->'tag1'>1")
+        tdSql.query(f"select spread(dataint) from {dbname}.jsons1 where jtag->'tag1'>1")
        tdSql.checkData(0, 0, 10)
-        tdSql.query("select ceil(dataint) from jsons1 where jtag->'tag1'>1")
+        tdSql.query(f"select ceil(dataint) from {dbname}.jsons1 where jtag->'tag1'>1")
        tdSql.checkRows(3)
-        tdSql.query("select floor(dataint) from jsons1 where jtag->'tag1'>1")
+        tdSql.query(f"select floor(dataint) from {dbname}.jsons1 where jtag->'tag1'>1")
        tdSql.checkRows(3)
-        tdSql.query("select round(dataint) from jsons1 where jtag->'tag1'>1")
+        tdSql.query(f"select round(dataint) from {dbname}.jsons1 where jtag->'tag1'>1")
        tdSql.checkRows(3)

        #math function
-        tdSql.query("select sin(dataint) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select sin(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select cos(dataint) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select cos(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select tan(dataint) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select tan(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select asin(dataint) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select asin(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select acos(dataint) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select acos(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select atan(dataint) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select atan(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select ceil(dataint) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select ceil(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select floor(dataint) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select floor(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select round(dataint) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select round(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select abs(dataint) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select abs(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select pow(dataint,5) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select pow(dataint,5) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select log(dataint,10) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select log(dataint,10) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select sqrt(dataint) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select sqrt(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select HISTOGRAM(dataint,'user_input','[1, 33, 555, 7777]',1)  from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select HISTOGRAM(dataint,'user_input','[1, 33, 555, 7777]',1)  from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select csum(dataint) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select csum(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select mavg(dataint,1) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select mavg(dataint,1) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select statecount(dataint,'GE',10) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select statecount(dataint,'GE',10) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select stateduration(dataint,'GE',0) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select stateduration(dataint,'GE',0) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select sample(dataint,3) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select sample(dataint,3) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select HYPERLOGLOG(dataint) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select HYPERLOGLOG(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(1)
-        tdSql.query("select twa(dataint) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select twa(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(1)

        # function not ready
-        tdSql.query("select tail(dataint,1) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select tail(dataint,1) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(1)
-        tdSql.query("select unique(dataint) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select unique(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select mode(dataint) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select mode(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(1)
-        tdSql.query("select irate(dataint) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select irate(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(1)

        #str function
-        tdSql.query("select upper(dataStr) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select upper(dataStr) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select ltrim(dataStr) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select ltrim(dataStr) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select lower(dataStr) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select lower(dataStr) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select rtrim(dataStr) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select rtrim(dataStr) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select LENGTH(dataStr) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select LENGTH(dataStr) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select CHAR_LENGTH(dataStr) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select CHAR_LENGTH(dataStr) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select SUBSTR(dataStr,5) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select SUBSTR(dataStr,5) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select CONCAT(dataStr,dataStrBin) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select CONCAT(dataStr,dataStrBin) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select CONCAT_ws('adad!@!@%$^$%$^$%^a',dataStr,dataStrBin) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select CONCAT_ws('adad!@!@%$^$%$^$%^a',dataStr,dataStrBin) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select CAST(dataStr as bigint) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select CAST(dataStr as bigint) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)

        #time function
-        tdSql.query("select now() from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select now() from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select today() from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select today() from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select TIMEZONE() from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select TIMEZONE() from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select TO_ISO8601(ts) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select TO_ISO8601(ts) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select TO_UNIXTIMESTAMP(datastr) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select TO_UNIXTIMESTAMP(datastr) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select TIMETRUNCATE(ts,1s) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select TIMETRUNCATE(ts,1s) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select TIMEDIFF(ts,_c0) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select TIMEDIFF(ts,_c0) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select TIMEDIFF(ts,1u) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select TIMEDIFF(ts,1u) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(3)
-        tdSql.query("select ELAPSED(ts,1h) from jsons1 where jtag->'tag1'>1;")
+        tdSql.query(f"select ELAPSED(ts,1h) from {dbname}.jsons1 where jtag->'tag1'>1;")
        tdSql.checkRows(1)

        # to_json()
-        tdSql.query("select to_json('{\"abc\":123}') from jsons1_1")
+        tdSql.query(f"select to_json('{{\"abc\":123}}') from {dbname}.jsons1_1")
        tdSql.checkRows(2)
        tdSql.checkData(0, 0, '{"abc":123}')
        tdSql.checkData(1, 0, '{"abc":123}')
-        tdSql.query("select to_json('null') from jsons1_1")
+        tdSql.query(f"select to_json('null') from {dbname}.jsons1_1")
        tdSql.checkRows(2)
        tdSql.checkData(0, 0, 'null')
        tdSql.checkData(1, 0, 'null')
-        tdSql.query("select to_json('{\"key\"}') from jsons1_1")
+        tdSql.query(f"select to_json('{{\"key\"}}') from {dbname}.jsons1_1")
        tdSql.checkRows(2)
        tdSql.checkData(0, 0, 'null')
        tdSql.checkData(1, 0, 'null')

        #test TD-12077
-        tdSql.execute("insert into jsons1_16 using jsons1 tags('{\"tag1\":\"收到货\",\"tag2\":\"\",\"tag3\":-2.111}') values(1591062628000, 2, NULL, '你就会', 'dws')")
-        tdSql.query("select jtag->'tag3' from jsons1_16")
+        tdSql.execute(f"insert into {dbname}.jsons1_16 using {dbname}.jsons1 tags('{{\"tag1\":\"收到货\",\"tag2\":\"\",\"tag3\":-2.111}}') values(1591062628000, 2, NULL, '你就会', 'dws')")
+        tdSql.query(f"select jtag->'tag3' from {dbname}.jsons1_16")
        tdSql.checkData(0, 0, '-2.111000000')

        # test TD-12452
-        tdSql.execute("ALTER TABLE jsons1_1 SET TAG jtag=NULL")
-        tdSql.query("select jtag from jsons1_1")
+        tdSql.execute(f"ALTER table {dbname}.jsons1_1 SET TAG jtag=NULL")
+        tdSql.query(f"select jtag from {dbname}.jsons1_1")
        tdSql.checkData(0, 0, None)
-        tdSql.execute("CREATE TABLE if not exists jsons1_20 using jsons1 tags(NULL)")
-        tdSql.query("select jtag from jsons1_20")
+        tdSql.execute(f"create TABLE if not exists {dbname}.jsons1_20 using {dbname}.jsons1 tags(NULL)")
+        tdSql.query(f"select jtag from {dbname}.jsons1_20")
        tdSql.checkRows(0)
-        tdSql.execute("insert into jsons1_21 using jsons1 tags(NULL) values(1591061628000, 11, false, '你就会','')")
-        tdSql.query("select jtag from jsons1_21")
+        tdSql.execute(f"insert into {dbname}.jsons1_21 using {dbname}.jsons1 tags(NULL) values(1591061628000, 11, false, '你就会','')")
+        tdSql.query(f"select jtag from {dbname}.jsons1_21")
        tdSql.checkData(0, 0, None)
        #
        # #test TD-12389
@ -691,23 +672,23 @@ class TDTestCase:
        tdSql.checkData(5, 2, 4095)
        #
        # #test TD-13918
-        tdSql.execute("drop table  if exists jsons_13918_1")
-        tdSql.execute("drop table  if exists jsons_13918_2")
-        tdSql.execute("drop table  if exists jsons_13918_3")
-        tdSql.execute("drop table  if exists jsons_13918_4")
-        tdSql.execute("drop table  if exists jsons_stb")
-        tdSql.execute("create table jsons_stb (ts timestamp, dataInt int) tags (jtag json)")
-        tdSql.error("create table jsons_13918_1 using jsons_stb tags ('nullx')")
-        tdSql.error("create table jsons_13918_2 using jsons_stb tags (nullx)")
-        tdSql.error("insert into jsons_13918_3 using jsons_stb tags('NULLx') values(1591061628001, 11)")
-        tdSql.error("insert into jsons_13918_4 using jsons_stb tags(NULLx) values(1591061628002, 11)")
-        tdSql.execute("create table jsons_13918_1 using jsons_stb tags ('null')")
-        tdSql.execute("create table jsons_13918_2 using jsons_stb tags (null)")
-        tdSql.execute("insert into jsons_13918_1 values(1591061628003, 11)")
-        tdSql.execute("insert into jsons_13918_2 values(1591061628004, 11)")
-        tdSql.execute("insert into jsons_13918_3 using jsons_stb tags('NULL') values(1591061628005, 11)")
-        tdSql.execute("insert into jsons_13918_4 using jsons_stb tags(\"NULL\") values(1591061628006, 11)")
-        tdSql.query("select * from jsons_stb")
+        tdSql.execute(f"drop table  if exists {dbname}.jsons_13918_1")
+        tdSql.execute(f"drop table  if exists {dbname}.jsons_13918_2")
+        tdSql.execute(f"drop table  if exists {dbname}.jsons_13918_3")
+        tdSql.execute(f"drop table  if exists {dbname}.jsons_13918_4")
+        tdSql.execute(f"drop table  if exists {dbname}.jsons_stb")
+        tdSql.execute(f"create table {dbname}.jsons_stb (ts timestamp, dataInt int) tags (jtag json)")
+        tdSql.error(f"create table {dbname}.jsons_13918_1 using {dbname}.jsons_stb tags ('nullx')")
+        tdSql.error(f"create table {dbname}.jsons_13918_2 using {dbname}.jsons_stb tags (nullx)")
+        tdSql.error(f"insert into {dbname}.jsons_13918_3 using {dbname}.jsons_stb tags('NULLx') values(1591061628001, 11)")
+        tdSql.error(f"insert into {dbname}.jsons_13918_4 using {dbname}.jsons_stb tags(NULLx) values(1591061628002, 11)")
+        tdSql.execute(f"create table {dbname}.jsons_13918_1 using {dbname}.jsons_stb tags ('null')")
+        tdSql.execute(f"create table {dbname}.jsons_13918_2 using {dbname}.jsons_stb tags (null)")
+        tdSql.execute(f"insert into {dbname}.jsons_13918_1 values(1591061628003, 11)")
+        tdSql.execute(f"insert into {dbname}.jsons_13918_2 values(1591061628004, 11)")
+        tdSql.execute(f"insert into {dbname}.jsons_13918_3 using {dbname}.jsons_stb tags('NULL') values(1591061628005, 11)")
+        tdSql.execute(f"insert into {dbname}.jsons_13918_4 using {dbname}.jsons_stb tags(\"NULL\") values(1591061628006, 11)")
+        tdSql.query(f"select * from {dbname}.jsons_stb")
        tdSql.checkRows(4)

    def stop(self):
@ -717,4 +698,3 @@ class TDTestCase:

 tdCases.addWindows(__file__, TDTestCase())
 tdCases.addLinux(__file__, TDTestCase())
-
--- a/tests/system-test/2-query/json_tag_large_tables.py
+++ b/tests/system-test/2-query/json_tag_large_tables.py
@ -35,7 +35,7 @@ class TDTestCase:
        self.testcaseFilename = os.path.split(__file__)[-1]
        # os.system("rm -rf %s/%s.sql" % (self.testcasePath,self.testcaseFilename))
        tdLog.debug("start to execute %s" % __file__)
-        tdSql.init(conn.cursor(), True)
+        tdSql.init(conn.cursor(), False)

    def run(self):
        # tdSql.prepare()
@ -47,20 +47,20 @@ class TDTestCase:
        i = 0
        # add 100000 table
        tdSql.execute("create table if not exists jsons1(ts timestamp, dataInt int, dataBool bool, dataStr nchar(50), dataStrBin binary(150)) tags(jtag json)")
-        while i <= 10 0000:
+        while i <= 100000:
            sql = """insert into jsons1_{%d} using jsons1 tags('{"tag1":{%d}}') values(1591060618000, 1, false, 'json1', '你是') (1591060608000, 23, true, '等等', 'json')"""%(i, i)
            tdSql.execute(sql)
            i = i + 1

-        // do query
+        # do query
        i = 0
-        while i <= 10 0000:
+        while i <= 100000:
            sql = """select count(*) from jsons1 where jtag->'tag1' = %d"""%(i)
            tdSql.query(sql)
            if 1 != tdSql.getRows():
                print("err: %s"%(sql))

-        while i <= 10000000
+        while i <= 10000000:
            sql = """insert into jsons1_{%d} using jsons1 tags('{"tag1":{%d}}') values(1591060618000, 1, false, 'json1', '你是') (1591060608000, 23, true, '等等', 'json')"""%(i, i)
            tdSql.execute(sql)
            i = i + 1
@ -704,4 +704,3 @@ class TDTestCase:

 tdCases.addWindows(__file__, TDTestCase())
 tdCases.addLinux(__file__, TDTestCase())
-
--- a/tests/system-test/2-query/last_row.py
+++ b/tests/system-test/2-query/last_row.py
@ -10,29 +10,26 @@ import random


 class TDTestCase:
-    updatecfgDict = {'debugFlag': 143, "cDebugFlag": 143, "uDebugFlag": 143, "rpcDebugFlag": 143, "tmrDebugFlag": 143,
-                     "jniDebugFlag": 143, "simDebugFlag": 143, "dDebugFlag": 143, "dDebugFlag": 143, "vDebugFlag": 143, "mDebugFlag": 143, "qDebugFlag": 143,
-                     "wDebugFlag": 143, "sDebugFlag": 143, "tsdbDebugFlag": 143, "tqDebugFlag": 143, "fsDebugFlag": 143, "fnDebugFlag": 143 ,"udf":0}

    def init(self, conn, logSql):
        tdLog.debug(f"start to excute {__file__}")
-        tdSql.init(conn.cursor(), True)
+        tdSql.init(conn.cursor(), False)
        self.tb_nums = 10
        self.row_nums = 20
        self.ts = 1434938400000
        self.time_step = 1000

-    def insert_datas_and_check_abs(self ,tbnums , rownums , time_step ,cache_value ):
-        tdSql.execute("drop database if exists test ")
-        tdLog.info(" prepare datas for auto check abs function ")
+    def insert_datas_and_check_abs(self, tbnums, rownums, time_step, cache_value, dbname="test"):
+        tdSql.execute(f"drop database if exists {dbname} ")
+        tdLog.info("prepare datas for auto check abs function ")

-        tdSql.execute(f" create database test cachemodel {cache_value} ")
-        tdSql.execute(" use test ")
-        tdSql.execute(" create stable test.stb (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint,\
+        tdSql.execute(f"create database {dbname} cachemodel {cache_value} ")
+        tdSql.execute(f"use {dbname} ")
+        tdSql.execute(f"create stable {dbname}.stb (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint,\
             c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp) tags (t1 int)")
        for tbnum in range(tbnums):
-            tbname = "test.sub_tb_%d"%tbnum
-            tdSql.execute(" create table %s using stb tags(%d) "%(tbname , tbnum))
+            tbname = f"{dbname}.sub_tb_{tbnum}"
+            tdSql.execute(f"create table {tbname} using {dbname}.stb tags({tbnum}) ")

            ts = self.ts
            for row in range(rownums):
@ -49,66 +46,65 @@ class TDTestCase:
                c10 = ts
                tdSql.execute(f" insert into  {tbname} values ({ts},{c1},{c2},{c3},{c4},{c5},{c6},{c7},{c8},{c9},{c10})")

-        tdSql.execute("use test")
        tbnames = ["stb", "sub_tb_1"]
        support_types = ["BIGINT", "SMALLINT", "TINYINT", "FLOAT", "DOUBLE", "INT"]
        for tbname in tbnames:
-            tdSql.query("desc {}".format(tbname))
+            tdSql.query(f"desc {dbname}.{tbname}")
            coltypes = tdSql.queryResult
            for coltype in coltypes:
                colname = coltype[0]
-                abs_sql = "select abs({}) from {} order by tbname ".format(colname, 'test.'+tbname)
-                origin_sql = "select {} from {} order by tbname".format(colname, 'test.'+tbname)
+                abs_sql = f"select abs({colname}) from {dbname}.{tbname} order by tbname "
+                origin_sql = f"select {colname} from {dbname}.{tbname} order by tbname"
                if coltype[1] in support_types:
                    self.check_result_auto(origin_sql , abs_sql)

-    def prepare_datas(self ,cache_value):
-        tdSql.execute("drop database if exists db ")
-        create_db_sql = f"create database if not exists db keep 3650 duration 1000 cachemodel {cache_value}"
+    def prepare_datas(self ,cache_value, dbname="db"):
+        tdSql.execute(f"drop database if exists {dbname} ")
+        create_db_sql = f"create database if not exists {dbname} keep 3650 duration 1000 cachemodel {cache_value}"
        tdSql.execute(create_db_sql)

-        tdSql.execute("use db")
+        tdSql.execute(f"use {dbname}")
        tdSql.execute(
-            '''create table db.stb1
+            f'''create table {dbname}.stb1
            (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp)
            tags (t1 int)
            '''
        )

        tdSql.execute(
-            '''
-            create table db.t1
+            f'''
+            create table {dbname}.t1
            (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp)
            '''
        )
        for i in range(4):
-            tdSql.execute(f'create table db.ct{i+1} using stb1 tags ( {i+1} )')
+            tdSql.execute(f'create table {dbname}.ct{i+1} using {dbname}.stb1 tags ( {i+1} )')

        for i in range(9):
            tdSql.execute(
-                f"insert into db.ct1 values ( now()-{i*10}s, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a )"
+                f"insert into {dbname}.ct1 values ( now()-{i*10}s, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a )"
            )
            tdSql.execute(
-                f"insert into db.ct4 values ( now()-{i*90}d, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a )"
+                f"insert into {dbname}.ct4 values ( now()-{i*90}d, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a )"
            )
        tdSql.execute(
-            "insert into db.ct1 values (now()-45s, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar0', now()+8a )")
+            f"insert into {dbname}.ct1 values (now()-45s, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar0', now()+8a )")
        tdSql.execute(
-            "insert into db.ct1 values (now()+10s, 9, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a )")
+            f"insert into {dbname}.ct1 values (now()+10s, 9, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a )")
        tdSql.execute(
-            "insert into db.ct1 values (now()+15s, 9, -99999, -999, -99, -9.99, NULL, 1, 'binary9', 'nchar9', now()+9a )")
+            f"insert into {dbname}.ct1 values (now()+15s, 9, -99999, -999, -99, -9.99, NULL, 1, 'binary9', 'nchar9', now()+9a )")
        tdSql.execute(
-            "insert into db.ct1 values (now()+20s, 9, -99999, -999, NULL, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a )")
+            f"insert into {dbname}.ct1 values (now()+20s, 9, -99999, -999, NULL, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a )")

        tdSql.execute(
-            "insert into db.ct4 values (now()-810d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ")
+            f"insert into {dbname}.ct4 values (now()-810d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ")
        tdSql.execute(
-            "insert into db.ct4 values (now()-400d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ")
+            f"insert into {dbname}.ct4 values (now()-400d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ")
        tdSql.execute(
-            "insert into db.ct4 values (now()+90d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL  ) ")
+            f"insert into {dbname}.ct4 values (now()+90d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL  ) ")

        tdSql.execute(
-            f'''insert into db.t1 values
+            f'''insert into {dbname}.t1 values
            ( '2020-04-21 01:01:01.000', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
            ( '2020-10-21 01:01:01.000', 1, 11111, 111, 11, 1.11, 11.11, 1, "binary1", "nchar1", now()+1a )
            ( '2020-12-31 01:01:01.000', 2, 22222, 222, 22, 2.22, 22.22, 0, "binary2", "nchar2", now()+2a )
@ -124,53 +120,53 @@ class TDTestCase:
            '''
        )

-    def prepare_tag_datas(self,cache_value):
+    def prepare_tag_datas(self,cache_value, dbname="testdb"):

-        tdSql.execute("drop database if exists testdb ")
+        tdSql.execute(f"drop database if exists {dbname} ")
        # prepare datas
-        tdSql.execute(f"create database if not exists testdb keep 3650 duration 1000 cachemodel {cache_value}")
+        tdSql.execute(f"create database if not exists {dbname} keep 3650 duration 1000 cachemodel {cache_value}")

-        tdSql.execute(" use testdb ")
+        tdSql.execute(f"use {dbname} ")

-        tdSql.execute(f" create stable testdb.stb1 (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp , uc1 int unsigned,\
+        tdSql.execute(f"create stable {dbname}.stb1 (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp , uc1 int unsigned,\
             uc2 bigint unsigned ,uc3 smallint unsigned , uc4 tinyint unsigned ) tags( t1 int , t2 bigint , t3 smallint , t4 tinyint , t5 float , t6 double , t7 bool , t8 binary(36)\
                 , t9 nchar(36) , t10 int unsigned , t11 bigint unsigned ,t12 smallint unsigned , t13 tinyint unsigned ,t14 timestamp  ) ")

        tdSql.execute(
-            '''
-            create table testdb.t1
+            f'''
+            create table {dbname}.t1
            (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp)
            '''
        )
        for i in range(4):
            tdSql.execute(
-                f'create table testdb.ct{i+1} using stb1 tags ( {1*i}, {11111*i}, {111*i}, {1*i}, {1.11*i}, {11.11*i}, {i%2}, "binary{i}", "nchar{i}" ,{111*i}, {1*i},{1*i},{1*i},now())')
+                f'create table {dbname}.ct{i+1} using {dbname}.stb1 tags ( {1*i}, {11111*i}, {111*i}, {1*i}, {1.11*i}, {11.11*i}, {i%2}, "binary{i}", "nchar{i}" ,{111*i}, {1*i},{1*i},{1*i},now())')

        for i in range(9):
            tdSql.execute(
-                f"insert into testdb.ct1 values ( now()-{i*10}s, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a ,{111*i},{1111*i},{i},{i} )"
+                f"insert into {dbname}.ct1 values ( now()-{i*10}s, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a ,{111*i},{1111*i},{i},{i} )"
            )
            tdSql.execute(
-                f"insert into testdb.ct4 values ( now()-{i*90}d, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a ,{111*i},{1111*i},{i},{i})"
+                f"insert into {dbname}.ct4 values ( now()-{i*90}d, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a ,{111*i},{1111*i},{i},{i})"
            )
        tdSql.execute(
-            "insert into testdb.ct1 values (now()-45s, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar0', now()+8a ,0,0,0,0)")
+            f"insert into {dbname}.ct1 values (now()-45s, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar0', now()+8a ,0,0,0,0)")
        tdSql.execute(
-            "insert into testdb.ct1 values (now()+10s, 9, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a , 999 , 9999 , 9 , 9)")
+            f"insert into {dbname}.ct1 values (now()+10s, 9, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a , 999 , 9999 , 9 , 9)")
        tdSql.execute(
-            "insert into testdb.ct1 values (now()+15s, 9, -99999, -999, -99, -9.99, NULL, 1, 'binary9', 'nchar9', now()+9a , 999 , 99999 , 9 , 9)")
+            f"insert into {dbname}.ct1 values (now()+15s, 9, -99999, -999, -99, -9.99, NULL, 1, 'binary9', 'nchar9', now()+9a , 999 , 99999 , 9 , 9)")
        tdSql.execute(
-            "insert into testdb.ct1 values (now()+20s, 9, -99999, -999, NULL, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a ,999 , 99999 , 9 , 9)")
+            f"insert into {dbname}.ct1 values (now()+20s, 9, -99999, -999, NULL, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a ,999 , 99999 , 9 , 9)")

        tdSql.execute(
-            "insert into testdb.ct4 values (now()-810d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL , NULL, NULL, NULL, NULL) ")
+            f"insert into {dbname}.ct4 values (now()-810d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL , NULL, NULL, NULL, NULL) ")
        tdSql.execute(
-            "insert into testdb.ct4 values (now()-400d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL , NULL, NULL, NULL, NULL) ")
+            f"insert into {dbname}.ct4 values (now()-400d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL , NULL, NULL, NULL, NULL) ")
        tdSql.execute(
-            "insert into testdb.ct4 values (now()+90d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL , NULL, NULL, NULL, NULL ) ")
+            f"insert into {dbname}.ct4 values (now()+90d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL , NULL, NULL, NULL, NULL ) ")

        tdSql.execute(
-            f'''insert into testdb.t1 values
+            f'''insert into {dbname}.t1 values
            ( '2020-04-21 01:01:01.000', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
            ( '2020-10-21 01:01:01.000', 1, 11111, 111, 11, 1.11, 11.11, 1, "binary1", "nchar1", now()+1a )
            ( '2020-12-31 01:01:01.000', 2, 22222, 222, 22, 2.22, 22.22, 0, "binary2", "nchar2", now()+2a )
@ -217,108 +213,106 @@ class TDTestCase:
            tdLog.info(
                "abs value check pass , it work as expected ,sql is \"%s\"   " % abs_query)

-    def test_errors(self):
-        tdSql.execute("use testdb")
-
+    def test_errors(self, dbname="testdb"):
        # bug need fix
-        tdSql.error("select last_row(c1 ,NULL) from testdb.t1")
+        tdSql.error(f"select last_row(c1 ,NULL) from {dbname}.t1")

        error_sql_lists = [
-            "select last_row from testdb.t1",
-            "select last_row(-+--+c1) from testdb.t1",
-            "select last_row(123--123)==1 from testdb.t1",
-            "select last_row(c1) as 'd1' from testdb.t1",
-            #"select last_row(c1 ,NULL) from testdb.t1",
-            "select last_row(,) from testdb.t1;",
-            "select last_row(abs(c1) ab from testdb.t1)",
-            "select last_row(c1) as int from testdb.t1",
-            "select last_row from testdb.stb1",
-            "select last_row(123--123)==1 from testdb.stb1",
-            "select last_row(c1) as 'd1' from testdb.stb1",
-            #"select last_row(c1 ,NULL) from testdb.stb1",
-            "select last_row(,) from testdb.stb1;",
-            "select last_row(abs(c1) ab from testdb.stb1)",
-            "select last_row(c1) as int from testdb.stb1"
+            f"select last_row from {dbname}.t1",
+            f"select last_row(-+--+c1) from {dbname}.t1",
+            f"select last_row(123--123)==1 from {dbname}.t1",
+            f"select last_row(c1) as 'd1' from {dbname}.t1",
+            #f"select last_row(c1 ,NULL) from {dbname}.t1",
+            f"select last_row(,) from {dbname}.t1;",
+            f"select last_row(abs(c1) ab from {dbname}.t1)",
+            f"select last_row(c1) as int from {dbname}.t1",
+            f"select last_row from {dbname}.stb1",
+            f"select last_row(123--123)==1 from {dbname}.stb1",
+            f"select last_row(c1) as 'd1' from {dbname}.stb1",
+            #f"select last_row(c1 ,NULL) from {dbname}.stb1",
+            f"select last_row(,) from {dbname}.stb1;",
+            f"select last_row(abs(c1) ab from {dbname}.stb1)",
+            f"select last_row(c1) as int from {dbname}.stb1"
        ]
        for error_sql in error_sql_lists:
            tdSql.error(error_sql)

-    def support_types(self):
-        tdSql.execute("use testdb")
+    def support_types(self, dbname="testdb"):
+        tdSql.execute(f"use {dbname}")
        tbnames = ["stb1", "t1", "ct1", "ct2"]

        for tbname in tbnames:
-            tdSql.query("desc {}".format(tbname))
+            tdSql.query(f"desc {dbname}.{tbname}")
            coltypes = tdSql.queryResult
            for coltype in coltypes:
                colname = coltype[0]
                col_note = coltype[-1]
                if col_note != "TAG":
-                    abs_sql = "select last_row({}) from {}".format(colname, "testdb."+tbname)
+                    abs_sql = f"select last_row({colname}) from {dbname}.{tbname}"
                    tdSql.query(abs_sql)


-    def basic_abs_function(self):
+    def basic_abs_function(self, dbname="testdb"):

        # basic query
-        tdSql.query("select c1 from testdb.ct3")
+        tdSql.query(f"select c1 from {dbname}.ct3")
        tdSql.checkRows(0)
-        tdSql.query("select c1 from testdb.t1")
+        tdSql.query(f"select c1 from {dbname}.t1")
        tdSql.checkRows(12)
-        tdSql.query("select c1 from testdb.stb1")
+        tdSql.query(f"select c1 from {dbname}.stb1")
        tdSql.checkRows(25)

        # used for empty table  , ct3 is empty
-        tdSql.query("select last_row(c1) from testdb.ct3")
+        tdSql.query(f"select last_row(c1) from {dbname}.ct3")
        tdSql.checkRows(0)
-        tdSql.query("select last_row(c2) from testdb.ct3")
+        tdSql.query(f"select last_row(c2) from {dbname}.ct3")
        tdSql.checkRows(0)
-        tdSql.query("select last_row(c3) from testdb.ct3")
+        tdSql.query(f"select last_row(c3) from {dbname}.ct3")
        tdSql.checkRows(0)
-        tdSql.query("select last_row(c4) from testdb.ct3")
+        tdSql.query(f"select last_row(c4) from {dbname}.ct3")
        tdSql.checkRows(0)
-        tdSql.query("select last_row(c5) from testdb.ct3")
+        tdSql.query(f"select last_row(c5) from {dbname}.ct3")
        tdSql.checkRows(0)
-        tdSql.query("select last_row(c6) from testdb.ct3")
+        tdSql.query(f"select last_row(c6) from {dbname}.ct3")

        # used for regular table

        # bug need fix
-        tdSql.query("select last_row(c1) from testdb.t1")
+        tdSql.query(f"select last_row(c1) from {dbname}.t1")
        tdSql.checkData(0, 0, None)
-        tdSql.query("select last_row(c1) from testdb.ct4")
+        tdSql.query(f"select last_row(c1) from {dbname}.ct4")
        tdSql.checkData(0, 0, None)
-        tdSql.query("select last_row(c1) from testdb.stb1")
+        tdSql.query(f"select last_row(c1) from {dbname}.stb1")
        tdSql.checkData(0, 0, None)

        # support regular query about last ,first ,last_row
-        tdSql.error("select last_row(c1,NULL) from testdb.t1")
-        tdSql.error("select last_row(NULL) from testdb.t1")
-        tdSql.error("select last(NULL) from testdb.t1")
-        tdSql.error("select first(NULL) from testdb.t1")
+        tdSql.error(f"select last_row(c1,NULL) from {dbname}.t1")
+        tdSql.error(f"select last_row(NULL) from {dbname}.t1")
+        tdSql.error(f"select last(NULL) from {dbname}.t1")
+        tdSql.error(f"select first(NULL) from {dbname}.t1")

-        tdSql.query("select last_row(c1,123) from testdb.t1")
+        tdSql.query(f"select last_row(c1,123) from {dbname}.t1")
        tdSql.checkData(0,0,None)
        tdSql.checkData(0,1,123)

-        tdSql.query("select last_row(123) from testdb.t1")
+        tdSql.query(f"select last_row(123) from {dbname}.t1")
        tdSql.checkData(0,0,123)

-        tdSql.error("select last(c1,NULL) from testdb.t1")
+        tdSql.error(f"select last(c1,NULL) from {dbname}.t1")

-        tdSql.query("select last(c1,123) from testdb.t1")
+        tdSql.query(f"select last(c1,123) from {dbname}.t1")
        tdSql.checkData(0,0,9)
        tdSql.checkData(0,1,123)

-        tdSql.error("select first(c1,NULL) from testdb.t1")
+        tdSql.error(f"select first(c1,NULL) from {dbname}.t1")

-        tdSql.query("select first(c1,123) from testdb.t1")
+        tdSql.query(f"select first(c1,123) from {dbname}.t1")
        tdSql.checkData(0,0,1)
        tdSql.checkData(0,1,123)

-        tdSql.error("select last_row(c1,c2,c3,NULL,c4) from testdb.t1")
+        tdSql.error(f"select last_row(c1,c2,c3,NULL,c4) from {dbname}.t1")

-        tdSql.query("select last_row(c1,c2,c3,123,c4) from testdb.t1")
+        tdSql.query(f"select last_row(c1,c2,c3,123,c4) from {dbname}.t1")
        tdSql.checkData(0,0,None)
        tdSql.checkData(0,1,None)
        tdSql.checkData(0,2,None)
@ -326,9 +320,9 @@ class TDTestCase:
        tdSql.checkData(0,4,None)


-        tdSql.error("select last_row(c1,c2,c3,NULL,c4,t1,t2) from testdb.ct1")
+        tdSql.error(f"select last_row(c1,c2,c3,NULL,c4,t1,t2) from {dbname}.ct1")

-        tdSql.query("select last_row(c1,c2,c3,123,c4,t1,t2) from testdb.ct1")
+        tdSql.query(f"select last_row(c1,c2,c3,123,c4,t1,t2) from {dbname}.ct1")
        tdSql.checkData(0,0,9)
        tdSql.checkData(0,1,-99999)
        tdSql.checkData(0,2,-999)
@ -338,13 +332,13 @@ class TDTestCase:
        tdSql.checkData(0,5,0)

        # # bug need fix
-        tdSql.query("select last_row(c1), c2, c3 , c4, c5 from testdb.t1")
+        tdSql.query(f"select last_row(c1), c2, c3 , c4, c5 from {dbname}.t1")
        tdSql.checkData(0, 0, None)
        tdSql.checkData(0, 1, None)
        tdSql.checkData(0, 2, None)

        # # bug need fix
-        tdSql.query("select last_row(c1), c2, c3 , c4, c5 from testdb.ct1")
+        tdSql.query(f"select last_row(c1), c2, c3 , c4, c5 from {dbname}.ct1")
        tdSql.checkData(0, 0, 9)
        tdSql.checkData(0, 1, -99999)
        tdSql.checkData(0, 2, -999)
@ -352,7 +346,7 @@ class TDTestCase:
        tdSql.checkData(0, 4,-9.99000)

        # bug need fix
-        tdSql.query("select last_row(c1), c2, c3 , c4, c5 from testdb.stb1 where tbname='ct1'")
+        tdSql.query(f"select last_row(c1), c2, c3 , c4, c5 from {dbname}.stb1 where tbname='ct1'")
        tdSql.checkData(0, 0, 9)
        tdSql.checkData(0, 1, -99999)
        tdSql.checkData(0, 2, -999)
@ -360,124 +354,124 @@ class TDTestCase:
        tdSql.checkData(0, 4,-9.99000)

        # bug fix
-        tdSql.query("select last_row(abs(c1)) from testdb.ct1")
+        tdSql.query(f"select last_row(abs(c1)) from {dbname}.ct1")
        tdSql.checkData(0,0,9)

        # # bug fix
-        tdSql.query("select last_row(c1+1) from testdb.ct1")
-        tdSql.query("select last_row(c1+1) from testdb.stb1")
-        tdSql.query("select last_row(c1+1) from testdb.t1")
+        tdSql.query(f"select last_row(c1+1) from {dbname}.ct1")
+        tdSql.query(f"select last_row(c1+1) from {dbname}.stb1")
+        tdSql.query(f"select last_row(c1+1) from {dbname}.t1")

        # used for stable table
-        tdSql.query("select last_row(c1 ,c2 ,c3) ,last_row(c4) from testdb.ct1")
+        tdSql.query(f"select last_row(c1 ,c2 ,c3) ,last_row(c4) from {dbname}.ct1")
        tdSql.checkData(0,0,9)
        tdSql.checkData(0,1,-99999)
        tdSql.checkData(0,2,-999)
        tdSql.checkData(0,3,None)

        # bug need fix
-        tdSql.query("select last_row(c1 ,c2 ,c3) from testdb.stb1 ")
+        tdSql.query(f"select last_row(c1 ,c2 ,c3) from {dbname}.stb1 ")
        tdSql.checkData(0,0,None)
        tdSql.checkData(0,1,None)
        tdSql.checkData(0,2,None)


-        tdSql.query('select last_row(c1) from testdb.t1 where ts <"2022-12-31 01:01:36.000"')
+        tdSql.query(f'select last_row(c1) from {dbname}.t1 where ts <"2022-12-31 01:01:36.000"')
        tdSql.checkData(0,0,8)
        # bug need fix
-        tdSql.query("select abs(last_row(c1)-2)+max(c1),ceil(last_row(c4)-2) from testdb.stb1 where c4 is not null")
+        tdSql.query(f"select abs(last_row(c1)-2)+max(c1),ceil(last_row(c4)-2) from {dbname}.stb1 where c4 is not null")
        tdSql.checkData(0,0,16.000000000)
        tdSql.checkData(0,1,-101.000000000)

-        tdSql.query("select abs(last_row(c1)-2)+max(c1),ceil(last_row(c4)-2) from testdb.ct1 where c4<0")
+        tdSql.query(f"select abs(last_row(c1)-2)+max(c1),ceil(last_row(c4)-2) from {dbname}.ct1 where c4<0")
        tdSql.checkData(0,0,16.000000000)
        tdSql.checkData(0,1,-101.000000000)

-        tdSql.query("select last_row(ceil(c1+2)+floor(c1)-10) from testdb.stb1")
+        tdSql.query(f"select last_row(ceil(c1+2)+floor(c1)-10) from {dbname}.stb1")
        tdSql.checkData(0,0,None)

-        tdSql.query("select last_row(ceil(c1+2)+floor(c1)-10) from testdb.ct1")
+        tdSql.query(f"select last_row(ceil(c1+2)+floor(c1)-10) from {dbname}.ct1")
        tdSql.checkData(0,0,10.000000000)

        # filter for last_row

        # bug need fix for all function

-        tdSql.query("select last_row(ts ,c1 ) from testdb.ct4 where t1 = 1 ")
+        tdSql.query(f"select last_row(ts ,c1 ) from {dbname}.ct4 where t1 = 1 ")
        tdSql.checkRows(0)

-        tdSql.query("select count(c1) from testdb.ct4 where t1 = 1 ")
+        tdSql.query(f"select count(c1) from {dbname}.ct4 where t1 = 1 ")
        tdSql.checkRows(0)

-        tdSql.query("select last_row(c1) ,last(c1)  from testdb.stb1 where  c1 is null")
+        tdSql.query(f"select last_row(c1) ,last(c1)  from {dbname}.stb1 where  c1 is null")
        tdSql.checkRows(1)
        tdSql.checkData(0,0,None)
        tdSql.checkData(0,1,None)

-        tdSql.query("select last_row(c1) ,count(*)  from testdb.stb1 where  c1 is null")
+        tdSql.query(f"select last_row(c1) ,count(*)  from {dbname}.stb1 where  c1 is null")
        tdSql.checkData(0,0,None)
        tdSql.checkData(0,1,3)

-        tdSql.query("select last_row(c1) ,count(c1)  from testdb.stb1 where  c1 is null")
+        tdSql.query(f"select last_row(c1) ,count(c1)  from {dbname}.stb1 where  c1 is null")
        tdSql.checkData(0,0,None)
        tdSql.checkData(0,1,0)

        # bug need fix
-        tdSql.query("select tbname ,last_row(c1) from testdb.stb1")
+        tdSql.query(f"select tbname ,last_row(c1) from {dbname}.stb1")
        tdSql.checkData(0,0,'ct4')
        tdSql.checkData(0,1,None)

-        tdSql.query(" select tbname ,last_row(c1) from testdb.stb1 partition by tbname order by tbname ")
+        tdSql.query(f"select tbname ,last_row(c1) from {dbname}.stb1 partition by tbname order by tbname ")
        tdSql.checkData(0,0,'ct1')
        tdSql.checkData(0,1,9)
        tdSql.checkData(1,0,'ct4')
        tdSql.checkData(1,1,None)

-        tdSql.query(" select tbname ,last_row(c1) from testdb.stb1 group by tbname order by tbname ")
+        tdSql.query(f"select tbname ,last_row(c1) from {dbname}.stb1 group by tbname order by tbname ")
        tdSql.checkData(0,0,'ct1')
        tdSql.checkData(0,1,9)
        tdSql.checkData(1,0,'ct4')
        tdSql.checkData(1,1,None)

-        tdSql.query(" select t1 ,count(c1) from testdb.stb1 partition by t1 ")
+        tdSql.query(f"select t1 ,count(c1) from {dbname}.stb1 partition by t1 ")
        tdSql.checkRows(2)

        # filter by tbname
-        tdSql.query("select last_row(c1) from testdb.stb1 where tbname = 'ct1' ")
+        tdSql.query(f"select last_row(c1) from {dbname}.stb1 where tbname = 'ct1' ")
        tdSql.checkData(0,0,9)

        # bug need fix
-        tdSql.query("select tbname ,last_row(c1) from testdb.stb1 where tbname = 'ct1' ")
+        tdSql.query(f"select tbname ,last_row(c1) from {dbname}.stb1 where tbname = 'ct1' ")
        tdSql.checkData(0,1,9)
-        tdSql.query("select tbname ,last_row(c1) from testdb.stb1 partition by tbname order by tbname")
+        tdSql.query(f"select tbname ,last_row(c1) from {dbname}.stb1 partition by tbname order by tbname")
        tdSql.checkData(0, 0, 'ct1')
        tdSql.checkData(0, 1, 9)
        tdSql.checkData(1, 0, 'ct4')
        tdSql.checkData(1, 1, None)

-        tdSql.query("select tbname ,last_row(c1) from testdb.stb1 group by tbname order by tbname")
+        tdSql.query(f"select tbname ,last_row(c1) from {dbname}.stb1 group by tbname order by tbname")
        tdSql.checkData(0, 0, 'ct1')
        tdSql.checkData(0, 1, 9)
        tdSql.checkData(1, 0, 'ct4')
        tdSql.checkData(1, 1, None)

        # last_row for only tag
-        tdSql.query("select last_row(t1 ,t2 ,t3 , t4 ) from testdb.stb1")
+        tdSql.query(f"select last_row(t1 ,t2 ,t3 , t4 ) from {dbname}.stb1")
        tdSql.checkData(0,0,3)
        tdSql.checkData(0,1,33333)
        tdSql.checkData(0,2,333)
        tdSql.checkData(0,3,3)

-        tdSql.query("select last_row(abs(floor(t1)) ,t2 ,ceil(abs(t3)) , abs(ceil(t4)) ) from testdb.stb1")
+        tdSql.query(f"select last_row(abs(floor(t1)) ,t2 ,ceil(abs(t3)) , abs(ceil(t4)) ) from {dbname}.stb1")
        tdSql.checkData(0,0,3)
        tdSql.checkData(0,1,33333)
        tdSql.checkData(0,2,333)
        tdSql.checkData(0,3,3)

        # filter by tag
-        tdSql.query("select tbname ,last_row(c1) from testdb.stb1 where t1 =0 ")
+        tdSql.query(f"select tbname ,last_row(c1) from {dbname}.stb1 where t1 =0 ")
        tdSql.checkData(0,1,9)
-        tdSql.query("select tbname ,last_row(c1) ,t1 from testdb.stb1 partition by t1 order by t1")
+        tdSql.query(f"select tbname ,last_row(c1) ,t1 from {dbname}.stb1 partition by t1 order by t1")
        tdSql.checkData(0, 0, 'ct1')
        tdSql.checkData(0, 1, 9)
        tdSql.checkData(1, 0, 'ct4')
@ -485,56 +479,55 @@ class TDTestCase:

        # filter by col

-        tdSql.query("select tbname ,last_row(c1),abs(c1)from testdb.stb1 where c1 =1;")
+        tdSql.query(f"select tbname ,last_row(c1),abs(c1)from {dbname}.stb1 where c1 =1;")
        tdSql.checkData(0, 0, 'ct1')
        tdSql.checkData(0, 1, 1)
        tdSql.checkData(0, 2, 1)
-        tdSql.query("select last_row(c1) from testdb.stb1 where abs(ceil(c1))*c1==1")
+        tdSql.query(f"select last_row(c1) from {dbname}.stb1 where abs(ceil(c1))*c1==1")
        tdSql.checkData(0,0,1)

        # mix with common functions
-        tdSql.query("select last_row(*) ,last(*) from testdb.stb1  ")
+        tdSql.query(f"select last_row(*) ,last(*) from {dbname}.stb1  ")
        tdSql.checkRows(1)

-        tdSql.query("select last_row(*) ,last(*) from testdb.stb1  ")
+        tdSql.query(f"select last_row(*) ,last(*) from {dbname}.stb1  ")
        tdSql.checkRows(1)


-        tdSql.query("select last_row(c1+abs(c1)) from testdb.stb1 partition by tbname order by tbname")
-        tdSql.query("select last(c1), max(c1+abs(c1)),last_row(c1+abs(c1)) from testdb.stb1 partition by tbname order by tbname")
+        tdSql.query(f"select last_row(c1+abs(c1)) from {dbname}.stb1 partition by tbname order by tbname")
+        tdSql.query(f"select last(c1), max(c1+abs(c1)),last_row(c1+abs(c1)) from {dbname}.stb1 partition by tbname order by tbname")

        # # bug need fix ,taosd crash
-        tdSql.error("select last_row(*) ,last(*) from testdb.stb1 partition by tbname order by last(*)")
-        tdSql.error("select last_row(*) ,last(*) from testdb.stb1 partition by tbname order by last_row(*)")
+        tdSql.error(f"select last_row(*) ,last(*) from {dbname}.stb1 partition by tbname order by last(*)")
+        tdSql.error(f"select last_row(*) ,last(*) from {dbname}.stb1 partition by tbname order by last_row(*)")

        # mix with agg functions
-        tdSql.query("select last(*), last_row(*),last(c1), last_row(c1) from testdb.stb1 ")
-        tdSql.query("select last(*), last_row(*),last(c1), last_row(c1) from testdb.ct1 ")
-        tdSql.query("select last(*), last_row(*),last(c1+1)*max(c1), last_row(c1+2)/2 from testdb.t1 ")
-        tdSql.query("select last_row(*) ,abs(c1/2)+100 from testdb.stb1 where tbname =\"ct1\" ")
-        tdSql.query("select c1, last_row(c5) from testdb.ct1 ")
-        tdSql.error("select c1, last_row(c5) ,last(c1) from testdb.stb1 ")
+        tdSql.query(f"select last(*), last_row(*),last(c1), last_row(c1) from {dbname}.stb1 ")
+        tdSql.query(f"select last(*), last_row(*),last(c1), last_row(c1) from {dbname}.ct1 ")
+        tdSql.query(f"select last(*), last_row(*),last(c1+1)*max(c1), last_row(c1+2)/2 from {dbname}.t1 ")
+        tdSql.query(f"select last_row(*) ,abs(c1/2)+100 from {dbname}.stb1 where tbname =\"ct1\" ")
+        tdSql.query(f"select c1, last_row(c5) from {dbname}.ct1 ")
+        tdSql.error(f"select c1, last_row(c5) ,last(c1) from {dbname}.stb1 ")

        # agg functions mix with agg functions

-        tdSql.query("select last(c1) , max(c5), count(c5) from testdb.stb1")
-        tdSql.query("select last_row(c1) , max(c5), count(c5) from testdb.ct1")
+        tdSql.query(f"select last(c1) , max(c5), count(c5) from {dbname}.stb1")
+        tdSql.query(f"select last_row(c1) , max(c5), count(c5) from {dbname}.ct1")

        # bug fix for compute
-        tdSql.query("select  last_row(c1) -0 ,last(c1)-0 ,last(c1)+last_row(c1) from testdb.ct4 ")
+        tdSql.query(f"select  last_row(c1) -0 ,last(c1)-0 ,last(c1)+last_row(c1) from {dbname}.ct4 ")
        tdSql.checkData(0,0,None)
        tdSql.checkData(0,1,0.000000000)
        tdSql.checkData(0,2,None)

-        tdSql.query(" select c1, abs(c1) -0 ,last_row(c1-0.1)-0.1 from testdb.ct1")
+        tdSql.query(f"select c1, abs(c1) -0 ,last_row(c1-0.1)-0.1 from {dbname}.ct1")
        tdSql.checkData(0,0,9)
        tdSql.checkData(0,1,9.000000000)
        tdSql.checkData(0,2,8.800000000)

-    def abs_func_filter(self):
-        tdSql.execute("use db")
+    def abs_func_filter(self, dbname="db"):
        tdSql.query(
-            "select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,last_row(log(c1,2)-0.5) from db.ct4 where c1>5 ")
+            f"select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,last_row(log(c1,2)-0.5) from {dbname}.ct4 where c1>5 ")
        tdSql.checkData(0, 0, 6)
        tdSql.checkData(0, 1, 6.000000000)
        tdSql.checkData(0, 2, 6.000000000)
@ -542,19 +535,19 @@ class TDTestCase:
        tdSql.checkData(0, 4, 2.084962501)

        tdSql.query(
-            "select last_row(c1,c2,c1+5) from db.ct4 where c1=5 ")
+            f"select last_row(c1,c2,c1+5) from {dbname}.ct4 where c1=5 ")
        tdSql.checkData(0, 0, 5)
        tdSql.checkData(0, 1, 55555)
        tdSql.checkData(0, 2, 10.000000000)

        tdSql.query(
-            "select last(c1,c2,c1+5) from db.ct4 where c1=5 ")
+            f"select last(c1,c2,c1+5) from {dbname}.ct4 where c1=5 ")
        tdSql.checkData(0, 0, 5)
        tdSql.checkData(0, 1, 55555)
        tdSql.checkData(0, 2, 10.000000000)

        tdSql.query(
-            "select c1,c2 , abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) from db.ct4 where c1>log(c1,2) limit 1 ")
+            f"select c1,c2 , abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) from {dbname}.ct4 where c1>log(c1,2) limit 1 ")
        tdSql.checkRows(1)
        tdSql.checkData(0, 0, 8)
        tdSql.checkData(0, 1, 88888)
@ -566,166 +559,162 @@ class TDTestCase:
    def abs_Arithmetic(self):
        pass

-    def check_boundary_values(self):
+    def check_boundary_values(self, dbname="bound_test"):

-        tdSql.execute("drop database if exists bound_test")
-        tdSql.execute("create database if not exists bound_test cachemodel 'LAST_ROW' ")
+        tdSql.execute(f"drop database if exists {dbname}")
+        tdSql.execute(f"create database if not exists {dbname} cachemodel 'LAST_ROW' ")

        time.sleep(3)
-        tdSql.execute("use bound_test")
+        tdSql.execute(f"use {dbname}")
        tdSql.execute(
-            "create table bound_test.stb_bound (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(32),c9 nchar(32), c10 timestamp) tags (t1 int);"
+            f"create table {dbname}.stb_bound (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(32),c9 nchar(32), c10 timestamp) tags (t1 int);"
        )
-        tdSql.execute(f'create table bound_test.sub1_bound using stb_bound tags ( 1 )')
+        tdSql.execute(f'create table {dbname}.sub1_bound using {dbname}.stb_bound tags ( 1 )')
        tdSql.execute(
-            f"insert into bound_test.sub1_bound values ( now()-1s, 2147483647, 9223372036854775807, 32767, 127, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            f"insert into {dbname}.sub1_bound values ( now()-1s, 2147483647, 9223372036854775807, 32767, 127, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
        )
        tdSql.execute(
-            f"insert into bound_test.sub1_bound values ( now()-1s, -2147483647, -9223372036854775807, -32767, -127, -3.40E+38, -1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            f"insert into {dbname}.sub1_bound values ( now()-1s, -2147483647, -9223372036854775807, -32767, -127, -3.40E+38, -1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
        )
        tdSql.execute(
-            f"insert into bound_test.sub1_bound values ( now(), 2147483646, 9223372036854775806, 32766, 126, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            f"insert into {dbname}.sub1_bound values ( now(), 2147483646, 9223372036854775806, 32766, 126, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
        )
        tdSql.execute(
-            f"insert into bound_test.sub1_bound values ( now(), -2147483646, -9223372036854775806, -32766, -126, -3.40E+38, -1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            f"insert into {dbname}.sub1_bound values ( now(), -2147483646, -9223372036854775806, -32766, -126, -3.40E+38, -1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
        )
        tdSql.error(
-            f"insert into bound_test.sub1_bound values ( now()+1s, 2147483648, 9223372036854775808, 32768, 128, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            f"insert into {dbname}.sub1_bound values ( now()+1s, 2147483648, 9223372036854775808, 32768, 128, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
        )

        # check basic elem for table per row
        tdSql.query(
-            "select last(c1) ,last_row(c2), last_row(c3)+1 , last(c4)+1  from bound_test.sub1_bound ")
+            f"select last(c1) ,last_row(c2), last_row(c3)+1 , last(c4)+1  from {dbname}.sub1_bound ")
        tdSql.checkData(0, 0, -2147483646)
        tdSql.checkData(0, 1, -9223372036854775806)
        tdSql.checkData(0, 2, -32765.000000000)
        tdSql.checkData(0, 3, -125.000000000)
        # check  + - * / in functions
        tdSql.query(
-            "select last_row(c1+1) ,last_row(c2) , last(c3*1) , last(c4/2)  from bound_test.sub1_bound ")
-
-    def test_tag_compute_for_scalar_function(self):
-
-        tdSql.execute("use testdb")
+            f"select last_row(c1+1) ,last_row(c2) , last(c3*1) , last(c4/2)  from {dbname}.sub1_bound ")

+    def test_tag_compute_for_scalar_function(self, dbname="testdb"):
        # bug need fix

-        tdSql.query(" select sum(c1) from testdb.stb1 where t1+10 >1; ")
-        tdSql.query("select c1 ,t1 from testdb.stb1 where t1 =0 ")
+        tdSql.query(f"select sum(c1) from {dbname}.stb1 where t1+10 >1; ")
+        tdSql.query(f"select c1 ,t1 from {dbname}.stb1 where t1 =0 ")
        tdSql.checkRows(13)
-        tdSql.query("select last_row(c1,t1) from testdb.stb1 ")
+        tdSql.query(f"select last_row(c1,t1) from {dbname}.stb1 ")
        tdSql.checkData(0,0,None)
        tdSql.checkData(0,1,3)
-        tdSql.query("select last_row(c1),t1 from testdb.stb1 ")
+        tdSql.query(f"select last_row(c1),t1 from {dbname}.stb1 ")
        tdSql.checkData(0,0,None)
        tdSql.checkData(0,1,3)
-        tdSql.query("select last_row(c1,t1),last(t1) from testdb.stb1 ")
+        tdSql.query(f"select last_row(c1,t1),last(t1) from {dbname}.stb1 ")
        tdSql.checkData(0,0,None)
        tdSql.checkData(0,1,3)
        tdSql.checkData(0,2,3)

-        tdSql.query("select last_row(t1) from testdb.stb1 where t1 >0 ")
+        tdSql.query(f"select last_row(t1) from {dbname}.stb1 where t1 >0 ")
        tdSql.checkRows(1)
        tdSql.checkData(0,0,3)
-        tdSql.query("select last_row(t1) from testdb.stb1 where t1 =3 ")
+        tdSql.query(f"select last_row(t1) from {dbname}.stb1 where t1 =3 ")
        tdSql.checkRows(1)
        tdSql.checkData(0,0,3)

-        tdSql.query("select last_row(t1) from testdb.stb1 where t1 =2")
+        tdSql.query(f"select last_row(t1) from {dbname}.stb1 where t1 =2")
        tdSql.checkRows(0)

        # nest query for last_row
-        tdSql.query("select last_row(t1) from (select ts , c1 ,t1 from testdb.stb1)")
+        tdSql.query(f"select last_row(t1) from (select ts , c1 ,t1 from {dbname}.stb1)")
        tdSql.checkData(0,0,3)
-        tdSql.query("select distinct(c1) ,t1 from testdb.stb1")
+        tdSql.query(f"select distinct(c1) ,t1 from {dbname}.stb1")
        tdSql.checkRows(20)
-        tdSql.query("select last_row(c1) from (select _rowts , c1 ,t1 from testdb.stb1)")
+        tdSql.query(f"select last_row(c1) from (select _rowts , c1 ,t1 from {dbname}.stb1)")
        tdSql.checkData(0,0,None)

-        tdSql.query("select last_row(c1) from (select ts , c1 ,t1 from testdb.stb1)")
+        tdSql.query(f"select last_row(c1) from (select ts , c1 ,t1 from {dbname}.stb1)")
        tdSql.checkData(0,0,None)

-        tdSql.query("select ts , last_row(c1) ,c1  from (select ts , c1 ,t1 from testdb.stb1)")
+        tdSql.query(f"select ts , last_row(c1) ,c1  from (select ts , c1 ,t1 from {dbname}.stb1)")
        tdSql.checkData(0,1,None)

-        tdSql.query("select ts , last_row(c1) ,c1  from (select ts , max(c1) c1  ,t1 from testdb.stb1 where ts >now -1h and ts <now+1h interval(10s) fill(value ,10 ))")
+        tdSql.query(f"select ts , last_row(c1) ,c1  from (select ts , max(c1) c1  ,t1 from {dbname}.stb1 where ts >now -1h and ts <now+1h interval(10s) fill(value ,10 ))")
        tdSql.checkData(0,1,10)
        tdSql.checkData(0,1,10)

-        tdSql.error("select ts , last_row(c1) ,c1  from (select count(c1) c1 from testdb.stb1 where ts >now -1h and ts <now+1h interval(10s) fill(value ,10 ))")
+        tdSql.error(f"select ts , last_row(c1) ,c1  from (select count(c1) c1 from {dbname}.stb1 where ts >now -1h and ts <now+1h interval(10s) fill(value ,10 ))")

-        tdSql.error("select  last_row(c1) ,c1  from (select  count(c1) c1 from testdb.stb1 where ts >now -1h and ts <now+1h interval(10s) fill(value ,10 ))")
+        tdSql.error(f"select  last_row(c1) ,c1  from (select  count(c1) c1 from {dbname}.stb1 where ts >now -1h and ts <now+1h interval(10s) fill(value ,10 ))")

        # tag filter with last_row function
-        tdSql.query("select last_row(t1) from testdb.stb1 where abs(t1)=1")
+        tdSql.query(f"select last_row(t1) from {dbname}.stb1 where abs(t1)=1")
        tdSql.checkRows(0)
-        tdSql.query("select last_row(t1) from testdb.stb1 where abs(t1)=0")
+        tdSql.query(f"select last_row(t1) from {dbname}.stb1 where abs(t1)=0")
        tdSql.checkRows(1)
-        tdSql.query(" select last_row(t1),last_row(c1) from db.ct1 where abs(c1+t1)=1")
+        tdSql.query(f"select last_row(t1),last_row(c1) from db.ct1 where abs(c1+t1)=1")
        tdSql.checkRows(1)
        tdSql.checkData(0,0,1)
        tdSql.checkData(0,1,0)

        tdSql.query(
-            "select last_row(c1+t1)*t1 from testdb.stb1 where abs(c1)/floor(abs(ceil(t1))) ==1")
+            f"select last_row(c1+t1)*t1 from {dbname}.stb1 where abs(c1)/floor(abs(ceil(t1))) ==1")

-    def group_test(self):
-        tdSql.execute(" use testdb ")
-        tdSql.query(" select last_row(c1) from testdb.stb1 group by t1 order by t1 ")
+    def group_test(self, dbname="testdb"):
+        tdSql.query(f"select last_row(c1) from {dbname}.stb1 group by t1 order by t1 ")
        tdSql.checkRows(2)

        # bug need fix
-        tdSql.query("select last_row(c1) from testdb.stb1 group by c1 order by c1,t1 ")
+        tdSql.query(f"select last_row(c1) from {dbname}.stb1 group by c1 order by c1,t1 ")
        tdSql.checkRows(10)
        tdSql.checkData(9,0,8)
-        tdSql.query("select last_row(c1) from db.stb1 group by c1 order by t1 ")
+        tdSql.query(f"select last_row(c1) from {dbname}.stb1 group by c1 order by t1 ")
        tdSql.checkRows(10)
        tdSql.checkData(0,0,4)

-        tdSql.query("select last_row(c1) from testdb.stb1 group by c1 order by t1")
+        tdSql.query(f"select last_row(c1) from {dbname}.stb1 group by c1 order by t1")
        tdSql.checkRows(11)

-        tdSql.query("select last_row(c1) from testdb.stb1 group by c1 order by c1,t1;")
+        tdSql.query(f"select last_row(c1) from {dbname}.stb1 group by c1 order by c1,t1;")
        tdSql.checkRows(11)
        tdSql.checkData(10,0,9)

        # bug need fix , result is error
-        tdSql.query("select last_row(c1) from testdb.ct4 group by c1 order by t1 ")
-        tdSql.query("select last_row(t1) from testdb.ct4 group by c1 order by t1 ")
+        tdSql.query(f"select last_row(c1) from {dbname}.ct4 group by c1 order by t1 ")
+        tdSql.query(f"select last_row(t1) from {dbname}.ct4 group by c1 order by t1 ")

-        tdSql.query("select last_row(t1) from testdb.stb1 group by t1 order by t1 ")
+        tdSql.query(f"select last_row(t1) from {dbname}.stb1 group by t1 order by t1 ")
        tdSql.checkRows(2)
-        tdSql.query("select last_row(c1) from testdb.stb1 group by c1 order by c1 ")
+        tdSql.query(f"select last_row(c1) from {dbname}.stb1 group by c1 order by c1 ")
        tdSql.checkRows(11)
        tdSql.checkData(0,0,None)
        tdSql.checkData(10,0,9)

-        tdSql.query("select ceil(abs(last_row(abs(c1)))) from testdb.stb1 group by abs(c1) order by abs(c1);")
+        tdSql.query(f"select ceil(abs(last_row(abs(c1)))) from {dbname}.stb1 group by abs(c1) order by abs(c1);")
        tdSql.checkRows(11)
        tdSql.checkData(0,0,None)
        tdSql.checkData(10,0,9)
-        tdSql.query("select last_row(c1+c3) from testdb.stb1 group by abs(c1+c3) order by abs(c1+c3)")
+        tdSql.query(f"select last_row(c1+c3) from {dbname}.stb1 group by abs(c1+c3) order by abs(c1+c3)")
        tdSql.checkRows(11)

        # bug need fix , taosd crash
-        tdSql.query("select last_row(c1+c3)+c2 from testdb.stb1 group by abs(c1+c3)+c2 order by abs(c1+c3)+c2")
+        tdSql.query(f"select last_row(c1+c3)+c2 from {dbname}.stb1 group by abs(c1+c3)+c2 order by abs(c1+c3)+c2")
        tdSql.checkRows(11)
-        tdSql.query("select last_row(c1+c3)+last_row(c2) from testdb.stb1 group by abs(c1+c3)+abs(c2) order by abs(c1+c3)+abs(c2)")
+        tdSql.query(f"select last_row(c1+c3)+last_row(c2) from {dbname}.stb1 group by abs(c1+c3)+abs(c2) order by abs(c1+c3)+abs(c2)")
        tdSql.checkRows(11)
        tdSql.checkData(0,0,None)
        tdSql.checkData(2,0,11223.000000000)

-        tdSql.query("select last_row(t1) from testdb.stb1 where abs(c1+t1)=1 partition by tbname")
+        tdSql.query(f"select last_row(t1) from {dbname}.stb1 where abs(c1+t1)=1 partition by tbname")
        tdSql.checkData(0,0,1)

-        tdSql.query("select tbname , last_row(c1) from testdb.stb1 partition by tbname order by tbname")
+        tdSql.query(f"select tbname , last_row(c1) from {dbname}.stb1 partition by tbname order by tbname")
        tdSql.checkRows(2)
        tdSql.checkData(0, 0, 'ct1')
        tdSql.checkData(0, 1,  9)
        tdSql.checkData(0, 2, 'ct4')
        tdSql.checkData(0, 3, None)

-        tdSql.query("select tbname , last_row(c1) from testdb.stb1 partition by t1 order by t1")
+        tdSql.query(f"select tbname , last_row(c1) from {dbname}.stb1 partition by t1 order by t1")
        tdSql.checkRows(2)
        tdSql.checkData(0, 0, 'ct1')
        tdSql.checkData(0, 1,  9)
@ -733,110 +722,109 @@ class TDTestCase:
        tdSql.checkData(0, 3, None)

        # bug need fix
-        tdSql.query("select tbname , last_row(c1) from testdb.stb1 partition by c2 order by c1")
+        tdSql.query(f"select tbname , last_row(c1) from {dbname}.stb1 partition by c2 order by c1")
        tdSql.checkRows(11)
        tdSql.checkData(10,1,9)

-        tdSql.query("select tbname , last_row(c1) from testdb.stb1 partition by c2 order by c2")
+        tdSql.query(f"select tbname , last_row(c1) from {dbname}.stb1 partition by c2 order by c2")
        tdSql.checkRows(11)
        tdSql.checkData(10,1,88888)

-        tdSql.query("select tbname , last_row(t1) from testdb.stb1 partition by c2 order by t1")
+        tdSql.query(f"select tbname , last_row(t1) from {dbname}.stb1 partition by c2 order by t1")
        tdSql.checkRows(11)

-        tdSql.query("select abs(c1) ,c2 ,t1, last_row(t1) from testdb.stb1 partition by c2 order by t1")
+        tdSql.query(f"select abs(c1) ,c2 ,t1, last_row(t1) from {dbname}.stb1 partition by c2 order by t1")
        tdSql.checkRows(11)

-        tdSql.query("select t1 ,last_row(t1) ,c2 from testdb.stb1 partition by c2 order by t1")
+        tdSql.query(f"select t1 ,last_row(t1) ,c2 from {dbname}.stb1 partition by c2 order by t1")
        tdSql.checkRows(11)

-        tdSql.query("select last_row(t1) ,last_row(t1) ,last_row(c2) from testdb.stb1 partition by c2 order by c2")
+        tdSql.query(f"select last_row(t1) ,last_row(t1) ,last_row(c2) from {dbname}.stb1 partition by c2 order by c2")
        tdSql.checkRows(11)

-        tdSql.query("select abs(c1) , last_row(t1) ,c2 from testdb.stb1 partition by tbname order by tbname")
+        tdSql.query(f"select abs(c1) , last_row(t1) ,c2 from {dbname}.stb1 partition by tbname order by tbname")
        tdSql.checkRows(2)

-        tdSql.query("select last_row(c1) , ceil(t1) ,c2 from testdb.stb1 partition by t1 order by t1")
+        tdSql.query(f"select last_row(c1) , ceil(t1) ,c2 from {dbname}.stb1 partition by t1 order by t1")
        tdSql.checkRows(2)

-        tdSql.query("select last_row(c1) , abs(t1) ,c2 from testdb.stb1 partition by abs(c1) order by abs(c1)")
+        tdSql.query(f"select last_row(c1) , abs(t1) ,c2 from {dbname}.stb1 partition by abs(c1) order by abs(c1)")
        tdSql.checkRows(11)

-        tdSql.query("select abs(last_row(c1)) , abs(floor(t1)) ,floor(c2) from testdb.stb1 partition by abs(floor(c1)) order by abs(c1)")
+        tdSql.query(f"select abs(last_row(c1)) , abs(floor(t1)) ,floor(c2) from {dbname}.stb1 partition by abs(floor(c1)) order by abs(c1)")
        tdSql.checkRows(11)

-        tdSql.query("select last_row(ceil(c1-2)) , abs(floor(t1+1)) ,floor(c2-c1) from testdb.stb1 partition by abs(floor(c1)) order by abs(c1)")
+        tdSql.query(f"select last_row(ceil(c1-2)) , abs(floor(t1+1)) ,floor(c2-c1) from {dbname}.stb1 partition by abs(floor(c1)) order by abs(c1)")
        tdSql.checkRows(11)


-        tdSql.query("select max(c1) from stb1 interval(50s) sliding(30s)")
+        tdSql.query(f"select max(c1) from {dbname}.stb1 interval(50s) sliding(30s)")
        tdSql.checkRows(13)

-        tdSql.query("select unique(c1) from stb1 partition by tbname")
+        tdSql.query(f"select unique(c1) from {dbname}.stb1 partition by tbname")

        # interval

-        tdSql.query("select last_row(c1) from testdb.stb1 interval(50s) sliding(30s)")
+        tdSql.query(f"select last_row(c1) from {dbname}.stb1 interval(50s) sliding(30s)")
        tdSql.checkRows(27)


-        tdSql.query("select last_row(c1) from testdb.ct1 interval(50s) sliding(30s)")
+        tdSql.query(f"select last_row(c1) from {dbname}.ct1 interval(50s) sliding(30s)")
        tdSql.checkRows(5)
        last_row_result = tdSql.queryResult
-        tdSql.query("select last(c1) from testdb.ct1 interval(50s) sliding(30s)")
+        tdSql.query(f"select last(c1) from {dbname}.ct1 interval(50s) sliding(30s)")
        for ind , row in enumerate(last_row_result):
            tdSql.checkData(ind , 0 , row[0])

        # bug need fix
-        tdSql.query('select max(c1) from testdb.t1 where ts>="2021-01-01 01:01:06.000" and ts < "2021-07-21 01:01:01.000" interval(50d) sliding(30d) fill(NULL)')
+        tdSql.query(f'select max(c1) from {dbname}.t1 where ts>="2021-01-01 01:01:06.000" and ts < "2021-07-21 01:01:01.000" interval(50d) sliding(30d) fill(NULL)')
        tdSql.checkRows(8)
        tdSql.checkData(7,0,None)

-        tdSql.query('select last_row(c1) from testdb.t1 where ts>="2021-01-01 01:01:06.000" and ts < "2021-07-21 01:01:01.000" interval(50d) sliding(30d) fill(value ,2 )')
+        tdSql.query(f'select last_row(c1) from {dbname}.t1 where ts>="2021-01-01 01:01:06.000" and ts < "2021-07-21 01:01:01.000" interval(50d) sliding(30d) fill(value ,2 )')
        tdSql.checkRows(8)
        tdSql.checkData(7,0,2)

-        tdSql.query('select last_row(c1) from testdb.stb1 where ts>="2022-07-06 16:00:00.000 " and ts < "2022-07-06 17:00:00.000 " interval(50s) sliding(30s)')
-        tdSql.query('select last_row(c1) from (select ts ,  c1  from testdb.t1 where ts>="2021-01-01 01:01:06.000" and ts < "2021-07-21 01:01:01.000" ) interval(10s) sliding(5s)')
+        tdSql.query(f'select last_row(c1) from {dbname}.stb1 where ts>="2022-07-06 16:00:00.000 " and ts < "2022-07-06 17:00:00.000 " interval(50s) sliding(30s)')
+        tdSql.query(f'select last_row(c1) from (select ts ,  c1  from {dbname}.t1 where ts>="2021-01-01 01:01:06.000" and ts < "2021-07-21 01:01:01.000" ) interval(10s) sliding(5s)')

        # join
-        tdSql.query("use test")
-        tdSql.query("select last(sub_tb_1.c1), last(sub_tb_2.c2) from sub_tb_1, sub_tb_2 where sub_tb_1.ts=sub_tb_2.ts")
+        db1 = "test"
+        tdSql.query(f"use {db1}")
+        tdSql.query(f"select last(sub_tb_1.c1), last(sub_tb_2.c2) from {db1}.sub_tb_1 sub_tb_1, {db1}.sub_tb_2 sub_tb_2 where sub_tb_1.ts=sub_tb_2.ts")
        tdSql.checkCols(2)
        last_row_result = tdSql.queryResult
-        tdSql.query("select last_row(sub_tb_1.c1), last_row(sub_tb_2.c2) from sub_tb_1, sub_tb_2 where sub_tb_1.ts=sub_tb_2.ts")
+        tdSql.query(f"select last_row(sub_tb_1.c1), last_row(sub_tb_2.c2) from {db1}.sub_tb_1 sub_tb_1, {db1}.sub_tb_2 sub_tb_2 where sub_tb_1.ts=sub_tb_2.ts")

        for ind , row in enumerate(last_row_result):
            tdSql.checkData(ind , 0 , row[0])

-        tdSql.query("select last(*), last(*) from sub_tb_1, sub_tb_2 where sub_tb_1.ts=sub_tb_2.ts")
+        tdSql.query(f"select last(*), last(*) from {db1}.sub_tb_1 sub_tb_1, {db1}.sub_tb_2 where sub_tb_1.ts=sub_tb_2.ts")

        last_row_result = tdSql.queryResult
-        tdSql.query("select last_row(*), last_row(*) from sub_tb_1, sub_tb_2 where sub_tb_1.ts=sub_tb_2.ts")
+        tdSql.query(f"select last_row(*), last_row(*) from {db1}.sub_tb_1 sub_tb_1, {db1}.sub_tb_2 where sub_tb_1.ts=sub_tb_2.ts")
        for ind , row in enumerate(last_row_result):
            tdSql.checkData(ind , 0 , row[0])

-        tdSql.query("select last(*), last_row(*) from sub_tb_1, sub_tb_2 where sub_tb_1.ts=sub_tb_2.ts")
+        tdSql.query(f"select last(*), last_row(*) from {db1}.sub_tb_1 sub_tb_1, {db1}.sub_tb_2 where sub_tb_1.ts=sub_tb_2.ts")
        for ind , row in enumerate(last_row_result):
            tdSql.checkData(ind , 0 , row[0])

-        tdSql.query("select last_row(*), last(*) from sub_tb_1, sub_tb_2 where sub_tb_1.ts=sub_tb_2.ts")
+        tdSql.query(f"select last_row(*), last(*) from {db1}.sub_tb_1 sub_tb_1, {db1}.sub_tb_2 where sub_tb_1.ts=sub_tb_2.ts")
        for ind , row in enumerate(last_row_result):
            tdSql.checkData(ind , 0 , row[0])


-    def support_super_table_test(self):
-        tdSql.execute(" use testdb ")
-        self.check_result_auto( " select c1 from testdb.stb1 order by ts " , "select abs(c1) from testdb.stb1 order by ts" )
-        self.check_result_auto( " select c1 from testdb.stb1 order by tbname " , "select abs(c1) from testdb.stb1 order by tbname" )
-        self.check_result_auto( " select c1 from testdb.stb1 where c1 > 0 order by tbname  " , "select abs(c1) from testdb.stb1 where c1 > 0 order by tbname" )
-        self.check_result_auto( " select c1 from testdb.stb1 where c1 > 0 order by tbname  " , "select abs(c1) from testdb.stb1 where c1 > 0 order by tbname" )
+    def support_super_table_test(self, dbname="testdb"):
+        self.check_result_auto( f"select c1 from {dbname}.stb1 order by ts " , f"select abs(c1) from {dbname}.stb1 order by ts" )
+        self.check_result_auto( f"select c1 from {dbname}.stb1 order by tbname " , f"select abs(c1) from {dbname}.stb1 order by tbname" )
+        self.check_result_auto( f"select c1 from {dbname}.stb1 where c1 > 0 order by tbname  " , f"select abs(c1) from {dbname}.stb1 where c1 > 0 order by tbname" )
+        self.check_result_auto( f"select c1 from {dbname}.stb1 where c1 > 0 order by tbname  " , f"select abs(c1) from {dbname}.stb1 where c1 > 0 order by tbname" )

-        self.check_result_auto( " select t1,c1 from testdb.stb1 order by ts " , "select t1, abs(c1) from testdb.stb1 order by ts" )
-        self.check_result_auto( " select t2,c1 from testdb.stb1 order by tbname " , "select t2 ,abs(c1) from testdb.stb1 order by tbname" )
-        self.check_result_auto( " select t3,c1 from testdb.stb1 where c1 > 0 order by tbname  " , "select t3 ,abs(c1) from testdb.stb1 where c1 > 0 order by tbname" )
-        self.check_result_auto( " select t4,c1 from testdb.stb1 where c1 > 0 order by tbname  " , "select t4 , abs(c1) from testdb.stb1 where c1 > 0 order by tbname" )
-        pass
+        self.check_result_auto( f"select t1,c1 from {dbname}.stb1 order by ts " , f"select t1, abs(c1) from {dbname}.stb1 order by ts" )
+        self.check_result_auto( f"select t2,c1 from {dbname}.stb1 order by tbname " , f"select t2 ,abs(c1) from {dbname}.stb1 order by tbname" )
+        self.check_result_auto( f"select t3,c1 from {dbname}.stb1 where c1 > 0 order by tbname  " , f"select t3 ,abs(c1) from {dbname}.stb1 where c1 > 0 order by tbname" )
+        self.check_result_auto( f"select t4,c1 from {dbname}.stb1 where c1 > 0 order by tbname  " , f"select t4 , abs(c1) from {dbname}.stb1 where c1 > 0 order by tbname" )

    def basic_query(self):

--- a/tests/system-test/2-query/leastsquares.py
+++ b/tests/system-test/2-query/leastsquares.py
@ -26,6 +26,7 @@ TS_TYPE_COL = [ TS_COL, ]

 ALL_COL = [ INT_COL, BINT_COL, SINT_COL, TINT_COL, FLOAT_COL, DOUBLE_COL, BOOL_COL, BINARY_COL, NCHAR_COL, TS_COL ]

+DBNAME = "db"
 class TDTestCase:

    def init(self, conn, logSql):
@ -133,13 +134,13 @@ class TDTestCase:
        return f"select leastsquares({select_clause}, {start_val}, {step_val}) from {from_clause} {where_condition} {group_condition}"

    @property
-    def __tb_list(self):
+    def __tb_list(self, dbname=DBNAME):
        return [
-            "ct1",
-            "ct4",
-            "t1",
-            "ct2",
-            "stb1",
+            f"{dbname}.ct1",
+            f"{dbname}.ct4",
+            f"{dbname}.nt1",
+            f"{dbname}.ct2",
+            f"{dbname}.stb1",
        ]

    @property
@ -161,36 +162,37 @@ class TDTestCase:
        err_sqls = []
        __no_join_tblist = self.__tb_list
        for tb in __no_join_tblist:
-                select_claus_list = self.__query_condition(tb)
-                for select_claus in select_claus_list:
-                    group_claus = self.__group_condition(col=select_claus)
-                    where_claus = self.__where_condition(query_conditon=select_claus)
-                    having_claus = self.__group_condition(col=select_claus, having=f"{select_claus} is not null")
-                    for arg in self.start_step_val:
-                        if not  isinstance(arg,int) or isinstance(arg, bool) :
-                            err_sqls.extend(
-                                (
-                                    self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg),
-                                    self.__single_sql(select_clause=select_claus, from_clause=tb, step_val=arg, group_condition=group_claus),
-                                    self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg, where_condition=where_claus, group_condition=having_claus),
-                                )
+            tbname = tb.split(".")[-1]
+            select_claus_list = self.__query_condition(tbname)
+            for select_claus in select_claus_list:
+                group_claus = self.__group_condition(col=select_claus)
+                where_claus = self.__where_condition(query_conditon=select_claus)
+                having_claus = self.__group_condition(col=select_claus, having=f"{select_claus} is not null")
+                for arg in self.start_step_val:
+                    if not  isinstance(arg,int) or isinstance(arg, bool) :
+                        err_sqls.extend(
+                            (
+                                self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg),
+                                self.__single_sql(select_clause=select_claus, from_clause=tb, step_val=arg, group_condition=group_claus),
+                                self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg, where_condition=where_claus, group_condition=having_claus),
                            )
-                        elif isinstance(select_claus, str) and any([BOOL_COL in select_claus, BINARY_COL in select_claus, NCHAR_COL in select_claus, TS_COL in select_claus]):
-                            err_sqls.extend(
-                                (
-                                    self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg),
-                                    self.__single_sql(select_clause=select_claus, from_clause=tb, step_val=arg, group_condition=group_claus),
-                                    self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg, where_condition=where_claus, group_condition=having_claus),
-                                )
+                        )
+                    elif isinstance(select_claus, str) and any([BOOL_COL in select_claus, BINARY_COL in select_claus, NCHAR_COL in select_claus, TS_COL in select_claus]):
+                        err_sqls.extend(
+                            (
+                                self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg),
+                                self.__single_sql(select_clause=select_claus, from_clause=tb, step_val=arg, group_condition=group_claus),
+                                self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg, where_condition=where_claus, group_condition=having_claus),
                            )
-                        else:
-                            current_sqls.extend(
-                                (
-                                    self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg, step_val=0),
-                                    self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=0, step_val=arg, group_condition=group_claus),
-                                    self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg, step_val=arg, where_condition=where_claus, group_condition=having_claus),
-                                )
+                        )
+                    else:
+                        current_sqls.extend(
+                            (
+                                self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg, step_val=0),
+                                self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=0, step_val=arg, group_condition=group_claus),
+                                self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg, step_val=arg, where_condition=where_claus, group_condition=having_claus),
                            )
+                        )

        # return filter(None, sqls)
        return list(filter(None, current_sqls)), list(filter(None, err_sqls))
@ -207,25 +209,25 @@ class TDTestCase:


    def __test_current(self):
-        # tdSql.query("explain select c1 from ct1")
-        # tdSql.query("explain select 1 from ct2")
-        # tdSql.query("explain select cast(ceil(c6) as bigint) from ct4 group by c6")
-        # tdSql.query("explain select count(c3) from ct4 group by c7 having count(c3) > 0")
-        # tdSql.query("explain select ct2.c3 from ct4 join ct2 on ct4.ts=ct2.ts")
+        # tdSql.query("explain select c1 from {dbname}.ct1")
+        # tdSql.query("explain select 1 from {dbname}.ct2")
+        # tdSql.query("explain select cast(ceil(c6) as bigint) from {dbname}.ct4 group by c6")
+        # tdSql.query("explain select count(c3) from {dbname}.ct4 group by c7 having count(c3) > 0")
+        # tdSql.query("explain select ct2.c3 from {dbname}.ct4 join ct2 on ct4.ts=ct2.ts")
        # tdSql.query("explain select c1 from stb1 where c1 is not null and c1 in (0, 1, 2) or c1 between 2 and 100 ")

        self.leastsquares_check()

-    def __test_error(self):
+    def __test_error(self, dbname=DBNAME):

        tdLog.printNoPrefix("===step 0: err case, must return err")
-        tdSql.error( "select leastsquares(c1) from ct8" )
-        tdSql.error( "select leastsquares(c1, 1) from  ct1 " )
-        tdSql.error( "select leastsquares(c1, null, 1) from  ct1 " )
-        tdSql.error( "select leastsquares(c1, 1, null) from  ct1 " )
-        tdSql.error( "select leastsquares(null, 1, 1) from  ct1 " )
-        tdSql.error( '''select leastsquares(['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10'])
-                    from ct1
+        tdSql.error( f"select leastsquares(c1) from {dbname}.ct8" )
+        tdSql.error( f"select leastsquares(c1, 1) from {dbname}.ct1 " )
+        tdSql.error( f"select leastsquares(c1, null, 1) from {dbname}.ct1 " )
+        tdSql.error( f"select leastsquares(c1, 1, null) from {dbname}.ct1 " )
+        tdSql.error( f"select leastsquares(null, 1, 1) from {dbname}.ct1 " )
+        tdSql.error( f'''select leastsquares(['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10'])
+                    from {dbname}.ct1
                    where ['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10'] is not null
                    group by ['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10']
                    having ['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10'] is not null ''' )
@ -234,16 +236,16 @@ class TDTestCase:
        self.__test_error()
        self.__test_current()

-    def __create_tb(self):
+    def __create_tb(self, dbname=DBNAME):

        tdLog.printNoPrefix("==========step1:create table")
-        create_stb_sql  =  f'''create table stb1(
+        create_stb_sql  =  f'''create table {dbname}.stb1(
                ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint,
                 {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool,
                 {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp
            ) tags (t1 int)
            '''
-        create_ntb_sql = f'''create table t1(
+        create_ntb_sql = f'''create table {dbname}.nt1(
                ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint,
                 {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool,
                 {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp
@ -253,30 +255,29 @@ class TDTestCase:
        tdSql.execute(create_ntb_sql)

        for i in range(4):
-            tdSql.execute(f'create table ct{i+1} using stb1 tags ( {i+1} )')
-            { i % 32767 }, { i % 127}, { i * 1.11111 }, { i * 1000.1111 }, { i % 2}
+            tdSql.execute(f'create table {dbname}.ct{i+1} using {dbname}.stb1 tags ( {i+1} )')

-    def __insert_data(self, rows):
+    def __insert_data(self, rows, dbname=DBNAME):
        now_time = int(datetime.datetime.timestamp(datetime.datetime.now()) * 1000)
        for i in range(rows):
            tdSql.execute(
-                f"insert into ct1 values ( { now_time - i * 1000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )"
+                f"insert into {dbname}.ct1 values ( { now_time - i * 1000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )"
            )
            tdSql.execute(
-                f"insert into ct4 values ( { now_time - i * 7776000000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )"
+                f"insert into {dbname}.ct4 values ( { now_time - i * 7776000000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )"
            )
            tdSql.execute(
-                f"insert into ct2 values ( { now_time - i * 7776000000 }, {-i},  {-11111 * i}, {-111 * i % 32767 }, {-11 * i % 127}, {-1.11*i}, {-1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )"
+                f"insert into {dbname}.ct2 values ( { now_time - i * 7776000000 }, {-i},  {-11111 * i}, {-111 * i % 32767 }, {-11 * i % 127}, {-1.11*i}, {-1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )"
            )
        tdSql.execute(
-            f'''insert into ct1 values
+            f'''insert into {dbname}.ct1 values
            ( { now_time - rows * 5 }, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar_测试_0', { now_time + 8 } )
            ( { now_time + 10000 }, { rows }, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar_测试_9', { now_time + 9 } )
            '''
        )

        tdSql.execute(
-            f'''insert into ct4 values
+            f'''insert into {dbname}.ct4 values
            ( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
            ( { now_time - rows * 3888000000 + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
            ( { now_time +  7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
@ -292,7 +293,7 @@ class TDTestCase:
        )

        tdSql.execute(
-            f'''insert into ct2 values
+            f'''insert into {dbname}.ct2 values
            ( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
            ( { now_time - rows * 3888000000 + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
            ( { now_time + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
@ -308,13 +309,13 @@ class TDTestCase:
        )

        for i in range(rows):
-            insert_data = f'''insert into t1 values
+            insert_data = f'''insert into {dbname}.nt1 values
                ( { now_time - i * 3600000 }, {i}, {i * 11111}, { i % 32767 }, { i % 127}, { i * 1.11111 }, { i * 1000.1111 }, { i % 2},
                "binary_{i}", "nchar_测试_{i}", { now_time - 1000 * i } )
                '''
            tdSql.execute(insert_data)
        tdSql.execute(
-            f'''insert into t1 values
+            f'''insert into {dbname}.nt1 values
            ( { now_time + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
            ( { now_time - (( rows // 2 ) * 60 + 30) * 60000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
            ( { now_time - rows * 3600000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
@ -332,7 +333,7 @@ class TDTestCase:


    def run(self):
-        tdSql.prepare()
+        tdSql.prepare(DBNAME)

        tdLog.printNoPrefix("==========step1:create table")
        self.__create_tb()
@ -344,10 +345,9 @@ class TDTestCase:
        tdLog.printNoPrefix("==========step3:all check")
        self.all_test()

-        tdDnodes.stop(1)
-        tdDnodes.start(1)
+        tdSql.execute(f"flush database {DBNAME}")

-        tdSql.execute("use db")
+        tdSql.execute(f"use {DBNAME}")

        tdLog.printNoPrefix("==========step4:after wal, all check again ")
        self.all_test()
--- a/tests/system-test/2-query/length.py
+++ b/tests/system-test/2-query/length.py
@ -19,6 +19,7 @@ TS_COL      = "c10"
 UN_CHAR_COL = [INT_COL, BINT_COL, SINT_COL, TINT_COL, FLOAT_COL, DOUBLE_COL, BOOL_COL, ]
 CHAR_COL    = [ BINARY_COL, NCHAR_COL, ]
 TS_TYPE_COL = [TS_COL]
+DBNAME = "db"

 class TDTestCase:

@ -102,16 +103,16 @@ class TDTestCase:

        return sqls

-    def __test_current(self):
+    def __test_current(self, dbname=DBNAME):
        tdLog.printNoPrefix("==========current sql condition check , must return query ok==========")
-        tbname = ["ct1", "ct2", "ct4", "t1", "stb1"]
+        tbname = [f"{dbname}.ct1", f"{dbname}.ct2", f"{dbname}.ct4", f"{dbname}.nt1", f"{dbname}.stb1"]
        for tb in tbname:
            self.__length_current_check(tb)
            tdLog.printNoPrefix(f"==========current sql condition check in {tb} over==========")

-    def __test_error(self):
+    def __test_error(self, dbname=DBNAME):
        tdLog.printNoPrefix("==========err sql condition check , must return error==========")
-        tbname = ["ct1", "ct2", "ct4", "t1", "stb1"]
+        tbname = [f"{dbname}.ct1", f"{dbname}.ct2", f"{dbname}.ct4", f"{dbname}.nt1", f"{dbname}.stb1"]

        for tb in tbname:
            for errsql in self.__length_err_check(tb):
@ -124,17 +125,16 @@ class TDTestCase:
        self.__test_error()


-    def __create_tb(self):
-        tdSql.prepare()
+    def __create_tb(self, dbname=DBNAME):

        tdLog.printNoPrefix("==========step1:create table")
-        create_stb_sql  =  f'''create table stb1(
+        create_stb_sql  =  f'''create table {dbname}.stb1(
                ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint,
                 {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool,
                 {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp
            ) tags (t1 int)
            '''
-        create_ntb_sql = f'''create table t1(
+        create_ntb_sql = f'''create table {dbname}.nt1(
                ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint,
                 {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool,
                 {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp
@ -144,29 +144,29 @@ class TDTestCase:
        tdSql.execute(create_ntb_sql)

        for i in range(4):
-            tdSql.execute(f'create table ct{i+1} using stb1 tags ( {i+1} )')
+            tdSql.execute(f'create table {dbname}.ct{i+1} using {dbname}.stb1 tags ( {i+1} )')

-    def __insert_data(self, rows):
+    def __insert_data(self, rows, dbname=DBNAME):
        now_time = int(datetime.datetime.timestamp(datetime.datetime.now()) * 1000)
        for i in range(rows):
            tdSql.execute(
-                f"insert into ct1 values ( { now_time - i * 1000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar{i}', { now_time + 1 * i } )"
+                f"insert into {dbname}.ct1 values ( { now_time - i * 1000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar{i}', { now_time + 1 * i } )"
            )
            tdSql.execute(
-                f"insert into ct4 values ( { now_time - i * 7776000000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar{i}', { now_time + 1 * i } )"
+                f"insert into {dbname}.ct4 values ( { now_time - i * 7776000000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar{i}', { now_time + 1 * i } )"
            )
            tdSql.execute(
-                f"insert into ct2 values ( { now_time - i * 7776000000 }, {-i},  {-11111 * i}, {-111 * i % 32767 }, {-11 * i % 127}, {-1.11*i}, {-1100.0011*i}, {i%2}, 'binary{i}', 'nchar{i}', { now_time + 1 * i } )"
+                f"insert into {dbname}.ct2 values ( { now_time - i * 7776000000 }, {-i},  {-11111 * i}, {-111 * i % 32767 }, {-11 * i % 127}, {-1.11*i}, {-1100.0011*i}, {i%2}, 'binary{i}', 'nchar{i}', { now_time + 1 * i } )"
            )
        tdSql.execute(
-            f'''insert into ct1 values
+            f'''insert into {dbname}.ct1 values
            ( { now_time - rows * 5 }, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar0', { now_time + 8 } )
            ( { now_time + 10000 }, { rows }, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar9', { now_time + 9 } )
            '''
        )

        tdSql.execute(
-            f'''insert into ct4 values
+            f'''insert into {dbname}.ct4 values
            ( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
            ( { now_time - rows * 3888000000+ 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
            ( { now_time +  7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
@ -182,7 +182,7 @@ class TDTestCase:
        )

        tdSql.execute(
-            f'''insert into ct2 values
+            f'''insert into {dbname}.ct2 values
            ( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
            ( { now_time - rows * 3888000000+ 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
            ( { now_time + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
@ -198,13 +198,13 @@ class TDTestCase:
        )

        for i in range(rows):
-            insert_data = f'''insert into t1 values
+            insert_data = f'''insert into {dbname}.nt1 values
                ( { now_time - i * 3600000 }, {i}, {i * 11111}, { i % 32767 }, { i % 127}, { i * 1.11111 }, { i * 1000.1111 }, { i % 2},
                "binary_{i}", "nchar_{i}", { now_time - 1000 * i } )
                '''
            tdSql.execute(insert_data)
        tdSql.execute(
-            f'''insert into t1 values
+            f'''insert into {dbname}.nt1 values
            ( { now_time + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
            ( { now_time - (( rows // 2 ) * 60 + 30) * 60000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
            ( { now_time - rows * 3600000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
@ -233,8 +233,7 @@ class TDTestCase:
        tdLog.printNoPrefix("==========step3:all check")
        self.all_test()

-        tdDnodes.stop(1)
-        tdDnodes.start(1)
+        tdSql.execute("flush database db")

        tdSql.execute("use db")

--- a/tests/system-test/2-query/log.py
+++ b/tests/system-test/2-query/log.py
@ -10,48 +10,46 @@ from util.cases import *


 class TDTestCase:
-    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 ,
-    "jniDebugFlag":143 ,"simDebugFlag":143,"dDebugFlag":143, "dDebugFlag":143,"vDebugFlag":143,"mDebugFlag":143,"qDebugFlag":143,
-    "wDebugFlag":143,"sDebugFlag":143,"tsdbDebugFlag":143,"tqDebugFlag":143 ,"fsDebugFlag":143 ,"udfDebugFlag":143}
+
    def init(self, conn, logSql):
        tdLog.debug(f"start to excute {__file__}")
        tdSql.init(conn.cursor())

-    def prepare_datas(self):
+    def prepare_datas(self, dbname="db"):
        tdSql.execute(
-            '''create table stb1
+            f'''create table {dbname}.stb1
            (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp)
            tags (t1 int)
            '''
        )

        tdSql.execute(
-            '''
-            create table t1
+            f'''
+            create table {dbname}.t1
            (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp)
            '''
        )
        for i in range(4):
-            tdSql.execute(f'create table ct{i+1} using stb1 tags ( {i+1} )')
+            tdSql.execute(f'create table {dbname}.ct{i+1} using {dbname}.stb1 tags ( {i+1} )')

        for i in range(9):
            tdSql.execute(
-                f"insert into ct1 values ( now()-{i*10}s, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a )"
+                f"insert into {dbname}.ct1 values ( now()-{i*10}s, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a )"
            )
            tdSql.execute(
-                f"insert into ct4 values ( now()-{i*90}d, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a )"
+                f"insert into {dbname}.ct4 values ( now()-{i*90}d, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a )"
            )
-        tdSql.execute("insert into ct1 values (now()-45s, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar0', now()+8a )")
-        tdSql.execute("insert into ct1 values (now()+10s, 9, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a )")
-        tdSql.execute("insert into ct1 values (now()+15s, 9, -99999, -999, -99, -9.99, NULL, 1, 'binary9', 'nchar9', now()+9a )")
-        tdSql.execute("insert into ct1 values (now()+20s, 9, -99999, -999, NULL, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a )")
+        tdSql.execute(f"insert into {dbname}.ct1 values (now()-45s, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar0', now()+8a )")
+        tdSql.execute(f"insert into {dbname}.ct1 values (now()+10s, 9, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a )")
+        tdSql.execute(f"insert into {dbname}.ct1 values (now()+15s, 9, -99999, -999, -99, -9.99, NULL, 1, 'binary9', 'nchar9', now()+9a )")
+        tdSql.execute(f"insert into {dbname}.ct1 values (now()+20s, 9, -99999, -999, NULL, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a )")

-        tdSql.execute("insert into ct4 values (now()-810d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ")
-        tdSql.execute("insert into ct4 values (now()-400d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ")
-        tdSql.execute("insert into ct4 values (now()+90d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL  ) ")
+        tdSql.execute(f"insert into {dbname}.ct4 values (now()-810d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ")
+        tdSql.execute(f"insert into {dbname}.ct4 values (now()-400d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ")
+        tdSql.execute(f"insert into {dbname}.ct4 values (now()+90d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL  ) ")

        tdSql.execute(
-            f'''insert into t1 values
+            f'''insert into {dbname}.t1 values
            ( '2020-04-21 01:01:01.000', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
            ( '2020-10-21 01:01:01.000', 1, 11111, 111, 11, 1.11, 11.11, 1, "binary1", "nchar1", now()+1a )
            ( '2020-12-31 01:01:01.000', 2, 22222, 222, 22, 2.22, 22.22, 0, "binary2", "nchar2", now()+2a )
@ -185,68 +183,68 @@ class TDTestCase:
        else:
            tdLog.info("log value check pass , it work as expected ,sql is \"%s\"   "%log_query )

-    def test_errors(self):
+    def test_errors(self, dbname="db"):
        error_sql_lists = [
-            "select log from t1",
-            # "select log(-+--+c1 ,2) from t1",
-            # "select +-log(c1,2) from t1",
-            # "select ++-log(c1,2) from t1",
-            # "select ++--log(c1,2) from t1",
-            # "select - -log(c1,2)*0 from t1",
-            # "select log(tbname+1,2) from t1 ",
-            "select log(123--123,2)==1 from t1",
-            "select log(c1,2) as 'd1' from t1",
-            "select log(c1 ,c2 ,2) from t1",
-            "select log(c1 ,NULL ,2) from t1",
-            "select log(, 2) from t1;",
-            "select log(log(c1, 2) ab from t1)",
-            "select log(c1 ,2 ) as int from t1",
-            "select log from stb1",
-            # "select log(-+--+c1) from stb1",
-            # "select +-log(c1) from stb1",
-            # "select ++-log(c1) from stb1",
-            # "select ++--log(c1) from stb1",
-            # "select - -log(c1)*0 from stb1",
-            # "select log(tbname+1) from stb1 ",
-            "select log(123--123 ,2)==1 from stb1",
-            "select log(c1 ,2) as 'd1' from stb1",
-            "select log(c1 ,c2 ,2 ) from stb1",
-            "select log(c1 ,NULL,2) from stb1",
-            "select log(,) from stb1;",
-            "select log(log(c1 , 2) ab from stb1)",
-            "select log(c1 , 2) as int from stb1"
+            f"select log from {dbname}.t1",
+            # f"select log(-+--+c1 ,2) from {dbname}.t1",
+            # f"select +-log(c1,2) from {dbname}.t1",
+            # f"select ++-log(c1,2) from {dbname}.t1",
+            # f"select ++--log(c1,2) from {dbname}.t1",
+            # f"select - -log(c1,2)*0 from {dbname}.t1",
+            # f"select log(tbname+1,2) from {dbname}.t1 ",
+            f"select log(123--123,2)==1 from {dbname}.t1",
+            f"select log(c1,2) as 'd1' from {dbname}.t1",
+            f"select log(c1 ,c2 ,2) from {dbname}.t1",
+            f"select log(c1 ,NULL ,2) from {dbname}.t1",
+            f"select log(, 2) from {dbname}.t1;",
+            f"select log(log(c1, 2) ab from {dbname}.t1)",
+            f"select log(c1 ,2 ) as int from {dbname}.t1",
+            f"select log from {dbname}.stb1",
+            # f"select log(-+--+c1) from {dbname}.stb1",
+            # f"select +-log(c1) from {dbname}.stb1",
+            # f"select ++-log(c1) from {dbname}.stb1",
+            # f"select ++--log(c1) from {dbname}.stb1",
+            # f"select - -log(c1)*0 from {dbname}.stb1",
+            # f"select log(tbname+1) from {dbname}.stb1 ",
+            f"select log(123--123 ,2)==1 from {dbname}.stb1",
+            f"select log(c1 ,2) as 'd1' from {dbname}.stb1",
+            f"select log(c1 ,c2 ,2 ) from {dbname}.stb1",
+            f"select log(c1 ,NULL,2) from {dbname}.stb1",
+            f"select log(,) from {dbname}.stb1;",
+            f"select log(log(c1 , 2) ab from {dbname}.stb1)",
+            f"select log(c1 , 2) as int from {dbname}.stb1"
        ]
        for error_sql in error_sql_lists:
            tdSql.error(error_sql)

-    def support_types(self):
+    def support_types(self, dbname="db"):
        type_error_sql_lists = [
-            "select log(ts ,2 ) from t1" ,
-            "select log(c7,c2 ) from t1",
-            "select log(c8,c1 ) from t1",
-            "select log(c9,c2 ) from t1",
-            "select log(ts,c7 ) from ct1" ,
-            "select log(c7,c9 ) from ct1",
-            "select log(c8,c2 ) from ct1",
-            "select log(c9,c1 ) from ct1",
-            "select log(ts,2 ) from ct3" ,
-            "select log(c7,2 ) from ct3",
-            "select log(c8,2 ) from ct3",
-            "select log(c9,2 ) from ct3",
-            "select log(ts,2 ) from ct4" ,
-            "select log(c7,2 ) from ct4",
-            "select log(c8,2 ) from ct4",
-            "select log(c9,2 ) from ct4",
-            "select log(ts,2 ) from stb1" ,
-            "select log(c7,2 ) from stb1",
-            "select log(c8,2 ) from stb1",
-            "select log(c9,2 ) from stb1" ,
+            f"select log(ts ,2 ) from {dbname}.t1" ,
+            f"select log(c7,c2 ) from {dbname}.t1",
+            f"select log(c8,c1 ) from {dbname}.t1",
+            f"select log(c9,c2 ) from {dbname}.t1",
+            f"select log(ts,c7 ) from {dbname}.ct1" ,
+            f"select log(c7,c9 ) from {dbname}.ct1",
+            f"select log(c8,c2 ) from {dbname}.ct1",
+            f"select log(c9,c1 ) from {dbname}.ct1",
+            f"select log(ts,2 ) from {dbname}.ct3" ,
+            f"select log(c7,2 ) from {dbname}.ct3",
+            f"select log(c8,2 ) from {dbname}.ct3",
+            f"select log(c9,2 ) from {dbname}.ct3",
+            f"select log(ts,2 ) from {dbname}.ct4" ,
+            f"select log(c7,2 ) from {dbname}.ct4",
+            f"select log(c8,2 ) from {dbname}.ct4",
+            f"select log(c9,2 ) from {dbname}.ct4",
+            f"select log(ts,2 ) from {dbname}.stb1" ,
+            f"select log(c7,2 ) from {dbname}.stb1",
+            f"select log(c8,2 ) from {dbname}.stb1",
+            f"select log(c9,2 ) from {dbname}.stb1" ,

-            "select log(ts,2 ) from stbbb1" ,
-            "select log(c7,2 ) from stbbb1",
+            f"select log(ts,2 ) from {dbname}.stbbb1" ,
+            f"select log(c7,2 ) from {dbname}.stbbb1",

-            "select log(ts,2 ) from tbname",
-            "select log(c9,2 ) from tbname"
+            f"select log(ts,2 ) from {dbname}.tbname",
+            f"select log(c9,2 ) from {dbname}.tbname"

        ]

@ -255,98 +253,88 @@ class TDTestCase:


        type_sql_lists = [
-            "select log(c1,2 ) from t1",
-            "select log(c2,2 ) from t1",
-            "select log(c3,2 ) from t1",
-            "select log(c4,2 ) from t1",
-            "select log(c5,2 ) from t1",
-            "select log(c6,2 ) from t1",
+            f"select log(c1,2 ) from {dbname}.t1",
+            f"select log(c2,2 ) from {dbname}.t1",
+            f"select log(c3,2 ) from {dbname}.t1",
+            f"select log(c4,2 ) from {dbname}.t1",
+            f"select log(c5,2 ) from {dbname}.t1",
+            f"select log(c6,2 ) from {dbname}.t1",

-            "select log(c1,2 ) from ct1",
-            "select log(c2,2 ) from ct1",
-            "select log(c3,2 ) from ct1",
-            "select log(c4,2 ) from ct1",
-            "select log(c5,2 ) from ct1",
-            "select log(c6,2 ) from ct1",
+            f"select log(c1,2 ) from {dbname}.ct1",
+            f"select log(c2,2 ) from {dbname}.ct1",
+            f"select log(c3,2 ) from {dbname}.ct1",
+            f"select log(c4,2 ) from {dbname}.ct1",
+            f"select log(c5,2 ) from {dbname}.ct1",
+            f"select log(c6,2 ) from {dbname}.ct1",

-            "select log(c1,2 ) from ct3",
-            "select log(c2,2 ) from ct3",
-            "select log(c3,2 ) from ct3",
-            "select log(c4,2 ) from ct3",
-            "select log(c5,2 ) from ct3",
-            "select log(c6,2 ) from ct3",
+            f"select log(c1,2 ) from {dbname}.ct3",
+            f"select log(c2,2 ) from {dbname}.ct3",
+            f"select log(c3,2 ) from {dbname}.ct3",
+            f"select log(c4,2 ) from {dbname}.ct3",
+            f"select log(c5,2 ) from {dbname}.ct3",
+            f"select log(c6,2 ) from {dbname}.ct3",

-            "select log(c1,2 ) from stb1",
-            "select log(c2,2 ) from stb1",
-            "select log(c3,2 ) from stb1",
-            "select log(c4,2 ) from stb1",
-            "select log(c5,2 ) from stb1",
-            "select log(c6,2 ) from stb1",
+            f"select log(c1,2 ) from {dbname}.stb1",
+            f"select log(c2,2 ) from {dbname}.stb1",
+            f"select log(c3,2 ) from {dbname}.stb1",
+            f"select log(c4,2 ) from {dbname}.stb1",
+            f"select log(c5,2 ) from {dbname}.stb1",
+            f"select log(c6,2 ) from {dbname}.stb1",

-            "select log(c6,2) as alisb from stb1",
-            "select log(c6,2) alisb from stb1",
+            f"select log(c6,2) as alisb from {dbname}.stb1",
+            f"select log(c6,2) alisb from {dbname}.stb1",
        ]

        for type_sql in type_sql_lists:
            tdSql.query(type_sql)

-    def basic_log_function(self):
+    def basic_log_function(self, dbname="db"):

        # basic query
-        tdSql.query("select c1 from ct3")
+        tdSql.query(f"select c1 from {dbname}.ct3")
        tdSql.checkRows(0)
-        tdSql.query("select c1 from t1")
+        tdSql.query(f"select c1 from {dbname}.t1")
        tdSql.checkRows(12)
-        tdSql.query("select c1 from stb1")
+        tdSql.query(f"select c1 from {dbname}.stb1")
        tdSql.checkRows(25)

        # used for empty table  , ct3 is empty

-        tdSql.query("select log(c1 ,2) from ct3")
+        tdSql.query(f"select log(c1 ,2) from {dbname}.ct3")
        tdSql.checkRows(0)
-        tdSql.query("select log(c2 ,2) from ct3")
+        tdSql.query(f"select log(c2 ,2) from {dbname}.ct3")
        tdSql.checkRows(0)
-        tdSql.query("select log(c3 ,2) from ct3")
+        tdSql.query(f"select log(c3 ,2) from {dbname}.ct3")
        tdSql.checkRows(0)
-        tdSql.query("select log(c4 ,2) from ct3")
+        tdSql.query(f"select log(c4 ,2) from {dbname}.ct3")
        tdSql.checkRows(0)
-        tdSql.query("select log(c5 ,2) from ct3")
+        tdSql.query(f"select log(c5 ,2) from {dbname}.ct3")
        tdSql.checkRows(0)
-        tdSql.query("select log(c6 ,2) from ct3")
+        tdSql.query(f"select log(c6 ,2) from {dbname}.ct3")
        tdSql.checkRows(0)


        # # used for regular table
-        tdSql.query("select log(c1 ,2) from t1")
+        tdSql.query(f"select log(c1 ,2) from {dbname}.t1")
        tdSql.checkData(0, 0, None)
        tdSql.checkData(1 , 0, 0.000000000)
        tdSql.checkData(3 , 0, 1.584962501)
        tdSql.checkData(5 , 0, None)

-        tdSql.query("select log(c1) from t1")
+        tdSql.query(f"select log(c1) from {dbname}.t1")
        tdSql.checkData(0, 0, None)
        tdSql.checkData(1 , 0, 0.000000000)
        tdSql.checkData(2 , 0, 0.693147181)
        tdSql.checkData(3 , 0, 1.098612289)
        tdSql.checkData(4 , 0, 1.386294361)

-        tdSql.query("select c1, c2, c3 , c4, c5 from t1")
-        tdSql.checkData(1, 4, 1.11000)
-        tdSql.checkData(3, 3, 33)
-        tdSql.checkData(5, 4, None)
-
-        tdSql.query("select ts,c1, c2, c3 , c4, c5 from t1")
-        tdSql.checkData(1, 5, 1.11000)
-        tdSql.checkData(3, 4, 33)
-        tdSql.checkData(5, 5, None)
-
-        self.check_result_auto_log( "select c1, c2, c3 , c4, c5 from t1", "select log(c1), log(c2) ,log(c3), log(c4), log(c5) from t1")
-        self.check_result_auto_log2( "select c1, c2, c3 , c4, c5 from t1", "select log(c1 ,2), log(c2 ,2) ,log(c3, 2), log(c4 ,2), log(c5 ,2) from t1")
-        self.check_result_auto_log1( "select c1, c2, c3 , c4, c5 from t1", "select log(c1 ,1), log(c2 ,1) ,log(c3, 1), log(c4 ,1), log(c5 ,1) from t1")
-        self.check_result_auto_log__10( "select c1, c2, c3 , c4, c5 from t1", "select log(c1 ,-10), log(c2 ,-10) ,log(c3, -10), log(c4 ,-10), log(c5 ,-10) from t1")
+        self.check_result_auto_log( f"select c1, c2, c3 , c4, c5 from {dbname}.t1", f"select log(c1), log(c2) ,log(c3), log(c4), log(c5) from {dbname}.t1")
+        self.check_result_auto_log2( f"select c1, c2, c3 , c4, c5 from {dbname}.t1", f"select log(c1 ,2), log(c2 ,2) ,log(c3, 2), log(c4 ,2), log(c5 ,2) from {dbname}.t1")
+        self.check_result_auto_log__10( f"select c1, c2, c3 , c4, c5 from {dbname}.t1", f"select log(c1 ,1), log(c2 ,1) ,log(c3, 1), log(c4 ,1), log(c5 ,1) from {dbname}.t1")
+        self.check_result_auto_log__10( f"select c1, c2, c3 , c4, c5 from {dbname}.t1", f"select log(c1 ,-10), log(c2 ,-10) ,log(c3, -10), log(c4 ,-10), log(c5 ,-10) from {dbname}.t1")

        # used for sub table
-        tdSql.query("select c1 ,log(c1 ,3) from ct1")
+        tdSql.query(f"select c1 ,log(c1 ,3) from {dbname}.ct1")
        tdSql.checkData(0, 1, 1.892789261)
        tdSql.checkData(1 , 1, 1.771243749)
        tdSql.checkData(3 , 1, 1.464973521)
@ -354,19 +342,19 @@ class TDTestCase:

        # test bug fix for log(c1,c2)

-        tdSql.query("select c1, c2 ,log(c1,c2) from ct1")
+        tdSql.query(f"select c1, c2 ,log(c1,c2) from {dbname}.ct1")
        tdSql.checkData(0 , 2, 0.182485070)
        tdSql.checkData(1 , 2, 0.172791608)
        tdSql.checkData(2 , 2, 0.161311499)
        tdSql.checkData(3 , 2, 0.147315235)
        tdSql.checkData(4 , 2, None)

-        self.check_result_auto_log( "select c1, c2, c3 , c4, c5 from ct1", "select log(c1), log(c2) ,log(c3), log(c4), log(c5) from ct1")
-        self.check_result_auto_log2( "select c1, c2, c3 , c4, c5 from ct1", "select log(c1,2), log(c2,2) ,log(c3,2), log(c4,2), log(c5,2) from ct1")
-        self.check_result_auto_log__10( "select c1, c2, c3 , c4, c5 from ct1", "select log(c1,-10), log(c2,-10) ,log(c3,-10), log(c4,-10), log(c5,-10) from ct1")
+        self.check_result_auto_log( f"select c1, c2, c3 , c4, c5 from {dbname}.ct1", f"select log(c1), log(c2) ,log(c3), log(c4), log(c5) from {dbname}.ct1")
+        self.check_result_auto_log2( f"select c1, c2, c3 , c4, c5 from {dbname}.ct1", f"select log(c1,2), log(c2,2) ,log(c3,2), log(c4,2), log(c5,2) from {dbname}.ct1")
+        self.check_result_auto_log__10( f"select c1, c2, c3 , c4, c5 from {dbname}.ct1", f"select log(c1,-10), log(c2,-10) ,log(c3,-10), log(c4,-10), log(c5,-10) from {dbname}.ct1")

        # nest query for log functions
-        tdSql.query("select c1  , log(c1,3) ,log(log(c1,3),3) , log(log(log(c1,3),3),3) from ct1;")
+        tdSql.query(f"select c1  , log(c1,3) ,log(log(c1,3),3) , log(log(log(c1,3),3),3) from {dbname}.ct1;")
        tdSql.checkData(0 , 0 , 8)
        tdSql.checkData(0 , 1 , 1.892789261)
        tdSql.checkData(0 , 2 , 0.580779541)
@ -384,36 +372,36 @@ class TDTestCase:

        # # used for stable table

-        tdSql.query("select log(c1, 2) from stb1")
+        tdSql.query(f"select log(c1, 2) from {dbname}.stb1")
        tdSql.checkRows(25)


        # used for not exists table
-        tdSql.error("select log(c1, 2) from stbbb1")
-        tdSql.error("select log(c1, 2) from tbname")
-        tdSql.error("select log(c1, 2) from ct5")
+        tdSql.error(f"select log(c1, 2) from {dbname}.stbbb1")
+        tdSql.error(f"select log(c1, 2) from {dbname}tbname")
+        tdSql.error(f"select log(c1, 2) from {dbname}.ct5")

        # mix with common col
-        tdSql.query("select c1, log(c1 ,2) from ct1")
+        tdSql.query(f"select c1, log(c1 ,2) from {dbname}.ct1")
        tdSql.checkData(0 , 0 ,8)
        tdSql.checkData(0 , 1 ,3.000000000)
        tdSql.checkData(4 , 0 ,0)
        tdSql.checkData(4 , 1 ,None)
-        tdSql.query("select c1, log(c1,2) from ct4")
+        tdSql.query(f"select c1, log(c1,2) from {dbname}.ct4")
        tdSql.checkData(0 , 0 , None)
        tdSql.checkData(0 , 1 ,None)
        tdSql.checkData(4 , 0 ,5)
        tdSql.checkData(4 , 1 ,2.321928095)
        tdSql.checkData(5 , 0 ,None)
        tdSql.checkData(5 , 1 ,None)
-        tdSql.query("select c1, log(c1 ,2 ) from ct4 ")
+        tdSql.query(f"select c1, log(c1 ,2 ) from {dbname}.ct4 ")
        tdSql.checkData(0 , 0 ,None)
        tdSql.checkData(0 , 1 ,None)
        tdSql.checkData(4 , 0 ,5)
        tdSql.checkData(4 , 1 ,2.321928095)

        # mix with common functions
-        tdSql.query("select c1, log(c1 ,2),c5, log(c5 ,2) from ct4 ")
+        tdSql.query(f"select c1, log(c1 ,2),c5, log(c5 ,2) from {dbname}.ct4 ")
        tdSql.checkData(0 , 0 ,None)
        tdSql.checkData(0 , 1 ,None)
        tdSql.checkData(0 , 2 ,None)
@ -424,34 +412,34 @@ class TDTestCase:
        tdSql.checkData(3 , 2 ,6.66000)
        tdSql.checkData(3 , 3 ,2.735522144)

-        tdSql.query("select c1, log(c1,1),c5, floor(c5 ) from stb1 ")
+        tdSql.query(f"select c1, log(c1,1),c5, floor(c5 ) from {dbname}.stb1 ")

        # # mix with agg functions , not support
-        tdSql.error("select c1, log(c1 ,2),c5, count(c5) from stb1 ")
-        tdSql.error("select c1, log(c1 ,2),c5, count(c5) from ct1 ")
-        tdSql.error("select log(c1 ,2), count(c5) from stb1 ")
-        tdSql.error("select log(c1 ,2), count(c5) from ct1 ")
-        tdSql.error("select c1, count(c5) from ct1 ")
-        tdSql.error("select c1, count(c5) from stb1 ")
+        tdSql.error(f"select c1, log(c1 ,2),c5, count(c5) from {dbname}.stb1 ")
+        tdSql.error(f"select c1, log(c1 ,2),c5, count(c5) from {dbname}.ct1 ")
+        tdSql.error(f"select log(c1 ,2), count(c5) from {dbname}.stb1 ")
+        tdSql.error(f"select log(c1 ,2), count(c5) from {dbname}.ct1 ")
+        tdSql.error(f"select c1, count(c5) from {dbname}.ct1 ")
+        tdSql.error(f"select c1, count(c5) from {dbname}.stb1 ")

        # agg functions mix with agg functions

-        tdSql.query("select max(c5), count(c5) from stb1")
-        tdSql.query("select max(c5), count(c5) from ct1")
+        tdSql.query(f"select max(c5), count(c5) from {dbname}.stb1")
+        tdSql.query(f"select max(c5), count(c5) from {dbname}.ct1")


        # bug fix for count
-        tdSql.query("select count(c1) from ct4 ")
+        tdSql.query(f"select count(c1) from {dbname}.ct4 ")
        tdSql.checkData(0,0,9)
-        tdSql.query("select count(*) from ct4 ")
+        tdSql.query(f"select count(*) from {dbname}.ct4 ")
        tdSql.checkData(0,0,12)
-        tdSql.query("select count(c1) from stb1 ")
+        tdSql.query(f"select count(c1) from {dbname}.stb1 ")
        tdSql.checkData(0,0,22)
-        tdSql.query("select count(*) from stb1 ")
+        tdSql.query(f"select count(*) from {dbname}.stb1 ")
        tdSql.checkData(0,0,25)

        # # bug fix for compute
-        tdSql.query("select c1, log(c1 ,2) -0 ,log(c1-4 ,2)-0 from ct4 ")
+        tdSql.query(f"select c1, log(c1 ,2) -0 ,log(c1-4 ,2)-0 from {dbname}.ct4 ")
        tdSql.checkData(0, 0, None)
        tdSql.checkData(0, 1, None)
        tdSql.checkData(0, 2, None)
@ -459,7 +447,7 @@ class TDTestCase:
        tdSql.checkData(1, 1, 3.000000000)
        tdSql.checkData(1, 2, 2.000000000)

-        tdSql.query(" select c1, log(c1 ,2) -0 ,log(c1-0.1 ,2)-0.1 from ct4")
+        tdSql.query(f"select c1, log(c1 ,2) -0 ,log(c1-0.1 ,2)-0.1 from {dbname}.ct4")
        tdSql.checkData(0, 0, None)
        tdSql.checkData(0, 1, None)
        tdSql.checkData(0, 2, None)
@ -467,88 +455,87 @@ class TDTestCase:
        tdSql.checkData(1, 1, 3.000000000)
        tdSql.checkData(1, 2, 2.881852653)

-        tdSql.query("select c1, log(c1, -10), c2, log(c2, -10), c3, log(c3, -10) from ct1")
+        tdSql.query(f"select c1, log(c1, -10), c2, log(c2, -10), c3, log(c3, -10) from {dbname}.ct1")

-    def test_big_number(self):
+    def test_big_number(self, dbname="db"):

-        tdSql.query("select c1, log(c1, 100000000) from ct1")  # bigint to double data overflow
+        tdSql.query(f"select c1, log(c1, 100000000) from {dbname}.ct1")  # bigint to double data overflow
        tdSql.checkData(0, 1, 0.112886248)
        tdSql.checkData(1, 1, 0.105637255)
        tdSql.checkData(4, 1, None)


-        tdSql.query("select c1, log(c1, 10000000000000) from ct1")  # bigint to double data overflow
+        tdSql.query(f"select c1, log(c1, 10000000000000) from {dbname}.ct1")  # bigint to double data overflow
        tdSql.checkData(0, 1, 0.069468461)
        tdSql.checkData(1, 1, 0.065007542)
        tdSql.checkData(4, 1, None)

-        tdSql.query("select c1, log(c1, 10000000000000000000000000) from ct1")  # bigint to double data overflow
-        tdSql.query("select c1, log(c1, 10000000000000000000000000.0) from ct1") # 10000000000000000000000000.0 is a double value
+        tdSql.query(f"select c1, log(c1, 10000000000000000000000000) from {dbname}.ct1")  # bigint to double data overflow
+        tdSql.query(f"select c1, log(c1, 10000000000000000000000000.0) from {dbname}.ct1") # 10000000000000000000000000.0 is a double value
        tdSql.checkData(0, 1, 0.036123599)
        tdSql.checkData(1, 1, 0.033803922)
        tdSql.checkData(4, 1, None)

-        tdSql.query("select c1, log(c1, 10000000000000000000000000000000000) from ct1")  # bigint to double data overflow
-        tdSql.query("select c1, log(c1, 10000000000000000000000000000000000.0) from ct1") # 10000000000000000000000000.0 is a double value
+        tdSql.query(f"select c1, log(c1, 10000000000000000000000000000000000) from {dbname}.ct1")  # bigint to double data overflow
+        tdSql.query(f"select c1, log(c1, 10000000000000000000000000000000000.0) from {dbname}.ct1") # 10000000000000000000000000.0 is a double value
        tdSql.checkData(0, 1, 0.026561470)
        tdSql.checkData(1, 1, 0.024855825)
        tdSql.checkData(4, 1, None)

-        tdSql.query("select c1, log(c1, 10000000000000000000000000000000000000000) from ct1")  # bigint to double data overflow
-        tdSql.query("select c1, log(c1, 10000000000000000000000000000000000000000.0) from ct1") # 10000000000000000000000000.0 is a double value
+        tdSql.query(f"select c1, log(c1, 10000000000000000000000000000000000000000) from {dbname}.ct1")  # bigint to double data overflow
+        tdSql.query(f"select c1, log(c1, 10000000000000000000000000000000000000000.0) from {dbname}.ct1") # 10000000000000000000000000.0 is a double value
        tdSql.checkData(0, 1, 0.022577250)
        tdSql.checkData(1, 1, 0.021127451)
        tdSql.checkData(4, 1, None)

-        tdSql.query("select c1, log(c1, 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) from ct1")  # bigint to double data overflow
+        tdSql.query(f"select c1, log(c1, 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) from {dbname}.ct1")  # bigint to double data overflow

-    def log_base_test(self):
+    def log_base_test(self, dbname="db"):

        # base is an regular number ,int or double
-        tdSql.query("select c1, log(c1, 2) from ct1")
+        tdSql.query(f"select c1, log(c1, 2) from {dbname}.ct1")
        tdSql.checkData(0, 1,3.000000000)
-        tdSql.query("select c1, log(c1, 2.0) from ct1")
+        tdSql.query(f"select c1, log(c1, 2.0) from {dbname}.ct1")
        tdSql.checkData(0, 1, 3.000000000)

-        tdSql.query("select c1, log(1, 2.0) from ct1")
+        tdSql.query(f"select c1, log(1, 2.0) from {dbname}.ct1")
        tdSql.checkData(0, 1, 0.000000000)
        tdSql.checkRows(13)


        # # bug for compute in functions
-        # tdSql.query("select c1, abs(1/0) from ct1")
+        # tdSql.query(f"select c1, abs(1/0) from {dbname}.ct1")
        # tdSql.checkData(0, 0, 8)
        # tdSql.checkData(0, 1, 1)

-        tdSql.query("select c1, log(1, 2.0) from ct1")
+        tdSql.query(f"select c1, log(1, 2.0) from {dbname}.ct1")
        tdSql.checkData(0, 1, 0.000000000)
        tdSql.checkRows(13)

        # two cols start log(x,y)
-        tdSql.query("select c1,c2, log(c1,c2) from ct1")
+        tdSql.query(f"select c1,c2, log(c1,c2) from {dbname}.ct1")
        tdSql.checkData(0, 2, 0.182485070)
        tdSql.checkData(1, 2, 0.172791608)
        tdSql.checkData(4, 2, None)

-        tdSql.query("select c1,c2, log(c2,c1) from ct1")
+        tdSql.query(f"select c1,c2, log(c2,c1) from {dbname}.ct1")
        tdSql.checkData(0, 2, 5.479900349)
        tdSql.checkData(1, 2, 5.787318105)
        tdSql.checkData(4, 2, None)

-        tdSql.query("select c1, log(2.0 , c1) from ct1")
+        tdSql.query(f"select c1, log(2.0 , c1) from {dbname}.ct1")
        tdSql.checkData(0, 1, 0.333333333)
        tdSql.checkData(1, 1, 0.356207187)
        tdSql.checkData(4, 1, None)

-        tdSql.query("select c1, log(2.0 , ceil(abs(c1))) from ct1")
+        tdSql.query(f"select c1, log(2.0 , ceil(abs(c1))) from {dbname}.ct1")
        tdSql.checkData(0, 1, 0.333333333)
        tdSql.checkData(1, 1, 0.356207187)
        tdSql.checkData(4, 1, None)


-    def abs_func_filter(self):
-        tdSql.execute("use db")
-        tdSql.query("select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) from ct4 where c1>5 ")
+    def abs_func_filter(self, dbname="db"):
+        tdSql.query(f"select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) from {dbname}.ct4 where c1>5 ")
        tdSql.checkRows(3)
        tdSql.checkData(0,0,8)
        tdSql.checkData(0,1,8.000000000)
@ -556,7 +543,7 @@ class TDTestCase:
        tdSql.checkData(0,3,7.900000000)
        tdSql.checkData(0,4,3.000000000)

-        tdSql.query("select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) from ct4 where c1=5 ")
+        tdSql.query(f"select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) from {dbname}.ct4 where c1=5 ")
        tdSql.checkRows(1)
        tdSql.checkData(0,0,5)
        tdSql.checkData(0,1,5.000000000)
@ -564,15 +551,7 @@ class TDTestCase:
        tdSql.checkData(0,3,4.900000000)
        tdSql.checkData(0,4,2.000000000)

-        tdSql.query("select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) from ct4 where c1=5 ")
-        tdSql.checkRows(1)
-        tdSql.checkData(0,0,5)
-        tdSql.checkData(0,1,5.000000000)
-        tdSql.checkData(0,2,5.000000000)
-        tdSql.checkData(0,3,4.900000000)
-        tdSql.checkData(0,4,2.000000000)
-
-        tdSql.query("select c1,c2 , abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) from ct4 where c1>log(c1,2) limit 1 ")
+        tdSql.query(f"select c1,c2 , abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) from {dbname}.ct4 where c1>log(c1,2) limit 1 ")
        tdSql.checkRows(1)
        tdSql.checkData(0,0,8)
        tdSql.checkData(0,1,88888)
@ -581,46 +560,43 @@ class TDTestCase:
        tdSql.checkData(0,4,7.900000000)
        tdSql.checkData(0,5,3.000000000)

-    def log_Arithmetic(self):
-        pass

-    def check_boundary_values(self):
+    def check_boundary_values(self, dbname="bound_test"):

-        tdSql.execute("drop database if exists bound_test")
-        tdSql.execute("create database if not exists bound_test")
+        tdSql.execute(f"drop database if exists {dbname}")
+        tdSql.execute(f"create database if not exists {dbname}")
        time.sleep(3)
-        tdSql.execute("use bound_test")
        tdSql.execute(
-            "create table stb_bound (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(32),c9 nchar(32), c10 timestamp) tags (t1 int);"
+            f"create table {dbname}.stb_bound (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(32),c9 nchar(32), c10 timestamp) tags (t1 int);"
        )
-        tdSql.execute(f'create table sub1_bound using stb_bound tags ( 1 )')
+        tdSql.execute(f'create table {dbname}.sub1_bound using {dbname}.stb_bound tags ( 1 )')
        tdSql.execute(
-                f"insert into sub1_bound values ( now()-1s, 2147483647, 9223372036854775807, 32767, 127, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+                f"insert into {dbname}.sub1_bound values ( now()-1s, 2147483647, 9223372036854775807, 32767, 127, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
            )
        tdSql.execute(
-                f"insert into sub1_bound values ( now()-1s, -2147483647, -9223372036854775807, -32767, -127, -3.40E+38, -1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+                f"insert into {dbname}.sub1_bound values ( now()-1s, -2147483647, -9223372036854775807, -32767, -127, -3.40E+38, -1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
            )
        tdSql.execute(
-                f"insert into sub1_bound values ( now(), 2147483646, 9223372036854775806, 32766, 126, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+                f"insert into {dbname}.sub1_bound values ( now(), 2147483646, 9223372036854775806, 32766, 126, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
            )
        tdSql.execute(
-                f"insert into sub1_bound values ( now(), -2147483646, -9223372036854775806, -32766, -126, -3.40E+38, -1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+                f"insert into {dbname}.sub1_bound values ( now(), -2147483646, -9223372036854775806, -32766, -126, -3.40E+38, -1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
            )
        tdSql.error(
-                f"insert into sub1_bound values ( now()+1s, 2147483648, 9223372036854775808, 32768, 128, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+                f"insert into {dbname}.sub1_bound values ( now()+1s, 2147483648, 9223372036854775808, 32768, 128, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
            )
-        self.check_result_auto_log( "select c1, c2, c3 , c4, c5 ,c6 from sub1_bound ", "select log(c1), log(c2) ,log(c3), log(c4), log(c5) ,log(c6) from sub1_bound")
-        self.check_result_auto_log2( "select c1, c2, c3 , c4, c5 ,c6 from sub1_bound ", "select log(c1,2), log(c2,2) ,log(c3,2), log(c4,2), log(c5,2) ,log(c6,2) from sub1_bound")
-        self.check_result_auto_log__10( "select c1, c2, c3 , c4, c5 ,c6 from sub1_bound ", "select log(c1,-10), log(c2,-10) ,log(c3,-10), log(c4,-10), log(c5,-10) ,log(c6,-10) from sub1_bound")
+        self.check_result_auto_log( f"select c1, c2, c3 , c4, c5 ,c6 from {dbname}.sub1_bound ", f"select log(c1), log(c2) ,log(c3), log(c4), log(c5) ,log(c6) from {dbname}.sub1_bound")
+        self.check_result_auto_log2( f"select c1, c2, c3 , c4, c5 ,c6 from {dbname}.sub1_bound ", f"select log(c1,2), log(c2,2) ,log(c3,2), log(c4,2), log(c5,2) ,log(c6,2) from {dbname}.sub1_bound")
+        self.check_result_auto_log__10( f"select c1, c2, c3 , c4, c5 ,c6 from {dbname}.sub1_bound ", f"select log(c1,-10), log(c2,-10) ,log(c3,-10), log(c4,-10), log(c5,-10) ,log(c6,-10) from {dbname}.sub1_bound")

-        self.check_result_auto_log2( "select c1, c2, c3 , c3, c2 ,c1 from sub1_bound ", "select log(c1,2), log(c2,2) ,log(c3,2), log(c3,2), log(c2,2) ,log(c1,2) from sub1_bound")
-        self.check_result_auto_log( "select c1, c2, c3 , c3, c2 ,c1 from sub1_bound ", "select log(c1), log(c2) ,log(c3), log(c3), log(c2) ,log(c1) from sub1_bound")
+        self.check_result_auto_log2( f"select c1, c2, c3 , c3, c2 ,c1 from {dbname}.sub1_bound ", f"select log(c1,2), log(c2,2) ,log(c3,2), log(c3,2), log(c2,2) ,log(c1,2) from {dbname}.sub1_bound")
+        self.check_result_auto_log( f"select c1, c2, c3 , c3, c2 ,c1 from {dbname}.sub1_bound ", f"select log(c1), log(c2) ,log(c3), log(c3), log(c2) ,log(c1) from {dbname}.sub1_bound")


-        self.check_result_auto_log2("select abs(abs(abs(abs(abs(abs(abs(abs(abs(c1)))))))))  nest_col_func from sub1_bound" , "select log(abs(c1) ,2) from sub1_bound" )
+        self.check_result_auto_log2(f"select abs(abs(abs(abs(abs(abs(abs(abs(abs(c1)))))))))  nest_col_func from {dbname}.sub1_bound" , f"select log(abs(c1) ,2) from {dbname}.sub1_bound" )

        # check basic elem for table per row
-        tdSql.query("select log(abs(c1),2) ,log(abs(c2),2) , log(abs(c3),2) , log(abs(c4),2), log(abs(c5),2), log(abs(c6),2) from sub1_bound ")
+        tdSql.query(f"select log(abs(c1),2) ,log(abs(c2),2) , log(abs(c3),2) , log(abs(c4),2), log(abs(c5),2), log(abs(c6),2) from {dbname}.sub1_bound ")
        tdSql.checkData(0,0,math.log(2147483647,2))
        tdSql.checkData(0,1,math.log(9223372036854775807 ,2))
        tdSql.checkData(0,2,math.log(32767,2))
@ -641,7 +617,7 @@ class TDTestCase:
        tdSql.checkData(3,5,math.log(169999999999999993883079578865998174333346074304075874502773119193537729178160565864330091787584707988572262467983188919169916105593357174268369962062473635296474636515660464935663040684957844303524367815028553272712298986386310828644513212353921123253311675499856875650512437415429217994623324794855339589632.000000000,2))

        # check basic elem for table per row
-        tdSql.query("select log(abs(c1)) ,log(abs(c2)) , log(abs(c3)) , log(abs(c4)), log(abs(c5)), log(abs(c6)) from sub1_bound ")
+        tdSql.query(f"select log(abs(c1)) ,log(abs(c2)) , log(abs(c3)) , log(abs(c4)), log(abs(c5)), log(abs(c6)) from {dbname}.sub1_bound ")
        tdSql.checkData(0,0,math.log(2147483647))
        tdSql.checkData(0,1,math.log(9223372036854775807))
        tdSql.checkData(0,2,math.log(32767))
@ -661,28 +637,25 @@ class TDTestCase:
        tdSql.checkData(3,4,math.log(339999995214436424907732413799364296704.00000))
        tdSql.checkData(3,5,math.log(169999999999999993883079578865998174333346074304075874502773119193537729178160565864330091787584707988572262467983188919169916105593357174268369962062473635296474636515660464935663040684957844303524367815028553272712298986386310828644513212353921123253311675499856875650512437415429217994623324794855339589632.000000000))

-
-
        # check  + - * / in functions
-        tdSql.query("select log(abs(c1+1) ,2) ,log(abs(c2),2) , log(abs(c3*1),2) , log(abs(c4/2),2), log(abs(c5) ,2)/2, log(abs(c6) ,2) from sub1_bound ")
+        tdSql.query(f"select log(abs(c1+1) ,2) ,log(abs(c2),2) , log(abs(c3*1),2) , log(abs(c4/2),2), log(abs(c5) ,2)/2, log(abs(c6) ,2) from {dbname}.sub1_bound ")
        tdSql.checkData(0,0,math.log(2147483648.000000000,2))
        tdSql.checkData(0,1,math.log(9223372036854775807,2))
        tdSql.checkData(0,2,math.log(32767.000000000,2))
        tdSql.checkData(0,3,math.log(63.500000000,2))
        tdSql.checkData(0,4,63.999401166)

-    def support_super_table_test(self):
-        tdSql.execute(" use db ")
-        self.check_result_auto_log2( " select c5 from stb1 order by ts " , "select log(c5,2) from stb1 order by ts" )
-        self.check_result_auto_log2( " select c5 from stb1 order by tbname " , "select log(c5,2) from stb1 order by tbname" )
-        self.check_result_auto_log2( " select c5 from stb1 where c1 > 0 order by tbname  " , "select log(c5,2) from stb1 where c1 > 0 order by tbname" )
-        self.check_result_auto_log2( " select c5 from stb1 where c1 > 0 order by tbname  " , "select log(c5,2) from stb1 where c1 > 0 order by tbname" )
+    def support_super_table_test(self, dbname="db"):

-        self.check_result_auto_log2( " select t1,c5 from stb1 order by ts " , "select log(t1,2), log(c5,2) from stb1 order by ts" )
-        self.check_result_auto_log2( " select t1,c5 from stb1 order by tbname " , "select log(t1,2) ,log(c5,2) from stb1 order by tbname" )
-        self.check_result_auto_log2( " select t1,c5 from stb1 where c1 > 0 order by tbname  " , "select log(t1,2) ,log(c5,2) from stb1 where c1 > 0 order by tbname" )
-        self.check_result_auto_log2( " select t1,c5 from stb1 where c1 > 0 order by tbname  " , "select log(t1,2) , log(c5,2) from stb1 where c1 > 0 order by tbname" )
-        pass
+        self.check_result_auto_log2( f"select c5 from {dbname}.stb1 order by ts " , f"select log(c5,2) from {dbname}.stb1 order by ts" )
+        self.check_result_auto_log2( f"select c5 from {dbname}.stb1 order by tbname " , f"select log(c5,2) from {dbname}.stb1 order by tbname" )
+        self.check_result_auto_log2( f"select c5 from {dbname}.stb1 where c1 > 0 order by tbname  " , f"select log(c5,2) from {dbname}.stb1 where c1 > 0 order by tbname" )
+        self.check_result_auto_log2( f"select c5 from {dbname}.stb1 where c1 > 0 order by tbname  " , f"select log(c5,2) from {dbname}.stb1 where c1 > 0 order by tbname" )
+
+        self.check_result_auto_log2( f"select t1,c5 from {dbname}.stb1 order by ts " , f"select log(t1,2), log(c5,2) from {dbname}.stb1 order by ts" )
+        self.check_result_auto_log2( f"select t1,c5 from {dbname}.stb1 order by tbname " , f"select log(t1,2) ,log(c5,2) from {dbname}.stb1 order by tbname" )
+        self.check_result_auto_log2( f"select t1,c5 from {dbname}.stb1 where c1 > 0 order by tbname  " , f"select log(t1,2) ,log(c5,2) from {dbname}.stb1 where c1 > 0 order by tbname" )
+        self.check_result_auto_log2( f"select t1,c5 from {dbname}.stb1 where c1 > 0 order by tbname  " , f"select log(t1,2) , log(c5,2) from {dbname}.stb1 where c1 > 0 order by tbname" )

    def run(self):  # sourcery skip: extract-duplicate-method, remove-redundant-fstring
        tdSql.prepare()
--- a/tests/system-test/fulltest.sh
+++ b/tests/system-test/fulltest.sh
@ -110,15 +110,20 @@ python3 ./test.py -f 2-query/histogram.py
 python3 ./test.py -f 2-query/histogram.py -R
 python3 ./test.py -f 2-query/hyperloglog.py
 python3 ./test.py -f 2-query/hyperloglog.py -R
+python3 ./test.py -f 2-query/interp.py
+python3 ./test.py -f 2-query/interp.py -R
 python3 ./test.py -f 2-query/irate.py
 # python3 ./test.py -f 2-query/irate.py -R
 python3 ./test.py -f 2-query/join.py
 python3 ./test.py -f 2-query/join.py -R
-
-python3 ./test.py -f 2-query/interp.py
-python3 ./test.py -f 2-query/interp.py -R
-
-
+python3 ./test.py -f 2-query/last_row.py
+python3 ./test.py -f 2-query/last_row.py -R
+python3 ./test.py -f 2-query/last.py
+python3 ./test.py -f 2-query/last.py -R
+python3 ./test.py -f 2-query/leastsquares.py
+python3 ./test.py -f 2-query/leastsquares.py -R
+python3 ./test.py -f 2-query/length.py
+python3 ./test.py -f 2-query/length.py -R

 python3 ./test.py -f 1-insert/update_data.py

@ -127,7 +132,6 @@ python3 ./test.py -f 1-insert/delete_data.py
 python3 ./test.py -f 2-query/varchar.py
 python3 ./test.py -f 2-query/ltrim.py
 python3 ./test.py -f 2-query/rtrim.py
-python3 ./test.py -f 2-query/length.py
 python3 ./test.py -f 2-query/upper.py
 python3 ./test.py -f 2-query/lower.py
 python3 ./test.py -f 2-query/join2.py
@ -136,7 +140,6 @@ python3 ./test.py -f 2-query/union.py
 python3 ./test.py -f 2-query/union1.py
 python3 ./test.py -f 2-query/concat2.py
 python3 ./test.py -f 2-query/spread.py
-python3 ./test.py -f 2-query/leastsquares.py


 python3 ./test.py -f 2-query/timezone.py
@ -144,7 +147,6 @@ python3 ./test.py -f 2-query/Now.py
 python3 ./test.py -f 2-query/Today.py
 python3 ./test.py -f 2-query/max.py
 python3 ./test.py -f 2-query/min.py
-python3 ./test.py -f 2-query/last.py
 python3 ./test.py -f 2-query/To_iso8601.py
 python3 ./test.py -f 2-query/To_unixtimestamp.py
 python3 ./test.py -f 2-query/timetruncate.py
@ -178,7 +180,6 @@ python3 ./test.py -f 2-query/ttl_comment.py
 python3 ./test.py -f 2-query/twa.py
 python3 ./test.py -f 2-query/queryQnode.py
 python3 ./test.py -f 2-query/max_partition.py
-python3 ./test.py -f 2-query/last_row.py
 python3 ./test.py -f 2-query/tsbsQuery.py

 python3 ./test.py -f 6-cluster/5dnode1mnode.py
--- a/tests/system-test/test.py
+++ b/tests/system-test/test.py
@ -194,7 +194,7 @@ if __name__ == "__main__":
            processID = subprocess.check_output(psCmd, shell=True)

        for port in range(6030, 6041):
-            usePortPID = "lsof -i tcp:%d | grep LISTEn | awk '{print $2}'" % port
+            usePortPID = "lsof -i tcp:%d | grep LISTEN | awk '{print $2}'" % port
            processID = subprocess.check_output(usePortPID, shell=True)

            if processID:
@ -206,11 +206,13 @@ if __name__ == "__main__":
            time.sleep(2)

        if restful:
-            toBeKilled = "taosadapter"
+            toBeKilled = "taosadapt"

-            killCmd = "ps -ef|grep -w %s| grep -v grep | awk '{print $2}' | xargs kill -TERM > /dev/null 2>&1" % toBeKilled
+            # killCmd = "ps -ef|grep -w %s| grep -v grep | awk '{print $2}' | xargs kill -TERM > /dev/null 2>&1" % toBeKilled
+            killCmd = f"pkill {toBeKilled}"

            psCmd = "ps -ef|grep -w %s| grep -v grep | awk '{print $2}'" % toBeKilled
+            # psCmd = f"pgrep {toBeKilled}"
            processID = subprocess.check_output(psCmd, shell=True)

            while(processID):
@ -218,15 +220,15 @@ if __name__ == "__main__":
                time.sleep(1)
                processID = subprocess.check_output(psCmd, shell=True)

-            for port in range(6030, 6041):
-                usePortPID = "lsof -i tcp:%d | grep LISTEn | awk '{print $2}'" % port
-                processID = subprocess.check_output(usePortPID, shell=True)
+            port = 6041
+            usePortPID = f"lsof -i tcp:{port} | grep LISTEN | awk '{{print $2}}'"
+            processID = subprocess.check_output(usePortPID, shell=True)

-                if processID:
-                    killCmd = "kill -TERM %s" % processID
-                    os.system(killCmd)
-                fuserCmd = "fuser -k -n tcp %d" % port
-                os.system(fuserCmd)
+            if processID:
+                killCmd = f"kill -TERM {processID}"
+                os.system(killCmd)
+            fuserCmd = f"fuser -k -n tcp {port}"
+            os.system(fuserCmd)

            tdLog.info('stop taosadapter')

--- a/tools/CMakeLists.txt
+++ b/tools/CMakeLists.txt
@ -99,11 +99,20 @@ ELSE ()
    MESSAGE("CURRENT SOURCE DIR ${CMAKE_CURRENT_SOURCE_DIR}")
    IF (TD_LINUX)
        include(ExternalProject)
+        set(_upx_prefix "$ENV{HOME}/.taos/externals/upx")
+        ExternalProject_Add(upx
+            PREFIX              "${_upx_prefix}"
+            URL                 https://github.com/upx/upx/releases/download/v3.96/upx-3.96-${PLATFORM_ARCH_STR}_linux.tar.xz
+            CONFIGURE_COMMAND   cmake -E true
+            BUILD_COMMAND       cmake -E true
+            INSTALL_COMMAND     cmake -E true
+            )
+
        ExternalProject_Add(taosadapter
                PREFIX        "taosadapter"
                SOURCE_DIR    ${CMAKE_CURRENT_SOURCE_DIR}/taosadapter
                BUILD_ALWAYS         off
-                DEPENDS             taos
+                DEPENDS             taos upx
                BUILD_IN_SOURCE     1
                CONFIGURE_COMMAND cmake -E echo "taosadapter no need cmake to config"
                PATCH_COMMAND
@ -112,7 +121,7 @@ ELSE ()
                COMMAND CGO_CFLAGS=-I${CMAKE_CURRENT_SOURCE_DIR}/../include/client CGO_LDFLAGS=-L${CMAKE_BINARY_DIR}/build/lib  go build -a -ldflags "-s -w -X github.com/taosdata/taosadapter/version.Version=${taos_version} -X github.com/taosdata/taosadapter/version.CommitID=${taosadapter_commit_sha1}"
                COMMAND CGO_CFLAGS=-I${CMAKE_CURRENT_SOURCE_DIR}/../include/client CGO_LDFLAGS=-L${CMAKE_BINARY_DIR}/build/lib  go build -a -o taosadapter-debug -ldflags "-X github.com/taosdata/taosadapter/version.Version=${taos_version} -X github.com/taosdata/taosadapter/version.CommitID=${taosadapter_commit_sha1}"
                INSTALL_COMMAND
-                COMMAND wget -nc https://github.com/upx/upx/releases/download/v3.96/upx-3.96-${PLATFORM_ARCH_STR}_linux.tar.xz -O $ENV{HOME}/upx.tar.xz && tar -xvJf $ENV{HOME}/upx.tar.xz -C $ENV{HOME}/ --strip-components 1 > /dev/null && $ENV{HOME}/upx taosadapter || :
+                COMMAND ${_upx_prefix}/src/upx/upx taosadapter
                COMMAND cmake -E copy taosadapter ${CMAKE_BINARY_DIR}/build/bin
                COMMAND cmake -E make_directory ${CMAKE_BINARY_DIR}/test/cfg/
                COMMAND cmake -E copy ./example/config/taosadapter.toml ${CMAKE_BINARY_DIR}/test/cfg/
@ -140,6 +149,7 @@ ELSE ()
                COMMAND cmake -E copy ./taosadapter.service ${CMAKE_BINARY_DIR}/test/cfg/
                COMMAND cmake -E copy taosadapter-debug ${CMAKE_BINARY_DIR}/build/bin
                )
+        unset(_upx_prefix)
    ELSE ()
        MESSAGE("${Yellow} Windows system still use original embedded httpd ${ColourReset}")
    ENDIF ()