Merge branch 'develop' into feature/query

3163eff6 · Haojun Liao · c8b92c46 · f3bcb2f3 · 3163eff6 · 3163eff6
262 changed file
--- a/.travis.yml
+++ b/.travis.yml
@@ -270,19 +270,20 @@ matrix:
        fi
      - make > /dev/null
-#  - os: osx
+  - os: osx
-#    language: c
+    osx_image: xcode11.4
-#    compiler: clang
+    language: c
-#    env: DESC="mac/clang build"
+    compiler: clang
-#    git:
+    env: DESC="mac/clang build"
-#      - depth: 1
+    git:
-#    addons:
+      - depth: 1
-#      homebrew:
+    addons:
-#        - cmake
+      homebrew:
-#
+        - cmake
-#    script:
-#      - cd ${TRAVIS_BUILD_DIR}
+    script:
-#      - mkdir debug
+      - cd ${TRAVIS_BUILD_DIR}
-#      - cd debug
+      - mkdir debug
-#      - cmake .. > /dev/null
+      - cd debug
-#      - make > /dev/null
+      - cmake .. > /dev/null
+      - make > /dev/null
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -13,7 +13,7 @@ ENDIF ()
 SET(TD_ACCOUNT FALSE)
 SET(TD_ADMIN FALSE)
 SET(TD_GRANT FALSE)
-SET(TD_MQTT TRUE)
+SET(TD_MQTT FALSE)
 SET(TD_TSDB_PLUGINS FALSE)
 SET(TD_COVER FALSE)
@@ -29,6 +29,11 @@ MESSAGE(STATUS "Community directory: " ${TD_COMMUNITY_DIR})
 INCLUDE(cmake/input.inc)
 INCLUDE(cmake/platform.inc)
+IF (TD_WINDOWS OR TD_DARWIN) 
+  SET(TD_SOMODE_STATIC TRUE)
+ENDIF ()
 INCLUDE(cmake/define.inc)
 INCLUDE(cmake/env.inc)
 INCLUDE(cmake/version.inc)

--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -176,5 +176,84 @@ pipeline {
    }
  }
  }
+  post {      
+        success {
+            emailext (
+                subject: "PR-result: Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]'",
+                body: '''<!DOCTYPE html>
+                <html>
+                <head>
+                <meta charset="UTF-8">
+                </head>
+                <body leftmargin="8" marginwidth="0" topmargin="8" marginheight="4" offset="0">
+                    <table width="95%" cellpadding="0" cellspacing="0" style="font-size: 16pt; font-family: Tahoma, Arial, Helvetica, sans-serif">
+                        <tr>
+                            <td><br />
+                                <b><font color="#0B610B"><font size="6">构建信息</font></font></b>
+                                <hr size="2" width="100%" align="center" /></td>
+                        </tr>
+                        <tr>
+                            <td>
+                                <ul>
+                                <div style="font-size:18px">
+                                    <li>构建名称>>分支：${PROJECT_NAME}</li>
+                                    <li>构建结果：<span style="color:green"> Successful </span></li>
+                                    <li>构建编号：${BUILD_NUMBER}</li>
+                                    <li>触发用户：${CAUSE}</li>
+                                    <li>提交信息：${CHANGE_TITLE}</li>
+                                    <li>构建地址：<a href=${BUILD_URL}>${BUILD_URL}</a></li>
+                                    <li>构建日志：<a href=${BUILD_URL}console>${BUILD_URL}console</a></li>
+                                    <li>变更集：${JELLY_SCRIPT}</li>
+                                </div>
+                                </ul>
+                            </td>
+                        </tr>
+                    </table></font>
+                </body>
+                </html>''',
+                to: "${env.CHANGE_AUTHOR_EMAIL}",
+                from: "support@taosdata.com"
+            )
+        }
+        failure {
+            emailext (
+                subject: "PR-result: Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]'",
+                body: '''<!DOCTYPE html>
+                <html>
+                <head>
+                <meta charset="UTF-8">
+                </head>
+                <body leftmargin="8" marginwidth="0" topmargin="8" marginheight="4" offset="0">
+                    <table width="95%" cellpadding="0" cellspacing="0" style="font-size: 16pt; font-family: Tahoma, Arial, Helvetica, sans-serif">
+                        <tr>
+                            <td><br />
+                                <b><font color="#0B610B"><font size="6">构建信息</font></font></b>
+                                <hr size="2" width="100%" align="center" /></td>
+                        </tr>
+                        <tr>
+                            <td>
+                                <ul>
+                                <div style="font-size:18px">
+                                    <li>构建名称>>分支：${PROJECT_NAME}</li>
+                                    <li>构建结果：<span style="color:green"> Successful </span></li>
+                                    <li>构建编号：${BUILD_NUMBER}</li>
+                                    <li>触发用户：${CAUSE}</li>
+                                    <li>提交信息：${CHANGE_TITLE}</li>
+                                    <li>构建地址：<a href=${BUILD_URL}>${BUILD_URL}</a></li>
+                                    <li>构建日志：<a href=${BUILD_URL}console>${BUILD_URL}console</a></li>
+                                    <li>变更集：${JELLY_SCRIPT}</li>
+                                </div>
+                                </ul>
+                            </td>
+                        </tr>
+                    </table></font>
+                </body>
+                </html>''',
+                to: "${env.CHANGE_AUTHOR_EMAIL}",
+                from: "support@taosdata.com"
+            )
+        }
+    }
 }
--- a/README.md
+++ b/README.md
@@ -126,44 +126,57 @@ cmake .. -DCPUTYPE=aarch32 && cmake --build .
 If you use the Visual Studio 2013, please open a command window by executing "cmd.exe".
 Please specify "x86_amd64" for 64 bits Windows or specify "x86" is for 32 bits Windows when you execute vcvarsall.bat.
-```
+```cmd
 mkdir debug && cd debug
 "C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\vcvarsall.bat" < x86_amd64 | x86 >
 cmake .. -G "NMake Makefiles"
 nmake
 ```
-If you use the Visual Studio 2019, please open a command window by executing "cmd.exe".
+If you use the Visual Studio 2019 or 2017:
+please open a command window by executing "cmd.exe".
 Please specify "x64" for 64 bits Windows or specify "x86" is for 32 bits Windows when you execute vcvarsall.bat.
-```
+```cmd
 mkdir debug && cd debug
 "c:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvarsall.bat" < x64 | x86 >
 cmake .. -G "NMake Makefiles"
 nmake
 ```
-Or, you can open a command window by clicking Visual Studio 2019 menu "Tools -> Command Line -> Developer Command Prompt" or "Tools -> Command Line -> Developer PowerShell" then execute commands as follows:
+Or, you can simply open a command window by clicking Windows Start -> "Visual Studio < 2019 | 2017 >" folder -> "x64 Native Tools Command Prompt for VS < 2019 | 2017 >" or "x86 Native Tools Command Prompt for VS < 2019 | 2017 >" depends what architecture your Windows is, then execute commands as follows:
-```
+```cmd
 mkdir debug && cd debug
 cmake .. -G "NMake Makefiles"
 nmake
 ```
+### On Mac OS X platform
+Please install XCode command line tools and cmake. Verified with XCode 11.4+ on Catalina and Big Sur.
+```shell
+mkdir debug && cd debug
+cmake .. && cmake --build .
+```
 # Quick Run
 # Quick Run
 To quickly start a TDengine server after building, run the command below in terminal:
-```cmd
+```bash
 ./build/bin/taosd -c test/cfg
 ```
 In another terminal, use the TDengine shell to connect the server:
-```
+```bash
 ./build/bin/taos -c test/cfg
 ```
 option "-c test/cfg" specifies the system configuration file directory. 
 # Installing
 After building successfully, TDengine can be installed by:
-```cmd
+```bash
 make install
 ```
 Users can find more information about directories installed on the system in the [directory and files](https://www.taosdata.com/en/documentation/administrator/#Directory-and-Files) section. It should be noted that installing from source code does not configure service management for TDengine.

--- a/cmake/define.inc
+++ b/cmake/define.inc
@@ -128,6 +128,8 @@ IF (TD_DARWIN_64)
  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -Wno-missing-braces -fPIC -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
  SET(DEBUG_FLAGS "-O0 -g3 -DDEBUG")
  SET(RELEASE_FLAGS "-Og")
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/cJson/inc)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/lz4/inc)
 ENDIF ()
 IF (TD_WINDOWS)
@@ -139,6 +141,9 @@ IF (TD_WINDOWS)
  SET(CMAKE_GENERATOR "NMake Makefiles" CACHE INTERNAL "" FORCE)
  IF (NOT TD_GODLL)
    SET(COMMON_FLAGS "/nologo /WX /wd4018 /wd2220 /Oi /Oy- /Gm- /EHsc /MT /GS /Gy /fp:precise /Zc:wchar_t /Zc:forScope /Gd /errorReport:prompt /analyze-")
+    IF (MSVC AND (MSVC_VERSION GREATER_EQUAL 1900))
+      SET(COMMON_FLAGS "${COMMON_FLAGS} /Wv:18")
+    ENDIF ()
    SET(DEBUG_FLAGS "/Zi /W3 /GL")
    SET(RELEASE_FLAGS "/W0 /O3 /GL")
  ENDIF ()

--- 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.17-dist.jar DESTINATION connector/jdbc)
+    INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.18-dist.jar DESTINATION connector/jdbc)
  ENDIF ()
 ELSEIF (TD_DARWIN)
  SET(TD_MAKE_INSTALL_SH "${TD_COMMUNITY_DIR}/packaging/tools/make_install.sh")

--- a/deps/CMakeLists.txt
+++ b/deps/CMakeLists.txt
@@ -13,3 +13,7 @@ ADD_SUBDIRECTORY(MsvcLibX)
 IF (TD_LINUX AND TD_MQTT)
  ADD_SUBDIRECTORY(MQTT-C)
 ENDIF ()
+IF (TD_DARWIN AND TD_MQTT)
+  ADD_SUBDIRECTORY(MQTT-C)
+ENDIF ()
--- a/deps/zlib-1.2.11/src/gzlib.c
+++ b/deps/zlib-1.2.11/src/gzlib.c
@@ -5,6 +5,10 @@
 #include <stdint.h>
 #include "gzguts.h"
+#ifndef O_BINARY
+  #define O_BINARY 0
+#endif
 #if defined(_WIN32) && !defined(__BORLANDC__) && !defined(__MINGW32__)
 #  define LSEEK _lseeki64
 #else
@@ -240,9 +244,9 @@ local gzFile gz_open(path, fd, mode)
    /* open the file with the appropriate flags (or just use fd) */
    state->fd = fd > -1 ? fd : (
 #ifdef WIDECHAR
-        fd == -2 ? _wopen(path, oflag, 0666) :
+        fd == -2 ? _wopen(path, oflag | O_BINARY, 0666) :
 #endif
-        open((const char *)path, oflag, 0666));
+        open((const char *)path, oflag | O_BINARY, 0666));
    if (state->fd == -1) {
        free(state->path);
        free(state);

--- a/documentation20/webdocs/markdowndocs/TAOS SQL-ch.md
+++ b/documentation20/webdocs/markdowndocs/TAOS SQL-ch.md
@@ -213,16 +213,19 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
    如果表是通过[超级表](../super-table/)创建，更改表结构的操作只能对超级表进行。同时针对超级表的结构更改对所有通过该结构创建的表生效。对于不是通过超级表创建的表，可以直接修改表结构
 ## 超级表STable管理
+注意：在 2.0.15 以前的版本中，并不支持 STABLE 保留字，而是写作 TABLE。也即，在本节后文的指令说明中，CREATE、DROP、ALTER 三个指令在老版本中保留字需写作 TABLE 而不是 STABLE。
 - **创建超级表**
    ```mysql
-    CREATE TABLE [IF NOT EXISTS] stb_name (timestamp_field_name TIMESTAMP, field1_name data_type1 [, field2_name data_type2 ...]) TAGS (tag1_name tag_type1, tag2_name tag_type2 [, tag3_name tag_type3]);
+    CREATE STABLE [IF NOT EXISTS] stb_name (timestamp_field_name TIMESTAMP, field1_name data_type1 [, field2_name data_type2 ...]) TAGS (tag1_name tag_type1, tag2_name tag_type2 [, tag3_name tag_type3]);
    ```
-    创建STable, 与创建表的SQL语法相似，但需指定TAGS字段的名称和类型
+    创建 STable，与创建表的 SQL 语法相似，但需指定 TAGS 字段的名称和类型
    说明：
-    1) TAGS 列的数据类型不能是timestamp类型；
+    1) TAGS 列的数据类型不能是 timestamp 类型；
    2) TAGS 列名不能与其他列名相同；
@@ -233,16 +236,16 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
 - **删除超级表**
    ```mysql
-    DROP TABLE [IF EXISTS] stb_name;
+    DROP STABLE [IF EXISTS] stb_name;
    ```
-    删除STable会自动删除通过STable创建的子表。
+    删除 STable 会自动删除通过 STable 创建的子表。
 - **显示当前数据库下的所有超级表信息**
    ```mysql
    SHOW STABLES [LIKE tb_name_wildcar];
    ```
-    查看数据库内全部STable，及其相关信息，包括STable的名称、创建时间、列数量、标签（TAG）数量、通过该STable建表的数量。
+    查看数据库内全部 STable，及其相关信息，包括 STable 的名称、创建时间、列数量、标签（TAG）数量、通过该 STable 建表的数量。
 - **获取超级表的结构信息**
@@ -253,43 +256,43 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
 - **超级表增加列**
    ```mysql
-    ALTER TABLE stb_name ADD COLUMN field_name data_type;
+    ALTER STABLE stb_name ADD COLUMN field_name data_type;
    ```
 - **超级表删除列**
    ```mysql
-    ALTER TABLE stb_name DROP COLUMN field_name; 
+    ALTER STABLE stb_name DROP COLUMN field_name; 
    ```
 ## 超级表 STable 中 TAG 管理
 - **添加标签**
    ```mysql
-    ALTER TABLE stb_name ADD TAG new_tag_name tag_type;
+    ALTER STABLE stb_name ADD TAG new_tag_name tag_type;
    ```
-    为STable增加一个新的标签，并指定新标签的类型。标签总数不能超过128个，总长度不超过16k个字符。
+    为 STable 增加一个新的标签，并指定新标签的类型。标签总数不能超过 128 个，总长度不超过 16k 个字符。
 - **删除标签**
    ```mysql
-    ALTER TABLE stb_name DROP TAG tag_name;
+    ALTER STABLE stb_name DROP TAG tag_name;
    ```
    删除超级表的一个标签，从超级表删除某个标签后，该超级表下的所有子表也会自动删除该标签。
 - **修改标签名**
    ```mysql
-    ALTER TABLE stb_name CHANGE TAG old_tag_name new_tag_name;
+    ALTER STABLE stb_name CHANGE TAG old_tag_name new_tag_name;
    ```
    修改超级表的标签名，从超级表修改某个标签名后，该超级表下的所有子表也会自动更新该标签名。
 - **修改子表标签值**
    ```mysql
-    ALTER TABLE tb_name SET TAG tag_name=new_tag_value;
+    ALTER STABLE tb_name SET TAG tag_name=new_tag_value;
    ```
-    说明：除了更新标签的值的操作是针对子表进行，其他所有的标签操作（添加标签、删除标签等）均只能作用于STable，不能对单个子表操作。对STable添加标签以后，依托于该STable建立的所有表将自动增加了一个标签，所有新增标签的默认值都是NULL。
+    说明：除了更新标签的值的操作是针对子表进行，其他所有的标签操作（添加标签、删除标签等）均只能作用于 STable，不能对单个子表操作。对 STable 添加标签以后，依托于该 STable 建立的所有表将自动增加了一个标签，所有新增标签的默认值都是 NULL。
 ## 数据写入
@@ -467,6 +470,17 @@ Query OK, 2 row(s) in set (0.003112s)
 注意：普通表的通配符 * 中并不包含 _标签列_。
+##### 获取标签列的去重取值
+从 2.0.15 版本开始，支持在超级表查询标签列时，指定 distinct 关键字，这样将返回指定标签列的所有不重复取值。
+```mysql
+SELECT DISTINCT tag_name FROM stb_name;
+```
+注意：目前 distinct 关键字只支持对超级表的标签列进行去重，而不能用于普通列。
 #### 结果集列名
 ```SELECT```子句中，如果不指定返回结果集合的列名，结果集列名称默认使用```SELECT```子句中的表达式名称作为列名称。此外，用户可使用```AS```来重命名返回结果集合中列的名称。例如：

--- a/documentation20/webdocs/markdowndocs/administrator-ch.md
+++ b/documentation20/webdocs/markdowndocs/administrator-ch.md
@@ -12,7 +12,7 @@
 Memory Size = maxVgroupsPerDb * (blocks * cache + 10Mb) + numOfTables * (tagSizePerTable + 0.5Kb)
 ```
-示例：假设是4核机器，cache是缺省大小16M, blocks是缺省值6，假设有10万张表，标签总长度是256字节，则总的内存需求为：4\*(16\*6+10) + 100000*(0.25+0.5)/1000 = 499M。
+示例：假设是4核机器，cache是缺省大小16M, blocks是缺省值6，假设有10万张表，标签总长度是256字节，则总的内存需求为：4\*(16\*6+10) + 100000\*(0.25+0.5)/1000 = 499M。
 实际运行的系统往往会根据数据特点的不同，将数据存放在不同的DB里。因此做规划时，也需要考虑。
@@ -35,7 +35,7 @@ TDengine相对于通用数据库，有超高的压缩比，在绝大多数场景
 Raw DataSize = numOfTables * rowSizePerTable * rowsPerTable
 ```
-示例：1000万台智能电表，每台电表每15分钟采集一次数据，每次采集的数据128字节，那么一年的原始数据量是：10000000\*128\*24\*60/15*365 = 44.8512T。TDengine大概需要消耗44.851/5=8.97024T空间。
+示例：1000万台智能电表，每台电表每15分钟采集一次数据，每次采集的数据128字节，那么一年的原始数据量是：10000000\*128\*24\*60/15\*365 = 44.8512T。TDengine大概需要消耗44.851/5=8.97024T空间。
 用户可以通过参数keep，设置数据在磁盘中的最大保存时长。为进一步减少存储成本，TDengine还提供多级存储，最冷的数据可以存放在最廉价的存储介质上，应用的访问不用做任何调整，只是读取速度降低了。
@@ -181,7 +181,7 @@ taos -C  或  taos --dump-config
    客户端的输入的字符均采用操作系统当前默认的编码格式，在Linux系统上多为UTF-8，部分中文系统编码则可能是GB18030或GBK等。在docker环境中默认的编码是POSIX。在中文版Windows系统中，编码则是CP936。客户端需要确保正确设置自己所使用的字符集，即客户端运行的操作系统当前编码字符集，才能保证nchar中的数据正确转换为UCS4-LE编码格式。
-    在 Linux 中 locale 的命名规则为: <语言>_<地区>.<字符集编码> 如：zh_CN.UTF-8，zh代表中文，CN代表大陆地区，UTF-8表示字符集。字符集编码为客户端正确解析本地字符串提供编码转换的说明。Linux系统与 Mac OSX 系统可以通过设置locale来确定系统的字符编码，由于Windows使用的locale中不是POSIX标准的locale格式，因此在Windows下需要采用另一个配置参数charset来指定字符编码。在Linux 系统中也可以使用charset来指定字符编码。
+    在 Linux 中 locale 的命名规则为: <语言>\_<地区>.<字符集编码> 如：zh_CN.UTF-8，zh代表中文，CN代表大陆地区，UTF-8表示字符集。字符集编码为客户端正确解析本地字符串提供编码转换的说明。Linux系统与 Mac OSX 系统可以通过设置locale来确定系统的字符编码，由于Windows使用的locale中不是POSIX标准的locale格式，因此在Windows下需要采用另一个配置参数charset来指定字符编码。在Linux 系统中也可以使用charset来指定字符编码。
 - charset
@@ -452,39 +452,39 @@ TDengine的所有可执行文件默认存放在 _/usr/local/taos/bin_ 目录下
 | 关键字列表 |             |              |            |           |
 | ---------- | ----------- | ------------ | ---------- | --------- |
-| ABLOCKS    | CONNECTION  | GT           | MINUS      | SHOW      |
+| ABLOCKS    | CONNECTION  | GROUP        | MINUS      | SLASH     |
-| ABORT      | CONNECTIONS | ID           | MNODES     | SLASH     |
+| ABORT      | CONNECTIONS | GT           | MNODES     | SLIDING   |
-| ACCOUNT    | COPY        | IF           | MODULES    | SLIDING   |
+| ACCOUNT    | COPY        | ID           | MODULES    | SMALLINT  |
-| ACCOUNTS   | COUNT       | IGNORE       | NCHAR      | SMALLINT  |
+| ACCOUNTS   | COUNT       | IF           | NCHAR      | SPREAD    |
-| ADD        | CREATE      | IMMEDIATE    | NE         | SPREAD    |
+| ADD        | CREATE      | IGNORE       | NE         | STABLE    |
-| AFTER      | CTIME       | IMPORT       | NONE       | STAR      |
+| AFTER      | CTIME       | IMMEDIATE    | NONE       | STABLES   |
-| ALL        | DATABASE    | IN           | NOT        | STATEMENT |
+| ALL        | DATABASE    | IMPORT       | NOT        | STAR      |
-| ALTER      | DATABASES   | INITIALLY    | NOTNULL    | STDDEV    |
+| ALTER      | DATABASES   | IN           | NOTNULL    | STATEMENT |
-| AND        | DAYS        | INSERT       | NOW        | STREAM    |
+| AND        | DAYS        | INITIALLY    | NOW        | STDDEV    |
-| AS         | DEFERRED    | INSTEAD      | OF         | STREAMS   |
+| AS         | DEFERRED    | INSERT       | OF         | STREAM    |
-| ASC        | DELIMITERS  | INTEGER      | OFFSET     | STRING    |
+| ASC        | DELIMITERS  | INSTEAD      | OFFSET     | STREAMS   |
-| ATTACH     | DESC        | INTERVAL     | OR         | SUM       |
+| ATTACH     | DESC        | INTEGER      | OR         | STRING    |
-| AVG        | DESCRIBE    | INTO         | ORDER      | TABLE     |
+| AVG        | DESCRIBE    | INTERVAL     | ORDER      | SUM       |
-| BEFORE     | DETACH      | IP           | PASS       | TABLES    |
+| BEFORE     | DETACH      | INTO         | PASS       | TABLE     |
-| BEGIN      | DIFF        | IS           | PERCENTILE | TAG       |
+| BEGIN      | DIFF        | IP           | PERCENTILE | TABLES    |
-| BETWEEN    | DIVIDE      | ISNULL       | PLUS       | TAGS      |
+| BETWEEN    | DISTINCT    | IS           | PLUS       | TAG       |
-| BIGINT     | DNODE       | JOIN         | PRAGMA     | TBLOCKS   |
+| BIGINT     | DIVIDE      | ISNULL       | PRAGMA     | TAGS      |
-| BINARY     | DNODES      | KEEP         | PREV       | TBNAME    |
+| BINARY     | DNODE       | JOIN         | PREV       | TBLOCKS   |
-| BITAND     | DOT         | KEY          | PRIVILEGE  | TIMES     |
+| BITAND     | DNODES      | KEEP         | PRIVILEGE  | TBNAME    |
-| BITNOT     | DOUBLE      | KILL         | QUERIES    | TIMESTAMP |
+| BITNOT     | DOT         | KEY          | QUERIES    | TIMES     |
-| BITOR      | DROP        | LAST         | QUERY      | TINYINT   |
+| BITOR      | DOUBLE      | KILL         | QUERY      | TIMESTAMP |
-| BOOL       | EACH        | LE           | RAISE      | TOP       |
+| BOOL       | DROP        | LAST         | RAISE      | TINYINT   |
-| BOTTOM     | END         | LEASTSQUARES | REM        | TRIGGER   |
+| BOTTOM     | EACH        | LE           | REM        | TOP       |
-| BY         | EQ          | LIKE         | REPLACE    | UMINUS    |
+| BY         | END         | LEASTSQUARES | REPLACE    | TRIGGER   |
-| CACHE      | EXISTS      | LIMIT        | REPLICA    | UPLUS     |
+| CACHE      | EQ          | LIKE         | REPLICA    | UMINUS    |
-| CASCADE    | EXPLAIN     | LINEAR       | RESET      | USE       |
+| CASCADE    | EXISTS      | LIMIT        | RESET      | UPLUS     |
-| CHANGE     | FAIL        | LOCAL        | RESTRICT   | USER      |
+| CHANGE     | EXPLAIN     | LINEAR       | RESTRICT   | USE       |
-| CLOG       | FILL        | LP           | ROW        | USERS     |
+| CLOG       | FAIL        | LOCAL        | ROW        | USER      |
-| CLUSTER    | FIRST       | LSHIFT       | ROWS       | USING     |
+| CLUSTER    | FILL        | LP           | ROWS       | USERS     |
-| COLON      | FLOAT       | LT           | RP         | VALUES    |
+| COLON      | FIRST       | LSHIFT       | RP         | USING     |
-| COLUMN     | FOR         | MATCH        | RSHIFT     | VARIABLE  |
+| COLUMN     | FLOAT       | LT           | RSHIFT     | VALUES    |
-| COMMA      | FROM        | MAX          | SCORES     | VGROUPS   |
+| COMMA      | FOR         | MATCH        | SCORES     | VARIABLE  |
-| COMP       | GE          | METRIC       | SELECT     | VIEW      |
+| COMP       | FROM        | MAX          | SELECT     | VGROUPS   |
-| CONCAT     | GLOB        | METRICS      | SEMI       | WAVG      |
+| CONCAT     | GE          | METRIC       | SEMI       | VIEW      |
-| CONFIGS    | GRANTS      | MIN          | SET        | WHERE     |
+| CONFIGS    | GLOB        | METRICS      | SET        | WAVG      |
-| CONFLICT   | GROUP       |              |            |           |
+| CONFLICT   | GRANTS      | MIN          | SHOW       | WHERE     |
\ No newline at end of file
--- a/documentation20/webdocs/markdowndocs/architecture-ch.md
+++ b/documentation20/webdocs/markdowndocs/architecture-ch.md
@@ -344,7 +344,6 @@ dataDir /mnt/disk6/taos 2
 挂载的盘也可以是非本地的网络盘，只要系统能访问即可。
 注：多级存储功能仅企业版支持
-**提示：该功能暂未提供**
 ## 数据查询
 TDengine提供了多种多样针对表和超级表的查询处理功能，除了常规的聚合查询之外，还提供针对时序数据的窗口查询、统计聚合等功能。TDengine的查询处理需要客户端、vnode, mnode节点协同完成。

--- a/documentation20/webdocs/markdowndocs/connector-java-ch.md
+++ b/documentation20/webdocs/markdowndocs/connector-java-ch.md
@@ -2,7 +2,7 @@
 TDengine 提供了遵循 JDBC 标准（3.0）API 规范的 `taos-jdbcdriver` 实现，可在 maven 的中央仓库 [Sonatype Repository][1] 搜索下载。
-`taos-jdbcdriver` 的实现包括 2 种形式： JDBC-JNI 和 JDBC-RESTful（taos-jdbcdriver-2.0.17 开始支持 JDBC-RESTful）。 JDBC-JNI 通过调用客户端 libtaos.so（或 taos.dll ）的本地方法实现， JDBC-RESTful 则在内部封装了 RESTful 接口实现。
+`taos-jdbcdriver` 的实现包括 2 种形式： JDBC-JNI 和 JDBC-RESTful（taos-jdbcdriver-2.0.18 开始支持 JDBC-RESTful）。 JDBC-JNI 通过调用客户端 libtaos.so（或 taos.dll ）的本地方法实现， JDBC-RESTful 则在内部封装了 RESTful 接口实现。
 ![tdengine-connector](../assets/tdengine-jdbc-connector.png)
@@ -67,7 +67,7 @@ maven 项目中使用如下 pom.xml 配置即可：
 <dependency>
  <groupId>com.taosdata.jdbc</groupId>
  <artifactId>taos-jdbcdriver</artifactId>
-  <version>2.0.17</version>
+  <version>2.0.18</version>
 </dependency>
 ```
@@ -334,16 +334,17 @@ conn.close();
 ```java
 public static void main(String[] args) throws SQLException {
    HikariConfig config = new HikariConfig();
+    // jdbc properties
    config.setJdbcUrl("jdbc:TAOS://127.0.0.1:6030/log");
    config.setUsername("root");
    config.setPassword("taosdata");
+    // connection pool configurations
-    config.setMinimumIdle(3);           //minimum number of idle connection
+    config.setMinimumIdle(10);           //minimum number of idle connection
    config.setMaximumPoolSize(10);      //maximum number of connection in the pool
-    config.setConnectionTimeout(10000); //maximum wait milliseconds for get connection from pool
+    config.setConnectionTimeout(30000); //maximum wait milliseconds for get connection from pool
-    config.setIdleTimeout(60000);       // max idle time for recycle idle connection
+    config.setMaxLifetime(0);       // maximum life time for each connection
-    config.setConnectionTestQuery("describe log.dn"); //validation query
+    config.setIdleTimeout(0);       // max idle time for recycle idle connection
-    config.setValidationTimeout(3000);   //validation query timeout
+    config.setConnectionTestQuery("select server_status()"); //validation query
    HikariDataSource ds = new HikariDataSource(config); //create datasource
@@ -375,32 +376,22 @@ conn.close();
 * 使用示例如下：
 ```java
 public static void main(String[] args) throws Exception {
-    Properties properties = new Properties();
-    properties.put("driverClassName","com.taosdata.jdbc.TSDBDriver");
-    properties.put("url","jdbc:TAOS://127.0.0.1:6030/log");
-    properties.put("username","root");
-    properties.put("password","taosdata");
-    properties.put("maxActive","10"); //maximum number of connection in the pool
-    properties.put("initialSize","3");//initial number of connection
-    properties.put("maxWait","10000");//maximum wait milliseconds for get connection from pool
-    properties.put("minIdle","3");//minimum number of connection in the pool
-    properties.put("timeBetweenEvictionRunsMillis","3000");// the interval milliseconds to test connection
-    properties.put("minEvictableIdleTimeMillis","60000");//the minimum milliseconds to keep idle
-    properties.put("maxEvictableIdleTimeMillis","90000");//the maximum milliseconds to keep idle
-    properties.put("validationQuery","describe log.dn"); //validation query
+    DruidDataSource dataSource = new DruidDataSource();
-    properties.put("testWhileIdle","true"); // test connection while idle
+    // jdbc properties
-    properties.put("testOnBorrow","false"); // don't need while testWhileIdle is true
+    dataSource.setDriverClassName("com.taosdata.jdbc.TSDBDriver");
-    properties.put("testOnReturn","false"); // don't need while testWhileIdle is true
+    dataSource.setUrl(url);
+    dataSource.setUsername("root");
-    //create druid datasource
+    dataSource.setPassword("taosdata");
-    DataSource ds = DruidDataSourceFactory.createDataSource(properties);
+    // pool configurations
-    Connection  connection = ds.getConnection(); // get connection
+    dataSource.setInitialSize(10);
+    dataSource.setMinIdle(10);
+    dataSource.setMaxActive(10);
+    dataSource.setMaxWait(30000);
+    dataSource.setValidationQuery("select server_status()");
+    Connection  connection = dataSource.getConnection(); // get connection
    Statement statement = connection.createStatement(); // get statement
    //query or insert 
    // ...
@@ -427,7 +418,7 @@ Query OK, 1 row(s) in set (0.000141s)
 ## 与框架使用
 * Spring JdbcTemplate 中使用 taos-jdbcdriver，可参考 [SpringJdbcTemplate][11]
-* Springboot + Mybatis 中使用，可参考 [springbootdemo
+* Springboot + Mybatis 中使用，可参考 [springbootdemo][12]

--- a/packaging/tools/install_client.sh
+++ b/packaging/tools/install_client.sh
@@ -21,7 +21,7 @@ else
    cd ${script_dir}
    script_dir="$(pwd)"
    data_dir="/var/lib/taos"
-    log_dir="~/TDengineLog"
+    log_dir=~/TDengine/log
 fi
 log_link_dir="/usr/local/taos/log"

--- a/packaging/tools/make_install.sh
+++ b/packaging/tools/make_install.sh
@@ -24,7 +24,7 @@ data_dir="/var/lib/taos"
 if [ "$osType" != "Darwin" ]; then
    log_dir="/var/log/taos"
 else
-    log_dir="~/TDengineLog"
+    log_dir=~/TDengine/log
 fi
 data_link_dir="/usr/local/taos/data"
@@ -178,7 +178,9 @@ function install_bin() {
 function install_lib() {
    # Remove links
    ${csudo} rm -f ${lib_link_dir}/libtaos.*     || :
+    if [ "$osType" != "Darwin" ]; then
      ${csudo} rm -f ${lib64_link_dir}/libtaos.*   || :
+    fi
    if [ "$osType" != "Darwin" ]; then
        ${csudo} cp ${binary_dir}/build/lib/libtaos.so.${verNumber} ${install_main_dir}/driver && ${csudo} chmod 777 ${install_main_dir}/driver/*
@@ -190,12 +192,14 @@ function install_lib() {
          ${csudo} ln -sf ${lib64_link_dir}/libtaos.so.1 ${lib64_link_dir}/libtaos.so
        fi
    else
-        ${csudo} cp ${binary_dir}/build/lib/libtaos.* ${install_main_dir}/driver && ${csudo} chmod 777 ${install_main_dir}/driver/*
+        ${csudo} cp -Rf ${binary_dir}/build/lib/libtaos.* ${install_main_dir}/driver && ${csudo} chmod 777 ${install_main_dir}/driver/*
-        ${csudo} ln -sf ${install_main_dir}/driver/libtaos.* ${lib_link_dir}/libtaos.1.dylib
+        ${csudo} ln -sf ${install_main_dir}/driver/libtaos.1.dylib ${lib_link_dir}/libtaos.1.dylib
        ${csudo} ln -sf ${lib_link_dir}/libtaos.1.dylib ${lib_link_dir}/libtaos.dylib
    fi
+    if [ "$osType" != "Darwin" ]; then
        ${csudo} ldconfig
+    fi
 }
 function install_header() {

--- a/src/balance/CMakeLists.txt
+++ b/src/balance/CMakeLists.txt
@@ -8,6 +8,4 @@ INCLUDE_DIRECTORIES(${TD_ENTERPRISE_DIR}/src/inc)
 INCLUDE_DIRECTORIES(inc)
 AUX_SOURCE_DIRECTORY(src SRC)
-IF (TD_LINUX)
+ADD_LIBRARY(balance ${SRC})
-  ADD_LIBRARY(balance ${SRC})
-ENDIF ()
--- a/src/balance/inc/bnThread.h
+++ b/src/balance/inc/bnThread.h
@@ -24,7 +24,7 @@ extern "C" {
 int32_t bnInitThread();
 void    bnCleanupThread();
 void    bnNotify();
-void    bnStartTimer(int64_t mseconds);
+void    bnStartTimer(int32_t mseconds);
 #ifdef __cplusplus
 }

--- a/src/balance/src/bnMain.c
+++ b/src/balance/src/bnMain.c
@@ -30,7 +30,7 @@
 #include "mnodeVgroup.h"
 extern int64_t tsDnodeRid;
-extern int64_t tsSdbRid;
+extern int32_t tsSdbRid;
 static SBnMgmt tsBnMgmt;
 static void  bnMonitorDnodeModule();

--- a/src/balance/src/bnScore.c
+++ b/src/balance/src/bnScore.c
@@ -271,23 +271,23 @@ static int32_t bnRetrieveScores(SShowObj *pShow, char *data, int32_t rows, void
    cols++;
    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(float *)pWrite = systemScore;
+    *(float *)pWrite = (float)systemScore;
    cols++;
    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(float *)pWrite = pDnode->customScore;
+    *(float *)pWrite = (float)pDnode->customScore;
    cols++;
    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(float *)pWrite = (int32_t)moduleScore;
+    *(float *)pWrite = (float)moduleScore;
    cols++;
    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(float *)pWrite = (int32_t)vnodeScore;
+    *(float *)pWrite = (float)vnodeScore;
    cols++;
    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(float *)pWrite = (int32_t)(vnodeScore + moduleScore + pDnode->customScore + systemScore);
+    *(float *)pWrite = (float)(vnodeScore + moduleScore + pDnode->customScore + systemScore);
    cols++;
    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;

--- a/src/balance/src/bnThread.c
+++ b/src/balance/src/bnThread.c
@@ -119,13 +119,13 @@ static void bnProcessTimer(void *handle, void *tmrId) {
  }
 }
-void bnStartTimer(int64_t mseconds) {
+void bnStartTimer(int32_t mseconds) {
  if (tsBnThread.stop) return;
  bool updateSoon = (mseconds != -1);
  if (updateSoon) {
-    mTrace("balance function will be called after %" PRId64 " ms", mseconds);
+    mTrace("balance function will be called after %d ms", mseconds);
-    taosTmrReset(bnProcessTimer, mseconds, (void *)mseconds, tsMnodeTmr, &tsBnThread.timer);
+    taosTmrReset(bnProcessTimer, mseconds, (void *)(int64_t)mseconds, tsMnodeTmr, &tsBnThread.timer);
  } else {
    taosTmrReset(bnProcessTimer, tsStatusInterval * 1000, NULL, tsMnodeTmr, &tsBnThread.timer);
  }

--- a/src/client/CMakeLists.txt
+++ b/src/client/CMakeLists.txt
@@ -28,6 +28,28 @@ IF (TD_LINUX)
  ADD_SUBDIRECTORY(tests)
+ELSEIF (TD_DARWIN)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/jni/linux)
+  # set the static lib name
+  ADD_LIBRARY(taos_static STATIC ${SRC})
+  TARGET_LINK_LIBRARIES(taos_static common query trpc tutil pthread m)
+  SET_TARGET_PROPERTIES(taos_static PROPERTIES OUTPUT_NAME "taos_static")
+  SET_TARGET_PROPERTIES(taos_static PROPERTIES CLEAN_DIRECT_OUTPUT 1)
+  # generate dynamic library (*.dylib)
+  ADD_LIBRARY(taos SHARED ${SRC})
+  TARGET_LINK_LIBRARIES(taos common query trpc tutil pthread m)
+  SET_TARGET_PROPERTIES(taos PROPERTIES CLEAN_DIRECT_OUTPUT 1)
+  #set version of .dylib
+  #VERSION    dylib version
+  #SOVERSION  dylib version
+  #MESSAGE(STATUS "build version ${TD_VER_NUMBER}")
+  SET_TARGET_PROPERTIES(taos PROPERTIES VERSION ${TD_VER_NUMBER} SOVERSION 1)
+  ADD_SUBDIRECTORY(tests)
 ELSEIF (TD_WINDOWS)
  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/jni/windows)
  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/jni/windows/win32)
@@ -49,12 +71,12 @@ ELSEIF (TD_DARWIN)
  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/jni/linux)
  ADD_LIBRARY(taos_static STATIC ${SRC})
-  TARGET_LINK_LIBRARIES(taos_static trpc tutil pthread m)
+  TARGET_LINK_LIBRARIES(taos_static query trpc tutil pthread m)
  SET_TARGET_PROPERTIES(taos_static PROPERTIES OUTPUT_NAME "taos_static")
  # generate dynamic library (*.dylib)
  ADD_LIBRARY(taos SHARED ${SRC})
-  TARGET_LINK_LIBRARIES(taos trpc tutil pthread m)
+  TARGET_LINK_LIBRARIES(taos query trpc tutil pthread m)
  SET_TARGET_PROPERTIES(taos PROPERTIES CLEAN_DIRECT_OUTPUT 1)

--- a/src/client/src/tscLocal.c
+++ b/src/client/src/tscLocal.c
@@ -749,7 +749,10 @@ static int32_t tscProcessCurrentUser(SSqlObj *pSql) {
 static int32_t tscProcessCurrentDB(SSqlObj *pSql) {
  char db[TSDB_DB_NAME_LEN] = {0};
+  pthread_mutex_lock(&pSql->pTscObj->mutex);
  extractDBName(pSql->pTscObj->db, db);
+  pthread_mutex_unlock(&pSql->pTscObj->mutex);
  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, pSql->cmd.clauseIndex);

--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -905,6 +905,13 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
      return tscInvalidSQLErrMsg(pCmd->payload, "keyword TAGS expected", sToken.z);
    }
+    index = 0;
+    sToken = tStrGetToken(sql, &index, false, 0, NULL);
+    sql += index;
+    if (sToken.type != TK_LP) {
+      return tscInvalidSQLErrMsg(pCmd->payload, NULL, sToken.z);
+    }
    SKVRowBuilder kvRowBuilder = {0};
    if (tdInitKVRowBuilder(&kvRowBuilder) < 0) {
      return TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -1548,12 +1555,13 @@ void tscImportDataFromFile(SSqlObj *pSql) {
  SSqlObj *pNew = createSubqueryObj(pSql, 0, parseFileSendDataBlock, pSupporter, TSDB_SQL_INSERT, NULL);
  pCmd->count = 1;
-  FILE *fp = fopen(pCmd->payload, "r");
+  FILE *fp = fopen(pCmd->payload, "rb");
  if (fp == NULL) {
    pSql->res.code = TAOS_SYSTEM_ERROR(errno);
    tscError("%p failed to open file %s to load data from file, code:%s", pSql, pCmd->payload, tstrerror(pSql->res.code));
    tfree(pSupporter);
+    taos_free_result(pNew);
    tscAsyncResultOnError(pSql);
    return;
  }

--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -13,10 +13,12 @@
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
+#ifndef __APPLE__
 #define _BSD_SOURCE
 #define _XOPEN_SOURCE 500
 #define _DEFAULT_SOURCE
 #define _GNU_SOURCE
+#endif // __APPLE__
 #include "os.h"
 #include "ttype.h"
@@ -60,7 +62,7 @@ static int32_t setShowInfo(SSqlObj* pSql, SSqlInfo* pInfo);
 static char*   getAccountId(SSqlObj* pSql);
 static bool has(SArray* pFieldList, int32_t startIdx, const char* name);
-static char* getCurrentDBName(SSqlObj* pSql);
+static char* cloneCurrentDBName(SSqlObj* pSql);
 static bool hasSpecifyDB(SStrToken* pTableName);
 static bool validateTableColumnInfo(SArray* pFieldList, SSqlCmd* pCmd);
 static bool validateTagParams(SArray* pTagsList, SArray* pFieldList, SSqlCmd* pCmd);
@@ -921,16 +923,19 @@ int32_t tscSetTableFullName(STableMetaInfo* pTableMetaInfo, SStrToken* pTableNam
      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
    }
  } else {  // get current DB name first, and then set it into path
-    char* t = getCurrentDBName(pSql);
+    char* t = cloneCurrentDBName(pSql);
    if (strlen(t) == 0) {
      return TSDB_CODE_TSC_DB_NOT_SELECTED;
    }
    code = tNameFromString(&pTableMetaInfo->name, t, T_NAME_ACCT | T_NAME_DB);
    if (code != 0) {
+      free(t);
      return TSDB_CODE_TSC_DB_NOT_SELECTED;
    }
+    free(t);
    if (pTableName->n >= TSDB_TABLE_NAME_LEN) {
      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
    }
@@ -1244,8 +1249,12 @@ static bool has(SArray* pFieldList, int32_t startIdx, const char* name) {
 static char* getAccountId(SSqlObj* pSql) { return pSql->pTscObj->acctId; }
-static char* getCurrentDBName(SSqlObj* pSql) {
+static char* cloneCurrentDBName(SSqlObj* pSql) {
-  return pSql->pTscObj->db;
+  pthread_mutex_lock(&pSql->pTscObj->mutex);
+  char *p = strdup(pSql->pTscObj->db);  
+  pthread_mutex_unlock(&pSql->pTscObj->mutex);
+  return p;
 }
 /* length limitation, strstr cannot be applied */
@@ -4300,6 +4309,77 @@ static void doAddJoinTagsColumnsIntoTagList(SSqlCmd* pCmd, SQueryInfo* pQueryInf
  }
 }
+static int32_t validateTagCondExpr(SSqlCmd* pCmd, tExprNode *p) {
+  const char *msg1 = "invalid tag operator";
+  const char* msg2 = "not supported filter condition";
+  do {
+    if (p->nodeType != TSQL_NODE_EXPR) {
+      break;
+    }
+    if (!p->_node.pLeft || !p->_node.pRight) {
+      break;
+    }
+    if (IS_ARITHMETIC_OPTR(p->_node.optr)) {
+      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1); 
+    }
+    if (!IS_RELATION_OPTR(p->_node.optr)) {
+      break;
+    }
+    tVariant * vVariant = NULL;
+    int32_t schemaType = -1;
+    if (p->_node.pLeft->nodeType == TSQL_NODE_VALUE && p->_node.pRight->nodeType == TSQL_NODE_COL) {
+      if (!p->_node.pRight->pSchema) {
+        break;
+      }
+      vVariant = p->_node.pLeft->pVal;
+      schemaType = p->_node.pRight->pSchema->type;
+    } else if (p->_node.pLeft->nodeType == TSQL_NODE_COL && p->_node.pRight->nodeType == TSQL_NODE_VALUE) {
+      if (!p->_node.pLeft->pSchema) {
+        break;
+      }
+      vVariant = p->_node.pRight->pVal;
+      schemaType = p->_node.pLeft->pSchema->type;
+    } else {
+      break;
+    }
+    if (schemaType >= TSDB_DATA_TYPE_TINYINT && schemaType <= TSDB_DATA_TYPE_BIGINT) {
+      schemaType = TSDB_DATA_TYPE_BIGINT;
+    } else if (schemaType == TSDB_DATA_TYPE_FLOAT || schemaType == TSDB_DATA_TYPE_DOUBLE) {
+      schemaType = TSDB_DATA_TYPE_DOUBLE;
+    }
+    int32_t retVal = TSDB_CODE_SUCCESS;
+    if (schemaType == TSDB_DATA_TYPE_BINARY) {
+      char *tmp = calloc(1, vVariant->nLen + TSDB_NCHAR_SIZE);
+      retVal = tVariantDump(vVariant, tmp, schemaType, false);
+      free(tmp);
+    } else if (schemaType == TSDB_DATA_TYPE_NCHAR) {
+      // pRight->val.nLen + 1 is larger than the actual nchar string length
+      char *tmp = calloc(1, (vVariant->nLen + 1) * TSDB_NCHAR_SIZE);
+      retVal = tVariantDump(vVariant, tmp, schemaType, false);
+      free(tmp);
+    } else {
+      double tmp;
+      retVal = tVariantDump(vVariant, (char*)&tmp, schemaType, false);
+    }
+    if (retVal != TSDB_CODE_SUCCESS) {
+      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+    }
+  }while (0);
+  return TSDB_CODE_SUCCESS;
+}
 static int32_t getTagQueryCondExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SCondExpr* pCondExpr, tSQLExpr** pExpr) {
  int32_t ret = TSDB_CODE_SUCCESS;
@@ -4342,6 +4422,10 @@ static int32_t getTagQueryCondExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SCondE
    tsSetSTableQueryCond(&pQueryInfo->tagCond, uid, &bw);
    doCompactQueryExpr(pExpr);
+    if (ret == TSDB_CODE_SUCCESS) {
+      ret = validateTagCondExpr(pCmd, p);
+    }
    tSqlExprDestroy(p1);
    tExprTreeDestroy(p, NULL);
@@ -4349,6 +4433,10 @@ static int32_t getTagQueryCondExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SCondE
    if (pQueryInfo->tagCond.pCond != NULL && taosArrayGetSize(pQueryInfo->tagCond.pCond) > 0 && !UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), "filter on tag not supported for normal table");
    }
+    if (ret) {
+      break;
+    }
  }
  pCondExpr->pTagCond = NULL;

--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -1251,7 +1251,9 @@ int32_t tscBuildShowMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
  if (tNameIsEmpty(&pTableMetaInfo->name)) {    
+    pthread_mutex_lock(&pObj->mutex);
    tstrncpy(pShowMsg->db, pObj->db, sizeof(pShowMsg->db));  
+    pthread_mutex_unlock(&pObj->mutex);
  } else {
    tNameGetFullDbName(&pTableMetaInfo->name, pShowMsg->db);
  }
@@ -1611,9 +1613,14 @@ int tscBuildConnectMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
  // TODO refactor full_name
  char *db;  // ugly code to move the space
+  pthread_mutex_lock(&pObj->mutex);
  db = strstr(pObj->db, TS_PATH_DELIMITER);
  db = (db == NULL) ? pObj->db : db + 1;
  tstrncpy(pConnect->db, db, sizeof(pConnect->db));
+  pthread_mutex_unlock(&pObj->mutex);
  tstrncpy(pConnect->clientVersion, version, sizeof(pConnect->clientVersion));
  tstrncpy(pConnect->msgVersion, "", sizeof(pConnect->msgVersion));
@@ -2131,10 +2138,13 @@ int tscProcessConnectRsp(SSqlObj *pSql) {
  SConnectRsp *pConnect = (SConnectRsp *)pRes->pRsp;
  tstrncpy(pObj->acctId, pConnect->acctId, sizeof(pObj->acctId));  // copy acctId from response
+  pthread_mutex_lock(&pObj->mutex);
  int32_t len = sprintf(temp, "%s%s%s", pObj->acctId, TS_PATH_DELIMITER, pObj->db);
  assert(len <= sizeof(pObj->db));
  tstrncpy(pObj->db, temp, sizeof(pObj->db));
+  pthread_mutex_unlock(&pObj->mutex);
  if (pConnect->epSet.numOfEps > 0) {
    tscEpSetHtons(&pConnect->epSet);
@@ -2161,11 +2171,18 @@ int tscProcessConnectRsp(SSqlObj *pSql) {
 int tscProcessUseDbRsp(SSqlObj *pSql) {
  STscObj *       pObj = pSql->pTscObj;
  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0, 0);
-  return tNameExtractFullName(&pTableMetaInfo->name, pObj->db);
+  pthread_mutex_lock(&pObj->mutex);
+  int ret = tNameExtractFullName(&pTableMetaInfo->name, pObj->db);
+  pthread_mutex_unlock(&pObj->mutex);
+  return ret;
 }
 int tscProcessDropDbRsp(SSqlObj *pSql) {
-  pSql->pTscObj->db[0] = 0;
+  //TODO LOCK DB WHEN MODIFY IT
+  //pSql->pTscObj->db[0] = 0;
  taosHashEmpty(tscTableMetaInfo);
  return 0;
 }

--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -295,6 +295,10 @@ void taos_close(TAOS *taos) {
      tscDebug("%p HB is freed", pHb);
      taosReleaseRef(tscObjRef, pHb->self);
+#ifdef __APPLE__
+      // to satisfy later tsem_destroy in taos_free_result
+      tsem_init(&pHb->rspSem, 0, 0);
+#endif // __APPLE__
      taos_free_result(pHb);
    }
  }

--- a/src/client/src/tscSub.c
+++ b/src/client/src/tscSub.c
@@ -313,7 +313,7 @@ static int tscLoadSubscriptionProgress(SSub* pSub) {
  char buf[TSDB_MAX_SQL_LEN];
  sprintf(buf, "%s/subscribe/%s", tsDataDir, pSub->topic);
-  FILE* fp = fopen(buf, "r");
+  FILE* fp = fopen(buf, "rb");
  if (fp == NULL) {
    tscDebug("subscription progress file does not exist: %s", pSub->topic);
    return 1;
@@ -368,7 +368,7 @@ void tscSaveSubscriptionProgress(void* sub) {
  }
  sprintf(path, "%s/subscribe/%s", tsDataDir, pSub->topic);
-  FILE* fp = fopen(path, "w+");
+  FILE* fp = fopen(path, "wb+");
  if (fp == NULL) {
    tscError("failed to create progress file for subscription: %s", pSub->topic);
    return;

--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -1018,7 +1018,7 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
  if (numOfRows > 0) {  // write the compressed timestamp to disk file
    if(pSupporter->f == NULL) {
-      pSupporter->f = fopen(pSupporter->path, "w");
+      pSupporter->f = fopen(pSupporter->path, "wb");
      if (pSupporter->f == NULL) {
        tscError("%p failed to create tmp file:%s, reason:%s", pSql, pSupporter->path, strerror(errno));
@@ -1066,7 +1066,7 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
    // continue to retrieve ts-comp data from vnode
    if (!pRes->completed) {
      taosGetTmpfilePath("ts-join", pSupporter->path);
-      pSupporter->f = fopen(pSupporter->path, "w");
+      pSupporter->f = fopen(pSupporter->path, "wb");
      pRes->row = pRes->numOfRows;
      taos_fetch_rows_a(tres, tsCompRetrieveCallback, param);
@@ -1092,7 +1092,7 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
    taosGetTmpfilePath("ts-join", pSupporter->path);
    // TODO check for failure
-    pSupporter->f = fopen(pSupporter->path, "w");
+    pSupporter->f = fopen(pSupporter->path, "wb");
    pRes->row = pRes->numOfRows;
    // set the callback function
@@ -1991,7 +1991,22 @@ static void tscAbortFurtherRetryRetrieval(SRetrieveSupport *trsupport, TAOS_RES
 * current query failed, and the retry count is less than the available
 * count, retry query clear previous retrieved data, then launch a new sub query
 */
-static int32_t tscReissueSubquery(SRetrieveSupport *trsupport, SSqlObj *pSql, int32_t code) {
+static int32_t tscReissueSubquery(SRetrieveSupport *oriTrs, SSqlObj *pSql, int32_t code) {
+  SRetrieveSupport *trsupport = malloc(sizeof(SRetrieveSupport));
+  if (trsupport == NULL) {
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+  memcpy(trsupport, oriTrs, sizeof(*trsupport));
+  const uint32_t nBufferSize = (1u << 16u);  // 64KB
+  trsupport->localBuffer = (tFilePage *)calloc(1, nBufferSize + sizeof(tFilePage));
+  if (trsupport->localBuffer == NULL) {
+    tscError("%p failed to malloc buffer for local buffer, reason:%s", pSql, strerror(errno));
+    tfree(trsupport);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
  SSqlObj *pParentSql = trsupport->pParentSql;
  int32_t  subqueryIndex = trsupport->subqueryIndex;

--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -1942,6 +1942,10 @@ SSqlObj* createSimpleSubObj(SSqlObj* pSql, __async_cb_func_t fp, void* param, in
  }
  if (tscAddSubqueryInfo(pCmd) != TSDB_CODE_SUCCESS) {
+#ifdef __APPLE__
+    // to satisfy later tsem_destroy in taos_free_result
+    tsem_init(&pNew->rspSem, 0, 0);
+#endif // __APPLE__
    tscFreeSqlObj(pNew);
    return NULL;
  }
@@ -2123,6 +2127,10 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
                                     pTableMetaInfo->tagColList, pTableMetaInfo->pVgroupTables);
  } else {  // transfer the ownership of pTableMeta to the newly create sql object.
    STableMetaInfo* pPrevInfo = tscGetTableMetaInfoFromCmd(&pPrevSql->cmd, pPrevSql->cmd.clauseIndex, 0);
+    if (pPrevInfo->pTableMeta && pPrevInfo->pTableMeta->tableType < 0) {
+      terrno = TSDB_CODE_TSC_APP_ERROR;
+      goto _error;
+    }
    STableMeta*  pPrevTableMeta = tscTableMetaDup(pPrevInfo->pTableMeta);
    SVgroupsInfo* pVgroupsInfo = pPrevInfo->vgroupList;
@@ -2508,7 +2516,11 @@ bool tscSetSqlOwner(SSqlObj* pSql) {
  SSqlRes* pRes = &pSql->res;
  // set the sql object owner
+#ifdef __APPLE__
+  pthread_t threadId = (pthread_t)taosGetSelfPthreadId();
+#else // __APPLE__
  uint64_t threadId = taosGetSelfPthreadId();
+#endif // __APPLE__
  if (atomic_val_compare_exchange_64(&pSql->owner, 0, threadId) != 0) {
    pRes->code = TSDB_CODE_QRY_IN_EXEC;
    return false;

--- a/src/common/inc/tdataformat.h
+++ b/src/common/inc/tdataformat.h
@@ -29,7 +29,7 @@ extern "C" {
 #define STR_TO_VARSTR(x, str)                     \
  do {                                            \
-    VarDataLenT __len = strlen(str);      \
+    VarDataLenT __len = (VarDataLenT)strlen(str); \
    *(VarDataLenT *)(x) = __len;                  \
    memcpy(varDataVal(x), (str), __len);          \
  } while (0);
@@ -42,7 +42,7 @@ extern "C" {
 #define STR_WITH_SIZE_TO_VARSTR(x, str, _size)  \
  do {                                          \
-    *(VarDataLenT *)(x) = (_size);             \
+    *(VarDataLenT *)(x) = (VarDataLenT)(_size); \
    memcpy(varDataVal(x), (str), (_size));      \
  } while (0);

--- a/src/common/inc/tglobal.h
+++ b/src/common/inc/tglobal.h
@@ -88,8 +88,8 @@ extern int32_t tsMinRowsInFileBlock;
 extern int32_t tsMaxRowsInFileBlock;
 extern int16_t tsCommitTime;  // seconds
 extern int32_t tsTimePrecision;
-extern int16_t tsCompression;
+extern int8_t  tsCompression;
-extern int16_t tsWAL;
+extern int8_t  tsWAL;
 extern int32_t tsFsyncPeriod;
 extern int32_t tsReplications;
 extern int32_t tsQuorum;

--- a/src/common/src/tglobal.c
+++ b/src/common/src/tglobal.c
@@ -121,8 +121,8 @@ int32_t tsMinRowsInFileBlock = TSDB_DEFAULT_MIN_ROW_FBLOCK;
 int32_t tsMaxRowsInFileBlock = TSDB_DEFAULT_MAX_ROW_FBLOCK;
 int16_t tsCommitTime    = TSDB_DEFAULT_COMMIT_TIME;  // seconds
 int32_t tsTimePrecision = TSDB_DEFAULT_PRECISION;
-int16_t tsCompression   = TSDB_DEFAULT_COMP_LEVEL;
+int8_t  tsCompression   = TSDB_DEFAULT_COMP_LEVEL;
-int16_t tsWAL           = TSDB_DEFAULT_WAL_LEVEL;
+int8_t  tsWAL           = TSDB_DEFAULT_WAL_LEVEL;
 int32_t tsFsyncPeriod   = TSDB_DEFAULT_FSYNC_PERIOD;
 int32_t tsReplications  = TSDB_DEFAULT_DB_REPLICA_OPTION;
 int32_t tsQuorum        = TSDB_DEFAULT_DB_QUORUM_OPTION;
@@ -137,7 +137,7 @@ int32_t tsTableIncStepPerVnode = TSDB_TABLES_STEP;
 int8_t  tsEnableBalance = 1;
 int8_t  tsAlternativeRole = 0;
 int32_t tsBalanceInterval = 300;           // seconds
-int32_t tsOfflineThreshold = 86400 * 100;  // seconds 10days
+int32_t tsOfflineThreshold = 86400 * 100;  // seconds 100 days
 int32_t tsMnodeEqualVnodeNum = 4;
 int8_t  tsEnableFlowCtrl = 1;
 int8_t  tsEnableSlaveQuery = 1;
@@ -550,7 +550,7 @@ static void doInitGlobalConfig(void) {
  cfg.valType = TAOS_CFG_VTYPE_INT32;
  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW;
  cfg.minValue = 3;
-  cfg.maxValue = 7200000;
+  cfg.maxValue = 86400 * 365;
  cfg.ptrLength = 0;
  cfg.unitType = TAOS_CFG_UTYPE_SECOND;
  taosInitConfigOption(cfg);
@@ -758,7 +758,7 @@ static void doInitGlobalConfig(void) {
  cfg.option = "comp";
  cfg.ptr = &tsCompression;
-  cfg.valType = TAOS_CFG_VTYPE_INT16;
+  cfg.valType = TAOS_CFG_VTYPE_INT8;
  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW;
  cfg.minValue = TSDB_MIN_COMP_LEVEL;
  cfg.maxValue = TSDB_MAX_COMP_LEVEL;
@@ -768,7 +768,7 @@ static void doInitGlobalConfig(void) {
  cfg.option = "walLevel";
  cfg.ptr = &tsWAL;
-  cfg.valType = TAOS_CFG_VTYPE_INT16;
+  cfg.valType = TAOS_CFG_VTYPE_INT8;
  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW;
  cfg.minValue = TSDB_MIN_WAL_LEVEL;
  cfg.maxValue = TSDB_MAX_WAL_LEVEL;

--- a/src/common/src/tvariant.c
+++ b/src/common/src/tvariant.c
@@ -430,7 +430,7 @@ static FORCE_INLINE int32_t convertToInteger(tVariant *pVariant, int64_t *result
  }
  errno = 0;
-  if (IS_SIGNED_NUMERIC_TYPE(pVariant->nType)) {
+  if (IS_SIGNED_NUMERIC_TYPE(pVariant->nType) || (pVariant->nType == TSDB_DATA_TYPE_BOOL)) {
    *result = pVariant->i64;
  } else if (IS_UNSIGNED_NUMERIC_TYPE(pVariant->nType)) {
    *result = pVariant->u64;
@@ -775,7 +775,7 @@ int32_t tVariantDump(tVariant *pVariant, char *payload, int16_t type, bool inclu
              return -1;
            }
          } else {
-            wcsncpy((wchar_t *)p, pVariant->wpz, pVariant->nLen);
+            memcpy(p, pVariant->wpz, pVariant->nLen);
            newlen = pVariant->nLen;
          }

--- a/src/connector/jdbc/CMakeLists.txt
+++ b/src/connector/jdbc/CMakeLists.txt
@@ -8,7 +8,7 @@ IF (TD_MVN_INSTALLED)
  ADD_CUSTOM_COMMAND(OUTPUT ${JDBC_CMD_NAME}
    POST_BUILD
    COMMAND mvn -Dmaven.test.skip=true install -f ${CMAKE_CURRENT_SOURCE_DIR}/pom.xml
-    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/target/taos-jdbcdriver-2.0.17-dist.jar ${LIBRARY_OUTPUT_PATH}
+    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/target/taos-jdbcdriver-2.0.18-dist.jar ${LIBRARY_OUTPUT_PATH}
    COMMAND mvn -Dmaven.test.skip=true clean -f ${CMAKE_CURRENT_SOURCE_DIR}/pom.xml
    COMMENT "build jdbc driver")
  ADD_CUSTOM_TARGET(${JDBC_TARGET_NAME} ALL WORKING_DIRECTORY ${EXECUTABLE_OUTPUT_PATH} DEPENDS ${JDBC_CMD_NAME})

--- a/src/connector/jdbc/deploy-pom.xml
+++ b/src/connector/jdbc/deploy-pom.xml
@@ -5,7 +5,7 @@
  <groupId>com.taosdata.jdbc</groupId>
  <artifactId>taos-jdbcdriver</artifactId>
-  <version>2.0.17</version>
+  <version>2.0.18</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.17</version>
+    <version>2.0.18</version>
    <packaging>jar</packaging>
    <name>JDBCDriver</name>
    <url>https://github.com/taosdata/TDengine/tree/master/src/connector/jdbc</url>
@@ -126,7 +126,7 @@
                        <include>**/*Test.java</include>
                    </includes>
                    <excludes>
-                        <exclude>**/BatchInsertTest.java</exclude>
+                        <exclude>**/AppMemoryLeakTest.java</exclude>
                        <exclude>**/FailOverTest.java</exclude>
                    </excludes>
                    <testFailureIgnore>true</testFailureIgnore>

--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBConstants.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBConstants.java
@@ -19,9 +19,12 @@ import java.util.Map;
 public abstract class TSDBConstants {
+    public static final String STATEMENT_CLOSED = "Statement already closed.";
    public static final String DEFAULT_PORT = "6200";
    public static final String UNSUPPORT_METHOD_EXCEPTIONZ_MSG = "this operation is NOT supported currently!";
    public static final String INVALID_VARIABLES = "invalid variables";
+    public static final String RESULT_SET_IS_CLOSED = "resultSet is closed.";
    public static Map<Integer, String> DATATYPE_MAP = null;
    public static final long JNI_NULL_POINTER = 0L;
@@ -74,7 +77,7 @@ public abstract class TSDBConstants {
    }
    static {
-        DATATYPE_MAP = new HashMap<Integer, String>();
+        DATATYPE_MAP = new HashMap<>();
        DATATYPE_MAP.put(1, "BOOL");
        DATATYPE_MAP.put(2, "TINYINT");
        DATATYPE_MAP.put(3, "SMALLINT");

--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBPreparedStatement.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBPreparedStatement.java
@@ -100,7 +100,6 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
     * order to process those supported SQLs.
     */
    private void preprocessSql() {
        /***** For processing some of Spark SQLs*****/
        // should replace it first
        this.rawSql = this.rawSql.replaceAll("or (.*) is null", "");
@@ -149,7 +148,6 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
            rawSql = rawSql.replace(matcher.group(1), tableFullName);
        }
        /***** for inner queries *****/
    }
    /**
@@ -196,7 +194,7 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
    @Override
    public void setNull(int parameterIndex, int sqlType) throws SQLException {
-        setObject(parameterIndex, new String("NULL"));
+        setObject(parameterIndex, "NULL");
    }
    @Override

--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSet.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSet.java
@@ -123,11 +123,21 @@ public class TSDBResultSet implements ResultSet {
    }
    public <T> T unwrap(Class<T> iface) throws SQLException {
-		throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.RESULT_SET_IS_CLOSED));
+        try {
+            return iface.cast(this);
+        } catch (ClassCastException cce) {
+            throw new SQLException("Unable to unwrap to " + iface.toString());
+        }
    }
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
-		throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.RESULT_SET_IS_CLOSED));
+        return iface.isInstance(this);
    }
    public boolean next() throws SQLException {

--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBStatement.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBStatement.java
@@ -52,12 +52,18 @@ public class TSDBStatement implements Statement {
        this.isClosed = false;
    }
+    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
-        throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        try {
+            return iface.cast(this);
+        } catch (ClassCastException cce) {
+            throw new SQLException("Unable to unwrap to " + iface.toString());
+        }
    }
+    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
-        throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        return iface.isInstance(this);
    }
    public ResultSet executeQuery(String sql) throws SQLException {
@@ -130,10 +136,15 @@ public class TSDBStatement implements Statement {
    }
    public void setMaxFieldSize(int max) throws SQLException {
+        if (isClosed())
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
        throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
    }
    public int getMaxRows() throws SQLException {
+        if (isClosed())
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
        // always set maxRows to zero, meaning unlimitted rows in a resultSet
        return 0;
    }

--- 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
--- 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
 package com.taosdata.jdbc.rs;
+import com.taosdata.jdbc.TSDBConstants;
 import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
+import java.sql.Timestamp;
 import java.util.ArrayList;
 public class RestfulResultSetMetaData implements ResultSetMetaData {
    private final String database;
    private ArrayList<RestfulResultSet.Field> fields;
+    private final RestfulResultSet resultSet;
-    public RestfulResultSetMetaData(String database, ArrayList<RestfulResultSet.Field> fields) {
+    public RestfulResultSetMetaData(String database, ArrayList<RestfulResultSet.Field> fields, RestfulResultSet resultSet) {
        this.database = database;
        this.fields = fields;
+        this.resultSet = resultSet;
    }
    @Override
@@ -26,13 +31,12 @@ public class RestfulResultSetMetaData implements ResultSetMetaData {
    @Override
    public boolean isCaseSensitive(int column) throws SQLException {
-        //TODO
        return false;
    }
    @Override
    public boolean isSearchable(int column) throws SQLException {
-        return false;
+        return true;
    }
    @Override
@@ -42,17 +46,30 @@ public class RestfulResultSetMetaData implements ResultSetMetaData {
    @Override
    public int isNullable(int column) throws SQLException {
+        if (column == 1)
+            return ResultSetMetaData.columnNoNulls;
        return ResultSetMetaData.columnNullable;
    }
    @Override
    public boolean isSigned(int column) throws SQLException {
+        String type = this.fields.get(column - 1).type.toUpperCase();
+        switch (type) {
+            case "TINYINT":
+            case "SMALLINT":
+            case "INT":
+            case "BIGINT":
+            case "FLOAT":
+            case "DOUBLE":
+                return true;
+            default:
                return false;
        }
+    }
    @Override
    public int getColumnDisplaySize(int column) throws SQLException {
-        return 0;
+        return this.fields.get(column - 1).length;
    }
    @Override
@@ -62,27 +79,46 @@ public class RestfulResultSetMetaData implements ResultSetMetaData {
    @Override
    public String getColumnName(int column) throws SQLException {
-        return null;
+        return fields.get(column - 1).name;
    }
    @Override
    public String getSchemaName(int column) throws SQLException {
-        return this.database;
+        return "";
    }
    @Override
    public int getPrecision(int column) throws SQLException {
+        String type = this.fields.get(column - 1).type.toUpperCase();
+        switch (type) {
+            case "FLOAT":
+                return 5;
+            case "DOUBLE":
+                return 9;
+            case "BINARY":
+            case "NCHAR":
+                return this.fields.get(column - 1).length;
+            default:
                return 0;
        }
+    }
    @Override
    public int getScale(int column) throws SQLException {
+        String type = this.fields.get(column - 1).type.toUpperCase();
+        switch (type) {
+            case "FLOAT":
+                return 5;
+            case "DOUBLE":
+                return 9;
+            default:
                return 0;
        }
+    }
    @Override
    public String getTableName(int column) throws SQLException {
-        return null;
+        return "";
    }
    @Override
@@ -92,17 +128,41 @@ public class RestfulResultSetMetaData implements ResultSetMetaData {
    @Override
    public int getColumnType(int column) throws SQLException {
-        return 0;
+        String type = this.fields.get(column - 1).type.toUpperCase();
+        switch (type) {
+            case "BOOL":
+                return java.sql.Types.BOOLEAN;
+            case "TINYINT":
+                return java.sql.Types.TINYINT;
+            case "SMALLINT":
+                return java.sql.Types.SMALLINT;
+            case "INT":
+                return java.sql.Types.INTEGER;
+            case "BIGINT":
+                return java.sql.Types.BIGINT;
+            case "FLOAT":
+                return java.sql.Types.FLOAT;
+            case "DOUBLE":
+                return java.sql.Types.DOUBLE;
+            case "BINARY":
+                return java.sql.Types.BINARY;
+            case "TIMESTAMP":
+                return java.sql.Types.TIMESTAMP;
+            case "NCHAR":
+                return java.sql.Types.NCHAR;
+        }
+        throw new SQLException(TSDBConstants.INVALID_VARIABLES);
    }
    @Override
    public String getColumnTypeName(int column) throws SQLException {
-        return null;
+        String type = fields.get(column - 1).type;
+        return type.toUpperCase();
    }
    @Override
    public boolean isReadOnly(int column) throws SQLException {
-        return false;
+        return true;
    }
    @Override
@@ -117,16 +177,43 @@ public class RestfulResultSetMetaData implements ResultSetMetaData {
    @Override
    public String getColumnClassName(int column) throws SQLException {
-        return null;
+        String type = this.fields.get(column - 1).type;
+        String columnClassName = "";
+        switch (type) {
+            case "BOOL":
+                return Boolean.class.getName();
+            case "TINYINT":
+            case "SMALLINT":
+                return Short.class.getName();
+            case "INT":
+                return Integer.class.getName();
+            case "BIGINT":
+                return Long.class.getName();
+            case "FLOAT":
+                return Float.class.getName();
+            case "DOUBLE":
+                return Double.class.getName();
+            case "TIMESTAMP":
+                return Timestamp.class.getName();
+            case "BINARY":
+            case "NCHAR":
+                return String.class.getName();
+        }
+        return columnClassName;
    }
    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
-        return null;
+        try {
+            return iface.cast(this);
+        } catch (ClassCastException cce) {
+            throw new SQLException("Unable to unwrap to " + iface.toString());
+        }
    }
    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
-        return false;
+        return iface.isInstance(this);
    }
 }
--- 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
@@ -14,7 +14,6 @@ import java.util.stream.Collectors;
 public class RestfulStatement implements Statement {
-    private static final String STATEMENT_CLOSED = "Statement already closed.";
    private boolean closed;
    private String database;
    private final RestfulConnection conn;
@@ -65,37 +64,18 @@ public class RestfulStatement implements Statement {
    public ResultSet executeQuery(String sql) throws SQLException {
        if (isClosed())
            throw new SQLException("statement already closed");
-        if (!SqlSyntaxValidator.isSelectSql(sql))
+        if (!SqlSyntaxValidator.isValidForExecuteQuery(sql))
-            throw new SQLException("not a select sql for executeQuery: " + sql);
+            throw new SQLException("not a valid sql for executeQuery: " + sql);
        final String url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sql";
-        // row data
+        if (SqlSyntaxValidator.isDatabaseUnspecifiedQuery(sql)) {
-        String result = HttpClientPoolUtil.execute(url, sql);
+            return executeOneQuery(url, sql);
-        JSONObject resultJson = JSON.parseObject(result);
-        if (resultJson.getString("status").equals("error")) {
-            throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + resultJson.getString("desc") + "\n" + "error code: " + resultJson.getString("code")));
-        }
-        // parse table name from sql
-        String[] tableIdentifiers = parseTableIdentifier(sql);
-        if (tableIdentifiers != null) {
-            List<JSONObject> fieldJsonList = new ArrayList<>();
-            for (String tableIdentifier : tableIdentifiers) {
-                // field meta
-                String fields = HttpClientPoolUtil.execute(url, "DESCRIBE " + tableIdentifier);
-                JSONObject fieldJson = JSON.parseObject(fields);
-                if (fieldJson.getString("status").equals("error")) {
-                    throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + fieldJson.getString("desc") + "\n" + "error code: " + fieldJson.getString("code")));
-                }
-                fieldJsonList.add(fieldJson);
-            }
-            this.resultSet = new RestfulResultSet(database, this, resultJson, fieldJsonList);
-        } else {
-            this.resultSet = new RestfulResultSet(database, this, resultJson);
        }
-        this.affectedRows = 0;
+        if (this.database == null || this.database.isEmpty())
-        return resultSet;
+            throw new SQLException("Database not specified or available");
+        HttpClientPoolUtil.execute(url, "use " + this.database);
+        return executeOneQuery(url, sql);
    }
    @Override
@@ -105,19 +85,15 @@ public class RestfulStatement implements Statement {
        if (!SqlSyntaxValidator.isValidForExecuteUpdate(sql))
            throw new SQLException("not a valid sql for executeUpdate: " + sql);
-        if (this.database == null)
+        final String url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sql";
-            throw new SQLException("Database not specified or available");
+        if (SqlSyntaxValidator.isDatabaseUnspecifiedUpdate(sql)) {
+            return executeOneUpdate(url, sql);
-        final String url = "http://" + conn.getHost().trim() + ":" + conn.getPort() + "/rest/sql";
-//        HttpClientPoolUtil.execute(url, "use " + conn.getDatabase());
-        String result = HttpClientPoolUtil.execute(url, sql);
-        JSONObject jsonObject = JSON.parseObject(result);
-        if (jsonObject.getString("status").equals("error")) {
-            throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + jsonObject.getString("desc") + "\n" + "error code: " + jsonObject.getString("code")));
        }
-        this.resultSet = null;
-        this.affectedRows = Integer.parseInt(jsonObject.getString("rows"));
+        if (this.database == null || this.database.isEmpty())
-        return this.affectedRows;
+            throw new SQLException("Database not specified or available");
+        HttpClientPoolUtil.execute(url, "use " + this.database);
+        return executeOneUpdate(url, sql);
    }
    @Override
@@ -131,14 +107,14 @@ public class RestfulStatement implements Statement {
    @Override
    public int getMaxFieldSize() throws SQLException {
        if (isClosed())
-            throw new SQLException(STATEMENT_CLOSED);
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
        return TSDBConstants.maxFieldSize;
    }
    @Override
    public void setMaxFieldSize(int max) throws SQLException {
        if (isClosed())
-            throw new SQLException(STATEMENT_CLOSED);
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
        if (max < 0)
            throw new SQLException(TSDBConstants.INVALID_VARIABLES);
        // nothing to do
@@ -147,14 +123,14 @@ public class RestfulStatement implements Statement {
    @Override
    public int getMaxRows() throws SQLException {
        if (isClosed())
-            throw new SQLException(STATEMENT_CLOSED);
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
        return 0;
    }
    @Override
    public void setMaxRows(int max) throws SQLException {
        if (isClosed())
-            throw new SQLException(STATEMENT_CLOSED);
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
        if (max < 0)
            throw new SQLException(TSDBConstants.INVALID_VARIABLES);
        // nothing to do
@@ -163,20 +139,20 @@ public class RestfulStatement implements Statement {
    @Override
    public void setEscapeProcessing(boolean enable) throws SQLException {
        if (isClosed())
-            throw new SQLException(RestfulStatement.STATEMENT_CLOSED);
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
    }
    @Override
    public int getQueryTimeout() throws SQLException {
        if (isClosed())
-            throw new SQLException(STATEMENT_CLOSED);
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
        return 0;
    }
    @Override
    public void setQueryTimeout(int seconds) throws SQLException {
        if (isClosed())
-            throw new SQLException(STATEMENT_CLOSED);
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
        if (seconds < 0)
            throw new SQLException(TSDBConstants.INVALID_VARIABLES);
    }
@@ -189,7 +165,7 @@ public class RestfulStatement implements Statement {
    @Override
    public SQLWarning getWarnings() throws SQLException {
        if (isClosed())
-            throw new SQLException(STATEMENT_CLOSED);
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
        return null;
    }
@@ -197,53 +173,93 @@ public class RestfulStatement implements Statement {
    public void clearWarnings() throws SQLException {
        // nothing to do
        if (isClosed())
-            throw new SQLException(STATEMENT_CLOSED);
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
    }
    @Override
    public void setCursorName(String name) throws SQLException {
        if (isClosed())
-            throw new SQLException(RestfulStatement.STATEMENT_CLOSED);
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
        throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
    }
    @Override
    public boolean execute(String sql) throws SQLException {
-        if (isClosed()) {
+        if (isClosed())
            throw new SQLException("Invalid method call on a closed statement.");
-        }
+        if (!SqlSyntaxValidator.isValidForExecute(sql))
+            throw new SQLException("not a valid sql for execute: " + sql);
        //如果执行了use操作应该将当前Statement的catalog设置为新的database
+        final String url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sql";
        if (SqlSyntaxValidator.isUseSql(sql)) {
+            HttpClientPoolUtil.execute(url, sql);
            this.database = sql.trim().replace("use", "").trim();
            this.conn.setCatalog(this.database);
+        } else if (SqlSyntaxValidator.isDatabaseUnspecifiedQuery(sql)) {
+            executeOneQuery(url, sql);
+        } else if (SqlSyntaxValidator.isDatabaseUnspecifiedUpdate(sql)) {
+            executeOneUpdate(url, sql);
+        } else {
+            if (SqlSyntaxValidator.isValidForExecuteQuery(sql)) {
+                executeQuery(sql);
+            } else {
+                executeUpdate(sql);
+            }
        }
-        if (this.database == null)
-            throw new SQLException("Database not specified or available");
-        if (SqlSyntaxValidator.isSelectSql(sql)) {
+        return true;
-            executeQuery(sql);
-        } else if (SqlSyntaxValidator.isShowSql(sql) || SqlSyntaxValidator.isDescribeSql(sql)) {
-            final String url = "http://" + conn.getHost().trim() + ":" + conn.getPort() + "/rest/sql";
-            if (!SqlSyntaxValidator.isShowDatabaseSql(sql)) {
-                HttpClientPoolUtil.execute(url, "use " + conn.getDatabase());
    }
+    private ResultSet executeOneQuery(String url, String sql) throws SQLException {
+        if (!SqlSyntaxValidator.isValidForExecuteQuery(sql))
+            throw new SQLException("not a select sql for executeQuery: " + sql);
+        // row data
        String result = HttpClientPoolUtil.execute(url, sql);
        JSONObject resultJson = JSON.parseObject(result);
        if (resultJson.getString("status").equals("error")) {
            throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + resultJson.getString("desc") + "\n" + "error code: " + resultJson.getString("code")));
        }
-            this.resultSet = new RestfulResultSet(database, this, resultJson);
+        // parse table name from sql
+        String[] tableIdentifiers = parseTableIdentifier(sql);
+        if (tableIdentifiers != null) {
+            List<JSONObject> fieldJsonList = new ArrayList<>();
+            for (String tableIdentifier : tableIdentifiers) {
+                // field meta
+                String fields = HttpClientPoolUtil.execute(url, "DESCRIBE " + tableIdentifier);
+                JSONObject fieldJson = JSON.parseObject(fields);
+                if (fieldJson.getString("status").equals("error")) {
+                    throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + fieldJson.getString("desc") + "\n" + "error code: " + fieldJson.getString("code")));
+                }
+                fieldJsonList.add(fieldJson);
+            }
+            this.resultSet = new RestfulResultSet(database, this, resultJson, fieldJsonList);
        } else {
-            executeUpdate(sql);
+            this.resultSet = new RestfulResultSet(database, this, resultJson);
+        }
+        this.affectedRows = 0;
+        return resultSet;
    }
-        return true;
+    private int executeOneUpdate(String url, String sql) throws SQLException {
+        if (!SqlSyntaxValidator.isValidForExecuteUpdate(sql))
+            throw new SQLException("not a valid sql for executeUpdate: " + sql);
+        String result = HttpClientPoolUtil.execute(url, sql);
+        JSONObject jsonObject = JSON.parseObject(result);
+        if (jsonObject.getString("status").equals("error")) {
+            throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + jsonObject.getString("desc") + "\n" + "error code: " + jsonObject.getString("code")));
+        }
+        this.resultSet = null;
+        this.affectedRows = Integer.parseInt(jsonObject.getString("rows"));
+        return this.affectedRows;
    }
    @Override
    public ResultSet getResultSet() throws SQLException {
        if (isClosed())
-            throw new SQLException(STATEMENT_CLOSED);
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
        return resultSet;
    }
@@ -275,7 +291,7 @@ public class RestfulStatement implements Statement {
    @Override
    public void setFetchSize(int rows) throws SQLException {
        if (isClosed())
-            throw new SQLException(STATEMENT_CLOSED);
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
        if (rows < 0)
            throw new SQLException(TSDBConstants.INVALID_VARIABLES);
        //nothing to do
@@ -284,28 +300,28 @@ public class RestfulStatement implements Statement {
    @Override
    public int getFetchSize() throws SQLException {
        if (isClosed())
-            throw new SQLException(STATEMENT_CLOSED);
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
        return 0;
    }
    @Override
    public int getResultSetConcurrency() throws SQLException {
        if (isClosed())
-            throw new SQLException(STATEMENT_CLOSED);
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
        return this.resultSet.getConcurrency();
    }
    @Override
    public int getResultSetType() throws SQLException {
        if (isClosed())
-            throw new SQLException(STATEMENT_CLOSED);
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
        return this.resultSet.getType();
    }
    @Override
    public void addBatch(String sql) throws SQLException {
        if (isClosed())
-            throw new SQLException(STATEMENT_CLOSED);
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
        //TODO:
    }
@@ -323,14 +339,14 @@ public class RestfulStatement implements Statement {
    @Override
    public Connection getConnection() throws SQLException {
        if (isClosed())
-            throw new SQLException(STATEMENT_CLOSED);
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
        return this.conn;
    }
    @Override
    public boolean getMoreResults(int current) throws SQLException {
        if (isClosed())
-            throw new SQLException(STATEMENT_CLOSED);
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
        if (resultSet == null)
            return false;
@@ -388,7 +404,7 @@ public class RestfulStatement implements Statement {
    @Override
    public int getResultSetHoldability() throws SQLException {
        if (isClosed())
-            throw new SQLException(STATEMENT_CLOSED);
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
        return this.resultSet.getHoldability();
    }
@@ -400,28 +416,28 @@ public class RestfulStatement implements Statement {
    @Override
    public void setPoolable(boolean poolable) throws SQLException {
        if (isClosed())
-            throw new SQLException(STATEMENT_CLOSED);
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
        //nothing to do
    }
    @Override
    public boolean isPoolable() throws SQLException {
        if (isClosed())
-            throw new SQLException(STATEMENT_CLOSED);
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
        return false;
    }
    @Override
    public void closeOnCompletion() throws SQLException {
        if (isClosed())
-            throw new SQLException(STATEMENT_CLOSED);
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
        this.closeOnCompletion = true;
    }
    @Override
    public boolean isCloseOnCompletion() throws SQLException {
        if (isClosed())
-            throw new SQLException(STATEMENT_CLOSED);
+            throw new SQLException(TSDBConstants.STATEMENT_CLOSED);
        return this.closeOnCompletion;
    }

--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/utils/SqlSyntaxValidator.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/utils/SqlSyntaxValidator.java
@@ -20,8 +20,11 @@ import java.sql.Connection;
 public class SqlSyntaxValidator {
-    private static final String[] updateSQL = {"insert", "update", "delete", "create", "alter", "drop", "show", "describe", "use", "import"};
+    private static final String[] SQL = {"select", "insert", "import", "create", "use", "alter", "drop", "set", "show", "describe"};
-    private static final String[] querySQL = {"select"};
+    private static final String[] updateSQL = {"insert", "import", "create", "use", "alter", "drop", "set"};
+    private static final String[] querySQL = {"select", "show", "describe"};
+    private static final String[] databaseUnspecifiedShow = {"databases", "dnodes", "mnodes", "variables"};
    private TSDBConnection tsdbConnection;
@@ -37,8 +40,38 @@ public class SqlSyntaxValidator {
        return false;
    }
+    public static boolean isValidForExecuteQuery(String sql) {
+        for (String prefix : querySQL) {
+            if (sql.trim().toLowerCase().startsWith(prefix))
+                return true;
+        }
+        return false;
+    }
+    public static boolean isValidForExecute(String sql) {
+        for (String prefix : SQL) {
+            if (sql.trim().toLowerCase().startsWith(prefix))
+                return true;
+        }
+        return false;
+    }
+    public static boolean isDatabaseUnspecifiedQuery(String sql) {
+        for (String databaseObj : databaseUnspecifiedShow) {
+            if (sql.trim().toLowerCase().matches("show\\s+" + databaseObj + ".*"))
+                return true;
+        }
+        return false;
+    }
+    public static boolean isDatabaseUnspecifiedUpdate(String sql) {
+        sql = sql.trim().toLowerCase();
+        return sql.matches("create\\s+database.*") || sql.startsWith("set") || sql.matches("drop\\s+database.*");
+    }
    public static boolean isUseSql(String sql) {
-        return sql.trim().toLowerCase().startsWith("use") || sql.trim().toLowerCase().matches("create\\s*database.*") || sql.toLowerCase().toLowerCase().matches("drop\\s*database.*");
+        return sql.trim().toLowerCase().startsWith("use");
+//                || sql.trim().toLowerCase().matches("create\\s*database.*") || sql.toLowerCase().toLowerCase().matches("drop\\s*database.*");
    }
    public static boolean isShowSql(String sql) {
@@ -58,8 +91,9 @@ public class SqlSyntaxValidator {
        return sql.trim().toLowerCase().startsWith("select");
    }
    public static boolean isShowDatabaseSql(String sql) {
        return sql.trim().toLowerCase().matches("show\\s*databases");
    }
 }
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/BaseTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/BaseTest.java
-package com.taosdata.jdbc;
-import com.taosdata.jdbc.utils.TDNodes;
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
-public abstract class BaseTest {
-    private static boolean testCluster = false;
-    private static TDNodes nodes = new TDNodes();
-    @BeforeClass
-    public static void setupEnv() {
-        try {
-            if (nodes.getTDNode(1).getTaosdPid() != null) {
-                System.out.println("Kill taosd before running JDBC test");
-                nodes.getTDNode(1).setRunning(1);
-                nodes.stop(1);
-            }
-            nodes.setTestCluster(testCluster);
-            nodes.deploy(1);
-            nodes.start(1);
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-    @AfterClass
-    public static void cleanUpEnv() {
-        nodes.stop(1);
-    }
-}
\ No newline at end of file
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/BatchInsertTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/BatchInsertTest.java
-package com.taosdata.jdbc;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import java.sql.*;
-import java.util.Properties;
-import java.util.Random;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.TimeUnit;
-import static org.junit.Assert.assertEquals;
-public class BatchInsertTest {
-    private Connection connection;
-    private static String dbName = "test";
-    private static String stbName = "meters";
-    private static String host = "127.0.0.1";
-    private static int numOfTables = 30;
-    private static int numOfRecordsPerTable = 1000;
-    private static long ts = 1496732686000l;
-    private static String tablePrefix = "t";
-    @Before
-    public void createDatabase() throws SQLException {
-        try {
-            Class.forName("com.taosdata.jdbc.TSDBDriver");
-        } catch (ClassNotFoundException e) {
-            return;
-        }
-        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");
-        connection = DriverManager.getConnection("jdbc:TAOS://" + host + ":0/", properties);
-        Statement stmt = connection.createStatement();
-        stmt.execute("drop database if exists " + dbName);
-        stmt.execute("create database if not exists " + dbName);
-        stmt.execute("use " + dbName);
-        String createTableSql = "create table " + stbName + "(ts timestamp, f1 int, f2 int, f3 int) tags(areaid int, loc binary(20))";
-        stmt.execute(createTableSql);
-        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 + "')";
-            stmt.execute(createSubTalbesSql);
-        }
-        stmt.close();
-    }
-    @Test
-    public void testBatchInsert() throws SQLException {
-        ExecutorService executorService = Executors.newFixedThreadPool(numOfTables);
-        for (int i = 0; i < numOfTables; i++) {
-            final int index = i;
-            executorService.execute(() -> {
-                try {
-                    long startTime = System.currentTimeMillis();
-                    Statement statement = connection.createStatement(); // get statement
-                    StringBuilder sb = new StringBuilder();
-                    sb.append("INSERT INTO " + tablePrefix + index + " VALUES");
-                    Random rand = new Random();
-                    for (int j = 1; j <= numOfRecordsPerTable; j++) {
-                        sb.append("(" + (ts + j) + ", ");
-                        sb.append(rand.nextInt(100) + ", ");
-                        sb.append(rand.nextInt(100) + ", ");
-                        sb.append(rand.nextInt(100) + ")");
-                    }
-                    statement.addBatch(sb.toString());
-                    statement.executeBatch();
-                    long endTime = System.currentTimeMillis();
-                    System.out.println("Thread " + index + " takes " + (endTime - startTime) + " microseconds");
-                    connection.commit();
-                    statement.close();
-                } catch (Exception e) {
-                    e.printStackTrace();
-                }
-            });
-        }
-        executorService.shutdown();
-        try {
-            executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
-        } catch (InterruptedException e) {
-            e.printStackTrace();
-        }
-        Statement statement = connection.createStatement();
-        ResultSet rs = statement.executeQuery("select * from meters");
-        int num = 0;
-        while (rs.next()) {
-            num++;
-        }
-        assertEquals(num, numOfTables * numOfRecordsPerTable);
-        rs.close();
-    }
-    @After
-    public void close() {
-        try {
-            if (connection != null)
-                connection.close();
-        } catch (SQLException e) {
-            e.printStackTrace();
-        }
-    }
-}
\ No newline at end of file
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/PreparedStatementTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/PreparedStatementTest.java
 package com.taosdata.jdbc;
-import org.junit.AfterClass;
+import org.junit.*;
-import org.junit.BeforeClass;
+import org.junit.runners.MethodSorters;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
 import java.sql.*;
 import java.util.Properties;
@@ -11,14 +9,13 @@ import java.util.Properties;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
-@FixMethodOrder()
+@FixMethodOrder(value = MethodSorters.NAME_ASCENDING)
-public class PreparedStatementTest extends BaseTest {
+public class PreparedStatementTest {
-    static Connection connection = null;
+    static Connection connection;
-    static PreparedStatement statement = null;
+    static TSDBPreparedStatement statement;
    static String dbName = "test";
    static String tName = "t0";
    static String host = "localhost";
-    static ResultSet resSet = null;
    @BeforeClass
    public static void createConnection() throws SQLException {
@@ -28,19 +25,16 @@ public class PreparedStatementTest extends BaseTest {
            return;
        }
        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");
        connection = DriverManager.getConnection("jdbc:TAOS://" + host + ":0/", properties);
        String sql = "drop database if exists " + dbName;
        statement = (TSDBPreparedStatement) connection.prepareStatement(sql);
    }
    @Test
-    public void createTableAndQuery() throws SQLException {
+    public void case001_createTableAndQuery() throws SQLException {
        long ts = System.currentTimeMillis();
        statement.executeUpdate("create database if not exists " + dbName);
@@ -48,141 +42,132 @@ public class PreparedStatementTest extends BaseTest {
        statement.executeUpdate("insert into " + dbName + "." + tName + " values (" + ts + ", 1)");
        PreparedStatement selectStatement = connection.prepareStatement("select * from " + dbName + "." + tName);
        ResultSet resultSet = selectStatement.executeQuery();
        assertTrue(null != resultSet);
        boolean isClosed = statement.isClosed();
        assertEquals(false, isClosed);
+        selectStatement.close();
    }
    @Test
-    public void testPreparedStatement() throws SQLException {
+    public void case002_testPreparedStatement() throws SQLException {
        long ts = System.currentTimeMillis() + 20000;
-        PreparedStatement saveStatement = connection
-                .prepareStatement("insert into " + dbName + "." + tName + " values (" + ts + ", 1)");
+        PreparedStatement saveStatement = connection.prepareStatement("insert into " + dbName + "." + tName + " values (" + ts + ", 1)");
        int affectedRows = saveStatement.executeUpdate();
        assertTrue(1 == affectedRows);
+        saveStatement.close();
    }
    @Test
-    public void testSavedPreparedStatement() throws SQLException {
+    public void case003_testSavedPreparedStatement() throws SQLException {
        long ts = System.currentTimeMillis();
+        TSDBPreparedStatement saveStatement = (TSDBPreparedStatement) connection.prepareStatement("insert into  " + dbName + "." + tName + " values (?, ?)");
-        TSDBPreparedStatement saveStatement = (TSDBPreparedStatement) connection
-                .prepareStatement("insert into  " + dbName + "." + tName + " values (?, ?)");
        saveStatement.setObject(1, ts + 10000);
        saveStatement.setObject(2, 3);
        int rows = saveStatement.executeUpdate();
        assertEquals(1, rows);
+        saveStatement.close();
    }
    @Test
-    public void testUnsupport() {
+    public void case004_testUnsupport() throws SQLException {
-        // if(null == resSet) {
-        // return;
+        Assert.assertNotNull(statement.unwrap(TSDBPreparedStatement.class));
-        // }
+        Assert.assertTrue(statement.isWrapperFor(TSDBPreparedStatement.class));
-        TSDBPreparedStatement tsdbStatement = (TSDBPreparedStatement) statement;
-        try {
-            tsdbStatement.unwrap(null);
-        } catch (SQLException e) {
-        }
-        try {
-            tsdbStatement.isWrapperFor(null);
-        } catch (SQLException e) {
-        }
        try {
-            tsdbStatement.getMaxFieldSize();
+            statement.getMaxFieldSize();
        } catch (SQLException e) {
        }
        try {
-            tsdbStatement.setMaxFieldSize(0);
+            statement.setMaxFieldSize(0);
        } catch (SQLException e) {
        }
        try {
-            tsdbStatement.setEscapeProcessing(true);
+            statement.setEscapeProcessing(true);
        } catch (SQLException e) {
        }
        try {
-            tsdbStatement.cancel();
+            statement.cancel();
        } catch (SQLException e) {
        }
        try {
-            tsdbStatement.getWarnings();
+            statement.getWarnings();
        } catch (SQLException e) {
        }
        try {
-            tsdbStatement.clearWarnings();
+            statement.clearWarnings();
        } catch (SQLException e) {
        }
        try {
-            tsdbStatement.setCursorName(null);
+            statement.setCursorName(null);
        } catch (SQLException e) {
        }
        try {
-            tsdbStatement.getMoreResults();
+            statement.getMoreResults();
        } catch (SQLException e) {
        }
        try {
-            tsdbStatement.setFetchDirection(0);
+            statement.setFetchDirection(0);
        } catch (SQLException e) {
        }
        try {
-            tsdbStatement.getFetchDirection();
+            statement.getFetchDirection();
        } catch (SQLException e) {
        }
        try {
-            tsdbStatement.getResultSetConcurrency();
+            statement.getResultSetConcurrency();
        } catch (SQLException e) {
        }
        try {
-            tsdbStatement.getResultSetType();
+            statement.getResultSetType();
        } catch (SQLException e) {
        }
        try {
-            tsdbStatement.getConnection();
+            statement.getConnection();
        } catch (SQLException e) {
        }
        try {
-            tsdbStatement.getMoreResults();
+            statement.getMoreResults();
        } catch (SQLException e) {
        }
        try {
-            tsdbStatement.getGeneratedKeys();
+            statement.getGeneratedKeys();
        } catch (SQLException e) {
        }
        try {
-            tsdbStatement.executeUpdate(null, 0);
+            statement.executeUpdate(null, 0);
        } catch (SQLException e) {
        }
        try {
-            tsdbStatement.executeUpdate(null, new int[]{0});
+            statement.executeUpdate(null, new int[]{0});
        } catch (SQLException e) {
        }
        try {
-            tsdbStatement.executeUpdate(null, new String[]{"str1", "str2"});
+            statement.executeUpdate(null, new String[]{"str1", "str2"});
        } catch (SQLException e) {
        }
        try {
-            tsdbStatement.getResultSetHoldability();
+            statement.getResultSetHoldability();
        } catch (SQLException e) {
        }
        try {
-            tsdbStatement.setPoolable(true);
+            statement.setPoolable(true);
        } catch (SQLException e) {
        }
        try {
-            tsdbStatement.isPoolable();
+            statement.isPoolable();
        } catch (SQLException e) {
        }
        try {
-            tsdbStatement.closeOnCompletion();
+            statement.closeOnCompletion();
        } catch (SQLException e) {
        }
        try {
-            tsdbStatement.isCloseOnCompletion();
+            statement.isCloseOnCompletion();
        } catch (SQLException e) {
        }
    }

--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/QueryDataTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/QueryDataTest.java
@@ -6,37 +6,22 @@ import org.junit.Test;
 import java.sql.*;
 import java.util.Properties;
-import java.util.Random;
 import static org.junit.Assert.assertEquals;
-import java.util.Properties;
-import java.util.concurrent.Executors;
-import java.util.concurrent.*;
-import static org.junit.Assert.assertTrue;
-public class QueryDataTest extends BaseTest {
+public class QueryDataTest {
-    static Connection connection = null;
+    static Connection connection;
-    static Statement statement = null;
+    static Statement statement;
    static String dbName = "test";
    static String stbName = "meters";
-    static String host = "localhost";
+    static String host = "127.0.0.1";
-    static int numOfTables = 30;
-    final static int numOfRecordsPerTable = 1000;
-    static long ts = 1496732686000l;
-    final static String tablePrefix = "t";
    @Before
-    public void createDatabase() throws SQLException {
+    public void createDatabase() {
        try {
            Class.forName("com.taosdata.jdbc.TSDBDriver");
-        } catch (ClassNotFoundException e) {
-            return;
-        }
            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");
@@ -47,35 +32,41 @@ public class QueryDataTest extends BaseTest {
            statement.executeUpdate("create database if not exists " + dbName);
            statement.executeUpdate("use " + dbName);
-        String createTableSql = "create table " + stbName + "(ts timestamp, name binary(6))";  
+            String createTableSql = "create table " + stbName + "(ts timestamp, name binary(64))";
            statement.executeUpdate(createTableSql);
+        } catch (ClassNotFoundException | SQLException e) {
+            return;
+        }
    }
    @Test
-    public void testQueryBinaryData() throws SQLException{                
+    public void testQueryBinaryData() throws SQLException {
+        String insertSql = "insert into " + stbName + " values(now, 'taosdata')";
-        String insertSql = "insert into "  + stbName + " values(now, 'taosda')";
        System.out.println(insertSql);
        statement.executeUpdate(insertSql);
        String querySql = "select * from " + stbName;
        ResultSet rs = statement.executeQuery(querySql);
-        while(rs.next()) {
+        while (rs.next()) {
-            String name = rs.getString(2) + "001";
+            String name = rs.getString(2);
            System.out.println("name = " + name);
-            assertEquals(name, "taosda001");
+            assertEquals("taosdata", name);
        }
        rs.close();
    }
    @After
-    public void close() throws Exception {        
+    public void close() {
+        try {
+            if (statement != null)
                statement.close();
+            if (connection != null)
                connection.close();
-        Thread.sleep(10);
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
    }
 }
\ No newline at end of file
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/ResultSetTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/ResultSetTest.java
 package com.taosdata.jdbc;
 import org.junit.AfterClass;
+import org.junit.Assert;
 import org.junit.BeforeClass;
 import org.junit.Test;
@@ -13,42 +14,37 @@ import java.util.Properties;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
-public class ResultSetTest extends BaseTest {
+public class ResultSetTest {
-    static Connection connection = null;
+    static Connection connection;
-    static Statement statement = null;
+    static Statement statement;
    static String dbName = "test";
    static String tName = "t0";
    static String host = "localhost";
-    static ResultSet resSet = null;
+    static ResultSet resSet;
    @BeforeClass
-    public static void createDatabaseAndTable() throws SQLException {
+    public static void createDatabaseAndTable() {
        try {
            Class.forName("com.taosdata.jdbc.TSDBDriver");
-        } catch (ClassNotFoundException e) {
-            return;
-        }
            Properties properties = new Properties();
-        properties.setProperty(TSDBDriver.PROPERTY_KEY_HOST, host);
            properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
            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");
            connection = DriverManager.getConnection("jdbc:TAOS://" + host + ":0/", properties);
            statement = connection.createStatement();
            statement.executeUpdate("drop database if exists " + dbName);
            statement.executeUpdate("create database if not exists " + dbName);
-        statement.executeUpdate("create table if not exists " + dbName + "." + tName +
+            statement.execute("use " + dbName);
-                " (ts timestamp, k1 int, k2 bigint, k3 float, k4 double, k5 binary(30), k6 smallint, k7 bool, k8 nchar(20))");
+            statement.executeUpdate("create table if not exists " + dbName + "." + tName + " (ts timestamp, k1 int, k2 bigint, k3 float, k4 double, k5 binary(30), k6 smallint, k7 bool, k8 nchar(20))");
+        } catch (ClassNotFoundException | SQLException e) {
+            return;
+        }
-        statement.executeQuery("use " + dbName);
    }
    @Test
    public void testResultSet() {
-        String sql = null;
+        String sql;
        long ts = 1496732686000l;
        int v1 = 2147483600;
        long v2 = ts + 1000;
@@ -119,16 +115,8 @@ public class ResultSetTest extends BaseTest {
    public void testUnsupport() throws SQLException {
        statement.executeQuery("show databases");
        resSet = statement.getResultSet();
-        try {
+        Assert.assertNotNull(resSet.unwrap(TSDBResultSet.class));
-            resSet.unwrap(null);
+        Assert.assertTrue(resSet.isWrapperFor(TSDBResultSet.class));
-        } catch (SQLException e) {
-            assertTrue(e.getMessage().contains("this operation is NOT supported currently!"));
-        }
-        try {
-            resSet.isWrapperFor(null);
-        } catch (SQLException e) {
-            assertTrue(e.getMessage().contains("this operation is NOT supported currently!"));
-        }
        try {
            resSet.getAsciiStream(0);
        } catch (SQLException e) {
@@ -815,13 +803,18 @@ public class ResultSetTest extends BaseTest {
        assertEquals(res.length, 2);
        statement.clearBatch();
    }
    @AfterClass
-    public static void close() throws Exception {
+    public static void close() {
+        try {
            statement.executeUpdate("drop database " + dbName);
+            if (statement != null)
                statement.close();
+            if (connection != null)
                connection.close();
-        Thread.sleep(10);
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
    }
 }
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/StableTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/StableTest.java
@@ -29,6 +29,7 @@ public class StableTest {
            properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
            connection = DriverManager.getConnection("jdbc:TAOS://" + host + ":0/", properties);
            Statement statement = connection.createStatement();
+            statement.execute("drop database if exists " + dbName);
            statement.execute("create database if not exists " + dbName);
            statement.execute("use " + dbName);
            statement.close();

--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/StatementTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/StatementTest.java
 package com.taosdata.jdbc;
 import org.junit.AfterClass;
+import org.junit.Assert;
 import org.junit.BeforeClass;
 import org.junit.Test;
@@ -16,23 +17,22 @@ public class StatementTest {
    static String dbName = "test";
    static String tName = "t0";
    static String host = "localhost";
-    static ResultSet resSet = null;
    @BeforeClass
    public static void createConnection() throws SQLException {
        try {
            Class.forName("com.taosdata.jdbc.TSDBDriver");
-        } catch (ClassNotFoundException e) {
-            return;
-        }
            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");
            connection = DriverManager.getConnection("jdbc:TAOS://" + host + ":0/?user=root&password=taosdata", properties);
            statement = connection.createStatement();
            statement.executeUpdate("drop database if exists " + dbName);
+        } catch (ClassNotFoundException e) {
+            return;
+        }
    }
    @Test
@@ -49,7 +49,6 @@ public class StatementTest {
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    @Test
@@ -67,118 +66,46 @@ public class StatementTest {
        assertEquals(false, isClosed);
    }
-    @Test
+    @Test(expected = SQLException.class)
-    public void testUnsupport() {
+    public void testUnsupport() throws SQLException {
-        TSDBStatement tsdbStatement = (TSDBStatement) statement;
+        Assert.assertNotNull(statement.unwrap(TSDBStatement.class));
-        try {
+        Assert.assertTrue(statement.isWrapperFor(TSDBStatement.class));
-            tsdbStatement.unwrap(null);
-        } catch (SQLException e) {
+        statement.getMaxFieldSize();
-        }
+        statement.setMaxFieldSize(0);
-        try {
+        statement.setEscapeProcessing(true);
-            tsdbStatement.isWrapperFor(null);
+        statement.cancel();
-        } catch (SQLException e) {
+        statement.getWarnings();
-        }
+        statement.clearWarnings();
-        try {
+        statement.setCursorName(null);
-            tsdbStatement.getMaxFieldSize();
+        statement.getMoreResults();
-        } catch (SQLException e) {
+        statement.setFetchDirection(0);
-        }
+        statement.getFetchDirection();
-        try {
+        statement.getResultSetConcurrency();
-            tsdbStatement.setMaxFieldSize(0);
+        statement.getResultSetType();
-        } catch (SQLException e) {
+        statement.getConnection();
-        }
+        statement.getMoreResults();
-        try {
+        statement.getGeneratedKeys();
-            tsdbStatement.setEscapeProcessing(true);
+        statement.executeUpdate(null, 0);
-        } catch (SQLException e) {
+        statement.executeUpdate(null, new int[]{0});
-        }
+        statement.executeUpdate(null, new String[]{"str1", "str2"});
-        try {
+        statement.getResultSetHoldability();
-            tsdbStatement.cancel();
+        statement.setPoolable(true);
-        } catch (SQLException e) {
+        statement.isPoolable();
-        }
+        statement.closeOnCompletion();
-        try {
+        statement.isCloseOnCompletion();
-            tsdbStatement.getWarnings();
-        } catch (SQLException e) {
-        }
-        try {
-            tsdbStatement.clearWarnings();
-        } catch (SQLException e) {
-        }
-        try {
-            tsdbStatement.setCursorName(null);
-        } catch (SQLException e) {
-        }
-        try {
-            tsdbStatement.getMoreResults();
-        } catch (SQLException e) {
-        }
-        try {
-            tsdbStatement.setFetchDirection(0);
-        } catch (SQLException e) {
-        }
-        try {
-            tsdbStatement.getFetchDirection();
-        } catch (SQLException e) {
-        }
-        try {
-            tsdbStatement.getResultSetConcurrency();
-        } catch (SQLException e) {
-        }
-        try {
-            tsdbStatement.getResultSetType();
-        } catch (SQLException e) {
-        }
-        try {
-            tsdbStatement.getConnection();
-        } catch (SQLException e) {
-        }
-        try {
-            tsdbStatement.getMoreResults();
-        } catch (SQLException e) {
-        }
-        try {
-            tsdbStatement.getGeneratedKeys();
-        } catch (SQLException e) {
-        }
-        try {
-            tsdbStatement.executeUpdate(null, 0);
-        } catch (SQLException e) {
-        }
-        try {
-            tsdbStatement.executeUpdate(null, new int[]{0});
-        } catch (SQLException e) {
-        }
-        try {
-            tsdbStatement.executeUpdate(null, new String[]{"str1", "str2"});
-        } catch (SQLException e) {
-        }
-        try {
-            tsdbStatement.getResultSetHoldability();
-        } catch (SQLException e) {
-        }
-        try {
-            tsdbStatement.setPoolable(true);
-        } catch (SQLException e) {
-        }
-        try {
-            tsdbStatement.isPoolable();
-        } catch (SQLException e) {
-        }
-        try {
-            tsdbStatement.closeOnCompletion();
-        } catch (SQLException e) {
-        }
-        try {
-            tsdbStatement.isCloseOnCompletion();
-        } catch (SQLException e) {
-        }
    }
    @AfterClass
-    public static void close() throws Exception {
+    public static void close() {
-        if (!statement.isClosed()) {
+        try {
-            statement.executeUpdate("drop database if exists " + dbName);
+            statement.execute("drop database if exists " + dbName);
+            if (statement != null)
                statement.close();
+            if (connection != null)
                connection.close();
-            Thread.sleep(10);
+        } catch (SQLException e) {
+            e.printStackTrace();
        }
    }
 }
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/SubscribeTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/SubscribeTest.java
@@ -10,21 +10,18 @@ import java.sql.SQLException;
 import java.sql.Statement;
 import java.util.Properties;
-public class SubscribeTest extends BaseTest {
+public class SubscribeTest {
-    Connection connection = null;
+    Connection connection;
-    Statement statement = null;
+    Statement statement;
    String dbName = "test";
    String tName = "t0";
    String host = "localhost";
    String topic = "test";
    @Before
-    public void createDatabase() throws SQLException {
+    public void createDatabase() {
        try {
            Class.forName("com.taosdata.jdbc.TSDBDriver");
-        } catch (ClassNotFoundException e) {
-            return;
-        }
            Properties properties = new Properties();
            properties.setProperty(TSDBDriver.PROPERTY_KEY_HOST, host);
            properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
@@ -41,6 +38,10 @@ public class SubscribeTest extends BaseTest {
                String sql = "insert into " + dbName + "." + tName + " values (" + ts + ", " + (100 + i) + ", " + i + ")";
                statement.executeUpdate(sql);
            }
+        } catch (ClassNotFoundException | SQLException e) {
+            return;
+        }
    }
    @Test
@@ -79,10 +80,16 @@ public class SubscribeTest extends BaseTest {
    }
    @After
-    public void close() throws Exception {
+    public void close() {
+        try {
            statement.executeQuery("drop database " + dbName);
+            if (statement != null)
                statement.close();
+            if (connection != null)
                connection.close();
-        Thread.sleep(10);
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
    }
 }
\ No newline at end of file
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBDatabaseMetaDataTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBDatabaseMetaDataTest.java
@@ -6,37 +6,9 @@ import java.sql.*;
 import java.util.Properties;
 public class TSDBDatabaseMetaDataTest {
-    private TSDBDatabaseMetaData metaData;
    private static final String host = "127.0.0.1";
-    private Connection connection;
+    private static Connection connection;
+    private static TSDBDatabaseMetaData metaData;
-    @BeforeClass
-    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");
-            connection = DriverManager.getConnection("jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata", properties);
-            metaData = connection.getMetaData().unwrap(TSDBDatabaseMetaData.class);
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        } catch (SQLException e) {
-            e.printStackTrace();
-        }
-    }
-    @AfterClass
-    public void after() {
-        try {
-            if (connection != null)
-                connection.close();
-        } catch (SQLException e) {
-            e.printStackTrace();
-        }
-    }
    @Test
    public void unwrap() throws SQLException {
@@ -61,7 +33,7 @@ public class TSDBDatabaseMetaDataTest {
    @Test
    public void getURL() throws SQLException {
-        Assert.assertEquals("jdbc:TAOS://localhost:6030/?user=root&password=taosdata", metaData.getURL());
+        Assert.assertEquals("jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata", metaData.getURL());
    }
    @Test
@@ -975,4 +947,32 @@ public class TSDBDatabaseMetaDataTest {
    public void generatedKeyAlwaysReturned() throws SQLException {
        Assert.assertFalse(metaData.generatedKeyAlwaysReturned());
    }
+    @BeforeClass
+    public static void beforeClass() {
+        try {
+            Class.forName("com.taosdata.jdbc.TSDBDriver");
+            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");
+            connection = DriverManager.getConnection("jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata", properties);
+            metaData = connection.getMetaData().unwrap(TSDBDatabaseMetaData.class);
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+    @AfterClass
+    public static void afterClass() {
+        try {
+            if (connection != null)
+                connection.close();
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
 }
\ No newline at end of file
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBDriverTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBDriverTest.java
@@ -3,9 +3,6 @@ package com.taosdata.jdbc;
 import org.junit.BeforeClass;
 import org.junit.Test;
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStreamReader;
 import java.sql.*;
 import java.util.Properties;
@@ -27,54 +24,15 @@ public class TSDBDriverTest {
            "jdbc:TAOS://:/test",
            "jdbc:TAOS://localhost:0/?user=root&password=taosdata"
    };
-    private static boolean islibLoaded = false;
-    private static boolean isTaosdActived;
    private Connection conn;
-    @BeforeClass
-    public static void before() {
-        String osName = System.getProperty("os.name").toLowerCase();
-        if (!osName.equals("linux"))
-            return;
-        // try to load taos lib
-        try {
-            System.loadLibrary("taos");
-            islibLoaded = true;
-        } catch (UnsatisfiedLinkError error) {
-            System.out.println("load tdengine lib failed.");
-            error.printStackTrace();
-        }
-        // check taosd is activated
-        try {
-            String[] cmd = {"/bin/bash", "-c", "ps -ef | grep taosd | grep -v \"grep\""};
-            Process exec = Runtime.getRuntime().exec(cmd);
-            BufferedReader reader = new BufferedReader(new InputStreamReader(exec.getInputStream()));
-            int lineCnt = 0;
-            while (reader.readLine() != null) {
-                lineCnt++;
-            }
-            if (lineCnt > 0)
-                isTaosdActived = true;
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-        try {
-            Class.forName("com.taosdata.jdbc.TSDBDriver");
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        }
-    }
    @Test
    public void testConnectWithJdbcURL() {
        final String url = "jdbc:TAOS://localhost:6030/log?user=root&password=taosdata";
        try {
-            if (islibLoaded && isTaosdActived) {
            conn = DriverManager.getConnection(url);
            assertNotNull("failure - connection should not be null", conn);
-            }
        } catch (SQLException e) {
            e.printStackTrace();
            fail("failure - should not throw Exception");
@@ -89,10 +47,8 @@ public class TSDBDriverTest {
        connProps.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
        connProps.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
        try {
-            if (islibLoaded && isTaosdActived) {
            conn = DriverManager.getConnection(jdbcUrl, connProps);
            assertNotNull("failure - connection should not be null", conn);
-            }
        } catch (SQLException e) {
            e.printStackTrace();
            fail("failure - should not throw Exception");
@@ -107,10 +63,8 @@ public class TSDBDriverTest {
        connProps.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
        connProps.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
        try {
-            if (islibLoaded && isTaosdActived) {
            conn = DriverManager.getConnection(jdbcUrl, connProps);
            assertNotNull("failure - connection should not be null", conn);
-            }
        } catch (SQLException e) {
            e.printStackTrace();
            fail("failure - should not throw Exception");
@@ -207,4 +161,14 @@ public class TSDBDriverTest {
        assertNull("failure - getParentLogger should be be null", new TSDBDriver().getParentLogger());
    }
+    @BeforeClass
+    public static void before() {
+        try {
+            Class.forName("com.taosdata.jdbc.TSDBDriver");
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        }
+    }
 }
\ No newline at end of file
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBPreparedStatementTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBPreparedStatementTest.java
+package com.taosdata.jdbc;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+public class TSDBPreparedStatementTest {
+    private static final String host = "127.0.0.1";
+    private static Connection conn;
+    @Test
+    public void executeQuery() {
+    }
+    @Test
+    public void executeUpdate() {
+    }
+    @Test
+    public void setNull() {
+    }
+    @Test
+    public void setBoolean() {
+    }
+    @Test
+    public void setByte() {
+    }
+    @Test
+    public void setShort() {
+    }
+    @Test
+    public void setInt() {
+    }
+    @Test
+    public void setLong() {
+    }
+    @Test
+    public void setFloat() {
+    }
+    @Test
+    public void setDouble() {
+    }
+    @Test
+    public void setBigDecimal() {
+    }
+    @Test
+    public void setString() {
+    }
+    @Test
+    public void setBytes() {
+    }
+    @Test
+    public void setDate() {
+    }
+    @Test
+    public void setTime() {
+    }
+    @Test
+    public void setTimestamp() {
+    }
+    @Test
+    public void setAsciiStream() {
+    }
+    @Test
+    public void setUnicodeStream() {
+    }
+    @Test
+    public void setBinaryStream() {
+    }
+    @Test
+    public void clearParameters() {
+    }
+    @Test
+    public void setObject() {
+    }
+    @Test
+    public void execute() {
+    }
+    @Test
+    public void addBatch() {
+    }
+    @Test
+    public void setCharacterStream() {
+    }
+    @Test
+    public void setRef() {
+    }
+    @Test
+    public void setBlob() {
+    }
+    @Test
+    public void setClob() {
+    }
+    @Test
+    public void setArray() {
+    }
+    @Test
+    public void getMetaData() {
+    }
+    @Test
+    public void setURL() {
+    }
+    @Test
+    public void getParameterMetaData() {
+    }
+    @Test
+    public void setRowId() {
+    }
+    @Test
+    public void setNString() {
+    }
+    @Test
+    public void setNCharacterStream() {
+    }
+    @Test
+    public void setNClob() {
+    }
+    @Test
+    public void setSQLXML() {
+    }
+    @BeforeClass
+    public static void beforeClass() {
+        try {
+            Class.forName("com.taosdata.jdbc.rs.RestfulDriver");
+            conn = DriverManager.getConnection("jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata");
+        } catch (ClassNotFoundException | SQLException e) {
+            e.printStackTrace();
+        }
+    }
+    @AfterClass
+    public static void afterClass() {
+        try {
+            if (conn != null)
+                conn.close();
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+}
\ No newline at end of file
--- 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
 package com.taosdata.jdbc.cases;
-import com.taosdata.jdbc.lib.TSDBCommon;
+import com.taosdata.jdbc.TSDBDriver;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
-import java.sql.Connection;
+import java.sql.*;
-import java.sql.ResultSet;
+import java.util.Properties;
-import java.sql.SQLException;
-import java.sql.Statement;
 import java.util.Random;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -18,36 +16,51 @@ import static org.junit.Assert.assertEquals;
 public class BatchInsertTest {
-    static String host = "localhost";
+    static String host = "127.0.0.1";
    static String dbName = "test";
    static String stbName = "meters";
    static int numOfTables = 30;
    final static int numOfRecordsPerTable = 1000;
    static long ts = 1496732686000l;
    final static String tablePrefix = "t";
    private Connection connection;
    @Before
    public void before() {
        try {
-            connection = TSDBCommon.getConn(host);
+            Class.forName("com.taosdata.jdbc.TSDBDriver");
-            TSDBCommon.createDatabase(connection, dbName);
+            Properties properties = new Properties();
-            TSDBCommon.createStable(connection, stbName);
+            properties.setProperty(TSDBDriver.PROPERTY_KEY_HOST, host);
-            TSDBCommon.createTables(connection, numOfTables, stbName, tablePrefix);
+            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");
+            connection = DriverManager.getConnection("jdbc:TAOS://" + host + ":0/", properties);
+            Statement statement = connection.createStatement();
+            statement.executeUpdate("drop database if exists " + dbName);
+            statement.executeUpdate("create database if not exists " + dbName);
+            statement.executeUpdate("use " + dbName);
+            // create stable
+            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++) {
+                String loc = i % 2 == 0 ? "beijing" : "shanghai";
+                String createSubTalbesSql = "create table " + tablePrefix + i + " using " + stbName + " tags(" + i + ", '" + loc + "')";
+                statement.executeUpdate(createSubTalbesSql);
+            }
+            statement.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    @Test
-    public void testBatchInsert(){
+    public void testBatchInsert() {
        ExecutorService executorService = Executors.newFixedThreadPool(numOfTables);
        for (int i = 0; i < numOfTables; i++) {
            final int index = i;
-            executorService.execute(new Runnable() {
+            executorService.execute(() -> {
-                @Override
-                public void run() {
                try {
                    long startTime = System.currentTimeMillis();
                    Statement statement = connection.createStatement(); // get statement
@@ -69,7 +82,6 @@ public class BatchInsertTest {
                } catch (Exception e) {
                    e.printStackTrace();
                }
-                }
            });
        }
@@ -80,7 +92,7 @@ public class BatchInsertTest {
            e.printStackTrace();
        }
-        try{
+        try {
            Statement statement = connection.createStatement();
            ResultSet rs = statement.executeQuery("select * from meters");
            int num = 0;
@@ -89,7 +101,7 @@ public class BatchInsertTest {
            }
            assertEquals(num, numOfTables * numOfRecordsPerTable);
            rs.close();
-        }catch (Exception e){
+        } catch (Exception e) {
            e.printStackTrace();
        }
    }
@@ -102,7 +114,6 @@ public class BatchInsertTest {
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
 }
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/lib/TSDBCommon.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/lib/TSDBCommon.java
-package com.taosdata.jdbc.lib;
-import com.taosdata.jdbc.TSDBDriver;
-import java.sql.Connection;
-import java.sql.DriverManager;
-import java.sql.SQLException;
-import java.sql.Statement;
-import java.util.Properties;
-public class TSDBCommon {
-    public static Connection getConn(String host) throws SQLException, ClassNotFoundException {
-        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");
-        return DriverManager.getConnection("jdbc:TAOS://" + host + ":0/", properties);
-    }
-    public static void createDatabase(Connection connection, String dbName) throws SQLException {
-        Statement statement = connection.createStatement();
-        statement.executeUpdate("drop database if exists " + dbName);
-        statement.executeUpdate("create database if not exists " + dbName);
-        statement.executeUpdate("use " + dbName);
-        statement.close();
-    }
-    public static void createStable(Connection connection, String stbName) throws SQLException {
-        Statement statement = connection.createStatement();
-        String createTableSql = "create table " + stbName + "(ts timestamp, f1 int, f2 int, f3 int) tags(areaid int, loc binary(20))";
-        statement.executeUpdate(createTableSql);
-        statement.close();
-    }
-    public static void createTables(Connection connection, int numOfTables, String stbName,String tablePrefix) throws SQLException {
-        Statement statement = connection.createStatement();
-        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);
-        }
-        statement.close();
-    }
-}
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/AuthenticationTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/AuthenticationTest.java
@@ -8,6 +8,7 @@ import java.sql.*;
 public class AuthenticationTest {
    private static final String host = "127.0.0.1";
+    //    private static final String host = "master";
    private static final String user = "root";
    private static final String password = "123456";
    private Connection conn;

--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulJDBCTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulJDBCTest.java
@@ -10,23 +10,12 @@ import java.util.Random;
 public class RestfulJDBCTest {
    private static final String host = "127.0.0.1";
-    private Connection connection;
+    //    private static final String host = "master";
+    private static Connection connection;
-    @Before
+    private Random random = new Random(System.currentTimeMillis());
-    public void before() throws ClassNotFoundException, SQLException {
-        Class.forName("com.taosdata.jdbc.rs.RestfulDriver");
-        connection = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/restful_test?user=root&password=taosdata");
-    }
-    @After
-    public void after() throws SQLException {
-        if (connection != null)
-            connection.close();
-    }
    /**
-     * 查询所有log.log
+     * select * from log.log
     **/
    @Test
    public void testCase001() {
@@ -85,7 +74,6 @@ public class RestfulJDBCTest {
        }
    }
-    private Random random = new Random(System.currentTimeMillis());
    @Test
    public void testCase005() {
@@ -105,5 +93,50 @@ public class RestfulJDBCTest {
        }
    }
+    @Test
+    public void testCase006() {
+        try (Statement stmt = connection.createStatement()) {
+            ResultSet rs = stmt.executeQuery("select * from weather");
+            while (rs.next()) {
+                System.out.print("ts: " + rs.getTimestamp("ts"));
+                System.out.print(", temperature: " + rs.getString("temperature"));
+                System.out.print(", humidity: " + rs.getString("humidity"));
+                System.out.println(", location: " + rs.getString("location"));
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+    @Test
+    public void testCase007() {
+        try (Statement stmt = connection.createStatement()) {
+            ResultSet rs = stmt.executeQuery("select * from weather");
+            ResultSetMetaData meta = rs.getMetaData();
+            while (rs.next()) {
+                int columnCount = meta.getColumnCount();
+                for (int i = 1; i <= columnCount; i++) {
+                    String columnLabel = meta.getColumnLabel(i);
+                    String value = rs.getString(i);
+                    System.out.print(columnLabel + ": " + value + "\t");
+                }
+                System.out.println();
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+    @BeforeClass
+    public static void before() throws ClassNotFoundException, SQLException {
+        Class.forName("com.taosdata.jdbc.rs.RestfulDriver");
+        connection = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/restful_test?user=root&password=taosdata");
+    }
+    @AfterClass
+    public static void after() throws SQLException {
+        if (connection != null)
+            connection.close();
+    }
 }
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulResultSetMetaDataTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulResultSetMetaDataTest.java
+package com.taosdata.jdbc.rs;
+import org.junit.AfterClass;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import java.sql.*;
+public class RestfulResultSetMetaDataTest {
+    private static final String host = "127.0.0.1";
+//    private static final String host = "master";
+    private static Connection conn;
+    private static Statement stmt;
+    private static ResultSet rs;
+    private static ResultSetMetaData meta;
+    @Test
+    public void getColumnCount() throws SQLException {
+        Assert.assertEquals(10, meta.getColumnCount());
+    }
+    @Test
+    public void isAutoIncrement() throws SQLException {
+        Assert.assertFalse(meta.isAutoIncrement(1));
+        Assert.assertFalse(meta.isAutoIncrement(2));
+        Assert.assertFalse(meta.isAutoIncrement(3));
+        Assert.assertFalse(meta.isAutoIncrement(4));
+        Assert.assertFalse(meta.isAutoIncrement(5));
+        Assert.assertFalse(meta.isAutoIncrement(6));
+        Assert.assertFalse(meta.isAutoIncrement(7));
+        Assert.assertFalse(meta.isAutoIncrement(8));
+        Assert.assertFalse(meta.isAutoIncrement(9));
+        Assert.assertFalse(meta.isAutoIncrement(10));
+    }
+    @Test
+    public void isCaseSensitive() throws SQLException {
+        Assert.assertFalse(meta.isCaseSensitive(1));
+    }
+    @Test
+    public void isSearchable() throws SQLException {
+        Assert.assertTrue(meta.isSearchable(1));
+    }
+    @Test
+    public void isCurrency() throws SQLException {
+        Assert.assertFalse(meta.isCurrency(1));
+    }
+    @Test
+    public void isNullable() throws SQLException {
+        Assert.assertEquals(ResultSetMetaData.columnNoNulls, meta.isNullable(1));
+        Assert.assertEquals(ResultSetMetaData.columnNullable, meta.isNullable(2));
+        Assert.assertEquals(ResultSetMetaData.columnNullable, meta.isNullable(3));
+        Assert.assertEquals(ResultSetMetaData.columnNullable, meta.isNullable(4));
+        Assert.assertEquals(ResultSetMetaData.columnNullable, meta.isNullable(5));
+        Assert.assertEquals(ResultSetMetaData.columnNullable, meta.isNullable(6));
+        Assert.assertEquals(ResultSetMetaData.columnNullable, meta.isNullable(7));
+        Assert.assertEquals(ResultSetMetaData.columnNullable, meta.isNullable(8));
+        Assert.assertEquals(ResultSetMetaData.columnNullable, meta.isNullable(9));
+        Assert.assertEquals(ResultSetMetaData.columnNullable, meta.isNullable(10));
+    }
+    @Test
+    public void isSigned() throws SQLException {
+        Assert.assertFalse(meta.isSigned(1));
+    }
+    @Test
+    public void getColumnDisplaySize() throws SQLException {
+        Assert.assertEquals(64, meta.getColumnDisplaySize(10));
+    }
+    @Test
+    public void getColumnLabel() throws SQLException {
+        Assert.assertEquals("f1", meta.getColumnLabel(1));
+    }
+    @Test
+    public void getColumnName() throws SQLException {
+        Assert.assertEquals("f1", meta.getColumnName(1));
+    }
+    @Test
+    public void getSchemaName() throws SQLException {
+        Assert.assertEquals("", meta.getSchemaName(1));
+    }
+    @Test
+    public void getPrecision() throws SQLException {
+        Assert.assertEquals(0, meta.getPrecision(1));
+    }
+    @Test
+    public void getScale() throws SQLException {
+        Assert.assertEquals(0, meta.getScale(1));
+    }
+    @Test
+    public void getTableName() throws SQLException {
+        Assert.assertEquals("", meta.getTableName(1));
+    }
+    @Test
+    public void getCatalogName() throws SQLException {
+        Assert.assertEquals("restful_test", meta.getCatalogName(1));
+        Assert.assertEquals("restful_test", meta.getCatalogName(2));
+        Assert.assertEquals("restful_test", meta.getCatalogName(3));
+        Assert.assertEquals("restful_test", meta.getCatalogName(4));
+        Assert.assertEquals("restful_test", meta.getCatalogName(5));
+        Assert.assertEquals("restful_test", meta.getCatalogName(6));
+        Assert.assertEquals("restful_test", meta.getCatalogName(7));
+        Assert.assertEquals("restful_test", meta.getCatalogName(8));
+        Assert.assertEquals("restful_test", meta.getCatalogName(9));
+        Assert.assertEquals("restful_test", meta.getCatalogName(10));
+    }
+    @Test
+    public void getColumnType() throws SQLException {
+        Assert.assertEquals(Types.TIMESTAMP, meta.getColumnType(1));
+        Assert.assertEquals(Types.INTEGER, meta.getColumnType(2));
+        Assert.assertEquals(Types.BIGINT, meta.getColumnType(3));
+        Assert.assertEquals(Types.FLOAT, meta.getColumnType(4));
+        Assert.assertEquals(Types.DOUBLE, meta.getColumnType(5));
+        Assert.assertEquals(Types.BINARY, meta.getColumnType(6));
+        Assert.assertEquals(Types.SMALLINT, meta.getColumnType(7));
+        Assert.assertEquals(Types.TINYINT, meta.getColumnType(8));
+        Assert.assertEquals(Types.BOOLEAN, meta.getColumnType(9));
+        Assert.assertEquals(Types.NCHAR, meta.getColumnType(10));
+    }
+    @Test
+    public void getColumnTypeName() throws SQLException {
+        Assert.assertEquals("TIMESTAMP", meta.getColumnTypeName(1));
+        Assert.assertEquals("INT", meta.getColumnTypeName(2));
+        Assert.assertEquals("BIGINT", meta.getColumnTypeName(3));
+        Assert.assertEquals("FLOAT", meta.getColumnTypeName(4));
+        Assert.assertEquals("DOUBLE", meta.getColumnTypeName(5));
+        Assert.assertEquals("BINARY", meta.getColumnTypeName(6));
+        Assert.assertEquals("SMALLINT", meta.getColumnTypeName(7));
+        Assert.assertEquals("TINYINT", meta.getColumnTypeName(8));
+        Assert.assertEquals("BOOL", meta.getColumnTypeName(9));
+        Assert.assertEquals("NCHAR", meta.getColumnTypeName(10));
+    }
+    @Test
+    public void isReadOnly() throws SQLException {
+        Assert.assertTrue(meta.isReadOnly(1));
+    }
+    @Test
+    public void isWritable() throws SQLException {
+        Assert.assertFalse(meta.isWritable(1));
+    }
+    @Test
+    public void isDefinitelyWritable() throws SQLException {
+        Assert.assertFalse(meta.isDefinitelyWritable(1));
+    }
+    @Test
+    public void getColumnClassName() throws SQLException {
+        Assert.assertEquals(Timestamp.class.getName(), meta.getColumnClassName(1));
+        Assert.assertEquals(Integer.class.getName(), meta.getColumnClassName(2));
+        Assert.assertEquals(Long.class.getName(), meta.getColumnClassName(3));
+        Assert.assertEquals(Float.class.getName(), meta.getColumnClassName(4));
+        Assert.assertEquals(Double.class.getName(), meta.getColumnClassName(5));
+        Assert.assertEquals(String.class.getName(), meta.getColumnClassName(6));
+        Assert.assertEquals(Short.class.getName(), meta.getColumnClassName(7));
+        Assert.assertEquals(Short.class.getName(), meta.getColumnClassName(8));
+        Assert.assertEquals(Boolean.class.getName(), meta.getColumnClassName(9));
+        Assert.assertEquals(String.class.getName(), meta.getColumnClassName(10));
+    }
+    @Test
+    public void unwrap() throws SQLException {
+        Assert.assertNotNull(meta.unwrap(RestfulResultSetMetaData.class));
+    }
+    @Test
+    public void isWrapperFor() throws SQLException {
+        Assert.assertTrue(meta.isWrapperFor(RestfulResultSetMetaData.class));
+    }
+    @BeforeClass
+    public static void beforeClass() {
+        try {
+            Class.forName("com.taosdata.jdbc.rs.RestfulDriver");
+            conn = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/restful_test?user=root&password=taosdata");
+            stmt = conn.createStatement();
+            stmt.execute("create database if not exists restful_test");
+            stmt.execute("use restful_test");
+            stmt.execute("drop table if exists weather");
+            stmt.execute("create table if not exists weather(f1 timestamp, f2 int, f3 bigint, f4 float, f5 double, f6 binary(64), f7 smallint, f8 tinyint, f9 bool, f10 nchar(64))");
+            stmt.execute("insert into restful_test.weather values('2021-01-01 00:00:00.000', 1, 100, 3.1415, 3.1415926, 'abc', 10, 10, true, '涛思数据')");
+            rs = stmt.executeQuery("select * from restful_test.weather");
+            rs.next();
+            meta = rs.getMetaData();
+        } catch (ClassNotFoundException | SQLException e) {
+            e.printStackTrace();
+        }
+    }
+    @AfterClass
+    public static void afterClass() {
+        try {
+            if (rs != null)
+                rs.close();
+            if (stmt != null)
+                stmt.close();
+            if (conn != null)
+                conn.close();
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+}
\ No newline at end of file
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulResultSetTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulResultSetTest.java
+package com.taosdata.jdbc.rs;
+import org.junit.AfterClass;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import java.io.InputStream;
+import java.io.Reader;
+import java.math.BigDecimal;
+import java.sql.*;
+public class RestfulResultSetTest {
+    private static final String host = "127.0.0.1";
+//    private static final String host = "master";
+    private static Connection conn;
+    private static Statement stmt;
+    private static ResultSet rs;
+    @Test
+    public void wasNull() throws SQLException {
+        Assert.assertFalse(rs.wasNull());
+    }
+    @Test
+    public void getString() throws SQLException {
+        String f10 = rs.getString("f10");
+        Assert.assertEquals("涛思数据", f10);
+        f10 = rs.getString(10);
+        Assert.assertEquals("涛思数据", f10);
+    }
+    @Test
+    public void getBoolean() throws SQLException {
+        Boolean f9 = rs.getBoolean("f9");
+        Assert.assertEquals(true, f9);
+        f9 = rs.getBoolean(9);
+        Assert.assertEquals(true, f9);
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getByte() throws SQLException {
+        rs.getByte(1);
+    }
+    @Test
+    public void getShort() throws SQLException {
+        short f7 = rs.getShort("f7");
+        Assert.assertEquals(10, f7);
+        f7 = rs.getShort(7);
+        Assert.assertEquals(10, f7);
+    }
+    @Test
+    public void getInt() throws SQLException {
+        int f2 = rs.getInt("f2");
+        Assert.assertEquals(1, f2);
+        f2 = rs.getInt(2);
+        Assert.assertEquals(1, f2);
+    }
+    @Test
+    public void getLong() throws SQLException {
+        long f3 = rs.getLong("f3");
+        Assert.assertEquals(100, f3);
+        f3 = rs.getLong(3);
+        Assert.assertEquals(100, f3);
+    }
+    @Test
+    public void getFloat() throws SQLException {
+        float f4 = rs.getFloat("f4");
+        Assert.assertEquals(3.1415f, f4, 0f);
+        f4 = rs.getFloat(4);
+        Assert.assertEquals(3.1415f, f4, 0f);
+    }
+    @Test
+    public void getDouble() throws SQLException {
+        double f5 = rs.getDouble("f5");
+        Assert.assertEquals(3.1415926, f5, 0.0);
+        f5 = rs.getDouble(5);
+        Assert.assertEquals(3.1415926, f5, 0.0);
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getBigDecimal() throws SQLException {
+        rs.getBigDecimal("f1");
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getBytes() throws SQLException {
+        rs.getBytes("f1");
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getDate() throws SQLException {
+        rs.getDate("f1");
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getTime() throws SQLException {
+        rs.getTime("f1");
+    }
+    @Test
+    public void getTimestamp() throws SQLException {
+        Timestamp f1 = rs.getTimestamp("f1");
+        Assert.assertEquals("2021-01-01 00:00:00.0", f1.toString());
+        f1 = rs.getTimestamp(1);
+        Assert.assertEquals("2021-01-01 00:00:00.0", f1.toString());
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getAsciiStream() throws SQLException {
+        rs.getAsciiStream("f1");
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getUnicodeStream() throws SQLException {
+        rs.getUnicodeStream("f1");
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getBinaryStream() throws SQLException {
+        rs.getBinaryStream("f1");
+    }
+    @Test
+    public void getWarnings() throws SQLException {
+        Assert.assertNull(rs.getWarnings());
+    }
+    @Test
+    public void clearWarnings() throws SQLException {
+        rs.clearWarnings();
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getCursorName() throws SQLException {
+        rs.getCursorName();
+    }
+    @Test
+    public void getMetaData() throws SQLException {
+        ResultSetMetaData meta = rs.getMetaData();
+        Assert.assertNotNull(meta);
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getObject() throws SQLException {
+        rs.getObject("f1");
+    }
+    @Test(expected = SQLException.class)
+    public void findColumn() throws SQLException {
+        int columnIndex = rs.findColumn("f1");
+        Assert.assertEquals(1, columnIndex);
+        columnIndex = rs.findColumn("f2");
+        Assert.assertEquals(2, columnIndex);
+        columnIndex = rs.findColumn("f3");
+        Assert.assertEquals(3, columnIndex);
+        columnIndex = rs.findColumn("f4");
+        Assert.assertEquals(4, columnIndex);
+        columnIndex = rs.findColumn("f5");
+        Assert.assertEquals(5, columnIndex);
+        columnIndex = rs.findColumn("f6");
+        Assert.assertEquals(6, columnIndex);
+        columnIndex = rs.findColumn("f7");
+        Assert.assertEquals(7, columnIndex);
+        columnIndex = rs.findColumn("f8");
+        Assert.assertEquals(8, columnIndex);
+        columnIndex = rs.findColumn("f9");
+        Assert.assertEquals(9, columnIndex);
+        columnIndex = rs.findColumn("f10");
+        Assert.assertEquals(10, columnIndex);
+        rs.findColumn("f11");
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getCharacterStream() throws SQLException {
+        rs.getCharacterStream(1);
+    }
+    @Test
+    public void isBeforeFirst() throws SQLException {
+        Assert.assertFalse(rs.isBeforeFirst());
+        rs.beforeFirst();
+        Assert.assertTrue(rs.isBeforeFirst());
+        rs.next();
+    }
+    @Test
+    public void isAfterLast() throws SQLException {
+        Assert.assertFalse(rs.isAfterLast());
+    }
+    @Test
+    public void isFirst() throws SQLException {
+        Assert.assertTrue(rs.isFirst());
+    }
+    @Test
+    public void isLast() throws SQLException {
+        Assert.assertTrue(rs.isLast());
+    }
+    @Test
+    public void beforeFirst() throws SQLException {
+        rs.beforeFirst();
+        Assert.assertTrue(rs.isBeforeFirst());
+        rs.next();
+    }
+    @Test
+    public void afterLast() throws SQLException {
+        rs.afterLast();
+        Assert.assertTrue(rs.isAfterLast());
+        rs.first();
+    }
+    @Test
+    public void first() throws SQLException {
+        rs.first();
+        Assert.assertEquals("2021-01-01 00:00:00.0", rs.getTimestamp("f1").toString());
+    }
+    @Test
+    public void last() throws SQLException {
+        rs.last();
+        Assert.assertEquals("2021-01-01 00:00:00.0", rs.getTimestamp("f1").toString());
+    }
+    @Test
+    public void getRow() throws SQLException {
+        int row = rs.getRow();
+        Assert.assertEquals(1, row);
+        rs.beforeFirst();
+        row = rs.getRow();
+        Assert.assertEquals(0, row);
+        rs.first();
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void absolute() throws SQLException {
+        rs.absolute(-1);
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void relative() throws SQLException {
+        rs.relative(-1);
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void previous() throws SQLException {
+        rs.previous();
+    }
+    @Test(expected = SQLException.class)
+    public void setFetchDirection() throws SQLException {
+        rs.setFetchDirection(ResultSet.FETCH_FORWARD);
+        rs.setFetchDirection(ResultSet.FETCH_UNKNOWN);
+    }
+    @Test
+    public void getFetchDirection() throws SQLException {
+        Assert.assertEquals(ResultSet.FETCH_FORWARD, rs.getFetchDirection());
+    }
+    @Test(expected = SQLException.class)
+    public void setFetchSize() throws SQLException {
+        rs.setFetchSize(0);
+    }
+    @Test
+    public void getFetchSize() throws SQLException {
+        Assert.assertEquals(1, rs.getFetchSize());
+    }
+    @Test
+    public void getType() throws SQLException {
+        Assert.assertEquals(ResultSet.TYPE_FORWARD_ONLY, rs.getType());
+    }
+    @Test
+    public void getConcurrency() throws SQLException {
+        Assert.assertEquals(ResultSet.CONCUR_READ_ONLY, rs.getConcurrency());
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void rowUpdated() throws SQLException {
+        rs.rowUpdated();
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void rowInserted() throws SQLException {
+        rs.rowInserted();
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void rowDeleted() throws SQLException {
+        rs.rowDeleted();
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateNull() throws SQLException {
+        rs.updateNull("f1");
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateBoolean() throws SQLException {
+        rs.updateBoolean(1, false);
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateByte() throws SQLException {
+        rs.updateByte(1, new Byte("0"));
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateShort() throws SQLException {
+        rs.updateShort(1, new Short("0"));
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateInt() throws SQLException {
+        rs.updateInt(1, 1);
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateLong() throws SQLException {
+        rs.updateLong(1, 1l);
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateFloat() throws SQLException {
+        rs.updateFloat(1, 1f);
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateDouble() throws SQLException {
+        rs.updateDouble(1, 1.0);
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateBigDecimal() throws SQLException {
+        rs.updateBigDecimal(1, new BigDecimal(1));
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateString() throws SQLException {
+        rs.updateString(1, "abc");
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateBytes() throws SQLException {
+        rs.updateBytes(1, new byte[]{});
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateDate() throws SQLException {
+        rs.updateDate(1, new Date(System.currentTimeMillis()));
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateTime() throws SQLException {
+        rs.updateTime(1, new Time(System.currentTimeMillis()));
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateTimestamp() throws SQLException {
+        rs.updateTimestamp(1, new Timestamp(System.currentTimeMillis()));
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateAsciiStream() throws SQLException {
+        rs.updateAsciiStream(1, null);
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateBinaryStream() throws SQLException {
+        rs.updateBinaryStream(1, null);
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateCharacterStream() throws SQLException {
+        rs.updateCharacterStream(1, null);
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateObject() throws SQLException {
+        rs.updateObject(1, null);
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void insertRow() throws SQLException {
+        rs.insertRow();
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateRow() throws SQLException {
+        rs.updateRow();
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void deleteRow() throws SQLException {
+        rs.deleteRow();
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void refreshRow() throws SQLException {
+        rs.refreshRow();
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void cancelRowUpdates() throws SQLException {
+        rs.cancelRowUpdates();
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void moveToInsertRow() throws SQLException {
+        rs.moveToInsertRow();
+    }
+    @Test
+    public void getStatement() throws SQLException {
+        Statement stmt = rs.getStatement();
+        Assert.assertNotNull(stmt);
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void moveToCurrentRow() throws SQLException {
+        rs.moveToCurrentRow();
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getRef() throws SQLException {
+        rs.getRef(1);
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getBlob() throws SQLException {
+        rs.getBlob("f1");
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getClob() throws SQLException {
+        rs.getClob("f1");
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getArray() throws SQLException {
+        rs.getArray("f1");
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getURL() throws SQLException {
+        rs.getURL("f1");
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateRef() throws SQLException {
+        rs.updateRef("f1", null);
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateBlob() throws SQLException {
+        rs.updateBlob(1, (InputStream) null);
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateClob() throws SQLException {
+        rs.updateClob(1, (Reader) null);
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateArray() throws SQLException {
+        rs.updateArray(1, null);
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getRowId() throws SQLException {
+        rs.getRowId("f1");
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateRowId() throws SQLException {
+        rs.updateRowId(1, null);
+    }
+    @Test
+    public void getHoldability() throws SQLException {
+        Assert.assertEquals(ResultSet.HOLD_CURSORS_OVER_COMMIT, rs.getHoldability());
+    }
+    @Test
+    public void isClosed() throws SQLException {
+        Assert.assertFalse(rs.isClosed());
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateNString() throws SQLException {
+        rs.updateNString(1, null);
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateNClob() throws SQLException {
+        rs.updateNClob(1, (Reader) null);
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getNClob() throws SQLException {
+        rs.getNClob("f1");
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getSQLXML() throws SQLException {
+        rs.getSQLXML("f1");
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateSQLXML() throws SQLException {
+        rs.updateSQLXML(1, null);
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getNString() throws SQLException {
+        rs.getNString("f1");
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getNCharacterStream() throws SQLException {
+        rs.getNCharacterStream("f1");
+    }
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateNCharacterStream() throws SQLException {
+        rs.updateNCharacterStream(1, null);
+    }
+    @Test
+    public void unwrap() throws SQLException {
+        RestfulResultSet unwrap = rs.unwrap(RestfulResultSet.class);
+        Assert.assertNotNull(unwrap);
+    }
+    @Test
+    public void isWrapperFor() throws SQLException {
+        Assert.assertTrue(rs.isWrapperFor(RestfulResultSet.class));
+    }
+    @BeforeClass
+    public static void beforeClass() {
+        try {
+            Class.forName("com.taosdata.jdbc.rs.RestfulDriver");
+            conn = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/restful_test?user=root&password=taosdata");
+            stmt = conn.createStatement();
+            stmt.execute("create database if not exists restful_test");
+            stmt.execute("use restful_test");
+            stmt.execute("drop table if exists weather");
+            stmt.execute("create table if not exists weather(f1 timestamp, f2 int, f3 bigint, f4 float, f5 double, f6 binary(64), f7 smallint, f8 tinyint, f9 bool, f10 nchar(64))");
+            stmt.execute("insert into restful_test.weather values('2021-01-01 00:00:00.000', 1, 100, 3.1415, 3.1415926, 'abc', 10, 10, true, '涛思数据')");
+            rs = stmt.executeQuery("select * from restful_test.weather");
+            rs.next();
+        } catch (ClassNotFoundException | SQLException e) {
+            e.printStackTrace();
+        }
+    }
+    @AfterClass
+    public static void afterClass() {
+        try {
+            if (rs != null)
+                rs.close();
+            if (stmt != null)
+                stmt.close();
+            if (conn != null)
+                conn.close();
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+}
\ No newline at end of file
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/SQLTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/SQLTest.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/utils/SQLExecutor.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/utils/SQLExecutor.java
+package com.taosdata.jdbc.utils;
+import java.sql.*;
+public class SQLExecutor {
+    // insert, import
+    public static void executeUpdate(Connection connection, String sql) {
+        try (Statement statement = connection.createStatement()) {
+            long start = System.currentTimeMillis();
+            int affectedRows = statement.executeUpdate(sql);
+            long end = System.currentTimeMillis();
+            System.out.println("[ affected rows : " + affectedRows + " ] time cost: " + (end - start) + " ms, execute statement ====> " + sql);
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+    // show databases, show tables, show stables
+    public static void executeWithResult(Connection connection, String sql) {
+        try (Statement statement = connection.createStatement()) {
+            statement.execute(sql);
+            ResultSet resultSet = statement.getResultSet();
+            printResult(resultSet);
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+    // use database, create database, create table, drop table...
+    public static void execute(Connection connection, String sql) {
+        try (Statement statement = connection.createStatement()) {
+            long start = System.currentTimeMillis();
+            boolean execute = statement.execute(sql);
+            long end = System.currentTimeMillis();
+            printSql(sql, execute, (end - start));
+        } catch (SQLException e) {
+            System.out.println("ERROR execute SQL ===> " + sql);
+            e.printStackTrace();
+        }
+    }
+    // select
+    public static void executeQuery(Connection connection, String sql) {
+        try (Statement statement = connection.createStatement()) {
+            long start = System.currentTimeMillis();
+            ResultSet resultSet = statement.executeQuery(sql);
+            long end = System.currentTimeMillis();
+            printSql(sql, true, (end - start));
+            printResult(resultSet);
+        } catch (SQLException e) {
+            System.out.println("ERROR execute SQL ===> " + sql);
+            e.printStackTrace();
+        }
+    }
+    private static void printSql(String sql, boolean succeed, long cost) {
+        System.out.println("[ " + (succeed ? "OK" : "ERROR!") + " ] time cost: " + cost + " ms, execute statement ====> " + sql);
+    }
+    private static void printResult(ResultSet resultSet) throws SQLException {
+        ResultSetMetaData metaData = resultSet.getMetaData();
+        while (resultSet.next()) {
+            StringBuilder sb = new StringBuilder();
+            for (int i = 1; i <= metaData.getColumnCount(); i++) {
+                String columnLabel = metaData.getColumnLabel(i);
+                String value = resultSet.getString(i);
+                sb.append(columnLabel + ": " + value + "\t");
+            }
+            System.out.println(sb.toString());
+        }
+    }
+}
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/utils/SqlSyntaxValidatorTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/utils/SqlSyntaxValidatorTest.java
@@ -16,10 +16,6 @@ public class SqlSyntaxValidatorTest {
    @Test
    public void isUseSQL() {
        Assert.assertTrue(SqlSyntaxValidator.isUseSql("use database test"));
-        Assert.assertTrue(SqlSyntaxValidator.isUseSql("create database test"));
-        Assert.assertTrue(SqlSyntaxValidator.isUseSql("create database if not exist test"));
-        Assert.assertTrue(SqlSyntaxValidator.isUseSql("drop database test"));
-        Assert.assertTrue(SqlSyntaxValidator.isUseSql("drop database if exist test"));
    }
 }
\ No newline at end of file
--- a/src/cq/CMakeLists.txt
+++ b/src/cq/CMakeLists.txt
@@ -6,12 +6,10 @@ INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/client/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc)
 AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/src SRC)
-IF (TD_LINUX)
+ADD_LIBRARY(tcq ${SRC})
-  ADD_LIBRARY(tcq ${SRC})
+IF (TD_SOMODE_STATIC)
-  IF (TD_SOMODE_STATIC)
  TARGET_LINK_LIBRARIES(tcq tutil common taos_static)
-  ELSE ()  
+ELSE ()
  TARGET_LINK_LIBRARIES(tcq tutil common taos)
-  ENDIF ()
-  ADD_SUBDIRECTORY(test)
 ENDIF ()
+ADD_SUBDIRECTORY(test)
--- a/src/cq/src/cqMain.c
+++ b/src/cq/src/cqMain.c
@@ -343,7 +343,7 @@ static void cqProcessStreamRes(void *param, TAOS_RES *tres, TAOS_ROW row) {
      char buf[TSDB_MAX_NCHAR_LEN];
      int32_t len = taos_fetch_lengths(tres)[i];
      taosMbsToUcs4(val, len, buf, sizeof(buf), &len);
-      memcpy(val + sizeof(VarDataLenT), buf, len);
+      memcpy((char *)val + sizeof(VarDataLenT), buf, len);
      varDataLen(val) = len;
    }
    tdAppendColVal(trow, val, c->type, c->bytes, c->offset);

--- a/src/cq/test/CMakeLists.txt
+++ b/src/cq/test/CMakeLists.txt
@@ -3,4 +3,4 @@ PROJECT(TDengine)
 LIST(APPEND CQTEST_SRC ./cqtest.c)
 ADD_EXECUTABLE(cqtest ${CQTEST_SRC})
-TARGET_LINK_LIBRARIES(cqtest tcq)
+TARGET_LINK_LIBRARIES(cqtest tcq taos_static)
--- a/src/dnode/CMakeLists.txt
+++ b/src/dnode/CMakeLists.txt
@@ -10,31 +10,30 @@ INCLUDE_DIRECTORIES(${TD_ENTERPRISE_DIR}/src/inc)
 INCLUDE_DIRECTORIES(inc)
 AUX_SOURCE_DIRECTORY(src SRC)
-IF (TD_LINUX)
+ADD_EXECUTABLE(taosd ${SRC})
-  ADD_EXECUTABLE(taosd ${SRC})
+TARGET_LINK_LIBRARIES(taosd mnode monitor http tsdb twal vnode cJson lz4 balance sync)
-  TARGET_LINK_LIBRARIES(taosd mnode monitor http tsdb twal vnode cJson lz4 balance sync)
-  IF (TD_SOMODE_STATIC)
+IF (TD_SOMODE_STATIC)
  TARGET_LINK_LIBRARIES(taosd taos_static)
-  ELSE ()
+ELSE ()
  TARGET_LINK_LIBRARIES(taosd taos)
-  ENDIF ()
+ENDIF ()
-  IF (TD_ACCOUNT)
+IF (TD_ACCOUNT)
  TARGET_LINK_LIBRARIES(taosd account)
-  ENDIF ()
+ENDIF ()
-  IF (TD_GRANT)
+IF (TD_GRANT)
  TARGET_LINK_LIBRARIES(taosd grant)
-  ENDIF ()
+ENDIF ()
-  IF (TD_MQTT)
+IF ((TD_LINUX OR TD_WINDOWS) AND TD_MQTT)
  TARGET_LINK_LIBRARIES(taosd mqtt)
-  ENDIF ()
+ENDIF ()
-  SET(PREPARE_ENV_CMD "prepare_env_cmd")
+SET(PREPARE_ENV_CMD "prepare_env_cmd")
-  SET(PREPARE_ENV_TARGET "prepare_env_target")
+SET(PREPARE_ENV_TARGET "prepare_env_target")
-  ADD_CUSTOM_COMMAND(OUTPUT ${PREPARE_ENV_CMD}
+ADD_CUSTOM_COMMAND(OUTPUT ${PREPARE_ENV_CMD}
    POST_BUILD
    COMMAND echo "make test directory"
    DEPENDS taosd
@@ -45,5 +44,4 @@ IF (TD_LINUX)
    COMMAND ${CMAKE_COMMAND} -E echo logDir ${TD_TESTS_OUTPUT_DIR}/log  >> ${TD_TESTS_OUTPUT_DIR}/cfg/taos.cfg
    COMMAND ${CMAKE_COMMAND} -E echo charset UTF-8  >> ${TD_TESTS_OUTPUT_DIR}/cfg/taos.cfg
    COMMENT "prepare taosd environment")
-  ADD_CUSTOM_TARGET(${PREPARE_ENV_TARGET} ALL WORKING_DIRECTORY ${TD_EXECUTABLE_OUTPUT_PATH} DEPENDS ${PREPARE_ENV_CMD})
+ADD_CUSTOM_TARGET(${PREPARE_ENV_TARGET} ALL WORKING_DIRECTORY ${TD_EXECUTABLE_OUTPUT_PATH} DEPENDS ${PREPARE_ENV_CMD})
-ENDIF ()
--- a/src/dnode/src/dnodeCfg.c
+++ b/src/dnode/src/dnodeCfg.c
@@ -97,7 +97,7 @@ static int32_t dnodeReadCfg() {
    goto PARSE_CFG_OVER;
  }
-  len = fread(content, 1, maxLen, fp);
+  len = (int32_t)fread(content, 1, maxLen, fp);
  if (len <= 0) {
    dError("failed to read %s, content is null", file);
    goto PARSE_CFG_OVER;
@@ -115,7 +115,7 @@ static int32_t dnodeReadCfg() {
    dError("failed to read %s, dnodeId not found", file);
    goto PARSE_CFG_OVER;
  }
-  cfg.dnodeId = dnodeId->valueint;
+  cfg.dnodeId = (int32_t)dnodeId->valueint;
  cJSON *clusterId = cJSON_GetObjectItem(root, "clusterId");
  if (!clusterId || clusterId->type != cJSON_String) {

--- a/src/dnode/src/dnodeCheck.c
+++ b/src/dnode/src/dnodeCheck.c
--- a/src/dnode/src/dnodeEps.c
+++ b/src/dnode/src/dnodeEps.c
--- a/src/dnode/src/dnodeMInfos.c
+++ b/src/dnode/src/dnodeMInfos.c
--- a/src/dnode/src/dnodeMPeer.c
+++ b/src/dnode/src/dnodeMPeer.c
--- a/src/dnode/src/dnodeMRead.c
+++ b/src/dnode/src/dnodeMRead.c
--- a/src/dnode/src/dnodeMWrite.c
+++ b/src/dnode/src/dnodeMWrite.c
--- a/src/dnode/src/dnodePeer.c
+++ b/src/dnode/src/dnodePeer.c
@@ -90,7 +90,10 @@ static void dnodeProcessReqMsgFromDnode(SRpcMsg *pMsg, SRpcEpSet *pEpSet) {
  };
  if (pMsg->pCont == NULL) return;
-  if (pMsg->msgType == TSDB_MSG_TYPE_NETWORK_TEST) return dnodeSendStartupStep(pMsg);
+  if (pMsg->msgType == TSDB_MSG_TYPE_NETWORK_TEST) {
+    dnodeSendStartupStep(pMsg);
+    return;
+  }
  if (dnodeGetRunStatus() != TSDB_RUN_STATUS_RUNING) {
    rspMsg.code = TSDB_CODE_APP_NOT_READY;

--- a/src/dnode/src/dnodeShell.c
+++ b/src/dnode/src/dnodeShell.c
--- a/src/dnode/src/dnodeStep.c
+++ b/src/dnode/src/dnodeStep.c
--- a/src/dnode/src/dnodeSystem.c
+++ b/src/dnode/src/dnodeSystem.c
--- a/src/dnode/src/dnodeTelemetry.c
+++ b/src/dnode/src/dnodeTelemetry.c
--- a/src/dnode/src/dnodeVWrite.c
+++ b/src/dnode/src/dnodeVWrite.c
--- a/src/dnode/src/dnodeVnodes.c
+++ b/src/dnode/src/dnodeVnodes.c
--- a/src/inc/taosdef.h
+++ b/src/inc/taosdef.h
--- a/src/inc/taoserror.h
+++ b/src/inc/taoserror.h
--- a/src/kit/shell/CMakeLists.txt
+++ b/src/kit/shell/CMakeLists.txt
--- a/src/kit/shell/src/shellDarwin.c
+++ b/src/kit/shell/src/shellDarwin.c
--- a/src/kit/shell/src/shellLinux.c
+++ b/src/kit/shell/src/shellLinux.c
--- a/src/kit/shell/src/shellMain.c
+++ b/src/kit/shell/src/shellMain.c
--- a/src/kit/shell/src/shellWindows.c
+++ b/src/kit/shell/src/shellWindows.c
--- a/src/kit/taosdemo/CMakeLists.txt
+++ b/src/kit/taosdemo/CMakeLists.txt
--- a/src/kit/taosdemox/CMakeLists.txt
+++ b/src/kit/taosdemox/CMakeLists.txt
--- a/src/kit/taosdump/CMakeLists.txt
+++ b/src/kit/taosdump/CMakeLists.txt
--- a/src/mnode/CMakeLists.txt
+++ b/src/mnode/CMakeLists.txt
--- a/src/mnode/src/mnodeAcct.c
+++ b/src/mnode/src/mnodeAcct.c
--- a/src/mnode/src/mnodeCluster.c
+++ b/src/mnode/src/mnodeCluster.c
--- a/src/mnode/src/mnodeDb.c
+++ b/src/mnode/src/mnodeDb.c
--- a/src/mnode/src/mnodeDnode.c
+++ b/src/mnode/src/mnodeDnode.c
--- a/src/mnode/src/mnodeMnode.c
+++ b/src/mnode/src/mnodeMnode.c
--- a/src/mnode/src/mnodeSdb.c
+++ b/src/mnode/src/mnodeSdb.c
--- a/src/mnode/src/mnodeShow.c
+++ b/src/mnode/src/mnodeShow.c
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
--- a/src/mnode/src/mnodeUser.c
+++ b/src/mnode/src/mnodeUser.c
--- a/src/mnode/src/mnodeVgroup.c
+++ b/src/mnode/src/mnodeVgroup.c
--- a/src/os/inc/eok.h
+++ b/src/os/inc/eok.h
--- a/src/os/inc/os.h
+++ b/src/os/inc/os.h
--- a/src/os/inc/osDarwin.h
+++ b/src/os/inc/osDarwin.h
--- a/src/os/inc/osDef.h
+++ b/src/os/inc/osDef.h
--- a/src/os/inc/osFile.h
+++ b/src/os/inc/osFile.h
--- a/src/os/inc/osSignal.h
+++ b/src/os/inc/osSignal.h
--- a/src/os/inc/osSocket.h
+++ b/src/os/inc/osSocket.h
--- a/src/os/inc/osWindows.h
+++ b/src/os/inc/osWindows.h
--- a/src/os/src/darwin/darwinEnv.c
+++ b/src/os/src/darwin/darwinEnv.c
--- a/src/os/src/darwin/darwinFile.c
+++ b/src/os/src/darwin/darwinFile.c
--- a/src/os/src/darwin/darwinSemphone.c
+++ b/src/os/src/darwin/darwinSemphone.c
--- a/src/os/src/darwin/darwinSysInfo.c
+++ b/src/os/src/darwin/darwinSysInfo.c
--- a/src/os/src/darwin/darwinTimer.c
+++ b/src/os/src/darwin/darwinTimer.c
--- a/src/os/src/darwin/eok.c
+++ b/src/os/src/darwin/eok.c
--- a/src/os/src/detail/CMakeLists.txt
+++ b/src/os/src/detail/CMakeLists.txt
--- a/src/os/src/detail/osDir.c
+++ b/src/os/src/detail/osDir.c
--- a/src/os/src/detail/osFile.c
+++ b/src/os/src/detail/osFile.c
--- a/src/os/src/detail/osSignal.c
+++ b/src/os/src/detail/osSignal.c
--- a/src/os/src/detail/osSocket.c
+++ b/src/os/src/detail/osSocket.c
--- a/src/os/src/detail/osSysinfo.c
+++ b/src/os/src/detail/osSysinfo.c
--- a/src/os/src/detail/osTime.c
+++ b/src/os/src/detail/osTime.c
--- a/src/os/src/detail/osTimer.c
+++ b/src/os/src/detail/osTimer.c
--- a/src/os/src/linux/linuxEnv.c
+++ b/src/os/src/linux/linuxEnv.c
--- a/src/os/src/windows/wFile.c
+++ b/src/os/src/windows/wFile.c
--- a/src/os/src/windows/wSignal.c
+++ b/src/os/src/windows/wSignal.c
--- a/src/os/src/windows/wSocket.c
+++ b/src/os/src/windows/wSocket.c
--- a/src/os/src/windows/wSysLog.c
+++ b/src/os/src/windows/wSysLog.c
--- a/src/os/src/windows/wSysinfo.c
+++ b/src/os/src/windows/wSysinfo.c
--- a/src/plugins/CMakeLists.txt
+++ b/src/plugins/CMakeLists.txt
--- a/src/plugins/http/CMakeLists.txt
+++ b/src/plugins/http/CMakeLists.txt
--- a/src/plugins/http/inc/httpContext.h
+++ b/src/plugins/http/inc/httpContext.h
--- a/src/plugins/http/inc/httpInt.h
+++ b/src/plugins/http/inc/httpInt.h
--- a/src/plugins/http/inc/httpUtil.h
+++ b/src/plugins/http/inc/httpUtil.h
--- a/src/plugins/http/src/httpAuth.c
+++ b/src/plugins/http/src/httpAuth.c
--- a/src/plugins/http/src/httpContext.c
+++ b/src/plugins/http/src/httpContext.c
--- a/src/plugins/http/src/httpGcHandle.c
+++ b/src/plugins/http/src/httpGcHandle.c
--- a/src/plugins/http/src/httpGcJson.c
+++ b/src/plugins/http/src/httpGcJson.c
--- a/src/plugins/http/src/httpGzip.c
+++ b/src/plugins/http/src/httpGzip.c
--- a/src/plugins/http/src/httpHandle.c
+++ b/src/plugins/http/src/httpHandle.c
--- a/src/plugins/http/src/httpJson.c
+++ b/src/plugins/http/src/httpJson.c
--- a/src/plugins/http/src/httpParser.c
+++ b/src/plugins/http/src/httpParser.c
--- a/src/plugins/http/src/httpQueue.c
+++ b/src/plugins/http/src/httpQueue.c
--- a/src/plugins/http/src/httpResp.c
+++ b/src/plugins/http/src/httpResp.c
--- a/src/plugins/http/src/httpRestHandle.c
+++ b/src/plugins/http/src/httpRestHandle.c
--- a/src/plugins/http/src/httpRestJson.c
+++ b/src/plugins/http/src/httpRestJson.c
--- a/src/plugins/http/src/httpServer.c
+++ b/src/plugins/http/src/httpServer.c
--- a/src/plugins/http/src/httpSession.c
+++ b/src/plugins/http/src/httpSession.c
--- a/src/plugins/http/src/httpSql.c
+++ b/src/plugins/http/src/httpSql.c
--- a/src/plugins/http/src/httpSystem.c
+++ b/src/plugins/http/src/httpSystem.c
--- a/src/plugins/http/src/httpTgHandle.c
+++ b/src/plugins/http/src/httpTgHandle.c
--- a/src/plugins/http/src/httpUtil.c
+++ b/src/plugins/http/src/httpUtil.c
--- a/src/plugins/monitor/CMakeLists.txt
+++ b/src/plugins/monitor/CMakeLists.txt
--- a/src/plugins/monitor/src/monMain.c
+++ b/src/plugins/monitor/src/monMain.c
--- a/src/plugins/mqtt/CMakeLists.txt
+++ b/src/plugins/mqtt/CMakeLists.txt
--- a/src/query/CMakeLists.txt
+++ b/src/query/CMakeLists.txt
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
--- a/src/query/src/qTsbuf.c
+++ b/src/query/src/qTsbuf.c
--- a/src/rpc/src/rpcTcp.c
+++ b/src/rpc/src/rpcTcp.c
--- a/src/rpc/src/rpcUdp.c
+++ b/src/rpc/src/rpcUdp.c
--- a/src/rpc/test/CMakeLists.txt
+++ b/src/rpc/test/CMakeLists.txt
--- a/src/sync/CMakeLists.txt
+++ b/src/sync/CMakeLists.txt
--- a/src/sync/inc/syncInt.h
+++ b/src/sync/inc/syncInt.h
--- a/src/sync/inc/syncMsg.h
+++ b/src/sync/inc/syncMsg.h
--- a/src/sync/inc/syncTcp.h
+++ b/src/sync/inc/syncTcp.h
--- a/src/sync/src/syncArbitrator.c
+++ b/src/sync/src/syncArbitrator.c
--- a/src/sync/src/syncMain.c
+++ b/src/sync/src/syncMain.c
--- a/src/sync/src/syncMsg.c
+++ b/src/sync/src/syncMsg.c
--- a/src/sync/src/syncRestore.c
+++ b/src/sync/src/syncRestore.c
--- a/src/sync/src/syncRetrieve.c
+++ b/src/sync/src/syncRetrieve.c
--- a/src/sync/src/syncTcp.c
+++ b/src/sync/src/syncTcp.c
--- a/src/sync/test/CMakeLists.txt
+++ b/src/sync/test/CMakeLists.txt
--- a/src/tsdb/inc/tsdbMain.h
+++ b/src/tsdb/inc/tsdbMain.h
--- a/src/tsdb/src/tsdbCommit.c
+++ b/src/tsdb/src/tsdbCommit.c
--- a/src/tsdb/src/tsdbFile.c
+++ b/src/tsdb/src/tsdbFile.c
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
--- a/src/tsdb/src/tsdbMemTable.c
+++ b/src/tsdb/src/tsdbMemTable.c
--- a/src/util/CMakeLists.txt
+++ b/src/util/CMakeLists.txt
--- a/src/util/inc/tsocket.h
+++ b/src/util/inc/tsocket.h
--- a/src/util/src/tfile.c
+++ b/src/util/src/tfile.c
--- a/src/util/src/tkvstore.c
+++ b/src/util/src/tkvstore.c
--- a/src/util/src/tnettest.c
+++ b/src/util/src/tnettest.c
--- a/src/util/src/tsocket.c
+++ b/src/util/src/tsocket.c
--- a/src/vnode/CMakeLists.txt
+++ b/src/vnode/CMakeLists.txt
--- a/src/vnode/src/vnodeCfg.c
+++ b/src/vnode/src/vnodeCfg.c
--- a/src/vnode/src/vnodeVersion.c
+++ b/src/vnode/src/vnodeVersion.c
--- a/src/vnode/src/vnodeWorker.c
+++ b/src/vnode/src/vnodeWorker.c
--- a/src/vnode/src/vnodeWrite.c
+++ b/src/vnode/src/vnodeWrite.c
--- a/src/wal/CMakeLists.txt
+++ b/src/wal/CMakeLists.txt
--- a/src/wal/src/walMgmt.c
+++ b/src/wal/src/walMgmt.c
--- a/src/wal/src/walWrite.c
+++ b/src/wal/src/walWrite.c
--- a/src/wal/test/CMakeLists.txt
+++ b/src/wal/test/CMakeLists.txt
--- a/tests/comparisonTest/tdengine/CMakeLists.txt
+++ b/tests/comparisonTest/tdengine/CMakeLists.txt
--- a/tests/examples/JDBC/JDBCDemo/pom.xml
+++ b/tests/examples/JDBC/JDBCDemo/pom.xml
--- a/tests/examples/JDBC/JDBCDemo/readme.md
+++ b/tests/examples/JDBC/JDBCDemo/readme.md
--- a/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/JDBCDemo.java
+++ b/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/JDBCDemo.java
--- a/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/JdbcRestfulDemo.java
+++ b/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/JdbcRestfulDemo.java
--- a/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/SubscribeDemo.java
+++ b/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/SubscribeDemo.java
--- a/tests/examples/JDBC/calciteDemo/pom.xml
+++ b/tests/examples/JDBC/calciteDemo/pom.xml
--- a/tests/examples/JDBC/calciteDemo/src/main/java/com/taosdata/example/calcite/CalciteDemo.java
+++ b/tests/examples/JDBC/calciteDemo/src/main/java/com/taosdata/example/calcite/CalciteDemo.java
--- a/tests/examples/JDBC/calciteDemo/src/main/resources/log4j.properties
+++ b/tests/examples/JDBC/calciteDemo/src/main/resources/log4j.properties
--- a/tests/examples/JDBC/connectionPools/README-cn.md
+++ b/tests/examples/JDBC/connectionPools/README-cn.md
--- a/tests/examples/JDBC/connectionPools/pom.xml
+++ b/tests/examples/JDBC/connectionPools/pom.xml
--- a/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/demo/ConnectionPoolDemo.java
+++ b/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/demo/ConnectionPoolDemo.java
--- a/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/demo/common/InsertTask.java
+++ b/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/demo/common/InsertTask.java
--- a/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/demo/pool/C3p0Builder.java
+++ b/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/demo/pool/C3p0Builder.java
--- a/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/demo/pool/DbcpBuilder.java
+++ b/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/demo/pool/DbcpBuilder.java
--- a/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/demo/pool/DruidPoolBuilder.java
+++ b/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/demo/pool/DruidPoolBuilder.java
--- a/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/demo/pool/HikariCpBuilder.java
+++ b/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/demo/pool/HikariCpBuilder.java
--- a/tests/examples/JDBC/mybatisplus-demo/pom.xml
+++ b/tests/examples/JDBC/mybatisplus-demo/pom.xml
--- a/tests/examples/JDBC/mybatisplus-demo/src/main/resources/application.yml
+++ b/tests/examples/JDBC/mybatisplus-demo/src/main/resources/application.yml
--- a/tests/examples/JDBC/springbootdemo/pom.xml
+++ b/tests/examples/JDBC/springbootdemo/pom.xml
--- a/tests/examples/JDBC/springbootdemo/readme.md
+++ b/tests/examples/JDBC/springbootdemo/readme.md
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/SpringbootdemoApplication.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/SpringbootdemoApplication.java
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/controller/WeatherController.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/controller/WeatherController.java
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/dao/WeatherMapper.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/dao/WeatherMapper.java
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/dao/WeatherMapper.xml
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/dao/WeatherMapper.xml
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/domain/Weather.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/domain/Weather.java
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/service/WeatherService.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/service/WeatherService.java
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/controller/RainStationController.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/controller/RainStationController.java
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/dao/DatabaseMapper.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/dao/DatabaseMapper.java
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/dao/DatabaseMapper.xml
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/dao/DatabaseMapper.xml
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/dao/RainfallMapper.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/dao/RainfallMapper.java
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/dao/RainfallMapper.xml
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/dao/RainfallMapper.xml
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/dao/TableMapper.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/dao/TableMapper.java
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/dao/TableMapper.xml
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/dao/TableMapper.xml
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/domain/FieldMetadata.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/domain/FieldMetadata.java
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/domain/Rainfall.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/domain/Rainfall.java
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/domain/TableMetadata.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/domain/TableMetadata.java
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/domain/TagMetadata.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/domain/TagMetadata.java
--- a/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/service/RainStationService.java
+++ b/tests/examples/JDBC/springbootdemo/src/main/java/com/taosdata/jdbc/springbootdemo/service/RainStationService.java
--- a/tests/examples/JDBC/springbootdemo/src/main/resources/application.properties
+++ b/tests/examples/JDBC/springbootdemo/src/main/resources/application.properties
--- a/tests/examples/JDBC/springbootdemo/src/test/java/com/taosdata/jdbc/springbootdemo/SpringbootdemoApplicationTests.java
+++ b/tests/examples/JDBC/springbootdemo/src/test/java/com/taosdata/jdbc/springbootdemo/SpringbootdemoApplicationTests.java
--- a/tests/examples/JDBC/taosdemo/pom.xml
+++ b/tests/examples/JDBC/taosdemo/pom.xml
--- a/tests/examples/c/CMakeLists.txt
+++ b/tests/examples/c/CMakeLists.txt
--- a/tests/examples/c/demo.c
+++ b/tests/examples/c/demo.c
--- a/tests/examples/c/epoll.c
+++ b/tests/examples/c/epoll.c
--- a/tests/pytest/cluster/clusterEnvSetup/basic.py
+++ b/tests/pytest/cluster/clusterEnvSetup/basic.py
--- a/tests/pytest/cluster/clusterEnvSetup/buildClusterEnv.sh
+++ b/tests/pytest/cluster/clusterEnvSetup/buildClusterEnv.sh
--- a/tests/pytest/cluster/clusterEnvSetup/docker-compose.yml
+++ b/tests/pytest/cluster/clusterEnvSetup/docker-compose.yml
--- a/tests/pytest/insert/unsigenedTinyint.py
+++ b/tests/pytest/insert/unsigenedTinyint.py
--- a/tests/pytest/multilevel/fileDistributionSameLevel.py
+++ b/tests/pytest/multilevel/fileDistributionSameLevel.py
--- a/tests/pytest/multilevel/threeLevelMountPoint.py
+++ b/tests/pytest/multilevel/threeLevelMountPoint.py
--- a/tests/pytest/stream/stream3.py
+++ b/tests/pytest/stream/stream3.py
--- a/tests/pytest/util/sql.py
+++ b/tests/pytest/util/sql.py
--- a/tests/script/general/http/grafana.sim
+++ b/tests/script/general/http/grafana.sim
--- a/tests/script/general/http/restful.sim
+++ b/tests/script/general/http/restful.sim
--- a/tests/script/general/http/restful_full.sim
+++ b/tests/script/general/http/restful_full.sim
--- a/tests/script/jenkins/basic.txt
+++ b/tests/script/jenkins/basic.txt
--- a/tests/script/jenkins/basic_1.txt
+++ b/tests/script/jenkins/basic_1.txt
--- a/tests/script/jenkins/basic_2.txt
+++ b/tests/script/jenkins/basic_2.txt
--- a/tests/script/jenkins/wbasic.txt
+++ b/tests/script/jenkins/wbasic.txt
--- a/tests/script/sh/cfg.bat
+++ b/tests/script/sh/cfg.bat
--- a/tests/script/sh/deploy.bat
+++ b/tests/script/sh/deploy.bat
--- a/tests/script/sh/exec.bat
+++ b/tests/script/sh/exec.bat
--- a/tests/script/sh/stop_dnodes.bat
+++ b/tests/script/sh/stop_dnodes.bat
--- a/tests/script/unique/http/admin.sim
+++ b/tests/script/unique/http/admin.sim
--- a/tests/script/wtest.bat
+++ b/tests/script/wtest.bat
--- a/tests/tsim/src/simExe.c
+++ b/tests/tsim/src/simExe.c
--- a/tests/tsim/src/simMain.c
+++ b/tests/tsim/src/simMain.c
--- a/tests/tsim/src/simSystem.c
+++ b/tests/tsim/src/simSystem.c