Merge branch 'develop' into origin/feature/TD-3086

2021-06-18 22:07:29 +08:00 · 2021-06-18 22:07:29 +08:00 · d3702a7dbd
parent 2d66f67893 55fea5300d
commit d3702a7dbd
93 changed files with 3961 additions and 877 deletions
--- 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.30.jar DESTINATION connector/jdbc)
+    INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.31.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
@ -81,7 +81,7 @@ TDengine是一个高效的存储、查询、分析时序大数据的平台，专
 ## [与其他工具的连接](/connections)
 * [Grafana](/connections#grafana)：获取并可视化保存在TDengine的数据
-* [Matlab](/connections#matlab)：通过配置Matlab的JDBC数据源访问保存在TDengine的数据
+* [MATLAB](/connections#matlab)：通过配置MATLAB的JDBC数据源访问保存在TDengine的数据
 * [R](/connections#r)：通过配置R的JDBC数据源访问保存在TDengine的数据
 * [IDEA Database](https://www.taosdata.com/blog/2020/08/27/1767.html)：通过IDEA 数据库管理工具可视化使用 TDengine
--- a/documentation20/cn/01.evaluation/docs.md
+++ b/documentation20/cn/01.evaluation/docs.md
@ -9,8 +9,8 @@ TDengine的模块之一是时序数据库。但除此之外，为减少研发的
 * __10倍以上的性能提升__：定义了创新的数据存储结构，单核每秒能处理至少2万次请求，插入数百万个数据点，读出一千万以上数据点，比现有通用数据库快十倍以上。
 * __硬件或云服务成本降至1/5__：由于超强性能，计算资源不到通用大数据方案的1/5；通过列式存储和先进的压缩算法，存储空间不到通用数据库的1/10。
 * __全栈时序数据处理引擎__：将数据库、消息队列、缓存、流式计算等功能融为一体，应用无需再集成Kafka/Redis/HBase/Spark/HDFS等软件，大幅降低应用开发和维护的复杂度成本。 
-* __强大的分析功能__：无论是十年前还是一秒钟前的数据，指定时间范围即可查询。数据可在时间轴上或多个设备上进行聚合。即席查询可通过Shell, Python, R, Matlab随时进行。
+* __强大的分析功能__：无论是十年前还是一秒钟前的数据，指定时间范围即可查询。数据可在时间轴上或多个设备上进行聚合。即席查询可通过Shell, Python, R, MATLAB随时进行。
-* __与第三方工具无缝连接__：不用一行代码，即可与Telegraf, Grafana, EMQ, HiveMQ, Prometheus, Matlab, R等集成。后续将支持OPC, Hadoop, Spark等, BI工具也将无缝连接。
+* __与第三方工具无缝连接__：不用一行代码，即可与Telegraf, Grafana, EMQ, HiveMQ, Prometheus, MATLAB, R等集成。后续将支持OPC, Hadoop, Spark等, BI工具也将无缝连接。
 * __零运维成本、零学习成本__：安装集群简单快捷，无需分库分表，实时备份。类似标准SQL，支持RESTful, 支持Python/Java/C/C++/C#/Go/Node.js, 与MySQL相似，零学习成本。
 采用TDengine，可将典型的物联网、车联网、工业互联网大数据平台的总拥有成本大幅降低。但需要指出的是，因充分利用了物联网时序数据的特点，它无法用来处理网络爬虫、微博、微信、电商、ERP、CRM等通用型数据。
--- a/documentation20/cn/08.connector/docs.md
+++ b/documentation20/cn/08.connector/docs.md
@ -56,7 +56,7 @@ TDengine提供了丰富的应用程序开发接口，其中包括C/C++、Java、
    *taos.tar.gz*：应用驱动安装包
    *driver*：TDengine应用驱动driver
    *connector*: 各种编程语言连接器（go/grafanaplugin/nodejs/python/JDBC）
-    *examples*: 各种编程语言的示例程序(c/C#/go/JDBC/matlab/python/R)
+    *examples*: 各种编程语言的示例程序(c/C#/go/JDBC/MATLAB/python/R)
 运行install_client.sh进行安装
--- a/documentation20/cn/09.connections/docs.md
+++ b/documentation20/cn/09.connections/docs.md
@ -75,17 +75,17 @@ sudo cp -rf /usr/local/taos/connector/grafanaplugin /var/lib/grafana/plugins/tde
 ![img](page://images/connections/import_dashboard2.jpg)
-## <a class="anchor" id="matlab"></a>Matlab
+## <a class="anchor" id="matlab"></a>MATLAB
-MatLab可以通过安装包内提供的JDBC Driver直接连接到TDengine获取数据到本地工作空间。
+MATLAB可以通过安装包内提供的JDBC Driver直接连接到TDengine获取数据到本地工作空间。
-### MatLab的JDBC接口适配
+### MATLAB的JDBC接口适配
-MatLab的适配有下面几个步骤，下面以Windows10上适配MatLab2017a为例：
+MATLAB的适配有下面几个步骤，下面以Windows10上适配MATLAB2017a为例：
 - 将TDengine安装包内的驱动程序JDBCDriver-1.0.0-dist.jar拷贝到${matlab_root}\MATLAB\R2017a\java\jar\toolbox
 - 将TDengine安装包内的taos.lib文件拷贝至${matlab_ root _dir}\MATLAB\R2017a\lib\win64
- 将新添加的驱动jar包加入MatLab的classpath。在${matlab_ root _dir}\MATLAB\R2017a\toolbox\local\classpath.txt文件中添加下面一行
+- 将新添加的驱动jar包加入MATLAB的classpath。在${matlab_ root _dir}\MATLAB\R2017a\toolbox\local\classpath.txt文件中添加下面一行
 ```
 $matlabroot/java/jar/toolbox/JDBCDriver-1.0.0-dist.jar
@ -96,9 +96,9 @@ $matlabroot/java/jar/toolbox/JDBCDriver-1.0.0-dist.jar
 C:\Windows\System32
 ```
-### 在MatLab中连接TDengine获取数据
+### 在MATLAB中连接TDengine获取数据
-在成功进行了上述配置后，打开MatLab。
+在成功进行了上述配置后，打开MATLAB。
 - 创建一个连接：
--- a/documentation20/cn/11.administrator/docs.md
+++ b/documentation20/cn/11.administrator/docs.md
@ -116,20 +116,22 @@ taosd -C
 **注意：**对于端口，TDengine会使用从serverPort起13个连续的TCP和UDP端口号，请务必在防火墙打开。因此如果是缺省配置，需要打开从6030到6042共13个端口，而且必须TCP和UDP都打开。（详细的端口情况请参见 [TDengine 2.0 端口说明](https://www.taosdata.com/cn/documentation/faq#port)）
-不同应用场景的数据往往具有不同的数据特征，比如保留天数、副本数、采集频次、记录大小、采集点的数量、压缩等都可完全不同。为获得在存储上的最高效率，TDengine提供如下存储相关的系统配置参数：
+不同应用场景的数据往往具有不同的数据特征，比如保留天数、副本数、采集频次、记录大小、采集点的数量、压缩等都可完全不同。为获得在存储上的最高效率，TDengine提供如下存储相关的系统配置参数（既可以作为 create database 指令的参数，也可以写在 taos.cfg 配置文件中用来设定创建新数据库时所采用的默认值）：
- days：一个数据文件存储数据的时间跨度，单位为天，默认值：10。
+- days：一个数据文件存储数据的时间跨度。单位为天，默认值：10。
- keep：数据库中数据保留的天数，单位为天，默认值：3650。（可通过 alter database 修改）
+- keep：数据库中数据保留的天数。单位为天，默认值：3650。（可通过 alter database 修改）
- minRows：文件块中记录的最小条数，单位为条，默认值：100。
+- minRows：文件块中记录的最小条数。单位为条，默认值：100。
- maxRows：文件块中记录的最大条数，单位为条，默认值：4096。
+- maxRows：文件块中记录的最大条数。单位为条，默认值：4096。
- comp：文件压缩标志位，0：关闭；1：一阶段压缩；2：两阶段压缩。默认值：2。（可通过 alter database 修改）
+- comp：文件压缩标志位。0：关闭；1：一阶段压缩；2：两阶段压缩。默认值：2。（可通过 alter database 修改）
- walLevel：WAL级别。1：写wal，但不执行fsync；2：写wal, 而且执行fsync。默认值：1。
+- wal：WAL级别。1：写wal，但不执行fsync；2：写wal, 而且执行fsync。默认值：1。（在 taos.cfg 中参数名需要写作 walLevel）（可通过 alter database 修改）
- fsync：当wal设置为2时，执行fsync的周期。设置为0，表示每次写入，立即执行fsync。单位为毫秒，默认值：3000。
+- fsync：当wal设置为2时，执行fsync的周期。设置为0，表示每次写入，立即执行fsync。单位为毫秒，默认值：3000。（可通过 alter database 修改）
- cache：内存块的大小，单位为兆字节（MB），默认值：16。
+- cache：内存块的大小。单位为兆字节（MB），默认值：16。
 - blocks：每个VNODE（TSDB）中有多少cache大小的内存块。因此一个VNODE的用的内存大小粗略为（cache * blocks）。单位为块，默认值：4。（可通过 alter database 修改）
- replica：副本个数，取值范围：1-3。单位为个，默认值：1。（可通过 alter database 修改）
+- replica：副本个数。取值范围：1-3，单位为个，默认值：1。（可通过 alter database 修改）
- precision：时间戳精度标识，ms表示毫秒，us表示微秒。默认值：ms。
+- quorum：多副本环境下指令执行的确认数要求。取值范围：1、2，单位为个，默认值：1。（可通过 alter database 修改）
- cacheLast：是否在内存中缓存子表的最近数据，0：关闭；1：缓存子表最近一行数据；2：缓存子表每一列的最近的非NULL值，3：同时打开缓存最近行和列功能，默认值：0。（可通过 alter database 修改）（从 2.0.11 版本开始支持此参数）
+- precision：时间戳精度标识。ms表示毫秒，us表示微秒，默认值：ms。（2.1.2.0 版本之前、2.0.20.7 版本之前在 taos.cfg 文件中不支持此参数。）
 - cacheLast：是否在内存中缓存子表的最近数据。0：关闭；1：缓存子表最近一行数据；2：缓存子表每一列的最近的非NULL值；3：同时打开缓存最近行和列功能。默认值：0。（可通过 alter database 修改）（从 2.1.2.0 版本开始此参数支持 0～3 的取值范围，在此之前取值只能是 [0, 1]；而 2.0.11.0 之前的版本在 SQL 指令中不支持此参数。）（2.1.2.0 版本之前、2.0.20.7 版本之前在 taos.cfg 文件中不支持此参数。）
 - update：是否允许更新。0：不允许；1：允许。默认值：0。（可通过 alter database 修改）
 对于一个应用场景，可能有多种数据特征的数据并存，最佳的设计是将具有相同数据特征的表放在一个库里，这样一个应用有多个库，而每个库可以配置不同的存储参数，从而保证系统有最优的性能。TDengine允许应用在创建库时指定上述存储参数，如果指定，该参数就将覆盖对应的系统配置参数。举例，有下述SQL：
@ -142,7 +144,6 @@ taosd -C
 TDengine集群中加入一个新的dnode时，涉及集群相关的一些参数必须与已有集群的配置相同，否则不能成功加入到集群中。会进行校验的参数如下：
 - numOfMnodes：系统中管理节点个数。默认值：3。
 - balance：是否启动负载均衡。0：否，1：是。默认值：1。
 - mnodeEqualVnodeNum: 一个mnode等同于vnode消耗的个数。默认值：4。
 - offlineThreshold: dnode离线阈值，超过该时间将导致该dnode从集群中删除。单位为秒，默认值：86400*10（即10天）。
 - statusInterval: dnode向mnode报告状态时长。单位为秒，默认值：1。
@ -150,6 +151,10 @@ TDengine集群中加入一个新的dnode时，涉及集群相关的一些参数
 - maxVgroupsPerDb: 每个数据库中能够使用的最大vgroup个数。
 - arbitrator: 系统中裁决器的end point，缺省为空。
 - timezone、locale、charset 的配置见客户端配置。（2.0.20.0 及以上的版本里，集群中加入新节点已不要求 locale 和 charset 参数取值一致）
 - balance：是否启用负载均衡。0：否，1：是。默认值：1。
 - flowctrl：是否启用非阻塞流控。0：否，1：是。默认值：1。
 - slaveQuery：是否启用 slave vnode 参与查询。0：否，1：是。默认值：1。
 - adjustMaster：是否启用 vnode master 负载均衡。0：否，1：是。默认值：1。
 为方便调试，可通过SQL语句临时调整每个dnode的日志配置，系统重启后会失效：
--- a/documentation20/cn/12.taos-sql/docs.md
+++ b/documentation20/cn/12.taos-sql/docs.md
@ -126,9 +126,25 @@ TDengine 缺省的时间戳是毫秒精度，但通过在 CREATE DATABASE 时传
    ```mysql
    ALTER DATABASE db_name CACHELAST 0;
    ```
-    CACHELAST 参数控制是否在内存中缓存数据子表的 last_row。缺省值为 0，取值范围 [0, 1]。其中 0 表示不启用、1 表示启用。（从 2.0.11.0 版本开始支持。从 2.1.1.0 版本开始，修改此参数后无需重启服务器即可生效。）
+    CACHELAST 参数控制是否在内存中缓存子表的最近数据。缺省值为 0，取值范围 [0, 1, 2, 3]。其中 0 表示不缓存，1 表示缓存子表最近一行数据，2 表示缓存子表每一列的最近的非 NULL 值，3 表示同时打开缓存最近行和列功能。（从 2.0.11.0 版本开始支持参数值 [0, 1]，从 2.1.2.0 版本开始支持参数值 [0, 1, 2, 3]。）  
    说明：缓存最近行，将显著改善 LAST_ROW 函数的性能表现；缓存每列的最近非 NULL 值，将显著改善无特殊影响（WHERE、ORDER BY、GROUP BY、INTERVAL）下的 LAST 函数的性能表现。
-    **Tips**: 以上所有参数修改后都可以用show databases来确认是否修改成功。
+    ```mysql
    ALTER DATABASE db_name WAL 1;
    ```
    WAL 参数控制 WAL 日志的落盘方式。缺省值为 1，取值范围为 [1, 2]。1 表示写 WAL，但不执行 fsync；2 表示写 WAL，而且执行 fsync。
    ```mysql
    ALTER DATABASE db_name FSYNC 3000;
    ```
    FSYNC 参数控制执行 fsync 操作的周期。缺省值为 3000，单位是毫秒，取值范围为 [0, 180000]。如果设置为 0，表示每次写入，立即执行 fsync。该设置项主要用于调节 WAL 参数设为 2 时的系统行为。
    ```mysql
    ALTER DATABASE db_name UPDATE 0;
    ```
    UPDATE 参数控制是否允许更新数据。缺省值为 0，取值范围为 [0, 1]。0 表示会直接丢弃后写入的相同时间戳的数据；1 表示会使用后写入的数据覆盖已有的相同时间戳的数据。
    **Tips**: 以上所有参数修改后都可以用show databases来确认是否修改成功。另外，从 2.1.1.0 版本开始，修改这些参数后无需重启服务器即可生效。
 - **显示系统所有数据库**
--- a/documentation20/en/00.index/docs.md
+++ b/documentation20/en/00.index/docs.md
@ -82,7 +82,7 @@ TDengine is a highly efficient platform to store, query, and analyze time-series
 ## [Connections with Other Tools](/connections)
 - [Grafana](/connections#grafana): query the data saved in TDengine and provide visualization
- [Matlab](/connections#matlab): access data stored in TDengine server via JDBC configured within Matlab
+- [MATLAB](/connections#matlab): access data stored in TDengine server via JDBC configured within MATLAB
 - [R](/connections#r): access data stored in TDengine server via JDBC configured within R
 - [IDEA Database](https://www.taosdata.com/blog/2020/08/27/1767.html): use TDengine visually through IDEA Database Management Tool
--- a/documentation20/en/01.evaluation/docs.md
+++ b/documentation20/en/01.evaluation/docs.md
@ -9,8 +9,8 @@ One of the modules of TDengine is the time-series database. However, in addition
 - **Performance improvement over 10 times**: An innovative data storage structure is defined, with each single core can process at least 20,000 requests per second, insert millions of data points, and read more than 10 million data points, which is more than 10 times faster than other existing general database.
 - **Reduce the cost of hardware or cloud services to 1/5**: Due to its ultra-performance, TDengine’s computing resources consumption is less than 1/5 of other common Big Data solutions; through columnar storage and advanced compression algorithms, the storage consumption is less than 1/10 of other general databases.
 - **Full-stack time-series data processing engine**: Integrate database, message queue, cache, stream computing, and other functions, and the applications do not need to integrate with software such as Kafka/Redis/HBase/Spark/HDFS, thus greatly reducing the complexity cost of application development and maintenance.
- **Powerful analysis functions**: Data from ten years ago or one second ago, can all be queried based on a specified time range. Data can be aggregated on a timeline or multiple devices. Ad-hoc queries can be made at any time through Shell, Python, R, and Matlab.
+- **Powerful analysis functions**: Data from ten years ago or one second ago, can all be queried based on a specified time range. Data can be aggregated on a timeline or multiple devices. Ad-hoc queries can be made at any time through Shell, Python, R, and MATLAB.
- **Seamless connection with third-party tools**: Integration with Telegraf, Grafana, EMQ, HiveMQ, Prometheus, Matlab, R, etc. without even one single line of code. OPC, Hadoop, Spark, etc. will be supported in the future, and more BI tools will be seamlessly connected to.
+- **Seamless connection with third-party tools**: Integration with Telegraf, Grafana, EMQ, HiveMQ, Prometheus, MATLAB, R, etc. without even one single line of code. OPC, Hadoop, Spark, etc. will be supported in the future, and more BI tools will be seamlessly connected to.
 - **Zero operation cost & zero learning cost**: Installing clusters is simple and quick, with real-time backup built-in, and no need to split libraries or tables. Similar to standard SQL, TDengine can support RESTful, Python/Java/C/C + +/C#/Go/Node.js, and similar to MySQL with zero learning cost.
 With TDengine, the total cost of ownership of typical IoT, Internet of Vehicles, and Industrial Internet Big Data platforms can be greatly reduced. However, it should be pointed out that due to making full use of the characteristics of IoT time-series data, TDengine cannot be used to process general data from web crawlers, microblogs, WeChat, e-commerce, ERP, CRM, and other sources.
--- a/documentation20/en/08.connector/docs.md
+++ b/documentation20/en/08.connector/docs.md
@ -58,7 +58,7 @@ After extracting the package, you will see the following files (directories) in
 *connector*: Connectors for various programming languages (go/grafanaplugin/nodejs/python/JDBC) 
-*Examples*: Sample programs for various programming languages (C/C #/go/JDBC/matlab/python/R)
+*Examples*: Sample programs for various programming languages (C/C #/go/JDBC/MATLAB/python/R)
 Run install_client.sh to install.
--- a/documentation20/en/09.connections/docs.md
+++ b/documentation20/en/09.connections/docs.md
@ -74,17 +74,17 @@ You can see as follows after Dashboard imported.
 ![img](page://images/connections/import_dashboard2.jpg)
-## <a class="anchor" id="matlab"></a> Matlab
+## <a class="anchor" id="matlab"></a> MATLAB
-MatLab can access data to the local workspace by connecting directly to the TDengine via the JDBC Driver provided in the installation package.
+MATLAB can access data to the local workspace by connecting directly to the TDengine via the JDBC Driver provided in the installation package.
-### JDBC Interface Adaptation of MatLab
+### JDBC Interface Adaptation of MATLAB
-Several steps are required to adapt Matlab to TDengine. Taking adapting Matlab2017a on Windows10 as an example:
+Several steps are required to adapt MATLAB to TDengine. Taking adapting MATLAB2017a on Windows10 as an example:
 - Copy the file JDBCDriver-1.0.0-dist.ja*r* in TDengine package to the directory ${matlab_root}\MATLAB\R2017a\java\jar\toolbox
 - Copy the file taos.lib in TDengine package to ${matlab root dir}\MATLAB\R2017a\lib\win64
- Add the .jar package just copied to the Matlab classpath. Append the line below as the end of the file of ${matlab root dir}\MATLAB\R2017a\toolbox\local\classpath.txt
+- Add the .jar package just copied to the MATLAB classpath. Append the line below as the end of the file of ${matlab root dir}\MATLAB\R2017a\toolbox\local\classpath.txt
 - ```
  $matlabroot/java/jar/toolbox/JDBCDriver-1.0.0-dist.jar
  ```
@ -94,9 +94,9 @@ Several steps are required to adapt Matlab to TDengine. Taking adapting Matlab20
  C:\Windows\System32
  ```
- ### Connect to TDengine in MatLab to get data
+- ### Connect to TDengine in MATLAB to get data
-After the above configured successfully, open MatLab.
+After the above configured successfully, open MATLAB.
 - Create a connection:
--- a/packaging/check_package.sh
+++ b/packaging/check_package.sh
@ -0,0 +1,245 @@
 #!/bin/bash
 #
 # This file is used to install database on linux systems. The operating system
 # is required to use systemd to manage services at boot
 set -e
 #set -x
 verMode=edge
 pagMode=full
 iplist=""
 serverFqdn=""
 # -----------------------Variables definition---------------------
 script_dir="../release"
 # Dynamic directory
 data_dir="/var/lib/taos"
 log_dir="/var/log/taos"
 data_link_dir="/usr/local/taos/data"
 log_link_dir="/usr/local/taos/log"
 cfg_install_dir="/etc/taos"
 bin_link_dir="/usr/bin"
 lib_link_dir="/usr/lib"
 lib64_link_dir="/usr/lib64"
 inc_link_dir="/usr/include"
 #install main path
 install_main_dir="/usr/local/taos"
 # old bin dir
 sbin_dir="/usr/local/taos/bin"
 temp_version=""
 fin_result=""
 service_config_dir="/etc/systemd/system"
 nginx_port=6060
 nginx_dir="/usr/local/nginxd"
 # Color setting
 RED='\033[0;31m'
 GREEN='\033[1;32m'
 GREEN_DARK='\033[0;32m'
 GREEN_UNDERLINE='\033[4;32m'
 NC='\033[0m'
 csudo=""
 if command -v sudo > /dev/null; then
    csudo="sudo"
 fi
 # =============================  get input parameters =================================================
 # install.sh -v [server | client]  -e [yes | no] -i [systemd | service | ...]
 # set parameters by default value
 interactiveFqdn=yes   # [yes | no]
 verType=server        # [server | client]
 initType=systemd      # [systemd | service | ...]
 while getopts "hv:d:" arg
 do
  case $arg in
    d)
      #echo "interactiveFqdn=$OPTARG"
      script_dir=$( echo $OPTARG )
      ;;
    h)
      echo "Usage: `basename $0` -d scripy_path"
      exit 0
      ;;
    ?) #unknow option
      echo "unkonw argument"
      exit 1
      ;;
  esac
 done
 #echo "verType=${verType} interactiveFqdn=${interactiveFqdn}"
 function kill_process() {
  pid=$(ps -ef | grep "$1" | grep -v "grep" | awk '{print $2}')
  if [ -n "$pid" ]; then
    ${csudo} kill -9 $pid   || :
  fi
 }
 function check_file() {
    #check file whether exists
    if [ ! -e $1/$2 ];then
        echo -e "$1/$2 \033[31mnot exists\033[0m!quit"
        fin_result=$fin_result"\033[31m$temp_version\033[0m test failed!\n"
        echo -e $fin_result
        exit 8 
    fi
 }
 function get_package_name() {
  var=$1
 	if [[ $1 =~ 'aarch' ]];then
 		echo ${var::-21}
 	else
 		echo ${var::-17}
 	fi
 }
 function check_link() {
    #check Link whether exists or broken
    if [ -L $1 ] ; then
        if [ ! -e $1 ] ; then
            echo -e "$1 \033[31Broken link\033[0m"
            fin_result=$fin_result"\033[31m$temp_version\033[0m test failed!\n"
            echo -e $fin_result
            exit 8 
        fi
    else
        echo -e "$1 \033[31mnot exists\033[0m!quit"
        fin_result=$fin_result"\033[31m$temp_version\033[0m test failed!\n"
        echo -e $fin_result
        exit 8 
    fi
 }
 function check_main_path() {
    #check install main dir and all sub dir
    main_dir=("" "cfg" "bin" "connector" "driver" "examples" "include" "init.d")
    for i in ${main_dir[@]};do
        check_file ${install_main_dir} $i
    done
    if [ "$verMode" == "cluster" ]; then
        nginx_main_dir=("admin" "conf" "html" "sbin" "logs")
        for i in ${nginx_main_dir[@]};do
            check_file ${nginx_dir}  $i
        done
    fi
    echo -e "Check main path:\033[32mOK\033[0m!"
 }
 function check_bin_path() {
    # check install bin dir and all sub dir
    bin_dir=("taos" "taosd" "taosdemo" "taosdump" "remove.sh" "tarbitrator" "set_core.sh")
    for i in ${bin_dir[@]};do
        check_file ${sbin_dir} $i
    done
    lbin_dir=("taos" "taosd" "taosdemo" "taosdump" "rmtaos" "tarbitrator" "set_core")
    for i in ${lbin_dir[@]};do
        check_link ${bin_link_dir}/$i
    done
    if [ "$verMode" == "cluster" ]; then
        check_file ${nginx_dir}/sbin nginx
    fi
    echo -e "Check bin  path:\033[32mOK\033[0m!"
 }
 function check_lib_path() {
    # check all links
    check_link ${lib_link_dir}/libtaos.so
    check_link ${lib_link_dir}/libtaos.so.1
    if [[ -d ${lib64_link_dir}  ]]; then
        check_link ${lib64_link_dir}/libtaos.so
        check_link ${lib64_link_dir}/libtaos.so.1
    fi
    echo -e "Check lib  path:\033[32mOK\033[0m!"
 }
 function check_header_path() {
 	# check all header 
 	header_dir=("taos.h" "taoserror.h")
    for i in ${header_dir[@]};do
        check_link ${inc_link_dir}/$i
    done
    echo -e "Check bin  path:\033[32mOK\033[0m!"
 }
 function check_config_dir() {
 	# check all config
 	check_file ${cfg_install_dir} taos.cfg
 	check_file ${install_main_dir}/cfg taos.cfg.org
 	echo -e "Check conf path:\033[32mOK\033[0m!"
 }
 function check_log_path() {
 	# check log path
 	check_file ${log_dir}
 	echo -e "Check log  path:\033[32mOK\033[0m!"
 }
 function check_data_path() {
 	# check data path
 	check_file ${data_dir} 
 	echo -e "Check data path:\033[32mOK\033[0m!"
 }
 function install_TDengine() {
 	cd ${script_dir}
 	tar zxf $1
  temp_version=$(get_package_name $1)
 	cd $(get_package_name $1)
  echo -e "\033[32muninstall TDengine && install TDengine...\033[0m"
 	rmtaos >/dev/null 2>&1 || echo 'taosd not installed' && echo -e '\n\n' |./install.sh >/dev/null 2>&1 
  echo -e "\033[32mTDengine has been installed!\033[0m"
  echo -e "\033[32mTDengine is starting...\033[0m"
  kill_process taos && systemctl start taosd && sleep 10
 }
 function test_TDengine() {
    check_main_path
    check_bin_path
    check_lib_path
    check_header_path
    check_config_dir
    check_log_path
    check_data_path
    result=`taos -s 'create database test ;create table test.tt(ts timestamp ,i int);insert into test.tt values(now,11);select * from test.tt' 2>&1 ||:`
    if [[ $result =~ "Unable to establish" ]];then
        echo -e "\033[31mTDengine connect failed\033[0m" 
        fin_result=$fin_result"\033[31m$temp_version\033[0m test failed!\n"
        echo -e $fin_result
        exit 8 
    fi  
    echo -e "Check TDengine connect:\033[32mOK\033[0m!"
    fin_result=$fin_result"\033[32m$temp_version\033[0m test OK!\n"
 } 
 # ## ==============================Main program starts from here============================
 TD_package_name=`ls ${script_dir}/*server*gz |awk -F '/' '{print $NF}' `
 temp=`pwd`
 for i in $TD_package_name;do
 	if [[ $i =~ 'enterprise' ]];then
 		verMode="cluster"
 	else
 		verMode=""
 	fi
  cd $temp
 	install_TDengine $i
 	test_TDengine
 done
 echo "============================================================"
 echo -e $fin_result
--- a/src/balance/src/bnMain.c
+++ b/src/balance/src/bnMain.c
@ -367,6 +367,7 @@ static bool bnMonitorBalance() {
        for (int32_t dest = 0; dest < src; dest++) {
          SDnodeObj *pDestDnode = tsBnDnodes.list[dest];
          if (bnCheckDnodeInVgroup(pDestDnode, pVgroup)) continue;
          if (taosGetTimestampMs() - pDestDnode->createdTime < 2000) continue;
          float destScore = bnTryCalcDnodeScore(pDestDnode, 1);
          if (srcScore + 0.0001 < destScore) continue;
--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@ -123,7 +123,8 @@ int32_t tscGetDataBlockFromList(SHashObj* pHashList, int64_t id, int32_t size, i
 */
 bool tscIsPointInterpQuery(SQueryInfo* pQueryInfo);
 bool tscIsTWAQuery(SQueryInfo* pQueryInfo);
-bool tscIsDiffQuery(SQueryInfo* pQueryInfo);
+bool tscIsIrateQuery(SQueryInfo* pQueryInfo);
 bool tscIsSessionWindowQuery(SQueryInfo* pQueryInfo);
 bool tscIsSecondStageQuery(SQueryInfo* pQueryInfo);
 bool tsIsArithmeticQueryOnAggResult(SQueryInfo* pQueryInfo);
--- a/src/client/jni/com_taosdata_jdbc_TSDBJNIConnector.h
+++ b/src/client/jni/com_taosdata_jdbc_TSDBJNIConnector.h
@ -51,10 +51,10 @@ JNIEXPORT jstring JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getTsCharset
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
- * Method:    getResultTimePrecision
+ * Method:    getResultTimePrecisionImp
- * Signature: (J)J
+ * Signature: (JJ)I
 */
-JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TDDBJNIConnector_getResultTimePrecision
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TDDBJNIConnector_getResultTimePrecisionImp
        (JNIEnv *, jobject, jlong, jlong);
 /*
--- a/src/client/src/TSDBJNIConnector.c
+++ b/src/client/src/TSDBJNIConnector.c
@ -113,7 +113,7 @@ static void jniGetGlobalMethod(JNIEnv *env) {
  g_rowdataSetFloatFp = (*env)->GetMethodID(env, g_rowdataClass, "setFloat", "(IF)V");
  g_rowdataSetDoubleFp = (*env)->GetMethodID(env, g_rowdataClass, "setDouble", "(ID)V");
  g_rowdataSetStringFp = (*env)->GetMethodID(env, g_rowdataClass, "setString", "(ILjava/lang/String;)V");
-  g_rowdataSetTimestampFp = (*env)->GetMethodID(env, g_rowdataClass, "setTimestamp", "(IJ)V");
+  g_rowdataSetTimestampFp = (*env)->GetMethodID(env, g_rowdataClass, "setTimestamp", "(IJI)V");
  g_rowdataSetByteArrayFp = (*env)->GetMethodID(env, g_rowdataClass, "setByteArray", "(I[B)V");
  (*env)->DeleteLocalRef(env, rowdataClass);
@ -519,9 +519,11 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_fetchRowImp(JNIEn
                               jniFromNCharToByteArray(env, (char *)row[i], length[i]));
        break;
      }
-      case TSDB_DATA_TYPE_TIMESTAMP:
+      case TSDB_DATA_TYPE_TIMESTAMP: {
-        (*env)->CallVoidMethod(env, rowobj, g_rowdataSetTimestampFp, i, (jlong) * ((int64_t *)row[i]));
+        int precision = taos_result_precision(result);
        (*env)->CallVoidMethod(env, rowobj, g_rowdataSetTimestampFp, i, (jlong) * ((int64_t *)row[i]), precision);
        break;
      }
      default:
        break;
    }
@ -672,7 +674,15 @@ JNIEXPORT jstring JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getTsCharset(J
  return (*env)->NewStringUTF(env, (const char *)tsCharset);
 }
-JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TDDBJNIConnector_getResultTimePrecision(JNIEnv *env, jobject jobj, jlong con,
+/**
 * Get Result Time Precision
 * @param env           vm
 * @param jobj          the TSDBJNIConnector java object
 * @param con           the c connection pointer
 * @param res           the TAOS_RES object, i.e. the SSqlObject
 * @return precision    0:ms 1:us 2:ns
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getResultTimePrecisionImp(JNIEnv *env, jobject jobj, jlong con,
                                                                                      jlong res) {
  TAOS *tscon = (TAOS *)con;
  if (tscon == NULL) {
--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@ -906,7 +906,7 @@ static int insertStmtBindParam(STscStmt* stmt, TAOS_BIND* bind) {
    int code = doBindParam(pBlock, data, param, &bind[param->idx], 1);
    if (code != TSDB_CODE_SUCCESS) {
-      tscDebug("0x%"PRIx64" bind column %d: type mismatch or invalid", pStmt->pSql->self, param->idx);      
+      tscDebug("0x%"PRIx64" bind column %d: type mismatch or invalid", pStmt->pSql->self, param->idx);
      return invalidOperationMsg(tscGetErrorMsgPayload(&stmt->pSql->cmd), "bind column type mismatch or invalid");
    }
  }
@ -1256,7 +1256,7 @@ int stmtParseInsertTbTags(SSqlObj* pSql, STscStmt* pStmt) {
      return TSDB_CODE_SUCCESS;
    }
-    if (sToken.n <= 0 || sToken.type != TK_USING) {      
+    if (sToken.n <= 0 || sToken.type != TK_USING) {
      tscError("keywords USING is expected, sql:%s", pCmd->insertParam.sql);
      return tscSQLSyntaxErrMsg(pCmd->payload, "keywords USING is expected", sToken.z ? sToken.z : pCmd->insertParam.sql);
    }
@ -1403,7 +1403,7 @@ int stmtGenInsertStatement(SSqlObj* pSql, STscStmt* pStmt, const char* name, TAO
  } else {
    tfree(pSql->sqlstr);
  }
-  
+
  pSql->sqlstr = str;
  return TSDB_CODE_SUCCESS;
@ -1415,7 +1415,7 @@ int stmtGenInsertStatement(SSqlObj* pSql, STscStmt* pStmt, const char* name, TAO
 TAOS_STMT* taos_stmt_init(TAOS* taos) {
  STscObj* pObj = (STscObj*)taos;
  STscStmt* pStmt = NULL;
-  
+
  if (pObj == NULL || pObj->signature != pObj) {
    terrno = TSDB_CODE_TSC_DISCONNECTED;
    tscError("connection disconnected");
@ -1469,7 +1469,7 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
    tscError("sql is NULL");
    STMT_RET(invalidOperationMsg(tscGetErrorMsgPayload(&pStmt->pSql->cmd), "sql is NULL"));
  }
-  
+
  if (pStmt->last != STMT_INIT) {
    tscError("prepare status error, last:%d", pStmt->last);
    STMT_RET(invalidOperationMsg(tscGetErrorMsgPayload(&pStmt->pSql->cmd), "prepare status error"));
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@ -148,16 +148,16 @@ int16_t getNewResColId(SSqlCmd* pCmd) {
  return pCmd->resColumnId--;
 }
-// serialize expr in exprlist to binary 
+// serialize expr in exprlist to binary
 // formate  "type | size | value"
 bool serializeExprListToVariant(SArray* pList, tVariant **dst, int16_t colType, uint8_t precision) {
  bool ret = false;
  if (!pList || pList->size <= 0 || colType < 0) {
    return ret;
-  }  
+  }
-  
+
-  tSqlExprItem* item = (tSqlExprItem *)taosArrayGet(pList, 0); 
+  tSqlExprItem* item = (tSqlExprItem *)taosArrayGet(pList, 0);
-  int32_t firstTokenType = item->pNode->token.type; 
+  int32_t firstTokenType = item->pNode->token.type;
  int32_t type  = firstTokenType;
  //nchar to binary and other xxint to bigint  
@ -170,12 +170,13 @@ bool serializeExprListToVariant(SArray* pList, tVariant **dst, int16_t colType,
  type = colType; 
  SBufferWriter bw = tbufInitWriter( NULL, false);
  tbufEnsureCapacity(&bw, 512);
  int32_t size = (int32_t)(pList->size);
-  tbufWriteUint32(&bw, type);  
+  tbufWriteUint32(&bw, type);
  tbufWriteInt32(&bw,  size);
-   
+
  for (int32_t i = 0; i < size; i++) {
    tSqlExpr* pSub = ((tSqlExprItem*)(taosArrayGet(pList, i)))->pNode;
@ -203,11 +204,11 @@ bool serializeExprListToVariant(SArray* pList, tVariant **dst, int16_t colType,
    } else if (type == TSDB_DATA_TYPE_BINARY){
      tbufWriteBinary(&bw, var.pz, var.nLen);
    } else if (type == TSDB_DATA_TYPE_NCHAR) {
-      char   *buf = (char *)calloc(1, (var.nLen + 1)*TSDB_NCHAR_SIZE);       
+      char   *buf = (char *)calloc(1, (var.nLen + 1)*TSDB_NCHAR_SIZE);
      if (tVariantDump(&var, buf, type, false) != TSDB_CODE_SUCCESS) {
        free(buf);
        tVariantDestroy(&var);
-        break;  
+        break;
      }
      tbufWriteBinary(&bw, buf, twcslen((wchar_t *)buf) * TSDB_NCHAR_SIZE);
      free(buf);
@ -229,21 +230,21 @@ bool serializeExprListToVariant(SArray* pList, tVariant **dst, int16_t colType,
  if (ret == true) {
    if ((*dst = calloc(1, sizeof(tVariant))) != NULL) {
-      tVariantCreateFromBinary(*dst, tbufGetData(&bw, false), tbufTell(&bw), TSDB_DATA_TYPE_BINARY);    
+      tVariantCreateFromBinary(*dst, tbufGetData(&bw, false), tbufTell(&bw), TSDB_DATA_TYPE_BINARY);
    } else {
      ret = false;
    }
  }
-  tbufCloseWriter(&bw); 
+  tbufCloseWriter(&bw);
  return ret;
 }
 static int32_t validateParamOfRelationIn(tVariant *pVar, int32_t colType) {
  if (pVar->nType != TSDB_DATA_TYPE_BINARY) {
-    return -1; 
+    return -1;
  }
-  SBufferReader br = tbufInitReader(pVar->pz, pVar->nLen, false); 
+  SBufferReader br = tbufInitReader(pVar->pz, pVar->nLen, false);
-  return colType == TSDB_DATA_TYPE_NCHAR ?  0 : (tbufReadUint32(&br) == colType ? 0: -1);     
+  return colType == TSDB_DATA_TYPE_NCHAR ?  0 : (tbufReadUint32(&br) == colType ? 0: -1);
 }
 static uint8_t convertOptr(SStrToken *pToken) {
@ -447,18 +448,6 @@ int32_t tscValidateSqlInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
        if(code != TSDB_CODE_SUCCESS) {
          return code; 
        }
        if (pInfo->pMiscInfo->tableType == TSDB_SUPER_TABLE) {
 ////          code = tscGetTableMeta(pSql, pTableMetaInfo);
 ////          if (code != TSDB_CODE_SUCCESS) {
 ////            return code;
 ////          }
 //
 //          if (!UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
 //            return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
 //          }
        }
      } else if (pInfo->type == TSDB_SQL_DROP_DNODE) {
        if (pzName->type == TK_STRING) {
          pzName->n = strdequote(pzName->z);
@ -531,7 +520,7 @@ int32_t tscValidateSqlInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
      break;
    }
-  
+
    case TSDB_SQL_CREATE_DNODE: {
      const char* msg = "invalid host name (ip address)";
@ -796,6 +785,11 @@ int32_t tscValidateSqlInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
      pCmd->active = pCmd->pQueryInfo;
      pCmd->command = pCmd->pQueryInfo->command;
      STableMetaInfo* pTableMetaInfo1 = tscGetMetaInfo(pCmd->active, 0);
      if (pTableMetaInfo1->pTableMeta != NULL) {
        pSql->res.precision = tscGetTableInfo(pTableMetaInfo1->pTableMeta).precision;
      }
      return TSDB_CODE_SUCCESS;  // do not build query message here
    }
@ -827,12 +821,12 @@ int32_t tscValidateSqlInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
      }
      break;
    }
-    case TSDB_SQL_COMPACT_VNODE:{ 
+    case TSDB_SQL_COMPACT_VNODE:{
      const char* msg = "invalid compact";
      if (setCompactVnodeInfo(pSql, pInfo) != TSDB_CODE_SUCCESS) {
        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
-      }                            
+      }
-      break;                             
+      break;
    }
    default:
      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), "not support sql expression");
@ -980,20 +974,22 @@ int32_t validateIntervalNode(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNode* pS
 static int32_t validateStateWindowNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSqlNode, bool isStable) {
  const char* msg1 = "invalid column name";
  const char* msg2 = "invalid column type";
  const char* msg3 = "not support state_window with group by ";
  const char* msg4 = "function not support for super table query";
  const char* msg5 = "not support state_window on tag column";
  SStrToken *col = &(pSqlNode->windowstateVal.col) ;
  if (col->z == NULL || col->n <= 0) {
-    return TSDB_CODE_SUCCESS; 
+    return TSDB_CODE_SUCCESS;
-  } 
+  }
  if (pQueryInfo->colList == NULL) {
    pQueryInfo->colList = taosArrayInit(4, POINTER_BYTES);
  }
  if (pQueryInfo->groupbyExpr.numOfGroupCols > 0) {
    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
-  } 
+  }
  pQueryInfo->groupbyExpr.numOfGroupCols = 1;
  //TODO(dengyihao): check tag column
@ -1004,23 +1000,27 @@ static int32_t validateStateWindowNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SS
  SColumnIndex index = COLUMN_INDEX_INITIALIZER;
  if (getColumnIndexByName(pCmd, col, pQueryInfo, &index) !=  TSDB_CODE_SUCCESS) {
    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
-  } 
+  }
  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
  STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
  int32_t numOfCols = tscGetNumOfColumns(pTableMeta);
-  if (index.columnIndex == TSDB_TBNAME_COLUMN_INDEX || index.columnIndex >= numOfCols) {
+  if (index.columnIndex == TSDB_TBNAME_COLUMN_INDEX) {
    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
  } else if (index.columnIndex >= numOfCols) {
    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
  }
  SGroupbyExpr* pGroupExpr = &pQueryInfo->groupbyExpr;
  if (pGroupExpr->columnInfo == NULL) {
    pGroupExpr->columnInfo = taosArrayInit(4, sizeof(SColIndex));
  }
-  
+
  SSchema* pSchema = tscGetTableColumnSchema(pTableMeta, index.columnIndex);
-  if (pSchema->type == TSDB_DATA_TYPE_TIMESTAMP || pSchema->type == TSDB_DATA_TYPE_FLOAT || pSchema->type == TSDB_DATA_TYPE_DOUBLE) {
+  if (pSchema->type == TSDB_DATA_TYPE_TIMESTAMP || pSchema->type == TSDB_DATA_TYPE_FLOAT 
-    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      || pSchema->type == TSDB_DATA_TYPE_DOUBLE || pSchema->type == TSDB_DATA_TYPE_NCHAR
      || pSchema->type == TSDB_DATA_TYPE_BINARY) {
    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
  }
  tscColumnListInsert(pQueryInfo->colList, index.columnIndex, pTableMeta->id.uid, pSchema);
@ -1069,7 +1069,7 @@ int32_t validateSessionNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode * pS
  }
  if (index.columnIndex != PRIMARYKEY_TIMESTAMP_COL_INDEX) {
    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
-  } 
+  }
  pQueryInfo->sessionWindow.primaryColId = PRIMARYKEY_TIMESTAMP_COL_INDEX;
@ -1819,7 +1819,6 @@ int32_t validateSelectNodeList(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pS
  assert(pSelNodeList != NULL && pCmd != NULL);
  const char* msg1 = "too many items in selection clause";
  const char* msg2 = "functions or others can not be mixed up";
  const char* msg3 = "not support query expression";
  const char* msg4 = "only support distinct one tag";
@ -2047,8 +2046,10 @@ int32_t addProjectionExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, t
    if (index.columnIndex == TSDB_TBNAME_COLUMN_INDEX) {
      SSchema colSchema = *tGetTbnameColumnSchema();
-      getColumnName(pItem, colSchema.name, colSchema.name, sizeof(colSchema.name) - 1);
+      char name[TSDB_COL_NAME_LEN] = {0};
      getColumnName(pItem, name, colSchema.name, sizeof(colSchema.name) - 1);
      tstrncpy(colSchema.name, name, TSDB_COL_NAME_LEN);
      /*SExprInfo* pExpr = */tscAddFuncInSelectClause(pQueryInfo, startPos, TSDB_FUNC_TAGPRJ, &index, &colSchema, TSDB_COL_TAG, getNewResColId(pCmd));
    } else {
      STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
@ -2362,7 +2363,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
          tickPerSec /= 1000000;
        } else if (info.precision == TSDB_TIME_PRECISION_MICRO) {
          tickPerSec /= 1000;
-	} 
+	}
        if (tickPerSec <= 0 || tickPerSec < TSDB_TICK_PER_SECOND(info.precision)) {
          return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg10);
@ -2748,6 +2749,8 @@ void getColumnName(tSqlExprItem* pItem, char* resultFieldName, char* rawName, in
  strncpy(rawName, pItem->pNode->token.z, len);
  if (pItem->aliasName != NULL) {
    int32_t aliasNameLen = (int32_t) strlen(pItem->aliasName);
    len = (aliasNameLen < nameLength)? aliasNameLen:nameLength;
    strncpy(resultFieldName, pItem->aliasName, len);
  } else {
    strncpy(resultFieldName, rawName, len);
@ -2997,7 +3000,7 @@ int32_t setKillInfo(SSqlObj* pSql, struct SSqlInfo* pInfo, int32_t killType) {
 static int32_t setCompactVnodeInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
  SSqlCmd* pCmd = &pSql->cmd;
  pCmd->command = pInfo->type;
-  
+
  return TSDB_CODE_SUCCESS;
 }
 bool validateIpAddress(const char* ip, size_t size) {
@ -3085,8 +3088,8 @@ void tscRestoreFuncForSTableQuery(SQueryInfo* pQueryInfo) {
 }
 bool hasUnsupportFunctionsForSTableQuery(SSqlCmd* pCmd, SQueryInfo* pQueryInfo) {
-  const char* msg1 = "TWA/Diff not allowed to apply to super table directly";
+  const char* msg1 = "TWA/Diff/Derivative/Irate not allowed to apply to super table directly";
-  const char* msg2 = "TWA/Diff only support group by tbname for super table query";
+  const char* msg2 = "TWA/Diff/Derivative/Irate only support group by tbname for super table query";
  const char* msg3 = "function not support for super table query";
  // filter sql function not supported by metric query yet.
@ -3099,7 +3102,7 @@ bool hasUnsupportFunctionsForSTableQuery(SSqlCmd* pCmd, SQueryInfo* pQueryInfo)
    }
  }
-  if (tscIsTWAQuery(pQueryInfo) || tscIsDiffQuery(pQueryInfo)) {
+  if (tscIsTWAQuery(pQueryInfo) || tscIsDiffDerivQuery(pQueryInfo) || tscIsIrateQuery(pQueryInfo)) {
    if (pQueryInfo->groupbyExpr.numOfGroupCols == 0) {
      invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
      return true;
@ -3117,7 +3120,7 @@ bool hasUnsupportFunctionsForSTableQuery(SSqlCmd* pCmd, SQueryInfo* pQueryInfo)
    }
  } else if (tscIsSessionWindowQuery(pQueryInfo)) {
    invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
-    return true; 
+    return true;
  }
  return false;
@ -3360,12 +3363,11 @@ static int32_t doExtractColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo,
  // TK_GT,TK_GE,TK_EQ,TK_NE are based on the pColumn->lowerBndd
  } else if (pExpr->tokenId == TK_IN) {
    tVariant *pVal; 
    if (pRight->tokenId != TK_SET || !serializeExprListToVariant(pRight->pParam, &pVal, colType, timePrecision)) {
      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
-    }         
+    }
    if (validateParamOfRelationIn(pVal, colType) != TSDB_CODE_SUCCESS) {
-      tVariantDestroy(pVal); 
+      tVariantDestroy(pVal);
      free(pVal);
      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
    }
@ -3374,9 +3376,9 @@ static int32_t doExtractColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo,
    pColumnFilter->filterstr = 1;
    memcpy((char *)(pColumnFilter->pz), (char *)(pVal->pz), pVal->nLen);  
-    tVariantDestroy(pVal); 
+    tVariantDestroy(pVal);
    free(pVal);
-     
+
  } else if (colType == TSDB_DATA_TYPE_BINARY) {
    pColumnFilter->pz = (int64_t)calloc(1, bufLen * TSDB_NCHAR_SIZE);
    pColumnFilter->len = pRight->value.nLen;
@ -4907,7 +4909,7 @@ int32_t getTimeRange(STimeWindow* win, tSqlExpr* pRight, int32_t optr, int16_t t
    if (pRight->flags & (1 << EXPR_FLAG_NS_TIMESTAMP)) {
      pRight->value.i64 = convertTimePrecision(pRight->value.i64, TSDB_TIME_PRECISION_NANO, timePrecision);
    }
-    
+
    tVariantDump(&pRight->value, (char*)&val, TSDB_DATA_TYPE_BIGINT, true);
  }
@ -5565,7 +5567,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
    if (pItem->type != TSDB_DATA_TYPE_BINARY && pItem->type != TSDB_DATA_TYPE_NCHAR) {
      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg21);
    }
-    
+
    SColumnIndex columnIndex = COLUMN_INDEX_INITIALIZER;
    SStrToken    name = {.type = TK_STRING, .z = pItem->name, .n = (uint32_t)strlen(pItem->name)};
    if (getColumnIndexByName(pCmd, &name, pQueryInfo, &columnIndex) != TSDB_CODE_SUCCESS) {
@ -5586,11 +5588,11 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
        (pItem->type == TSDB_DATA_TYPE_NCHAR && (pItem->bytes <= 0 || pItem->bytes > TSDB_MAX_NCHAR_LEN))) {
      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg24);
    }
-        
+
    if (pItem->bytes <= pColSchema->bytes) {
      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg22);
    }
-    
+
    TAOS_FIELD f = tscCreateField(pColSchema->type, name.z, pItem->bytes);
    tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
  }else if (pAlterSQL->type == TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN) {
@ -5602,7 +5604,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
    if (pItem->type != TSDB_DATA_TYPE_BINARY && pItem->type != TSDB_DATA_TYPE_NCHAR) {
      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg21);
    }
-    
+
    SColumnIndex columnIndex = COLUMN_INDEX_INITIALIZER;
    SStrToken    name = {.type = TK_STRING, .z = pItem->name, .n = (uint32_t)strlen(pItem->name)};
    if (getColumnIndexByName(pCmd, &name, pQueryInfo, &columnIndex) != TSDB_CODE_SUCCESS) {
@ -5627,11 +5629,11 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
        (pItem->type == TSDB_DATA_TYPE_NCHAR && (pItem->bytes <= 0 || pItem->bytes > TSDB_MAX_NCHAR_LEN))) {
      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg24);
    }
-        
+
    if (pItem->bytes <= pColSchema->bytes) {
      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg22);
    }
-    
+
    TAOS_FIELD f = tscCreateField(pColSchema->type, name.z, pItem->bytes);
    tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
  }
@ -5997,7 +5999,7 @@ static int32_t setKeepOption(SSqlCmd* pCmd, SCreateDbMsg* pMsg, SCreateDbInfo* p
    tVariantListItem* p0 = taosArrayGet(pKeep, 0);
    tVariantListItem* p1 = (s > 1) ? taosArrayGet(pKeep, 1) : p0;
    tVariantListItem* p2 = (s > 2) ? taosArrayGet(pKeep, 2) : p1;
-    
+
    if ((int32_t)p0->pVar.i64 <= 0 || (int32_t)p1->pVar.i64 <= 0 || (int32_t)p2->pVar.i64 <= 0) {
      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
    }
@ -7111,7 +7113,7 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) {
  } else {
    if (pQueryInfo->interval.interval == 0) {
      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg7);
-    }  
+    }
  }
  // set the created table[stream] name
@ -7784,6 +7786,7 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
  const char* msg4 = "interval query not supported, since the result of sub query not include valid timestamp column";
  const char* msg5 = "only tag query not compatible with normal column filter";
  const char* msg6 = "not support stddev/percentile in outer query yet";
  const char* msg7 = "drivative requires timestamp column exists in subquery";
  int32_t code = TSDB_CODE_SUCCESS;
@ -7833,11 +7836,27 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
      }
    }
    // todo derivative function requires ts column exists in subquery
    STableMeta* pTableMeta = tscGetMetaInfo(pQueryInfo, 0)->pTableMeta;
    SSchema* pSchema = tscGetTableColumnSchema(pTableMeta, 0);
    if (tscNumOfExprs(pQueryInfo) > 1) {
      SExprInfo* pExpr = tscExprGet(pQueryInfo, 1);
      if (pExpr->base.functionId == TSDB_FUNC_DERIVATIVE && pSchema->type != TSDB_DATA_TYPE_TIMESTAMP) {
        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg7);
      }
    }
    // validate the query filter condition info
    if (pSqlNode->pWhere != NULL) {
      if (validateWhereNode(pQueryInfo, &pSqlNode->pWhere, pSql) != TSDB_CODE_SUCCESS) {
        return TSDB_CODE_TSC_INVALID_OPERATION;
      }
      if (pTableMeta->tableInfo.precision == TSDB_TIME_PRECISION_MILLI) {
        pQueryInfo->window.skey = pQueryInfo->window.skey / 1000;
        pQueryInfo->window.ekey = pQueryInfo->window.ekey / 1000;
      }
    }
    // validate the interval info
@ -7858,7 +7877,6 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
    }
    // set order by info
    STableMeta* pTableMeta = tscGetMetaInfo(pQueryInfo, 0)->pTableMeta;
    if (validateOrderbyNode(pCmd, pQueryInfo, pSqlNode, tscGetTableSchema(pTableMeta)) != TSDB_CODE_SUCCESS) {
      return TSDB_CODE_TSC_INVALID_OPERATION;
    }
@ -7911,7 +7929,7 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
        TSDB_CODE_SUCCESS) {
      return TSDB_CODE_TSC_INVALID_OPERATION;
    }
-    // parse the window_state 
+    // parse the window_state
    if (validateStateWindowNode(pCmd, pQueryInfo, pSqlNode, isSTable) != TSDB_CODE_SUCCESS) {
      return TSDB_CODE_TSC_INVALID_OPERATION;
    }
@ -8009,7 +8027,6 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
    pQueryInfo->arithmeticOnAgg   = tsIsArithmeticQueryOnAggResult(pQueryInfo);
    pQueryInfo->orderProjectQuery = tscOrderedProjectionQueryOnSTable(pQueryInfo, 0);
 //    pQueryInfo->diffQuery         = tscIsDiffQuery(pQueryInfo);
    SExprInfo** p = NULL;
    int32_t numOfExpr = 0;
@ -8137,7 +8154,7 @@ int32_t exprTreeFromSqlExpr(SSqlCmd* pCmd, tExprNode **pExpr, const tSqlExpr* pS
        SColIndex* idx = taosArrayGet(pCols, 0);
        SSchema* pSchema = tscGetTableColumnSchema(pTableMeta, idx->colIndex);
        if (pSchema != NULL) {
-          colType = pSchema->type; 
+          colType = pSchema->type;
        }
      }
      tVariant *pVal;
--- a/src/client/src/tscSub.c
+++ b/src/client/src/tscSub.c
@ -283,6 +283,7 @@ static int tscUpdateSubscription(STscObj* pObj, SSub* pSub) {
  SArray* tables = getTableList(pSql);
  if (tables == NULL) {
    pSub->lastSyncTime = 0;   //force to get table list next time
    return 0;
  }
  size_t numOfTables = taosArrayGetSize(tables);
@ -489,7 +490,15 @@ TAOS_RES *taos_consume(TAOS_SUB *tsub) {
  SSub *pSub = (SSub *)tsub;
  if (pSub == NULL) return NULL;
-  if (pSub->pSql->cmd.command == TSDB_SQL_RETRIEVE_EMPTY_RESULT) {
+  if (pSub->pTimer == NULL) {
    int64_t duration = taosGetTimestampMs() - pSub->lastConsumeTime;
    if (duration < (int64_t)(pSub->interval)) {
      tscDebug("subscription consume too frequently, blocking...");
      taosMsleep(pSub->interval - (int32_t)duration);
    }
  }
  if (pSub->pSql->cmd.command == TSDB_SQL_RETRIEVE_EMPTY_RESULT) {  //may reach here when retireve stable vgroup failed
    SSqlObj* pSql = recreateSqlObj(pSub);
    if (pSql == NULL) {
      return NULL;
@ -503,6 +512,11 @@ TAOS_RES *taos_consume(TAOS_SUB *tsub) {
    pSub->pSql = pSql;
    pSql->pSubscription = pSub;
    // no table list now, force to update it
    tscDebug("begin table synchronization");
    if (!tscUpdateSubscription(pSub->taos, pSub)) return NULL;
    tscDebug("table synchronization completed");    
  }
  tscSaveSubscriptionProgress(pSub);
@ -527,14 +541,6 @@ TAOS_RES *taos_consume(TAOS_SUB *tsub) {
    tscDebug("subscribe:%s set next round subscribe skey:%"PRId64, pSub->topic, pQueryInfo->window.skey);
  }
  if (pSub->pTimer == NULL) {
    int64_t duration = taosGetTimestampMs() - pSub->lastConsumeTime;
    if (duration < (int64_t)(pSub->interval)) {
      tscDebug("subscription consume too frequently, blocking...");
      taosMsleep(pSub->interval - (int32_t)duration);
    }
  }
  size_t size = taosArrayGetSize(pSub->progress) * sizeof(STableIdInfo);
  size += sizeof(SQueryTableMsg) + 4096;
  int code = tscAllocPayload(&pSql->cmd, (int)size);
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@ -109,7 +109,7 @@ bool subAndCheckDone(SSqlObj *pSql, SSqlObj *pParentSql, int idx) {
 //    pthread_mutex_unlock(&subState->mutex);
 //    return false;
 //  }
-  
+
  tscDebug("0x%"PRIx64" subquery:0x%"PRIx64", index:%d state set to 1", pParentSql->self, pSql->self, idx);
  subState->states[idx] = 1;
@ -622,7 +622,7 @@ static int32_t tscLaunchRealSubqueries(SSqlObj* pSql) {
      int16_t colId = tscGetJoinTagColIdByUid(&pQueryInfo->tagCond, pTableMetaInfo->pTableMeta->id.uid);
      // set the tag column id for executor to extract correct tag value
-#ifndef _TD_NINGSI_60      
+#ifndef _TD_NINGSI_60
      pExpr->base.param[0] = (tVariant) {.i64 = colId, .nType = TSDB_DATA_TYPE_BIGINT, .nLen = sizeof(int64_t)};
 #else
      pExpr->base.param[0].i64 = colId;
@ -1843,7 +1843,7 @@ int32_t tscCreateJoinSubquery(SSqlObj *pSql, int16_t tableIndex, SJoinSupporter
    // refactor as one method
    SQueryInfo *pNewQueryInfo = tscGetQueryInfo(&pNew->cmd);
    assert(pNewQueryInfo != NULL);
-    
+
    pSupporter->colList = pNewQueryInfo->colList;
    pNewQueryInfo->colList = NULL;
@ -3158,7 +3158,7 @@ int32_t tscHandleMultivnodeInsert(SSqlObj *pSql) {
      pRes->code = TSDB_CODE_TSC_APP_ERROR;
      return pRes->code;
    }
-    
+
    for(int32_t i = 0; i < pSql->subState.numOfSub; ++i) {
      SSqlObj* pSub = pSql->pSubs[i];
      SInsertSupporter* pSup = calloc(1, sizeof(SInsertSupporter));
--- a/src/client/src/tscSystem.c
+++ b/src/client/src/tscSystem.c
@ -288,16 +288,24 @@ static int taos_options_imp(TSDB_OPTION option, const char *pStr) {
        if (strlen(tsLocale) == 0) { // locale does not set yet
          char* defaultLocale = setlocale(LC_CTYPE, "");
          // The locale of the current OS does not be set correctly, so the default locale cannot be acquired.
          // The launch of current system will abort soon.
          if (defaultLocale == NULL) {
            tscError("failed to get default locale, please set the correct locale in current OS");
            return -1;
          }
          tstrncpy(tsLocale, defaultLocale, TSDB_LOCALE_LEN);
        }
        // set the user specified locale
        char *locale = setlocale(LC_CTYPE, pStr);
-        if (locale != NULL) {
+        if (locale != NULL) { // failed to set the user specified locale
          tscInfo("locale set, prev locale:%s, new locale:%s", tsLocale, locale);
          cfg->cfgStatus = TAOS_CFG_CSTATUS_OPTION;
-        } else { // set the user-specified localed failed, use default LC_CTYPE as current locale
+        } else { // set the user specified locale failed, use default LC_CTYPE as current locale
          locale = setlocale(LC_CTYPE, tsLocale);
          tscInfo("failed to set locale:%s, current locale:%s", pStr, tsLocale);
        }
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@ -460,17 +460,15 @@ bool tscIsTWAQuery(SQueryInfo* pQueryInfo) {
  return false;
 }
-bool tscIsDiffQuery(SQueryInfo* pQueryInfo) {
+bool tscIsIrateQuery(SQueryInfo* pQueryInfo) {
-  size_t num = tscNumOfExprs(pQueryInfo);
+  size_t numOfExprs = tscNumOfExprs(pQueryInfo);
-  for(int32_t i = 0; i < num; ++i) {
+  for (int32_t i = 0; i < numOfExprs; ++i) {
    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
-
+    if (pExpr == NULL) {
    int32_t f = pExpr->base.functionId;
    if (pExpr == NULL || f == TSDB_FUNC_TS_DUMMY) {
      continue;
    }
-    if (f == TSDB_FUNC_DIFF || f == TSDB_FUNC_DERIVATIVE) {
+    if (pExpr->base.functionId == TSDB_FUNC_IRATE) {
      return true;
    }
  }
@ -516,7 +514,7 @@ bool isSimpleAggregateRv(SQueryInfo* pQueryInfo) {
    return false;
  }
-  if (tscIsDiffQuery(pQueryInfo)) {
+  if (tscIsDiffDerivQuery(pQueryInfo)) {
    return false;
  }
@ -3495,6 +3493,7 @@ static void tscSubqueryRetrieveCallback(void* param, TAOS_RES* tres, int code) {
  if (pSql->res.code == TSDB_CODE_SUCCESS) {
    (*pSql->fp)(pParentSql->param, pParentSql, pParentSql->res.numOfRows);
  } else {
    pParentSql->res.code = pSql->res.code;
    tscAsyncResultOnError(pParentSql);
  }
 }
@ -4260,7 +4259,7 @@ int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAt
  pQueryAttr->hasTagResults     = hasTagValOutput(pQueryInfo);
  pQueryAttr->stabledev         = isStabledev(pQueryInfo);
  pQueryAttr->tsCompQuery       = isTsCompQuery(pQueryInfo);
-  pQueryAttr->diffQuery         = tscIsDiffQuery(pQueryInfo);
+  pQueryAttr->diffQuery         = tscIsDiffDerivQuery(pQueryInfo);
  pQueryAttr->simpleAgg         = isSimpleAggregateRv(pQueryInfo);
  pQueryAttr->needReverseScan   = tscNeedReverseScan(pQueryInfo);
  pQueryAttr->stableQuery       = QUERY_IS_STABLE_QUERY(pQueryInfo->type);
--- a/src/client/tests/CMakeLists.txt
+++ b/src/client/tests/CMakeLists.txt
@ -7,7 +7,12 @@ FIND_LIBRARY(LIB_GTEST_STATIC_DIR libgtest.a /usr/lib/ /usr/local/lib)
 IF (HEADER_GTEST_INCLUDE_DIR AND LIB_GTEST_STATIC_DIR)
    MESSAGE(STATUS "gTest library found, build unit test")
-    INCLUDE_DIRECTORIES(${HEADER_GTEST_INCLUDE_DIR})
+    # GoogleTest requires at least C++11
    SET(CMAKE_CXX_STANDARD 11)
    INCLUDE_DIRECTORIES(/usr/include /usr/local/include)
    LINK_DIRECTORIES(/usr/lib /usr/local/lib)
    AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SOURCE_LIST)
    ADD_EXECUTABLE(cliTest ${SOURCE_LIST})
--- a/src/connector/jdbc/CMakeLists.txt
+++ b/src/connector/jdbc/CMakeLists.txt
@ -8,9 +8,8 @@ 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.30.jar ${LIBRARY_OUTPUT_PATH}
+    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/target/taos-jdbcdriver-2.0.31.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})
-ENDIF ()
+ENDIF ()
--- 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.30</version>
+  <version>2.0.31</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.30</version>
+    <version>2.0.31</version>
    <packaging>jar</packaging>
    <name>JDBCDriver</name>
    <url>https://github.com/taosdata/TDengine/tree/master/src/connector/jdbc</url>
@ -122,7 +122,7 @@
                        <exclude>**/FailOverTest.java</exclude>
                        <exclude>**/InvalidResultSetPointerTest.java</exclude>
                        <exclude>**/RestfulConnectionTest.java</exclude>
-                        <exclude>**/TD4144Test.java</exclude>
+                        <exclude>**/ConnectMultiTaosdByRestfulWithDifferentTokenTest.java</exclude>
                    </excludes>
                    <testFailureIgnore>true</testFailureIgnore>
                </configuration>
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractConnection.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractConnection.java
@ -1,5 +1,7 @@
 package com.taosdata.jdbc;
 import com.taosdata.jdbc.rs.enums.TimestampFormat;
 import java.sql.*;
 import java.util.Enumeration;
 import java.util.Map;
@ -18,7 +20,7 @@ public abstract class AbstractConnection extends WrapperImpl implements Connecti
        for (String propName : propNames) {
            clientInfoProps.setProperty(propName, properties.getProperty(propName));
        }
-        String timestampFormat = properties.getProperty(TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT, "STRING");
+        String timestampFormat = properties.getProperty(TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT, String.valueOf(TimestampFormat.STRING));
        clientInfoProps.setProperty(TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT, timestampFormat);
    }
@ -516,7 +518,6 @@ public abstract class AbstractConnection extends WrapperImpl implements Connecti
    public void abort(Executor executor) throws SQLException {
        if (isClosed())
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
        // do nothing
    }
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractStatement.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractStatement.java
@ -9,8 +9,6 @@ public abstract class AbstractStatement extends WrapperImpl implements Statement
    protected List<String> batchedArgs;
    private int fetchSize;
    @Override
    public abstract ResultSet executeQuery(String sql) throws SQLException;
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBError.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBError.java
@ -32,6 +32,7 @@ public class TSDBError {
        TSDBErrorMap.put(TSDBErrorNumbers.ERROR_INVALID_SQL, "invalid sql");
        TSDBErrorMap.put(TSDBErrorNumbers.ERROR_NUMERIC_VALUE_OUT_OF_RANGE, "numeric value out of range");
        TSDBErrorMap.put(TSDBErrorNumbers.ERROR_UNKNOWN_TAOS_TYPE_IN_TDENGINE, "unknown taos type in tdengine");
        TSDBErrorMap.put(TSDBErrorNumbers.ERROR_UNKNOWN_TIMESTAMP_PERCISION, "unknown timestamp precision");
        /**************************************************/
        TSDBErrorMap.put(TSDBErrorNumbers.ERROR_UNKNOWN, "unknown error");
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBErrorNumbers.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBErrorNumbers.java
@ -25,6 +25,7 @@ public class TSDBErrorNumbers {
    public static final int ERROR_INVALID_SQL = 0x2313;     // invalid sql
    public static final int ERROR_NUMERIC_VALUE_OUT_OF_RANGE = 0x2314;  // numeric value out of range
    public static final int ERROR_UNKNOWN_TAOS_TYPE_IN_TDENGINE = 0x2315; //unknown taos type in tdengine
    public static final int ERROR_UNKNOWN_TIMESTAMP_PERCISION = 0x2316;     // unknown timestamp precision
    public static final int ERROR_UNKNOWN = 0x2350;    //unknown error
@ -62,6 +63,7 @@ public class TSDBErrorNumbers {
        errorNumbers.add(ERROR_INVALID_SQL);
        errorNumbers.add(ERROR_NUMERIC_VALUE_OUT_OF_RANGE);
        errorNumbers.add(ERROR_UNKNOWN_TAOS_TYPE_IN_TDENGINE);
        errorNumbers.add(ERROR_UNKNOWN_TIMESTAMP_PERCISION);
        /*****************************************************/
        errorNumbers.add(ERROR_SUBSCRIBE_FAILED);
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBJNIConnector.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBJNIConnector.java
@ -216,6 +216,16 @@ public class TSDBJNIConnector {
    private native int fetchBlockImp(long connection, long resultSet, TSDBResultSetBlockData blockData);
    /**
     * Get Result Time Precision.
     * @return 0: ms, 1: us, 2: ns
    */
    public int getResultTimePrecision(long sqlObj) {
        return this.getResultTimePrecisionImp(this.taos, sqlObj);
    }
    private native int getResultTimePrecisionImp(long connection, long result);
    /**
     * Execute close operation from C to release connection pointer by JNI
     *
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBPreparedStatement.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBPreparedStatement.java
@ -38,7 +38,6 @@ import java.util.regex.Pattern;
 public class TSDBPreparedStatement extends TSDBStatement implements PreparedStatement {
    private String rawSql;
    private Object[] parameters;
    private boolean isPrepared;
    private ArrayList<ColumnInfo> colData;
    private ArrayList<TableTagInfo> tableTags;
@ -47,8 +46,6 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
    private String tableName;
    private long nativeStmtHandle = 0;
    private volatile TSDBParameterMetaData parameterMetaData;
    TSDBPreparedStatement(TSDBConnection connection, String sql) {
        super(connection);
        init(sql);
@ -61,7 +58,6 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
                }
            }
            parameters = new Object[parameterCnt];
            this.isPrepared = true;
        }
        if (parameterCnt > 1) {
@ -76,11 +72,6 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
        preprocessSql();
    }
    @Override
    public int[] executeBatch() throws SQLException {
        return super.executeBatch();
    }
    /*
     * Some of the SQLs sent by other popular frameworks or tools like Spark, contains syntax that cannot be parsed by
     * the TDengine client. Thus, some simple parsers/filters are intentionally added in this JDBC implementation in
@ -137,29 +128,15 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
        /***** for inner queries *****/
    }
    /**
     * Populate parameters into prepared sql statements
     *
     * @return a string of the native sql statement for TSDB
     */
    private String getNativeSql(String rawSql) throws SQLException {
        return Utils.getNativeSql(rawSql, this.parameters);
    }
    @Override
    public ResultSet executeQuery() throws SQLException {
-        if (!isPrepared)
+        final String sql = Utils.getNativeSql(this.rawSql, this.parameters);
            return executeQuery(this.rawSql);
        final String sql = getNativeSql(this.rawSql);
        return executeQuery(sql);
    }
    @Override
    public int executeUpdate() throws SQLException {
-        if (!isPrepared)
+        String sql = Utils.getNativeSql(this.rawSql, this.parameters);
            return executeUpdate(this.rawSql);
        String sql = getNativeSql(this.rawSql);
        return executeUpdate(sql);
    }
@ -282,25 +259,14 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
    @Override
    public boolean execute() throws SQLException {
-        if (!isPrepared)
+        final String sql = Utils.getNativeSql(this.rawSql, this.parameters);
            return execute(this.rawSql);
        final String sql = getNativeSql(this.rawSql);
        return execute(sql);
    }
    @Override
    public void addBatch() throws SQLException {
-        if (this.batchedArgs == null) {
+        String sql = Utils.getNativeSql(this.rawSql, this.parameters);
-            batchedArgs = new ArrayList<>();
+        addBatch(sql);
        }
        if (!isPrepared) {
            addBatch(this.rawSql);
        } else {
            String sql = this.getConnection().nativeSQL(this.rawSql);
            addBatch(sql);
        }
    }
    @Override
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetRowData.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetRowData.java
@ -147,30 +147,14 @@ public class TSDBResultSetRowData {
            case TSDBConstants.TSDB_DATA_TYPE_NCHAR:
            case TSDBConstants.TSDB_DATA_TYPE_BINARY:
                return Integer.parseInt((String) obj);
-            case TSDBConstants.TSDB_DATA_TYPE_UTINYINT: {
+            case TSDBConstants.TSDB_DATA_TYPE_UTINYINT:
-                Byte value = (byte) obj;
+                return parseUnsignedTinyIntToInt(obj);
-                if (value < 0)
+            case TSDBConstants.TSDB_DATA_TYPE_USMALLINT:
-                    throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_NUMERIC_VALUE_OUT_OF_RANGE);
+                return parseUnsignedSmallIntToInt(obj);
-                return value;
+            case TSDBConstants.TSDB_DATA_TYPE_UINT:
-            }
+                return parseUnsignedIntegerToInt(obj);
-            case TSDBConstants.TSDB_DATA_TYPE_USMALLINT: {
+            case TSDBConstants.TSDB_DATA_TYPE_UBIGINT:
-                short value = (short) obj;
+                return parseUnsignedBigIntToInt(obj);
                if (value < 0)
                    throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_NUMERIC_VALUE_OUT_OF_RANGE);
                return value;
            }
            case TSDBConstants.TSDB_DATA_TYPE_UINT: {
                int value = (int) obj;
                if (value < 0)
                    throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_NUMERIC_VALUE_OUT_OF_RANGE);
                return value;
            }
            case TSDBConstants.TSDB_DATA_TYPE_UBIGINT: {
                long value = (long) obj;
                if (value < 0)
                    throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_NUMERIC_VALUE_OUT_OF_RANGE);
                return Long.valueOf(value).intValue();
            }
            case TSDBConstants.TSDB_DATA_TYPE_FLOAT:
                return ((Float) obj).intValue();
            case TSDBConstants.TSDB_DATA_TYPE_DOUBLE:
@ -180,6 +164,35 @@ public class TSDBResultSetRowData {
        }
    }
    private byte parseUnsignedTinyIntToInt(Object obj) throws SQLException {
        byte value = (byte) obj;
        if (value < 0)
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_NUMERIC_VALUE_OUT_OF_RANGE);
        return value;
    }
    private short parseUnsignedSmallIntToInt(Object obj) throws SQLException {
        short value = (short) obj;
        if (value < 0)
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_NUMERIC_VALUE_OUT_OF_RANGE);
        return value;
    }
    private int parseUnsignedIntegerToInt(Object obj) throws SQLException {
        int value = (int) obj;
        if (value < 0)
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_NUMERIC_VALUE_OUT_OF_RANGE);
        return value;
    }
    private int parseUnsignedBigIntToInt(Object obj) throws SQLException {
        long value = (long) obj;
        if (value < 0)
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_NUMERIC_VALUE_OUT_OF_RANGE);
        return Long.valueOf(value).intValue();
    }
    /**
     * $$$ this method is invoked by databaseMetaDataResultSet and so on which use a index start from 1 in JDBC api
     */
@ -216,7 +229,7 @@ public class TSDBResultSetRowData {
            case TSDBConstants.TSDB_DATA_TYPE_BINARY:
                return Long.parseLong((String) obj);
            case TSDBConstants.TSDB_DATA_TYPE_UTINYINT: {
-                Byte value = (byte) obj;
+                byte value = (byte) obj;
                if (value < 0)
                    throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_NUMERIC_VALUE_OUT_OF_RANGE);
                return value;
@ -414,26 +427,40 @@ public class TSDBResultSetRowData {
     * $$$ this method is invoked by databaseMetaDataResultSet and so on which use a index start from 1 in JDBC api
     */
    public void setTimestampValue(int colIndex, long value) {
-        setTimestamp(colIndex - 1, value);
+        setTimestamp(colIndex - 1, value, 0);
    }
    /**
     * !!! this method is invoked by JNI method and the index start from 0 in C implementations
     * @param precision 0 : ms, 1 : us, 2 : ns
     */
-    public void setTimestamp(int col, long ts) {
+    public void setTimestamp(int col, long ts, int precision) {
-        //TODO: this implementation contains logical error
+        long milliseconds = 0;
-        // when precision is us the (long ts) is 16 digital number
+        int fracNanoseconds = 0;
-        // when precision is ms, the (long ts) is 13 digital number
+        switch (precision) {
-        // we need a JNI function like this:
+            case 0: {
-        //      public void setTimestamp(int col, long epochSecond, long nanoAdjustment)
+                milliseconds = ts;
-        if (ts < 1_0000_0000_0000_0L) {
+                fracNanoseconds = (int)(ts*1_000_000%1_000_000_000);
-            data.set(col, new Timestamp(ts));
+                break;
-        } else {
+            }
-            long epochSec = ts / 1000_000l;
+            case 1: {
-            long nanoAdjustment = ts % 1000_000l * 1000l;
+                milliseconds = ts/1_000;
-            Timestamp timestamp = Timestamp.from(Instant.ofEpochSecond(epochSec, nanoAdjustment));
+                fracNanoseconds = (int)(ts*1_000%1_000_000_000);
-            data.set(col, timestamp);
+                break;
            }
            case 2: {
                milliseconds = ts/1_000_000;
                fracNanoseconds = (int)(ts%1_000_000_000);
                break;
            }
            default: {
                throw new IllegalArgumentException("precision is not valid. precision: " + precision);
            }
        }
        Timestamp tsObj = new Timestamp(milliseconds);
        tsObj.setNanos(fracNanoseconds);
        data.set(col, tsObj);
    }
    public Timestamp getTimestamp(int col, int nativeType) {
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/enums/TimestampPrecision.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/enums/TimestampPrecision.java
@ -0,0 +1,8 @@
 package com.taosdata.jdbc.enums;
 public enum TimestampPrecision {
    MS,
    US,
    NS,
    UNKNOWN
 }
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulConnection.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulConnection.java
@ -17,16 +17,18 @@ public class RestfulConnection extends AbstractConnection {
    private final int port;
    private final String url;
    private volatile String database;
    private final String token;
    /******************************************************/
    private boolean isClosed;
    private final DatabaseMetaData metadata;
-    public RestfulConnection(String host, String port, Properties props, String database, String url) {
+    public RestfulConnection(String host, String port, Properties props, String database, String url, String token) {
        super(props);
        this.host = host;
        this.port = Integer.parseInt(port);
        this.database = database;
        this.url = url;
        this.token = token;
        this.metadata = new RestfulDatabaseMetaData(url, props.getProperty(TSDBDriver.PROPERTY_KEY_USER), this);
    }
@ -66,6 +68,7 @@ public class RestfulConnection extends AbstractConnection {
        return this.metadata;
    }
    // getters
    public String getHost() {
        return host;
    }
@ -81,4 +84,8 @@ public class RestfulConnection extends AbstractConnection {
    public String getUrl() {
        return url;
    }
    public String getToken() {
        return token;
    }
 }
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulDriver.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulDriver.java
@ -38,15 +38,11 @@ public class RestfulDriver extends AbstractDriver {
        String port = props.getProperty(TSDBDriver.PROPERTY_KEY_PORT, "6041");
        String database = props.containsKey(TSDBDriver.PROPERTY_KEY_DBNAME) ? props.getProperty(TSDBDriver.PROPERTY_KEY_DBNAME) : null;
-        String loginUrl = "http://" + props.getProperty(TSDBDriver.PROPERTY_KEY_HOST) + ":"
+        String loginUrl = "http://" + host + ":" + port + "/rest/login/" + props.getProperty(TSDBDriver.PROPERTY_KEY_USER) + "/" + props.getProperty(TSDBDriver.PROPERTY_KEY_PASSWORD) + "";
                + props.getProperty(TSDBDriver.PROPERTY_KEY_PORT) + "/rest/login/"
                + props.getProperty(TSDBDriver.PROPERTY_KEY_USER) + "/"
                + props.getProperty(TSDBDriver.PROPERTY_KEY_PASSWORD) + "";
        try {
            String user = URLEncoder.encode(props.getProperty(TSDBDriver.PROPERTY_KEY_USER), "UTF-8");
            String password = URLEncoder.encode(props.getProperty(TSDBDriver.PROPERTY_KEY_PASSWORD), "UTF-8");
-            loginUrl = "http://" + props.getProperty(TSDBDriver.PROPERTY_KEY_HOST) + ":"
+            loginUrl = "http://" + props.getProperty(TSDBDriver.PROPERTY_KEY_HOST) + ":" + props.getProperty(TSDBDriver.PROPERTY_KEY_PORT) + "/rest/login/" + user + "/" + password + "";
                    + props.getProperty(TSDBDriver.PROPERTY_KEY_PORT) + "/rest/login/" + user + "/" + password + "";
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
@ -55,12 +51,12 @@ public class RestfulDriver extends AbstractDriver {
        JSONObject jsonResult = JSON.parseObject(result);
        String status = jsonResult.getString("status");
        String token = jsonResult.getString("desc");
-        HttpClientPoolUtil.token = token;
+
        if (!status.equals("succ")) {
            throw new SQLException(jsonResult.getString("desc"));
        }
-        RestfulConnection conn = new RestfulConnection(host, port, props, database, url);
+        RestfulConnection conn = new RestfulConnection(host, port, props, database, url, token);
        if (database != null && !database.trim().replaceAll("\\s", "").isEmpty()) {
            Statement stmt = conn.createStatement();
            stmt.execute("use " + database);
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulPreparedStatement.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulPreparedStatement.java
@ -44,7 +44,7 @@ public class RestfulPreparedStatement extends RestfulStatement implements Prepar
        if (!isPrepared)
            return executeQuery(this.rawSql);
-        final String sql = getNativeSql(this.rawSql);
+        final String sql = Utils.getNativeSql(this.rawSql, this.parameters);
        return executeQuery(sql);
    }
@ -55,20 +55,10 @@ public class RestfulPreparedStatement extends RestfulStatement implements Prepar
        if (!isPrepared)
            return executeUpdate(this.rawSql);
-        final String sql = getNativeSql(this.rawSql);
+        final String sql = Utils.getNativeSql(rawSql, this.parameters);
        return executeUpdate(sql);
    }
    /****
     * 将rawSql转换成一条可执行的sql语句，使用属性parameters中的变脸进行替换
     * 对于insert into ?.? (?,?,?) using ?.? (?,?,?) tags(?, ?, ?) values(?, ?, ?)
     * @param rawSql，可能是insert、select或其他，使用?做占位符
     * @return
     */
    private String getNativeSql(String rawSql) {
        return Utils.getNativeSql(rawSql, this.parameters);
    }
    @Override
    public void setNull(int parameterIndex, int sqlType) throws SQLException {
        if (isClosed())
@ -224,16 +214,13 @@ public class RestfulPreparedStatement extends RestfulStatement implements Prepar
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
        if (!isPrepared)
            return execute(this.rawSql);
-        final String sql = getNativeSql(rawSql);
+        final String sql = Utils.getNativeSql(rawSql, this.parameters);
        return execute(sql);
    }
    @Override
    public void addBatch() throws SQLException {
-        if (isClosed())
+        final String sql = Utils.getNativeSql(rawSql, this.parameters);
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
        final String sql = getNativeSql(this.rawSql);
        addBatch(sql);
    }
--- 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
@ -6,6 +6,8 @@ import com.google.common.primitives.Ints;
 import com.google.common.primitives.Longs;
 import com.google.common.primitives.Shorts;
 import com.taosdata.jdbc.*;
 import com.taosdata.jdbc.enums.TimestampPrecision;
 import com.taosdata.jdbc.rs.enums.TimestampFormat;
 import com.taosdata.jdbc.utils.Utils;
 import java.math.BigDecimal;
@ -46,6 +48,7 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
            columnNames.clear();
            columns.clear();
            this.resultSet.clear();
            this.metaData = new RestfulResultSetMetaData(this.database, null, this);
            return;
        }
        // get head
@ -131,7 +134,6 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
        }
    }
    private Object parseColumnData(JSONArray row, int colIndex, int taosType) throws SQLException {
        switch (taosType) {
            case TSDBConstants.TSDB_DATA_TYPE_NULL:
@ -150,44 +152,8 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
                return row.getFloat(colIndex);
            case TSDBConstants.TSDB_DATA_TYPE_DOUBLE:
                return row.getDouble(colIndex);
-            case TSDBConstants.TSDB_DATA_TYPE_TIMESTAMP: {
+            case TSDBConstants.TSDB_DATA_TYPE_TIMESTAMP:
-                if (row.get(colIndex) == null)
+                return parseTimestampColumnData(row, colIndex);
                    return null;
                String timestampFormat = this.statement.getConnection().getClientInfo(TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT);
                if ("TIMESTAMP".equalsIgnoreCase(timestampFormat)) {
                    Long value = row.getLong(colIndex);
                    //TODO: this implementation has bug if the timestamp bigger than 9999_9999_9999_9
                    if (value < 1_0000_0000_0000_0L)
                        return new Timestamp(value);
                    long epochSec = value / 1000_000l;
                    long nanoAdjustment = value % 1000_000l * 1000l;
                    return Timestamp.from(Instant.ofEpochSecond(epochSec, nanoAdjustment));
                }
                if ("UTC".equalsIgnoreCase(timestampFormat)) {
                    String value = row.getString(colIndex);
                    long epochSec = Timestamp.valueOf(value.substring(0, 19).replace("T", " ")).getTime() / 1000;
                    int fractionalSec = Integer.parseInt(value.substring(20, value.length() - 5));
                    long nanoAdjustment = 0;
                    if (value.length() > 28) {
                        // ms timestamp: yyyy-MM-ddTHH:mm:ss.SSSSSS+0x00
                        nanoAdjustment = fractionalSec * 1000l;
                    } else {
                        // ms timestamp: yyyy-MM-ddTHH:mm:ss.SSS+0x00
                        nanoAdjustment = fractionalSec * 1000_000l;
                    }
                    ZoneOffset zoneOffset = ZoneOffset.of(value.substring(value.length() - 5));
                    Instant instant = Instant.ofEpochSecond(epochSec, nanoAdjustment).atOffset(zoneOffset).toInstant();
                    return Timestamp.from(instant);
                }
                String value = row.getString(colIndex);
                if (value.length() <= 23)    // ms timestamp: yyyy-MM-dd HH:mm:ss.SSS
                    return row.getTimestamp(colIndex);
                // us timestamp: yyyy-MM-dd HH:mm:ss.SSSSSS
                long epochSec = Timestamp.valueOf(value.substring(0, 19)).getTime() / 1000;
                long nanoAdjustment = Integer.parseInt(value.substring(20)) * 1000l;
                Timestamp timestamp = Timestamp.from(Instant.ofEpochSecond(epochSec, nanoAdjustment));
                return timestamp;
            }
            case TSDBConstants.TSDB_DATA_TYPE_BINARY:
                return row.getString(colIndex) == null ? null : row.getString(colIndex).getBytes();
            case TSDBConstants.TSDB_DATA_TYPE_NCHAR:
@ -197,7 +163,66 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
        }
    }
-    public class Field {
+    private Timestamp parseTimestampColumnData(JSONArray row, int colIndex) throws SQLException {
        if (row.get(colIndex) == null)
            return null;
        String tsFormatUpperCase = this.statement.getConnection().getClientInfo(TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT).toUpperCase();
        TimestampFormat timestampFormat = TimestampFormat.valueOf(tsFormatUpperCase);
        switch (timestampFormat) {
            case TIMESTAMP: {
                Long value = row.getLong(colIndex);
                //TODO: this implementation has bug if the timestamp bigger than 9999_9999_9999_9
                if (value < 1_0000_0000_0000_0L)
                    return new Timestamp(value);
                long epochSec = value / 1000_000l;
                long nanoAdjustment = value % 1000_000l * 1000l;
                return Timestamp.from(Instant.ofEpochSecond(epochSec, nanoAdjustment));
            }
            case UTC: {
                String value = row.getString(colIndex);
                long epochSec = Timestamp.valueOf(value.substring(0, 19).replace("T", " ")).getTime() / 1000;
                int fractionalSec = Integer.parseInt(value.substring(20, value.length() - 5));
                long nanoAdjustment;
                if (value.length() > 31) {
                    // ns timestamp: yyyy-MM-ddTHH:mm:ss.SSSSSSSSS+0x00
                    nanoAdjustment = fractionalSec;
                } else if (value.length() > 28) {
                    // ms timestamp: yyyy-MM-ddTHH:mm:ss.SSSSSS+0x00
                    nanoAdjustment = fractionalSec * 1000L;
                } else {
                    // ms timestamp: yyyy-MM-ddTHH:mm:ss.SSS+0x00
                    nanoAdjustment = fractionalSec * 1000_000L;
                }
                ZoneOffset zoneOffset = ZoneOffset.of(value.substring(value.length() - 5));
                Instant instant = Instant.ofEpochSecond(epochSec, nanoAdjustment).atOffset(zoneOffset).toInstant();
                return Timestamp.from(instant);
            }
            case STRING:
            default: {
                String value = row.getString(colIndex);
                TimestampPrecision precision = Utils.guessTimestampPrecision(value);
                if (precision == TimestampPrecision.MS) {
                    // ms timestamp: yyyy-MM-dd HH:mm:ss.SSS
                    return row.getTimestamp(colIndex);
                }
                if (precision == TimestampPrecision.US) {
                    // us timestamp: yyyy-MM-dd HH:mm:ss.SSSSSS
                    long epochSec = Timestamp.valueOf(value.substring(0, 19)).getTime() / 1000;
                    long nanoAdjustment = Integer.parseInt(value.substring(20)) * 1000L;
                    return Timestamp.from(Instant.ofEpochSecond(epochSec, nanoAdjustment));
                }
                if (precision == TimestampPrecision.NS) {
                    // ms timestamp: yyyy-MM-dd HH:mm:ss.SSSSSSSSS
                    long epochSec = Timestamp.valueOf(value.substring(0, 19)).getTime() / 1000;
                    long nanoAdjustment = Integer.parseInt(value.substring(20));
                    return Timestamp.from(Instant.ofEpochSecond(epochSec, nanoAdjustment));
                }
                throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNKNOWN_TIMESTAMP_PERCISION);
            }
        }
    }
    public static class Field {
        String name;
        int type;
        int length;
@ -211,6 +236,7 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
            this.note = note;
            this.taos_type = taos_type;
        }
    }
    @Override
@ -334,6 +360,7 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
            wasNull = true;
            return 0;
        }
        wasNull = false;
        if (value instanceof Timestamp) {
            return ((Timestamp) value).getTime();
--- 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
@ -8,20 +8,22 @@ import java.sql.SQLException;
 import java.sql.Timestamp;
 import java.sql.Types;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 public class RestfulResultSetMetaData extends WrapperImpl implements ResultSetMetaData {
    private final String database;
-    private ArrayList<RestfulResultSet.Field> fields;
+    private List<RestfulResultSet.Field> fields;
    private final RestfulResultSet resultSet;
    public RestfulResultSetMetaData(String database, ArrayList<RestfulResultSet.Field> fields, RestfulResultSet resultSet) {
        this.database = database;
-        this.fields = fields;
+        this.fields = fields == null ? Collections.emptyList() : fields;
        this.resultSet = resultSet;
    }
-    public ArrayList<RestfulResultSet.Field> getFields() {
+    public List<RestfulResultSet.Field> getFields() {
        return fields;
    }
--- 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
@ -83,7 +83,7 @@ public class RestfulStatement extends AbstractStatement {
        }
        if (SqlSyntaxValidator.isUseSql(sql)) {
-            HttpClientPoolUtil.execute(url, sql);
+            HttpClientPoolUtil.execute(url, sql, this.conn.getToken());
            this.database = sql.trim().replace("use", "").trim();
            this.conn.setCatalog(this.database);
            result = false;
@ -116,7 +116,7 @@ public class RestfulStatement extends AbstractStatement {
        if ("UTC".equalsIgnoreCase(timestampFormat))
            url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sqlutc";
-        String result = HttpClientPoolUtil.execute(url, sql);
+        String result = HttpClientPoolUtil.execute(url, sql, this.conn.getToken());
        JSONObject resultJson = JSON.parseObject(result);
        if (resultJson.getString("status").equals("error")) {
            throw TSDBError.createSQLException(resultJson.getInteger("code"), resultJson.getString("desc"));
@ -130,7 +130,7 @@ public class RestfulStatement extends AbstractStatement {
        if (!SqlSyntaxValidator.isValidForExecuteUpdate(sql))
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_FOR_EXECUTE_UPDATE, "not a valid sql for executeUpdate: " + sql);
-        String result = HttpClientPoolUtil.execute(url, sql);
+        String result = HttpClientPoolUtil.execute(url, sql, this.conn.getToken());
        JSONObject jsonObject = JSON.parseObject(result);
        if (jsonObject.getString("status").equals("error")) {
            throw TSDBError.createSQLException(jsonObject.getInteger("code"), jsonObject.getString("desc"));
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/enums/TimestampFormat.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/enums/TimestampFormat.java
@ -0,0 +1,7 @@
 package com.taosdata.jdbc.rs.enums;
 public enum TimestampFormat {
    STRING,
    TIMESTAMP,
    UTC
 }
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/utils/HttpClientPoolUtil.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/utils/HttpClientPoolUtil.java
@ -16,43 +16,32 @@ import org.apache.http.protocol.HTTP;
 import org.apache.http.protocol.HttpContext;
 import org.apache.http.util.EntityUtils;
-import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 public class HttpClientPoolUtil {
    public static PoolingHttpClientConnectionManager cm = null;
    public static CloseableHttpClient httpClient = null;
    public static String token = "cm9vdDp0YW9zZGF0YQ==";
    /**
     * 默认content 类型
     */
    private static final String DEFAULT_CONTENT_TYPE = "application/json";
    /**
     * 默认请求超时时间30s
     */
    private static final int DEFAULT_TIME_OUT = 15000;
    private static final int count = 32;
    private static final int totalCount = 1000;
    private static final int Http_Default_Keep_Time = 15000;
-    /**
+    private static final String DEFAULT_CONTENT_TYPE = "application/json";
-     * 初始化连接池
+    private static final int DEFAULT_TIME_OUT = 15000;
-     */
+    private static final int DEFAULT_MAX_PER_ROUTE = 32;
    private static final int DEFAULT_MAX_TOTAL = 1000;
    private static final int DEFAULT_HTTP_KEEP_TIME = 15000;
    private static PoolingHttpClientConnectionManager connectionManager;
    private static CloseableHttpClient httpClient;
    private static synchronized void initPools() {
        if (httpClient == null) {
-            cm = new PoolingHttpClientConnectionManager();
+            connectionManager = new PoolingHttpClientConnectionManager();
-            cm.setDefaultMaxPerRoute(count);
+            connectionManager.setDefaultMaxPerRoute(DEFAULT_MAX_PER_ROUTE);
-            cm.setMaxTotal(totalCount);
+            connectionManager.setMaxTotal(DEFAULT_MAX_TOTAL);
-            httpClient = HttpClients.custom().setKeepAliveStrategy(defaultStrategy).setConnectionManager(cm).build();
+            httpClient = HttpClients.custom().setKeepAliveStrategy(DEFAULT_KEEP_ALIVE_STRATEGY).setConnectionManager(connectionManager).build();
        }
    }
-    /**
+    private static ConnectionKeepAliveStrategy DEFAULT_KEEP_ALIVE_STRATEGY = (response, context) -> {
     * Http connection keepAlive 设置
     */
    private static ConnectionKeepAliveStrategy defaultStrategy = (response, context) -> {
        HeaderElementIterator it = new BasicHeaderElementIterator(response.headerIterator(HTTP.CONN_KEEP_ALIVE));
-        int keepTime = Http_Default_Keep_Time * 1000;
+        int keepTime = DEFAULT_HTTP_KEEP_TIME * 1000;
        while (it.hasNext()) {
            HeaderElement headerElement = it.nextElement();
            String param = headerElement.getName();
@ -76,7 +65,7 @@ public class HttpClientPoolUtil {
     * @param data 请求数据
     * @return responseBody
     */
-    public static String execute(String uri, String data) {
+    public static String execute(String uri, String data, String token) {
        long startTime = System.currentTimeMillis();
        HttpEntity httpEntity = null;
        HttpEntityEnclosingRequestBase method = null;
@ -90,7 +79,7 @@ public class HttpClientPoolUtil {
            method.setHeader("Connection", "keep-alive");
            method.setHeader("Authorization", "Taosd " + token);
-            method.setEntity(new StringEntity(data, Charset.forName("UTF-8")));
+            method.setEntity(new StringEntity(data, StandardCharsets.UTF_8));
            HttpContext context = HttpClientContext.create();
            CloseableHttpResponse httpResponse = httpClient.execute(method, context);
            httpEntity = httpResponse.getEntity();
@ -175,28 +164,18 @@ public class HttpClientPoolUtil {
            httpEntity = httpResponse.getEntity();
            if (httpEntity != null) {
                responseBody = EntityUtils.toString(httpEntity, "UTF-8");
 //                logger.info("请求URL: " + uri + "+ 返回状态码：" + httpResponse.getStatusLine().getStatusCode());
            }
        } catch (Exception e) {
            if (method != null) {
                method.abort();
            }
            e.printStackTrace();
 //            logger.error("execute get request exception, url:" + uri + ", exception:" + e.toString() + ",cost time(ms):"
 //                    + (System.currentTimeMillis() - startTime));
            System.out.println("log:调用 HttpClientPoolUtil execute get request exception, url:" + uri + ", exception:" + e.toString() + ",cost time(ms):"
                    + (System.currentTimeMillis() - startTime));
        } finally {
            if (httpEntity != null) {
                try {
                    EntityUtils.consumeQuietly(httpEntity);
                } catch (Exception e) {
-//                    e.printStackTrace();
+                    new Exception("close response exception, url:" + uri + ", exception:" + e.toString() + ",cost time(ms):" + (System.currentTimeMillis() - startTime)).printStackTrace();
 //                    logger.error("close response exception, url:" + uri + ", exception:" + e.toString()
 //                            + ",cost time(ms):" + (System.currentTimeMillis() - startTime));
                    new Exception("close response exception, url:" + uri + ", exception:" + e.toString()
                            + ",cost time(ms):" + (System.currentTimeMillis() - startTime))
                            .printStackTrace();
                }
            }
        }
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/utils/Utils.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/utils/Utils.java
@ -3,14 +3,13 @@ package com.taosdata.jdbc.utils;
 import com.google.common.collect.Range;
 import com.google.common.collect.RangeSet;
 import com.google.common.collect.TreeRangeSet;
 import com.taosdata.jdbc.enums.TimestampPrecision;
 import java.nio.charset.Charset;
 import java.sql.Date;
 import java.sql.Time;
 import java.sql.Timestamp;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
 import java.time.format.DateTimeFormatter;
 import java.time.format.DateTimeFormatterBuilder;
 import java.time.format.DateTimeParseException;
@ -25,39 +24,52 @@ public class Utils {
    private static Pattern ptn = Pattern.compile(".*?'");
-    private static final DateTimeFormatter formatter = new DateTimeFormatterBuilder()
+    private static final DateTimeFormatter milliSecFormatter = new DateTimeFormatterBuilder().appendPattern("yyyy-MM-dd HH:mm:ss.SSS").toFormatter();
-            .appendPattern("yyyy-MM-dd HH:mm:ss.SSS").toFormatter();
+    private static final DateTimeFormatter microSecFormatter = new DateTimeFormatterBuilder().appendPattern("yyyy-MM-dd HH:mm:ss.SSSSSS").toFormatter();
-    private static final DateTimeFormatter formatter2 = new DateTimeFormatterBuilder()
+    private static final DateTimeFormatter nanoSecFormatter = new DateTimeFormatterBuilder().appendPattern("yyyy-MM-dd HH:mm:ss.SSSSSSSSS").toFormatter();
            .appendPattern("yyyy-MM-dd HH:mm:ss.SSSSSS").toFormatter();
    public static Time parseTime(String timestampStr) throws DateTimeParseException {
-        LocalTime time;
+        LocalDateTime dateTime = parseLocalDateTime(timestampStr);
-        try {
+        return dateTime != null ? Time.valueOf(dateTime.toLocalTime()) : null;
            time = LocalTime.parse(timestampStr, formatter);
        } catch (DateTimeParseException e) {
            time = LocalTime.parse(timestampStr, formatter2);
        }
        return Time.valueOf(time);
    }
-    public static Date parseDate(String timestampStr) throws DateTimeParseException {
+    public static Date parseDate(String timestampStr) {
-        LocalDate date;
+        LocalDateTime dateTime = parseLocalDateTime(timestampStr);
-        try {
+        return dateTime != null ? Date.valueOf(String.valueOf(dateTime)) : null;
            date = LocalDate.parse(timestampStr, formatter);
        } catch (DateTimeParseException e) {
            date = LocalDate.parse(timestampStr, formatter2);
        }
        return Date.valueOf(date);
    }
    public static Timestamp parseTimestamp(String timeStampStr) {
-        LocalDateTime dateTime;
+        LocalDateTime dateTime = parseLocalDateTime(timeStampStr);
        return dateTime != null ? Timestamp.valueOf(dateTime) : null;
    }
    private static LocalDateTime parseLocalDateTime(String timeStampStr) {
        try {
-            dateTime = LocalDateTime.parse(timeStampStr, formatter);
+            return parseMilliSecTimestamp(timeStampStr);
        } catch (DateTimeParseException e) {
-            dateTime = LocalDateTime.parse(timeStampStr, formatter2);
+            try {
                return parseMicroSecTimestamp(timeStampStr);
            } catch (DateTimeParseException ee) {
                try {
                    return parseNanoSecTimestamp(timeStampStr);
                } catch (DateTimeParseException eee) {
                    eee.printStackTrace();
                }
            }
        }
-        return Timestamp.valueOf(dateTime);
+        return null;
    }
    private static LocalDateTime parseMilliSecTimestamp(String timeStampStr) throws DateTimeParseException {
        return LocalDateTime.parse(timeStampStr, milliSecFormatter);
    }
    private static LocalDateTime parseMicroSecTimestamp(String timeStampStr) throws DateTimeParseException {
        return LocalDateTime.parse(timeStampStr, microSecFormatter);
    }
    private static LocalDateTime parseNanoSecTimestamp(String timeStampStr) throws DateTimeParseException {
        return LocalDateTime.parse(timeStampStr, nanoSecFormatter);
    }
    public static String escapeSingleQuota(String origin) {
@ -93,6 +105,8 @@ public class Utils {
    }
    public static String getNativeSql(String rawSql, Object[] parameters) {
        if (parameters == null || !rawSql.contains("?"))
            return rawSql;
        // toLowerCase
        String preparedSql = rawSql.trim().toLowerCase();
        String[] clause = new String[]{"values\\s*\\(.*?\\)", "tags\\s*\\(.*?\\)", "where\\s*.*"};
@ -167,13 +181,47 @@ public class Utils {
        }).collect(Collectors.joining());
    }
    public static String formatTimestamp(Timestamp timestamp) {
        int nanos = timestamp.getNanos();
        if (nanos % 1000000l != 0)
-            return timestamp.toLocalDateTime().format(formatter2);
+            return timestamp.toLocalDateTime().format(microSecFormatter);
-        return timestamp.toLocalDateTime().format(formatter);
+        return timestamp.toLocalDateTime().format(milliSecFormatter);
    }
    public static TimestampPrecision guessTimestampPrecision(String value) {
        if (isMilliSecFormat(value))
            return TimestampPrecision.MS;
        if (isMicroSecFormat(value))
            return TimestampPrecision.US;
        if (isNanoSecFormat(value))
            return TimestampPrecision.NS;
        return TimestampPrecision.UNKNOWN;
    }
    private static boolean isMilliSecFormat(String timestampStr) {
        try {
            milliSecFormatter.parse(timestampStr);
        } catch (DateTimeParseException e) {
            return false;
        }
        return true;
    }
    private static boolean isMicroSecFormat(String timestampStr) {
        try {
            microSecFormatter.parse(timestampStr);
        } catch (DateTimeParseException e) {
            return false;
        }
        return true;
    }
    private static boolean isNanoSecFormat(String timestampStr) {
        try {
            nanoSecFormatter.parse(timestampStr);
        } catch (DateTimeParseException e) {
            return false;
        }
        return true;
    }
 }
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBJNIConnectorTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBJNIConnectorTest.java
@ -1,12 +1,17 @@
 package com.taosdata.jdbc;
 import org.junit.Test;
 import static org.junit.Assert.*;
 import java.sql.SQLException;
 import java.sql.SQLWarning;
 import java.util.ArrayList;
 import java.util.List;
 import java.lang.management.ManagementFactory;
 import java.lang.management.RuntimeMXBean;
 import java.lang.management.ThreadMXBean;
 public class TSDBJNIConnectorTest {
    private static TSDBResultSetRowData rowData;
@ -14,17 +19,68 @@ public class TSDBJNIConnectorTest {
    @Test
    public void test() {
        try {
            try {
                //change sleepSeconds when debugging with attach to process to find PID
                int sleepSeconds = -1;
                if (sleepSeconds>0) {
                    RuntimeMXBean runtimeBean = ManagementFactory.getRuntimeMXBean();
                    String jvmName = runtimeBean.getName();
                    long pid = Long.valueOf(jvmName.split("@")[0]);
                    System.out.println("JVM PID  = " + pid);
                    Thread.sleep(sleepSeconds*1000);
                }
            }
            catch (Exception e) {
                e.printStackTrace();
            }
            // init
-            TSDBJNIConnector.init("/etc/taos/taos.cfg", null, null, null);
+            TSDBJNIConnector.init("/etc/taos", null, null, null);
            // connect
            TSDBJNIConnector connector = new TSDBJNIConnector();
-            connector.connect("127.0.0.1", 6030, "unsign_jni", "root", "taosdata");
+            connector.connect("127.0.0.1", 6030, null, "root", "taosdata");
            // setup
            String setupSqlStrs[] = {"create database if not exists d precision \"us\"",
                                      "create table if not exists d.t(ts timestamp, f int)",
                                      "create database if not exists d2",
                                      "create table if not exists d2.t2(ts timestamp, f int)",
                                      "insert into d.t values(now+100s, 100)",
                                      "insert into d2.t2 values(now+200s, 200)"
                                      };
            for (String setupSqlStr : setupSqlStrs) {
                long setupSql = connector.executeQuery(setupSqlStr);
                assertEquals(0, connector.getResultTimePrecision(setupSql));
                if (connector.isUpdateQuery(setupSql)) {
                    connector.freeResultSet(setupSql);
                }
            }
            {
                long sqlObj1 = connector.executeQuery("select * from d2.t2");
                assertEquals(0, connector.getResultTimePrecision(sqlObj1));
                List<ColumnMetaData> columnMetaDataList = new ArrayList<>();
                int code = connector.getSchemaMetaData(sqlObj1, columnMetaDataList);
                rowData = new TSDBResultSetRowData(columnMetaDataList.size());
                assertTrue(next(connector, sqlObj1));
                assertEquals(0, connector.getResultTimePrecision(sqlObj1));
                connector.freeResultSet(sqlObj1);
            }
            // executeQuery
-            long pSql = connector.executeQuery("select * from unsign_jni.us_table");
+            long pSql = connector.executeQuery("select * from d.t");
            if (connector.isUpdateQuery(pSql)) {
                connector.freeResultSet(pSql);
                throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_WITH_EXECUTEQUERY);
            }
            assertEquals(1, connector.getResultTimePrecision(pSql));
            // get schema
            List<ColumnMetaData> columnMetaDataList = new ArrayList<>();
            int code = connector.getSchemaMetaData(pSql, columnMetaDataList);
@ -37,6 +93,8 @@ public class TSDBJNIConnectorTest {
            if (code == TSDBConstants.JNI_NUM_OF_FIELDS_0) {
                throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_NUM_OF_FIELDS_0);
            }
            assertEquals(1, connector.getResultTimePrecision(pSql));
            int columnSize = columnMetaDataList.size();
            // print metadata
            for (int i = 0; i < columnSize; i++) {
@ -45,9 +103,8 @@ public class TSDBJNIConnectorTest {
            rowData = new TSDBResultSetRowData(columnSize);
            // iterate resultSet
            for (int i = 0; next(connector, pSql); i++) {
-//                System.out.println("col[" + i + "] size: " + rowData.getColSize());
+                assertEquals(1, connector.getResultTimePrecision(pSql));
-//                rowData.getData().stream().forEach(col -> System.out.print(col + "\t"));
+                System.out.println();
 //                System.out.println();
            }
            // close resultSet
            code = connector.freeResultSet(pSql);
@ -86,4 +143,4 @@ public class TSDBJNIConnectorTest {
        }
    }
-}
+}
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBPreparedStatementTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBPreparedStatementTest.java
@ -5,7 +5,6 @@ import org.junit.*;
 import java.io.IOException;
 import java.math.BigDecimal;
 import java.sql.*;
 import java.time.LocalTime;
 import java.util.ArrayList;
 import java.util.Random;
@ -15,6 +14,7 @@ public class TSDBPreparedStatementTest {
    private static Connection conn;
    private static final String sql_insert = "insert into t1 values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
    private static final String sql_select = "select * from t1 where ts >= ? and ts < ? and f1 >= ?";
    private static final String dbname = "test_pstmt_jni";
    private PreparedStatement pstmt_insert;
    private PreparedStatement pstmt_select;
@ -299,53 +299,53 @@ public class TSDBPreparedStatementTest {
    }
    @Test
-    public void executeTest() throws SQLException {   
+    public void executeTest() throws SQLException {
-        Statement stmt = conn.createStatement();            
+        Statement stmt = conn.createStatement();
-        int numOfRows = 1000;        
+        int numOfRows = 1000;
-        for (int loop = 0; loop < 10; loop++){
+        for (int loop = 0; loop < 10; loop++) {
            stmt.execute("drop table if exists weather_test");
-            stmt.execute("create table weather_test(ts timestamp, f1 nchar(4), f2 float, f3 double, f4 timestamp, f5 int, f6 bool, f7 binary(10))");            
+            stmt.execute("create table weather_test(ts timestamp, f1 nchar(4), f2 float, f3 double, f4 timestamp, f5 int, f6 bool, f7 binary(10))");
            TSDBPreparedStatement s = (TSDBPreparedStatement) conn.prepareStatement("insert into ? values(?, ?, ?, ?, ?, ?, ?, ?)");
            Random r = new Random();
            s.setTableName("weather_test");
-            
+
            ArrayList<Long> ts = new ArrayList<Long>();
-            for(int i = 0; i < numOfRows; i++) {
+            for (int i = 0; i < numOfRows; i++) {
                ts.add(System.currentTimeMillis() + i);
-            }        
+            }
            s.setTimestamp(0, ts);
            int random = 10 + r.nextInt(5);
-            ArrayList<String> s2 = new ArrayList<String>();        
+            ArrayList<String> s2 = new ArrayList<String>();
-            for(int i = 0; i < numOfRows; i++) {
+            for (int i = 0; i < numOfRows; i++) {
-                if(i % random == 0) {
+                if (i % random == 0) {
                    s2.add(null);
-                }else{
+                } else {
                    s2.add("分支" + i % 4);
                }
-            }        
+            }
-            s.setNString(1, s2, 4);      
+            s.setNString(1, s2, 4);
            random = 10 + r.nextInt(5);
-            ArrayList<Float> s3 = new ArrayList<Float>();        
+            ArrayList<Float> s3 = new ArrayList<Float>();
-            for(int i = 0; i < numOfRows; i++) {
+            for (int i = 0; i < numOfRows; i++) {
-                if(i % random == 0) {
+                if (i % random == 0) {
                    s3.add(null);
-                }else{
+                } else {
                    s3.add(r.nextFloat());
                }
-            }        
+            }
            s.setFloat(2, s3);
            random = 10 + r.nextInt(5);
            ArrayList<Double> s4 = new ArrayList<Double>();
-            for(int i = 0; i < numOfRows; i++) {
+            for (int i = 0; i < numOfRows; i++) {
-                if(i % random == 0) {
+                if (i % random == 0) {
                    s4.add(null);
-                }else{
+                } else {
                    s4.add(r.nextDouble());
                }
            }
@ -353,47 +353,47 @@ public class TSDBPreparedStatementTest {
            random = 10 + r.nextInt(5);
            ArrayList<Long> ts2 = new ArrayList<Long>();
-            for(int i = 0; i < numOfRows; i++) {
+            for (int i = 0; i < numOfRows; i++) {
-                if(i % random == 0) {
+                if (i % random == 0) {
                    ts2.add(null);
-                }else{
+                } else {
                    ts2.add(System.currentTimeMillis() + i);
                }
            }
            s.setTimestamp(4, ts2);
            random = 10 + r.nextInt(5);
-            ArrayList<Integer>  vals = new ArrayList<>();
+            ArrayList<Integer> vals = new ArrayList<>();
-            for(int i = 0; i < numOfRows; i++) {
+            for (int i = 0; i < numOfRows; i++) {
-                if(i % random == 0) {
+                if (i % random == 0) {
                    vals.add(null);
-                }else{
+                } else {
                    vals.add(r.nextInt());
-                }                
+                }
            }
            s.setInt(5, vals);
            random = 10 + r.nextInt(5);
            ArrayList<Boolean> sb = new ArrayList<>();
-            for(int i = 0; i < numOfRows; i++) {
+            for (int i = 0; i < numOfRows; i++) {
-                if(i % random == 0) {
+                if (i % random == 0) {
                    sb.add(null);
-                }else{
+                } else {
                    sb.add(i % 2 == 0 ? true : false);
                }
            }
-            s.setBoolean(6, sb);        
+            s.setBoolean(6, sb);
            random = 10 + r.nextInt(5);
            ArrayList<String> s5 = new ArrayList<String>();
-            for(int i = 0; i < numOfRows; i++) {
+            for (int i = 0; i < numOfRows; i++) {
-                if(i % random == 0) {
+                if (i % random == 0) {
                    s5.add(null);
-                }else{
+                } else {
                    s5.add("test" + i % 10);
                }
            }
-            s.setString(7, s5, 10);        
+            s.setString(7, s5, 10);
            s.columnDataAddBatch();
            s.columnDataExecuteBatch();
@ -403,54 +403,54 @@ public class TSDBPreparedStatementTest {
            PreparedStatement statement = conn.prepareStatement(sql);
            ResultSet rs = statement.executeQuery();
            int rows = 0;
-            while(rs.next()) {
+            while (rs.next()) {
                rows++;
            }
-            Assert.assertEquals(numOfRows, rows);            
+            Assert.assertEquals(numOfRows, rows);
        }
    }
    @Test
-    public void bindDataSelectColumnTest() throws SQLException {   
+    public void bindDataSelectColumnTest() throws SQLException {
-        Statement stmt = conn.createStatement();            
+        Statement stmt = conn.createStatement();
-        int numOfRows = 1000;        
+        int numOfRows = 1000;
-        for (int loop = 0; loop < 10; loop++){
+        for (int loop = 0; loop < 10; loop++) {
            stmt.execute("drop table if exists weather_test");
-            stmt.execute("create table weather_test(ts timestamp, f1 nchar(4), f2 float, f3 double, f4 timestamp, f5 int, f6 bool, f7 binary(10))");            
+            stmt.execute("create table weather_test(ts timestamp, f1 nchar(4), f2 float, f3 double, f4 timestamp, f5 int, f6 bool, f7 binary(10))");
            TSDBPreparedStatement s = (TSDBPreparedStatement) conn.prepareStatement("insert into ? (ts, f1, f7) values(?, ?, ?)");
            Random r = new Random();
            s.setTableName("weather_test");
-            
+
            ArrayList<Long> ts = new ArrayList<Long>();
-            for(int i = 0; i < numOfRows; i++) {
+            for (int i = 0; i < numOfRows; i++) {
                ts.add(System.currentTimeMillis() + i);
-            }        
+            }
            s.setTimestamp(0, ts);
            int random = 10 + r.nextInt(5);
-            ArrayList<String> s2 = new ArrayList<String>();        
+            ArrayList<String> s2 = new ArrayList<String>();
-            for(int i = 0; i < numOfRows; i++) {
+            for (int i = 0; i < numOfRows; i++) {
-                if(i % random == 0) {
+                if (i % random == 0) {
                    s2.add(null);
-                }else{
+                } else {
                    s2.add("分支" + i % 4);
                }
-            }        
+            }
-            s.setNString(1, s2, 4);                   
+            s.setNString(1, s2, 4);
            random = 10 + r.nextInt(5);
            ArrayList<String> s3 = new ArrayList<String>();
-            for(int i = 0; i < numOfRows; i++) {
+            for (int i = 0; i < numOfRows; i++) {
-                if(i % random == 0) {
+                if (i % random == 0) {
                    s3.add(null);
-                }else{
+                } else {
                    s3.add("test" + i % 10);
                }
            }
-            s.setString(2, s3, 10);        
+            s.setString(2, s3, 10);
            s.columnDataAddBatch();
            s.columnDataExecuteBatch();
@ -460,30 +460,30 @@ public class TSDBPreparedStatementTest {
            PreparedStatement statement = conn.prepareStatement(sql);
            ResultSet rs = statement.executeQuery();
            int rows = 0;
-            while(rs.next()) {
+            while (rs.next()) {
                rows++;
            }
-            Assert.assertEquals(numOfRows, rows);            
+            Assert.assertEquals(numOfRows, rows);
        }
    }
    @Test
-    public void bindDataWithSingleTagTest() throws SQLException { 
+    public void bindDataWithSingleTagTest() throws SQLException {
-        Statement stmt = conn.createStatement();                
+        Statement stmt = conn.createStatement();
-        String types[] = new String[] {"tinyint", "smallint", "int", "bigint", "bool", "float", "double", "binary(10)", "nchar(10)"};                
+        String types[] = new String[]{"tinyint", "smallint", "int", "bigint", "bool", "float", "double", "binary(10)", "nchar(10)"};
        for (String type : types) {
            stmt.execute("drop table if exists weather_test");
            stmt.execute("create table weather_test(ts timestamp, f1 nchar(10), f2 binary(10)) tags (t " + type + ")");
            int numOfRows = 1;
-    
+
            TSDBPreparedStatement s = (TSDBPreparedStatement) conn.prepareStatement("insert into ? using weather_test tags(?) values(?, ?, ?)");
            Random r = new Random();
            s.setTableName("w1");
-            
+
-            switch(type) {
+            switch (type) {
                case "tinyint":
                case "smallint":
                case "int":
@ -508,37 +508,37 @@ public class TSDBPreparedStatementTest {
                default:
                    break;
            }
-            
+
-            
+
            ArrayList<Long> ts = new ArrayList<Long>();
-            for(int i = 0; i < numOfRows; i++) {
+            for (int i = 0; i < numOfRows; i++) {
                ts.add(System.currentTimeMillis() + i);
-            }        
+            }
            s.setTimestamp(0, ts);
-    
+
            int random = 10 + r.nextInt(5);
-            ArrayList<String> s2 = new ArrayList<String>();        
+            ArrayList<String> s2 = new ArrayList<String>();
-            for(int i = 0; i < numOfRows; i++) {            
+            for (int i = 0; i < numOfRows; i++) {
-                s2.add("分支" + i % 4);            
+                s2.add("分支" + i % 4);
-            }        
+            }
            s.setNString(1, s2, 10);
-            
+
            random = 10 + r.nextInt(5);
-            ArrayList<String> s3 = new ArrayList<String>();        
+            ArrayList<String> s3 = new ArrayList<String>();
-            for(int i = 0; i < numOfRows; i++) {            
+            for (int i = 0; i < numOfRows; i++) {
-                s3.add("test" + i % 4);            
+                s3.add("test" + i % 4);
-            }        
+            }
            s.setString(2, s3, 10);
-    
+
            s.columnDataAddBatch();
            s.columnDataExecuteBatch();
            s.columnDataCloseBatch();
-    
+
            String sql = "select * from weather_test";
            PreparedStatement statement = conn.prepareStatement(sql);
            ResultSet rs = statement.executeQuery();
            int rows = 0;
-            while(rs.next()) {
+            while (rs.next()) {
                rows++;
            }
            Assert.assertEquals(numOfRows, rows);
@ -547,32 +547,32 @@ public class TSDBPreparedStatementTest {
    @Test
-    public void bindDataWithMultipleTagsTest() throws SQLException { 
+    public void bindDataWithMultipleTagsTest() throws SQLException {
-        Statement stmt = conn.createStatement();                
+        Statement stmt = conn.createStatement();
-        
+
        stmt.execute("drop table if exists weather_test");
        stmt.execute("create table weather_test(ts timestamp, f1 nchar(10), f2 binary(10)) tags (t1 int, t2 binary(10))");
        int numOfRows = 1;
-        TSDBPreparedStatement s = (TSDBPreparedStatement) conn.prepareStatement("insert into ? using weather_test tags(?,?) (ts, f2) values(?, ?)");        
+        TSDBPreparedStatement s = (TSDBPreparedStatement) conn.prepareStatement("insert into ? using weather_test tags(?,?) (ts, f2) values(?, ?)");
-        s.setTableName("w2");  
+        s.setTableName("w2");
        s.setTagInt(0, 1);
        s.setTagString(1, "test");
-        
+
-        
+
        ArrayList<Long> ts = new ArrayList<Long>();
-        for(int i = 0; i < numOfRows; i++) {
+        for (int i = 0; i < numOfRows; i++) {
            ts.add(System.currentTimeMillis() + i);
-        }        
+        }
        s.setTimestamp(0, ts);
-        
+
-        ArrayList<String> s2 = new ArrayList<String>();        
+        ArrayList<String> s2 = new ArrayList<String>();
-        for(int i = 0; i < numOfRows; i++) {            
+        for (int i = 0; i < numOfRows; i++) {
            s2.add("test" + i % 4);
        }
        s.setString(1, s2, 10);
-    
+
        s.columnDataAddBatch();
        s.columnDataExecuteBatch();
        s.columnDataCloseBatch();
@ -581,21 +581,20 @@ public class TSDBPreparedStatementTest {
        PreparedStatement statement = conn.prepareStatement(sql);
        ResultSet rs = statement.executeQuery();
        int rows = 0;
-        while(rs.next()) {
+        while (rs.next()) {
            rows++;
        }
        Assert.assertEquals(numOfRows, rows);
    }
-    
+
-    @Test
+    @Test(expected = SQLException.class)
    public void createTwoSameDbTest() throws SQLException {
-        Statement stmt = conn.createStatement();                
+        // when
-                
+        Statement stmt = conn.createStatement();
        stmt.execute("create database dbtest");
        stmt.execute("create database dbtest");
        Assert.assertThrows(SQLException.class, () -> stmt.execute("create database dbtest"));                
    }
-    
+
    @Test
    public void setBoolean() throws SQLException {
        // given
@ -1097,9 +1096,9 @@ public class TSDBPreparedStatementTest {
        try {
            conn = DriverManager.getConnection("jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata");
            try (Statement stmt = conn.createStatement()) {
-                stmt.execute("drop database if exists test_pstmt_jni");
+                stmt.execute("drop database if exists " + dbname);
-                stmt.execute("create database if not exists test_pstmt_jni");
+                stmt.execute("create database if not exists " + dbname);
-                stmt.execute("use test_pstmt_jni");
+                stmt.execute("use " + dbname);
            }
        } catch (SQLException e) {
            e.printStackTrace();
@ -1109,6 +1108,9 @@ public class TSDBPreparedStatementTest {
    @AfterClass
    public static void afterClass() {
        try {
            Statement statement = conn.createStatement();
            statement.execute("drop database if exists " + dbname);
            statement.close();
            if (conn != null)
                conn.close();
        } catch (SQLException e) {
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/BatchInsertTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/BatchInsertTest.java
@ -28,9 +28,7 @@ public class BatchInsertTest {
    @Before
    public void before() {
        try {
            Class.forName("com.taosdata.jdbc.TSDBDriver");
            Properties properties = new Properties();
            properties.setProperty(TSDBDriver.PROPERTY_KEY_HOST, host);
            properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
            properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
            properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
@ -44,7 +42,7 @@ public class BatchInsertTest {
            String createTableSql = "create table " + stbName + "(ts timestamp, f1 int, f2 int, f3 int) tags(areaid int, loc binary(20))";
            statement.executeUpdate(createTableSql);
            // create tables
-            for(int i = 0; i < numOfTables; i++) {
+            for (int i = 0; i < numOfTables; i++) {
                String loc = i % 2 == 0 ? "beijing" : "shanghai";
                String createSubTalbesSql = "create table " + tablePrefix + i + " using " + stbName + " tags(" + i + ", '" + loc + "')";
                statement.executeUpdate(createSubTalbesSql);
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/ConnectMultiTaosdByRestfulWithDifferentTokenTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/ConnectMultiTaosdByRestfulWithDifferentTokenTest.java
@ -0,0 +1,59 @@
 package com.taosdata.jdbc.cases;
 import com.taosdata.jdbc.TSDBDriver;
 import org.junit.Before;
 import org.junit.Test;
 import java.sql.*;
 import java.util.Properties;
 public class ConnectMultiTaosdByRestfulWithDifferentTokenTest {
    private static String host1 = "192.168.17.156";
    private static String user1 = "root";
    private static String password1 = "tqueue";
    private Connection conn1;
    private static String host2 = "192.168.17.82";
    private static String user2 = "root";
    private static String password2 = "taosdata";
    private Connection conn2;
    @Test
    public void test() {
        //when
        executeSelectStatus(conn1);
        executeSelectStatus(conn2);
        executeSelectStatus(conn1);
    }
    private void executeSelectStatus(Connection connection) {
        try (Statement stmt = connection.createStatement()) {
            ResultSet rs = stmt.executeQuery("select server_status()");
            ResultSetMetaData meta = rs.getMetaData();
            while (rs.next()) {
                for (int i = 1; i <= meta.getColumnCount(); i++) {
                    System.out.println(meta.getColumnLabel(i) + ": " + rs.getString(i));
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    @Before
    public void before() {
        Properties properties = new Properties();
        properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
        properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
        properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
        String url1 = "jdbc:TAOS-RS://" + host1 + ":6041/?user=" + user1 + "&password=" + password1;
        String url2 = "jdbc:TAOS-RS://" + host2 + ":6041/?user=" + user2 + "&password=" + password2;
        try {
            conn1 = DriverManager.getConnection(url1, properties);
            conn2 = DriverManager.getConnection(url2, properties);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
 }
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/DoubleQuoteInSqlTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/DoubleQuoteInSqlTest.java
@ -7,56 +7,64 @@ import org.junit.*;
 import java.sql.*;
 import java.util.Properties;
-public class TD4174Test {
+public class DoubleQuoteInSqlTest {
    private Connection conn;
    private static final String host = "127.0.0.1";
    private static final String dbname = "td4174";
    private Connection conn;
    @Test
    public void test() {
        // given
        long ts = System.currentTimeMillis();
        try (PreparedStatement pstmt = conn.prepareStatement("insert into weather values(" + ts + ", ?)")) {
            JSONObject value = new JSONObject();
            value.put("name", "John Smith");
            value.put("age", 20);
            Assert.assertEquals("{\"name\":\"John Smith\",\"age\":20}",value.toJSONString());
            pstmt.setString(1, value.toJSONString());
            int ret = pstmt.executeUpdate();
            Assert.assertEquals(1, ret);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        JSONObject value = new JSONObject();
        value.put("name", "John Smith");
        value.put("age", 20);
-        System.out.println(value.toJSONString());
+
        // when
        int ret = 0;
        try (PreparedStatement pstmt = conn.prepareStatement("insert into weather values(" + ts + ", ?)")) {
            pstmt.setString(1, value.toJSONString());
            ret = pstmt.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        // then
        Assert.assertEquals("{\"name\":\"John Smith\",\"age\":20}", value.toJSONString());
        Assert.assertEquals(1, ret);
    }
    @Before
-    public void before() throws SQLException {
+    public void before() {
        String url = "jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata";
        Properties properties = new Properties();
        properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
        properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
        properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
-        conn = DriverManager.getConnection(url, properties);
+        try {
-        try (Statement stmt = conn.createStatement()) {
+            conn = DriverManager.getConnection(url, properties);
-            stmt.execute("drop database if exists td4174");
+            Statement stmt = conn.createStatement();
-            stmt.execute("create database if not exists td4174");
+            stmt.execute("drop database if exists " + dbname);
-            stmt.execute("use td4174");
+            stmt.execute("create database if not exists " + dbname);
            stmt.execute("use " + dbname);
            stmt.execute("create table weather(ts timestamp, text binary(64))");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    @After
-    public void after() throws SQLException {
+    public void after() {
-        if (conn != null)
+        try {
            Statement stmt = conn.createStatement();
            stmt.execute("drop database if exists " + dbname);
            stmt.close();
            conn.close();
-
+        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
 }
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/TwoTypeTimestampPercisionInJniTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/TwoTypeTimestampPercisionInJniTest.java
@ -10,7 +10,7 @@ import org.junit.Test;
 import java.sql.*;
 import java.util.Properties;
-public class TwoTypeTimestampPercisionInJniTest {
+public class MicroSecondPrecisionJNITest {
    private static final String host = "127.0.0.1";
    private static final String ms_timestamp_db = "ms_precision_test";
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/TwoTypeTimestampPercisionInRestfulTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/TwoTypeTimestampPercisionInRestfulTest.java
@ -10,10 +10,9 @@ import org.junit.Test;
 import java.sql.*;
 import java.util.Properties;
-public class TwoTypeTimestampPercisionInRestfulTest {
+public class MicroSecondPrecisionRestfulTest {
    private static final String host = "127.0.0.1";
    private static final String ms_timestamp_db = "ms_precision_test";
    private static final String us_timestamp_db = "us_precision_test";
    private static final long timestamp1 = System.currentTimeMillis();
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NanoSecondTimestampJNITest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NanoSecondTimestampJNITest.java
@ -0,0 +1,182 @@
 package com.taosdata.jdbc.cases;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
 import java.sql.*;
 import java.time.Instant;
 import java.util.Random;
 public class NanoSecondTimestampJNITest {
    private static final String host = "127.0.0.1";
    private static final String dbname = "nano_sec_test";
    private static final Random random = new Random(System.currentTimeMillis());
    private static Connection conn;
    @Test
    public void insertUsingLongValue() {
        // given
        long ms = System.currentTimeMillis();
        long ns = ms * 1000_000 + random.nextInt(1000_000);
        // when
        int ret = 0;
        try (Statement stmt = conn.createStatement()) {
            ret = stmt.executeUpdate("insert into weather(ts, temperature, humidity) values(" + ns + ", 12.3, 4)");
        } catch (SQLException e) {
            e.printStackTrace();
        }
        // then
        Assert.assertEquals(1, ret);
    }
    @Test
    public void insertUsingStringValue() {
        // given
        // when
        int ret = 0;
        try (Statement stmt = conn.createStatement()) {
            ret = stmt.executeUpdate("insert into weather(ts, temperature, humidity) values('2021-01-01 12:00:00.123456789', 12.3, 4)");
        } catch (SQLException e) {
            e.printStackTrace();
        }
        // then
        Assert.assertEquals(1, ret);
    }
    @Test
    public void insertUsingTimestampValue() {
        // given
        long epochSec = System.currentTimeMillis() / 1000;
        long nanoAdjustment = random.nextInt(1000_000_000);
        Timestamp ts = Timestamp.from(Instant.ofEpochSecond(epochSec, nanoAdjustment));
        // when
        int ret = 0;
        String sql = "insert into weather(ts, temperature, humidity) values( ?, ?, ?)";
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setTimestamp(1, ts);
            pstmt.setFloat(2, 12.34f);
            pstmt.setInt(3, 55);
            ret = pstmt.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        // then
        Assert.assertEquals(1, ret);
    }
    @Test
    public void selectUsingLongValue() throws SQLException {
        // given
        long ms = System.currentTimeMillis();
        long ns = ms * 1000_000L + random.nextInt(1000_000);
        // when
        ResultSet rs = null;
        try (Statement stmt = conn.createStatement()) {
            stmt.executeUpdate("insert into weather(ts, temperature, humidity) values(" + ns + ", 12.3, 4)");
            rs = stmt.executeQuery("select * from weather");
            rs.next();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        // then
        long actual = rs.getLong(1);
        Assert.assertEquals(ms, actual);
        actual = rs.getLong("ts");
        Assert.assertEquals(ms, actual);
    }
    @Test
    public void selectUsingStringValue() throws SQLException {
        // given
        String timestampStr = "2021-01-01 12:00:00.123456789";
        // when
        ResultSet rs = null;
        try (Statement stmt = conn.createStatement()) {
            stmt.executeUpdate("insert into weather(ts, temperature, humidity) values('" + timestampStr + "', 12.3, 4)");
            rs = stmt.executeQuery("select * from weather");
            rs.next();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        // then
        String actual = rs.getString(1);
        Assert.assertEquals(timestampStr, actual);
        actual = rs.getString("ts");
        Assert.assertEquals(timestampStr, actual);
    }
    @Test
    public void selectUsingTimestampValue() throws SQLException {
        // given
        long timeMillis = System.currentTimeMillis();
        long epochSec = timeMillis / 1000;
        long nanoAdjustment = (timeMillis % 1000) * 1000_000L + random.nextInt(1000_000);
        Timestamp ts = Timestamp.from(Instant.ofEpochSecond(epochSec, nanoAdjustment));
        // insert one row
        String sql = "insert into weather(ts, temperature, humidity) values( ?, ?, ?)";
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setTimestamp(1, ts);
            pstmt.setFloat(2, 12.34f);
            pstmt.setInt(3, 55);
            pstmt.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        // when
        ResultSet rs = null;
        try (Statement stmt = conn.createStatement()) {
            rs = stmt.executeQuery("select * from weather");
            rs.next();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        // then
        Timestamp actual = rs.getTimestamp(1);
        Assert.assertEquals(ts, actual);
        actual = rs.getTimestamp("ts");
        Assert.assertEquals(ts, actual);
        Assert.assertEquals(timeMillis, actual.getTime());
        Assert.assertEquals(nanoAdjustment, actual.getNanos());
    }
    @Before
    public void before() {
        try (Statement stmt = conn.createStatement()) {
            stmt.execute("drop table if exists weather");
            stmt.execute("create table weather(ts timestamp, temperature float, humidity int)");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    @BeforeClass
    public static void beforeClass() {
        final String url = "jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata";
        try {
            conn = DriverManager.getConnection(url);
            Statement stmt = conn.createStatement();
            stmt.execute("drop database if exists " + dbname);
            stmt.execute("create database if not exists " + dbname + " precision 'ns'");
            stmt.execute("use " + dbname);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
 }
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NanoSecondTimestampRestfulTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NanoSecondTimestampRestfulTest.java
@ -0,0 +1,182 @@
 package com.taosdata.jdbc.cases;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
 import java.sql.*;
 import java.time.Instant;
 import java.util.Random;
 public class NanoSecondTimestampRestfulTest {
    private static final String host = "127.0.0.1";
    private static final String dbname = "nano_sec_test";
    private static final Random random = new Random(System.currentTimeMillis());
    private static Connection conn;
    @Test
    public void insertUsingLongValue() {
        // given
        long ms = System.currentTimeMillis();
        long ns = ms * 1000_000 + random.nextInt(1000_000);
        // when
        int ret = 0;
        try (Statement stmt = conn.createStatement()) {
            ret = stmt.executeUpdate("insert into weather(ts, temperature, humidity) values(" + ns + ", 12.3, 4)");
        } catch (SQLException e) {
            e.printStackTrace();
        }
        // then
        Assert.assertEquals(1, ret);
    }
    @Test
    public void insertUsingStringValue() {
        // given
        // when
        int ret = 0;
        try (Statement stmt = conn.createStatement()) {
            ret = stmt.executeUpdate("insert into weather(ts, temperature, humidity) values('2021-01-01 12:00:00.123456789', 12.3, 4)");
        } catch (SQLException e) {
            e.printStackTrace();
        }
        // then
        Assert.assertEquals(1, ret);
    }
    @Test
    public void insertUsingTimestampValue() {
        // given
        long epochSec = System.currentTimeMillis() / 1000;
        long nanoAdjustment = random.nextInt(1000_000_000);
        Timestamp ts = Timestamp.from(Instant.ofEpochSecond(epochSec, nanoAdjustment));
        // when
        int ret = 0;
        String sql = "insert into weather(ts, temperature, humidity) values( ?, ?, ?)";
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setTimestamp(1, ts);
            pstmt.setFloat(2, 12.34f);
            pstmt.setInt(3, 55);
            ret = pstmt.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        // then
        Assert.assertEquals(1, ret);
    }
    @Test
    public void selectUsingLongValue() throws SQLException {
        // given
        long ms = System.currentTimeMillis();
        long ns = ms * 1000_000L + random.nextInt(1000_000);
        // when
        ResultSet rs = null;
        try (Statement stmt = conn.createStatement()) {
            stmt.executeUpdate("insert into weather(ts, temperature, humidity) values(" + ns + ", 12.3, 4)");
            rs = stmt.executeQuery("select * from weather");
            rs.next();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        // then
        long actual = rs.getLong(1);
        Assert.assertEquals(ms, actual);
        actual = rs.getLong("ts");
        Assert.assertEquals(ms, actual);
    }
    @Test
    public void selectUsingStringValue() throws SQLException {
        // given
        String timestampStr = "2021-01-01 12:00:00.123456789";
        // when
        ResultSet rs = null;
        try (Statement stmt = conn.createStatement()) {
            stmt.executeUpdate("insert into weather(ts, temperature, humidity) values('" + timestampStr + "', 12.3, 4)");
            rs = stmt.executeQuery("select * from weather");
            rs.next();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        // then
        String actual = rs.getString(1);
        Assert.assertEquals(timestampStr, actual);
        actual = rs.getString("ts");
        Assert.assertEquals(timestampStr, actual);
    }
    @Test
    public void selectUsingTimestampValue() throws SQLException {
        // given
        long timeMillis = System.currentTimeMillis();
        long epochSec = timeMillis / 1000;
        long nanoAdjustment = (timeMillis % 1000) * 1000_000L + random.nextInt(1000_000);
        Timestamp ts = Timestamp.from(Instant.ofEpochSecond(epochSec, nanoAdjustment));
        // insert one row
        String sql = "insert into weather(ts, temperature, humidity) values( ?, ?, ?)";
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setTimestamp(1, ts);
            pstmt.setFloat(2, 12.34f);
            pstmt.setInt(3, 55);
            pstmt.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        // when
        ResultSet rs = null;
        try (Statement stmt = conn.createStatement()) {
            rs = stmt.executeQuery("select * from weather");
            rs.next();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        // then
        Timestamp actual = rs.getTimestamp(1);
        Assert.assertEquals(ts, actual);
        actual = rs.getTimestamp("ts");
        Assert.assertEquals(ts, actual);
        Assert.assertEquals(timeMillis, actual.getTime());
        Assert.assertEquals(nanoAdjustment, actual.getNanos());
    }
    @Before
    public void before() {
        try (Statement stmt = conn.createStatement()) {
            stmt.execute("drop table if exists weather");
            stmt.execute("create table weather(ts timestamp, temperature float, humidity int)");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    @BeforeClass
    public static void beforeClass() {
        final String url = "jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata";
        try {
            conn = DriverManager.getConnection(url);
            Statement stmt = conn.createStatement();
            stmt.execute("drop database if exists " + dbname);
            stmt.execute("create database if not exists " + dbname + " precision 'ns'");
            stmt.execute("use " + dbname);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
 }
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NullValueInResultSetForJdbcJniTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NullValueInResultSetForJdbcJniTest.java
@ -6,7 +6,7 @@ import org.junit.Test;
 import java.sql.*;
-public class NullValueInResultSetForJdbcJniTest {
+public class NullValueInResultSetJNITest {
    private static final String host = "127.0.0.1";
    Connection conn;
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NullValueInResultSetForJdbcRestfulTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NullValueInResultSetForJdbcRestfulTest.java
@ -6,7 +6,7 @@ import org.junit.Test;
 import java.sql.*;
-public class NullValueInResultSetForJdbcRestfulTest {
+public class NullValueInResultSetRestfulTest {
    private static final String host = "127.0.0.1";
    Connection conn;
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NullValueInResultSetTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NullValueInResultSetTest.java
@ -7,7 +7,7 @@ import org.junit.*;
 import java.sql.*;
 import java.util.Properties;
-public class TD3841Test {
+public class NullValueInResultSetTest {
    private static final String host = "127.0.0.1";
    private static Properties properties;
    private static Connection conn_restful;
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/PreparedStatementBatchInsertJNITest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/PreparedStatementBatchInsertJNITest.java
@ -0,0 +1,98 @@
 package com.taosdata.jdbc.cases;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import java.sql.*;
 import java.util.List;
 import java.util.Random;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 public class PreparedStatementBatchInsertJNITest {
    private static final String host = "127.0.0.1";
    private static final String dbname = "td4668";
    private final Random random = new Random(System.currentTimeMillis());
    private Connection conn;
    @Test
    public void test() {
        // given
        long ts = System.currentTimeMillis();
        List<Object[]> rows = IntStream.range(0, 10).mapToObj(i -> {
            Object[] row = new Object[6];
            final String groupId = String.format("%02d", random.nextInt(100));
            // table name (d + groupId)组合
            row[0] = "d" + groupId;
            // tag
            row[1] = groupId;
            // ts
            row[2] = ts + i;
            // current 电流
            row[3] = random.nextFloat();
            // voltage 电压
            row[4] = Math.random() > 0.5 ? 220 : 380;
            // phase 相位
            row[5] = random.nextInt(10);
            return row;
        }).collect(Collectors.toList());
        final String sql = "INSERT INTO ? (TS,CURRENT,VOLTAGE,PHASE) USING METERS TAGS (?)  VALUES (?,?,?,?)";
        // when
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            for (Object[] row : rows) {
                for (int i = 0; i < row.length; i++) {
                    pstmt.setObject(i + 1, row[i]);
                }
                pstmt.addBatch();
            }
            pstmt.executeBatch();
        } catch (SQLException e) {
            e.printStackTrace();
            Assert.fail();
        }
        // then
        try (Statement stmt = conn.createStatement()) {
            ResultSet rs = stmt.executeQuery("select * from meters");
            int count = 0;
            while (rs.next()) {
                count++;
            }
            Assert.assertEquals(10, count);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    @Before
    public void before() {
        try {
            conn = DriverManager.getConnection("jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata");
            Statement stmt = conn.createStatement();
            stmt.execute("drop database if exists " + dbname);
            stmt.execute("create database if not exists " + dbname);
            stmt.execute("use " + dbname);
            stmt.execute("create table meters(ts timestamp, current float, voltage int, phase int) tags(groupId int)");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    @After
    public void after() {
        try {
            Statement stmt = conn.createStatement();
            stmt.execute("drop database if exists " + dbname);
            stmt.close();
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
 }
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/PreparedStatementBatchInsertRestfulTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/PreparedStatementBatchInsertRestfulTest.java
@ -0,0 +1,98 @@
 package com.taosdata.jdbc.cases;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import java.sql.*;
 import java.util.List;
 import java.util.Random;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 public class PreparedStatementBatchInsertRestfulTest {
    private static final String host = "127.0.0.1";
    private static final String dbname = "td4668";
    private final Random random = new Random(System.currentTimeMillis());
    private Connection conn;
    @Test
    public void test() {
        // given
        long ts = System.currentTimeMillis();
        List<Object[]> rows = IntStream.range(0, 10).mapToObj(i -> {
            Object[] row = new Object[6];
            final String groupId = String.format("%02d", random.nextInt(100));
            // table name (d + groupId)组合
            row[0] = "d" + groupId;
            // tag
            row[1] = groupId;
            // ts
            row[2] = ts + i;
            // current 电流
            row[3] = random.nextFloat();
            // voltage 电压
            row[4] = Math.random() > 0.5 ? 220 : 380;
            // phase 相位
            row[5] = random.nextInt(10);
            return row;
        }).collect(Collectors.toList());
        final String sql = "INSERT INTO ? (TS,CURRENT,VOLTAGE,PHASE) USING METERS TAGS (?)  VALUES (?,?,?,?)";
        // when
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            for (Object[] row : rows) {
                for (int i = 0; i < row.length; i++) {
                    pstmt.setObject(i + 1, row[i]);
                }
                pstmt.addBatch();
            }
            pstmt.executeBatch();
        } catch (SQLException e) {
            e.printStackTrace();
            Assert.fail();
        }
        // then
        try (Statement stmt = conn.createStatement()) {
            ResultSet rs = stmt.executeQuery("select * from meters");
            int count = 0;
            while (rs.next()) {
                count++;
            }
            Assert.assertEquals(10, count);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    @Before
    public void before() {
        try {
            conn = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata");
            Statement stmt = conn.createStatement();
            stmt.execute("drop database if exists " + dbname);
            stmt.execute("create database if not exists " + dbname);
            stmt.execute("use " + dbname);
            stmt.execute("create table meters(ts timestamp, current float, voltage int, phase int) tags(groupId int)");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    @After
    public void after() {
        try {
            Statement stmt = conn.createStatement();
            stmt.execute("drop database if exists " + dbname);
            stmt.close();
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
 }
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/ResultSetMetaShouldNotBeNullRestfulTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/ResultSetMetaShouldNotBeNullRestfulTest.java
@ -0,0 +1,86 @@
 package com.taosdata.jdbc.cases;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import java.sql.*;
 public class ResultSetMetaShouldNotBeNullRestfulTest {
    private static final String host = "127.0.0.1";
    private static final String dbname = "td4745";
    private Connection connection;
    @Test
    public void testExecuteQuery() {
        // given
        ResultSetMetaData metaData = null;
        int columnCount = -1;
        // when
        try {
            Statement statement = connection.createStatement();
            metaData = statement.executeQuery("select * from weather").getMetaData();
            columnCount = metaData.getColumnCount();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        // then
        Assert.assertNotNull(metaData);
        Assert.assertEquals(0, columnCount);
    }
    @Test
    public void testExecute() {
        // given
        ResultSetMetaData metaData = null;
        int columnCount = -1;
        boolean execute = false;
        // when
        try {
            Statement statement = connection.createStatement();
            execute = statement.execute("select * from weather");
            metaData = statement.getResultSet().getMetaData();
            columnCount = metaData.getColumnCount();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        // then
        Assert.assertEquals(true, execute);
        Assert.assertNotNull(metaData);
        Assert.assertEquals(0, columnCount);
    }
    @Before
    public void before() {
        try {
            connection = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata");
            Statement stmt = connection.createStatement();
            stmt.execute("drop database if exists " + dbname);
            stmt.execute("create database if not exists " + dbname);
            stmt.execute("use " + dbname);
            stmt.execute("create table weather (ts timestamp, temperature float)");
            stmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    @After
    public void after() {
        try {
            Statement stmt = connection.createStatement();
            stmt.execute("drop database if exists " + dbname);
            stmt.close();
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
 }
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/TD4144Test.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/TD4144Test.java
@ -1,105 +0,0 @@
 package com.taosdata.jdbc.cases;
 import com.taosdata.jdbc.TSDBConnection;
 import com.taosdata.jdbc.TSDBDriver;
 import com.taosdata.jdbc.TSDBResultSet;
 import com.taosdata.jdbc.TSDBSubscribe;
 import org.junit.AfterClass;
 import org.junit.BeforeClass;
 import org.junit.Test;
 import java.sql.DriverManager;
 import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
 import java.sql.Statement;
 import java.util.Properties;
 import java.util.concurrent.TimeUnit;
 public class TD4144Test {
    private static TSDBConnection connection;
    private static final String host = "127.0.0.1";
    private static final String topic = "topic-meter-current-bg-10";
    private static final String sql = "select * from meters where current > 10";
    private static final String sql2 = "select * from meters where ts >= '2020-08-15 12:20:00.000'";
    @Test
    public void test() throws SQLException {
        TSDBSubscribe subscribe = null;
        TSDBResultSet res = null;
        boolean hasNext = false;
        try {
            subscribe = connection.subscribe(topic, sql, false);
            int count = 0;
            while (true) {
                // 等待1秒，避免频繁调用 consume，给服务端造成压力
                TimeUnit.SECONDS.sleep(1);
                if (res == null) {
                    // 消费数据
                    res = subscribe.consume();
                    hasNext = res.next();
                }
                if (res == null) {
                    continue;
                }
                ResultSetMetaData metaData = res.getMetaData();
                int number = 0;
                while (hasNext) {
                    int columnCount = metaData.getColumnCount();
                    for (int i = 1; i <= columnCount; i++) {
                        System.out.print(metaData.getColumnLabel(i) + ": " + res.getString(i) + "\t");
                    }
                    System.out.println();
                    count++;
                    number++;
                    hasNext = res.next();
                    if (!hasNext) {
                        res.close();
                        res = null;
                        System.out.println("rows： " + count);
                    }
                    if (hasNext == true && number >= 10) {
                        System.out.println("batch" + number);
                        break;
                    }
                }
            }
        } catch (SQLException | InterruptedException throwables) {
            throwables.printStackTrace();
        } finally {
            if (subscribe != null)
                subscribe.close(true);
        }
    }
    @BeforeClass
    public static void beforeClass() throws SQLException {
        Properties properties = new Properties();
        properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
        properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
        String url = "jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata";
        connection = (DriverManager.getConnection(url, properties)).unwrap(TSDBConnection.class);
        try (Statement stmt = connection.createStatement()) {
            stmt.execute("drop database if exists power");
            stmt.execute("create database if not exists power");
            stmt.execute("use power");
            stmt.execute("create table meters(ts timestamp, current float, voltage int, phase int) tags(location binary(64), groupId int)");
            stmt.execute("create table d1001 using meters tags(\"Beijing.Chaoyang\", 2)");
            stmt.execute("create table d1002 using meters tags(\"Beijing.Haidian\", 2)");
            stmt.execute("insert into d1001 values(\"2020-08-15 12:00:00.000\", 12, 220, 1),(\"2020-08-15 12:10:00.000\", 12.3, 220, 2),(\"2020-08-15 12:20:00.000\", 12.2, 220, 1)");
            stmt.execute("insert into d1002 values(\"2020-08-15 12:00:00.000\", 9.9, 220, 1),(\"2020-08-15 12:10:00.000\", 10.3, 220, 1),(\"2020-08-15 12:20:00.000\", 11.2, 220, 1)");
        }
    }
    @AfterClass
    public static void afterClass() throws SQLException {
        if (connection != null)
            connection.close();
    }
 }
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/utils/UtilsTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/utils/UtilsTest.java
@ -3,22 +3,98 @@ package com.taosdata.jdbc.utils;
 import org.junit.Assert;
 import org.junit.Test;
-import static org.junit.Assert.*;
+import java.util.stream.Stream;
 public class UtilsTest {
    @Test
    public void escapeSingleQuota() {
        // given
        String s = "'''''a\\'";
        // when
        String news = Utils.escapeSingleQuota(s);
        // then
        Assert.assertEquals("\\'\\'\\'\\'\\'a\\'", news);
        // given
        s = "\'''''a\\'";
        // when
        news = Utils.escapeSingleQuota(s);
        // then
        Assert.assertEquals("\\'\\'\\'\\'\\'a\\'", news);
        // given
        s = "\'\'\'\''a\\'";
        // when
        news = Utils.escapeSingleQuota(s);
        // then
        Assert.assertEquals("\\'\\'\\'\\'\\'a\\'", news);
    }
    @Test
    public void getNativeSqlReplaceQuestionMarks() {
        // given
        String nativeSql = "insert into ?.? (ts, temperature, humidity) using ?.? tags(?,?) values(now, ?, ?)";
        Object[] parameters = Stream.of("test", "t1", "test", "weather", "beijing", 1, 12.2, 4).toArray();
        // when
        String actual = Utils.getNativeSql(nativeSql, parameters);
        // then
        String expected = "insert into test.t1 (ts, temperature, humidity) using test.weather tags('beijing',1) values(now, 12.2, 4)";
        Assert.assertEquals(expected, actual);
    }
    @Test
    public void getNativeSqlReplaceQuestionMarks2() {
        // given
        String nativeSql = "INSERT INTO ? (TS,CURRENT,VOLTAGE,PHASE) USING METERS TAGS (?)  VALUES (?,?,?,?)";
        Object[] parameters = Stream.of("d1", 1, 123, 3.14, 220, 4).toArray();
        // when
        String actual = Utils.getNativeSql(nativeSql, parameters);
        // then
        String expected = "INSERT INTO d1 (TS,CURRENT,VOLTAGE,PHASE) USING METERS TAGS (1)  VALUES (123,3.14,220,4)";
        Assert.assertEquals(expected, actual);
    }
    @Test
    public void getNativeSqlReplaceNothing() {
        // given
        String nativeSql = "insert into test.t1 (ts, temperature, humidity) using test.weather tags('beijing',1) values(now, 12.2, 4)";
        // when
        String actual = Utils.getNativeSql(nativeSql, null);
        // then
        Assert.assertEquals(nativeSql, actual);
    }
    @Test
    public void getNativeSqlReplaceNothing2() {
        // given
        String nativeSql = "insert into test.t1 (ts, temperature, humidity) using test.weather tags('beijing',1) values(now, 12.2, 4)";
        Object[] parameters = Stream.of("test", "t1", "test", "weather", "beijing", 1, 12.2, 4).toArray();
        // when
        String actual = Utils.getNativeSql(nativeSql, parameters);
        // then
        Assert.assertEquals(nativeSql, actual);
    }
    @Test
    public void getNativeSqlReplaceNothing3() {
        // given
        String nativeSql = "insert into ?.? (ts, temperature, humidity) using ?.? tags(?,?) values(now, ?, ?)";
        // when
        String actual = Utils.getNativeSql(nativeSql, null);
        // then
        Assert.assertEquals(nativeSql, actual);
    }
 }
--- a/src/connector/python/setup.py
+++ b/src/connector/python/setup.py
@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 setuptools.setup(
    name="taos",
-    version="2.0.10",
+    version="2.0.11",
    author="Taosdata Inc.",
    author_email="support@taosdata.com",
    description="TDengine python client package",
--- a/src/connector/python/taos/cinterface.py
+++ b/src/connector/python/taos/cinterface.py
@ -14,12 +14,22 @@ def _convert_microsecond_to_datetime(micro):
    return datetime.datetime.fromtimestamp(micro / 1000000.0)
-def _crow_timestamp_to_python(data, num_of_rows, nbytes=None, micro=False):
+def _convert_nanosecond_to_datetime(nanosec):
    return nanosec
 def _crow_timestamp_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
    """Function to convert C bool row to python row
    """
    _timestamp_converter = _convert_millisecond_to_datetime
-    if micro:
+    if precision == FieldType.C_TIMESTAMP_MILLI:
        _timestamp_converter = _convert_millisecond_to_datetime
    elif precision == FieldType.C_TIMESTAMP_MICRO:
        _timestamp_converter = _convert_microsecond_to_datetime
    elif precision == FieldType.C_TIMESTAMP_NANO:
        _timestamp_converter = _convert_nanosecond_to_datetime
    else:
        raise DatabaseError("Unknown precision returned from database")
    return [
        None if ele == FieldType.C_BIGINT_NULL else _timestamp_converter(ele) for ele in ctypes.cast(
@ -28,7 +38,7 @@ def _crow_timestamp_to_python(data, num_of_rows, nbytes=None, micro=False):
            :abs(num_of_rows)]]
-def _crow_bool_to_python(data, num_of_rows, nbytes=None, micro=False):
+def _crow_bool_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
    """Function to convert C bool row to python row
    """
    return [
@ -38,7 +48,7 @@ def _crow_bool_to_python(data, num_of_rows, nbytes=None, micro=False):
            :abs(num_of_rows)]]
-def _crow_tinyint_to_python(data, num_of_rows, nbytes=None, micro=False):
+def _crow_tinyint_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
    """Function to convert C tinyint row to python row
    """
    return [None if ele == FieldType.C_TINYINT_NULL else ele for ele in ctypes.cast(
@ -49,7 +59,7 @@ def _crow_tinyint_unsigned_to_python(
        data,
        num_of_rows,
        nbytes=None,
-        micro=False):
+        precision=FieldType.C_TIMESTAMP_UNKNOWN):
    """Function to convert C tinyint row to python row
    """
    return [
@ -59,7 +69,7 @@ def _crow_tinyint_unsigned_to_python(
            :abs(num_of_rows)]]
-def _crow_smallint_to_python(data, num_of_rows, nbytes=None, micro=False):
+def _crow_smallint_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
    """Function to convert C smallint row to python row
    """
    return [
@ -70,7 +80,7 @@ def _crow_smallint_to_python(data, num_of_rows, nbytes=None, micro=False):
 def _crow_smallint_unsigned_to_python(
-        data, num_of_rows, nbytes=None, micro=False):
+        data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
    """Function to convert C smallint row to python row
    """
    return [
@ -80,14 +90,14 @@ def _crow_smallint_unsigned_to_python(
            :abs(num_of_rows)]]
-def _crow_int_to_python(data, num_of_rows, nbytes=None, micro=False):
+def _crow_int_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
    """Function to convert C int row to python row
    """
    return [None if ele == FieldType.C_INT_NULL else ele for ele in ctypes.cast(
        data, ctypes.POINTER(ctypes.c_int))[:abs(num_of_rows)]]
-def _crow_int_unsigned_to_python(data, num_of_rows, nbytes=None, micro=False):
+def _crow_int_unsigned_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
    """Function to convert C int row to python row
    """
    return [
@ -97,7 +107,7 @@ def _crow_int_unsigned_to_python(data, num_of_rows, nbytes=None, micro=False):
            :abs(num_of_rows)]]
-def _crow_bigint_to_python(data, num_of_rows, nbytes=None, micro=False):
+def _crow_bigint_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
    """Function to convert C bigint row to python row
    """
    return [None if ele == FieldType.C_BIGINT_NULL else ele for ele in ctypes.cast(
@ -108,7 +118,7 @@ def _crow_bigint_unsigned_to_python(
        data,
        num_of_rows,
        nbytes=None,
-        micro=False):
+        precision=FieldType.C_TIMESTAMP_UNKNOWN):
    """Function to convert C bigint row to python row
    """
    return [
@ -118,21 +128,21 @@ def _crow_bigint_unsigned_to_python(
            :abs(num_of_rows)]]
-def _crow_float_to_python(data, num_of_rows, nbytes=None, micro=False):
+def _crow_float_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
    """Function to convert C float row to python row
    """
    return [None if math.isnan(ele) else ele for ele in ctypes.cast(
        data, ctypes.POINTER(ctypes.c_float))[:abs(num_of_rows)]]
-def _crow_double_to_python(data, num_of_rows, nbytes=None, micro=False):
+def _crow_double_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
    """Function to convert C double row to python row
    """
    return [None if math.isnan(ele) else ele for ele in ctypes.cast(
        data, ctypes.POINTER(ctypes.c_double))[:abs(num_of_rows)]]
-def _crow_binary_to_python(data, num_of_rows, nbytes=None, micro=False):
+def _crow_binary_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
    """Function to convert C binary row to python row
    """
    assert(nbytes is not None)
@ -140,7 +150,7 @@ def _crow_binary_to_python(data, num_of_rows, nbytes=None, micro=False):
        'utf-8') for ele in (ctypes.cast(data, ctypes.POINTER(ctypes.c_char * nbytes)))[:abs(num_of_rows)]]
-def _crow_nchar_to_python(data, num_of_rows, nbytes=None, micro=False):
+def _crow_nchar_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
    """Function to convert C nchar row to python row
    """
    assert(nbytes is not None)
@ -159,7 +169,7 @@ def _crow_nchar_to_python(data, num_of_rows, nbytes=None, micro=False):
    return res
-def _crow_binary_to_python_block(data, num_of_rows, nbytes=None, micro=False):
+def _crow_binary_to_python_block(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
    """Function to convert C binary row to python row
    """
    assert(nbytes is not None)
@ -178,7 +188,7 @@ def _crow_binary_to_python_block(data, num_of_rows, nbytes=None, micro=False):
    return res
-def _crow_nchar_to_python_block(data, num_of_rows, nbytes=None, micro=False):
+def _crow_nchar_to_python_block(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
    """Function to convert C nchar row to python row
    """
    assert(nbytes is not None)
@ -448,8 +458,7 @@ class CTaosInterface(object):
            result, ctypes.byref(pblock))
        if num_of_rows == 0:
            return None, 0
-        isMicro = (CTaosInterface.libtaos.taos_result_precision(
+        precision = CTaosInterface.libtaos.taos_result_precision(result)
            result) == FieldType.C_TIMESTAMP_MICRO)
        blocks = [None] * len(fields)
        fieldL = CTaosInterface.libtaos.taos_fetch_lengths(result)
        fieldLen = [
@ -462,7 +471,7 @@ class CTaosInterface(object):
            if fields[i]['type'] not in _CONVERT_FUNC_BLOCK:
                raise DatabaseError("Invalid data type returned from database")
            blocks[i] = _CONVERT_FUNC_BLOCK[fields[i]['type']](
-                data, num_of_rows, fieldLen[i], isMicro)
+                data, num_of_rows, fieldLen[i], precision)
        return blocks, abs(num_of_rows)
@ -472,8 +481,7 @@ class CTaosInterface(object):
        pblock = CTaosInterface.libtaos.taos_fetch_row(result)
        if pblock:
            num_of_rows = 1
-            isMicro = (CTaosInterface.libtaos.taos_result_precision(
+            precision = CTaosInterface.libtaos.taos_result_precision(result)
                result) == FieldType.C_TIMESTAMP_MICRO)
            blocks = [None] * len(fields)
            fieldL = CTaosInterface.libtaos.taos_fetch_lengths(result)
            fieldLen = [
@ -490,7 +498,7 @@ class CTaosInterface(object):
                    blocks[i] = [None]
                else:
                    blocks[i] = _CONVERT_FUNC[fields[i]['type']](
-                        data, num_of_rows, fieldLen[i], isMicro)
+                        data, num_of_rows, fieldLen[i], precision)
        else:
            return None, 0
        return blocks, abs(num_of_rows)
--- a/src/connector/python/taos/constants.py
+++ b/src/connector/python/taos/constants.py
@ -40,3 +40,5 @@ class FieldType(object):
    # Timestamp precision definition
    C_TIMESTAMP_MILLI = 0
    C_TIMESTAMP_MICRO = 1
    C_TIMESTAMP_NANO = 2
    C_TIMESTAMP_UNKNOWN = 3
--- a/src/dnode/inc/dnodeCfg.h
+++ b/src/dnode/inc/dnodeCfg.h
@ -27,6 +27,7 @@ void    dnodeUpdateCfg(SDnodeCfg *cfg);
 int32_t dnodeGetDnodeId();
 void    dnodeGetClusterId(char *clusterId);
 void    dnodeGetCfg(int32_t *dnodeId, char *clusterId);
 void    dnodeSetDropped();
 #ifdef __cplusplus
 }
--- a/src/dnode/src/dnodeCfg.c
+++ b/src/dnode/src/dnodeCfg.c
@ -21,6 +21,7 @@
 static SDnodeCfg tsCfg = {0};
 static pthread_mutex_t tsCfgMutex;
 static int32_t tsDnodeDropped;
 static int32_t dnodeReadCfg();
 static int32_t dnodeWriteCfg();
@ -34,6 +35,10 @@ int32_t dnodeInitCfg() {
  if (ret == 0) {
    dInfo("dnode cfg is initialized");
  }
  if (tsDnodeDropped) {
    dInfo("dnode is dropped, exiting");
    return -1;
  }
  return ret;
 }
@ -44,6 +49,14 @@ void dnodeUpdateCfg(SDnodeCfg *cfg) {
  dnodeResetCfg(cfg);
 }
 void dnodeSetDropped() {
  pthread_mutex_lock(&tsCfgMutex);
  tsDnodeDropped = 1;
  dnodeWriteCfg();
  pthread_mutex_unlock(&tsCfgMutex);
 }
 int32_t dnodeGetDnodeId() {
  int32_t dnodeId = 0;
  pthread_mutex_lock(&tsCfgMutex);
@ -119,6 +132,14 @@ static int32_t dnodeReadCfg() {
  }
  cfg.dnodeId = (int32_t)dnodeId->valueint;
  cJSON *dnodeDropped = cJSON_GetObjectItem(root, "dnodeDropped");
  if (!dnodeDropped || dnodeDropped->type != cJSON_Number) {
    dError("failed to read %s, dnodeDropped not found", file);
    //goto PARSE_CFG_OVER;
  } else {
    tsDnodeDropped = (int32_t)dnodeDropped->valueint;
  }
  cJSON *clusterId = cJSON_GetObjectItem(root, "clusterId");
  if (!clusterId || clusterId->type != cJSON_String) {
    dError("failed to read %s, clusterId not found", file);
@ -154,6 +175,7 @@ static int32_t dnodeWriteCfg() {
  len += snprintf(content + len, maxLen - len, "{\n");
  len += snprintf(content + len, maxLen - len, "  \"dnodeId\": %d,\n", tsCfg.dnodeId);
  len += snprintf(content + len, maxLen - len, "  \"dnodeDropped\": %d,\n", tsDnodeDropped);
  len += snprintf(content + len, maxLen - len, "  \"clusterId\": \"%s\"\n", tsCfg.clusterId);
  len += snprintf(content + len, maxLen - len, "}\n");
--- a/src/dnode/src/dnodeVnodes.c
+++ b/src/dnode/src/dnodeVnodes.c
@ -202,6 +202,7 @@ static void dnodeProcessStatusRsp(SRpcMsg *pMsg) {
      char clusterId[TSDB_CLUSTER_ID_LEN];
      dnodeGetClusterId(clusterId);
      if (clusterId[0] != '\0') {
        dnodeSetDropped();
        dError("exit zombie dropped dnode");
        exit(EXIT_FAILURE);
      }
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@ -1475,6 +1475,7 @@ static int32_t mnodeChangeSuperTableColumn(SMnodeMsg *pMsg) {
  SSchema *schema = (SSchema *) (pStable->schema + col);
  ASSERT(schema->type == TSDB_DATA_TYPE_BINARY || schema->type == TSDB_DATA_TYPE_NCHAR);
  schema->bytes = pAlter->schema[0].bytes;
  pStable->sversion++;
  mInfo("msg:%p, app:%p stable %s, start to modify column %s len to %d", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
         name, schema->bytes);
@ -1504,6 +1505,7 @@ static int32_t mnodeChangeSuperTableTag(SMnodeMsg *pMsg) {
  SSchema *schema = (SSchema *) (pStable->schema + col + pStable->numOfColumns);
  ASSERT(schema->type == TSDB_DATA_TYPE_BINARY || schema->type == TSDB_DATA_TYPE_NCHAR);
  schema->bytes = pAlter->schema[0].bytes;
  pStable->tversion++;
  mInfo("msg:%p, app:%p stable %s, start to modify tag len %s to %d", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
         name, schema->bytes);
--- a/src/os/tests/CMakeLists.txt
+++ b/src/os/tests/CMakeLists.txt
@ -7,7 +7,12 @@ FIND_LIBRARY(LIB_GTEST_STATIC_DIR libgtest.a /usr/lib/ /usr/local/lib)
 IF (HEADER_GTEST_INCLUDE_DIR AND LIB_GTEST_STATIC_DIR)
    MESSAGE(STATUS "gTest library found, build unit test")
-    INCLUDE_DIRECTORIES(${HEADER_GTEST_INCLUDE_DIR})
+    # GoogleTest requires at least C++11
    SET(CMAKE_CXX_STANDARD 11)
    INCLUDE_DIRECTORIES(/usr/include /usr/local/include)
    LINK_DIRECTORIES(/usr/lib /usr/local/lib)
    AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SOURCE_LIST)
    ADD_EXECUTABLE(osTest ${SOURCE_LIST})
--- a/src/plugins/http/inc/httpParser.h
+++ b/src/plugins/http/inc/httpParser.h
@ -19,6 +19,70 @@
 #define HTTP_MAX_URL 5  // http url stack size
 #define HTTP_CODE_CONTINUE                 100
 #define HTTP_CODE_SWITCHING_PROTOCOL       101
 #define HTTP_CODE_PROCESSING               102
 #define HTTP_CODE_EARLY_HINTS              103
 #define HTTP_CODE_OK                       200
 #define HTTP_CODE_CREATED                  201
 #define HTTP_CODE_ACCEPTED                 202
 #define HTTP_CODE_NON_AUTHORITATIVE_INFO   203
 #define HTTP_CODE_NO_CONTENT               204
 #define HTTP_CODE_RESET_CONTENT            205
 #define HTTP_CODE_PARTIAL_CONTENT          206
 #define HTTP_CODE_MULTI_STATUS             207
 #define HTTP_CODE_ALREADY_REPORTED         208
 #define HTTP_CODE_IM_USED                  226
 #define HTTP_CODE_MULTIPLE_CHOICE          300
 #define HTTP_CODE_MOVED_PERMANENTLY        301
 #define HTTP_CODE_FOUND                    302
 #define HTTP_CODE_SEE_OTHER                303
 #define HTTP_CODE_NOT_MODIFIED             304
 #define HTTP_CODE_USE_PROXY                305
 #define HTTP_CODE_UNUSED                   306
 #define HTTP_CODE_TEMPORARY_REDIRECT       307
 #define HTTP_CODE_PERMANENT_REDIRECT       308
 #define HTTP_CODE_BAD_REQUEST              400
 #define HTTP_CODE_UNAUTHORIZED             401
 #define HTTP_CODE_PAYMENT_REQUIRED         402
 #define HTTP_CODE_FORBIDDEN                403
 #define HTTP_CODE_NOT_FOUND                404
 #define HTTP_CODE_METHOD_NOT_ALLOWED       405
 #define HTTP_CODE_NOT_ACCEPTABLE           406
 #define HTTP_CODE_PROXY_AUTH_REQUIRED      407
 #define HTTP_CODE_REQUEST_TIMEOUT          408
 #define HTTP_CODE_CONFLICT                 409
 #define HTTP_CODE_GONE                     410
 #define HTTP_CODE_LENGTH_REQUIRED          411
 #define HTTP_CODE_PRECONDITION_FAILED      412
 #define HTTP_CODE_PAYLOAD_TOO_LARGE        413
 #define HTTP_CODE_URI_TOO_LARGE            414
 #define HTTP_CODE_UNSUPPORTED_MEDIA_TYPE   415
 #define HTTP_CODE_RANGE_NOT_SATISFIABLE    416
 #define HTTP_CODE_EXPECTATION_FAILED       417
 #define HTTP_CODE_IM_A_TEAPOT              418
 #define HTTP_CODE_MISDIRECTED_REQUEST      421
 #define HTTP_CODE_UNPROCESSABLE_ENTITY     422
 #define HTTP_CODE_LOCKED                   423
 #define HTTP_CODE_FAILED_DEPENDENCY        424
 #define HTTP_CODE_TOO_EARLY                425
 #define HTTP_CODE_UPGRADE_REQUIRED         426
 #define HTTP_CODE_PRECONDITION_REQUIRED    428
 #define HTTP_CODE_TOO_MANY_REQUESTS        429
 #define HTTP_CODE_REQ_HDR_FIELDS_TOO_LARGE 431
 #define HTTP_CODE_UNAVAIL_4_LEGAL_REASONS  451
 #define HTTP_CODE_INTERNAL_SERVER_ERROR    500
 #define HTTP_CODE_NOT_IMPLEMENTED          501
 #define HTTP_CODE_BAD_GATEWAY              502
 #define HTTP_CODE_SERVICE_UNAVAILABLE      503
 #define HTTP_CODE_GATEWAY_TIMEOUT          504
 #define HTTP_CODE_HTTP_VER_NOT_SUPPORTED   505
 #define HTTP_CODE_VARIANT_ALSO_NEGOTIATES  506
 #define HTTP_CODE_INSUFFICIENT_STORAGE     507
 #define HTTP_CODE_LOOP_DETECTED            508
 #define HTTP_CODE_NOT_EXTENDED             510
 #define HTTP_CODE_NETWORK_AUTH_REQUIRED    511
 typedef enum HTTP_PARSER_STATE {
  HTTP_PARSER_BEGIN,
  HTTP_PARSER_REQUEST_OR_RESPONSE,
--- a/src/plugins/http/src/httpGcJson.c
+++ b/src/plugins/http/src/httpGcJson.c
@ -133,6 +133,16 @@ bool gcBuildQueryJson(HttpContext *pContext, HttpSqlCmd *cmd, TAOS_RES *result,
      int32_t len;
      len = snprintf(target, HTTP_GC_TARGET_SIZE, "%s{", aliasBuffer);
      for (int32_t i = dataFields + 1; i < num_fields; i++) {
        if (row[i] == NULL) {
          len += snprintf(target + len, HTTP_GC_TARGET_SIZE - len, "%s:nil", fields[i].name);
          if (i < num_fields - 1) {
            len += snprintf(target + len, HTTP_GC_TARGET_SIZE - len, ", ");
          }
          continue;
        }
        switch (fields[i].type) {
          case TSDB_DATA_TYPE_BOOL:
          case TSDB_DATA_TYPE_TINYINT:
--- a/src/plugins/http/src/httpParser.c
+++ b/src/plugins/http/src/httpParser.c
@ -25,70 +25,70 @@
 static void httpOnData(ehttp_gzip_t *gzip, void *arg, const char *buf, int32_t len);
 static HttpStatus httpStatusCodes[] = {
-  {100, "Continue"},
+  {HTTP_CODE_CONTINUE,                "Continue"},
-  {101, "Switching Protocol"},
+  {HTTP_CODE_SWITCHING_PROTOCOL,      "Switching Protocol"},
-  {102, "Processing (WebDAV)"},
+  {HTTP_CODE_PROCESSING,              "Processing (WebDAV)"},
-  {103, "Early Hints"},
+  {HTTP_CODE_EARLY_HINTS,             "Early Hints"},
-  {200, "OK"},
+  {HTTP_CODE_OK,                      "OK"},
-  {201, "Created"},
+  {HTTP_CODE_CREATED,                 "Created"},
-  {202, "Accepted"},
+  {HTTP_CODE_ACCEPTED,                "Accepted"},
-  {203, "Non-Authoritative Information"},
+  {HTTP_CODE_NON_AUTHORITATIVE_INFO,  "Non-Authoritative Information"},
-  {204, "No Content"},
+  {HTTP_CODE_NO_CONTENT,              "No Content"},
-  {205, "Reset Content"},
+  {HTTP_CODE_RESET_CONTENT,           "Reset Content"},
-  {206, "Partial Content"},
+  {HTTP_CODE_PARTIAL_CONTENT,         "Partial Content"},
-  {207, "Multi-Status (WebDAV)"},
+  {HTTP_CODE_MULTI_STATUS,            "Multi-Status (WebDAV)"},
-  {208, "Already Reported (WebDAV)"},
+  {HTTP_CODE_ALREADY_REPORTED,        "Already Reported (WebDAV)"},
-  {226, "IM Used (HTTP Delta encoding)"},
+  {HTTP_CODE_IM_USED,                 "IM Used (HTTP Delta encoding)"},
-  {300, "Multiple Choice"},
+  {HTTP_CODE_MULTIPLE_CHOICE,         "Multiple Choice"},
-  {301, "Moved Permanently"},
+  {HTTP_CODE_MOVED_PERMANENTLY,       "Moved Permanently"},
-  {302, "Found"},
+  {HTTP_CODE_FOUND,                   "Found"},
-  {303, "See Other"},
+  {HTTP_CODE_SEE_OTHER,               "See Other"},
-  {304, "Not Modified"},
+  {HTTP_CODE_NOT_MODIFIED,            "Not Modified"},
-  {305, "Use Proxy"},
+  {HTTP_CODE_USE_PROXY,               "Use Proxy"},
-  {306, "unused"},
+  {HTTP_CODE_UNUSED,                  "unused"},
-  {307, "Temporary Redirect"},
+  {HTTP_CODE_TEMPORARY_REDIRECT,      "Temporary Redirect"},
-  {308, "Permanent Redirect"},
+  {HTTP_CODE_PERMANENT_REDIRECT,      "Permanent Redirect"},
-  {400, "Bad Request"},
+  {HTTP_CODE_BAD_REQUEST,             "Bad Request"},
-  {401, "Unauthorized"},
+  {HTTP_CODE_UNAUTHORIZED,            "Unauthorized"},
-  {402, "Payment Required"},
+  {HTTP_CODE_PAYMENT_REQUIRED,        "Payment Required"},
-  {403, "Forbidden"},
+  {HTTP_CODE_FORBIDDEN,               "Forbidden"},
-  {404, "Not Found"},
+  {HTTP_CODE_NOT_FOUND,               "Not Found"},
-  {405, "Method Not Allowed"},
+  {HTTP_CODE_METHOD_NOT_ALLOWED,      "Method Not Allowed"},
-  {406, "Not Acceptable"},
+  {HTTP_CODE_NOT_ACCEPTABLE,          "Not Acceptable"},
-  {407, "Proxy Authentication Required"},
+  {HTTP_CODE_PROXY_AUTH_REQUIRED,     "Proxy Authentication Required"},
-  {408, "Request Timeout"},
+  {HTTP_CODE_REQUEST_TIMEOUT,         "Request Timeout"},
-  {409, "Conflict"},
+  {HTTP_CODE_CONFLICT,                "Conflict"},
-  {410, "Gone"},
+  {HTTP_CODE_GONE,                    "Gone"},
-  {411, "Length Required"},
+  {HTTP_CODE_LENGTH_REQUIRED,         "Length Required"},
-  {412, "Precondition Failed"},
+  {HTTP_CODE_PRECONDITION_FAILED,     "Precondition Failed"},
-  {413, "Payload Too Large"},
+  {HTTP_CODE_PAYLOAD_TOO_LARGE,       "Payload Too Large"},
-  {414, "URI Too Long"},
+  {HTTP_CODE_URI_TOO_LARGE,           "URI Too Long"},
-  {415, "Unsupported Media Type"},
+  {HTTP_CODE_UNSUPPORTED_MEDIA_TYPE,  "Unsupported Media Type"},
-  {416, "Range Not Satisfiable"},
+  {HTTP_CODE_RANGE_NOT_SATISFIABLE,   "Range Not Satisfiable"},
-  {417, "Expectation Failed"},
+  {HTTP_CODE_EXPECTATION_FAILED,      "Expectation Failed"},
-  {418, "I'm a teapot"},
+  {HTTP_CODE_IM_A_TEAPOT,             "I'm a teapot"},
-  {421, "Misdirected Request"},
+  {HTTP_CODE_MISDIRECTED_REQUEST,     "Misdirected Request"},
-  {422, "Unprocessable Entity (WebDAV)"},
+  {HTTP_CODE_UNPROCESSABLE_ENTITY,    "Unprocessable Entity (WebDAV)"},
-  {423, "Locked (WebDAV)"},
+  {HTTP_CODE_LOCKED,                  "Locked (WebDAV)"},
-  {424, "Failed Dependency (WebDAV)"},
+  {HTTP_CODE_FAILED_DEPENDENCY,       "Failed Dependency (WebDAV)"},
-  {425, "Too Early"},
+  {HTTP_CODE_TOO_EARLY,               "Too Early"},
-  {426, "Upgrade Required"},
+  {HTTP_CODE_UPGRADE_REQUIRED,        "Upgrade Required"},
-  {428, "Precondition Required"},
+  {HTTP_CODE_PRECONDITION_REQUIRED,   "Precondition Required"},
-  {429, "Too Many Requests"},
+  {HTTP_CODE_TOO_MANY_REQUESTS,       "Too Many Requests"},
-  {431, "Request Header Fields Too Large"},
+  {HTTP_CODE_REQ_HDR_FIELDS_TOO_LARGE,"Request Header Fields Too Large"},
-  {451, "Unavailable For Legal Reasons"},
+  {HTTP_CODE_UNAVAIL_4_LEGAL_REASONS, "Unavailable For Legal Reasons"},
-  {500, "Internal Server Error"},
+  {HTTP_CODE_INTERNAL_SERVER_ERROR,   "Internal Server Error"},
-  {501, "Not Implemented"},
+  {HTTP_CODE_NOT_IMPLEMENTED,         "Not Implemented"},
-  {502, "Bad Gateway"},
+  {HTTP_CODE_BAD_GATEWAY,             "Bad Gateway"},
-  {503, "Service Unavailable"},
+  {HTTP_CODE_SERVICE_UNAVAILABLE,     "Service Unavailable"},
-  {504, "Gateway Timeout"},
+  {HTTP_CODE_GATEWAY_TIMEOUT,         "Gateway Timeout"},
-  {505, "HTTP Version Not Supported"},
+  {HTTP_CODE_HTTP_VER_NOT_SUPPORTED,  "HTTP Version Not Supported"},
-  {506, "Variant Also Negotiates"},
+  {HTTP_CODE_VARIANT_ALSO_NEGOTIATES, "Variant Also Negotiates"},
-  {507, "Insufficient Storage"},
+  {HTTP_CODE_INSUFFICIENT_STORAGE,    "Insufficient Storage"},
-  {508, "Loop Detected (WebDAV)"},
+  {HTTP_CODE_LOOP_DETECTED,           "Loop Detected (WebDAV)"},
-  {510, "Not Extended"},
+  {HTTP_CODE_NOT_EXTENDED,            "Not Extended"},
-  {511, "Network Authentication Required"},
+  {HTTP_CODE_NETWORK_AUTH_REQUIRED,   "Network Authentication Required"},
-  {0,   NULL}
+  {0,                                 NULL}
 };
 char *httpGetStatusDesc(int32_t statusCode) {
@ -552,7 +552,7 @@ static int32_t httpParserOnBegin(HttpParser *parser, HTTP_PARSER_STATE state, co
      if (httpAppendString(&parser->str, &c, 1)) {
        httpError("context:%p, fd:%d, parser state:%d, char:[%c]%02x, oom", pContext, pContext->fd, state, c, c);
        ok = -1;
-        httpOnError(parser, 507, TSDB_CODE_HTTP_PARSE_METHOD_FAILED);
+        httpOnError(parser, HTTP_CODE_INSUFFICIENT_STORAGE, TSDB_CODE_HTTP_PARSE_METHOD_FAILED);
        break;
      }
      httpPopStack(parser);
@ -561,7 +561,7 @@ static int32_t httpParserOnBegin(HttpParser *parser, HTTP_PARSER_STATE state, co
    }
    httpError("context:%p, fd:%d, parser state:%d, unexpected char:[%c]%02x", pContext, pContext->fd, state, c, c);
    ok = -1;
-    httpOnError(parser, 400, TSDB_CODE_HTTP_PARSE_METHOD_FAILED);
+    httpOnError(parser, HTTP_CODE_BAD_REQUEST, TSDB_CODE_HTTP_PARSE_METHOD_FAILED);
  } while (0);
  return ok;
 }
@ -599,7 +599,7 @@ static int32_t httpParserOnRquestOrResponse(HttpParser *parser, HTTP_PARSER_STAT
    httpError("context:%p, fd:%d, parser state:%d, unexpected char:[%c]%02x", pContext, pContext->fd, state, c, c);
    ok = -1;
-    httpOnError(parser, 400, TSDB_CODE_HTTP_PARSE_METHOD_FAILED);
+    httpOnError(parser, HTTP_CODE_BAD_REQUEST, TSDB_CODE_HTTP_PARSE_METHOD_FAILED);
  } while (0);
  return ok;
 }
@ -612,7 +612,7 @@ static int32_t httpParserOnMethod(HttpParser *parser, HTTP_PARSER_STATE state, c
      if (httpAppendString(&parser->str, &c, 1)) {
        httpError("context:%p, fd:%d, parser state:%d, char:[%c]%02x, oom", pContext, pContext->fd, state, c, c);
        ok = -1;
-        httpOnError(parser, 507, TSDB_CODE_HTTP_PARSE_METHOD_FAILED);
+        httpOnError(parser, HTTP_CODE_INSUFFICIENT_STORAGE, TSDB_CODE_HTTP_PARSE_METHOD_FAILED);
        break;
      }
      break;
@ -621,7 +621,7 @@ static int32_t httpParserOnMethod(HttpParser *parser, HTTP_PARSER_STATE state, c
    if (!parser->method) {
      httpError("context:%p, fd:%d, parser state:%d, char:[%c]%02x, oom", pContext, pContext->fd, state, c, c);
      ok = -1;
-      httpOnError(parser, 507, TSDB_CODE_HTTP_PARSE_METHOD_FAILED);
+      httpOnError(parser, HTTP_CODE_INSUFFICIENT_STORAGE, TSDB_CODE_HTTP_PARSE_METHOD_FAILED);
      break;
    } else {
      httpTrace("context:%p, fd:%d, httpMethod:%s", pContext, pContext->fd, parser->method);
@ -641,7 +641,7 @@ static int32_t httpParserOnTarget(HttpParser *parser, HTTP_PARSER_STATE state, c
      if (httpAppendString(&parser->str, &c, 1)) {
        httpError("context:%p, fd:%d, parser state:%d, char:[%c]%02x, oom", pContext, pContext->fd, state, c, c);
        ok = -1;
-        httpOnError(parser, 507, TSDB_CODE_HTTP_PARSE_TARGET_FAILED);
+        httpOnError(parser, HTTP_CODE_INSUFFICIENT_STORAGE, TSDB_CODE_HTTP_PARSE_TARGET_FAILED);
        break;
      }
      break;
@ -650,7 +650,7 @@ static int32_t httpParserOnTarget(HttpParser *parser, HTTP_PARSER_STATE state, c
    if (!parser->target) {
      httpError("context:%p, fd:%d, parser state:%d, char:[%c]%02x, oom", pContext, pContext->fd, state, c, c);
      ok = -1;
-      httpOnError(parser, 507, TSDB_CODE_HTTP_PARSE_TARGET_FAILED);
+      httpOnError(parser, HTTP_CODE_INSUFFICIENT_STORAGE, TSDB_CODE_HTTP_PARSE_TARGET_FAILED);
      break;
    }
    httpClearString(&parser->str);
@ -670,13 +670,13 @@ static int32_t httpParserOnVersion(HttpParser *parser, HTTP_PARSER_STATE state,
      if (prefix[parser->str.pos] != c) {
        httpError("context:%p, fd:%d, parser state:%d, unexpected char:[%c]%02x", pContext, pContext->fd, state, c, c);
        ok = -1;
-        httpOnError(parser, 400, TSDB_CODE_HTTP_PARSE_VERSION_FAILED);
+        httpOnError(parser, HTTP_CODE_BAD_REQUEST, TSDB_CODE_HTTP_PARSE_VERSION_FAILED);
        break;
      }
      if (httpAppendString(&parser->str, &c, 1)) {
        httpError("context:%p, fd:%d, parser state:%d, char:[%c]%02x, oom", pContext, pContext->fd, state, c, c);
        ok = -1;
-        httpOnError(parser, 507, TSDB_CODE_HTTP_PARSE_VERSION_FAILED);
+        httpOnError(parser, HTTP_CODE_INSUFFICIENT_STORAGE, TSDB_CODE_HTTP_PARSE_VERSION_FAILED);
        break;
      }
      break;
@ -685,14 +685,14 @@ static int32_t httpParserOnVersion(HttpParser *parser, HTTP_PARSER_STATE state,
    if (c != '0' && c != '1' && c != '2') {
      httpError("context:%p, fd:%d, parser state:%d, unexpected char:[%c]%02x", pContext, pContext->fd, state, c, c);
      ok = -1;
-      httpOnError(parser, 400, TSDB_CODE_HTTP_PARSE_VERSION_FAILED);
+      httpOnError(parser, HTTP_CODE_BAD_REQUEST, TSDB_CODE_HTTP_PARSE_VERSION_FAILED);
      break;
    }
    if (httpAppendString(&parser->str, &c, 1)) {
      httpError("context:%p, fd:%d, parser state:%d, char:[%c]%02x, oom", pContext, pContext->fd, state, c, c);
      ok = -1;
-      httpOnError(parser, 507, TSDB_CODE_HTTP_PARSE_VERSION_FAILED);
+      httpOnError(parser, HTTP_CODE_INSUFFICIENT_STORAGE, TSDB_CODE_HTTP_PARSE_VERSION_FAILED);
      break;
    }
@ -709,7 +709,7 @@ static int32_t httpParserOnVersion(HttpParser *parser, HTTP_PARSER_STATE state,
    if (!parser->version) {
      httpError("context:%p, fd:%d, parser state:%d, char:[%c]%02x, oom", pContext, pContext->fd, state, c, c);
      ok = -1;
-      httpOnError(parser, 507, TSDB_CODE_HTTP_PARSE_VERSION_FAILED);
+      httpOnError(parser, HTTP_CODE_INSUFFICIENT_STORAGE, TSDB_CODE_HTTP_PARSE_VERSION_FAILED);
      break;
    }
@ -739,7 +739,7 @@ static int32_t httpParserOnSp(HttpParser *parser, HTTP_PARSER_STATE state, const
    }
    httpError("context:%p, fd:%d, parser state:%d, char:[%c]%02x, oom", pContext, pContext->fd, state, c, c);
    ok = -1;
-    httpOnError(parser, 507, TSDB_CODE_HTTP_PARSE_SP_FAILED);
+    httpOnError(parser, HTTP_CODE_INSUFFICIENT_STORAGE, TSDB_CODE_HTTP_PARSE_SP_FAILED);
  } while (0);
  return ok;
 }
@ -752,7 +752,7 @@ static int32_t httpParserOnStatusCode(HttpParser *parser, HTTP_PARSER_STATE stat
      if (httpAppendString(&parser->str, &c, 1)) {
        httpError("context:%p, fd:%d, parser state:%d, char:[%c]%02x, oom", pContext, pContext->fd, state, c, c);
        ok = -1;
-        httpOnError(parser, 507, TSDB_CODE_HTTP_PARSE_STATUS_FAILED);
+        httpOnError(parser, HTTP_CODE_INSUFFICIENT_STORAGE, TSDB_CODE_HTTP_PARSE_STATUS_FAILED);
        break;
      }
      if (parser->str.pos < 3) break;
@ -764,7 +764,7 @@ static int32_t httpParserOnStatusCode(HttpParser *parser, HTTP_PARSER_STATE stat
    }
    httpError("context:%p, fd:%d, parser state:%d, unexpected char:[%c]%02x", pContext, pContext->fd, state, c, c);
    ok = -1;
-    httpOnError(parser, 400, TSDB_CODE_HTTP_PARSE_STATUS_FAILED);
+    httpOnError(parser, HTTP_CODE_BAD_REQUEST, TSDB_CODE_HTTP_PARSE_STATUS_FAILED);
  } while (0);
  return ok;
 }
@ -778,7 +778,7 @@ static int32_t httpParserOnReasonPhrase(HttpParser *parser, HTTP_PARSER_STATE st
      if (!parser->reasonPhrase) {
        httpError("context:%p, fd:%d, parser state:%d, char:[%c]%02x, oom", pContext, pContext->fd, state, c, c);
        ok = -1;
-        httpOnError(parser, 507, TSDB_CODE_HTTP_PARSE_PHRASE_FAILED);
+        httpOnError(parser, HTTP_CODE_INSUFFICIENT_STORAGE, TSDB_CODE_HTTP_PARSE_PHRASE_FAILED);
        break;
      }
      ok = httpOnStatusLine(parser, parser->statusCode, parser->reasonPhrase);
@ -790,7 +790,7 @@ static int32_t httpParserOnReasonPhrase(HttpParser *parser, HTTP_PARSER_STATE st
    if (httpAppendString(&parser->str, &c, 1)) {
      httpError("context:%p, fd:%d, parser state:%d, char:[%c]%02x, oom", pContext, pContext->fd, state, c, c);
      ok = -1;
-      httpOnError(parser, 507, TSDB_CODE_HTTP_PARSE_PHRASE_FAILED);
+      httpOnError(parser, HTTP_CODE_INSUFFICIENT_STORAGE, TSDB_CODE_HTTP_PARSE_PHRASE_FAILED);
      break;
    }
  } while (0);
@ -802,7 +802,7 @@ static int32_t httpParserPostProcess(HttpParser *parser) {
  if (parser->gzip) {
    if (ehttp_gzip_finish(parser->gzip)) {
      httpError("context:%p, fd:%d, gzip failed", pContext, pContext->fd);
-      httpOnError(parser, 507, TSDB_CODE_HTTP_FINISH_GZIP_FAILED);
+      httpOnError(parser, HTTP_CODE_INSUFFICIENT_STORAGE, TSDB_CODE_HTTP_FINISH_GZIP_FAILED);
      return -1;
    }
  }
@ -819,13 +819,13 @@ static int32_t httpParserOnCrlf(HttpParser *parser, HTTP_PARSER_STATE state, con
    if (s[parser->str.pos] != c) {
      httpError("context:%p, fd:%d, parser state:%d, unexpected char:[%c]%02x", pContext, pContext->fd, state, c, c);
      ok = -1;
-      httpOnError(parser, 400, TSDB_CODE_HTTP_PARSE_CRLF_FAILED);
+      httpOnError(parser, HTTP_CODE_BAD_REQUEST, TSDB_CODE_HTTP_PARSE_CRLF_FAILED);
      break;
    }
    if (httpAppendString(&parser->str, &c, 1)) {
      httpError("context:%p, fd:%d, parser state:%d, char:[%c]%02x, oom", pContext, pContext->fd, state, c, c);
      ok = -1;
-      httpOnError(parser, 507, TSDB_CODE_HTTP_PARSE_CRLF_FAILED);
+      httpOnError(parser, HTTP_CODE_INSUFFICIENT_STORAGE, TSDB_CODE_HTTP_PARSE_CRLF_FAILED);
      break;
    }
    if (parser->str.pos == len) {
@ -862,7 +862,7 @@ static int32_t httpParserOnHeader(HttpParser *parser, HTTP_PARSER_STATE state, c
      if (httpAppendString(&parser->str, &c, 1)) {
        httpError("context:%p, fd:%d, parser state:%d, char:[%c]%02x, oom", pContext, pContext->fd, state, c, c);
        ok = -1;
-        httpOnError(parser, 507, TSDB_CODE_HTTP_PARSE_HEADER_FAILED);
+        httpOnError(parser, HTTP_CODE_INSUFFICIENT_STORAGE, TSDB_CODE_HTTP_PARSE_HEADER_FAILED);
        break;
      }
      httpPushStack(parser, HTTP_PARSER_CRLF);
@ -873,7 +873,7 @@ static int32_t httpParserOnHeader(HttpParser *parser, HTTP_PARSER_STATE state, c
    }
    httpError("context:%p, fd:%d, parser state:%d, unexpected char:[%c]%02x", pContext, pContext->fd, state, c, c);
    ok = -1;
-    httpOnError(parser, 400, TSDB_CODE_HTTP_PARSE_HEADER_FAILED);
+    httpOnError(parser, HTTP_CODE_BAD_REQUEST, TSDB_CODE_HTTP_PARSE_HEADER_FAILED);
  } while (0);
  return ok;
 }
@ -886,7 +886,7 @@ static int32_t httpParserOnHeaderKey(HttpParser *parser, HTTP_PARSER_STATE state
      if (httpAppendString(&parser->str, &c, 1)) {
        httpError("context:%p, fd:%d, parser state:%d, char:[%c]%02x, oom", pContext, pContext->fd, state, c, c);
        ok = -1;
-        httpOnError(parser, 507, TSDB_CODE_HTTP_PARSE_HEADER_KEY_FAILED);
+        httpOnError(parser, HTTP_CODE_INSUFFICIENT_STORAGE, TSDB_CODE_HTTP_PARSE_HEADER_KEY_FAILED);
        break;
      }
      break;
@ -896,7 +896,7 @@ static int32_t httpParserOnHeaderKey(HttpParser *parser, HTTP_PARSER_STATE state
      if (!parser->key) {
        httpError("context:%p, fd:%d, parser state:%d, char:[%c]%02x, oom", pContext, pContext->fd, state, c, c);
        ok = -1;
-        httpOnError(parser, 507, TSDB_CODE_HTTP_PARSE_HEADER_KEY_FAILED);
+        httpOnError(parser, HTTP_CODE_INSUFFICIENT_STORAGE, TSDB_CODE_HTTP_PARSE_HEADER_KEY_FAILED);
        break;
      }
      httpClearString(&parser->str);
@ -905,7 +905,7 @@ static int32_t httpParserOnHeaderKey(HttpParser *parser, HTTP_PARSER_STATE state
    }
    httpError("context:%p, fd:%d, parser state:%d, unexpected char:[%c]%02x", pContext, pContext->fd, state, c, c);
    ok = -1;
-    httpOnError(parser, 400, TSDB_CODE_HTTP_PARSE_HEADER_KEY_FAILED);
+    httpOnError(parser, HTTP_CODE_BAD_REQUEST, TSDB_CODE_HTTP_PARSE_HEADER_KEY_FAILED);
  } while (0);
  return ok;
 }
@ -919,7 +919,7 @@ static int32_t httpParserOnHeaderVal(HttpParser *parser, HTTP_PARSER_STATE state
        httpError("context:%p, fd:%d, parser state:%d, char:[%c]%02x, oom", pContext, pContext->fd, state, c, c);
        ok = -1;
        parser->parseCode = TSDB_CODE_HTTP_PARSE_HEADER_VAL_FAILED;
-        httpOnError(parser, 507, TSDB_CODE_HTTP_PARSE_HEADER_VAL_FAILED);
+        httpOnError(parser, HTTP_CODE_INSUFFICIENT_STORAGE, TSDB_CODE_HTTP_PARSE_HEADER_VAL_FAILED);
        break;
      }
      break;
@ -948,7 +948,7 @@ static int32_t httpParserOnChunkSize(HttpParser *parser, HTTP_PARSER_STATE state
      if (httpAppendString(&parser->str, &c, 1)) {
        httpError("context:%p, fd:%d, parser state:%d, char:[%c]%02x, oom", pContext, pContext->fd, state, c, c);
        ok = -1;
-        httpOnError(parser, 507, TSDB_CODE_HTTP_PARSE_CHUNK_SIZE_FAILED);
+        httpOnError(parser, HTTP_CODE_INSUFFICIENT_STORAGE, TSDB_CODE_HTTP_PARSE_CHUNK_SIZE_FAILED);
        break;
      }
      break;
@ -982,7 +982,7 @@ static int32_t httpParserOnChunkSize(HttpParser *parser, HTTP_PARSER_STATE state
    }
    httpError("context:%p, fd:%d, parser state:%d, unexpected char:[%c]%02x", pContext, pContext->fd, state, c, c);
    ok = -1;
-    httpOnError(parser, 400, TSDB_CODE_HTTP_PARSE_CHUNK_SIZE_FAILED);
+    httpOnError(parser, HTTP_CODE_BAD_REQUEST, TSDB_CODE_HTTP_PARSE_CHUNK_SIZE_FAILED);
  } while (0);
  return ok;
 }
@ -994,7 +994,7 @@ static int32_t httpParserOnChunk(HttpParser *parser, HTTP_PARSER_STATE state, co
    if (httpAppendString(&parser->str, &c, 1)) {
      httpError("context:%p, fd:%d, parser state:%d, char:[%c]%02x, oom", pContext, pContext->fd, state, c, c);
      ok = -1;
-      httpOnError(parser, 507, TSDB_CODE_HTTP_PARSE_CHUNK_FAILED);
+      httpOnError(parser, HTTP_CODE_INSUFFICIENT_STORAGE, TSDB_CODE_HTTP_PARSE_CHUNK_FAILED);
      break;
    }
    ++parser->receivedSize;
@ -1005,7 +1005,7 @@ static int32_t httpParserOnChunk(HttpParser *parser, HTTP_PARSER_STATE state, co
      if (ehttp_gzip_write(parser->gzip, parser->str.str, parser->str.pos)) {
        httpError("context:%p, fd:%d, gzip failed", pContext, pContext->fd);
        ok = -1;
-        httpOnError(parser, 507, TSDB_CODE_HTTP_PARSE_CHUNK_FAILED);
+        httpOnError(parser, HTTP_CODE_INSUFFICIENT_STORAGE, TSDB_CODE_HTTP_PARSE_CHUNK_FAILED);
        break;
      }
    } else {
@ -1027,7 +1027,7 @@ static int32_t httpParserOnEnd(HttpParser *parser, HTTP_PARSER_STATE state, cons
  do {
    ok = -1;
    httpError("context:%p, fd:%d, parser state:%d, unexpected char:[%c]%02x", pContext, pContext->fd, state, c, c);
-    httpOnError(parser, 507, TSDB_CODE_HTTP_PARSE_END_FAILED);
+    httpOnError(parser, HTTP_CODE_INSUFFICIENT_STORAGE, TSDB_CODE_HTTP_PARSE_END_FAILED);
  } while (0);
  return ok;
 }
@ -1104,7 +1104,7 @@ static int32_t httpParseChar(HttpParser *parser, const char c, int32_t *again) {
    ok = -1;
    httpError("context:%p, fd:%d, unknown parse state:%d", pContext, pContext->fd, state);
-    httpOnError(parser, 500, TSDB_CODE_HTTP_PARSE_INVALID_STATE);
+    httpOnError(parser, HTTP_CODE_INTERNAL_SERVER_ERROR, TSDB_CODE_HTTP_PARSE_INVALID_STATE);
  } while (0);
  if (ok == -1) {
@ -1115,7 +1115,7 @@ static int32_t httpParseChar(HttpParser *parser, const char c, int32_t *again) {
  if (ok == -2) {
    ok = -1;
    httpError("context:%p, fd:%d, failed to parse, invalid state", pContext, pContext->fd);
-    httpOnError(parser, 500, TSDB_CODE_HTTP_PARSE_ERROR_STATE);
+    httpOnError(parser, HTTP_CODE_INTERNAL_SERVER_ERROR, TSDB_CODE_HTTP_PARSE_ERROR_STATE);
  }
  return ok;
--- a/src/plugins/http/src/httpResp.c
+++ b/src/plugins/http/src/httpResp.c
@ -67,81 +67,81 @@ static void httpSendErrorRespImp(HttpContext *pContext, int32_t httpCode, char *
 }
 void httpSendErrorResp(HttpContext *pContext, int32_t errNo) {
-  int32_t httpCode = 500;
+  int32_t httpCode = HTTP_CODE_INTERNAL_SERVER_ERROR;
  if (errNo == TSDB_CODE_SUCCESS)
-    httpCode = 200;
+    httpCode = HTTP_CODE_OK;
  else if (errNo == TSDB_CODE_HTTP_SERVER_OFFLINE)
-    httpCode = 404;
+    httpCode = HTTP_CODE_NOT_FOUND;
  else if (errNo == TSDB_CODE_HTTP_UNSUPPORT_URL)
-    httpCode = 404;
+    httpCode = HTTP_CODE_BAD_REQUEST;
  else if (errNo == TSDB_CODE_HTTP_INVALID_URL)
-    httpCode = 404;
+    httpCode = HTTP_CODE_BAD_REQUEST;
  else if (errNo == TSDB_CODE_HTTP_NO_ENOUGH_MEMORY)
-    httpCode = 507;
+    httpCode = HTTP_CODE_INSUFFICIENT_STORAGE;
  else if (errNo == TSDB_CODE_HTTP_REQUSET_TOO_BIG)
-    httpCode = 413;
+    httpCode = HTTP_CODE_PAYLOAD_TOO_LARGE;
  else if (errNo == TSDB_CODE_HTTP_NO_AUTH_INFO)
-    httpCode = 401;
+    httpCode = HTTP_CODE_UNAUTHORIZED;
  else if (errNo == TSDB_CODE_HTTP_NO_MSG_INPUT)
-    httpCode = 400;
+    httpCode = HTTP_CODE_BAD_REQUEST;
  else if (errNo == TSDB_CODE_HTTP_NO_SQL_INPUT)
-    httpCode = 400;
+    httpCode = HTTP_CODE_BAD_REQUEST;
  else if (errNo == TSDB_CODE_HTTP_NO_EXEC_USEDB)
-    httpCode = 400;
+    httpCode = HTTP_CODE_BAD_REQUEST;
  else if (errNo == TSDB_CODE_HTTP_SESSION_FULL)
-    httpCode = 421;
+    httpCode = HTTP_CODE_INTERNAL_SERVER_ERROR;
  else if (errNo == TSDB_CODE_HTTP_GEN_TAOSD_TOKEN_ERR)
-    httpCode = 507;
+    httpCode = HTTP_CODE_INTERNAL_SERVER_ERROR;
  else if (errNo == TSDB_CODE_HTTP_INVALID_MULTI_REQUEST)
-    httpCode = 400;
+    httpCode = HTTP_CODE_BAD_REQUEST;
  else if (errNo == TSDB_CODE_HTTP_CREATE_GZIP_FAILED)
-    httpCode = 507;
+    httpCode = HTTP_CODE_INTERNAL_SERVER_ERROR;
  else if (errNo == TSDB_CODE_HTTP_FINISH_GZIP_FAILED)
-    httpCode = 507;
+    httpCode = HTTP_CODE_INTERNAL_SERVER_ERROR;
  else if (errNo == TSDB_CODE_HTTP_INVALID_VERSION)
-    httpCode = 406;
+    httpCode = HTTP_CODE_HTTP_VER_NOT_SUPPORTED;
  else if (errNo == TSDB_CODE_HTTP_INVALID_CONTENT_LENGTH)
-    httpCode = 406;
+    httpCode = HTTP_CODE_LENGTH_REQUIRED;
  else if (errNo == TSDB_CODE_HTTP_INVALID_AUTH_TYPE)
-    httpCode = 406;
+    httpCode = HTTP_CODE_UNAUTHORIZED;
  else if (errNo == TSDB_CODE_HTTP_INVALID_AUTH_FORMAT)
-    httpCode = 406;
+    httpCode = HTTP_CODE_UNAUTHORIZED;
  else if (errNo == TSDB_CODE_HTTP_INVALID_BASIC_AUTH)
-    httpCode = 406;
+    httpCode = HTTP_CODE_UNAUTHORIZED;
  else if (errNo == TSDB_CODE_HTTP_INVALID_TAOSD_AUTH)
-    httpCode = 406;
+    httpCode = HTTP_CODE_UNAUTHORIZED;
  else if (errNo == TSDB_CODE_HTTP_PARSE_METHOD_FAILED)
-    httpCode = 406;
+    httpCode = HTTP_CODE_BAD_REQUEST;
  else if (errNo == TSDB_CODE_HTTP_PARSE_TARGET_FAILED)
-    httpCode = 406;
+    httpCode = HTTP_CODE_BAD_REQUEST;
  else if (errNo == TSDB_CODE_HTTP_PARSE_VERSION_FAILED)
-    httpCode = 406;
+    httpCode = HTTP_CODE_BAD_REQUEST;
  else if (errNo == TSDB_CODE_HTTP_PARSE_SP_FAILED)
-    httpCode = 406;
+    httpCode = HTTP_CODE_BAD_REQUEST;
  else if (errNo == TSDB_CODE_HTTP_PARSE_STATUS_FAILED)
-    httpCode = 406;
+    httpCode = HTTP_CODE_BAD_REQUEST;
  else if (errNo == TSDB_CODE_HTTP_PARSE_PHRASE_FAILED)
-    httpCode = 406;
+    httpCode = HTTP_CODE_BAD_REQUEST;
  else if (errNo == TSDB_CODE_HTTP_PARSE_CRLF_FAILED)
-    httpCode = 406;
+    httpCode = HTTP_CODE_BAD_REQUEST;
  else if (errNo == TSDB_CODE_HTTP_PARSE_HEADER_FAILED)
-    httpCode = 406;
+    httpCode = HTTP_CODE_BAD_REQUEST;
  else if (errNo == TSDB_CODE_HTTP_PARSE_HEADER_KEY_FAILED)
-    httpCode = 406;
+    httpCode = HTTP_CODE_BAD_REQUEST;
  else if (errNo == TSDB_CODE_HTTP_PARSE_HEADER_VAL_FAILED)
-    httpCode = 406;
+    httpCode = HTTP_CODE_BAD_REQUEST;
  else if (errNo == TSDB_CODE_HTTP_PARSE_CHUNK_SIZE_FAILED)
-    httpCode = 406;
+    httpCode = HTTP_CODE_BAD_REQUEST;
  else if (errNo == TSDB_CODE_HTTP_PARSE_CHUNK_FAILED)
-    httpCode = 406;
+    httpCode = HTTP_CODE_BAD_REQUEST;
  else if (errNo == TSDB_CODE_HTTP_PARSE_END_FAILED)
-    httpCode = 406;
+    httpCode = HTTP_CODE_BAD_REQUEST;
  else if (errNo == TSDB_CODE_HTTP_PARSE_INVALID_STATE)
-    httpCode = 406;
+    httpCode = HTTP_CODE_BAD_REQUEST;
  else if (errNo == TSDB_CODE_HTTP_PARSE_ERROR_STATE)
-    httpCode = 406;
+    httpCode = HTTP_CODE_BAD_REQUEST;
  else
-    httpCode = 400;
+    httpCode = HTTP_CODE_BAD_REQUEST;
  if (pContext->parser && pContext->parser->httpCode != 0) {
    httpCode = pContext->parser->httpCode;
@ -152,7 +152,7 @@ void httpSendErrorResp(HttpContext *pContext, int32_t errNo) {
 }
 void httpSendTaosdInvalidSqlErrorResp(HttpContext *pContext, char *errMsg) {
-  int32_t httpCode = 400;
+  int32_t httpCode = HTTP_CODE_BAD_REQUEST;
  char    temp[512] = {0};
  int32_t len = sprintf(temp, "invalid SQL: %s", errMsg);
--- a/src/query/inc/qTableMeta.h
+++ b/src/query/inc/qTableMeta.h
@ -138,7 +138,6 @@ typedef struct SQueryInfo {
  bool               hasFilter;
  bool               onlyTagQuery;
  bool               orderProjectQuery;
 //  bool               diffQuery;
  bool               stateWindow;
 } SQueryInfo;
--- a/src/query/inc/sql.y
+++ b/src/query/inc/sql.y
@ -176,7 +176,7 @@ cmd ::= ALTER ACCOUNT ids(X) PASS ids(Y) acct_optr(Z).      { setCreateAcctSql(p
 ////////////////////////////// COMPACT STATEMENT //////////////////////////////////////////////
-cmd ::= COMPACT VNODES IN LP exprlist(Y) RP.    { setCompactVnodeSql(pInfo, TSDB_SQL_COMPACT_VNODE, Y);}  
+cmd ::= COMPACT VNODES IN LP exprlist(Y) RP.    { setCompactVnodeSql(pInfo, TSDB_SQL_COMPACT_VNODE, Y);}
 // An IDENTIFIER can be a generic identifier, or one of several keywords.
 // Any non-standard keyword can also be an identifier.
--- a/src/query/src/qAggMain.c
+++ b/src/query/src/qAggMain.c
@ -3613,16 +3613,7 @@ static void deriv_function(SQLFunctionCtx *pCtx) {
      qError("error input type");
  }
-  // initial value is not set yet, all data block are null
+  GET_RES_INFO(pCtx)->numOfRes += notNullElems;
  if (!pDerivInfo->valueSet || notNullElems <= 0) {
    /*
     * 1. current block and blocks before are full of null
     * 2. current block may be null value
     */
    assert(pCtx->hasNull);
  } else {
    GET_RES_INFO(pCtx)->numOfRes += notNullElems;
  }
 }
 #define DIFF_IMPL(ctx, d, type)                                                              \
@ -3662,7 +3653,7 @@ static void diff_function(SQLFunctionCtx *pCtx) {
        if (pCtx->param[1].nType != INITIAL_VALUE_NOT_ASSIGNED) {  // initial value is not set yet
          *pOutput = (int32_t)(pData[i] - pCtx->param[1].i64);  // direct previous may be null
-          *pTimestamp = tsList[i];
+          *pTimestamp = (tsList != NULL)? tsList[i]:0;
          pOutput    += 1;
          pTimestamp += 1;
        }
@ -3684,7 +3675,7 @@ static void diff_function(SQLFunctionCtx *pCtx) {
        if (pCtx->param[1].nType != INITIAL_VALUE_NOT_ASSIGNED) {  // initial value is not set yet
          *pOutput = pData[i] - pCtx->param[1].i64;  // direct previous may be null
-          *pTimestamp = tsList[i];
+          *pTimestamp = (tsList != NULL)? tsList[i]:0;
          pOutput    += 1;
          pTimestamp += 1;
        }
@ -3706,7 +3697,7 @@ static void diff_function(SQLFunctionCtx *pCtx) {
        if (pCtx->param[1].nType != INITIAL_VALUE_NOT_ASSIGNED) {  // initial value is not set yet
          *pOutput = pData[i] - pCtx->param[1].dKey;  // direct previous may be null
-          *pTimestamp = tsList[i];
+          *pTimestamp = (tsList != NULL)? tsList[i]:0;
          pOutput    += 1;
          pTimestamp += 1;
        }
@ -3728,7 +3719,7 @@ static void diff_function(SQLFunctionCtx *pCtx) {
        if (pCtx->param[1].nType != INITIAL_VALUE_NOT_ASSIGNED) {  // initial value is not set yet
          *pOutput = (float)(pData[i] - pCtx->param[1].dKey);  // direct previous may be null
-          *pTimestamp = tsList[i];
+          *pTimestamp = (tsList != NULL)? tsList[i]:0;
          pOutput    += 1;
          pTimestamp += 1;
        }
@ -3750,7 +3741,7 @@ static void diff_function(SQLFunctionCtx *pCtx) {
        if (pCtx->param[1].nType != INITIAL_VALUE_NOT_ASSIGNED) {  // initial value is not set yet
          *pOutput = (int16_t)(pData[i] - pCtx->param[1].i64);  // direct previous may be null
-          *pTimestamp = tsList[i];
+          *pTimestamp = (tsList != NULL)? tsList[i]:0;
          pOutput    += 1;
          pTimestamp += 1;
        }
@ -3773,7 +3764,7 @@ static void diff_function(SQLFunctionCtx *pCtx) {
        if (pCtx->param[1].nType != INITIAL_VALUE_NOT_ASSIGNED) {  // initial value is not set yet
          *pOutput = (int8_t)(pData[i] - pCtx->param[1].i64);  // direct previous may be null
-          *pTimestamp = tsList[i];
+          *pTimestamp = (tsList != NULL)? tsList[i]:0;
          pOutput    += 1;
          pTimestamp += 1;
        }
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@ -1312,6 +1312,8 @@ static void doHashGroupbyAgg(SOperatorInfo* pOperator, SGroupbyOperatorInfo *pIn
      }
    }
    // todo opt perf
    for (int32_t k = 0; k < pOperator->numOfOutput; ++k) {
      pInfo->binfo.pCtx[k].size = 1;
      int32_t functionId = pInfo->binfo.pCtx[k].functionId;
@ -7529,7 +7531,8 @@ static void doSetTagValueToResultBuf(char* output, const char* val, int16_t type
  if (IS_VAR_DATA_TYPE(type)) {
    // Binary data overflows for sort of unknown reasons. Let trim the overflow data
    if (varDataTLen(val) > bytes) {
-      int32_t len = bytes - VARSTR_HEADER_SIZE;   // remain available space
+      int32_t maxLen = bytes - VARSTR_HEADER_SIZE;
      int32_t len = (varDataLen(val) > maxLen)? maxLen:varDataLen(val);
      memcpy(varDataVal(output), varDataVal(val), len);
      varDataSetLen(output, len);
    } else {
--- a/src/query/src/qTsbuf.c
+++ b/src/query/src/qTsbuf.c
@ -812,34 +812,31 @@ int32_t tsBufMerge(STSBuf* pDestBuf, const STSBuf* pSrcBuf) {
  int64_t offset = getDataStartOffset();
  int32_t size = (int32_t)pSrcBuf->fileSize - (int32_t)offset;
-
+  int64_t written = taosFSendFile(pDestBuf->f, pSrcBuf->f, &offset, size);
  int64_t rc = taosFSendFile(pDestBuf->f, pSrcBuf->f, &offset, size);
-  if (rc == -1) {
+  if (written == -1 || written != size) {
 //    tscError("failed to merge tsBuf from:%s to %s, reason:%s\n", pSrcBuf->path, pDestBuf->path, strerror(errno));
    return -1;
  }
  if (rc != size) {
 //    tscError("failed to merge tsBuf from:%s to %s, reason:%s\n", pSrcBuf->path, pDestBuf->path, strerror(errno));
    return -1;
  }
  pDestBuf->numOfTotal += pSrcBuf->numOfTotal;
-  
+
  int32_t oldSize = pDestBuf->fileSize;
-  
+
  // file meta data may be cached, close and reopen the file for accurate file size.
  fclose(pDestBuf->f);
  pDestBuf->f = fopen(pDestBuf->path, "rb+");
  if (pDestBuf->f == NULL) {
    return -1;
  }
  struct stat fileStat;
  if (fstat(fileno(pDestBuf->f), &fileStat) != 0) {
    return -1;  
  }
  pDestBuf->fileSize = (uint32_t)fileStat.st_size;
-  
+
  assert(pDestBuf->fileSize == oldSize + size);
-  
+
 //  tscDebug("tsBuf merge success, %p, path:%s, fd:%d, file size:%d, numOfGroups:%d, autoDelete:%d", pDestBuf,
 //           pDestBuf->path, fileno(pDestBuf->f), pDestBuf->fileSize, pDestBuf->numOfGroups, pDestBuf->autoDelete);
  return 0;
 }
--- a/src/query/tests/CMakeLists.txt
+++ b/src/query/tests/CMakeLists.txt
@ -7,11 +7,17 @@ FIND_LIBRARY(LIB_GTEST_STATIC_DIR libgtest.a /usr/lib/ /usr/local/lib)
 IF (HEADER_GTEST_INCLUDE_DIR AND LIB_GTEST_STATIC_DIR)
    MESSAGE(STATUS "gTest library found, build unit test")
    # GoogleTest requires at least C++11
    SET(CMAKE_CXX_STANDARD 11)
    INCLUDE_DIRECTORIES(/usr/include /usr/local/include)
    LINK_DIRECTORIES(/usr/lib /usr/local/lib)
    INCLUDE_DIRECTORIES(${HEADER_GTEST_INCLUDE_DIR})
    AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SOURCE_LIST)
    ADD_EXECUTABLE(queryTest ${SOURCE_LIST})
-    TARGET_LINK_LIBRARIES(queryTest taos query gtest pthread gcov)
+    TARGET_LINK_LIBRARIES(queryTest taos query gtest pthread)
 ENDIF()
 SET_SOURCE_FILES_PROPERTIES(./astTest.cpp PROPERTIES COMPILE_FLAGS -w)
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
@ -812,6 +812,7 @@ int tsdbRestoreInfo(STsdbRepo *pRepo) {
      STable *pTable = pMeta->tables[i];
      if (pTable == NULL) continue;
      pTable->restoreColumnNum = 0;  
      pTable->hasRestoreLastColumn = false;
    }
  }
@ -895,6 +896,7 @@ int tsdbCacheLastData(STsdbRepo *pRepo, STsdbCfg* oldCfg) {
    maxTableIdx = i;
    if (cacheLastCol) {
      pTable->restoreColumnNum = 0;
      pTable->hasRestoreLastColumn = false;
    } 
  }
@ -913,6 +915,7 @@ int tsdbCacheLastData(STsdbRepo *pRepo, STsdbCfg* oldCfg) {
      }
      if (need_free_last_col) {
        tsdbFreeLastColumns(pTable);
        pTable->hasRestoreLastColumn = false;
      }
    }    
  }
--- a/src/tsdb/src/tsdbMeta.c
+++ b/src/tsdb/src/tsdbMeta.c
@ -148,7 +148,9 @@ int tsdbCreateTable(STsdbRepo *repo, STableCfg *pCfg) {
  return 0;
 _err:
-  tsdbFreeTable(super);
+  if (newSuper) {
    tsdbFreeTable(super);
  }
  tsdbFreeTable(table);
  return -1;
 }
@ -211,7 +213,7 @@ void *tsdbGetTableTagVal(const void* pTable, int32_t colId, int16_t type, int16_
  }
  char *val = tdGetKVRowValOfCol(((STable*)pTable)->tagVal, colId);
-  assert(type == pCol->type && bytes == pCol->bytes);
+  assert(type == pCol->type && bytes >= pCol->bytes);
  // if (val != NULL && IS_VAR_DATA_TYPE(type)) {
  //   assert(varDataLen(val) < pCol->bytes);
@ -607,6 +609,7 @@ void tsdbFreeLastColumns(STable* pTable) {
  pTable->maxColNum = 0;
  pTable->lastColSVersion = -1;
  pTable->restoreColumnNum = 0;
  pTable->hasRestoreLastColumn = false;
 }
 int16_t tsdbGetLastColumnsIndexByColId(STable* pTable, int16_t colId) {
@ -643,6 +646,7 @@ int tsdbInitColIdCacheWithSchema(STable* pTable, STSchema* pSchema) {
  pTable->lastColSVersion = schemaVersion(pSchema);
  pTable->maxColNum = numOfColumn;
  pTable->restoreColumnNum = 0;
  pTable->hasRestoreLastColumn = false;
  return 0;
 }
@ -655,7 +659,7 @@ int tsdbUpdateLastColSchema(STable *pTable, STSchema *pNewSchema) {
    return 0;
  }
-  tsdbInfo("tsdbUpdateLastColSchema:%s,%d->%d", pTable->name->data, pTable->lastColSVersion, schemaVersion(pNewSchema));
+  tsdbDebug("tsdbUpdateLastColSchema:%s,%d->%d", pTable->name->data, pTable->lastColSVersion, schemaVersion(pNewSchema));
  int16_t numOfCols = pNewSchema->numOfCols;
  SDataCol *lastCols = (SDataCol*)malloc(numOfCols * sizeof(SDataCol));
@ -800,6 +804,7 @@ static STable *tsdbNewTable() {
  pTable->lastCols = NULL;
  pTable->restoreColumnNum = 0;
  pTable->maxColNum = 0;
  pTable->hasRestoreLastColumn = false;
  pTable->lastColSVersion = -1;
  return pTable;
 }
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@ -2520,7 +2520,7 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
    int32_t numOfCols = pTable->maxColNum;
    if (pTable->lastCols == NULL || pTable->maxColNum <= 0) {
-      tsdbWarn("no last cached for table, uid:%" PRIu64 ",tid:%d", pTable->tableId.uid, pTable->tableId.tid);
+      tsdbWarn("no last cached for table %s, uid:%" PRIu64 ",tid:%d", pTable->name->data, pTable->tableId.uid, pTable->tableId.tid);
      continue;
    }
--- a/tests/pytest/alter/alter_keep.py
+++ b/tests/pytest/alter/alter_keep.py
@ -15,6 +15,7 @@ import sys
 from util.log import *
 from util.cases import *
 from util.sql import *
 import time
 class TDTestCase:
@ -129,9 +130,6 @@ class TDTestCase:
        tdSql.prepare()
        ##TODO: need to wait for TD-4445 to implement the following
        ##      tests
        ## preset the keep
        tdSql.prepare()
@ -176,20 +174,22 @@ class TDTestCase:
        tdSql.error('insert into tb values (now-15d, 10)')
        tdSql.query('select * from tb')
        tdSql.checkRows(rowNum)
-
+        
        tdLog.notice('testing keep will be altered if sudden change from small to big')
-        tdSql.execute('alter database db keep 14,14,14')
+        for i in range(30):
-        tdSql.execute('alter database db keep 15,15,15')
+            tdSql.execute('alter database db keep 14,14,14')
-        tdSql.execute('insert into tb values (now-15d, 10)')
+            tdSql.execute('alter database db keep 16,16,16')
-        tdSql.query('select * from tb')
+            tdSql.execute('insert into tb values (now-15d, 10)')
-        tdSql.checkRows(rowNum + 1)
+            tdSql.query('select * from tb')
            rowNum += 1
            tdSql.checkRows(rowNum )
        tdLog.notice('testing keep will be altered if sudden change from big to small')
        tdSql.execute('alter database db keep 16,16,16')
        tdSql.execute('alter database db keep 14,14,14')
        tdSql.error('insert into tb values (now-15d, 10)')
        tdSql.query('select * from tb')
-        tdSql.checkRows(rowNum + 1)
+        tdSql.checkRows(rowNum)
--- a/tests/pytest/client/change_time_1_1.py
+++ b/tests/pytest/client/change_time_1_1.py
@ -19,6 +19,7 @@ from util.pathFinding import *
 from util.dnodes import tdDnodes
 from datetime import datetime
 import subprocess
 import time
 ##TODO: this is now automatic, but not sure if this will run through jenkins
 class TDTestCase:
@ -34,24 +35,36 @@ class TDTestCase:
        ## change system time to 2020/10/20
        os.system('sudo timedatectl set-ntp off')
        tdLog.sleep(10)
        os.system('sudo timedatectl set-time 2020-10-20')
        #run taosdemo to insert data. one row per second from 2020/10/11 to 2020/10/20
        #11 data files should be generated
        #vnode at TDinternal/community/sim/dnode1/data/vnode
-        os.system(f"{binPath}taosdemo -f tools/taosdemoAllTest/manual_change_time_1_1_A.json")  
+        try:
-        commandArray = ['ls', '-l', f'{TDenginePath}/sim/dnode1/data/vnode/vnode2/tsdb/data']
+            os.system(f"{binPath}taosdemo -f tools/taosdemoAllTest/manual_change_time_1_1_A.json")
-        result = subprocess.run(commandArray, stdout=subprocess.PIPE).stdout.decode('utf-8')
+            commandArray = ['ls', '-l', f'{TDenginePath}/sim/dnode1/data/vnode/vnode2/tsdb/data']
-        print(result.count('data'))
+            result = subprocess.run(commandArray, stdout=subprocess.PIPE).stdout.decode('utf-8')
        except BaseException:
            os.system('sudo timedatectl set-ntp on')
            tdLog.sleep(10)
        if result.count('data') != 11:
            os.system('sudo timedatectl set-ntp on')
            tdLog.sleep(10)
            tdLog.exit('wrong number of files')
        else:
            tdLog.debug("data file number correct")
        #move 5 days ahead to 2020/10/25. 4 oldest files should be removed during the new write
        #leaving 7 data files.
-        os.system ('timedatectl set-time 2020-10-25')
+        try:
-        os.system(f"{binPath}taosdemo -f tools/taosdemoAllTest/manual_change_time_1_1_B.json") 
+            os.system ('timedatectl set-time 2020-10-25')
            os.system(f"{binPath}taosdemo -f tools/taosdemoAllTest/manual_change_time_1_1_B.json")
        except BaseException:
            os.system('sudo timedatectl set-ntp on')
            tdLog.sleep(10)
        os.system('sudo timedatectl set-ntp on') 
        tdLog.sleep(10)
        commandArray = ['ls', '-l', f'{TDenginePath}/sim/dnode1/data/vnode/vnode2/tsdb/data']
        result = subprocess.run(commandArray, stdout=subprocess.PIPE).stdout.decode('utf-8')
        print(result.count('data'))
@ -61,9 +74,12 @@ class TDTestCase:
            tdLog.debug("data file number correct")
        tdSql.query('select first(ts) from stb_0')
        tdSql.checkData(0,0,datetime(2020,10,14,8,0,0,0)) #check the last data in the database
        os.system('sudo timedatectl set-ntp on')
        tdLog.sleep(10)
    def stop(self):
        os.system('sudo timedatectl set-ntp on')
        tdLog.sleep(10)
        tdSql.close()
        tdLog.success("alter block manual check finish")
--- a/tests/pytest/client/change_time_1_2.py
+++ b/tests/pytest/client/change_time_1_2.py
@ -34,34 +34,52 @@ class TDTestCase:
        ## change system time to 2020/10/20
        os.system ('timedatectl set-ntp off')
        tdLog.sleep(10)
        os.system ('timedatectl set-time 2020-10-20')
        #run taosdemo to insert data. one row per second from 2020/10/11 to 2020/10/20
        #11 data files should be generated
        #vnode at TDinternal/community/sim/dnode1/data/vnode
-        os.system(f"{binPath}taosdemo -f tools/taosdemoAllTest/manual_change_time_1_1_A.json") 
+        try:
-        commandArray = ['ls', '-l', f'{TDenginePath}/sim/dnode1/data/vnode/vnode2/tsdb/data']
+            os.system(f"{binPath}taosdemo -f tools/taosdemoAllTest/manual_change_time_1_1_A.json") 
-        result = subprocess.run(commandArray, stdout=subprocess.PIPE).stdout.decode('utf-8')
+            commandArray = ['ls', '-l', f'{TDenginePath}/sim/dnode1/data/vnode/vnode2/tsdb/data']
-        print(result.count('data'))
+            result = subprocess.run(commandArray, stdout=subprocess.PIPE).stdout.decode('utf-8')
        except BaseException:
            os.system('sudo timedatectl set-ntp on')
            tdLog.sleep(10) 
        if result.count('data') != 11:
            os.system('sudo timedatectl set-ntp on')
            tdLog.sleep(10)
            tdLog.exit('wrong number of files')
        else:
            tdLog.debug("data file number correct")
        tdSql.query('select first(ts) from stb_0') #check the last data in the database
        tdSql.checkData(0,0,datetime(2020,10,11,0,0,0,0))
-        os.system ('timedatectl set-time 2020-10-25')
+        try:
            tdSql.query('select first(ts) from stb_0') #check the last data in the database
            tdSql.checkData(0,0,datetime(2020,10,11,0,0,0,0))
        except BaseException:
            os.system('sudo timedatectl set-ntp on')
            tdLog.sleep(10) 
        #moves 5 days ahead to 2020/10/25 and restart taosd
        #4 oldest data file should be removed from tsdb/data
        #7 data file should be found 
        #vnode at TDinternal/community/sim/dnode1/data/vnode
-        os.system ('timedatectl set-time 2020-10-25')
+
-        tdDnodes.stop(1)
+        try:
-        tdDnodes.start(1)
+            os.system ('timedatectl set-time 2020-10-25')
-        tdSql.query('select first(ts) from stb_0')
+            tdDnodes.stop(1)
-        tdSql.checkData(0,0,datetime(2020,10,14,8,0,0,0)) #check the last data in the database
+            tdDnodes.start(1)
            tdSql.query('select first(ts) from stb_0')
            tdSql.checkData(0,0,datetime(2020,10,14,8,0,0,0)) #check the last data in the database
        except BaseException:
            os.system('sudo timedatectl set-ntp on')
            tdLog.sleep(10) 
        os.system('sudo timedatectl set-ntp on')
        tdLog.sleep(10)
        commandArray = ['ls', '-l', f'{TDenginePath}/sim/dnode1/data/vnode/vnode2/tsdb/data']
        result = subprocess.run(commandArray, stdout=subprocess.PIPE).stdout.decode('utf-8')
        print(result.count('data'))
@ -69,8 +87,8 @@ class TDTestCase:
            tdLog.exit('wrong number of files')
        else:
            tdLog.debug("data file number correct")
-
+        os.system('sudo timedatectl set-ntp on')
-
+        tdLog.sleep(10)
    def stop(self):
        os.system('sudo timedatectl set-ntp on')
--- a/tests/pytest/fulltest.sh
+++ b/tests/pytest/fulltest.sh
@ -25,6 +25,8 @@ python3 ./test.py -f insert/special_character_show.py
 python3 bug2265.py
 python3 ./test.py -f insert/bug3654.py
 python3 ./test.py -f insert/insertDynamicColBeforeVal.py
 python3 ./test.py -f insert/in_function.py
 python3 ./test.py -f insert/modify_column.py
 #table
 python3 ./test.py -f table/alter_wal0.py
@ -258,8 +260,8 @@ python3 ./test.py -f client/client.py
 python3 ./test.py -f client/version.py
 python3 ./test.py -f client/alterDatabase.py
 python3 ./test.py -f client/noConnectionErrorTest.py
-#python3 test.py -f client/change_time_1_1.py
+# python3 test.py -f client/change_time_1_1.py
-#python3 test.py -f client/change_time_1_2.py
+# python3 test.py -f client/change_time_1_2.py
 # Misc
 python3 testCompress.py
@ -343,7 +345,7 @@ python3 test.py -f tools/taosdemoAllTest/taosdemoTestInsertWithJson.py
 python3 test.py -f tools/taosdemoAllTest/taosdemoTestQueryWithJson.py
 python3 ./test.py -f tag_lite/drop_auto_create.py
 python3 test.py -f insert/insert_before_use_db.py
-#python3 test.py -f alter/alter_keep.py
+python3 test.py -f alter/alter_keep.py
 python3 test.py -f alter/alter_cacheLastRow.py
 python3 ./test.py -f query/querySession.py 
 python3 test.py -f  alter/alter_create_exception.py
--- a/tests/pytest/functions/function_derivative.py
+++ b/tests/pytest/functions/function_derivative.py
@ -128,7 +128,14 @@ class TDTestCase:
    def run(self):
        tdSql.prepare()        
-        self.insertAndCheckData()               
+        self.insertAndCheckData()
        tdSql.execute("create table st(ts timestamp, c1 int, c2 int) tags(id int)")
        tdSql.execute("insert into dev1(ts, c1) using st tags(1) values(now, 1)")
        tdSql.error("select derivative(c1, 10s, 0) from (select c1 from st)")
        tdSql.query("select diff(c1) from (select derivative(c1, 1s, 0) c1 from dev1)")
        tdSql.checkRows(0)
    def stop(self):
        tdSql.close()
--- a/tests/pytest/insert/in_function.py
+++ b/tests/pytest/insert/in_function.py
@ -0,0 +1,726 @@
 ###################################################################
 #           Copyright (c) 2016 by TAOS Technologies, Inc.
 #                     All rights reserved.
 #
 #  This file is proprietary and confidential to TAOS Technologies.
 #  No part of this file may be reproduced, stored, transmitted,
 #  disclosed or used in any form or by any means other than as
 #  expressly provided by the written permission from Jianhui Tao
 #
 ###################################################################
 # -*- coding: utf-8 -*-
 import sys
 import datetime
 from util.log import *
 from util.cases import *
 from util.sql import *
 class TDTestCase:
    def init(self, conn, logSql):
        tdLog.debug("start to execute %s" % __file__)
        tdSql.init(conn.cursor(), logSql)
    def run(self):
        tdSql.prepare()
        # test case for https://jira.taosdata.com:18080/browse/TD-4568
        tdLog.info("=============== step1,check bool and tinyint data type")    
        tdLog.info("=============== step1.1,drop table && create table")    
        cmd1 = 'drop table if exists in_bool_tinyint_1 ;'
        cmd2 = 'drop table if exists in_bool_tinyint_2 ;'
        cmd3 = 'drop table if exists in_bool_tinyint_3 ;'
        cmd10 = 'drop table if exists in_stable_1 ;'
        cmd11 = 'create stable in_stable_1(ts timestamp,in_bool bool,in_tinyint tinyint) tags (tin_bool bool,tin_tinyint tinyint) ;'
        cmd12 = 'create table in_bool_tinyint_1 using in_stable_1 tags(\'true\',\'127\') ; '
        cmd13 = 'create table in_bool_tinyint_2 using in_stable_1 tags(\'false\',\'-127\') ; '
        cmd14 = 'create table in_bool_tinyint_3 using in_stable_1 tags(\'false\',\'0\') ; '
        tdLog.info(cmd1)
        tdSql.execute(cmd1)
        tdLog.info(cmd2)
        tdSql.execute(cmd2)
        tdLog.info(cmd3)
        tdSql.execute(cmd3)
        tdLog.info(cmd10)
        tdSql.execute(cmd10)        
        tdLog.info(cmd11)
        tdSql.execute(cmd11)
        tdLog.info(cmd12)
        tdSql.execute(cmd12)
        tdLog.info(cmd13)
        tdSql.execute(cmd13)
        tdLog.info(cmd14)
        tdSql.execute(cmd14)        
        tdLog.info("=============== step1.2,insert stable right data and check in function") 
        cmd1 = 'insert into in_bool_tinyint_1 values(now,\'true\',\'-127\') ;'
        tdLog.info(cmd1)
        tdSql.execute(cmd1)         
        tdSql.query('select * from in_stable_1 where in_bool in (true) order by ts desc')
        tdSql.checkData(0,1,'True') 
        tdSql.checkData(0,2,'-127')
        tdSql.checkData(0,3,'True') 
        tdSql.checkData(0,4,'127')  
        tdSql.query('select * from in_stable_1 where in_tinyint in (-127) order by ts desc')
        tdSql.checkData(0,1,'True') 
        tdSql.checkData(0,2,'-127')
        tdSql.checkData(0,3,'True') 
        tdSql.checkData(0,4,'127')     
        tdSql.query('select * from in_stable_1 where tin_bool in (true) order by ts desc')
        tdSql.checkData(0,1,'True') 
        tdSql.checkData(0,2,'-127')
        tdSql.checkData(0,3,'True') 
        tdSql.checkData(0,4,'127')  
        tdSql.query('select * from in_stable_1 where tin_tinyint in (127) order by ts desc')
        tdSql.checkData(0,1,'True') 
        tdSql.checkData(0,2,'-127')
        tdSql.checkData(0,3,'True') 
        tdSql.checkData(0,4,'127')  
        tdSql.query('select * from in_bool_tinyint_1 where in_bool in (true) order by ts desc')
        tdSql.checkData(0,1,'True') 
        tdSql.checkData(0,2,'-127')
        tdSql.query('select * from in_bool_tinyint_1 where in_tinyint in (-127) order by ts desc')
        tdSql.checkData(0,1,'True') 
        tdSql.checkData(0,2,'-127')                
        cmd2 = 'insert into in_bool_tinyint_2 values(now,\'false\',\'127\') ;'
        tdLog.info(cmd2)
        tdSql.execute(cmd2)         
        tdSql.query('select * from in_stable_1 where in_bool in (false) order by ts desc')
        tdSql.checkData(0,1,'False') 
        tdSql.checkData(0,2,'127')
        tdSql.checkData(0,3,'False') 
        tdSql.checkData(0,4,'-127') 
        tdSql.query('select * from in_stable_1 where in_tinyint in (127) order by ts desc')
        tdSql.checkData(0,1,'False') 
        tdSql.checkData(0,2,'127')
        tdSql.checkData(0,3,'False') 
        tdSql.checkData(0,4,'-127')   
        tdSql.query('select * from in_stable_1 where tin_bool in (false) order by ts desc')
        tdSql.checkData(0,1,'False') 
        tdSql.checkData(0,2,'127')
        tdSql.checkData(0,3,'False') 
        tdSql.checkData(0,4,'-127') 
        tdSql.query('select * from in_stable_1 where tin_tinyint in (-127) order by ts desc')
        tdSql.checkData(0,1,'False') 
        tdSql.checkData(0,2,'127')
        tdSql.checkData(0,3,'False') 
        tdSql.checkData(0,4,'-127') 
        tdSql.query('select * from in_bool_tinyint_2 where in_bool in (false) order by ts desc')
        tdSql.checkData(0,1,'False') 
        tdSql.checkData(0,2,'127')
        tdSql.query('select * from in_bool_tinyint_2 where in_tinyint in (127) order by ts desc')
        tdSql.checkData(0,1,'False') 
        tdSql.checkData(0,2,'127')         
        cmd3 = 'insert into in_bool_tinyint_3 values(now,\'true\',\'0\') ;'
        tdLog.info(cmd3)
        tdSql.execute(cmd3)         
        tdSql.query('select * from in_stable_1 where in_tinyint in (0) order by ts desc')
        tdSql.checkData(0,1,'True') 
        tdSql.checkData(0,2,'0')
        tdSql.checkData(0,3,'False') 
        tdSql.checkData(0,4,'0')  
        tdSql.query('select * from in_stable_1 where tin_tinyint in (0) order by ts desc')
        tdSql.checkData(0,1,'True') 
        tdSql.checkData(0,2,'0')
        tdSql.checkData(0,3,'False') 
        tdSql.checkData(0,4,'0')  
        tdSql.query('select * from in_bool_tinyint_3 where in_bool in (true) order by ts desc')
        tdSql.checkData(0,1,'True') 
        tdSql.checkData(0,2,'0')
        tdSql.query('select * from in_bool_tinyint_3 where in_tinyint in (0) order by ts desc')
        tdSql.checkData(0,1,'True') 
        tdSql.checkData(0,2,'0')
        tdLog.info("=============== step1.3,drop normal table && create table") 
        cmd1 = 'drop table if exists normal_in_bool_tinyint_1 ;'
        cmd2 = 'create table normal_in_bool_tinyint_1 (ts timestamp,in_bool bool,in_tinyint tinyint) ; '
        tdLog.info(cmd1)
        tdSql.execute(cmd1)
        tdLog.info(cmd2)
        tdSql.execute(cmd2)
        tdLog.info("=============== step1.4,insert normal table right data and check in function") 
        cmd1 = 'insert into normal_in_bool_tinyint_1 values(now,\'true\',\'-127\') ;'
        tdLog.info(cmd1)
        tdSql.execute(cmd1)         
        tdSql.query('select * from normal_in_bool_tinyint_1 where in_bool in (true) order by ts desc')
        tdSql.checkData(0,1,'True') 
        tdSql.checkData(0,2,'-127')         
        tdSql.query('select * from normal_in_bool_tinyint_1 where in_tinyint in (-127) order by ts desc')
        tdSql.checkData(0,1,'True') 
        tdSql.checkData(0,2,'-127')  
        cmd2 = 'insert into normal_in_bool_tinyint_1 values(now,\'false\',\'127\') ;'
        tdLog.info(cmd2)
        tdSql.execute(cmd2)         
        tdSql.query('select * from normal_in_bool_tinyint_1 where in_bool in (false) order by ts desc')
        tdSql.checkData(0,1,'False') 
        tdSql.checkData(0,2,'127') 
        tdSql.query('select * from normal_in_bool_tinyint_1 where in_tinyint in (127) order by ts desc')
        tdSql.checkData(0,1,'False') 
        tdSql.checkData(0,2,'127')        
        cmd3 = 'insert into normal_in_bool_tinyint_1 values(now,\'true\',\'0\') ;'
        tdLog.info(cmd3)
        tdSql.execute(cmd3)         
        tdSql.query('select * from normal_in_bool_tinyint_1 where in_tinyint in (0) order by ts desc')
        tdSql.checkData(0,1,'True') 
        tdSql.checkData(0,2,'0')
        tdLog.info("=============== step2,check int、smallint and bigint data type")  
        tdLog.info("=============== step2.1,drop table && create table")    
        cmd1 = 'drop table if exists in_int_smallint_bigint_1 ;'
        cmd2 = 'drop table if exists in_int_smallint_bigint_2 ;'
        cmd3 = 'drop table if exists in_int_smallint_bigint_3 ;'
        cmd10 = 'drop table if exists in_stable_2 ;'
        cmd11 = 'create stable in_stable_2(ts timestamp,in_int int,in_small smallint , in_big bigint) tags (tin_int int,tin_small smallint , tin_big bigint) ;'
        cmd12 = 'create table in_int_smallint_bigint_1 using in_stable_2 tags(\'2147483647\',\'-32767\',\'0\') ; '
        cmd13 = 'create table in_int_smallint_bigint_2 using in_stable_2 tags(\'-2147483647\',\'0\',\'9223372036854775807\') ; '
        cmd14 = 'create table in_int_smallint_bigint_3 using in_stable_2 tags(\'0\',\'32767\',\'-9223372036854775807\') ; '
        tdLog.info(cmd1)
        tdSql.execute(cmd1)
        tdLog.info(cmd2)
        tdSql.execute(cmd2)
        tdLog.info(cmd3)
        tdSql.execute(cmd3)
        tdLog.info(cmd10)
        tdSql.execute(cmd10)        
        tdLog.info(cmd11)
        tdSql.execute(cmd11)
        tdLog.info(cmd12)
        tdSql.execute(cmd12)
        tdLog.info(cmd13)
        tdSql.execute(cmd13)
        tdLog.info(cmd14)
        tdSql.execute(cmd14)        
        tdLog.info("=============== step2.2,insert stable right data and check in function") 
        cmd1 = 'insert into in_int_smallint_bigint_1 values(now,\'2147483647\',\'-32767\',\'0\') ;'
        tdLog.info(cmd1)
        tdSql.execute(cmd1)         
        tdSql.query('select * from in_stable_2 where in_int in (2147483647) order by ts desc')
        tdSql.checkData(0,1,'2147483647') 
        tdSql.checkData(0,2,'-32767')
        tdSql.checkData(0,3,'0') 
        tdSql.checkData(0,4,'2147483647')  
        tdSql.checkData(0,5,'-32767') 
        tdSql.checkData(0,6,'0')  
        tdSql.query('select * from in_stable_2 where in_small in (-32767) order by ts desc')
        tdSql.checkData(0,1,'2147483647') 
        tdSql.checkData(0,2,'-32767')
        tdSql.checkData(0,3,'0') 
        tdSql.checkData(0,4,'2147483647')  
        tdSql.checkData(0,5,'-32767') 
        tdSql.checkData(0,6,'0')    
        tdSql.query('select * from in_stable_2 where in_big in (0) order by ts desc')
        tdSql.checkData(0,1,'2147483647') 
        tdSql.checkData(0,2,'-32767')
        tdSql.checkData(0,3,'0') 
        tdSql.checkData(0,4,'2147483647')  
        tdSql.checkData(0,5,'-32767') 
        tdSql.checkData(0,6,'0')  
        tdSql.query('select * from in_stable_2 where tin_int in (2147483647) order by ts desc')
        tdSql.checkData(0,1,'2147483647') 
        tdSql.checkData(0,2,'-32767')
        tdSql.checkData(0,3,'0') 
        tdSql.checkData(0,4,'2147483647')  
        tdSql.checkData(0,5,'-32767') 
        tdSql.checkData(0,6,'0')  
        tdSql.query('select * from in_stable_2 where tin_small in (-32767) order by ts desc')
        tdSql.checkData(0,1,'2147483647') 
        tdSql.checkData(0,2,'-32767')
        tdSql.checkData(0,3,'0') 
        tdSql.checkData(0,4,'2147483647')  
        tdSql.checkData(0,5,'-32767') 
        tdSql.checkData(0,6,'0')    
        tdSql.query('select * from in_stable_2 where tin_big in (0) order by ts desc')
        tdSql.checkData(0,1,'2147483647') 
        tdSql.checkData(0,2,'-32767')
        tdSql.checkData(0,3,'0') 
        tdSql.checkData(0,4,'2147483647')  
        tdSql.checkData(0,5,'-32767') 
        tdSql.checkData(0,6,'0')     
        tdSql.query('select * from in_int_smallint_bigint_1 where in_int in (2147483647) order by ts desc')
        tdSql.checkData(0,1,'2147483647') 
        tdSql.checkData(0,2,'-32767')
        tdSql.checkData(0,3,'0') 
        tdSql.query('select * from in_int_smallint_bigint_1 where in_small in (-32767) order by ts desc')
        tdSql.checkData(0,1,'2147483647') 
        tdSql.checkData(0,2,'-32767')
        tdSql.checkData(0,3,'0')  
        tdSql.query('select * from in_int_smallint_bigint_1 where in_big in (0) order by ts desc')
        tdSql.checkData(0,1,'2147483647') 
        tdSql.checkData(0,2,'-32767')
        tdSql.checkData(0,3,'0')      
        cmd2 = 'insert into in_int_smallint_bigint_2 values(now,\'-2147483647\',\'0\',\'9223372036854775807\') ;'
        tdLog.info(cmd2)
        tdSql.execute(cmd2)         
        tdSql.query('select * from in_stable_2 where in_int in (-2147483647) order by ts desc')
        tdSql.checkData(0,1,'-2147483647') 
        tdSql.checkData(0,2,'0')
        tdSql.checkData(0,3,'9223372036854775807') 
        tdSql.checkData(0,4,'-2147483647')  
        tdSql.checkData(0,5,'0') 
        tdSql.checkData(0,6,'9223372036854775807')  
        tdSql.query('select * from in_stable_2 where in_small in (0) order by ts desc')
        tdSql.checkData(0,1,'-2147483647') 
        tdSql.checkData(0,2,'0')
        tdSql.checkData(0,3,'9223372036854775807') 
        tdSql.checkData(0,4,'-2147483647')  
        tdSql.checkData(0,5,'0') 
        tdSql.checkData(0,6,'9223372036854775807')     
        tdSql.query('select * from in_stable_2 where in_big in (9223372036854775807) order by ts desc')
        tdSql.checkData(0,1,'-2147483647') 
        tdSql.checkData(0,2,'0')
        tdSql.checkData(0,3,'9223372036854775807') 
        tdSql.checkData(0,4,'-2147483647')  
        tdSql.checkData(0,5,'0') 
        tdSql.checkData(0,6,'9223372036854775807')    
        tdSql.query('select * from in_stable_2 where tin_int in (-2147483647) order by ts desc')
        tdSql.checkData(0,1,'-2147483647') 
        tdSql.checkData(0,2,'0')
        tdSql.checkData(0,3,'9223372036854775807') 
        tdSql.checkData(0,4,'-2147483647')  
        tdSql.checkData(0,5,'0') 
        tdSql.checkData(0,6,'9223372036854775807') 
        tdSql.query('select * from in_stable_2 where tin_small in (0) order by ts desc')
        tdSql.checkData(0,1,'-2147483647') 
        tdSql.checkData(0,2,'0')
        tdSql.checkData(0,3,'9223372036854775807') 
        tdSql.checkData(0,4,'-2147483647')  
        tdSql.checkData(0,5,'0') 
        tdSql.checkData(0,6,'9223372036854775807')   
        tdSql.query('select * from in_stable_2 where tin_big in (9223372036854775807) order by ts desc')
        tdSql.checkData(0,1,'-2147483647') 
        tdSql.checkData(0,2,'0')
        tdSql.checkData(0,3,'9223372036854775807') 
        tdSql.checkData(0,4,'-2147483647')  
        tdSql.checkData(0,5,'0') 
        tdSql.checkData(0,6,'9223372036854775807')  
        tdSql.query('select * from in_int_smallint_bigint_2 where in_int in (-2147483647) order by ts desc')
        tdSql.checkData(0,1,'-2147483647') 
        tdSql.checkData(0,2,'0')
        tdSql.checkData(0,3,'9223372036854775807')  
        tdSql.query('select * from in_int_smallint_bigint_2 where in_small in (0) order by ts desc')
        tdSql.checkData(0,1,'-2147483647') 
        tdSql.checkData(0,2,'0')
        tdSql.checkData(0,3,'9223372036854775807')     
        tdSql.query('select * from in_int_smallint_bigint_2 where in_big in (9223372036854775807) order by ts desc')
        tdSql.checkData(0,1,'-2147483647') 
        tdSql.checkData(0,2,'0')
        tdSql.checkData(0,3,'9223372036854775807')             
        cmd3 = 'insert into in_int_smallint_bigint_3 values(now,\'0\',\'32767\',\'-9223372036854775807\') ;'
        tdLog.info(cmd3)
        tdSql.execute(cmd3)         
        tdSql.query('select * from in_stable_2 where in_int in (0) order by ts desc')
        tdSql.checkData(0,1,'0') 
        tdSql.checkData(0,2,'32767')
        tdSql.checkData(0,3,'-9223372036854775807') 
        tdSql.checkData(0,4,'0')  
        tdSql.checkData(0,5,'32767') 
        tdSql.checkData(0,6,'-9223372036854775807')  
        tdSql.query('select * from in_stable_2 where in_small in (32767) order by ts desc')
        tdSql.checkData(0,1,'0') 
        tdSql.checkData(0,2,'32767')
        tdSql.checkData(0,3,'-9223372036854775807') 
        tdSql.checkData(0,4,'0')  
        tdSql.checkData(0,5,'32767') 
        tdSql.checkData(0,6,'-9223372036854775807')    
        tdSql.query('select * from in_stable_2 where in_big in (-9223372036854775807) order by ts desc')
        tdSql.checkData(0,1,'0') 
        tdSql.checkData(0,2,'32767')
        tdSql.checkData(0,3,'-9223372036854775807') 
        tdSql.checkData(0,4,'0')  
        tdSql.checkData(0,5,'32767') 
        tdSql.checkData(0,6,'-9223372036854775807')    
        tdSql.query('select * from in_stable_2 where tin_int in (0) order by ts desc')
        tdSql.checkData(0,1,'0') 
        tdSql.checkData(0,2,'32767')
        tdSql.checkData(0,3,'-9223372036854775807') 
        tdSql.checkData(0,4,'0')  
        tdSql.checkData(0,5,'32767') 
        tdSql.checkData(0,6,'-9223372036854775807')  
        tdSql.query('select * from in_stable_2 where tin_small in (32767) order by ts desc')
        tdSql.checkData(0,1,'0') 
        tdSql.checkData(0,2,'32767')
        tdSql.checkData(0,3,'-9223372036854775807') 
        tdSql.checkData(0,4,'0')  
        tdSql.checkData(0,5,'32767') 
        tdSql.checkData(0,6,'-9223372036854775807')    
        tdSql.query('select * from in_stable_2 where tin_big in (-9223372036854775807) order by ts desc')
        tdSql.checkData(0,1,'0') 
        tdSql.checkData(0,2,'32767')
        tdSql.checkData(0,3,'-9223372036854775807') 
        tdSql.checkData(0,4,'0')  
        tdSql.checkData(0,5,'32767') 
        tdSql.checkData(0,6,'-9223372036854775807')  
        tdSql.query('select * from in_int_smallint_bigint_3 where in_int in (0) order by ts desc')
        tdSql.checkData(0,1,'0') 
        tdSql.checkData(0,2,'32767')
        tdSql.checkData(0,3,'-9223372036854775807') 
        tdSql.query('select * from in_int_smallint_bigint_3 where in_small in (32767) order by ts desc')
        tdSql.checkData(0,1,'0') 
        tdSql.checkData(0,2,'32767')
        tdSql.checkData(0,3,'-9223372036854775807')   
        tdSql.query('select * from in_int_smallint_bigint_3 where in_big in (-9223372036854775807) order by ts desc')
        tdSql.checkData(0,1,'0') 
        tdSql.checkData(0,2,'32767')
        tdSql.checkData(0,3,'-9223372036854775807')       
        tdLog.info("=============== step2.3,drop normal table && create table") 
        cmd1 = 'drop table if exists normal_int_smallint_bigint_1 ;'
        cmd2 = 'create table normal_int_smallint_bigint_1 (ts timestamp,in_int int,in_small smallint , in_big bigint) ; '
        tdLog.info(cmd1)
        tdSql.execute(cmd1)
        tdLog.info(cmd2)
        tdSql.execute(cmd2)
        tdLog.info("=============== step2.4,insert normal table right data and check in function") 
        cmd1 = 'insert into normal_int_smallint_bigint_1 values(now,\'2147483647\',\'-32767\',\'0\') ;'
        tdLog.info(cmd1)
        tdSql.execute(cmd1)         
        tdSql.query('select * from normal_int_smallint_bigint_1 where in_int in (2147483647) order by ts desc')
        tdSql.checkData(0,1,'2147483647') 
        tdSql.checkData(0,2,'-32767')
        tdSql.checkData(0,3,'0')             
        tdSql.query('select * from normal_int_smallint_bigint_1 where in_small in (-32767) order by ts desc')
        tdSql.checkData(0,1,'2147483647') 
        tdSql.checkData(0,2,'-32767')
        tdSql.checkData(0,3,'0')  
        tdSql.query('select * from normal_int_smallint_bigint_1 where in_big in (0) order by ts desc')
        tdSql.checkData(0,1,'2147483647') 
        tdSql.checkData(0,2,'-32767')
        tdSql.checkData(0,3,'0')        
        cmd2 = 'insert into normal_int_smallint_bigint_1 values(now,\'-2147483647\',\'0\',\'9223372036854775807\') ;'
        tdLog.info(cmd2)
        tdSql.execute(cmd2)         
        tdSql.query('select * from normal_int_smallint_bigint_1 where in_int in (-2147483647) order by ts desc')
        tdSql.checkData(0,1,'-2147483647') 
        tdSql.checkData(0,2,'0')
        tdSql.checkData(0,3,'9223372036854775807')             
        tdSql.query('select * from normal_int_smallint_bigint_1 where in_small in (0) order by ts desc')
        tdSql.checkData(0,1,'-2147483647') 
        tdSql.checkData(0,2,'0')
        tdSql.checkData(0,3,'9223372036854775807')  
        tdSql.query('select * from normal_int_smallint_bigint_1 where in_big in (9223372036854775807) order by ts desc')
        tdSql.checkData(0,1,'-2147483647') 
        tdSql.checkData(0,2,'0')
        tdSql.checkData(0,3,'9223372036854775807')          
        cmd3 = 'insert into normal_int_smallint_bigint_1 values(now,\'0\',\'32767\',\'-9223372036854775807\') ;'
        tdLog.info(cmd3)
        tdSql.execute(cmd3)         
        tdSql.query('select * from normal_int_smallint_bigint_1 where in_int in (0) order by ts desc')
        tdSql.checkData(0,1,'0') 
        tdSql.checkData(0,2,'32767')
        tdSql.checkData(0,3,'-9223372036854775807')             
        tdSql.query('select * from normal_int_smallint_bigint_1 where in_small in (32767) order by ts desc')
        tdSql.checkData(0,1,'0') 
        tdSql.checkData(0,2,'32767')
        tdSql.checkData(0,3,'-9223372036854775807')  
        tdSql.query('select * from normal_int_smallint_bigint_1 where in_big in (-9223372036854775807) order by ts desc')
        tdSql.checkData(0,1,'0') 
        tdSql.checkData(0,2,'32767')
        tdSql.checkData(0,3,'-9223372036854775807')   
        tdLog.info("=============== step3,check binary and nchar data type")    
        tdLog.info("=============== step3.1,drop table && create table")    
        cmd1 = 'drop table if exists in_binary_nchar_1 ;'
        cmd2 = 'drop table if exists in_binary_nchar_2 ;'
        cmd3 = 'drop table if exists in_binary_nchar_3 ;'
        cmd10 = 'drop table if exists in_stable_3 ;'
        cmd11 = 'create stable in_stable_3(ts timestamp,in_binary binary(8),in_nchar nchar(12)) tags (tin_binary binary(16),tin_nchar nchar(20)) ;'
        cmd12 = 'create table in_binary_nchar_1 using in_stable_3 tags(\'0\',\'0\') ; '
        cmd13 = 'create table in_binary_nchar_2 using in_stable_3 tags(\'TDengine\',\'北京涛思数据科技有限公司\') ; '
        cmd14 = 'create table in_binary_nchar_3 using in_stable_3 tags(\'taosdataTDengine\',\'北京涛思数据科技有限公司TDengine\') ; '
        tdLog.info(cmd1)
        tdSql.execute(cmd1)
        tdLog.info(cmd2)
        tdSql.execute(cmd2)
        tdLog.info(cmd3)
        tdSql.execute(cmd3)
        tdLog.info(cmd10)
        tdSql.execute(cmd10)        
        tdLog.info(cmd11)
        tdSql.execute(cmd11)
        tdLog.info(cmd12)
        tdSql.execute(cmd12)
        tdLog.info(cmd13)
        tdSql.execute(cmd13)
        tdLog.info(cmd14)
        tdSql.execute(cmd14)        
        tdLog.info("=============== step3.2,insert stable right data and check in function") 
        cmd1 = 'insert into in_binary_nchar_1 values(now,\'0\',\'0\') ;'
        tdLog.info(cmd1)
        tdSql.execute(cmd1)         
        tdSql.query('select * from in_stable_3 where in_binary in (\'0\') order by ts desc')
        tdSql.checkData(0,1,'0') 
        tdSql.checkData(0,2,'0')
        tdSql.checkData(0,3,'0') 
        tdSql.checkData(0,4,'0')  
        tdSql.query('select * from in_stable_3 where in_nchar in (\'0\') order by ts desc')
        tdSql.checkData(0,1,'0') 
        tdSql.checkData(0,2,'0')
        tdSql.checkData(0,3,'0') 
        tdSql.checkData(0,4,'0')     
        tdSql.query('select * from in_stable_3 where tin_binary in (\'0\') order by ts desc')
        tdSql.checkData(0,1,'0') 
        tdSql.checkData(0,2,'0')
        tdSql.checkData(0,3,'0') 
        tdSql.checkData(0,4,'0')  
        tdSql.query('select * from in_stable_3 where tin_nchar in (\'0\') order by ts desc')
        tdSql.checkData(0,1,'0') 
        tdSql.checkData(0,2,'0')
        tdSql.checkData(0,3,'0') 
        tdSql.checkData(0,4,'0') 
        tdSql.query('select * from in_binary_nchar_1 where in_binary in (\'0\') order by ts desc')
        tdSql.checkData(0,1,'0') 
        tdSql.checkData(0,2,'0')  
        tdSql.query('select * from in_binary_nchar_1 where in_nchar in (\'0\') order by ts desc')
        tdSql.checkData(0,1,'0') 
        tdSql.checkData(0,2,'0')        
        cmd2 = 'insert into in_binary_nchar_2 values(now,\'TAOS\',\'涛思数据TAOSdata\') ;'
        tdLog.info(cmd2)
        tdSql.execute(cmd2)         
        tdSql.query('select * from in_stable_3 where in_binary in (\'TAOS\') order by ts desc')
        tdSql.checkData(0,1,'TAOS') 
        tdSql.checkData(0,2,'涛思数据TAOSdata')
        tdSql.checkData(0,3,'TDengine') 
        tdSql.checkData(0,4,'北京涛思数据科技有限公司')  
        tdSql.query('select * from in_stable_3 where in_nchar in (\'涛思数据TAOSdata\') order by ts desc')
        tdSql.checkData(0,1,'TAOS') 
        tdSql.checkData(0,2,'涛思数据TAOSdata')
        tdSql.checkData(0,3,'TDengine') 
        tdSql.checkData(0,4,'北京涛思数据科技有限公司')      
        tdSql.query('select * from in_stable_3 where tin_binary in (\'TDengine\') order by ts desc')
        tdSql.checkData(0,1,'TAOS') 
        tdSql.checkData(0,2,'涛思数据TAOSdata')
        tdSql.checkData(0,3,'TDengine') 
        tdSql.checkData(0,4,'北京涛思数据科技有限公司')  
        tdSql.query('select * from in_stable_3 where tin_nchar in (\'北京涛思数据科技有限公司\') order by ts desc')
        tdSql.checkData(0,1,'TAOS') 
        tdSql.checkData(0,2,'涛思数据TAOSdata')
        tdSql.checkData(0,3,'TDengine') 
        tdSql.checkData(0,4,'北京涛思数据科技有限公司') 
        tdSql.query('select * from in_binary_nchar_2 where in_binary in (\'TAOS\') order by ts desc')
        tdSql.checkData(0,1,'TAOS') 
        tdSql.checkData(0,2,'涛思数据TAOSdata') 
        tdSql.query('select * from in_binary_nchar_2 where in_nchar in (\'涛思数据TAOSdata\') order by ts desc')
        tdSql.checkData(0,1,'TAOS') 
        tdSql.checkData(0,2,'涛思数据TAOSdata')     
        cmd3 = 'insert into in_binary_nchar_3 values(now,\'TDengine\',\'北京涛思数据科技有限公司\') ;'
        tdLog.info(cmd3)
        tdSql.execute(cmd3)         
        tdSql.query('select * from in_stable_3 where in_binary in (\'TDengine\') order by ts desc')
        tdSql.checkData(0,1,'TDengine') 
        tdSql.checkData(0,2,'北京涛思数据科技有限公司')
        tdSql.checkData(0,3,'taosdataTDengine') 
        tdSql.checkData(0,4,'北京涛思数据科技有限公司TDengine')  
        tdSql.query('select * from in_stable_3 where in_nchar in (\'北京涛思数据科技有限公司\') order by ts desc')
        tdSql.checkData(0,1,'TDengine') 
        tdSql.checkData(0,2,'北京涛思数据科技有限公司')
        tdSql.checkData(0,3,'taosdataTDengine') 
        tdSql.checkData(0,4,'北京涛思数据科技有限公司TDengine')     
        tdSql.query('select * from in_stable_3 where tin_binary in (\'taosdataTDengine\') order by ts desc')
        tdSql.checkData(0,1,'TDengine') 
        tdSql.checkData(0,2,'北京涛思数据科技有限公司')
        tdSql.checkData(0,3,'taosdataTDengine') 
        tdSql.checkData(0,4,'北京涛思数据科技有限公司TDengine')   
        tdSql.query('select * from in_stable_3 where tin_nchar in (\'北京涛思数据科技有限公司TDengine\') order by ts desc')
        tdSql.checkData(0,1,'TDengine') 
        tdSql.checkData(0,2,'北京涛思数据科技有限公司')
        tdSql.checkData(0,3,'taosdataTDengine') 
        tdSql.checkData(0,4,'北京涛思数据科技有限公司TDengine') 
        tdSql.query('select * from in_binary_nchar_3 where in_binary in (\'TDengine\') order by ts desc')
        tdSql.checkData(0,1,'TDengine') 
        tdSql.checkData(0,2,'北京涛思数据科技有限公司') 
        tdSql.query('select * from in_binary_nchar_3 where in_nchar in (\'北京涛思数据科技有限公司\') order by ts desc')
        tdSql.checkData(0,1,'TDengine') 
        tdSql.checkData(0,2,'北京涛思数据科技有限公司') 
        tdLog.info("=============== step3.3,drop normal table && create table") 
        cmd1 = 'drop table if exists normal_in_binary_nchar_1 ;'
        cmd2 = 'create table normal_in_binary_nchar_1 (ts timestamp,in_binary binary(8),in_nchar nchar(12)) ; '
        tdLog.info(cmd1)
        tdSql.execute(cmd1)
        tdLog.info(cmd2)
        tdSql.execute(cmd2)
        tdLog.info("=============== step3.4,insert normal table right data and check in function") 
        cmd1 = 'insert into normal_in_binary_nchar_1 values(now,\'0\',\'0\') ;'
        tdLog.info(cmd1)
        tdSql.execute(cmd1)         
        tdSql.query('select * from normal_in_binary_nchar_1 where in_binary in (\'0\') order by ts desc')
        tdSql.checkData(0,1,'0') 
        tdSql.checkData(0,2,'0')         
        tdSql.query('select * from normal_in_binary_nchar_1 where in_nchar in (\'0\') order by ts desc')
        tdSql.checkData(0,1,'0') 
        tdSql.checkData(0,2,'0')  
        cmd2 = 'insert into normal_in_binary_nchar_1 values(now,\'TAOS\',\'涛思数据TAOSdata\') ;'
        tdLog.info(cmd2)
        tdSql.execute(cmd2)         
        tdSql.query('select * from normal_in_binary_nchar_1 where in_binary in (\'TAOS\') order by ts desc')
        tdSql.checkData(0,1,'TAOS') 
        tdSql.checkData(0,2,'涛思数据TAOSdata')         
        tdSql.query('select * from normal_in_binary_nchar_1 where in_nchar in (\'涛思数据TAOSdata\') order by ts desc')
        tdSql.checkData(0,1,'TAOS') 
        tdSql.checkData(0,2,'涛思数据TAOSdata')       
        cmd3 = 'insert into normal_in_binary_nchar_1 values(now,\'TDengine\',\'北京涛思数据科技有限公司\') ;'
        tdLog.info(cmd3)
        tdSql.execute(cmd3)         
        tdSql.query('select * from normal_in_binary_nchar_1 where in_binary in (\'TDengine\') order by ts desc')
        tdSql.checkData(0,1,'TDengine') 
        tdSql.checkData(0,2,'北京涛思数据科技有限公司')         
        tdSql.query('select * from normal_in_binary_nchar_1 where in_nchar in (\'北京涛思数据科技有限公司\') order by ts desc')
        tdSql.checkData(0,1,'TDengine') 
        tdSql.checkData(0,2,'北京涛思数据科技有限公司')   
        tdLog.info("=============== step4,check float and double data type,not support")    
        tdLog.info("=============== step4.1,drop table && create table")    
        cmd1 = 'drop table if exists in_float_double_1 ;'
        cmd10 = 'drop table if exists in_stable_4 ;'
        cmd11 = 'create stable in_stable_4(ts timestamp,in_float float,in_double double) tags (tin_float float,tin_double double) ;'
        cmd12 = 'create table in_float_double_1 using in_stable_4 tags(\'666\',\'88888\') ; '
        tdLog.info(cmd1)
        tdSql.execute(cmd1)
        tdLog.info(cmd10)
        tdSql.execute(cmd10)        
        tdLog.info(cmd11)
        tdSql.execute(cmd11)
        tdLog.info(cmd12)
        tdSql.execute(cmd12)    
        tdLog.info("=============== step4.2,insert stable right data and check in function") 
        cmd1 = 'insert into in_float_double_1 values(now,\'888\',\'66666\') ;'
        tdLog.info(cmd1)
        tdSql.execute(cmd1)         
        cmd2 = 'select * from in_stable_4 where in_float in (\'888\');'
        tdLog.info(cmd2)
        tdSql.error(cmd2)
        try:
            tdSql.execute(cmd2)
            tdLog.exit("invalid operation: not supported filter condition")
        except Exception as e:
            tdLog.info(repr(e))
            tdLog.info("invalid operation: not supported filter condition") 
        cmd3 = 'select * from in_stable_4 where in_double in (\'66666\');'
        tdLog.info(cmd3)
        tdSql.error(cmd3)
        try:
            tdSql.execute(cmd3)
            tdLog.exit("invalid operation: not supported filter condition")
        except Exception as e:
            tdLog.info(repr(e))
            tdLog.info("invalid operation: not supported filter condition") 
        cmd4 = 'select * from in_stable_4 where tin_float in (\'666\');'
        tdLog.info(cmd4)
        tdSql.error(cmd4)
        try:
            tdSql.execute(cmd4)
            tdLog.exit("invalid operation: not supported filter condition")
        except Exception as e:
            tdLog.info(repr(e))
            tdLog.info("invalid operation: not supported filter condition") 
        cmd5 = 'select * from in_stable_4 where tin_double in (\'88888\');'
        tdLog.info(cmd5)
        tdSql.error(cmd5)
        try:
            tdSql.execute(cmd5)
            tdLog.exit("invalid operation: not supported filter condition")
        except Exception as e:
            tdLog.info(repr(e))
            tdLog.info("invalid operation: not supported filter condition") 
        cmd6 = 'select * from in_float_double_1 where in_float in (\'888\');'
        tdLog.info(cmd6)
        tdSql.error(cmd6)
        try:
            tdSql.execute(cmd6)
            tdLog.exit("invalid operation: not supported filter condition")
        except Exception as e:
            tdLog.info(repr(e))
            tdLog.info("invalid operation: not supported filter condition") 
        cmd7 = 'select * from in_float_double_1 where in_double in (\'66666\');'
        tdLog.info(cmd7)
        tdSql.error(cmd7)
        try:
            tdSql.execute(cmd7)
            tdLog.exit("invalid operation: not supported filter condition")
        except Exception as e:
            tdLog.info(repr(e))
            tdLog.info("invalid operation: not supported filter condition") 
        tdLog.info("=============== step4.3,drop normal table && create table") 
        cmd1 = 'drop table if exists normal_in_float_double_1 ;'
        cmd2 = 'create table normal_in_float_double_1 (ts timestamp,in_float float,in_double double) ; '
        tdLog.info(cmd1)
        tdSql.execute(cmd1)
        tdLog.info(cmd2)
        tdSql.execute(cmd2)
        tdLog.info("=============== step4.4,insert normal table right data and check in function") 
        cmd1 = 'insert into normal_in_float_double_1 values(now,\'888\',\'666666\') ;'
        tdLog.info(cmd1)
        tdSql.execute(cmd1)   
        cmd2 = 'select * from normal_in_float_double_1 where in_float in (\'888\');'
        tdLog.info(cmd2)
        tdSql.error(cmd2)
        try:
            tdSql.execute(cmd2)
            tdLog.exit("invalid operation: not supported filter condition")
        except Exception as e:
            tdLog.info(repr(e))
            tdLog.info("invalid operation: not supported filter condition") 
        cmd3 = 'select * from normal_in_float_double_1 where in_double in (\'66666\');'
        tdLog.info(cmd3)
        tdSql.error(cmd3)
        try:
            tdSql.execute(cmd3)
            tdLog.exit("invalid operation: not supported filter condition")
        except Exception as e:
            tdLog.info(repr(e))
            tdLog.info("invalid operation: not supported filter condition") 
    def stop(self):
        tdSql.close()
        tdLog.success("%s successfully executed" % __file__)
 tdCases.addWindows(__file__, TDTestCase())
 tdCases.addLinux(__file__, TDTestCase())
--- a/tests/pytest/insert/modify_column.py
+++ b/tests/pytest/insert/modify_column.py
@ -0,0 +1,382 @@
 ###################################################################
 #           Copyright (c) 2016 by TAOS Technologies, Inc.
 #                     All rights reserved.
 #
 #  This file is proprietary and confidential to TAOS Technologies.
 #  No part of this file may be reproduced, stored, transmitted,
 #  disclosed or used in any form or by any means other than as
 #  expressly provided by the written permission from Jianhui Tao
 #
 ###################################################################
 # -*- coding: utf-8 -*-
 import sys
 import datetime
 from util.log import *
 from util.cases import *
 from util.sql import *
 class TDTestCase:
    def init(self, conn, logSql):
        tdLog.debug("start to execute %s" % __file__)
        tdSql.init(conn.cursor(), logSql)
    def run(self):
        tdSql.prepare()
        # test case for https://jira.taosdata.com:18080/browse/TD-4541
        tdLog.info("=============== step1,check normal table")    
        tdLog.info("=============== step1.1,drop table && create table")    
        cmd1 = 'drop table if exists length11 ;'
        cmd2 = 'create table length11 (ts timestamp,lengthbia binary(10),lengthnchar nchar(20));'
        tdLog.info(cmd1)
        tdSql.execute(cmd1)
        tdLog.info(cmd2)
        tdSql.execute(cmd2)
        tdLog.info("=============== step1.2,insert table right data") 
        cmd1 = 'insert into length11 values(now,\'aaaaaaaaaa\',\'bbbbbbbbbbbbbbbbbbbb\') ;'
        tdLog.info(cmd1)
        tdSql.execute(cmd1)         
        tdSql.query('select * from length11 order by ts desc')
        tdSql.checkData(0,1,'aaaaaaaaaa') 
        tdSql.checkData(0,2,'bbbbbbbbbbbbbbbbbbbb')
        tdLog.info("=============== step1.3,insert table wrong data") 
        cmd1 = 'insert into length11 values(now,\'aaaaaaaaaa1\',\'bbbbbbbbbbbbbbbbbbbb1\') ;'
        tdLog.info(cmd1)
        tdSql.error(cmd1)
        try:
            tdSql.execute(cmd1)
            tdLog.exit("string data overflow")
        except Exception as e:
            tdLog.info(repr(e))
            tdLog.info("insert wrong data error catched")      
        tdSql.query('select * from length11 order by ts desc')
        tdSql.checkData(0,1,'aaaaaaaaaa') 
        tdSql.checkData(0,2,'bbbbbbbbbbbbbbbbbbbb')
        tdLog.info("=============== step1.4,modify columu length ") 
        cmd1 = 'alter table length11 modify column lengthbia binary(10) ;'
        tdLog.info(cmd1)
        tdSql.error(cmd1)
        try:
            tdSql.execute(cmd1)
            tdLog.exit("new column length should be bigger than old one")
        except Exception as e:
            tdLog.info(repr(e))
            tdLog.info("new column length should be bigger than old one")   
        cmd2 = 'alter table length11 modify column lengthnchar nchar(20);'
        tdLog.info(cmd2)
        tdSql.error(cmd2)
        try:
            tdSql.execute(cmd2)
            tdLog.exit("new column length should be bigger than old one")
        except Exception as e:
            tdLog.info(repr(e))
            tdLog.info("new column length should be bigger than old one") 
        cmd3 = 'alter table length11 modify column lengthbia binary(11) ;'
        cmd4 = 'describe length11 ;'
        tdLog.info(cmd3)
        tdSql.execute(cmd3) 
        tdLog.info(cmd4)
        tdSql.execute(cmd4) 
        tdSql.query('describe length11 ;')
        tdSql.checkData(1,2,11) 
        cmd5 = 'alter table length11 modify column lengthnchar nchar(21);'
        cmd6 = 'describe length11 ;'
        tdLog.info(cmd5)
        tdSql.execute(cmd5) 
        tdLog.info(cmd6)
        tdSql.execute(cmd6) 
        tdSql.query('describe length11 ;')
        tdSql.checkData(2,2,21) 
        tdSql.query('select * from length11 order by ts desc')
        tdSql.checkData(0,1,'aaaaaaaaaa') 
        tdSql.checkData(0,2,'bbbbbbbbbbbbbbbbbbbb')
        tdLog.info("=============== step1.5,insert table right data") 
        cmd1 = 'insert into length11 values(now,\'aaaaaaaaaa1\',\'bbbbbbbbbbbbbbbbbbbb1\') ;'
        tdLog.info(cmd1)    
        tdSql.execute(cmd1)  
        tdSql.query('select * from length11 order by ts desc')
        tdSql.checkData(0,1,'aaaaaaaaaa1') 
        tdSql.checkData(0,2,'bbbbbbbbbbbbbbbbbbbb1')
        tdLog.info("=============== step2,check stable table and tag")    
        tdLog.info("=============== step2.1,drop table && create table")    
        cmd1 = 'drop table if exists length1 ;'
        cmd2 = 'drop table if exists length2 ;'
        cmd3 = 'drop table if exists length2 ;'
        cmd4 = 'drop table if exists lengthsta1 ;'
        cmd5 = 'create stable lengthsta1(ts timestamp,lengthbia binary(10),lengthnchar nchar(20)) tags (tlengthbia binary(15),tlengthnchar nchar(25)) ;'
        cmd6 = 'create table length1 using lengthsta1 tags(\'aaaaabbbbbaaaaa\',\'bbbbbaaaaabbbbbaaaaabbbbb\') ; '
        tdLog.info(cmd1)
        tdSql.execute(cmd1)
        tdLog.info(cmd2)
        tdSql.execute(cmd2)
        tdLog.info(cmd3)
        tdSql.execute(cmd3)
        tdLog.info(cmd4)
        tdSql.execute(cmd4)
        tdLog.info(cmd5)
        tdSql.execute(cmd5)
        tdLog.info(cmd6)
        tdSql.execute(cmd6)
        tdLog.info("=============== step2.2,insert table right data") 
        cmd1 = 'insert into length1 values(now,\'aaaaaaaaaa\',\'bbbbbbbbbbbbbbbbbbbb\') ;'
        tdLog.info(cmd1)
        tdSql.execute(cmd1)         
        tdSql.query('select * from length1 order by ts desc')
        tdSql.checkData(0,1,'aaaaaaaaaa') 
        tdSql.checkData(0,2,'bbbbbbbbbbbbbbbbbbbb')
        tdLog.info("=============== step2.3,insert table wrong data") 
        cmd1 = 'insert into length1 values(now,\'aaaaaaaaaa1\',\'bbbbbbbbbbbbbbbbbbbb1\') ;'
        tdLog.info(cmd1)
        tdSql.error(cmd1)
        try:
            tdSql.execute(cmd1)
            tdLog.exit("string data overflow")
        except Exception as e:
            tdLog.info(repr(e))
            tdLog.info("insert wrong data error catched")      
        tdSql.query('select * from length1 order by ts desc')
        tdSql.checkData(0,1,'aaaaaaaaaa') 
        tdSql.checkData(0,2,'bbbbbbbbbbbbbbbbbbbb')
        tdLog.info("=============== step2.4,modify columu length ") 
        cmd0 = 'alter table length1 modify column lengthbia binary(10) ;'
        tdLog.info(cmd0)
        tdSql.error(cmd0)
        try:
            tdSql.execute(cmd1)
            tdLog.exit("invalid operation: column can only be modified by super table")
        except Exception as e:
            tdLog.info(repr(e))
            tdLog.info("invalid operation: column can only be modified by super table")  
        cmd1 = 'alter table lengthsta1 modify column lengthbia binary(10) ;'
        tdLog.info(cmd1)
        tdSql.error(cmd1)
        try:
            tdSql.execute(cmd1)
            tdLog.exit("new column length should be bigger than old one")
        except Exception as e:
            tdLog.info(repr(e))
            tdLog.info("new column length should be bigger than old one")   
        cmd2 = 'alter table lengthsta1 modify column lengthnchar nchar(20);'
        tdLog.info(cmd2)
        tdSql.error(cmd2)
        try:
            tdSql.execute(cmd2)
            tdLog.exit("new column length should be bigger than old one")
        except Exception as e:
            tdLog.info(repr(e))
            tdLog.info("new column length should be bigger than old one") 
        cmd3 = 'alter table lengthsta1 modify column lengthbia binary(11) ;'
        cmd4 = 'describe lengthsta1 ;'
        tdLog.info(cmd3)
        tdSql.execute(cmd3) 
        tdLog.info(cmd4)
        tdSql.execute(cmd4) 
        tdSql.query('describe length1 ;')
        tdSql.checkData(1,2,11) 
        cmd5 = 'alter table lengthsta1 modify column lengthnchar nchar(21);'
        cmd6 = 'describe lengthsta1 ;'
        tdLog.info(cmd5)
        tdSql.execute(cmd5) 
        tdLog.info(cmd6)
        tdSql.execute(cmd6) 
        tdSql.query('describe lengthsta1 ;')
        tdSql.checkData(2,2,21) 
        tdSql.query('select * from lengthsta1 order by ts desc')
        tdSql.checkData(0,1,'aaaaaaaaaa') 
        tdSql.checkData(0,2,'bbbbbbbbbbbbbbbbbbbb')
        tdLog.info("=============== step2.5,insert table right data") 
        cmd1 = 'insert into length1 values(now,\'aaaaaaaaaa1\',\'bbbbbbbbbbbbbbbbbbbb1\') ;'
        tdLog.info(cmd1)    
        tdSql.execute(cmd1)  
        tdSql.query('select * from length1 order by ts desc')
        tdSql.checkData(0,1,'aaaaaaaaaa1') 
        tdSql.checkData(0,2,'bbbbbbbbbbbbbbbbbbbb1')
        tdLog.info("=============== step2.6,create table wrong tag") 
        cmd1 = 'create table length2 using lengthsta1 tags(\'aaaaabbbbbaaaaa1\',\'bbbbbaaaaabbbbbaaaaabbbbb1\')  ;'
        tdLog.info(cmd1)
        tdSql.error(cmd1)
        try:
            tdSql.execute(cmd1)
            tdLog.exit("invalid operation: tag value too long")
        except Exception as e:
            tdLog.info(repr(e))
            tdLog.info("invalid operation: tag value too long")      
        tdSql.query('select * from lengthsta1 order by ts desc')
        tdSql.checkData(0,1,'aaaaaaaaaa1') 
        tdSql.checkData(0,2,'bbbbbbbbbbbbbbbbbbbb1')
        tdLog.info("=============== step2.7,modify tag columu length ")  
        cmd1 = 'alter table lengthsta1 modify tag tlengthbia binary(15) ;'
        tdLog.info(cmd1)
        tdSql.error(cmd1)
        try:
            tdSql.execute(cmd1)
            tdLog.exit("new column length should be bigger than old one")
        except Exception as e:
            tdLog.info(repr(e))
            tdLog.info("new column length should be bigger than old one")   
        cmd2 = 'alter table lengthsta1 modify tag tlengthnchar nchar(25);'
        tdLog.info(cmd2)
        tdSql.error(cmd2)
        try:
            tdSql.execute(cmd2)
            tdLog.exit("new column length should be bigger than old one")
        except Exception as e:
            tdLog.info(repr(e))
            tdLog.info("new column length should be bigger than old one") 
        cmd3 = 'alter table lengthsta1 modify tag tlengthbia binary(16) ;'
        cmd4 = 'describe lengthsta1 ;'
        tdLog.info(cmd3)
        tdSql.execute(cmd3) 
        tdLog.info(cmd4)
        tdSql.execute(cmd4) 
        tdSql.query('describe lengthsta1 ;')
        tdSql.checkData(3,2,16) 
        cmd5 = 'alter table lengthsta1 modify tag tlengthnchar nchar(26);'
        cmd6 = 'describe lengthsta1 ;'
        tdLog.info(cmd5)
        tdSql.execute(cmd5) 
        tdLog.info(cmd6)
        tdSql.execute(cmd6) 
        tdSql.query('describe lengthsta1 ;')
        tdSql.checkData(4,2,26) 
        tdSql.query('select * from lengthsta1 order by ts desc')
        tdSql.checkData(0,1,'aaaaaaaaaa1') 
        tdSql.checkData(0,2,'bbbbbbbbbbbbbbbbbbbb1')
        tdSql.checkData(0,3,'aaaaabbbbbaaaaa') 
        tdSql.checkData(0,4,'bbbbbaaaaabbbbbaaaaabbbbb')        
        tdLog.info("=============== step2.8,creat tag right data and insert data") 
        cmd1 = 'create table length2 using lengthsta1 tags(\'aaaaabbbbbaaaaa1\',\'bbbbbaaaaabbbbbaaaaabbbbb1\')  ;'
        tdLog.info(cmd1)    
        tdSql.execute(cmd1)  
        tdSql.query('describe length2 ;')
        tdSql.checkData(3,2,16) 
        tdSql.checkData(4,2,26) 
        cmd2 = 'insert into length2 values(now,\'aaaaaaaaaa1\',\'bbbbbbbbbbbbbbbbbbbb1\') ;'
        tdLog.info(cmd2)    
        tdSql.execute(cmd2)  
        tdSql.query('select * from length2 order by ts desc')
        tdSql.checkData(0,1,'aaaaaaaaaa1') 
        tdSql.checkData(0,2,'bbbbbbbbbbbbbbbbbbbb1')
        tdSql.query('select * from lengthsta1 order by ts desc')
        tdSql.checkData(0,1,'aaaaaaaaaa1') 
        tdSql.checkData(0,2,'bbbbbbbbbbbbbbbbbbbb1')
        tdSql.checkData(0,3,'aaaaabbbbbaaaaa1') 
        tdSql.checkData(0,4,'bbbbbaaaaabbbbbaaaaabbbbb1')  
        tdLog.info("=============== step2.9,modify tag columu length again ")  
        cmd1 = 'alter table lengthsta1 modify tag tlengthbia binary(16) ;'
        tdLog.info(cmd1)
        tdSql.error(cmd1)
        try:
            tdSql.execute(cmd1)
            tdLog.exit("new column length should be bigger than old one")
        except Exception as e:
            tdLog.info(repr(e))
            tdLog.info("new column length should be bigger than old one")   
        cmd2 = 'alter table lengthsta1 modify tag tlengthnchar nchar(26);'
        tdLog.info(cmd2)
        tdSql.error(cmd2)
        try:
            tdSql.execute(cmd2)
            tdLog.exit("new column length should be bigger than old one")
        except Exception as e:
            tdLog.info(repr(e))
            tdLog.info("new column length should be bigger than old one") 
        cmd3 = 'alter table lengthsta1 modify tag tlengthbia binary(20) ;'
        cmd4 = 'describe lengthsta1 ;'
        tdLog.info(cmd3)
        tdSql.execute(cmd3) 
        tdLog.info(cmd4)
        tdSql.execute(cmd4) 
        tdSql.query('describe lengthsta1 ;')
        tdSql.checkData(3,2,20) 
        cmd5 = 'alter table lengthsta1 modify tag tlengthnchar nchar(30);'
        cmd6 = 'describe lengthsta1 ;'
        tdLog.info(cmd5)
        tdSql.execute(cmd5) 
        tdLog.info(cmd6)
        tdSql.execute(cmd6) 
        tdSql.query('describe lengthsta1 ;')
        tdSql.checkData(4,2,30) 
        tdSql.query('select * from lengthsta1 order by ts desc')
        tdSql.checkData(0,1,'aaaaaaaaaa1') 
        tdSql.checkData(0,2,'bbbbbbbbbbbbbbbbbbbb1')
        tdSql.checkData(0,3,'aaaaabbbbbaaaaa1') 
        tdSql.checkData(0,4,'bbbbbaaaaabbbbbaaaaabbbbb1')        
        tdLog.info("=============== step2.10,creat tag right data and insert data again") 
        cmd1 = 'create table length3 using lengthsta1 tags(\'aaaaabbbbbaaaaabbbbb\',\'bbbbbaaaaabbbbbaaaaabbbbbaaaaa\')  ;'
        tdLog.info(cmd1)    
        tdSql.execute(cmd1)  
        tdSql.query('describe length3 ;')
        tdSql.checkData(3,2,20) 
        tdSql.checkData(4,2,30) 
        cmd2 = 'insert into length3 values(now,\'aaaaaaaaaa1\',\'bbbbbbbbbbbbbbbbbbbb1\') ;'
        tdLog.info(cmd2)    
        tdSql.execute(cmd2)  
        tdSql.query('select * from length3 order by ts desc')
        tdSql.checkData(0,1,'aaaaaaaaaa1') 
        tdSql.checkData(0,2,'bbbbbbbbbbbbbbbbbbbb1')
        tdSql.query('select * from lengthsta1 order by ts desc')
        tdSql.checkData(0,1,'aaaaaaaaaa1') 
        tdSql.checkData(0,2,'bbbbbbbbbbbbbbbbbbbb1')
        tdSql.checkData(0,3,'aaaaabbbbbaaaaabbbbb') 
        tdSql.checkData(0,4,'bbbbbaaaaabbbbbaaaaabbbbbaaaaa')  
    def stop(self):
        tdSql.close()
        tdLog.success("%s successfully executed" % __file__)
 tdCases.addWindows(__file__, TDTestCase())
 tdCases.addLinux(__file__, TDTestCase())
--- a/tests/pytest/util/sql.py
+++ b/tests/pytest/util/sql.py
@ -18,6 +18,7 @@ import datetime
 import inspect
 import psutil
 import shutil
 import pandas as pd
 from util.log import *
@ -134,25 +135,32 @@ class TDSql:
        return self.cursor.istype(col, dataType)
    def checkData(self, row, col, data):
-        self.checkRowCol(row, col) 
+        self.checkRowCol(row, col)
-        if self.queryResult[row][col] != data:            
+        if self.queryResult[row][col] != data:
-            if self.cursor.istype(col, "TIMESTAMP") and self.queryResult[row][col] == datetime.datetime.fromisoformat(data):
+            if self.cursor.istype(col, "TIMESTAMP"):
-                tdLog.info("sql:%s, row:%d col:%d data:%s == expect:%s" %
+                # suppose user want to check nanosecond timestamp if a longer data passed
                if (len(data) >= 28):
                    if pd.to_datetime(self.queryResult[row][col]) == pd.to_datetime(data):
                        tdLog.info("sql:%s, row:%d col:%d data:%d == expect:%s" %
                            (self.sql, row, col, self.queryResult[row][col], data))
                else:
                    if self.queryResult[row][col] == datetime.datetime.fromisoformat(data):
                        tdLog.info("sql:%s, row:%d col:%d data:%s == expect:%s" %
                            (self.sql, row, col, self.queryResult[row][col], data))
                return
            if str(self.queryResult[row][col]) == str(data):
                tdLog.info("sql:%s, row:%d col:%d data:%s == expect:%s" %
-                            (self.sql, row, col, self.queryResult[row][col], data)) 
+                            (self.sql, row, col, self.queryResult[row][col], data))
                return
-            elif isinstance(data, float) and abs(self.queryResult[row][col] - data) <= 0.000001:                
+            elif isinstance(data, float) and abs(self.queryResult[row][col] - data) <= 0.000001:
                tdLog.info("sql:%s, row:%d col:%d data:%f == expect:%f" %
-                            (self.sql, row, col, self.queryResult[row][col], data)) 
+                            (self.sql, row, col, self.queryResult[row][col], data))
                return
            else:
                caller = inspect.getframeinfo(inspect.stack()[1][0])
                args = (caller.filename, caller.lineno, self.sql, row, col, self.queryResult[row][col], data)
-                tdLog.exit("%s(%d) failed: sql:%s row:%d col:%d data:%s != expect:%s" % args)        
+                tdLog.exit("%s(%d) failed: sql:%s row:%d col:%d data:%s != expect:%s" % args)
        if data is None:
            tdLog.info("sql:%s, row:%d col:%d data:%s == expect:%s" %
@ -162,11 +170,11 @@ class TDSql:
                       (self.sql, row, col, self.queryResult[row][col], data))
        elif isinstance(data, datetime.date):
            tdLog.info("sql:%s, row:%d col:%d data:%s == expect:%s" %
-                       (self.sql, row, col, self.queryResult[row][col], data))        
+                       (self.sql, row, col, self.queryResult[row][col], data))
        elif isinstance(data, float):
            tdLog.info("sql:%s, row:%d col:%d data:%s == expect:%s" %
                       (self.sql, row, col, self.queryResult[row][col], data))
-        else:            
+        else:
            tdLog.info("sql:%s, row:%d col:%d data:%s == expect:%d" %
                       (self.sql, row, col, self.queryResult[row][col], data))
@ -200,7 +208,7 @@ class TDSql:
            tdLog.exit("%s(%d) failed: sql:%s, affectedRows:%d != expect:%d" % args)
        tdLog.info("sql:%s, affectedRows:%d == expect:%d" % (self.sql, self.affectedRows, expectAffectedRows))
-    
+
    def taosdStatus(self, state):
        tdLog.sleep(5)
        pstate = 0
@ -221,7 +229,7 @@ class TDSql:
                continue
            pstate = 0
            break
-            
+
        args=(pstate,state)
        if pstate == state:
            tdLog.info("taosd state is %d == expect:%d" %args)
@ -236,11 +244,11 @@ class TDSql:
                    tdLog.exit("dir: %s is empty, expect: not empty" %dir)
                else:
                    tdLog.info("dir: %s is empty, expect: empty" %dir)
-            else:  
+            else:
                if state :
                    tdLog.info("dir: %s is not empty, expect: not empty" %dir)
                else:
-                    tdLog.exit("dir: %s is not empty, expect: empty" %dir)  
+                    tdLog.exit("dir: %s is not empty, expect: empty" %dir)
        else:
            tdLog.exit("dir: %s doesn't exist" %dir)
    def createDir(self, dir):
@ -250,5 +258,5 @@ class TDSql:
        os.makedirs( dir, 755 )
        tdLog.info("dir: %s is created" %dir)
        pass
-        
+
 tdSql = TDSql()
--- a/tests/script/api/stmtBatchTest.c
+++ b/tests/script/api/stmtBatchTest.c
@ -4406,6 +4406,654 @@ static void SpecifyColumnBatchCase_autoCreateTbl(TAOS *taos) {
 }
 /*=======================*/
 /*
 char * taos_stmt_errstr(TAOS_STMT *stmt) 用于在其他stmt API 返回错误（返回错误码或空指针）时获取错误信息，返回的错误信息可能是以下3种的一个：
 1. 当stmt或sqlobj为空时的terrno对于的错误消息;
 2. （可有的）详细错误消息；
 3. 返回的错误码对于的错误消息；
 */
 static int stmt_specifyCol_bind_error_case_001(TAOS_STMT *stmt, int tableNum, int rowsOfPerColum, int bingNum, int lenOfBinaryDef, int lenOfBinaryAct, int columnNum) {
  sampleValue* v = (sampleValue *)calloc(1, sizeof(sampleValue));
  int totalRowsPerTbl = rowsOfPerColum * bingNum;
  v->ts = (int64_t *)malloc(sizeof(int64_t) * (size_t)(totalRowsPerTbl * tableNum));
  v->br = (char *)malloc(sizeof(int64_t) * (size_t)(totalRowsPerTbl * lenOfBinaryDef));
  v->nr = (char *)malloc(sizeof(int64_t) * (size_t)(totalRowsPerTbl * lenOfBinaryDef));
  int *lb = (int *)malloc(MAX_ROWS_OF_PER_COLUMN * sizeof(int));
  TAOS_MULTI_BIND *params = calloc(1, sizeof(TAOS_MULTI_BIND) * (size_t)(bingNum * columnNum * (tableNum+1) * rowsOfPerColum));
  char* is_null = malloc(sizeof(char) * MAX_ROWS_OF_PER_COLUMN);
  char* no_null = malloc(sizeof(char) * MAX_ROWS_OF_PER_COLUMN);
  int64_t tts = 1591060628000;
  for (int i = 0; i < rowsOfPerColum; ++i) {
    lb[i] = lenOfBinaryAct;
    no_null[i] = 0;
    is_null[i] = (i % 10 == 2) ? 1 : 0;
    v->b[i]  = (int8_t)(i % 2);
    v->v1[i] = (int8_t)((i+1) % 2);
    v->v2[i] = (int16_t)i;
    v->v4[i] = (int32_t)(i+1);
    v->v8[i] = (int64_t)(i+2);
    v->f4[i] = (float)(i+3);
    v->f8[i] = (double)(i+4);
    char tbuf[MAX_BINARY_DEF_LEN];
    memset(tbuf, 0, MAX_BINARY_DEF_LEN);
    sprintf(tbuf, "binary-%d-0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789",  i%10);
    memcpy(v->br + i*lenOfBinaryDef, tbuf, (size_t)lenOfBinaryAct);
    memset(tbuf, 0, MAX_BINARY_DEF_LEN);
    sprintf(tbuf, "nchar-%d-0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789",  i%10);
    memcpy(v->nr + i*lenOfBinaryDef, tbuf, (size_t)lenOfBinaryAct);
    v->ts2[i] = tts + i;
  }
  int i = 0;
  for (int j = 0; j < bingNum * tableNum; j++) {
    params[i+0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
    params[i+0].buffer_length = sizeof(int64_t);
    params[i+0].buffer = &v->ts[j*rowsOfPerColum];
    params[i+0].length = NULL;
    params[i+0].is_null = no_null;
    params[i+0].num = rowsOfPerColum;
    params[i+1].buffer_type = TSDB_DATA_TYPE_BOOL;
    params[i+1].buffer_length = sizeof(int8_t);
    params[i+1].buffer = v->b;
    params[i+1].length = NULL;
    params[i+1].is_null = is_null;
    params[i+1].num = rowsOfPerColum;
    params[i+2].buffer_type = TSDB_DATA_TYPE_INT;
    params[i+2].buffer_length = sizeof(int32_t);
    params[i+2].buffer = v->v4;
    params[i+2].length = NULL;
    params[i+2].is_null = is_null;
    params[i+2].num = rowsOfPerColum;
    params[i+3].buffer_type = TSDB_DATA_TYPE_FLOAT;
    params[i+3].buffer_length = sizeof(float);
    params[i+3].buffer = v->f4;
    params[i+3].length = NULL;
    params[i+3].is_null = is_null;
    params[i+3].num = rowsOfPerColum;
    params[i+4].buffer_type = TSDB_DATA_TYPE_BINARY;
    params[i+4].buffer_length = (uintptr_t)lenOfBinaryDef;
    params[i+4].buffer = v->br;
    params[i+4].length = lb;
    params[i+4].is_null = is_null;
    params[i+4].num = rowsOfPerColum;
    i+=columnNum;
  }
  //int64_t tts = 1591060628000;
  for (int i = 0; i < totalRowsPerTbl * tableNum; ++i) {
    v->ts[i] = tts + i;
  }
  unsigned long long starttime = getCurrentTime();
 // create table m%d (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, br binary(%d), nr nchar(%d), ts2 timestamp)
  char *sql = "insert into m0 (ts,b,v4,f4,br) values(?,?,?,?,?)";
  int code;
  //TAOS_STMT *stmtNull = NULL;
  //int code = taos_stmt_prepare(stmtNull, sql, 0);
  //if (code != 0){
  //  printf("failed to execute taos_stmt_prepare. code:0x%x[%s][%s]\n", code, tstrerror(code),  taos_stmt_errstr(stmtNull));
  //  return -1;
  //}
  //char* sqlNull = NULL;
  //code = taos_stmt_prepare(stmt, sqlNull, 0);
  //if (code != 0){
  //  printf("failed to execute taos_stmt_prepare. code:0x%x[%s][%s]\n", code, tstrerror(code),  taos_stmt_errstr(stmt));
  //}
  code = taos_stmt_prepare(stmt, sql, 0);
  if (code != 0){
    printf("failed to execute taos_stmt_prepare. code:0x%x[%s][%s]\n", code, tstrerror(code),  taos_stmt_errstr(stmt));
    return -1;
  }
  int id = 0;
  for (int l = 0; l < bingNum; l++) {
    for (int zz = 0; zz < tableNum; zz++) {
      //char buf[32];
      //sprintf(buf, "m%d", zz);
      //code = taos_stmt_set_tbname(stmt, buf);
      //if (code != 0){
      //  printf("failed to execute taos_stmt_set_tbname. code:0x%x[%s]\n", code, tstrerror(code));
      //  return -1;
      //}  
      //for (int col=0; col < columnNum + 1000; ++col) {
      for (int col=0; col < columnNum; ++col) {
        if (col >= columnNum) col = 0;
        //code = taos_stmt_bind_single_param_batch(NULL, params + id, col);
        //code = taos_stmt_bind_single_param_batch(stmt, NULL, col);
        //code = taos_stmt_bind_single_param_batch(stmt, params + id, columnNum);
        code = taos_stmt_bind_single_param_batch(stmt, params + id, col);
        if (code != 0){
          printf("failed to execute taos_stmt_bind_single_param_batch. code:0x%x[%s][%s]\n", code, tstrerror(code),  taos_stmt_errstr(stmt));
          return -1;
        }
        id++;
      }
      //code = taos_stmt_add_batch(NULL);
      code = taos_stmt_add_batch(stmt);
      if (code != 0) {
        printf("failed to execute taos_stmt_add_batch. code:0x%x[%s][%s]\n", code, tstrerror(code),  taos_stmt_errstr(stmt));
        return -1;
      }      
      //code = taos_stmt_add_batch(stmt);
      //if (code != 0) {
      //  printf("failed to execute taos_stmt_add_batch second. code:0x%x[%s][%s]\n", code, tstrerror(code),  taos_stmt_errstr(stmt));
      //  return -1;
      //}
    }
    code = taos_stmt_execute(stmt);
    if (code != 0) {
      printf("failed to execute taos_stmt_execute. code:0x%x[%s]\n", code, tstrerror(code));
      return -1;
    }
  }
  unsigned long long endtime = getCurrentTime();
  unsigned long long totalRows = (uint32_t)(totalRowsPerTbl * tableNum);
  printf("insert total %d records, used %u seconds, avg:%u useconds per record\n", totalRows, (endtime-starttime)/1000000UL, (endtime-starttime)/totalRows);
  free(v->ts);  
  free(v->br);  
  free(v->nr);  
  free(v);
  free(lb);
  free(params);
  free(is_null);
  free(no_null);
  return 0;
 }
 static int stmt_specifyCol_bind_error_case_002(TAOS_STMT *stmt, int tableNum, int rowsOfPerColum, int bingNum, int lenOfBinaryDef, int lenOfBinaryAct, int columnNum) {
  sampleValue* v = (sampleValue *)calloc(1, sizeof(sampleValue));
  int totalRowsPerTbl = rowsOfPerColum * bingNum;
  v->ts = (int64_t *)malloc(sizeof(int64_t) * (size_t)(totalRowsPerTbl * tableNum));
  v->br = (char *)malloc(sizeof(int64_t) * (size_t)(totalRowsPerTbl * lenOfBinaryDef));
  v->nr = (char *)malloc(sizeof(int64_t) * (size_t)(totalRowsPerTbl * lenOfBinaryDef));
  int *lb = (int *)malloc(MAX_ROWS_OF_PER_COLUMN * sizeof(int));
  TAOS_MULTI_BIND *params = calloc(1, sizeof(TAOS_MULTI_BIND) * (size_t)(bingNum * columnNum * (tableNum+1) * rowsOfPerColum));
  char* is_null = malloc(sizeof(char) * MAX_ROWS_OF_PER_COLUMN);
  char* no_null = malloc(sizeof(char) * MAX_ROWS_OF_PER_COLUMN);
  int64_t tts = 1591060628000;
  for (int i = 0; i < rowsOfPerColum; ++i) {
    lb[i] = lenOfBinaryAct;
    no_null[i] = 0;
    is_null[i] = (i % 10 == 2) ? 1 : 0;
    v->b[i]  = (int8_t)(i % 2);
    v->v1[i] = (int8_t)((i+1) % 2);
    v->v2[i] = (int16_t)i;
    v->v4[i] = (int32_t)(i+1);
    v->v8[i] = (int64_t)(i+2);
    v->f4[i] = (float)(i+3);
    v->f8[i] = (double)(i+4);
    char tbuf[MAX_BINARY_DEF_LEN];
    memset(tbuf, 0, MAX_BINARY_DEF_LEN);
    sprintf(tbuf, "binary-%d",  i%10);
    memcpy(v->br + i*lenOfBinaryDef, tbuf, (size_t)lenOfBinaryAct);
    memset(tbuf, 0, MAX_BINARY_DEF_LEN);
    sprintf(tbuf, "nchar-%d",  i%10);
    memcpy(v->nr + i*lenOfBinaryDef, tbuf, (size_t)lenOfBinaryAct);
    v->ts2[i] = tts + i;
  }
  int i = 0;
  for (int j = 0; j < bingNum * tableNum; j++) {
    params[i+0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
    params[i+0].buffer_length = sizeof(int64_t);
    params[i+0].buffer = &v->ts[j*rowsOfPerColum];
    params[i+0].length = NULL;
    params[i+0].is_null = no_null;
    params[i+0].num = rowsOfPerColum;
    params[i+1].buffer_type = TSDB_DATA_TYPE_BOOL;
    params[i+1].buffer_length = sizeof(int8_t);
    params[i+1].buffer = v->b;
    params[i+1].length = NULL;
    params[i+1].is_null = is_null;
    params[i+1].num = rowsOfPerColum;
    params[i+2].buffer_type = TSDB_DATA_TYPE_INT;
    params[i+2].buffer_length = sizeof(int32_t);
    params[i+2].buffer = v->v4;
    params[i+2].length = NULL;
    params[i+2].is_null = is_null;
    params[i+2].num = rowsOfPerColum;
    params[i+3].buffer_type = TSDB_DATA_TYPE_FLOAT;
    params[i+3].buffer_length = sizeof(float);
    params[i+3].buffer = v->f4;
    params[i+3].length = NULL;
    params[i+3].is_null = is_null;
    params[i+3].num = rowsOfPerColum;
    params[i+4].buffer_type = TSDB_DATA_TYPE_BINARY;
    params[i+4].buffer_length = (uintptr_t)lenOfBinaryDef;
    params[i+4].buffer = v->br;
    params[i+4].length = lb;
    params[i+4].is_null = is_null;
    params[i+4].num = rowsOfPerColum;
    i+=columnNum;
  }
  //int64_t tts = 1591060628000;
  for (int i = 0; i < totalRowsPerTbl * tableNum; ++i) {
    v->ts[i] = tts + i;
  }
  unsigned long long starttime = getCurrentTime();
 // create table m%d (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, br binary(%d), nr nchar(%d), ts2 timestamp)
  char *sql = "insert into ? (ts,b,v4,f4,br) values(?,?,?,?,?)";
  int code = taos_stmt_prepare(stmt, sql, 0);
  if (code != 0){
    printf("failed to execute taos_stmt_prepare. code:0x%x[%s]\n", code, tstrerror(code));
    return -1;
  }
  int id = 0;
  for (int l = 0; l < bingNum; l++) {
    for (int zz = 0; zz < tableNum; zz++) {
      char buf[32];
      sprintf(buf, "m%d", zz);
      //stmt=NULL;
      code = taos_stmt_set_tbname(stmt, buf);
      if (code != 0){
        printf("failed to execute taos_stmt_set_tbname. code:0x%x[%s][%s]\n", code, tstrerror(code),  taos_stmt_errstr(stmt));
        return -1;
      }  
      for (int col=0; col < columnNum; ++col) {
        code = taos_stmt_bind_single_param_batch(stmt, params + id, col);
        if (code != 0){
          printf("failed to execute taos_stmt_bind_single_param_batch. code:0x%x[%s]\n", code, tstrerror(code));
          return -1;
        }
        id++;
      }
      code = taos_stmt_add_batch(stmt);
      if (code != 0) {
        printf("failed to execute taos_stmt_add_batch. code:0x%x[%s]\n", code, tstrerror(code));
        return -1;
      }
    }
    code = taos_stmt_execute(stmt);
    if (code != 0) {
      printf("failed to execute taos_stmt_execute. code:0x%x[%s]\n", code, tstrerror(code));
      return -1;
    }
  }
  unsigned long long endtime = getCurrentTime();
  unsigned long long totalRows = (uint32_t)(totalRowsPerTbl * tableNum);
  printf("insert total %d records, used %u seconds, avg:%u useconds per record\n", totalRows, (endtime-starttime)/1000000UL, (endtime-starttime)/totalRows);
  free(v->ts);  
  free(v->br);  
  free(v->nr);  
  free(v);
  free(lb);
  free(params);
  free(is_null);
  free(no_null);
  return 0;
 }
 static void SpecifyColumnBatchErrorCase(TAOS *taos) {
  TAOS_STMT *stmt = NULL;
  int tableNum;
  int lenOfBinaryDef;
  int rowsOfPerColum;
  int bingNum;
  int lenOfBinaryAct;
  int columnNum;
  int totalRowsPerTbl;
 //=======================================================================//
 //=============================== single table ==========================//
 //========== case 1: ======================//
 #if 0
 {
  stmt = taos_stmt_init(taos);
  tableNum = 1;
  rowsOfPerColum = 1;
  bingNum = 1;
  lenOfBinaryDef = 40;
  lenOfBinaryAct = 8;
  columnNum = 5;
  prepareVcolumn(taos, 1, tableNum, lenOfBinaryDef, "db1");
  stmt_specifyCol_bind_error_case_001(stmt, tableNum, rowsOfPerColum, bingNum, lenOfBinaryDef, lenOfBinaryAct, columnNum);
  totalRowsPerTbl = rowsOfPerColum * bingNum;
  checkResult(taos, "m0", 0, totalRowsPerTbl);
  taos_stmt_close(stmt);
  printf("case 1 check result end\n\n");
 }
 #endif  
  //========== case 2: ======================//
 #if 1
 {
    stmt = taos_stmt_init(taos);
    tableNum = 1;
    rowsOfPerColum = 5;
    bingNum = 1;
    lenOfBinaryDef = 1000;
    lenOfBinaryAct = 15;
    columnNum = 5;
    prepareVcolumn(taos, 1, tableNum, lenOfBinaryDef, "db2");
    stmt_specifyCol_bind_error_case_002(stmt, tableNum, rowsOfPerColum, bingNum, lenOfBinaryDef, lenOfBinaryAct, columnNum);
    totalRowsPerTbl = rowsOfPerColum * bingNum;
    checkResult(taos, "m0", 0, totalRowsPerTbl);
    //checkResult(taos, "m1", 0, totalRowsPerTbl);
    //checkResult(taos, "m2", 0, totalRowsPerTbl);  
    //checkResult(taos, "m3", 0, totalRowsPerTbl);
    //checkResult(taos, "m4", 0, totalRowsPerTbl);
    //checkResult(taos, "m5", 0, totalRowsPerTbl);
    //checkResult(taos, "m6", 0, totalRowsPerTbl);  
    //checkResult(taos, "m7", 0, totalRowsPerTbl);
    //checkResult(taos, "m8", 0, totalRowsPerTbl);  
    //checkResult(taos, "m9", 0, totalRowsPerTbl);
    taos_stmt_close(stmt);
    printf("case 2 check result end\n\n");
 }
 #endif  
      //========== case 2-1: ======================//
 #if 0
    {
        stmt = taos_stmt_init(taos);
        tableNum = 1;
        rowsOfPerColum = 32767;
        bingNum = 1;
        lenOfBinaryDef = 1000;
        lenOfBinaryAct = 15;
        columnNum = 5;
        prepareVcolumn(taos, 1, tableNum, lenOfBinaryDef, "db2_1");
        stmt_specifyCol_bind_case_001(stmt, tableNum, rowsOfPerColum, bingNum, lenOfBinaryDef, lenOfBinaryAct, columnNum);
        totalRowsPerTbl = rowsOfPerColum * bingNum;
        checkResult(taos, "m0", 0, totalRowsPerTbl);
        //checkResult(taos, "m1", 0, totalRowsPerTbl);
        //checkResult(taos, "m2", 0, totalRowsPerTbl);  
        //checkResult(taos, "m3", 0, totalRowsPerTbl);
        //checkResult(taos, "m4", 0, totalRowsPerTbl);
        //checkResult(taos, "m5", 0, totalRowsPerTbl);
        //checkResult(taos, "m6", 0, totalRowsPerTbl);  
        //checkResult(taos, "m7", 0, totalRowsPerTbl);
        //checkResult(taos, "m8", 0, totalRowsPerTbl);  
        //checkResult(taos, "m9", 0, totalRowsPerTbl);
        taos_stmt_close(stmt);
        printf("case 2-1 check result end\n\n");
    }
 #endif  
          //========== case 2-2: ======================//
 #if 0
        {
            printf("====case 2-2 error test start\n");
            stmt = taos_stmt_init(taos);
            tableNum = 1;
            rowsOfPerColum = 32768;
            bingNum = 1;
            lenOfBinaryDef = 1000;
            lenOfBinaryAct = 15;
            columnNum = 5;
            prepareVcolumn(taos, 1, tableNum, lenOfBinaryDef, "db2_2");
            stmt_specifyCol_bind_case_001(stmt, tableNum, rowsOfPerColum, bingNum, lenOfBinaryDef, lenOfBinaryAct, columnNum);
            totalRowsPerTbl = rowsOfPerColum * bingNum;
            checkResult(taos, "m0", 0, totalRowsPerTbl);
            //checkResult(taos, "m1", 0, totalRowsPerTbl);
            //checkResult(taos, "m2", 0, totalRowsPerTbl);  
            //checkResult(taos, "m3", 0, totalRowsPerTbl);
            //checkResult(taos, "m4", 0, totalRowsPerTbl);
            //checkResult(taos, "m5", 0, totalRowsPerTbl);
            //checkResult(taos, "m6", 0, totalRowsPerTbl);  
            //checkResult(taos, "m7", 0, totalRowsPerTbl);
            //checkResult(taos, "m8", 0, totalRowsPerTbl);  
            //checkResult(taos, "m9", 0, totalRowsPerTbl);
            taos_stmt_close(stmt);
            printf("====case 2-2 check result end\n\n");
        }
 #endif  
    //========== case 3: ======================//
 #if 0
  {
      stmt = taos_stmt_init(taos);
      tableNum = 1;
      rowsOfPerColum = 1;
      bingNum = 5;
      lenOfBinaryDef = 1000;
      lenOfBinaryAct = 20;
      columnNum = 5;
      prepareVcolumn(taos, 1, tableNum, lenOfBinaryDef, "db3");
      stmt_specifyCol_bind_case_001(stmt, tableNum, rowsOfPerColum, bingNum, lenOfBinaryDef, lenOfBinaryAct, columnNum);
      totalRowsPerTbl = rowsOfPerColum * bingNum;
      checkResult(taos, "m0", 0, totalRowsPerTbl);
    //checkResult(taos, "m1", 0, totalRowsPerTbl);
    //checkResult(taos, "m2", 0, totalRowsPerTbl);  
    //checkResult(taos, "m3", 0, totalRowsPerTbl);
    //checkResult(taos, "m4", 0, totalRowsPerTbl);
    //checkResult(taos, "m5", 0, totalRowsPerTbl);
    //checkResult(taos, "m6", 0, totalRowsPerTbl);  
    //checkResult(taos, "m7", 0, totalRowsPerTbl);
    //checkResult(taos, "m8", 0, totalRowsPerTbl);  
    //checkResult(taos, "m9", 0, totalRowsPerTbl);
      taos_stmt_close(stmt);
      printf("case 3 check result end\n\n");
  }
 #endif  
      //========== case 4: ======================//
 #if 0
    {
        stmt = taos_stmt_init(taos);
        tableNum = 1;
        rowsOfPerColum = 5;
        bingNum = 5;
        lenOfBinaryDef = 1000;
        lenOfBinaryAct = 33;
        columnNum = 5;
        prepareVcolumn(taos, 1, tableNum, lenOfBinaryDef, "db4");
        stmt_specifyCol_bind_case_001(stmt, tableNum, rowsOfPerColum, bingNum, lenOfBinaryDef, lenOfBinaryAct, columnNum);
        totalRowsPerTbl = rowsOfPerColum * bingNum;
        checkResult(taos, "m0", 0, totalRowsPerTbl);
      //checkResult(taos, "m1", 0, totalRowsPerTbl);
      //checkResult(taos, "m2", 0, totalRowsPerTbl);  
      //checkResult(taos, "m3", 0, totalRowsPerTbl);
      //checkResult(taos, "m4", 0, totalRowsPerTbl);
      //checkResult(taos, "m5", 0, totalRowsPerTbl);
      //checkResult(taos, "m6", 0, totalRowsPerTbl);  
      //checkResult(taos, "m7", 0, totalRowsPerTbl);
      //checkResult(taos, "m8", 0, totalRowsPerTbl);  
      //checkResult(taos, "m9", 0, totalRowsPerTbl);
        taos_stmt_close(stmt);
        printf("case 4 check result end\n\n");
    }
 #endif  
 //=======================================================================//
 //=============================== multi tables ==========================//
  //========== case 5: ======================//
 #if 0
  {
    stmt = taos_stmt_init(taos);
    tableNum = 5;
    rowsOfPerColum = 1;
    bingNum = 1;
    lenOfBinaryDef = 40;
    lenOfBinaryAct = 16;
    columnNum = 5;
    prepareVcolumn(taos, 1, tableNum, lenOfBinaryDef, "db5");
    stmt_specifyCol_bind_case_002(stmt, tableNum, rowsOfPerColum, bingNum, lenOfBinaryDef, lenOfBinaryAct, columnNum);
    totalRowsPerTbl = rowsOfPerColum * bingNum;
    checkResult(taos, "m0", 0, totalRowsPerTbl);
    checkResult(taos, "m1", 0, totalRowsPerTbl);
    checkResult(taos, "m2", 0, totalRowsPerTbl);  
    checkResult(taos, "m3", 0, totalRowsPerTbl);
    checkResult(taos, "m4", 0, totalRowsPerTbl);
    taos_stmt_close(stmt);
    printf("case 5 check result end\n\n");
  }
 #endif  
    //========== case 6: ======================//
 #if 0
  {
      stmt = taos_stmt_init(taos);
      tableNum = 5;
      rowsOfPerColum = 5;
      bingNum = 1;
      lenOfBinaryDef = 1000;
      lenOfBinaryAct = 20;
      columnNum = 5;
      prepareVcolumn(taos, 1, tableNum, lenOfBinaryDef, "db6");
      stmt_specifyCol_bind_case_002(stmt, tableNum, rowsOfPerColum, bingNum, lenOfBinaryDef, lenOfBinaryAct, columnNum);
      totalRowsPerTbl = rowsOfPerColum * bingNum;
      checkResult(taos, "m0", 0, totalRowsPerTbl);
      checkResult(taos, "m1", 0, totalRowsPerTbl);
      checkResult(taos, "m2", 0, totalRowsPerTbl);  
      checkResult(taos, "m3", 0, totalRowsPerTbl);
      checkResult(taos, "m4", 0, totalRowsPerTbl);
      taos_stmt_close(stmt);
      printf("case 6 check result end\n\n");
  }
 #endif  
      //========== case 7: ======================//
 #if 0
    {
        stmt = taos_stmt_init(taos);
        tableNum = 5;
        rowsOfPerColum = 1;
        bingNum = 5;
        lenOfBinaryDef = 1000;
        lenOfBinaryAct = 33;
        columnNum = 5;
        prepareVcolumn(taos, 1, tableNum, lenOfBinaryDef, "db7");
        stmt_specifyCol_bind_case_002(stmt, tableNum, rowsOfPerColum, bingNum, lenOfBinaryDef, lenOfBinaryAct, columnNum);
        totalRowsPerTbl = rowsOfPerColum * bingNum;
        checkResult(taos, "m0", 0, totalRowsPerTbl);
        checkResult(taos, "m1", 0, totalRowsPerTbl);
        checkResult(taos, "m2", 0, totalRowsPerTbl);  
        checkResult(taos, "m3", 0, totalRowsPerTbl);
        checkResult(taos, "m4", 0, totalRowsPerTbl);
        taos_stmt_close(stmt);
        printf("case 7 check result end\n\n");
    }
 #endif  
        //========== case 8: ======================//
 #if 0
 {
    stmt = taos_stmt_init(taos);
    tableNum = 5;
    rowsOfPerColum = 5;
    bingNum = 5;
    lenOfBinaryDef = 1000;
    lenOfBinaryAct = 40;
    columnNum = 5;
    prepareVcolumn(taos, 1, tableNum, lenOfBinaryDef, "db8");
    stmt_specifyCol_bind_case_002(stmt, tableNum, rowsOfPerColum, bingNum, lenOfBinaryDef, lenOfBinaryAct, columnNum);
    totalRowsPerTbl = rowsOfPerColum * bingNum;
    checkResult(taos, "m0", 0, totalRowsPerTbl);
    checkResult(taos, "m1", 0, totalRowsPerTbl);
    checkResult(taos, "m2", 0, totalRowsPerTbl);  
    checkResult(taos, "m3", 0, totalRowsPerTbl);
    checkResult(taos, "m4", 0, totalRowsPerTbl);
    taos_stmt_close(stmt);
    printf("case 8 check result end\n\n");
 }
 #endif  
  //=======================================================================//
  //=============================== multi-rows to single table ==========================//
  //========== case 9: ======================//
 #if 0
  {
    stmt = taos_stmt_init(taos);
    tableNum = 1;
    rowsOfPerColum = 23740;
    bingNum = 1;
    lenOfBinaryDef = 40;
    lenOfBinaryAct = 8;
    columnNum = 5;
    prepareVcolumn(taos, 1, tableNum, lenOfBinaryDef, "db9");
    stmt_specifyCol_bind_case_001(stmt, tableNum, rowsOfPerColum, bingNum, lenOfBinaryDef, lenOfBinaryAct, columnNum);
    totalRowsPerTbl = rowsOfPerColum * bingNum;
    checkResult(taos, "m0", 0, totalRowsPerTbl);
    taos_stmt_close(stmt);
    printf("case 9 check result end\n\n");
  }
 #endif  
  return ;
 }
 int main(int argc, char *argv[])
 {
  TAOS *taos;
@ -4472,6 +5120,7 @@ int main(int argc, char *argv[])
  //runCase_long(taos);
  //SpecifyColumnBatchCase(taos);
  SpecifyColumnBatchCase_autoCreateTbl(taos);
  //SpecifyColumnBatchErrorCase(taos);
  return 0;
 }
--- a/tests/script/general/http/grafana_bug.sim
+++ b/tests/script/general/http/grafana_bug.sim
@ -20,17 +20,22 @@ sql use db
 sql create table tb (ts timestamp, val int, val1 int, val2 int)
 sql create table tb2 (ts timestamp, val int, val1 int, val2 int)
 sql create table t2 (ts timestamp, val int)
 sql create table tb3 (ts timestamp, val int, val1 int, val2 int)
 sql insert into tb values('2020-01-01 00:00:00.000', 1, 11, 21)
 sql insert into tb values('2020-01-02 00:00:00.000', 1, 12, 22)
 sql insert into tb values('2020-01-03 00:00:00.000', 2, 13, 23)
 sql insert into tb values('2020-01-04 00:00:00.000', 2, 14, 24)
 sql insert into tb2 values('2020-01-01 00:00:00.000', 21, 211, 221)
 sql insert into tb2 values('2020-01-02 00:00:00.000', 21, 212, 222)
 sql insert into tb2 values('2020-01-03 00:00:00.000', 22, 213, 223)
 sql insert into tb2 values('2020-01-04 00:00:00.000', 22, 214, 224)
 sql insert into tb3 values('2020-01-01 00:00:00.000', NULL, NULL, NULL)
 sql insert into tb3 values('2020-01-02 00:00:00.000', NULL, NULL, NULL)
 print ===============  step1 - one query, 1 column, with timestamp
 system_content curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d '[ {"refId":"A","alias":"","sql":"select ts from db.tb where ts >= 1577980800000 "} ]' 127.0.0.1:7111/grafana/query
@ -235,4 +240,11 @@ if $system_content != @[{"refId":"B","target":"BB{val2:223,}","datapoints":[[213
  return -1
 endi
 print ===============  step26 - 2 column, no timestamp, NULL
 system_content curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d '[ {"refId":"A","alias":"","sql":"select * from db.tb3 "} ]' 127.0.0.1:7111/grafana/query
 print step1-> $system_content
 if $system_content != @[{"refId":"A","target":"{val1:nil, val2:nil}","datapoints":[[null,1577808000000],[null,1577894400000]]}]@ then
  return -1
 endi
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
--- a/tests/script/general/parser/function.sim
+++ b/tests/script/general/parser/function.sim
@ -817,6 +817,9 @@ print ====================> TODO stddev + normal column filter
 print ====================> irate
 sql_error select irate(f1) from st1;
 sql select irate(f1) from  st1 group by tbname;
 sql select irate(k) from t1
 if $rows != 1 then
  return -1
@ -1073,6 +1076,12 @@ sql insert into t0 values('2020-1-1 1:3:9', 9);
 sql insert into t0 values('2020-1-1 1:4:10', 10);
 sql insert into t1 values('2020-1-1 1:1:2', 2);
 print ===========================>td-4739
 sql select diff(val) from (select derivative(k, 1s, 0) val from t1);
 if $rows != 0 then
  return -1
 endi
 sql insert into t1 values('2020-1-1 1:1:4', 20);
 sql insert into t1 values('2020-1-1 1:1:6', 200);
 sql insert into t1 values('2020-1-1 1:1:8', 2000);
@ -1080,6 +1089,8 @@ sql insert into t1 values('2020-1-1 1:1:10', 20000);
 sql_error select derivative(k, 1s, 0) from m1;
 sql_error select derivative(k, 1s, 0) from m1 group by a;
 sql_error select derivative(f1, 1s, 0) from (select k from t1);
 sql select derivative(k, 1s, 0) from m1 group by tbname
 if $rows != 12 then
  return -1
@ -1119,4 +1130,6 @@ endi
 if $data92 != t1 then
  return -1
-endi
+endi
 sql select derivative(test_column_alias_name, 1s, 0) from (select avg(k) test_column_alias_name from t1 interval(1s));
--- a/tests/script/general/parser/nestquery.sim
+++ b/tests/script/general/parser/nestquery.sim
@ -273,4 +273,18 @@ if $data03 != @20-09-15 00:00:00.000@ then
  return -1
 endi
 sql_error select derivative(val, 1s, 0) from (select c1 val from nest_tb0);
 sql select diff(val) from (select c1 val from nest_tb0);
 if $rows != 9999 then
  return -1
 endi
 if $data00 != @70-01-01 08:00:00.000@ then
  return -1
 endi
 if $data01 != 1 then
  return -1
 endi
 system sh/exec.sh -n dnode1 -s stop -x SIGINT