Merge branch '3.0' into fix/TD-18331

2022-08-11 19:54:44 +08:00 · 2022-08-11 19:54:44 +08:00 · 73f57290b4
parent 7409cc9513 e252eba6cd
commit 73f57290b4
229 changed files with 2031 additions and 35177 deletions
--- a/.gitignore
+++ b/.gitignore
@ -119,3 +119,11 @@ contrib/*
 sql
 debug*/
 .env
+tools/README
+tools/LICENSE
+tools/README.1ST
+tools/THANKS
+tools/NEWS
+tools/COPYING
+tools/BUGS
+tools/taos-tools
--- a/2
+++ b/2
@ -265,6 +265,7 @@ def pre_test_build_win() {
    '''
    bat '''
        cd %WIN_CONNECTOR_ROOT%
+        python.exe -m pip install --upgrade pip
        python -m pip install .
        xcopy /e/y/i/f %WIN_INTERNAL_ROOT%\\debug\\build\\lib\\taos.dll C:\\Windows\\System32
    '''
@ -283,6 +284,7 @@ def run_win_test() {
    bat '''
        echo "windows test ..."
        cd %WIN_CONNECTOR_ROOT%
+        python.exe -m pip install --upgrade pip
        python -m pip install .
        xcopy /e/y/i/f %WIN_INTERNAL_ROOT%\\debug\\build\\lib\\taos.dll C:\\Windows\\System32
        ls -l C:\\Windows\\System32\\taos.dll
--- a/README-CN.md
+++ b/README-CN.md
@ -20,33 +20,27 @@

 # TDengine 简介

-TDengine 是一款高性能、分布式、支持 SQL 的时序数据库（Time-Series Database）。而且除时序数据库功能外，它还提供缓存、数据订阅、流式计算等功能，最大程度减少研发和运维的复杂度，且核心代码，包括集群功能全部开源（开源协议，AGPL v3.0）。与其他时序数据数据库相比，TDengine 有以下特点：
+TDengine 是一款开源、高性能、云原生的时序数据库 (Time-Series Database, TSDB)。TDengine 能被广泛运用于物联网、工业互联网、车联网、IT 运维、金融等领域。除核心的时序数据库功能外，TDengine 还提供缓存、数据订阅、流式计算等功能，是一极简的时序数据处理平台，最大程度的减小系统设计的复杂度，降低研发和运营成本。TDengine 的主要优势如下：

- **高性能**：通过创新的存储引擎设计，无论是数据写入还是查询，TDengine 的性能比通用数据库快 10 倍以上，也远超其他时序数据库，而且存储空间也大为节省。
+- 高性能：通过创新的存储引擎设计，无论是数据写入还是查询，TDengine 的性能比通用数据库快 10 倍以上，也远超其他时序数据库，存储空间不及通用数据库的1/10。

- **分布式**：通过原生分布式的设计，TDengine 提供了水平扩展的能力，只需要增加节点就能获得更强的数据处理能力，同时通过多副本机制保证了系统的高可用。
+- 云原生：通过原生分布式的设计，充分利用云平台的优势，TDengine 提供了水平扩展能力，具备弹性、韧性和可观测性，支持k8s部署，可运行在公有云、私有云和混合云上。

- **支持 SQL**：TDengine 采用 SQL 作为数据查询语言，减少学习和迁移成本，同时提供 SQL 扩展来处理时序数据特有的分析，而且支持方便灵活的 schemaless 数据写入。
+- 极简时序数据平台：TDengine 内建消息队列、缓存、流式计算等功能，应用无需再集成 Kafka/Redis/HBase/Spark 等软件，大幅降低系统的复杂度，降低应用开发和运营成本。

- **All in One**：将数据库、消息队列、缓存、流式计算等功能融合一起，应用无需再集成 Kafka/Redis/HBase/Spark 等软件，大幅降低应用开发和维护成本。
+- 分析能力：支持 SQL，同时为时序数据特有的分析提供SQL扩展。通过超级表、存储计算分离、分区分片、预计算、自定义函数等技术，TDengine 具备强大的分析能力。

- **零管理**：安装、集群几秒搞定，无任何依赖，不用分库分表，系统运行状态监测能与 Grafana 或其他运维工具无缝集成。
+- 简单易用：无任何依赖，安装、集群几秒搞定；提供REST以及各种语言连接器，与众多第三方工具无缝集成；提供命令行程序，便于管理和即席查询；提供各种运维工具。

- **零学习成本**：采用 SQL 查询语言，支持 Python、Java、C/C++、Go、Rust、Node.js 等多种编程语言，与 MySQL 相似，零学习成本。
-
- **无缝集成**：不用一行代码，即可与 Telegraf、Grafana、EMQX、Prometheus、StatsD、collectd、Matlab、R 等第三方工具无缝集成。
-
- **互动 Console**: 通过命令行 console，不用编程，执行 SQL 语句就能做即席查询、各种数据库的操作、管理以及集群的维护.
-
-TDengine 可以广泛应用于物联网、工业互联网、车联网、IT 运维、能源、金融等领域，让大量设备、数据采集器每天产生的高达 TB 甚至 PB 级的数据能得到高效实时的处理，对业务的运行状态进行实时的监测、预警，从大数据中挖掘出商业价值。
+- 核心开源：TDengine 的核心代码包括集群功能全部开源，截止到2022年8月1日，全球超过 135.9k 个运行实例，GitHub Star 18.7k，Fork 4.4k，社区活跃。

 # 文档

-TDengine 采用传统的关系数据库模型，您可以像使用关系型数据库 MySQL 一样来使用它。但由于引入了超级表，一个采集点一张表的概念，建议您在使用前仔细阅读一遍下面的文档，特别是 [数据模型](https://www.taosdata.com/cn/documentation/architecture) 与 [数据建模](https://www.taosdata.com/cn/documentation/model)。除本文档之外，欢迎 [下载产品白皮书](https://www.taosdata.com/downloads/TDengine%20White%20Paper.pdf)。
+关于完整的使用手册，系统架构和更多细节，请参考 [TDengine 文档](https://docs.taosdata.com) 或者  [English Version](https://docs.tdengine.com)。

 # 构建

-TDengine 目前 2.0 版服务器仅能在 Linux 系统上安装和运行，后续会支持 Windows、macOS 等系统。客户端可以在 Windows 或 Linux 上安装和运行。任何 OS 的应用也可以选择 RESTful 接口连接服务器 taosd。CPU 支持 X64/ARM64/MIPS64/Alpha64，后续会支持 ARM32、RISC-V 等 CPU 架构。用户可根据需求选择通过[源码](https://www.taosdata.com/cn/getting-started/#通过源码安装)或者[安装包](https://www.taosdata.com/cn/getting-started/#通过安装包安装)来安装。本快速指南仅适用于通过源码安装。
+TDengine 目前 2.0 版服务器仅能在 Linux 系统上安装和运行，后续会支持 Windows、macOS 等系统。客户端可以在 Windows 或 Linux 上安装和运行。任何 OS 的应用也可以选择 RESTful 接口连接服务器 taosd。CPU 支持 X64/ARM64/MIPS64/Alpha64，后续会支持 ARM32、RISC-V 等 CPU 架构。用户可根据需求选择通过源码或者[安装包](https://docs.taosdata.com/get-started/package/)来安装。本快速指南仅适用于通过源码安装。

 ## 安装工具

@ -188,7 +182,7 @@ apt install autoconf
 cmake .. -DJEMALLOC_ENABLED=true
 ```

-在 X86-64、X86、arm64、arm32 和 mips64 平台上，TDengine 生成脚本可以自动检测机器架构。也可以手动配置 CPUTYPE 参数来指定 CPU 类型，如 aarch64 或 aarch32 等。
+在 X86-64、X86、arm64 平台上，TDengine 生成脚本可以自动检测机器架构。也可以手动配置 CPUTYPE 参数来指定 CPU 类型，如 aarch64 等。

 aarch64：

@ -196,18 +190,6 @@ aarch64：
 cmake .. -DCPUTYPE=aarch64 && cmake --build .
 ```

-aarch32：
-
-```bash
-cmake .. -DCPUTYPE=aarch32 && cmake --build .
-```
-
-mips64：
-
-```bash
-cmake .. -DCPUTYPE=mips64 && cmake --build .
-```
-
 ### Windows 系统

 如果你使用的是 Visual Studio 2013 版本：
@ -351,19 +333,14 @@ Query OK, 2 row(s) in set (0.001700s)

 TDengine 提供了丰富的应用程序开发接口，其中包括 C/C++、Java、Python、Go、Node.js、C# 、RESTful 等，便于用户快速开发应用：

- [Java](https://www.taosdata.com/cn/documentation/connector/java)
-
+- [Java](https://docs.taosdata.com/reference/connector/java/)
 - [C/C++](https://www.taosdata.com/cn/documentation/connector#c-cpp)
-
- [Python](https://www.taosdata.com/cn/documentation/connector#python)
-
- [Go](https://www.taosdata.com/cn/documentation/connector#go)
-
- [RESTful API](https://www.taosdata.com/cn/documentation/connector#restful)
-
- [Node.js](https://www.taosdata.com/cn/documentation/connector#nodejs)
-
- [Rust](https://www.taosdata.com/cn/documentation/connector/rust)
+- [Python](https://docs.taosdata.com/reference/connector/python/)
+- [Go](https://docs.taosdata.com/reference/connector/go/)
+- [Node.js](https://docs.taosdata.com/reference/connector/node/)
+- [Rust](https://docs.taosdata.com/reference/connector/rust/)
+- [C#](https://docs.taosdata.com/reference/connector/csharp/)
+- [RESTful API](https://docs.taosdata.com/reference/rest-api/)

 ## 第三方连接器

@ -372,6 +349,7 @@ TDengine 社区生态中也有一些非常友好的第三方连接器，可以
 - [Rust Bindings](https://github.com/songtianyi/tdengine-rust-bindings/tree/master/examples)
 - [.Net Core Connector](https://github.com/maikebing/Maikebing.EntityFrameworkCore.Taos)
 - [Lua Connector](https://github.com/taosdata/TDengine/tree/develop/examples/lua)
+- [PHP](https://www.taosdata.com/en/documentation/connector#c-cpp)

 # 运行和添加测试例

--- a/README.md
+++ b/README.md
@ -20,30 +20,23 @@ English | [简体中文](README-CN.md) | We are hiring, check [here](https://tde

 # What is TDengine？

-TDengine is a high-performance, scalable time-series database with SQL support. Its code including cluster feature is open source under [GNU AGPL v3.0](http://www.gnu.org/licenses/agpl-3.0.html). Besides the database, it provides caching, stream processing, data subscription and other functionalities to reduce the complexity and cost of development and operation. TDengine differentiates itself from other TSDBs with the following advantages.
+TDengine is an open source, cloud native time-series database optimized for Internet of Things (IoT), Connected Cars, and Industrial IoT. It enables efficient, real-time data ingestion, processing, and monitoring of TB and even PB scale data per day, generated by billions of sensors and data collectors. Below are the most outstanding advantages of TDengine:

- **High Performance**: TDengine outperforms other time series databases in data ingestion and querying while significantly reducing storage cost and compute costs, with an innovatively designed and purpose-built storage engine.
+- High-Performance: TDengine is the only time-series database to solve the high cardinality issue to support billions of data collection points while out performing other time-series databases for data ingestion, querying and data compression.

- **Scalable**: TDengine provides out-of-box scalability and high-availability through its native distributed design. Nodes can be added through simple configuration to achieve greater data processing power. In addition, this feature is open source.
+- Simplified Solution: Through built-in caching, stream processing and data subscription features, TDengine provides a simplified solution for time-series data processing. It reduces system design complexity and operation costs significantly.

- **SQL Support**: TDengine uses SQL as the query language, thereby reducing learning and migration costs, while adding SQL extensions to handle time-series data better, and supporting convenient and flexible schemaless data ingestion.
+- Cloud Native: Through native distributed design, sharding and partitioning, separation of compute and storage, RAFT, support for kubernetes deployment and full observability, TDengine can be deployed on public, private or hybrid clouds.

- **All in One**: TDengine has built-in caching, stream processing and data subscription functions, it is no longer necessary to integrate Kafka/Redis/HBase/Spark or other software in some scenarios. It makes the system architecture much simpler and easy to maintain.
+- Open Source: TDengine’s core modules, including cluster feature, are all available under open source licenses. It has gathered 18.7k stars on GitHub, an active developer community, and over 137k running instances worldwide.

- **Seamless Integration**: Without a single line of code, TDengine provide seamless integration with third-party tools such as Telegraf, Grafana, EMQX, Prometheus, StatsD, collectd, etc. More will be integrated.
+- Ease of Use: For administrators, TDengine significantly reduces the effort to deploy and maintain. For developers, it provides a simple interface, simplified solution and seamless integrations for third party tools. For data users, it gives easy data access. 

- **Zero Management**: Installation and cluster setup can be done in seconds. Data partitioning and sharding are executed automatically. TDengine’s running status can be monitored via Grafana or other DevOps tools.
-
- **Zero Learning Cost**: With SQL as the query language, support for ubiquitous tools like Python, Java, C/C++, Go, Rust, Node.js connectors, there is zero learning cost.
-
- **Interactive Console**: TDengine provides convenient console access to the database to run ad hoc queries, maintain the database, or manage the cluster without any programming.
-
-TDengine can be widely applied to Internet of Things (IoT), Connected Vehicles, Industrial IoT, DevOps, energy, finance and many other scenarios.
+- Easy Data Analytics: Through super tables, storage and compute separation, data partitioning by time interval, pre-computation and other means, TDengine makes it easy to explore, format, and get access to data in a highly efficient way. 

 # Documentation

-For user manual, system design and architecture, engineering blogs, refer to [TDengine Documentation](https://www.taosdata.com/en/documentation/)(中文版请点击[这里](https://www.taosdata.com/cn/documentation20/))
-for details. The documentation from our website can also be downloaded locally from _documentation/tdenginedocs-en_ or _documentation/tdenginedocs-cn_.
+For user manual, system design and architecture, please refer to [TDengine Documentation](https://docs.tdengine.com) (中文版请点击[这里](https://docs.taosdata.com))

 # Building

@ -205,8 +198,8 @@ apt install autoconf
 cmake .. -DJEMALLOC_ENABLED=true
 ```

-TDengine build script can detect the host machine's architecture on X86-64, X86, arm64, arm32 and mips64 platform.
-You can also specify CPUTYPE option like aarch64 or aarch32 too if the detection result is not correct:
+TDengine build script can detect the host machine's architecture on X86-64, X86, arm64 platform.
+You can also specify CPUTYPE option like aarch64 too if the detection result is not correct:

 aarch64:

@ -214,18 +207,6 @@ aarch64:
 cmake .. -DCPUTYPE=aarch64 && cmake --build .
 ```

-aarch32:
-
-```bash
-cmake .. -DCPUTYPE=aarch32 && cmake --build .
-```
-
-mips64:
-
-```bash
-cmake .. -DCPUTYPE=mips64 && cmake --build .
-```
-
 ### On Windows platform

 If you use the Visual Studio 2013, please open a command window by executing "cmd.exe".
@ -381,13 +362,14 @@ Query OK, 2 row(s) in set (0.001700s)

 TDengine provides abundant developing tools for users to develop on TDengine. Follow the links below to find your desired connectors and relevant documentation.

- [Java](https://www.taosdata.com/en/documentation/connector/java)
- [C/C++](https://www.taosdata.com/en/documentation/connector#c-cpp)
- [Python](https://www.taosdata.com/en/documentation/connector#python)
- [Go](https://www.taosdata.com/en/documentation/connector#go)
- [RESTful API](https://www.taosdata.com/en/documentation/connector#restful)
- [Node.js](https://www.taosdata.com/en/documentation/connector#nodejs)
- [Rust](https://www.taosdata.com/en/documentation/connector/rust)
+- [Java](https://docs.taosdata.com/reference/connector/java/)
+- [C/C++](https://docs.taosdata.com/reference/connector/cpp/)
+- [Python](https://docs.taosdata.com/reference/connector/python/)
+- [Go](https://docs.taosdata.com/reference/connector/go/)
+- [Node.js](https://docs.taosdata.com/reference/connector/node/)
+- [Rust](https://docs.taosdata.com/reference/connector/rust/)
+- [C#](https://docs.taosdata.com/reference/connector/csharp/)
+- [RESTful API](https://docs.taosdata.com/reference/rest-api/)

 ## Third Party Connectors

@ -396,21 +378,13 @@ The TDengine community has also kindly built some of their own connectors! Follo
 - [Rust Bindings](https://github.com/songtianyi/tdengine-rust-bindings/tree/master/examples)
 - [.Net Core Connector](https://github.com/maikebing/Maikebing.EntityFrameworkCore.Taos)
 - [Lua Connector](https://github.com/taosdata/TDengine/tree/develop/tests/examples/lua)
+- [PHP](https://www.taosdata.com/en/documentation/connector#c-cpp)

 # How to run the test cases and how to add a new test case

 TDengine's test framework and all test cases are fully open source.
 Please refer to [this document](https://github.com/taosdata/TDengine/blob/develop/tests/How-To-Run-Test-And-How-To-Add-New-Test-Case.md) for how to run test and develop new test case.

-# TDengine Roadmap
-
- Support event-driven stream computing
- Support user defined functions
- Support MQTT connection
- Support OPC connection
- Support Hadoop, Spark connections
- Support Tableau and other BI tools
-
 # Contribute to TDengine

 Please follow the [contribution guidelines](CONTRIBUTING.md) to contribute to the project.
--- a/cmake/cmake.install
+++ b/cmake/cmake.install
@ -22,7 +22,9 @@ ELSEIF (TD_WINDOWS)
  INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/taos.exe DESTINATION .)
  INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/taosd.exe DESTINATION .)
  INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/udfd.exe DESTINATION .)
+  IF (BUILD_TOOLS)
    INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/taosBenchmark.exe DESTINATION .)
+  ENDIF ()

  IF (TD_MVN_INSTALLED)
    INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.38-dist.jar DESTINATION connector/jdbc)
--- 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 57bdfbf
+        GIT_TAG 11d23e5
        SOURCE_DIR "${TD_SOURCE_DIR}/tools/taos-tools"
        BINARY_DIR ""
        #BUILD_IN_SOURCE TRUE
--- a/docs/en/02-intro/eco_system.webp
+++ b/docs/en/02-intro/eco_system.webp
--- a/docs/en/14-reference/03-connector/03-connector.mdx
+++ b/docs/en/14-reference/03-connector/03-connector.mdx
@ -17,7 +17,6 @@ Currently, TDengine's native interface connectors can support platforms such as
 | **X86 64bit** | **Win32** | ● | ● | ● | ● | ○ | ○ | ● |
 | **X86 32bit** | **Win32** | ○ | ○ | ○ | ○ | ○ | ○ | ● |
 | **ARM64** | **Linux** | ● | ● | ● | ● | ○ | ○ | ● |
-| **ARM32** | **Linux** | ● | ● | ● | ● | ○ | ○ | ● |
 | **MIPS** | **Linux** | ○ | ○ | ○ | ○ | ○ | ○ | ○ |

 Where ● means the official test verification passed, ○ means the unofficial test verification passed, -- means no assurance.
--- a/docs/en/14-reference/09-support-platform/index.md
+++ b/docs/en/14-reference/09-support-platform/index.md
@ -19,15 +19,15 @@ TDengine's connector can support a wide range of platforms, including X64/X86/AR

 The comparison matrix is as follows.

-| **CPU**     | **X64 64bit** |           |           | **X86 32bit** | **ARM64** | **ARM32** | **MIPS**  | **Alpha** |
-| ----------- | ------------- | --------- | --------- | ------------- | --------- | --------- | --------- | --------- |
-| **OS**      | **Linux**     | **Win64** | **Win32** | **Win32**     | **Linux** | **Linux** | **Linux** | **Linux** |
-| **C/C++**   | ●             | ●         | ●         | ○             | ●         | ●         | ●         | ●         |
-| **JDBC**    | ●             | ●         | ●         | ○             | ●         | ●         | ●         | ●         |
-| **Python**  | ●             | ●         | ●         | ○             | ●         | ●         | ●         | --        |
-| **Go**      | ●             | ●         | ●         | ○             | ●         | ●         | ○         | --        |
-| **NodeJs**  | ●             | ●         | ○         | ○             | ●         | ●         | ○         | --        |
-| **C#**      | ●             | ●         | ○         | ○             | ○         | ○         | ○         | --        |
-| **RESTful** | ●             | ●         | ●         | ●             | ●         | ●         | ●         | ●         |
+| **CPU**     | **X64 64bit** |           |           | **X86 32bit** | **ARM64** | **MIPS**  | **Alpha** |
+| ----------- | ------------- | --------- | --------- | ------------- | --------- | --------- | --------- |
+| **OS**      | **Linux**     | **Win64** | **Win32** | **Win32**     | **Linux** | **Linux** | **Linux** |
+| **C/C++**   | ●             | ●         | ●         | ○             | ●         | ●         | ●         |
+| **JDBC**    | ●             | ●         | ●         | ○             | ●         | ●         | ●         |
+| **Python**  | ●             | ●         | ●         | ○             | ●         | ●         | --        |
+| **Go**      | ●             | ●         | ●         | ○             | ●         | ○         | --        |
+| **NodeJs**  | ●             | ●         | ○         | ○             | ●         | ○         | --        |
+| **C#**      | ●             | ●         | ○         | ○             | ○         | ○         | --        |
+| **RESTful** | ●             | ●         | ●         | ●             | ●         | ●         | ●         |

 Note: ● means the official test is verified, ○ means the unofficial test is verified, -- means not verified.
--- a/docs/en/14-reference/13-schemaless/13-schemaless.md
+++ b/docs/en/14-reference/13-schemaless/13-schemaless.md
@ -3,7 +3,7 @@ title: Schemaless Writing
 description: "The Schemaless write method eliminates the need to create super tables/sub tables in advance and automatically creates the storage structure corresponding to the data, as it is written to the interface."
 ---

-In IoT applications, data is collected for many purposes such as intelligent control, business analysis, device monitoring and so on. Due to changes in business or functional requirements or changes in device hardware, the application logic and even the data collected may change. To provide the flexibility needed in such cases and in a rapidly changing IoT landscape, TDengine starting from version 2.2.0.0, provides a series of interfaces for the schemaless writing method. These interfaces eliminate the need to create super tables and subtables in advance by automatically creating the storage structure corresponding to the data as the data is written to the interface. When necessary, schemaless writing will automatically add the required columns to ensure that the data written by the user is stored correctly.
+In IoT applications, data is collected for many purposes such as intelligent control, business analysis, device monitoring and so on. Due to changes in business or functional requirements or changes in device hardware, the application logic and even the data collected may change. To provide the flexibility needed in such cases and in a rapidly changing IoT landscape, TDengine provides a series of interfaces for the schemaless writing method. These interfaces eliminate the need to create super tables and subtables in advance by automatically creating the storage structure corresponding to the data as the data is written to the interface. When necessary, schemaless writing will automatically add the required columns to ensure that the data written by the user is stored correctly.

 The schemaless writing method creates super tables and their corresponding subtables. These are completely indistinguishable from the super tables and subtables created directly via SQL. You can write data directly to them via SQL statements. Note that the names of tables created by schemaless writing are based on fixed mapping rules for tag values, so they are not explicitly ideographic and they lack readability.

@ -39,10 +39,10 @@ In the schemaless writing data line protocol, each data item in the field_set ne
 | -------- | -------- | ------------ | -------------- |
 | 1 | none or f64 | double | 8 |
 | 2 | f32 | float | 4 |
-| 3 | i8 | TinyInt | 1 |
-| 4 | i16 | SmallInt | 2 |
-| 5 | i32 | Int | 4 |
-| 6 | i64 or i | Bigint | 8 |
+| 3 | i8/u8 | TinyInt/UTinyInt | 1 |
+| 4 | i16/u16 | SmallInt/USmallInt | 2 |
+| 5 | i32/u32 | Int/UInt | 4 |
+| 6 | i64/i/u64/u | Bigint/Bigint/UBigint/UBigint | 8 |

 - `t`, `T`, `true`, `True`, `TRUE`, `f`, `F`, `false`, and `False` will be handled directly as BOOL types.

@ -72,11 +72,11 @@ If the subtable obtained by the parse line protocol does not exist, Schemaless c
 4. If the specified tag or regular column in the data row does not exist, the corresponding tag or regular column is added to the super table (only incremental).
 5. If there are some tag columns or regular columns in the super table that are not specified to take values in a data row, then the values of these columns are set to NULL.
 6. For BINARY or NCHAR columns, if the length of the value provided in a data row exceeds the column type limit, the maximum length of characters allowed to be stored in the column is automatically increased (only incremented and not decremented) to ensure complete preservation of the data.
-7. If the specified data subtable already exists, and the specified tag column takes a value different from the saved value this time, the value in the latest data row overwrites the old tag column take value.
-8. Errors encountered throughout the processing will interrupt the writing process and return an error code.
+7. Errors encountered throughout the processing will interrupt the writing process and return an error code.
+8. In order to improve the efficiency of writing, it is assumed by default that the order of the fields in the same Super is the same (the first data contains all fields, and the following data is in this order). If the order is different, the parameter smlDataFormat needs to be configured to be false. Otherwise, the data is written in the same order, and the data in the library will be abnormal.

 :::tip
-All processing logic of schemaless will still follow TDengine's underlying restrictions on data structures, such as the total length of each row of data cannot exceed 48k bytes. See [TAOS SQL Boundary Limits](/taos-sql/limit) for specific constraints in this area.
+All processing logic of schemaless will still follow TDengine's underlying restrictions on data structures, such as the total length of each row of data cannot exceed 16k bytes. See [TAOS SQL Boundary Limits](/taos-sql/limit) for specific constraints in this area.
 :::

 ## Time resolution recognition
--- a/docs/zh/01-index.md
+++ b/docs/zh/01-index.md
@ -4,7 +4,7 @@ sidebar_label: 文档首页
 slug: /
 ---

-TDengine是一款开源、[高性能](https://www.taosdata.com/fast)、云原生的时序数据库(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)的时序数据库(Time-Series Database, TSDB), 它专为物联网、工业互联网、金融等场景优化设计。同时它还带有内建的缓存、流式计算、数据订阅等系统功能，能大幅减少系统设计的复杂度，降低研发和运营成本，是一极简的时序数据处理平台。本文档是 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 是一款开源、高性能、云原生的时序数据库 (Time-Series Database, TSDB)。TDengine 能被广泛运用于物联网、工业互联网、车联网、IT 运维、金融等领域。除核心的时序数据库功能外，TDengine 还提供[缓存](/develop/cache/)、[数据订阅](/develop/subscribe)、[流式计算](/develop/continuous-query)等功能，是一极简的时序数据处理平台，最大程度的减小系统设计的复杂度，降低研发和运营成本。
+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/subscribe)、[流式计算](/develop/continuous-query)等功能，是一极简的时序数据处理平台，最大程度的减小系统设计的复杂度，降低研发和运营成本。

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

@ -33,17 +33,17 @@ TDengine的主要功能如下：

 由于 TDengine 充分利用了[时序数据特点](https://www.taosdata.com/blog/2019/07/09/105.html)，比如结构化、无需事务、很少删除或更新、写多读少等等，设计了全新的针对时序数据的存储引擎和计算引擎，因此与其他时序数据库相比，TDengine 有以下特点：

- **高性能**：通过创新的存储引擎设计，无论是数据写入还是查询，TDengine 的性能比通用数据库快 10 倍以上，也远超其他时序数据库，存储空间不及通用数据库的1/10。
+- **[高性能](https://www.taosdata.com/tdengine/fast)**：通过创新的存储引擎设计，无论是数据写入还是查询，TDengine 的性能比通用数据库快 10 倍以上，也远超其他时序数据库，存储空间不及通用数据库的1/10。

- **云原生**：通过原生分布式的设计，充分利用云平台的优势，TDengine 提供了水平扩展能力，具备弹性、韧性和可观测性，支持k8s部署，可运行在公有云、私有云和混合云上。
+- **[云原生](https://www.taosdata.com/tdengine/cloud_native_time-series_database)**：通过原生分布式的设计，充分利用云平台的优势，TDengine 提供了水平扩展能力，具备弹性、韧性和可观测性，支持k8s部署，可运行在公有云、私有云和混合云上。

- **极简时序数据平台**：TDengine 内建消息队列、缓存、流式计算等功能，应用无需再集成 Kafka/Redis/HBase/Spark 等软件，大幅降低系统的复杂度，降低应用开发和运营成本。
+- **[极简时序数据平台](https://www.taosdata.com/tdengine/simplified_solution_for_time-series_data_processing)**：TDengine 内建消息队列、缓存、流式计算等功能，应用无需再集成 Kafka/Redis/HBase/Spark 等软件，大幅降低系统的复杂度，降低应用开发和运营成本。

- **分析能力**：支持 SQL，同时为时序数据特有的分析提供SQL扩展。通过超级表、存储计算分离、分区分片、预计算、自定义函数等技术，TDengine 具备强大的分析能力。
+- **[分析能力](https://www.taosdata.com/tdengine/easy_data_analytics)**：支持 SQL，同时为时序数据特有的分析提供SQL扩展。通过超级表、存储计算分离、分区分片、预计算、自定义函数等技术，TDengine 具备强大的分析能力。

- **简单易用**：无任何依赖，安装、集群几秒搞定；提供REST以及各种语言连接器，与众多第三方工具无缝集成；提供命令行程序，便于管理和即席查询；提供各种运维工具。
+- **[简单易用](https://www.taosdata.com/tdengine/ease_of_use)**：无任何依赖，安装、集群几秒搞定；提供REST以及各种语言连接器，与众多第三方工具无缝集成；提供命令行程序，便于管理和即席查询；提供各种运维工具。

- **核心开源**：TDengine 的核心代码包括集群功能全部开源，截止到2022年8月1日，全球超过 135.9k 个运行实例，GitHub Star 18.7k，Fork 4.4k，社区活跃。 
+- **[核心开源](https://www.taosdata.com/tdengine/open_source_time-series_database)**：TDengine 的核心代码包括集群功能全部开源，截止到2022年8月1日，全球超过 135.9k 个运行实例，GitHub Star 18.7k，Fork 4.4k，社区活跃。 

 采用 TDengine，可将典型的物联网、车联网、工业互联网大数据平台的总拥有成本大幅降低。表现在几个方面：

--- a/docs/zh/05-get-started/01-docker.md
+++ b/docs/zh/05-get-started/01-docker.md
@ -47,9 +47,7 @@ Docker version 20.10.3, build 48d30b5

 ## 运行 TDengine CLI

-有两种方式在 Docker 环境下使用 TDengine CLI (taos) 访问 TDengine. 
- 进入容器后，执行 taos 
- 在宿主机使用容器映射到主机的端口进行访问 `taos -h <hostname> -P <port>`
+进入容器，执行 taos 

 ```
 $ taos
@ -62,51 +60,11 @@ taos>

 ```

-## 访问 REST 接口
-
-taosAdapter 是 TDengine 中提供 REST 服务的组件。下面这条命令会在容器中同时启动 `taosd` 和 `taosadapter` 两个服务组件。默认 Docker 镜像同时启动 TDengine 后台服务 taosd 和 taosAdatper。
-
-```shell
-docker run -d --name tdengine -p 6041:6041 tdengine/tdengine
-```
-
-可以在宿主机使用 curl 通过 RESTful 端口访问 Docker 容器内的 TDengine server。
-
-```
-curl -L -u root:taosdata -d "show databases" 127.0.0.1:6041/rest/sql
-```
-
-输出示例如下：
-
-```
-{"code":0,"column_meta":[["name","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],["wal","TINYINT",1],["fsync","INT",4],["comp","TINYINT",1],["cacheModel","VARCHAR",11],["precision","VARCHAR",2],["single_stable","BOOL",1],["status","VARCHAR",10],["retention","VARCHAR",60]],"data":[["information_schema",null,null,14,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"ready"],["performance_schema",null,null,3,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"ready"]],"rows":2}
-```
-
-这条命令，通过 REST API 访问 TDengine server，这时连接的是从容器映射到主机的 6041 端口。
-
-TDengine REST API 详情请参考[官方文档](/reference/rest-api/)。
-
-## 单独启动 REST 服务
-
-如果想只启动 `taosadapter`：
-
-```bash
-docker run -d --network=host --name tdengine-taosa -e TAOS_FIRST_EP=tdengine-taosd tdengine/tdengine:3.0.0.0 taosadapter
-```
-
-只启动 `taosd`：
-
-```bash
-docker run -d --network=host --name tdengine-taosd -e TAOS_DISABLE_ADAPTER=true tdengine/tdengine:3.0.0.0
-```
-
-注意以上为容器使用 host 方式网络配置进行单独部署 taosAdapter 的命令行参数。其他网络访问方式请设置 hostname、 DNS 等必要的网络配置。
-
 ## 写入数据

 可以使用 TDengine 的自带工具 taosBenchmark 快速体验 TDengine 的写入。

-假定启动容器时已经将容器的6030端口映射到了宿主机的6030端口，则可以直接在宿主机命令行启动 taosBenchmark，也可以进入容器后执行：
+进入容器，启动 taosBenchmark：

   ```bash
   $ taosBenchmark
@ -121,7 +79,7 @@ docker run -d --network=host --name tdengine-taosd -e TAOS_DISABLE_ADAPTER=true

 ## 体验查询

-使用上述 taosBenchmark 插入数据后，可以在 TDengine CLI 输入查询命令，体验查询速度。可以直接在宿主机上也可以进入容器后运行。
+使用上述 taosBenchmark 插入数据后，可以在 TDengine CLI 输入查询命令，体验查询速度。。

 查询超级表下记录总条数：

@ -152,3 +110,7 @@ taos> select avg(current), max(voltage), min(phase) from test.meters where group
 ```sql
 taos> select avg(current), max(voltage), min(phase) from test.d10 interval(10s);
 ```
+
+## 其它
+
+更多关于在 Docker 环境下使用 TDengine 的细节，请参考 [在 Docker 下使用 TDengine](../../reference/docker)
--- a/docs/zh/05-get-started/03-package.md
+++ b/docs/zh/05-get-started/03-package.md
@ -11,7 +11,7 @@ import TabItem from "@theme/TabItem";

 :::

-TDengine 开源版本提供 deb 和 rpm 格式安装包，用户可以根据自己的运行环境选择合适的安装包。其中 deb 支持 Debian/Ubuntu 及衍生系统，rpm 支持 CentOS/RHEL/SUSE 及衍生系统。同时我们也为企业用户提供 tar.gz 格式安装包。也支持通过 `apt-get` 工具从线上进行安装。
+TDengine 开源版本提供 deb 和 rpm 格式安装包，用户可以根据自己的运行环境选择合适的安装包。其中 deb 支持 Debian/Ubuntu 及衍生系统，rpm 支持 CentOS/RHEL/SUSE 及衍生系统。同时我们也为企业用户提供 tar.gz 格式安装包，也支持通过 `apt-get` 工具从线上进行安装。

 ## 安装

--- a/docs/zh/07-develop/06-stream.md
+++ b/docs/zh/07-develop/06-stream.md
@ -1,84 +1,128 @@
 ---
-sidebar_label: 连续查询
-description: "连续查询是一个按照预设频率自动执行的查询功能，提供按照时间窗口的聚合查询能力，是一种简化的时间驱动流式计算。"
-title: "连续查询（Continuous Query）"
+sidebar_label: 流式计算
+description: "TDengine 流式计算将数据的写入、预处理、复杂分析、实时计算、报警触发等功能融为一体，是一个能够降低用户部署成本、存储成本和运维成本的计算引擎。"
+title: 流式计算
 ---

-连续查询是 TDengine 定期自动执行的查询，采用滑动窗口的方式进行计算，是一种简化的时间驱动的流式计算。针对库中的表或超级表，TDengine 可提供定期自动执行的连续查询，用户可让 TDengine 推送查询的结果，也可以将结果再写回到 TDengine 中。每次执行的查询是一个时间窗口，时间窗口随着时间流动向前滑动。在定义连续查询的时候需要指定时间窗口（time window, 参数 interval）大小和每次前向增量时间（forward sliding times, 参数 sliding）。
+在时序数据的处理中，经常要对原始数据进行清洗、预处理，再使用时序数据库进行长久的储存。用户通常需要在时序数据库之外再搭建 Kafka、Flink、Spark 等流计算处理引擎，增加了用户的开发成本和维护成本。
+使用 TDengine 3.0 的流式计算引擎能够最大限度的减少对这些额外中间件的依赖，真正将数据的写入、预处理、长期存储、复杂分析、实时计算、实时报警触发等功能融为一体，并且，所有这些任务只需要使用 SQL 完成，极大降低了用户的学习成本、使用成本。

-TDengine 的连续查询采用时间驱动模式，可以直接使用 TAOS SQL 进行定义，不需要额外的操作。使用连续查询，可以方便快捷地按照时间窗口生成结果，从而对原始采集数据进行降采样（down sampling）。用户通过 TAOS SQL 定义连续查询以后，TDengine 自动在最后的一个完整的时间周期末端拉起查询，并将计算获得的结果推送给用户或者写回 TDengine。
-
-TDengine 提供的连续查询与普通流计算中的时间窗口计算具有以下区别：
-
- 不同于流计算的实时反馈计算结果，连续查询只在时间窗口关闭以后才开始计算。例如时间周期是 1 天，那么当天的结果只会在 23:59:59 以后才会生成。
- 如果有历史记录写入到已经计算完成的时间区间，连续查询并不会重新进行计算，也不会重新将结果推送给用户。对于写回 TDengine 的模式，也不会更新已经存在的计算结果。
- 使用连续查询推送结果的模式，服务端并不缓存客户端计算状态，也不提供 Exactly-Once 的语义保证。如果用户的应用端崩溃，再次拉起的连续查询将只会从再次拉起的时间开始重新计算最近的一个完整的时间窗口。如果使用写回模式，TDengine 可确保数据写回的有效性和连续性。
-
-## 连续查询语法
+## 流式计算的创建

 ```sql
-[CREATE TABLE AS] SELECT select_expr [, select_expr ...]
-    FROM {tb_name_list}
-    [WHERE where_condition]
-    [INTERVAL(interval_val [, interval_offset]) [SLIDING sliding_val]]
-
+CREATE STREAM [IF NOT EXISTS] stream_name [stream_options] INTO stb_name AS subquery
+stream_options: {
+ TRIGGER    [AT_ONCE | WINDOW_CLOSE | MAX_DELAY time]
+ WATERMARK   time
+ IGNORE EXPIRED
+}
 ```

-INTERVAL: 连续查询作用的时间窗口
+详细的语法规则参考 [流式计算](../../taos-sql/stream)

-SLIDING: 连续查询的时间窗口向前滑动的时间间隔
+## 示例一

-## 使用连续查询
+企业电表的数据经常都是成百上千亿条的，那么想要将这些分散、凌乱的数据清洗或转换都需要比较长的时间，很难做到高效性和实时性，以下例子中，通过流计算可以将过去 12 小时电表电压大于 220V 的数据清洗掉，然后以小时为窗口整合并计算出每个窗口中电流的最大值，并将结果输出到指定的数据表中。

-下面以智能电表场景为例介绍连续查询的具体使用方法。假设我们通过下列 SQL 语句创建了超级表和子表：
+### 创建 DB 和原始数据表
+
+首先准备数据，完成建库、建一张超级表和多张子表操作

 ```sql
-create table meters (ts timestamp, current float, voltage int, phase float) tags (location binary(64), groupId int);
-create table D1001 using meters tags ("California.SanFrancisco", 2);
-create table D1002 using meters tags ("California.LosAngeles", 2);
-...
+drop database if exists stream_db;
+create database stream_db;
+
+create stable stream_db.meters (ts timestamp, current float, voltage int) TAGS (location varchar(64), groupId int);
+
+create table stream_db.d1001 using stream_db.meters tags("beijing", 1);
+create table stream_db.d1002 using stream_db.meters tags("guangzhou", 2);
+create table stream_db.d1003 using stream_db.meters tags("shanghai", 3);
 ```

-可以通过下面这条 SQL 语句以一分钟为时间窗口、30 秒为前向增量统计这些电表的平均电压。
+### 创建流

 ```sql
-select avg(voltage) from meters interval(1m) sliding(30s);
+create stream stream1 into stream_db.stream1_output_stb as select _wstart as start, _wend as end, max(current) as max_current from stream_db.meters where voltage <= 220 and ts > now - 12h interval (1h);
 ```

-每次执行这条语句，都会重新计算所有数据。 如果需要每隔 30 秒执行一次来增量计算最近一分钟的数据，可以把上面的语句改进成下面的样子，每次使用不同的 `startTime` 并定期执行：
+### 写入数据
+```sql
+insert into stream_db.d1001 values(now-14h, 10.3, 210);
+insert into stream_db.d1001 values(now-13h, 13.5, 216);
+insert into stream_db.d1001 values(now-12h, 12.5, 219);
+insert into stream_db.d1002 values(now-11h, 14.7, 221);
+insert into stream_db.d1002 values(now-10h, 10.5, 218);
+insert into stream_db.d1002 values(now-9h, 11.2, 220);
+insert into stream_db.d1003 values(now-8h, 11.5, 217);
+insert into stream_db.d1003 values(now-7h, 12.3, 227);
+insert into stream_db.d1003 values(now-6h, 12.3, 215);
+```
+
+### 查询以观查结果
+```sql
+taos> select * from stream_db.stream1_output_stb;
+          start          |           end           |     max_current      |       group_id        |
+===================================================================================================
+ 2022-08-09 14:00:00.000 | 2022-08-09 15:00:00.000 |             10.50000 |                     0 |
+ 2022-08-09 15:00:00.000 | 2022-08-09 16:00:00.000 |             11.20000 |                     0 |
+ 2022-08-09 16:00:00.000 | 2022-08-09 17:00:00.000 |             11.50000 |                     0 |
+ 2022-08-09 18:00:00.000 | 2022-08-09 19:00:00.000 |             12.30000 |                     0 |
+Query OK, 4 rows in database (0.012033s)
+```
+
+## 示例二
+某运营商平台要采集机房所有服务器的系统资源指标，包含 cpu、内存、网络延迟等，采集后需要对数据进行四舍五入运算，将地域和服务器名以下划线拼接，然后将结果按时间排序并以服务器名分组输出到新的数据表中。
+
+### 创建 DB 和原始数据表
+首先准备数据，完成建库、建一张超级表和多张子表操作

 ```sql
-select avg(voltage) from meters where ts > {startTime} interval(1m) sliding(30s);
+drop database if exists stream_db;
+create database stream_db;
+
+create stable stream_db.idc (ts timestamp, cpu float, mem float, latency float) TAGS (location varchar(64), groupId int);
+
+create table stream_db.server01 using stream_db.idc tags("beijing", 1);
+create table stream_db.server02 using stream_db.idc tags("shanghai", 2);
+create table stream_db.server03 using stream_db.idc tags("beijing", 2);
+create table stream_db.server04 using stream_db.idc tags("tianjin", 3);
+create table stream_db.server05 using stream_db.idc tags("shanghai", 1);
 ```

-这样做没有问题，但 TDengine 提供了更简单的方法，只要在最初的查询语句前面加上 `create table {tableName} as` 就可以了，例如：
+### 创建流

 ```sql
-create table avg_vol as select avg(voltage) from meters interval(1m) sliding(30s);
+create stream stream2 into stream_db.stream2_output_stb as select ts, concat_ws("_", location, tbname) as server_location, round(cpu) as cpu, round(mem) as mem, round(latency) as latency from stream_db.idc partition by tbname order by ts;
 ```

-会自动创建一个名为 `avg_vol` 的新表，然后每隔 30 秒，TDengine 会增量执行 `as` 后面的 SQL 语句，并将查询结果写入这个表中，用户程序后续只要从 `avg_vol` 中查询数据即可。例如：
-
+### 写入数据
 ```sql
-taos> select * from avg_vol;
-            ts           |        avg_voltage_    |
-===================================================
- 2020-07-29 13:37:30.000 |            222.0000000 |
- 2020-07-29 13:38:00.000 |            221.3500000 |
- 2020-07-29 13:38:30.000 |            220.1700000 |
- 2020-07-29 13:39:00.000 |            223.0800000 |
+insert into stream_db.server01 values(now-14h, 50.9, 654.8, 23.11);
+insert into stream_db.server01 values(now-13h, 13.5, 221.2, 11.22);
+insert into stream_db.server02 values(now-12h, 154.7, 218.3, 22.33);
+insert into stream_db.server02 values(now-11h, 120.5, 111.5, 5.55);
+insert into stream_db.server03 values(now-10h, 101.5, 125.6, 5.99);
+insert into stream_db.server03 values(now-9h, 12.3, 165.6, 6.02);
+insert into stream_db.server04 values(now-8h, 160.9, 120.7, 43.51);
+insert into stream_db.server04 values(now-7h, 240.9, 520.7, 54.55);
+insert into stream_db.server05 values(now-6h, 190.9, 320.7, 55.43);
+insert into stream_db.server05 values(now-5h, 110.9, 600.7, 35.54);
 ```
-
-需要注意，查询时间窗口的最小值是 10 毫秒，没有时间窗口范围的上限。
-
-此外，TDengine 还支持用户指定连续查询的起止时间。如果不输入开始时间，连续查询将从第一条原始数据所在的时间窗口开始；如果没有输入结束时间，连续查询将永久运行；如果用户指定了结束时间，连续查询在系统时间达到指定的时间以后停止运行。比如使用下面的 SQL 创建的连续查询将运行一小时，之后会自动停止。
-
+### 查询以观查结果
 ```sql
-create table avg_vol as select avg(voltage) from meters where ts > now and ts <= now + 1h interval(1m) sliding(30s);
+taos> select ts, server_location, cpu, mem, latency from stream_db.stream2_output_stb;
+           ts            |        server_location         |         cpu          |         mem          |       latency        |
+================================================================================================================================
+ 2022-08-09 21:24:56.785 | beijing_server01               |             51.00000 |            655.00000 |             23.00000 |
+ 2022-08-09 22:24:56.795 | beijing_server01               |             14.00000 |            221.00000 |             11.00000 |
+ 2022-08-09 23:24:56.806 | shanghai_server02              |            155.00000 |            218.00000 |             22.00000 |
+ 2022-08-10 00:24:56.815 | shanghai_server02              |            121.00000 |            112.00000 |              6.00000 |
+ 2022-08-10 01:24:56.826 | beijing_server03               |            102.00000 |            126.00000 |              6.00000 |
+ 2022-08-10 02:24:56.838 | beijing_server03               |             12.00000 |            166.00000 |              6.00000 |
+ 2022-08-10 03:24:56.846 | tianjin_server04               |            161.00000 |            121.00000 |             44.00000 |
+ 2022-08-10 04:24:56.853 | tianjin_server04               |            241.00000 |            521.00000 |             55.00000 |
+ 2022-08-10 05:24:56.866 | shanghai_server05              |            191.00000 |            321.00000 |             55.00000 |
+ 2022-08-10 06:24:57.301 | shanghai_server05              |            111.00000 |            601.00000 |             36.00000 |
+Query OK, 10 rows in database (0.022950s)
 ```

-需要说明的是，上面例子中的 `now` 是指创建连续查询的时间，而不是查询执行的时间，否则，查询就无法自动停止了。另外，为了尽量避免原始数据延迟写入导致的问题，TDengine 中连续查询的计算有一定的延迟。也就是说，一个时间窗口过去后，TDengine 并不会立即计算这个窗口的数据，所以要稍等一会（一般不会超过 1 分钟）才能查到计算结果。
-
-## 管理连续查询
-
-用户可在控制台中通过 `show streams` 命令来查看系统中全部运行的连续查询，并可以通过 `kill stream` 命令杀掉对应的连续查询。后续版本会提供更细粒度和便捷的连续查询管理命令。
--- a/docs/zh/12-taos-sql/02-database.md
+++ b/docs/zh/12-taos-sql/02-database.md
@ -112,9 +112,9 @@ alter_database_options:
 alter_database_option: {
    CACHEMODEL {'none' | 'last_row' | 'last_value' | 'both'}
  | CACHESIZE value
-  | FSYNC value
+  | WAL_LEVEL value
+  | WAL_FSYNC_PERIOD value
  | KEEP value
-  | WAL value
 }
 ```

--- a/docs/zh/12-taos-sql/06-select.md
+++ b/docs/zh/12-taos-sql/06-select.md
@ -140,10 +140,6 @@ taos> SELECT ts, ts AS primary_key_ts FROM d1001;

 但是针对`first(*)`、`last(*)`、`last_row(*)`不支持针对单列的重命名。

-### 隐式结果列
-
-`Select_exprs`可以是表所属列的列名，也可以是基于列的函数表达式或计算式，数量的上限 256 个。当用户使用了`interval`或`group by tags`的子句以后，在最后返回结果中会强制返回时间戳列（第一列）和 group by 子句中的标签列。后续的版本中可以支持关闭 group by 子句中隐式列的输出，列输出完全由 select 子句控制。
-
 ### 伪列

 **TBNAME**
@ -152,7 +148,13 @@ taos> SELECT ts, ts AS primary_key_ts FROM d1001;
 获取一个超级表所有的子表名及相关的标签信息：

 ```mysql
-SELECT TBNAME, location FROM meters;
+SELECT DISTINCT TBNAME, location FROM meters;
+```
+
+建议用户使用 INFORMATION_SCHEMA 下的 INS_TAGS 系统表来查询超级表的子表标签信息，例如获取超级表 meters 所有的子表名和标签值：
+
+```mysql
+SELECT table_name, tag_name, tag_type, tag_value FROM information_schema.ins_tags WHERE stable_name='meters';
 ```

 统计超级表下辖子表数量：
--- a/docs/zh/12-taos-sql/23-perf.md
+++ b/docs/zh/12-taos-sql/23-perf.md
@ -95,15 +95,15 @@ TDengine 3.0 版本开始提供一个内置数据库 `performance_schema`，其
 ## PERF_TRANS

 | #   |     **列名**     | **数据类型** | **说明**                                                       |
-| --- | :--------------: | ------------ | -------- |
-| 1   |        id        | INT          |          |
-| 2   |   create_time    | TIMESTAMP    |          |
-| 3   |      stage       | BINARY(12)   |          |
-| 4   |       db1        | BINARY(64)   |          |
-| 5   |       db2        | BINARY(64)   |          |
-| 6   |   failed_times   | INT          |          |
-| 7   |  last_exec_time  | TIMESTAMP    |          |
-| 8   | last_action_info | BINARY(511)  |          |
+| --- | :--------------: | ------------ | -------------------------------------------------------------- |
+| 1   |        id        | INT          | 正在进行的事务的编号                                           |
+| 2   |   create_time    | TIMESTAMP    | 事务的创建时间                                                 |
+| 3   |      stage       | BINARY(12)   | 事务的当前阶段，通常为 redoAction、undoAction、commit 三个阶段 |
+| 4   |       db1        | BINARY(64)   | 与此事务存在冲突的数据库一的名称                               |
+| 5   |       db2        | BINARY(64)   | 与此事务存在冲突的数据库二的名称                               |
+| 6   |   failed_times   | INT          | 事务执行失败的总次数                                           |
+| 7   |  last_exec_time  | TIMESTAMP    | 事务上次执行的时间                                             |
+| 8   | last_action_info | BINARY(511)  | 事务上次执行失败的明细信息                                     |

 ## PERF_SMAS

--- a/docs/zh/14-reference/03-connector/03-connector.mdx
+++ b/docs/zh/14-reference/03-connector/03-connector.mdx
@ -17,7 +17,6 @@ TDengine 提供了丰富的应用程序开发接口，为了便于用户快速
 | **X86 64bit**  | **Win32** | ●        | ●          | ●      | ●           | ○      | ○        | ●     |
 | **X86 32bit**  | **Win32** | ○        | ○          | ○      | ○           | ○      | ○        | ●     |
 | **ARM64**      | **Linux** | ●        | ●          | ●      | ●           | ○      | ○        | ●     |
-| **ARM32**      | **Linux** | ○        | ○          | ○      | ○           | ○      | ○        | ●     |
 | **MIPS 龙芯**  | **Linux** | ○        | ○          | ○      | ○           | ○      | ○        | ○     |
 | **Alpha 申威** | **Linux** | ○        | ○          | --     | --          | --     | --       | ○     |
 | **X86 海光**   | **Linux** | ○        | ○          | ○      | --          | --     | --       | ○     |
--- a/docs/zh/14-reference/09-support-platform/index.md
+++ b/docs/zh/14-reference/09-support-platform/index.md
@ -19,15 +19,15 @@ description: "TDengine 服务端、客户端和连接器支持的平台列表"

 对照矩阵如下：

-| **CPU**     | **X64 64bit** |           |           | **X86 32bit** | **ARM64** | **ARM32** | **MIPS 龙芯** | **Alpha 申威** | **X64 海光** |
-| ----------- | ------------- | --------- | --------- | ------------- | --------- | --------- | ------------- | -------------- | ------------ |
-| **OS**      | **Linux**     | **Win64** | **Win32** | **Win32**     | **Linux** | **Linux** | **Linux**     | **Linux**      | **Linux**    |
-| **C/C++**   | ●             | ●         | ●         | ○             | ●         | ●         | ●             | ●              | ●            |
-| **JDBC**    | ●             | ●         | ●         | ○             | ●         | ●         | ●             | ●              | ●            |
-| **Python**  | ●             | ●         | ●         | ○             | ●         | ●         | ●             | --             | ●            |
-| **Go**      | ●             | ●         | ●         | ○             | ●         | ●         | ○             | --             | --           |
-| **NodeJs**  | ●             | ●         | ○         | ○             | ●         | ●         | ○             | --             | --           |
-| **C#**      | ●             | ●         | ○         | ○             | ○         | ○         | ○             | --             | --           |
-| **RESTful** | ●             | ●         | ●         | ●             | ●         | ●         | ●             | ●              | ●            |
+| **CPU**     | **X64 64bit** |           |           | **X86 32bit** | **ARM64** | **MIPS 龙芯** | **Alpha 申威** | **X64 海光** |
+| ----------- | ------------- | --------- | --------- | ------------- | --------- | ------------- | -------------- | ------------ |
+| **OS**      | **Linux**     | **Win64** | **Win32** | **Win32**     | **Linux** | **Linux**     | **Linux**      | **Linux**    |
+| **C/C++**   | ●             | ●         | ●         | ○             | ●         | ●             | ●              | ●            |
+| **JDBC**    | ●             | ●         | ●         | ○             | ●         | ●             | ●              | ●            |
+| **Python**  | ●             | ●         | ●         | ○             | ●         | ●             | --             | ●            |
+| **Go**      | ●             | ●         | ●         | ○             | ●         | ○             | --             | --           |
+| **NodeJs**  | ●             | ●         | ○         | ○             | ●         | ○             | --             | --           |
+| **C#**      | ●             | ●         | ○         | ○             | ○         | ○             | --             | --           |
+| **RESTful** | ●             | ●         | ●         | ●             | ●         | ●             | ●              | ●            |

 注：● 表示官方测试验证通过，○ 表示非官方测试验证通过，-- 表示未经验证。
--- a/docs/zh/14-reference/13-schemaless/13-schemaless.md
+++ b/docs/zh/14-reference/13-schemaless/13-schemaless.md
@ -3,8 +3,7 @@ title: Schemaless 写入
 description: 'Schemaless 写入方式，可以免于预先创建超级表/子表的步骤，随着数据写入接口能够自动创建与数据对应的存储结构'
 ---

-在物联网应用中，常会采集比较多的数据项，用于实现智能控制、业务分析、设备监控等。由于应用逻辑的版本升级，或者设备自身的硬件调整等原因，数据采集项就有可能比较频繁地出现变动。为了在这种情况下方便地完成数据记录工作，TDengine
-从 2.2.0.0 版本开始，提供调用 Schemaless 写入方式，可以免于预先创建超级表/子表的步骤，随着数据写入接口能够自动创建与数据对应的存储结构。并且在必要时，Schemaless
+在物联网应用中，常会采集比较多的数据项，用于实现智能控制、业务分析、设备监控等。由于应用逻辑的版本升级，或者设备自身的硬件调整等原因，数据采集项就有可能比较频繁地出现变动。为了在这种情况下方便地完成数据记录工作，TDengine提供调用 Schemaless 写入方式，可以免于预先创建超级表/子表的步骤，随着数据写入接口能够自动创建与数据对应的存储结构。并且在必要时，Schemaless
 将自动增加必要的数据列，保证用户写入的数据可以被正确存储。

 无模式写入方式建立的超级表及其对应的子表与通过 SQL 直接建立的超级表和子表完全没有区别，你也可以通过，SQL 语句直接向其中写入数据。需要注意的是，通过无模式写入方式建立的表，其表名是基于标签值按照固定的映射规则生成，所以无法明确地进行表意，缺乏可读性。
@ -41,10 +40,10 @@ tag_set 中的所有的数据自动转化为 nchar 数据类型，并不需要
 | -------- | -------- | ------------ | -------------- |
 | 1        | 无或 f64 | double       | 8              |
 | 2        | f32      | float        | 4              |
-| 3        | i8       | TinyInt      | 1              |
-| 4        | i16      | SmallInt     | 2              |
-| 5        | i32      | Int          | 4              |
-| 6        | i64 或 i | Bigint       | 8              |
+| 3        | i8/u8       | TinyInt/UTinyInt      | 1              |
+| 4        | i16/u16      | SmallInt/USmallInt     | 2              |
+| 5        | i32/u32      | Int/UInt          | 4              |
+| 6        | i64/i/u64/u  | BigInt/BigInt/UBigInt/UBigInt       | 8              |

 - t, T, true, True, TRUE, f, F, false, False 将直接作为 BOOL 型来处理。

@ -69,20 +68,21 @@ st,t1=3,t2=4,t3=t3 c1=3i64,c3="passit",c2=false,c4=4f64 1626006833639000000
 ```

 需要注意的是，这里的 tag_key1, tag_key2 并不是用户输入的标签的原始顺序，而是使用了标签名称按照字符串升序排列后的结果。所以，tag_key1 并不是在行协议中输入的第一个标签。
-排列完成以后计算该字符串的 MD5 散列值 "md5_val"。然后将计算的结果与字符串组合生成表名：“t_md5_val”。其中的 “t\*” 是固定的前缀，每个通过该映射关系自动生成的表都具有该前缀。
+排列完成以后计算该字符串的 MD5 散列值 "md5_val"。然后将计算的结果与字符串组合生成表名：“t_md5_val”。其中的 “t_” 是固定的前缀，每个通过该映射关系自动生成的表都具有该前缀。
+为了让用户可以指定生成的表名，可以通过配置smlChildTableName来指定（比如 配置smlChildTableName=tname    插入数据为st,tname=cpu1,t1=4 c1=3 1626006833639000000   则创建的表名为cpu1，注意如果多行数据tname相同，但是后面的tag_set不同，则使用第一次自动建表时指定的tag_set，其他的会忽略）。

-2. 如果解析行协议获得的超级表不存在，则会创建这个超级表。
+2. 如果解析行协议获得的超级表不存在，则会创建这个超级表（不建议手动创建超级表，不然插入数据可能异常）。
 3. 如果解析行协议获得子表不存在，则 Schemaless 会按照步骤 1 或 2 确定的子表名来创建子表。
 4. 如果数据行中指定的标签列或普通列不存在，则在超级表中增加对应的标签列或普通列（只增不减）。
 5. 如果超级表中存在一些标签列或普通列未在一个数据行中被指定取值，那么这些列的值在这一行中会被置为
   NULL。
 6. 对 BINARY 或 NCHAR 列，如果数据行中所提供值的长度超出了列类型的限制，自动增加该列允许存储的字符长度上限（只增不减），以保证数据的完整保存。
-7. 如果指定的数据子表已经存在，而且本次指定的标签列取值跟已保存的值不一样，那么最新的数据行中的值会覆盖旧的标签列取值。
-8. 整个处理过程中遇到的错误会中断写入过程，并返回错误代码。
+7. 整个处理过程中遇到的错误会中断写入过程，并返回错误代码。
+8. 为了提高写入的效率，默认假设同一个超级表中field_set的顺序是一样的（第一条数据包含所有的field，后面的数据按照这个顺序），如果顺序不一样，需要配置参数smlDataFormat为false，否则，数据写入按照相同顺序写入，库中数据会异常。

 :::tip
 无模式所有的处理逻辑，仍会遵循 TDengine 对数据结构的底层限制，例如每行数据的总长度不能超过
-48KB。这方面的具体限制约束请参见 [TAOS SQL 边界限制](/taos-sql/limit)
+16KB。这方面的具体限制约束请参见 [TAOS SQL 边界限制](/taos-sql/limit)

 :::

--- a/docs/zh/eco_system.webp
+++ b/docs/zh/eco_system.webp
--- a/packaging/tools/install.sh
+++ b/packaging/tools/install.sh
@ -194,6 +194,9 @@ function install_bin() {
  ${csudo}rm -f ${bin_link_dir}/${serverName} || :
  ${csudo}rm -f ${bin_link_dir}/${adapterName} || :
  ${csudo}rm -f ${bin_link_dir}/${uninstallScript} || :
+  ${csudo}rm -f ${bin_link_dir}/${demoName} || :
+  ${csudo}rm -f ${bin_link_dir}/${benchmarkName} || :
+  ${csudo}rm -f ${bin_link_dir}/${dumpName} || :
  ${csudo}rm -f ${bin_link_dir}/set_core || :
  ${csudo}rm -f ${bin_link_dir}/TDinsight.sh || :

@ -205,7 +208,6 @@ function install_bin() {
  [ -x ${install_main_dir}/bin/${adapterName} ] && ${csudo}ln -s ${install_main_dir}/bin/${adapterName} ${bin_link_dir}/${adapterName} || :
  [ -x ${install_main_dir}/bin/${benchmarkName} ] && ${csudo}ln -s ${install_main_dir}/bin/${benchmarkName} ${bin_link_dir}/${demoName} || :
  [ -x ${install_main_dir}/bin/${benchmarkName} ] && ${csudo}ln -s ${install_main_dir}/bin/${benchmarkName} ${bin_link_dir}/${benchmarkName} || :
-  [ -x ${install_main_dir}/bin/${tmqName} ] && ${csudo}ln -s ${install_main_dir}/bin/${tmqName} ${bin_link_dir}/${tmqName} || :
  [ -x ${install_main_dir}/bin/${dumpName} ] && ${csudo}ln -s ${install_main_dir}/bin/${dumpName} ${bin_link_dir}/${dumpName} || :
  [ -x ${install_main_dir}/bin/TDinsight.sh ] && ${csudo}ln -s ${install_main_dir}/bin/TDinsight.sh ${bin_link_dir}/TDinsight.sh || :
  [ -x ${install_main_dir}/bin/remove.sh ] && ${csudo}ln -s ${install_main_dir}/bin/remove.sh ${bin_link_dir}/${uninstallScript} || :
@ -964,6 +966,10 @@ function installProduct() {
 ## ==============================Main program starts from here============================
 serverFqdn=$(hostname)
 if [ "$verType" == "server" ]; then
+  # Check default 2.x data file.
+  if [ -x ${data_dir}/dnode/dnodeCfg.json ]; then
+    echo -e "\033[44;31;5mThe default data directory ${data_dir} contains old data of tdengine 2.x, please clear it before installing!\033[0m"
+  else
    # Install server and client
    if [ -x ${bin_dir}/${serverName} ]; then
      update_flag=1
@ -971,6 +977,7 @@ if [ "$verType" == "server" ]; then
    else
      installProduct
    fi
+  fi
 elif [ "$verType" == "client" ]; then
  interactiveFqdn=no
  # Only install client
--- a/source/common/CMakeLists.txt
+++ b/source/common/CMakeLists.txt
@ -5,6 +5,10 @@ if (DEFINED GRANT_CFG_INCLUDE_DIR)
  add_definitions(-DGRANTS_CFG)
 endif()

+IF (TD_GRANT)
+  ADD_DEFINITIONS(-D_GRANT)
+ENDIF ()
+
 target_include_directories(
    common
    PUBLIC "${TD_SOURCE_DIR}/include/common"
--- a/source/common/src/tglobal.c
+++ b/source/common/src/tglobal.c
@ -405,9 +405,8 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
  tsNumOfVnodeWriteThreads = TMAX(tsNumOfVnodeWriteThreads, 1);
  if (cfgAddInt32(pCfg, "numOfVnodeWriteThreads", tsNumOfVnodeWriteThreads, 1, 1024, 0) != 0) return -1;

-  // tsNumOfVnodeSyncThreads = tsNumOfCores;
-  tsNumOfVnodeSyncThreads = 32;
-  tsNumOfVnodeSyncThreads = TMAX(tsNumOfVnodeSyncThreads, 1);
+  tsNumOfVnodeSyncThreads = tsNumOfCores * 2;
+  tsNumOfVnodeSyncThreads = TMAX(tsNumOfVnodeSyncThreads, 16);
  if (cfgAddInt32(pCfg, "numOfVnodeSyncThreads", tsNumOfVnodeSyncThreads, 1, 1024, 0) != 0) return -1;

  tsNumOfQnodeQueryThreads = tsNumOfCores * 2;
--- a/source/dnode/mgmt/node_mgmt/src/dmEnv.c
+++ b/source/dnode/mgmt/node_mgmt/src/dmEnv.c
@ -53,14 +53,27 @@ static bool dmCheckDiskSpace() {
  osUpdate();
  if (!osDataSpaceAvailable()) {
    dError("free disk size: %f GB, too little, require %f GB at least at least , quit", (double)tsDataSpace.size.avail / 1024.0 / 1024.0 / 1024.0, (double)tsDataSpace.reserved / 1024.0 / 1024.0 / 1024.0);
+    terrno = TSDB_CODE_NO_AVAIL_DISK;
    return false;
  }
  if (!osLogSpaceAvailable()) {
    dError("free disk size: %f GB, too little, require %f GB at least at least, quit", (double)tsLogSpace.size.avail / 1024.0 / 1024.0 / 1024.0, (double)tsLogSpace.reserved / 1024.0 / 1024.0 / 1024.0);
+    terrno = TSDB_CODE_NO_AVAIL_DISK;
    return false;
  }
  if (!osTempSpaceAvailable()) {
    dError("free disk size: %f GB, too little, require %f GB at least at least, quit", (double)tsTempSpace.size.avail / 1024.0 / 1024.0 / 1024.0, (double)tsTempSpace.reserved / 1024.0 / 1024.0 / 1024.0);
+    terrno = TSDB_CODE_NO_AVAIL_DISK;
+    return false;
+  }
+  return true;
+}
+
+static bool dmCheckDataDirVersion() {
+  char checkDataDirJsonFileName[PATH_MAX];
+  snprintf(checkDataDirJsonFileName, PATH_MAX, "%s/dnode/dnodeCfg.json", tsDataDir);
+  if (taosCheckExistFile(checkDataDirJsonFileName)) {
+    dError("The default data directory %s contains old data of tdengine 2.x, please clear it before running!", tsDataDir);
    return false;
  }
  return true;
@ -68,6 +81,7 @@ static bool dmCheckDiskSpace() {

 int32_t dmInit(int8_t rtype) {
  dInfo("start to init dnode env");
+  if (!dmCheckDataDirVersion()) return -1;
  if (!dmCheckDiskSpace()) return -1;
  if (dmCheckRepeatInit(dmInstance()) != 0) return -1;
  if (dmInitSystem() != 0) return -1;
--- a/source/dnode/mnode/impl/CMakeLists.txt
+++ b/source/dnode/mnode/impl/CMakeLists.txt
@ -15,6 +15,7 @@ target_include_directories(
 target_link_libraries(
    mnode scheduler sdb wal transport cjson sync monitor executor qworker stream parser
 )
+
 IF (TD_GRANT)
  TARGET_LINK_LIBRARIES(mnode grant)
  ADD_DEFINITIONS(-D_GRANT)
--- a/source/dnode/mnode/impl/src/mndDb.c
+++ b/source/dnode/mnode/impl/src/mndDb.c
@ -1419,7 +1419,7 @@ const char *mndGetDbStr(const char *src) {
  return pos;
 }

-int64_t getValOfDiffPrecision(int8_t unit, int64_t val) {
+static int64_t getValOfDiffPrecision(int8_t unit, int64_t val) {
  int64_t v = 0;
  switch (unit) {
    case 's':
@ -1444,7 +1444,7 @@ int64_t getValOfDiffPrecision(int8_t unit, int64_t val) {
  return v;
 }

-char *buildRetension(SArray *pRetension) {
+static char *buildRetension(SArray *pRetension) {
  size_t size = taosArrayGetSize(pRetension);
  if (size == 0) {
    return NULL;
--- a/source/dnode/vnode/CMakeLists.txt
+++ b/source/dnode/vnode/CMakeLists.txt
@ -86,6 +86,11 @@ target_link_libraries(
    PUBLIC stream
    PUBLIC index
 )
+
+IF (TD_GRANT)
+  TARGET_LINK_LIBRARIES(vnode PUBLIC grant)
+ENDIF ()
+
 target_compile_definitions(vnode PUBLIC -DMETA_REFACT)

 if(${BUILD_WITH_INVERTEDINDEX})
--- a/source/dnode/vnode/src/meta/metaTable.c
+++ b/source/dnode/vnode/src/meta/metaTable.c
@ -209,8 +209,8 @@ int metaCreateSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
  return 0;

 _err:
-  metaError("vgId:%d, failed to create stb:%s uid:%" PRId64 " since %s", TD_VID(pMeta->pVnode), pReq->name,
-            pReq->suid, tstrerror(terrno));
+  metaError("vgId:%d, failed to create stb:%s uid:%" PRId64 " since %s", TD_VID(pMeta->pVnode), pReq->name, pReq->suid,
+            tstrerror(terrno));
  return -1;
 }

@ -304,7 +304,8 @@ int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {

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

@ -1196,6 +1197,9 @@ static int metaSaveToSkmDb(SMeta *pMeta, const SMetaEntry *pME) {
    goto _exit;
  }

+  metaDebug("vgId:%d, set schema:(%" PRId64 ") sver:%d since %s", TD_VID(pMeta->pVnode), pME->uid, pSW->version,
+            tstrerror(terrno));
+
 _exit:
  taosMemoryFree(pVal);
  tEncoderClear(&coder);
--- a/source/dnode/vnode/src/tsdb/tsdbRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbRead.c
@ -13,8 +13,8 @@
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

-#include "tsdb.h"
 #include "osDef.h"
+#include "tsdb.h"
 #define ASCENDING_TRAVERSE(o) (o == TSDB_ORDER_ASC)

 typedef enum {
@ -1213,8 +1213,8 @@ static int32_t buildDataBlockFromBuf(STsdbReader* pReader, STableBlockScanInfo*
  return code;
 }

-static bool tryCopyDistinctRowFromFileBlock(STsdbReader* pReader, SBlockData* pBlockData, int64_t key, SFileBlockDumpInfo* pDumpInfo) {
-
+static bool tryCopyDistinctRowFromFileBlock(STsdbReader* pReader, SBlockData* pBlockData, int64_t key,
+                                            SFileBlockDumpInfo* pDumpInfo) {
  // opt version
  // 1. it is not a border point
  // 2. the direct next point is not an duplicated timestamp
@ -1239,7 +1239,7 @@ static FORCE_INLINE STSchema* doGetSchemaForTSRow(int32_t sversion, STsdbReader*
    pReader->pSchema = metaGetTbTSchema(pReader->pTsdb->pVnode->pMeta, uid, -1);
  }

-  if (sversion == pReader->pSchema->version) {
+  if (pReader->pSchema && sversion == pReader->pSchema->version) {
    return pReader->pSchema;
  }

@ -1547,6 +1547,8 @@ static int32_t buildComposedDataBlock(STsdbReader* pReader, STableBlockScanInfo*
  SBlockData*         pBlockData = &pReader->status.fileBlockData;
  int32_t             step = ASCENDING_TRAVERSE(pReader->order) ? 1 : -1;

+  int32_t numOfSub = 1;
+
  int64_t st = taosGetTimestampUs();

  while (1) {
@ -1556,6 +1558,8 @@ static int32_t buildComposedDataBlock(STsdbReader* pReader, STableBlockScanInfo*
        pDumpInfo->rowIndex += step;

        SBlock* pBlock = getCurrentBlock(&pReader->status.blockIter);
+        numOfSub = pBlock->nSubBlock;
+
        if (pDumpInfo->rowIndex >= pBlock->nRow || pDumpInfo->rowIndex < 0) {
          setBlockAllDumped(pDumpInfo, pBlock, pReader->order);
          break;
@ -1585,9 +1589,9 @@ static int32_t buildComposedDataBlock(STsdbReader* pReader, STableBlockScanInfo*
  setComposedBlockFlag(pReader, true);
  int64_t et = taosGetTimestampUs();

-  tsdbDebug("%p uid:%" PRIu64 ", composed data block created, brange:%" PRIu64 "-%" PRIu64
+  tsdbDebug("%p uid:%" PRIu64 ", composed data block created, subBlock:%d, brange:%" PRIu64 "-%" PRIu64
            " rows:%d, elapsed time:%.2f ms %s",
-            pReader, pBlockScanInfo->uid, pResBlock->info.window.skey, pResBlock->info.window.ekey,
+            pReader, pBlockScanInfo->uid, numOfSub, pResBlock->info.window.skey, pResBlock->info.window.ekey,
            pResBlock->info.rows, (et - st) / 1000.0, pReader->idStr);

  return TSDB_CODE_SUCCESS;
@ -2182,7 +2186,6 @@ TSDBROW* getValidRow(SIterInfo* pIter, const SArray* pDelList, STsdbReader* pRea
  }
 }

-
 int32_t doMergeRowsInBuf(SIterInfo* pIter, uint64_t uid, int64_t ts, SArray* pDelList, SRowMerger* pMerger,
                         STsdbReader* pReader) {
  while (1) {
@ -2314,7 +2317,6 @@ int32_t doMergeRowsInFileBlocks(SBlockData* pBlockData, STableBlockScanInfo* pSc

 void doMergeMultiRows(TSDBROW* pRow, uint64_t uid, SIterInfo* pIter, SArray* pDelList, STSRow** pTSRow,
                      STsdbReader* pReader, bool* freeTSRow) {
-
  TSDBROW* pNextRow = NULL;
  TSDBROW  current = *pRow;

@ -2346,6 +2348,10 @@ void doMergeMultiRows(TSDBROW* pRow, uint64_t uid, SIterInfo* pIter, SArray* pDe
  // get the correct schema for data in memory
  STSchema* pTSchema = doGetSchemaForTSRow(TSDBROW_SVERSION(&current), pReader, uid);

+  if (pReader->pSchema == NULL) {
+    pReader->pSchema = pTSchema;
+  }
+
  tRowMergerInit2(&merge, pReader->pSchema, &current, pTSchema);

  STSchema* pTSchema1 = doGetSchemaForTSRow(TSDBROW_SVERSION(pNextRow), pReader, uid);
@ -2386,8 +2392,8 @@ void doMergeMemIMemRows(TSDBROW* pRow, TSDBROW* piRow, STableBlockScanInfo* pBlo
  tRowMergerGetRow(&merge, pTSRow);
 }

-int32_t tsdbGetNextRowInMem(STableBlockScanInfo* pBlockScanInfo, STsdbReader* pReader, STSRow** pTSRow,
-                            int64_t endKey, bool* freeTSRow) {
+int32_t tsdbGetNextRowInMem(STableBlockScanInfo* pBlockScanInfo, STsdbReader* pReader, STSRow** pTSRow, int64_t endKey,
+                            bool* freeTSRow) {
  TSDBROW* pRow = getValidRow(&pBlockScanInfo->iter, pBlockScanInfo->delSkyline, pReader);
  TSDBROW* piRow = getValidRow(&pBlockScanInfo->iiter, pBlockScanInfo->delSkyline, pReader);
  SArray*  pDelList = pBlockScanInfo->delSkyline;
@ -2577,9 +2583,7 @@ void* tsdbGetIvtIdx(SMeta* pMeta) {
  return metaGetIvtIdx(pMeta);
 }

-uint64_t getReaderMaxVersion(STsdbReader *pReader) {
-  return pReader->verRange.maxVer;
-}
+uint64_t getReaderMaxVersion(STsdbReader* pReader) { return pReader->verRange.maxVer; }

 /**
 * @brief Get all suids since suid
@ -2757,7 +2761,8 @@ void tsdbReaderClose(STsdbReader* pReader) {
  SIOCostSummary* pCost = &pReader->cost;

  tsdbDebug("%p :io-cost summary: head-file:%" PRIu64 ", head-file time:%.2f ms, SMA:%" PRId64
-            " SMA-time:%.2f ms, fileBlocks:%" PRId64 ", fileBlocks-time:%.2f ms, "
+            " SMA-time:%.2f ms, fileBlocks:%" PRId64
+            ", fileBlocks-time:%.2f ms, "
            "build in-memory-block-time:%.2f ms, STableBlockScanInfo size:%.2f Kb %s",
            pReader, pCost->headFileLoad, pCost->headFileLoadTime, pCost->smaData, pCost->smaLoadTime,
            pCost->numOfBlocks, pCost->blockLoadTime, pCost->buildmemBlock,
@ -2765,7 +2770,9 @@ void tsdbReaderClose(STsdbReader* pReader) {

  taosMemoryFree(pReader->idStr);
  taosMemoryFree(pReader->pSchema);
+  if (pReader->pMemSchema != pReader->pSchema) {
    taosMemoryFree(pReader->pMemSchema);
+  }
  taosMemoryFreeClear(pReader);
 }

--- a/source/libs/executor/inc/executorimpl.h
+++ b/source/libs/executor/inc/executorimpl.h
@ -675,6 +675,7 @@ typedef struct SWindowRowsSup {
  TSKEY       prevTs;
  int32_t     startRowIndex;
  int32_t     numOfRows;
+  uint64_t    groupId;
 } SWindowRowsSup;

 typedef struct SSessionAggOperatorInfo {
@ -694,6 +695,7 @@ typedef struct SSessionAggOperatorInfo {
 typedef struct SResultWindowInfo {
  SResultRowPosition pos;
  STimeWindow win;
+  uint64_t groupId;
  bool isOutput;
  bool isClosed;
 } SResultWindowInfo;
@ -1008,8 +1010,6 @@ SResultWindowInfo* getSessionTimeWindow(SStreamAggSupporter* pAggSup, TSKEY star
 SResultWindowInfo* getCurSessionWindow(SStreamAggSupporter* pAggSup, TSKEY startTs,
    TSKEY endTs, uint64_t groupId, int64_t gap, int32_t* pIndex);
 bool isInTimeWindow(STimeWindow* pWin, TSKEY ts, int64_t gap);
-int32_t updateSessionWindowInfo(SResultWindowInfo* pWinInfo, TSKEY* pStartTs,
-    TSKEY* pEndTs, int32_t rows, int32_t start, int64_t gap, SHashObj* pStDeleted);
 bool functionNeedToExecute(SqlFunctionCtx* pCtx);
 bool isOverdue(TSKEY ts, STimeWindowAggSupp* pSup);
 bool isCloseWindow(STimeWindow* pWin, STimeWindowAggSupp* pSup);
--- a/source/libs/executor/src/timewindowoperator.c
+++ b/source/libs/executor/src/timewindowoperator.c
@ -90,16 +90,18 @@ static void updateTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pWin, b
  ts[4] = pWin->ekey + delta;  // window end key
 }

-static void doKeepTuple(SWindowRowsSup* pRowSup, int64_t ts) {
+static void doKeepTuple(SWindowRowsSup* pRowSup, int64_t ts, uint64_t groupId) {
  pRowSup->win.ekey = ts;
  pRowSup->prevTs = ts;
  pRowSup->numOfRows += 1;
+  pRowSup->groupId = groupId;
 }

-static void doKeepNewWindowStartInfo(SWindowRowsSup* pRowSup, const int64_t* tsList, int32_t rowIndex) {
+static void doKeepNewWindowStartInfo(SWindowRowsSup* pRowSup, const int64_t* tsList, int32_t rowIndex, uint64_t groupId) {
  pRowSup->startRowIndex = rowIndex;
  pRowSup->numOfRows = 0;
  pRowSup->win.skey = tsList[rowIndex];
+  pRowSup->groupId = groupId;
 }

 static FORCE_INLINE int32_t getForwardStepsInBlock(int32_t numOfRows, __block_search_fn_t searchFn, TSKEY ekey,
@ -1156,7 +1158,7 @@ static void doStateWindowAggImpl(SOperatorInfo* pOperator, SStateWindowOperatorI

    char* val = colDataGetData(pStateColInfoData, j);

-    if (!pInfo->hasKey) {
+    if (gid != pRowSup->groupId || !pInfo->hasKey) {
      // todo extract method
      if (IS_VAR_DATA_TYPE(pInfo->stateKey.type)) {
        varDataCopy(pInfo->stateKey.pData, val);
@ -1166,10 +1168,10 @@ static void doStateWindowAggImpl(SOperatorInfo* pOperator, SStateWindowOperatorI

      pInfo->hasKey = true;

-      doKeepNewWindowStartInfo(pRowSup, tsList, j);
-      doKeepTuple(pRowSup, tsList[j]);
+      doKeepNewWindowStartInfo(pRowSup, tsList, j, gid);
+      doKeepTuple(pRowSup, tsList[j], gid);
    } else if (compareVal(val, &pInfo->stateKey)) {
-      doKeepTuple(pRowSup, tsList[j]);
+      doKeepTuple(pRowSup, tsList[j], gid);
      if (j == 0 && pRowSup->startRowIndex != 0) {
        pRowSup->startRowIndex = 0;
      }
@ -1191,8 +1193,8 @@ static void doStateWindowAggImpl(SOperatorInfo* pOperator, SStateWindowOperatorI
                       pRowSup->numOfRows, NULL, pBlock->info.rows, numOfOutput, TSDB_ORDER_ASC);

      // here we start a new session window
-      doKeepNewWindowStartInfo(pRowSup, tsList, j);
-      doKeepTuple(pRowSup, tsList[j]);
+      doKeepNewWindowStartInfo(pRowSup, tsList, j, gid);
+      doKeepTuple(pRowSup, tsList[j], gid);

      // todo extract method
      if (IS_VAR_DATA_TYPE(pInfo->stateKey.type)) {
@ -1645,13 +1647,13 @@ static SSDataBlock* doStreamIntervalAgg(SOperatorInfo* pOperator) {
  while ((pIte = taosHashIterate(pUpdatedMap, pIte)) != NULL) {
    taosArrayPush(pUpdated, pIte);
  }
-  taosHashCleanup(pUpdatedMap);
  taosArraySort(pUpdated, resultrowComparAsc);

  finalizeUpdatedResult(pOperator->exprSupp.numOfExprs, pInfo->aggSup.pResultBuf, pUpdated, pSup->rowEntryInfoOffset);
  initMultiResInfoFromArrayList(&pInfo->groupResInfo, pUpdated);
  blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity);
  removeDeleteResults(pUpdatedMap, pInfo->pDelWins);
+  taosHashCleanup(pUpdatedMap);
  doBuildDeleteResult(pInfo->pDelWins, &pInfo->delIndex, pInfo->pDelRes);
  if (pInfo->pDelRes->info.rows > 0) {
    return pInfo->pDelRes;
@ -1935,7 +1937,7 @@ _error:
  return NULL;
 }

-// todo handle multiple tables cases.
+// todo handle multiple timeline cases. assume no timeline interweaving
 static void doSessionWindowAggImpl(SOperatorInfo* pOperator, SSessionAggOperatorInfo* pInfo, SSDataBlock* pBlock) {
  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
  SExprSupp*     pSup = &pOperator->exprSupp;
@ -1959,12 +1961,13 @@ static void doSessionWindowAggImpl(SOperatorInfo* pOperator, SSessionAggOperator
  // In case of ascending or descending order scan data, only one time window needs to be kepted for each table.
  TSKEY* tsList = (TSKEY*)pColInfoData->pData;
  for (int32_t j = 0; j < pBlock->info.rows; ++j) {
-    if (pInfo->winSup.prevTs == INT64_MIN) {
-      doKeepNewWindowStartInfo(pRowSup, tsList, j);
-      doKeepTuple(pRowSup, tsList[j]);
-    } else if (tsList[j] - pRowSup->prevTs <= gap && (tsList[j] - pRowSup->prevTs) >= 0) {
+    if (gid != pRowSup->groupId || pInfo->winSup.prevTs == INT64_MIN) {
+      doKeepNewWindowStartInfo(pRowSup, tsList, j, gid);
+      doKeepTuple(pRowSup, tsList[j], gid);
+    } else if ((tsList[j] - pRowSup->prevTs >= 0) && tsList[j] - pRowSup->prevTs <= gap ||
+            (pRowSup->prevTs - tsList[j] >= 0 ) && (pRowSup->prevTs - tsList[j] <= gap)) {
      // The gap is less than the threshold, so it belongs to current session window that has been opened already.
-      doKeepTuple(pRowSup, tsList[j]);
+      doKeepTuple(pRowSup, tsList[j], gid);
      if (j == 0 && pRowSup->startRowIndex != 0) {
        pRowSup->startRowIndex = 0;
      }
@ -1987,8 +1990,8 @@ static void doSessionWindowAggImpl(SOperatorInfo* pOperator, SSessionAggOperator
                       pRowSup->numOfRows, NULL, pBlock->info.rows, numOfOutput, TSDB_ORDER_ASC);

      // here we start a new session window
-      doKeepNewWindowStartInfo(pRowSup, tsList, j);
-      doKeepTuple(pRowSup, tsList[j]);
+      doKeepNewWindowStartInfo(pRowSup, tsList, j, gid);
+      doKeepTuple(pRowSup, tsList[j], gid);
    }
  }

@ -3616,9 +3619,7 @@ SOperatorInfo* createStreamSessionAggOperatorInfo(SOperatorInfo* downstream, SPh
  _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
  pInfo->pStDeleted = taosHashInit(64, hashFn, true, HASH_NO_LOCK);
  pInfo->pDelIterator = NULL;
-  // pInfo->pDelRes = createSpecialDataBlock(STREAM_DELETE_RESULT);
-  pInfo->pDelRes = createOneDataBlock(pInfo->binfo.pRes, false);  // todo(liuyao) for delete
-  pInfo->pDelRes->info.type = STREAM_DELETE_RESULT;               // todo(liuyao) for delete
+  pInfo->pDelRes = createSpecialDataBlock(STREAM_DELETE_RESULT);
  pInfo->pChildren = NULL;
  pInfo->isFinal = false;
  pInfo->pPhyNode = pPhyNode;
@ -3764,7 +3765,7 @@ SResultWindowInfo* getSessionTimeWindow(SStreamAggSupporter* pAggSup, TSKEY star
  return insertNewSessionWindow(pWinInfos, startTs, index + 1);
 }

-int32_t updateSessionWindowInfo(SResultWindowInfo* pWinInfo, TSKEY* pStartTs, TSKEY* pEndTs, int32_t rows,
+int32_t updateSessionWindowInfo(SResultWindowInfo* pWinInfo, TSKEY* pStartTs, TSKEY* pEndTs, uint64_t groupId,int32_t rows,
                                int32_t start, int64_t gap, SHashObj* pStDeleted) {
  for (int32_t i = start; i < rows; ++i) {
    if (!isInWindow(pWinInfo, pStartTs[i], gap) && (!pEndTs || !isInWindow(pWinInfo, pEndTs[i], gap))) {
@ -3772,7 +3773,8 @@ int32_t updateSessionWindowInfo(SResultWindowInfo* pWinInfo, TSKEY* pStartTs, TS
    }
    if (pWinInfo->win.skey > pStartTs[i]) {
      if (pStDeleted && pWinInfo->isOutput) {
-        taosHashPut(pStDeleted, &pWinInfo->pos, sizeof(SResultRowPosition), &pWinInfo->win.skey, sizeof(TSKEY));
+        SWinRes res = {.ts = pWinInfo->win.skey, .groupId = groupId};
+        taosHashPut(pStDeleted, &pWinInfo->pos, sizeof(SResultRowPosition), &res, sizeof(SWinRes));
        pWinInfo->isOutput = false;
      }
      pWinInfo->win.skey = pStartTs[i];
@ -3891,7 +3893,8 @@ void compactTimeWindow(SStreamSessionAggOperatorInfo* pInfo, int32_t startIndex,
    compactFunctions(pSup->pCtx, pInfo->pDummyCtx, numOfOutput, pTaskInfo);
    taosHashRemove(pStUpdated, &pWinInfo->pos, sizeof(SResultRowPosition));
    if (pWinInfo->isOutput) {
-      taosHashPut(pStDeleted, &pWinInfo->pos, sizeof(SResultRowPosition), &pWinInfo->win.skey, sizeof(TSKEY));
+      SWinRes res = {.ts = pWinInfo->win.skey, .groupId = groupId};
+      taosHashPut(pStDeleted, &pWinInfo->pos, sizeof(SResultRowPosition), &res, sizeof(SWinRes));
      pWinInfo->isOutput = false;
    }
    taosArrayRemove(pInfo->streamAggSup.pCurWins, i);
@ -3941,7 +3944,7 @@ static void doStreamSessionAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSData
    int32_t            winIndex = 0;
    SResultWindowInfo* pCurWin = getSessionTimeWindow(pAggSup, startTsCols[i], endTsCols[i], groupId, gap, &winIndex);
    winRows =
-        updateSessionWindowInfo(pCurWin, startTsCols, endTsCols, pSDataBlock->info.rows, i, pInfo->gap, pStDeleted);
+        updateSessionWindowInfo(pCurWin, startTsCols, endTsCols, groupId, pSDataBlock->info.rows, i, pInfo->gap, pStDeleted);
    code = doOneWindowAgg(pInfo, pSDataBlock, pCurWin, &pResult, i, winRows, numOfOutput, pOperator);
    if (code != TSDB_CODE_SUCCESS || pResult == NULL) {
      longjmp(pTaskInfo->env, TSDB_CODE_QRY_OUT_OF_MEMORY);
@ -3990,6 +3993,7 @@ static void doDeleteTimeWindows(SStreamAggSupporter* pAggSup, SSDataBlock* pBloc
      }
      deleteWindow(pAggSup->pCurWins, winIndex, fp);
      if (result) {
+        pCurWin->groupId = gpDatas[i];
        taosArrayPush(result, pCurWin);
      }
    }
@ -4010,7 +4014,7 @@ static void doClearSessionWindows(SStreamAggSupporter* pAggSup, SExprSupp* pSup,
      step = 1;
      continue;
    }
-    step = updateSessionWindowInfo(pCurWin, tsCols, NULL, pBlock->info.rows, i, gap, NULL);
+    step = updateSessionWindowInfo(pCurWin, tsCols, NULL, 0, pBlock->info.rows, i, gap, NULL);
    ASSERT(isInWindow(pCurWin, tsCols[i], gap));
    doClearWindowImpl(&pCurWin->pos, pAggSup->pResultBuf, pSup, numOfOutput);
    if (result) {
@ -4047,12 +4051,11 @@ void doBuildDeleteDataBlock(SHashObj* pStDeleted, SSDataBlock* pBlock, void** It
  blockDataEnsureCapacity(pBlock, size);
  size_t keyLen = 0;
  while (((*Ite) = taosHashIterate(pStDeleted, *Ite)) != NULL) {
-    SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX);
-    colDataAppend(pColInfoData, pBlock->info.rows, *Ite, false);
-    for (int32_t i = 1; i < taosArrayGetSize(pBlock->pDataBlock); i++) {
-      pColInfoData = taosArrayGet(pBlock->pDataBlock, i);
-      colDataAppendNULL(pColInfoData, pBlock->info.rows);
-    }
+    SWinRes* res = *Ite;
+    SColumnInfoData* pTsCol = taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX);
+    colDataAppend(pTsCol, pBlock->info.rows, (const char*)&res->ts, false);
+    SColumnInfoData* pGpCol = taosArrayGet(pBlock->pDataBlock, GROUPID_COLUMN_INDEX);
+    colDataAppend(pGpCol, pBlock->info.rows, (const char*)&res->groupId, false);
    pBlock->info.rows += 1;
    if (pBlock->info.rows + 1 >= pBlock->info.capacity) {
      break;
@ -4179,7 +4182,8 @@ static void copyDeleteWindowInfo(SArray* pResWins, SHashObj* pStDeleted) {
  int32_t size = taosArrayGetSize(pResWins);
  for (int32_t i = 0; i < size; i++) {
    SResultWindowInfo* pWinInfo = taosArrayGet(pResWins, i);
-    taosHashPut(pStDeleted, &pWinInfo->pos, sizeof(SResultRowPosition), &pWinInfo->win.skey, sizeof(TSKEY));
+    SWinRes res = {.ts = pWinInfo->win.skey, .groupId = pWinInfo->groupId};
+    taosHashPut(pStDeleted, &pWinInfo->pos, sizeof(SResultRowPosition), &res, sizeof(SWinRes));
  }
 }

--- a/source/libs/function/src/builtinsimpl.c
+++ b/source/libs/function/src/builtinsimpl.c
@ -748,6 +748,7 @@ int32_t sumCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
    pDBuf->dsum += pSBuf->dsum;
  }
  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
+  pDResInfo->isNullRes &= pSResInfo->isNullRes;
  return TSDB_CODE_SUCCESS;
 }

@ -1746,6 +1747,7 @@ int32_t minMaxCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx, int3
    }
  }
  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
+  pDResInfo->isNullRes &= pSResInfo->isNullRes;
  return TSDB_CODE_SUCCESS;
 }

@ -2121,6 +2123,7 @@ int32_t stddevCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
  }
  pDBuf->count += pSBuf->count;
  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
+  pDResInfo->isNullRes &= pSResInfo->isNullRes;
  return TSDB_CODE_SUCCESS;
 }

@ -2311,6 +2314,7 @@ int32_t leastSQRCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
  pDparam[1][2] += pSparam[1][2];
  pDBuf->num += pSBuf->num;
  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
+  pDResInfo->isNullRes &= pSResInfo->isNullRes;
  return TSDB_CODE_SUCCESS;
 }

@ -2707,6 +2711,7 @@ int32_t apercentileCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx)

  apercentileTransferInfo(pSBuf, pDBuf);
  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
+  pDResInfo->isNullRes &= pSResInfo->isNullRes;
  return TSDB_CODE_SUCCESS;
 }

@ -3890,6 +3895,7 @@ int32_t spreadCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
  SSpreadInfo*         pSBuf = GET_ROWCELL_INTERBUF(pSResInfo);
  spreadTransferInfo(pSBuf, pDBuf);
  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
+  pDResInfo->isNullRes &= pSResInfo->isNullRes;
  return TSDB_CODE_SUCCESS;
 }

@ -4062,6 +4068,7 @@ int32_t elapsedCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {

  elapsedTransferInfo(pSBuf, pDBuf);
  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
+  pDResInfo->isNullRes &= pSResInfo->isNullRes;
  return TSDB_CODE_SUCCESS;
 }

@ -4379,6 +4386,7 @@ int32_t histogramCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {

  histogramTransferInfo(pSBuf, pDBuf);
  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
+  pDResInfo->isNullRes &= pSResInfo->isNullRes;
  return TSDB_CODE_SUCCESS;
 }

@ -4576,6 +4584,7 @@ int32_t hllCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {

  hllTransferInfo(pSBuf, pDBuf);
  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
+  pDResInfo->isNullRes &= pSResInfo->isNullRes;
  return TSDB_CODE_SUCCESS;
 }

--- a/source/libs/scalar/src/filter.c
+++ b/source/libs/scalar/src/filter.c
@ -3265,7 +3265,7 @@ bool filterRangeExecute(SFilterInfo *info, SColumnDataAgg **pDataStatis, int32_t
    int32_t index = -1;
    SFilterRangeCtx *ctx = info->colRange[k];
    for(int32_t i = 0; i < numOfCols; ++i) {
-      if (pDataStatis[i]->colId == ctx->colId) {
+      if (pDataStatis[i] != NULL && pDataStatis[i]->colId == ctx->colId) {
        index = i;
        break;
      }
--- a/source/libs/sync/inc/syncRaftCfg.h
+++ b/source/libs/sync/inc/syncRaftCfg.h
@ -29,7 +29,30 @@ extern "C" {

 #define CONFIG_FILE_LEN 2048

-#define MAX_CONFIG_INDEX_COUNT 512
+#define MAX_CONFIG_INDEX_COUNT 256
+
+// SRaftCfgIndex ------------------------------------------
+typedef struct SRaftCfgIndex {
+  TdFilePtr pFile;
+  char      path[TSDB_FILENAME_LEN * 2];
+
+  SyncIndex configIndexArr[MAX_CONFIG_INDEX_COUNT];
+  int32_t   configIndexCount;
+} SRaftCfgIndex;
+
+SRaftCfgIndex *raftCfgIndexOpen(const char *path);
+int32_t        raftCfgIndexClose(SRaftCfgIndex *pRaftCfgIndex);
+int32_t        raftCfgIndexPersist(SRaftCfgIndex *pRaftCfgIndex);
+int32_t        raftCfgIndexAddConfigIndex(SRaftCfgIndex *pRaftCfgIndex, SyncIndex configIndex);
+
+cJSON  *raftCfgIndex2Json(SRaftCfgIndex *pRaftCfgIndex);
+char   *raftCfgIndex2Str(SRaftCfgIndex *pRaftCfgIndex);
+int32_t raftCfgIndexFromJson(const cJSON *pRoot, SRaftCfgIndex *pRaftCfgIndex);
+int32_t raftCfgIndexFromStr(const char *s, SRaftCfgIndex *pRaftCfgIndex);
+
+int32_t raftCfgIndexCreateFile(const char *path);
+
+// ---------------------------------------------------------

 typedef struct SRaftCfg {
  SSyncCfg  cfg;
@ -82,6 +105,11 @@ void raftCfgPrint2(char *s, SRaftCfg *pCfg);
 void raftCfgLog(SRaftCfg *pCfg);
 void raftCfgLog2(char *s, SRaftCfg *pCfg);

+void raftCfgIndexPrint(SRaftCfgIndex *pCfg);
+void raftCfgIndexPrint2(char *s, SRaftCfgIndex *pCfg);
+void raftCfgIndexLog(SRaftCfgIndex *pCfg);
+void raftCfgIndexLog2(char *s, SRaftCfgIndex *pCfg);
+
 #ifdef __cplusplus
 }
 #endif
--- a/source/libs/sync/src/syncMain.c
+++ b/source/libs/sync/src/syncMain.c
@ -1132,10 +1132,12 @@ void syncNodeStart(SSyncNode* pSyncNode) {
    syncNodeBecomeFollower(pSyncNode, "first start");
  }

+  if (pSyncNode->vgId == 1) {
    int32_t ret = 0;
-  // ret = syncNodeStartPingTimer(pSyncNode);
+    ret = syncNodeStartPingTimer(pSyncNode);
    ASSERT(ret == 0);
  }
+}

 void syncNodeStartStandBy(SSyncNode* pSyncNode) {
  // state change
@ -1146,6 +1148,12 @@ void syncNodeStartStandBy(SSyncNode* pSyncNode) {
  int32_t electMS = TIMER_MAX_MS;
  int32_t ret = syncNodeRestartElectTimer(pSyncNode, electMS);
  ASSERT(ret == 0);
+
+  if (pSyncNode->vgId == 1) {
+    int32_t ret = 0;
+    ret = syncNodeStartPingTimer(pSyncNode);
+    ASSERT(ret == 0);
+  }
 }

 void syncNodeClose(SSyncNode* pSyncNode) {
--- a/source/libs/sync/src/syncRaftCfg.c
+++ b/source/libs/sync/src/syncRaftCfg.c
@ -18,6 +18,149 @@
 #include "syncEnv.h"
 #include "syncUtil.h"

+// file must already exist!
+SRaftCfgIndex *raftCfgIndexOpen(const char *path) {
+  SRaftCfgIndex *pRaftCfgIndex = taosMemoryMalloc(sizeof(SRaftCfg));
+  snprintf(pRaftCfgIndex->path, sizeof(pRaftCfgIndex->path), "%s", path);
+
+  pRaftCfgIndex->pFile = taosOpenFile(pRaftCfgIndex->path, TD_FILE_READ | TD_FILE_WRITE);
+  ASSERT(pRaftCfgIndex->pFile != NULL);
+
+  taosLSeekFile(pRaftCfgIndex->pFile, 0, SEEK_SET);
+
+  int32_t bufLen = MAX_CONFIG_INDEX_COUNT * 16;
+  char   *pBuf = taosMemoryMalloc(bufLen);
+  memset(pBuf, 0, bufLen);
+  int64_t len = taosReadFile(pRaftCfgIndex->pFile, pBuf, bufLen);
+  ASSERT(len > 0);
+
+  int32_t ret = raftCfgIndexFromStr(pBuf, pRaftCfgIndex);
+  ASSERT(ret == 0);
+
+  taosMemoryFree(pBuf);
+
+  return pRaftCfgIndex;
+}
+
+int32_t raftCfgIndexClose(SRaftCfgIndex *pRaftCfgIndex) {
+  if (pRaftCfgIndex != NULL) {
+    int64_t ret = taosCloseFile(&(pRaftCfgIndex->pFile));
+    ASSERT(ret == 0);
+    taosMemoryFree(pRaftCfgIndex);
+  }
+  return 0;
+}
+
+int32_t raftCfgIndexPersist(SRaftCfgIndex *pRaftCfgIndex) {
+  ASSERT(pRaftCfgIndex != NULL);
+
+  char *s = raftCfgIndex2Str(pRaftCfgIndex);
+  taosLSeekFile(pRaftCfgIndex->pFile, 0, SEEK_SET);
+
+  int64_t ret = taosWriteFile(pRaftCfgIndex->pFile, s, strlen(s) + 1);
+  ASSERT(ret == strlen(s) + 1);
+
+  taosMemoryFree(s);
+  taosFsyncFile(pRaftCfgIndex->pFile);
+  return 0;
+}
+
+int32_t raftCfgIndexAddConfigIndex(SRaftCfgIndex *pRaftCfgIndex, SyncIndex configIndex) {
+  ASSERT(pRaftCfgIndex->configIndexCount <= MAX_CONFIG_INDEX_COUNT);
+  (pRaftCfgIndex->configIndexArr)[pRaftCfgIndex->configIndexCount] = configIndex;
+  ++(pRaftCfgIndex->configIndexCount);
+  return 0;
+}
+
+cJSON *raftCfgIndex2Json(SRaftCfgIndex *pRaftCfgIndex) {
+  cJSON *pRoot = cJSON_CreateObject();
+
+  cJSON_AddNumberToObject(pRoot, "configIndexCount", pRaftCfgIndex->configIndexCount);
+  cJSON *pIndexArr = cJSON_CreateArray();
+  cJSON_AddItemToObject(pRoot, "configIndexArr", pIndexArr);
+  for (int i = 0; i < pRaftCfgIndex->configIndexCount; ++i) {
+    char buf64[128];
+    snprintf(buf64, sizeof(buf64), "%" PRId64, (pRaftCfgIndex->configIndexArr)[i]);
+    cJSON *pIndexObj = cJSON_CreateObject();
+    cJSON_AddStringToObject(pIndexObj, "index", buf64);
+    cJSON_AddItemToArray(pIndexArr, pIndexObj);
+  }
+
+  cJSON *pJson = cJSON_CreateObject();
+  cJSON_AddItemToObject(pJson, "SRaftCfgIndex", pRoot);
+  return pJson;
+}
+
+char *raftCfgIndex2Str(SRaftCfgIndex *pRaftCfgIndex) {
+  cJSON *pJson = raftCfgIndex2Json(pRaftCfgIndex);
+  char  *serialized = cJSON_Print(pJson);
+  cJSON_Delete(pJson);
+  return serialized;
+}
+
+int32_t raftCfgIndexFromJson(const cJSON *pRoot, SRaftCfgIndex *pRaftCfgIndex) {
+  cJSON *pJson = cJSON_GetObjectItem(pRoot, "SRaftCfgIndex");
+
+  cJSON *pJsonConfigIndexCount = cJSON_GetObjectItem(pJson, "configIndexCount");
+  pRaftCfgIndex->configIndexCount = cJSON_GetNumberValue(pJsonConfigIndexCount);
+
+  cJSON *pIndexArr = cJSON_GetObjectItem(pJson, "configIndexArr");
+  int    arraySize = cJSON_GetArraySize(pIndexArr);
+  ASSERT(arraySize == pRaftCfgIndex->configIndexCount);
+
+  memset(pRaftCfgIndex->configIndexArr, 0, sizeof(pRaftCfgIndex->configIndexArr));
+  for (int i = 0; i < arraySize; ++i) {
+    cJSON *pIndexObj = cJSON_GetArrayItem(pIndexArr, i);
+    ASSERT(pIndexObj != NULL);
+
+    cJSON *pIndex = cJSON_GetObjectItem(pIndexObj, "index");
+    ASSERT(cJSON_IsString(pIndex));
+    (pRaftCfgIndex->configIndexArr)[i] = atoll(pIndex->valuestring);
+  }
+
+  return 0;
+}
+
+int32_t raftCfgIndexFromStr(const char *s, SRaftCfgIndex *pRaftCfgIndex) {
+  cJSON *pRoot = cJSON_Parse(s);
+  ASSERT(pRoot != NULL);
+
+  int32_t ret = raftCfgIndexFromJson(pRoot, pRaftCfgIndex);
+  ASSERT(ret == 0);
+
+  cJSON_Delete(pRoot);
+  return 0;
+}
+
+int32_t raftCfgIndexCreateFile(const char *path) {
+  TdFilePtr pFile = taosOpenFile(path, TD_FILE_CREATE | TD_FILE_WRITE);
+  if (pFile == NULL) {
+    int32_t     err = terrno;
+    const char *errStr = tstrerror(err);
+    int32_t     sysErr = errno;
+    const char *sysErrStr = strerror(errno);
+    sError("create raft cfg index file error, err:%d %X, msg:%s, syserr:%d, sysmsg:%s", err, err, errStr, sysErr,
+           sysErrStr);
+    ASSERT(0);
+
+    return -1;
+  }
+
+  SRaftCfgIndex raftCfgIndex;
+  memset(raftCfgIndex.configIndexArr, 0, sizeof(raftCfgIndex.configIndexArr));
+  raftCfgIndex.configIndexCount = 1;
+  raftCfgIndex.configIndexArr[0] = -1;
+
+  char   *s = raftCfgIndex2Str(&raftCfgIndex);
+  int64_t ret = taosWriteFile(pFile, s, strlen(s) + 1);
+  ASSERT(ret == strlen(s) + 1);
+
+  taosMemoryFree(s);
+  taosCloseFile(&pFile);
+  return 0;
+}
+
+// ---------------------------------------
 // file must already exist!
 SRaftCfg *raftCfgOpen(const char *path) {
  SRaftCfg *pCfg = taosMemoryMalloc(sizeof(SRaftCfg));
@ -361,3 +504,30 @@ void raftCfgLog2(char *s, SRaftCfg *pCfg) {
  sTrace("raftCfgLog2 | len:%" PRIu64 " | %s | %s", strlen(serialized), s, serialized);
  taosMemoryFree(serialized);
 }
+
+// ---------
+void raftCfgIndexPrint(SRaftCfgIndex *pCfg) {
+  char *serialized = raftCfgIndex2Str(pCfg);
+  printf("raftCfgIndexPrint | len:%" PRIu64 " | %s \n", strlen(serialized), serialized);
+  fflush(NULL);
+  taosMemoryFree(serialized);
+}
+
+void raftCfgIndexPrint2(char *s, SRaftCfgIndex *pCfg) {
+  char *serialized = raftCfgIndex2Str(pCfg);
+  printf("raftCfgIndexPrint2 | len:%" PRIu64 " | %s | %s \n", strlen(serialized), s, serialized);
+  fflush(NULL);
+  taosMemoryFree(serialized);
+}
+
+void raftCfgIndexLog(SRaftCfgIndex *pCfg) {
+  char *serialized = raftCfgIndex2Str(pCfg);
+  sTrace("raftCfgIndexLog | len:%" PRIu64 " | %s", strlen(serialized), serialized);
+  taosMemoryFree(serialized);
+}
+
+void raftCfgIndexLog2(char *s, SRaftCfgIndex *pCfg) {
+  char *serialized = raftCfgIndex2Str(pCfg);
+  sTrace("raftCfgIndexLog2 | len:%" PRIu64 " | %s | %s", strlen(serialized), s, serialized);
+  taosMemoryFree(serialized);
+}
--- a/source/libs/sync/src/syncTimeout.c
+++ b/source/libs/sync/src/syncTimeout.c
@ -15,12 +15,55 @@

 #include "syncTimeout.h"
 #include "syncElection.h"
+#include "syncRaftCfg.h"
 #include "syncReplication.h"
 #include "syncRespMgr.h"

+static void syncNodeCleanConfigIndex(SSyncNode* ths) {
+  int32_t   newArrIndex = 0;
+  SyncIndex newConfigIndexArr[MAX_CONFIG_INDEX_COUNT];
+  memset(newConfigIndexArr, 0, sizeof(newConfigIndexArr));
+
+  SSnapshot snapshot = {0};
+  if (ths->pFsm != NULL && ths->pFsm->FpGetSnapshotInfo != NULL) {
+    ths->pFsm->FpGetSnapshotInfo(ths->pFsm, &snapshot);
+  }
+
+  if (snapshot.lastApplyIndex != SYNC_INDEX_INVALID) {
+    for (int i = 0; i < ths->pRaftCfg->configIndexCount; ++i) {
+      if (ths->pRaftCfg->configIndexArr[i] < snapshot.lastConfigIndex) {
+        // pass
+        ;
+      } else {
+        // save
+        newConfigIndexArr[newArrIndex] = ths->pRaftCfg->configIndexArr[i];
+        ++newArrIndex;
+      }
+    }
+
+    int32_t oldCnt = ths->pRaftCfg->configIndexCount;
+    ths->pRaftCfg->configIndexCount = newArrIndex;
+    memcpy(ths->pRaftCfg->configIndexArr, newConfigIndexArr, sizeof(newConfigIndexArr));
+
+    int32_t code = raftCfgPersist(ths->pRaftCfg);
+    ASSERT(code == 0);
+
+    do {
+      char logBuf[128];
+      snprintf(logBuf, sizeof(logBuf), "clean config index arr, old-cnt:%d, new-cnt:%d", oldCnt,
+               ths->pRaftCfg->configIndexCount);
+      syncNodeEventLog(ths, logBuf);
+    } while (0);
+  }
+}
+
 int32_t syncNodeTimerRoutine(SSyncNode* ths) {
  syncNodeEventLog(ths, "timer routines");

+  if (ths->vgId == 1) {
+    syncNodeCleanConfigIndex(ths);
+  }
+
 #if 0
  if (ths->vgId != 1) {
    syncRespClean(ths->pSyncRespMgr);
@ -41,7 +84,7 @@ int32_t syncNodeOnTimeoutCb(SSyncNode* ths, SyncTimeout* pMsg) {
      // syncNodePingAll(ths);
      // syncNodePingPeers(ths);

-      sTrace("vgId:%d, sync timeout, type:ping count:%d", ths->vgId, ths->pingTimerCounter);
+      // sTrace("vgId:%d, sync timeout, type:ping count:%d", ths->vgId, ths->pingTimerCounter);
      syncNodeTimerRoutine(ths);
    }

--- a/source/libs/sync/test/CMakeLists.txt
+++ b/source/libs/sync/test/CMakeLists.txt
@ -56,6 +56,7 @@ add_executable(syncRaftLogTest3 "")
 add_executable(syncLeaderTransferTest "")
 add_executable(syncReconfigFinishTest "")
 add_executable(syncRestoreFromSnapshot "")
+add_executable(syncRaftCfgIndexTest "")


 target_sources(syncTest
@ -290,6 +291,10 @@ target_sources(syncRestoreFromSnapshot
    PRIVATE
    "syncRestoreFromSnapshot.cpp"
 )
+target_sources(syncRaftCfgIndexTest
+    PRIVATE
+    "syncRaftCfgIndexTest.cpp"
+)


 target_include_directories(syncTest
@ -582,6 +587,11 @@ target_include_directories(syncRestoreFromSnapshot
    "${TD_SOURCE_DIR}/include/libs/sync"
    "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
+target_include_directories(syncRaftCfgIndexTest
+    PUBLIC
+    "${TD_SOURCE_DIR}/include/libs/sync"
+    "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
+)


 target_link_libraries(syncTest
@ -816,6 +826,10 @@ target_link_libraries(syncRestoreFromSnapshot
    sync
    gtest_main
 )
+target_link_libraries(syncRaftCfgIndexTest
+    sync
+    gtest_main
+)


 enable_testing()
--- a/source/libs/sync/test/syncRaftCfgIndexTest.cpp
+++ b/source/libs/sync/test/syncRaftCfgIndexTest.cpp
@ -0,0 +1,96 @@
+#include "syncRaftStore.h"
+//#include <gtest/gtest.h>
+#include <stdio.h>
+#include "syncIO.h"
+#include "syncInt.h"
+#include "syncRaftCfg.h"
+#include "syncUtil.h"
+
+void logTest() {
+  sTrace("--- sync log test: trace");
+  sDebug("--- sync log test: debug");
+  sInfo("--- sync log test: info");
+  sWarn("--- sync log test: warn");
+  sError("--- sync log test: error");
+  sFatal("--- sync log test: fatal");
+}
+
+SRaftCfg* createRaftCfg() {
+  SRaftCfg* pCfg = (SRaftCfg*)taosMemoryMalloc(sizeof(SRaftCfg));
+  memset(pCfg, 0, sizeof(SRaftCfg));
+
+  pCfg->cfg.replicaNum = 3;
+  pCfg->cfg.myIndex = 1;
+  for (int i = 0; i < pCfg->cfg.replicaNum; ++i) {
+    ((pCfg->cfg.nodeInfo)[i]).nodePort = i * 100;
+    snprintf(((pCfg->cfg.nodeInfo)[i]).nodeFqdn, sizeof(((pCfg->cfg.nodeInfo)[i]).nodeFqdn), "100.200.300.%d", i);
+  }
+  pCfg->isStandBy = taosGetTimestampSec() % 100;
+  pCfg->batchSize = taosGetTimestampSec() % 100;
+
+  pCfg->configIndexCount = 5;
+  for (int i = 0; i < MAX_CONFIG_INDEX_COUNT; ++i) {
+    (pCfg->configIndexArr)[i] = -1;
+  }
+  for (int i = 0; i < pCfg->configIndexCount; ++i) {
+    (pCfg->configIndexArr)[i] = i * 100;
+  }
+
+  return pCfg;
+}
+
+SSyncCfg* createSyncCfg() {
+  SSyncCfg* pCfg = (SSyncCfg*)taosMemoryMalloc(sizeof(SSyncCfg));
+  memset(pCfg, 0, sizeof(SSyncCfg));
+
+  pCfg->replicaNum = 3;
+  pCfg->myIndex = 1;
+  for (int i = 0; i < pCfg->replicaNum; ++i) {
+    ((pCfg->nodeInfo)[i]).nodePort = i * 100;
+    snprintf(((pCfg->nodeInfo)[i]).nodeFqdn, sizeof(((pCfg->nodeInfo)[i]).nodeFqdn), "100.200.300.%d", i);
+  }
+
+  return pCfg;
+}
+
+const char *pFile = "./raft_config_index.json";
+
+void test1() {
+  int32_t code = raftCfgIndexCreateFile(pFile);
+  ASSERT(code == 0);
+
+  SRaftCfgIndex *pRaftCfgIndex = raftCfgIndexOpen(pFile);
+  raftCfgIndexLog2((char*)"==test1==", pRaftCfgIndex);
+
+  raftCfgIndexClose(pRaftCfgIndex);
+}
+
+void test2() {
+  SRaftCfgIndex *pRaftCfgIndex = raftCfgIndexOpen(pFile);
+  for (int i = 0; i < 500; ++i) {
+    raftCfgIndexAddConfigIndex(pRaftCfgIndex, i);
+  }
+  raftCfgIndexPersist(pRaftCfgIndex);
+
+  raftCfgIndexLog2((char*)"==test2==", pRaftCfgIndex);
+  raftCfgIndexClose(pRaftCfgIndex);
+}
+
+void test3() {
+  SRaftCfgIndex *pRaftCfgIndex = raftCfgIndexOpen(pFile);
+
+  raftCfgIndexLog2((char*)"==test3==", pRaftCfgIndex);
+  raftCfgIndexClose(pRaftCfgIndex);
+}
+
+int main() {
+  tsAsyncLog = 0;
+  sDebugFlag = DEBUG_TRACE + DEBUG_SCREEN + DEBUG_FILE;
+
+  logTest();
+  test1();
+  test2();
+  test3();
+
+  return 0;
+}
--- a/source/libs/transport/src/transCli.c
+++ b/source/libs/transport/src/transCli.c
@ -222,7 +222,7 @@ static void cliReleaseUnfinishedMsg(SCliConn* conn) {
        SCliMsg* cliMsg = transQueueGet(&conn->cliMsgs, 0);                                                          \
        if (cliMsg->type == Release) return;                                                                         \
      }                                                                                                              \
-      tDebug("%s conn %p receive release request, ref:%d", CONN_GET_INST_LABEL(conn), conn, T_REF_VAL_GET(conn)); \
+      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);                                                                                   \
      }                                                                                                              \
@ -890,8 +890,8 @@ SCliConn* cliGetConn(SCliMsg* pMsg, SCliThrd* pThrd, bool* ignore) {
  if (refId != 0) {
    SExHandle* exh = transAcquireExHandle(transGetRefMgt(), refId);
    if (exh == NULL) {
+      tError("failed to get conn, refId: %" PRId64 "", refId);
      *ignore = true;
-      destroyCmsg(pMsg);
      return NULL;
    } else {
      conn = exh->handle;
@ -937,7 +937,16 @@ void cliHandleReq(SCliMsg* pMsg, SCliThrd* pThrd) {
  bool      ignore = false;
  SCliConn* conn = cliGetConn(pMsg, pThrd, &ignore);
  if (ignore == true) {
-    tError("ignore msg");
+    // persist conn already release by server
+    STransMsg resp = {0};
+    resp.code = TSDB_CODE_RPC_BROKEN_LINK;
+    resp.msgType = pMsg->msg.msgType + 1;
+
+    resp.info.ahandle = pMsg && pMsg->ctx ? pMsg->ctx->ahandle : NULL;
+    resp.info.traceId = pMsg->msg.info.traceId;
+
+    pTransInst->cfp(pTransInst->parent, &resp, NULL);
+    destroyCmsg(pMsg);
    return;
  }

--- a/tests/pytest/query/nestedQuery/insertData.json
+++ b/tests/pytest/query/nestedQuery/insertData.json
@ -1,62 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 4,
-    "create_table_thread_count": 4,
-    "result_file":"./insert_res.txt",
-    "confirm_parameter_prompt": "no",   
-    "insert_interval": 0,
-    "interlace_rows": 10,
-    "num_of_records_per_req": 1000,
-    "max_sql_len": 1024000,
-    "databases": [{
-        "dbinfo": {
-            "name": "db",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "ms",
-            "keep": 365,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": 1,
-            "childtable_prefix": "stb0_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 100000,
-            "childtable_limit": -1,
-            "childtable_offset": 0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval": 0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1,
-            "timestamp_step": 1000,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./tools/taosdemoAllTest/sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT", "count":1}, {"type": "BINARY", "len": 16, "count":1}, {"type": "BOOL"}],
-            "tags": [{"type": "TINYINT", "count":1}, {"type": "BINARY", "len": 16, "count":1}]
-        }]
-    }]
-}
--- a/tests/pytest/query/nestedQuery/nestedQueryJson.py
+++ b/tests/pytest/query/nestedQuery/nestedQueryJson.py
@ -1,81 +0,0 @@
-###################################################################
-#           Copyright (c) 2016 by TAOS Technologies, Inc.
-#                     All rights reserved.
-#
-#  This file is proprietary and confidential to TAOS Technologies.
-#  No part of this file may be reproduced, stored, transmitted,
-#  disclosed or used in any form or by any means other than as
-#  expressly provided by the written permission from Jianhui Tao
-#
-###################################################################
-
-# -*- coding: utf-8 -*-
-
-import sys
-import os
-from util.log import *
-from util.cases import *
-from util.sql import *
-from util.dnodes import *
-
-
-class TDTestCase:
-    def init(self, conn, logSql):
-        tdLog.debug("start to execute %s" % __file__)
-        tdSql.init(conn.cursor(), logSql)
-        
-    def getBuildPath(self):
-        selfPath = os.path.dirname(os.path.realpath(__file__))
-
-        if ("community" in selfPath):
-            projPath = selfPath[:selfPath.find("community")]
-        else:
-            projPath = selfPath[:selfPath.find("tests")]
-
-        for root, dirs, files in os.walk(projPath):
-            if ("taosd" in files):
-                rootRealPath = os.path.dirname(os.path.realpath(root))
-                if ("packaging" not in rootRealPath):
-                    buildPath = root[:len(root)-len("/build/bin")]
-                    break
-        return buildPath
-        
-    def run(self):
-        buildPath = self.getBuildPath()
-        if (buildPath == ""):
-            tdLog.exit("taosd not found!")
-        else:
-            tdLog.info("taosd found in %s" % buildPath)
-        binPath = buildPath+ "/build/bin/"
-
-        # insert: create one  or mutiple tables per sql and insert multiple rows per sql 
-        os.system("%staosdemo -f query/nestedQuery/insertData.json -y " % binPath)
-        tdSql.execute("use db")
-        tdSql.query("select count (tbname) from stb0")
-        tdSql.checkData(0, 0, 1000)
-        tdSql.query("select count (tbname) from stb1")
-        tdSql.checkData(0, 0, 1000)
-        tdSql.query("select count(*) from stb00_0")
-        tdSql.checkData(0, 0, 100)
-        tdSql.query("select count(*) from stb0")
-        tdSql.checkData(0, 0, 100000)
-        tdSql.query("select count(*) from stb01_1")
-        tdSql.checkData(0, 0, 200)
-        tdSql.query("select count(*) from stb1")
-        tdSql.checkData(0, 0, 200000)        
-
-
- 
-        testcaseFilename = os.path.split(__file__)[-1]
-        os.system("rm -rf ./insert_res.txt")
-        os.system("rm -rf query/nestedQuery/%s.sql" % testcaseFilename )      
-        
-        
-        
-    def stop(self):
-        tdSql.close()
-        tdLog.success("%s successfully executed" % __file__)
-
-
-tdCases.addWindows(__file__, TDTestCase())
-tdCases.addLinux(__file__, TDTestCase())
--- a/tests/pytest/tools/taosdemoAllTest/1174-tag.csv
+++ b/tests/pytest/tools/taosdemoAllTest/1174-tag.csv
@ -1,3 +0,0 @@
-1
-2
-3
--- a/tests/pytest/tools/taosdemoAllTest/1174.csv
+++ b/tests/pytest/tools/taosdemoAllTest/1174.csv
--- a/tests/pytest/tools/taosdemoAllTest/NanoTestCase/nano_samples.csv
+++ b/tests/pytest/tools/taosdemoAllTest/NanoTestCase/nano_samples.csv
@ -1,100 +0,0 @@
-8.855,"binary_str0" ,1626870128248246976
-8.75,"binary_str1" ,1626870128249060032
-5.44,"binary_str2" ,1626870128249067968
-8.45,"binary_str3" ,1626870128249072064
-4.07,"binary_str4" ,1626870128249075904
-6.97,"binary_str5" ,1626870128249078976
-6.86,"binary_str6" ,1626870128249082048
-1.585,"binary_str7" ,1626870128249085120
-1.4,"binary_str8" ,1626870128249087936
-5.135,"binary_str9" ,1626870128249092032
-3.15,"binary_str10" ,1626870128249095104
-1.765,"binary_str11" ,1626870128249097920
-7.71,"binary_str12" ,1626870128249100992
-3.91,"binary_str13" ,1626870128249104064
-5.615,"binary_str14" ,1626870128249106880
-9.495,"binary_str15" ,1626870128249109952
-3.825,"binary_str16" ,1626870128249113024
-1.94,"binary_str17" ,1626870128249117120
-5.385,"binary_str18" ,1626870128249119936
-7.075,"binary_str19" ,1626870128249123008
-5.715,"binary_str20" ,1626870128249126080
-1.83,"binary_str21" ,1626870128249128896
-6.365,"binary_str22" ,1626870128249131968
-6.55,"binary_str23" ,1626870128249135040
-6.315,"binary_str24" ,1626870128249138112
-3.82,"binary_str25" ,1626870128249140928
-2.455,"binary_str26" ,1626870128249145024
-7.795,"binary_str27" ,1626870128249148096
-2.47,"binary_str28" ,1626870128249150912
-1.37,"binary_str29" ,1626870128249155008
-5.39,"binary_str30" ,1626870128249158080
-5.13,"binary_str31" ,1626870128249160896
-4.09,"binary_str32" ,1626870128249163968
-5.855,"binary_str33" ,1626870128249167040
-0.17,"binary_str34" ,1626870128249170112
-1.955,"binary_str35" ,1626870128249173952
-0.585,"binary_str36" ,1626870128249178048
-0.33,"binary_str37" ,1626870128249181120
-7.925,"binary_str38" ,1626870128249183936
-9.685,"binary_str39" ,1626870128249187008
-2.6,"binary_str40" ,1626870128249191104
-5.705,"binary_str41" ,1626870128249193920
-3.965,"binary_str42" ,1626870128249196992
-4.43,"binary_str43" ,1626870128249200064
-8.73,"binary_str44" ,1626870128249202880
-3.105,"binary_str45" ,1626870128249205952
-9.39,"binary_str46" ,1626870128249209024
-2.825,"binary_str47" ,1626870128249212096
-9.675,"binary_str48" ,1626870128249214912
-9.99,"binary_str49" ,1626870128249217984
-4.51,"binary_str50" ,1626870128249221056
-4.94,"binary_str51" ,1626870128249223872
-7.72,"binary_str52" ,1626870128249226944
-4.135,"binary_str53" ,1626870128249231040
-2.325,"binary_str54" ,1626870128249234112
-4.585,"binary_str55" ,1626870128249236928
-8.76,"binary_str56" ,1626870128249240000
-4.715,"binary_str57" ,1626870128249243072
-0.56,"binary_str58" ,1626870128249245888
-5.35,"binary_str59" ,1626870128249249984
-5.075,"binary_str60" ,1626870128249253056
-6.665,"binary_str61" ,1626870128249256128
-7.13,"binary_str62" ,1626870128249258944
-2.775,"binary_str63" ,1626870128249262016
-5.775,"binary_str64" ,1626870128249265088
-1.62,"binary_str65" ,1626870128249267904
-1.625,"binary_str66" ,1626870128249270976
-8.15,"binary_str67" ,1626870128249274048
-0.75,"binary_str68" ,1626870128249277120
-3.265,"binary_str69" ,1626870128249280960
-8.585,"binary_str70" ,1626870128249284032
-1.88,"binary_str71" ,1626870128249287104
-8.44,"binary_str72" ,1626870128249289920
-5.12,"binary_str73" ,1626870128249295040
-2.58,"binary_str74" ,1626870128249298112
-9.42,"binary_str75" ,1626870128249300928
-1.765,"binary_str76" ,1626870128249304000
-2.66,"binary_str77" ,1626870128249308096
-1.405,"binary_str78" ,1626870128249310912
-5.595,"binary_str79" ,1626870128249315008
-2.28,"binary_str80" ,1626870128249318080
-9.24,"binary_str81" ,1626870128249320896
-9.03,"binary_str82" ,1626870128249323968
-6.055,"binary_str83" ,1626870128249327040
-1.74,"binary_str84" ,1626870128249330112
-5.77,"binary_str85" ,1626870128249332928
-1.97,"binary_str86" ,1626870128249336000
-0.3,"binary_str87" ,1626870128249339072
-7.145,"binary_str88" ,1626870128249342912
-0.88,"binary_str89" ,1626870128249345984
-8.025,"binary_str90" ,1626870128249349056
-4.81,"binary_str91" ,1626870128249351872
-0.725,"binary_str92" ,1626870128249355968
-3.85,"binary_str93" ,1626870128249359040
-9.455,"binary_str94" ,1626870128249362112
-2.265,"binary_str95" ,1626870128249364928
-3.985,"binary_str96" ,1626870128249368000
-9.375,"binary_str97" ,1626870128249371072
-0.2,"binary_str98" ,1626870128249373888
-6.95,"binary_str99" ,1626870128249377984
--- a/tests/pytest/tools/taosdemoAllTest/NanoTestCase/nano_sampletags.csv
+++ b/tests/pytest/tools/taosdemoAllTest/NanoTestCase/nano_sampletags.csv
@ -1,100 +0,0 @@
-"string0",7,8.615
-"string1",4,9.895
-"string2",3,2.92
-"string3",3,5.62
-"string4",7,1.615
-"string5",6,1.45
-"string6",5,7.48
-"string7",7,3.01
-"string8",5,4.76
-"string9",10,7.09
-"string10",2,8.38
-"string11",7,8.65
-"string12",5,5.025
-"string13",10,5.765
-"string14",2,4.57
-"string15",2,1.03
-"string16",7,6.98
-"string17",10,0.23
-"string18",7,5.815
-"string19",1,2.37
-"string20",10,8.865
-"string21",3,1.235
-"string22",2,8.62
-"string23",9,1.045
-"string24",8,4.34
-"string25",1,5.455
-"string26",2,4.475
-"string27",1,6.95
-"string28",2,3.39
-"string29",3,6.79
-"string30",7,9.735
-"string31",1,9.79
-"string32",10,9.955
-"string33",1,5.095
-"string34",3,3.86
-"string35",9,5.105
-"string36",10,4.22
-"string37",1,2.78
-"string38",9,6.345
-"string39",1,0.975
-"string40",5,6.16
-"string41",4,7.735
-"string42",5,6.6
-"string43",8,2.845
-"string44",1,0.655
-"string45",3,2.995
-"string46",9,3.6
-"string47",8,3.47
-"string48",3,7.98
-"string49",6,2.225
-"string50",9,5.44
-"string51",4,6.335
-"string52",3,2.955
-"string53",1,0.565
-"string54",6,5.575
-"string55",6,9.905
-"string56",9,6.025
-"string57",8,0.94
-"string58",10,0.15
-"string59",8,1.555
-"string60",4,2.28
-"string61",2,8.29
-"string62",9,6.22
-"string63",6,3.35
-"string64",10,6.7
-"string65",3,9.345
-"string66",7,9.815
-"string67",1,5.365
-"string68",10,3.81
-"string69",1,6.405
-"string70",8,2.715
-"string71",3,8.58
-"string72",8,6.34
-"string73",2,7.49
-"string74",4,8.64
-"string75",3,8.995
-"string76",7,3.465
-"string77",1,7.64
-"string78",6,3.65
-"string79",6,1.4
-"string80",6,5.875
-"string81",2,1.22
-"string82",5,7.87
-"string83",9,8.41
-"string84",9,8.9
-"string85",9,3.89
-"string86",2,5.0
-"string87",2,4.495
-"string88",4,2.835
-"string89",3,5.895
-"string90",7,8.41
-"string91",5,5.125
-"string92",7,9.165
-"string93",5,8.315
-"string94",10,7.485
-"string95",7,4.635
-"string96",2,6.015
-"string97",8,0.595
-"string98",3,8.79
-"string99",4,1.72
--- a/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoInsertMSDB.json
+++ b/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoInsertMSDB.json
@ -1,63 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 10,
-    "create_table_thread_count": 10,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 100,
-    "num_of_records_per_req": 1000,
-    "max_sql_len": 1024000,
-    "databases": [{
-        "dbinfo": {
-            "name": "testdb3",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "ms",
-            "keep": 3600,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": 100,
-            "childtable_prefix": "tb0_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 20,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 100,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1000,
-            "start_timestamp": "2021-07-01 00:00:00.000",
-            "sample_format": "",
-            "sample_file": "",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":3}, {"type": "BINARY", "len": 16, "count":2}, {"type": "BINARY", "len": 32, "count":2},
-            {"type": "TIMESTAMP"}, {"type": "BIGINT", "count":3},{"type": "FLOAT", "count":1},{"type": "SMALLINT", "count":1},{"type": "TINYINT", "count":1},
-                {"type": "BOOL"},{"type": "NCHAR","len":16}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5},{"type": "NCHAR","len":16, "count":1}]
-        }]
-    }]
-}
-
--- a/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoInsertNanoDB.json
+++ b/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoInsertNanoDB.json
@ -1,63 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 10,
-    "create_table_thread_count": 10,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 100,
-    "num_of_records_per_req": 1000,
-    "max_sql_len": 1024000,
-    "databases": [{
-        "dbinfo": {
-            "name": "testdb1",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "ns",
-            "keep": 3600,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": 100,
-            "childtable_prefix": "tb0_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 20,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 100,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1000,
-            "start_timestamp": "2021-07-01 00:00:00.000",
-            "sample_format": "",
-            "sample_file": "",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":3}, {"type": "BINARY", "len": 16, "count":2}, {"type": "BINARY", "len": 32, "count":2},
-            {"type": "TIMESTAMP"}, {"type": "BIGINT", "count":3},{"type": "FLOAT", "count":1},{"type": "SMALLINT", "count":1},{"type": "TINYINT", "count":1},
-                {"type": "BOOL"},{"type": "NCHAR","len":16}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5},{"type": "NCHAR","len":16, "count":1}]
-        }]
-    }]
-}
-
--- a/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoInsertUSDB.json
+++ b/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoInsertUSDB.json
@ -1,63 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 10,
-    "create_table_thread_count": 10,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 100,
-    "num_of_records_per_req": 1000,
-    "max_sql_len": 1024000,
-    "databases": [{
-        "dbinfo": {
-            "name": "testdb2",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "us",
-            "keep": 3600,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": 100,
-            "childtable_prefix": "tb0_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 20,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 100,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1000,
-            "start_timestamp": "2021-07-01 00:00:00.000",
-            "sample_format": "",
-            "sample_file": "",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":3}, {"type": "BINARY", "len": 16, "count":2}, {"type": "BINARY", "len": 32, "count":2},
-            {"type": "TIMESTAMP"}, {"type": "BIGINT", "count":3},{"type": "FLOAT", "count":1},{"type": "SMALLINT", "count":1},{"type": "TINYINT", "count":1},
-                {"type": "BOOL"},{"type": "NCHAR","len":16}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5},{"type": "NCHAR","len":16, "count":1}]
-        }]
-    }]
-}
-
--- a/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestInsertTime_step.py
+++ b/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestInsertTime_step.py
@ -1,115 +0,0 @@
-###################################################################
-#           Copyright (c) 2016 by TAOS Technologies, Inc.
-#                     All rights reserved.
-#
-#  This file is proprietary and confidential to TAOS Technologies.
-#  No part of this file may be reproduced, stored, transmitted,
-#  disclosed or used in any form or by any means other than as
-#  expressly provided by the written permission from Jianhui Tao
-#
-###################################################################
-
-# -*- coding: utf-8 -*-
-
-import sys
-import os
-from util.log import *
-from util.cases import *
-from util.sql import *
-from util.dnodes import *
-
-
-class TDTestCase:
-    def init(self, conn, logSql):
-        tdLog.debug("start to execute %s" % __file__)
-        tdSql.init(conn.cursor(), logSql)
-
-    def getBuildPath(self):
-        selfPath = os.path.dirname(os.path.realpath(__file__))
-
-        if ("community" in selfPath):
-            projPath = selfPath[:selfPath.find("community")]
-        else:
-            projPath = selfPath[:selfPath.find("tests")]
-
-        for root, dirs, files in os.walk(projPath):
-            if ("taosd" in files):
-                rootRealPath = os.path.dirname(os.path.realpath(root))
-                if ("packaging" not in rootRealPath):
-                    buildPath = root[:len(root)-len("/build/bin")]
-                    break
-        return buildPath
-
-    def run(self):
-        buildPath = self.getBuildPath()
-        if (buildPath == ""):
-            tdLog.exit("taosd not found!")
-        else:
-            tdLog.info("taosd found in %s" % buildPath)
-        binPath = buildPath+ "/build/bin/"
-
-        # insert: create one  or mutiple tables per sql and insert multiple rows per sql
-        
-        # check the params of taosdemo about time_step is nano
-        os.system("%staosdemo -f tools/taosdemoAllTest/NanoTestCase/taosdemoInsertNanoDB.json -y " % binPath)
-        tdSql.execute("use testdb1")
-        tdSql.query("show stables")
-        tdSql.checkData(0, 4, 100)
-        tdSql.query("select count (tbname) from stb0")
-        tdSql.checkData(0, 0, 100)
-        tdSql.query("select count(*) from tb0_0")
-        tdSql.checkData(0, 0, 100)
-        tdSql.query("select count(*) from stb0")
-        tdSql.checkData(0, 0, 10000)
-        tdSql.query("describe stb0")
-        tdSql.getData(9, 1)
-        tdSql.checkDataType(9, 1,"TIMESTAMP")
-        tdSql.query("select last(ts) from stb0")
-        tdSql.checkData(0, 0,"2021-07-01 00:00:00.000099000") 
-
-        # check the params of taosdemo about time_step is us
-        os.system("%staosdemo -f tools/taosdemoAllTest/NanoTestCase/taosdemoInsertUSDB.json -y " % binPath)
-        tdSql.execute("use testdb2")
-        tdSql.query("show stables")
-        tdSql.checkData(0, 4, 100)
-        tdSql.query("select count (tbname) from stb0")
-        tdSql.checkData(0, 0, 100)
-        tdSql.query("select count(*) from tb0_0")
-        tdSql.checkData(0, 0, 100)
-        tdSql.query("select count(*) from stb0")
-        tdSql.checkData(0, 0, 10000)
-        tdSql.query("describe stb0")
-        tdSql.getData(9, 1)
-        tdSql.checkDataType(9, 1,"TIMESTAMP")
-        tdSql.query("select last(ts) from stb0")
-        tdSql.checkData(0, 0,"2021-07-01 00:00:00.099000") 
-
-        # check the params of taosdemo about time_step is ms
-        os.system("%staosdemo -f tools/taosdemoAllTest/NanoTestCase/taosdemoInsertMSDB.json -y " % binPath)
-        tdSql.execute("use testdb3")
-        tdSql.query("show stables")
-        tdSql.checkData(0, 4, 100)
-        tdSql.query("select count (tbname) from stb0")
-        tdSql.checkData(0, 0, 100)
-        tdSql.query("select count(*) from tb0_0")
-        tdSql.checkData(0, 0, 100)
-        tdSql.query("select count(*) from stb0")
-        tdSql.checkData(0, 0, 10000)
-        tdSql.query("describe stb0")
-        tdSql.checkDataType(9, 1,"TIMESTAMP")
-        tdSql.query("select last(ts) from stb0")
-        tdSql.checkData(0, 0,"2021-07-01 00:01:39.000") 
-
-      
-        os.system("rm -rf ./res.txt")
-        os.system("rm -rf ./*.py.sql")
-      
-       
-
-    def stop(self):
-        tdSql.close()
-        tdLog.success("%s successfully executed" % __file__)
-
-
-tdCases.addWindows(__file__, TDTestCase())
-tdCases.addLinux(__file__, TDTestCase())
--- a/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestNanoDatabase.json
+++ b/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestNanoDatabase.json
@ -1,88 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 10,
-    "create_table_thread_count": 10,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 100,
-    "num_of_records_per_req": 1000,
-    "max_sql_len": 1024000,
-    "databases": [{
-        "dbinfo": {
-            "name": "nsdb",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "ns",
-            "keep": 3600,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": 100,
-            "childtable_prefix": "tb0_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 20,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 100,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 10000000,
-            "start_timestamp": "2021-07-01 00:00:00.000",
-            "sample_format": "",
-            "sample_file": "",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":3}, {"type": "BINARY", "len": 16, "count":2}, {"type": "BINARY", "len": 32, "count":2},
-            {"type": "TIMESTAMP"}, {"type": "BIGINT", "count":3},{"type": "FLOAT", "count":1},{"type": "SMALLINT", "count":1},{"type": "TINYINT", "count":1},
-                {"type": "BOOL"},{"type": "NCHAR","len":16}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5},{"type": "NCHAR","len":16, "count":1}]
-        },
-        {
-            "name": "stb1",
-            "child_table_exists":"no",
-            "childtable_count": 100,
-            "childtable_prefix": "tb1_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 20,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 100,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 10,
-            "disorder_range": 1000,
-            "timestamp_step": 10000000,
-            "start_timestamp": "2021-07-01 00:00:00.000",
-            "sample_format": "",
-            "sample_file": "",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":3}, {"type": "BINARY", "len": 16, "count":2}, {"type": "BINARY", "len": 32, "count":2},
-            {"type": "TIMESTAMP"}, {"type": "BIGINT", "count":3},{"type": "FLOAT", "count":1},{"type": "SMALLINT", "count":1},{"type": "TINYINT", "count":1},
-                {"type": "BOOL"},{"type": "NCHAR","len":16}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5},{"type": "NCHAR","len":16, "count":1}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestNanoDatabaseInsertForSub.json
+++ b/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestNanoDatabaseInsertForSub.json
@ -1,84 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 10,
-    "create_table_thread_count": 10,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 100,
-    "num_of_records_per_req": 1000,
-    "max_sql_len": 1024000,
-    "databases": [{
-        "dbinfo": {
-            "name": "subnsdb",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "ns",
-            "keep": 3600,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": 10,
-            "childtable_prefix": "tb0_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 20,
-            "data_source": "samples",
-            "insert_mode": "taosc",
-            "insert_rows": 10,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 10000000,
-            "start_timestamp": "2021-07-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./tools/taosdemoAllTest/NanoTestCase/nano_samples.csv",
-            "tags_file": "./tools/taosdemoAllTest/NanoTestCase/nano_sampletags.csv",
-            "columns": [{"type": "DOUBLE"}, {"type": "BINARY", "len": 64, "count":1}, {"type": "TIMESTAMP", "count":1}],
-            "tags": [{"type": "BINARY", "len": 16, "count":1},{"type": "INT"},{"type": "DOUBLE"}]
-        },
-        {
-            "name": "stb1",
-            "child_table_exists":"no",
-            "childtable_count": 10,
-            "childtable_prefix": "tb1_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 20,
-            "data_source": "samples",
-            "insert_mode": "taosc",
-            "insert_rows": 10,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 10,
-            "disorder_range": 1000,
-            "timestamp_step": 10000000,
-            "start_timestamp": "2021-07-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./tools/taosdemoAllTest/NanoTestCase/nano_samples.csv",
-            "tags_file": "./tools/taosdemoAllTest/NanoTestCase/nano_sampletags.csv",
-            "columns": [{"type": "DOUBLE"}, {"type": "BINARY", "len": 64, "count":1}, {"type": "TIMESTAMP", "count":1}],
-            "tags": [{"type": "BINARY", "len": 16, "count":1},{"type": "INT"},{"type": "DOUBLE"}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestNanoDatabaseNow.json
+++ b/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestNanoDatabaseNow.json
@ -1,62 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 10,
-    "create_table_thread_count": 10,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 100,
-    "num_of_records_per_req": 1000,
-    "max_sql_len": 1024000,
-    "databases": [{
-        "dbinfo": {
-            "name": "nsdb2",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "ns",
-            "keep": 3600,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": 100,
-            "childtable_prefix": "tb0_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 20,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 100,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 10,
-            "start_timestamp": "now",
-            "sample_format": "",
-            "sample_file": "",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":3}, {"type": "BINARY", "len": 16, "count":2}, {"type": "BINARY", "len": 32, "count":2},
-            {"type": "TIMESTAMP"}, {"type": "BIGINT", "count":3},{"type": "FLOAT", "count":1},{"type": "SMALLINT", "count":1},{"type": "TINYINT", "count":1},
-                {"type": "BOOL"},{"type": "NCHAR","len":16}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5},{"type": "NCHAR","len":16, "count":1}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestNanoDatabasecsv.json
+++ b/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestNanoDatabasecsv.json
@ -1,84 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 10,
-    "create_table_thread_count": 10,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 100,
-    "num_of_records_per_req": 1000,
-    "max_sql_len": 1024000,
-    "databases": [{
-        "dbinfo": {
-            "name": "nsdbcsv",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "ns",
-            "keep": 3600,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": 100,
-            "childtable_prefix": "tb0_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 20,
-            "data_source": "samples",
-            "insert_mode": "taosc",
-            "insert_rows": 100,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 10000000,
-            "start_timestamp": "2021-07-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./tools/taosdemoAllTest/NanoTestCase/nano_samples.csv",
-            "tags_file": "./tools/taosdemoAllTest/NanoTestCase/nano_sampletags.csv",
-            "columns": [{"type": "DOUBLE"}, {"type": "BINARY", "len": 64, "count":1}, {"type": "TIMESTAMP", "count":1}],
-            "tags": [{"type": "BINARY", "len": 16, "count":1},{"type": "INT"},{"type": "DOUBLE"}]
-        },
-        {
-            "name": "stb1",
-            "child_table_exists":"no",
-            "childtable_count": 100,
-            "childtable_prefix": "tb1_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 20,
-            "data_source": "samples",
-            "insert_mode": "taosc",
-            "insert_rows": 100,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 10,
-            "disorder_range": 1000,
-            "timestamp_step": 10000000,
-            "start_timestamp": "2021-07-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./tools/taosdemoAllTest/NanoTestCase/nano_samples.csv",
-            "tags_file": "./tools/taosdemoAllTest/NanoTestCase/nano_sampletags.csv",
-            "columns": [{"type": "DOUBLE"}, {"type": "BINARY", "len": 64, "count":1}, {"type": "TIMESTAMP", "count":1}],
-            "tags": [{"type": "BINARY", "len": 16, "count":1},{"type": "INT"},{"type": "DOUBLE"}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestSupportNanoInsert.py
+++ b/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestSupportNanoInsert.py
@ -1,169 +0,0 @@
-###################################################################
-#           Copyright (c) 2016 by TAOS Technologies, Inc.
-#                     All rights reserved.
-#
-#  This file is proprietary and confidential to TAOS Technologies.
-#  No part of this file may be reproduced, stored, transmitted,
-#  disclosed or used in any form or by any means other than as
-#  expressly provided by the written permission from Jianhui Tao
-#
-###################################################################
-
-# -*- coding: utf-8 -*-
-
-import sys
-import os
-from util.log import *
-from util.cases import *
-from util.sql import *
-from util.dnodes import *
-
-
-class TDTestCase:
-    def init(self, conn, logSql):
-        tdLog.debug("start to execute %s" % __file__)
-        tdSql.init(conn.cursor(), logSql)
-
-    def getBuildPath(self):
-        selfPath = os.path.dirname(os.path.realpath(__file__))
-
-        if ("community" in selfPath):
-            projPath = selfPath[:selfPath.find("community")]
-        else:
-            projPath = selfPath[:selfPath.find("tests")]
-
-        for root, dirs, files in os.walk(projPath):
-            if ("taosd" in files):
-                rootRealPath = os.path.dirname(os.path.realpath(root))
-                if ("packaging" not in rootRealPath):
-                    buildPath = root[:len(root) - len("/build/bin")]
-                    break
-        return buildPath
-
-    def run(self):
-        buildPath = self.getBuildPath()
-        if (buildPath == ""):
-            tdLog.exit("taosd not found!")
-        else:
-            tdLog.info("taosd found in %s" % buildPath)
-        binPath = buildPath + "/build/bin/"
-
-        # insert: create one  or mutiple tables per sql and insert multiple rows per sql
-        # insert data from a special timestamp
-        # check stable stb0
-
-        os.system(
-            "%staosdemo -f tools/taosdemoAllTest/NanoTestCase/taosdemoTestNanoDatabase.json -y " %
-            binPath)
-        tdSql.execute("use nsdb")
-        tdSql.query("show stables")
-        tdSql.checkData(0, 4, 100)
-        tdSql.query("select count (tbname) from stb0")
-        tdSql.checkData(0, 0, 100)
-        tdSql.query("select count(*) from tb0_0")
-        tdSql.checkData(0, 0, 100)
-        tdSql.query("select count(*) from stb0")
-        tdSql.checkData(0, 0, 10000)
-        tdSql.query("describe stb0")
-        tdSql.checkDataType(9, 1, "TIMESTAMP")
-        tdSql.query("select last(ts) from stb0")
-        tdSql.checkData(0, 0, "2021-07-01 00:00:00.990000000")
-
-        # check stable stb1 which is insert with disord
-
-        tdSql.query("select count (tbname) from stb1")
-        tdSql.checkData(0, 0, 100)
-        tdSql.query("select count(*) from tb1_0")
-        tdSql.checkData(0, 0, 100)
-        tdSql.query("select count(*) from stb1")
-        tdSql.checkData(0, 0, 10000)
-        # check c8 is an nano timestamp
-        tdSql.query("describe stb1")
-        tdSql.checkDataType(9, 1, "TIMESTAMP")
-        # check insert timestamp_step is nano_second
-        tdSql.query("select last(ts) from stb1")
-        tdSql.checkData(0, 0, "2021-07-01 00:00:00.990000000")
-
-        # insert data from now time
-
-        # check stable stb0
-        os.system(
-            "%staosdemo -f tools/taosdemoAllTest/NanoTestCase/taosdemoTestNanoDatabaseNow.json -y " %
-            binPath)
-
-        tdSql.execute("use nsdb2")
-        tdSql.query("show stables")
-        tdSql.checkData(0, 4, 100)
-        tdSql.query("select count (tbname) from stb0")
-        tdSql.checkData(0, 0, 100)
-        tdSql.query("select count(*) from tb0_0")
-        tdSql.checkData(0, 0, 100)
-        tdSql.query("select count(*) from stb0")
-        tdSql.checkData(0, 0, 10000)
-        # check c8 is an nano timestamp
-        tdSql.query("describe stb0")
-        tdSql.checkDataType(9, 1, "TIMESTAMP")
-
-        # insert by csv files and timetamp is long int , strings  in ts and
-        # cols
-
-        os.system(
-            "%staosdemo -f tools/taosdemoAllTest/NanoTestCase/taosdemoTestNanoDatabasecsv.json  -y " %
-            binPath)
-        tdSql.execute("use nsdbcsv")
-        tdSql.query("show stables")
-        tdSql.checkData(0, 4, 100)
-        tdSql.query("select count(*) from stb0")
-        tdSql.checkData(0, 0, 10000)
-        tdSql.query("describe stb0")
-        tdSql.checkDataType(3, 1, "TIMESTAMP")
-        tdSql.query(
-            "select count(*) from stb0 where ts > \"2021-07-01 00:00:00.490000000\"")
-        tdSql.checkData(0, 0, 5000)
-        tdSql.query("select count(*) from stb0 where ts < 1626918583000000000")
-        tdSql.checkData(0, 0, 10000)
-
-        os.system("rm -rf ./insert_res.txt")
-        os.system(
-            "rm -rf tools/taosdemoAllTest/NanoTestCase/taosdemoTestSupportNano*.py.sql")
-
-        # taosdemo test insert with command and parameter , detals show
-        # taosdemo --help
-        os.system(
-            "%staosdemo  -u root -ptaosdata -P 6030  -a 1  -m pre -n 10 -T 20 -t 60 -o res.txt -y " %
-            binPath)
-        tdSql.query("select count(*) from test.meters")
-        tdSql.checkData(0, 0, 600)
-        # check taosdemo -s
-
-        sqls_ls = [
-            'drop database  if exists nsdbsql;',
-            'create database nsdbsql precision "ns" keep 3600 duration 6 update 1;',
-            'use nsdbsql;',
-            'CREATE STABLE meters (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupdId int);',
-            'CREATE TABLE d1001 USING meters TAGS ("Beijing.Chaoyang", 2);',
-            'INSERT INTO d1001 USING METERS TAGS ("Beijng.Chaoyang", 2) VALUES (now, 10.2, 219, 0.32);',
-            'INSERT INTO d1001 USING METERS TAGS ("Beijng.Chaoyang", 2) VALUES (now, 85, 32, 0.76);']
-
-        with open("./taosdemoTestNanoCreateDB.sql", mode="a") as sql_files:
-            for sql in sqls_ls:
-                sql_files.write(sql + "\n")
-            sql_files.close()
-
-        sleep(10)
-
-        os.system("%staosdemo  -s taosdemoTestNanoCreateDB.sql  -y " % binPath)
-        tdSql.query("select count(*) from nsdbsql.meters")
-        tdSql.checkData(0, 0, 2)
-
-        os.system("rm -rf ./res.txt")
-        os.system("rm -rf ./*.py.sql")
-        os.system("rm -rf ./taosdemoTestNanoCreateDB.sql")
-
-    def stop(self):
-        tdSql.close()
-        tdLog.success("%s successfully executed" % __file__)
-
-
-tdCases.addWindows(__file__, TDTestCase())
-tdCases.addLinux(__file__, TDTestCase())
--- a/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestSupportNanoQuery.json
+++ b/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestSupportNanoQuery.json
@ -1,92 +0,0 @@
-{
-    "filetype": "query",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "confirm_parameter_prompt": "no",
-    "databases": "nsdb",
-    "query_times": 10,
-    "query_mode": "taosc",
-    "specified_table_query": {
-      "query_interval": 1,
-      "concurrent": 2,
-      "sqls": [
-        {
-          "sql": "select count(*) from stb0 where ts>\"2021-07-01 00:01:00.000000000 \" ;",
-          "result": "./query_res0.txt"
-        },
-        {
-          "sql": "select count(*) from stb0 where ts>\"2021-07-01 00:01:00.000000000\" and ts <=\"2021-07-01 00:01:10.000000000\" ;",
-          "result": "./query_res1.txt"
-        },
-        {
-            "sql": "select count(*) from stb0 where ts>now-20d ;",
-            "result": "./query_res2.txt"
-        },
-        {
-          "sql": "select max(c10) from stb0;",
-          "result": "./query_res3.txt"
-        },
-        {
-            "sql": "select min(c1) from stb0;",
-            "result": "./query_res4.txt"
-        },
-        {
-            "sql": "select avg(c1) from stb0;",
-            "result": "./query_res5.txt"
-        },
-        {
-            "sql":"select count(*) from stb0 group by tbname;",
-            "result":"./query_res6.txt"
-        }
-
-      ]
-    },
-    "super_table_query": {
-      "stblname": "stb0",
-      "query_interval": 0,
-      "threads": 4,
-      "sqls": [
-        {
-          "sql": "select count(*) from xxxx where ts>\"2021-07-01 00:01:00.000000000 \" ;",
-          "result": "./query_res_tb0.txt"
-        },
-        {
-          "sql":"select count(*) from xxxx where ts>\"2021-07-01 00:01:00.000000000\" and ts <=\"2021-07-01 00:01:10.000000000\" ;",
-          "result": "./query_res_tb1.txt"
-        },
-        {
-            "sql":"select first(*) from xxxx ;",
-            "result": "./query_res_tb2.txt"
-        },
-        {
-            "sql":"select last(*) from xxxx;",
-            "result": "./query_res_tb3.txt"
-
-        },
-        {
-            "sql":"select last_row(*) from xxxx  ;",
-            "result": "./query_res_tb4.txt"
-
-        },
-        {
-            "sql":"select max(c10) from xxxx  ;",
-            "result": "./query_res_tb5.txt"
-
-        },
-        {
-            "sql":"select min(c1) from xxxx  ;",
-            "result": "./query_res_tb6.txt"
-
-        },
-        {
-            "sql":"select avg(c10) from xxxx  ;",
-            "result": "./query_res_tb7.txt"
-
-        }
-
-      ]
-    }
-  }
--- a/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestSupportNanoQuery.py
+++ b/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestSupportNanoQuery.py
@ -1,157 +0,0 @@
-###################################################################
-#           Copyright (c) 2016 by TAOS Technologies, Inc.
-#                     All rights reserved.
-#
-#  This file is proprietary and confidential to TAOS Technologies.
-#  No part of this file may be reproduced, stored, transmitted,
-#  disclosed or used in any form or by any means other than as
-#  expressly provided by the written permission from Jianhui Tao
-#
-###################################################################
-
-# -*- coding: utf-8 -*-
-
-import sys
-import os
-from util.log import *
-from util.cases import *
-from util.sql import *
-from util.dnodes import *
-
-
-class TDTestCase:
-    def init(self, conn, logSql):
-        tdLog.debug("start to execute %s" % __file__)
-        tdSql.init(conn.cursor(), logSql)
-
-    def getBuildPath(self):
-        selfPath = os.path.dirname(os.path.realpath(__file__))
-
-        if ("community" in selfPath):
-            projPath = selfPath[:selfPath.find("community")]
-        else:
-            projPath = selfPath[:selfPath.find("tests")]
-
-        for root, dirs, files in os.walk(projPath):
-            if ("taosd" in files):
-                rootRealPath = os.path.dirname(os.path.realpath(root))
-                if ("packaging" not in rootRealPath):
-                    buildPath = root[:len(root)-len("/build/bin")]
-                    break
-        return buildPath
-
-    def run(self):
-        buildPath = self.getBuildPath()
-        if (buildPath == ""):
-            tdLog.exit("taosd not found!")
-        else:
-            tdLog.info("taosd found in %s" % buildPath)
-        binPath = buildPath+ "/build/bin/"
-
-       # query: query test for nanoSecond  with where and max min groupby order 
-        os.system("%staosdemo -f tools/taosdemoAllTest/NanoTestCase/taosdemoTestNanoDatabase.json -y " % binPath)
-
-        tdSql.execute("use nsdb")
-
-        # use where to filter 
-        
-        tdSql.query("select count(*) from stb0 where ts>\"2021-07-01 00:00:00.590000000 \" ")
-        tdSql.checkData(0, 0, 4000)
-        tdSql.query("select count(*) from stb0 where ts>\"2021-07-01 00:00:00.000000000\" and ts <=\"2021-07-01 00:00:00.590000000\" ")
-        tdSql.checkData(0, 0, 5900)
-
-        tdSql.query("select count(*) from tb0_0 where ts>\"2021-07-01 00:00:00.590000000 \" ;")
-        tdSql.checkData(0, 0, 40)
-        tdSql.query("select count(*) from tb0_0 where ts>\"2021-07-01 00:00:00.000000000\" and ts <=\"2021-07-01 00:00:00.590000000\" ")
-        tdSql.checkData(0, 0, 59)
-
-
-        # select max min avg from special col
-        tdSql.query("select max(c10) from stb0;")
-        print("select max(c10) from stb0 : " , tdSql.getData(0, 0))
-
-        tdSql.query("select max(c10) from tb0_0;")
-        print("select max(c10) from tb0_0 : " , tdSql.getData(0, 0))
-       
-
-        tdSql.query("select min(c1) from stb0;")
-        print( "select min(c1) from stb0 : " , tdSql.getData(0, 0))
-
-        tdSql.query("select min(c1) from tb0_0;")
-        print( "select min(c1) from tb0_0 : " , tdSql.getData(0, 0))
-
-        tdSql.query("select avg(c1) from stb0;")
-        print( "select avg(c1) from stb0 : " , tdSql.getData(0, 0))
-
-        tdSql.query("select avg(c1) from tb0_0;")
-        print( "select avg(c1) from tb0_0 : " , tdSql.getData(0, 0))
-
-        tdSql.query("select count(*) from stb0 group by tbname;")
-        tdSql.checkData(0, 0, 100)
-        tdSql.checkData(10, 0, 100)
-
-         #  query : query above sqls by taosdemo and continuously
-
-        os.system("%staosdemo -f tools/taosdemoAllTest/NanoTestCase/taosdemoTestSupportNanoQuery.json -y " % binPath)
-
-
-        os.system("%staosdemo -f tools/taosdemoAllTest/NanoTestCase/taosdemoTestNanoDatabasecsv.json  -y " % binPath)
-        tdSql.execute("use nsdbcsv")
-        tdSql.query("show stables")
-        tdSql.checkData(0, 4, 100)
-        tdSql.query("select count(*) from stb0")
-        tdSql.checkData(0, 0, 10000)
-        tdSql.query("describe stb0")
-        tdSql.checkDataType(3, 1, "TIMESTAMP")
-        tdSql.query("select count(*) from stb0 where ts >\"2021-07-01 00:00:00.490000000\"")
-        tdSql.checkData(0, 0, 5000)
-        tdSql.query("select count(*) from stb0 where ts <now -1d-1h-3s")
-        tdSql.checkData(0, 0, 10000)
-        tdSql.query("select count(*) from stb0 where ts < 1626918583000000000")
-        tdSql.checkData(0, 0, 10000)
-        tdSql.execute('select count(*) from stb0 where c2 >  162687012800000000')
-        tdSql.execute('select count(*) from stb0 where c2 <  162687012800000000')
-        tdSql.execute('select count(*) from stb0 where c2 =  162687012800000000')
-        tdSql.execute('select count(*) from stb0 where c2 != 162687012800000000')
-        tdSql.execute('select count(*) from stb0 where c2 <> 162687012800000000')
-        tdSql.execute('select count(*) from stb0 where c2 >  "2021-07-21 20:22:08.248246976"')
-        tdSql.execute('select count(*) from stb0 where c2 <  "2021-07-21 20:22:08.248246976"')
-        tdSql.execute('select count(*) from stb0 where c2 =  "2021-07-21 20:22:08.248246976"')
-        tdSql.execute('select count(*) from stb0 where c2 != "2021-07-21 20:22:08.248246976"')
-        tdSql.execute('select count(*) from stb0 where c2 <> "2021-07-21 20:22:08.248246976"')
-        tdSql.execute('select count(*) from stb0 where ts between "2021-07-01 00:00:00.000000000" and "2021-07-01 00:00:00.990000000"')
-        tdSql.execute('select count(*) from stb0 where ts between 1625068800000000000 and 1625068801000000000')
-        tdSql.query('select avg(c0) from stb0 interval(5000000000b)')
-        tdSql.checkRows(1)
-
-        tdSql.query('select avg(c0) from stb0 interval(100000000b)')
-        tdSql.checkRows(10)
-
-        tdSql.error('select avg(c0) from stb0 interval(1b)')
-        tdSql.error('select avg(c0) from stb0 interval(999b)')
-
-        tdSql.query('select avg(c0) from stb0 interval(1000b)')
-        tdSql.checkRows(100)
-
-        tdSql.query('select avg(c0) from stb0 interval(1u)')
-        tdSql.checkRows(100)
-
-        tdSql.query('select avg(c0) from stb0 interval(100000000b) sliding (100000000b)')
-        tdSql.checkRows(10)
-
-        #  query : query above sqls by taosdemo and continuously
-        os.system("%staosdemo -f tools/taosdemoAllTest/NanoTestCase/taosdemoTestSupportNanoQuerycsv.json -y " % binPath)
-
-        os.system("rm -rf ./query_res*.txt*")
-        os.system("rm -rf tools/taosdemoAllTest/NanoTestCase/*.py.sql")
- 
-
-
-
-    def stop(self):
-        tdSql.close()
-        tdLog.success("%s successfully executed" % __file__)
-
-
-tdCases.addWindows(__file__, TDTestCase())
-tdCases.addLinux(__file__, TDTestCase())
--- a/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestSupportNanoQuerycsv.json
+++ b/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestSupportNanoQuerycsv.json
@ -1,110 +0,0 @@
-{
-    "filetype": "query",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "confirm_parameter_prompt": "no",
-    "databases": "nsdbcsv",
-    "query_times": 10,
-    "query_mode": "taosc",
-    "specified_table_query": {
-      "query_interval": 1,
-      "concurrent": 2,
-      "sqls": [
-        {
-          "sql": "select count(*) from stb0 where ts> \"2021-07-01 00:00:00.490000000\" ;",
-          "result": "./query_res0.txt"
-        },
-        {
-          "sql": "select count(*) from stb0 where ts < now -22d-1h-3s ;",
-          "result": "./query_res1.txt"
-        },
-        {
-            "sql": "select count(*) from stb0 where ts < 1626918583000000000 ;",
-            "result": "./query_res2.txt"
-        },
-        {
-          "sql": "select count(*) from stb0 where c2 <>  162687012800000000;",
-          "result": "./query_res3.txt"
-        },
-        {
-            "sql": "select count(*) from stb0 where c2 != \"2021-07-21 20:22:08.248246976\";",
-            "result": "./query_res4.txt"
-        },
-        {
-            "sql": "select count(*) from stb0 where ts between \"2021-07-01 00:00:00.000000000\" and \"2021-07-01 00:00:00.990000000\";",
-            "result": "./query_res5.txt"
-        },
-        {
-            "sql":"select count(*) from stb0 group by tbname;",
-            "result":"./query_res6.txt"
-        },
-        {
-          "sql":"select count(*) from stb0 where ts between 1625068800000000000 and 1625068801000000000;",
-          "result":"./query_res7.txt"
-        },
-        {
-          "sql":"select avg(c0) from stb0 interval(5000000000b);",
-          "result":"./query_res8.txt"
-        },
-        {
-          "sql":"select avg(c0) from stb0 interval(100000000b) sliding (100000000b);",
-          "result":"./query_res9.txt"
-        }
-
-      ]
-    },
-    "super_table_query": {
-      "stblname": "stb0",
-      "query_interval": 0,
-      "threads": 4,
-      "sqls": [
-        {
-          "sql": "select count(*) from xxxx where ts > \"2021-07-01 00:00:00.490000000\" ;",
-          "result": "./query_res_tb0.txt"
-        },
-        {
-          "sql":"select count(*) from xxxx where ts between \"2021-07-01 00:00:00.000000000\" and \"2021-07-01 00:00:00.990000000\" ;",
-          "result": "./query_res_tb1.txt"
-        },
-        {
-            "sql":"select first(*) from xxxx ;",
-            "result": "./query_res_tb2.txt"
-        },
-        {
-            "sql":"select last(*) from xxxx;",
-            "result": "./query_res_tb3.txt"
-
-        },
-        {
-            "sql":"select last_row(*) from xxxx  ;",
-            "result": "./query_res_tb4.txt"
-
-        },
-        {
-            "sql":"select max(c0) from xxxx  ;",
-            "result": "./query_res_tb5.txt"
-
-        },
-        {
-            "sql":"select min(c0) from xxxx  ;",
-            "result": "./query_res_tb6.txt"
-
-        },
-        {
-            "sql":"select avg(c0) from xxxx  ;",
-            "result": "./query_res_tb7.txt"
-
-        },
-        {
-          "sql":"select avg(c0) from xxxx interval(100000000b) sliding (100000000b) ;",
-          "result": "./query_res_tb8.txt"
-
-        }
-
-
-      ]
-    }
-  }
--- a/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestSupportNanoSubscribe.json
+++ b/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestSupportNanoSubscribe.json
@ -1,32 +0,0 @@
-{
-  "filetype":"subscribe",
-  "cfgdir": "/etc/taos",
-  "host": "127.0.0.1",
-  "port": 6030,
-  "user": "root",
-  "password": "taosdata",
-  "databases": "subnsdb",
-  "confirm_parameter_prompt": "no",
-  "specified_table_query":
-    {
-     "concurrent":2, 
-     "mode":"sync", 
-     "interval":10000, 
-     "restart":"yes", 
-     "keepProgress":"yes",
-     "sqls": [
-      {
-        "sql": "select * from stb0 where ts>= \"2021-07-01 00:00:00.000000000\" ;",
-        "result": "./subscribe_res0.txt"
-      },
-      {
-        "sql": "select * from stb0 where ts < now -2d-1h-3s ;",
-        "result": "./subscribe_res1.txt"
-      },
-      {
-          "sql": "select * from stb0 where ts < 1626918583000000000 ;",
-          "result": "./subscribe_res2.txt"
-      }]
-
-    }
-}
--- a/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestSupportNanosubscribe.py
+++ b/tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestSupportNanosubscribe.py
@ -1,125 +0,0 @@
-###################################################################
-#           Copyright (c) 2016 by TAOS Technologies, Inc.
-#                     All rights reserved.
-#
-#  This file is proprietary and confidential to TAOS Technologies.
-#  No part of this file may be reproduced, stored, transmitted,
-#  disclosed or used in any form or by any means other than as
-#  expressly provided by the written permission from Jianhui Tao
-#
-###################################################################
-
-# -*- coding: utf-8 -*-
-
-import sys
-import os
-from util.log import *
-from util.cases import *
-from util.sql import *
-from util.dnodes import *
-import time
-from datetime import datetime
-import subprocess
-
-
-class TDTestCase:
-    def init(self, conn, logSql):
-        tdLog.debug("start to execute %s" % __file__)
-        tdSql.init(conn.cursor(), logSql)
-        
-    def getBuildPath(self):
-        selfPath = os.path.dirname(os.path.realpath(__file__))
-
-        if ("community" in selfPath):
-            projPath = selfPath[:selfPath.find("community")]
-        else:
-            projPath = selfPath[:selfPath.find("tests")]
-
-        for root, dirs, files in os.walk(projPath):
-            if ("taosd" in files):
-                rootRealPath = os.path.dirname(os.path.realpath(root))
-                if ("packaging" not in rootRealPath):
-                    buildPath = root[:len(root)-len("/build/bin")]
-                    break
-        return buildPath
-
-    # get the number of subscriptions
-    def subTimes(self,filename):
-        self.filename = filename
-        command = 'cat %s |wc -l'% filename
-        times = int(subprocess.getstatusoutput(command)[1]) 
-        return times
-    
-    # assert results
-    def assertCheck(self,filename,subResult,expectResult):
-        self.filename = filename
-        self.subResult = subResult
-        self.expectResult = expectResult
-        args0 = (filename, subResult, expectResult)
-        assert subResult == expectResult , "Queryfile:%s ,result is %s != expect: %s" % args0    
-
-    def run(self):
-        buildPath = self.getBuildPath()
-        if (buildPath == ""):
-            tdLog.exit("taosd not found!")
-        else:
-            tdLog.info("taosd found in %s" % buildPath)
-        binPath = buildPath+ "/build/bin/"      
-
-        # clear env
-        os.system("ps -ef |grep 'taosdemoAllTest/taosdemoTestSupportNanoSubscribe.json' |grep -v 'grep' |awk '{print $2}'|xargs kill -9")
-        os.system("rm -rf ./subscribe_res*")  
-        os.system("rm -rf ./all_subscribe_res*")  
-        
-
-        # insert data
-        os.system("%staosdemo -f tools/taosdemoAllTest/NanoTestCase/taosdemoTestNanoDatabaseInsertForSub.json" % binPath)
-        os.system("nohup %staosdemo -f tools/taosdemoAllTest/NanoTestCase/taosdemoTestSupportNanoSubscribe.json &" % binPath)
-        query_pid = int(subprocess.getstatusoutput('ps aux|grep "taosdemoAllTest/NanoTestCase/taosdemoTestSupportNanoSubscribe.json" |grep -v "grep"|awk \'{print $2}\'')[1])
-
-
-        # merge result files
-        sleep(5)
-        os.system("cat subscribe_res0.txt* > all_subscribe_res0.txt")
-        os.system("cat subscribe_res1.txt* > all_subscribe_res1.txt")
-        os.system("cat subscribe_res2.txt* > all_subscribe_res2.txt")
-
-        
-        # correct subscribeTimes testcase
-        subTimes0 = self.subTimes("all_subscribe_res0.txt")
-        self.assertCheck("all_subscribe_res0.txt",subTimes0 ,200)
-
-        subTimes1 = self.subTimes("all_subscribe_res1.txt")
-        self.assertCheck("all_subscribe_res1.txt",subTimes1 ,200)
-
-        subTimes2 = self.subTimes("all_subscribe_res2.txt")
-        self.assertCheck("all_subscribe_res2.txt",subTimes2 ,200)
-
-
-        # insert extral data     
-        tdSql.execute("use subnsdb")
-        tdSql.execute("insert into tb0_0 values(now,100.1000,'subtest1',now-1s)")
-        sleep(15)   
-
-        os.system("cat subscribe_res0.txt* > all_subscribe_res0.txt")
-        subTimes0 = self.subTimes("all_subscribe_res0.txt")
-        print("pass")
-        self.assertCheck("all_subscribe_res0.txt",subTimes0 ,202)
-
-        
-
-        # correct data testcase
-        os.system("kill -9 %d" % query_pid)
-        sleep(3)
-        os.system("rm -rf ./subscribe_res*")   
-        os.system("rm -rf ./all_subscribe*")
-        os.system("rm -rf ./*.py.sql")
-  
-
-         
-    def stop(self):
-        tdSql.close()
-        tdLog.success("%s successfully executed" % __file__)
-
-tdCases.addWindows(__file__, TDTestCase())
-tdCases.addLinux(__file__, TDTestCase())
--- a/tests/pytest/tools/taosdemoAllTest/Resubjson/subSyncResubAC1endAfter1.json
+++ b/tests/pytest/tools/taosdemoAllTest/Resubjson/subSyncResubAC1endAfter1.json
@ -1,41 +0,0 @@
-{
-    "filetype":"subscribe",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "databases": "db",
-    "confirm_parameter_prompt": "no",
-    "specified_table_query":
-      {
-       "concurrent":2, 
-       "mode":"sync", 
-       "interval":0, 
-       "resubAfterConsume":1,
-       "endAfterConsume":1,
-       "keepProgress":"yes",
-       "restart":"no",
-       "sqls": [
-        {
-          "sql": "select * from stb00_0", 
-          "result": "./subscribe_res0.txt"
-        }]
-      },
-    "super_table_query": 
-      {
-       "stblname": "stb0",
-       "threads":2, 
-       "mode":"sync", 
-       "interval":1000, 
-       "resubAfterConsume":1,
-       "endAfterConsume":1,
-       "keepProgress":"yes",
-       "restart":"no",
-       "sqls": [
-        {
-          "sql": "select * from xxxx where ts >= '2021-02-25 10:00:01.000' ", 
-          "result": "./subscribe_res2.txt"
-        }]
-      }
-  }
--- a/tests/pytest/tools/taosdemoAllTest/Resubjson/subSyncResubAC1endAfterMin1.json
+++ b/tests/pytest/tools/taosdemoAllTest/Resubjson/subSyncResubAC1endAfterMin1.json
@ -1,41 +0,0 @@
-{
-    "filetype":"subscribe",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "databases": "db",
-    "confirm_parameter_prompt": "no",
-    "specified_table_query":
-      {
-       "concurrent":2, 
-       "mode":"sync", 
-       "interval":0, 
-       "resubAfterConsume":1,
-       "endAfterConsume":-1,
-       "keepProgress":"no",
-       "restart":"yes",
-       "sqls": [
-        {
-          "sql": "select * from stb00_0", 
-          "result": "./subscribe_res0.txt"
-        }]
-      },
-    "super_table_query": 
-      {
-       "stblname": "stb0",
-       "threads":2, 
-       "mode":"sync", 
-       "interval":1000, 
-       "resubAfterConsume":1,
-       "endAfterConsume":-1,
-       "keepProgress":"no",
-       "restart":"yes",
-       "sqls": [
-        {
-          "sql": "select * from xxxx where ts >= '2021-02-25 10:00:01.000' ", 
-          "result": "./subscribe_res2.txt"
-        }]
-      }
-  }
--- a/tests/pytest/tools/taosdemoAllTest/Resubjson/subSyncResubACMinus1.json
+++ b/tests/pytest/tools/taosdemoAllTest/Resubjson/subSyncResubACMinus1.json
@ -1,41 +0,0 @@
-{
-    "filetype":"subscribe",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "databases": "db",
-    "confirm_parameter_prompt": "no",
-    "specified_table_query":
-      {
-       "concurrent":2, 
-       "mode":"sync", 
-       "interval":0, 
-       "resubAfterConsume":-1,
-       "endAfterConsume":-1,
-       "keepProgress":"no",
-       "restart":"yes",
-       "sqls": [
-        {
-          "sql": "select * from stb00_0", 
-          "result": "./subscribe_res0.txt"
-        }]
-      },
-    "super_table_query": 
-      {
-       "stblname": "stb0",
-       "threads":2, 
-       "mode":"sync", 
-       "interval":1000, 
-       "resubAfterConsume":-1,
-       "endAfterConsume":-1,
-       "keepProgress":"no",
-       "restart":"yes",
-       "sqls": [
-        {
-          "sql": "select * from xxxx where ts >= '2021-02-25 10:00:01.000' ", 
-          "result": "./subscribe_res2.txt"
-        }]
-      }
-  }
--- a/tests/pytest/tools/taosdemoAllTest/Resubjson/subSyncResubACMinus1endAfter0.json
+++ b/tests/pytest/tools/taosdemoAllTest/Resubjson/subSyncResubACMinus1endAfter0.json
@ -1,41 +0,0 @@
-{
-    "filetype":"subscribe",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "databases": "db",
-    "confirm_parameter_prompt": "no",
-    "specified_table_query":
-      {
-       "concurrent":2, 
-       "mode":"sync", 
-       "interval":0, 
-       "resubAfterConsume":-1,
-       "endAfterConsume":0,
-       "keepProgress":"no",
-       "restart":"yes",
-       "sqls": [
-        {
-          "sql": "select * from stb00_0", 
-          "result": "./subscribe_res0.txt"
-        }]
-      },
-    "super_table_query": 
-      {
-       "stblname": "stb0",
-       "threads":2, 
-       "mode":"sync", 
-       "interval":0, 
-       "resubAfterConsume":-1,
-       "endAfterConsume":0,
-       "keepProgress":"no",
-       "restart":"yes",
-       "sqls": [
-        {
-          "sql": "select * from xxxx where ts >= '2021-02-25 10:00:01.000' ", 
-          "result": "./subscribe_res2.txt"
-        }]
-      }
-  }
--- a/tests/pytest/tools/taosdemoAllTest/Resubjson/subSyncResubACMinus1endAfterNo0.json
+++ b/tests/pytest/tools/taosdemoAllTest/Resubjson/subSyncResubACMinus1endAfterNo0.json
@ -1,41 +0,0 @@
-{
-    "filetype":"subscribe",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "databases": "db",
-    "confirm_parameter_prompt": "no",
-    "specified_table_query":
-      {
-       "concurrent":2, 
-       "mode":"sync", 
-       "interval":0, 
-       "resubAfterConsume":-1,
-       "endAfterConsume":1,
-       "keepProgress":"no",
-       "restart":"yes",
-       "sqls": [
-        {
-          "sql": "select * from stb00_0", 
-          "result": "./subscribe_res0.txt"
-        }]
-      },
-    "super_table_query": 
-      {
-       "stblname": "stb0",
-       "threads":2, 
-       "mode":"sync", 
-       "interval":1000, 
-       "resubAfterConsume":-1,
-       "endAfterConsume":2,
-       "keepProgress":"no",
-       "restart":"yes",
-       "sqls": [
-        {
-          "sql": "select * from xxxx where ts >= '2021-02-25 10:00:01.000' ", 
-          "result": "./subscribe_res2.txt"
-        }]
-      }
-  }
--- a/tests/pytest/tools/taosdemoAllTest/TD-3453/query-interrupt.json
+++ b/tests/pytest/tools/taosdemoAllTest/TD-3453/query-interrupt.json
@ -1,62 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 4,
-    "create_table_thread_count": 4,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 100,
-    "num_of_records_per_req": 1000,
-    "max_sql_len": 1024000,
-    "databases": [{
-        "dbinfo": {
-            "name": "db",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "ms",
-            "keep": 365,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": 60,
-            "childtable_prefix": "stb00_",  
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 20,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 100000,
-            "childtable_limit": -1,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 1000,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":10}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/TD-3453/query-interrupt.py
+++ b/tests/pytest/tools/taosdemoAllTest/TD-3453/query-interrupt.py
@ -1,89 +0,0 @@
-###################################################################
-#           Copyright (c) 2016 by TAOS Technologies, Inc.
-#                     All rights reserved.
-#
-#  This file is proprietary and confidential to TAOS Technologies.
-#  No part of this file may be reproduced, stored, transmitted,
-#  disclosed or used in any form or by any means other than as
-#  expressly provided by the written permission from Jianhui Tao
-#
-###################################################################
-
-# -*- coding: utf-8 -*-
-
-import sys
-import os
-import subprocess
-import time
-from util.log import *
-from util.cases import *
-from util.sql import *
-from util.dnodes import *
-
-
-class TDTestCase:
-    def init(self, conn, logSql):
-        tdLog.debug("start to execute %s" % __file__)
-        tdSql.init(conn.cursor(), logSql)
-        
-    def getBuildPath(self):
-        selfPath = os.path.dirname(os.path.realpath(__file__))
-
-        if ("community" in selfPath):
-            projPath = selfPath[:selfPath.find("community")]
-        else:
-            projPath = selfPath[:selfPath.find("tests")]
-
-        for root, dirs, files in os.walk(projPath):
-            if ("taosd" in files):
-                rootRealPath = os.path.dirname(os.path.realpath(root))
-                if ("packaging" not in rootRealPath):
-                    buildPath = root[:len(root)-len("/build/bin")]
-                    break
-        return buildPath
-        
-    def run(self):
-        tdSql.prepare()
-        buildPath = self.getBuildPath()
-        if (buildPath == ""):
-            tdLog.exit("taosd not found!")
-        else:
-            tdLog.info("taosd found in %s" % buildPath)
-        binPath = buildPath+ "/build/bin/"
-
-        # # insert 1000w rows in stb0
-        os.system("%staosdemo -f tools/taosdemoAllTest/TD-3453/query-interrupt.json -y " % binPath)
-        tdSql.execute("use db")
-        tdSql.query("select count (tbname) from stb0")
-        tdSql.checkData(0, 0,60)
-        tdSql.query("select count(*) from stb0")
-        tdSql.checkData(0, 0, 6000000) 
-        os.system('%staosdemo -f tools/taosdemoAllTest/TD-3453/queryall.json -y & ' % binPath)
-        time.sleep(2)
-        query_pid = int(subprocess.getstatusoutput('ps aux|grep "TD-3453/queryall.json" |grep -v "grep"|awk \'{print $2}\'')[1])
-        taosd_cpu_load_1 = float(subprocess.getstatusoutput('top -n 1 -b -p $(ps aux|grep "bin/taosd -c"|grep -v "grep" |awk \'{print $2}\')|awk \'END{print}\' |awk \'{print $9}\'')[1])    
-        if taosd_cpu_load_1 > 10.0 :
-            os.system("kill -9 %d" % query_pid)
-            time.sleep(5)
-            taosd_cpu_load_2 = float(subprocess.getstatusoutput('top -n 1 -b -p $(ps aux|grep "bin/taosd -c"|grep -v "grep" |awk \'{print $2}\')|awk \'END{print}\' |awk \'{print $9}\'')[1])
-            if taosd_cpu_load_2 < 10.0 :
-                suc_kill = 60
-            else:
-                suc_kill = 10
-                print("taosd_cpu_load is higher than 10%")
-        else:
-            suc_kill = 20
-            print("taosd_cpu_load is still  less than 10%")
-        tdSql.query("select count (tbname) from stb0")
-        tdSql.checkData(0, 0, "%d" % suc_kill)
-        os.system("rm -rf querySystemInfo*")
-        os.system("rm -rf insert_res.txt")
-        os.system("rm -rf query_res.txt")
-
-    def stop(self):
-        tdSql.close()
-        tdLog.success("%s successfully executed" % __file__)
-
-
-tdCases.addWindows(__file__, TDTestCase())
-tdCases.addLinux(__file__, TDTestCase())
--- a/tests/pytest/tools/taosdemoAllTest/TD-3453/queryall.json
+++ b/tests/pytest/tools/taosdemoAllTest/TD-3453/queryall.json
@ -1,20 +0,0 @@
-{
-  "filetype":"query",
-  "cfgdir": "/etc/taos",
-  "host": "127.0.0.1",
-  "port": 6030,
-  "user": "root",
-  "password": "taosdata",
-  "confirm_parameter_prompt": "no",
-  "databases": "db",
-  "specified_table_query":{
-    "query_interval":1, 
-    "concurrent":1,
-    "sqls":[
-      {
-        "sql": "select * from stb0",
-        "result": "./query_res.txt"
-      }
-    ]
-  }
-}
--- a/tests/pytest/tools/taosdemoAllTest/TD-4985/query-limit-offset.csv
+++ b/tests/pytest/tools/taosdemoAllTest/TD-4985/query-limit-offset.csv
@ -1,10 +0,0 @@
-0,0,'TAOSdata-0'
-1,1,'TAOSdata-1'
-2,22,'TAOSdata-2'
-3,333,'TAOSdata-3'
-4,4444,'TAOSdata-4'
-5,55555,'TAOSdata-5'
-6,666666,'TAOSdata-6'
-7,7777777,'TAOSdata-7'
-8,88888888,'TAOSdata-8'
-9,999999999,'TAOSdata-9'
--- a/tests/pytest/tools/taosdemoAllTest/TD-4985/query-limit-offset.json
+++ b/tests/pytest/tools/taosdemoAllTest/TD-4985/query-limit-offset.json
@ -1,62 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 10,
-    "create_table_thread_count": 10,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 10,
-    "num_of_records_per_req": 1,
-    "max_sql_len": 1024000,
-    "databases": [{
-        "dbinfo": {
-            "name": "db",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "ms",
-            "keep": 36500,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": 10000,
-            "childtable_prefix": "stb00_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 1,
-            "data_source": "sample",
-            "insert_mode": "taosc",
-            "insert_rows": 10,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./tools/taosdemoAllTest/TD-4985/query-limit-offset.csv",
-            "tags_file": "./tools/taosdemoAllTest/TD-4985/query-limit-offset.csv",
-            "columns": [{"type": "INT","count":2}, {"type": "BINARY", "len": 16, "count":1}],
-            "tags": [{"type": "INT", "count":2}, {"type": "BINARY", "len": 16, "count":1}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/TD-4985/query-limit-offset.py
+++ b/tests/pytest/tools/taosdemoAllTest/TD-4985/query-limit-offset.py
@ -1,192 +0,0 @@
-###################################################################
-#           Copyright (c) 2016 by TAOS Technologies, Inc.
-#                     All rights reserved.
-#
-#  This file is proprietary and confidential to TAOS Technologies.
-#  No part of this file may be reproduced, stored, transmitted,
-#  disclosed or used in any form or by any means other than as
-#  expressly provided by the written permission from Jianhui Tao
-#
-###################################################################
-
-# -*- coding: utf-8 -*-
-
-import sys
-import os
-import time
-from util.log import *
-from util.cases import *
-from util.sql import *
-from util.dnodes import *
-
-
-class TDTestCase:
-    def init(self, conn, logSql):
-        tdLog.debug("start to execute %s" % __file__)
-        tdSql.init(conn.cursor(), logSql)
-
-        now = time.time()
-        self.ts = int(round(now * 1000))
-
-    def getBuildPath(self):
-        selfPath = os.path.dirname(os.path.realpath(__file__))
-
-        if ("community" in selfPath):
-            projPath = selfPath[:selfPath.find("community")]
-        else:
-            projPath = selfPath[:selfPath.find("tests")]
-
-        for root, dirs, files in os.walk(projPath):
-            if ("taosd" in files):
-                rootRealPath = os.path.dirname(os.path.realpath(root))
-                if ("packaging" not in rootRealPath):
-                    buildPath = root[:len(root)-len("/build/bin")]
-                    break
-        return buildPath
-
-    def run(self):
-        buildPath = self.getBuildPath()
-        if (buildPath == ""):
-            tdLog.exit("taosd not found!")
-        else:
-            tdLog.info("taosd found in %s" % buildPath)
-        binPath = buildPath+ "/build/bin/"
-
-        # insert: create one  or mutiple tables per sql and insert multiple rows per sql
-        # test case for https://jira.taosdata.com:18080/browse/TD-4985
-        os.system("rm -rf tools/taosdemoAllTest/TD-4985/query-limit-offset.py.sql")
-        os.system("%staosdemo -f tools/taosdemoAllTest/TD-4985/query-limit-offset.json -y " % binPath)
-        tdSql.execute("use db")
-        tdSql.query("select count (tbname) from stb0")
-        tdSql.checkData(0, 0, 10000)
-
-        for i in range(1000):
-            tdSql.execute('''insert into stb00_9999 values(%d, %d, %d,'test99.%s')'''
-                            % (self.ts + i, i, -10000+i, i))
-            tdSql.execute('''insert into stb00_8888 values(%d, %d, %d,'test98.%s')'''
-                            % (self.ts + i, i, -10000+i, i))
-            tdSql.execute('''insert into stb00_7777 values(%d, %d, %d,'test97.%s')'''
-                            % (self.ts + i, i, -10000+i, i))
-            tdSql.execute('''insert into stb00_6666 values(%d, %d, %d,'test96.%s')'''
-                            % (self.ts + i, i, -10000+i, i))
-            tdSql.execute('''insert into stb00_5555 values(%d, %d, %d,'test95.%s')'''
-                            % (self.ts + i, i, -10000+i, i))
-            tdSql.execute('''insert into stb00_4444 values(%d, %d, %d,'test94.%s')'''
-                            % (self.ts + i, i, -10000+i, i))
-            tdSql.execute('''insert into stb00_3333 values(%d, %d, %d,'test93.%s')'''
-                            % (self.ts + i, i, -10000+i, i))
-            tdSql.execute('''insert into stb00_2222 values(%d, %d, %d,'test92.%s')'''
-                            % (self.ts + i, i, -10000+i, i))
-            tdSql.execute('''insert into stb00_1111 values(%d, %d, %d,'test91.%s')'''
-                            % (self.ts + i, i, -10000+i, i))
-            tdSql.execute('''insert into stb00_100 values(%d, %d, %d,'test90.%s')'''
-                            % (self.ts + i, i, -10000+i, i))
-        tdSql.query("select * from stb0 where c2 like 'test99%' ")
-        tdSql.checkRows(1000)
-        tdSql.query("select * from stb0 where  tbname like 'stb00_9999'  limit 10" )
-        tdSql.checkData(0, 1, 0)
-        tdSql.checkData(1, 1, 1)
-        tdSql.checkData(2, 1, 2)
-        tdSql.query("select * from stb0 where  tbname like 'stb00_9999'  limit 10 offset 5" )
-        tdSql.checkData(0, 1, 5)
-        tdSql.checkData(1, 1, 6)
-        tdSql.checkData(2, 1, 7)
-        tdSql.query("select *  from stb0 where c2 like 'test98%' ")
-        tdSql.checkRows(1000)
-        tdSql.query("select  *  from stb0 where tbname like 'stb00_8888' limit 10" )
-        tdSql.checkData(0, 1, 0)
-        tdSql.checkData(1, 1, 1)
-        tdSql.checkData(2, 1, 2)
-        tdSql.query("select *  from stb0 where tbname like 'stb00_8888' limit 10 offset 5" )
-        tdSql.checkData(0, 1, 5)
-        tdSql.checkData(1, 1, 6)
-        tdSql.checkData(2, 1, 7)
-        tdSql.query("select *  from stb0 where c2 like 'test97%' ")
-        tdSql.checkRows(1000)
-        tdSql.query("select  *  from stb0 where tbname like 'stb00_7777' limit 10" )
-        tdSql.checkData(0, 1, 0)
-        tdSql.checkData(1, 1, 1)
-        tdSql.checkData(2, 1, 2)
-        tdSql.query("select  *  from stb0 where tbname like 'stb00_7777' limit 10 offset 5" )
-        tdSql.checkData(0, 1, 5)
-        tdSql.checkData(1, 1, 6)
-        tdSql.checkData(2, 1, 7)
-        tdSql.query("select *  from stb0 where c2 like 'test96%' ")
-        tdSql.checkRows(1000)
-        tdSql.query("select  *  from stb0 where tbname like 'stb00_6666' limit 10" )
-        tdSql.checkData(0, 1, 0)
-        tdSql.checkData(1, 1, 1)
-        tdSql.checkData(2, 1, 2)
-        tdSql.query("select  *  from stb0 where tbname like 'stb00_6666' limit 10 offset 5" )
-        tdSql.checkData(0, 1, 5)
-        tdSql.checkData(1, 1, 6)
-        tdSql.checkData(2, 1, 7)
-        tdSql.query("select *  from stb0 where c2 like 'test95%' ")
-        tdSql.checkRows(1000)
-        tdSql.query("select  *  from stb0 where tbname like 'stb00_5555' limit 10" )
-        tdSql.checkData(0, 1, 0)
-        tdSql.checkData(1, 1, 1)
-        tdSql.checkData(2, 1, 2)
-        tdSql.query("select  *  from stb0 where tbname like 'stb00_5555' limit 10 offset 5" )
-        tdSql.checkData(0, 1, 5)
-        tdSql.checkData(1, 1, 6)
-        tdSql.checkData(2, 1, 7)
-        tdSql.query("select * from stb0 where c2 like 'test94%' ")
-        tdSql.checkRows(1000)
-        tdSql.query("select * from stb0 where tbname like 'stb00_4444' limit 10" )
-        tdSql.checkData(0, 1, 0)
-        tdSql.checkData(1, 1, 1)
-        tdSql.checkData(2, 1, 2)
-        tdSql.query("select * from stb0 where tbname like 'stb00_4444' limit 10 offset 5" )
-        tdSql.checkData(0, 1, 5)
-        tdSql.checkData(1, 1, 6)
-        tdSql.checkData(2, 1, 7)
-        tdSql.query("select *  from stb0 where c2 like 'test93%' ")
-        tdSql.checkRows(1000)
-        tdSql.query("select  *  from stb0 where tbname like 'stb00_3333' limit 100" )
-        tdSql.checkData(0, 1, 0)
-        tdSql.checkData(1, 1, 1)
-        tdSql.checkData(2, 1, 2)
-        tdSql.query("select *  from stb0 where tbname like 'stb00_3333' limit 100 offset 5" )
-        tdSql.checkData(0, 1, 5)
-        tdSql.checkData(1, 1, 6)
-        tdSql.checkData(2, 1, 7)
-        tdSql.query("select *  from stb0 where c2 like 'test92%' ")
-        tdSql.checkRows(1000)
-        tdSql.query("select  *  from stb0 where tbname like 'stb00_2222' limit 100" )
-        tdSql.checkData(0, 1, 0)
-        tdSql.checkData(1, 1, 1)
-        tdSql.checkData(2, 1, 2)
-        tdSql.query("select  *  from stb0 where tbname like 'stb00_2222' limit 100 offset 5" )
-        tdSql.checkData(0, 1, 5)
-        tdSql.checkData(1, 1, 6)
-        tdSql.checkData(2, 1, 7)
-        tdSql.query("select *  from stb0 where c2 like 'test91%' ")
-        tdSql.checkRows(1000)
-        tdSql.query("select  *  from stb0 where tbname like 'stb00_1111' limit 100" )
-        tdSql.checkData(0, 1, 0)
-        tdSql.checkData(1, 1, 1)
-        tdSql.checkData(2, 1, 2)
-        tdSql.query("select  *  from stb0 where tbname like 'stb00_1111' limit 100 offset 5" )
-        tdSql.checkData(0, 1, 5)
-        tdSql.checkData(1, 1, 6)
-        tdSql.checkData(2, 1, 7)
-        tdSql.query("select *  from stb0 where c2 like 'test90%' ")
-        tdSql.checkRows(1000)
-        tdSql.query("select  *  from stb0 where tbname like 'stb00_100' limit 100" )
-        tdSql.checkData(0, 1, 0)
-        tdSql.checkData(1, 1, 1)
-        tdSql.checkData(2, 1, 2)
-        tdSql.query("select  *  from stb0 where tbname like 'stb00_100' limit 100 offset 5" )
-        tdSql.checkData(0, 1, 5)
-        tdSql.checkData(1, 1, 6)
-        tdSql.checkData(2, 1, 7)
-        
-
-    def stop(self):
-        tdSql.close()
-        tdLog.success("%s successfully executed" % __file__)
-
-
-tdCases.addWindows(__file__, TDTestCase())
-tdCases.addLinux(__file__, TDTestCase())
--- a/tests/pytest/tools/taosdemoAllTest/TD-5213/insert4096columns_not_use_taosdemo.py
+++ b/tests/pytest/tools/taosdemoAllTest/TD-5213/insert4096columns_not_use_taosdemo.py
@ -1,703 +0,0 @@
-###################################################################
-#           Copyright (c) 2016 by TAOS Technologies, Inc.
-#                     All rights reserved.
-#
-#  This file is proprietary and confidential to TAOS Technologies.
-#  No part of this file may be reproduced, stored, transmitted,
-#  disclosed or used in any form or by any means other than as
-#  expressly provided by the written permission from Jianhui Tao
-#
-###################################################################
-
-# -*- coding: utf-8 -*-
-
-import random
-import string
-import os
-import time
-from util.log import tdLog
-from util.cases import tdCases
-from util.sql import tdSql
-from util.dnodes import tdDnodes
-
-class TDTestCase:
-    updatecfgDict={'maxSQLLength':1048576}
-    def init(self, conn, logSql):
-        tdLog.debug("start to execute %s" % __file__)
-        tdSql.init(conn.cursor(), logSql)
-
-        self.ts = 1538548685000
-        self.num = 100
-
-    def get_random_string(self, length):
-        letters = string.ascii_lowercase
-        result_str = ''.join(random.choice(letters) for i in range(length))
-        return result_str
-
-    def run(self):
-        tdSql.prepare()
-        # test case for https://jira.taosdata.com:18080/browse/TD-5213
-
-        print("==============step1, regular table, 1 ts + 4094 cols + 1 binary==============")
-        startTime = time.time() 
-        sql = "create table regular_table_1(ts timestamp, "
-        for i in range(4094):
-            sql += "col%d int, " % (i + 1)
-        sql += "col4095 binary(22))"  
-        tdLog.info(len(sql))      
-        tdSql.execute(sql)
-
-        for i in range(self.num):
-            sql = "insert into regular_table_1 values(%d, "
-            for j in range(4094):
-                str = "'%s', " % random.randint(0,1000)                
-                sql += str
-            sql += "'%s')" % self.get_random_string(22)
-            tdSql.execute(sql % (self.ts + i))
-        time.sleep(1)
-        tdSql.query("select count(*) from regular_table_1")
-        tdSql.checkData(0, 0, self.num)
-        tdSql.query("select * from regular_table_1")
-        tdSql.checkRows(self.num)
-        tdSql.checkCols(4096)
-
-        endTime = time.time()
-        print("total time %ds" % (endTime - startTime))
-
-        #insert in order
-        tdLog.info('test insert in order') 
-        for i in range(self.num):
-            sql = "insert into regular_table_1 (ts,col1,col2,col3,col4,col5,col6,col7,col8,col9,col10,col4095) values(%d, "
-            for j in range(10):
-                str = "'%s', " % random.randint(0,1000)                
-                sql += str
-            sql += "'%s')" % self.get_random_string(22)
-            tdSql.execute(sql % (self.ts + i + 1000))
-        time.sleep(1)
-        tdSql.query("select count(*) from regular_table_1")
-        tdSql.checkData(0, 0, 2*self.num)
-        tdSql.query("select * from regular_table_1")
-        tdSql.checkRows(2*self.num)
-        tdSql.checkCols(4096)
-
-        #insert out of order
-        tdLog.info('test insert out of order') 
-        for i in range(self.num):
-            sql = "insert into regular_table_1 (ts,col123,col2213,col331,col41,col523,col236,col71,col813,col912,col1320,col4095) values(%d, "
-            for j in range(10):
-                str = "'%s', " % random.randint(0,1000)                
-                sql += str
-            sql += "'%s')" % self.get_random_string(22)
-            tdSql.execute(sql % (self.ts + i + 2000))
-        time.sleep(1)
-        tdSql.query("select count(*) from regular_table_1")
-        tdSql.checkData(0, 0, 3*self.num)
-        tdSql.query("select * from regular_table_1")
-        tdSql.checkRows(3*self.num)
-        tdSql.checkCols(4096)
-
-
-        print("==============step2,regular table error col or value==============")
-        tdLog.info('test regular table exceeds row num') 
-        # column > 4096
-        sql = "create table regular_table_2(ts timestamp, "
-        for i in range(4095):
-            sql += "col%d int, " % (i + 1)
-        sql += "col4096 binary(22))"  
-        tdLog.info(len(sql))      
-        tdSql.error(sql)
-
-        # column > 4096
-        sql = "insert into regular_table_1 values(%d, "
-        for j in range(4095):
-            str = "'%s', " % random.randint(0,1000)                
-            sql += str
-        sql += "'%s')" % self.get_random_string(22)
-        tdSql.error(sql)
-
-        # insert column < 4096
-        sql = "insert into regular_table_1 values(%d, "
-        for j in range(4092):
-            str = "'%s', " % random.randint(0,1000)                
-            sql += str
-        sql += "'%s')" % self.get_random_string(22)
-        tdSql.error(sql)
-
-        # alter column > 4096
-        sql = "alter table regular_table_1 add column max int; "
-        tdSql.error(sql)
-
-        print("==============step3,regular table , mix data type==============")
-        startTime = time.time() 
-        sql = "create table regular_table_3(ts timestamp, "
-        for i in range(2000):
-            sql += "col%d int, " % (i + 1)
-        for i in range(2000,4094):
-            sql += "col%d bigint, " % (i + 1)
-        sql += "col4095 binary(22))"  
-        tdLog.info(len(sql))      
-        tdSql.execute(sql)
-
-        for i in range(self.num):
-            sql = "insert into regular_table_3 values(%d, "
-            for j in range(4094):
-                str = "'%s', " % random.randint(0,1000)                
-                sql += str
-            sql += "'%s')" % self.get_random_string(22)
-            tdSql.execute(sql % (self.ts + i))
-        time.sleep(1)
-        tdSql.query("select count(*) from regular_table_3")
-        tdSql.checkData(0, 0, self.num)
-        tdSql.query("select * from regular_table_3")
-        tdSql.checkRows(self.num)
-        tdSql.checkCols(4096)
-
-        endTime = time.time()
-        print("total time %ds" % (endTime - startTime))
-
-        sql = "create table regular_table_4(ts timestamp, "
-        for i in range(500):
-            sql += "int_%d int, " % (i + 1)
-        for i in range(500,1000):
-            sql += "smallint_%d smallint, " % (i + 1)
-        for i in range(1000,1500):
-            sql += "tinyint_%d tinyint, " % (i + 1)
-        for i in range(1500,2000):
-            sql += "double_%d double, " % (i + 1)
-        for i in range(2000,2500):
-            sql += "float_%d float, " % (i + 1)
-        for i in range(2500,3000):
-            sql += "bool_%d bool, " % (i + 1)
-        for i in range(3000,3500):
-            sql += "bigint_%d bigint, " % (i + 1)
-        for i in range(3500,3800):
-            sql += "nchar_%d nchar(4), " % (i + 1)
-        for i in range(3800,4090):
-            sql += "binary_%d binary(10), " % (i + 1)
-        for i in range(4090,4094):
-            sql += "timestamp_%d timestamp, " % (i + 1)
-        sql += "col4095 binary(22))"  
-        tdLog.info(len(sql))      
-        tdSql.execute(sql)
-
-        for i in range(self.num):
-            sql = "insert into regular_table_4 values(%d, "
-            for j in range(500):
-                str = "'%s', " % random.randint(-2147483647,2147483647)                
-                sql += str
-            for j in range(500,1000):
-                str = "'%s', " % random.randint(-32767,32767 )                
-                sql += str
-            for j in range(1000,1500):
-                str = "'%s', " % random.randint(-127,127)                
-                sql += str
-            for j in range(1500,2000):
-                str = "'%s', " % random.randint(-922337203685477580700,922337203685477580700)                
-                sql += str
-            for j in range(2000,2500):
-                str = "'%s', " % random.randint(-92233720368547758070,92233720368547758070)                
-                sql += str
-            for j in range(2500,3000):
-                str = "'%s', " % random.choice(['true','false'])               
-                sql += str
-            for j in range(3000,3500):
-                str = "'%s', " % random.randint(-9223372036854775807,9223372036854775807)                
-                sql += str
-            for j in range(3500,3800):
-                str = "'%s', " % self.get_random_string(4)                
-                sql += str
-            for j in range(3800,4090):
-                str = "'%s', " % self.get_random_string(10)                
-                sql += str
-            for j in range(4090,4094):
-                str = "%s, " % (self.ts + j)                
-                sql += str
-            sql += "'%s')" % self.get_random_string(22)
-            tdSql.execute(sql % (self.ts + i))
-        time.sleep(1)
-        tdSql.query("select count(*) from regular_table_4")
-        tdSql.checkData(0, 0, self.num)
-        tdSql.query("select * from regular_table_4")
-        tdSql.checkRows(self.num)
-        tdSql.checkCols(4096)
-        tdLog.info("end ,now new one")
-
-        #insert null value 
-        tdLog.info('test insert null value') 
-        for i in range(self.num):
-            sql = "insert into regular_table_4 values(%d, "
-            for j in range(2500):
-                str = "'%s', " % random.choice(['NULL' ,'NULL' ,'NULL' ,1 , 10 ,100 ,-100 ,-10, 88 ,66 ,'NULL' ,'NULL' ,'NULL' ])               
-                sql += str
-            for j in range(2500,3000):
-                str = "'%s', " % random.choice(['true' ,'false'])               
-                sql += str
-            for j in range(3000,3500):
-                str = "'%s', " % random.randint(-9223372036854775807,9223372036854775807)                
-                sql += str
-            for j in range(3500,3800):
-                str = "'%s', " % self.get_random_string(4)                
-                sql += str
-            for j in range(3800,4090):
-                str = "'%s', " % self.get_random_string(10)                
-                sql += str
-            for j in range(4090,4094):
-                str = "%s, " % (self.ts + j)                
-                sql += str
-            sql += "'%s')" % self.get_random_string(22)
-            tdSql.execute(sql % (self.ts + i + 10000))
-        time.sleep(1)
-        tdSql.query("select count(*) from regular_table_4")
-        tdSql.checkData(0, 0, 2*self.num)
-        tdSql.query("select * from regular_table_4")
-        tdSql.checkRows(2*self.num)
-        tdSql.checkCols(4096)
-
-        #insert in order
-        tdLog.info('test insert in order') 
-        for i in range(self.num):
-            sql = "insert into regular_table_4 (ts,int_2,int_22,int_169,smallint_537,smallint_607,tinyint_1030,tinyint_1491,double_1629,double_1808,float_2075,col4095) values(%d, "
-            for j in range(10):
-                str = "'%s', " % random.randint(0,100)                
-                sql += str
-            sql += "'%s')" % self.get_random_string(22)
-            tdSql.execute(sql % (self.ts + i + 1000))
-        time.sleep(1)
-        tdSql.query("select count(*) from regular_table_4")
-        tdSql.checkData(0, 0, 3*self.num)
-        tdSql.query("select * from regular_table_4")
-        tdSql.checkRows(3*self.num)
-        tdSql.checkCols(4096)
-
-        #insert out of order
-        tdLog.info('test insert out of order') 
-        for i in range(self.num):
-            sql = "insert into regular_table_4 (ts,int_169,float_2075,int_369,tinyint_1491,tinyint_1030,float_2360,smallint_537,double_1808,double_1608,double_1629,col4095) values(%d, "
-            for j in range(10):
-                str = "'%s', " % random.randint(0,100)                
-                sql += str
-            sql += "'%s')" % self.get_random_string(22)
-            tdSql.execute(sql % (self.ts + i + 2000))
-        time.sleep(1)
-        tdSql.query("select count(*) from regular_table_4")
-        tdSql.checkData(0, 0, 4*self.num)
-        tdSql.query("select * from regular_table_4")
-        tdSql.checkRows(4*self.num)
-        tdSql.checkCols(4096)
-
-        #define TSDB_MAX_BYTES_PER_ROW 49151[old:1024 && 16384]
-        #ts:8\int:4\smallint:2\bigint:8\bool:1\float:4\tinyint:1\nchar:4*（）+2[offset]\binary:1*（）+2[offset]
-        tdLog.info('test regular_table max bytes per row 49151') 
-        sql = "create table regular_table_5(ts timestamp, "
-        for i in range(500):
-            sql += "int_%d int, " % (i + 1)
-        for i in range(500,1000):
-            sql += "smallint_%d smallint, " % (i + 1)
-        for i in range(1000,1500):
-            sql += "tinyint_%d tinyint, " % (i + 1)
-        for i in range(1500,2000):
-            sql += "double_%d double, " % (i + 1)
-        for i in range(2000,2500):
-            sql += "float_%d float, " % (i + 1)
-        for i in range(2500,3000):
-            sql += "bool_%d bool, " % (i + 1)
-        for i in range(3000,3500):
-            sql += "bigint_%d bigint, " % (i + 1)
-        for i in range(3500,3800):
-            sql += "nchar_%d nchar(20), " % (i + 1)
-        for i in range(3800,4090):
-            sql += "binary_%d binary(34), " % (i + 1)
-        for i in range(4090,4094):
-            sql += "timestamp_%d timestamp, " % (i + 1)
-        sql += "col4095 binary(69))"       
-        tdSql.execute(sql)
-        tdSql.query("select * from regular_table_5")
-        tdSql.checkCols(4096)
-        # TD-5324
-        sql = "alter table regular_table_5 modify column col4095 binary(70); "
-        tdSql.error(sql)     
-        
-        # drop and add
-        sql = "alter table regular_table_5 drop column col4095; "
-        tdSql.execute(sql)
-        sql = "select * from regular_table_5; "
-        tdSql.query(sql)
-        tdSql.checkCols(4095)
-        sql = "alter table regular_table_5 add column col4095 binary(70); "
-        tdSql.error(sql) 
-        sql = "alter table regular_table_5 add column col4095 binary(69); "
-        tdSql.execute(sql)
-        sql = "select * from regular_table_5; "
-        tdSql.query(sql)
-        tdSql.checkCols(4096)  
-
-        #out TSDB_MAX_BYTES_PER_ROW 49151
-        tdLog.info('test regular_table max bytes per row out 49151') 
-        sql = "create table regular_table_6(ts timestamp, "
-        for i in range(500):
-            sql += "int_%d int, " % (i + 1)
-        for i in range(500,1000):
-            sql += "smallint_%d smallint, " % (i + 1)
-        for i in range(1000,1500):
-            sql += "tinyint_%d tinyint, " % (i + 1)
-        for i in range(1500,2000):
-            sql += "double_%d double, " % (i + 1)
-        for i in range(2000,2500):
-            sql += "float_%d float, " % (i + 1)
-        for i in range(2500,3000):
-            sql += "bool_%d bool, " % (i + 1)
-        for i in range(3000,3500):
-            sql += "bigint_%d bigint, " % (i + 1)
-        for i in range(3500,3800):
-            sql += "nchar_%d nchar(20), " % (i + 1)
-        for i in range(3800,4090):
-            sql += "binary_%d binary(34), " % (i + 1)
-        for i in range(4090,4094):
-            sql += "timestamp_%d timestamp, " % (i + 1)
-        sql += "col4095 binary(70))"  
-        tdLog.info(len(sql))      
-        tdSql.error(sql)
-
-
-        print("==============step4, super table , 1 ts + 4090 cols + 4 tags ==============")
-        startTime = time.time() 
-        sql = "create stable stable_1(ts timestamp, "
-        for i in range(4090):
-            sql += "col%d int, " % (i + 1)
-        sql += "col4091 binary(22))"  
-        sql += " tags (loc nchar(10),tag_1 int,tag_2 int,tag_3 int) " 
-        tdLog.info(len(sql))      
-        tdSql.execute(sql)
-        sql = '''create table table_0 using stable_1 
-                    tags('table_0' , '1' , '2' , '3' );'''
-        tdSql.execute(sql)
-
-        for i in range(self.num):
-            sql = "insert into table_0 values(%d, "
-            for j in range(4090):
-                str = "'%s', " % random.randint(0,1000)                
-                sql += str
-            sql += "'%s')" % self.get_random_string(22)
-            tdSql.execute(sql % (self.ts + i))
-        time.sleep(1)
-        tdSql.query("select count(*) from table_0")
-        tdSql.checkData(0, 0, self.num)
-        tdSql.query("select * from table_0")
-        tdSql.checkRows(self.num)
-        tdSql.checkCols(4092)
-
-        sql = '''create table table_1 using stable_1 
-                    tags('table_1' , '1' , '2' , '3' );'''
-        tdSql.execute(sql)
-
-        for i in range(self.num):
-            sql = "insert into table_1 values(%d, "
-            for j in range(2080):                
-                sql += "'%d', " % random.randint(0,1000)
-            for j in range(2080,4080):                
-                sql += "'%s', " % 'NULL'
-            for j in range(4080,4090):                
-                sql += "'%s', " % random.randint(0,10000)
-            sql += "'%s')" % self.get_random_string(22)
-            tdSql.execute(sql % (self.ts + i))
-        time.sleep(1)
-        tdSql.query("select count(*) from table_1")
-        tdSql.checkData(0, 0, self.num)
-        tdSql.query("select * from table_1")
-        tdSql.checkRows(self.num)
-        tdSql.checkCols(4092)
-
-        endTime = time.time()
-        print("total time %ds" % (endTime - startTime))
-
-        #insert in order
-        tdLog.info('test insert in order')
-        for i in range(self.num):
-            sql = "insert into table_1 (ts,col1,col2,col3,col4,col5,col6,col7,col8,col9,col10,col4091) values(%d, "
-            for j in range(10):
-                str = "'%s', " % random.randint(0,1000)                
-                sql += str
-            sql += "'%s')" % self.get_random_string(22)
-            tdSql.execute(sql % (self.ts + i + 1000))
-        time.sleep(1)
-        tdSql.query("select count(*) from table_1")
-        tdSql.checkData(0, 0, 2*self.num)
-        tdSql.query("select * from table_1")
-        tdSql.checkRows(2*self.num)
-        tdSql.checkCols(4092)
-
-        #insert out of order
-        tdLog.info('test insert out of order') 
-        for i in range(self.num):
-            sql = "insert into table_1 (ts,col123,col2213,col331,col41,col523,col236,col71,col813,col912,col1320,col4091) values(%d, "
-            for j in range(10):
-                str = "'%s', " % random.randint(0,1000)                
-                sql += str
-            sql += "'%s')" % self.get_random_string(22)
-            tdSql.execute(sql % (self.ts + i + 2000))
-        time.sleep(1)
-        tdSql.query("select count(*) from table_1")
-        tdSql.checkData(0, 0, 3*self.num)
-        tdSql.query("select * from table_1")
-        tdSql.checkRows(3*self.num)
-        tdSql.checkCols(4092)
-
-        print("==============step5,stable table , mix data type==============")
-        sql = "create stable stable_3(ts timestamp, "
-        for i in range(500):
-            sql += "int_%d int, " % (i + 1)
-        for i in range(500,1000):
-            sql += "smallint_%d smallint, " % (i + 1)
-        for i in range(1000,1500):
-            sql += "tinyint_%d tinyint, " % (i + 1)
-        for i in range(1500,2000):
-            sql += "double_%d double, " % (i + 1)
-        for i in range(2000,2500):
-            sql += "float_%d float, " % (i + 1)
-        for i in range(2500,3000):
-            sql += "bool_%d bool, " % (i + 1)
-        for i in range(3000,3500):
-            sql += "bigint_%d bigint, " % (i + 1)
-        for i in range(3500,3800):
-            sql += "nchar_%d nchar(4), " % (i + 1)
-        for i in range(3800,4090):
-            sql += "binary_%d binary(10), " % (i + 1)
-        sql += "col4091 binary(22))"  
-        sql += " tags (loc nchar(10),tag_1 int,tag_2 int,tag_3 int) " 
-        tdLog.info(len(sql))      
-        tdSql.execute(sql)
-        sql = '''create table table_30 using stable_3 
-                    tags('table_30' , '1' , '2' , '3' );'''
-        tdSql.execute(sql)
-
-        for i in range(self.num):
-            sql = "insert into table_30 values(%d, "
-            for j in range(500):
-                str = "'%s', " % random.randint(-2147483647,2147483647)                
-                sql += str
-            for j in range(500,1000):
-                str = "'%s', " % random.randint(-32767,32767 )                
-                sql += str
-            for j in range(1000,1500):
-                str = "'%s', " % random.randint(-127,127)                
-                sql += str
-            for j in range(1500,2000):
-                str = "'%s', " % random.randint(-922337203685477580700,922337203685477580700)                
-                sql += str
-            for j in range(2000,2500):
-                str = "'%s', " % random.randint(-92233720368547758070,92233720368547758070)                
-                sql += str
-            for j in range(2500,3000):
-                str = "'%s', " % random.choice(['true','false'])               
-                sql += str
-            for j in range(3000,3500):
-                str = "'%s', " % random.randint(-9223372036854775807,9223372036854775807)                
-                sql += str
-            for j in range(3500,3800):
-                str = "'%s', " % self.get_random_string(4)                
-                sql += str
-            for j in range(3800,4090):
-                str = "'%s', " % self.get_random_string(10)                
-                sql += str
-            sql += "'%s')" % self.get_random_string(22)
-            tdSql.execute(sql % (self.ts + i))
-        time.sleep(1)
-        tdSql.query("select count(*) from table_30")
-        tdSql.checkData(0, 0, self.num)
-        tdSql.query("select * from table_30")
-        tdSql.checkRows(self.num)
-        tdSql.checkCols(4092)
-
-        #insert null value 
-        tdLog.info('test insert null value') 
-        sql = '''create table table_31 using stable_3 
-                    tags('table_31' , '1' , '2' , '3' );'''
-        tdSql.execute(sql)
-
-        for i in range(self.num):
-            sql = "insert into table_31 values(%d, "
-            for j in range(2500):
-                str = "'%s', " % random.choice(['NULL' ,'NULL' ,'NULL' ,1 , 10 ,100 ,-100 ,-10, 88 ,66 ,'NULL' ,'NULL' ,'NULL' ])               
-                sql += str
-            for j in range(2500,3000):
-                str = "'%s', " % random.choice(['true' ,'false'])               
-                sql += str
-            for j in range(3000,3500):
-                str = "'%s', " % random.randint(-9223372036854775807,9223372036854775807)                
-                sql += str
-            for j in range(3500,3800):
-                str = "'%s', " % self.get_random_string(4)                
-                sql += str
-            for j in range(3800,4090):
-                str = "'%s', " % self.get_random_string(10)                
-                sql += str
-            sql += "'%s')" % self.get_random_string(22)
-            tdSql.execute(sql % (self.ts + i))
-        time.sleep(1)
-        tdSql.query("select count(*) from table_31")
-        tdSql.checkData(0, 0, self.num)
-        tdSql.query("select * from table_31")
-        tdSql.checkRows(self.num)
-        tdSql.checkCols(4092)
-
-        #insert in order
-        tdLog.info('test insert in order') 
-        for i in range(self.num):
-            sql = "insert into table_31 (ts,int_2,int_22,int_169,smallint_537,smallint_607,tinyint_1030,tinyint_1491,double_1629,double_1808,float_2075,col4091) values(%d, "
-            for j in range(10):
-                str = "'%s', " % random.randint(0,100)                
-                sql += str
-            sql += "'%s')" % self.get_random_string(22)
-            tdSql.execute(sql % (self.ts + i + 1000))
-        time.sleep(1)
-        tdSql.query("select count(*) from table_31")
-        tdSql.checkData(0, 0, 2*self.num)
-        tdSql.query("select * from table_31")
-        tdSql.checkRows(2*self.num)
-        tdSql.checkCols(4092)
-
-        #insert out of order
-        tdLog.info('test insert out of order') 
-        for i in range(self.num):
-            sql = "insert into table_31 (ts,int_169,float_2075,int_369,tinyint_1491,tinyint_1030,float_2360,smallint_537,double_1808,double_1608,double_1629,col4091) values(%d, "
-            for j in range(10):
-                str = "'%s', " % random.randint(0,100)                
-                sql += str
-            sql += "'%s')" % self.get_random_string(22)
-            tdSql.execute(sql % (self.ts + i + 2000))
-        time.sleep(1)
-        tdSql.query("select count(*) from table_31")
-        tdSql.checkData(0, 0, 3*self.num)
-        tdSql.query("select * from table_31")
-        tdSql.checkRows(3*self.num)
-        tdSql.checkCols(4092)
-
-        #define TSDB_MAX_BYTES_PER_ROW 49151   TSDB_MAX_TAGS_LEN 16384 
-        #ts:8\int:4\smallint:2\bigint:8\bool:1\float:4\tinyint:1\nchar:4*（）+2[offset]\binary:1*（）+2[offset]
-        tdLog.info('test super table max bytes per row 49151') 
-        sql = "create table stable_4(ts timestamp, "
-        for i in range(500):
-            sql += "int_%d int, " % (i + 1)
-        for i in range(500,1000):
-            sql += "smallint_%d smallint, " % (i + 1)
-        for i in range(1000,1500):
-            sql += "tinyint_%d tinyint, " % (i + 1)
-        for i in range(1500,2000):
-            sql += "double_%d double, " % (i + 1)
-        for i in range(2000,2500):
-            sql += "float_%d float, " % (i + 1)
-        for i in range(2500,3000):
-            sql += "bool_%d bool, " % (i + 1)
-        for i in range(3000,3500):
-            sql += "bigint_%d bigint, " % (i + 1)
-        for i in range(3500,3800):
-            sql += "nchar_%d nchar(20), " % (i + 1)
-        for i in range(3800,4090):
-            sql += "binary_%d binary(34), " % (i + 1)
-        sql += "col4091 binary(101))"  
-        sql += " tags (loc nchar(10),tag_1 int,tag_2 int,tag_3 int) " 
-        tdSql.execute(sql)
-        sql = '''create table table_40 using stable_4 
-                    tags('table_40' , '1' , '2' , '3' );'''
-        tdSql.execute(sql)
-        tdSql.query("select * from table_40")
-        tdSql.checkCols(4092)
-        tdSql.query("describe table_40")
-        tdSql.checkRows(4096)
-
-        tdLog.info('test super table drop and add column or tag') 
-        sql = "alter stable stable_4 drop column col4091; "
-        tdSql.execute(sql)
-        sql = "select * from stable_4; "
-        tdSql.query(sql)
-        tdSql.checkCols(4095)
-        sql = "alter table stable_4 add column col4091 binary(102); "
-        tdSql.error(sql) 
-        sql = "alter table stable_4 add column col4091 binary(101); "
-        tdSql.execute(sql)
-        sql = "select * from stable_4; "
-        tdSql.query(sql)
-        tdSql.checkCols(4096) 
-
-        sql = "alter stable stable_4 drop tag tag_1; "
-        tdSql.execute(sql)
-        sql = "select * from stable_4; "
-        tdSql.query(sql)
-        tdSql.checkCols(4095)
-        sql = "alter table stable_4 add tag tag_1 int; "
-        tdSql.execute(sql)
-        sql = "select * from stable_4; "
-        tdSql.query(sql)
-        tdSql.checkCols(4096) 
-        sql = "alter table stable_4 add tag loc1 nchar(10); "
-        tdSql.error(sql) 
-
-        tdLog.info('test super table max bytes per row 49151') 
-        sql = "create table stable_5(ts timestamp, "
-        for i in range(500):
-            sql += "int_%d int, " % (i + 1)
-        for i in range(500,1000):
-            sql += "smallint_%d smallint, " % (i + 1)
-        for i in range(1000,1500):
-            sql += "tinyint_%d tinyint, " % (i + 1)
-        for i in range(1500,2000):
-            sql += "double_%d double, " % (i + 1)
-        for i in range(2000,2500):
-            sql += "float_%d float, " % (i + 1)
-        for i in range(2500,3000):
-            sql += "bool_%d bool, " % (i + 1)
-        for i in range(3000,3500):
-            sql += "bigint_%d bigint, " % (i + 1)
-        for i in range(3500,3800):
-            sql += "nchar_%d nchar(20), " % (i + 1)
-        for i in range(3800,4090):
-            sql += "binary_%d binary(34), " % (i + 1)
-        sql += "col4091 binary(102))"  
-        sql += " tags (loc nchar(10),tag_1 int,tag_2 int,tag_3 int) " 
-        tdSql.error(sql)
-
-        print("==============step6, super table error col ==============")
-        tdLog.info('test exceeds row num') 
-        # column + tag > 4096 
-        sql = "create stable stable_2(ts timestamp, "
-        for i in range(4091):
-            sql += "col%d int, " % (i + 1)
-        sql += "col4092 binary(22))"  
-        sql += " tags (loc nchar(10),tag_1 int,tag_2 int,tag_3 int) " 
-        tdLog.info(len(sql))      
-        tdSql.error(sql)
-        
-        # column + tag > 4096
-        sql = "create stable stable_2(ts timestamp, "
-        for i in range(4090):
-            sql += "col%d int, " % (i + 1)
-        sql += "col4091 binary(22))"  
-        sql += " tags (loc nchar(10),tag_1 int,tag_2 int,tag_3 int,tag_4 int) " 
-        tdLog.info(len(sql))  
-        tdSql.error(sql)
-
-        # alter column + tag > 4096
-        sql = "alter table stable_1 add column max int; "
-        tdSql.error(sql)
-        # TD-5322
-        sql = "alter table stable_1 add tag max int; "
-        tdSql.error(sql)
-        # TD-5324
-        sql = "alter table stable_4 modify column col4091 binary(102); "
-        tdSql.error(sql)
-        sql = "alter table stable_4 modify tag loc nchar(20); "
-        tdSql.query("select * from table_40")
-        tdSql.checkCols(4092)
-        tdSql.query("describe table_40")
-        tdSql.checkRows(4096)
-
-        os.system("rm -rf tools/taosdemoAllTest/TD-5213/insert4096columns_not_use_taosdemo.py.sql") 
-
-
-    def stop(self):
-        tdSql.close()
-        tdLog.success("%s successfully executed" % __file__)
-
-
-tdCases.addWindows(__file__, TDTestCase())
-tdCases.addLinux(__file__, TDTestCase())
--- a/tests/pytest/tools/taosdemoAllTest/TD-5213/insertSigcolumnsNum4096.csv
+++ b/tests/pytest/tools/taosdemoAllTest/TD-5213/insertSigcolumnsNum4096.csv
--- a/tests/pytest/tools/taosdemoAllTest/TD-5213/insertSigcolumnsNum4096.json
+++ b/tests/pytest/tools/taosdemoAllTest/TD-5213/insertSigcolumnsNum4096.json
@ -1,137 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 10,
-    "create_table_thread_count": 10,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 10,
-    "num_of_records_per_req": 1,
-    "max_sql_len": 102400000,
-    "databases": [{
-        "dbinfo": {
-            "name": "json",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "ms",
-            "keep": 365,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb_old",
-            "child_table_exists":"no",
-            "childtable_count": 1,
-            "childtable_prefix": "stb_old_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 5,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 10,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./tools/taosdemoAllTest/TD-5213/insertSigcolumnsNum4096.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT","count":1000}, {"type": "BINARY", "len": 16, "count":20}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":1}]
-        },{
-            "name": "stb_new",
-            "child_table_exists":"no",
-            "childtable_count": 1,
-            "childtable_prefix": "stb_new_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 5,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 10,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./tools/taosdemoAllTest/sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT","count":4000}, {"type": "BINARY", "len": 16, "count":90}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":3}]
-        },{
-            "name": "stb_mix",
-            "child_table_exists":"no",
-            "childtable_count": 1,
-            "childtable_prefix": "stb_mix_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 5,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 10,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./tools/taosdemoAllTest/sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT","count":500},{"type": "SMALLINT","count":500},{"type": "TINYINT","count":500},{"type": "DOUBLE","count":500},{"type": "FLOAT","count":500},{"type": "BOOL","count":500},{"type": "BIGINT","count":500},{"type": "NCHAR","len": 20,"count":300},{"type": "BINARY","len": 34,"count":290},{"type": "BINARY","len": 101,"count":1}],
-            "tags": [{"type": "INT", "count":3}, {"type": "NCHAR", "len": 10, "count":1}]
-        },{
-            "name": "stb_excel",
-            "child_table_exists":"no",
-            "childtable_count": 1,
-            "childtable_prefix": "stb_excel_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 5,
-            "data_source": "sample",
-            "insert_mode": "taosc",
-            "insert_rows": 10,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./tools/taosdemoAllTest/TD-5213/insertSigcolumnsNum4096.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT","count":500},{"type": "SMALLINT","count":500},{"type": "SMALLINT","count":500},{"type": "DOUBLE","count":500},{"type": "FLOAT","count":500},{"type": "BOOL","count":500},{"type": "BIGINT","count":500},{"type": "NCHAR","len": 19,"count":300},{"type": "BINARY","len": 34,"count":290},{"type": "BINARY","len": 101,"count":1}],
-            "tags": [{"type": "INT", "count":3}, {"type": "NCHAR", "len": 10, "count":1}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/TD-5213/insertSigcolumnsNum4096.py
+++ b/tests/pytest/tools/taosdemoAllTest/TD-5213/insertSigcolumnsNum4096.py
@ -1,176 +0,0 @@
-###################################################################
-#           Copyright (c) 2016 by TAOS Technologies, Inc.
-#                     All rights reserved.
-#
-#  This file is proprietary and confidential to TAOS Technologies.
-#  No part of this file may be reproduced, stored, transmitted,
-#  disclosed or used in any form or by any means other than as
-#  expressly provided by the written permission from Jianhui Tao
-#
-###################################################################
-
-# -*- coding: utf-8 -*-
-
-import sys
-import os
-import time
-from util.log import *
-from util.cases import *
-from util.sql import *
-from util.dnodes import *
-
-
-class TDTestCase:
-    def init(self, conn, logSql):
-        tdLog.debug("start to execute %s" % __file__)
-        tdSql.init(conn.cursor(), logSql)
-        
-    def getBuildPath(self):
-        selfPath = os.path.dirname(os.path.realpath(__file__))
-
-        if ("community" in selfPath):
-            projPath = selfPath[:selfPath.find("community")]
-        else:
-            projPath = selfPath[:selfPath.find("tests")]
-
-        for root, dirs, files in os.walk(projPath):
-            if ("taosd" in files):
-                rootRealPath = os.path.dirname(os.path.realpath(root))
-                if ("packaging" not in rootRealPath):
-                    buildPath = root[:len(root)-len("/build/bin")]
-                    break
-        return buildPath
-        
-    def run(self):
-        buildPath = self.getBuildPath()
-        if (buildPath == ""):
-            tdLog.exit("taosd not found!")
-        else:
-            tdLog.info("taosd found in %s" % buildPath)
-        binPath = buildPath+ "/build/bin/"
-
-        #-N:regular table  -d:database name   -t:table num  -n:rows num per table  -l:col num  -y:force
-        #regular old && new
-        startTime = time.time()
-        os.system("%staosdemo -N -d regular_old -t 1 -n 10 -l 1023 -y" % binPath)
-        tdSql.execute("use regular_old")
-        tdSql.query("show tables;")
-        tdSql.checkRows(1)
-        tdSql.query("select * from d0;")
-        tdSql.checkCols(1024)
-        tdSql.query("describe d0;")
-        tdSql.checkRows(1024)
-
-        os.system("%staosdemo -N -d regular_new -t 1 -n 10 -l 4095 -y" % binPath)
-        tdSql.execute("use regular_new")
-        tdSql.query("show tables;")
-        tdSql.checkRows(1)
-        tdSql.query("select * from d0;")
-        tdSql.checkCols(4096)
-        tdSql.query("describe d0;")
-        tdSql.checkRows(4096)
-
-        #super table  -d:database name   -t:table num  -n:rows num per table  -l:col num  -y:force
-        os.system("%staosdemo -d super_old -t 1 -n 10 -l 1021 -y" % binPath)
-        tdSql.execute("use super_old")
-        tdSql.query("show tables;")
-        tdSql.checkRows(1)
-        tdSql.query("select * from meters;")
-        tdSql.checkCols(1024)
-        tdSql.query("select * from d0;")
-        tdSql.checkCols(1022)
-        tdSql.query("describe meters;")
-        tdSql.checkRows(1024)
-        tdSql.query("describe d0;")
-        tdSql.checkRows(1024)
-
-        os.system("%staosdemo -d super_new -t 1 -n 10 -l 4093 -y" % binPath)
-        tdSql.execute("use super_new")
-        tdSql.query("show tables;")
-        tdSql.checkRows(1)
-        tdSql.query("select * from meters;")
-        tdSql.checkCols(4096)
-        tdSql.query("select * from d0;")
-        tdSql.checkCols(4094)
-        tdSql.query("describe meters;")
-        tdSql.checkRows(4096)
-        tdSql.query("describe d0;")
-        tdSql.checkRows(4096)
-        tdSql.execute("create table stb_new1_1 using meters tags(1,2)")
-        tdSql.query("select * from stb_new1_1")
-        tdSql.checkCols(4094)
-        tdSql.query("describe stb_new1_1;")
-        tdSql.checkRows(4096)
-
-        # insert: create one  or mutiple tables per sql and insert multiple rows per sql 
-        # test case for https://jira.taosdata.com:18080/browse/TD-5213
-        os.system("%staosdemo -f tools/taosdemoAllTest/TD-5213/insertSigcolumnsNum4096.json -y " % binPath)
-        tdSql.execute("use json")
-        tdSql.query("select count (tbname) from stb_old")
-        tdSql.checkData(0, 0, 1)
-
-        tdSql.query("select * from stb_old")
-        tdSql.checkRows(10)
-        tdSql.checkCols(1024)
-            
-        tdSql.query("select count (tbname) from stb_new")
-        tdSql.checkData(0, 0, 1)
-
-        tdSql.query("select * from stb_new")
-        tdSql.checkRows(10)
-        tdSql.checkCols(4096)
-        tdSql.query("describe stb_new;")
-        tdSql.checkRows(4096)
-        tdSql.query("select * from stb_new_0")
-        tdSql.checkRows(10)
-        tdSql.checkCols(4091)
-        tdSql.query("describe stb_new_0;")
-        tdSql.checkRows(4096)
-        tdSql.execute("create table stb_new1_1 using stb_new tags(1,2,3,4,5)")
-        tdSql.query("select * from stb_new1_1")
-        tdSql.checkCols(4091)
-        tdSql.query("describe stb_new1_1;")
-        tdSql.checkRows(4096)
-
-        tdSql.query("select count (tbname) from stb_mix")
-        tdSql.checkData(0, 0, 1)
-
-        tdSql.query("select * from stb_mix")
-        tdSql.checkRows(10)
-        tdSql.checkCols(4096)
-        tdSql.query("describe stb_mix;")
-        tdSql.checkRows(4096)
-        tdSql.query("select * from stb_mix_0")
-        tdSql.checkRows(10)
-        tdSql.checkCols(4092)
-        tdSql.query("describe stb_mix_0;")
-        tdSql.checkRows(4096)
-
-        tdSql.query("select count (tbname) from stb_excel")
-        tdSql.checkData(0, 0, 1)
-
-        tdSql.query("select * from stb_excel")
-        tdSql.checkRows(10)
-        tdSql.checkCols(4096)
-        tdSql.query("describe stb_excel;")
-        tdSql.checkRows(4096)
-        tdSql.query("select * from stb_excel_0")
-        tdSql.checkRows(10)
-        tdSql.checkCols(4092)
-        tdSql.query("describe stb_excel_0;")
-        tdSql.checkRows(4096)
-        endTime = time.time()
-        print("total time %ds" % (endTime - startTime))  
-
-
-        os.system("rm -rf tools/taosdemoAllTest/TD-5213/insertSigcolumnsNum4096.py.sql")        
-        
-        
-        
-    def stop(self):
-        tdSql.close()
-        tdLog.success("%s successfully executed" % __file__)
-
-
-tdCases.addWindows(__file__, TDTestCase())
-tdCases.addLinux(__file__, TDTestCase())
--- a/tests/pytest/tools/taosdemoAllTest/convertResFile.py
+++ b/tests/pytest/tools/taosdemoAllTest/convertResFile.py
@ -1,43 +0,0 @@
-from datetime import datetime
-import time
-import os
-
-# class  FileSeparaSpaceConvertcomma:
-#     def __init__(self):
-#         self.inputfile = ""
-#         self.oputfile = ""
-#         self.affectedRows = 0
-   
-#     def ConvertFile(self, inputfile,):
-
-os.system("awk -v  OFS=','  '{$1=$1;print$0}' ./all_query_res0.txt  > ./new_query_res0.txt")
-with open('./new_query_res0.txt','r+') as f0:
-    contents = f0.readlines()
-    if os.path.exists('./test_query_res0.txt'):
-        os.system("rm -rf ./test_query_res0.txt")
-    for i in range(len(contents)):
-        content = contents[i].rstrip('\n')
-        stimestamp = content.split(',')[0]
-        timestamp = int(stimestamp)
-        d = datetime.fromtimestamp(timestamp/1000)
-        str0 = d.strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
-        ts = "'"+str0+"'"
-        str1 = "'"+content.split(',')[1]+"'"
-        str2 = "'"+content.split(',')[2]+"'"
-        content = ts + ","  + str1 + "," + str2 + "," + content.split(',',3)[3] 
-        contents[i] = content + "\n"
-        with open('./test_query_res0.txt','a') as fi:
-            fi.write(contents[i])
-
-os.system("rm -rf ./new_query_res0.txt")
-
-
-
-
-    
-
-        
-# timestamp = 1604160000099
-# d = datetime.fromtimestamp(timestamp/1000)
-# str1 = d.strftime("%Y-%m-%d %H:%M:%S.%f")
-# print(str1[:-3])
--- a/tests/pytest/tools/taosdemoAllTest/insert-1s1tnt1r.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-1s1tnt1r.json
@ -1,88 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 4,
-    "create_table_thread_count": 4,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 10,
-    "num_of_records_per_req": 1,
-    "max_sql_len": 1024000,
-    "databases": [{
-        "dbinfo": {
-            "name": "db",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "ms",
-            "keep": 365,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": 1000,
-            "childtable_prefix": "stb00_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 1,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 100,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":1}, {"type": "BINARY", "len": 16, "count":1}, {"type": "BINARY", "len": 32, "count":1}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":1}]
-        },
-        {
-            "name": "stb1",
-            "child_table_exists":"no",
-            "childtable_count": 1000,
-            "childtable_prefix": "stb01_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 200,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":1}, {"type": "BINARY", "len": 16, "count":1}, {"type": "BINARY", "len": 32, "count":1}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":1}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/insert-1s1tntmr.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-1s1tntmr.json
@ -1,88 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 4,
-    "create_table_thread_count": 4,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 10,
-    "num_of_records_per_req": 1000,
-    "max_sql_len": 1024000,
-    "databases": [{
-        "dbinfo": {
-            "name": "db",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "ms",
-            "keep": 365,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": 10,
-            "childtable_prefix": "stb00_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 10000,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":1}, {"type": "BINARY", "len": 16, "count":1}, {"type": "BINARY", "len": 32, "count":1}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":1}]
-        },
-        {
-            "name": "stb1",
-            "child_table_exists":"no",
-            "childtable_count": 20,
-            "childtable_prefix": "stb01_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 20000,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":1}, {"type": "BINARY", "len": 16, "count":1}, {"type": "BINARY", "len": 32, "count":1}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":1}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/insert-disorder.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-disorder.json
@ -1,88 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 4,
-    "create_table_thread_count": 4,
-    "result_file":"./insert_res.txt",
-    "confirm_parameter_prompt": "no", 
-    "insert_interval": 0,
-    "interlace_rows": 10,
-    "num_of_records_per_req": 1000,
-    "max_sql_len": 1024000,
-    "databases": [{
-        "dbinfo": {
-            "name": "db",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "ms",
-            "keep": 365,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": 1,
-            "childtable_prefix": "stb00_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 10,
-            "childtable_limit": -1,
-            "childtable_offset": 0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 1,
-            "insert_interval": 0,
-            "max_sql_len": 1024000, 
-            "disorder_ratio": 10,
-            "disorder_range": 100,
-            "timestamp_step": 1000,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        },
-        {
-            "name": "stb1",
-            "child_table_exists":"no",
-            "childtable_count":1,
-            "childtable_prefix": "stb01_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 1,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 10,
-            "childtable_limit": -1,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 100,
-            "disorder_range": 1,
-            "timestamp_step": 1000,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":10}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/insert-drop-exist-auto-N00.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-drop-exist-auto-N00.json
@ -1,181 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 4,                   
-    "create_table_thread_count": 4,        
-    "result_file": "./insert_res.txt",   
-    "confirm_parameter_prompt": "no",    
-    "insert_interval": 0,         
-    "interlace_rows": 100,        
-    "num_of_records_per_req": 100,
-    "databases": [{
-        "dbinfo": {
-            "name": "db",
-            "drop": "no",                
-            "replica": 1,
-
-
-
-            "precision": "ms",
-            "keep": 3650,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb",
-            "child_table_exists":"no",
-            "auto_create_table": "123",   
-            "childtable_count": 20,   
-            "childtable_prefix": "NN123_",    
-            "batch_create_tbl_num": 100,   
-            "data_source": "rand",       
-            "insert_mode": "taosc",      
-            "insert_rows": 5,       
-            "childtable_limit": 40,      
-            "childtable_offset":0,     
-            "interlace_rows": 0,         
-            "insert_interval":0,         
-            "max_sql_len": 1024000,      
-            "disorder_ratio": 0,         
-            "disorder_range": 1000,      
-            "timestamp_step": 10,         
-            "start_timestamp": "now",  
-            "sample_format": "csv",       
-            "sample_file": "./sample.csv",   
-            "tags_file": "",              
-            "columns": [{"type": "INT"}],
-            "tags": [{"type": "TINYINT"}]
-        },{
-            "name": "stb",
-            "child_table_exists":"no",
-            "auto_create_table": "no",   
-            "childtable_count": 20,   
-            "childtable_prefix": "NNN_",    
-            "batch_create_tbl_num": 100,   
-            "data_source": "rand",       
-            "insert_mode": "taosc",      
-            "insert_rows": 5,       
-            "childtable_limit": 40,      
-            "childtable_offset":0,     
-            "interlace_rows": 0,         
-            "insert_interval":0,         
-            "max_sql_len": 1024000,      
-            "disorder_ratio": 0,         
-            "disorder_range": 1000,      
-            "timestamp_step": 10,         
-            "start_timestamp": "now",  
-            "sample_format": "csv",       
-            "sample_file": "./sample.csv",   
-            "tags_file": "",              
-            "columns": [{"type": "INT"}],
-            "tags": [{"type": "TINYINT"}]
-        },{
-            "name": "stb",
-            "child_table_exists":"no",
-            "auto_create_table": "yes",   
-            "childtable_count": 20,   
-            "childtable_prefix": "NNY_",    
-            "batch_create_tbl_num": 100,   
-            "data_source": "rand",       
-            "insert_mode": "taosc",      
-            "insert_rows": 5,       
-            "childtable_limit": 40,      
-            "childtable_offset":0,     
-            "interlace_rows": 0,         
-            "insert_interval":0,         
-            "max_sql_len": 1024000,      
-            "disorder_ratio": 0,         
-            "disorder_range": 1000,      
-            "timestamp_step": 10,         
-            "start_timestamp": "now",  
-            "sample_format": "csv",       
-            "sample_file": "./sample.csv",   
-            "tags_file": "",              
-            "columns": [{"type": "INT"}],
-            "tags": [{"type": "TINYINT"}]
-        },{
-            "name": "stb",
-            "child_table_exists":"yes",
-            "auto_create_table": "123",   
-            "childtable_count": 20,   
-            "childtable_prefix": "NY123_",    
-            "batch_create_tbl_num": 100,   
-            "data_source": "rand",       
-            "insert_mode": "taosc",      
-            "insert_rows": 5,       
-            "childtable_limit": 40,      
-            "childtable_offset":0,     
-            "interlace_rows": 0,         
-            "insert_interval":0,         
-            "max_sql_len": 1024000,      
-            "disorder_ratio": 0,         
-            "disorder_range": 1000,      
-            "timestamp_step": 10,         
-            "start_timestamp": "now",  
-            "sample_format": "csv",       
-            "sample_file": "./sample.csv",   
-            "tags_file": "",              
-            "columns": [{"type": "INT"}],
-            "tags": [{"type": "TINYINT"}]
-        },{
-            "name": "stb",
-            "child_table_exists":"yes",
-            "auto_create_table": "no",   
-            "childtable_count": 20,   
-            "childtable_prefix": "NYN_",    
-            "batch_create_tbl_num": 100,   
-            "data_source": "rand",       
-            "insert_mode": "taosc",      
-            "insert_rows": 5,       
-            "childtable_limit": 40,      
-            "childtable_offset":0,     
-            "interlace_rows": 0,         
-            "insert_interval":0,         
-            "max_sql_len": 1024000,      
-            "disorder_ratio": 0,         
-            "disorder_range": 1000,      
-            "timestamp_step": 10,         
-            "start_timestamp": "now",  
-            "sample_format": "csv",       
-            "sample_file": "./sample.csv",   
-            "tags_file": "",              
-            "columns": [{"type": "INT"}],
-            "tags": [{"type": "TINYINT"}]
-        },{
-            "name": "stb",
-            "child_table_exists":"yes",
-            "auto_create_table": "yes",   
-            "childtable_count": 20,   
-            "childtable_prefix": "NYY_",    
-            "batch_create_tbl_num": 100,   
-            "data_source": "rand",       
-            "insert_mode": "taosc",      
-            "insert_rows": 5,       
-            "childtable_limit": 40,      
-            "childtable_offset":0,     
-            "interlace_rows": 0,         
-            "insert_interval":0,         
-            "max_sql_len": 1024000,      
-            "disorder_ratio": 0,         
-            "disorder_range": 1000,      
-            "timestamp_step": 10,         
-            "start_timestamp": "now",  
-            "sample_format": "csv",       
-            "sample_file": "./sample.csv",   
-            "tags_file": "",              
-            "columns": [{"type": "INT"}],
-            "tags": [{"type": "TINYINT"}]
-        }
-    ]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/insert-drop-exist-auto-Y00.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-drop-exist-auto-Y00.json
@ -1,181 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 4,                   
-    "create_table_thread_count": 4,        
-    "result_file": "./insert_res.txt",   
-    "confirm_parameter_prompt": "no",    
-    "insert_interval": 0,         
-    "interlace_rows": 100,        
-    "num_of_records_per_req": 100,
-    "databases": [{
-        "dbinfo": {
-            "name": "db",
-            "drop": "yes",                
-            "replica": 1,
-
-
-
-            "precision": "ms",
-            "keep": 3650,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb",
-            "child_table_exists":"no",
-            "auto_create_table": "123",   
-            "childtable_count": 20,   
-            "childtable_prefix": "YN123_",    
-            "batch_create_tbl_num": 100,   
-            "data_source": "rand",       
-            "insert_mode": "taosc",      
-            "insert_rows": 5,       
-            "childtable_limit": 40,      
-            "childtable_offset":0,     
-            "interlace_rows": 0,         
-            "insert_interval":0,         
-            "max_sql_len": 1024000,      
-            "disorder_ratio": 0,         
-            "disorder_range": 1000,      
-            "timestamp_step": 10,         
-            "start_timestamp": "now",  
-            "sample_format": "csv",       
-            "sample_file": "./sample.csv",   
-            "tags_file": "",              
-            "columns": [{"type": "INT"}],
-            "tags": [{"type": "TINYINT"}]
-        },{
-            "name": "stb",
-            "child_table_exists":"no",
-            "auto_create_table": "no",   
-            "childtable_count": 20,   
-            "childtable_prefix": "YNN_",    
-            "batch_create_tbl_num": 100,   
-            "data_source": "rand",       
-            "insert_mode": "taosc",      
-            "insert_rows": 5,       
-            "childtable_limit": 40,      
-            "childtable_offset":0,     
-            "interlace_rows": 0,         
-            "insert_interval":0,         
-            "max_sql_len": 1024000,      
-            "disorder_ratio": 0,         
-            "disorder_range": 1000,      
-            "timestamp_step": 10,         
-            "start_timestamp": "now",  
-            "sample_format": "csv",       
-            "sample_file": "./sample.csv",   
-            "tags_file": "",              
-            "columns": [{"type": "INT"}],
-            "tags": [{"type": "TINYINT"}]
-        },{
-            "name": "stb",
-            "child_table_exists":"no",
-            "auto_create_table": "yes",   
-            "childtable_count": 20,   
-            "childtable_prefix": "YNY_",    
-            "batch_create_tbl_num": 100,   
-            "data_source": "rand",       
-            "insert_mode": "taosc",      
-            "insert_rows": 5,       
-            "childtable_limit": 40,      
-            "childtable_offset":0,     
-            "interlace_rows": 0,         
-            "insert_interval":0,         
-            "max_sql_len": 1024000,      
-            "disorder_ratio": 0,         
-            "disorder_range": 1000,      
-            "timestamp_step": 10,         
-            "start_timestamp": "now",  
-            "sample_format": "csv",       
-            "sample_file": "./sample.csv",   
-            "tags_file": "",              
-            "columns": [{"type": "INT"}],
-            "tags": [{"type": "TINYINT"}]
-        },{
-            "name": "stb",
-            "child_table_exists":"yes",
-            "auto_create_table": "123",   
-            "childtable_count": 20,   
-            "childtable_prefix": "YY123_",    
-            "batch_create_tbl_num": 100,   
-            "data_source": "rand",       
-            "insert_mode": "taosc",      
-            "insert_rows": 5,       
-            "childtable_limit": 40,      
-            "childtable_offset":0,     
-            "interlace_rows": 0,         
-            "insert_interval":0,         
-            "max_sql_len": 1024000,      
-            "disorder_ratio": 0,         
-            "disorder_range": 1000,      
-            "timestamp_step": 10,         
-            "start_timestamp": "now",  
-            "sample_format": "csv",       
-            "sample_file": "./sample.csv",   
-            "tags_file": "",              
-            "columns": [{"type": "INT"}],
-            "tags": [{"type": "TINYINT"}]
-        },{
-            "name": "stb",
-            "child_table_exists":"yes",
-            "auto_create_table": "no",   
-            "childtable_count": 20,   
-            "childtable_prefix": "YYN_",    
-            "batch_create_tbl_num": 100,   
-            "data_source": "rand",       
-            "insert_mode": "taosc",      
-            "insert_rows": 5,       
-            "childtable_limit": 40,      
-            "childtable_offset":0,     
-            "interlace_rows": 0,         
-            "insert_interval":0,         
-            "max_sql_len": 1024000,      
-            "disorder_ratio": 0,         
-            "disorder_range": 1000,      
-            "timestamp_step": 10,         
-            "start_timestamp": "now",  
-            "sample_format": "csv",       
-            "sample_file": "./sample.csv",   
-            "tags_file": "",              
-            "columns": [{"type": "INT"}],
-            "tags": [{"type": "TINYINT"}]
-        },{
-            "name": "stb",
-            "child_table_exists":"yes",
-            "auto_create_table": "yes",   
-            "childtable_count": 20,   
-            "childtable_prefix": "YYY_",    
-            "batch_create_tbl_num": 100,   
-            "data_source": "rand",       
-            "insert_mode": "taosc",      
-            "insert_rows": 5,       
-            "childtable_limit": 40,      
-            "childtable_offset":0,     
-            "interlace_rows": 0,         
-            "insert_interval":0,         
-            "max_sql_len": 1024000,      
-            "disorder_ratio": 0,         
-            "disorder_range": 1000,      
-            "timestamp_step": 10,         
-            "start_timestamp": "now",  
-            "sample_format": "csv",       
-            "sample_file": "./sample.csv",   
-            "tags_file": "",              
-            "columns": [{"type": "INT"}],
-            "tags": [{"type": "TINYINT"}]
-        }
-    ]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/insert-illegal.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-illegal.json
@ -1,88 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 4,
-    "create_table_thread_count": 4,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 10,
-    "num_of_records_per_req": "-asdf",
-    "max_sql_len": 1024000,
-    "databases": [{
-        "dbinfo": {
-            "name": "db",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "ms",
-            "keep": 365,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": 10,
-            "childtable_prefix": "stb00_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 10000,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":-4,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":10}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        },
-        {
-            "name": "stb1",
-            "child_table_exists":"no",
-            "childtable_count": 20,
-            "childtable_prefix": "stb01_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": "asdf",
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 20000,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":10}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/insert-interlace-row.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-interlace-row.json
@ -1,62 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 4,
-    "create_table_thread_count": 4,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 100,
-    "num_of_records_per_req": 1000,
-    "max_sql_len": 1024000,
-    "databases": [{
-        "dbinfo": {
-            "name": "db",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "ms",
-            "keep": 365,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": 100,
-            "childtable_prefix": "stb00_",  
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 20,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 150,
-            "childtable_limit": -1,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 151,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":10}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/insert-interval-speed.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-interval-speed.json
@ -1,88 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 4,
-    "create_table_thread_count": 4,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 100,
-    "interlace_rows": 0,
-    "num_of_records_per_req": 2000,
-    "max_sql_len": 1024000,
-    "databases": [{
-        "dbinfo": {
-            "name": "db",
-            "drop": "yes",
-            "replica": 1,
-
-
-
-            "precision": "ms",
-            "keep": 365,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": 100,
-            "childtable_prefix": "stb00_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 20000,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 1000,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":1}, {"type": "BINARY", "len": 16, "count":1}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        },
-        {
-            "name": "stb1",
-            "child_table_exists":"no",
-            "childtable_count": 100,
-            "childtable_prefix": "stb01_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 20000,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 1000,
-            "insert_interval": 2000,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":1}, {"type": "BINARY", "len": 16, "count":1}, {"type": "BINARY", "len": 32, "count":1}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":1}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/insert-newdb.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-newdb.json
@ -1,166 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 4,
-    "create_table_thread_count": 4,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 0,
-    "num_of_records_per_req": 3000,
-    "max_sql_len": 1024000,
-    "databases": [{
-        "dbinfo": {
-            "name": "db",
-            "drop": "yes",
-            "replica": 1,
-
-
-
-            "precision": "ms",
-            "keep": 365,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-            "update": 1
-        },
-        "super_tables": [{
-            "name": "stb0", 
-            "child_table_exists":"yes",
-            "childtable_count": 5,
-            "childtable_prefix": "stb00_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 10,
-            "childtable_limit": -1,
-            "childtable_offset": 0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval": 0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":1}, {"type": "BINARY", "len": 16, "count":1}, {"type": "BINARY", "len": 32, "count":1}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        },
-        {
-            "name": "stb1",
-            "child_table_exists":"no",
-            "childtable_count": 6,
-            "childtable_prefix": "stb01_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 20,
-            "childtable_limit":  -1,
-            "childtable_offset": 0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval": 0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":6}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        },
-        {
-            "name": "stb2",
-            "child_table_exists":"no",
-            "childtable_count": 7,
-            "childtable_prefix": "stb02_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 20,
-            "childtable_limit": 4,
-            "childtable_offset": 0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval": 0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":6}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        },
-        {
-            "name": "stb3",
-            "child_table_exists":"no",
-            "childtable_count": 8,
-            "childtable_prefix": "stb03_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 20,
-            "childtable_limit": 2,
-            "childtable_offset": 7,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval": 0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":6}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        },
-        {
-            "name": "stb4",
-            "child_table_exists":"no",
-            "childtable_count": 8,
-            "childtable_prefix": "stb04_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 20,
-            "childtable_limit": 0,
-            "childtable_offset": 7,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval": 0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":6}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/insert-newtable.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-newtable.json
@ -1,166 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 4,
-    "create_table_thread_count": 4,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 0,
-    "num_of_records_per_req": 3000,
-    "max_sql_len": 1024000,
-    "databases": [{
-        "dbinfo": { 
-            "name": "db",
-            "drop": "no",
-            "replica": 1,
-
-
-
-            "precision": "ms",
-            "keep": 365,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-            "update": 1
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"yes",
-            "childtable_count": 5,
-            "childtable_prefix": "stb00_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 20,
-            "childtable_limit": -1,
-            "childtable_offset": 0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval": 0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-12-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":6}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        },
-        {
-            "name": "stb1",
-            "child_table_exists":"no",
-            "childtable_count": 6,
-            "childtable_prefix": "stb01_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 20,
-            "childtable_limit":  -1,
-            "childtable_offset": 0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval": 0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-12-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":6}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        },
-        {
-            "name": "stb2",
-            "child_table_exists":"no",
-            "childtable_count": 7,
-            "childtable_prefix": "stb02_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 20,
-            "childtable_limit": 4,
-            "childtable_offset": 0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval": 0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-12-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":6}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        },
-        {
-            "name": "stb3",
-            "child_table_exists":"no",
-            "childtable_count": 8,
-            "childtable_prefix": "stb03_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 20,
-            "childtable_limit": 2,
-            "childtable_offset": 7,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval": 0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-12-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":6}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        },
-        {
-            "name": "stb4",
-            "child_table_exists":"no",
-            "childtable_count": 8,
-            "childtable_prefix": "stb04_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 30,
-            "childtable_limit": 0,
-            "childtable_offset": 7,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval": 0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-12-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":6}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/insert-nodbnodrop.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-nodbnodrop.json
@ -1,62 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 4,
-    "create_table_thread_count": 4,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 0,
-    "num_of_records_per_req": 3000,
-    "max_sql_len": 1024000,
-    "databases": [{
-        "dbinfo": {
-            "name": "dbno",
-            "drop": "no",
-            "replica": 1,
-
-
-
-            "precision": "ms",
-            "keep": 365,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-            "update": 1
-        },
-        "super_tables": [{
-            "name": "stb0", 
-            "child_table_exists":"no",
-            "childtable_count": 5,
-            "childtable_prefix": "stb00_",
-            "auto_create_table": "yes",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 10,
-            "childtable_limit": -1,
-            "childtable_offset": 0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval": 0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":6}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/insert-offset.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-offset.json
@ -1,166 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 4,
-    "create_table_thread_count": 4,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 0,
-    "num_of_records_per_req": 3000,
-    "max_sql_len": 1024000,
-    "databases": [{
-        "dbinfo": {
-            "name": "db",
-            "drop": "no",
-            "replica": 1,
-
-
-
-            "precision": "ms",
-            "keep": 365,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"yes",
-            "childtable_count": 5,
-            "childtable_prefix": "stb00_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 20,
-            "childtable_limit": 0,
-            "childtable_offset": 0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval": 0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-11-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":6}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        },
-        {
-            "name": "stb1",
-            "child_table_exists":"yes",
-            "childtable_count": 6,
-            "childtable_prefix": "stb01_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 20,
-            "childtable_limit":  -1,
-            "childtable_offset": 0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval": 0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-11-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":6}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        },
-        {
-            "name": "stb2",
-            "child_table_exists":"yes",
-            "childtable_count": 7,
-            "childtable_prefix": "stb02_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 20,
-            "childtable_limit": 4,
-            "childtable_offset": 0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval": 0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-11-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":6}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        },
-        {
-            "name": "stb3",
-            "child_table_exists":"yes",
-            "childtable_count": 8,
-            "childtable_prefix": "stb03_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 20,
-            "childtable_limit": 2,
-            "childtable_offset":7,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval": 0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-11-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":6}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        },
-        {
-            "name": "stb4",
-            "child_table_exists":"yes",
-            "childtable_count": 8,
-            "childtable_prefix": "stb04_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 20,
-            "childtable_limit": 0,
-            "childtable_offset": 7,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval": 0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-11-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":6}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/insert-renewdb.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-renewdb.json
@ -1,166 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 4,
-    "create_table_thread_count": 4,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 0,
-    "num_of_records_per_req": 3000,
-    "max_sql_len": 1024000,
-    "databases": [{
-        "dbinfo": {
-            "name": "db",
-            "drop": "yes",
-            "replica": 1,
-
-
-
-            "precision": "ms",
-            "keep": 365,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-            "update": 1
-        },
-        "super_tables": [{
-            "name": "stb0", 
-            "child_table_exists":"yes",
-            "childtable_count": 5,
-            "childtable_prefix": "stb00_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 10,
-            "childtable_limit": -1,
-            "childtable_offset": 0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval": 0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":6}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        },
-        {
-            "name": "stb1",
-            "child_table_exists":"no",
-            "childtable_count": 6,
-            "childtable_prefix": "stb01_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 20,
-            "childtable_limit":  -1,
-            "childtable_offset": 0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval": 0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":6}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        },
-        {
-            "name": "stb2",
-            "child_table_exists":"no",
-            "childtable_count": 7,
-            "childtable_prefix": "stb02_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 20,
-            "childtable_limit": 4,
-            "childtable_offset": 0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval": 0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":6}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        },
-        {
-            "name": "stb3",
-            "child_table_exists":"no",
-            "childtable_count": 8,
-            "childtable_prefix": "stb03_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 20,
-            "childtable_limit": 2,
-            "childtable_offset": 7,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval": 0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":6}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        },
-        {
-            "name": "stb4",
-            "child_table_exists":"no",
-            "childtable_count": 8,
-            "childtable_prefix": "stb04_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 20,
-            "childtable_limit": 0,
-            "childtable_offset": 7,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval": 0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":6}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/insert-sample.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-sample.json
@ -1,88 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 4,
-    "create_table_thread_count": 4,
-    "result_file":"./insert_res.txt",
-    "confirm_parameter_prompt": "no",   
-    "insert_interval": 0,
-    "interlace_rows": 10,
-    "num_of_records_per_req": 1000,
-    "max_sql_len": 1024000,
-    "databases": [{
-        "dbinfo": {
-            "name": "dbtest123",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "ms",
-            "keep": 365,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": 1,
-            "childtable_prefix": "stb00_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "sample",
-            "insert_mode": "taosc",
-            "insert_rows": 10,
-            "childtable_limit": -1,
-            "childtable_offset": 0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval": 0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./tools/taosdemoAllTest/sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT", "count":3}, {"type": "DOUBLE", "count":3}, {"type": "BINARY", "len": 16, "count":1}, {"type": "BINARY", "len": 32, "count":1}, {"type": "BOOL"}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        },
-        {
-            "name": "stb1",
-            "child_table_exists":"no",
-            "childtable_count":2,
-            "childtable_prefix": "stb01_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 10,
-            "childtable_limit": -1,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 10,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "./tools/taosdemoAllTest/tags.csv",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":10}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":3}, {"type": "BINARY", "len": 16, "count":2}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/insert-timestep.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-timestep.json
@ -1,88 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 4,
-    "create_table_thread_count": 4,
-    "result_file":"./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 10,
-    "num_of_records_per_req": 1000,
-    "max_sql_len": 1024000,
-    "databases": [{
-        "dbinfo": {
-            "name": "db",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "ms",
-            "keep": 365,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": 10,
-            "childtable_prefix": "stb00_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 20,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":10}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        },
-        {
-            "name": "stb1",
-            "child_table_exists":"no",
-            "childtable_count":20,
-            "childtable_prefix": "stb01_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 20,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 10,
-            "start_timestamp": "2020-11-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":10}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/insertBinaryLenLarge16374AllcolLar49151.json
+++ b/tests/pytest/tools/taosdemoAllTest/insertBinaryLenLarge16374AllcolLar49151.json
@ -1,166 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 4,
-    "create_table_thread_count": 4,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 10,
-    "num_of_records_per_req": 10240000000,
-    "max_sql_len": 10240000000, 
-    "databases": [{
-        "dbinfo": {
-            "name": "db",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "ms",
-            "keep": 365,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": 1,
-            "childtable_prefix": "stb00_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 1,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "BINARY", "len": 16374, "count":1}],  
-            "tags": [{"type": "TINYINT", "count":12}, {"type": "BINARY", "len": 16, "count":2}]
-        },
-        {
-            "name": "stb1",
-            "child_table_exists":"no",
-            "childtable_count": 1,
-            "childtable_prefix": "stb01_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 12,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 1,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "BINARY", "len": 16370, "count":1},{"type": "INT"}], 
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        },
-        {
-            "name": "stb3",
-            "child_table_exists":"no",
-            "childtable_count": 1,
-            "childtable_prefix": "stb03_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 12,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 1,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "BINARY", "len": 16371, "count":3},{"type": "INT","count":6}], 
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        },
-        {
-            "name": "stb2",
-            "child_table_exists":"no",
-            "childtable_count": 1,
-            "childtable_prefix": "stb02_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 12,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 1,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "BINARY", "len": 16375, "count":1},{"type": "INT"}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        },
-        {
-            "name": "stb4",
-            "child_table_exists":"no",
-            "childtable_count": 1,
-            "childtable_prefix": "stb04_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 12,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 1,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 100,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "BINARY", "len": 16371, "count":3},{"type": "INT","count":6},{"type": "TINYINT"}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/insertChildTab0.json
+++ b/tests/pytest/tools/taosdemoAllTest/insertChildTab0.json
@ -1,88 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 4,
-    "create_table_thread_count": 4,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 10,
-    "num_of_records_per_req": 10,
-    "max_sql_len": 10240000000, 
-    "databases": [{
-        "dbinfo": {
-            "name": "db",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "ms",
-            "keep": 365,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": 0,
-            "childtable_prefix": "stb00_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 1,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "BINARY", "len": 1, "count":1}],
-            "tags": [{"type": "TINYINT", "count":1}, {"type": "BINARY", "len": 16, "count":2}]
-        },
-        {
-            "name": "stb1",
-            "child_table_exists":"no",
-            "childtable_count": 10,
-            "childtable_prefix": "stb01_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 12,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 2,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "BINARY", "len": 1, "count":1}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/insertChildTabLess0.json
+++ b/tests/pytest/tools/taosdemoAllTest/insertChildTabLess0.json
@ -1,88 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 4,
-    "create_table_thread_count": 4,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 10,
-    "num_of_records_per_req": 10,
-    "max_sql_len": 10240000000, 
-    "databases": [{
-        "dbinfo": {
-            "name": "db",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "ms",
-            "keep": 365,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": -1,
-            "childtable_prefix": "stb00_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 1,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "BINARY", "len": 1, "count":1}],
-            "tags": [{"type": "TINYINT", "count":1}, {"type": "BINARY", "len": 16, "count":2}]
-        },
-        {
-            "name": "stb1",
-            "child_table_exists":"no",
-            "childtable_count": 10,
-            "childtable_prefix": "stb01_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 12,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 2,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "BINARY", "len": 1, "count":1}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/insertColumnsAndTagNum4096.json
+++ b/tests/pytest/tools/taosdemoAllTest/insertColumnsAndTagNum4096.json
@ -1,62 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 4,
-    "create_table_thread_count": 4,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 0,
-    "num_of_records_per_req": 1000,
-    "max_sql_len": 10240000000, 
-    "databases": [{
-        "dbinfo": {
-            "name": "db",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "ms",
-            "keep": 365,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": 10,
-            "childtable_prefix": "stb00_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 1000,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":1004}, {"type": "BINARY", "len": 5, "count":3075}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":7}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/insertColumnsAndTagNumLarge4096.json
+++ b/tests/pytest/tools/taosdemoAllTest/insertColumnsAndTagNumLarge4096.json
@ -1,62 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 4,
-    "create_table_thread_count": 4,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 10000,
-    "num_of_records_per_req": 10000,
-    "max_sql_len": 10240000000, 
-    "databases": [{
-        "dbinfo": {
-            "name": "db",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "ms",
-            "keep": 365,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": 10,
-            "childtable_prefix": "stb00_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 1000,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":1005}, {"type": "BINARY", "len": 5, "count":3075}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":7}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/insertColumnsNum0.json
+++ b/tests/pytest/tools/taosdemoAllTest/insertColumnsNum0.json
@ -1,62 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 4,
-    "create_table_thread_count": 4,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 10,
-    "num_of_records_per_req": 100,
-    "max_sql_len": 10240000000, 
-    "databases": [{
-        "dbinfo": {
-            "name": "db",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "ms",
-            "keep": 365,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": 10,
-            "childtable_prefix": "stb00_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 1000,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 0,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":0}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":7}]
-        }]
-    }]
-}
--- a/tests/pytest/tools/taosdemoAllTest/insertInterlaceRowsLarge1M.json
+++ b/tests/pytest/tools/taosdemoAllTest/insertInterlaceRowsLarge1M.json
@ -1,62 +0,0 @@
-{
-    "filetype": "insert",
-    "cfgdir": "/etc/taos",
-    "host": "127.0.0.1",
-    "port": 6030,
-    "user": "root",
-    "password": "taosdata",
-    "thread_count": 4,
-    "create_table_thread_count": 4,
-    "result_file": "./insert_res.txt",
-    "confirm_parameter_prompt": "no",
-    "insert_interval": 0,
-    "interlace_rows": 0,
-    "num_of_records_per_req": 1000,
-    "max_sql_len": 10240000000, 
-    "databases": [{
-        "dbinfo": {
-            "name": "db",
-            "drop": "yes",
-            "replica": 1,
-
-            "cache": 50,
-
-            "precision": "ms",
-            "keep": 365,
-            "minRows": 100,
-            "maxRows": 4096,
-            "comp":2
-
-
-
-
-
-        },
-        "super_tables": [{
-            "name": "stb0",
-            "child_table_exists":"no",
-            "childtable_count": 10,
-            "childtable_prefix": "stb00_",
-            "auto_create_table": "no",
-            "batch_create_tbl_num": 10,
-            "data_source": "rand",
-            "insert_mode": "taosc",
-            "insert_rows": 1001,
-            "childtable_limit": 0,
-            "childtable_offset":0,
-            "multi_thread_write_one_tbl": "no",
-            "interlace_rows": 1000,
-            "insert_interval":0,
-            "max_sql_len": 1024000,
-            "disorder_ratio": 0,
-            "disorder_range": 1000,
-            "timestamp_step": 1,
-            "start_timestamp": "2020-10-01 00:00:00.000",
-            "sample_format": "csv",
-            "sample_file": "./sample.csv",
-            "tags_file": "",
-            "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":1004}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
-            "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":7}]
-        }]
-    }]
-}
--- a/Show More
+++ b/Show More