Merge branch '3.0' into 3.0test/jcy

docs/zh/05-get-started/03-package.md

 ---
 sidebar_label: 安装包
-title: 使用安装包安装和卸载
+title: 使用安装包立即开始
 ---
 
 import Tabs from "@theme/Tabs";
@@ -169,72 +169,128 @@ install.sh 安装脚本在执行过程中，会通过命令行交互界面询问
 
 :::
 
-## 卸载
+## 启动
 
-<Tabs>
-<TabItem label="apt-get 卸载" value="aptremove">
+安装后，请使用 `systemctl` 命令来启动 TDengine 的服务进程。
 
-内容 TBD
+```bash
+systemctl start taosd
+```
 
-</TabItem>
-<TabItem label="Deb 卸载" value="debuninst">
+检查服务是否正常工作：
+
+```bash
+systemctl status taosd
+```
 
-卸载命令如下:
+如果服务进程处于活动状态，则 status 指令会显示如下的相关信息：
 
 ```
-$ sudo dpkg -r tdengine
-(Reading database ... 137504 files and directories currently installed.)
-Removing tdengine (2.4.0.7) ...
-TDengine is removed successfully!
+Active: active (running)
+```
 
+如果后台服务进程处于停止状态，则 status 指令会显示如下的相关信息：
+
+```
+Active: inactive (dead)
 ```
 
-</TabItem>
+如果 TDengine 服务正常工作，那么您可以通过 TDengine 的命令行程序 `taos` 来访问并体验 TDengine。
+
+systemctl 命令汇总：
+
+- 启动服务进程：`systemctl start taosd`
+
+- 停止服务进程：`systemctl stop taosd`
+
+- 重启服务进程：`systemctl restart taosd`
+
+- 查看服务状态：`systemctl status taosd`
+
+:::info
+
+- systemctl 命令需要 _root_ 权限来运行，如果您非 _root_ 用户，请在命令前添加 sudo 。
+- `systemctl stop taosd` 指令在执行后并不会马上停止 TDengine 服务，而是会等待系统中必要的落盘工作正常完成。在数据量很大的情况下，这可能会消耗较长时间。
+- 如果系统中不支持 `systemd`，也可以用手动运行 `/usr/local/taos/bin/taosd` 方式启动 TDengine 服务。
+
+:::
 
-<TabItem label="RPM 卸载" value="rpmuninst">
+## TDengine 命令行 (CLI)
 
-卸载命令如下:
+为便于检查 TDengine 的状态，执行数据库 (Database) 的各种即席(Ad Hoc)查询，TDengine 提供一命令行应用程序(以下简称为 TDengine CLI) taos。要进入 TDengine 命令行，您只要在安装有 TDengine 的 Linux 终端执行 `taos` 即可。
 
+```bash
+taos
 ```
-$ sudo rpm -e tdengine
-TDengine is removed successfully!
+
+如果连接服务成功，将会打印出欢迎消息和版本信息。如果失败，则会打印错误消息出来（请参考 [FAQ](/train-faq/faq) 来解决终端连接服务端失败的问题）。 TDengine CLI 的提示符号如下：
+
+```cmd
+taos>
 ```
 
-</TabItem>
+在 TDengine CLI 中，用户可以通过 SQL 命令来创建/删除数据库、表等，并进行数据库(database)插入查询操作。在终端中运行的 SQL 语句需要以分号结束来运行。示例：
+
+```sql
+create database demo;
+use demo;
+create table t (ts timestamp, speed int);
+insert into t values ('2019-07-15 00:00:00', 10);
+insert into t values ('2019-07-15 01:00:00', 20);
+select * from t;
+           ts            |    speed    |
+========================================
+ 2019-07-15 00:00:00.000 |          10 |
+ 2019-07-15 01:00:00.000 |          20 |
+Query OK, 2 row(s) in set (0.003128s)
+```
 
-<TabItem label="tar.gz 卸载" value="taruninst">
+除执行 SQL 语句外，系统管理员还可以从 TDengine CLI 进行检查系统运行状态、添加删除用户账号等操作。TDengine CLI 连同应用驱动也可以独立安装在 Linux 或 Windows 机器上运行，更多细节请参考 [这里](../reference/taos-shell/)
 
-卸载命令如下:
+## 使用 taosBenchmark 体验写入速度
 
-```
-$ rmtaos
-Nginx for TDengine is running, stopping it...
-TDengine is removed successfully!
+启动 TDengine 的服务，在 Linux 终端执行 `taosBenchmark` （曾命名为 `taosdemo`）：
 
-taosKeeper is removed successfully!
+```bash
+taosBenchmark
 ```
 
-</TabItem>
-</Tabs>
+该命令将在数据库 test 下面自动创建一张超级表 meters，该超级表下有 1 万张表，表名为 "d0" 到 "d9999"，每张表有 1 万条记录，每条记录有 (ts, current, voltage, phase) 四个字段，时间戳从 "2017-07-14 10:40:00 000" 到 "2017-07-14 10:40:09 999"，每张表带有标签 location 和 groupId，groupId 被设置为 1 到 10， location 被设置为 "California.SanFrancisco" 或者 "California.LosAngeles"。
 
-:::info
+这条命令很快完成 1 亿条记录的插入。具体时间取决于硬件性能，即使在一台普通的 PC 服务器往往也仅需十几秒。
+
+taosBenchmark 命令本身带有很多选项，配置表的数目、记录条数等等，您可以设置不同参数进行体验，请执行 `taosBenchmark --help` 详细列出。taosBenchmark 详细使用方法请参照 [如何使用 taosBenchmark 对 TDengine 进行性能测试](https://www.taosdata.com/2021/10/09/3111.html)。
+
+## 使用 TDengine CLI 体验查询速度
+
+使用上述 taosBenchmark 插入数据后，可以在 TDengine CLI 输入查询命令，体验查询速度。
+
+查询超级表下记录总条数：
 
-- TDengine 提供了多种安装包，但最好不要在一个系统上同时使用 tar.gz 安装包和 deb 或 rpm 安装包。否则会相互影响，导致在使用时出现问题。
+```sql
+taos> select count(*) from test.meters;
+```
 
-- 对于 deb 包安装后，如果安装目录被手工误删了部分，出现卸载、或重新安装不能成功。此时，需要清除 TDengine 包的安装信息，执行如下命令：
+查询 1 亿条记录的平均值、最大值、最小值等：
 
-  ```
-  $ sudo rm -f /var/lib/dpkg/info/tdengine*
-  ```
+```sql
+taos> select avg(current), max(voltage), min(phase) from test.meters;
+```
 
-然后再重新进行安装就可以了。
+查询 location="California.SanFrancisco" 的记录总条数：
 
-- 对于 rpm 包安装后，如果安装目录被手工误删了部分，出现卸载、或重新安装不能成功。此时，需要清除 TDengine 包的安装信息，执行如下命令：
+```sql
+taos> select count(*) from test.meters where location="California.SanFrancisco";
+```
 
-  ```
-  $ sudo rpm -e --noscripts tdengine
-  ```
+查询 groupId=10 的所有记录的平均值、最大值、最小值等：
+
+```sql
+taos> select avg(current), max(voltage), min(phase) from test.meters where groupId=10;
+```
 
-然后再重新进行安装就可以了。
+对表 d10 按 10s 进行平均值、最大值和最小值聚合统计：
 
-:::
+```sql
\ No newline at end of file
+taos> select avg(current), max(voltage), min(phase) from test.d10 interval(10s);
+```
\ No newline at end of file

docs/zh/05-get-started/06-first-use.md

----
-sidebar_label: 开始使用
-title: 快速体验 TDengine
----
-
-import Tabs from "@theme/Tabs";
-import TabItem from "@theme/TabItem";
-import PkgInstall from "./\_pkg_install.mdx";
-import AptGetInstall from "./\_apt_get_install.mdx";
-
-## 启动
-
-安装后，请使用 `systemctl` 命令来启动 TDengine 的服务进程。
-
-```bash
-systemctl start taosd
-```
-
-检查服务是否正常工作：
-
-```bash
-systemctl status taosd
-```
-
-如果服务进程处于活动状态，则 status 指令会显示如下的相关信息：
-
-```
-Active: active (running)
-```
-
-如果后台服务进程处于停止状态，则 status 指令会显示如下的相关信息：
-
-```
-Active: inactive (dead)
-```
-
-如果 TDengine 服务正常工作，那么您可以通过 TDengine 的命令行程序 `taos` 来访问并体验 TDengine。
-
-systemctl 命令汇总：
-
-- 启动服务进程：`systemctl start taosd`
-
-- 停止服务进程：`systemctl stop taosd`
-
-- 重启服务进程：`systemctl restart taosd`
-
-- 查看服务状态：`systemctl status taosd`
-
-:::info
-
-- systemctl 命令需要 _root_ 权限来运行，如果您非 _root_ 用户，请在命令前添加 sudo 。
-- `systemctl stop taosd` 指令在执行后并不会马上停止 TDengine 服务，而是会等待系统中必要的落盘工作正常完成。在数据量很大的情况下，这可能会消耗较长时间。
-- 如果系统中不支持 `systemd`，也可以用手动运行 `/usr/local/taos/bin/taosd` 方式启动 TDengine 服务。
-
-:::
-
-## TDengine 命令行 (CLI)
-
-为便于检查 TDengine 的状态，执行数据库 (Database) 的各种即席(Ad Hoc)查询，TDengine 提供一命令行应用程序(以下简称为 TDengine CLI) taos。要进入 TDengine 命令行，您只要在安装有 TDengine 的 Linux 终端执行 `taos` 即可。
-
-```bash
-taos
-```
-
-如果连接服务成功，将会打印出欢迎消息和版本信息。如果失败，则会打印错误消息出来（请参考 [FAQ](/train-faq/faq) 来解决终端连接服务端失败的问题）。 TDengine CLI 的提示符号如下：
-
-```cmd
-taos>
-```
-
-在 TDengine CLI 中，用户可以通过 SQL 命令来创建/删除数据库、表等，并进行数据库(database)插入查询操作。在终端中运行的 SQL 语句需要以分号结束来运行。示例：
-
-```sql
-create database demo;
-use demo;
-create table t (ts timestamp, speed int);
-insert into t values ('2019-07-15 00:00:00', 10);
-insert into t values ('2019-07-15 01:00:00', 20);
-select * from t;
-           ts            |    speed    |
-========================================
- 2019-07-15 00:00:00.000 |          10 |
- 2019-07-15 01:00:00.000 |          20 |
-Query OK, 2 row(s) in set (0.003128s)
-```
-
-除执行 SQL 语句外，系统管理员还可以从 TDengine CLI 进行检查系统运行状态、添加删除用户账号等操作。TDengine CLI 连同应用驱动也可以独立安装在 Linux 或 Windows 机器上运行，更多细节请参考 [这里](../reference/taos-shell/)
-
-## 使用 taosBenchmark 体验写入速度
-
-启动 TDengine 的服务，在 Linux 终端执行 `taosBenchmark` （曾命名为 `taosdemo`）：
-
-```bash
-taosBenchmark
-```
-
-该命令将在数据库 test 下面自动创建一张超级表 meters，该超级表下有 1 万张表，表名为 "d0" 到 "d9999"，每张表有 1 万条记录，每条记录有 (ts, current, voltage, phase) 四个字段，时间戳从 "2017-07-14 10:40:00 000" 到 "2017-07-14 10:40:09 999"，每张表带有标签 location 和 groupId，groupId 被设置为 1 到 10， location 被设置为 "California.SanFrancisco" 或者 "California.LosAngeles"。
-
-这条命令很快完成 1 亿条记录的插入。具体时间取决于硬件性能，即使在一台普通的 PC 服务器往往也仅需十几秒。
-
-taosBenchmark 命令本身带有很多选项，配置表的数目、记录条数等等，您可以设置不同参数进行体验，请执行 `taosBenchmark --help` 详细列出。taosBenchmark 详细使用方法请参照 [如何使用 taosBenchmark 对 TDengine 进行性能测试](https://www.taosdata.com/2021/10/09/3111.html)。
-
-## 使用 TDengine CLI 体验查询速度
-
-使用上述 taosBenchmark 插入数据后，可以在 TDengine CLI 输入查询命令，体验查询速度。
-
-查询超级表下记录总条数：
-
-```sql
-taos> select count(*) from test.meters;
-```
-
-查询 1 亿条记录的平均值、最大值、最小值等：
-
-```sql
-taos> select avg(current), max(voltage), min(phase) from test.meters;
-```
-
-查询 location="California.SanFrancisco" 的记录总条数：
-
-```sql
-taos> select count(*) from test.meters where location="California.SanFrancisco";
-```
-
-查询 groupId=10 的所有记录的平均值、最大值、最小值等：
-
-```sql
-taos> select avg(current), max(voltage), min(phase) from test.meters where groupId=10;
-```
-
-对表 d10 按 10s 进行平均值、最大值和最小值聚合统计：
-
-```sql
-taos> select avg(current), max(voltage), min(phase) from test.d10 interval(10s);
-```

docs/zh/10-deployment/01-deploy.md

@@ -55,6 +55,8 @@ fqdn                  h1.taosdata.com
 // 配置本数据节点的端口号，缺省是 6030
 serverPort            6030
 
+```
+
 一定要修改的参数是 firstEp 和 fqdn。在每个数据节点，firstEp 需全部配置成一样，但 fqdn 一定要配置成其所在数据节点的值。其他参数可不做任何修改，除非你很清楚为什么要修改。
 
 加入到集群中的数据节点 dnode，下表中涉及集群相关的参数必须完全相同，否则不能成功加入到集群中。
@@ -68,12 +70,9 @@ serverPort            6030
 
 ## 启动集群
 
-### 启动第一个数据节点
-
 按照《立即开始》里的步骤，启动第一个数据节点，例如 h1.taosdata.com，然后执行 taos，启动 taos shell，从 shell 里执行命令“SHOW DNODES”，如下所示：
 
 ```
-
 Welcome to the TDengine shell from Linux, Client Version:3.0.0.0
 Copyright (c) 2022 by TAOS Data, Inc. All rights reserved.
 
@@ -85,15 +84,12 @@ id | endpoint | vnodes | support_vnodes | status | create_time | note |
 1 | h1.taosdata.com:6030 | 0 | 1024 | ready | 2022-07-16 10:50:42.673 | |
 Query OK, 1 rows affected (0.007984s)
 
-taos>
 
-taos>
-
-````
+```
 
 上述命令里，可以看到刚启动的数据节点的 End Point 是：h1.taos.com:6030，就是这个新集群的 firstEp。
 
-### 添加数据节点
+## 添加数据节点
 
 将后续的数据节点添加到现有集群，具体有以下几步：
 

docs/zh/13-operation/01-pkg-install.md

@@ -8,9 +8,11 @@ import TabItem from "@theme/TabItem";
 
 本节将介绍一些关于安装和卸载更深层次的内容，以及升级的注意事项。
 
-## 安装和卸载
+## 安装
+
+关于安装，请参考 [使用安装包立即开始](../get-started/package)
+
 
-关于安装和卸载，请参考 [安装和卸载](../get-started/package)
 
 ## 安装目录说明
 
@@ -40,6 +42,76 @@ lrwxrwxrwx  1 root root   13 Feb 22 09:34 log -> /var/log/taos/
 - /usr/local/taos/driver 目录下的动态库文件，会软链接到 /usr/lib 目录下；
 - /usr/local/taos/include 目录下的头文件，会软链接到到 /usr/include 目录下；
 
+## 卸载
+
+<Tabs>
+<TabItem label="apt-get 卸载" value="aptremove">
+
+内容 TBD
+
+</TabItem>
+<TabItem label="Deb 卸载" value="debuninst">
+
+卸载命令如下:
+
+```
+$ sudo dpkg -r tdengine
+(Reading database ... 137504 files and directories currently installed.)
+Removing tdengine (2.4.0.7) ...
+TDengine is removed successfully!
+
+```
+
+</TabItem>
+
+<TabItem label="RPM 卸载" value="rpmuninst">
+
+卸载命令如下:
+
+```
+$ sudo rpm -e tdengine
+TDengine is removed successfully!
+```
+
+</TabItem>
+
+<TabItem label="tar.gz 卸载" value="taruninst">
+
+卸载命令如下:
+
+```
+$ rmtaos
+Nginx for TDengine is running, stopping it...
+TDengine is removed successfully!
+
+taosKeeper is removed successfully!
+```
+
+</TabItem>
+</Tabs>
+
+:::info
+
+- TDengine 提供了多种安装包，但最好不要在一个系统上同时使用 tar.gz 安装包和 deb 或 rpm 安装包。否则会相互影响，导致在使用时出现问题。
+
+- 对于 deb 包安装后，如果安装目录被手工误删了部分，出现卸载、或重新安装不能成功。此时，需要清除 TDengine 包的安装信息，执行如下命令：
+
+  ```
+  $ sudo rm -f /var/lib/dpkg/info/tdengine*
+  ```
+
+然后再重新进行安装就可以了。
+
+- 对于 rpm 包安装后，如果安装目录被手工误删了部分，出现卸载、或重新安装不能成功。此时，需要清除 TDengine 包的安装信息，执行如下命令：
+
+  ```
+  $ sudo rpm -e --noscripts tdengine
+  ```
+
+然后再重新进行安装就可以了。
+
+:::
+
 ## 卸载和更新文件说明
 
 卸载安装包的时候，将保留配置文件、数据库文件和日志文件，即 /etc/taos/taos.cfg 、 /var/lib/taos 、 /var/log/taos 。如果用户确认后不需保留，可以手工删除，但一定要慎重，因为删除后，数据将永久丢失，不可以恢复！
@@ -64,4 +136,4 @@ lrwxrwxrwx  1 root root   13 Feb 22 09:34 log -> /var/log/taos/
 :::warning
 TDengine 不保证低版本能够兼容高版本的数据，所以任何时候都不推荐降级
 
-:::
+:::
\ No newline at end of file

include/common/tcommon.h

@@ -103,6 +103,7 @@ typedef struct SDataBlockInfo {
   int16_t     hasVarCol;
   uint32_t    capacity;
   // TODO: optimize and remove following
+  int64_t     version;  // used for stream, and need serialization
   int32_t     childId;  // used for stream, do not serialize
   EStreamType type;     // used for stream, do not serialize
   STimeWindow calWin;   // used for stream, do not serialize

include/common/tmsg.h

@@ -438,7 +438,7 @@ static FORCE_INLINE int32_t tDecodeSSchemaWrapperEx(SDecoder* pDecoder, SSchemaW
   return 0;
 }
 
-STSchema* tdGetSTSChemaFromSSChema(SSchema** pSchema, int32_t nCols);
+STSchema* tdGetSTSChemaFromSSChema(SSchema* pSchema, int32_t nCols, int32_t sver);
 
 typedef struct {
   char     name[TSDB_TABLE_FNAME_LEN];
@@ -1359,6 +1359,7 @@ typedef struct {
   int32_t numOfCols;
   int64_t skey;
   int64_t ekey;
+  int64_t version;  // for stream
   char    data[];
 } SRetrieveTableRsp;
 

include/libs/executor/executor.h

@@ -64,7 +64,7 @@ qTaskInfo_t qCreateStreamExecTaskInfo(void* msg, SReadHandle* readers);
  * @param SReadHandle
  * @return
  */
-qTaskInfo_t qCreateQueueExecTaskInfo(void* msg, SReadHandle* readers, int32_t* numOfCols);
+qTaskInfo_t qCreateQueueExecTaskInfo(void* msg, SReadHandle* readers, int32_t* numOfCols, SSchemaWrapper** pSchemaWrapper);
 
 /**
  * Set the input data block for the stream scan.

include/libs/stream/tstream.h

@@ -142,6 +142,7 @@ static FORCE_INLINE void* streamQueueNextItem(SStreamQueue* queue) {
     ASSERT(queue->qItem != NULL);
     return streamQueueCurItem(queue);
   } else {
+    queue->qItem = NULL;
     taosGetQitem(queue->qall, &queue->qItem);
     if (queue->qItem == NULL) {
       taosReadAllQitems(queue->queue, queue->qall);

source/client/test/clientTests.cpp

@@ -826,7 +826,7 @@ TEST(testCase, update_test) {
   TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
   ASSERT_NE(pConn, nullptr);
 
-  TAOS_RES* pRes = taos_query(pConn, "create database if not exists abc1");
+  TAOS_RES* pRes = taos_query(pConn, "select cast(0 as timestamp)-1y");
   if (taos_errno(pRes) != TSDB_CODE_SUCCESS) {
     printf("failed to create database, code:%s", taos_errstr(pRes));
     taos_free_result(pRes);

source/common/src/tdatablock.c

@@ -1163,9 +1163,15 @@ static int32_t doEnsureCapacity(SColumnInfoData* pColumn, const SDataBlockInfo*
 void colInfoDataCleanup(SColumnInfoData* pColumn, uint32_t numOfRows) {
   if (IS_VAR_DATA_TYPE(pColumn->info.type)) {
     pColumn->varmeta.length = 0;
+    if (pColumn->varmeta.offset > 0) {
+      memset(pColumn->varmeta.offset, 0, sizeof(int32_t) * numOfRows);
+    }
   } else {
     if (pColumn->nullbitmap != NULL) {
       memset(pColumn->nullbitmap, 0, BitmapLen(numOfRows));
+      if (pColumn->pData != NULL) {
+        memset(pColumn->pData, 0, pColumn->info.bytes * numOfRows);
+      }
     }
   }
 }

source/common/src/tmsg.c

@@ -4941,14 +4941,14 @@ int tDecodeSVCreateStbReq(SDecoder *pCoder, SVCreateStbReq *pReq) {
   return 0;
 }
 
-STSchema *tdGetSTSChemaFromSSChema(SSchema **pSchema, int32_t nCols) {
+STSchema *tdGetSTSChemaFromSSChema(SSchema *pSchema, int32_t nCols, int32_t sver) {
   STSchemaBuilder schemaBuilder = {0};
-  if (tdInitTSchemaBuilder(&schemaBuilder, 1) < 0) {
+  if (tdInitTSchemaBuilder(&schemaBuilder, sver) < 0) {
     return NULL;
   }
 
   for (int i = 0; i < nCols; i++) {
-    SSchema *schema = *pSchema + i;
+    SSchema *schema = pSchema + i;
     if (tdAddColToSchema(&schemaBuilder, schema->type, schema->flags, schema->colId, schema->bytes) < 0) {
       tdDestroyTSchemaBuilder(&schemaBuilder);
       return NULL;

source/common/src/trow.c

@@ -568,6 +568,7 @@ int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow) {
   int32_t   maxVarDataLen = 0;
   int32_t   iColVal = 0;
   void     *varBuf = NULL;
+  bool      isAlloc = false;
 
   ASSERT(nColVal > 1);
 
@@ -610,8 +611,11 @@ int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow) {
     ++iColVal;
   }
 
-  *ppRow = (STSRow *)taosMemoryCalloc(
-      1, sizeof(STSRow) + pTSchema->flen + varDataLen + TD_BITMAP_BYTES(pTSchema->numOfCols - 1));
+  if (!(*ppRow)) {
+    *ppRow = (STSRow *)taosMemoryCalloc(
+        1, sizeof(STSRow) + pTSchema->flen + varDataLen + TD_BITMAP_BYTES(pTSchema->numOfCols - 1));
+    isAlloc = true;
+  }
 
   if (!(*ppRow)) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -621,7 +625,9 @@ int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow) {
   if (maxVarDataLen > 0) {
     varBuf = taosMemoryMalloc(maxVarDataLen);
     if (!varBuf) {
-      taosMemoryFreeClear(*ppRow);
+      if(isAlloc) {
+        taosMemoryFreeClear(*ppRow);
+      }
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       return -1;
     }
@@ -1323,12 +1329,11 @@ void tTSRowGetVal(STSRow *pRow, STSchema *pTSchema, int16_t iCol, SColVal *pColV
   SCellVal  cv;
   SValue    value;
 
-  ASSERT(iCol > 0);
+  ASSERT((pTColumn->colId == PRIMARYKEY_TIMESTAMP_COL_ID) || (iCol > 0));
 
   if (TD_IS_TP_ROW(pRow)) {
     tdSTpRowGetVal(pRow, pTColumn->colId, pTColumn->type, pTSchema->flen, pTColumn->offset, iCol - 1, &cv);
   } else if (TD_IS_KV_ROW(pRow)) {
-    ASSERT(iCol > 0);
     tdSKvRowGetVal(pRow, pTColumn->colId, iCol - 1, &cv);
   } else {
     ASSERT(0);

source/common/test/dataformatTest.cpp

@@ -116,7 +116,7 @@ STSchema *genSTSchema(int16_t nCols) {
   }
 
   STSchema *pResult = NULL;
-  pResult = tdGetSTSChemaFromSSChema(&pSchema, nCols);
+  pResult = tdGetSTSChemaFromSSChema(pSchema, nCols, 1);
 
   taosMemoryFree(pSchema);
   return pResult;

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

@@ -868,7 +868,10 @@ int32_t mndDropSubByTopic(SMnode *pMnode, STrans *pTrans, const char *topicName)
     }
 
     // iter all vnode to delete handle
-    ASSERT(taosHashGetSize(pSub->consumerHash) == 0);
+    if (taosHashGetSize(pSub->consumerHash) != 0) {
+      sdbRelease(pSdb, pSub);
+      return -1;
+    }
     int32_t sz = taosArrayGetSize(pSub->unassignedVgs);
     for (int32_t i = 0; i < sz; i++) {
       SMqVgEp       *pVgEp = taosArrayGetP(pSub->unassignedVgs, i);

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

@@ -583,6 +583,7 @@ static int32_t mndProcessDropTopicReq(SRpcMsg *pReq) {
   mndTransSetDbName(pTrans, pTopic->db, NULL);
   if (pTrans == NULL) {
     mError("topic:%s, failed to drop since %s", pTopic->name, terrstr());
+    mndReleaseTopic(pMnode, pTopic);
     return -1;
   }
 
@@ -590,11 +591,17 @@ static int32_t mndProcessDropTopicReq(SRpcMsg *pReq) {
 
   if (mndDropOffsetByTopic(pMnode, pTrans, dropReq.name) < 0) {
     ASSERT(0);
+    mndTransDrop(pTrans);
+    mndReleaseTopic(pMnode, pTopic);
     return -1;
   }
 
+  // TODO check if rebalancing
   if (mndDropSubByTopic(pMnode, pTrans, dropReq.name) < 0) {
-    ASSERT(0);
+    /*ASSERT(0);*/
+    mError("topic:%s, failed to drop since %s", pTopic->name, terrstr());
+    mndTransDrop(pTrans);
+    mndReleaseTopic(pMnode, pTopic);
     return -1;
   }
 

source/dnode/vnode/src/inc/tq.h

@@ -68,7 +68,7 @@ typedef struct {
 
 typedef struct {
   char*       qmsg;
-  qTaskInfo_t task[5];
+  qTaskInfo_t task;
 } STqExecCol;
 
 typedef struct {
@@ -82,13 +82,14 @@ typedef struct {
 typedef struct {
   int8_t subType;
 
-  STqReader* pExecReader[5];
+  STqReader* pExecReader;
   union {
     STqExecCol execCol;
     STqExecTb  execTb;
     STqExecDb  execDb;
   };
-  int32_t numOfCols;  // number of out pout column, temporarily used
+  int32_t         numOfCols;       // number of out pout column, temporarily used
+  SSchemaWrapper *pSchemaWrapper;  // columns that are involved in query
 } STqExecHandle;
 
 typedef struct {
@@ -138,8 +139,7 @@ int64_t tqScan(STQ* pTq, const STqHandle* pHandle, SMqDataRsp* pRsp, STqOffsetVa
 int64_t tqFetchLog(STQ* pTq, STqHandle* pHandle, int64_t* fetchOffset, SWalCkHead** pHeadWithCkSum);
 
 // tqExec
-int32_t tqLogScanExec(STQ* pTq, STqExecHandle* pExec, SSubmitReq* pReq, SMqDataRsp* pRsp, int32_t workerId);
-int32_t tqScanSnapshot(STQ* pTq, const STqExecHandle* pExec, SMqDataRsp* pRsp, STqOffsetVal offset, int32_t workerId);
+int32_t tqLogScanExec(STQ* pTq, STqExecHandle* pExec, SSubmitReq* pReq, SMqDataRsp* pRsp);
 int32_t tqSendDataRsp(STQ* pTq, const SRpcMsg* pMsg, const SMqPollReq* pReq, const SMqDataRsp* pRsp);
 
 // tqMeta

source/dnode/vnode/src/inc/vnodeInt.h

@@ -146,7 +146,7 @@ int32_t tqCheckColModifiable(STQ* pTq, int32_t colId);
 int32_t tqProcessVgChangeReq(STQ* pTq, char* msg, int32_t msgLen);
 int32_t tqProcessVgDeleteReq(STQ* pTq, char* msg, int32_t msgLen);
 int32_t tqProcessOffsetCommitReq(STQ* pTq, char* msg, int32_t msgLen);
-int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId);
+int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg);
 int32_t tqProcessTaskDeployReq(STQ* pTq, char* msg, int32_t msgLen);
 int32_t tqProcessTaskDropReq(STQ* pTq, char* msg, int32_t msgLen);
 int32_t tqProcessStreamTrigger(STQ* pTq, SSubmitReq* data);

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

@@ -579,9 +579,11 @@ static int32_t tdRSmaFetchAndSubmitResult(SRSmaInfoItem *pItem, STSchema *pTSche
   while (1) {
     SSDataBlock *output = NULL;
     uint64_t     ts;
-    if (qExecTask(pItem->taskInfo, &output, &ts) < 0) {
+
+    int32_t code = qExecTask(pItem->taskInfo, &output, &ts);
+    if (code < 0) {
       smaError("vgId:%d, qExecTask for rsma table %" PRIi64 "l evel %" PRIi8 " failed since %s", SMA_VID(pSma), suid,
-               pItem->level, terrstr());
+               pItem->level, terrstr(code));
       goto _err;
     }
     if (!output) {
@@ -597,35 +599,36 @@ static int32_t tdRSmaFetchAndSubmitResult(SRSmaInfoItem *pItem, STSchema *pTSche
     }
 
     taosArrayPush(pResult, output);
-  }
 
-  if (taosArrayGetSize(pResult) > 0) {
+    if (taosArrayGetSize(pResult) > 0) {
 #if 1
-    char flag[10] = {0};
-    snprintf(flag, 10, "level %" PRIi8, pItem->level);
-    blockDebugShowDataBlocks(pResult, flag);
+      char flag[10] = {0};
+      snprintf(flag, 10, "level %" PRIi8, pItem->level);
+      blockDebugShowDataBlocks(pResult, flag);
 #endif
-    STsdb      *sinkTsdb = (pItem->level == TSDB_RETENTION_L1 ? pSma->pRSmaTsdb[0] : pSma->pRSmaTsdb[1]);
-    SSubmitReq *pReq = NULL;
-    // TODO: the schema update should be handled
-    if (buildSubmitReqFromDataBlock(&pReq, pResult, pTSchema, SMA_VID(pSma), suid) < 0) {
-      smaError("vgId:%d, build submit req for rsma table %" PRIi64 "l evel %" PRIi8 " failed since %s", SMA_VID(pSma),
-               suid, pItem->level, terrstr());
-      goto _err;
-    }
+      STsdb      *sinkTsdb = (pItem->level == TSDB_RETENTION_L1 ? pSma->pRSmaTsdb[0] : pSma->pRSmaTsdb[1]);
+      SSubmitReq *pReq = NULL;
+      // TODO: the schema update should be handled
+      if (buildSubmitReqFromDataBlock(&pReq, pResult, pTSchema, SMA_VID(pSma), suid) < 0) {
+        smaError("vgId:%d, build submit req for rsma table %" PRIi64 "l evel %" PRIi8 " failed since %s", SMA_VID(pSma),
+                 suid, pItem->level, terrstr());
+        goto _err;
+      }
+
+      if (pReq && tdProcessSubmitReq(sinkTsdb, atomic_add_fetch_64(&pStat->submitVer, 1), pReq) < 0) {
+        taosMemoryFreeClear(pReq);
+        smaError("vgId:%d, process submit req for rsma table %" PRIi64 " level %" PRIi8 " failed since %s",
+                 SMA_VID(pSma), suid, pItem->level, terrstr());
+        goto _err;
+      }
 
-    if (pReq && tdProcessSubmitReq(sinkTsdb, atomic_add_fetch_64(&pStat->submitVer, 1), pReq) < 0) {
       taosMemoryFreeClear(pReq);
-      smaError("vgId:%d, process submit req for rsma table %" PRIi64 " level %" PRIi8 " failed since %s", SMA_VID(pSma),
-               suid, pItem->level, terrstr());
-      goto _err;
+      taosArrayClear(pResult);
+    } else if (terrno == 0) {
+      smaDebug("vgId:%d, no rsma %" PRIi8 " data fetched yet", SMA_VID(pSma), pItem->level);
+    } else {
+      smaDebug("vgId:%d, no rsma %" PRIi8 " data fetched since %s", SMA_VID(pSma), pItem->level, tstrerror(terrno));
     }
-
-    taosMemoryFreeClear(pReq);
-  } else if (terrno == 0) {
-    smaDebug("vgId:%d, no rsma %" PRIi8 " data fetched yet", SMA_VID(pSma), pItem->level);
-  } else {
-    smaDebug("vgId:%d, no rsma %" PRIi8 " data fetched since %s", SMA_VID(pSma), pItem->level, tstrerror(terrno));
   }
 
   tdDestroySDataBlockArray(pResult);
@@ -1364,4 +1367,4 @@ static void tdRSmaFetchTrigger(void *param, void *tmrId) {
 
 _end:
   tdReleaseSmaRef(smaMgmt.rsetId, pItem->refId, __func__, __LINE__);
-}
+}
\ No newline at end of file

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

@@ -262,7 +262,7 @@ static int32_t tqInitDataRsp(SMqDataRsp* pRsp, const SMqPollReq* pReq, int8_t su
 
 static int32_t tqInitMetaRsp(SMqMetaRsp* pRsp, const SMqPollReq* pReq) { return 0; }
 
-int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
+int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg) {
   SMqPollReq*  pReq = pMsg->pCont;
   int64_t      consumerId = pReq->consumerId;
   int64_t      timeout = pReq->timeout;
@@ -271,9 +271,6 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
   STqOffsetVal reqOffset = pReq->reqOffset;
   STqOffsetVal fetchOffsetNew;
 
-  // todo
-  workerId = 0;
-
   // 1.find handle
   STqHandle* pHandle = taosHashGet(pTq->handles, pReq->subKey, strlen(pReq->subKey));
   /*ASSERT(pHandle);*/
@@ -405,7 +402,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
       if (pHead->msgType == TDMT_VND_SUBMIT) {
         SSubmitReq* pCont = (SSubmitReq*)&pHead->body;
 
-        if (tqLogScanExec(pTq, &pHandle->execHandle, pCont, &dataRsp, workerId) < 0) {
+        if (tqLogScanExec(pTq, &pHandle->execHandle, pCont, &dataRsp) < 0) {
           /*ASSERT(0);*/
         }
         // TODO batch optimization:
@@ -518,27 +515,23 @@ int32_t tqProcessVgChangeReq(STQ* pTq, char* msg, int32_t msgLen) {
       pHandle->execHandle.execCol.qmsg = req.qmsg;
       pHandle->snapshotVer = ver;
       req.qmsg = NULL;
-      for (int32_t i = 0; i < 5; i++) {
-        SReadHandle handle = {
-            .meta = pTq->pVnode->pMeta,
-            .vnode = pTq->pVnode,
-            .initTableReader = true,
-            .initTqReader = true,
-            .version = ver,
-        };
-        pHandle->execHandle.execCol.task[i] =
-            qCreateQueueExecTaskInfo(pHandle->execHandle.execCol.qmsg, &handle, &pHandle->execHandle.numOfCols);
-        ASSERT(pHandle->execHandle.execCol.task[i]);
-        void* scanner = NULL;
-        qExtractStreamScanner(pHandle->execHandle.execCol.task[i], &scanner);
-        ASSERT(scanner);
-        pHandle->execHandle.pExecReader[i] = qExtractReaderFromStreamScanner(scanner);
-        ASSERT(pHandle->execHandle.pExecReader[i]);
-      }
+      SReadHandle handle = {
+          .meta = pTq->pVnode->pMeta,
+          .vnode = pTq->pVnode,
+          .initTableReader = true,
+          .initTqReader = true,
+          .version = ver,
+      };
+      pHandle->execHandle.execCol.task =
+          qCreateQueueExecTaskInfo(pHandle->execHandle.execCol.qmsg, &handle, &pHandle->execHandle.numOfCols, &pHandle->execHandle.pSchemaWrapper);
+      ASSERT(pHandle->execHandle.execCol.task);
+      void* scanner = NULL;
+      qExtractStreamScanner(pHandle->execHandle.execCol.task, &scanner);
+      ASSERT(scanner);
+      pHandle->execHandle.pExecReader = qExtractReaderFromStreamScanner(scanner);
+      ASSERT(pHandle->execHandle.pExecReader);
     } else if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__DB) {
-      for (int32_t i = 0; i < 5; i++) {
-        pHandle->execHandle.pExecReader[i] = tqOpenReader(pTq->pVnode);
-      }
+      pHandle->execHandle.pExecReader = tqOpenReader(pTq->pVnode);
       pHandle->execHandle.execDb.pFilterOutTbUid =
           taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
     } else if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__TABLE) {
@@ -550,10 +543,8 @@ int32_t tqProcessVgChangeReq(STQ* pTq, char* msg, int32_t msgLen) {
         int64_t tbUid = *(int64_t*)taosArrayGet(tbUidList, i);
         tqDebug("vgId:%d, idx %d, uid:%" PRId64, TD_VID(pTq->pVnode), i, tbUid);
       }
-      for (int32_t i = 0; i < 5; i++) {
-        pHandle->execHandle.pExecReader[i] = tqOpenReader(pTq->pVnode);
-        tqReaderSetTbUidList(pHandle->execHandle.pExecReader[i], tbUidList);
-      }
+      pHandle->execHandle.pExecReader = tqOpenReader(pTq->pVnode);
+      tqReaderSetTbUidList(pHandle->execHandle.pExecReader, tbUidList);
       taosArrayDestroy(tbUidList);
     }
     taosHashPut(pTq->handles, req.subKey, strlen(req.subKey), pHandle, sizeof(STqHandle));
@@ -634,7 +625,7 @@ int32_t tqProcessTaskDeployReq(STQ* pTq, char* msg, int32_t msgLen) {
     ASSERT(pTask->tbSink.pSchemaWrapper->pSchema);
 
     pTask->tbSink.pTSchema =
-        tdGetSTSChemaFromSSChema(&pTask->tbSink.pSchemaWrapper->pSchema, pTask->tbSink.pSchemaWrapper->nCols);
+        tdGetSTSChemaFromSSChema(pTask->tbSink.pSchemaWrapper->pSchema, pTask->tbSink.pSchemaWrapper->nCols, 1);
     ASSERT(pTask->tbSink.pTSchema);
   }
 

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

@@ -37,8 +37,8 @@ static int32_t tqAddBlockDataToRsp(const SSDataBlock* pBlock, SMqDataRsp* pRsp,
   return 0;
 }
 
-static int32_t tqAddBlockSchemaToRsp(const STqExecHandle* pExec, int32_t workerId, SMqDataRsp* pRsp) {
-  SSchemaWrapper* pSW = tCloneSSchemaWrapper(pExec->pExecReader[workerId]->pSchemaWrapper);
+static int32_t tqAddBlockSchemaToRsp(const STqExecHandle* pExec, SMqDataRsp* pRsp) {
+  SSchemaWrapper* pSW = tCloneSSchemaWrapper(pExec->pExecReader->pSchemaWrapper);
   if (pSW == NULL) {
     return -1;
   }
@@ -61,7 +61,7 @@ static int32_t tqAddTbNameToRsp(const STQ* pTq, int64_t uid, SMqDataRsp* pRsp) {
 
 int64_t tqScan(STQ* pTq, const STqHandle* pHandle, SMqDataRsp* pRsp, STqOffsetVal* pOffset) {
   const STqExecHandle* pExec = &pHandle->execHandle;
-  qTaskInfo_t          task = pExec->execCol.task[0];
+  qTaskInfo_t          task = pExec->execCol.task;
 
   if (qStreamPrepareScan(task, pOffset) < 0) {
     if (pOffset->type == TMQ_OFFSET__LOG) {
@@ -89,7 +89,7 @@ int64_t tqScan(STQ* pTq, const STqHandle* pHandle, SMqDataRsp* pRsp, STqOffsetVa
     if (pDataBlock != NULL) {
       if (pRsp->withTbName) {
         if (pOffset->type == TMQ_OFFSET__LOG) {
-          int64_t uid = pExec->pExecReader[0]->msgIter.uid;
+          int64_t uid = pExec->pExecReader->msgIter.uid;
           if (tqAddTbNameToRsp(pTq, uid, pRsp) < 0) {
             continue;
           }
@@ -184,12 +184,12 @@ int32_t tqScanSnapshot(STQ* pTq, const STqExecHandle* pExec, SMqDataRsp* pRsp, S
 }
 #endif
 
-int32_t tqLogScanExec(STQ* pTq, STqExecHandle* pExec, SSubmitReq* pReq, SMqDataRsp* pRsp, int32_t workerId) {
+int32_t tqLogScanExec(STQ* pTq, STqExecHandle* pExec, SSubmitReq* pReq, SMqDataRsp* pRsp) {
   ASSERT(pExec->subType != TOPIC_SUB_TYPE__COLUMN);
 
   if (pExec->subType == TOPIC_SUB_TYPE__TABLE) {
     pRsp->withSchema = 1;
-    STqReader* pReader = pExec->pExecReader[workerId];
+    STqReader* pReader = pExec->pExecReader;
     tqReaderSetDataMsg(pReader, pReq, 0);
     while (tqNextDataBlock(pReader)) {
       SSDataBlock block = {0};
@@ -197,18 +197,18 @@ int32_t tqLogScanExec(STQ* pTq, STqExecHandle* pExec, SSubmitReq* pReq, SMqDataR
         if (terrno == TSDB_CODE_TQ_TABLE_SCHEMA_NOT_FOUND) continue;
       }
       if (pRsp->withTbName) {
-        int64_t uid = pExec->pExecReader[workerId]->msgIter.uid;
+        int64_t uid = pExec->pExecReader->msgIter.uid;
         if (tqAddTbNameToRsp(pTq, uid, pRsp) < 0) {
           continue;
         }
       }
       tqAddBlockDataToRsp(&block, pRsp, taosArrayGetSize(block.pDataBlock));
-      tqAddBlockSchemaToRsp(pExec, workerId, pRsp);
+      tqAddBlockSchemaToRsp(pExec, pRsp);
       pRsp->blockNum++;
     }
   } else if (pExec->subType == TOPIC_SUB_TYPE__DB) {
     pRsp->withSchema = 1;
-    STqReader* pReader = pExec->pExecReader[workerId];
+    STqReader* pReader = pExec->pExecReader;
     tqReaderSetDataMsg(pReader, pReq, 0);
     while (tqNextDataBlockFilterOut(pReader, pExec->execDb.pFilterOutTbUid)) {
       SSDataBlock block = {0};
@@ -216,13 +216,13 @@ int32_t tqLogScanExec(STQ* pTq, STqExecHandle* pExec, SSubmitReq* pReq, SMqDataR
         if (terrno == TSDB_CODE_TQ_TABLE_SCHEMA_NOT_FOUND) continue;
       }
       if (pRsp->withTbName) {
-        int64_t uid = pExec->pExecReader[workerId]->msgIter.uid;
+        int64_t uid = pExec->pExecReader->msgIter.uid;
         if (tqAddTbNameToRsp(pTq, uid, pRsp) < 0) {
           continue;
         }
       }
       tqAddBlockDataToRsp(&block, pRsp, taosArrayGetSize(block.pDataBlock));
-      tqAddBlockSchemaToRsp(pExec, workerId, pRsp);
+      tqAddBlockSchemaToRsp(pExec, pRsp);
       pRsp->blockNum++;
     }
   }

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

@@ -80,27 +80,23 @@ int32_t tqMetaOpen(STQ* pTq) {
     tDecoderInit(&decoder, (uint8_t*)pVal, vLen);
     tDecodeSTqHandle(&decoder, &handle);
     handle.pWalReader = walOpenReader(pTq->pVnode->pWal, NULL);
-    /*for (int32_t i = 0; i < 5; i++) {*/
-    /*handle.execHandle.pExecReader[i] = tqOpenReader(pTq->pVnode);*/
-    /*}*/
     if (handle.execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
-      for (int32_t i = 0; i < 5; i++) {
-        SReadHandle reader = {
-            .meta = pTq->pVnode->pMeta,
-            .vnode = pTq->pVnode,
-            .initTableReader = true,
-            .initTqReader = true,
-            .version = handle.snapshotVer,
-        };
-
-        handle.execHandle.execCol.task[i] = qCreateQueueExecTaskInfo(handle.execHandle.execCol.qmsg, &reader, &handle.execHandle.numOfCols);
-        ASSERT(handle.execHandle.execCol.task[i]);
-        void* scanner = NULL;
-        qExtractStreamScanner(handle.execHandle.execCol.task[i], &scanner);
-        ASSERT(scanner);
-        handle.execHandle.pExecReader[i] = qExtractReaderFromStreamScanner(scanner);
-        ASSERT(handle.execHandle.pExecReader[i]);
-      }
+      SReadHandle reader = {
+          .meta = pTq->pVnode->pMeta,
+          .vnode = pTq->pVnode,
+          .initTableReader = true,
+          .initTqReader = true,
+          .version = handle.snapshotVer,
+      };
+
+      handle.execHandle.execCol.task =
+          qCreateQueueExecTaskInfo(handle.execHandle.execCol.qmsg, &reader, &handle.execHandle.numOfCols, &handle.execHandle.pSchemaWrapper);
+      ASSERT(handle.execHandle.execCol.task);
+      void* scanner = NULL;
+      qExtractStreamScanner(handle.execHandle.execCol.task, &scanner);
+      ASSERT(scanner);
+      handle.execHandle.pExecReader = qExtractReaderFromStreamScanner(scanner);
+      ASSERT(handle.execHandle.pExecReader);
     } else {
       handle.execHandle.execDb.pFilterOutTbUid =
           taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);

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

@@ -249,6 +249,8 @@ int tqPushMsg(STQ* pTq, void* msg, int32_t msgLen, tmsg_t msgType, int64_t ver)
       return -1;
     }
     memcpy(data, msg, msgLen);
+    SSubmitReq* pReq = (SSubmitReq*)data;
+    pReq->version = ver;
 
     tqProcessStreamTrigger(pTq, data);
   }

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

@@ -314,6 +314,7 @@ int32_t tqRetrieveDataBlock(SSDataBlock* pBlock, STqReader* pReader) {
 
   pBlock->info.uid = pReader->msgIter.uid;
   pBlock->info.rows = pReader->msgIter.numOfRows;
+  pBlock->info.version = pReader->pMsg->version;
 
   while ((row = tGetSubmitBlkNext(&pReader->blkIter)) != NULL) {
     tdSTSRowIterReset(&iter, row);
@@ -393,10 +394,8 @@ int32_t tqUpdateTbUidList(STQ* pTq, const SArray* tbUidList, bool isAdd) {
     if (pIter == NULL) break;
     STqHandle* pExec = (STqHandle*)pIter;
     if (pExec->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
-      for (int32_t i = 0; i < 5; i++) {
-        int32_t code = qUpdateQualifiedTableId(pExec->execHandle.execCol.task[i], tbUidList, isAdd);
-        ASSERT(code == 0);
-      }
+      int32_t code = qUpdateQualifiedTableId(pExec->execHandle.execCol.task, tbUidList, isAdd);
+      ASSERT(code == 0);
     } else if (pExec->execHandle.subType == TOPIC_SUB_TYPE__DB) {
       if (!isAdd) {
         int32_t sz = taosArrayGetSize(tbUidList);

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

@@ -127,6 +127,8 @@ SSubmitReq* tdBlockToSubmit(const SArray* pBlocks, const STSchema* pTSchema, boo
 
     int32_t rows = pDataBlock->info.rows;
 
+    tqDebug("tq sink, convert block %d, rows: %d", i, rows);
+
     int32_t dataLen = 0;
 
     void* blkSchema = POINTER_SHIFT(blkHead, sizeof(SSubmitBlk));
@@ -178,11 +180,14 @@ void tqTableSink(SStreamTask* pTask, void* vnode, int64_t ver, void* data) {
   const SArray* pRes = (const SArray*)data;
   SVnode*       pVnode = (SVnode*)vnode;
 
-  tqDebug("task write into table, vgId %d, block num: %d", pVnode->config.vgId, (int32_t)pRes->size);
+  tqDebug("vgId:%d, task %d write into table, block num: %d", TD_VID(pVnode), pTask->taskId, (int32_t)pRes->size);
 
   ASSERT(pTask->tbSink.pTSchema);
   SSubmitReq* pReq = tdBlockToSubmit(pRes, pTask->tbSink.pTSchema, true, pTask->tbSink.stbUid,
                                      pTask->tbSink.stbFullName, pVnode->config.vgId);
+
+  tqDebug("vgId:%d, task %d convert blocks over, put into write-queue", TD_VID(pVnode), pTask->taskId);
+
   /*tPrintFixedSchemaSubmitReq(pReq, pTask->tbSink.pTSchema);*/
   // build write msg
   SRpcMsg msg = {

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

@@ -1943,17 +1943,20 @@ int32_t initDelSkylineIterator(STableBlockScanInfo* pBlockScanInfo, STsdbReader*
   if (pDelFile) {
     SDelFReader* pDelFReader = NULL;
     code = tsdbDelFReaderOpen(&pDelFReader, pDelFile, pTsdb, NULL);
-    if (code) {
+    if (code != TSDB_CODE_SUCCESS) {
       goto _err;
     }
 
     SArray* aDelIdx = taosArrayInit(4, sizeof(SDelIdx));
     if (aDelIdx == NULL) {
+      tsdbDelFReaderClose(&pDelFReader);
       goto _err;
     }
 
     code = tsdbReadDelIdx(pDelFReader, aDelIdx, NULL);
-    if (code) {
+    if (code != TSDB_CODE_SUCCESS) {
+      taosArrayDestroy(aDelIdx);
+      tsdbDelFReaderClose(&pDelFReader);
       goto _err;
     }
 
@@ -1962,9 +1965,13 @@ int32_t initDelSkylineIterator(STableBlockScanInfo* pBlockScanInfo, STsdbReader*
 
     if (pIdx != NULL) {
       code = tsdbReadDelData(pDelFReader, pIdx, pDelData, NULL);
-      if (code != TSDB_CODE_SUCCESS) {
-        goto _err;
-      }
+    }
+
+    taosArrayDestroy(aDelIdx);
+    tsdbDelFReaderClose(&pDelFReader);
+
+    if (code != TSDB_CODE_SUCCESS) {
+      goto _err;
     }
   }
 
@@ -2532,8 +2539,7 @@ static int32_t checkForNeighborFileBlock(STsdbReader* pReader, STableBlockScanIn
 
     pDumpInfo->rowIndex =
         doMergeRowsInFileBlockImpl(pBlockData, pDumpInfo->rowIndex, key, pMerger, &pReader->verRange, step);
-
-    if (pDumpInfo->rowIndex >= pBlock->nRow) {
+    if (pDumpInfo->rowIndex >= pDumpInfo->totalRows) {
       *state = CHECK_FILEBLOCK_CONT;
     }
   }

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

@@ -316,7 +316,7 @@ int32_t vnodeProcessFetchMsg(SVnode *pVnode, SRpcMsg *pMsg, SQueueInfo *pInfo) {
     case TDMT_VND_TABLE_CFG:
       return vnodeGetTableCfg(pVnode, pMsg);
     case TDMT_VND_CONSUME:
-      return tqProcessPollReq(pVnode->pTq, pMsg, pInfo->workerId);
+      return tqProcessPollReq(pVnode->pTq, pMsg);
     case TDMT_STREAM_TASK_RUN:
       return tqProcessTaskRunReq(pVnode->pTq, pMsg);
     case TDMT_STREAM_TASK_DISPATCH:

source/libs/executor/inc/executorimpl.h

@@ -164,6 +164,7 @@ typedef struct {
   char*           dbname;
   int32_t         tversion;
   SSchemaWrapper* sw;
+  SSchemaWrapper* qsw;
 } SSchemaInfo;
 
 typedef struct SExecTaskInfo {
@@ -868,7 +869,7 @@ SOperatorInfo* createDataBlockInfoScanOperator(void* dataReader, SReadHandle* re
                                                SExecTaskInfo* pTaskInfo);
 
 SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode* pTableScanNode, SNode* pTagCond,
-                                            SExecTaskInfo* pTaskInfo, STimeWindowAggSupp* pTwSup);
+                                            SExecTaskInfo* pTaskInfo);
 
 SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* pPhyFillNode, SExecTaskInfo* pTaskInfo);
 

source/libs/executor/src/executor.c

@@ -120,7 +120,7 @@ int32_t qSetMultiStreamInput(qTaskInfo_t tinfo, const void* pBlocks, size_t numO
   return code;
 }
 
-qTaskInfo_t qCreateQueueExecTaskInfo(void* msg, SReadHandle* readers, int32_t* numOfCols) {
+qTaskInfo_t qCreateQueueExecTaskInfo(void* msg, SReadHandle* readers, int32_t* numOfCols, SSchemaWrapper** pSchemaWrapper) {
   if (msg == NULL) {
     // TODO create raw scan
     return NULL;
@@ -154,6 +154,7 @@ qTaskInfo_t qCreateQueueExecTaskInfo(void* msg, SReadHandle* readers, int32_t* n
     }
   }
 
+  *pSchemaWrapper = tCloneSSchemaWrapper(((SExecTaskInfo*)pTaskInfo)->schemaInfo.qsw);
   return pTaskInfo;
 }
 

source/libs/executor/src/executorMain.c

@@ -199,6 +199,10 @@ int32_t qAsyncKillTask(qTaskInfo_t qinfo) {
 
 void qDestroyTask(qTaskInfo_t qTaskHandle) {
   SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)qTaskHandle;
+  if (pTaskInfo == NULL) {
+    return;
+  }
+
   qDebug("%s execTask completed, numOfRows:%" PRId64, GET_TASKID(pTaskInfo), pTaskInfo->pRoot->resultInfo.totalRows);
 
   queryCostStatis(pTaskInfo);  // print the query cost summary

source/libs/executor/src/executorimpl.c

@@ -1647,11 +1647,6 @@ static int32_t compressQueryColData(SColumnInfoData* pColRes, int32_t numOfRows,
                                                       colSize + COMP_OVERFLOW_BYTES, compressed, NULL, 0);
 }
 
-int32_t doFillTimeIntervalGapsInResults(struct SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t capacity) {
-  int32_t numOfRows = (int32_t)taosFillResultDataBlock(pFillInfo, pBlock, capacity - pBlock->info.rows);
-  return pBlock->info.rows;
-}
-
 void queryCostStatis(SExecTaskInfo* pTaskInfo) {
   STaskCostInfo* pSummary = &pTaskInfo->cost;
 
@@ -4147,35 +4142,62 @@ static STsdbReader* doCreateDataReader(STableScanPhysiNode* pTableScanNode, SRea
 
 static SArray* extractColumnInfo(SNodeList* pNodeList);
 
-int32_t extractTableSchemaInfo(SReadHandle* pHandle, uint64_t uid, SExecTaskInfo* pTaskInfo) {
+SSchemaWrapper* extractQueriedColumnSchema(SScanPhysiNode* pScanNode);
+
+int32_t extractTableSchemaInfo(SReadHandle* pHandle, SScanPhysiNode* pScanNode, SExecTaskInfo* pTaskInfo) {
   SMetaReader mr = {0};
   metaReaderInit(&mr, pHandle->meta, 0);
-  int32_t code = metaGetTableEntryByUid(&mr, uid);
+  int32_t code = metaGetTableEntryByUid(&mr, pScanNode->uid);
   if (code != TSDB_CODE_SUCCESS) {
+    qError("failed to get the table meta, uid:0x%"PRIx64", suid:0x%"PRIx64 ", %s", pScanNode->uid, pScanNode->suid,
+        GET_TASKID(pTaskInfo));
+
     metaReaderClear(&mr);
     return terrno;
   }
 
-  pTaskInfo->schemaInfo.tablename = strdup(mr.me.name);
+  SSchemaInfo* pSchemaInfo = &pTaskInfo->schemaInfo;
+  pSchemaInfo->tablename = strdup(mr.me.name);
 
   if (mr.me.type == TSDB_SUPER_TABLE) {
-    pTaskInfo->schemaInfo.sw = tCloneSSchemaWrapper(&mr.me.stbEntry.schemaRow);
-    pTaskInfo->schemaInfo.tversion = mr.me.stbEntry.schemaTag.version;
+    pSchemaInfo->sw = tCloneSSchemaWrapper(&mr.me.stbEntry.schemaRow);
+    pSchemaInfo->tversion = mr.me.stbEntry.schemaTag.version;
   } else if (mr.me.type == TSDB_CHILD_TABLE) {
     tDecoderClear(&mr.coder);
 
     tb_uid_t suid = mr.me.ctbEntry.suid;
     metaGetTableEntryByUid(&mr, suid);
-    pTaskInfo->schemaInfo.sw = tCloneSSchemaWrapper(&mr.me.stbEntry.schemaRow);
-    pTaskInfo->schemaInfo.tversion = mr.me.stbEntry.schemaTag.version;
+    pSchemaInfo->sw = tCloneSSchemaWrapper(&mr.me.stbEntry.schemaRow);
+    pSchemaInfo->tversion = mr.me.stbEntry.schemaTag.version;
   } else {
-    pTaskInfo->schemaInfo.sw = tCloneSSchemaWrapper(&mr.me.ntbEntry.schemaRow);
+    pSchemaInfo->sw = tCloneSSchemaWrapper(&mr.me.ntbEntry.schemaRow);
   }
 
   metaReaderClear(&mr);
+
+  pSchemaInfo->qsw = extractQueriedColumnSchema(pScanNode);
   return TSDB_CODE_SUCCESS;
 }
 
+SSchemaWrapper* extractQueriedColumnSchema(SScanPhysiNode* pScanNode) {
+  int32_t numOfCols = LIST_LENGTH(pScanNode->pScanCols);
+  SSchemaWrapper* pqSw = taosMemoryCalloc(1, sizeof(SSchemaWrapper));
+  pqSw->pSchema = taosMemoryCalloc(numOfCols, sizeof(SSchema));
+
+  for(int32_t i = 0; i < numOfCols; ++i) {
+    STargetNode* pNode = (STargetNode*)nodesListGetNode(pScanNode->pScanCols, i);
+    SColumnNode* pColNode = (SColumnNode*)pNode->pExpr;
+
+    SSchema* pSchema = &pqSw->pSchema[pqSw->nCols++];
+    pSchema->colId = pColNode->colId;
+    pSchema->type = pColNode->node.resType.type;
+    pSchema->type = pColNode->node.resType.bytes;
+    strncpy(pSchema->name, pColNode->colName, tListLen(pSchema->name));
+  }
+
+  return pqSw;
+}
+
 static void cleanupTableSchemaInfo(SSchemaInfo* pSchemaInfo) {
   taosMemoryFreeClear(pSchemaInfo->dbname);
   if (pSchemaInfo->sw == NULL) {
@@ -4183,8 +4205,8 @@ static void cleanupTableSchemaInfo(SSchemaInfo* pSchemaInfo) {
   }
 
   taosMemoryFree(pSchemaInfo->tablename);
-  taosMemoryFree(pSchemaInfo->sw->pSchema);
-  taosMemoryFree(pSchemaInfo->sw);
+  tDeleteSSchemaWrapper(pSchemaInfo->sw);
+  tDeleteSSchemaWrapper(pSchemaInfo->qsw);
 }
 
 static int32_t sortTableGroup(STableListInfo* pTableListInfo, int32_t groupNum) {
@@ -4385,7 +4407,7 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
         return NULL;
       }
 
-      code = extractTableSchemaInfo(pHandle, pTableScanNode->scan.uid, pTaskInfo);
+      code = extractTableSchemaInfo(pHandle, &pTableScanNode->scan, pTaskInfo);
       if (code) {
         pTaskInfo->code = terrno;
         return NULL;
@@ -4405,7 +4427,7 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
         return NULL;
       }
 
-      code = extractTableSchemaInfo(pHandle, pTableScanNode->scan.uid, pTaskInfo);
+      code = extractTableSchemaInfo(pHandle, &pTableScanNode->scan, pTaskInfo);
       if (code) {
         pTaskInfo->code = terrno;
         return NULL;
@@ -4422,11 +4444,6 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
       return createExchangeOperatorInfo(pHandle->pMsgCb->clientRpc, (SExchangePhysiNode*)pPhyNode, pTaskInfo);
     } else if (QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN == type) {
       STableScanPhysiNode* pTableScanNode = (STableScanPhysiNode*)pPhyNode;
-      STimeWindowAggSupp   twSup = {
-            .waterMark = pTableScanNode->watermark,
-            .calTrigger = pTableScanNode->triggerType,
-            .maxTs = INT64_MIN,
-      };
       if (pHandle->vnode) {
         int32_t code = createScanTableListInfo(&pTableScanNode->scan, pTableScanNode->pGroupTags,
                                                pTableScanNode->groupSort, pHandle, pTableListInfo, pTagCond, pTagIndexCond, GET_TASKID(pTaskInfo));
@@ -4436,7 +4453,8 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
         }
       }
 
-      SOperatorInfo* pOperator = createStreamScanOperatorInfo(pHandle, pTableScanNode, pTagCond, pTaskInfo, &twSup);
+      pTaskInfo->schemaInfo.qsw = extractQueriedColumnSchema(&pTableScanNode->scan);
+      SOperatorInfo* pOperator = createStreamScanOperatorInfo(pHandle, pTableScanNode, pTagCond, pTaskInfo);
       return pOperator;
 
     } else if (QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN == type) {
@@ -4487,7 +4505,7 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
         return NULL;
       }
 
-      code = extractTableSchemaInfo(pHandle, pScanNode->scan.uid, pTaskInfo);
+      code = extractTableSchemaInfo(pHandle, &pScanNode->scan, pTaskInfo);
       if (code != TSDB_CODE_SUCCESS) {
         pTaskInfo->code = code;
         return NULL;

source/libs/executor/src/scanoperator.c

@@ -1525,7 +1525,7 @@ static void destroyStreamScanOperatorInfo(void* param, int32_t numOfOutput) {
 }
 
 SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode* pTableScanNode, SNode* pTagCond,
-                                            SExecTaskInfo* pTaskInfo, STimeWindowAggSupp* pTwSup) {
+                                            SExecTaskInfo* pTaskInfo) {
   SStreamScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamScanInfo));
   SOperatorInfo*   pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
 
@@ -1539,6 +1539,12 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys
 
   pInfo->pTagCond = pTagCond;
 
+  pInfo->twAggSup = (STimeWindowAggSupp){
+      .waterMark = pTableScanNode->watermark,
+      .calTrigger = pTableScanNode->triggerType,
+      .maxTs = INT64_MIN,
+  };
+
   int32_t numOfCols = 0;
   pInfo->pColMatchInfo = extractColMatchInfo(pScanPhyNode->pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID);
 
@@ -1591,7 +1597,7 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys
     }
 
     if (pTSInfo->interval.interval > 0) {
-      pInfo->pUpdateInfo = updateInfoInitP(&pTSInfo->interval, pTwSup->waterMark);
+      pInfo->pUpdateInfo = updateInfoInitP(&pTSInfo->interval, pInfo->twAggSup.waterMark);
     } else {
       pInfo->pUpdateInfo = NULL;
     }
@@ -1631,7 +1637,6 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys
   pInfo->deleteDataIndex = 0;
   pInfo->pDeleteDataRes = createPullDataBlock();
   pInfo->updateWin = (STimeWindow){.skey = INT64_MAX, .ekey = INT64_MAX};
-  pInfo->twAggSup = *pTwSup;
 
   pOperator->name = "StreamScanOperator";
   pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN;

source/libs/executor/src/tfill.c

@@ -66,12 +66,32 @@ static void setNullRow(SSDataBlock* pBlock, int64_t ts, int32_t rowIndex) {
 
 static void doSetVal(SColumnInfoData* pDstColInfoData, int32_t rowIndex, const SGroupKeys* pKey);
 
+static void doSetUserSpecifiedValue(SColumnInfoData* pDst, SVariant* pVar, int32_t rowIndex, int64_t currentKey)  {
+  if (pDst->info.type == TSDB_DATA_TYPE_FLOAT) {
+    float v = 0;
+    GET_TYPED_DATA(v, float, pVar->nType, &pVar->i);
+    colDataAppend(pDst, rowIndex, (char*)&v, false);
+  } else if (pDst->info.type == TSDB_DATA_TYPE_DOUBLE) {
+    double v = 0;
+    GET_TYPED_DATA(v, double, pVar->nType, &pVar->i);
+    colDataAppend(pDst, rowIndex, (char*)&v, false);
+  } else if (IS_SIGNED_NUMERIC_TYPE(pDst->info.type)) {
+    int64_t v = 0;
+    GET_TYPED_DATA(v, int64_t, pVar->nType, &pVar->i);
+    colDataAppend(pDst, rowIndex, (char*)&v, false);
+  } else if (pDst->info.type == TSDB_DATA_TYPE_TIMESTAMP) {
+    colDataAppend(pDst, rowIndex, (const char*)&currentKey, false);
+  } else {  // varchar/nchar data
+    colDataAppendNULL(pDst, rowIndex);
+  }
+}
+
 static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock* pSrcBlock, int64_t ts,
                          bool outOfBound) {
   SPoint  point1, point2, point;
   int32_t step = GET_FORWARD_DIRECTION_FACTOR(pFillInfo->order);
 
-//   set the primary timestamp column value
+  // set the primary timestamp column value
   int32_t index = pBlock->info.rows;
 
   // set the other values
@@ -160,30 +180,13 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock*
   } else {  // fill with user specified value for each column
     for (int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
       SFillColInfo* pCol = &pFillInfo->pFillCol[i];
-      if (TSDB_COL_IS_TAG(pCol->flag) /* || IS_VAR_DATA_TYPE(pCol->schema.type)*/) {
+      if (TSDB_COL_IS_TAG(pCol->flag)) {
         continue;
       }
 
       SVariant* pVar = &pFillInfo->pFillCol[i].fillVal;
-
       SColumnInfoData* pDst = taosArrayGet(pBlock->pDataBlock, i);
-      if (pDst->info.type == TSDB_DATA_TYPE_FLOAT) {
-        float v = 0;
-        GET_TYPED_DATA(v, float, pVar->nType, &pVar->i);
-        colDataAppend(pDst, index, (char*)&v, false);
-      } else if (pDst->info.type == TSDB_DATA_TYPE_DOUBLE) {
-        double v = 0;
-        GET_TYPED_DATA(v, double, pVar->nType, &pVar->i);
-        colDataAppend(pDst, index, (char*)&v, false);
-      } else if (IS_SIGNED_NUMERIC_TYPE(pDst->info.type)) {
-        int64_t v = 0;
-        GET_TYPED_DATA(v, int64_t, pVar->nType, &pVar->i);
-        colDataAppend(pDst, index, (char*)&v, false);
-      } else if (pDst->info.type == TSDB_DATA_TYPE_TIMESTAMP) {
-        colDataAppend(pDst, index, (const char*)&pFillInfo->currentKey, false);
-      } else {  // varchar/nchar data
-        colDataAppendNULL(pDst, index);
-      }
+      doSetUserSpecifiedValue(pDst, pVar, index, pFillInfo->currentKey);
     }
   }
 
@@ -273,7 +276,7 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t
         return outputRows;
       }
     } else {
-      assert(pFillInfo->currentKey == ts);
+      ASSERT(pFillInfo->currentKey == ts);
       int32_t index = pBlock->info.rows;
 
       if (pFillInfo->type == TSDB_FILL_NEXT && (pFillInfo->index + 1) < pFillInfo->numOfRows) {
@@ -295,27 +298,32 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t
         SColumnInfoData* pSrc = taosArrayGet(pFillInfo->pSrcBlock->pDataBlock, srcSlotId);
 
         char* src = colDataGetData(pSrc, pFillInfo->index);
-        if (i == 0 || (/*pCol->functionId != FUNCTION_COUNT &&*/ !colDataIsNull_s(pSrc, pFillInfo->index)) /*||
-            (pCol->functionId == FUNCTION_COUNT && GET_INT64_VAL(src) != 0)*/) {
+        if (/*i == 0 || (*/!colDataIsNull_s(pSrc, pFillInfo->index)) {
           bool isNull = colDataIsNull_s(pSrc, pFillInfo->index);
           colDataAppend(pDst, index, src, isNull);
           saveColData(pFillInfo->prev, i, src, isNull);
-        } else {  // i > 0 and data is null , do interpolation
-          if (pFillInfo->type == TSDB_FILL_PREV) {
-            SGroupKeys* pKey = taosArrayGet(pFillInfo->prev, i);
-            doSetVal(pDst, index, pKey);
-          } else if (pFillInfo->type == TSDB_FILL_LINEAR) {
-            bool isNull = colDataIsNull_s(pSrc, pFillInfo->index);
-            colDataAppend(pDst, index, src, isNull);
-            saveColData(pFillInfo->prev, i, src, isNull);
-          } else if (pFillInfo->type == TSDB_FILL_NULL) {
-            colDataAppendNULL(pDst, index);
-          } else if (pFillInfo->type == TSDB_FILL_NEXT) {
-            SGroupKeys* pKey = taosArrayGet(pFillInfo->next, i);
-            doSetVal(pDst, index, pKey);
-          } else {
-            SVariant* pVar = &pFillInfo->pFillCol[i].fillVal;
-            colDataAppend(pDst, index, (char*)&pVar->i, false);
+        } else {
+          if (pDst->info.type == TSDB_DATA_TYPE_TIMESTAMP) {
+            colDataAppend(pDst, index, (const char*)&pFillInfo->currentKey, false);
+          } else {  // i > 0 and data is null , do interpolation
+            if (pFillInfo->type == TSDB_FILL_PREV) {
+              SArray*     p = FILL_IS_ASC_FILL(pFillInfo) ? pFillInfo->prev : pFillInfo->next;
+              SGroupKeys* pKey = taosArrayGet(p, i);
+              doSetVal(pDst, index, pKey);
+            } else if (pFillInfo->type == TSDB_FILL_LINEAR) {
+              bool isNull = colDataIsNull_s(pSrc, pFillInfo->index);
+              colDataAppend(pDst, index, src, isNull);
+              saveColData(pFillInfo->prev, i, src, isNull); // todo:
+            } else if (pFillInfo->type == TSDB_FILL_NULL) {
+              colDataAppendNULL(pDst, index);
+            } else if (pFillInfo->type == TSDB_FILL_NEXT) {
+              SArray*     p = FILL_IS_ASC_FILL(pFillInfo) ? pFillInfo->next : pFillInfo->prev;
+              SGroupKeys* pKey = taosArrayGet(p, i);
+              doSetVal(pDst, index, pKey);
+            } else {
+              SVariant* pVar = &pFillInfo->pFillCol[i].fillVal;
+              doSetUserSpecifiedValue(pDst, pVar, index, pFillInfo->currentKey);
+            }
           }
         }
       }

source/libs/parser/src/parInsert.c

@@ -1200,7 +1200,7 @@ static int parseOneRow(SInsertParseContext* pCxt, STableDataBlocks* pDataBlocks,
 
     *gotRow = true;
 #ifdef TD_DEBUG_PRINT_ROW
-    STSchema* pSTSchema = tdGetSTSChemaFromSSChema(&schema, spd->numOfCols);
+    STSchema* pSTSchema = tdGetSTSChemaFromSSChema(schema, spd->numOfCols, 1);
     tdSRowPrint(row, pSTSchema, __func__);
     taosMemoryFree(pSTSchema);
 #endif
@@ -1972,7 +1972,7 @@ int32_t qBindStmtColsValue(void* pBlock, TAOS_MULTI_BIND* bind, char* msgBuf, in
       }
     }
 #ifdef TD_DEBUG_PRINT_ROW
-    STSchema* pSTSchema = tdGetSTSChemaFromSSChema(&pSchema, spd->numOfCols);
+    STSchema* pSTSchema = tdGetSTSChemaFromSSChema(pSchema, spd->numOfCols, 1);
     tdSRowPrint(row, pSTSchema, __func__);
     taosMemoryFree(pSTSchema);
 #endif
@@ -2057,7 +2057,7 @@ int32_t qBindStmtSingleColValue(void* pBlock, TAOS_MULTI_BIND* bind, char* msgBu
 
 #ifdef TD_DEBUG_PRINT_ROW
     if (rowEnd) {
-      STSchema* pSTSchema = tdGetSTSChemaFromSSChema(&pSchema, spd->numOfCols);
+      STSchema* pSTSchema = tdGetSTSChemaFromSSChema(pSchema, spd->numOfCols, 1);
       tdSRowPrint(row, pSTSchema, __func__);
       taosMemoryFree(pSTSchema);
     }

source/libs/parser/src/parInsertData.c

@@ -19,6 +19,7 @@
 #include "parInt.h"
 #include "parUtil.h"
 #include "querynodes.h"
+#include "tRealloc.h"
 
 #define IS_RAW_PAYLOAD(t) \
   (((int)(t)) == PAYLOAD_TYPE_RAW)  // 0: K-V payload for non-prepare insert, 1: rawPayload for prepare insert
@@ -34,6 +35,32 @@ typedef struct SBlockKeyInfo {
   SBlockKeyTuple* pKeyTuple;
 } SBlockKeyInfo;
 
+typedef struct {
+  int32_t   index;
+  SArray*   rowArray;  // array of merged rows(mem allocated by tRealloc/free by tFree)
+  STSchema* pSchema;
+  int64_t   tbUid;  // suid for child table, uid for normal table
+} SBlockRowMerger;
+
+static FORCE_INLINE void tdResetSBlockRowMerger(SBlockRowMerger* pMerger) {
+  if (pMerger) {
+    pMerger->index = -1;
+  }
+}
+
+static void tdFreeSBlockRowMerger(SBlockRowMerger* pMerger) {
+  if (pMerger) {
+    int32_t size = taosArrayGetSize(pMerger->rowArray);
+    for (int32_t i = 0; i < size; ++i) {
+      tFree(*(void**)taosArrayGet(pMerger->rowArray, i));
+    }
+    taosArrayDestroy(pMerger->rowArray);
+
+    taosMemoryFreeClear(pMerger->pSchema);
+    taosMemoryFree(pMerger);
+  }
+}
+
 static int32_t rowDataCompar(const void* lhs, const void* rhs) {
   TSKEY left = *(TSKEY*)lhs;
   TSKEY right = *(TSKEY*)rhs;
@@ -328,7 +355,7 @@ void sortRemoveDataBlockDupRowsRaw(STableDataBlocks* dataBuf) {
 }
 
 // data block is disordered, sort it in ascending order
-int sortRemoveDataBlockDupRows(STableDataBlocks* dataBuf, SBlockKeyInfo* pBlkKeyInfo) {
+static int sortRemoveDataBlockDupRows(STableDataBlocks* dataBuf, SBlockKeyInfo* pBlkKeyInfo) {
   SSubmitBlk* pBlocks = (SSubmitBlk*)dataBuf->pData;
   int16_t     nRows = pBlocks->numOfRows;
 
@@ -396,6 +423,201 @@ int sortRemoveDataBlockDupRows(STableDataBlocks* dataBuf, SBlockKeyInfo* pBlkKey
   return 0;
 }
 
+static void* tdGetCurRowFromBlockMerger(SBlockRowMerger* pBlkRowMerger) {
+  if (pBlkRowMerger && (pBlkRowMerger->index >= 0)) {
+    ASSERT(pBlkRowMerger->index < taosArrayGetSize(pBlkRowMerger->rowArray));
+    return *(void**)taosArrayGet(pBlkRowMerger->rowArray, pBlkRowMerger->index);
+  }
+  return NULL;
+}
+
+static int32_t tdBlockRowMerge(STableMeta* pTableMeta, SBlockKeyTuple* pEndKeyTp, int32_t nDupRows,
+                               SBlockRowMerger** pBlkRowMerger, int32_t rowSize) {
+  ASSERT(nDupRows > 1);
+  SBlockKeyTuple* pStartKeyTp = pEndKeyTp - (nDupRows - 1);
+  ASSERT(pStartKeyTp->skey == pEndKeyTp->skey);
+
+  // TODO: optimization if end row is all normal
+#if 0
+  STSRow* pEndRow = (STSRow*)pEndKeyTp->payloadAddr;
+  if(isNormal(pEndRow)) { // set the end row if it is normal and return directly
+    pStartKeyTp->payloadAddr = pEndKeyTp->payloadAddr;
+    return TSDB_CODE_SUCCESS;
+  }
+#endif
+
+  if (!(*pBlkRowMerger)) {
+    (*pBlkRowMerger) = taosMemoryCalloc(1, sizeof(**pBlkRowMerger));
+    if (!(*pBlkRowMerger)) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      return TSDB_CODE_FAILED;
+    }
+    (*pBlkRowMerger)->index = -1;
+    if (!(*pBlkRowMerger)->rowArray) {
+      (*pBlkRowMerger)->rowArray = taosArrayInit(1, sizeof(void*));
+      if (!(*pBlkRowMerger)->rowArray) {
+        terrno = TSDB_CODE_OUT_OF_MEMORY;
+        return TSDB_CODE_FAILED;
+      }
+    }
+  }
+
+  if ((*pBlkRowMerger)->pSchema) {
+    if ((*pBlkRowMerger)->pSchema->version != pTableMeta->sversion) {
+      taosMemoryFreeClear((*pBlkRowMerger)->pSchema);
+    } else {
+      if ((*pBlkRowMerger)->tbUid != (pTableMeta->suid > 0 ? pTableMeta->suid : pTableMeta->uid)) {
+        taosMemoryFreeClear((*pBlkRowMerger)->pSchema);
+      }
+    }
+  }
+
+  if (!(*pBlkRowMerger)->pSchema) {
+    (*pBlkRowMerger)->pSchema =
+        tdGetSTSChemaFromSSChema(pTableMeta->schema, pTableMeta->tableInfo.numOfColumns, pTableMeta->sversion);
+
+    if (!(*pBlkRowMerger)->pSchema) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      return TSDB_CODE_FAILED;
+    }
+    (*pBlkRowMerger)->tbUid = pTableMeta->suid > 0 ? pTableMeta->suid : pTableMeta->uid;
+  }
+
+  void* pDestRow = NULL;
+  ++((*pBlkRowMerger)->index);
+  if ((*pBlkRowMerger)->index < taosArrayGetSize((*pBlkRowMerger)->rowArray)) {
+    void* pAlloc = *(void**)taosArrayGet((*pBlkRowMerger)->rowArray, (*pBlkRowMerger)->index);
+    if (tRealloc((uint8_t**)&pAlloc, rowSize) != 0) {
+      return TSDB_CODE_FAILED;
+    }
+    pDestRow = pAlloc;
+  } else {
+    if (tRealloc((uint8_t**)&pDestRow, rowSize) != 0) {
+      return TSDB_CODE_FAILED;
+    }
+    taosArrayPush((*pBlkRowMerger)->rowArray, &pDestRow);
+  }
+
+  // merge rows to pDestRow
+  STSchema* pSchema = (*pBlkRowMerger)->pSchema;
+  SArray*   pArray = taosArrayInit(pSchema->numOfCols, sizeof(SColVal));
+  for (int32_t i = 0; i < pSchema->numOfCols; ++i) {
+    SColVal colVal = {0};
+    for (int32_t j = 0; j < nDupRows; ++j) {
+      tTSRowGetVal((pEndKeyTp - j)->payloadAddr, pSchema, i, &colVal);
+      if (!colVal.isNone) {
+        break;
+      }
+    }
+    taosArrayPush(pArray, &colVal);
+  }
+  if (tdSTSRowNew(pArray, pSchema, (STSRow**)&pDestRow) < 0) {
+    taosArrayDestroy(pArray);
+    return TSDB_CODE_FAILED;
+  }
+
+  taosArrayDestroy(pArray);
+  return TSDB_CODE_SUCCESS;
+}
+
+// data block is disordered, sort it in ascending order, and merge dup rows if exists
+static int sortMergeDataBlockDupRows(STableDataBlocks* dataBuf, SBlockKeyInfo* pBlkKeyInfo,
+                                     SBlockRowMerger** ppBlkRowMerger) {
+  SSubmitBlk* pBlocks = (SSubmitBlk*)dataBuf->pData;
+  STableMeta* pTableMeta = dataBuf->pTableMeta;
+  int16_t     nRows = pBlocks->numOfRows;
+
+  // size is less than the total size, since duplicated rows may be removed.
+
+  // allocate memory
+  size_t nAlloc = nRows * sizeof(SBlockKeyTuple);
+  if (pBlkKeyInfo->pKeyTuple == NULL || pBlkKeyInfo->maxBytesAlloc < nAlloc) {
+    char* tmp = taosMemoryRealloc(pBlkKeyInfo->pKeyTuple, nAlloc);
+    if (tmp == NULL) {
+      return TSDB_CODE_TSC_OUT_OF_MEMORY;
+    }
+    pBlkKeyInfo->pKeyTuple = (SBlockKeyTuple*)tmp;
+    pBlkKeyInfo->maxBytesAlloc = (int32_t)nAlloc;
+  }
+  memset(pBlkKeyInfo->pKeyTuple, 0, nAlloc);
+
+  tdResetSBlockRowMerger(*ppBlkRowMerger);
+
+  int32_t         extendedRowSize = getExtendedRowSize(dataBuf);
+  SBlockKeyTuple* pBlkKeyTuple = pBlkKeyInfo->pKeyTuple;
+  char*           pBlockData = pBlocks->data + pBlocks->schemaLen;
+  int             n = 0;
+  while (n < nRows) {
+    pBlkKeyTuple->skey = TD_ROW_KEY((STSRow*)pBlockData);
+    pBlkKeyTuple->payloadAddr = pBlockData;
+    pBlkKeyTuple->index = n;
+
+    // next loop
+    pBlockData += extendedRowSize;
+    ++pBlkKeyTuple;
+    ++n;
+  }
+
+  if (!dataBuf->ordered) {
+    pBlkKeyTuple = pBlkKeyInfo->pKeyTuple;
+
+    taosSort(pBlkKeyTuple, nRows, sizeof(SBlockKeyTuple), rowDataComparStable);
+
+    pBlkKeyTuple = pBlkKeyInfo->pKeyTuple;
+    bool    hasDup = false;
+    int32_t nextPos = 0;
+    int32_t i = 0;
+    int32_t j = 1;
+
+    while (j < nRows) {
+      TSKEY ti = (pBlkKeyTuple + i)->skey;
+      TSKEY tj = (pBlkKeyTuple + j)->skey;
+
+      if (ti == tj) {
+        ++j;
+        continue;
+      }
+
+      if ((j - i) > 1) {
+        if (tdBlockRowMerge(pTableMeta, (pBlkKeyTuple + j - 1), j - i, ppBlkRowMerger, extendedRowSize) < 0) {
+          return TSDB_CODE_FAILED;
+        }
+        (pBlkKeyTuple + nextPos)->payloadAddr = tdGetCurRowFromBlockMerger(*ppBlkRowMerger);
+        if (!hasDup) {
+          hasDup = true;
+        }
+        i = j;
+      } else {
+        if (hasDup) {
+          memmove(pBlkKeyTuple + nextPos, pBlkKeyTuple + i, sizeof(SBlockKeyTuple));
+        }
+        ++i;
+      }
+
+      ++nextPos;
+      ++j;
+    }
+
+    if ((j - i) > 1) {
+      ASSERT((pBlkKeyTuple + i)->skey == (pBlkKeyTuple + j - 1)->skey);
+      if (tdBlockRowMerge(pTableMeta, (pBlkKeyTuple + j - 1), j - i, ppBlkRowMerger, extendedRowSize) < 0) {
+        return TSDB_CODE_FAILED;
+      }
+      (pBlkKeyTuple + nextPos)->payloadAddr = tdGetCurRowFromBlockMerger(*ppBlkRowMerger);
+    } else if (hasDup) {
+      memmove(pBlkKeyTuple + nextPos, pBlkKeyTuple + i, sizeof(SBlockKeyTuple));
+    }
+
+    dataBuf->ordered = true;
+    pBlocks->numOfRows = nextPos + 1;
+  }
+
+  dataBuf->size = sizeof(SSubmitBlk) + pBlocks->numOfRows * extendedRowSize;
+  dataBuf->prevTS = INT64_MIN;
+
+  return TSDB_CODE_SUCCESS;
+}
+
 // Erase the empty space reserved for binary data
 static int trimDataBlock(void* pDataBlock, STableDataBlocks* pTableDataBlock, SBlockKeyTuple* blkKeyTuple,
                          bool isRawPayload) {
@@ -464,6 +686,8 @@ int32_t mergeTableDataBlocks(SHashObj* pHashObj, uint8_t payloadType, SArray** p
   STableDataBlocks** p = taosHashIterate(pHashObj, NULL);
   STableDataBlocks*  pOneTableBlock = *p;
   SBlockKeyInfo      blkKeyInfo = {0};  // share by pOneTableBlock
+  SBlockRowMerger    *pBlkRowMerger = NULL;
+
   while (pOneTableBlock) {
     SSubmitBlk* pBlocks = (SSubmitBlk*)pOneTableBlock->pData;
     if (pBlocks->numOfRows > 0) {
@@ -473,6 +697,7 @@ int32_t mergeTableDataBlocks(SHashObj* pHashObj, uint8_t payloadType, SArray** p
           getDataBlockFromList(pVnodeDataBlockHashList, &pOneTableBlock->vgId, sizeof(pOneTableBlock->vgId), TSDB_PAYLOAD_SIZE, INSERT_HEAD_SIZE, 0,
                                pOneTableBlock->pTableMeta, &dataBuf, pVnodeDataBlockList, NULL);
       if (ret != TSDB_CODE_SUCCESS) {
+        tdFreeSBlockRowMerger(pBlkRowMerger);
         taosHashCleanup(pVnodeDataBlockHashList);
         destroyBlockArrayList(pVnodeDataBlockList);
         taosMemoryFreeClear(blkKeyInfo.pKeyTuple);
@@ -490,6 +715,7 @@ int32_t mergeTableDataBlocks(SHashObj* pHashObj, uint8_t payloadType, SArray** p
         if (tmp != NULL) {
           dataBuf->pData = tmp;
         } else {  // failed to allocate memory, free already allocated memory and return error code
+          tdFreeSBlockRowMerger(pBlkRowMerger);
           taosHashCleanup(pVnodeDataBlockHashList);
           destroyBlockArrayList(pVnodeDataBlockList);
           taosMemoryFreeClear(dataBuf->pData);
@@ -501,7 +727,8 @@ int32_t mergeTableDataBlocks(SHashObj* pHashObj, uint8_t payloadType, SArray** p
       if (isRawPayload) {
         sortRemoveDataBlockDupRowsRaw(pOneTableBlock);
       } else {
-        if ((code = sortRemoveDataBlockDupRows(pOneTableBlock, &blkKeyInfo)) != 0) {
+        if ((code = sortMergeDataBlockDupRows(pOneTableBlock, &blkKeyInfo, &pBlkRowMerger)) != 0) {
+          tdFreeSBlockRowMerger(pBlkRowMerger);
           taosHashCleanup(pVnodeDataBlockHashList);
           destroyBlockArrayList(pVnodeDataBlockList);
           taosMemoryFreeClear(dataBuf->pData);
@@ -529,6 +756,7 @@ int32_t mergeTableDataBlocks(SHashObj* pHashObj, uint8_t payloadType, SArray** p
   }
 
   // free the table data blocks;
+  tdFreeSBlockRowMerger(pBlkRowMerger);
   taosHashCleanup(pVnodeDataBlockHashList);
   taosMemoryFreeClear(blkKeyInfo.pKeyTuple);
   *pVgDataBlocks = pVnodeDataBlockList;

source/libs/stream/src/streamData.c

@@ -34,6 +34,7 @@ int32_t streamDispatchReqToData(const SStreamDispatchReq* pReq, SStreamDataBlock
     // TODO: refactor
     pDataBlock->info.window.skey = be64toh(pRetrieve->skey);
     pDataBlock->info.window.ekey = be64toh(pRetrieve->ekey);
+    pDataBlock->info.version = be64toh(pRetrieve->version);
 
     pDataBlock->info.type = pRetrieve->streamBlockType;
     pDataBlock->info.childId = pReq->upstreamChildId;
@@ -54,6 +55,7 @@ int32_t streamRetrieveReqToData(const SStreamRetrieveReq* pReq, SStreamDataBlock
   // TODO: refactor
   pDataBlock->info.window.skey = be64toh(pRetrieve->skey);
   pDataBlock->info.window.ekey = be64toh(pRetrieve->ekey);
+  pDataBlock->info.version = be64toh(pRetrieve->version);
 
   pDataBlock->info.type = pRetrieve->streamBlockType;
 

source/libs/stream/src/streamDispatch.c

@@ -108,6 +108,7 @@ int32_t streamBroadcastToChildren(SStreamTask* pTask, const SSDataBlock* pBlock)
   pRetrieve->numOfCols = htonl(numOfCols);
   pRetrieve->skey = htobe64(pBlock->info.window.skey);
   pRetrieve->ekey = htobe64(pBlock->info.window.ekey);
+  pRetrieve->version = htobe64(pBlock->info.version);
 
   int32_t actualLen = 0;
   blockEncode(pBlock, pRetrieve->data, &actualLen, numOfCols, false);
@@ -182,6 +183,7 @@ static int32_t streamAddBlockToDispatchMsg(const SSDataBlock* pBlock, SStreamDis
   pRetrieve->numOfRows = htonl(pBlock->info.rows);
   pRetrieve->skey = htobe64(pBlock->info.window.skey);
   pRetrieve->ekey = htobe64(pBlock->info.window.ekey);
+  pRetrieve->version = htobe64(pBlock->info.version);
 
   int32_t numOfCols = (int32_t)taosArrayGetSize(pBlock->pDataBlock);
   pRetrieve->numOfCols = htonl(numOfCols);

source/libs/sync/src/syncMain.c

@@ -1550,12 +1550,12 @@ void syncNodeEventLog(const SSyncNode* pSyncNode, char* str) {
     char logBuf[256 + 256];
     if (pSyncNode != NULL && pSyncNode->pRaftCfg != NULL && pSyncNode->pRaftStore != NULL) {
       snprintf(logBuf, sizeof(logBuf),
-               "vgId:%d, sync %s %s, term:%" PRIu64 ", commit:%" PRId64 ", first:%" PRId64 ", last:%" PRId64
-               ", snapshot:%" PRId64 ", snapshot-term:%" PRIu64
-               ", standby:%d, "
-               "strategy:%d, batch:%d, "
-               "replica-num:%d, "
-               "lconfig:%" PRId64 ", changing:%d, restore:%d, %s",
+               "vgId:%d, sync %s %s, tm:%" PRIu64 ", cmt:%" PRId64 ", fst:%" PRId64 ", lst:%" PRId64 ", snap:%" PRId64
+               ", snap-tm:%" PRIu64
+               ", sby:%d, "
+               "stgy:%d, bch:%d, "
+               "r-num:%d, "
+               "lcfg:%" PRId64 ", chging:%d, rsto:%d, %s",
                pSyncNode->vgId, syncUtilState2String(pSyncNode->state), str, pSyncNode->pRaftStore->currentTerm,
                pSyncNode->commitIndex, logBeginIndex, logLastIndex, snapshot.lastApplyIndex, snapshot.lastApplyTerm,
                pSyncNode->pRaftCfg->isStandBy, pSyncNode->pRaftCfg->snapshotStrategy, pSyncNode->pRaftCfg->batchSize,
@@ -1573,12 +1573,12 @@ void syncNodeEventLog(const SSyncNode* pSyncNode, char* str) {
     char* s = (char*)taosMemoryMalloc(len);
     if (pSyncNode != NULL && pSyncNode->pRaftCfg != NULL && pSyncNode->pRaftStore != NULL) {
       snprintf(s, len,
-               "vgId:%d, sync %s %s, term:%" PRIu64 ", commit:%" PRId64 ", first:%" PRId64 ", last:%" PRId64
-               ", snapshot:%" PRId64 ", snapshot-term:%" PRIu64
-               ", standby:%d, "
-               "strategy:%d, batch:%d, "
-               "replica-num:%d, "
-               "lconfig:%" PRId64 ", changing:%d, restore:%d, %s",
+               "vgId:%d, sync %s %s, tm:%" PRIu64 ", cmt:%" PRId64 ", fst:%" PRId64 ", lst:%" PRId64 ", snap:%" PRId64
+               ", snap-tm:%" PRIu64
+               ", sby:%d, "
+               "stgy:%d, bch:%d, "
+               "r-num:%d, "
+               "lcfg:%" PRId64 ", chging:%d, rsto:%d, %s",
                pSyncNode->vgId, syncUtilState2String(pSyncNode->state), str, pSyncNode->pRaftStore->currentTerm,
                pSyncNode->commitIndex, logBeginIndex, logLastIndex, snapshot.lastApplyIndex, snapshot.lastApplyTerm,
                pSyncNode->pRaftCfg->isStandBy, pSyncNode->pRaftCfg->snapshotStrategy, pSyncNode->pRaftCfg->batchSize,
@@ -1621,12 +1621,12 @@ void syncNodeErrorLog(const SSyncNode* pSyncNode, char* str) {
     char logBuf[256 + 256];
     if (pSyncNode != NULL && pSyncNode->pRaftCfg != NULL && pSyncNode->pRaftStore != NULL) {
       snprintf(logBuf, sizeof(logBuf),
-               "vgId:%d, sync %s %s, term:%" PRIu64 ", commit:%" PRId64 ", first:%" PRId64 ", last:%" PRId64
-               ", snapshot:%" PRId64 ", snapshot-term:%" PRIu64
-               ", standby:%d, "
-               "strategy:%d, batch:%d, "
-               "replica-num:%d, "
-               "lconfig:%" PRId64 ", changing:%d, restore:%d, %s",
+               "vgId:%d, sync %s %s, tm:%" PRIu64 ", cmt:%" PRId64 ", fst:%" PRId64 ", lst:%" PRId64 ", snap:%" PRId64
+               ", snap-tm:%" PRIu64
+               ", sby:%d, "
+               "stgy:%d, bch:%d, "
+               "r-num:%d, "
+               "lcfg:%" PRId64 ", chging:%d, rsto:%d, %s",
                pSyncNode->vgId, syncUtilState2String(pSyncNode->state), str, pSyncNode->pRaftStore->currentTerm,
                pSyncNode->commitIndex, logBeginIndex, logLastIndex, snapshot.lastApplyIndex, snapshot.lastApplyTerm,
                pSyncNode->pRaftCfg->isStandBy, pSyncNode->pRaftCfg->snapshotStrategy, pSyncNode->pRaftCfg->batchSize,
@@ -1642,12 +1642,12 @@ void syncNodeErrorLog(const SSyncNode* pSyncNode, char* str) {
     char* s = (char*)taosMemoryMalloc(len);
     if (pSyncNode != NULL && pSyncNode->pRaftCfg != NULL && pSyncNode->pRaftStore != NULL) {
       snprintf(s, len,
-               "vgId:%d, sync %s %s, term:%" PRIu64 ", commit:%" PRId64 ", first:%" PRId64 ", last:%" PRId64
-               ", snapshot:%" PRId64 ", snapshot-term:%" PRIu64
-               ", standby:%d, "
-               "strategy:%d, batch:%d, "
-               "replica-num:%d, "
-               "lconfig:%" PRId64 ", changing:%d, restore:%d, %s",
+               "vgId:%d, sync %s %s, tm:%" PRIu64 ", cmt:%" PRId64 ", fst:%" PRId64 ", lst:%" PRId64 ", snap:%" PRId64
+               ", snap-tm:%" PRIu64
+               ", sby:%d, "
+               "stgy:%d, bch:%d, "
+               "r-num:%d, "
+               "lcfg:%" PRId64 ", chging:%d, rsto:%d, %s",
                pSyncNode->vgId, syncUtilState2String(pSyncNode->state), str, pSyncNode->pRaftStore->currentTerm,
                pSyncNode->commitIndex, logBeginIndex, logLastIndex, snapshot.lastApplyIndex, snapshot.lastApplyTerm,
                pSyncNode->pRaftCfg->isStandBy, pSyncNode->pRaftCfg->snapshotStrategy, pSyncNode->pRaftCfg->batchSize,
@@ -1675,11 +1675,10 @@ char* syncNode2SimpleStr(const SSyncNode* pSyncNode) {
   SyncIndex logBeginIndex = pSyncNode->pLogStore->syncLogBeginIndex(pSyncNode->pLogStore);
 
   snprintf(s, len,
-           "vgId:%d, sync %s, term:%" PRIu64 ", commit:%" PRId64 ", first:%" PRId64 ", last:%" PRId64
-           ", snapshot:%" PRId64
-           ", standby:%d, "
-           "replica-num:%d, "
-           "lconfig:%" PRId64 ", changing:%d, restore:%d",
+           "vgId:%d, sync %s, tm:%" PRIu64 ", cmt:%" PRId64 ", fst:%" PRId64 ", lst:%" PRId64 ", snap:%" PRId64
+           ", sby:%d, "
+           "r-num:%d, "
+           "lcfg:%" PRId64 ", chging:%d, rsto:%d",
            pSyncNode->vgId, syncUtilState2String(pSyncNode->state), pSyncNode->pRaftStore->currentTerm,
            pSyncNode->commitIndex, logBeginIndex, logLastIndex, snapshot.lastApplyIndex, pSyncNode->pRaftCfg->isStandBy,
            pSyncNode->replicaNum, pSyncNode->pRaftCfg->lastConfigIndex, pSyncNode->changing, pSyncNode->restoreFinish);
@@ -2977,7 +2976,7 @@ void syncLogSendAppendEntries(SSyncNode* pSyncNode, const SyncAppendEntries* pMs
   char logBuf[256];
   snprintf(logBuf, sizeof(logBuf),
            "send sync-append-entries to %s:%d, {term:%" PRIu64 ", pre-index:%" PRId64 ", pre-term:%" PRIu64
-           ", pterm:%" PRIu64 ", commit:%" PRId64
+           ", pterm:%" PRIu64 ", cmt:%" PRId64
            ", "
            "datalen:%d}, %s",
            host, port, pMsg->term, pMsg->prevLogIndex, pMsg->prevLogTerm, pMsg->privateTerm, pMsg->commitIndex,
@@ -2992,7 +2991,7 @@ void syncLogRecvAppendEntries(SSyncNode* pSyncNode, const SyncAppendEntries* pMs
   char logBuf[256];
   snprintf(logBuf, sizeof(logBuf),
            "recv sync-append-entries from %s:%d {term:%" PRIu64 ", pre-index:%" PRIu64 ", pre-term:%" PRIu64
-           ", commit:%" PRIu64 ", pterm:%" PRIu64
+           ", cmt:%" PRIu64 ", pterm:%" PRIu64
            ", "
            "datalen:%d}, %s",
            host, port, pMsg->term, pMsg->prevLogIndex, pMsg->prevLogTerm, pMsg->commitIndex, pMsg->privateTerm,
@@ -3007,7 +3006,7 @@ void syncLogSendAppendEntriesBatch(SSyncNode* pSyncNode, const SyncAppendEntries
   char logBuf[256];
   snprintf(logBuf, sizeof(logBuf),
            "send sync-append-entries-batch to %s:%d, {term:%" PRIu64 ", pre-index:%" PRId64 ", pre-term:%" PRIu64
-           ", pterm:%" PRIu64 ", commit:%" PRId64 ", datalen:%d, count:%d}, %s",
+           ", pterm:%" PRIu64 ", cmt:%" PRId64 ", datalen:%d, count:%d}, %s",
            host, port, pMsg->term, pMsg->prevLogIndex, pMsg->prevLogTerm, pMsg->privateTerm, pMsg->commitIndex,
            pMsg->dataLen, pMsg->dataCount, s);
   syncNodeEventLog(pSyncNode, logBuf);
@@ -3020,7 +3019,7 @@ void syncLogRecvAppendEntriesBatch(SSyncNode* pSyncNode, const SyncAppendEntries
   char logBuf[256];
   snprintf(logBuf, sizeof(logBuf),
            "recv sync-append-entries-batch from %s:%d, {term:%" PRIu64 ", pre-index:%" PRId64 ", pre-term:%" PRIu64
-           ", pterm:%" PRIu64 ", commit:%" PRId64 ", datalen:%d, count:%d}, %s",
+           ", pterm:%" PRIu64 ", cmt:%" PRId64 ", datalen:%d, count:%d}, %s",
            host, port, pMsg->term, pMsg->prevLogIndex, pMsg->prevLogTerm, pMsg->privateTerm, pMsg->commitIndex,
            pMsg->dataLen, pMsg->dataCount, s);
   syncNodeEventLog(pSyncNode, logBuf);

source/libs/sync/src/syncRaftCfg.c

@@ -101,7 +101,7 @@ cJSON *syncCfg2Json(SSyncCfg *pSyncCfg) {
 
 char *syncCfg2Str(SSyncCfg *pSyncCfg) {
   cJSON *pJson = syncCfg2Json(pSyncCfg);
-  char * serialized = cJSON_Print(pJson);
+  char  *serialized = cJSON_Print(pJson);
   cJSON_Delete(pJson);
   return serialized;
 }
@@ -109,10 +109,10 @@ char *syncCfg2Str(SSyncCfg *pSyncCfg) {
 char *syncCfg2SimpleStr(SSyncCfg *pSyncCfg) {
   if (pSyncCfg != NULL) {
     int32_t len = 512;
-    char *  s = taosMemoryMalloc(len);
+    char   *s = taosMemoryMalloc(len);
     memset(s, 0, len);
 
-    snprintf(s, len, "{replica-num:%d, my-index:%d, ", pSyncCfg->replicaNum, pSyncCfg->myIndex);
+    snprintf(s, len, "{r-num:%d, my:%d, ", pSyncCfg->replicaNum, pSyncCfg->myIndex);
     char *p = s + strlen(s);
     for (int i = 0; i < pSyncCfg->replicaNum; ++i) {
       /*
@@ -206,7 +206,7 @@ cJSON *raftCfg2Json(SRaftCfg *pRaftCfg) {
 
 char *raftCfg2Str(SRaftCfg *pRaftCfg) {
   cJSON *pJson = raftCfg2Json(pRaftCfg);
-  char * serialized = cJSON_Print(pJson);
+  char  *serialized = cJSON_Print(pJson);
   cJSON_Delete(pJson);
   return serialized;
 }
@@ -285,7 +285,7 @@ int32_t raftCfgFromJson(const cJSON *pRoot, SRaftCfg *pRaftCfg) {
     (pRaftCfg->configIndexArr)[i] = atoll(pIndex->valuestring);
   }
 
-  cJSON * pJsonSyncCfg = cJSON_GetObjectItem(pJson, "SSyncCfg");
+  cJSON  *pJsonSyncCfg = cJSON_GetObjectItem(pJson, "SSyncCfg");
   int32_t code = syncCfgFromJson(pJsonSyncCfg, &(pRaftCfg->cfg));
   ASSERT(code == 0);
 

source/libs/transport/inc/transComm.h

@@ -229,8 +229,8 @@ typedef struct {
   int8_t      stop;
 } SAsyncPool;
 
-SAsyncPool* transCreateAsyncPool(uv_loop_t* loop, int sz, void* arg, AsyncCB cb);
-void        transDestroyAsyncPool(SAsyncPool* pool);
+SAsyncPool* transAsyncPoolCreate(uv_loop_t* loop, int sz, void* arg, AsyncCB cb);
+void        transAsyncPoolDestroy(SAsyncPool* pool);
 int         transAsyncSend(SAsyncPool* pool, queue* mq);
 bool        transAsyncPoolIsEmpty(SAsyncPool* pool);
 
@@ -322,7 +322,7 @@ typedef struct STransReq {
 } STransReq;
 
 void  transReqQueueInit(queue* q);
-void* transReqQueuePushReq(queue* q);
+void* transReqQueuePush(queue* q);
 void* transReqQueueRemove(void* arg);
 void  transReqQueueClear(queue* q);
 
@@ -393,9 +393,9 @@ typedef struct SDelayQueue {
   uv_loop_t*  loop;
 } SDelayQueue;
 
-int  transDQCreate(uv_loop_t* loop, SDelayQueue** queue);
-void transDQDestroy(SDelayQueue* queue, void (*freeFunc)(void* arg));
-int  transDQSched(SDelayQueue* queue, void (*func)(void* arg), void* arg, uint64_t timeoutMs);
+int         transDQCreate(uv_loop_t* loop, SDelayQueue** queue);
+void        transDQDestroy(SDelayQueue* queue, void (*freeFunc)(void* arg));
+SDelayTask* transDQSched(SDelayQueue* queue, void (*func)(void* arg), void* arg, uint64_t timeoutMs);
 
 bool transEpSetIsEqual(SEpSet* a, SEpSet* b);
 /*

source/libs/transport/src/transCli.c

@@ -26,7 +26,7 @@ typedef struct SCliConn {
 
   SConnBuffer readBuf;
   STransQueue cliMsgs;
-  queue       conn;
+  queue       q;
   uint64_t    expireTime;
 
   STransCtx  ctx;
@@ -451,7 +451,7 @@ void cliTimeoutCb(uv_timer_t* handle) {
   while (p != NULL) {
     while (!QUEUE_IS_EMPTY(&p->conn)) {
       queue*    h = QUEUE_HEAD(&p->conn);
-      SCliConn* c = QUEUE_DATA(h, SCliConn, conn);
+      SCliConn* c = QUEUE_DATA(h, SCliConn, q);
       if (c->expireTime < currentTime) {
         QUEUE_REMOVE(h);
         transUnrefCliHandle(c);
@@ -475,7 +475,7 @@ void* destroyConnPool(void* pool) {
   while (connList != NULL) {
     while (!QUEUE_IS_EMPTY(&connList->conn)) {
       queue*    h = QUEUE_HEAD(&connList->conn);
-      SCliConn* c = QUEUE_DATA(h, SCliConn, conn);
+      SCliConn* c = QUEUE_DATA(h, SCliConn, q);
       cliDestroyConn(c, true);
     }
     connList = taosHashIterate((SHashObj*)pool, connList);
@@ -501,11 +501,11 @@ static SCliConn* getConnFromPool(void* pool, char* ip, uint32_t port) {
     return NULL;
   }
   queue*    h = QUEUE_HEAD(&plist->conn);
-  SCliConn* conn = QUEUE_DATA(h, SCliConn, conn);
+  SCliConn* conn = QUEUE_DATA(h, SCliConn, q);
   conn->status = ConnNormal;
-  QUEUE_REMOVE(&conn->conn);
-  QUEUE_INIT(&conn->conn);
-  assert(h == &conn->conn);
+  QUEUE_REMOVE(&conn->q);
+  QUEUE_INIT(&conn->q);
+  assert(h == &conn->q);
   return conn;
 }
 static int32_t allocConnRef(SCliConn* conn, bool update) {
@@ -560,8 +560,8 @@ static void addConnToPool(void* pool, SCliConn* conn) {
   SConnList* plist = taosHashGet((SHashObj*)pool, key, strlen(key));
   // list already create before
   assert(plist != NULL);
-  QUEUE_INIT(&conn->conn);
-  QUEUE_PUSH(&plist->conn, &conn->conn);
+  QUEUE_INIT(&conn->q);
+  QUEUE_PUSH(&plist->conn, &conn->q);
   assert(!QUEUE_IS_EMPTY(&plist->conn));
 }
 static void cliAllocRecvBufferCb(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf) {
@@ -614,7 +614,7 @@ static SCliConn* cliCreateConn(SCliThrd* pThrd) {
   transReqQueueInit(&conn->wreqQueue);
 
   transQueueInit(&conn->cliMsgs, NULL);
-  QUEUE_INIT(&conn->conn);
+  QUEUE_INIT(&conn->q);
   conn->hostThrd = pThrd;
   conn->status = ConnNormal;
   conn->broken = 0;
@@ -626,8 +626,8 @@ static SCliConn* cliCreateConn(SCliThrd* pThrd) {
 }
 static void cliDestroyConn(SCliConn* conn, bool clear) {
   tTrace("%s conn %p remove from conn pool", CONN_GET_INST_LABEL(conn), conn);
-  QUEUE_REMOVE(&conn->conn);
-  QUEUE_INIT(&conn->conn);
+  QUEUE_REMOVE(&conn->q);
+  QUEUE_INIT(&conn->q);
   transRemoveExHandle(transGetRefMgt(), conn->refId);
   conn->refId = -1;
 
@@ -735,7 +735,7 @@ void cliSend(SCliConn* pConn) {
     CONN_SET_PERSIST_BY_APP(pConn);
   }
 
-  uv_write_t* req = transReqQueuePushReq(&pConn->wreqQueue);
+  uv_write_t* req = transReqQueuePush(&pConn->wreqQueue);
   uv_write(req, (uv_stream_t*)pConn->stream, &wb, 1, cliSendCb);
   return;
 _RETURN:
@@ -990,7 +990,7 @@ static SCliThrd* createThrdObj() {
   pThrd->loop = (uv_loop_t*)taosMemoryMalloc(sizeof(uv_loop_t));
   uv_loop_init(pThrd->loop);
 
-  pThrd->asyncPool = transCreateAsyncPool(pThrd->loop, 5, pThrd, cliAsyncCb);
+  pThrd->asyncPool = transAsyncPoolCreate(pThrd->loop, 5, pThrd, cliAsyncCb);
   uv_timer_init(pThrd->loop, &pThrd->timer);
   pThrd->timer.data = pThrd;
 
@@ -1009,7 +1009,7 @@ static void destroyThrdObj(SCliThrd* pThrd) {
   CLI_RELEASE_UV(pThrd->loop);
   taosThreadMutexDestroy(&pThrd->msgMtx);
   TRANS_DESTROY_ASYNC_POOL_MSG(pThrd->asyncPool, SCliMsg, destroyCmsg);
-  transDestroyAsyncPool(pThrd->asyncPool);
+  transAsyncPoolDestroy(pThrd->asyncPool);
 
   transDQDestroy(pThrd->delayQueue, destroyCmsg);
   taosMemoryFree(pThrd->loop);
@@ -1054,6 +1054,12 @@ static void doDelayTask(void* param) {
   cliHandleReq(pMsg, pThrd);
 }
 
+static void doCloseIdleConn(void* param) {
+  STaskArg* arg = param;
+  SCliConn* conn = arg->param1;
+  SCliThrd* pThrd = arg->param2;
+}
+
 static void cliSchedMsgToNextNode(SCliMsg* pMsg, SCliThrd* pThrd) {
   STransConnCtx* pCtx = pMsg->ctx;
 
@@ -1075,7 +1081,7 @@ void cliCompareAndSwap(int8_t* val, int8_t exp, int8_t newVal) {
   }
 }
 
-bool cliTryToExtractEpSet(STransMsg* pResp, SEpSet* dst) {
+bool cliTryExtractEpSet(STransMsg* pResp, SEpSet* dst) {
   if ((pResp == NULL || pResp->info.hasEpSet == 0)) {
     return false;
   }
@@ -1116,7 +1122,8 @@ int cliAppCb(SCliConn* pConn, STransMsg* pResp, SCliMsg* pMsg) {
    */
   STransConnCtx* pCtx = pMsg->ctx;
   int32_t        code = pResp->code;
-  bool           retry = (pTransInst->retry != NULL && pTransInst->retry(code, pResp->msgType - 1)) ? true : false;
+
+  bool retry = (pTransInst->retry != NULL && pTransInst->retry(code, pResp->msgType - 1)) ? true : false;
   if (retry) {
     pMsg->sent = 0;
     pCtx->retryCnt += 1;
@@ -1125,6 +1132,7 @@ int cliAppCb(SCliConn* pConn, STransMsg* pResp, SCliMsg* pMsg) {
       if (pCtx->retryCnt < pCtx->retryLimit) {
         transUnrefCliHandle(pConn);
         EPSET_FORWARD_INUSE(&pCtx->epSet);
+        transFreeMsg(pResp->pCont);
         cliSchedMsgToNextNode(pMsg, pThrd);
         return -1;
       }
@@ -1148,7 +1156,7 @@ int cliAppCb(SCliConn* pConn, STransMsg* pResp, SCliMsg* pMsg) {
 
   STraceId* trace = &pResp->info.traceId;
 
-  bool hasEpSet = cliTryToExtractEpSet(pResp, &pCtx->epSet);
+  bool hasEpSet = cliTryExtractEpSet(pResp, &pCtx->epSet);
   if (hasEpSet) {
     char tbuf[256] = {0};
     EPSET_DEBUG_STR(&pCtx->epSet, tbuf);
@@ -1336,19 +1344,18 @@ int transSendRecv(void* shandle, const SEpSet* pEpSet, STransMsg* pReq, STransMs
   tGDebug("%s send request at thread:%08" PRId64 ", dst:%s:%d, app:%p", transLabel(pTransInst), pThrd->pid,
           EPSET_GET_INUSE_IP(&pCtx->epSet), EPSET_GET_INUSE_PORT(&pCtx->epSet), pReq->info.ahandle);
 
-  if (0 != transAsyncSend(pThrd->asyncPool, &cliMsg->q)) {
-    tsem_destroy(sem);
-    taosMemoryFree(sem);
+  int ret = transAsyncSend(pThrd->asyncPool, &cliMsg->q);
+  if (ret != 0) {
     destroyCmsg(cliMsg);
-    transReleaseExHandle(transGetInstMgt(), (int64_t)shandle);
-    return -1;
+    goto _RETURN;
   }
   tsem_wait(sem);
+
+_RETURN:
   tsem_destroy(sem);
   taosMemoryFree(sem);
-
   transReleaseExHandle(transGetInstMgt(), (int64_t)shandle);
-  return 0;
+  return ret;
 }
 /*
  *

source/libs/transport/src/transComm.c

@@ -175,7 +175,7 @@ int transSetConnOption(uv_tcp_t* stream) {
   return ret;
 }
 
-SAsyncPool* transCreateAsyncPool(uv_loop_t* loop, int sz, void* arg, AsyncCB cb) {
+SAsyncPool* transAsyncPoolCreate(uv_loop_t* loop, int sz, void* arg, AsyncCB cb) {
   SAsyncPool* pool = taosMemoryCalloc(1, sizeof(SAsyncPool));
   pool->nAsync = sz;
   pool->asyncs = taosMemoryCalloc(1, sizeof(uv_async_t) * pool->nAsync);
@@ -194,7 +194,7 @@ SAsyncPool* transCreateAsyncPool(uv_loop_t* loop, int sz, void* arg, AsyncCB cb)
   return pool;
 }
 
-void transDestroyAsyncPool(SAsyncPool* pool) {
+void transAsyncPoolDestroy(SAsyncPool* pool) {
   for (int i = 0; i < pool->nAsync; i++) {
     uv_async_t* async = &(pool->asyncs[i]);
     // uv_close((uv_handle_t*)async, NULL);
@@ -205,6 +205,14 @@ void transDestroyAsyncPool(SAsyncPool* pool) {
   taosMemoryFree(pool->asyncs);
   taosMemoryFree(pool);
 }
+bool transAsyncPoolIsEmpty(SAsyncPool* pool) {
+  for (int i = 0; i < pool->nAsync; i++) {
+    uv_async_t* async = &(pool->asyncs[i]);
+    SAsyncItem* item = async->data;
+    if (!QUEUE_IS_EMPTY(&item->qmsg)) return false;
+  }
+  return true;
+}
 int transAsyncSend(SAsyncPool* pool, queue* q) {
   if (atomic_load_8(&pool->stop) == 1) {
     return -1;
@@ -228,14 +236,6 @@ int transAsyncSend(SAsyncPool* pool, queue* q) {
   }
   return uv_async_send(async);
 }
-bool transAsyncPoolIsEmpty(SAsyncPool* pool) {
-  for (int i = 0; i < pool->nAsync; i++) {
-    uv_async_t* async = &(pool->asyncs[i]);
-    SAsyncItem* item = async->data;
-    if (!QUEUE_IS_EMPTY(&item->qmsg)) return false;
-  }
-  return true;
-}
 
 void transCtxInit(STransCtx* ctx) {
   // init transCtx
@@ -308,7 +308,7 @@ void transReqQueueInit(queue* q) {
   // init req queue
   QUEUE_INIT(q);
 }
-void* transReqQueuePushReq(queue* q) {
+void* transReqQueuePush(queue* q) {
   uv_write_t* req = taosMemoryCalloc(1, sizeof(uv_write_t));
   STransReq*  wreq = taosMemoryCalloc(1, sizeof(STransReq));
   wreq->data = req;
@@ -488,8 +488,25 @@ void transDQDestroy(SDelayQueue* queue, void (*freeFunc)(void* arg)) {
   heapDestroy(queue->heap);
   taosMemoryFree(queue);
 }
+void transDQCancel(SDelayQueue* queue, SDelayTask* task) {
+  uv_timer_stop(queue->timer);
+
+  if (heapSize(queue->heap) <= 0) return;
+  heapRemove(queue->heap, &task->node);
 
-int transDQSched(SDelayQueue* queue, void (*func)(void* arg), void* arg, uint64_t timeoutMs) {
+  if (heapSize(queue->heap) != 0) {
+    HeapNode* minNode = heapMin(queue->heap);
+    if (minNode != NULL) return;
+
+    uint64_t    now = taosGetTimestampMs();
+    SDelayTask* task = container_of(minNode, SDelayTask, node);
+    uint64_t    timeout = now > task->execTime ? now - task->execTime : 0;
+
+    uv_timer_start(queue->timer, transDQTimeout, timeout, 0);
+  }
+}
+
+SDelayTask* transDQSched(SDelayQueue* queue, void (*func)(void* arg), void* arg, uint64_t timeoutMs) {
   uint64_t    now = taosGetTimestampMs();
   SDelayTask* task = taosMemoryCalloc(1, sizeof(SDelayTask));
   task->func = func;
@@ -507,7 +524,7 @@ int transDQSched(SDelayQueue* queue, void (*func)(void* arg), void* arg, uint64_
   tTrace("timer %p put task into delay queue, timeoutMs:%" PRIu64, queue->timer, timeoutMs);
   heapInsert(queue->heap, &task->node);
   uv_timer_start(queue->timer, transDQTimeout, timeoutMs, 0);
-  return 0;
+  return task;
 }
 
 void transPrintEpSet(SEpSet* pEpSet) {

source/libs/transport/src/transSvr.c

@@ -434,7 +434,7 @@ static void uvStartSendRespInternal(SSvrMsg* smsg) {
   uvPrepareSendData(smsg, &wb);
 
   transRefSrvHandle(pConn);
-  uv_write_t* req = transReqQueuePushReq(&pConn->wreqQueue);
+  uv_write_t* req = transReqQueuePush(&pConn->wreqQueue);
   uv_write(req, (uv_stream_t*)pConn->pTcp, &wb, 1, uvOnSendCb);
 }
 static void uvStartSendResp(SSvrMsg* smsg) {
@@ -697,7 +697,7 @@ static bool addHandleToWorkloop(SWorkThrd* pThrd, char* pipeName) {
   // conn set
   QUEUE_INIT(&pThrd->conn);
 
-  pThrd->asyncPool = transCreateAsyncPool(pThrd->loop, 1, pThrd, uvWorkerAsyncCb);
+  pThrd->asyncPool = transAsyncPoolCreate(pThrd->loop, 1, pThrd, uvWorkerAsyncCb);
   uv_pipe_connect(&pThrd->connect_req, pThrd->pipe, pipeName, uvOnPipeConnectionCb);
   // uv_read_start((uv_stream_t*)pThrd->pipe, uvAllocConnBufferCb, uvOnConnectionCb);
   return true;
@@ -976,7 +976,7 @@ void destroyWorkThrd(SWorkThrd* pThrd) {
   taosThreadJoin(pThrd->thread, NULL);
   SRV_RELEASE_UV(pThrd->loop);
   TRANS_DESTROY_ASYNC_POOL_MSG(pThrd->asyncPool, SSvrMsg, destroySmsg);
-  transDestroyAsyncPool(pThrd->asyncPool);
+  transAsyncPoolDestroy(pThrd->asyncPool);
   taosMemoryFree(pThrd->loop);
   taosMemoryFree(pThrd);
 }

tests/pytest/crash_gen/crash_gen_main.py

@@ -809,6 +809,8 @@ class StateEmpty(AnyState):
         ]
 
     def verifyTasksToState(self, tasks, newState):
+        if Config.getConfig().ignore_errors: # if we are asked to ignore certain errors, let's not verify CreateDB success.
+            return
         if (self.hasSuccess(tasks, TaskCreateDb)
                 ):  # at EMPTY, if there's succes in creating DB
             if (not self.hasTask(tasks, TaskDropDb)):  # and no drop_db tasks
@@ -2491,7 +2493,7 @@ class MainExec:
             action='store',
             default=None,
             type=str,
-            help='Ignore error codes, comma separated, 0x supported (default: None)')
+            help='Ignore error codes, comma separated, 0x supported, also suppresses certain transition state checks. (default: None)')
         parser.add_argument(
             '-i',
             '--num-replicas',

tests/pytest/util/common.py

@@ -28,6 +28,7 @@ from util.common import *
 from util.constant import *
 from dataclasses import dataclass,field
 from typing import List
+from datetime import datetime
 
 @dataclass
 class DataSet:

tests/script/jenkins/basic.txt

@@ -89,7 +89,7 @@
 ./test.sh -f tsim/parser/alter.sim
 # jira ./test.sh -f tsim/parser/alter1.sim
 ./test.sh -f tsim/parser/auto_create_tb_drop_tb.sim
-# jira ./test.sh -f tsim/parser/auto_create_tb.sim
+./test.sh -f tsim/parser/auto_create_tb.sim
 ./test.sh -f tsim/parser/between_and.sim
 ./test.sh -f tsim/parser/binary_escapeCharacter.sim
 # jira ./test.sh -f tsim/parser/col_arithmetic_operation.sim     
@@ -110,9 +110,9 @@
 ./test.sh -f tsim/parser/fourArithmetic-basic.sim
 # jira ./test.sh -f tsim/parser/function.sim
 ./test.sh -f tsim/parser/groupby-basic.sim
-# ./test.sh -f tsim/parser/groupby.sim
-# ./test.sh -f tsim/parser/having_child.sim
-## ./test.sh -f tsim/parser/having.sim
+# jira ./test.sh -f tsim/parser/groupby.sim
+# jira ./test.sh -f tsim/parser/having_child.sim
+# jira ./test.sh -f tsim/parser/having.sim
 ./test.sh -f tsim/parser/import_commit1.sim
 ./test.sh -f tsim/parser/import_commit2.sim
 ./test.sh -f tsim/parser/import_commit3.sim
@@ -121,53 +121,49 @@
 ./test.sh -f tsim/parser/insert_multiTbl.sim
 ./test.sh -f tsim/parser/insert_tb.sim
 # jira ./test.sh -f tsim/parser/interp.sim
-# ./test.sh -f tsim/parser/join.sim
-# ./test.sh -f tsim/parser/join_manyblocks.sim
+./test.sh -f tsim/parser/join_manyblocks.sim
 ## ./test.sh -f tsim/parser/join_multitables.sim
 # ./test.sh -f tsim/parser/join_multivnode.sim
+# jira ./test.sh -f tsim/parser/join.sim
 ./test.sh -f tsim/parser/last_cache.sim
-## ./test.sh -f tsim/parser/last_groupby.sim
+./test.sh -f tsim/parser/last_groupby.sim
 # jira ./test.sh -f tsim/parser/lastrow.sim
-## ./test.sh -f tsim/parser/like.sim
-# ./test.sh -f tsim/parser/limit.sim
-# ./test.sh -f tsim/parser/limit1.sim
-# ./test.sh -f tsim/parser/limit1_tblocks100.sim
-## ./test.sh -f tsim/parser/limit2.sim
-## ./test.sh -f tsim/parser/limit2_tblocks100.sim
-## ./test.sh -f tsim/parser/limit_stb.sim
-## ./test.sh -f tsim/parser/limit_tb.sim
-## ./test.sh -f tsim/parser/line_insert.sim
-# ./test.sh -f tsim/parser/mixed_blocks.sim
-# ./test.sh -f tsim/parser/nchar.sim
-# ./test.sh -f tsim/parser/nestquery.sim
-# ./test.sh -f tsim/parser/null_char.sim
-## ./test.sh -f tsim/parser/precision_ns.sim
-# ./test.sh -f tsim/parser/projection_limit_offset.sim
-## ./test.sh -f tsim/parser/regex.sim
-# ./test.sh -f tsim/parser/repeatAlter.sim
-# ./test.sh -f tsim/parser/selectResNum.sim
-# ./test.sh -f tsim/parser/select_across_vnodes.sim
-# ./test.sh -f tsim/parser/select_distinct_tag.sim
-# ./test.sh -f tsim/parser/select_from_cache_disk.sim
-# ./test.sh -f tsim/parser/select_with_tags.sim
-# ./test.sh -f tsim/parser/set_tag_vals.sim
-# ./test.sh -f tsim/parser/single_row_in_tb.sim
-# ./test.sh -f tsim/parser/sliding.sim
-# ./test.sh -f tsim/parser/slimit_alter_tags.sim
-# ./test.sh -f tsim/parser/slimit.sim
-# ./test.sh -f tsim/parser/slimit1.sim
+./test.sh -f tsim/parser/like.sim
+# jira ./test.sh -f tsim/parser/limit.sim
+# jira ./test.sh -f tsim/parser/limit1.sim
+# jira ./test.sh -f tsim/parser/limit2.sim
+# jira ./test.sh -f tsim/parser/line_insert.sim
+./test.sh -f tsim/parser/mixed_blocks.sim
+./test.sh -f tsim/parser/nchar.sim
+# jira ./test.sh -f tsim/parser/nestquery.sim
+# jira ./test.sh -f tsim/parser/null_char.sim
+./test.sh -f tsim/parser/precision_ns.sim
+./test.sh -f tsim/parser/projection_limit_offset.sim
+./test.sh -f tsim/parser/regex.sim
+./test.sh -f tsim/parser/select_across_vnodes.sim
+./test.sh -f tsim/parser/select_distinct_tag.sim
+./test.sh -f tsim/parser/select_from_cache_disk.sim
+# jira ./test.sh -f tsim/parser/select_with_tags.sim
+./test.sh -f tsim/parser/selectResNum.sim
+# jira ./test.sh -f tsim/parser/set_tag_vals.sim
+./test.sh -f tsim/parser/single_row_in_tb.sim
+# jira ./test.sh -f tsim/parser/sliding.sim
+# jira ./test.sh -f tsim/parser/slimit_alter_tags.sim
+# jira ./test.sh -f tsim/parser/slimit.sim
+# jira ./test.sh -f tsim/parser/slimit1.sim
 ./test.sh -f tsim/parser/stableOp.sim
-# ./test.sh -f tsim/parser/tags_dynamically_specifiy.sim
-# ./test.sh -f tsim/parser/tags_filter.sim
+# jira ./test.sh -f tsim/parser/tags_dynamically_specifiy.sim
+# jira ./test.sh -f tsim/parser/tags_filter.sim
 ./test.sh -f tsim/parser/tbnameIn.sim
 ./test.sh -f tsim/parser/timestamp.sim
 ./test.sh -f tsim/parser/top_groupby.sim
 ./test.sh -f tsim/parser/topbot.sim
-# ./test.sh -f tsim/parser/udf_dll_stable.sim
-# ./test.sh -f tsim/parser/udf_dll.sim
-# ./test.sh -f tsim/parser/udf.sim
-# ./test.sh -f tsim/parser/union.sim
-# ./test.sh -f tsim/parser/where.sim
+# jira ./test.sh -f tsim/parser/udf_dll_stable.sim
+# jira ./test.sh -f tsim/parser/udf_dll.sim
+# jira ./test.sh -f tsim/parser/udf.sim
+./test.sh -f tsim/parser/union.sim
+# jira ./test.sh -f tsim/parser/union_sysinfo.sim
+# jira ./test.sh -f tsim/parser/where.sim
 
 # ---- query
 ./test.sh -f tsim/query/interval.sim
@@ -426,18 +422,18 @@
 ./test.sh -f tsim/tag/bool_binary.sim
 ./test.sh -f tsim/tag/bool_int.sim
 ./test.sh -f tsim/tag/bool.sim
-# ./test.sh -f tsim/tag/change.sim
-# ./test.sh -f tsim/tag/column.sim
-# ./test.sh -f tsim/tag/commit.sim
-# ./test.sh -f tsim/tag/create.sim
-# ./test.sh -f tsim/tag/delete.sim
+# jira ./test.sh -f tsim/tag/change.sim
+# jira ./test.sh -f tsim/tag/column.sim
+# jira ./test.sh -f tsim/tag/commit.sim
+# jira ./test.sh -f tsim/tag/create.sim
+# jira /test.sh -f tsim/tag/delete.sim
 # jira ./test.sh -f tsim/tag/double.sim
-# ./test.sh -f tsim/tag/filter.sim
+# jira ./test.sh -f tsim/tag/filter.sim
 # jira ./test.sh -f tsim/tag/float.sim
 ./test.sh -f tsim/tag/int_binary.sim
 ./test.sh -f tsim/tag/int_float.sim
 ./test.sh -f tsim/tag/int.sim
-# ./test.sh -f tsim/tag/set.sim
+# jira ./test.sh -f tsim/tag/set.sim
 ./test.sh -f tsim/tag/smallint.sim
 ./test.sh -f tsim/tag/tinyint.sim
 

tests/script/test.sh

@@ -84,6 +84,7 @@ echo "SIM_DIR  : $SIM_DIR"
 echo "CODE_DIR : $CODE_DIR"
 echo "CFG_DIR  : $CFG_DIR"
 
+rm -rf $SIM_DIR/*
 rm -rf $LOG_DIR
 rm -rf $CFG_DIR
 

tests/script/tsim/insert/dupinsert.sim

+system sh/stop_dnodes.sh
+system sh/deploy.sh -n dnode1 -i 1
+system sh/exec.sh -n dnode1 -s start
+sql connect
+
+print =============== create database
+sql drop database if exists d0
+sql create database d0 keep 365000d,365000d,365000d
+sql use d0
+
+print =============== create super table
+sql create table if not exists stb (ts timestamp, c1 int unsigned, c2 double, c3 binary(10), c4 nchar(10), c5 double) tags (city binary(20),district binary(20));
+
+sql show stables
+if $rows != 1 then 
+  return -1
+endi
+
+print =============== create child table
+sql create table ct1 using stb tags("BeiJing", "ChaoYang")
+sql create table ct2 using stb tags("BeiJing", "HaiDian")
+sql create table ct3 using stb tags("BeiJing", "PingGu")
+sql create table ct4 using stb tags("BeiJing", "YanQing")
+
+sql show tables
+if $rows != 4 then 
+  print rows $rows != 4
+  return -1
+endi
+
+print =============== step 1 insert records into ct1 - taosd merge
+sql insert into ct1(ts,c1,c2) values('2022-05-03 16:59:00.010', 10, 20);
+sql insert into ct1(ts,c1,c2,c3,c4) values('2022-05-03 16:59:00.011', 11, NULL, 'binary', 'nchar');
+sql insert into ct1 values('2022-05-03 16:59:00.016', 16, NULL, NULL, 'nchar', NULL);
+sql insert into ct1 values('2022-05-03 16:59:00.016', 17, NULL, NULL, 'nchar', 170);
+sql insert into ct1 values('2022-05-03 16:59:00.020', 20, NULL, NULL, 'nchar', 200);
+sql insert into ct1 values('2022-05-03 16:59:00.016', 18, NULL, NULL, 'nchar', 180);
+sql insert into ct1 values('2022-05-03 16:59:00.021', 21, NULL, NULL, 'nchar', 210);
+sql insert into ct1 values('2022-05-03 16:59:00.022', 22, NULL, NULL, 'nchar', 220);
+
+print =============== step 2 insert records into ct1/ct2 - taosc merge for 2022-05-03 16:59:00.010
+sql insert into ct1(ts,c1,c2) values('2022-05-03 16:59:00.010', 10,10), ('2022-05-03 16:59:00.010',20,10.0), ('2022-05-03 16:59:00.010',30,NULL) ct2(ts,c1) values('2022-05-03 16:59:00.010',10), ('2022-05-03 16:59:00.010',20) ct1(ts,c2) values('2022-05-03 16:59:00.010',10), ('2022-05-03 16:59:00.010',100) ct1(ts,c3) values('2022-05-03 16:59:00.010','bin1'), ('2022-05-03 16:59:00.010','bin2') ct1(ts,c4,c5) values('2022-05-03 16:59:00.010',NULL,NULL), ('2022-05-03 16:59:00.010','nchar4',1000.01) ct2(ts,c2,c3,c4,c5) values('2022-05-03 16:59:00.010',20,'xkl','zxc',10);
+
+print =============== step 3 insert records into ct3
+sql insert into ct3(ts,c1,c5) values('2022-05-03 16:59:00.020', 10,10);
+sql insert into ct3(ts,c1,c5) values('2022-05-03 16:59:00.021', 10,10), ('2022-05-03 16:59:00.021',20,20.0);
+sql insert into ct3(ts,c1,c5) values('2022-05-03 16:59:00.022', 30,30), ('2022-05-03 16:59:00.022',40,40.0),('2022-05-03 16:59:00.022',50,50.0);
+sql insert into ct3(ts,c1,c5) values('2022-05-03 16:59:00.023', 60,60), ('2022-05-03 16:59:00.023',70,70.0),('2022-05-03 16:59:00.023',80,80.0), ('2022-05-03 16:59:00.023',90,90.0);
+sql insert into ct3(ts,c1,c5) values('2022-05-03 16:59:00.024', 100,100), ('2022-05-03 16:59:00.025',110,110.0),('2022-05-03 16:59:00.025',120,120.0), ('2022-05-03 16:59:00.025',130,130.0);
+sql insert into ct3(ts,c1,c5) values('2022-05-03 16:59:00.030', 140,140), ('2022-05-03 16:59:00.030',150,150.0),('2022-05-03 16:59:00.031',160,160.0), ('2022-05-03 16:59:00.030',170,170.0), ('2022-05-03 16:59:00.031',180,180.0);
+sql insert into ct3(ts,c1,c5) values('2022-05-03 16:59:00.042', 190,190), ('2022-05-03 16:59:00.041',200,200.0),('2022-05-03 16:59:00.040',210,210.0);
+sql insert into ct3(ts,c1,c5) values('2022-05-03 16:59:00.050', 220,220), ('2022-05-03 16:59:00.051',230,230.0),('2022-05-03 16:59:00.052',240,240.0);
+
+print =============== step 4 insert records into ct4
+sql insert into ct4(ts,c1,c3,c4) values('2022-05-03 16:59:00.020', 10,'b0','n0');
+sql insert into ct4(ts,c1,c3,c4) values('2022-05-03 16:59:00.021', 20,'b1','n1'), ('2022-05-03 16:59:00.021',30,'b2','n2');
+sql insert into ct4(ts,c1,c3,c4) values('2022-05-03 16:59:00.022', 40,'b3','n3'), ('2022-05-03 16:59:00.022',40,'b4','n4'),('2022-05-03 16:59:00.022',50,'b5','n5');
+sql insert into ct4(ts,c1,c3,c4) values('2022-05-03 16:59:00.023', 60,'b6','n6'), ('2022-05-03 16:59:00.024',70,'b7','n7'),('2022-05-03 16:59:00.024',80,'b8','n8'), ('2022-05-03 16:59:00.023',90,'b9','n9');
+
+
+
+print =============== step 5 query records of ct1 from memory(taosc and taosd merge)
+sql select * from ct1;
+print $data00 $data01 $data02 $data03 $data04 $data05
+print $data10 $data11 $data12 $data13 $data14 $data15
+print $data20 $data21 $data22 $data23 $data24 $data25
+print $data30 $data31 $data32 $data33 $data34 $data35
+print $data40 $data41 $data42 $data43 $data44 $data45
+print $data50 $data51 $data52 $data53 $data54 $data55
+
+
+
+print =============== step 6 query records of ct2 from memory(taosc and taosd merge)
+sql select * from ct2;
+print $data00 $data01 $data02 $data03 $data04 $data05
+
+if $rows != 1 then 
+  print rows $rows != 1
+  return -1
+endi
+
+
+
+print =============== step 7 query records of ct3 from memory
+sql select * from ct3;
+print $data00 $data01 $data02 $data03 $data04 $data05
+print $data10 $data11 $data12 $data13 $data14 $data15
+print $data20 $data21 $data22 $data23 $data24 $data25
+print $data30 $data31 $data32 $data33 $data34 $data35
+print $data40 $data41 $data42 $data43 $data44 $data45
+print $data50 $data51 $data52 $data53 $data54 $data55
+print $data60 $data61 $data62 $data63 $data64 $data65
+print $data70 $data71 $data72 $data73 $data74 $data75
+print $data80 $data81 $data82 $data83 $data84 $data85
+print $data90 $data91 $data92 $data93 $data94 $data95
+print $data[10][0] $data[10][1] $data[10][2] $data[10][3] $data[10][4] $data[10][5] 
+print $data[11][0] $data[11][1] $data[11][2] $data[11][3] $data[11][4] $data[11][5] 
+print $data[12][0] $data[12][1] $data[12][2] $data[12][3] $data[12][4] $data[12][5] 
+print $data[13][0] $data[13][1] $data[13][2] $data[13][3] $data[13][4] $data[13][5] 
+
+if $rows != 14 then 
+  print rows $rows != 14
+  return -1
+endi
+
+
+print =============== step 8 query records of ct4 from memory
+sql select * from ct4;
+print $data00 $data01 $data02 $data03 $data04 $data05
+print $data10 $data11 $data12 $data13 $data14 $data15
+print $data20 $data21 $data22 $data23 $data24 $data25
+print $data30 $data31 $data32 $data33 $data34 $data35
+print $data40 $data41 $data42 $data43 $data44 $data45
+
+
+if $rows != 5 then 
+  print rows $rows != 5
+  return -1
+endi
+
+
+#==================== reboot to trigger commit data to file
+system sh/exec.sh -n dnode1 -s stop -x SIGINT
+system sh/exec.sh -n dnode1 -s start
+
+
+print =============== step 9 query records of ct1 from file
+sql select * from ct1;
+print $data00 $data01 $data02 $data03 $data04 $data05
+print $data10 $data11 $data12 $data13 $data14 $data15
+print $data20 $data21 $data22 $data23 $data24 $data25
+print $data30 $data31 $data32 $data33 $data34 $data35
+print $data40 $data41 $data42 $data43 $data44 $data45
+print $data50 $data51 $data52 $data53 $data54 $data55
+
+if $rows != 6 then 
+  print rows $rows != 6
+  return -1
+endi
+
+
+print =============== step 10 query records of ct2 from file
+sql select * from ct2;
+print $data00 $data01 $data02 $data03 $data04 $data05
+
+if $rows != 1 then 
+  print rows $rows != 1
+  return -1
+endi
+
+
+print =============== step 11 query records of ct3 from file
+sql select * from ct3;
+print $data00 $data01 $data02 $data03 $data04 $data05
+print $data10 $data11 $data12 $data13 $data14 $data15
+print $data20 $data21 $data22 $data23 $data24 $data25
+print $data30 $data31 $data32 $data33 $data34 $data35
+print $data40 $data41 $data42 $data43 $data44 $data45
+print $data50 $data51 $data52 $data53 $data54 $data55
+print $data60 $data61 $data62 $data63 $data64 $data65
+print $data70 $data71 $data72 $data73 $data74 $data75
+print $data80 $data81 $data82 $data83 $data84 $data85
+print $data90 $data91 $data92 $data93 $data94 $data95
+print $data[10][0] $data[10][1] $data[10][2] $data[10][3] $data[10][4] $data[10][5] 
+print $data[11][0] $data[11][1] $data[11][2] $data[11][3] $data[11][4] $data[11][5] 
+print $data[12][0] $data[12][1] $data[12][2] $data[12][3] $data[12][4] $data[12][5] 
+print $data[13][0] $data[13][1] $data[13][2] $data[13][3] $data[13][4] $data[13][5] 
+
+
+print =============== step 12 query records of ct4 from file
+sql select * from ct4;
+print $data00 $data01 $data02 $data03 $data04 $data05
+print $data10 $data11 $data12 $data13 $data14 $data15
+print $data20 $data21 $data22 $data23 $data24 $data25
+print $data30 $data31 $data32 $data33 $data34 $data35
+print $data40 $data41 $data42 $data43 $data44 $data45
\ No newline at end of file

tests/script/tsim/insert/update0.sim

@@ -79,8 +79,8 @@ if $rows != 3 then
   return -1
 endi
 
-if $data01 != 103 then
-  print data01 $data01 != 103
+if $data01 != 303 then
+  print data01 $data01 != 303
   return -1
 endi
 
@@ -89,8 +89,8 @@ if $data11 != 80 then
   return -1
 endi
 
-if $data21 != 40 then
-  print data21 $data21 != 40
+if $data21 != 60 then
+  print data21 $data21 != 60
   return -1
 endi
 
@@ -138,8 +138,8 @@ if $rows != 3 then
   return -1
 endi
 
-if $data01 != 103 then
-  print data01 $data01 != 103
+if $data01 != 303 then
+  print data01 $data01 != 303
   return -1
 endi
 
@@ -148,8 +148,8 @@ if $data11 != 80 then
   return -1
 endi
 
-if $data21 != 40 then
-  print data21 $data21 != 40
+if $data21 != 60 then
+  print data21 $data21 != 60
   return -1
 endi
 
@@ -208,8 +208,8 @@ if $data01 != 10 then
   return -1
 endi
 
-if $data11 != 103 then
-  print data11 $data11 != 103
+if $data11 != 303 then
+  print data11 $data11 != 303
   return -1
 endi
 
@@ -218,8 +218,8 @@ if $data21 != NULL then
   return -1
 endi
 
-if $data31 != 40 then
-  print data31 $data31 != 40
+if $data31 != 60 then
+  print data31 $data31 != 60
   return -1
 endi
 

tests/script/tsim/insert/update1_sort_merge.sim

+system sh/stop_dnodes.sh
+system sh/deploy.sh -n dnode1 -i 1
+system sh/exec.sh -n dnode1 -s start
+sql connect
+
+print =============== create database
+sql drop database if exists d0
+sql create database d0 keep 365000d,365000d,365000d
+sql use d0
+
+print =============== create super table
+sql create table if not exists stb (ts timestamp, c1 int unsigned, c2 double, c3 binary(10), c4 nchar(10), c5 double) tags (city binary(20),district binary(20));
+
+sql show stables
+if $rows != 1 then 
+  return -1
+endi
+
+print =============== create child table
+sql create table ct1 using stb tags("BeiJing", "ChaoYang")
+sql create table ct2 using stb tags("BeiJing", "HaiDian")
+sql create table ct3 using stb tags("BeiJing", "PingGu")
+sql create table ct4 using stb tags("BeiJing", "YanQing")
+
+sql show tables
+if $rows != 4 then 
+  print rows $rows != 4
+  return -1
+endi
+
+print =============== step 1 insert records into ct1 - taosd merge
+sql insert into ct1(ts,c1,c2) values('2022-05-03 16:59:00.010', 10, 20);
+sql insert into ct1(ts,c1,c2,c3,c4) values('2022-05-03 16:59:00.011', 11, NULL, 'binary', 'nchar');
+sql insert into ct1 values('2022-05-03 16:59:00.016', 16, NULL, NULL, 'nchar', NULL);
+sql insert into ct1 values('2022-05-03 16:59:00.016', 17, NULL, NULL, 'nchar', 170);
+sql insert into ct1 values('2022-05-03 16:59:00.020', 20, NULL, NULL, 'nchar', 200);
+sql insert into ct1 values('2022-05-03 16:59:00.016', 18, NULL, NULL, 'nchar', 180);
+sql insert into ct1 values('2022-05-03 16:59:00.021', 21, NULL, NULL, 'nchar', 210);
+sql insert into ct1 values('2022-05-03 16:59:00.022', 22, NULL, NULL, 'nchar', 220);
+
+print =============== step 2 insert records into ct1/ct2 - taosc merge for 2022-05-03 16:59:00.010
+sql insert into ct1(ts,c1,c2) values('2022-05-03 16:59:00.010', 10,10), ('2022-05-03 16:59:00.010',20,10.0), ('2022-05-03 16:59:00.010',30,NULL) ct2(ts,c1) values('2022-05-03 16:59:00.010',10), ('2022-05-03 16:59:00.010',20) ct1(ts,c2) values('2022-05-03 16:59:00.010',10), ('2022-05-03 16:59:00.010',100) ct1(ts,c3) values('2022-05-03 16:59:00.010','bin1'), ('2022-05-03 16:59:00.010','bin2') ct1(ts,c4,c5) values('2022-05-03 16:59:00.010',NULL,NULL), ('2022-05-03 16:59:00.010','nchar4',1000.01) ct2(ts,c2,c3,c4,c5) values('2022-05-03 16:59:00.010',20,'xkl','zxc',10);
+
+print =============== step 3 insert records into ct3
+sql insert into ct3(ts,c1,c5) values('2022-05-03 16:59:00.020', 10,10);
+sql insert into ct3(ts,c1,c5) values('2022-05-03 16:59:00.021', 10,10), ('2022-05-03 16:59:00.021',20,20.0);
+sql insert into ct3(ts,c1,c5) values('2022-05-03 16:59:00.022', 30,30), ('2022-05-03 16:59:00.022',40,40.0),('2022-05-03 16:59:00.022',50,50.0);
+sql insert into ct3(ts,c1,c5) values('2022-05-03 16:59:00.023', 60,60), ('2022-05-03 16:59:00.023',70,70.0),('2022-05-03 16:59:00.023',80,80.0), ('2022-05-03 16:59:00.023',90,90.0);
+sql insert into ct3(ts,c1,c5) values('2022-05-03 16:59:00.024', 100,100), ('2022-05-03 16:59:00.025',110,110.0),('2022-05-03 16:59:00.025',120,120.0), ('2022-05-03 16:59:00.025',130,130.0);
+sql insert into ct3(ts,c1,c5) values('2022-05-03 16:59:00.030', 140,140), ('2022-05-03 16:59:00.030',150,150.0),('2022-05-03 16:59:00.031',160,160.0), ('2022-05-03 16:59:00.030',170,170.0), ('2022-05-03 16:59:00.031',180,180.0);
+sql insert into ct3(ts,c1,c5) values('2022-05-03 16:59:00.042', 190,190), ('2022-05-03 16:59:00.041',200,200.0),('2022-05-03 16:59:00.040',210,210.0);
+sql insert into ct3(ts,c1,c5) values('2022-05-03 16:59:00.050', 220,220), ('2022-05-03 16:59:00.051',230,230.0),('2022-05-03 16:59:00.052',240,240.0);
+
+print =============== step 4 insert records into ct4
+sql insert into ct4(ts,c1,c3,c4) values('2022-05-03 16:59:00.020', 10,'b0','n0');
+sql insert into ct4(ts,c1,c3,c4) values('2022-05-03 16:59:00.021', 20,'b1','n1'), ('2022-05-03 16:59:00.021',30,'b2','n2');
+sql insert into ct4(ts,c1,c3,c4) values('2022-05-03 16:59:00.022', 40,'b3','n3'), ('2022-05-03 16:59:00.022',40,'b4','n4'),('2022-05-03 16:59:00.022',50,'b5','n5');
+sql insert into ct4(ts,c1,c3,c4) values('2022-05-03 16:59:00.023', 60,'b6','n6'), ('2022-05-03 16:59:00.024',70,'b7','n7'),('2022-05-03 16:59:00.024',80,'b8','n8'), ('2022-05-03 16:59:00.023',90,'b9','n9');
+
+
+
+print =============== step 5 query records of ct1 from memory(taosc and taosd merge)
+sql select * from ct1;
+print $data00 $data01 $data02 $data03 $data04 $data05
+print $data10 $data11 $data12 $data13 $data14 $data15
+print $data20 $data21 $data22 $data23 $data24 $data25
+print $data30 $data31 $data32 $data33 $data34 $data35
+print $data40 $data41 $data42 $data43 $data44 $data45
+print $data50 $data51 $data52 $data53 $data54 $data55
+
+if $rows != 6 then 
+  print rows $rows != 6
+  return -1
+endi
+
+if $data01 != 30 then
+  print data01 $data01 != 30
+  return -1
+endi
+
+if $data02 != 100.000000000 then
+  print data02 $data02 != 100.000000000
+  return -1
+endi
+
+if $data03 != bin2 then
+  print data03 $data03 != bin2
+  return -1
+endi
+
+if $data04 != nchar4 then
+  print data04 $data04 != nchar4
+  return -1
+endi
+
+if $data05 != 1000.010000000 then
+  print data05 $data05 != 1000.010000000
+  return -1
+endi
+
+if $data11 != 11 then
+  print data11 $data11 != 11
+  return -1
+endi
+
+if $data12 != NULL then
+  print data12 $data12 != NULL
+  return -1
+endi
+
+if $data13 != binary then
+  print data13 $data13 != binary
+  return -1
+endi
+
+if $data14 != nchar then
+  print data14 $data14 != nchar
+  return -1
+endi
+
+if $data15 != NULL then
+  print data15 $data15 != NULL
+  return -1
+endi
+
+if $data51 != 22 then
+  print data51 $data51 != 22
+  return -1
+endi
+
+if $data52 != NULL then
+  print data52 $data52 != NULL
+  return -1
+endi
+
+if $data53 != NULL then
+  print data53 $data53 != NULL
+  return -1
+endi
+
+if $data54 != nchar then
+  print data54 $data54 != nchar
+  return -1
+endi
+
+if $data55 != 220.000000000 then
+  print data55 $data55 != 220.000000000
+  return -1
+endi
+
+
+print =============== step 6 query records of ct2 from memory(taosc and taosd merge)
+sql select * from ct2;
+print $data00 $data01 $data02 $data03 $data04 $data05
+
+if $rows != 1 then 
+  print rows $rows != 1
+  return -1
+endi
+
+if $data01 != 20 then
+  print data01 $data01 != 20
+  return -1
+endi
+
+if $data02 != 20.000000000 then
+  print data02 $data02 != 20.000000000
+  return -1
+endi
+
+if $data03 != xkl then
+  print data03 $data03 != xkl
+  return -1
+endi
+
+if $data04 != zxc then
+  print data04 $data04 != zxc
+  return -1
+endi
+
+if $data05 != 10.000000000 then
+  print data05 $data05 != 10.000000000
+  return -1
+endi
+
+print =============== step 7 query records of ct3 from memory
+sql select * from ct3;
+print $data00 $data01 $data02 $data03 $data04 $data05
+print $data10 $data11 $data12 $data13 $data14 $data15
+print $data20 $data21 $data22 $data23 $data24 $data25
+print $data30 $data31 $data32 $data33 $data34 $data35
+print $data40 $data41 $data42 $data43 $data44 $data45
+print $data50 $data51 $data52 $data53 $data54 $data55
+print $data60 $data61 $data62 $data63 $data64 $data65
+print $data70 $data71 $data72 $data73 $data74 $data75
+print $data80 $data81 $data82 $data83 $data84 $data85
+print $data90 $data91 $data92 $data93 $data94 $data95
+print $data[10][0] $data[10][1] $data[10][2] $data[10][3] $data[10][4] $data[10][5] 
+print $data[11][0] $data[11][1] $data[11][2] $data[11][3] $data[11][4] $data[11][5] 
+print $data[12][0] $data[12][1] $data[12][2] $data[12][3] $data[12][4] $data[12][5] 
+print $data[13][0] $data[13][1] $data[13][2] $data[13][3] $data[13][4] $data[13][5] 
+
+if $rows != 14 then 
+  print rows $rows != 14
+  return -1
+endi
+
+if $data01 != 10 then
+  print data01 $data01 != 10
+  return -1
+endi
+
+if $data11 != 20 then
+  print data11 $data1 != 20
+  return -1
+endi
+
+if $data21 != 50 then
+  print data21 $data21 != 50
+  return -1
+endi
+
+if $data31 != 90 then
+  print data31 $data31 != 90
+  return -1
+endi
+
+if $data41 != 100 then
+  print data41 $data41 != 100
+  return -1
+endi
+
+if $data51 != 130 then
+  print data51 $data51 != 130
+  return -1
+endi
+
+if $data61 != 170 then
+  print data61 $data61 != 170
+  return -1
+endi
+
+if $data71 != 180 then
+  print data71 $data71 != 180
+  return -1
+endi
+
+if $data81 != 210 then
+  print data81 $data81 != 210
+  return -1
+endi
+
+if $data91 != 200 then
+  print data91 $data91 != 200
+  return -1
+endi
+
+if $data[10][1] != 190 then
+  print data[10][1] $data[10][1] != 190
+  return -1
+endi
+
+if $data[11][1] != 220 then
+  print data[11][1] $data[11][1] != 220
+  return -1
+endi
+
+if $data[12][1] != 230 then
+  print data[12][1] $data[12][1] != 230
+  return -1
+endi
+
+if $data[13][1] != 240 then
+  print data[13][1] $data[13][1] != 240
+  return -1
+endi
+
+if $data05 != 10.000000000 then
+  print data05 $data05 != 10.000000000
+  return -1
+endi
+
+if $data15 != 20.000000000 then
+  print data15 $data5 != 20.000000000
+  return -1
+endi
+
+if $data25 != 50.000000000 then
+  print data25 $data25 != 50.000000000
+  return -1
+endi
+
+if $data35 != 90.000000000 then
+  print data35 $data35 != 90.000000000
+  return -1
+endi
+
+if $data45 != 100.000000000 then
+  print data45 $data45 != 100.000000000
+  return -1
+endi
+
+if $data55 != 130.000000000 then
+  print data55 $data55 != 130.000000000
+  return -1
+endi
+
+if $data65 != 170.000000000 then
+  print data65 $data65 != 170.000000000
+  return -1
+endi
+
+if $data75 != 180.000000000 then
+  print data75 $data75 != 180.000000000
+  return -1
+endi
+
+if $data85 != 210.000000000 then
+  print data85 $data85 != 210.000000000
+  return -1
+endi
+
+if $data95 != 200.000000000 then
+  print data95 $data95 != 200.000000000
+  return -1
+endi
+
+if $data[10][5] != 190.000000000 then
+  print data[10][5] $data[10][5] != 190.000000000
+  return -1
+endi
+
+if $data[11][5] != 220.000000000 then
+  print data[11][5] $data[11][5] != 220.000000000
+  return -1
+endi
+
+if $data[12][5] != 230.000000000 then
+  print data[12][5] $data[12][5] != 230.000000000
+  return -1
+endi
+
+if $data[13][5] != 240.000000000 then
+  print data[13][5] $data[13][5] != 240.000000000
+  return -1
+endi
+
+
+print =============== step 8 query records of ct4 from memory
+sql select * from ct4;
+print $data00 $data01 $data02 $data03 $data04 $data05
+print $data10 $data11 $data12 $data13 $data14 $data15
+print $data20 $data21 $data22 $data23 $data24 $data25
+print $data30 $data31 $data32 $data33 $data34 $data35
+print $data40 $data41 $data42 $data43 $data44 $data45
+
+
+if $rows != 5 then 
+  print rows $rows != 5
+  return -1
+endi
+
+if $data01 != 10 then
+  print data01 $data01 != 10
+  return -1
+endi
+
+if $data11 != 30 then
+  print data11 $data11 != 30
+  return -1
+endi
+
+if $data21 != 50 then
+  print data21 $data21 != 50
+  return -1
+endi
+
+if $data31 != 90 then
+  print data31 $data31 != 90
+  return -1
+endi
+
+if $data41 != 80 then
+  print data41 $data41 != 80
+  return -1
+endi
+
+if $data03 != b0 then
+  print data03 $data03 != b0
+  return -1
+endi
+
+if $data13 != b2 then
+  print data13 $data13 != b2
+  return -1
+endi
+
+if $data23 != b5 then
+  print data23 $data23 != b5
+  return -1
+endi
+
+if $data33 != b9 then
+  print data33 $data33 != b9
+  return -1
+endi
+
+if $data43 != b8  then
+  print data43 $data43 != b8
+  return -1
+endi
+
+if $data04 != n0 then
+  print data04 $data04 != n0
+  return -1
+endi
+
+if $data14 != n2 then
+  print data14 $data14 != n2
+  return -1
+endi
+
+if $data24 != n5 then
+  print data24 $data24 != n5
+  return -1
+endi
+
+if $data34 != n9 then
+  print data34 $data34 != n9
+  return -1
+endi
+
+if $data44 != n8 then
+  print data44 $data44 != n8
+  return -1
+endi
+
+#==================== reboot to trigger commit data to file
+system sh/exec.sh -n dnode1 -s stop -x SIGINT
+system sh/exec.sh -n dnode1 -s start
+
+
+
+print =============== step 9 query records of ct1 from file
+sql select * from ct1;
+print $data00 $data01 $data02 $data03 $data04 $data05
+print $data10 $data11 $data12 $data13 $data14 $data15
+print $data20 $data21 $data22 $data23 $data24 $data25
+print $data30 $data31 $data32 $data33 $data34 $data35
+print $data40 $data41 $data42 $data43 $data44 $data45
+print $data50 $data51 $data52 $data53 $data54 $data55
+
+if $rows != 6 then 
+  print rows $rows != 6
+  return -1
+endi
+
+if $data01 != 30 then
+  print data01 $data01 != 30
+  return -1
+endi
+
+if $data02 != 100.000000000 then
+  print data02 $data02 != 100.000000000
+  return -1
+endi
+
+if $data03 != bin2 then
+  print data03 $data03 != bin2
+  return -1
+endi
+
+if $data04 != nchar4 then
+  print data04 $data04 != nchar4
+  return -1
+endi
+
+if $data05 != 1000.010000000 then
+  print data05 $data05 != 1000.010000000
+  return -1
+endi
+
+if $data11 != 11 then
+  print data11 $data11 != 11
+  return -1
+endi
+
+if $data12 != NULL then
+  print data12 $data12 != NULL
+  return -1
+endi
+
+if $data13 != binary then
+  print data13 $data13 != binary
+  return -1
+endi
+
+if $data14 != nchar then
+  print data14 $data14 != nchar
+  return -1
+endi
+
+if $data15 != NULL then
+  print data15 $data15 != NULL
+  return -1
+endi
+
+if $data51 != 22 then
+  print data51 $data51 != 22
+  return -1
+endi
+
+if $data52 != NULL then
+  print data52 $data52 != NULL
+  return -1
+endi
+
+if $data53 != NULL then
+  print data53 $data53 != NULL
+  return -1
+endi
+
+if $data54 != nchar then
+  print data54 $data54 != nchar
+  return -1
+endi
+
+if $data55 != 220.000000000 then
+  print data55 $data55 != 220.000000000
+  return -1
+endi
+
+
+print =============== step 10 query records of ct2 from file
+sql select * from ct2;
+print $data00 $data01 $data02 $data03 $data04 $data05
+
+if $rows != 1 then 
+  print rows $rows != 1
+  return -1
+endi
+
+if $data01 != 20 then
+  print data01 $data01 != 20
+  return -1
+endi
+
+if $data02 != 20.000000000 then
+  print data02 $data02 != 20.000000000
+  return -1
+endi
+
+if $data03 != xkl then
+  print data03 $data03 != xkl
+  return -1
+endi
+
+if $data04 != zxc then
+  print data04 $data04 != zxc
+  return -1
+endi
+
+if $data05 != 10.000000000 then
+  print data05 $data05 != 10.000000000
+  return -1
+endi
+
+print =============== step 11 query records of ct3 from file
+sql select * from ct3;
+print $data00 $data01 $data02 $data03 $data04 $data05
+print $data10 $data11 $data12 $data13 $data14 $data15
+print $data20 $data21 $data22 $data23 $data24 $data25
+print $data30 $data31 $data32 $data33 $data34 $data35
+print $data40 $data41 $data42 $data43 $data44 $data45
+print $data50 $data51 $data52 $data53 $data54 $data55
+print $data60 $data61 $data62 $data63 $data64 $data65
+print $data70 $data71 $data72 $data73 $data74 $data75
+print $data80 $data81 $data82 $data83 $data84 $data85
+print $data90 $data91 $data92 $data93 $data94 $data95
+print $data[10][0] $data[10][1] $data[10][2] $data[10][3] $data[10][4] $data[10][5] 
+print $data[11][0] $data[11][1] $data[11][2] $data[11][3] $data[11][4] $data[11][5] 
+print $data[12][0] $data[12][1] $data[12][2] $data[12][3] $data[12][4] $data[12][5] 
+print $data[13][0] $data[13][1] $data[13][2] $data[13][3] $data[13][4] $data[13][5] 
+
+if $rows != 14 then 
+  print rows $rows != 14
+  return -1
+endi
+
+if $data01 != 10 then
+  print data01 $data01 != 10
+  return -1
+endi
+
+if $data11 != 20 then
+  print data11 $data1 != 20
+  return -1
+endi
+
+if $data21 != 50 then
+  print data21 $data21 != 50
+  return -1
+endi
+
+if $data31 != 90 then
+  print data31 $data31 != 90
+  return -1
+endi
+
+if $data41 != 100 then
+  print data41 $data41 != 100
+  return -1
+endi
+
+if $data51 != 130 then
+  print data51 $data51 != 130
+  return -1
+endi
+
+if $data61 != 170 then
+  print data61 $data61 != 170
+  return -1
+endi
+
+if $data71 != 180 then
+  print data71 $data71 != 180
+  return -1
+endi
+
+if $data81 != 210 then
+  print data81 $data81 != 210
+  return -1
+endi
+
+if $data91 != 200 then
+  print data91 $data91 != 200
+  return -1
+endi
+
+if $data[10][1] != 190 then
+  print data[10][1] $data[10][1] != 190
+  return -1
+endi
+
+if $data[11][1] != 220 then
+  print data[11][1] $data[11][1] != 220
+  return -1
+endi
+
+if $data[12][1] != 230 then
+  print data[12][1] $data[12][1] != 230
+  return -1
+endi
+
+if $data[13][1] != 240 then
+  print data[13][1] $data[13][1] != 240
+  return -1
+endi
+
+if $data05 != 10.000000000 then
+  print data05 $data05 != 10.000000000
+  return -1
+endi
+
+if $data15 != 20.000000000 then
+  print data15 $data5 != 20.000000000
+  return -1
+endi
+
+if $data25 != 50.000000000 then
+  print data25 $data25 != 50.000000000
+  return -1
+endi
+
+if $data35 != 90.000000000 then
+  print data35 $data35 != 90.000000000
+  return -1
+endi
+
+if $data45 != 100.000000000 then
+  print data45 $data45 != 100.000000000
+  return -1
+endi
+
+if $data55 != 130.000000000 then
+  print data55 $data55 != 130.000000000
+  return -1
+endi
+
+if $data65 != 170.000000000 then
+  print data65 $data65 != 170.000000000
+  return -1
+endi
+
+if $data75 != 180.000000000 then
+  print data75 $data75 != 180.000000000
+  return -1
+endi
+
+if $data85 != 210.000000000 then
+  print data85 $data85 != 210.000000000
+  return -1
+endi
+
+if $data95 != 200.000000000 then
+  print data95 $data95 != 200.000000000
+  return -1
+endi
+
+if $data[10][5] != 190.000000000 then
+  print data[10][5] $data[10][5] != 190.000000000
+  return -1
+endi
+
+if $data[11][5] != 220.000000000 then
+  print data[11][5] $data[11][5] != 220.000000000
+  return -1
+endi
+
+if $data[12][5] != 230.000000000 then
+  print data[12][5] $data[12][5] != 230.000000000
+  return -1
+endi
+
+if $data[13][5] != 240.000000000 then
+  print data[13][5] $data[13][5] != 240.000000000
+  return -1
+endi
+
+
+print =============== step 12 query records of ct4 from file
+sql select * from ct4;
+print $data00 $data01 $data02 $data03 $data04 $data05
+print $data10 $data11 $data12 $data13 $data14 $data15
+print $data20 $data21 $data22 $data23 $data24 $data25
+print $data30 $data31 $data32 $data33 $data34 $data35
+print $data40 $data41 $data42 $data43 $data44 $data45
+
+
+if $rows != 5 then 
+  print rows $rows != 5
+  return -1
+endi
+
+if $data01 != 10 then
+  print data01 $data01 != 10
+  return -1
+endi
+
+if $data11 != 30 then
+  print data11 $data11 != 30
+  return -1
+endi
+
+if $data21 != 50 then
+  print data21 $data21 != 50
+  return -1
+endi
+
+if $data31 != 90 then
+  print data31 $data31 != 90
+  return -1
+endi
+
+if $data41 != 80 then
+  print data41 $data41 != 80
+  return -1
+endi
+
+if $data03 != b0 then
+  print data03 $data03 != b0
+  return -1
+endi
+
+if $data13 != b2 then
+  print data13 $data13 != b2
+  return -1
+endi
+
+if $data23 != b5 then
+  print data23 $data23 != b5
+  return -1
+endi
+
+if $data33 != b9 then
+  print data33 $data33 != b9
+  return -1
+endi
+
+if $data43 != b8  then
+  print data43 $data43 != b8
+  return -1
+endi
+
+if $data04 != n0 then
+  print data04 $data04 != n0
+  return -1
+endi
+
+if $data14 != n2 then
+  print data14 $data14 != n2
+  return -1
+endi
+
+if $data24 != n5 then
+  print data24 $data24 != n5
+  return -1
+endi
+
+if $data34 != n9 then
+  print data34 $data34 != n9
+  return -1
+endi
+
+if $data44 != n8 then
+  print data44 $data44 != n8
+  return -1
+endi
\ No newline at end of file

tests/script/tsim/parser/auto_create_tb.sim

@@ -282,7 +282,7 @@ if $rows != 2 then
   return -1
 endi
 
-sql insert into tick_000001 ('ts', 'last_prc', 'volume', 'amount', 'oi', 'bid_prc1', 'ask_prc1') using tick tags (000001, Stocks) VALUES (1546391700000, 0.000000, 0, 0.000000, 0, 0.000000, 10.320000);
+sql insert into tick_000001 (ts, last_prc, volume, amount, oi, bid_prc1, ask_prc1) using tick tags ('000001', 'Stocks') VALUES (1546391700000, 0.000000, 0, 0.000000, 0, 0.000000, 10.320000);
 sql select tbname from tick
 if $rows != 1 then
    return -1

tests/script/tsim/parser/join.sim

@@ -233,8 +233,15 @@ endi
 
 print 1
 #select + where condition + interval query
-sql select count(join_tb1.*) from $tb1 , $tb2 where $ts1 = $ts2 and join_tb1.ts >= 100000 and join_tb0.c7 = true interval(10a) order by join_tb0.ts desc;
+print select count(join_tb1.*) from $tb1 , $tb2 where $ts1 = $ts2 and join_tb1.ts >= 100000 and join_tb0.c7 = true interval(10a) order by _wstart asc;
+sql select count(join_tb1.*) from $tb1 , $tb2 where $ts1 = $ts2 and join_tb1.ts >= 100000 and join_tb0.c7 = true interval(10a) order by _wstart asc;
+$val = 100
+if $rows != $val then
+  return -1
+endi
 
+print select count(join_tb1.*) from $tb1 , $tb2 where $ts1 = $ts2 and join_tb1.ts >= 100000 and join_tb0.c7 = true interval(10a) order by _wstart desc;
+sql select count(join_tb1.*) from $tb1 , $tb2 where $ts1 = $ts2 and join_tb1.ts >= 100000 and join_tb0.c7 = true interval(10a) order by _wstart desc;
 $val = 100
 if $rows != $val then
   return -1

tests/script/tsim/parser/join_manyblocks.sim

@@ -73,8 +73,6 @@ while $i < $tbNum
   $tstart = 100000
 endw
 
-sleep 100
-
 print ===============join_manyblocks.sim
 print ==============> td-3313
 sql select join_mt0.ts,join_mt0.ts,join_mt0.t1 from join_mt0, join_mt1 where join_mt0.ts=join_mt1.ts and join_mt0.t1=join_mt1.t1;

tests/script/tsim/parser/last_groupby.sim

@@ -4,14 +4,11 @@ system sh/exec.sh -n dnode1 -s start
 sql connect
 
 print ======================== dnode1 start
-
 $db = testdb
-
 sql create database $db
 sql use $db
 
 sql create stable st2 (ts timestamp, f1 int, f2 float, f3 double, f4 bigint, f5 smallint, f6 tinyint, f7 bool, f8 binary(10), f9 nchar(10)) tags (id1 int, id2 float, id3 nchar(10), id4 double, id5 smallint, id6 bigint, id7 binary(10))
-
 sql create table tb1 using st2 tags (1,1.0,"1",1.0,1,1,"1");
  
 sql insert into tb1 values (now-200s,1,1.0,1.0,1,1,1,true,"1","1")
@@ -23,16 +20,13 @@ sql insert into tb1 values (now+300s,4,4.0,4.0,4,4,4,true,"4","4")
 sql insert into tb1 values (now+400s,4,4.0,4.0,4,4,4,true,"4","4")
 sql insert into tb1 values (now+500s,4,4.0,4.0,4,4,4,true,"4","4")
 
-sql select f1,last(*) from st2 group by f1;
-
+sql select f1, last(*) from st2 group by f1 order by f1;
 if $rows != 4 then
   return -1
 endi
-
 if $data00 != 1 then 
   return -1
 endi
-
 if $data02 != 1 then 
   print $data02
   return -1
@@ -59,15 +53,13 @@ if $data09 != 1 then
   return -1
 endi
 
-sql select f1,last(f1,st2.*) from st2 group by f1;
+sql select f1, last(f1,st2.*) from st2 group by f1 order by f1;
 if $rows != 4 then
   return -1
 endi
-
 if $data00 != 1 then 
   return -1
 endi
-
 if $data01 != 1 then 
   return -1
 endi

tests/script/tsim/parser/like.sim

@@ -5,7 +5,6 @@ sql connect
 
 print ======================== dnode1 start
 
-
 $db = testdb
 sql drop database if exists $db
 sql create database $db cachemodel 'last_value'
@@ -32,7 +31,6 @@ if $rows != 2 then
   return -1
 endi
 
-
 sql select b from $table1 where b like 'table\_name'
 if $rows != 1 then
   return -1

tests/script/tsim/parser/limit1.sim

@@ -18,7 +18,7 @@ $stb = $stbPrefix . $i
 
 sql drop database $db -x step1
 step1:
-sql create database $db 
+sql create database $db cache 16
 print ====== create tables
 sql use $db
 sql create table $stb (ts timestamp, c1 int, c2 bigint, c3 float, c4 double, c5 smallint, c6 tinyint, c7 bool, c8 binary(10), c9 nchar(10)) tags(t1 int)
@@ -57,11 +57,10 @@ run tsim/parser/limit1_stb.sim
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 
 run tsim/parser/limit1_tb.sim
 run tsim/parser/limit1_stb.sim
 
-system sh/exec.sh -n dnode1 -s stop -x SIGINT
+system sh/exec.sh -n dnode1 -s stop -x SIGINT
\ No newline at end of file

tests/script/tsim/parser/limit1_stb.sim

-sleep 100
 sql connect
 
 $dbPrefix = lm1_db

tests/script/tsim/parser/limit1_tb.sim

-sleep 100
 sql connect
 
 $dbPrefix = lm1_db

tests/script/tsim/parser/limit1_tblocks100.sim

-system sh/stop_dnodes.sh
-system sh/deploy.sh -n dnode1 -i 1
-system sh/exec.sh -n dnode1 -s start
-sql connect
-
-$dbPrefix = lm1_db
-$tbPrefix = lm1_tb
-$stbPrefix = lm1_stb
-$tbNum = 10
-$rowNum = 10000
-$totalNum = $tbNum * $rowNum
-$ts0 = 1537146000000
-$delta = 600000
-print ========== limit1.sim
-$i = 0
-$db = $dbPrefix . $i
-$stb = $stbPrefix . $i
-
-sql drop database $db -x step1
-step1:
-sql create database $db cache 16
-print ====== create tables
-sql use $db
-sql create table $stb (ts timestamp, c1 int, c2 bigint, c3 float, c4 double, c5 smallint, c6 tinyint, c7 bool, c8 binary(10), c9 nchar(10)) tags(t1 int)
-
-$i = 0
-$ts = $ts0
-$halfNum = $tbNum / 2
-while $i < $halfNum
-  $tbId = $i + $halfNum
-  $tb = $tbPrefix . $i
-  $tb1 = $tbPrefix . $tbId
-  sql create table $tb using $stb tags( $i )
-  sql create table $tb1 using $stb tags( $tbId )
- 
-  $x = 0
-  while $x < $rowNum
-    $xs = $x * $delta
-    $ts = $ts0 + $xs
-    $c = $x / 10
-    $c = $c * 10
-    $c = $x - $c
-    $binary = 'binary . $c
-    $binary = $binary . '
-    $nchar = 'nchar . $c
-    $nchar = $nchar . '
-    sql insert into $tb values ( $ts , $c , $c , $c , $c , $c , $c , true, $binary , $nchar )  $tb1 values ( $ts , $c , NULL , $c , NULL , $c , $c , true, $binary , $nchar )
-    $x = $x + 1
-  endw 
-
-  $i = $i + 1
-endw 
-print ====== tables created
-
-run tsim/parser/limit1_tb.sim
-run tsim/parser/limit1_stb.sim
-
-print ================== restart server to commit data into disk
-system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 500
-system sh/exec.sh -n dnode1 -s start
-print ================== server restart completed
-
-run tsim/parser/limit1_tb.sim
-run tsim/parser/limit1_stb.sim
-
-system sh/exec.sh -n dnode1 -s stop -x SIGINT

tests/script/tsim/parser/limit2.sim

 system sh/stop_dnodes.sh
-
 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 1
-system sh/cfg.sh -n dnode1 -c rowsInFileBlock -v 255
 system sh/exec.sh -n dnode1 -s start
-sleep 100
 sql connect
 
 $dbPrefix = lm2_db
@@ -69,10 +65,8 @@ print ====== tables created
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 500
+sleep 100
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 
 run tsim/parser/limit2_query.sim
-
-system sh/exec.sh -n dnode1 -s stop -x SIGINT
\ No newline at end of file

tests/script/tsim/parser/limit2_query.sim

-sleep 100
 sql connect
 
 $dbPrefix = lm2_db
@@ -24,8 +23,11 @@ sql use $db
 ##### aggregation on stb with 6 tags + where + group by + limit offset
 $val1 = 1
 $val2 = $tbNum - 1
-sql select count(*) from $stb where t1 > $val1 and t1 < $val2 group by t1, t2, t3, t4, t5, t6 order by t1 asc limit 1 offset 0
+print select count(*) from $stb where t1 > $val1 and t1 < $val2 group by t1, t2, t3, t4, t5, t6 order by t1 asc limit 1 offset 0
+sql select count(*), t1, t2, t3, t4, t5, t6 from $stb where t1 > $val1 and t1 < $val2 group by t1, t2, t3, t4, t5, t6 order by t1 asc limit 1 offset 0
 $val = $tbNum - 3
+
+print $rows $val
 if $rows != $val then
   return -1
 endi

tests/script/tsim/parser/limit2_tblocks100.sim

-system sh/stop_dnodes.sh
-
-system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 1
-system sh/cfg.sh -n dnode1 -c rowsInFileBlock -v 255
-system sh/exec.sh -n dnode1 -s start
-sleep 100
-sql connect
-
-$dbPrefix = lm2_db
-$tbPrefix = lm2_tb
-$stbPrefix = lm2_stb
-$tbNum = 10
-$rowNum = 10000
-$totalNum = $tbNum * $rowNum
-$ts0 = 1537146000000
-$delta = 600000
-$tsu = $rowNum * $delta
-$tsu = $tsu - $delta
-$tsu = $tsu + $ts0
-
-print ========== limit2.sim
-$i = 0
-$db = $dbPrefix . $i
-$stb = $stbPrefix . $i
-
-sql drop database $db -x step1
-step1:
-sql create database $db tblocks 100 
-print ====== create tables
-sql use $db
-sql create table $stb (ts timestamp, c1 int, c2 bigint, c3 float, c4 double, c5 smallint, c6 tinyint, c7 bool, c8 binary(10), c9 nchar(10)) tags(t1 int, t2 nchar(20), t3 binary(20), t4 bigint, t5 smallint, t6 double)
-
-$i = 0
-$ts = $ts0
-$halfNum = $tbNum / 2
-while $i < $halfNum
-  $i1 = $i + $halfNum
-  $tb = $tbPrefix . $i
-  $tb1 = $tbPrefix . $i1
-  $tgstr = 'tb . $i
-  $tgstr = $tgstr . '
-  $tgstr1 = 'tb . $i1
-  $tgstr1 = $tgstr1 . '
-  sql create table $tb using $stb tags( $i , $tgstr , $tgstr , $i , $i , $i )
-  sql create table $tb1 using $stb tags( $i1 , $tgstr1 , $tgstr1 , $i , $i , $i )
- 
-  $x = 0
-  while $x < $rowNum
-    $xs = $x * $delta
-    $ts = $ts0 + $xs
-    $c = $x / 10
-    $c = $c * 10
-    $c = $x - $c
-    $binary = 'binary . $c
-    $binary = $binary . '
-    $nchar = 'nchar . $c
-    $nchar = $nchar . '
-    sql insert into $tb values ( $ts , $c , $c , $c , $c , $c , $c , true, $binary , $nchar ) 
-    sql insert into $tb1 values ( $ts , $c , NULL , $c , NULL , $c , $c , true, $binary , $nchar ) 
-    $x = $x + 1
-  endw 
-
-  $i = $i + 1
-endw 
-print ====== tables created
-
-#run tsim/parser/limit2_query.sim
-
-print ================== restart server to commit data into disk
-system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 100
-system sh/exec.sh -n dnode1 -s start
-print ================== server restart completed
-
-run tsim/parser/limit2_query.sim

tests/script/tsim/parser/limit_stb.sim

-sleep 100
 sql connect
 
 $dbPrefix = lm_db

tests/script/tsim/parser/limit_tb.sim

-sleep 100
 sql connect
 
 $dbPrefix = lm_db

tests/script/tsim/parser/line_insert.sim

@@ -43,7 +43,7 @@ endi
 #print =============== clear
 sql drop database $db
 sql show databases
-if $rows != 0 then 
+if $rows != 2 then 
   return -1
 endi
 

tests/script/tsim/parser/mixed_blocks.sim

@@ -54,7 +54,6 @@ sql show databases
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 
@@ -76,7 +75,7 @@ while $x < $rowNum
 endw 
 
 #### query a STable and using where clause to filter out all the data from tb2 and make the query only return first/last of tb1
-sql select first(ts,c1), last(ts,c1), spread(c1) from $stb where c1 > 0 group by t1
+sql select first(ts,c1), last(ts,c1), spread(c1), t1 from $stb where c1 > 0 group by t1
 if $rows != 1 then
   return -1
 endi
@@ -99,7 +98,7 @@ if $data05 != 1 then
   return -1
 endi
 
-sql select max(c1), min(c1), sum(c1), avg(c1), count(c1) from $stb where c1 > 0 group by t1
+sql select max(c1), min(c1), sum(c1), avg(c1), count(c1), t1 from $stb where c1 > 0 group by t1
 if $rows != 1 then
   return -1
 endi
@@ -149,7 +148,6 @@ sql insert into t2 values('2020-1-1 1:5:1', 99);
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 sql select ts from m1 where ts='2020-1-1 1:5:1'

tests/script/tsim/parser/nchar.sim

@@ -228,7 +228,8 @@ sql_error select avg(tbcol) from $mt where tbcol1 = 1 group by tgcol
 sql_error select sum(tbcol) from $mt where tbcol1 = 1 group by tgcol 
 sql_error select min(tbcol) from $mt where tbcol1 = 1 group by tgcol 
 sql_error select max(tbcol) from $mt where tbcol1 = 1 group by tgcol  
-sql select first(tbcol) from $mt where tbcol1 = 1 group by tgcol 
+
+sql select first(tbcol), tgcol from $mt where tbcol1 = 1 group by tgcol order by tgcol
 if $rows != 2 then
   return -1
 endi
@@ -244,7 +245,8 @@ endi
 if $data11 != 1 then
   return -1
 endi
-sql select last(tbcol) from $mt where tbcol1 = 1 group by tgcol
+
+sql select last(tbcol), tgcol from $mt where tbcol1 = 1 group by tgcol order by tgcol
 if $rows != 2 then
   return -1
 endi
@@ -265,6 +267,7 @@ sql create table stbb (ts timestamp, c1 nchar(5)) tags (t1 int)
 sql create table tbb1 using stbb tags(1)
 sql insert into tbb1 values ('2018-09-17 09:00:00', '涛思')
 sql insert into tbb1 values ('2018-09-17 09:00:01', 'insrt')
+
 sql select * from tbb1 order by ts asc
 if $rows != 2 then
   return -1

tests/script/tsim/parser/nestquery.sim

@@ -53,8 +53,6 @@ while $i < $half
   $i = $i + 1
 endw
 
-sleep 100
-
 $i = 1
 $tb = $tbPrefix . $i
 
@@ -63,7 +61,6 @@ sql select count(*) from (select count(*) from nest_mt0)
 if $rows != 1 then
  return -1
 endi
-
 if $data00 != 1 then
   return -1
 endi
@@ -72,35 +69,31 @@ sql select count(*) from (select count(*) from nest_mt0 group by tbname)
 if $rows != 1 then
   return -1
 endi
-
 if $data00 != 10 then
   return -1
 endi
 
-sql select count(*) from (select count(*) from nest_mt0 interval(10h) group by tbname)
+sql select count(*) from (select count(*) from nest_mt0 partition by tbname interval(10h) )
 if $rows != 1 then
   return -1
 endi
-
 if $data00 != 170 then
   return -1
 endi
 
-sql select sum(a) from (select count(*) a from nest_mt0 interval(10h) group by tbname)
+sql select sum(a) from (select count(*) a from nest_mt0 partition by tbname interval(10h))
 if $rows != 1 then
   return -1
 endi
-
 if $data00 != 100000 then
   return -1
 endi
 
 print =================> alias name test
-sql select ts from (select count(*) a from nest_tb0 interval(1h))
+sql select ts from (select _wstart as ts, count(*) a from nest_tb0 interval(1h))
 if $rows != 167 then
   return -1
 endi
-
 if $data00 != @20-09-15 00:00:00.000@ then
   return -1
 endi
@@ -109,7 +102,6 @@ sql select count(a) from (select count(*) a from nest_tb0 interval(1h))
 if $rows != 1 then
   return -1
 endi
-
 if $data00 != 167 then
    return -1
 endi
@@ -125,19 +117,16 @@ if $rows != 0 then
   return -1
 endi
 
-sql select * from (select count(*) a, tbname f1 from nest_mt0 group by tbname) t where t.a>0 and f1 = 'nest_tb0';
+sql select * from (select count(*) a, tbname f1, tbname from nest_mt0 group by tbname) t where t.a>0 and f1 = 'nest_tb0';
 if $rows != 1 then
   return -1
 endi
-
 if $data00 != 10000 then
   return -1
 endi
-
 if $data01 != @nest_tb0@ then
   return -1
 endi
-
 if $data02 != @nest_tb0@ then
   return -1
 endi
@@ -145,37 +134,30 @@ endi
 print ===================> nest query interval
 sql_error select ts, avg(c1) from (select ts, c1 from nest_tb0);
 
-sql select avg(c1) from (select * from nest_tb0) interval(3d)
+sql select _wstart, avg(c1) from (select * from nest_tb0) interval(3d)
 if $rows != 3 then
   return -1
 endi
-
 if $data00 != @20-09-14 00:00:00.000@  then
   return -1
 endi
-
 if $data01 != 49.222222222 then
   return -1
 endi
-
 if $data10 != @20-09-17 00:00:00.000@  then
-  print expect 20-09-17 00:00:00.000, actual: $data10
   return -1
 endi
-
-if $data11 != 49.685185185 then
+if $data11 != 49.581325301 then
   return -1
 endi
-
 if $data20 != @20-09-20 00:00:00.000@  then
   return -1
 endi
-
-if $data21 != 49.500000000 then
+if $data21 != 49.703539823 then
   return -1
 endi
 
-sql_error select stddev(c1) from (select c1 from nest_tb0);
+sql select stddev(c1) from (select c1 from nest_tb0);
 sql_error select percentile(c1, 20) from (select * from nest_tb0);
 sql_error select interp(c1) from (select * from nest_tb0);
 sql_error select derivative(val, 1s, 0) from (select c1 val from nest_tb0);
@@ -184,39 +166,31 @@ sql_error select irate(c1) from (select c1 from nest_tb0);
 sql_error select diff(c1), twa(c1) from (select * from nest_tb0);
 sql_error select irate(c1), interp(c1), twa(c1) from (select * from nest_tb0);
 
-sql select apercentile(c1, 50) from (select * from nest_tb0) interval(1d)
+sql select _wstart, apercentile(c1, 50) from (select * from nest_tb0) interval(1d)
 if $rows != 7 then
   return -1
 endi
-
 if $data00 != @20-09-15 00:00:00.000@ then
   return -1
 endi
-
 if $data01 != 47.571428571 then
   return -1
 endi
-
 if $data10 != @20-09-16 00:00:00.000@ then
   return -1
 endi
-
 if $data11 != 49.666666667 then
   return -1
 endi
-
 if $data20 != @20-09-17 00:00:00.000@ then
   return -1
 endi
-
 if $data21 != 49.000000000 then
   return -1
 endi
-
 if $data30 != @20-09-18 00:00:00.000@ then
   return -1
 endi
-
 if $data31 != 48.333333333 then
   return -1
 endi
@@ -225,7 +199,6 @@ sql select twa(c1) from (select * from nest_tb0);
 if $rows != 1 then
   return -1
 endi
-
 if $data00 != 49.500000000 then
   return -1
 endi
@@ -234,7 +207,6 @@ sql select leastsquares(c1, 1, 1) from (select * from nest_tb0);
 if $rows != 1 then
   return -1
 endi
-
 if $data00 != @{slop:0.000100, intercept:49.000000}@ then
   return -1
 endi
@@ -248,19 +220,15 @@ sql select derivative(c1, 1s, 0) from (select * from nest_tb0);
 if $rows != 9999 then
   return -1
 endi
-
 if $data00 != @20-09-15 00:01:00.000@ then
   return -1
 endi
-
 if $data01 != 0.016666667 then
   return -1
 endi
-
 if $data10 != @20-09-15 00:02:00.000@ then
   return -1
 endi
-
 if $data11 != 0.016666667 then
   return -1
 endi
@@ -274,54 +242,42 @@ sql select avg(c1),sum(c2), max(c3), min(c4), count(*), first(c7), last(c7),spre
 if $rows != 7 then
   return -1
 endi
-
 if $data00 != @20-09-15 00:00:00.000@ then
   return -1
 endi
-
 if $data01 != 48.666666667 then
   print expect 48.666666667, actual: $data01
   return -1
 endi
-
 if $data02 != 70080.000000000 then
   return -1
 endi
-
 if $data03 != 99 then
   return -1
 endi
-
 if $data04 != 0 then
   return -1
 endi
-
 if $data05 != 1440 then
   return -1
 endi
-
 if $data06 != 0 then
   print $data06
   return -1
 endi
-
 if $data07 != 1 then
   return -1
 endi
-
 if $data08 != 99.000000000 then
   print expect 99.000000000, actual: $data08
   return -1
 endi
-
 if $data10 != @20-09-16 00:00:00.000@ then
   return -1
 endi
-
 if $data11 != 49.777777778 then
   return -1
 endi
-
 if $data12 != 71680.000000000 then
   return -1
 endi
@@ -332,39 +288,28 @@ sql select bottom(x, 20) from (select c1 x from nest_tb0)
 
 print ===================> group by + having
 
-
-
 print =========================> ascending order/descending order
 
-
-
-
 print =========================> nest query join
 sql select a.ts,a.k,b.ts from (select count(*) k from nest_tb0 interval(30a)) a, (select count(*) f from nest_tb1 interval(30a)) b where a.ts = b.ts ;
 if $rows != 10000 then
   return -1
 endi
-
 if $data00 != @20-09-15 00:00:00.000@ then
   return -1
 endi
-
 if $data01 != 1 then
   return -1
 endi
-
 if $data02 != @20-09-15 00:00:00.000@ then
   return -1
 endi
-
 if $data10 != @20-09-15 00:01:00.000@ then
   return -1
 endi
-
 if $data11 != 1 then
   return -1
 endi
-
 if $data12 != @20-09-15 00:01:00.000@ then
   return -1
 endi
@@ -373,11 +318,9 @@ sql select sum(a.k), sum(b.f) from (select count(*) k from nest_tb0 interval(30a
 if $rows != 1 then
   return -1
 endi
-
 if $data00 != 10000 then
   return -1
 endi
-
 if $data01 != 10000 then
   return -1
 endi
@@ -386,19 +329,15 @@ sql select a.ts,a.k,b.ts,c.ts,c.ts,c.x from (select count(*) k from nest_tb0 int
 if $rows != 10000 then
   return -1
 endi
-
 if $data00 != @20-09-15 00:00:00.000@ then
   return -1
 endi
-
 if $data01 != 1 then
   return -1
 endi
-
 if $data02 != @20-09-15 00:00:00.000@ then
   return -1
 endi
-
 if $data03 != @20-09-15 00:00:00.000@ then
   return -1
 endi
@@ -407,11 +346,9 @@ sql select diff(val) from (select c1 val from nest_tb0);
 if $rows != 9999 then
   return -1
 endi
-
 if $data00 != @70-01-01 08:00:00.000@ then
   return -1
 endi
-
 if $data01 != 1 then
   return -1
 endi
@@ -425,19 +362,15 @@ sql select count(*),c1 from (select * from nest_tb0) where c1 < 2 group by c1;
 if $rows != 2 then
   return -1
 endi
-
 if $data00 != 100 then
   return -1
 endi
-
 if $data01 != 0 then
   return -1
 endi
-
 if $data10 != 100 then
   return -1
 endi
-
 if $data11 != 1 then
   return -1
 endi
@@ -447,11 +380,9 @@ sql select twa(c1) from nest_tb1 interval(19a);
 if $rows != 10000 then
   return -1
 endi
-
 if $data00 != @20-09-14 23:59:59.992@ then
   return -1
 endi
-
 if $data01 != 0.000083333 then
   return -1
 endi
@@ -461,19 +392,15 @@ sql select min(val),max(val),first(val),last(val),count(val),sum(val),avg(val) f
 if $rows != 1 then
   return -1
 endi
-
 if $data00 != 10000 then
   return -1
 endi
-
 if $data01 != 10000 then
   return -1
 endi
-
 if $data04 != 10 then
   return -1
 endi
-
 if $data05 != 100000 then
   return -1
 endi
@@ -487,19 +414,15 @@ sql select avg(k) from (select avg(k) k from t1 interval(1s)) interval(1m);
 if $rows != 2 then
   return -1
 endi
-
 if $data00 != @20-01-01 01:01:00.000000@ then
   return -1
 endi
-
 if $data01 != 1.000000000 then
   return -1
 endi
-
 if $data10 != @20-01-01 01:02:00.000000@ then
   return -1
 endi
-
 if $data11 != 2.000000000 then
   return -1
 endi

tests/script/tsim/parser/null_char.sim

@@ -78,6 +78,8 @@ endi
 #### case 1: tag NULL, or 'NULL'
 sql create table mt2 (ts timestamp, col1 int, col3 float, col5 binary(8), col6 bool, col9 nchar(8)) tags (tag1 binary(8), tag2 nchar(8), tag3 int, tag5 bool)
 sql create table st2 using mt2 tags (NULL, 'NULL', 102, 'true')
+sql insert into st2 (ts, col1) values(now, 1)
+
 sql select tag1, tag2, tag3, tag5 from st2
 if $rows != 1 then
   return -1
@@ -115,6 +117,7 @@ if $rows != 0 then
 endi
 
 sql create table st3 using mt2 tags (NULL, 'ABC', 103, 'FALSE')
+sql insert into st3 (ts, col1) values(now, 1)
 sql select tag1, tag2, tag3, tag5 from st3
 if $rows != 1 then
   return -1
@@ -134,9 +137,10 @@ if $data03 != 0 then
 endi
 
 ### bool:
-sql_error create table stx using mt2 tags ('NULL', '123aBc', 104, '123')
-sql_error create table sty using mt2 tags ('NULL', '123aBc', 104, 'xtz')
+sql create table stx using mt2 tags ('NULL', '123aBc', 104, '123')
+sql create table sty using mt2 tags ('NULL', '123aBc', 104, 'xtz')
 sql create table st4 using mt2 tags ('NULL', '123aBc', 104, 'NULL')
+sql insert into st4 (ts, col1) values(now, 1)
 sql select tag1,tag2,tag3,tag5 from st4
 if $rows != 1 then
   return -1
@@ -150,12 +154,13 @@ endi
 if $data02 != 104 then
   return -1
 endi
-if $data03 != NULL then
+if $data03 != 0 then
   print ==6== expect: NULL, actually: $data03
   return -1
 endi
 
 sql create table st5 using mt2 tags ('NULL', '123aBc', 105, NULL)
+sql insert into st5 (ts, col1) values(now, 1)
 sql select tag1,tag2,tag3,tag5 from st5
 if $rows != 1 then
   return -1
@@ -173,8 +178,6 @@ if $data03 != NULL then
   return -1
 endi
 
-
-
 #### case 2: dynamic create table using super table when insert into
 sql create table mt3 (ts timestamp, col1 int, col3 float, col5 binary(8), col6 bool, col9 nchar(8)) tags (tag1 binary(8), tag2 nchar(8), tag3 int, tag5 bool)
 sql_error insert into st31 using mt3 tags (NULL, 'NULL', 102, 'true')     values (now+1s, 31, 31, 'bin_31', '123', 'nchar_31')
@@ -182,10 +185,10 @@ sql_error insert into st32 using mt3 tags (NULL, 'ABC', 103, 'FALSE')     values
 sql_error insert into st33 using mt3 tags ('NULL', '123aBc', 104, 'NULL') values (now+3s, 33, 33, 'bin_33', 'false123', 'nchar_33')
 sql_error insert into st34 using mt3 tags ('NULL', '123aBc', 105, NULL)   values (now+4s, 34, 34.12345, 'bin_34', 'true123', 'nchar_34')
 
-
 #### case 3: set tag value
 sql create table mt4 (ts timestamp, c1 int) tags (tag_binary binary(16), tag_nchar nchar(16), tag_int int, tag_bool bool, tag_float float, tag_double double)
 sql create table st41 using mt4 tags ("beijing", 'nchar_tag', 100, false, 9.12345, 7.123456789)
+sql insert into st41 (ts, c1) values(now, 1)
 sql select tag_binary, tag_nchar, tag_int, tag_bool, tag_float, tag_double from st41
 if $rows != 1 then
   return -1
@@ -245,7 +248,7 @@ endi
 ################### nchar
 sql alter table st41 set tag tag_nchar = "��˼����"
 sql select tag_binary, tag_nchar, tag_int, tag_bool, tag_float, tag_double from  st41
-#sleep 100
+
 #if $data01 != ��˼���� then
 #  print ==== expect ��˼����, actually $data01
 #  return -1

tests/script/tsim/parser/precision_ns.sim

@@ -48,8 +48,6 @@ while $x < $rowNum
     $x = $x + 1  
 endw
 
-sleep 100
-
 print =============== step2: select count(*) from tables
 $i = 0
 $tb = $tbPrefix . $i
@@ -103,7 +101,7 @@ sql select count(*) from $mt interval(100000000b) sliding(100000000b)
 print =============== clear
 sql drop database $db
 sql show databases
-if $rows != 0 then 
+if $rows != 2 then 
   return -1
 endi
 

tests/script/tsim/parser/projection_limit_offset.sim

@@ -271,14 +271,14 @@ endi
 
 #[tbase-695]
 sql select ts,tbname from group_mt0 where ts>='1970-01-01 8:1:40' and ts<'1970-1-1 8:1:45' and c1<99999999 limit 100000 offset 5000
+print ===> $data00 $data01 $data02 $data03 $data04 $data05 $data06 $data07 $data08 $data09
+print ===> $data10 $data11 $data12 $data13 $data14 $data15 $data16 $data17 $data18 $data19
+print ===> $data20 $data21 $data22 $data23 $data24 $data25 $data26 $data27 $data28 $data29
+print ===> $data30 $data31 $data32 $data33 $data34 $data35 $data36 $data37 $data38 $data39
 if $row != 35000 then
    return -1
 endi
 
-if $data00 != @70-01-01 08:01:40.000@ then
-   return -1
-endi
-
 #=================================parse error sql==========================================
 sql_error select ts,tbname from group_mt0 order by ts desc limit 100 offset -1;
 sql_error select ts,tbname from group_mt0 order by c1 asc limit 100 offset -1;
@@ -287,13 +287,13 @@ sql_error select ts,tbname from group_mt0 order by ts desc slimit -1, 100;
 sql_error select ts,tbname from group_mt0 order by ts desc slimit 1 soffset 1;
 
 #================================functions applys to sql===================================
-sql_error select first(t1) from group_mt0;
-sql_error select last(t1) from group_mt0;
-sql_error select min(t1) from group_mt0;
-sql_error select max(t1) from group_mt0;
-sql_error select top(t1, 20) from group_mt0;
-sql_error select bottom(t1, 20) from group_mt0;
-sql_error select avg(t1) from group_mt0;
+sql select first(t1) from group_mt0;
+sql select last(t1) from group_mt0;
+sql select min(t1) from group_mt0;
+sql select max(t1) from group_mt0;
+sql select top(t1, 20) from group_mt0;
+sql select bottom(t1, 20) from group_mt0;
+sql select avg(t1) from group_mt0;
 sql_error select percentile(t1, 50) from group_mt0;
 sql_error select percentile(t1, 50) from group_mt0;
 sql_error select percentile(t1, 50) from group_mt0;
@@ -309,7 +309,7 @@ endi
 
 #====================================tbase-716==============================================
 print tbase-716
-sql_error select count(*) from group_tb0 where ts in ('2016-1-1 12:12:12');
+sql select count(*) from group_tb0 where ts in ('2016-1-1 12:12:12');
 sql_error select count(*) from group_tb0 where ts < '12:12:12';
 
 #===============================sql for twa==========================================
@@ -345,7 +345,7 @@ if $rows != 0 then
   return -1
 endi
 
-sql select count(*),first(k),last(k) from m1 where tbname in ('tm0') interval(1s) order by ts desc;
+sql select _wstart, count(*),first(k),last(k) from m1 where tbname in ('tm0') interval(1s) order by _wstart desc;
 if $row != 5 then
     return -1
 endi
@@ -374,6 +374,7 @@ if $data13 != NULL then
    return -1
 endi
 
+
 print =============tbase-1324
 sql select a, k-k from m1
 if $row != 8 then
@@ -384,8 +385,7 @@ sql select diff(k) from tm0
 if $row != 3 then
    return -1
 endi
-
-if $data21 != -1 then
+if $data20 != -1 then
    return -1
 endi
 
@@ -395,20 +395,19 @@ sql_error select * from 1;
 sql_error select k+k;
 sql_error select k+1;
 sql_error select abc();
-sql_error select 1 where 1=2;
-sql_error select 1 limit 1;
-sql_error select 1 slimit 1;
-sql_error select 1 interval(1h);
+sql select 1 where 1=2;
+sql select 1 limit 1;
+sql select 1 slimit 1;
+sql select 1 interval(1h);
 sql_error select count(*);
 sql_error select sum(k);
-sql_error select 'abc';
+sql select 'abc';
 sql_error select k+1,sum(k) from tm0;
 sql_error select k, sum(k) from tm0;
 sql_error select k, sum(k)+1 from tm0;
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 

tests/script/tsim/parser/regex.sim

@@ -18,12 +18,15 @@ sql create table $ct1_name using $st_name tags('taosdata1')
 sql create table $ct2_name using $st_name tags('taosdata2')
 sql create table not_match using $st_name tags('NOTMATCH')
 
+sql insert into $ct1_name values(now, 'this is engine')
+sql insert into $ct2_name values(now, 'this is app egnine')
+sql insert into not_match values (now + 1s, '1234')
+
 sql select tbname from $st_name where tbname match '.*'
 if $rows != 3 then
   return -1
 endi
 
-
 sql select tbname from $st_name where tbname match '^ct[[:digit:]]'
 if $rows != 2 then
   return -1
@@ -54,9 +57,6 @@ if $rows != 1 then
   return -1
 endi
 
-sql insert into $ct1_name values(now, 'this is engine')
-sql insert into $ct2_name values(now, 'this is app egnine')
-
 sql select c1b from $st_name where c1b match 'engine'
 if $data00 != @this is engine@ then
   return -1
@@ -66,12 +66,11 @@ if $rows != 1 then
   return -1
 endi  
 
-sql select c1b from $st_name where c1b nmatch 'engine'
+sql select c1b from $st_name where c1b nmatch 'engine' order by ts
 if $data00 != @this is app egnine@ then
   return -1
 endi
-
-if $rows != 1 then
+if $rows != 2 then
   return -1
 endi  
 
@@ -96,8 +95,8 @@ sql_error select * from wrong_type where c5 match '.*'
 sql_error select * from wrong_type where c5 nmatch '.*'
 sql_error select * from wrong_type where c6 match '.*'
 sql_error select * from wrong_type where c6 nmatch '.*'
-sql_error select * from wrong_type where c7 match '.*'
-sql_error select * from wrong_type where c7 nmatch '.*'
+sql select * from wrong_type where c7 match '.*'
+sql select * from wrong_type where c7 nmatch '.*'
 sql_error select * from wrong_type where t1 match '.*'
 sql_error select * from wrong_type where t1 nmatch '.*'
 sql_error select * from wrong_type where t2 match '.*'
@@ -110,9 +109,7 @@ sql_error select * from wrong_type where t5 match '.*'
 sql_error select * from wrong_type where t5 nmatch '.*'
 sql_error select * from wrong_type where t6 match '.*'
 sql_error select * from wrong_type where t6 nmatch '.*'
-sql_error select * from wrong_type where t7 match '.*'
-sql_error select * from wrong_type where t7 nmatch '.*'
+sql select * from wrong_type where t7 match '.*'
+sql select * from wrong_type where t7 nmatch '.*'
 
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-
-

tests/script/tsim/parser/selectResNum.sim

@@ -20,7 +20,7 @@ $stb = $stbPrefix . $i
 
 sql drop database $db -x step1
 step1:
-sql create database $db cache 16
+sql create database $db 
 print ====== create tables
 sql use $db
 sql create table $stb (ts timestamp, c1 int, c2 bigint, c3 float, c4 double, c5 smallint, c6 tinyint, c7 bool, c8 binary(10), c9 nchar(10)) tags(t1 int)
@@ -114,12 +114,8 @@ endw
 
 print ====== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ====== server restart completed
-sleep 100
-sql connect
-sleep 100
 sql use $db
 
 ##### repeat test after server restart

tests/script/tsim/parser/select_across_vnodes.sim

@@ -17,7 +17,7 @@ $db = $dbPrefix
 $stb = $stbPrefix
 
 sql drop database if exists $db
-sql create database $db
+sql create database $db vgroups 10
 sql use $db
 print ====== create tables
 sql create table $stb (ts timestamp, c1 int, c2 bigint, c3 float, c4 double, c5 smallint, c6 tinyint, c7 bool, c8 binary(10), c9 nchar(10)) tags(t1 int)
@@ -72,7 +72,7 @@ endi
 
 sql drop database $db
 sql show databases
-if $rows != 0 then 
+if $rows != 2 then 
   return -1
 endi
 

tests/script/tsim/parser/select_distinct_tag.sim

@@ -27,6 +27,7 @@ $ts = $ts0
 while $i < $tbNum
   $tb = $tbPrefix . $i
   sql create table $tb using $stb tags( $i , 0 )
+  sql insert into $tb (ts, c1) values (now, 1);
   $i = $i + 1
 endw 
 
@@ -50,7 +51,7 @@ sql_error select distinct t1, t2 from &stb
 
 sql drop database $db
 sql show databases
-if $rows != 0 then 
+if $rows != 2 then 
   return -1
 endi
 

tests/script/tsim/parser/select_from_cache_disk.sim

@@ -31,17 +31,13 @@ sql insert into $tb values ('2018-09-17 09:00:00.030', 3)
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
-sql connect
-sleep 100
-sql use $db
 
 # generate some data in cache
 sql insert into $tb values ('2018-09-17 09:00:04.000', 4)
 sql insert into $tb values ('2018-09-17 09:00:04.010', 5)
-sql select count(*) from $stb interval(1s) group by t1
+sql select _wstart, count(*), t1 from $stb partition by t1 interval(1s) order by _wstart
 if $rows != 2 then
   return -1
 endi

tests/script/tsim/parser/select_with_tags.sim

@@ -62,9 +62,6 @@ while $i < $tbNum
 
 endw
 
-sleep 100
-
-
 #======================= only check first table tag, TD-4827
 sql select count(*) from $mt where t1 in (0)  
 if $rows != 1 then 
@@ -178,15 +175,15 @@ if $data03 != @abc15@ then
 endi
 
 sql select top(c6, 3) from select_tags_mt0 interval(10a)
-sql select top(c3,10) from select_tags_mt0 interval(10a) group by tbname,t1,t2
-sql select top(c6, 3) from select_tags_mt0 interval(10a) group by tbname;
+sql select top(c3,10) from select_tags_mt0 partition by tbname,t1,t2 interval(10a)
+sql select top(c6, 3) from select_tags_mt0 partition by tbname interval(10a)
 
 sql select top(c6, 10) from select_tags_mt0 interval(10a);
 if $rows != 12800 then
   return -1
 endi
 
-sql select top(c1, 80), tbname, t1, t2 from select_tags_mt0;
+sql select _rowts, top(c1, 80), tbname, t1, t2 from select_tags_mt0;
 if $rows != 80 then
    return -1
 endi

tests/script/tsim/parser/set_tag_vals.sim

@@ -55,10 +55,8 @@ while $i < $tbNum
 
   $i = $i + 1
 endw 
-print ====== tables created
-
-sleep 500
 
+print ====== tables created
 sql show tables
 if $rows != $tbNum then
   return -1
@@ -74,12 +72,16 @@ while $i < $tbNum
   sql insert into $tb (ts, c1) values (now-100a, $i )
   sql alter table $tb set tag t3 = $i
   sql insert into $tb (ts, c1) values (now, $i )
-  sql alter table $tb set tag t4 = $i
+
+  $name = ' . $i
+  $name = $name . '
+  sql alter table $tb set tag t4 = $name
   $i = $i + 1
 endw
 
 print ================== all tags have been changed!
-sql_error select tbname from $stb where t3 = 'NULL'
+sql reset query cache
+sql select tbname from $stb where t3 = 'NULL'
 
 print ================== set tag to NULL
 sql create table stb1_tg (ts timestamp, c1 int) tags(t1 int,t2 bigint,t3 double,t4 float,t5 smallint,t6 tinyint)
@@ -142,7 +144,9 @@ sql alter table tb1_tg2 set tag t1 = false
 sql alter table tb1_tg2 set tag t2 = 'binary2'
 sql alter table tb1_tg2 set tag t3 = '涛思'
 sql reset query cache
+
 sql select * from stb1_tg
+print ===> $data00 $data01 $data02 $data03 $data04 $data05 $data06 $data07 $data08 $data09
 if $rows != 1 then
   return -1
 endi
@@ -164,7 +168,9 @@ endi
 if $data07 != -6 then
   return -1
 endi
+
 sql select * from stb2_tg
+print ===> $data00 $data01 $data02 $data03 $data04 $data05 $data06 $data07 $data08 $data09
 if $data02 != 0 then
   return -1
 endi
@@ -185,7 +191,9 @@ sql alter table tb1_tg2 set tag t1 = NULL
 sql alter table tb1_tg2 set tag t2 = NULL
 sql alter table tb1_tg2 set tag t3 = NULL
 sql reset query cache
+
 sql select * from stb1_tg
+print ===> $data00 $data01 $data02 $data03 $data04 $data05 $data06 $data07 $data08 $data09
 if $rows != 1 then
   return -1
 endi
@@ -207,12 +215,12 @@ endi
 if $data07 != NULL then
   return -1
 endi
+
 sql select * from stb2_tg
+print ===> $data00 $data01 $data02 $data03 $data04 $data05 $data06 $data07 $data08 $data09
 if $data02 != NULL then
   return -1
 endi
-
-print $data03
 if $data03 != NULL then
   return -1
 endi

tests/script/tsim/parser/single_row_in_tb_query.sim

-sleep 100
 sql connect
 
 $dbPrefix = sr_db
@@ -113,7 +112,7 @@ if $data02 != 2 then
 endi
 
 #### query a STable and using where clause
-sql select first(ts,c1), last(ts,c1), spread(c1) from $stb where ts >= $ts0 and ts < '2018-09-20 00:00:00.000' group by t1
+sql select first(ts,c1), last(ts,c1), spread(c1), t1 from $stb where ts >= $ts0 and ts < '2018-09-20 00:00:00.000' group by t1
 if $rows != 1 then
   return -1
 endi
@@ -137,7 +136,7 @@ if $data05 != 1 then
   return -1
 endi
 
-sql select first(c1), last(c1) from $stb where ts >= $ts0 and ts < '2018-09-20 00:00:00.000' interval(1d) group by t1
+sql select _wstart, first(c1), last(c1) from sr_stb where ts >= 1537146000000 and ts < '2018-09-20 00:00:00.000' partition by t1 interval(1d)
 if $rows != 1 then
   return -1
 endi
@@ -151,7 +150,7 @@ if $data02 != 1 then
   return -1
 endi
 
-sql select max(c1), min(c1), sum(c1), avg(c1), count(c1) from $stb where c1 > 0 group by t1
+sql select max(c1), min(c1), sum(c1), avg(c1), count(c1), t1 from $stb where c1 > 0 group by t1
 if $rows != 1 then
   return -1
 endi
@@ -174,7 +173,7 @@ if $data05 != 1 then
   return -1
 endi
 
-sql select first(ts,c1), last(ts,c1) from $tb1 where ts >= $ts0 and ts < '2018-09-20 00:00:00.000' interval(1d)
+sql select _wstart, first(ts,c1), last(ts,c1) from $tb1 where ts >= $ts0 and ts < '2018-09-20 00:00:00.000' interval(1d)
 if $rows != 1 then
   return -1
 endi

tests/script/tsim/parser/sliding.sim

@@ -58,8 +58,6 @@ while $i < $tbNum
   $tstart = 946656000000
 endw
 
-sleep 100
-
 $i1 = 1
 $i2 = 0
 
@@ -76,425 +74,355 @@ $ts1 = $tb1 . .ts
 $ts2 = $tb2 . .ts
 
 print ===============================interval_sliding query
-sql select count(*) from sliding_tb0 interval(30s) sliding(30s);
+sql select _wstart, count(*) from sliding_tb0 interval(30s) sliding(30s);
 if $row != 10 then
  return -1
 endi
-
 if $data00 != @00-01-01 00:00:00.000@ then
  return -1
 endi
-
 if $data01 != 1000 then
  return -1
 endi
-
 if $data10 != @00-01-01 00:00:30.000@ then
  return -1
 endi
-
 if $data11 != 1000 then
  return -1
 endi
 
-sql select stddev(c1) from sliding_tb0 interval(10a) sliding(10a)
+sql select _wstart, stddev(c1) from sliding_tb0 interval(10a) sliding(10a);
 if $row != 10000 then
   return -1
 endi
-
 if $data00 != @00-01-01 00:00:00.000@ then
   return -1
 endi
-
 if $data01 != 0.000000000 then
    return -1
 endi
-
 if $data90 != @00-01-01 00:00:00.270@ then
   return -1
 endi
-
 if $data91 != 0.000000000 then
   return -1
 endi
 
-sql select stddev(c1),count(c2),first(c3),last(c4) from sliding_tb0 interval(10a) sliding(10a) order by ts desc;
+sql select _wstart, stddev(c1),count(c2),first(c3),last(c4) from sliding_tb0 interval(10a) sliding(10a) order by _wstart desc;
 if $row != 10000 then
   return -1
 endi
-
 if $data00 != @00-01-01 00:04:59.970@ then
  return -1
 endi
-
 if $data01 != 0.000000000 then
   return -1
 endi
-
 if $data02 != 1 then
   return -1
 endi
-
 if $data03 != 99 then
   return -1
 endi
-
 if $data04 != 99 then
   return -1
 endi
-
 if $data90 != @00-01-01 00:04:59.700@ then
   return -1
 endi
-
 if $data91 != 0.000000000 then
   return -1
 endi
-
 if $data92 != 1 then
   return -1
 endi
-
 if $data93 != 90 then
   return -1
 endi
-
 if $data94 != 90 then
   return -1
 endi
 
-sql select count(c2),last(c4) from sliding_tb0 interval(30s) sliding(10s) order by ts asc;
+sql select _wstart, count(c2),last(c4) from sliding_tb0 interval(30s) sliding(10s) order by _wstart asc;
 if $row != 32 then
   return -1
 endi
-
 if $data00 != @99-12-31 23:59:40.000@ then
   print expect 12-31 23:59:40.000, actual: $data00
   return -1
 endi
-
 if $data01 != 334 then
   return -1
 endi
-
 if $data02 != 33 then
   return -1
 endi
 
-sql select count(c2),stddev(c3),first(c4),last(c4) from sliding_tb0 where ts>'2000-01-01 0:0:0' and ts<'2000-1-1 0:0:31' interval(30s) sliding(30s) order by ts asc;
+sql select _wstart, count(c2),stddev(c3),first(c4),last(c4) from sliding_tb0 where ts>'2000-01-01 0:0:0' and ts<'2000-1-1 0:0:31' interval(30s) sliding(30s) order by _wstart asc;
 if $row != 2 then
   return -1
 endi
-
 if $data04 != 99 then
   return -1
 endi
-
 if $data01 != 999 then
   return -1
 endi
-
 if $data02 != 28.837977152 then
   return -1
 endi
 
 #interval offset + limit
-sql select count(c2), first(c3),stddev(c4) from sliding_tb0 interval(10a) sliding(10a) order by ts desc limit 10 offset 990;
+sql select _wstart, count(c2), first(c3),stddev(c4) from sliding_tb0 interval(10a) sliding(10a) order by _wstart desc limit 10 offset 990;
 if $row != 10 then
   return -1
 endi
-
 if $data00 != @00-01-01 00:04:30.270@ then
   return -1
 endi
-
 if $data01 != 1 then
   return -1
 endi
-
 if $data02 != 9 then
   return -1
 endi
-
 if $data03 != 0.000000000 then
   return -1
 endi
-
 if $data90 != @00-01-01 00:04:30.000@ then
   return -1
 endi
-
 if $data91 != 1 then
   return -1
 endi
-
 if $data92 != 0 then
   return -1
 endi
-
 if $data93 != 0.000000000 then
   return -1
 endi
 
 #interval offset test
-sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(30s) order by ts asc limit 1000 offset 1;
+sql select _wstart, count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(30s) order by _wstart asc limit 1000 offset 1;
 if $row != 9 then
   return -1
 endi
-
 if $data00 != @00-01-01 00:00:30.000@ then
   return -1
 endi
-
 if $data01 != 1000 then
   return -1
 endi
-
 if $data02 != 99 then
   return -1
 endi
-
 if $data80 != @00-01-01 00:04:30.000@ then
   return -1
 endi
-
 if $data81 != 1000 then
   return -1
 endi
 
-sql select count(c2),last(c4),stddev(c3) from sliding_tb0 where ts>'2000-1-1 0:0:0' and ts<'2000-1-1 0:0:31' interval(30s) sliding(30s) order by ts asc limit 1000 offset 0;
+sql select _wstart, count(c2),last(c4),stddev(c3) from sliding_tb0 where ts>'2000-1-1 0:0:0' and ts<'2000-1-1 0:0:31' interval(30s) sliding(30s) order by _wstart asc limit 1000 offset 0;
 if $row != 2 then
  return -1
 endi
-
 if $data00 != @00-01-01 00:00:00.000@ then
  return -1
 endi
-
 if $data01 != 999 then
  return -1
 endi
-
 if $data02 != 99 then
  return -1
 endi
-
 if $data03 != 28.837977152 then
  return -1
 endi
-
 if $data10 != @00-01-01 00:00:30.000@ then
  return -1
 endi
-
 if $data11 != 34 then
  return -1
 endi
-
 if $data12 != 33 then
  return -1
 endi
-
 if $data13 != 9.810708435 then
  return -1
 endi
 
-sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by ts asc limit 100 offset 1;
+sql select _wstart, count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by _wstart asc limit 100 offset 1;
 if $row != 15 then
  return -1
 endi
-
 if $data00 != @00-01-01 00:00:00.000@ then
  return -1
 endi
-
 if $data01 != 1000 then
  return -1
 endi
-
 if $data02 != 99 then
  return -1
 endi
-
 if $data03 != 28.866070048 then
  return -1
 endi
-
 if $data90 != @00-01-01 00:03:00.000@ then
  return -1
 endi
-
 if $data91 != 1000 then
  return -1
 endi
-
 if $data92 != 99 then
  return -1
 endi
 
-sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by ts asc limit 100 offset 5;
+sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by _wstart asc limit 100 offset 5;
 if $row != 11 then
  return -1
 endi
 
-sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by ts asc limit 100 offset 6;
+sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by _wstart asc limit 100 offset 6;
 if $row != 10 then
  return -1
 endi
 
-sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by ts asc limit 100 offset 7;
+sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by _wstart asc limit 100 offset 7;
 if $row != 9 then
  return -1
 endi
 
-sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by ts asc limit 100 offset 8;
+sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by _wstart asc limit 100 offset 8;
 if $row != 8 then
  return -1
 endi
 
-sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by ts asc limit 100 offset 9;
+sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by _wstart asc limit 100 offset 9;
 if $row != 7 then
  return -1
 endi
 
-sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by ts asc limit 100 offset 10;
+sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by _wstart asc limit 100 offset 10;
 if $row != 6 then
  return -1
 endi
 
-sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by ts asc limit 100 offset 11;
+sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by _wstart asc limit 100 offset 11;
 if $row != 5 then
  return -1
 endi
 
-sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by ts asc limit 100 offset 12;
+sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by _wstart asc limit 100 offset 12;
 if $row != 4 then
  return -1
 endi
 
-sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by ts asc limit 100 offset 13;
+sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by _wstart asc limit 100 offset 13;
 if $row != 3 then
  return -1
 endi
 
-sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by ts asc limit 100 offset 14;
+sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by _wstart asc limit 100 offset 14;
 if $row != 2 then
  return -1
 endi
 
-sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by ts asc limit 100 offset 15;
+sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by _wstart asc limit 100 offset 15;
 if $row != 1 then
  return -1
 endi
 
-sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by ts asc limit 100 offset 16;
+sql select count(c2),last(c4),stddev(c3) from sliding_tb0 interval(30s) sliding(20s) order by _wstart asc limit 100 offset 16;
 if $row != 0 then
  return -1
 endi
 
-sql select count(c2),last(c4),stddev(c3),spread(c3) from sliding_tb0 where c2 = 0 interval(30s) order by ts desc;
+sql select _wstart, count(c2),last(c4),stddev(c3),spread(c3) from sliding_tb0 where c2 = 0 interval(30s) order by _wstart desc;
 if $row != 10 then
  return -1
 endi
-
 #00-01-01 00:04:30.000|                   10|       0|              0.000000000|              0.000000000|
 if $data00 != @00-01-01 00:04:30.000@ then
  return -1
 endi
-
 if $data01 != 10 then
  return -1
 endi
-
 if $data02 != 0 then
  return -1
 endi
-
 if $data03 != 0.000000000 then
  return -1
 endi
 
-sql select count(c2),last(c4),stddev(c3),spread(c3) from sliding_tb0 where c2 = 0 interval(30s) sliding(20s) order by ts desc limit 1 offset 15;
+sql select count(c2),last(c4),stddev(c3),spread(c3) from sliding_tb0 where c2 = 0 interval(30s) sliding(20s) order by _wstart desc limit 1 offset 15;
 if $row != 1 then
  return -1
 endi
 
-sql select count(c2),last(c4),stddev(c3),spread(c3) from sliding_tb0 where c2 = 0 interval(30s) sliding(20s) order by ts desc limit 1 offset 16;
+sql select count(c2),last(c4),stddev(c3),spread(c3) from sliding_tb0 where c2 = 0 interval(30s) sliding(20s) order by _wstart desc limit 1 offset 16;
 if $row != 0 then
  return -1
 endi
 
-sql select count(c2), first(c3),stddev(c4) from sliding_tb0 interval(10a) order by ts desc limit 10 offset 2;
+sql select _wstart, count(c2), first(c3),stddev(c4) from sliding_tb0 interval(10a) order by _wstart desc limit 10 offset 2;
 if $data00 != @00-01-01 00:04:59.910@ then
   return -1
 endi
 
-sql select count(*),stddev(c1),count(c1),first(c2),last(c3) from sliding_tb0 where ts>'2000-1-1 00:00:00' and ts<'2000-1-1 00:00:01.002' and c2 >= 0 interval(30s) sliding(10s) order by ts asc limit 1000;
+sql select _wstart, count(*),stddev(c1),count(c1),first(c2),last(c3) from sliding_tb0 where ts>'2000-1-1 00:00:00' and ts<'2000-1-1 00:00:01.002' and c2 >= 0 interval(30s) sliding(10s) order by _wstart asc limit 1000;
 if $row != 3 then
  return -1
 endi
-
 if $data00 != @99-12-31 23:59:40.000@ then
  return -1
 endi
-
 if $data02 != 9.521904571 then
  return -1
 endi
-
 if $data05 != 33 then
  return -1
 endi
-
 if $data10 != @99-12-31 23:59:50.000@ then
  return -1
 endi
-
 if $data12 != 9.521904571 then
  return -1
 endi
-
 if $data15 != 33 then
  return -1
 endi
-
 if $data25 != 33 then
  return -1
 endi
 
-sql select count(*),stddev(c1),count(c1),first(c2),last(c3) from sliding_tb0 where ts>'2000-1-1 00:00:00' and ts<'2000-1-1 00:00:01.002' and c2 >= 0 interval(30s) sliding(10s) order by ts desc limit 1000;
+sql select _wstart, count(*),stddev(c1),count(c1),first(c2),last(c3) from sliding_tb0 where ts>'2000-1-1 00:00:00' and ts<'2000-1-1 00:00:01.002' and c2 >= 0 interval(30s) sliding(10s) order by _wstart desc limit 1000;
 if $row != 3 then
  return -1
 endi
-
 if $data00 != @00-01-01 00:00:00.000@ then
  print expect 00-01-01 00:00:00.000, actual: $data00
  return -1
 endi
-
 if $data01 != 33 then
  return -1
 endi
-
 if $data02 != 9.521904571 then
  return -1
 endi
-
 if $data03 != 33 then
  return -1
 endi
-
 if $data10 != @99-12-31 23:59:50.000@ then
  return -1
 endi
-
 if $data11 != 33 then
  return -1
 endi
 if $data12 != 9.521904571 then
  return -1
 endi
-
 if $data20 != @99-12-31 23:59:40.000@ then
  return -1
 endi

tests/script/tsim/parser/union.sim

@@ -102,11 +102,11 @@ $i = 1
 $tb = $tbPrefix . $i
 
 ## column type not identical
-sql_error select count(*) as a from union_mt0 union all select avg(c1) as a from union_mt0
-sql_error select count(*) as a from union_mt0 union all select spread(c1) as a from union_mt0;
+sql select count(*) as a from union_mt0 union all select avg(c1) as a from union_mt0
+sql select count(*) as a from union_mt0 union all select spread(c1) as a from union_mt0;
 
 ## union not supported
-sql_error (select count(*) from union_mt0) union (select count(*) from union_mt0);
+sql (select count(*) from union_mt0) union (select count(*) from union_mt0);
 
 ## column type not identical
 sql_error select c1 from union_mt0 limit 10 union all select c2 from union_tb1 limit 20;
@@ -123,145 +123,114 @@ sql (((select c1 from union_tb0)))
 if $rows != 10000 then
   return -1
 endi
-
 if $data00 != 0 then
   return -1
 endi
-
 if $data10 != 1 then
   return -1
 endi
 
-sql select 'ab' as options from union_tb1 limit 1 union all select 'dd' as options from union_tb0 limit 1;
+sql (select 'ab' as options from union_tb1 limit 1) union all (select 'dd' as options from union_tb0 limit 1) order by options;
 if $rows != 2 then
   return -1
 endi
-
 if $data00 != @ab@ then
   return -1
 endi
-
 if $data10 != @dd@ then
   return -1
 endi
 
-
-sql select 'ab' as options from union_tb1 limit 1 union all select '1234567' as options from union_tb0 limit 1;
+sql (select 'ab12345' as options from union_tb1 limit 1) union all (select '1234567' as options from union_tb0 limit 1) order by options desc;
 if $rows != 2 then
   return -1
 endi
-
-if $data00 != @ab@ then
+if $data00 != @ab12345@ then
   return -1
 endi
-
 if $data10 != @1234567@ then
   return -1
 endi
 
-
 # mixed order
-sql select ts, c1 from union_tb1 order by ts asc limit 10 union all select ts, c1 from union_tb0 order by ts desc limit 2 union all select ts, c1 from union_tb2 order by ts asc limit 10
+sql (select ts, c1 from union_tb1 order by ts asc limit 10) union all (select ts, c1 from union_tb0 order by ts desc limit 2) union all (select ts, c1 from union_tb2 order by ts asc limit 10) order by ts
 if $rows != 22 then
   return -1
 endi
-
 if $data00 != @20-01-05 13:51:24.000@ then
   return -1
 endi
-
 if $data01 != 0 then
   return -1
 endi
-
-if $data10 != @20-01-05 13:52:24.000@ then
+if $data10 != @20-01-05 13:51:24.000@ then
   return -1
 endi
-
-if $data11 != 1 then
+if $data11 != 0 then
   return -1
 endi
-
-if $data90 != @20-01-05 14:00:24.000@ then
+print $data90 $data91
+if $data90 != @20-01-05 13:55:24.000@ then
   return -1
 endi
-
-if $data91 != 9 then
+if $data91 != 4 then
   return -1
 endi
 
 # different sort order
 
 # super table & normal table mixed up
-sql select c3 from union_tb0 limit 2 union all select sum(c1) as c3 from union_mt0;
+sql (select c3 from union_tb0 limit 2) union all (select sum(c1) as c3 from union_mt0) order by c3;
 if $rows != 3 then
   return -1
 endi
-
 if $data00 != 0 then
   return -1
 endi
-
 if $data10 != 1 then
   return -1
 endi
-
 if $data20 != 4950000 then
   return -1
 endi
 
 # type compatible
-sql select c3 from union_tb0 limit 2 union all select sum(c1) as c3 from union_tb1;
+sql (select c3 from union_tb0 limit 2) union all (select sum(c1) as c3 from union_tb1) order by c3;
 if $rows != 3 then
  return -1
 endi
-
 if $data00 != 0 then
    return -1
 endi
-
 if $data10 != 1 then
   return -1
 endi
-
 if $data20 != 495000 then
   return -1
 endi
 
 # two join subclause
-sql select count(*) as c from union_tb0, union_tb1 where union_tb0.ts=union_tb1.ts union all select union_tb0.c3 as c from union_tb0, union_tb1 where union_tb0.ts=union_tb1.ts limit 10
+sql (select count(*) as c from union_tb0, union_tb1 where union_tb0.ts=union_tb1.ts) union all (select union_tb0.c3 as c from union_tb0, union_tb1 where union_tb0.ts=union_tb1.ts limit 10) order by c desc
 if $rows != 11 then
   return -1
 endi
-
 if $data00 != 10000 then
   return -1
 endi
-
-if $data10 != 0 then
+if $data10 != 9 then
   return -1
 endi
-
-if $data20 != 1 then
+if $data20 != 8 then
   return -1
 endi
-
-if $data90 != 8 then
+if $data90 != 1 then
  return -1
 endi
 
 print ===========================================tags union
 # two super table tag union, limit is not active during retrieve tags query
-sql select t1 from union_mt0 union all select t1 from union_mt0
-if $rows != 20 then
-  return -1
-endi
-
-if $data00 != 0 then
-  return -1
-endi
-
-if $data90 != 9 then
+sql (select t1 from union_mt0) union all (select t1 from union_mt0)
+if $rows != 200000 then
   return -1
 endi
 
@@ -271,39 +240,35 @@ endi
 #endi
 #========================================== two super table join subclause
 print ================two super table join subclause
-sql select avg(union_mt0.c1) as c from union_mt0 interval(1h) limit 10 union all select union_mt1.ts, union_mt1.c1/1.0 as c from union_mt0, union_mt1 where union_mt1.ts=union_mt0.ts and union_mt1.t1=union_mt0.t1 limit 5;
+sql (select _wstart as ts, avg(union_mt0.c1) as c from union_mt0 interval(1h) limit 10) union all (select union_mt1.ts, union_mt1.c1/1.0 as c from union_mt0, union_mt1 where union_mt1.ts=union_mt0.ts and union_mt1.t1=union_mt0.t1 limit 5);
 print the rows value is: $rows
-
 if $rows != 15 then
   return -1
 endi
 
 # first subclause are empty
-sql select count(*) as c from union_tb0 where ts > now + 3650d union all select sum(c1) as c from union_tb1;
+sql (select count(*) as c from union_tb0 where ts > now + 3650d) union all (select sum(c1) as c from union_tb1);
 if $rows != 1 then
   return -1
 endi
-
 if $data00 != 495000 then
   return -1
 endi
 
 # all subclause are empty
-sql select c1 from union_tb0 limit 0 union all select c1 from union_tb1 where ts>'2021-1-1 0:0:0'
+sql (select c1 from union_tb0 limit 0) union all (select c1 from union_tb1 where ts>'2021-1-1 0:0:0')
 if $rows != 0 then
   return -1
 endi
 
 # middle subclause empty
-sql select c1 from union_tb0 limit 1 union all select c1 from union_tb1 where ts>'2030-1-1 0:0:0' union all select last(c1) as c1 from union_tb1;
+sql (select c1 from union_tb0 limit 1) union all (select c1 from union_tb1 where ts>'2030-1-1 0:0:0' union all select last(c1) as c1 from union_tb1) order by c1;
 if $rows != 2 then
   return -1
 endi
-
 if $data00 != 0 then
   return -1
 endi
-
 if $data10 != 99 then
   return -1
 endi
@@ -319,141 +284,90 @@ sql (select ts, c1 from union_mt0 limit 1) union all (select ts, c1 from union_m
 if $rows != 2 then
   return -1
 endi
-
 if $data00 != @20-01-05 13:51:24.000@ then
   return -1
 endi
-
 if $data01 != 0 then
   return -1
 endi
-
 if $data10 != @20-01-05 13:51:24.000@ then
   return -1
 endi
-
 if $data11 != 0 then
   return -1
 endi
 
 # two aggregated functions for super tables
-sql select sum(c1) as a from union_mt0 interval(1s) limit 9 union all select ts, max(c3) as a from union_mt0 limit 2;
+sql (select _wstart as ts, sum(c1) as a from union_mt0 interval(1s) limit 9) union all (select ts, max(c3) as a from union_mt0 limit 2) order by ts;
 if $rows != 10 then
   return -1
 endi
-
 if $data00 != @20-01-05 13:51:24.000@ then
   return -1
 endi
-
 if $data01 != 0 then
   return -1
 endi
-
 if $data10 != @20-01-05 13:52:24.000@ then
   return -1
 endi
-
 if $data11 != 10 then
   return -1
 endi
-
 if $data20 != @20-01-05 13:53:24.000@ then
   return -1
 endi
-
 if $data21 != 20 then
   return -1
 endi
-
 if $data90 != @20-01-05 15:30:24.000@ then
   return -1
 endi
-
 if $data91 != 99 then
   return -1
 endi
 
 #=================================================================================================
 # two aggregated functions for normal tables
-sql select sum(c1) as a from union_tb0 limit 1 union all select sum(c3) as a from union_tb1 limit 2;
+sql (select sum(c1) as a from union_tb0 limit 1) union all (select sum(c3) as a from union_tb1 limit 2);
 if $rows != 2 then
   return -1
 endi
-
 if $data00 != 495000 then
   return -1
 endi
-
 if $data10 != 495000 then
   return -1
 endi
 
 # two super table query + interval + limit
-sql select ts, first(c3) as a from union_mt0 limit 1 union all select sum(c3) as a from union_mt0 interval(1h) limit 1;
+sql (select ts, first(c3) as a from union_mt0 limit 1) union all (select _wstart as ts, sum(c3) as a from union_mt0 interval(1h) limit 1) order by ts desc;
 if $rows != 2 then
   return -1
 endi
-
 if $data00 != @20-01-05 13:51:24.000@ then
  return -1
 endi
-
 if $data01 != 0 then
   return -1
 endi
-
 if $data10 != @20-01-05 13:00:00.000@ then
  return -1
 endi
-
 if $data11 != 360 then
   return -1
 endi
 
-sql select server_status() union all select server_status()
-if $rows != 2 then
-  return -1
-endi
-
-if $data00 != 1 then
-  return -1
-endi
-
-if $data10 != 1 then
-  return -1
-endi
-
-sql select client_version() union all select server_version()
-if $rows != 2 then
-  return -1
-endi
-
-sql select database() union all select database()
-if $rows != 2 then
-  return -1
-endi
-
-if $data00 != @union_db0@ then
-  return -1
-endi
-
-if $data10 != @union_db0@ then
-  return -1
-endi
-
-sql select 'aaa' as option from union_tb1 where c1 < 0 limit 1 union all select 'bbb' as option from union_tb0 limit 1
+sql (select 'aaa' as option from union_tb1 where c1 < 0 limit 1) union all (select 'bbb' as option from union_tb0 limit 1)
 if $rows != 1 then
   return -1
 endi
-
 if $data00 != @bbb@ then
   return -1
 endi
 
-
-sql_error show tables union all show tables
-sql_error show stables union all show stables
-sql_error show databases union all show databases
+sql_error (show tables) union all (show tables)
+sql_error (show stables) union all (show stables)
+sql_error (show databases) union all (show databases)
 
 system sh/exec.sh -n dnode1 -s stop -x SIGINT

tests/script/tsim/parser/union_sysinfo.sim

+system sh/stop_dnodes.sh
+system sh/deploy.sh -n dnode1 -i 1
+system sh/exec.sh -n dnode1 -s start
+sql connect
+
+sql (select server_status()) union all (select server_status())
+if $rows != 2 then
+  return -1
+endi
+
+if $data00 != 1 then
+  return -1
+endi
+
+if $data10 != 1 then
+  return -1
+endi
+
+sql (select client_version()) union all (select server_version())
+if $rows != 2 then
+  return -1
+endi
+
+sql (select database()) union all (select database())
+if $rows != 2 then
+  return -1
+endi
+if $data00 != @union_db0@ then
+  return -1
+endi
+if $data10 != @union_db0@ then
+  return -1
+endi
+
+system sh/exec.sh -n dnode1 -s stop -x SIGINT

tests/script/tsim/stream/basic1.sim

@@ -391,13 +391,13 @@ if $data02 != 4 then
   return -1
 endi
 
-if $data03 != 14 then
-  print ======$data03
+if $data03 != 50 then
+  print ======$data03 != 50
   return -1
 endi
 
-if $data04 != 4 then
-  print ======$data04
+if $data04 != 20 then
+  print ======$data04 != 20
   return -1
 endi
 
@@ -421,13 +421,13 @@ if $data12 != 4 then
   return -1
 endi
 
-if $data13 != 10 then
-  print ======$data13
+if $data13 != 46 then
+  print ======$data13 != 46
   return -1
 endi
 
-if $data14 != 3 then
-  print ======$data14
+if $data14 != 20 then
+  print ======$data14 != 20
   return -1
 endi
 

tests/system-test/2-query/Now.py

@@ -12,24 +12,24 @@ class TDTestCase:
         tdSql.init(conn.cursor(),True)
         self.setsql = TDSetSql()
         # name of normal table
-        self.ntbname = 'ntb'    
+        self.ntbname = 'ntb'
         # name of stable
-        self.stbname = 'stb'    
+        self.stbname = 'stb'
         # structure of column
-        self.column_dict = {    
+        self.column_dict = {
             'ts':'timestamp',
             'c1':'int',
             'c2':'float',
             'c3':'double'
         }
         # structure of tag
-        self.tag_dict = {       
+        self.tag_dict = {
             't0':'int'
         }
         # number of child tables
-        self.tbnum = 2       
+        self.tbnum = 2
         # values of tag,the number of values should equal to tbnum
-        self.tag_values = [     
+        self.tag_values = [
             f'10',
             f'100'
         ]
@@ -43,7 +43,7 @@ class TDTestCase:
         self.db_percision = ['ms','us','ns']
     def tbtype_check(self,tb_type):
         if tb_type == 'normal table' or tb_type == 'child table':
-            tdSql.checkRows(len(self.values_list))  
+            tdSql.checkRows(len(self.values_list))
         elif tb_type == 'stable':
             tdSql.checkRows(len(self.values_list) * self.tbnum)
     def data_check(self,tbname,tb_type):
@@ -98,7 +98,7 @@ class TDTestCase:
 
         self.now_check_ntb()
         self.now_check_stb()
-        
+
     def stop(self):
         tdSql.close()
         tdLog.success(f"{__file__} successfully executed")

tests/system-test/2-query/distribute_agg_apercentile.py

@@ -2,11 +2,11 @@ from util.log import *
 from util.cases import *
 from util.sql import *
 import numpy as np
-import random 
+import random
 
 
 class TDTestCase:
-    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 , 
+    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 ,
     "jniDebugFlag":143 ,"simDebugFlag":143,"dDebugFlag":143, "dDebugFlag":143,"vDebugFlag":143,"mDebugFlag":143,"qDebugFlag":143,
     "wDebugFlag":143,"sDebugFlag":143,"tsdbDebugFlag":143,"tqDebugFlag":143 ,"fsDebugFlag":143 ,"udfDebugFlag":143,
     "maxTablesPerVnode":2 ,"minTablesPerVnode":2,"tableIncStepPerVnode":2 }
@@ -18,7 +18,7 @@ class TDTestCase:
         self.ts = 1537146000000
 
     def prepare_datas_of_distribute(self):
-        
+
         # prepate datas for  20 tables distributed at different vgroups
         tdSql.execute("create database if not exists testdb keep 3650 duration 1000 vgroups 5")
         tdSql.execute(" use testdb ")
@@ -89,17 +89,17 @@ class TDTestCase:
         vgroups = tdSql.queryResult
 
         vnode_tables={}
-        
+
         for vgroup_id in vgroups:
             vnode_tables[vgroup_id[0]]=[]
-        
+
 
         # check sub_table of per vnode ,make sure sub_table has been distributed
         tdSql.query("show tables like 'ct%'")
         table_names = tdSql.queryResult
         tablenames = []
         for table_name in table_names:
-            vnode_tables[table_name[6]].append(table_name[0]) 
+            vnode_tables[table_name[6]].append(table_name[0])
         self.vnode_disbutes = vnode_tables
 
         count = 0
@@ -108,7 +108,7 @@ class TDTestCase:
                 count+=1
         if count < 2:
             tdLog.exit(" the datas of all not satisfy sub_table has been distributed ")
-        
+
     def distribute_agg_query(self):
         # basic filter
         tdSql.query("select apercentile(c1 , 20) from stb1 where c1 is null")
@@ -129,12 +129,12 @@ class TDTestCase:
         tdSql.query("select apercentile(c1,20) from stb1 where t1> 4  partition by tbname")
         tdSql.checkRows(15)
 
-        # union all 
+        # union all
         tdSql.query("select apercentile(c1,20) from stb1 union all select apercentile(c1,20) from stb1 ")
         tdSql.checkRows(2)
         tdSql.checkData(0,0,7.389181281)
 
-        # join 
+        # join
 
         tdSql.execute(" create database if not exists db ")
         tdSql.execute(" use db ")
@@ -142,7 +142,7 @@ class TDTestCase:
         tdSql.execute(" create table tb1 using st tags(1) ")
         tdSql.execute(" create table tb2 using st tags(2) ")
 
-        
+
         for i in range(10):
             ts = i*10 + self.ts
             tdSql.execute(f" insert into tb1 values({ts},{i},{i}.0)")
@@ -153,7 +153,7 @@ class TDTestCase:
         tdSql.checkData(0,0,9.000000000)
         tdSql.checkData(0,0,9.000000000)
 
-        # group by 
+        # group by
         tdSql.execute(" use testdb ")
         tdSql.query(" select max(c1),c1  from stb1 group by t1 ")
         tdSql.checkRows(20)
@@ -189,7 +189,7 @@ class TDTestCase:
         self.check_distribute_datas()
         self.distribute_agg_query()
 
-    
+
     def stop(self):
         tdSql.close()
         tdLog.success("%s successfully executed" % __file__)

tests/system-test/2-query/distribute_agg_avg.py

@@ -7,7 +7,7 @@ import platform
 
 
 class TDTestCase:
-    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 , 
+    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 ,
     "jniDebugFlag":143 ,"simDebugFlag":143,"dDebugFlag":143, "dDebugFlag":143,"vDebugFlag":143,"mDebugFlag":143,"qDebugFlag":143,
     "wDebugFlag":143,"sDebugFlag":143,"tsdbDebugFlag":143,"tqDebugFlag":143 ,"fsDebugFlag":143 ,"udfDebugFlag":143,
     "maxTablesPerVnode":2 ,"minTablesPerVnode":2,"tableIncStepPerVnode":2 }
@@ -24,7 +24,7 @@ class TDTestCase:
         avg_sql = f"select avg({col_name}) from {tbname};"
 
         same_sql = f"select {col_name} from {tbname} where {col_name} is not null "
-   
+
         tdSql.query(same_sql)
         pre_data = np.array(tdSql.queryResult)[np.array(tdSql.queryResult) != None]
         if (platform.system().lower() == 'windows' and pre_data.dtype == 'int32'):
@@ -35,7 +35,7 @@ class TDTestCase:
         tdSql.checkData(0,0,pre_avg)
 
     def prepare_datas_of_distribute(self):
-        
+
         # prepate datas for  20 tables distributed at different vgroups
         tdSql.execute("create database if not exists testdb keep 3650 duration 1000 vgroups 5")
         tdSql.execute(" use testdb ")
@@ -106,17 +106,17 @@ class TDTestCase:
         vgroups = tdSql.queryResult
 
         vnode_tables={}
-        
+
         for vgroup_id in vgroups:
             vnode_tables[vgroup_id[0]]=[]
-        
+
 
         # check sub_table of per vnode ,make sure sub_table has been distributed
         tdSql.query("show tables like 'ct%'")
         table_names = tdSql.queryResult
         tablenames = []
         for table_name in table_names:
-            vnode_tables[table_name[6]].append(table_name[0]) 
+            vnode_tables[table_name[6]].append(table_name[0])
         self.vnode_disbutes = vnode_tables
 
         count = 0
@@ -127,14 +127,14 @@ class TDTestCase:
             tdLog.exit(" the datas of all not satisfy sub_table has been distributed ")
 
     def check_avg_distribute_diff_vnode(self,col_name):
-    
+
         vgroup_ids = []
         for k ,v in self.vnode_disbutes.items():
             if len(v)>=2:
                 vgroup_ids.append(k)
-        
+
         distribute_tbnames = []
-        
+
         for vgroup_id in vgroup_ids:
             vnode_tables = self.vnode_disbutes[vgroup_id]
             distribute_tbnames.append(random.sample(vnode_tables,1)[0])
@@ -143,7 +143,7 @@ class TDTestCase:
             tbname_ins += "'%s' ,"%tbname
 
         tbname_filters = tbname_ins[:-1]
-        
+
         avg_sql = f"select avg({col_name}) from stb1 where tbname in ({tbname_filters});"
 
         same_sql = f"select {col_name}  from stb1 where tbname in ({tbname_filters}) and {col_name} is not null "
@@ -158,8 +158,8 @@ class TDTestCase:
         tdSql.checkData(0,0,pre_avg)
 
     def check_avg_status(self):
-        # check max function work status 
-        
+        # check max function work status
+
         tdSql.query("show tables like 'ct%'")
         table_names = tdSql.queryResult
         tablenames = []
@@ -168,26 +168,26 @@ class TDTestCase:
 
         tdSql.query("desc stb1")
         col_names = tdSql.queryResult
-        
+
         colnames = []
         for col_name in col_names:
             if col_name[1] in ["INT" ,"BIGINT" ,"SMALLINT" ,"TINYINT" , "FLOAT" ,"DOUBLE"]:
                 colnames.append(col_name[0])
-        
+
         for tablename in tablenames:
             for colname in colnames:
                 self.check_avg_functions(tablename,colname)
 
-        # check max function for different vnode 
+        # check max function for different vnode
 
         for colname in colnames:
             if colname.startswith("c"):
                 self.check_avg_distribute_diff_vnode(colname)
             else:
-                # self.check_avg_distribute_diff_vnode(colname) # bug for tag 
+                # self.check_avg_distribute_diff_vnode(colname) # bug for tag
                 pass
 
-        
+
     def distribute_agg_query(self):
         # basic filter
         tdSql.query(" select avg(c1) from stb1 ")
@@ -211,7 +211,7 @@ class TDTestCase:
         tdSql.query("select avg(c1) from stb1 where t1> 4  partition by tbname")
         tdSql.checkRows(15)
 
-        # union all 
+        # union all
         tdSql.query("select avg(c1) from stb1 union all select avg(c1) from stb1 ")
         tdSql.checkRows(2)
         tdSql.checkData(0,0,14.086956522)
@@ -220,7 +220,7 @@ class TDTestCase:
         tdSql.checkRows(1)
         tdSql.checkData(0,0,14.086956522)
 
-        # join 
+        # join
 
         tdSql.execute(" create database if not exists db ")
         tdSql.execute(" use db ")
@@ -228,7 +228,7 @@ class TDTestCase:
         tdSql.execute(" create table tb1 using st tags(1) ")
         tdSql.execute(" create table tb2 using st tags(2) ")
 
-        
+
         for i in range(10):
             ts = i*10 + self.ts
             tdSql.execute(f" insert into tb1 values({ts},{i},{i}.0)")
@@ -239,7 +239,7 @@ class TDTestCase:
         tdSql.checkData(0,0,4.500000000)
         tdSql.checkData(0,1,4.500000000)
 
-        # group by 
+        # group by
         tdSql.execute(" use testdb ")
 
         # partition by tbname or partition by tag
@@ -270,7 +270,7 @@ class TDTestCase:
         self.check_avg_status()
         self.distribute_agg_query()
 
-    
+
     def stop(self):
         tdSql.close()
         tdLog.success("%s successfully executed" % __file__)

tests/system-test/2-query/distribute_agg_count.py

@@ -2,11 +2,11 @@ from util.log import *
 from util.cases import *
 from util.sql import *
 import numpy as np
-import random 
+import random
 
 
 class TDTestCase:
-    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 , 
+    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 ,
     "jniDebugFlag":143 ,"simDebugFlag":143,"dDebugFlag":143, "dDebugFlag":143,"vDebugFlag":143,"mDebugFlag":143,"qDebugFlag":143,
     "wDebugFlag":143,"sDebugFlag":143,"tsdbDebugFlag":143,"tqDebugFlag":143 ,"fsDebugFlag":143 ,"udfDebugFlag":143,
     "maxTablesPerVnode":2 ,"minTablesPerVnode":2,"tableIncStepPerVnode":2 }
@@ -25,7 +25,7 @@ class TDTestCase:
         same_sql = f"select sum(c) from (select {col_name} ,1 as c  from {tbname} where {col_name} is not null) "
 
         tdSql.query(max_sql)
-        max_result = tdSql.queryResult 
+        max_result = tdSql.queryResult
 
         tdSql.query(same_sql)
         same_result = tdSql.queryResult
@@ -37,7 +37,7 @@ class TDTestCase:
 
 
     def prepare_datas_of_distribute(self):
-        
+
         # prepate datas for  20 tables distributed at different vgroups
         tdSql.execute("create database if not exists testdb keep 3650 duration 1000 vgroups 5")
         tdSql.execute(" use testdb ")
@@ -108,17 +108,17 @@ class TDTestCase:
         vgroups = tdSql.queryResult
 
         vnode_tables={}
-        
+
         for vgroup_id in vgroups:
             vnode_tables[vgroup_id[0]]=[]
-        
+
 
         # check sub_table of per vnode ,make sure sub_table has been distributed
         tdSql.query("show tables like 'ct%'")
         table_names = tdSql.queryResult
         tablenames = []
         for table_name in table_names:
-            vnode_tables[table_name[6]].append(table_name[0]) 
+            vnode_tables[table_name[6]].append(table_name[0])
         self.vnode_disbutes = vnode_tables
 
         count = 0
@@ -129,14 +129,14 @@ class TDTestCase:
             tdLog.exit(" the datas of all not satisfy sub_table has been distributed ")
 
     def check_count_distribute_diff_vnode(self,col_name):
-    
+
         vgroup_ids = []
         for k ,v in self.vnode_disbutes.items():
             if len(v)>=2:
                 vgroup_ids.append(k)
-        
+
         distribute_tbnames = []
-        
+
         for vgroup_id in vgroup_ids:
             vnode_tables = self.vnode_disbutes[vgroup_id]
             distribute_tbnames.append(random.sample(vnode_tables,1)[0])
@@ -145,13 +145,13 @@ class TDTestCase:
             tbname_ins += "'%s' ,"%tbname
 
         tbname_filters = tbname_ins[:-1]
-        
+
         max_sql = f"select count({col_name}) from stb1 where tbname in ({tbname_filters});"
 
         same_sql = f"select sum(c) from (select {col_name} ,1 as c  from stb1 where tbname in ({tbname_filters}) and {col_name} is not null) "
 
         tdSql.query(max_sql)
-        max_result = tdSql.queryResult 
+        max_result = tdSql.queryResult
 
         tdSql.query(same_sql)
         same_result = tdSql.queryResult
@@ -162,8 +162,8 @@ class TDTestCase:
             tdLog.info(" count function work as expected, sql : %s "% max_sql)
 
     def check_count_status(self):
-        # check max function work status 
-        
+        # check max function work status
+
         tdSql.query("show tables like 'ct%'")
         table_names = tdSql.queryResult
         tablenames = []
@@ -172,26 +172,26 @@ class TDTestCase:
 
         tdSql.query("desc stb1")
         col_names = tdSql.queryResult
-        
+
         colnames = []
         for col_name in col_names:
             if col_name[1] in ["INT" ,"BIGINT" ,"SMALLINT" ,"TINYINT" , "FLOAT" ,"DOUBLE"]:
                 colnames.append(col_name[0])
-        
+
         for tablename in tablenames:
             for colname in colnames:
                 self.check_count_functions(tablename,colname)
 
-        # check max function for different vnode 
+        # check max function for different vnode
 
         for colname in colnames:
             if colname.startswith("c"):
                 self.check_count_distribute_diff_vnode(colname)
             else:
-                # self.check_count_distribute_diff_vnode(colname) # bug for tag 
+                # self.check_count_distribute_diff_vnode(colname) # bug for tag
                 pass
 
-        
+
     def distribute_agg_query(self):
         # basic filter
         tdSql.query("select count(c1) from stb1 ")
@@ -212,12 +212,12 @@ class TDTestCase:
         tdSql.query("select count(c1) from stb1 where t1> 4  partition by tbname")
         tdSql.checkRows(15)
 
-        # union all 
+        # union all
         tdSql.query("select count(c1) from stb1 union all select count(c1) from stb1 ")
         tdSql.checkRows(2)
         tdSql.checkData(0,0,184)
 
-        # join 
+        # join
 
         tdSql.execute(" create database if not exists db ")
         tdSql.execute(" use db ")
@@ -225,7 +225,7 @@ class TDTestCase:
         tdSql.execute(" create table tb1 using st tags(1) ")
         tdSql.execute(" create table tb2 using st tags(2) ")
 
-        
+
         for i in range(10):
             ts = i*10 + self.ts
             tdSql.execute(f" insert into tb1 values({ts},{i},{i}.0)")
@@ -236,7 +236,7 @@ class TDTestCase:
         tdSql.checkData(0,0,10)
         tdSql.checkData(0,1,10)
 
-        # group by 
+        # group by
         tdSql.execute(" use testdb ")
 
         tdSql.query(" select count(*)  from stb1 ")
@@ -251,7 +251,7 @@ class TDTestCase:
         # partition by tbname or partition by tag
         tdSql.query("select max(c1),tbname from stb1 partition by tbname")
         query_data = tdSql.queryResult
-        
+
         for row in query_data:
             tbname = row[1]
             tdSql.query(" select max(c1) from %s "%tbname)
@@ -259,7 +259,7 @@ class TDTestCase:
 
         tdSql.query("select max(c1),tbname from stb1 partition by t1")
         query_data = tdSql.queryResult
-        
+
         for row in query_data:
             tbname = row[1]
             tdSql.query(" select max(c1) from %s "%tbname)
@@ -287,7 +287,7 @@ class TDTestCase:
         self.check_count_status()
         self.distribute_agg_query()
 
-    
+
     def stop(self):
         tdSql.close()
         tdLog.success("%s successfully executed" % __file__)

tests/system-test/2-query/distribute_agg_max.py

@@ -2,11 +2,11 @@ from util.log import *
 from util.cases import *
 from util.sql import *
 import numpy as np
-import random 
+import random
 
 
 class TDTestCase:
-    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 , 
+    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 ,
     "jniDebugFlag":143 ,"simDebugFlag":143,"dDebugFlag":143, "dDebugFlag":143,"vDebugFlag":143,"mDebugFlag":143,"qDebugFlag":143,
     "wDebugFlag":143,"sDebugFlag":143,"tsdbDebugFlag":143,"tqDebugFlag":143 ,"fsDebugFlag":143 ,"udfDebugFlag":143,
     "maxTablesPerVnode":2 ,"minTablesPerVnode":2,"tableIncStepPerVnode":2 }
@@ -25,7 +25,7 @@ class TDTestCase:
         same_sql = f"select {col_name} from {tbname} order by {col_name} desc limit 1"
 
         tdSql.query(max_sql)
-        max_result = tdSql.queryResult 
+        max_result = tdSql.queryResult
 
         tdSql.query(same_sql)
         same_result = tdSql.queryResult
@@ -37,7 +37,7 @@ class TDTestCase:
 
 
     def prepare_datas_of_distribute(self):
-        
+
         # prepate datas for  20 tables distributed at different vgroups
         tdSql.execute("create database if not exists testdb keep 3650 duration 1000 vgroups 5")
         tdSql.execute(" use testdb ")
@@ -108,17 +108,17 @@ class TDTestCase:
         vgroups = tdSql.queryResult
 
         vnode_tables={}
-        
+
         for vgroup_id in vgroups:
             vnode_tables[vgroup_id[0]]=[]
-        
+
 
         # check sub_table of per vnode ,make sure sub_table has been distributed
         tdSql.query("show tables like 'ct%'")
         table_names = tdSql.queryResult
         tablenames = []
         for table_name in table_names:
-            vnode_tables[table_name[6]].append(table_name[0]) 
+            vnode_tables[table_name[6]].append(table_name[0])
         self.vnode_disbutes = vnode_tables
 
         count = 0
@@ -129,14 +129,14 @@ class TDTestCase:
             tdLog.exit(" the datas of all not satisfy sub_table has been distributed ")
 
     def check_max_distribute_diff_vnode(self,col_name):
-    
+
         vgroup_ids = []
         for k ,v in self.vnode_disbutes.items():
             if len(v)>=2:
                 vgroup_ids.append(k)
-        
+
         distribute_tbnames = []
-        
+
         for vgroup_id in vgroup_ids:
             vnode_tables = self.vnode_disbutes[vgroup_id]
             distribute_tbnames.append(random.sample(vnode_tables,1)[0])
@@ -145,13 +145,13 @@ class TDTestCase:
             tbname_ins += "'%s' ,"%tbname
 
         tbname_filters = tbname_ins[:-1]
-        
+
         max_sql = f"select max({col_name}) from stb1 where tbname in ({tbname_filters});"
 
         same_sql = f"select {col_name} from stb1 where tbname in ({tbname_filters}) order by {col_name} desc limit 1"
 
         tdSql.query(max_sql)
-        max_result = tdSql.queryResult 
+        max_result = tdSql.queryResult
 
         tdSql.query(same_sql)
         same_result = tdSql.queryResult
@@ -162,8 +162,8 @@ class TDTestCase:
             tdLog.info(" max function work as expected, sql : %s "% max_sql)
 
     def check_max_status(self):
-        # check max function work status 
-        
+        # check max function work status
+
         tdSql.query("show tables like 'ct%'")
         table_names = tdSql.queryResult
         tablenames = []
@@ -172,26 +172,26 @@ class TDTestCase:
 
         tdSql.query("desc stb1")
         col_names = tdSql.queryResult
-        
+
         colnames = []
         for col_name in col_names:
             if col_name[1] in ["INT" ,"BIGINT" ,"SMALLINT" ,"TINYINT" , "FLOAT" ,"DOUBLE"]:
                 colnames.append(col_name[0])
-        
+
         for tablename in tablenames:
             for colname in colnames:
                 self.check_max_functions(tablename,colname)
 
-        # check max function for different vnode 
+        # check max function for different vnode
 
         for colname in colnames:
             if colname.startswith("c"):
                 self.check_max_distribute_diff_vnode(colname)
             else:
-                # self.check_max_distribute_diff_vnode(colname) # bug for tag 
+                # self.check_max_distribute_diff_vnode(colname) # bug for tag
                 pass
 
-        
+
     def distribute_agg_query(self):
         # basic filter
         tdSql.query("select max(c1) from stb1 where c1 is null")
@@ -212,12 +212,12 @@ class TDTestCase:
         tdSql.query("select max(c1) from stb1 where t1> 4  partition by tbname")
         tdSql.checkRows(15)
 
-        # union all 
+        # union all
         tdSql.query("select max(c1) from stb1 union all select max(c1) from stb1 ")
         tdSql.checkRows(2)
         tdSql.checkData(0,0,28)
 
-        # join 
+        # join
 
         tdSql.execute(" create database if not exists db ")
         tdSql.execute(" use db ")
@@ -225,7 +225,7 @@ class TDTestCase:
         tdSql.execute(" create table tb1 using st tags(1) ")
         tdSql.execute(" create table tb2 using st tags(2) ")
 
-        
+
         for i in range(10):
             ts = i*10 + self.ts
             tdSql.execute(f" insert into tb1 values({ts},{i},{i}.0)")
@@ -236,7 +236,7 @@ class TDTestCase:
         tdSql.checkData(0,0,9)
         tdSql.checkData(0,0,9.00000)
 
-        # group by 
+        # group by
         tdSql.execute(" use testdb ")
         tdSql.query(" select max(c1),c1  from stb1 group by t1 ")
         tdSql.checkRows(20)
@@ -263,13 +263,13 @@ class TDTestCase:
         tdSql.checkRows(1)
         tdSql.checkData(0,0,28)
         tdSql.checkData(0,1,19)
-        tdSql.checkData(0,2,311110.000000000)   
-        tdSql.checkData(0,3,2109)  
+        tdSql.checkData(0,2,311110.000000000)
+        tdSql.checkData(0,3,2109)
 
         # partition by tbname or partition by tag
         tdSql.query("select max(c1),tbname from stb1 partition by tbname")
         query_data = tdSql.queryResult
-        
+
         for row in query_data:
             tbname = row[1]
             tdSql.query(" select max(c1) from %s "%tbname)
@@ -277,7 +277,7 @@ class TDTestCase:
 
         tdSql.query("select max(c1),tbname from stb1 partition by t1")
         query_data = tdSql.queryResult
-        
+
         for row in query_data:
             tbname = row[1]
             tdSql.query(" select max(c1) from %s "%tbname)
@@ -305,7 +305,7 @@ class TDTestCase:
         self.check_max_status()
         self.distribute_agg_query()
 
-    
+
     def stop(self):
         tdSql.close()
         tdLog.success("%s successfully executed" % __file__)

tests/system-test/2-query/distribute_agg_min.py

@@ -2,11 +2,11 @@ from util.log import *
 from util.cases import *
 from util.sql import *
 import numpy as np
-import random 
+import random
 
 
 class TDTestCase:
-    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 , 
+    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 ,
     "jniDebugFlag":143 ,"simDebugFlag":143,"dDebugFlag":143, "dDebugFlag":143,"vDebugFlag":143,"mDebugFlag":143,"qDebugFlag":143,
     "wDebugFlag":143,"sDebugFlag":143,"tsdbDebugFlag":143,"tqDebugFlag":143 ,"fsDebugFlag":143 ,"udfDebugFlag":143,
     "maxTablesPerVnode":2 ,"minTablesPerVnode":2,"tableIncStepPerVnode":2 }
@@ -25,7 +25,7 @@ class TDTestCase:
         same_sql = f"select {col_name} from {tbname} where {col_name} is not null order by {col_name} asc limit 1"
 
         tdSql.query(min_sql)
-        min_result = tdSql.queryResult 
+        min_result = tdSql.queryResult
 
         tdSql.query(same_sql)
         same_result = tdSql.queryResult
@@ -37,7 +37,7 @@ class TDTestCase:
 
 
     def prepare_datas_of_distribute(self):
-        
+
         # prepate datas for  20 tables distributed at different vgroups
         tdSql.execute("create database if not exists testdb keep 3650 duration 1000 vgroups 5")
         tdSql.execute(" use testdb ")
@@ -108,17 +108,17 @@ class TDTestCase:
         vgroups = tdSql.queryResult
 
         vnode_tables={}
-        
+
         for vgroup_id in vgroups:
             vnode_tables[vgroup_id[0]]=[]
-        
+
 
         # check sub_table of per vnode ,make sure sub_table has been distributed
         tdSql.query("show tables like 'ct%'")
         table_names = tdSql.queryResult
         tablenames = []
         for table_name in table_names:
-            vnode_tables[table_name[6]].append(table_name[0]) 
+            vnode_tables[table_name[6]].append(table_name[0])
         self.vnode_disbutes = vnode_tables
 
         count = 0
@@ -129,14 +129,14 @@ class TDTestCase:
             tdLog.exit(" the datas of all not satisfy sub_table has been distributed ")
 
     def check_min_distribute_diff_vnode(self,col_name):
-    
+
         vgroup_ids = []
         for k ,v in self.vnode_disbutes.items():
             if len(v)>=2:
                 vgroup_ids.append(k)
-        
+
         distribute_tbnames = []
-        
+
         for vgroup_id in vgroup_ids:
             vnode_tables = self.vnode_disbutes[vgroup_id]
             distribute_tbnames.append(random.sample(vnode_tables,1)[0])
@@ -145,13 +145,13 @@ class TDTestCase:
             tbname_ins += "'%s' ,"%tbname
 
         tbname_filters = tbname_ins[:-1]
-        
+
         min_sql = f"select min({col_name}) from stb1 where tbname in ({tbname_filters});"
 
         same_sql = f"select {col_name} from stb1 where tbname in ({tbname_filters}) and {col_name} is not null order by {col_name} asc limit 1"
 
         tdSql.query(min_sql)
-        min_result = tdSql.queryResult 
+        min_result = tdSql.queryResult
 
         tdSql.query(same_sql)
         same_result = tdSql.queryResult
@@ -162,8 +162,8 @@ class TDTestCase:
             tdLog.info(" min function work as expected, sql : %s "% min_sql)
 
     def check_min_status(self):
-        # check max function work status 
-        
+        # check max function work status
+
         tdSql.query("show tables like 'ct%'")
         table_names = tdSql.queryResult
         tablenames = []
@@ -172,26 +172,26 @@ class TDTestCase:
 
         tdSql.query("desc stb1")
         col_names = tdSql.queryResult
-        
+
         colnames = []
         for col_name in col_names:
             if col_name[1] in ["INT" ,"BIGINT" ,"SMALLINT" ,"TINYINT" , "FLOAT" ,"DOUBLE"]:
                 colnames.append(col_name[0])
-        
+
         for tablename in tablenames:
             for colname in colnames:
                 self.check_min_functions(tablename,colname)
 
-        # check max function for different vnode 
+        # check max function for different vnode
 
         for colname in colnames:
             if colname.startswith("c"):
                 self.check_min_distribute_diff_vnode(colname)
             else:
-                # self.check_min_distribute_diff_vnode(colname) # bug for tag 
+                # self.check_min_distribute_diff_vnode(colname) # bug for tag
                 pass
 
-        
+
     def distribute_agg_query(self):
         # basic filter
         tdSql.query("select min(c1) from stb1 where c1 is null")
@@ -212,12 +212,12 @@ class TDTestCase:
         tdSql.query("select min(c1) from stb1 where t1> 4  partition by tbname")
         tdSql.checkRows(15)
 
-        # union all 
+        # union all
         tdSql.query("select min(c1) from stb1 union all select min(c1) from stb1 ")
         tdSql.checkRows(2)
         tdSql.checkData(0,0,0)
 
-        # join 
+        # join
 
         tdSql.execute(" create database if not exists db ")
         tdSql.execute(" use db ")
@@ -225,7 +225,7 @@ class TDTestCase:
         tdSql.execute(" create table tb1 using st tags(1) ")
         tdSql.execute(" create table tb2 using st tags(2) ")
 
-        
+
         for i in range(10):
             ts = i*10 + self.ts
             tdSql.execute(f" insert into tb1 values({ts},{i},{i}.0)")
@@ -236,7 +236,7 @@ class TDTestCase:
         tdSql.checkData(0,0,0)
         tdSql.checkData(0,0,0.00000)
 
-        # group by 
+        # group by
         tdSql.execute(" use testdb ")
         tdSql.query(" select min(c1),c1  from stb1 group by t1 ")
         tdSql.checkRows(20)
@@ -261,12 +261,12 @@ class TDTestCase:
         tdSql.query("select min(c1),ceil(t1),pow(c2,1)+2,abs(t3) from stb1 where c1>12")
         tdSql.checkRows(1)
         tdSql.checkData(0,0,13)
-        tdSql.checkData(0,2,144445.000000000)   
-   
+        tdSql.checkData(0,2,144445.000000000)
+
         # partition by tbname or partition by tag
         tdSql.query("select min(c1),tbname from stb1 partition by tbname")
         query_data = tdSql.queryResult
-        
+
         for row in query_data:
             tbname = row[1]
             tdSql.query(" select min(c1) from %s "%tbname)
@@ -274,7 +274,7 @@ class TDTestCase:
 
         tdSql.query("select min(c1),tbname from stb1 partition by t1")
         query_data = tdSql.queryResult
-        
+
         for row in query_data:
             tbname = row[1]
             tdSql.query(" select min(c1) from %s "%tbname)
@@ -303,7 +303,7 @@ class TDTestCase:
         self.check_min_status()
         self.distribute_agg_query()
 
-    
+
     def stop(self):
         tdSql.close()
         tdLog.success("%s successfully executed" % __file__)

tests/system-test/2-query/distribute_agg_spread.py

@@ -2,11 +2,11 @@ from util.log import *
 from util.cases import *
 from util.sql import *
 import numpy as np
-import random 
+import random
 
 
 class TDTestCase:
-    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 , 
+    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 ,
     "jniDebugFlag":143 ,"simDebugFlag":143,"dDebugFlag":143, "dDebugFlag":143,"vDebugFlag":143,"mDebugFlag":143,"qDebugFlag":143,
     "wDebugFlag":143,"sDebugFlag":143,"tsdbDebugFlag":143,"tqDebugFlag":143 ,"fsDebugFlag":143 ,"udfDebugFlag":143,
     "maxTablesPerVnode":2 ,"minTablesPerVnode":2,"tableIncStepPerVnode":2 }
@@ -25,7 +25,7 @@ class TDTestCase:
         same_sql = f"select max({col_name})-min({col_name}) from {tbname}"
 
         tdSql.query(spread_sql)
-        spread_result = tdSql.queryResult 
+        spread_result = tdSql.queryResult
 
         tdSql.query(same_sql)
         same_result = tdSql.queryResult
@@ -37,7 +37,7 @@ class TDTestCase:
 
 
     def prepare_datas_of_distribute(self):
-        
+
         # prepate datas for  20 tables distributed at different vgroups
         tdSql.execute("create database if not exists testdb keep 3650 duration 1000 vgroups 5")
         tdSql.execute(" use testdb ")
@@ -108,17 +108,17 @@ class TDTestCase:
         vgroups = tdSql.queryResult
 
         vnode_tables={}
-        
+
         for vgroup_id in vgroups:
             vnode_tables[vgroup_id[0]]=[]
-        
+
 
         # check sub_table of per vnode ,make sure sub_table has been distributed
         tdSql.query("show tables like 'ct%'")
         table_names = tdSql.queryResult
         tablenames = []
         for table_name in table_names:
-            vnode_tables[table_name[6]].append(table_name[0]) 
+            vnode_tables[table_name[6]].append(table_name[0])
         self.vnode_disbutes = vnode_tables
 
         count = 0
@@ -129,14 +129,14 @@ class TDTestCase:
             tdLog.exit(" the datas of all not satisfy sub_table has been distributed ")
 
     def check_spread_distribute_diff_vnode(self,col_name):
-    
+
         vgroup_ids = []
         for k ,v in self.vnode_disbutes.items():
             if len(v)>=2:
                 vgroup_ids.append(k)
-        
+
         distribute_tbnames = []
-        
+
         for vgroup_id in vgroup_ids:
             vnode_tables = self.vnode_disbutes[vgroup_id]
             distribute_tbnames.append(random.sample(vnode_tables,1)[0])
@@ -145,13 +145,13 @@ class TDTestCase:
             tbname_ins += "'%s' ,"%tbname
 
         tbname_filters = tbname_ins[:-1]
-        
+
         spread_sql = f"select spread({col_name}) from stb1 where tbname in ({tbname_filters})"
 
         same_sql = f"select max({col_name}) - min({col_name}) from stb1 where tbname in ({tbname_filters})"
 
         tdSql.query(spread_sql)
-        spread_result = tdSql.queryResult 
+        spread_result = tdSql.queryResult
 
         tdSql.query(same_sql)
         same_result = tdSql.queryResult
@@ -162,8 +162,8 @@ class TDTestCase:
             tdLog.info(" spread function work as expected, sql : %s "% spread_sql)
 
     def check_spread_status(self):
-        # check max function work status 
-        
+        # check max function work status
+
         tdSql.query("show tables like 'ct%'")
         table_names = tdSql.queryResult
         tablenames = []
@@ -172,26 +172,26 @@ class TDTestCase:
 
         tdSql.query("desc stb1")
         col_names = tdSql.queryResult
-        
+
         colnames = []
         for col_name in col_names:
             if col_name[1] in ["INT" ,"BIGINT" ,"SMALLINT" ,"TINYINT" , "FLOAT" ,"DOUBLE"]:
                 colnames.append(col_name[0])
-        
+
         for tablename in tablenames:
             for colname in colnames:
                 self.check_spread_functions(tablename,colname)
 
-        # check max function for different vnode 
+        # check max function for different vnode
 
         for colname in colnames:
             if colname.startswith("c"):
                 self.check_spread_distribute_diff_vnode(colname)
             else:
-                # self.check_spread_distribute_diff_vnode(colname) # bug for tag 
+                # self.check_spread_distribute_diff_vnode(colname) # bug for tag
                 pass
 
-        
+
     def distribute_agg_query(self):
         # basic filter
         tdSql.query("select spread(c1) from stb1 where c1 is null")
@@ -212,12 +212,12 @@ class TDTestCase:
         tdSql.query("select spread(c1) from stb1 where t1> 4  partition by tbname")
         tdSql.checkRows(15)
 
-        # union all 
+        # union all
         tdSql.query("select spread(c1) from stb1 union all select max(c1)-min(c1) from stb1 ")
         tdSql.checkRows(2)
         tdSql.checkData(0,0,28.000000000)
 
-        # join 
+        # join
 
         tdSql.execute(" create database if not exists db ")
         tdSql.execute(" use db ")
@@ -225,7 +225,7 @@ class TDTestCase:
         tdSql.execute(" create table tb1 using st tags(1) ")
         tdSql.execute(" create table tb2 using st tags(2) ")
 
-        
+
         for i in range(10):
             ts = i*10 + self.ts
             tdSql.execute(f" insert into tb1 values({ts},{i},{i}.0)")
@@ -236,7 +236,7 @@ class TDTestCase:
         tdSql.checkData(0,0,9.000000000)
         tdSql.checkData(0,0,9.00000)
 
-        # group by 
+        # group by
         tdSql.execute(" use testdb ")
         tdSql.query(" select max(c1),c1  from stb1 group by t1 ")
         tdSql.checkRows(20)
@@ -272,7 +272,7 @@ class TDTestCase:
         self.check_spread_status()
         self.distribute_agg_query()
 
-    
+
     def stop(self):
         tdSql.close()
         tdLog.success("%s successfully executed" % __file__)

tests/system-test/2-query/distribute_agg_sum.py

@@ -7,7 +7,7 @@ import platform
 
 
 class TDTestCase:
-    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 , 
+    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 ,
     "jniDebugFlag":143 ,"simDebugFlag":143,"dDebugFlag":143, "dDebugFlag":143,"vDebugFlag":143,"mDebugFlag":143,"qDebugFlag":143,
     "wDebugFlag":143,"sDebugFlag":143,"tsdbDebugFlag":143,"tqDebugFlag":143 ,"fsDebugFlag":143 ,"udfDebugFlag":143,
     "maxTablesPerVnode":2 ,"minTablesPerVnode":2,"tableIncStepPerVnode":2 }
@@ -24,7 +24,7 @@ class TDTestCase:
         sum_sql = f"select sum({col_name}) from {tbname};"
 
         same_sql = f"select {col_name} from {tbname} where {col_name} is not null "
-   
+
         tdSql.query(same_sql)
         pre_data = np.array(tdSql.queryResult)[np.array(tdSql.queryResult) != None]
         if (platform.system().lower() == 'windows' and pre_data.dtype == 'int32'):
@@ -35,7 +35,7 @@ class TDTestCase:
         tdSql.checkData(0,0,pre_sum)
 
     def prepare_datas_of_distribute(self):
-        
+
         # prepate datas for  20 tables distributed at different vgroups
         tdSql.execute("create database if not exists testdb keep 3650 duration 1000 vgroups 5")
         tdSql.execute(" use testdb ")
@@ -106,17 +106,17 @@ class TDTestCase:
         vgroups = tdSql.queryResult
 
         vnode_tables={}
-        
+
         for vgroup_id in vgroups:
             vnode_tables[vgroup_id[0]]=[]
-        
+
 
         # check sub_table of per vnode ,make sure sub_table has been distributed
         tdSql.query("show tables like 'ct%'")
         table_names = tdSql.queryResult
         tablenames = []
         for table_name in table_names:
-            vnode_tables[table_name[6]].append(table_name[0]) 
+            vnode_tables[table_name[6]].append(table_name[0])
         self.vnode_disbutes = vnode_tables
 
         count = 0
@@ -127,14 +127,14 @@ class TDTestCase:
             tdLog.exit(" the datas of all not satisfy sub_table has been distributed ")
 
     def check_sum_distribute_diff_vnode(self,col_name):
-    
+
         vgroup_ids = []
         for k ,v in self.vnode_disbutes.items():
             if len(v)>=2:
                 vgroup_ids.append(k)
-        
+
         distribute_tbnames = []
-        
+
         for vgroup_id in vgroup_ids:
             vnode_tables = self.vnode_disbutes[vgroup_id]
             distribute_tbnames.append(random.sample(vnode_tables,1)[0])
@@ -143,7 +143,7 @@ class TDTestCase:
             tbname_ins += "'%s' ,"%tbname
 
         tbname_filters = tbname_ins[:-1]
-        
+
         sum_sql = f"select sum({col_name}) from stb1 where tbname in ({tbname_filters});"
 
         same_sql = f"select {col_name}  from stb1 where tbname in ({tbname_filters}) and {col_name} is not null "
@@ -158,8 +158,8 @@ class TDTestCase:
         tdSql.checkData(0,0,pre_sum)
 
     def check_sum_status(self):
-        # check max function work status 
-        
+        # check max function work status
+
         tdSql.query("show tables like 'ct%'")
         table_names = tdSql.queryResult
         tablenames = []
@@ -168,26 +168,26 @@ class TDTestCase:
 
         tdSql.query("desc stb1")
         col_names = tdSql.queryResult
-        
+
         colnames = []
         for col_name in col_names:
             if col_name[1] in ["INT" ,"BIGINT" ,"SMALLINT" ,"TINYINT" , "FLOAT" ,"DOUBLE"]:
                 colnames.append(col_name[0])
-        
+
         for tablename in tablenames:
             for colname in colnames:
                 self.check_sum_functions(tablename,colname)
 
-        # check max function for different vnode 
+        # check max function for different vnode
 
         for colname in colnames:
             if colname.startswith("c"):
                 self.check_sum_distribute_diff_vnode(colname)
             else:
-                # self.check_sum_distribute_diff_vnode(colname) # bug for tag 
+                # self.check_sum_distribute_diff_vnode(colname) # bug for tag
                 pass
 
-        
+
     def distribute_agg_query(self):
         # basic filter
         tdSql.query(" select sum(c1) from stb1 ")
@@ -211,7 +211,7 @@ class TDTestCase:
         tdSql.query("select sum(c1) from stb1 where t1> 4  partition by tbname")
         tdSql.checkRows(15)
 
-        # union all 
+        # union all
         tdSql.query("select sum(c1) from stb1 union all select sum(c1) from stb1 ")
         tdSql.checkRows(2)
         tdSql.checkData(0,0,2592)
@@ -220,7 +220,7 @@ class TDTestCase:
         tdSql.checkRows(1)
         tdSql.checkData(0,0,5184)
 
-        # join 
+        # join
 
         tdSql.execute(" create database if not exists db ")
         tdSql.execute(" use db ")
@@ -228,7 +228,7 @@ class TDTestCase:
         tdSql.execute(" create table tb1 using st tags(1) ")
         tdSql.execute(" create table tb2 using st tags(2) ")
 
-        
+
         for i in range(10):
             ts = i*10 + self.ts
             tdSql.execute(f" insert into tb1 values({ts},{i},{i}.0)")
@@ -239,7 +239,7 @@ class TDTestCase:
         tdSql.checkData(0,0,45)
         tdSql.checkData(0,1,45.000000000)
 
-        # group by 
+        # group by
         tdSql.execute(" use testdb ")
 
         # partition by tbname or partition by tag
@@ -269,7 +269,7 @@ class TDTestCase:
         self.check_sum_status()
         self.distribute_agg_query()
 
-    
+
     def stop(self):
         tdSql.close()
         tdLog.success("%s successfully executed" % __file__)

tests/system-test/2-query/irate.py

@@ -23,7 +23,7 @@ class TDTestCase:
         self.time_step = 1000
 
     def insert_datas_and_check_irate(self ,tbnums , rownums , time_step ):
-    
+
         tdLog.info(" prepare datas for auto check irate function ")
 
         tdSql.execute(" create database test ")
@@ -48,7 +48,7 @@ class TDTestCase:
                 c9 = "'nchar_val'"
                 c10 = ts
                 tdSql.execute(f" insert into  {tbname} values ({ts},{c1},{c2},{c3},{c4},{c5},{c6},{c7},{c8},{c9},{c10})")
-                
+
         tdSql.execute("use test")
         tbnames = ["stb", "sub_tb_1"]
         support_types = ["BIGINT", "SMALLINT", "TINYINT", "FLOAT", "DOUBLE", "INT"]
@@ -204,11 +204,11 @@ class TDTestCase:
         # used for sub table
         tdSql.query("select irate(abs(c1+c2)) from ct1")
         tdSql.checkData(0, 0, 0.000000000)
-   
+
 
         # mix with common col
         tdSql.error("select c1, irate(c1) from ct1")
-   
+
         # mix with common functions
         tdSql.error("select irate(c1), abs(c1) from ct4 ")
 
@@ -236,7 +236,7 @@ class TDTestCase:
             "select irate(c1+c2)/10 from stb1 where c1 = 5 partition by tbname ")
         tdSql.checkRows(2)
         tdSql.checkData(0, 0, 0.000000000)
-      
+
 
     def irate_Arithmetic(self):
         pass

tests/system-test/2-query/log.py

@@ -10,13 +10,13 @@ from util.cases import *
 
 
 class TDTestCase:
-    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 , 
+    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 ,
     "jniDebugFlag":143 ,"simDebugFlag":143,"dDebugFlag":143, "dDebugFlag":143,"vDebugFlag":143,"mDebugFlag":143,"qDebugFlag":143,
     "wDebugFlag":143,"sDebugFlag":143,"tsdbDebugFlag":143,"tqDebugFlag":143 ,"fsDebugFlag":143 ,"udfDebugFlag":143}
     def init(self, conn, logSql):
         tdLog.debug(f"start to excute {__file__}")
         tdSql.init(conn.cursor())
-    
+
     def prepare_datas(self):
         tdSql.execute(
             '''create table stb1
@@ -24,7 +24,7 @@ class TDTestCase:
             tags (t1 int)
             '''
         )
-        
+
         tdSql.execute(
             '''
             create table t1
@@ -69,12 +69,12 @@ class TDTestCase:
 
 
     def check_result_auto_log(self ,origin_query , log_query):
-    
+
         log_result = tdSql.getResult(log_query)
         origin_result = tdSql.getResult(origin_query)
 
         auto_result =[]
-        
+
         for row in origin_result:
             row_check = []
             for elem in row:
@@ -91,20 +91,20 @@ class TDTestCase:
         for row_index , row in enumerate(log_result):
             for col_index , elem in enumerate(row):
                 if auto_result[row_index][col_index] != elem:
-                    check_status = False 
+                    check_status = False
         if not check_status:
             tdLog.notice("log function value has not as expected , sql is \"%s\" "%log_query )
             sys.exit(1)
         else:
             tdLog.info("log value check pass , it work as expected ,sql is \"%s\"   "%log_query )
-    
+
     def check_result_auto_log2(self ,origin_query , log_query):
 
         log_result = tdSql.getResult(log_query)
         origin_result = tdSql.getResult(origin_query)
 
         auto_result =[]
-        
+
         for row in origin_result:
             row_check = []
             for elem in row:
@@ -121,7 +121,7 @@ class TDTestCase:
         for row_index , row in enumerate(log_result):
             for col_index , elem in enumerate(row):
                 if auto_result[row_index][col_index] != elem:
-                    check_status = False 
+                    check_status = False
         if not check_status:
             tdLog.notice("log function value has not as expected , sql is \"%s\" "%log_query )
             sys.exit(1)
@@ -133,7 +133,7 @@ class TDTestCase:
         origin_result = tdSql.getResult(origin_query)
 
         auto_result =[]
-        
+
         for row in origin_result:
             row_check = []
             for elem in row:
@@ -150,7 +150,7 @@ class TDTestCase:
         for row_index , row in enumerate(log_result):
             for col_index , elem in enumerate(row):
                 if auto_result[row_index][col_index] != elem:
-                    check_status = False 
+                    check_status = False
         if not check_status:
             tdLog.notice("log function value has not as expected , sql is \"%s\" "%log_query )
             sys.exit(1)
@@ -161,7 +161,7 @@ class TDTestCase:
         origin_result = tdSql.getResult(origin_query)
 
         auto_result =[]
-        
+
         for row in origin_result:
             row_check = []
             for elem in row:
@@ -178,13 +178,13 @@ class TDTestCase:
         for row_index , row in enumerate(log_result):
             for col_index , elem in enumerate(row):
                 if auto_result[row_index][col_index] != elem:
-                    check_status = False 
+                    check_status = False
         if not check_status:
             tdLog.notice("log function value has not as expected , sql is \"%s\" "%log_query )
             sys.exit(1)
         else:
             tdLog.info("log value check pass , it work as expected ,sql is \"%s\"   "%log_query )
-        
+
     def test_errors(self):
         error_sql_lists = [
             "select log from t1",
@@ -218,42 +218,42 @@ class TDTestCase:
         ]
         for error_sql in error_sql_lists:
             tdSql.error(error_sql)
-    
+
     def support_types(self):
         type_error_sql_lists = [
-            "select log(ts ,2 ) from t1" , 
+            "select log(ts ,2 ) from t1" ,
             "select log(c7,c2 ) from t1",
             "select log(c8,c1 ) from t1",
             "select log(c9,c2 ) from t1",
-            "select log(ts,c7 ) from ct1" , 
+            "select log(ts,c7 ) from ct1" ,
             "select log(c7,c9 ) from ct1",
             "select log(c8,c2 ) from ct1",
             "select log(c9,c1 ) from ct1",
-            "select log(ts,2 ) from ct3" , 
+            "select log(ts,2 ) from ct3" ,
             "select log(c7,2 ) from ct3",
             "select log(c8,2 ) from ct3",
             "select log(c9,2 ) from ct3",
-            "select log(ts,2 ) from ct4" , 
+            "select log(ts,2 ) from ct4" ,
             "select log(c7,2 ) from ct4",
             "select log(c8,2 ) from ct4",
             "select log(c9,2 ) from ct4",
-            "select log(ts,2 ) from stb1" , 
+            "select log(ts,2 ) from stb1" ,
             "select log(c7,2 ) from stb1",
             "select log(c8,2 ) from stb1",
             "select log(c9,2 ) from stb1" ,
 
-            "select log(ts,2 ) from stbbb1" , 
+            "select log(ts,2 ) from stbbb1" ,
             "select log(c7,2 ) from stbbb1",
 
             "select log(ts,2 ) from tbname",
             "select log(c9,2 ) from tbname"
 
         ]
-        
+
         for type_sql in type_error_sql_lists:
             tdSql.error(type_sql)
-        
-        
+
+
         type_sql_lists = [
             "select log(c1,2 ) from t1",
             "select log(c2,2 ) from t1",
@@ -283,16 +283,16 @@ class TDTestCase:
             "select log(c5,2 ) from stb1",
             "select log(c6,2 ) from stb1",
 
-            "select log(c6,2) as alisb from stb1", 
-            "select log(c6,2) alisb from stb1", 
+            "select log(c6,2) as alisb from stb1",
+            "select log(c6,2) alisb from stb1",
         ]
 
         for type_sql in type_sql_lists:
             tdSql.query(type_sql)
-    
+
     def basic_log_function(self):
 
-        # basic query 
+        # basic query
         tdSql.query("select c1 from ct3")
         tdSql.checkRows(0)
         tdSql.query("select c1 from t1")
@@ -344,7 +344,7 @@ class TDTestCase:
         self.check_result_auto_log2( "select c1, c2, c3 , c4, c5 from t1", "select log(c1 ,2), log(c2 ,2) ,log(c3, 2), log(c4 ,2), log(c5 ,2) from t1")
         self.check_result_auto_log1( "select c1, c2, c3 , c4, c5 from t1", "select log(c1 ,1), log(c2 ,1) ,log(c3, 1), log(c4 ,1), log(c5 ,1) from t1")
         self.check_result_auto_log__10( "select c1, c2, c3 , c4, c5 from t1", "select log(c1 ,-10), log(c2 ,-10) ,log(c3, -10), log(c4 ,-10), log(c5 ,-10) from t1")
-        
+
         # used for sub table
         tdSql.query("select c1 ,log(c1 ,3) from ct1")
         tdSql.checkData(0, 1, 1.892789261)
@@ -382,18 +382,18 @@ class TDTestCase:
         tdSql.checkData(4 , 2 , None)
         tdSql.checkData(4 , 3 , None)
 
-        # # used for stable table 
-        
+        # # used for stable table
+
         tdSql.query("select log(c1, 2) from stb1")
         tdSql.checkRows(25)
-      
+
 
         # used for not exists table
         tdSql.error("select log(c1, 2) from stbbb1")
         tdSql.error("select log(c1, 2) from tbname")
         tdSql.error("select log(c1, 2) from ct5")
 
-        # mix with common col 
+        # mix with common col
         tdSql.query("select c1, log(c1 ,2) from ct1")
         tdSql.checkData(0 , 0 ,8)
         tdSql.checkData(0 , 1 ,3.000000000)
@@ -418,7 +418,7 @@ class TDTestCase:
         tdSql.checkData(0 , 1 ,None)
         tdSql.checkData(0 , 2 ,None)
         tdSql.checkData(0 , 3 ,None)
-        
+
         tdSql.checkData(3 , 0 , 6)
         tdSql.checkData(3 , 1 , 2.584962501)
         tdSql.checkData(3 , 2 ,6.66000)
@@ -439,7 +439,7 @@ class TDTestCase:
         tdSql.query("select max(c5), count(c5) from stb1")
         tdSql.query("select max(c5), count(c5) from ct1")
 
-        
+
         # bug fix for count
         tdSql.query("select count(c1) from ct4 ")
         tdSql.checkData(0,0,9)
@@ -450,7 +450,7 @@ class TDTestCase:
         tdSql.query("select count(*) from stb1 ")
         tdSql.checkData(0,0,25)
 
-        # # bug fix for compute 
+        # # bug fix for compute
         tdSql.query("select c1, log(c1 ,2) -0 ,log(c1-4 ,2)-0 from ct4 ")
         tdSql.checkData(0, 0, None)
         tdSql.checkData(0, 1, None)
@@ -507,40 +507,40 @@ class TDTestCase:
         # base is an regular number ,int or double
         tdSql.query("select c1, log(c1, 2) from ct1")
         tdSql.checkData(0, 1,3.000000000)
-        tdSql.query("select c1, log(c1, 2.0) from ct1")  
+        tdSql.query("select c1, log(c1, 2.0) from ct1")
         tdSql.checkData(0, 1, 3.000000000)
 
-        tdSql.query("select c1, log(1, 2.0) from ct1")  
+        tdSql.query("select c1, log(1, 2.0) from ct1")
         tdSql.checkData(0, 1, 0.000000000)
         tdSql.checkRows(13)
 
 
         # # bug for compute in functions
-        # tdSql.query("select c1, abs(1/0) from ct1") 
+        # tdSql.query("select c1, abs(1/0) from ct1")
         # tdSql.checkData(0, 0, 8)
         # tdSql.checkData(0, 1, 1)
 
-        tdSql.query("select c1, log(1, 2.0) from ct1")  
+        tdSql.query("select c1, log(1, 2.0) from ct1")
         tdSql.checkData(0, 1, 0.000000000)
         tdSql.checkRows(13)
 
         # two cols start log(x,y)
-        tdSql.query("select c1,c2, log(c1,c2) from ct1") 
+        tdSql.query("select c1,c2, log(c1,c2) from ct1")
         tdSql.checkData(0, 2, 0.182485070)
         tdSql.checkData(1, 2, 0.172791608)
         tdSql.checkData(4, 2, None)
 
-        tdSql.query("select c1,c2, log(c2,c1) from ct1") 
+        tdSql.query("select c1,c2, log(c2,c1) from ct1")
         tdSql.checkData(0, 2, 5.479900349)
         tdSql.checkData(1, 2, 5.787318105)
         tdSql.checkData(4, 2, None)
 
-        tdSql.query("select c1, log(2.0 , c1) from ct1") 
+        tdSql.query("select c1, log(2.0 , c1) from ct1")
         tdSql.checkData(0, 1, 0.333333333)
         tdSql.checkData(1, 1, 0.356207187)
         tdSql.checkData(4, 1, None)
 
-        tdSql.query("select c1, log(2.0 , ceil(abs(c1))) from ct1") 
+        tdSql.query("select c1, log(2.0 , ceil(abs(c1))) from ct1")
         tdSql.checkData(0, 1, 0.333333333)
         tdSql.checkData(1, 1, 0.356207187)
         tdSql.checkData(4, 1, None)
@@ -580,10 +580,10 @@ class TDTestCase:
         tdSql.checkData(0,3,8.000000000)
         tdSql.checkData(0,4,7.900000000)
         tdSql.checkData(0,5,3.000000000)
-        
+
     def log_Arithmetic(self):
         pass
-    
+
     def check_boundary_values(self):
 
         tdSql.execute("drop database if exists bound_test")
@@ -612,13 +612,13 @@ class TDTestCase:
         self.check_result_auto_log( "select c1, c2, c3 , c4, c5 ,c6 from sub1_bound ", "select log(c1), log(c2) ,log(c3), log(c4), log(c5) ,log(c6) from sub1_bound")
         self.check_result_auto_log2( "select c1, c2, c3 , c4, c5 ,c6 from sub1_bound ", "select log(c1,2), log(c2,2) ,log(c3,2), log(c4,2), log(c5,2) ,log(c6,2) from sub1_bound")
         self.check_result_auto_log__10( "select c1, c2, c3 , c4, c5 ,c6 from sub1_bound ", "select log(c1,-10), log(c2,-10) ,log(c3,-10), log(c4,-10), log(c5,-10) ,log(c6,-10) from sub1_bound")
-        
+
         self.check_result_auto_log2( "select c1, c2, c3 , c3, c2 ,c1 from sub1_bound ", "select log(c1,2), log(c2,2) ,log(c3,2), log(c3,2), log(c2,2) ,log(c1,2) from sub1_bound")
         self.check_result_auto_log( "select c1, c2, c3 , c3, c2 ,c1 from sub1_bound ", "select log(c1), log(c2) ,log(c3), log(c3), log(c2) ,log(c1) from sub1_bound")
 
 
         self.check_result_auto_log2("select abs(abs(abs(abs(abs(abs(abs(abs(abs(c1)))))))))  nest_col_func from sub1_bound" , "select log(abs(c1) ,2) from sub1_bound" )
-        
+
         # check basic elem for table per row
         tdSql.query("select log(abs(c1),2) ,log(abs(c2),2) , log(abs(c3),2) , log(abs(c4),2), log(abs(c5),2), log(abs(c6),2) from sub1_bound ")
         tdSql.checkData(0,0,math.log(2147483647,2))
@@ -683,45 +683,45 @@ class TDTestCase:
         self.check_result_auto_log2( " select t1,c5 from stb1 where c1 > 0 order by tbname  " , "select log(t1,2) ,log(c5,2) from stb1 where c1 > 0 order by tbname" )
         self.check_result_auto_log2( " select t1,c5 from stb1 where c1 > 0 order by tbname  " , "select log(t1,2) , log(c5,2) from stb1 where c1 > 0 order by tbname" )
         pass
-    
+
     def run(self):  # sourcery skip: extract-duplicate-method, remove-redundant-fstring
         tdSql.prepare()
 
         tdLog.printNoPrefix("==========step1:create table ==============")
-        
+
         self.prepare_datas()
 
-        tdLog.printNoPrefix("==========step2:test errors ==============")    
+        tdLog.printNoPrefix("==========step2:test errors ==============")
 
         self.test_errors()
-        
-        tdLog.printNoPrefix("==========step3:support types ============") 
+
+        tdLog.printNoPrefix("==========step3:support types ============")
 
         self.support_types()
 
-        tdLog.printNoPrefix("==========step4: log basic query ============") 
+        tdLog.printNoPrefix("==========step4: log basic query ============")
 
         self.basic_log_function()
 
-        tdLog.printNoPrefix("==========step5: big number log query ============") 
+        tdLog.printNoPrefix("==========step5: big number log query ============")
 
         self.test_big_number()
 
-        tdLog.printNoPrefix("==========step6: base  number for log query ============") 
+        tdLog.printNoPrefix("==========step6: base  number for log query ============")
 
         self.log_base_test()
 
-        tdLog.printNoPrefix("==========step7: log boundary query ============") 
+        tdLog.printNoPrefix("==========step7: log boundary query ============")
 
         self.check_boundary_values()
 
-        tdLog.printNoPrefix("==========step8: log filter query ============") 
+        tdLog.printNoPrefix("==========step8: log filter query ============")
 
         self.abs_func_filter()
 
         tdLog.printNoPrefix("==========step9: check log result of  stable query ============")
 
-        self.support_super_table_test()            
+        self.support_super_table_test()
 
     def stop(self):
         tdSql.close()

tests/system-test/2-query/query_cols_tags_and_or.py

@@ -50,7 +50,7 @@ class TDTestCase:
         tb_name = tdCom.getLongName(8, "letters")
         tdSql.execute(
             f"CREATE TABLE {tb_name} (ts timestamp, c1 tinyint, c2 smallint, c3 int, c4 bigint, c5 float, c6 double, c7 binary(100), c8 nchar(200), c9 bool, c10 tinyint unsigned, c11 smallint unsigned, c12 int unsigned, c13 bigint unsigned) tags (t1 tinyint, t2 smallint, t3 int, t4 bigint, t5 float, t6 double, t7 binary(100), t8 nchar(200), t9 bool, t10 tinyint unsigned, t11 smallint unsigned, t12 int unsigned, t13 bigint unsigned)")
-        for i in range(1, count+1):    
+        for i in range(1, count+1):
             tdSql.execute(
                 f'CREATE TABLE {tb_name}_sub_{i} using {tb_name} tags ({i}, {i}, {i}, {i}, {i}.{i}, {i}.{i}, "binary{i}", "nchar{i}", true, {i}, {i}, {i}, {i})')
             self.insertData(f'{tb_name}_sub_{i}')
@@ -412,7 +412,7 @@ class TDTestCase:
         query_sql = f'select c1,c2,c3,c4,c5,c6,c7,c8,c9,c10,c11,c12,c13 from {tb_name} where c1 > 2 and c1 >= 3 or c1 < 1 or c1 <= 0 or c1 =2 or c1 != 1 or c1 <> 1 and c1 is null or c1 between 2 and 3 and c1 not between 1 and 1 and c1 in (2, 3) and c1 not in (1, 2)'
         res = tdSql.query(query_sql)
         tdSql.checkRows(1)
-    
+
     def queryUtinyintCol(self, tb_name, check_elm=None):
         select_elm = "*" if check_elm is None else check_elm
         # >
@@ -497,7 +497,7 @@ class TDTestCase:
         query_sql = f'select c1,c2,c3,c4,c5,c6,c7,c8,c9,c10,c11,c12,c13 from {tb_name} where c10 > 2 and c10 >= 3 or c10 < 1 or c10 <= 0 or c10 =2 or c10 != 1 or c10 <> 1 and c10 is null or c10 between 2 and 3 and c10 not between 1 and 1 and c10 in (2, 3) and c10 not in (1, 2)'
         res = tdSql.query(query_sql)
         tdSql.checkRows(10)
-    
+
     def querySmallintCol(self, tb_name, check_elm=None):
         select_elm = "*" if check_elm is None else check_elm
         # >
@@ -582,7 +582,7 @@ class TDTestCase:
         query_sql = f'select c1,c2,c3,c4,c5,c6,c7,c8,c9,c10,c11,c12,c13 from {tb_name} where c2 > 0 and c2 >= 1 or c2 < 4 and c2 <= 3 and c2 != 1 and c2 <> 2 and c2 = 3 or c2 is not null and c2 between 2 and 3 and c2 not between 1 and 2 and c2 in (2,3) and c2 not in (1,2)'
         tdSql.query(query_sql)
         tdSql.checkRows(11)
-    
+
     def queryUsmallintCol(self, tb_name, check_elm=None):
         select_elm = "*" if check_elm is None else check_elm
         # >
@@ -752,7 +752,7 @@ class TDTestCase:
         query_sql = f'select c1,c2,c3,c4,c5,c6,c7,c8,c9,c10,c11,c12,c13 from {tb_name} where c3 > 0 and c3 >= 1 or c3 < 5 and c3 <= 4 and c3 != 2 and c3 <> 2 and c3 = 4 or c3 is not null and c3 between 2 and 4 and c3 not between 1 and 2 and c3 in (2,4) and c3 not in (1,2)'
         tdSql.query(query_sql)
         tdSql.checkRows(11)
-    
+
     def queryUintCol(self, tb_name, check_elm=None):
         select_elm = "*" if check_elm is None else check_elm
         # >
@@ -1086,7 +1086,7 @@ class TDTestCase:
         query_sql = f'select c1,c2,c3,c4,c5,c6,c7,c8,c9,c10,c11,c12,c13 from {tb_name} where c5 > 0 and c5 >= 1 or c5 < 5 and c5 <= 6.6 and c5 != 2 and c5 <> 2 and c5 = 4 or c5 is not null and c5 between 2 and 4 and c5 not between 1 and 2 and c5 in (2,4) and c5 not in (1,2)'
         tdSql.query(query_sql)
         tdSql.checkRows(11)
-    
+
     def queryDoubleCol(self, tb_name, check_elm=None):
         select_elm = "*" if check_elm is None else check_elm
         # >
@@ -1711,19 +1711,19 @@ class TDTestCase:
         tdSql.checkRows(4)
         tdSql.checkEqual(self.queryLastC10(query_sql), 7)
 
-        ## condition_A or (condition_B and condition_C) or (condition_D and condition_E) and condition_F 
+        ## condition_A or (condition_B and condition_C) or (condition_D and condition_E) and condition_F
         query_sql = f'select * from {tb_name} where c1 != 1 or (c2 <= 1 and c3 <4) or (c3 >= 4 or c7 is not Null) and c9 <> true'
         tdSql.query(query_sql)
         tdSql.checkRows(3)
         tdSql.checkEqual(self.queryLastC10(query_sql), 10)
 
-        ## (condition_A or (condition_B and condition_C) or (condition_D and condition_E)) and condition_F 
+        ## (condition_A or (condition_B and condition_C) or (condition_D and condition_E)) and condition_F
         query_sql = f'select * from {tb_name} where (c1 != 1 or (c2 <= 2 and c3 >= 4) or (c3 >= 4 or c7 is not Null)) and c9 != false'
         tdSql.query(query_sql)
         tdSql.checkRows(9)
         tdSql.checkEqual(self.queryLastC10(query_sql), 9)
 
-        ## (condition_A or condition_B) or (condition_C or condition_D) and (condition_E or condition_F or condition_G) 
+        ## (condition_A or condition_B) or (condition_C or condition_D) and (condition_E or condition_F or condition_G)
         query_sql = f'select * from {tb_name} where c1 != 1 or (c2 <= 3 and c3 > 4) and c3 <= 5 and (c7 is not Null and c9 != false)'
         tdSql.query(query_sql)
         tdSql.checkRows(2)
@@ -1780,17 +1780,17 @@ class TDTestCase:
         tdSql.query(query_sql)
         tdSql.checkRows(55)
 
-        ## condition_A or (condition_B and condition_C) or (condition_D and condition_E) and condition_F 
+        ## condition_A or (condition_B and condition_C) or (condition_D and condition_E) and condition_F
         query_sql = f'select * from {tb_name} where t1 != 1 or (t2 <= 1 and t3 <4) or (t3 >= 4 or t7 is not Null) and t9 <> true'
         tdSql.query(query_sql)
         tdSql.checkRows(55)
 
-        ## (condition_A or (condition_B and condition_C) or (condition_D and condition_E)) and condition_F 
+        ## (condition_A or (condition_B and condition_C) or (condition_D and condition_E)) and condition_F
         query_sql = f'select * from {tb_name} where (t1 != 1 or (t2 <= 2 and t3 >= 4) or (t3 >= 4 or t7 is not Null)) and t9 != false'
         tdSql.query(query_sql)
         tdSql.checkRows(55)
 
-        ## (condition_A or condition_B) or (condition_C or condition_D) and (condition_E or condition_F or condition_G) 
+        ## (condition_A or condition_B) or (condition_C or condition_D) and (condition_E or condition_F or condition_G)
         query_sql = f'select * from {tb_name} where t1 != 1 or (t2 <= 3 and t3 > 4) and t3 <= 5 and (t7 is not Null and t9 != false)'
         tdSql.query(query_sql)
         tdSql.checkRows(44)
@@ -2033,7 +2033,7 @@ class TDTestCase:
             self.checkColType(tb_name, check_elm)
         else:
             self.checkColType(stb_name, check_elm)
-        
+
     def checkStbTagTypeOperator(self):
         '''
             Super table full tag type and operator
@@ -2089,7 +2089,7 @@ class TDTestCase:
         tb_name = self.initStb()
         self.queryColPreCal(f'{tb_name}_sub_1')
         self.queryTagPreCal(tb_name)
-   
+
     def checkMultiTb(self):
         '''
             test "or" in multi ordinary table
@@ -2110,7 +2110,7 @@ class TDTestCase:
         '''
         tb_name = self.initStb()
         self.queryMultiTbWithTag(tb_name)
-    
+
     def checkMultiStbJoin(self):
         '''
             join test

tests/system-test/7-tmq/TD-17699.py

+import sys
+import time
+import socket
+import os
+import threading
+
+import taos
+from util.log import *
+from util.sql import *
+from util.cases import *
+from util.dnodes import *
+from util.common import *
+sys.path.append("./7-tmq")
+from tmqCommon import *
+
+class TDTestCase:
+    paraDict = {'dbName':     'db1',
+                'dropFlag':   1,
+                'event':      '',
+                'vgroups':    2,
+                'stbName':    'stb0',
+                'colPrefix':  'c',
+                'tagPrefix':  't',
+                'colSchema':   [{'type': 'INT', 'count':2}, {'type': 'binary', 'len':16, 'count':1}, {'type': 'timestamp','count':1}],
+                'tagSchema':   [{'type': 'INT', 'count':1}, {'type': 'binary', 'len':20, 'count':1}],
+                'ctbPrefix':  'ctb',
+                'ctbStartIdx': 0,
+                'ctbNum':     100,
+                'rowsPerTbl': 1000,
+                'batchNum':   1000,
+                'startTs':    1640966400000,  # 2022-01-01 00:00:00.000
+                'pollDelay':  20,
+                'showMsg':    1,
+                'showRow':    1}
+
+    cdbName = 'cdb'
+    # some parameter to consumer processor
+    consumerId = 0
+    expectrowcnt = 0
+    topicList = ''
+    ifcheckdata = 0
+    ifManualCommit = 1
+    groupId = 'group.id:cgrp1'
+    autoCommit = 'enable.auto.commit:false'
+    autoCommitInterval = 'auto.commit.interval.ms:1000'
+    autoOffset = 'auto.offset.reset:earliest'
+
+    pollDelay = 20
+    showMsg   = 1
+    showRow   = 1  
+
+    hostname = socket.gethostname()
+
+    def init(self, conn, logSql):
+        tdLog.debug(f"start to excute {__file__}")
+        logSql = False
+        tdSql.init(conn.cursor(), logSql)
+
+    def tmqCase1(self):
+        tdLog.printNoPrefix("======== test case 1: ")
+        tdLog.info("step 1: create database, stb, ctb and insert data")
+        
+        tmqCom.initConsumerTable(self.cdbName)
+
+        tdCom.create_database(tdSql,self.paraDict["dbName"],self.paraDict["dropFlag"])
+
+        self.paraDict["stbName"] = 'stb1'
+        tdCom.create_stable(tdSql,dbname=self.paraDict["dbName"],stbname=self.paraDict["stbName"],column_elm_list=self.paraDict["colSchema"],tag_elm_list=self.paraDict["tagSchema"],count=1, default_stbname_prefix=self.paraDict["stbName"])
+        tdCom.create_ctable(tdSql,dbname=self.paraDict["dbName"],stbname=self.paraDict["stbName"],tag_elm_list=self.paraDict['tagSchema'],count=self.paraDict["ctbNum"],default_ctbname_prefix=self.paraDict["ctbPrefix"])
+        tmqCom.insert_data_2(tdSql,self.paraDict["dbName"],self.paraDict["ctbPrefix"],self.paraDict["ctbNum"],self.paraDict["rowsPerTbl"],self.paraDict["batchNum"],self.paraDict["startTs"],self.paraDict["ctbStartIdx"])
+        # pThread1 = tmqCom.asyncInsertData(paraDict=self.paraDict)
+        
+        self.paraDict["stbName"] = 'stb2'
+        self.paraDict["ctbPrefix"] = 'newctb'
+        self.paraDict["batchNum"] = 1000
+        tdCom.create_stable(tdSql,dbname=self.paraDict["dbName"],stbname=self.paraDict["stbName"],column_elm_list=self.paraDict["colSchema"],tag_elm_list=self.paraDict["tagSchema"],count=1, default_stbname_prefix=self.paraDict["stbName"])
+        tdCom.create_ctable(tdSql,dbname=self.paraDict["dbName"],stbname=self.paraDict["stbName"],tag_elm_list=self.paraDict['tagSchema'],count=self.paraDict["ctbNum"],default_ctbname_prefix=self.paraDict["ctbPrefix"])
+        # tmqCom.insert_data_2(tdSql,self.paraDict["dbName"],self.paraDict["ctbPrefix"],self.paraDict["ctbNum"],self.paraDict["rowsPerTbl"],self.paraDict["batchNum"],self.paraDict["startTs"],self.paraDict["ctbStartIdx"])
+        pThread2 = tmqCom.asyncInsertData(paraDict=self.paraDict)        
+
+        tdLog.info("create topics from db")
+        topicName1 = 'UpperCasetopic_%s'%(self.paraDict['dbName'])        
+        tdSql.execute("create topic %s as database %s" %(topicName1, self.paraDict['dbName']))
+        
+        topicList = topicName1 + ',' +topicName1
+        keyList = '%s,%s,%s,%s'%(self.groupId,self.autoCommit,self.autoCommitInterval,self.autoOffset)
+        self.expectrowcnt = self.paraDict["rowsPerTbl"] * self.paraDict["ctbNum"] * 2
+        tmqCom.insertConsumerInfo(self.consumerId, self.expectrowcnt,topicList,keyList,self.ifcheckdata,self.ifManualCommit)
+        
+        tdLog.info("start consume processor")  
+        tmqCom.startTmqSimProcess(self.pollDelay,self.paraDict["dbName"],self.showMsg, self.showRow,self.cdbName)
+        
+        tmqCom.getStartConsumeNotifyFromTmqsim()  
+        tdLog.info("drop one stable")
+        self.paraDict["stbName"] = 'stb1'    
+        tdSql.execute("drop table %s.%s" %(self.paraDict['dbName'], self.paraDict['stbName']))        
+        tmqCom.drop_ctable(tdSql, dbname=self.paraDict['dbName'], count=self.paraDict["ctbNum"], default_ctbname_prefix=self.paraDict["ctbPrefix"])
+
+        # pThread2.join()
+    
+        tdLog.info("wait result from consumer, then check it")
+        expectRows = 1
+        resultList = tmqCom.selectConsumeResult(expectRows)
+
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+        
+        if not (totalConsumeRows >= self.expectrowcnt/2 and totalConsumeRows <= self.expectrowcnt):
+            tdLog.info("act consume rows: %d, expect consume rows: between %d and %d"%(totalConsumeRows, self.expectrowcnt/2, self.expectrowcnt))
+            tdLog.exit("tmq consume rows error!")
+
+        time.sleep(10)
+        tdSql.query("drop topic %s"%topicName1)
+
+        tdLog.printNoPrefix("======== test case 1 end ...... ")
+
+    def run(self):
+        tdSql.prepare()
+        self.tmqCase1()
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success(f"{__file__} successfully executed")
+
+event = threading.Event()
+
+tdCases.addLinux(__file__, TDTestCase())
+tdCases.addWindows(__file__, TDTestCase())

tests/system-test/7-tmq/tmqCommon.py

@@ -20,6 +20,8 @@ import threading
 import requests
 import time
 # import socketfrom
+import json
+import toml
 
 import taos
 from util.log import *
@@ -207,7 +209,7 @@ class TMQCom:
 
     def drop_ctable(self, tsql, dbname=None, count=1, default_ctbname_prefix="ctb",ctbStartIdx=0):
         for _ in range(count):
-            create_ctable_sql = f'drop table {dbname}.{default_ctbname_prefix}{ctbStartIdx};'
+            create_ctable_sql = f'drop table if exists {dbname}.{default_ctbname_prefix}{ctbStartIdx};'
             ctbStartIdx += 1
             tdLog.info("drop ctb sql: %s"%create_ctable_sql)
             tsql.execute(create_ctable_sql)
@@ -503,6 +505,37 @@ class TMQCom:
                 break
         return 
 
+    def create_ntable(self, tsql, dbname=None, tbname_prefix="ntb", tbname_index_start_num = 1, column_elm_list=None, colPrefix='c', tblNum=1, **kwargs):
+        tb_params = ""
+        if len(kwargs) > 0:
+            for param, value in kwargs.items():
+                tb_params += f'{param} "{value}" '
+        column_type_str = tdCom.gen_column_type_str(colPrefix, column_elm_list)
+
+        for _ in range(tblNum):
+            create_table_sql = f'create table {dbname}.{tbname_prefix}{tbname_index_start_num} ({column_type_str}) {tb_params};'
+            tbname_index_start_num += 1
+            tsql.execute(create_table_sql)
+
+    def insert_rows_into_ntbl(self, tsql, dbname=None, tbname_prefix="ntb", tbname_index_start_num = 1, column_ele_list=None, startTs=None, tblNum=1, rows=1):
+        if startTs is None:
+            startTs = tdCom.genTs()[0]
+
+        for tblIdx in range(tblNum):
+            for rowIdx in range(rows):
+                column_value_list = tdCom.gen_column_value_list(column_ele_list, f'{startTs}+{rowIdx}s')
+                column_value_str = ''
+                idx = 0
+                for column_value in column_value_list:
+                    if isinstance(column_value, str) and idx != 0:
+                        column_value_str += f'"{column_value}", '
+                    else:
+                        column_value_str += f'{column_value}, '
+                        idx += 1
+                column_value_str = column_value_str.rstrip()[:-1]
+                insert_sql = f'insert into {dbname}.{tbname_prefix}{tblIdx+tbname_index_start_num} values ({column_value_str});'
+                tsql.execute(insert_sql)
+
     def close(self):
         self.cursor.close()
 

tests/system-test/7-tmq/tmqDropNtb.py

+
+import taos
+import sys
+import time
+import socket
+import os
+import threading
+from enum import Enum
+
+from util.log import *
+from util.sql import *
+from util.cases import *
+from util.dnodes import *
+sys.path.append("./7-tmq")
+from tmqCommon import *
+
+class TDTestCase:
+    def __init__(self):
+        self.snapshot   = 0
+        self.vgroups    = 4
+        self.ctbNum     = 100
+        self.rowsPerTbl = 10
+        
+    def init(self, conn, logSql):
+        tdLog.debug(f"start to excute {__file__}")
+        tdSql.init(conn.cursor(), False)
+        
+    def waitSubscriptionExit(self, max_wait_count=20):
+        wait_cnt = 0
+        while (wait_cnt < max_wait_count):
+            tdSql.query("show subscriptions")
+            if tdSql.getRows() == 0:
+                break
+            else:
+                time.sleep(1)
+                wait_cnt += 1
+                
+        tdLog.info("wait subscriptions exit for %d s"%wait_cnt)
+    
+    # drop some ntbs
+    def tmqCase1(self):
+        tdLog.printNoPrefix("======== test case 1: ")
+        paraDict = {'dbName':     'dbt',
+                    'dropFlag':   1,
+                    'event':      '',
+                    'vgroups':    4,
+                    'stbName':    'stb',
+                    'colPrefix':  'c',
+                    'tagPrefix':  't',
+                    'colSchema':   [{'type': 'INT', 'count':1},{'type': 'BIGINT', 'count':1},{'type': 'DOUBLE', 'count':1},{'type': 'TIMESTAMP', 'count':1}],
+                    'tagSchema':   [{'type': 'INT', 'count':1},{'type': 'BIGINT', 'count':1},{'type': 'DOUBLE', 'count':1},{'type': 'BINARY', 'len':32, 'count':1},{'type': 'NCHAR', 'len':32, 'count':1}],
+                    'ctbPrefix':  'ntb',
+                    'ctbStartIdx': 0,
+                    'ctbNum':     100,
+                    'rowsPerTbl': 1000,
+                    'batchNum':   1000,
+                    'startTs':    1640966400000,  # 2022-01-01 00:00:00.000
+                    'endTs': 0,
+                    'pollDelay':  5,
+                    'showMsg':    1,
+                    'showRow':    1,
+                    'snapshot':   0}
+        paraDict['snapshot'] = self.snapshot
+        paraDict['vgroups'] = self.vgroups
+        paraDict['ctbNum'] = self.ctbNum
+        paraDict['rowsPerTbl'] = self.rowsPerTbl        
+        
+        tmqCom.initConsumerTable()
+        tdLog.info("start create database....")
+        tdCom.create_database(tdSql, paraDict["dbName"],paraDict["dropFlag"], vgroups=paraDict["vgroups"],replica=1)
+        tdLog.info("start create normal tables....")
+        tmqCom.create_ntable(tsql=tdSql, dbname=paraDict["dbName"], tbname_prefix=paraDict["ctbPrefix"], tbname_index_start_num = 1, column_elm_list=paraDict["colSchema"], colPrefix='c', tblNum=paraDict["ctbNum"])
+        tdLog.info("start insert data into normal tables....")
+        tmqCom.insert_rows_into_ntbl(tsql=tdSql, dbname=paraDict["dbName"], tbname_prefix=paraDict["ctbPrefix"], tbname_index_start_num = 1, column_ele_list=paraDict["colSchema"],startTs=paraDict["startTs"], tblNum=paraDict["ctbNum"], rows=paraDict["rowsPerTbl"])
+                
+        tdLog.info("create topics from database")
+        topicFromDb = 'topic_dbt'                
+        tdSql.execute("create topic %s as database %s" %(topicFromDb, paraDict['dbName']))
+        
+        if self.snapshot == 0:
+            consumerId     = 0
+        elif self.snapshot == 1:
+            consumerId     = 1
+
+        expectrowcnt   = int(paraDict["rowsPerTbl"] * paraDict["ctbNum"])
+        topicList      = topicFromDb
+        ifcheckdata    = 1
+        ifManualCommit = 1
+        keyList        = 'group.id:cgrp1,\
+                        enable.auto.commit:true,\
+                        auto.commit.interval.ms:1000,\
+                        auto.offset.reset:earliest'
+        tmqCom.insertConsumerInfo(consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifManualCommit)
+
+        tdLog.info("start consume processor")
+        tmqCom.startTmqSimProcess(pollDelay=paraDict['pollDelay'],dbName=paraDict["dbName"],showMsg=paraDict['showMsg'], showRow=paraDict['showRow'],snapshot=paraDict['snapshot'])
+
+        tmqCom.getStartConsumeNotifyFromTmqsim()  
+        tdLog.info("drop some ntables")
+        # drop 1/4 ctbls from half offset
+        paraDict["ctbStartIdx"] = paraDict["ctbStartIdx"] + int(paraDict["ctbNum"] * 1 / 2)
+        paraDict["ctbNum"] = int(paraDict["ctbNum"] / 4)
+        tmqCom.drop_ctable(tdSql, dbname=paraDict['dbName'], count=paraDict["ctbNum"], default_ctbname_prefix=paraDict["ctbPrefix"], ctbStartIdx=paraDict["ctbStartIdx"])
+        
+        tdLog.info("start to check consume result")
+        expectRows = 1
+        resultList = tmqCom.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+
+        tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, expectrowcnt))
+        
+        if not ((totalConsumeRows >= expectrowcnt * 3/4) and (totalConsumeRows < expectrowcnt)):
+            tdLog.exit("tmq consume rows error with snapshot = 0!")
+        
+        tdLog.info("wait subscriptions exit ....")      
+        self.waitSubscriptionExit()
+            
+        tdSql.query("drop topic %s"%topicFromDb)
+        tdLog.info("success dorp topic: %s"%topicFromDb)
+        tdLog.printNoPrefix("======== test case 1 end ...... ")
+    
+
+    
+    # drop some ntbs and create some new ntbs
+    def tmqCase2(self):
+        tdLog.printNoPrefix("======== test case 2: ")
+        paraDict = {'dbName':     'dbt',
+                    'dropFlag':   1,
+                    'event':      '',
+                    'vgroups':    4,
+                    'stbName':    'stb',
+                    'colPrefix':  'c',
+                    'tagPrefix':  't',
+                    'colSchema':   [{'type': 'INT', 'count':1},{'type': 'BIGINT', 'count':1},{'type': 'DOUBLE', 'count':1},{'type': 'TIMESTAMP', 'count':1}],
+                    'tagSchema':   [{'type': 'INT', 'count':1},{'type': 'BIGINT', 'count':1},{'type': 'DOUBLE', 'count':1},{'type': 'BINARY', 'len':32, 'count':1},{'type': 'NCHAR', 'len':32, 'count':1}],
+                    'ctbPrefix':  'ntb',
+                    'ctbStartIdx': 0,
+                    'ctbNum':     100,
+                    'rowsPerTbl': 1000,
+                    'batchNum':   1000,
+                    'startTs':    1640966400000,  # 2022-01-01 00:00:00.000
+                    'endTs': 0,
+                    'pollDelay':  10,
+                    'showMsg':    1,
+                    'showRow':    1,
+                    'snapshot':   0}
+        paraDict['snapshot'] = self.snapshot
+        paraDict['vgroups'] = self.vgroups
+        paraDict['ctbNum'] = self.ctbNum
+        paraDict['rowsPerTbl'] = self.rowsPerTbl        
+        
+        tmqCom.initConsumerTable()
+        tdLog.info("start create database....")
+        tdCom.create_database(tdSql, paraDict["dbName"],paraDict["dropFlag"], vgroups=paraDict["vgroups"],replica=1)
+        tdLog.info("start create normal tables....")
+        tmqCom.create_ntable(tsql=tdSql, dbname=paraDict["dbName"], tbname_prefix=paraDict["ctbPrefix"], tbname_index_start_num = 1, column_elm_list=paraDict["colSchema"], colPrefix='c', tblNum=paraDict["ctbNum"])
+        tdLog.info("start insert data into normal tables....")
+        tmqCom.insert_rows_into_ntbl(tsql=tdSql, dbname=paraDict["dbName"], tbname_prefix=paraDict["ctbPrefix"], tbname_index_start_num = 1, column_ele_list=paraDict["colSchema"],startTs=paraDict["startTs"], tblNum=paraDict["ctbNum"], rows=paraDict["rowsPerTbl"])
+                
+        tdLog.info("create topics from database")
+        topicFromDb = 'topic_dbt'                
+        tdSql.execute("create topic %s as database %s" %(topicFromDb, paraDict['dbName']))
+        
+        if self.snapshot == 0:
+            consumerId     = 2
+        elif self.snapshot == 1:
+            consumerId     = 3
+
+        expectrowcnt   = int(paraDict["rowsPerTbl"] * paraDict["ctbNum"] * 2)
+        topicList      = topicFromDb
+        ifcheckdata    = 1
+        ifManualCommit = 1
+        keyList        = 'group.id:cgrp1,\
+                        enable.auto.commit:true,\
+                        auto.commit.interval.ms:1000,\
+                        auto.offset.reset:earliest'
+        tmqCom.insertConsumerInfo(consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifManualCommit)
+
+        tdLog.info("start consume processor")
+        tmqCom.startTmqSimProcess(pollDelay=paraDict['pollDelay'],dbName=paraDict["dbName"],showMsg=paraDict['showMsg'], showRow=paraDict['showRow'],snapshot=paraDict['snapshot'])
+
+        tmqCom.getStartConsumeNotifyFromTmqsim()  
+        tdLog.info("drop some ntables")
+        # drop 1/4 ctbls from half offset
+        paraDict["ctbStartIdx"] = paraDict["ctbStartIdx"] + int(paraDict["ctbNum"] * 1 / 2)
+        paraDict["ctbNum"] = int(paraDict["ctbNum"] / 4)
+        tmqCom.drop_ctable(tdSql, dbname=paraDict['dbName'], count=paraDict["ctbNum"], default_ctbname_prefix=paraDict["ctbPrefix"], ctbStartIdx=paraDict["ctbStartIdx"])
+                
+        tdLog.info("start create some new normal tables....")
+        paraDict["ctbPrefix"] = 'newCtb'
+        paraDict["ctbNum"] = self.ctbNum
+        tmqCom.create_ntable(tsql=tdSql, dbname=paraDict["dbName"], tbname_prefix=paraDict["ctbPrefix"], tbname_index_start_num = 1, column_elm_list=paraDict["colSchema"], colPrefix='c', tblNum=paraDict["ctbNum"])
+        tdLog.info("start insert data into these new normal tables....")
+        tmqCom.insert_rows_into_ntbl(tsql=tdSql, dbname=paraDict["dbName"], tbname_prefix=paraDict["ctbPrefix"], tbname_index_start_num = 1, column_ele_list=paraDict["colSchema"],startTs=paraDict["startTs"], tblNum=paraDict["ctbNum"], rows=paraDict["rowsPerTbl"])
+        
+        tdLog.info("start to check consume result")
+        expectRows = 1
+        resultList = tmqCom.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+
+        tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, expectrowcnt))
+        
+        if not ((totalConsumeRows >= expectrowcnt / 2 * (1 + 3/4)) and (totalConsumeRows < expectrowcnt)):
+            tdLog.exit("tmq consume rows error with snapshot = 0!")
+        
+        tdLog.info("wait subscriptions exit ....")      
+        self.waitSubscriptionExit()
+            
+        tdSql.query("drop topic %s"%topicFromDb)
+        tdLog.info("success dorp topic: %s"%topicFromDb)
+        tdLog.printNoPrefix("======== test case 2 end ...... ")
+        
+    def run(self):        
+        tdLog.printNoPrefix("=============================================")
+        tdLog.printNoPrefix("======== snapshot is 0: only consume from wal")
+        self.snapshot = 0
+        # self.tmqCase1()
+        self.tmqCase2()               
+        
+        tdLog.printNoPrefix("====================================================================")
+        tdLog.printNoPrefix("======== snapshot is 1: firstly consume from tsbs, and then from wal")
+        self.snapshot = 1
+        # self.tmqCase1()
+        self.tmqCase2()
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success(f"{__file__} successfully executed")
+
+event = threading.Event()
+
+tdCases.addLinux(__file__, TDTestCase())
+tdCases.addWindows(__file__, TDTestCase())

taos-tools @ 0b8a3373

-Subproject commit 69b558ccbfe54a4407fe23eeae2e67c540f59e55
+Subproject commit 0b8a3373bb7548f8106d13e7d3b0a988d3c4d48a

taosadapter @ d8f19ede

-Subproject commit df8678f070e3f707faf59baebec90065f6e1268b
+Subproject commit d8f19ede56f1f489c5d2ac8f963cced01e68ecef

taosws-rs @ c5fded26

-Subproject commit 267a96fb09fc2ba14acfa47f7d3678def64c29c5
+Subproject commit c5fded266d3b10508e38bf3285bb7ecf798bc343