Merge remote-tracking branch 'origin/develop' into feature/tqueue

2021-03-10 09:14:31 +08:00 · 2021-03-10 09:14:31 +08:00 · 521113ec0a
parent 833dde3166 fd5fd885c4
commit 521113ec0a
265 changed files with 2599 additions and 1588 deletions
--- a/2
+++ b/2
@ -227,6 +227,8 @@ pipeline {
              ./test-all.sh p4
              cd ${WKC}/tests
              ./test-all.sh full jdbc
+              cd ${WKC}/tests
+              ./test-all.sh full unit
              date'''
            }
          }
--- a/cmake/install.inc
+++ b/cmake/install.inc
@ -32,7 +32,7 @@ ELSEIF (TD_WINDOWS)
  #INSTALL(TARGETS taos RUNTIME DESTINATION driver)
  #INSTALL(TARGETS shell RUNTIME DESTINATION .)
  IF (TD_MVN_INSTALLED)
-    INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.20-dist.jar DESTINATION connector/jdbc)
+    INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.21-dist.jar DESTINATION connector/jdbc)
  ENDIF ()
 ELSEIF (TD_DARWIN)
  SET(TD_MAKE_INSTALL_SH "${TD_COMMUNITY_DIR}/packaging/tools/make_install.sh")
--- a/documentation20/cn/00.index/docs.md
+++ b/documentation20/cn/00.index/docs.md
@ -120,6 +120,7 @@ TDengine是一个高效的存储、查询、分析时序大数据的平台，专
 * [TDengine性能对比测试工具](https://www.taosdata.com/blog/2020/01/18/1166.html)
 * [IDEA数据库管理工具可视化使用TDengine](https://www.taosdata.com/blog/2020/08/27/1767.html)
 * [基于eletron开发的跨平台TDengine图形化管理工具](https://github.com/skye0207/TDengineGUI)
+* [DataX，支持TDengine的离线数据采集/同步工具](https://github.com/alibaba/DataX)

 ## TDengine与其他数据库的对比测试

--- a/documentation20/cn/03.architecture/docs.md
+++ b/documentation20/cn/03.architecture/docs.md
@ -178,11 +178,11 @@ TDengine 分布式架构的逻辑结构图如下：

 **FQDN配置**：一个数据节点有一个或多个FQDN，可以在系统配置文件taos.cfg通过参数“fqdn"进行指定，如果没有指定，系统将自动获取计算机的hostname作为其FQDN。如果节点没有配置FQDN，可以直接将该节点的配置参数fqdn设置为它的IP地址。但不建议使用IP，因为IP地址可变，一旦变化，将让集群无法正常工作。一个数据节点的EP(End Point)由FQDN + Port组成。采用FQDN，需要保证DNS服务正常工作，或者在节点以及应用所在的节点配置好hosts文件。

-**端口配置：**一个数据节点对外的端口由TDengine的系统配置参数serverPort决定，对集群内部通讯的端口是serverPort+5。集群内数据节点之间的数据复制操作还占有一个TCP端口，是serverPort+10. 为支持多线程高效的处理UDP数据，每个对内和对外的UDP连接，都需要占用5个连续的端口。因此一个数据节点总的端口范围为serverPort到serverPort + 10，总共11个TCP/UDP端口。使用时，需要确保防火墙将这些端口打开。每个数据节点可以配置不同的serverPort。
+**端口配置：**一个数据节点对外的端口由TDengine的系统配置参数serverPort决定，对集群内部通讯的端口是serverPort+5。集群内数据节点之间的数据复制操作还占有一个TCP端口，是serverPort+10. 为支持多线程高效的处理UDP数据，每个对内和对外的UDP连接，都需要占用5个连续的端口。因此一个数据节点总的端口范围为serverPort到serverPort + 10，总共11个TCP/UDP端口。（另外还可能有 RESTful、Arbitrator 所使用的端口，那样的话就一共是 13 个。）使用时，需要确保防火墙将这些端口打开，以备使用。每个数据节点可以配置不同的serverPort。

 **集群对外连接:** TDengine集群可以容纳单个、多个甚至几千个数据节点。应用只需要向集群中任何一个数据节点发起连接即可，连接需要提供的网络参数是一数据节点的End Point(FQDN加配置的端口号）。通过命令行CLI启动应用taos时，可以通过选项-h来指定数据节点的FQDN, -P来指定其配置的端口号，如果端口不配置，将采用TDengine的系统配置参数serverPort。

-**集群内部通讯**: 各个数据节点之间通过TCP/UDP进行连接。一个数据节点启动时，将获取mnode所在的dnode的EP信息，然后与系统中的mnode建立起连接，交换信息。获取mnode的EP信息有三步，1：检查mnodeEpList文件是否存在，如果不存在或不能正常打开获得mnode EP信息，进入第二步；2：检查系统配置文件taos.cfg, 获取节点配置参数firstEp, secondEp，（这两个参数指定的节点可以是不带mnode的普通节点，这样的话，节点被连接时会尝试重定向到mnode节点）如果不存在或者taos.cfg里没有这两个配置参数，或无效，进入第三步；3：将自己的EP设为mnode EP, 并独立运行起来。获取mnode EP列表后，数据节点发起连接，如果连接成功，则成功加入进工作的集群，如果不成功，则尝试mnode EP列表中的下一个。如果都尝试了，但连接都仍然失败，则休眠几秒后，再进行尝试。
+**集群内部通讯**: 各个数据节点之间通过TCP/UDP进行连接。一个数据节点启动时，将获取mnode所在的dnode的EP信息，然后与系统中的mnode建立起连接，交换信息。获取mnode的EP信息有三步，1：检查mnodeEpSet文件是否存在，如果不存在或不能正常打开获得mnode EP信息，进入第二步；2：检查系统配置文件taos.cfg, 获取节点配置参数firstEp, secondEp，（这两个参数指定的节点可以是不带mnode的普通节点，这样的话，节点被连接时会尝试重定向到mnode节点）如果不存在或者taos.cfg里没有这两个配置参数，或无效，进入第三步；3：将自己的EP设为mnode EP, 并独立运行起来。获取mnode EP列表后，数据节点发起连接，如果连接成功，则成功加入进工作的集群，如果不成功，则尝试mnode EP列表中的下一个。如果都尝试了，但连接都仍然失败，则休眠几秒后，再进行尝试。

 **MNODE的选择:** TDengine逻辑上有管理节点，但没有单独的执行代码，服务器侧只有一套执行代码taosd。那么哪个数据节点会是管理节点呢？这是系统自动决定的，无需任何人工干预。原则如下：一个数据节点启动时，会检查自己的End Point, 并与获取的mnode EP List进行比对，如果在其中，该数据节点认为自己应该启动mnode模块，成为mnode。如果自己的EP不在mnode EP List里，则不启动mnode模块。在系统的运行过程中，由于负载均衡、宕机等原因，mnode有可能迁移至新的dnode，但一切都是透明的，无需人工干预，配置参数的修改，是mnode自己根据资源做出的决定。

--- a/documentation20/cn/08.connector/docs.md
+++ b/documentation20/cn/08.connector/docs.md
@ -209,7 +209,7 @@ C/C++的API类似于MySQL的C API。应用程序使用时，需要包含TDengine

 - `TAOS_RES* taos_query(TAOS *taos, const char *sql)`

-  该API用来执行SQL语句，可以是DQL、DML或DDL语句。 其中的`taos`参数是通过`taos_connect`获得的指针。返回值 NULL 表示失败。
+  该API用来执行SQL语句，可以是DQL、DML或DDL语句。 其中的`taos`参数是通过`taos_connect`获得的指针。不能通过返回值是否是 NULL 来判断执行结果是否失败，而是需要用`taos_errno`函数解析结果集中的错误代码来进行判断。

 - `int taos_result_precision(TAOS_RES *res)`

@ -591,7 +591,8 @@ curl -u username:password -d '<SQL>' <ip>:<PORT>/rest/sql
 ```json
 {
    "status": "succ",
-    "head": ["Time Stamp","current", …],
+    "head": ["ts","current", …],
+    "column_meta": [["ts",9,8],["current",6,4], …],
    "data": [
        ["2018-10-03 14:38:05.000", 10.3, …],
        ["2018-10-03 14:38:15.000", 12.6, …]
@ -602,10 +603,23 @@ curl -u username:password -d '<SQL>' <ip>:<PORT>/rest/sql

 说明：

- status: 告知操作结果是成功还是失败
- head: 表的定义，如果不返回结果集，仅有一列“affected_rows”
- data: 具体返回的数据，一排一排的呈现，如果不返回结果集，仅[[affected_rows]]
- rows: 表明总共多少行数据
+- status: 告知操作结果是成功还是失败。
+- head: 表的定义，如果不返回结果集，则仅有一列“affected_rows”。（从 2.0.17 版本开始，建议不要依赖 head 返回值来判断数据列类型，而推荐使用 column_meta。在未来版本中，有可能会从返回值中去掉 head 这一项。）
+- column_meta: 从 2.0.17 版本开始，返回值中增加这一项来说明 data 里每一列的数据类型。具体每个列会用三个值来说明，分别为：列名、列类型、类型长度。例如`["current",6,4]`表示列名为“current”；列类型为 6，也即 float 类型；类型长度为 4，也即对应 4 个字节表示的 float。如果列类型为 binary 或 nchar，则类型长度表示该列最多可以保存的内容长度，而不是本次返回值中的具体数据长度。当列类型是 nchar 的时候，其类型长度表示可以保存的 unicode 字符数量，而不是 bytes。
+- data: 具体返回的数据，一行一行的呈现，如果不返回结果集，那么就仅有[[affected_rows]]。data 中每一行的数据列顺序，与 column_meta 中描述数据列的顺序完全一致。
+- rows: 表明总共多少行数据。
+
+column_meta 中的列类型说明：
+* 1：BOOL
+* 2：TINYINT
+* 3：SMALLINT
+* 4：INT
+* 5：BIGINT
+* 6：FLOAT
+* 7：DOUBLE
+* 8：BINARY
+* 9：TIMESTAMP
+* 10：NCHAR

 ### 自定义授权码

@ -651,7 +665,8 @@ curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'select * from demo.d1001
 ```json
 {
    "status": "succ",
-    "head": ["Time Stamp","current","voltage","phase"],
+    "head": ["ts","current","voltage","phase"],
+    "column_meta": [["ts",9,8],["current",6,4],["voltage",4,4],["phase",6,4]],
    "data": [
        ["2018-10-03 14:38:05.000",10.3,219,0.31],
        ["2018-10-03 14:38:15.000",12.6,218,0.33]
@ -671,8 +686,9 @@ curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'create database demo' 19
 {
    "status": "succ",
    "head": ["affected_rows"],
+    "column_meta": [["affected_rows",4,4]],
    "data": [[1]],
-    "rows": 1,
+    "rows": 1
 }
 ```

@ -691,7 +707,8 @@ curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'select * from demo.d1001
 ```json
 {
    "status": "succ",
-    "head": ["column1","column2","column3"],
+    "head": ["ts","current","voltage","phase"],
+    "column_meta": [["ts",9,8],["current",6,4],["voltage",4,4],["phase",6,4]],
    "data": [
        [1538548685000,10.3,219,0.31],
        [1538548695000,12.6,218,0.33]
@ -712,7 +729,8 @@ HTTP请求URL采用`sqlutc`时，返回结果集的时间戳将采用UTC时间
 ```json
 {
    "status": "succ",
-    "head": ["column1","column2","column3"],
+    "head": ["ts","current","voltage","phase"],
+    "column_meta": [["ts",9,8],["current",6,4],["voltage",4,4],["phase",6,4]],
    "data": [
        ["2018-10-03T14:38:05.000+0800",10.3,219,0.31],
        ["2018-10-03T14:38:15.000+0800",12.6,218,0.33]
--- a/documentation20/cn/09.connections/docs.md
+++ b/documentation20/cn/09.connections/docs.md
@ -155,11 +155,3 @@ TDengine客户端暂不支持如下函数：
 - dbExistsTable(conn, "test")：是否存在表test
 - dbListTables(conn)：显示连接中的所有表

-
-## <a class="anchor" id="datax"></a>DataX
-
-[DataX](https://github.com/alibaba/DataX) 是阿里巴巴集团开源的一款通用离线数据采集/同步工具，能够简单、高效地接入 TDengine 进行数据写入和读取。
-
-* 数据读取集成的方法请参见 [TSDBReader 插件文档](https://github.com/alibaba/DataX/blob/master/tsdbreader/doc/tsdbreader.md)
-* 数据写入集成的方法请参见 [TSDBWriter 插件文档](https://github.com/alibaba/DataX/blob/master/tsdbwriter/doc/tsdbhttpwriter.md)
-
--- a/documentation20/cn/10.cluster/docs.md
+++ b/documentation20/cn/10.cluster/docs.md
@ -13,7 +13,7 @@ TDengine的集群管理极其简单，除添加和删除节点需要人工干预
 **第零步**：规划集群所有物理节点的FQDN，将规划好的FQDN分别添加到每个物理节点的/etc/hostname；修改每个物理节点的/etc/hosts，将所有集群物理节点的IP与FQDN的对应添加好。【如部署了DNS，请联系网络管理员在DNS上做好相关配置】

 **第一步**：如果搭建集群的物理节点中，存有之前的测试数据、装过1.X的版本，或者装过其他版本的TDengine，请先将其删除，并清空所有数据，具体步骤请参考博客[《TDengine多种安装包的安装和卸载》](https://www.taosdata.com/blog/2019/08/09/566.html )   
-**注意1：**因为FQDN的信息会写进文件，如果之前没有配置或者更改FQDN，且启动了TDengine。请一定在确保数据无用或者备份的前提下，清理一下之前的数据（rm -rf /var/lib/taos/）；  
+**注意1：**因为FQDN的信息会写进文件，如果之前没有配置或者更改FQDN，且启动了TDengine。请一定在确保数据无用或者备份的前提下，清理一下之前的数据（`rm -rf /var/lib/taos/*`）；  
 **注意2：**客户端也需要配置，确保它可以正确解析每个节点的FQDN配置，不管是通过DNS服务，还是 Host 文件。

 **第二步**：建议关闭所有物理节点的防火墙，至少保证端口：6030 - 6042的TCP和UDP端口都是开放的。**强烈建议**先关闭防火墙，集群搭建完毕之后，再来配置端口；
@ -225,7 +225,13 @@ SHOW MNODES;

 ## <a class="anchor" id="arbitrator"></a>Arbitrator的使用

-如果副本数为偶数，当一个vnode group里一半vnode不工作时，是无法从中选出master的。同理，一半mnode不工作时，是无法选出mnode的master的，因为存在“split brain”问题。为解决这个问题，TDengine引入了Arbitrator的概念。Arbitrator模拟一个vnode或mnode在工作，但只简单的负责网络连接，不处理任何数据插入或访问。只要包含Arbitrator在内，超过半数的vnode或mnode工作，那么该vnode group或mnode组就可以正常的提供数据插入或查询服务。比如对于副本数为2的情形，如果一个节点A离线，但另外一个节点B正常，而且能连接到Arbitrator，那么节点B就能正常工作。
+如果副本数为偶数，当一个 vnode group 里一半 vnode 不工作时，是无法从中选出 master 的。同理，一半 mnode 不工作时，是无法选出 mnode 的 master 的，因为存在“split brain”问题。为解决这个问题，TDengine 引入了 Arbitrator 的概念。Arbitrator 模拟一个 vnode 或 mnode 在工作，但只简单的负责网络连接，不处理任何数据插入或访问。只要包含 Arbitrator 在内，超过半数的 vnode 或 mnode 工作，那么该 vnode group 或 mnode 组就可以正常的提供数据插入或查询服务。比如对于副本数为 2 的情形，如果一个节点 A 离线，但另外一个节点 B 正常，而且能连接到 Arbitrator，那么节点 B 就能正常工作。

-TDengine提供一个执行程序，名为 tarbitrator，找任何一台Linux服务器运行它即可。请点击[安装包下载](https://www.taosdata.com/cn/all-downloads/)，在TDengine Arbitrator Linux一节中，选择适合的版本下载并安装。该程序对系统资源几乎没有要求，只需要保证有网络连接即可。该应用的命令行参数`-p`可以指定其对外服务的端口号，缺省是6042。配置每个taosd实例时，可以在配置文件taos.cfg里将参数arbitrator设置为Arbitrator的End Point。如果该参数配置了，当副本数为偶数时，系统将自动连接配置的Arbitrator。如果副本数为奇数，即使配置了Arbitrator，系统也不会去建立连接。
+总之，在目前版本下，TDengine 建议在双副本环境要配置 Arbitrator，以提升系统的可用性。
+
+Arbitrator 的执行程序名为 tarbitrator。该程序对系统资源几乎没有要求，只需要保证有网络连接，找任何一台 Linux 服务器运行它即可。以下简要描述安装配置的步骤：
+1. 请点击 [安装包下载](https://www.taosdata.com/cn/all-downloads/)，在 TDengine Arbitrator Linux 一节中，选择合适的版本下载并安装。
+2. 该应用的命令行参数 `-p` 可以指定其对外服务的端口号，缺省是 6042。
+3. 修改每个 taosd 实例的配置文件，在 taos.cfg 里将参数 arbitrator 设置为 tarbitrator 程序所对应的 End Point。（如果该参数配置了，当副本数为偶数时，系统将自动连接配置的 Arbitrator。如果副本数为奇数，即使配置了 Arbitrator，系统也不会去建立连接。）
+4. 在配置文件中配置了的 Arbitrator，会出现在 `SHOW DNODES;` 指令的返回结果中，对应的 role 列的值会是“arb”。

--- a/documentation20/cn/11.administrator/docs.md
+++ b/documentation20/cn/11.administrator/docs.md
@ -432,60 +432,62 @@ TDengine的所有可执行文件默认存放在 _/usr/local/taos/bin_ 目录下

 ## <a class="anchor" id="keywords"></a>TDengine参数限制与保留关键字

- 数据库名：不能包含“.”以及特殊字符，不能超过32个字符
- 表名：不能包含“.”以及特殊字符，与所属数据库名一起，不能超过192个字符
- 表的列名：不能包含特殊字符，不能超过64个字符
+- 数据库名：不能包含“.”以及特殊字符，不能超过 32 个字符
+- 表名：不能包含“.”以及特殊字符，与所属数据库名一起，不能超过 192 个字符
+- 表的列名：不能包含特殊字符，不能超过 64 个字符
 - 数据库名、表名、列名，都不能以数字开头
- 表的列数：不能超过1024列
- 记录的最大长度：包括时间戳8 byte，不能超过16KB
- 单条SQL语句默认最大字符串长度：65480 byte
- 数据库副本数：不能超过3
- 用户名：不能超过23个byte
- 用户密码：不能超过15个byte
- 标签(Tags)数量：不能超过128个
- 标签的总长度：不能超过16Kbyte
+- 表的列数：不能超过 1024 列
+- 记录的最大长度：包括时间戳 8 byte，不能超过 16KB（每个 BINARY/NCHAR 类型的列还会额外占用 2 个 byte 的存储位置）
+- 单条 SQL 语句默认最大字符串长度：65480 byte
+- 数据库副本数：不能超过 3
+- 用户名：不能超过 23 个 byte
+- 用户密码：不能超过 15 个 byte
+- 标签(Tags)数量：不能超过 128 个
+- 标签的总长度：不能超过 16K byte
 - 记录条数：仅受存储空间限制
 - 表的个数：仅受节点个数限制
 - 库的个数：仅受节点个数限制
- 单个库上虚拟节点个数：不能超过64个
+- 单个库上虚拟节点个数：不能超过 64 个

-目前TDengine有将近200个内部保留关键字，这些关键字无论大小写均不可以用作库名、表名、STable名、数据列名及标签列名等。这些关键字列表如下：
+目前 TDengine 有将近 200 个内部保留关键字，这些关键字无论大小写均不可以用作库名、表名、STable 名、数据列名及标签列名等。这些关键字列表如下：

 | 关键字列表 |             |              |            |           |
 | ---------- | ----------- | ------------ | ---------- | --------- |
-| ABLOCKS    | CONNECTION  | GROUP        | MINUS      | SLASH     |
-| ABORT      | CONNECTIONS | GT           | MNODES     | SLIDING   |
-| ACCOUNT    | COPY        | ID           | MODULES    | SMALLINT  |
-| ACCOUNTS   | COUNT       | IF           | NCHAR      | SPREAD    |
-| ADD        | CREATE      | IGNORE       | NE         | STABLE    |
-| AFTER      | CTIME       | IMMEDIATE    | NONE       | STABLES   |
-| ALL        | DATABASE    | IMPORT       | NOT        | STAR      |
-| ALTER      | DATABASES   | IN           | NOTNULL    | STATEMENT |
-| AND        | DAYS        | INITIALLY    | NOW        | STDDEV    |
-| AS         | DEFERRED    | INSERT       | OF         | STREAM    |
-| ASC        | DELIMITERS  | INSTEAD      | OFFSET     | STREAMS   |
-| ATTACH     | DESC        | INTEGER      | OR         | STRING    |
-| AVG        | DESCRIBE    | INTERVAL     | ORDER      | SUM       |
-| BEFORE     | DETACH      | INTO         | PASS       | TABLE     |
-| BEGIN      | DIFF        | IP           | PERCENTILE | TABLES    |
-| BETWEEN    | DISTINCT    | IS           | PLUS       | TAG       |
-| BIGINT     | DIVIDE      | ISNULL       | PRAGMA     | TAGS      |
-| BINARY     | DNODE       | JOIN         | PREV       | TBLOCKS   |
-| BITAND     | DNODES      | KEEP         | PRIVILEGE  | TBNAME    |
-| BITNOT     | DOT         | KEY          | QUERIES    | TIMES     |
-| BITOR      | DOUBLE      | KILL         | QUERY      | TIMESTAMP |
-| BOOL       | DROP        | LAST         | RAISE      | TINYINT   |
-| BOTTOM     | EACH        | LE           | REM        | TOP       |
-| BY         | END         | LEASTSQUARES | REPLACE    | TRIGGER   |
-| CACHE      | EQ          | LIKE         | REPLICA    | UMINUS    |
-| CASCADE    | EXISTS      | LIMIT        | RESET      | UPLUS     |
-| CHANGE     | EXPLAIN     | LINEAR       | RESTRICT   | USE       |
-| CLOG       | FAIL        | LOCAL        | ROW        | USER      |
-| CLUSTER    | FILL        | LP           | ROWS       | USERS     |
-| COLON      | FIRST       | LSHIFT       | RP         | USING     |
-| COLUMN     | FLOAT       | LT           | RSHIFT     | VALUES    |
-| COMMA      | FOR         | MATCH        | SCORES     | VARIABLE  |
-| COMP       | FROM        | MAX          | SELECT     | VGROUPS   |
-| CONCAT     | GE          | METRIC       | SEMI       | VIEW      |
-| CONFIGS    | GLOB        | METRICS      | SET        | WAVG      |
-| CONFLICT   | GRANTS      | MIN          | SHOW       | WHERE     |
+| ABLOCKS    | CONNECTIONS | GT           | MNODES     | SLIDING   |
+| ABORT      | COPY        | ID           | MODULES    | SLIMIT    |
+| ACCOUNT    | COUNT       | IF           | NCHAR      | SMALLINT  |
+| ACCOUNTS   | CREATE      | IGNORE       | NE         | SPREAD    |
+| ADD        | CTIME       | IMMEDIATE    | NONE       | STABLE    |
+| AFTER      | DATABASE    | IMPORT       | NOT        | STABLES   |
+| ALL        | DATABASES   | IN           | NOTNULL    | STAR      |
+| ALTER      | DAYS        | INITIALLY    | NOW        | STATEMENT |
+| AND        | DEFERRED    | INSERT       | OF         | STDDEV    |
+| AS         | DELIMITERS  | INSTEAD      | OFFSET     | STREAM    |
+| ASC        | DESC        | INTEGER      | OR         | STREAMS   |
+| ATTACH     | DESCRIBE    | INTERVAL     | ORDER      | STRING    |
+| AVG        | DETACH      | INTO         | PASS       | SUM       |
+| BEFORE     | DIFF        | IP           | PERCENTILE | TABLE     |
+| BEGIN      | DISTINCT    | IS           | PLUS       | TABLES    |
+| BETWEEN    | DIVIDE      | ISNULL       | PRAGMA     | TAG       |
+| BIGINT     | DNODE       | JOIN         | PREV       | TAGS      |
+| BINARY     | DNODES      | KEEP         | PRIVILEGE  | TBLOCKS   |
+| BITAND     | DOT         | KEY          | QUERIES    | TBNAME    |
+| BITNOT     | DOUBLE      | KILL         | QUERY      | TIMES     |
+| BITOR      | DROP        | LAST         | RAISE      | TIMESTAMP |
+| BOOL       | EACH        | LE           | REM        | TINYINT   |
+| BOTTOM     | END         | LEASTSQUARES | REPLACE    | TOP       |
+| BY         | EQ          | LIKE         | REPLICA    | TRIGGER   |
+| CACHE      | EXISTS      | LIMIT        | RESET      | UMINUS    |
+| CASCADE    | EXPLAIN     | LINEAR       | RESTRICT   | UPLUS     |
+| CHANGE     | FAIL        | LOCAL        | ROW        | USE       |
+| CLOG       | FILL        | LP           | ROWS       | USER      |
+| CLUSTER    | FIRST       | LSHIFT       | RP         | USERS     |
+| COLON      | FLOAT       | LT           | RSHIFT     | USING     |
+| COLUMN     | FOR         | MATCH        | SCORES     | VALUES    |
+| COMMA      | FROM        | MAX          | SELECT     | VARIABLE  |
+| COMP       | GE          | METRIC       | SEMI       | VGROUPS   |
+| CONCAT     | GLOB        | METRICS      | SET        | VIEW      |
+| CONFIGS    | GRANTS      | MIN          | SHOW       | WAVG      |
+| CONFLICT   | GROUP       | MINUS        | SLASH      | WHERE     |
+| CONNECTION |             |              |            |           |
+
--- a/documentation20/cn/12.taos-sql/docs.md
+++ b/documentation20/cn/12.taos-sql/docs.md
@ -1,17 +1,19 @@
 # TAOS SQL

-本文档说明TAOS SQL支持的语法规则、主要查询功能、支持的SQL查询函数，以及常用技巧等内容。阅读本文档需要读者具有基本的SQL语言的基础。
+本文档说明 TAOS SQL 支持的语法规则、主要查询功能、支持的 SQL 查询函数，以及常用技巧等内容。阅读本文档需要读者具有基本的 SQL 语言的基础。

-TAOS SQL是用户对TDengine进行数据写入和查询的主要工具。TAOS SQL为了便于用户快速上手，在一定程度上提供类似于标准SQL类似的风格和模式。严格意义上，TAOS SQL并不是也不试图提供SQL标准的语法。此外，由于TDengine针对的时序性结构化数据不提供删除功能，因此在TAO SQL中不提供数据删除的相关功能。
+TAOS SQL 是用户对 TDengine 进行数据写入和查询的主要工具。TAOS SQL 为了便于用户快速上手，在一定程度上提供类似于标准 SQL 类似的风格和模式。严格意义上，TAOS SQL 并不是也不试图提供 SQL 标准的语法。此外，由于 TDengine 针对的时序性结构化数据不提供删除功能，因此在 TAO SQL 中不提供数据删除的相关功能。

-本章节SQL语法遵循如下约定：
+TAOS SQL 不支持关键字的缩写，例如 DESCRIBE 不能缩写为 DESC。 

- < > 里的内容是用户需要输入的，但不要输入<>本身
- [ ]表示内容为可选项，但不能输入[]本身
- | 表示多选一，选择其中一个即可，但不能输入|本身
+本章节 SQL 语法遵循如下约定：
+
+- < > 里的内容是用户需要输入的，但不要输入 <> 本身
+- [ ] 表示内容为可选项，但不能输入 [] 本身
+- | 表示多选一，选择其中一个即可，但不能输入 | 本身
 - … 表示前面的项可重复多个

-为更好地说明SQL语法的规则及其特点，本文假设存在一个数据集。以智能电表(meters)为例，假设每个智能电表采集电流、电压、相位三个量。其建模如下：
+为更好地说明 SQL 语法的规则及其特点，本文假设存在一个数据集。以智能电表(meters)为例，假设每个智能电表采集电流、电压、相位三个量。其建模如下：
 ```mysql
 taos> DESCRIBE meters;
             Field              |        Type        |   Length    |    Note    |
@ -23,7 +25,7 @@ taos> DESCRIBE meters;
 location                       | BINARY             |          64 | TAG        |
 groupid                        | INT                |           4 | TAG        |
 ```
-数据集包含4个智能电表的数据，按照TDengine的建模规则，对应4个子表，其名称分别是 d1001, d1002, d1003, d1004。
+数据集包含 4 个智能电表的数据，按照 TDengine 的建模规则，对应 4 个子表，其名称分别是 d1001, d1002, d1003, d1004。

 ## <a class="anchor" id="data-type"></a>支持的数据类型

@ -142,15 +144,15 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
    ```
    说明：

-    1) 表的第一个字段必须是TIMESTAMP，并且系统自动将其设为主键；
+    1) 表的第一个字段必须是 TIMESTAMP，并且系统自动将其设为主键；

-    2) 表名最大长度为192；
+    2) 表名最大长度为 192；

-    3) 表的每行长度不能超过16k个字符;
+    3) 表的每行长度不能超过 16k 个字符;（注意：每个 BINARY/NCHAR 类型的列还会额外占用 2 个字节的存储位置）

    4) 子表名只能由字母、数字和下划线组成，且不能以数字开头

-    5) 使用数据类型binary或nchar，需指定其最长的字节数，如binary(20)，表示20字节；
+    5) 使用数据类型 binary 或 nchar，需指定其最长的字节数，如 binary(20)，表示 20 字节；

 - **以超级表为模板创建数据表**

@ -402,8 +404,8 @@ SELECT select_expr [, select_expr ...]
    FROM {tb_name_list}
    [WHERE where_condition]
    [INTERVAL (interval_val [, interval_offset])]
+    [SLIDING sliding_val]
    [FILL fill_val]
-    [SLIDING fill_val]
    [GROUP BY col_list]
    [ORDER BY col_list { DESC | ASC }]
    [SLIMIT limit_val [, SOFFSET offset_val]]
@ -619,27 +621,30 @@ taos> SELECT COUNT(tbname) FROM meters WHERE groupId > 2;
 Query OK, 1 row(s) in set (0.001091s)
 ```

- 可以使用* 返回所有列，或指定列名。可以对数字列进行四则运算，可以给输出的列取列名
- where语句可以使用各种逻辑判断来过滤数字值，或使用通配符来过滤字符串
- 输出结果缺省按首列时间戳升序排序，但可以指定按降序排序(_c0指首列时间戳)。使用ORDER BY对其他字段进行排序为非法操作。
- 参数LIMIT控制输出条数，OFFSET指定从第几条开始输出。LIMIT/OFFSET对结果集的执行顺序在ORDER BY之后。
+- 可以使用 * 返回所有列，或指定列名。可以对数字列进行四则运算，可以给输出的列取列名
+- WHERE 语句可以使用各种逻辑判断来过滤数字值，或使用通配符来过滤字符串
+- 输出结果缺省按首列时间戳升序排序，但可以指定按降序排序( _c0 指首列时间戳)。使用 ORDER BY 对其他字段进行排序为非法操作。
+- 参数 LIMIT 控制输出条数，OFFSET 指定从第几条开始输出。LIMIT/OFFSET 对结果集的执行顺序在 ORDER BY 之后。
+- 参数 SLIMIT 控制由 GROUP BY 指令划分的每个分组中的输出条数。
 - 通过”>>"输出结果可以导出到指定文件

 ### 支持的条件过滤操作

-| Operation | Note                          | Applicable Data Types                 |
-| --------- | ----------------------------- | ------------------------------------- |
-| >         | larger than                   | **`timestamp`** and all numeric types |
-| <         | smaller than                  | **`timestamp`** and all numeric types |
-| >=        | larger than or equal to       | **`timestamp`** and all numeric types |
-| <=        | smaller than or equal to      | **`timestamp`** and all numeric types |
-| =         | equal to                      | all types                             |
-| <>        | not equal to                  | all types                             |
-| %         | match with any char sequences | **`binary`** **`nchar`**              |
-| _         | match with a single char      | **`binary`** **`nchar`**              |
+| Operation   | Note                          | Applicable Data Types                 |
+| ----------- | ----------------------------- | ------------------------------------- |
+| >           | larger than                   | **`timestamp`** and all numeric types |
+| <           | smaller than                  | **`timestamp`** and all numeric types |
+| >=          | larger than or equal to       | **`timestamp`** and all numeric types |
+| <=          | smaller than or equal to      | **`timestamp`** and all numeric types |
+| =           | equal to                      | all types                             |
+| <>          | not equal to                  | all types                             |
+| between and | within a certain range        | **`timestamp`** and all numeric types |
+| %           | match with any char sequences | **`binary`** **`nchar`**              |
+| _           | match with a single char      | **`binary`** **`nchar`**              |

 1. 同时进行多个字段的范围过滤，需要使用关键词 AND 来连接不同的查询条件，暂不支持 OR 连接的不同列之间的查询过滤条件。
-2. 针对单一字段的过滤，如果是时间过滤条件，则一条语句中只支持设定一个；但针对其他的（普通）列或标签列，则可以使用``` OR``` 关键字进行组合条件的查询过滤。例如：((value > 20 and value < 30) OR (value < 12)) 。
+2. 针对单一字段的过滤，如果是时间过滤条件，则一条语句中只支持设定一个；但针对其他的（普通）列或标签列，则可以使用 `OR` 关键字进行组合条件的查询过滤。例如：((value > 20 AND value < 30) OR (value < 12)) 。
+3. 从 2.0.17 版本开始，条件过滤开始支持 BETWEEN AND 语法，例如 `WHERE col2 BETWEEN 1.5 AND 3.25` 表示查询条件为“1.5 ≤ col2 ≤ 3.25”。

 ### SQL 示例 

@ -1160,17 +1165,20 @@ TDengine支持按时间段进行聚合，可以将表中数据按照时间段进
 SELECT function_list FROM tb_name
  [WHERE where_condition]
  INTERVAL (interval [, offset])
+  [SLIDING sliding]
  [FILL ({NONE | VALUE | PREV | NULL | LINEAR})]

 SELECT function_list FROM stb_name
  [WHERE where_condition]
  INTERVAL (interval [, offset])
+  [SLIDING sliding]
  [FILL ({ VALUE | PREV | NULL | LINEAR})]
  [GROUP BY tags]
 ```

 - 聚合时间段的长度由关键词INTERVAL指定，最短时间间隔10毫秒（10a），并且支持偏移（偏移必须小于间隔）。聚合查询中，能够同时执行的聚合和选择函数仅限于单个输出的函数：count、avg、sum 、stddev、leastsquares、percentile、min、max、first、last，不能使用具有多行输出结果的函数（例如：top、bottom、diff以及四则运算）。
 - WHERE语句可以指定查询的起止时间和其他过滤条件
+- SLIDING语句用于指定聚合时间段的前向增量
 - FILL语句指定某一时间区间数据缺失的情况下的填充模式。填充模式包括以下几种：
  * 不进行填充：NONE(默认填充模式)。
  * VALUE填充：固定值填充，此时需要指定填充的数值。例如：fill(value, 1.23)。
@ -1182,6 +1190,8 @@ SELECT function_list FROM stb_name
  2. 在时间维度聚合中，返回的结果中时间序列严格单调递增。
  3. 如果查询对象是超级表，则聚合函数会作用于该超级表下满足值过滤条件的所有表的数据。如果查询中没有使用group by语句，则返回的结果按照时间序列严格单调递增；如果查询中使用了group by语句分组，则返回结果中每个group内不按照时间序列严格单调递增。

+时间聚合也常被用于连续查询场景，可以参考文档 [连续查询(Continuous Query)](https://www.taosdata.com/cn/documentation/advanced-features#continuous-query)。
+
 **示例:** 智能电表的建表语句如下：

 ```mysql
@ -1200,11 +1210,11 @@ SELECT AVG(current), MAX(current), LEASTSQUARES(current, start_val, step_val), P

 ## <a class="anchor" id="limitation"></a>TAOS SQL 边界限制

- 数据库名最大长度为32
- 表名最大长度为192，每行数据最大长度16k个字符
- 列名最大长度为64，最多允许1024列，最少需要2列，第一列必须是时间戳
- 标签最多允许128个，可以1个，标签总长度不超过16k个字符
- SQL语句最大长度65480个字符，但可通过系统配置参数maxSQLLength修改，最长可配置为1M
+- 数据库名最大长度为 32
+- 表名最大长度为 192，每行数据最大长度 16k 个字符（注意：数据行内每个 BINARY/NCHAR 类型的列还会额外占用 2 个字节的存储位置）
+- 列名最大长度为 64，最多允许 1024 列，最少需要 2 列，第一列必须是时间戳
+- 标签最多允许 128 个，可以 1 个，标签总长度不超过 16k 个字符
+- SQL 语句最大长度 65480 个字符，但可通过系统配置参数 maxSQLLength 修改，最长可配置为 1M
 - 库的数目，超级表的数目、表的数目，系统不做限制，仅受系统资源限制

 ##  TAOS SQL其他约定
@ -1219,4 +1229,5 @@ TAOS SQL支持表之间按主键时间戳来join两张表的列，暂不支持

 **is not null与不为空的表达式适用范围**

-is not null支持所有类型的列。不为空的表达式为 <>""，仅对非数值类型的列适用。
+is not null支持所有类型的列。不为空的表达式为 <>""，仅对非数值类型的列适用。
+
--- a/documentation20/cn/13.faq/docs.md
+++ b/documentation20/cn/13.faq/docs.md
@ -92,6 +92,8 @@ TDengine 目前尚不支持删除功能，未来根据用户需求可能会支

 从 2.0.8.0 开始，TDengine 支持更新已经写入数据的功能。使用更新功能需要在创建数据库时使用 UPDATE 1 参数，之后可以使用 INSERT INTO 命令更新已经写入的相同时间戳数据。UPDATE 参数不支持 ALTER DATABASE 命令修改。没有使用 UPDATE 1 参数创建的数据库，写入相同时间戳的数据不会修改之前的数据，也不会报错。

+另需注意，在 UPDATE 设置为 0 时，后发送的相同时间戳的数据会被直接丢弃，但并不会报错，而且仍然会被计入 affected rows （所以不能利用 INSERT 指令的返回信息进行时间戳查重）。这样设计的主要原因是，TDengine 把写入的数据看做一个数据流，无论时间戳是否出现冲突，TDengine 都认为产生数据的原始设备真实地产生了这样的数据。UPDATE 参数只是控制这样的流数据在进行持久化时要怎样处理——UPDATE 为 0 时，表示先写入的数据覆盖后写入的数据；而 UPDATE 为 1 时，表示后写入的数据覆盖先写入的数据。这种覆盖关系如何选择，取决于对数据的后续使用和统计中，希望以先还是后生成的数据为准。
+
 ## 10. 我怎么创建超过1024列的表？

 使用2.0及其以上版本，默认支持1024列；2.0之前的版本，TDengine最大允许创建250列的表。但是如果确实超过限值，建议按照数据特性，逻辑地将这个宽表分解成几个小表。
--- a/src/connector/jdbc/CMakeLists.txt
+++ b/src/connector/jdbc/CMakeLists.txt
@ -8,7 +8,7 @@ IF (TD_MVN_INSTALLED)
  ADD_CUSTOM_COMMAND(OUTPUT ${JDBC_CMD_NAME}
    POST_BUILD
    COMMAND mvn -Dmaven.test.skip=true install -f ${CMAKE_CURRENT_SOURCE_DIR}/pom.xml
-    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/target/taos-jdbcdriver-2.0.20-dist.jar ${LIBRARY_OUTPUT_PATH}
+    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/target/taos-jdbcdriver-2.0.21-dist.jar ${LIBRARY_OUTPUT_PATH}
    COMMAND mvn -Dmaven.test.skip=true clean -f ${CMAKE_CURRENT_SOURCE_DIR}/pom.xml
    COMMENT "build jdbc driver")
  ADD_CUSTOM_TARGET(${JDBC_TARGET_NAME} ALL WORKING_DIRECTORY ${EXECUTABLE_OUTPUT_PATH} DEPENDS ${JDBC_CMD_NAME})
--- a/src/connector/jdbc/deploy-pom.xml
+++ b/src/connector/jdbc/deploy-pom.xml
@ -5,7 +5,7 @@

  <groupId>com.taosdata.jdbc</groupId>
  <artifactId>taos-jdbcdriver</artifactId>
-  <version>2.0.20</version>
+  <version>2.0.21</version>
  <packaging>jar</packaging>

  <name>JDBCDriver</name>
--- a/src/connector/jdbc/pom.xml
+++ b/src/connector/jdbc/pom.xml
@ -3,7 +3,7 @@
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.taosdata.jdbc</groupId>
    <artifactId>taos-jdbcdriver</artifactId>
-    <version>2.0.20</version>
+    <version>2.0.21</version>
    <packaging>jar</packaging>
    <name>JDBCDriver</name>
    <url>https://github.com/taosdata/TDengine/tree/master/src/connector/jdbc</url>
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/DatabaseMetaDataResultSet.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/DatabaseMetaDataResultSet.java
@ -308,7 +308,7 @@ public class DatabaseMetaDataResultSet implements ResultSet {
                return colMetaData.getColIndex() + 1;
            }
        }
-        throw new SQLException(TSDBConstants.INVALID_VARIABLES);
+        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_VARIABLE);
    }

    @Override
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBConstants.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBConstants.java
@ -14,16 +14,13 @@
 *****************************************************************************/
 package com.taosdata.jdbc;

+import java.sql.SQLException;
+import java.sql.Types;
 import java.util.HashMap;
 import java.util.Map;

 public abstract class TSDBConstants {

-    public static final String STATEMENT_CLOSED = "statement is closed";
-    public static final String UNSUPPORTED_METHOD_EXCEPTION_MSG = "this operation is NOT supported currently!";
-    public static final String INVALID_VARIABLES = "invalid variables";
-    public static final String RESULT_SET_IS_CLOSED = "resultSet is closed";
-
    public static final String DEFAULT_PORT = "6200";
    public static Map<Integer, String> DATATYPE_MAP = null;

@ -77,8 +74,65 @@ public abstract class TSDBConstants {
        return WrapErrMsg("unkown error!");
    }

+    public static int taosType2JdbcType(int taosType) throws SQLException {
+        switch (taosType) {
+            case TSDBConstants.TSDB_DATA_TYPE_NULL:
+                return Types.NULL;
+            case TSDBConstants.TSDB_DATA_TYPE_BOOL:
+                return Types.BOOLEAN;
+            case TSDBConstants.TSDB_DATA_TYPE_TINYINT:
+                return Types.TINYINT;
+            case TSDBConstants.TSDB_DATA_TYPE_SMALLINT:
+                return Types.SMALLINT;
+            case TSDBConstants.TSDB_DATA_TYPE_INT:
+                return Types.INTEGER;
+            case TSDBConstants.TSDB_DATA_TYPE_BIGINT:
+                return Types.BIGINT;
+            case TSDBConstants.TSDB_DATA_TYPE_FLOAT:
+                return Types.FLOAT;
+            case TSDBConstants.TSDB_DATA_TYPE_DOUBLE:
+                return Types.DOUBLE;
+            case TSDBConstants.TSDB_DATA_TYPE_BINARY:
+                return Types.BINARY;
+            case TSDBConstants.TSDB_DATA_TYPE_TIMESTAMP:
+                return Types.TIMESTAMP;
+            case TSDBConstants.TSDB_DATA_TYPE_NCHAR:
+                return Types.NCHAR;
+        }
+        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNKNOWN_SQL_TYPE_IN_TDENGINE);
+    }
+
+    public static int jdbcType2TaosType(int jdbcType) throws SQLException {
+        switch (jdbcType){
+            case Types.NULL:
+                return TSDBConstants.TSDB_DATA_TYPE_NULL;
+            case Types.BOOLEAN:
+                return TSDBConstants.TSDB_DATA_TYPE_BOOL;
+            case Types.TINYINT:
+                return TSDBConstants.TSDB_DATA_TYPE_TINYINT;
+            case Types.SMALLINT:
+                return TSDBConstants.TSDB_DATA_TYPE_SMALLINT;
+            case Types.INTEGER:
+                return TSDBConstants.TSDB_DATA_TYPE_INT;
+            case Types.BIGINT:
+                return TSDBConstants.TSDB_DATA_TYPE_BIGINT;
+            case Types.FLOAT:
+                return TSDBConstants.TSDB_DATA_TYPE_FLOAT;
+            case Types.DOUBLE:
+                return TSDBConstants.TSDB_DATA_TYPE_DOUBLE;
+            case Types.BINARY:
+                return TSDBConstants.TSDB_DATA_TYPE_BINARY;
+            case Types.TIMESTAMP:
+                return TSDBConstants.TSDB_DATA_TYPE_TIMESTAMP;
+            case Types.NCHAR:
+                return TSDBConstants.TSDB_DATA_TYPE_NCHAR;
+        }
+        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNKNOWN_SQL_TYPE_IN_TDENGINE);
+    }
+
    static {
        DATATYPE_MAP = new HashMap<>();
+        DATATYPE_MAP.put(0, "NULL");
        DATATYPE_MAP.put(1, "BOOL");
        DATATYPE_MAP.put(2, "TINYINT");
        DATATYPE_MAP.put(3, "SMALLINT");
@ -90,4 +144,8 @@ public abstract class TSDBConstants {
        DATATYPE_MAP.put(9, "TIMESTAMP");
        DATATYPE_MAP.put(10, "NCHAR");
    }
+
+    public static String jdbcType2TaosTypeName(int type) throws SQLException {
+        return DATATYPE_MAP.get(jdbcType2TaosType(type));
+    }
 }
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBErrorNumbers.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBErrorNumbers.java
@ -18,6 +18,7 @@ public class TSDBErrorNumbers {
    public static final int ERROR_INVALID_FOR_EXECUTE = 0x230c;         //not a valid sql for execute: (SQL)
    public static final int ERROR_PARAMETER_INDEX_OUT_RANGE = 0x230d; // parameter index out of range
    public static final int ERROR_SQLCLIENT_EXCEPTION_ON_CONNECTION_CLOSED = 0x230e;    // connection already closed
+    public static final int ERROR_UNKNOWN_SQL_TYPE_IN_TDENGINE = 0x230f;        //unknown sql type in tdengine

    public static final int ERROR_UNKNOWN = 0x2350;    //unknown error

@ -49,6 +50,7 @@ public class TSDBErrorNumbers {
        errorNumbers.add(ERROR_INVALID_FOR_EXECUTE);
        errorNumbers.add(ERROR_PARAMETER_INDEX_OUT_RANGE);
        errorNumbers.add(ERROR_SQLCLIENT_EXCEPTION_ON_CONNECTION_CLOSED);
+        errorNumbers.add(ERROR_UNKNOWN_SQL_TYPE_IN_TDENGINE);

        /*****************************************************/
        errorNumbers.add(ERROR_SUBSCRIBE_FAILED);
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetMetaData.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetMetaData.java
@ -20,7 +20,7 @@ import java.sql.Timestamp;
 import java.sql.Types;
 import java.util.List;

-public class TSDBResultSetMetaData implements ResultSetMetaData {
+public class TSDBResultSetMetaData extends WrapperImpl implements ResultSetMetaData {

 	List<ColumnMetaData> colMetaDataList = null;

@ -28,14 +28,6 @@ public class TSDBResultSetMetaData implements ResultSetMetaData {
 		this.colMetaDataList = metaDataList;
 	}

-	public <T> T unwrap(Class<T> iface) throws SQLException {
-		throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
-	}
-
-	public boolean isWrapperFor(Class<?> iface) throws SQLException {
-		throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
-	}
-
 	public int getColumnCount() throws SQLException {
 		return colMetaDataList.size();
 	}
@ -94,7 +86,7 @@ public class TSDBResultSetMetaData implements ResultSetMetaData {
 	}

 	public String getSchemaName(int column) throws SQLException {
-		throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
+		throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
 	}

 	public int getPrecision(int column) throws SQLException {
@ -125,18 +117,18 @@ public class TSDBResultSetMetaData implements ResultSetMetaData {
 	}

 	public String getTableName(int column) throws SQLException {
-		throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
+		throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
 	}

 	public String getCatalogName(int column) throws SQLException {
-		throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
+		throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
 	}

 	public int getColumnType(int column) throws SQLException {
 		ColumnMetaData meta = this.colMetaDataList.get(column - 1);
 		switch (meta.getColType()) {
 		case TSDBConstants.TSDB_DATA_TYPE_BOOL:
-			return java.sql.Types.BIT;
+			return Types.BOOLEAN;
 		case TSDBConstants.TSDB_DATA_TYPE_TINYINT:
 			return java.sql.Types.TINYINT;
 		case TSDBConstants.TSDB_DATA_TYPE_SMALLINT:
@ -150,13 +142,13 @@ public class TSDBResultSetMetaData implements ResultSetMetaData {
 		case TSDBConstants.TSDB_DATA_TYPE_DOUBLE:
 			return java.sql.Types.DOUBLE;
 		case TSDBConstants.TSDB_DATA_TYPE_BINARY:
-			return java.sql.Types.CHAR;
+			return Types.BINARY;
 		case TSDBConstants.TSDB_DATA_TYPE_TIMESTAMP:
-			return java.sql.Types.BIGINT;
+			return java.sql.Types.TIMESTAMP;
 		case TSDBConstants.TSDB_DATA_TYPE_NCHAR:
-			return java.sql.Types.CHAR;
+			return Types.NCHAR;
 		}
-		throw new SQLException(TSDBConstants.INVALID_VARIABLES);
+		throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_VARIABLE);
 	}

 	public String getColumnTypeName(int column) throws SQLException {
@ -173,7 +165,7 @@ public class TSDBResultSetMetaData implements ResultSetMetaData {
 	}

 	public boolean isDefinitelyWritable(int column) throws SQLException {
-		throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
+		throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
 	}

 	public String getColumnClassName(int column) throws SQLException {
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetWrapper.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetWrapper.java
@ -1153,11 +1153,11 @@ public class TSDBResultSetWrapper implements ResultSet {
    }

    public <T> T getObject(int columnIndex, Class<T> type) throws SQLException {
-        throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
+        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
    }

    public <T> T getObject(String columnLabel, Class<T> type) throws SQLException {
-        throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
+        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
    }

    @Override
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBSubscribe.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBSubscribe.java
@ -14,12 +14,11 @@
 *****************************************************************************/
 package com.taosdata.jdbc;

-import javax.management.OperationsException;
 import java.sql.SQLException;

 public class TSDBSubscribe {
-    private TSDBJNIConnector connecter = null;
-    private long id = 0;
+    private final TSDBJNIConnector connecter;
+    private final long id;

    TSDBSubscribe(TSDBJNIConnector connecter, long id) throws SQLException {
        if (null != connecter) {
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulResultSet.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulResultSet.java
@ -18,10 +18,10 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
    private final String database;
    private final Statement statement;
    // data
-    private ArrayList<ArrayList<Object>> resultSet = new ArrayList<>();
+    private ArrayList<ArrayList<Object>> resultSet;
    // meta
-    private ArrayList<String> columnNames = new ArrayList<>();
-    private ArrayList<Field> columns = new ArrayList<>();
+    private ArrayList<String> columnNames;
+    private ArrayList<Field> columns;
    private RestfulResultSetMetaData metaData;

    /**
@ -29,11 +29,36 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
     *
     * @param resultJson: 包含data信息的结果集，有sql返回的结果集
     ***/
-    public RestfulResultSet(String database, Statement statement, JSONObject resultJson) {
+    public RestfulResultSet(String database, Statement statement, JSONObject resultJson) throws SQLException {
        this.database = database;
        this.statement = statement;
+        // column metadata
+        JSONArray columnMeta = resultJson.getJSONArray("column_meta");
+        columnNames = new ArrayList<>();
+        columns = new ArrayList<>();
+        for (int colIndex = 0; colIndex < columnMeta.size(); colIndex++) {
+            JSONArray col = columnMeta.getJSONArray(colIndex);
+            String col_name = col.getString(0);
+            int col_type = TSDBConstants.taosType2JdbcType(col.getInteger(1));
+            int col_length = col.getInteger(2);
+            columnNames.add(col_name);
+            columns.add(new Field(col_name, col_type, col_length, ""));
+        }
+        this.metaData = new RestfulResultSetMetaData(this.database, columns, this);
+
        // row data
        JSONArray data = resultJson.getJSONArray("data");
+        resultSet = new ArrayList<>();
+        for (int rowIndex = 0; rowIndex < data.size(); rowIndex++) {
+            ArrayList row = new ArrayList();
+            JSONArray jsonRow = data.getJSONArray(rowIndex);
+            for (int colIndex = 0; colIndex < jsonRow.size(); colIndex++) {
+                row.add(parseColumnData(jsonRow, colIndex, columns.get(colIndex).type));
+            }
+            resultSet.add(row);
+        }
+
+        /*
        int columnIndex = 0;
        for (; columnIndex < data.size(); columnIndex++) {
            ArrayList oneRow = new ArrayList<>();
@ -52,50 +77,77 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
            columns.add(new Field(name, "", 0, ""));
        }
        this.metaData = new RestfulResultSetMetaData(this.database, columns, this);
+         */
    }

-    /**
-     * 由多个resultSet的JSON构造结果集
-     *
-     * @param resultJson: 包含data信息的结果集，有sql返回的结果集
-     * @param fieldJson:  包含多个（最多2个）meta信息的结果集，有describe xxx
-     **/
-    public RestfulResultSet(String database, Statement statement, JSONObject resultJson, List<JSONObject> fieldJson) {
-        this(database, statement, resultJson);
-        ArrayList<Field> newColumns = new ArrayList<>();
-
-        for (Field column : columns) {
-            Field field = findField(column.name, fieldJson);
-            if (field != null) {
-                newColumns.add(field);
-            } else {
-                newColumns.add(column);
-            }
+    private Object parseColumnData(JSONArray row, int colIndex, int sqlType) {
+        switch (sqlType) {
+            case Types.NULL:
+                return null;
+            case Types.BOOLEAN:
+                return row.getBoolean(colIndex);
+            case Types.TINYINT:
+            case Types.SMALLINT:
+                return row.getShort(colIndex);
+            case Types.INTEGER:
+                return row.getInteger(colIndex);
+            case Types.BIGINT:
+                return row.getBigInteger(colIndex);
+            case Types.FLOAT:
+                return row.getFloat(colIndex);
+            case Types.DOUBLE:
+                return row.getDouble(colIndex);
+            case Types.TIMESTAMP:
+                return new Timestamp(row.getDate(colIndex).getTime());
+            case Types.BINARY:
+            case Types.NCHAR:
+            default:
+                return row.getString(colIndex);
        }
-        this.columns = newColumns;
-        this.metaData = new RestfulResultSetMetaData(this.database, this.columns, this);
    }

-    public Field findField(String columnName, List<JSONObject> fieldJsonList) {
-        for (JSONObject fieldJSON : fieldJsonList) {
-            JSONArray fieldDataJson = fieldJSON.getJSONArray("data");
-            for (int i = 0; i < fieldDataJson.size(); i++) {
-                JSONArray field = fieldDataJson.getJSONArray(i);
-                if (columnName.equalsIgnoreCase(field.getString(0))) {
-                    return new Field(field.getString(0), field.getString(1), field.getInteger(2), field.getString(3));
-                }
-            }
-        }
-        return null;
-    }
+//    /**
+//     * 由多个resultSet的JSON构造结果集
+//     *
+//     * @param resultJson: 包含data信息的结果集，有sql返回的结果集
+//     * @param fieldJson:  包含多个（最多2个）meta信息的结果集，有describe xxx
+//     **/
+//    public RestfulResultSet(String database, Statement statement, JSONObject resultJson, List<JSONObject> fieldJson) throws SQLException {
+//        this(database, statement, resultJson);
+//        ArrayList<Field> newColumns = new ArrayList<>();
+//
+//        for (Field column : columns) {
+//            Field field = findField(column.name, fieldJson);
+//            if (field != null) {
+//                newColumns.add(field);
+//            } else {
+//                newColumns.add(column);
+//            }
+//        }
+//        this.columns = newColumns;
+//        this.metaData = new RestfulResultSetMetaData(this.database, this.columns, this);
+//    }
+
+//    public Field findField(String columnName, List<JSONObject> fieldJsonList) {
+//        for (JSONObject fieldJSON : fieldJsonList) {
+//            JSONArray fieldDataJson = fieldJSON.getJSONArray("data");
+//            for (int i = 0; i < fieldDataJson.size(); i++) {
+//                JSONArray field = fieldDataJson.getJSONArray(i);
+//                if (columnName.equalsIgnoreCase(field.getString(0))) {
+//                    return new Field(field.getString(0), field.getString(1), field.getInteger(2), field.getString(3));
+//                }
+//            }
+//        }
+//        return null;
+//    }

    public class Field {
        String name;
-        String type;
+        int type;
        int length;
        String note;

-        public Field(String name, String type, int length, String note) {
+        public Field(String name, int type, int length, String note) {
            this.name = name;
            this.type = type;
            this.length = length;
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulResultSetMetaData.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulResultSetMetaData.java
@ -5,6 +5,7 @@ import com.taosdata.jdbc.TSDBConstants;
 import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
 import java.sql.Timestamp;
+import java.sql.Types;
 import java.util.ArrayList;

 public class RestfulResultSetMetaData implements ResultSetMetaData {
@ -53,14 +54,14 @@ public class RestfulResultSetMetaData implements ResultSetMetaData {

    @Override
    public boolean isSigned(int column) throws SQLException {
-        String type = this.fields.get(column - 1).type.toUpperCase();
+        int type = this.fields.get(column - 1).type;
        switch (type) {
-            case "TINYINT":
-            case "SMALLINT":
-            case "INT":
-            case "BIGINT":
-            case "FLOAT":
-            case "DOUBLE":
+            case Types.TINYINT:
+            case Types.SMALLINT:
+            case Types.INTEGER:
+            case Types.BIGINT:
+            case Types.FLOAT:
+            case Types.DOUBLE:
                return true;
            default:
                return false;
@ -89,14 +90,14 @@ public class RestfulResultSetMetaData implements ResultSetMetaData {

    @Override
    public int getPrecision(int column) throws SQLException {
-        String type = this.fields.get(column - 1).type.toUpperCase();
+        int type = this.fields.get(column - 1).type;
        switch (type) {
-            case "FLOAT":
+            case Types.FLOAT:
                return 5;
-            case "DOUBLE":
+            case Types.DOUBLE:
                return 9;
-            case "BINARY":
-            case "NCHAR":
+            case Types.BINARY:
+            case Types.NCHAR:
                return this.fields.get(column - 1).length;
            default:
                return 0;
@ -105,11 +106,11 @@ public class RestfulResultSetMetaData implements ResultSetMetaData {

    @Override
    public int getScale(int column) throws SQLException {
-        String type = this.fields.get(column - 1).type.toUpperCase();
+        int type = this.fields.get(column - 1).type;
        switch (type) {
-            case "FLOAT":
+            case Types.FLOAT:
                return 5;
-            case "DOUBLE":
+            case Types.DOUBLE:
                return 9;
            default:
                return 0;
@ -128,36 +129,13 @@ public class RestfulResultSetMetaData implements ResultSetMetaData {

    @Override
    public int getColumnType(int column) throws SQLException {
-        String type = this.fields.get(column - 1).type.toUpperCase();
-        switch (type) {
-            case "BOOL":
-                return java.sql.Types.BOOLEAN;
-            case "TINYINT":
-                return java.sql.Types.TINYINT;
-            case "SMALLINT":
-                return java.sql.Types.SMALLINT;
-            case "INT":
-                return java.sql.Types.INTEGER;
-            case "BIGINT":
-                return java.sql.Types.BIGINT;
-            case "FLOAT":
-                return java.sql.Types.FLOAT;
-            case "DOUBLE":
-                return java.sql.Types.DOUBLE;
-            case "BINARY":
-                return java.sql.Types.BINARY;
-            case "TIMESTAMP":
-                return java.sql.Types.TIMESTAMP;
-            case "NCHAR":
-                return java.sql.Types.NCHAR;
-        }
-        throw new SQLException(TSDBConstants.INVALID_VARIABLES);
+        return this.fields.get(column - 1).type;
    }

    @Override
    public String getColumnTypeName(int column) throws SQLException {
-        String type = fields.get(column - 1).type;
-        return type.toUpperCase();
+        int type = fields.get(column - 1).type;
+        return TSDBConstants.jdbcType2TaosTypeName(type);
    }

    @Override
@ -177,26 +155,26 @@ public class RestfulResultSetMetaData implements ResultSetMetaData {

    @Override
    public String getColumnClassName(int column) throws SQLException {
-        String type = this.fields.get(column - 1).type;
+        int type = this.fields.get(column - 1).type;
        String columnClassName = "";
        switch (type) {
-            case "BOOL":
+            case Types.BOOLEAN:
                return Boolean.class.getName();
-            case "TINYINT":
-            case "SMALLINT":
+            case Types.TINYINT:
+            case Types.SMALLINT:
                return Short.class.getName();
-            case "INT":
+            case Types.INTEGER:
                return Integer.class.getName();
-            case "BIGINT":
+            case Types.BIGINT:
                return Long.class.getName();
-            case "FLOAT":
+            case Types.FLOAT:
                return Float.class.getName();
-            case "DOUBLE":
+            case Types.DOUBLE:
                return Double.class.getName();
-            case "TIMESTAMP":
+            case Types.TIMESTAMP:
                return Timestamp.class.getName();
-            case "BINARY":
-            case "NCHAR":
+            case Types.BINARY:
+            case Types.NCHAR:
                return String.class.getName();
        }
        return columnClassName;
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulStatement.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulStatement.java
@ -151,22 +151,21 @@ public class RestfulStatement extends AbstractStatement {
            throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + resultJson.getString("desc") + "\n" + "error code: " + resultJson.getString("code")));
        }
        // parse table name from sql
-        String[] tableIdentifiers = parseTableIdentifier(sql);
-        if (tableIdentifiers != null) {
-            List<JSONObject> fieldJsonList = new ArrayList<>();
-            for (String tableIdentifier : tableIdentifiers) {
-                // field meta
-                String fields = HttpClientPoolUtil.execute(url, "DESCRIBE " + tableIdentifier);
-                JSONObject fieldJson = JSON.parseObject(fields);
-                if (fieldJson.getString("status").equals("error")) {
-                    throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + fieldJson.getString("desc") + "\n" + "error code: " + fieldJson.getString("code")));
-                }
-                fieldJsonList.add(fieldJson);
-            }
-            this.resultSet = new RestfulResultSet(database, this, resultJson, fieldJsonList);
-        } else {
-            this.resultSet = new RestfulResultSet(database, this, resultJson);
-        }
+//        String[] tableIdentifiers = parseTableIdentifier(sql);
+//        if (tableIdentifiers != null) {
+//            List<JSONObject> fieldJsonList = new ArrayList<>();
+//            for (String tableIdentifier : tableIdentifiers) {
+//                String fields = HttpClientPoolUtil.execute(url, "DESCRIBE " + tableIdentifier);
+//                JSONObject fieldJson = JSON.parseObject(fields);
+//                if (fieldJson.getString("status").equals("error")) {
+//                    throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + fieldJson.getString("desc") + "\n" + "error code: " + fieldJson.getString("code")));
+//                }
+//                fieldJsonList.add(fieldJson);
+//            }
+//            this.resultSet = new RestfulResultSet(database, this, resultJson, fieldJsonList);
+//        } else {
+        this.resultSet = new RestfulResultSet(database, this, resultJson);
+//        }
        this.affectedRows = 0;
        return resultSet;
    }
@ -201,7 +200,7 @@ public class RestfulStatement extends AbstractStatement {
    @Override
    public ResultSet getResultSet() throws SQLException {
        if (isClosed())
-            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
        return resultSet;
    }

--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/ResultSetTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/ResultSetTest.java
@ -13,7 +13,6 @@ import java.util.HashMap;
 import java.util.Properties;

 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;

 public class ResultSetTest {
    static Connection connection;
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/SubscribeTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/SubscribeTest.java
@ -48,29 +48,28 @@ public class SubscribeTest {
    @Test
    public void subscribe() {
        try {
-
            String rawSql = "select * from " + dbName + "." + tName + ";";
            System.out.println(rawSql);
-            TSDBSubscribe subscribe = ((TSDBConnection) connection).subscribe(topic, rawSql, false);
+//            TSDBSubscribe subscribe = ((TSDBConnection) connection).subscribe(topic, rawSql, false);

-            int a = 0;
-            while (true) {
-                TimeUnit.MILLISECONDS.sleep(1000);
-                TSDBResultSet resSet = subscribe.consume();
-                while (resSet.next()) {
-                    for (int i = 1; i <= resSet.getMetaData().getColumnCount(); i++) {
-                        System.out.printf(i + ": " + resSet.getString(i) + "\t");
-                    }
-                    System.out.println("\n======" + a + "==========");
-                }
-                a++;
-                if (a >= 2) {
-                    break;
-                }
+//            int a = 0;
+//            while (true) {
+//                TimeUnit.MILLISECONDS.sleep(1000);
+//                TSDBResultSet resSet = subscribe.consume();
+//                while (resSet.next()) {
+//                    for (int i = 1; i <= resSet.getMetaData().getColumnCount(); i++) {
+//                        System.out.printf(i + ": " + resSet.getString(i) + "\t");
+//                    }
+//                    System.out.println("\n======" + a + "==========");
+//                }
+//                a++;
+//                if (a >= 2) {
+//                    break;
+//                }
 //                resSet.close();
-            }
-
-            subscribe.close(true);
+//            }
+//
+//            subscribe.close(true);
        } catch (Exception e) {
            e.printStackTrace();
        }
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulJDBCTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulJDBCTest.java
@ -10,7 +10,7 @@ import java.util.Random;
 public class RestfulJDBCTest {

    private static final String host = "127.0.0.1";
-    //    private static final String host = "master";
+//        private static final String host = "master";
    private static Connection connection;
    private Random random = new Random(System.currentTimeMillis());

--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/SQLTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/SQLTest.java
@ -12,7 +12,7 @@ import java.sql.*;
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
 public class SQLTest {
    private static final String host = "127.0.0.1";
-    //    private static final String host = "master";
+//        private static final String host = "master";
    private static Connection connection;

    @Test
@ -323,6 +323,18 @@ public class SQLTest {
        SQLExecutor.executeQuery(connection, sql);
    }

+    @Test
+    public void testCase052() {
+        String sql = "select server_status()";
+        SQLExecutor.executeQuery(connection, sql);
+    }
+
+    @Test
+    public void testCase053() {
+        String sql = "select avg(cpu_taosd), avg(cpu_system), max(cpu_cores), avg(mem_taosd), avg(mem_system), max(mem_total), avg(disk_used), max(disk_total), avg(band_speed), avg(io_read), avg(io_write), sum(req_http), sum(req_select), sum(req_insert) from log.dn1 where ts> now - 60m and ts<= now interval(1m) fill(value, 0)";
+        SQLExecutor.executeQuery(connection, sql);
+    }
+
    @BeforeClass
    public static void before() throws ClassNotFoundException, SQLException {
        Class.forName("com.taosdata.jdbc.rs.RestfulDriver");
--- a/src/dnode/src/dnodeVnodes.c
+++ b/src/dnode/src/dnodeVnodes.c
@ -198,6 +198,14 @@ void dnodeCleanupVnodes() {
 static void dnodeProcessStatusRsp(SRpcMsg *pMsg) {
  if (pMsg->code != TSDB_CODE_SUCCESS) {
    dError("status rsp is received, error:%s", tstrerror(pMsg->code));
+    if (pMsg->code == TSDB_CODE_MND_DNODE_NOT_EXIST) {
+      char clusterId[TSDB_CLUSTER_ID_LEN];
+      dnodeGetClusterId(clusterId);
+      if (clusterId[0] != '\0') {
+	dError("exit zombie dropped dnode");
+	exit(EXIT_FAILURE);
+      }
+    }
    taosTmrReset(dnodeSendStatusMsg, tsStatusInterval * 1000, NULL, tsDnodeTmr, &tsStatusTimer);
    return;
  }
--- a/src/kit/taosdemo/insert.json
+++ b/src/kit/taosdemo/insert.json
@ -8,10 +8,12 @@
 	"thread_count": 4,
 	"thread_count_create_tbl": 4,
 	"result_file": "./insert_res.txt",
-  "confirm_parameter_prompt": "no",
+    "confirm_parameter_prompt": "no",
+    "insert_interval": 0,
+    "num_of_records_per_req": 100,
 	"databases": [{
 		"dbinfo": {
-			"name": "dbx",
+			"name": "db",
 			"drop": "yes",
 			"replica": 1,
 			"days": 10,
@ -30,14 +32,13 @@
 		},
 		"super_tables": [{
 			"name": "stb",
-      "child_table_exists":"no",
+            "child_table_exists":"no",
 			"childtable_count": 100,
 			"childtable_prefix": "stb_",
 			"auto_create_table": "no",
 			"data_source": "rand",
 			"insert_mode": "taosc",
-			"insert_rate": 0,
-			"insert_rows": 1000,
+			"insert_rows": 100000,
 			"multi_thread_write_one_tbl": "no",
 			"number_of_tbl_in_one_sql": 0,
 			"rows_per_tbl": 100,
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
--- a/src/kit/taosdump/taosdump.c
+++ b/src/kit/taosdump/taosdump.c
@ -769,6 +769,7 @@ int32_t taosSaveTableOfMetricToTempFile(TAOS *taosCon, char* metric, struct argu
      }
      sprintf(tmpBuf, ".select-tbname.tmp");
      (void)remove(tmpBuf);      
+      free(tblBuf);
      close(fd);
      return -1;
    }
@ -1523,6 +1524,7 @@ int taosDumpDb(SDbInfo *dbInfo, struct arguments *arguments, FILE *fp, TAOS *tao
      }
      sprintf(tmpBuf, ".show-tables.tmp");
      (void)remove(tmpBuf);
+      free(tblBuf);
      close(fd);
      return -1;
    }
--- a/src/rpc/src/rpcMain.c
+++ b/src/rpc/src/rpcMain.c
@ -1281,7 +1281,7 @@ static void rpcSendReqToServer(SRpcInfo *pRpc, SRpcReqContext *pContext) {
  SRpcConn *pConn = rpcSetupConnToServer(pContext);
  if (pConn == NULL) {
    pContext->code = terrno;
-    taosTmrStart(rpcProcessConnError, 0, pContext, pRpc->tmrCtrl);
+    taosTmrStart(rpcProcessConnError, 1, pContext, pRpc->tmrCtrl);
    return;
  }

--- a/tests/Jenkinsfile
+++ b/tests/Jenkinsfile
@ -55,9 +55,15 @@ pipeline {
            sh '''
            cd ${WKC}/tests
            ./test-all.sh b1
+            date'''
+            sh '''
            cd ${WKC}/tests
            ./test-all.sh full jdbc
            date'''
+            sh '''
+            cd ${WKC}/tests
+            ./test-all.sh full unit
+            date'''
          }
        }

--- a/tests/examples/JDBC/springbootdemo/pom.xml
+++ b/tests/examples/JDBC/springbootdemo/pom.xml
@ -63,7 +63,9 @@
        <dependency>
            <groupId>com.taosdata.jdbc</groupId>
            <artifactId>taos-jdbcdriver</artifactId>
-            <version>2.0.18</version>
+            <version>2.0.20</version>
+<!--            <scope>system</scope>-->
+<!--            <systemPath>${project.basedir}/src/main/resources/taos-jdbcdriver-2.0.20-dist.jar</systemPath>-->
        </dependency>

        <dependency>
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/SpringbootdemoApplication.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/SpringbootdemoApplication.java
@ -10,4 +10,4 @@ public class SpringbootdemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootdemoApplication.class, args);
    }
-}
+}
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/controller/WeatherController.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/controller/WeatherController.java
@ -6,6 +6,7 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.*;

 import java.util.List;
+import java.util.Map;

@RequestMapping("/weather")
@RestController
@ -20,7 +21,7 @@ public class WeatherController {
     * @return
     */
    @GetMapping("/init")
-    public boolean init() {
+    public int init() {
        return weatherService.init();
    }

@ -44,19 +45,23 @@ public class WeatherController {
     * @return
     */
    @PostMapping("/{temperature}/{humidity}")
-    public int saveWeather(@PathVariable int temperature, @PathVariable float humidity) {
+    public int saveWeather(@PathVariable float temperature, @PathVariable int humidity) {
        return weatherService.save(temperature, humidity);
    }

-    /**
-     * upload multi weather info
-     *
-     * @param weatherList
-     * @return
-     */
-    @PostMapping("/batch")
-    public int batchSaveWeather(@RequestBody List<Weather> weatherList) {
-        return weatherService.save(weatherList);
+    @GetMapping("/count")
+    public int count() {
+        return weatherService.count();
+    }
+
+    @GetMapping("/subTables")
+    public List<String> getSubTables() {
+        return weatherService.getSubTables();
+    }
+
+    @GetMapping("/avg")
+    public List<Weather> avg() {
+        return weatherService.avg();
    }

 }
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/dao/WeatherMapper.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/dao/WeatherMapper.java
@ -4,16 +4,26 @@ import com.taosdata.example.springbootdemo.domain.Weather;
 import org.apache.ibatis.annotations.Param;

 import java.util.List;
+import java.util.Map;

 public interface WeatherMapper {

-    int insert(Weather weather);
-
-    int batchInsert(List<Weather> weatherList);
-
-    List<Weather> select(@Param("limit") Long limit, @Param("offset")Long offset);
+    void dropDB();

    void createDB();

-    void createTable();
+    void createSuperTable();
+
+    void createTable(Weather weather);
+
+    List<Weather> select(@Param("limit") Long limit, @Param("offset") Long offset);
+
+    int insert(Weather weather);
+
+    int count();
+
+    List<String> getSubTables();
+
+    List<Weather> avg();
+
 }
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/dao/WeatherMapper.xml
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/dao/WeatherMapper.xml
@ -4,28 +4,29 @@
 <mapper namespace="com.taosdata.example.springbootdemo.dao.WeatherMapper">

    <resultMap id="BaseResultMap" type="com.taosdata.example.springbootdemo.domain.Weather">
-        <id column="ts" jdbcType="TIMESTAMP" property="ts" />
-        <result column="temperature" jdbcType="INTEGER" property="temperature" />
-        <result column="humidity" jdbcType="FLOAT" property="humidity" />
+        <id column="ts" jdbcType="TIMESTAMP" property="ts"/>
+        <result column="temperature" jdbcType="FLOAT" property="temperature"/>
+        <result column="humidity" jdbcType="FLOAT" property="humidity"/>
    </resultMap>

-    <update id="createDB" >
-        create database if not exists test;
+    <update id="dropDB">
+        drop database if exists test
    </update>

-    <update id="createTable" >
-        create table if not exists test.weather(ts timestamp, temperature int, humidity float);
+    <update id="createDB">
+        create database if not exists test
    </update>

-    <sql id="Base_Column_List">
-        ts, temperature, humidity
-    </sql>
+    <update id="createSuperTable">
+        create table if not exists test.weather(ts timestamp, temperature float, humidity float) tags(location nchar(64), groupId int)
+    </update>
+
+    <update id="createTable" parameterType="com.taosdata.example.springbootdemo.domain.Weather">
+        create table if not exists test.t#{groupId} using test.weather tags(#{location}, #{groupId})
+    </update>

    <select id="select" resultMap="BaseResultMap">
-        select
-        <include refid="Base_Column_List" />
-        from test.weather
-        order by ts desc
+        select * from test.weather order by ts desc
        <if test="limit != null">
            limit #{limit,jdbcType=BIGINT}
        </if>
@ -34,16 +35,26 @@
        </if>
    </select>

-    <insert id="insert" parameterType="com.taosdata.example.springbootdemo.domain.Weather" >
-        insert into test.weather (ts, temperature, humidity) values (now, #{temperature,jdbcType=INTEGER}, #{humidity,jdbcType=FLOAT})
+    <insert id="insert" parameterType="com.taosdata.example.springbootdemo.domain.Weather">
+        insert into test.t#{groupId} (ts, temperature, humidity) values (#{ts}, ${temperature}, ${humidity})
    </insert>

-    <insert id="batchInsert" parameterType="java.util.List" >
-        insert into test.weather (ts, temperature, humidity) values
-        <foreach separator=" " collection="list" item="weather" index="index" >
-            (now + #{index}a, #{weather.temperature}, #{weather.humidity})
-        </foreach>
-    </insert>
+    <select id="getSubTables" resultType="String">
+        select tbname from test.weather
+    </select>

+    <select id="count" resultType="int">
+        select count(*) from test.weather
+    </select>
+
+    <resultMap id="avgResultSet" type="com.taosdata.example.springbootdemo.domain.Weather">
+        <id column="ts" jdbcType="TIMESTAMP" property="ts" />
+        <result column="avg(temperature)" jdbcType="FLOAT" property="temperature" />
+        <result column="avg(humidity)" jdbcType="FLOAT" property="humidity" />
+    </resultMap>
+
+    <select id="avg" resultMap="avgResultSet">
+        select avg(temperature), avg(humidity)from test.weather interval(1m)
+    </select>

 </mapper>
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/domain/Weather.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/domain/Weather.java
@ -6,12 +6,21 @@ import java.sql.Timestamp;

 public class Weather {

-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss.SSS",timezone = "GMT+8")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss.SSS", timezone = "GMT+8")
    private Timestamp ts;
-
-    private int temperature;
-
+    private float temperature;
    private float humidity;
+    private String location;
+    private int groupId;
+
+    public Weather() {
+    }
+
+    public Weather(Timestamp ts, float temperature, float humidity) {
+        this.ts = ts;
+        this.temperature = temperature;
+        this.humidity = humidity;
+    }

    public Timestamp getTs() {
        return ts;
@ -21,11 +30,11 @@ public class Weather {
        this.ts = ts;
    }

-    public int getTemperature() {
+    public float getTemperature() {
        return temperature;
    }

-    public void setTemperature(int temperature) {
+    public void setTemperature(float temperature) {
        this.temperature = temperature;
    }

@ -36,4 +45,20 @@ public class Weather {
    public void setHumidity(float humidity) {
        this.humidity = humidity;
    }
+
+    public String getLocation() {
+        return location;
+    }
+
+    public void setLocation(String location) {
+        this.location = location;
+    }
+
+    public int getGroupId() {
+        return groupId;
+    }
+
+    public void setGroupId(int groupId) {
+        this.groupId = groupId;
+    }
 }
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/service/WeatherService.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/service/WeatherService.java
@ -5,25 +5,41 @@ import com.taosdata.example.springbootdemo.domain.Weather;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;

+import java.sql.Timestamp;
 import java.util.List;
+import java.util.Map;
+import java.util.Random;

@Service
 public class WeatherService {

    @Autowired
    private WeatherMapper weatherMapper;
+    private Random random = new Random(System.currentTimeMillis());
+    private String[] locations = {"北京", "上海", "广州", "深圳", "天津"};

-    public boolean init() {
+    public int init() {
+        weatherMapper.dropDB();
        weatherMapper.createDB();
-        weatherMapper.createTable();
-        return true;
+        weatherMapper.createSuperTable();
+        long ts = System.currentTimeMillis();
+        long thirtySec = 1000 * 30;
+        int count = 0;
+        for (int i = 0; i < 20; i++) {
+            Weather weather = new Weather(new Timestamp(ts + (thirtySec * i)), 30 * random.nextFloat(), random.nextInt(100));
+            weather.setLocation(locations[random.nextInt(locations.length)]);
+            weather.setGroupId(i % locations.length);
+            weatherMapper.createTable(weather);
+            count += weatherMapper.insert(weather);
+        }
+        return count;
    }

    public List<Weather> query(Long limit, Long offset) {
        return weatherMapper.select(limit, offset);
    }

-    public int save(int temperature, float humidity) {
+    public int save(float temperature, int humidity) {
        Weather weather = new Weather();
        weather.setTemperature(temperature);
        weather.setHumidity(humidity);
@ -31,8 +47,15 @@ public class WeatherService {
        return weatherMapper.insert(weather);
    }

-    public int save(List<Weather> weatherList) {
-        return weatherMapper.batchInsert(weatherList);
+    public int count() {
+        return weatherMapper.count();
    }

+    public List<String> getSubTables() {
+        return weatherMapper.getSubTables();
+    }
+
+    public List<Weather> avg() {
+        return weatherMapper.avg();
+    }
 }
--- a/tests/examples/JDBC/springbootdemo/src/main/resources/application.properties
+++ b/tests/examples/JDBC/springbootdemo/src/main/resources/application.properties
@ -1,12 +1,14 @@
 # datasource config - JDBC-JNI
-spring.datasource.driver-class-name=com.taosdata.jdbc.TSDBDriver
-spring.datasource.url=jdbc:TAOS://127.0.0.1:6030/test?timezone=UTC-8&charset=UTF-8&locale=en_US.UTF-8
-spring.datasource.username=root
-spring.datasource.password=taosdata
+#spring.datasource.driver-class-name=com.taosdata.jdbc.TSDBDriver
+#spring.datasource.url=jdbc:TAOS://127.0.0.1:6030/test?timezone=UTC-8&charset=UTF-8&locale=en_US.UTF-8
+#spring.datasource.username=root
+#spring.datasource.password=taosdata

 # datasource config - JDBC-RESTful
-#spring.datasource.driver-class-name=com.taosdata.jdbc.rs.RestfulDriver
-#spring.datasource.url=jdbc:TAOS-RS://master:6041/test?user=root&password=taosdata
+spring.datasource.driver-class-name=com.taosdata.jdbc.rs.RestfulDriver
+spring.datasource.url=jdbc:TAOS-RS://master:6041/test?timezone=UTC-8&charset=UTF-8&locale=en_US.UTF-8
+spring.datasource.username=root
+spring.datasource.password=taosdata

 spring.datasource.druid.initial-size=5
 spring.datasource.druid.min-idle=5
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/TaosDemoApplication.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/TaosDemoApplication.java
@ -4,7 +4,7 @@ import com.taosdata.taosdemo.components.DataSourceFactory;
 import com.taosdata.taosdemo.components.JdbcTaosdemoConfig;
 import com.taosdata.taosdemo.domain.SuperTableMeta;
 import com.taosdata.taosdemo.service.DatabaseService;
-import com.taosdata.taosdemo.service.QueryService;
+import com.taosdata.taosdemo.service.SqlExecuteTask;
 import com.taosdata.taosdemo.service.SubTableService;
 import com.taosdata.taosdemo.service.SuperTableService;
 import com.taosdata.taosdemo.service.data.SuperTableMetaGenerator;
@ -32,6 +32,17 @@ public class TaosDemoApplication {
        }
        // 初始化
        final DataSource dataSource = DataSourceFactory.getInstance(config.host, config.port, config.user, config.password);
+        if (config.executeSql != null && !config.executeSql.isEmpty() && !config.executeSql.replaceAll("\\s", "").isEmpty()) {
+            Thread task = new Thread(new SqlExecuteTask(dataSource, config.executeSql));
+            task.start();
+            try {
+                task.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+            return;
+        }
+
        final DatabaseService databaseService = new DatabaseService(dataSource);
        final SuperTableService superTableService = new SuperTableService(dataSource);
        final SubTableService subTableService = new SubTableService(dataSource);
@ -96,7 +107,6 @@ public class TaosDemoApplication {
        // 查询


-
        /**********************************************************************************/
        // 删除表
        if (config.dropTable) {
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/components/JdbcTaosdemoConfig.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/components/JdbcTaosdemoConfig.java
@ -42,7 +42,7 @@ public final class JdbcTaosdemoConfig {
    public int rate = 10;
    public long range = 1000l;
    // select task
-
+    public String executeSql;
    // drop task
    public boolean dropTable = false;

@ -89,7 +89,7 @@ public final class JdbcTaosdemoConfig {
        System.out.println("-rate                       The proportion of data out of order. effective only if order is 1. min 0, max 100, default is 10");
        System.out.println("-range                      The range of data out of order. effective only if order is 1. default is 1000 ms");
        // query task
-//        System.out.println("-sqlFile                   The select sql file");
+        System.out.println("-executeSql                 execute a specific sql.");
        // drop task
        System.out.println("-dropTable                  Drop data before quit. Default is false");
        System.out.println("--help                      Give this help list");
@ -207,6 +207,9 @@ public final class JdbcTaosdemoConfig {
                range = Integer.parseInt(args[++i]);
            }
            // select task
+            if ("-executeSql".equals(args[i]) && i < args.length - 1) {
+                executeSql = args[++i];
+            }

            // drop task
            if ("-dropTable".equals(args[i]) && i < args.length - 1) {
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/SqlExecuteTask.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/SqlExecuteTask.java
@ -0,0 +1,36 @@
+package com.taosdata.taosdemo.service;
+
+import com.taosdata.taosdemo.utils.Printer;
+
+import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+public class SqlExecuteTask implements Runnable {
+    private final DataSource dataSource;
+    private final String sql;
+
+    public SqlExecuteTask(DataSource dataSource, String sql) {
+        this.dataSource = dataSource;
+        this.sql = sql;
+    }
+
+    @Override
+    public void run() {
+        try (Connection conn = dataSource.getConnection(); Statement stmt = conn.createStatement()) {
+            long start = System.currentTimeMillis();
+            boolean execute = stmt.execute(sql);
+            long end = System.currentTimeMillis();
+            if (execute) {
+                ResultSet rs = stmt.getResultSet();
+                Printer.printResult(rs);
+            } else {
+                Printer.printSql(sql, true, (end - start));
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+}
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/utils/Printer.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/utils/Printer.java
@ -0,0 +1,27 @@
+package com.taosdata.taosdemo.utils;
+
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+
+public class Printer {
+
+    public static void printResult(ResultSet resultSet) throws SQLException {
+        ResultSetMetaData metaData = resultSet.getMetaData();
+        while (resultSet.next()) {
+            for (int i = 1; i <= metaData.getColumnCount(); i++) {
+                String columnLabel = metaData.getColumnLabel(i);
+                String value = resultSet.getString(i);
+                System.out.printf("%s: %s\t", columnLabel, value);
+            }
+            System.out.println();
+        }
+    }
+
+    public static void printSql(String sql, boolean succeed, long cost) {
+        System.out.println("[ " + (succeed ? "OK" : "ERROR!") + " ] time cost: " + cost + " ms, execute statement ====> " + sql);
+    }
+
+    private Printer() {
+    }
+}
--- a/tests/pytest/cluster/clusterSetup.py
+++ b/tests/pytest/cluster/clusterSetup.py
@ -11,15 +11,9 @@

 # -*- coding: utf-8 -*-

-import os
-import sys
-sys.path.insert(0, os.getcwd())
 from fabric import Connection
-from util.sql import *
-from util.log import *
-import taos
 import random
-import threading
+import time
 import logging

 class Node:
@ -76,6 +70,19 @@ class Node:
            print("remove taosd error for node %d " % self.index)
            logging.exception(e)
    
+    def forceStopOneTaosd(self):
+        try:
+            self.conn.run("kill -9 $(ps -ax|grep taosd|awk '{print $1}')")
+        except Exception as e:
+            print("kill taosd error on node%d " % self.index)            
+    
+    def startOneTaosd(self):
+        try:
+            self.conn.run("nohup taosd -c /etc/taos/ > /dev/null 2>&1 &")
+        except Exception as e:
+            print("start taosd error on node%d " % self.index)
+            logging.exception(e)    
+    
    def installTaosd(self, packagePath):
        self.conn.put(packagePath, self.homeDir)
        self.conn.cd(self.homeDir)
@ -122,100 +129,51 @@ class Node:

 class Nodes:
    def __init__(self):
-        self.node1 = Node(1, 'root', '52.151.60.239', 'node1', 'r', '/root/')
-        self.node2 = Node(2, 'root', '52.183.32.246', 'node1', 'r', '/root/')
-        self.node3 = Node(3, 'root', '51.143.46.79', 'node1', 'r', '/root/')
-        self.node4 = Node(4, 'root', '52.183.2.76', 'node1', 'r', '/root/')
-        self.node5 = Node(5, 'root', '13.66.225.87', 'node1', 'r', '/root/')        
+        self.tdnodes = []
+        self.tdnodes.append(Node(0, 'root', '52.143.103.7', 'node1', 'a', '/root/'))
+        self.tdnodes.append(Node(1, 'root', '52.250.48.222', 'node2', 'a', '/root/'))
+        self.tdnodes.append(Node(2, 'root', '51.141.167.23', 'node3', 'a', '/root/'))
+        self.tdnodes.append(Node(3, 'root', '52.247.207.173', 'node4', 'a', '/root/'))
+        self.tdnodes.append(Node(4, 'root', '51.141.166.100', 'node5', 'a', '/root/'))
+
+    def stopOneNode(self, index):
+        self.tdnodes[index].forceStopOneTaosd()
+    
+    def startOneNode(self, index):
+        self.tdnodes[index].startOneTaosd()

    def stopAllTaosd(self):
-        self.node1.stopTaosd()
-        self.node2.stopTaosd()
-        self.node3.stopTaosd()
-    
+        for i in range(len(self.tdnodes)):
+            self.tdnodes[i].stopTaosd()
+
    def startAllTaosd(self):
-        self.node1.startTaosd()
-        self.node2.startTaosd()
-        self.node3.startTaosd()
+        for i in range(len(self.tdnodes)):
+            self.tdnodes[i].startTaosd()                    
    
    def restartAllTaosd(self):
-        self.node1.restartTaosd()
-        self.node2.restartTaosd()
-        self.node3.restartTaosd()
+        for i in range(len(self.tdnodes)):
+            self.tdnodes[i].restartTaosd()       
    
    def addConfigs(self, configKey, configValue):          
-        self.node1.configTaosd(configKey, configValue)
-        self.node2.configTaosd(configKey, configValue)
-        self.node3.configTaosd(configKey, configValue)
+        for i in range(len(self.tdnodes)):
+            self.tdnodes[i].configTaosd(configKey, configValue)        
    
-    def removeConfigs(self, configKey, configValue):          
-        self.node1.removeTaosConfig(configKey, configValue)
-        self.node2.removeTaosConfig(configKey, configValue)
-        self.node3.removeTaosConfig(configKey, configValue)        
+    def removeConfigs(self, configKey, configValue): 
+        for i in range(len(self.tdnodes)):
+            self.tdnodes[i].removeTaosConfig(configKey, configValue)  
    
    def removeAllDataFiles(self):
-        self.node1.removeData()
-        self.node2.removeData()
-        self.node3.removeData()
+        for i in range(len(self.tdnodes)):
+            self.tdnodes[i].removeData()

-class ClusterTest:
-    def __init__(self, hostName):
-        self.host = hostName
-        self.user = "root"
-        self.password = "taosdata"
-        self.config = "/etc/taos"        
-        self.dbName = "mytest"
-        self.stbName = "meters"
-        self.numberOfThreads = 20
-        self.numberOfTables = 10000
-        self.numberOfRecords = 1000
-        self.tbPrefix = "t"
-        self.ts = 1538548685000
-        self.repeat = 1        
-
-    def connectDB(self):
-        self.conn = taos.connect(
-            host=self.host,
-            user=self.user,
-            password=self.password,
-            config=self.config)
-
-    def createSTable(self, replica):
-        cursor = self.conn.cursor()
-        tdLog.info("drop database if exists %s" % self.dbName)
-        cursor.execute("drop database if exists %s" % self.dbName)
-        tdLog.info("create database %s replica %d" % (self.dbName, replica))
-        cursor.execute("create database %s replica %d" % (self.dbName, replica))
-        tdLog.info("use %s" % self.dbName)
-        cursor.execute("use %s" % self.dbName)
-        tdLog.info("drop table if exists %s" % self.stbName)
-        cursor.execute("drop table if exists %s" % self.stbName)
-        tdLog.info("create table %s(ts timestamp, current float, voltage int, phase int) tags(id int)" % self.stbName)
-        cursor.execute("create table %s(ts timestamp, current float, voltage int, phase int) tags(id int)" % self.stbName)
-        cursor.close()
-
-    def insertData(self, threadID):
-        print("Thread %d: starting" % threadID)
-        cursor = self.conn.cursor()
-        tablesPerThread = int(self.numberOfTables / self.numberOfThreads)
-        baseTableID = tablesPerThread * threadID
-        for i in range (tablesPerThread):
-            cursor.execute("create table %s%d using %s tags(%d)" % (self.tbPrefix, baseTableID + i, self.stbName, baseTableID + i))            
-            query = "insert into %s%d values" % (self.tbPrefix, baseTableID + i)
-            base = self.numberOfRecords * i            
-            for j in range(self.numberOfRecords):
-                query += "(%d, %f, %d, %d)" % (self.ts + base + j, random.random(), random.randint(210, 230), random.randint(0, 10)) 
-            cursor.execute(query)      
-        cursor.close()
-        print("Thread %d: finishing" % threadID)
-    
-    def run(self):        
-        threads = []
-        tdLog.info("Inserting data")
-        for i in range(self.numberOfThreads):
-            thread = threading.Thread(target=self.insertData, args=(i,))
-            threads.append(thread)
-            thread.start()
-
-        for i in range(self.numberOfThreads):
-            threads[i].join()
+# kill taosd randomly every 10 mins
+nodes = Nodes()
+loop = 0
+while True:
+    loop = loop + 1    
+    index = random.randint(0, 4)
+    print("loop: %d, kill taosd on node%d" %(loop, index))
+    nodes.stopOneNode(index)
+    time.sleep(60)
+    nodes.startOneNode(index)
+    time.sleep(600)
--- a/tests/pytest/crash_gen/crash_gen_main.py
+++ b/tests/pytest/crash_gen/crash_gen_main.py
@ -35,16 +35,19 @@ import os
 import signal
 import traceback
 import resource
-from guppy import hpy
+# from guppy import hpy
 import gc

 from crash_gen.service_manager import ServiceManager, TdeInstance
 from crash_gen.misc import Logging, Status, CrashGenError, Dice, Helper, Progress
 from crash_gen.db import DbConn, MyTDSql, DbConnNative, DbManager
+import crash_gen.settings 

 import taos
 import requests

+crash_gen.settings.init()
+
 # Require Python 3
 if sys.version_info[0] < 3:
    raise Exception("Must be using Python 3")
@ -259,6 +262,7 @@ class ThreadCoordinator:
        self._execStats = ExecutionStats()
        self._runStatus = Status.STATUS_RUNNING
        self._initDbs()
+        self._stepStartTime = None  # Track how long it takes to execute each step

    def getTaskExecutor(self):
        return self._te
@ -394,6 +398,10 @@ class ThreadCoordinator:
            try:
                self._syncAtBarrier() # For now just cross the barrier
                Progress.emit(Progress.END_THREAD_STEP)
+                if self._stepStartTime :
+                    stepExecTime = time.time() - self._stepStartTime
+                    Progress.emitStr('{:.3f}s/{}'.format(stepExecTime, DbConnNative.totalRequests))
+                    DbConnNative.resetTotalRequests() # reset to zero
            except threading.BrokenBarrierError as err:
                self._execStats.registerFailure("Aborted due to worker thread timeout")
                Logging.error("\n")
@ -433,6 +441,7 @@ class ThreadCoordinator:

            # Then we move on to the next step
            Progress.emit(Progress.BEGIN_THREAD_STEP)
+            self._stepStartTime = time.time()
            self._releaseAllWorkerThreads(transitionFailed)                    

        if hasAbortedTask or transitionFailed : # abnormal ending, workers waiting at "gate"
@ -691,7 +700,7 @@ class AnyState:
    def canDropDb(self):
        # If user requests to run up to a number of DBs,
        # we'd then not do drop_db operations any more
-        if gConfig.max_dbs > 0 : 
+        if gConfig.max_dbs > 0 or gConfig.use_shadow_db : 
            return False
        return self._info[self.CAN_DROP_DB]

@ -699,6 +708,8 @@ class AnyState:
        return self._info[self.CAN_CREATE_FIXED_SUPER_TABLE]

    def canDropFixedSuperTable(self):
+        if gConfig.use_shadow_db: # duplicate writes to shaddow DB, in which case let's disable dropping s-table
+            return False
        return self._info[self.CAN_DROP_FIXED_SUPER_TABLE]

    def canAddData(self):
@ -1037,7 +1048,7 @@ class Database:
    _clsLock = threading.Lock() # class wide lock
    _lastInt = 101  # next one is initial integer
    _lastTick = 0
-    _lastLaggingTick = 0 # lagging tick, for unsequenced insersions
+    _lastLaggingTick = 0 # lagging tick, for out-of-sequence (oos) data insertions

    def __init__(self, dbNum: int, dbc: DbConn): # TODO: remove dbc
        self._dbNum = dbNum # we assign a number to databases, for our testing purpose
@ -1093,21 +1104,24 @@ class Database:
        t3 = datetime.datetime(2012, 1, 1)  # default "keep" is 10 years
        t4 = datetime.datetime.fromtimestamp(
            t3.timestamp() + elSec2)  # see explanation above
-        Logging.debug("Setting up TICKS to start from: {}".format(t4))
+        Logging.info("Setting up TICKS to start from: {}".format(t4))
        return t4

    @classmethod
-    def getNextTick(cls):        
+    def getNextTick(cls):       
+        '''
+            Fetch a timestamp tick, with some random factor, may not be unique.
+        ''' 
        with cls._clsLock:  # prevent duplicate tick
            if cls._lastLaggingTick==0 or cls._lastTick==0 : # not initialized
                # 10k at 1/20 chance, should be enough to avoid overlaps
                tick = cls.setupLastTick()
                cls._lastTick = tick
-                cls._lastLaggingTick = tick + datetime.timedelta(0, -10000)                 
+                cls._lastLaggingTick = tick + datetime.timedelta(0, -60*2)  # lagging behind 2 minutes, should catch up fast
                # if : # should be quite a bit into the future

-            if Dice.throw(20) == 0:  # 1 in 20 chance, return lagging tick
-                cls._lastLaggingTick += datetime.timedelta(0, 1) # Go back in time 100 seconds
+            if gConfig.mix_oos_data and Dice.throw(20) == 0:  # if asked to do so, and 1 in 20 chance, return lagging tick
+                cls._lastLaggingTick += datetime.timedelta(0, 1) # pick the next sequence from the lagging tick sequence
                return cls._lastLaggingTick 
            else:  # regular
                # add one second to it
@ -1334,7 +1348,8 @@ class Task():
            elif self._isErrAcceptable(errno2, err.__str__()):
                self.logDebug("[=] Acceptable Taos library exception: errno=0x{:X}, msg: {}, SQL: {}".format(
                        errno2, err, wt.getDbConn().getLastSql()))
-                print("_", end="", flush=True)
+                # print("_", end="", flush=True)
+                Progress.emit(Progress.ACCEPTABLE_ERROR)
                self._err = err
            else: # not an acceptable error
                errMsg = "[=] Unexpected Taos library exception ({}): errno=0x{:X}, msg: {}, SQL: {}".format(
@ -1563,8 +1578,11 @@ class TaskCreateDb(StateTransitionTask):
            # numReplica = Dice.throw(gConfig.max_replicas) + 1 # 1,2 ... N
            numReplica = gConfig.max_replicas # fixed, always
            repStr = "replica {}".format(numReplica)
-        self.execWtSql(wt, "create database {} {}"
-            .format(self._db.getName(), repStr) )
+        updatePostfix = "update 1" if gConfig.verify_data else "" # allow update only when "verify data" is active
+        dbName = self._db.getName()
+        self.execWtSql(wt, "create database {} {} {} ".format(dbName, repStr, updatePostfix ) )
+        if dbName == "db_0" and gConfig.use_shadow_db:
+            self.execWtSql(wt, "create database {} {} {} ".format("db_s", repStr, updatePostfix ) )

 class TaskDropDb(StateTransitionTask):
    @classmethod
@ -1774,13 +1792,13 @@ class TdSuperTable:
                    ]) # TODO: add more from 'top'

            
-                if aggExpr not in ['stddev(speed)']: #TODO: STDDEV not valid for super tables?!
-                    sql = "select {} from {}.{}".format(aggExpr, self._dbName, self.getName())
-                    if Dice.throw(3) == 0: # 1 in X chance
-                        sql = sql + ' GROUP BY color'
-                        Progress.emit(Progress.QUERY_GROUP_BY)
-                        # Logging.info("Executing GROUP-BY query: " + sql)
-                    ret.append(SqlQuery(sql))
+                # if aggExpr not in ['stddev(speed)']: # STDDEV not valid for super tables?! (Done in TD-1049)
+                sql = "select {} from {}.{}".format(aggExpr, self._dbName, self.getName())
+                if Dice.throw(3) == 0: # 1 in X chance
+                    sql = sql + ' GROUP BY color'
+                    Progress.emit(Progress.QUERY_GROUP_BY)
+                    # Logging.info("Executing GROUP-BY query: " + sql)
+                ret.append(SqlQuery(sql))

        return ret        

@ -1988,7 +2006,7 @@ class TaskAddData(StateTransitionTask):
        numRecords = self.LARGE_NUMBER_OF_RECORDS if gConfig.larger_data else self.SMALL_NUMBER_OF_RECORDS        
        fullTableName = db.getName() + '.' + regTableName

-        sql = "insert into {} values ".format(fullTableName)
+        sql = "INSERT INTO {} VALUES ".format(fullTableName)
        for j in range(numRecords):  # number of records per table
            nextInt = db.getNextInt()
            nextTick = db.getNextTick()
@ -2016,12 +2034,24 @@ class TaskAddData(StateTransitionTask):
                # print("_w" + str(nextInt % 100), end="", flush=True) # Trace what was written

            try:
-                sql = "insert into {} values ('{}', {}, '{}');".format( # removed: tags ('{}', {})
+                sql = "INSERT INTO {} VALUES ('{}', {}, '{}');".format( # removed: tags ('{}', {})
                    fullTableName,
                    # ds.getFixedSuperTableName(),
                    # ds.getNextBinary(), ds.getNextFloat(),
                    nextTick, nextInt, nextColor)
                dbc.execute(sql)
+
+                # Quick hack, attach an update statement here. TODO: create an "update" task
+                if (not gConfig.use_shadow_db) and Dice.throw(5) == 0: # 1 in N chance, plus not using shaddow DB
+                    nextInt = db.getNextInt()
+                    nextColor = db.getNextColor()
+                    sql = "INSERt INTO {} VALUES ('{}', {}, '{}');".format( # "INSERt" means "update" here
+                    fullTableName,
+                    nextTick, nextInt, nextColor)
+                    # sql = "UPDATE {} set speed={}, color='{}' WHERE ts='{}'".format(
+                    #     fullTableName, db.getNextInt(), db.getNextColor(), nextTick)
+                    dbc.execute(sql)
+
            except: # Any exception at all
                if gConfig.verify_data:
                    self.unlockTable(fullTableName)     
@ -2070,7 +2100,8 @@ class TaskAddData(StateTransitionTask):
        random.shuffle(tblSeq) # now we have random sequence
        for i in tblSeq:
            if (i in self.activeTable):  # wow already active
-                print("x", end="", flush=True) # concurrent insertion
+                # print("x", end="", flush=True) # concurrent insertion
+                Progress.emit(Progress.CONCURRENT_INSERTION)
            else:
                self.activeTable.add(i)  # marking it active
            
@ -2373,6 +2404,11 @@ class MainExec:
            '--larger-data',
            action='store_true',
            help='Write larger amount of data during write operations (default: false)')
+        parser.add_argument(
+            '-m',
+            '--mix-oos-data',
+            action='store_false',
+            help='Mix out-of-sequence data into the test data stream (default: true)')
        parser.add_argument(
            '-n',
            '--dynamic-db-table-names',
@ -2414,6 +2450,11 @@ class MainExec:
            '--verify-data',
            action='store_true',
            help='Verify data written in a number of places by reading back (default: false)')
+        parser.add_argument(
+            '-w',
+            '--use-shadow-db',
+            action='store_true',
+            help='Use a shaddow database to verify data integrity (default: false)')
        parser.add_argument(
            '-x',
            '--continue-on-exception',
@ -2422,6 +2463,11 @@ class MainExec:

        global gConfig
        gConfig = parser.parse_args()
+        crash_gen.settings.gConfig = gConfig # TODO: fix this hack, consolidate this global var
+
+        # Sanity check for arguments
+        if gConfig.use_shadow_db and gConfig.max_dbs>1 :
+            raise CrashGenError("Cannot combine use-shadow-db with max-dbs of more than 1")

        Logging.clsInit(gConfig)

--- a/tests/pytest/crash_gen/db.py
+++ b/tests/pytest/crash_gen/db.py
@ -18,6 +18,8 @@ import datetime
 import traceback
 # from .service_manager import TdeInstance

+import crash_gen.settings 
+
 class DbConn:
    TYPE_NATIVE = "native-c"
    TYPE_REST =   "rest-api"
@ -244,7 +246,7 @@ class MyTDSql:
        self._conn.close() # TODO: very important, cursor close does NOT close DB connection!
        self._cursor.close()

-    def _execInternal(self, sql):
+    def _execInternal(self, sql):        
        startTime = time.time() 
        # Logging.debug("Executing SQL: " + sql)
        ret = self._cursor.execute(sql)
@ -257,6 +259,27 @@ class MyTDSql:
                cls.longestQuery = sql
                cls.longestQueryTime = queryTime
                cls.lqStartTime = startTime
+
+        # Now write to the shadow database
+        if crash_gen.settings.gConfig.use_shadow_db:
+            if sql[:11] == "INSERT INTO":
+                if sql[:16] == "INSERT INTO db_0":
+                    sql2 = "INSERT INTO db_s" + sql[16:]
+                    self._cursor.execute(sql2)
+                else:
+                    raise CrashGenError("Did not find db_0 in INSERT statement: {}".format(sql))
+            else: # not an insert statement
+                pass
+
+            if sql[:12] == "CREATE TABLE":
+                if sql[:17] == "CREATE TABLE db_0":
+                    sql2 = sql.replace('db_0', 'db_s')
+                    self._cursor.execute(sql2)
+                else:
+                    raise CrashGenError("Did not find db_0 in CREATE TABLE statement: {}".format(sql))
+            else: # not an insert statement
+                pass
+        
        return ret

    def query(self, sql):
@ -302,12 +325,18 @@ class DbConnNative(DbConn):
    _lock = threading.Lock()
    # _connInfoDisplayed = False # TODO: find another way to display this
    totalConnections = 0 # Not private
+    totalRequests = 0 

    def __init__(self, dbTarget):
        super().__init__(dbTarget)
        self._type = self.TYPE_NATIVE
        self._conn = None
-        # self._cursor = None        
+        # self._cursor = None   
+        
+    @classmethod
+    def resetTotalRequests(cls):        
+        with cls._lock: # force single threading for opening DB connections. # TODO: whaaat??!!!            
+            cls.totalRequests = 0

    def openByType(self):  # Open connection
        # global gContainer
@ -356,6 +385,8 @@ class DbConnNative(DbConn):
        Logging.debug("[SQL] Executing SQL: {}".format(sql))
        self._lastSql = sql
        nRows = self._tdSql.execute(sql)
+        cls = self.__class__
+        cls.totalRequests += 1
        Logging.debug(
            "[SQL] Execution Result, nRows = {}, SQL = {}".format(
                nRows, sql))
@ -369,6 +400,8 @@ class DbConnNative(DbConn):
        Logging.debug("[SQL] Executing SQL: {}".format(sql))
        self._lastSql = sql
        nRows = self._tdSql.query(sql)
+        cls = self.__class__
+        cls.totalRequests += 1
        Logging.debug(
            "[SQL] Query Result, nRows = {}, SQL = {}".format(
                nRows, sql))
--- a/tests/pytest/crash_gen/misc.py
+++ b/tests/pytest/crash_gen/misc.py
@ -176,11 +176,13 @@ class Progress:
    SERVICE_START_NAP           = 7
    CREATE_TABLE_ATTEMPT        = 8
    QUERY_GROUP_BY              = 9
+    CONCURRENT_INSERTION        = 10
+    ACCEPTABLE_ERROR            = 11

    tokens = {
        STEP_BOUNDARY:      '.',
-        BEGIN_THREAD_STEP:  '[',
-        END_THREAD_STEP:    '] ',
+        BEGIN_THREAD_STEP:  ' [',
+        END_THREAD_STEP:    ']',
        SERVICE_HEART_BEAT: '.Y.',
        SERVICE_RECONNECT_START:    '<r.',
        SERVICE_RECONNECT_SUCCESS:  '.r>',
@ -188,8 +190,14 @@ class Progress:
        SERVICE_START_NAP:           '_zz',
        CREATE_TABLE_ATTEMPT:       'c',
        QUERY_GROUP_BY:             'g',
+        CONCURRENT_INSERTION:       'x',
+        ACCEPTABLE_ERROR:           '_',
    }

    @classmethod
    def emit(cls, token):
        print(cls.tokens[token], end="", flush=True)
+
+    @classmethod
+    def emitStr(cls, str):
+        print('({})'.format(str), end="", flush=True)
--- a/tests/pytest/crash_gen/settings.py
+++ b/tests/pytest/crash_gen/settings.py
@ -0,0 +1,8 @@
+from __future__ import annotations
+import argparse
+
+gConfig:    argparse.Namespace 
+
+def init():
+    global gConfig
+    gConfig = []
--- a/tests/pytest/functions/function_operations.py
+++ b/tests/pytest/functions/function_operations.py
@ -69,15 +69,37 @@ class TDTestCase:
        tdSql.checkData(10, 0, None)

        # test for  tarithoperator.c coverage
-        col_list = [ 'col1' , 'col2' , 'col3' , 'col4' , 'col5' , 'col6' , 'col11' , 'col12' , 'col13' , 'col14' , '1' ]
+        tdSql.execute("insert into test1 values(1537146000010,1,NULL,9,8,1.2,1.3,0,1,1,5,4,3,2)")
+        tdSql.execute("insert into test1 values(1537146000011,2,1,NULL,9,1.2,1.3,1,2,2,6,5,4,3)")
+        tdSql.execute("insert into test1 values(1537146000012,3,2,1,NULL,1.2,1.3,0,3,3,7,6,5,4)")
+        tdSql.execute("insert into test1 values(1537146000013,4,3,2,1,1.2,1.3,1,4,4,8,7,6,5)")
+        tdSql.execute("insert into test1 values(1537146000014,5,4,3,2,1.2,1.3,0,5,5,9,8,7,6)")
+        tdSql.execute("insert into test1 values(1537146000015,6,5,4,3,1.2,1.3,1,6,6,NULL,9,8,7)")
+        tdSql.execute("insert into test1 values(1537146000016,7,6,5,4,1.2,1.3,0,7,7,1,NULL,9,8)")
+        tdSql.execute("insert into test1 values(1537146000017,8,7,6,5,1.2,1.3,1,8,8,2,1,NULL,9)")
+        tdSql.execute("insert into test1 values(1537146000018,9,8,7,6,1.2,1.3,0,9,9,3,2,1,NULL)")
+        tdSql.execute("insert into test1 values(1537146000019,NULL,9,8,7,1.2,1.3,1,10,10,4,3,2,1)")
+
+        self.ts = self.ts + self.rowNum + 10
+
+        tdSql.execute("insert into test1 values(%d, 1, 1, 1, 1, 1.1, 1.1, 1, NULL, '涛思数据3', 1, 1, 1, 1)"  % (  self.ts + self.rowNum + 1 ))
+        tdSql.execute("insert into test1 values(%d, 1, 1, 1, 1, 1.1, 1.1, 1, 'taosdata', NULL, 1, 1, 1, 1)"  % (  self.ts + self.rowNum + 2 ))
+        tdSql.execute("insert into test1 values(%d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL)"  % (  self.ts + self.rowNum + 3 ))
+        tdSql.execute("insert into test1 values(%d, 1, 1, 1, 1, NULL, 1.1, 1, NULL, '涛思数据3', 1, 1, 1, 1)"  % (  self.ts + self.rowNum + 4 ))
+        tdSql.execute("insert into test1 values(%d, 1, 1, 1, 1, 1.1, NULL, 1, 'taosdata', NULL, 1, 1, 1, 1)"  % (  self.ts + self.rowNum + 5 ))
+        self.rowNum = self.rowNum + 5
+
+        col_list = [ 'col1' , 'col2' , 'col3' , 'col4' , 'col5' , 'col6' , 'col7' , 'col8' , 'col9' , 'col11' , 'col12' , 'col13' , 'col14' , '1' , '1.1' , 'NULL' ]
        op_list = [ '+' , '-' , '*' , '/' , '%' ]
+        err_list = [ 'col7' , 'col8' , 'col9' , 'NULL' ]
        for i in col_list :
            for j in col_list :
                for k in op_list :
                    sql = " select %s %s %s from test1 " % ( i , k , j )
-                    print(sql)
-                    tdSql.query(sql)
-
+                    if i in err_list or j in err_list:
+                        tdSql.error(sql)
+                    else:
+                        tdSql.query(sql)
    def stop(self):
        tdSql.close()
        tdLog.success("%s successfully executed" % __file__)
--- a/tests/pytest/functions/function_operations_restart.py
+++ b/tests/pytest/functions/function_operations_restart.py
@ -41,24 +41,24 @@ class TDTestCase:
        tdSql.error("select col1 + col9 from test1")

        tdSql.query("select col1 + col2 from test1")
-        tdSql.checkRows(11)
+        tdSql.checkRows(25)
        tdSql.checkData(0, 0, 2.0)        

        tdSql.query("select col1 + col2 * col3 + col3 / col4 + col5 + col6 + col11 + col12 + col13 + col14 from test1")
-        tdSql.checkRows(11)
+        tdSql.checkRows(25)
        tdSql.checkData(0, 0, 7.2)

        #tdSql.execute("insert into test1(ts, col1) values(%d, 11)" % (self.ts + 11))
        tdSql.query("select col1 + col2 from test1")
-        tdSql.checkRows(11)
+        tdSql.checkRows(25)
        tdSql.checkData(10, 0, None)
        
        tdSql.query("select col1 + col2 * col3 from test1")
-        tdSql.checkRows(11)
+        tdSql.checkRows(25)
        tdSql.checkData(10, 0, None)

        tdSql.query("select col1 + col2 * col3 + col3 / col4 + col5 + col6 + col11 + col12 + col13 + col14 from test1")
-        tdSql.checkRows(11)
+        tdSql.checkRows(25)
        tdSql.checkData(10, 0, None)


--- a/tests/pytest/insert/metadataUpdate.py
+++ b/tests/pytest/insert/metadataUpdate.py
@ -52,8 +52,8 @@ class TDTestCase:
        p.start()        
        p.join()
        p.terminate()
-        
-        tdSql.execute("insert into tb values(%d, 1, 2)" % (self.ts + 1))
+                
+        tdSql.execute("insert into tb(ts, col1, col2) values(%d, 1, 2)" % (self.ts + 2))

        print("==============step2")
        tdSql.query("select * from tb")
--- a/tests/pytest/query/queryGroupbySort.py
+++ b/tests/pytest/query/queryGroupbySort.py
@ -28,12 +28,13 @@ class TDTestCase:
    def run(self):
        tdSql.prepare()

-        tdSql.execute("CREATE TABLE meters (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupId int)")
-        tdSql.execute("CREATE TABLE D1001 USING meters TAGS ('Beijing.Chaoyang', 2)")
-        tdSql.execute("CREATE TABLE D1002 USING meters TAGS ('Beijing.Chaoyang', 3)")
+        tdSql.execute("CREATE TABLE meters (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupId int, t3 float, t4 double)")
+        tdSql.execute("CREATE TABLE D1001 USING meters TAGS ('Beijing.Chaoyang', 2 , NULL, NULL)")
+        tdSql.execute("CREATE TABLE D1002 USING meters TAGS ('Beijing.Chaoyang', 3 , NULL , 1.7)")
+        tdSql.execute("CREATE TABLE D1003 USING meters TAGS ('Beijing.Chaoyang', 3 , 1.1 , 1.7)")
        tdSql.execute("INSERT INTO D1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6, 218, 0.33) (1538548696800, 12.3, 221, 0.31)")
        tdSql.execute("INSERT INTO D1002 VALUES (1538548685001, 10.5, 220, 0.28)  (1538548696800, 12.3, 221, 0.31)")
-
+        tdSql.execute("INSERT INTO D1003 VALUES (1538548685001, 10.5, 220, 0.28)  (1538548696800, 12.3, 221, 0.31)")
        tdSql.query("SELECT SUM(current), AVG(voltage) FROM meters WHERE groupId > 1 INTERVAL(1s) GROUP BY location order by ts DESC")
        tdSql.checkRows(3)
        tdSql.checkData(0, 0, "2018-10-03 14:38:16")
@ -49,6 +50,12 @@ class TDTestCase:
        tdSql.error("SELECT SUM(current) as s, AVG(voltage) FROM meters WHERE groupId > 1 INTERVAL(1s) GROUP BY location order by s ASC")

        tdSql.error("SELECT SUM(current) as s, AVG(voltage) FROM meters WHERE groupId > 1 INTERVAL(1s) GROUP BY location order by s DESC")
+
+        #add for TD-3170
+        tdSql.query("select avg(current) from meters group by t3;")
+        tdSql.checkData(0, 0, 11.6)
+        tdSql.query("select avg(current) from meters group by t4;")
+        tdSql.query("select avg(current) from meters group by t3,t4;")
        
    def stop(self):
        tdSql.close()
--- a/tests/pytest/tools/taosdemoTest.py
+++ b/tests/pytest/tools/taosdemoTest.py
@ -24,7 +24,7 @@ class TDTestCase:
        tdLog.debug("start to execute %s" % __file__)
        tdSql.init(conn.cursor(), logSql)

-        self.numberOfTables = 10000
+        self.numberOfTables = 1000
        self.numberOfRecords = 100

    def getBuildPath(self):
--- a/tests/script/general/cache/new_metrics.sim
+++ b/tests/script/general/cache/new_metrics.sim
@ -2,7 +2,7 @@ system sh/stop_dnodes.sh


 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start

 sleep 2000
--- a/tests/script/general/cache/restart_metrics.sim
+++ b/tests/script/general/cache/restart_metrics.sim
@ -2,7 +2,7 @@ system sh/stop_dnodes.sh


 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start

 sleep 2000
@ -51,7 +51,7 @@ print =============== step2
 system sh/exec.sh -n dnode1 -s stop
 sleep 3000
 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start

 print =============== step3
--- a/tests/script/general/cache/restart_table.sim
+++ b/tests/script/general/cache/restart_table.sim
@ -2,7 +2,7 @@ system sh/stop_dnodes.sh


 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start

 sleep 2000
@ -35,7 +35,7 @@ print =============== step2
 system sh/exec.sh -n dnode1 -s stop
 sleep 3000
 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start

 print =============== step3
--- a/tests/script/general/column/commit.sim
+++ b/tests/script/general/column/commit.sim
@ -2,7 +2,7 @@ system sh/stop_dnodes.sh


 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start

 sleep 2000
--- a/tests/script/general/column/metrics.sim
+++ b/tests/script/general/column/metrics.sim
@ -2,7 +2,7 @@ system sh/stop_dnodes.sh


 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start

 sleep 2000
--- a/tests/script/general/column/table.sim
+++ b/tests/script/general/column/table.sim
@ -2,7 +2,7 @@ system sh/stop_dnodes.sh


 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start

 sleep 2000
--- a/tests/script/general/compress/compress.sim
+++ b/tests/script/general/compress/compress.sim
@ -1,7 +1,7 @@
 system sh/stop_dnodes.sh

 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/cfg.sh -n dnode1 -c comp -v 1
 system sh/exec.sh -n dnode1 -s start

--- a/tests/script/general/compress/compress2.sim
+++ b/tests/script/general/compress/compress2.sim
@ -1,7 +1,7 @@
 system sh/stop_dnodes.sh

 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/cfg.sh -n dnode1 -c comp -v 2
 system sh/exec.sh -n dnode1 -s start

--- a/tests/script/general/compress/uncompress.sim
+++ b/tests/script/general/compress/uncompress.sim
@ -1,6 +1,6 @@
 system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/cfg.sh -n dnode1 -c comp -v 1
 system sh/exec.sh -n dnode1 -s start

--- a/tests/script/general/compute/avg.sim
+++ b/tests/script/general/compute/avg.sim
@ -1,7 +1,7 @@
 system sh/stop_dnodes.sh

 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start
 sleep 2000
 sql connect
--- a/tests/script/general/compute/bottom.sim
+++ b/tests/script/general/compute/bottom.sim
@ -1,7 +1,7 @@
 system sh/stop_dnodes.sh

 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start
 sleep 2000
 sql connect
--- a/tests/script/general/compute/count.sim
+++ b/tests/script/general/compute/count.sim
@ -1,7 +1,7 @@
 system sh/stop_dnodes.sh

 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start
 sleep 2000
 sql connect
--- a/tests/script/general/compute/diff.sim
+++ b/tests/script/general/compute/diff.sim
@ -1,7 +1,7 @@
 system sh/stop_dnodes.sh

 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start
 sleep 2000
 sql connect
--- a/tests/script/general/compute/diff2.sim
+++ b/tests/script/general/compute/diff2.sim
@ -1,7 +1,7 @@
 system sh/stop_dnodes.sh

 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start
 sleep 2000
 sql connect
--- a/tests/script/general/compute/first.sim
+++ b/tests/script/general/compute/first.sim
@ -1,7 +1,7 @@
 system sh/stop_dnodes.sh

 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start
 sleep 2000
 sql connect
--- a/tests/script/general/compute/interval.sim
+++ b/tests/script/general/compute/interval.sim
@ -1,7 +1,7 @@
 system sh/stop_dnodes.sh

 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start
 sleep 2000
 sql connect
--- a/tests/script/general/compute/last.sim
+++ b/tests/script/general/compute/last.sim
@ -1,7 +1,7 @@
 system sh/stop_dnodes.sh

 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start
 sleep 2000
 sql connect
--- a/tests/script/general/compute/last_row.sim
+++ b/tests/script/general/compute/last_row.sim
@ -1,7 +1,7 @@
 system sh/stop_dnodes.sh

 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start
 sleep 2000
 sql connect
--- a/tests/script/general/compute/leastsquare.sim
+++ b/tests/script/general/compute/leastsquare.sim
@ -1,7 +1,7 @@
 system sh/stop_dnodes.sh

 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start
 sleep 2000
 sql connect
--- a/tests/script/general/compute/max.sim
+++ b/tests/script/general/compute/max.sim
@ -1,7 +1,7 @@
 system sh/stop_dnodes.sh

 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start
 sleep 2000
 sql connect
--- a/tests/script/general/compute/min.sim
+++ b/tests/script/general/compute/min.sim
@ -1,7 +1,7 @@
 system sh/stop_dnodes.sh

 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start

 sleep 2000
--- a/tests/script/general/compute/null.sim
+++ b/tests/script/general/compute/null.sim
@ -1,7 +1,7 @@
 system sh/stop_dnodes.sh

 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start
 sleep 2000
 sql connect
--- a/tests/script/general/compute/percentile.sim
+++ b/tests/script/general/compute/percentile.sim
@ -1,7 +1,7 @@
 system sh/stop_dnodes.sh

 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start
 sleep 2000
 sql connect
--- a/tests/script/general/compute/stddev.sim
+++ b/tests/script/general/compute/stddev.sim
@ -1,7 +1,7 @@
 system sh/stop_dnodes.sh

 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start
 sleep 2000
 sql connect
--- a/tests/script/general/compute/sum.sim
+++ b/tests/script/general/compute/sum.sim
@ -1,7 +1,7 @@
 system sh/stop_dnodes.sh

 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start
 sleep 2000
 sql connect
--- a/tests/script/general/compute/top.sim
+++ b/tests/script/general/compute/top.sim
@ -1,7 +1,7 @@
 system sh/stop_dnodes.sh

 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start
 sleep 2000
 sql connect
--- a/tests/script/general/db/backup/keep.sim
+++ b/tests/script/general/db/backup/keep.sim
@ -6,9 +6,9 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/deploy.sh -n dnode2 -i 2
 system sh/deploy.sh -n dnode3 -i 3

-system sh/cfg.sh -n dnode1 -c walLevel -v 0
-system sh/cfg.sh -n dnode2 -c walLevel -v 0
-system sh/cfg.sh -n dnode3 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
+system sh/cfg.sh -n dnode2 -c walLevel -v 1
+system sh/cfg.sh -n dnode3 -c walLevel -v 1
 system sh/cfg.sh -n dnode1 -c numOfMnodes -v 1
 system sh/cfg.sh -n dnode2 -c numOfMnodes -v 1
 system sh/cfg.sh -n dnode3 -c numOfMnodes -v 1
--- a/tests/script/general/db/delete_reuse1.sim
+++ b/tests/script/general/db/delete_reuse1.sim
@ -5,10 +5,10 @@ system sh/deploy.sh -n dnode2 -i 2
 system sh/deploy.sh -n dnode3 -i 3
 system sh/deploy.sh -n dnode4 -i 4

-system sh/cfg.sh -n dnode1 -c walLevel -v 0
-system sh/cfg.sh -n dnode2 -c walLevel -v 0
-system sh/cfg.sh -n dnode3 -c walLevel -v 0
-system sh/cfg.sh -n dnode4 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
+system sh/cfg.sh -n dnode2 -c walLevel -v 1
+system sh/cfg.sh -n dnode3 -c walLevel -v 1
+system sh/cfg.sh -n dnode4 -c walLevel -v 1

 system sh/cfg.sh -n dnode1 -c numOfMnodes -v 1
 system sh/cfg.sh -n dnode2 -c numOfMnodes -v 1
--- a/tests/script/general/db/delete_reuse2.sim
+++ b/tests/script/general/db/delete_reuse2.sim
@ -5,10 +5,10 @@ system sh/deploy.sh -n dnode2 -i 2
 system sh/deploy.sh -n dnode3 -i 3
 system sh/deploy.sh -n dnode4 -i 4

-system sh/cfg.sh -n dnode1 -c walLevel -v 0
-system sh/cfg.sh -n dnode2 -c walLevel -v 0
-system sh/cfg.sh -n dnode3 -c walLevel -v 0
-system sh/cfg.sh -n dnode4 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
+system sh/cfg.sh -n dnode2 -c walLevel -v 1
+system sh/cfg.sh -n dnode3 -c walLevel -v 1
+system sh/cfg.sh -n dnode4 -c walLevel -v 1

 system sh/cfg.sh -n dnode1 -c numOfMnodes -v 1
 system sh/cfg.sh -n dnode2 -c numOfMnodes -v 1
--- a/tests/script/general/db/delete_writing1.sim
+++ b/tests/script/general/db/delete_writing1.sim
@ -5,10 +5,10 @@ system sh/deploy.sh -n dnode2 -i 2
 system sh/deploy.sh -n dnode3 -i 3
 system sh/deploy.sh -n dnode4 -i 4

-system sh/cfg.sh -n dnode1 -c walLevel -v 0
-system sh/cfg.sh -n dnode2 -c walLevel -v 0
-system sh/cfg.sh -n dnode3 -c walLevel -v 0
-system sh/cfg.sh -n dnode4 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
+system sh/cfg.sh -n dnode2 -c walLevel -v 1
+system sh/cfg.sh -n dnode3 -c walLevel -v 1
+system sh/cfg.sh -n dnode4 -c walLevel -v 1

 system sh/cfg.sh -n dnode1 -c numOfMnodes -v 1
 system sh/cfg.sh -n dnode2 -c numOfMnodes -v 1
--- a/tests/script/general/db/len.sim
+++ b/tests/script/general/db/len.sim
@ -2,7 +2,7 @@ system sh/stop_dnodes.sh


 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2000

 system sh/exec.sh -n dnode1 -s start
--- a/tests/script/general/db/show_create_db.sim
+++ b/tests/script/general/db/show_create_db.sim
@ -1,7 +1,7 @@
 system sh/stop_dnodes.sh

 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1

 system sh/exec.sh -n dnode1 -s start
 sleep 2000
--- a/tests/script/general/db/show_create_table.sim
+++ b/tests/script/general/db/show_create_table.sim
@ -1,7 +1,7 @@
 system sh/stop_dnodes.sh

 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1

 system sh/exec.sh -n dnode1 -s start
 sleep 2000
--- a/tests/script/general/db/tables.sim
+++ b/tests/script/general/db/tables.sim
@ -1,7 +1,7 @@
 system sh/stop_dnodes.sh

 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/cfg.sh -n dnode2 -c maxVgroupsPerDb -v 4
 system sh/cfg.sh -n dnode1 -c maxTablesPerVnode -v 4

--- a/tests/script/general/db/vnodes.sim
+++ b/tests/script/general/db/vnodes.sim
@ -5,7 +5,7 @@ $maxTables = 4
 $totalRows = $totalVnodes * $maxTables

 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel            -v 0
+system sh/cfg.sh -n dnode1 -c walLevel            -v 1
 system sh/cfg.sh -n dnode1 -c maxTablesPerVnode   -v $maxTables
 system sh/cfg.sh -n dnode1 -c maxVgroupsPerDb     -v $totalVnodes
 system sh/cfg.sh -n dnode1 -c maxVnodeConnections -v 100000
@ -44,4 +44,4 @@ if $data00 != $totalRows then
  return -1
 endi  

-system sh/exec.sh -n dnode1 -s stop  -x SIGINT
+system sh/exec.sh -n dnode1 -s stop  -x SIGINT
--- a/tests/script/general/field/2.sim
+++ b/tests/script/general/field/2.sim
@ -1,6 +1,6 @@
 system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start

 sleep 2000
--- a/tests/script/general/field/3.sim
+++ b/tests/script/general/field/3.sim
@ -1,6 +1,6 @@
 system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start

 sleep 2000
--- a/tests/script/general/field/4.sim
+++ b/tests/script/general/field/4.sim
@ -1,6 +1,6 @@
 system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start

 sleep 2000
--- a/tests/script/general/field/5.sim
+++ b/tests/script/general/field/5.sim
@ -1,6 +1,6 @@
 system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start

 sleep 2000
--- a/tests/script/general/field/6.sim
+++ b/tests/script/general/field/6.sim
@ -1,6 +1,6 @@
 system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start

 sleep 2000
--- a/tests/script/general/field/bigint.sim
+++ b/tests/script/general/field/bigint.sim
@ -1,6 +1,6 @@
 system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start

 sleep 2000
--- a/tests/script/general/field/binary.sim
+++ b/tests/script/general/field/binary.sim
@ -1,6 +1,6 @@
 system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start

 sleep 2000
--- a/tests/script/general/field/bool.sim
+++ b/tests/script/general/field/bool.sim
@ -1,6 +1,6 @@
 system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start

 sleep 2000
--- a/tests/script/general/field/double.sim
+++ b/tests/script/general/field/double.sim
@ -1,6 +1,6 @@
 system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start

 sleep 2000
--- a/tests/script/general/field/float.sim
+++ b/tests/script/general/field/float.sim
@ -1,6 +1,6 @@
 system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start

 sleep 2000
--- a/tests/script/general/field/int.sim
+++ b/tests/script/general/field/int.sim
@ -1,6 +1,6 @@
 system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start

 sleep 2000
--- a/Show More
+++ b/Show More