Merge remote-tracking branch 'upstream/develop' into mac

2021-01-17 00:51:26 +08:00 · 2021-01-17 00:51:26 +08:00 · 0759bbb2a6
parent 985de78208 9a140c2db9
commit 0759bbb2a6
171 changed files with 3362 additions and 1287 deletions
--- a/.travis.yml
+++ b/.travis.yml
@ -34,6 +34,7 @@ matrix:
          - psmisc
          - unixodbc
          - unixodbc-dev
+          - mono-complete

    before_script:
      - export TZ=Asia/Harbin
@ -59,6 +60,18 @@ matrix:
          pip3 install guppy3
          pip3 install --user ${TRAVIS_BUILD_DIR}/src/connector/python/linux/python3/

+          cd ${TRAVIS_BUILD_DIR}/tests/examples/C#/taosdemo
+          mcs -out:taosdemo *.cs || travis_terminate $?
+          pkill -TERM -x taosd
+          fuser -k -n tcp 6030
+          sleep 1
+          ${TRAVIS_BUILD_DIR}/debug/build/bin/taosd -c ${TRAVIS_BUILD_DIR}/debug/test/cfg > /dev/null &
+          sleep 5
+          mono taosdemo -Q DEFAULT -y || travis_terminate $?
+          pkill -KILL -x taosd
+          fuser -k -n tcp 6030
+          sleep 1
+
          cd ${TRAVIS_BUILD_DIR}/tests
          ./test-all.sh smoke || travis_terminate $?
          sleep 1
@ -74,6 +87,7 @@ matrix:
          ./valgrind-test.sh 2>&1 > mem-error-out.log
          sleep 1

+
          # Color setting
          RED='\033[0;31m'
          GREEN='\033[1;32m'
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 IF (CMAKE_VERSION VERSION_LESS 3.0)
  PROJECT(TDengine CXX)
  SET(PROJECT_VERSION_MAJOR "${LIB_MAJOR_VERSION}")
--- 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.15-dist.jar DESTINATION connector/jdbc)
+    INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.16-dist.jar DESTINATION connector/jdbc)
  ENDIF ()
 ELSEIF (TD_DARWIN)
  SET(TD_MAKE_INSTALL_SH "${TD_COMMUNITY_DIR}/packaging/tools/make_install.sh")
--- a/cmake/version.inc
+++ b/cmake/version.inc
@ -4,7 +4,7 @@ PROJECT(TDengine)
 IF (DEFINED VERNUMBER)
  SET(TD_VER_NUMBER ${VERNUMBER})
 ELSE ()
-  SET(TD_VER_NUMBER "2.0.13.0")
+  SET(TD_VER_NUMBER "2.0.14.0")
 ENDIF ()

 IF (DEFINED VERCOMPATIBLE)
--- a/deps/CMakeLists.txt
+++ b/deps/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 ADD_SUBDIRECTORY(zlib-1.2.11)
--- a/deps/MQTT-C/CMakeLists.txt
+++ b/deps/MQTT-C/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)

 # MQTT-C build options
 option(MQTT_C_OpenSSL_SUPPORT "Build MQTT-C with OpenSSL support?" OFF)
--- a/deps/MsvcLibX/CMakeLists.txt
+++ b/deps/MsvcLibX/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 IF (TD_WINDOWS)
--- a/deps/iconv/CMakeLists.txt
+++ b/deps/iconv/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 IF (TD_WINDOWS)
--- a/deps/pthread/CMakeLists.txt
+++ b/deps/pthread/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 IF (TD_WINDOWS)
--- a/deps/regex/CMakeLists.txt
+++ b/deps/regex/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 IF (TD_WINDOWS)
--- a/deps/wepoll/CMakeLists.txt
+++ b/deps/wepoll/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 IF (TD_WINDOWS)
--- a/deps/zlib-1.2.11/CMakeLists.txt
+++ b/deps/zlib-1.2.11/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 IF (TD_WINDOWS)
--- a/documentation20/webdocs/markdowndocs/TAOS
+++ b/documentation20/webdocs/markdowndocs/TAOS
@ -68,7 +68,9 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
  2) UPDATE 标志数据库支持更新相同时间戳数据；

  3) 数据库名最大长度为33；
+
  4) 一条SQL 语句的最大长度为65480个字符；
+
  5) 数据库还有更多与存储相关的配置参数，请参见系统管理。

 - **显示系统当前参数**
@ -130,19 +132,37 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
    CREATE TABLE [IF NOT EXISTS] tb_name (timestamp_field_name TIMESTAMP, field1_name data_type1 [, field2_name data_type2 ...]);
    ```
    说明：
+
    1) 表的第一个字段必须是TIMESTAMP，并且系统自动将其设为主键；
-    2) 表名最大长度为193；
+
+    2) 表名最大长度为192；
+
    3) 表的每行长度不能超过16k个字符;
+
    4) 子表名只能由字母、数字和下划线组成，且不能以数字开头
+
    5) 使用数据类型binary或nchar，需指定其最长的字节数，如binary(20)，表示20字节；

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

    ```mysql
-    CREATE TABLE [IF NOT EXISTS] tb_name USING stb_name TAGS (tag_value1 [, tag_value2 ...]);
+    CREATE TABLE [IF NOT EXISTS] tb_name USING stb_name TAGS (tag_value1, ...);
    ```
    以指定的超级表为模板，指定 tags 的值来创建数据表。

+- **批量创建数据表**
+
+    ```mysql
+    CREATE TABLE [IF NOT EXISTS] tb_name1 USING stb_name TAGS (tag_value1, ...) tb_name2 USING stb_name TAGS (tag_value2, ...) ...;
+    ```
+    以更快的速度批量创建大量数据表。（服务器端 2.0.14 及以上版本）
+    
+    说明：
+
+    1）批量建表方式要求数据表必须以超级表为模板。
+
+    2）在不超出 SQL 语句长度限制的前提下，单条语句中的建表数量建议控制在 1000～3000 之间，将会获得比较理想的建表速度。
+
 - **删除数据表**

    ```mysql
@ -155,7 +175,11 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
    SHOW TABLES [LIKE tb_name_wildcar];
    ```

-    显示当前数据库下的所有数据表信息。说明：可在 like 中使用通配符进行名称的匹配。 通配符匹配：1）“%”（百分号）匹配 0 到任意个字符；2）“\_”（下划线）匹配一个字符。
+    显示当前数据库下的所有数据表信息。
+
+    说明：可在like中使用通配符进行名称的匹配，这一通配符字符串最长不能超过24字节。
+
+    通配符匹配：1）’%’ (百分号)匹配0到任意个字符；2）’\_’下划线匹配一个字符。

 - **在线修改显示字符宽度**

@ -175,8 +199,10 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
    ALTER TABLE tb_name ADD COLUMN field_name data_type;
    ```
    说明：
+
    1) 列的最大个数为1024，最小个数为2；
-    2) 列名最大长度为65；
+
+    2) 列名最大长度为64；

 - **表删除列**

@ -194,9 +220,13 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
    创建STable, 与创建表的SQL语法相似，但需指定TAGS字段的名称和类型

    说明：
+
    1) TAGS 列的数据类型不能是timestamp类型；
+
    2) TAGS 列名不能与其他列名相同；
+
    3) TAGS 列名不能为预留关键字；
+
    4) TAGS 最多允许128个，至少1个，总长度不超过16k个字符。

 - **删除超级表**
@ -323,7 +353,9 @@ SELECT select_expr [, select_expr ...]
    [LIMIT limit_val [, OFFSET offset_val]]
    [>> export_file]
 ```
+
 说明：针对 insert 类型的 SQL 语句，我们采用的流式解析策略，在发现后面的错误之前，前面正确的部分SQL仍会执行。下面的sql中，insert语句是无效的，但是d1001仍会被创建。
+
 ```mysql
 taos> CREATE TABLE meters(ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS(location BINARY(30), groupId INT);
 Query OK, 0 row(s) affected (0.008245s)
@ -604,10 +636,20 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
    SELECT COUNT([*|field_name]) FROM tb_name [WHERE clause];
    ```
    功能说明：统计表/超级表中记录行数或某列的非空值个数。
+
    返回结果数据类型：长整型INT64。
+
    应用字段：应用全部字段。
+
    适用于：表、超级表。
-    说明：1）可以使用星号*来替代具体的字段，使用星号(*)返回全部记录数量。2）针对同一表的（不包含NULL值）字段查询结果均相同。3）如果统计对象是具体的列，则返回该列中非NULL值的记录数量。
+
+    说明：
+
+    1）可以使用星号*来替代具体的字段，使用星号(*)返回全部记录数量。
+
+    2）针对同一表的（不包含NULL值）字段查询结果均相同。
+
+    3）如果统计对象是具体的列，则返回该列中非NULL值的记录数量。

    示例：
    ```mysql
@ -629,8 +671,11 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
    SELECT AVG(field_name) FROM tb_name [WHERE clause];
    ```
    功能说明：统计表/超级表中某列的平均值。
+
    返回结果数据类型：双精度浮点数Double。
+
    应用字段：不能应用在timestamp、binary、nchar、bool字段。
+
    适用于：表、超级表。

    示例：
@ -653,9 +698,11 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
    SELECT TWA(field_name) FROM tb_name WHERE clause;
    ```
    功能说明：时间加权平均函数。统计表/超级表中某列在一段时间内的时间加权平均。
+
    返回结果数据类型：双精度浮点数Double。
+
    应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
-    说明：时间加权平均（time weighted average, TWA）查询需要指定查询时间段的 _开始时间_ 和 _结束时间_ 。
+
    适用于：表、超级表。

 - **SUM**
@ -663,8 +710,11 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
    SELECT SUM(field_name) FROM tb_name [WHERE clause];
    ```
    功能说明：统计表/超级表中某列的和。
+
    返回结果数据类型：双精度浮点数Double和长整型INT64。
+
    应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
+
    适用于：表、超级表。

    示例：
@ -687,8 +737,11 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
    SELECT STDDEV(field_name) FROM tb_name [WHERE clause];
    ```
    功能说明：统计表中某列的均方差。
+
    返回结果数据类型：双精度浮点数Double。
+
    应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
+
    适用于：表。

    示例：
@ -705,9 +758,13 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
    SELECT LEASTSQUARES(field_name, start_val, step_val) FROM tb_name [WHERE clause];
    ```
    功能说明：统计表中某列的值是主键（时间戳）的拟合直线方程。start_val是自变量初始值，step_val是自变量的步长值。
+
    返回结果数据类型：字符串表达式（斜率, 截距）。
+
    应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
+
    说明：自变量是时间戳，因变量是该列的值。
+
    适用于：表。

    示例：
@ -726,7 +783,9 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
    SELECT MIN(field_name) FROM {tb_name | stb_name} [WHERE clause];
    ```
    功能说明：统计表/超级表中某列的值最小值。
+
    返回结果数据类型：同应用的字段。
+
    应用字段：不能应用在timestamp、binary、nchar、bool类型字段。

    示例：
@ -749,7 +808,9 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
    SELECT MAX(field_name) FROM { tb_name | stb_name } [WHERE clause];
    ```
    功能说明：统计表/超级表中某列的值最大值。
+
    返回结果数据类型：同应用的字段。
+
    应用字段：不能应用在timestamp、binary、nchar、bool类型字段。

    示例：
@ -772,9 +833,18 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
    SELECT FIRST(field_name) FROM { tb_name | stb_name } [WHERE clause];
    ```
    功能说明：统计表/超级表中某列的值最先写入的非NULL值。
+
    返回结果数据类型：同应用的字段。
+
    应用字段：所有字段。
-    说明：1）如果要返回各个列的首个（时间戳最小）非NULL值，可以使用FIRST(\*)；2) 如果结果集中的某列全部为NULL值，则该列的返回结果也是NULL；3) 如果结果集中所有列全部为NULL值，则不返回结果。
+
+    说明：
+
+    1）如果要返回各个列的首个（时间戳最小）非NULL值，可以使用FIRST(\*)；
+
+    2) 如果结果集中的某列全部为NULL值，则该列的返回结果也是NULL；
+
+    3) 如果结果集中所有列全部为NULL值，则不返回结果。

    示例：
    ```mysql
@ -796,9 +866,16 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
    SELECT LAST(field_name) FROM { tb_name | stb_name } [WHERE clause];
    ```
    功能说明：统计表/超级表中某列的值最后写入的非NULL值。
+
    返回结果数据类型：同应用的字段。
+
    应用字段：所有字段。
-    说明：1）如果要返回各个列的最后（时间戳最大）一个非NULL值，可以使用LAST(\*)；2）如果结果集中的某列全部为NULL值，则该列的返回结果也是NULL；如果结果集中所有列全部为NULL值，则不返回结果。
+
+    说明：
+
+    1）如果要返回各个列的最后（时间戳最大）一个非NULL值，可以使用LAST(\*)；
+
+    2）如果结果集中的某列全部为NULL值，则该列的返回结果也是NULL；如果结果集中所有列全部为NULL值，则不返回结果。

    示例：
    ```mysql
@ -820,9 +897,16 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
    SELECT TOP(field_name, K) FROM { tb_name | stb_name } [WHERE clause];
    ```
    功能说明： 统计表/超级表中某列的值最大*k*个非NULL值。若多于k个列值并列最大，则返回时间戳小的。
+
    返回结果数据类型：同应用的字段。
+
    应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
-    说明：1）*k*值取值范围1≤*k*≤100；2）系统同时返回该记录关联的时间戳列。
+
+    说明：
+
+    1）*k*值取值范围1≤*k*≤100；
+
+    2）系统同时返回该记录关联的时间戳列。

    示例：
    ```mysql
@ -847,9 +931,16 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
    SELECT BOTTOM(field_name, K) FROM { tb_name | stb_name } [WHERE clause];
    ```
    功能说明：统计表/超级表中某列的值最小*k*个非NULL值。若多于k个列值并列最小，则返回时间戳小的。
+
    返回结果数据类型：同应用的字段。
+
    应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
-    说明：1）*k*值取值范围1≤*k*≤100；2）系统同时返回该记录关联的时间戳列。
+
+    说明：
+
+    1）*k*值取值范围1≤*k*≤100；
+
+    2）系统同时返回该记录关联的时间戳列。

    示例：
    ```mysql
@ -873,8 +964,11 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
    SELECT PERCENTILE(field_name, P) FROM { tb_name } [WHERE clause];
    ```
    功能说明：统计表中某列的值百分比分位数。
+
    返回结果数据类型： 双精度浮点数Double。
+
    应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
+
    说明：*P*值取值范围0≤*P*≤100，为0的时候等同于MIN，为100的时候等同于MAX。

    示例：
@ -891,9 +985,13 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
    SELECT APERCENTILE(field_name, P) FROM { tb_name | stb_name } [WHERE clause];
    ```
    功能说明：统计表中某列的值百分比分位数，与PERCENTILE函数相似，但是返回近似结果。
+
    返回结果数据类型： 双精度浮点数Double。
+
    应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
+
    说明：*P*值取值范围0≤*P*≤100，为0的时候等同于MIN，为100的时候等同于MAX。推荐使用```APERCENTILE```函数，该函数性能远胜于```PERCENTILE```函数
+
    ```mysql
    taos> SELECT APERCENTILE(current, 20) FROM d1001;
    apercentile(current, 20)  |
@ -907,8 +1005,11 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
    SELECT LAST_ROW(field_name) FROM { tb_name | stb_name };
    ```
    功能说明：返回表（超级表）的最后一条记录。
+
    返回结果数据类型：同应用的字段。
+
    应用字段：所有字段。
+
    说明：与last函数不同，last_row不支持时间范围限制，强制返回最后一条记录。

    示例：
@ -932,8 +1033,11 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
    SELECT DIFF(field_name) FROM tb_name [WHERE clause];
    ```
    功能说明：统计表中某列的值与前一行对应值的差。
+
    返回结果数据类型： 同应用字段。
+
    应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
+
    说明：输出结果行数是范围内总行数减一，第一行没有结果输出。

    示例：
@ -951,8 +1055,11 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
    SELECT SPREAD(field_name) FROM { tb_name | stb_name } [WHERE clause];
    ```
    功能说明：统计表/超级表中某列的最大值和最小值之差。
+
    返回结果数据类型： 双精度浮点数。
+
    应用字段：不能应用在binary、nchar、bool类型字段。
+
    说明：可用于TIMESTAMP字段，此时表示记录的时间覆盖范围。

    示例：
@ -976,9 +1083,16 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
    SELECT field_name [+|-|*|/|%][Value|field_name] FROM { tb_name | stb_name }  [WHERE clause];
    ```
    功能说明：统计表/超级表中某列或多列间的值加、减、乘、除、取余计算结果。
+
    返回结果数据类型：双精度浮点数。
+
    应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
-    说明：1）支持两列或多列之间进行计算，可使用括号控制计算优先级;2）NULL字段不参与计算，如果参与计算的某行中包含NULL，该行的计算结果为NULL。
+
+    说明：
+
+    1）支持两列或多列之间进行计算，可使用括号控制计算优先级；
+
+    2）NULL字段不参与计算，如果参与计算的某行中包含NULL，该行的计算结果为NULL。

    ```mysql
    taos> SELECT current + voltage * phase FROM d1001;
--- a/documentation20/webdocs/markdowndocs/administrator-ch.md
+++ b/documentation20/webdocs/markdowndocs/administrator-ch.md
@ -255,7 +255,7 @@ taos -C  或  taos --dump-config
 CREATE USER <user_name> PASS <'password'>;
 ```

-创建用户，并指定用户名和密码，密码需要用单引号引起来,单引号为英文半角
+创建用户，并指定用户名和密码，密码需要用单引号引起来，单引号为英文半角

 ```sql
 DROP USER <user_name>;
@ -267,13 +267,15 @@ DROP USER <user_name>;
 ALTER USER <user_name> PASS <'password'>;
 ```

-修改用户密码, 为避免被转换为小写，密码需要用单引号引用,单引号为英文半角
+修改用户密码，为避免被转换为小写，密码需要用单引号引用，单引号为英文半角

 ```sql
-ALTER USER <user_name> PRIVILEGE <super|write|read>;
+ALTER USER <user_name> PRIVILEGE <write|read>;
 ```

-修改用户权限为：super/write/read，不需要添加单引号
+修改用户权限为：write 或 read，不需要添加单引号
+
+说明：系统内共有 super/write/read 三种权限级别，但目前不允许通过 alter 指令把 super 权限赋予用户。

 ```mysql
 SHOW USERS;
@ -432,11 +434,12 @@ TDengine的所有可执行文件默认存放在 _/usr/local/taos/bin_ 目录下
 - 数据库名：不能包含“.”以及特殊字符，不能超过32个字符
 - 表名：不能包含“.”以及特殊字符，与所属数据库名一起，不能超过192个字符
 - 表的列名：不能包含特殊字符，不能超过64个字符
+- 数据库名、表名、列名，都不能以数字开头
 - 表的列数：不能超过1024列
 - 记录的最大长度：包括时间戳8 byte，不能超过16KB
 - 单条SQL语句默认最大字符串长度：65480 byte
 - 数据库副本数：不能超过3
- 用户名：不能超过20个byte
+- 用户名：不能超过23个byte
 - 用户密码：不能超过15个byte
 - 标签(Tags)数量：不能超过128个
 - 标签的总长度：不能超过16Kbyte
--- a/documentation20/webdocs/markdowndocs/cluster-ch.md
+++ b/documentation20/webdocs/markdowndocs/cluster-ch.md
@ -218,7 +218,7 @@ SHOW MNODES;

 如果一个数据节点离线，TDengine集群将自动检测到。有如下两种情况：

- 该数据节点离线超过一定时间（taos.cfg里配置参数offlineThreshold控制时长)，系统将自动把该数据节点删除，产生系统报警信息，触发负载均衡流程。如果该被删除的数据节点重现上线时，它将无法加入集群，需要系统管理员重新将其添加进集群才会开始工作。
+- 该数据节点离线超过一定时间（taos.cfg里配置参数offlineThreshold控制时长)，系统将自动把该数据节点删除，产生系统报警信息，触发负载均衡流程。如果该被删除的数据节点重新上线时，它将无法加入集群，需要系统管理员重新将其添加进集群才会开始工作。
 - 离线后，在offlineThreshold的时长内重新上线，系统将自动启动数据恢复流程，等数据完全恢复后，该节点将开始正常工作。

 **注意：**如果一个虚拟节点组（包括mnode组）里所归属的每个数据节点都处于离线或unsynced状态，必须等该虚拟节点组里的所有数据节点都上线、都能交换状态信息后，才能选出Master，该虚拟节点组才能对外提供服务。比如整个集群有3个数据节点，副本数为3，如果3个数据节点都宕机，然后2个数据节点重启，是无法工作的，只有等3个数据节点都重启成功，才能对外服务。
--- a/documentation20/webdocs/markdowndocs/cluster.md
+++ b/documentation20/webdocs/markdowndocs/cluster.md
@ -89,6 +89,8 @@ SHOW DNODES;
 ```
 它将列出集群中所有的dnode,每个dnode的fqdn:port, 状态(ready, offline等），vnode数目，还未使用的vnode数目等信息。在添加或删除一个节点后，可以使用该命令查看。

+如果集群配置了Arbitrator，那么它也会在这个节点列表中显示出来，其role列的值会是“arb”。
+
 ###查看虚拟节点组

 为充分利用多核技术，并提供scalability，数据需要分片处理。因此TDengine会将一个DB的数据切分成多份，存放在多个vnode里。这些vnode可能分布在多个dnode里，这样就实现了水平扩展。一个vnode仅仅属于一个DB，但一个DB可以有多个vnode。vnode的是mnode根据当前系统资源的情况，自动进行分配的，无需任何人工干预。
@ -139,4 +141,6 @@ SHOW MNODES;

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

-TDengine安装包里带有一个执行程序tarbitrator, 找任何一台Linux服务器运行它即可。该程序对系统资源几乎没有要求，只需要保证有网络连接即可。该应用的命令行参数`-p`可以指定其对外服务的端口号，缺省是6030。配置每个taosd实例时，可以在配置文件taos.cfg里将参数arbitrator设置为arbitrator的End Point。如果该参数配置了，当副本数为偶数数，系统将自动连接配置的arbitrator。
+TDengine安装包里带有一个执行程序tarbitrator, 找任何一台Linux服务器运行它即可。该程序对系统资源几乎没有要求，只需要保证有网络连接即可。该应用的命令行参数`-p`可以指定其对外服务的端口号，缺省是6030。配置每个taosd实例时，可以在配置文件taos.cfg里将参数arbitrator设置为Arbitrator的End Point。如果该参数配置了，当副本数为偶数数，系统将自动连接配置的Arbitrator。
+
+在配置了Arbitrator的情况下，它也会显示在“show dnodes;”指令给出的节点列表中。
--- a/documentation20/webdocs/markdowndocs/connector-ch.md
+++ b/documentation20/webdocs/markdowndocs/connector-ch.md
@ -252,7 +252,7 @@ C/C++的API类似于MySQL的C API。应用程序使用时，需要包含TDengine

 - `void taos_free_result(TAOS_RES *res)`

-  释放查询结果集以及相关的资源。查询完成后，务必调用该API释放资源，否则可能导致应用内存泄露。
+  释放查询结果集以及相关的资源。查询完成后，务必调用该API释放资源，否则可能导致应用内存泄露。但也需注意，释放资源后，如果再调用`taos_consume`等获取查询结果的函数，将导致应用Crash。

 - `char *taos_errstr(TAOS_RES *res)`

@ -262,11 +262,11 @@ C/C++的API类似于MySQL的C API。应用程序使用时，需要包含TDengine

  获取最近一次API调用失败的原因，返回值为错误代码。

-**注意**：对于每个数据库应用，2.0及以上版本 TDengine 推荐只建立一个连接。同时在应用中将该连接 (TAOS*) 结构体传递到不同的线程共享使用。基于 TAOS 结构体发出的查询、写入等操作具有多线程安全性。C 语言的连接器可以按照需求动态建立面向数据库的新连接（该过程对用户不可见），同时建议只有在程序最后退出的时候才调用 taos_close 关闭连接。
+**注意**：2.0及以上版本 TDengine 推荐数据库应用的每个线程都建立一个独立的连接，或基于线程建立连接池。而不推荐在应用中将该连接 (TAOS\*) 结构体传递到不同的线程共享使用。基于 TAOS 结构体发出的查询、写入等操作具有多线程安全性，但 “USE statement” 等状态量有可能在线程之间相互干扰。此外，C 语言的连接器可以按照需求动态建立面向数据库的新连接（该过程对用户不可见），同时建议只有在程序最后退出的时候才调用 taos_close 关闭连接。

 ### 异步查询API

-同步API之外，TDengine还提供性能更高的异步调用API处理数据插入、查询操作。在软硬件环境相同的情况下，异步API处理数据插入的速度比同步API快2~4倍。异步API采用非阻塞式的调用方式，在系统真正完成某个具体数据库操作前，立即返回。调用的线程可以去处理其他工作，从而可以提升整个应用的性能。异步API在网络延迟严重的情况下，优点尤为突出。
+同步API之外，TDengine还提供性能更高的异步调用API处理数据插入、查询操作。在软硬件环境相同的情况下，异步API处理数据插入的速度比同步API快2\~4倍。异步API采用非阻塞式的调用方式，在系统真正完成某个具体数据库操作前，立即返回。调用的线程可以去处理其他工作，从而可以提升整个应用的性能。异步API在网络延迟严重的情况下，优点尤为突出。

 异步API都需要应用提供相应的回调函数，回调函数参数设置如下：前两个参数都是一致的，第三个参数依不同的API而定。第一个参数param是应用调用异步API时提供给系统的，用于回调时，应用能够找回具体操作的上下文，依具体实现而定。第二个参数是SQL操作的结果集，如果为空，比如insert操作，表示没有记录返回，如果不为空，比如select操作，表示有记录返回。

@ -425,7 +425,7 @@ cd C:\TDengine\connector\python\windows
 python -m pip install python3\
 ```

-*如果机器上没有pip命令，用户可将src/connector/python/python3或src/connector/python/python2下的taos文件夹拷贝到应用程序的目录使用。
+* 如果机器上没有pip命令，用户可将src/connector/python/python3或src/connector/python/python2下的taos文件夹拷贝到应用程序的目录使用。
 对于windows 客户端，安装TDengine windows 客户端后，将C:\TDengine\driver\taos.dll拷贝到C:\windows\system32目录下即可。

 ### 使用
@ -442,7 +442,7 @@ import taos
 conn = taos.connect(host="127.0.0.1", user="root", password="taosdata", config="/etc/taos")
 c1 = conn.cursor()
 ```
-*<em>host</em> 是TDengine 服务端所有IP, <em>config</em> 为客户端配置文件所在目录
+* <em>host</em> 是TDengine 服务端所有IP, <em>config</em> 为客户端配置文件所在目录

 * 写入数据
 ```python
@ -510,17 +510,17 @@ conn.close()

 用户可通过python的帮助信息直接查看模块的使用信息，或者参考tests/examples/python中的示例程序。以下为部分常用类和方法：

- _TDengineConnection_类
+- _TDengineConnection_ 类

  参考python中help(taos.TDengineConnection)。
-  这个类对应客户端和TDengine建立的一个连接。在客户端多线程的场景下，这个连接实例可以是每个线程申请一个，也可以多线程共享一个连接。
+  这个类对应客户端和TDengine建立的一个连接。在客户端多线程的场景下，推荐每个线程申请一个独立的连接实例，而不建议多线程共享一个连接。

- _TDengineCursor_类
+- _TDengineCursor_ 类

  参考python中help(taos.TDengineCursor)。
  这个类对应客户端进行的写入、查询操作。在客户端多线程的场景下，这个游标实例必须保持线程独享，不能夸线程共享使用，否则会导致返回结果出现错误。

- _connect_方法
+- _connect_ 方法

  用于生成taos.TDengineConnection的实例。

@ -800,7 +800,7 @@ go env -w GOPROXY=https://goproxy.io,direct

 - `sql.Open(DRIVER_NAME string, dataSourceName string) *DB` 

-  该API用来打开DB，返回一个类型为*DB的对象，一般情况下，DRIVER_NAME设置为字符串`taosSql`, dataSourceName设置为字符串`user:password@/tcp(host:port)/dbname`，如果客户想要用多个goroutine并发访问TDengine, 那么需要在各个goroutine中分别创建一个sql.Open对象并用之访问TDengine
+  该API用来打开DB，返回一个类型为\*DB的对象，一般情况下，DRIVER_NAME设置为字符串`taosSql`, dataSourceName设置为字符串`user:password@/tcp(host:port)/dbname`，如果客户想要用多个goroutine并发访问TDengine, 那么需要在各个goroutine中分别创建一个sql.Open对象并用之访问TDengine

  **注意**： 该API成功创建的时候，并没有做权限等检查，只有在真正执行Query或者Exec的时候才能真正的去创建连接，并同时检查user/password/host/port是不是合法。 另外，由于整个驱动程序大部分实现都下沉到taosSql所依赖的libtaos中。所以，sql.Open本身特别轻量。 

@ -822,7 +822,7 @@ go env -w GOPROXY=https://goproxy.io,direct

 - `func (s *Stmt) Query(args ...interface{}) (*Rows, error)`

-  sql.Open内置的方法，Query executes a prepared query statement with the given arguments and returns the query results as a *Rows.
+  sql.Open内置的方法，Query executes a prepared query statement with the given arguments and returns the query results as a \*Rows.

 - `func (s *Stmt) Close() error`

@ -894,7 +894,7 @@ Node-example-raw.js

 验证方法：

-1. 新建安装验证目录，例如：~/tdengine-test，拷贝github上nodejsChecker.js源程序。下载地址：（https://github.com/taosdata/TDengine/tree/develop/tests/examples/nodejs/nodejsChecker.js）。
+1. 新建安装验证目录，例如：\~/tdengine-test，拷贝github上nodejsChecker.js源程序。下载地址：（https://github.com/taosdata/TDengine/tree/develop/tests/examples/nodejs/nodejsChecker.js）。

 2. 在命令中执行以下命令：

--- a/documentation20/webdocs/markdowndocs/faq-ch.md
+++ b/documentation20/webdocs/markdowndocs/faq-ch.md
@ -1,5 +1,19 @@
 # 常见问题

+## 0. 怎么报告问题？
+
+如果 FAQ 中的信息不能够帮到您，需要 TDengine 技术团队的技术支持与协助，请将以下两个目录中内容打包：
+1. /var/log/taos （如果没有修改过默认路径）
+2. /etc/taos
+
+附上必要的问题描述，包括使用的 TDengine 版本信息、平台环境信息、发生该问题的执行操作、出现问题的表征及大概的时间，在<a href='https://github.com/taosdata/TDengine'> GitHub</a>提交Issue。
+
+为了保证有足够的debug信息，如果问题能够重复，请修改/etc/taos/taos.cfg文件，最后面添加一行“debugFlag 135"(不带引号本身），然后重启taosd, 重复问题，然后再递交。也可以通过如下SQL语句，临时设置taosd的日志级别。
+```
+    alter dnode <dnode_id> debugFlag 135;
+```
+但系统正常运行时，请一定将debugFlag设置为131，否则会产生大量的日志信息，降低系统效率。
+
 ## 1. TDengine2.0之前的版本升级到2.0及以上的版本应该注意什么？☆☆☆

 2.0版本在之前版本的基础上，进行了完全的重构，配置文件和数据文件是不兼容的。在升级之前务必进行如下操作：
@ -118,16 +132,8 @@ TDengine是根据hostname唯一标志一台机器的，在数据文件从机器A
 - 2.0.7.0 及以后的版本，到/var/lib/taos/dnode下，修复dnodeEps.json的dnodeId对应的FQDN，重启。确保机器内所有机器的此文件是完全相同的。
 - 1.x 和 2.x 版本的存储结构不兼容，需要使用迁移工具或者自己开发应用导出导入数据。

-## 17. 怎么报告问题？
+## 17. TDengine 是否支持删除或更新已经写入的数据？

-如果 FAQ 中的信息不能够帮到您，需要 TDengine 技术团队的技术支持与协助，请将以下两个目录中内容打包：
-1. /var/log/taos
-2. /etc/taos
+TDengine 目前尚不支持删除功能，未来根据用户需求可能会支持。

-附上必要的问题描述，以及发生该问题的执行操作，出现问题的表征及大概的时间，在<a href='https://github.com/taosdata/TDengine'> GitHub</a>提交Issue。
-
-为了保证有足够的debug信息，如果问题能够重复，请修改/etc/taos/taos.cfg文件，最后面添加一行“debugFlag 135"(不带引号本身），然后重启taosd, 重复问题，然后再递交。也可以通过如下SQL语句，临时设置taosd的日志级别。
-```
-    alter dnode <dnode_id> debugFlag 135;
-```
-但系统正常运行时，请一定将debugFlag设置为131，否则会产生大量的日志信息，降低系统效率。
+从 2.0.8.0 开始，TDengine 支持更新已经写入数据的功能。使用更新功能需要在创建数据库时使用 UPDATE 1 参数，之后可以使用 INSERT INTO 命令更新已经写入的相同时间戳数据。UPDATE 参数不支持 ALTER DATABASE 命令修改。没有使用 UPDATE 1 参数创建的数据库，写入相同时间戳的数据不会修改之前的数据，也不会报错。
--- a/packaging/cfg/taos.cfg
+++ b/packaging/cfg/taos.cfg
@ -72,9 +72,6 @@
 # time interval of heart beat from shell to dnode, seconds
 # shellActivityTimer        3

-# time of keeping table meta data in cache, seconds
-# tableMetaKeepTimer        7200
-
 # minimum sliding window time, milli-second
 # minSlidingTime            10

@ -162,10 +159,10 @@
 # stop writing logs when the disk size of the log folder is less than this value
 # minimalLogDirGB       0.1

-# stop writing temporary files when the disk size of the log folder is less than this value
+# stop writing temporary files when the disk size of the tmp folder is less than this value
 # minimalTmpDirGB       0.1

-# stop writing data when the disk size of the log folder is less than this value
+# if disk free space is less than this value, taosd service exit directly within startup process
 # minimalDataDirGB      0.1

 # One mnode is equal to the number of vnode consumed
--- a/snap/snapcraft.yaml
+++ b/snap/snapcraft.yaml
@ -1,6 +1,6 @@
 name: tdengine
 base: core18
-version: '2.0.13.0'
+version: '2.0.14.0'
 icon: snap/gui/t-dengine.svg
 summary: an open-source big data platform designed and optimized for IoT. 
 description: |
@ -72,7 +72,7 @@ parts:
      - usr/bin/taosd
      - usr/bin/taos
      - usr/bin/taosdemo
-      - usr/lib/libtaos.so.2.0.13.0
+      - usr/lib/libtaos.so.2.0.14.0
      - usr/lib/libtaos.so.1
      - usr/lib/libtaos.so

--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 # Base compile
--- a/src/balance/CMakeLists.txt
+++ b/src/balance/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/mnode/inc)
--- a/src/client/CMakeLists.txt
+++ b/src/client/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 INCLUDE_DIRECTORIES(inc)
--- a/src/client/inc/tscSubquery.h
+++ b/src/client/inc/tscSubquery.h
@ -43,6 +43,11 @@ TAOS_ROW doSetResultRowData(SSqlObj *pSql);

 char *getArithmeticInputSrc(void *param, const char *name, int32_t colId);

+void tscLockByThread(int64_t *lockedBy);
+
+void tscUnlockByThread(int64_t *lockedBy);
+
+
 #ifdef __cplusplus
 }
 #endif
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@ -300,8 +300,8 @@ typedef struct STscObj {
  void *             pTimer;
  char               user[TSDB_USER_LEN];
  char               pass[TSDB_KEY_LEN];
-  char               acctId[TSDB_ACCT_LEN];
-  char               db[TSDB_ACCT_LEN + TSDB_DB_NAME_LEN];
+  char               acctId[TSDB_ACCT_ID_LEN];
+  char               db[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN];
  char               sversion[TSDB_VERSION_LEN];
  char               writeAuth : 1;
  char               superAuth : 1;
@ -347,6 +347,11 @@ typedef struct SSqlObj {
  SSubqueryState   subState;
  struct SSqlObj **pSubs;

+  int64_t          metaRid;
+  int64_t          svgroupRid;
+
+  int64_t          squeryLock;
+
  struct SSqlObj  *prev, *next;
  int64_t          self;
 } SSqlObj;
--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@ -402,8 +402,10 @@ void tscAsyncResultOnError(SSqlObj *pSql) {
 int tscSendMsgToServer(SSqlObj *pSql);

 void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
-  SSqlObj *pSql = (SSqlObj *)param;
-  if (pSql == NULL || pSql->signature != pSql) return;
+  SSqlObj* pSql = (SSqlObj*)taosAcquireRef(tscObjRef, (int64_t)param);
+  if (pSql == NULL) return;
+
+  assert(pSql->signature == pSql && (int64_t)param == pSql->self);

  SSqlCmd *pCmd = &pSql->cmd;
  SSqlRes *pRes = &pSql->res;
@ -428,7 +430,8 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
      code = tscGetTableMeta(pSql, pTableMetaInfo);
      assert(code == TSDB_CODE_TSC_ACTION_IN_PROGRESS || code == TSDB_CODE_SUCCESS);

-      if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+      if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {        
+        taosReleaseRef(tscObjRef, pSql->self);
        return;
      }

@ -436,6 +439,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {

      // tscProcessSql can add error into async res
      tscProcessSql(pSql);
+      taosReleaseRef(tscObjRef, pSql->self);
      return;
    } else {  // continue to process normal async query
      if (pCmd->parseFinished) {
@ -446,6 +450,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {

        assert(code == TSDB_CODE_TSC_ACTION_IN_PROGRESS || code == TSDB_CODE_SUCCESS);
        if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+          taosReleaseRef(tscObjRef, pSql->self);
          return;
        }

@ -458,6 +463,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {

          code = tsParseSql(pSql, true);
          if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+            taosReleaseRef(tscObjRef, pSql->self);
            return;
          } else if (code != TSDB_CODE_SUCCESS) {
            goto _error;
@ -468,12 +474,14 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
          tscProcessSql(pSql);
        }

+        taosReleaseRef(tscObjRef, pSql->self);
        return;
      } else {
        tscDebug("%p continue parse sql after get table meta", pSql);

        code = tsParseSql(pSql, false);
        if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+          taosReleaseRef(tscObjRef, pSql->self);
          return;
        } else if (code != TSDB_CODE_SUCCESS) {
          goto _error;
@ -483,12 +491,14 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
          STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
          code = tscGetTableMeta(pSql, pTableMetaInfo);
          if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+            taosReleaseRef(tscObjRef, pSql->self);
            return;
          } else {
            assert(code == TSDB_CODE_SUCCESS);      
          }

          (*pSql->fp)(pSql->param, pSql, code);
+          taosReleaseRef(tscObjRef, pSql->self);
          return;
        }

@ -501,6 +511,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {

    code = tscGetTableMeta(pSql, pTableMetaInfo);
    if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+      taosReleaseRef(tscObjRef, pSql->self);
      return;
    } else if (code != TSDB_CODE_SUCCESS) {
      goto _error;
@ -509,6 +520,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
    if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
      code = tscGetSTableVgroupInfo(pSql, pCmd->clauseIndex);
      if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+        taosReleaseRef(tscObjRef, pSql->self);
        return;
      } else if (code != TSDB_CODE_SUCCESS) {
        goto _error;
@ -521,10 +533,16 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
    }

    (*pSql->fp)(pSql->param, pSql, code);
+    
+    taosReleaseRef(tscObjRef, pSql->self);
+
    return;
  }

  tscDoQuery(pSql);
+
+  taosReleaseRef(tscObjRef, pSql->self);
+  
  return;

  _error:
@ -532,4 +550,6 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
    pSql->res.code = code;
    tscAsyncResultOnError(pSql);
  }
+
+  taosReleaseRef(tscObjRef, pSql->self);
 }
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@ -762,6 +762,8 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {

  char *sql = *sqlstr;

+  pSql->cmd.autoCreated = false;
+  
  // get the token of specified table
  index = 0;
  tableToken = tStrGetToken(sql, &index, false, 0, NULL);
@ -945,11 +947,15 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
    SKVRow row = tdGetKVRowFromBuilder(&kvRowBuilder);
    tdDestroyKVRowBuilder(&kvRowBuilder);
    if (row == NULL) {
-      return TSDB_CODE_TSC_OUT_OF_MEMORY;
+      return tscInvalidSQLErrMsg(pCmd->payload, "tag value expected", NULL);
    }
    tdSortKVRowByColIdx(row);

    pCmd->tagData.dataLen = kvRowLen(row);
+    if (pCmd->tagData.dataLen <= 0){
+      return tscInvalidSQLErrMsg(pCmd->payload, "tag value expected", NULL);
+    }
+    
    char* pTag = realloc(pCmd->tagData.data, pCmd->tagData.dataLen);
    if (pTag == NULL) {
      return TSDB_CODE_TSC_OUT_OF_MEMORY;
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@ -223,7 +223,7 @@ static int32_t handlePassword(SSqlCmd* pCmd, SStrToken* pPwd) {
    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
  }

-  if (pPwd->n >= TSDB_PASSWORD_LEN) {
+  if (pPwd->n >= TSDB_KEY_LEN) {
    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
  }

@ -1244,7 +1244,7 @@ int32_t setObjFullName(char* fullName, const char* account, SStrToken* pDB, SStr

  /* db name is not specified, the tableName dose not include db name */
  if (pDB != NULL) {
-    if (pDB->n >= TSDB_ACCT_LEN + TSDB_DB_NAME_LEN || pDB->n == 0) {
+    if (pDB->n >= TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN || pDB->n == 0) {
      return TSDB_CODE_TSC_INVALID_SQL;
    }

@ -6024,9 +6024,9 @@ int32_t tscCheckCreateDbParams(SSqlCmd* pCmd, SCreateDbMsg* pCreate) {
  }

  if (pCreate->quorum != -1 &&
-      (pCreate->quorum < TSDB_MIN_DB_REPLICA_OPTION || pCreate->quorum > TSDB_MAX_DB_REPLICA_OPTION)) {
+      (pCreate->quorum < TSDB_MIN_DB_QUORUM_OPTION || pCreate->quorum > TSDB_MAX_DB_QUORUM_OPTION)) {
    snprintf(msg, tListLen(msg), "invalid db option quorum: %d valid range: [%d, %d]", pCreate->quorum,
-             TSDB_MIN_DB_REPLICA_OPTION, TSDB_MAX_DB_REPLICA_OPTION);
+             TSDB_MIN_DB_QUORUM_OPTION, TSDB_MAX_DB_QUORUM_OPTION);
    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
  }

@ -6103,7 +6103,9 @@ void tscPrintSelectClause(SSqlObj* pSql, int32_t subClauseIndex) {
    int32_t tmpLen = 0;
    tmpLen =
        sprintf(tmpBuf, "%s(uid:%" PRId64 ", %d)", aAggs[pExpr->functionId].aName, pExpr->uid, pExpr->colInfo.colId);
-    if (tmpLen + offset > totalBufSize) break;
+
+    if (tmpLen + offset >= totalBufSize - 1) break;
+

    offset += sprintf(str + offset, "%s", tmpBuf);

@ -6112,7 +6114,9 @@ void tscPrintSelectClause(SSqlObj* pSql, int32_t subClauseIndex) {
    }
  }

+  assert(offset < totalBufSize);
  str[offset] = ']';
+  assert(offset < totalBufSize);
  tscDebug("%p select clause:%s", pSql, str);
 }

--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@ -423,7 +423,7 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcEpSet *pEpSet) {

  if (shouldFree) { // in case of table-meta/vgrouplist query, automatically free it
    taosRemoveRef(tscObjRef, pSql->self);
-    tscDebug("%p sqlObj is automatically freed", pSql);
+    tscDebug("%p sqlObj is automatically freed", pSql); 
  }

  rpcFreeCont(rpcMsg->pCont);
@ -1975,9 +1975,6 @@ int tscProcessMultiMeterMetaRsp(SSqlObj *pSql) {
    //
    //    rsp += tagLen;
    //    int32_t size = (int32_t)(rsp - ((char *)pMeta));  // Consistent with STableMeta in cache
-    //
-    //    pMeta->index = 0;
-    //    (void)taosCachePut(tscMetaCache, pMeta->tableId, (char *)pMeta, size, tsTableMetaKeepTimer);
    //  }
  }
  
@ -1990,16 +1987,20 @@ int tscProcessMultiMeterMetaRsp(SSqlObj *pSql) {
 }

 int tscProcessSTableVgroupRsp(SSqlObj *pSql) {
+  // master sqlObj locates in param
+  SSqlObj* parent = (SSqlObj*)taosAcquireRef(tscObjRef, (int64_t)pSql->param);
+  if(parent == NULL) {
+    return pSql->res.code;
+  }
+
+  assert(parent->signature == parent && (int64_t)pSql->param == parent->self);
+  
  SSqlRes* pRes = &pSql->res;
  
  // NOTE: the order of several table must be preserved.
  SSTableVgroupRspMsg *pStableVgroup = (SSTableVgroupRspMsg *)pRes->pRsp;
  pStableVgroup->numOfTables = htonl(pStableVgroup->numOfTables);
  char *pMsg = pRes->pRsp + sizeof(SSTableVgroupRspMsg);
-
-  // master sqlObj locates in param
-  SSqlObj* parent = pSql->param;
-  assert(parent != NULL);
  
  SSqlCmd* pCmd = &parent->cmd;
  for(int32_t i = 0; i < pStableVgroup->numOfTables; ++i) {
@ -2033,6 +2034,8 @@ int tscProcessSTableVgroupRsp(SSqlObj *pSql) {

    pMsg += size;
  }
+
+  taosReleaseRef(tscObjRef, parent->self);
  
  return pSql->res.code;
 }
@ -2326,11 +2329,15 @@ static int32_t getTableMetaFromMnode(SSqlObj *pSql, STableMetaInfo *pTableMetaIn

  tscDebug("%p new pSqlObj:%p to get tableMeta, auto create:%d", pSql, pNew, pNew->cmd.autoCreated);

-  pNew->fp = tscTableMetaCallBack;
-  pNew->param = pSql;
-
  registerSqlObj(pNew);

+  pNew->fp = tscTableMetaCallBack;
+  pNew->param = (void *)pSql->self;
+
+  tscDebug("%p metaRid from %" PRId64 " to %" PRId64 , pSql, pSql->metaRid, pNew->self);
+  
+  pSql->metaRid = pNew->self;
+
  int32_t code = tscProcessSql(pNew);
  if (code == TSDB_CODE_SUCCESS) {
    code = TSDB_CODE_TSC_ACTION_IN_PROGRESS;  // notify application that current process needs to be terminated
@ -2346,6 +2353,7 @@ int32_t tscGetTableMeta(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo) {
  uint32_t size = tscGetTableMetaMaxSize();
  pTableMetaInfo->pTableMeta = calloc(1, size);

+  pTableMetaInfo->pTableMeta->tableType = -1;
  pTableMetaInfo->pTableMeta->tableInfo.numOfColumns  = -1;
  int32_t len = (int32_t) strlen(pTableMetaInfo->name);

@ -2445,10 +2453,15 @@ int tscGetSTableVgroupInfo(SSqlObj *pSql, int32_t clauseIndex) {
  pNewQueryInfo->numOfTables = pQueryInfo->numOfTables;
  registerSqlObj(pNew);

+  tscDebug("%p svgroupRid from %" PRId64 " to %" PRId64 , pSql, pSql->svgroupRid, pNew->self);
+  
+  pSql->svgroupRid = pNew->self;
+  
+
  tscDebug("%p new sqlObj:%p to get vgroupInfo, numOfTables:%d", pSql, pNew, pNewQueryInfo->numOfTables);

  pNew->fp = tscTableMetaCallBack;
-  pNew->param = pSql;
+  pNew->param = (void *)pSql->self;
  code = tscProcessSql(pNew);
  if (code == TSDB_CODE_SUCCESS) {
    code = TSDB_CODE_TSC_ACTION_IN_PROGRESS;
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@ -47,7 +47,7 @@ static bool validUserName(const char* user) {
 }

 static bool validPassword(const char* passwd) {
-  return validImpl(passwd, TSDB_PASSWORD_LEN - 1);
+  return validImpl(passwd, TSDB_KEY_LEN - 1);
 }

 static SSqlObj *taosConnectImpl(const char *ip, const char *user, const char *pass, const char *auth, const char *db,
@ -238,11 +238,11 @@ TAOS *taos_connect_c(const char *ip, uint8_t ipLen, const char *user, uint8_t us
                     uint8_t passLen, const char *db, uint8_t dbLen, uint16_t port) {
  char ipBuf[TSDB_EP_LEN] = {0};
  char userBuf[TSDB_USER_LEN] = {0};
-  char passBuf[TSDB_PASSWORD_LEN] = {0};
+  char passBuf[TSDB_KEY_LEN] = {0};
  char dbBuf[TSDB_DB_NAME_LEN] = {0};
  strncpy(ipBuf, ip, MIN(TSDB_EP_LEN - 1, ipLen));
  strncpy(userBuf, user, MIN(TSDB_USER_LEN - 1, userLen));
-  strncpy(passBuf, pass, MIN(TSDB_PASSWORD_LEN - 1, passLen));
+  strncpy(passBuf, pass, MIN(TSDB_KEY_LEN - 1, passLen));
  strncpy(dbBuf, db, MIN(TSDB_DB_NAME_LEN - 1, dbLen));
  return taos_connect(ipBuf, userBuf, passBuf, dbBuf, port);
 }
@ -694,6 +694,8 @@ static void tscKillSTableQuery(SSqlObj *pSql) {
  // set the master sqlObj flag to cancel query
  pSql->res.code = TSDB_CODE_TSC_QUERY_CANCELLED;

+  tscLockByThread(&pSql->squeryLock);
+  
  for (int i = 0; i < pSql->subState.numOfSub; ++i) {
    // NOTE: pSub may have been released already here
    SSqlObj *pSub = pSql->pSubs[i];
@ -713,6 +715,12 @@ static void tscKillSTableQuery(SSqlObj *pSql) {
    taosReleaseRef(tscObjRef, pSubObj->self);
  }

+  if (pSql->subState.numOfSub <= 0) {
+    tscAsyncResultOnError(pSql);
+  }
+
+  tscUnlockByThread(&pSql->squeryLock);
+
  tscDebug("%p super table query cancelled", pSql);
 }

@ -978,7 +986,7 @@ static int tscParseTblNameList(SSqlObj *pSql, const char *tblNameList, int32_t t
      return code;
    }

-    if (++pCmd->count > TSDB_MULTI_METERMETA_MAX_NUM) {
+    if (++pCmd->count > TSDB_MULTI_TABLEMETA_MAX_NUM) {
      code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
      sprintf(pCmd->payload, "tables over the max number");
      return code;
--- a/src/client/src/tscStream.c
+++ b/src/client/src/tscStream.c
@ -551,7 +551,6 @@ static void tscCreateStream(void *param, TAOS_RES *res, int code) {
  int64_t starttime = tscGetLaunchTimestamp(pStream);
  pCmd->command = TSDB_SQL_SELECT;

-  registerSqlObj(pSql);
  tscAddIntoStreamList(pStream);

  taosTmrReset(tscProcessStreamTimer, (int32_t)starttime, pStream, tscTmr, &pStream->pTimer);
@ -610,12 +609,15 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p

  pSql->fp = tscCreateStream;
  pSql->fetchFp = tscCreateStream;
+
+  registerSqlObj(pSql);
+  
  int32_t code = tsParseSql(pSql, true);
  if (code == TSDB_CODE_SUCCESS) {
    tscCreateStream(pStream, pSql, code);
  } else if (code != TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
    tscError("%p open stream failed, sql:%s, code:%s", pSql, sqlstr, tstrerror(pRes->code));
-    tscFreeSqlObj(pSql);
+    taosReleaseRef(tscObjRef, pSql->self);
    free(pStream);
    return NULL;
  }
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@ -533,7 +533,7 @@ static void quitAllSubquery(SSqlObj* pSqlObj, SJoinSupporter* pSupporter) {
    freeJoinSubqueryObj(pSqlObj);
  }

-  tscDestroyJoinSupporter(pSupporter);
+  //tscDestroyJoinSupporter(pSupporter);
 }

 // update the query time range according to the join results on timestamp
@ -1362,9 +1362,11 @@ void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code) {

  SJoinSupporter* pSupporter = (SJoinSupporter*)param;
  SSqlObj* pParentSql = pSupporter->pObj;
-
+  
  // There is only one subquery and table for each subquery.
  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+
  assert(pQueryInfo->numOfTables == 1 && pSql->cmd.numOfClause == 1);

  // retrieve actual query results from vnode during the second stage join subquery
@ -1382,7 +1384,6 @@ void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code) {

    tscError("%p abort query, code:%s, global code:%s", pSql, tstrerror(code), tstrerror(pParentSql->res.code));
    pParentSql->res.code = code;
-
    quitAllSubquery(pParentSql, pSupporter);
    tscAsyncResultOnError(pParentSql);

@ -1405,9 +1406,6 @@ void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code) {
    return;
  }

-
-  STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
-
  // In case of consequence query from other vnode, do not wait for other query response here.
  if (!(pTableMetaInfo->vgroupIndex > 0 && tscNonOrderedProjectionQueryOnSTable(pQueryInfo, 0))) {
    if (atomic_sub_fetch_32(&pParentSql->subState.numOfRemain, 1) > 0) {
@ -1658,6 +1656,25 @@ static void doCleanupSubqueries(SSqlObj *pSql, int32_t numOfSubs) {
  }
 }

+void tscLockByThread(int64_t *lockedBy) {
+  int64_t tid = taosGetSelfPthreadId();
+  int     i = 0;
+  while (atomic_val_compare_exchange_64(lockedBy, 0, tid) != 0) {
+    if (++i % 100 == 0) {
+      sched_yield();
+    }
+  }
+}
+
+void tscUnlockByThread(int64_t *lockedBy) {
+  int64_t tid = taosGetSelfPthreadId();
+  if (atomic_val_compare_exchange_64(lockedBy, tid, 0) != tid) {
+    assert(false);
+  }
+}
+
+
+
 int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
  SSqlRes *pRes = &pSql->res;
  SSqlCmd *pCmd = &pSql->cmd;
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@ -468,6 +468,18 @@ void tscFreeRegisteredSqlObj(void *pSql) {

 }

+void tscFreeMetaSqlObj(int64_t *rid){
+  if (RID_VALID(*rid)) {
+    SSqlObj* pSql = (SSqlObj*)taosAcquireRef(tscObjRef, *rid);
+    if (pSql) {
+      taosRemoveRef(tscObjRef, *rid);
+      taosReleaseRef(tscObjRef, *rid);
+    }
+
+    *rid = 0;
+  }
+}
+
 void tscFreeSqlObj(SSqlObj* pSql) {
  if (pSql == NULL || pSql->signature != pSql) {
    return;
@ -477,6 +489,9 @@ void tscFreeSqlObj(SSqlObj* pSql) {

  pSql->res.code = TSDB_CODE_TSC_QUERY_CANCELLED;

+  tscFreeMetaSqlObj(&pSql->metaRid);
+  tscFreeMetaSqlObj(&pSql->svgroupRid);
+
  tscFreeSubobj(pSql);

  SSqlCmd* pCmd = &pSql->cmd;
@ -505,6 +520,7 @@ void tscFreeSqlObj(SSqlObj* pSql) {
  pCmd->allocSize = 0;
  
  tsem_destroy(&pSql->rspSem);
+  memset(pSql, 0, sizeof(*pSql));
  free(pSql);
 }

@ -2193,7 +2209,9 @@ void tscDoQuery(SSqlObj* pSql) {
          tscProcessSql(pSql);
        } else { // secondary stage join query.
          if (tscIsTwoStageSTableQuery(pQueryInfo, 0)) {  // super table query
+            tscLockByThread(&pSql->squeryLock);
            tscHandleMasterSTableQuery(pSql);
+            tscUnlockByThread(&pSql->squeryLock);
          } else {
            tscProcessSql(pSql);
          }
@ -2202,7 +2220,9 @@ void tscDoQuery(SSqlObj* pSql) {

      return;
    } else if (tscIsTwoStageSTableQuery(pQueryInfo, 0)) {  // super table query
+      tscLockByThread(&pSql->squeryLock);
      tscHandleMasterSTableQuery(pSql);
+      tscUnlockByThread(&pSql->squeryLock);
      return;
    }
    
--- a/src/client/tests/CMakeLists.txt
+++ b/src/client/tests/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 FIND_PATH(HEADER_GTEST_INCLUDE_DIR gtest.h /usr/include/gtest /usr/local/include/gtest)
--- a/src/client/tests/timeParseTest.cpp
+++ b/src/client/tests/timeParseTest.cpp
@ -162,6 +162,10 @@ TEST(testCase, parse_time) {
  
  taosParseTime(t13, &time, strlen(t13), TSDB_TIME_PRECISION_MILLI, 0);
  EXPECT_EQ(time, -28800 * MILLISECOND_PER_SECOND);
+
+  char* t = "2021-01-08T02:11:40.000+00:00";
+  taosParseTime(t, &time, strlen(t), TSDB_TIME_PRECISION_MILLI, 0);
+  printf("%ld\n", time);
 }


--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 INCLUDE_DIRECTORIES(inc)
--- a/src/common/inc/tglobal.h
+++ b/src/common/inc/tglobal.h
@ -63,7 +63,6 @@ extern int32_t  tsRetrieveBlockingModel;// retrieve threads will be blocked
 extern int8_t   tsKeepOriginalColumnName;

 // client
-extern int32_t tsTableMetaKeepTimer;
 extern int32_t tsMaxSQLStringLen;
 extern int8_t  tsTscEnableRecordSql;
 extern int32_t tsMaxNumOfOrderedResults;
--- a/src/common/src/tglobal.c
+++ b/src/common/src/tglobal.c
@ -72,7 +72,6 @@ char    tsTempDir[TSDB_FILENAME_LEN] = "/tmp/";
 int32_t tsCompressMsgSize = -1;

 // client
-int32_t tsTableMetaKeepTimer = 7200;  // second
 int32_t tsMaxSQLStringLen = TSDB_MAX_SQL_LEN;
 int8_t  tsTscEnableRecordSql = 0;

@ -596,16 +595,6 @@ static void doInitGlobalConfig(void) {
  cfg.unitType = TAOS_CFG_UTYPE_SECOND;
  taosInitConfigOption(cfg);

-  cfg.option = "tableMetaKeepTimer";
-  cfg.ptr = &tsTableMetaKeepTimer;
-  cfg.valType = TAOS_CFG_VTYPE_INT32;
-  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_CLIENT;
-  cfg.minValue = 1;
-  cfg.maxValue = 8640000;
-  cfg.ptrLength = 0;
-  cfg.unitType = TAOS_CFG_UTYPE_SECOND;
-  taosInitConfigOption(cfg);
-
  cfg.option = "minSlidingTime";
  cfg.ptr = &tsMinSlidingTime;
  cfg.valType = TAOS_CFG_VTYPE_INT32;
@ -811,8 +800,8 @@ static void doInitGlobalConfig(void) {
  cfg.ptr = &tsQuorum;
  cfg.valType = TAOS_CFG_VTYPE_INT32;
  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW;
-  cfg.minValue = TSDB_MIN_DB_REPLICA_OPTION;
-  cfg.maxValue = TSDB_MAX_DB_REPLICA_OPTION;
+  cfg.minValue = TSDB_MIN_DB_QUORUM_OPTION;
+  cfg.maxValue = TSDB_MAX_DB_QUORUM_OPTION;
  cfg.ptrLength = 0;
  cfg.unitType = TAOS_CFG_UTYPE_NONE;
  taosInitConfigOption(cfg);
--- a/src/common/src/tvariant.c
+++ b/src/common/src/tvariant.c
@ -399,6 +399,7 @@ static int32_t toNchar(tVariant *pVariant, char **pDest, int32_t *pDestSize) {
    pVariant->wpz = (wchar_t *)tmp;
  } else {
    int32_t output = 0;
+
    bool ret = taosMbsToUcs4(pDst, nLen, *pDest, (nLen + 1) * TSDB_NCHAR_SIZE, &output);
    if (!ret) {
      return -1;
--- a/src/connector/jdbc/.classpath
+++ b/src/connector/jdbc/.classpath
@ -1,32 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" output="target/classes" path="src/main/java">
-		<attributes>
-			<attribute name="optional" value="true"/>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources">
-		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
-		<attributes>
-			<attribute name="optional" value="true"/>
-			<attribute name="maven.pomderived" value="true"/>
-			<attribute name="test" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
-		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
-		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="output" path="target/classes"/>
-</classpath>
--- a/src/connector/jdbc/.project
+++ b/src/connector/jdbc/.project
@ -1,23 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>taos-jdbcdriver</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.m2e.core.maven2Builder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-		<nature>org.eclipse.m2e.core.maven2Nature</nature>
-	</natures>
-</projectDescription>
--- a/src/connector/jdbc/CMakeLists.txt
+++ b/src/connector/jdbc/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)

 PROJECT(TDengine)

@ -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.15-dist.jar ${LIBRARY_OUTPUT_PATH}
+    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/target/taos-jdbcdriver-2.0.16-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.15</version>
+  <version>2.0.16</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.15</version>
+    <version>2.0.16</version>
    <packaging>jar</packaging>
    <name>JDBCDriver</name>
    <url>https://github.com/taosdata/TDengine/tree/master/src/connector/jdbc</url>
@ -49,6 +49,7 @@
                </exclusion>
            </exclusions>
        </dependency>
+
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
@ -56,12 +57,6 @@
            <scope>test</scope>
        </dependency>

-        <dependency>
-            <groupId>mysql</groupId>
-            <artifactId>mysql-connector-java</artifactId>
-            <version>5.1.47</version>
-        </dependency>
-
        <!-- for restful -->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
@ -79,12 +74,6 @@
            <version>1.2.58</version>
        </dependency>

-        <dependency>
-            <groupId>mysql</groupId>
-            <artifactId>mysql-connector-java</artifactId>
-            <version>5.1.49</version>
-        </dependency>
-
    </dependencies>

    <build>
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractDatabaseMetaData.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractDatabaseMetaData.java
@ -497,12 +497,12 @@ public abstract class AbstractDatabaseMetaData implements DatabaseMetaData {

    public ResultSet getProcedures(String catalog, String schemaPattern, String procedureNamePattern)
            throws SQLException {
-        throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        return null;
    }

    public ResultSet getProcedureColumns(String catalog, String schemaPattern, String procedureNamePattern,
                                         String columnNamePattern) throws SQLException {
-        throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        return null;
    }

    public abstract ResultSet getTables(String catalog, String schemaPattern, String tableNamePattern, String[] types)
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDatabaseMetaData.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDatabaseMetaData.java
@ -20,13 +20,11 @@ import java.util.List;

 public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {

-    private String dbProductName = null;
-    private String url = null;
-    private String userName = null;
-    private Connection conn = null;
+    private String url;
+    private String userName;
+    private Connection conn;

-    public TSDBDatabaseMetaData(String dbProductName, String url, String userName) {
-        this.dbProductName = dbProductName;
+    public TSDBDatabaseMetaData(String url, String userName) {
        this.url = url;
        this.userName = userName;
    }
@ -35,12 +33,17 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
        this.conn = conn;
    }

+    @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());
+        }
    }

    public boolean isWrapperFor(Class<?> iface) throws SQLException {
-        return false;
+        return iface.isInstance(this);
    }

    public boolean allProceduresAreCallable() throws SQLException {
@ -80,11 +83,11 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
    }

    public String getDatabaseProductName() throws SQLException {
-        return this.dbProductName;
+        return "TDengine";
    }

    public String getDatabaseProductVersion() throws SQLException {
-        return "1.5.1";
+        return "2.0.x.x";
    }

    public String getDriverName() throws SQLException {
@ -92,7 +95,7 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
    }

    public String getDriverVersion() throws SQLException {
-        return "1.0.0";
+        return "2.0.x";
    }

    public int getDriverMajorVersion() {
@ -111,7 +114,9 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
        return false;
    }

+
    public boolean supportsMixedCaseIdentifiers() throws SQLException {
+        //像database、table这些对象的标识符，在存储时是否采用大小写混合的模式
        return false;
    }

@ -120,7 +125,7 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
    }

    public boolean storesLowerCaseIdentifiers() throws SQLException {
-        return false;
+        return true;
    }

    public boolean storesMixedCaseIdentifiers() throws SQLException {
@ -128,6 +133,7 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
    }

    public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException {
+        //像database、table这些对象的标识符，在存储时是否采用大小写混合、并带引号的模式
        return false;
    }

@ -188,10 +194,12 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
    }

    public boolean nullPlusNonNullIsNull() throws SQLException {
+        // null + non-null != null
        return false;
    }

    public boolean supportsConvert() throws SQLException {
+        // 是否支持转换函数convert
        return false;
    }

@ -216,7 +224,7 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
    }

    public boolean supportsGroupBy() throws SQLException {
-        return false;
+        return true;
    }

    public boolean supportsGroupByUnrelated() throws SQLException {
@ -488,7 +496,7 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
    }

    public int getDefaultTransactionIsolation() throws SQLException {
-        return 0;
+        return Connection.TRANSACTION_NONE;
    }

    public boolean supportsTransactions() throws SQLException {
@ -496,6 +504,8 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
    }

    public boolean supportsTransactionIsolationLevel(int level) throws SQLException {
+        if (level == Connection.TRANSACTION_NONE)
+            return true;
        return false;
    }

@ -517,28 +527,27 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {

    public ResultSet getProcedures(String catalog, String schemaPattern, String procedureNamePattern)
            throws SQLException {
-        throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        return null;
    }

    public ResultSet getProcedureColumns(String catalog, String schemaPattern, String procedureNamePattern,
                                         String columnNamePattern) throws SQLException {
-        throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        return null;
    }

-    public ResultSet getTables(String catalog, String schemaPattern, String tableNamePattern, String[] types)
-            throws SQLException {
-        Statement stmt = null;
-        if (null != conn && !conn.isClosed()) {
-            stmt = conn.createStatement();
-            if (catalog == null || catalog.length() < 1) {
-                catalog = conn.getCatalog();
-            }
+    public ResultSet getTables(String catalog, String schemaPattern, String tableNamePattern, String[] types) throws SQLException {
+        if (conn == null || conn.isClosed()) {
+            throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL));
+        }
+
+        try (Statement stmt = conn.createStatement()) {
+            if (catalog == null || catalog.isEmpty())
+                return null;
+
            stmt.executeUpdate("use " + catalog);
            ResultSet resultSet0 = stmt.executeQuery("show tables");
            GetTablesResultSet getTablesResultSet = new GetTablesResultSet(resultSet0, catalog, schemaPattern, tableNamePattern, types);
            return getTablesResultSet;
-        } else {
-            throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL));
        }
    }

@ -547,14 +556,12 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
    }

    public ResultSet getCatalogs() throws SQLException {
+        if (conn == null || conn.isClosed())
+            throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL));

-        if (conn != null && !conn.isClosed()) {
-            Statement stmt = conn.createStatement();
-            ResultSet resultSet0 = stmt.executeQuery("show databases");
-            CatalogResultSet resultSet = new CatalogResultSet(resultSet0);
-            return resultSet;
-        } else {
-            return getEmptyResultSet();
+        try (Statement stmt = conn.createStatement()) {
+            ResultSet rs = stmt.executeQuery("show databases");
+            return new CatalogResultSet(rs);
        }
    }

@ -562,7 +569,7 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
        DatabaseMetaDataResultSet resultSet = new DatabaseMetaDataResultSet();

        // set up ColumnMetaDataList
-        List<ColumnMetaData> columnMetaDataList = new ArrayList<ColumnMetaData>(1);
+        List<ColumnMetaData> columnMetaDataList = new ArrayList<>(1);
        ColumnMetaData colMetaData = new ColumnMetaData();
        colMetaData.setColIndex(0);
        colMetaData.setColName("TABLE_TYPE");
@ -571,7 +578,7 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
        columnMetaDataList.add(colMetaData);

        // set up rowDataList
-        List<TSDBResultSetRowData> rowDataList = new ArrayList<TSDBResultSetRowData>(2);
+        List<TSDBResultSetRowData> rowDataList = new ArrayList<>(2);
        TSDBResultSetRowData rowData = new TSDBResultSetRowData();
        rowData.setString(0, "TABLE");
        rowDataList.add(rowData);
@ -591,11 +598,10 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
        Statement stmt = null;
        if (null != conn && !conn.isClosed()) {
            stmt = conn.createStatement();
-            if (catalog == null || catalog.length() < 1) {
-                catalog = conn.getCatalog();
-            }
-            stmt.executeUpdate("use " + catalog);
+            if (catalog == null || catalog.isEmpty())
+                return null;

+            stmt.executeUpdate("use " + catalog);
            DatabaseMetaDataResultSet resultSet = new DatabaseMetaDataResultSet();
            // set up ColumnMetaDataList
            List<ColumnMetaData> columnMetaDataList = new ArrayList<>(24);
@ -851,7 +857,7 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
    }

    public Connection getConnection() throws SQLException {
-        return null;
+        return this.conn;
    }

    public boolean supportsSavepoints() throws SQLException {
@ -884,15 +890,17 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
    }

    public boolean supportsResultSetHoldability(int holdability) throws SQLException {
+        if (holdability == ResultSet.HOLD_CURSORS_OVER_COMMIT)
+            return true;
        return false;
    }

    public int getResultSetHoldability() throws SQLException {
-        return 0;
+        return ResultSet.HOLD_CURSORS_OVER_COMMIT;
    }

    public int getDatabaseMajorVersion() throws SQLException {
-        return 0;
+        return 2;
    }

    public int getDatabaseMinorVersion() throws SQLException {
@ -900,7 +908,7 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
    }

    public int getJDBCMajorVersion() throws SQLException {
-        return 0;
+        return 2;
    }

    public int getJDBCMinorVersion() throws SQLException {
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java
@ -214,7 +214,7 @@ public class TSDBDriver extends AbstractTaosDriver {
            urlProps.setProperty(TSDBDriver.PROPERTY_KEY_HOST, url);
        }
        
-        this.dbMetaData = new TSDBDatabaseMetaData(dbProductName, urlForMeta, urlProps.getProperty(TSDBDriver.PROPERTY_KEY_USER));
+        this.dbMetaData = new TSDBDatabaseMetaData(urlForMeta, urlProps.getProperty(TSDBDriver.PROPERTY_KEY_USER));
        return urlProps;
    }

--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSet.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSet.java
@ -39,7 +39,6 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.Map;

-@SuppressWarnings("unused")
 public class TSDBResultSet implements ResultSet {
 	private TSDBJNIConnector jniConnector = null;

@ -104,6 +103,7 @@ public class TSDBResultSet implements ResultSet {
 	}

 	public TSDBResultSet() {
+		
 	}

 	public TSDBResultSet(TSDBJNIConnector connector, long resultSetPointer) 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
@ -17,6 +17,7 @@ package com.taosdata.jdbc;
 import java.sql.*;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.TimeUnit;

 public class TSDBStatement implements Statement {
    private TSDBJNIConnector connector = null;
@ -68,7 +69,6 @@ public class TSDBStatement implements Statement {
        pSql = this.connector.executeQuery(sql);

        long resultSetPointer = this.connector.getResultSet();
-
        if (resultSetPointer == TSDBConstants.JNI_CONNECTION_NULL) {
            this.connector.freeResultSet(pSql);
            throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL));
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulDatabaseMetaData.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulDatabaseMetaData.java
@ -8,7 +8,6 @@ import java.util.List;

 public class RestfulDatabaseMetaData extends AbstractDatabaseMetaData {

-
    private final String url;
    private final String userName;
    private final Connection connection;
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/DatabaseMetaDataTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/DatabaseMetaDataTest.java
@ -1,245 +0,0 @@
-package com.taosdata.jdbc;
-
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import java.sql.*;
-import java.util.Properties;
-
-public class DatabaseMetaDataTest {
-    static Connection connection = null;
-    static PreparedStatement statement = null;
-    static String dbName = "test";
-    static String tName = "t0";
-    static String host = "localhost";
-
-    @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_HOST, host);
-        properties.setProperty(TSDBDriver.PROPERTY_KEY_USER, "root");
-        properties.setProperty(TSDBDriver.PROPERTY_KEY_PASSWORD, "taosdata");
-        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 = connection.prepareStatement(sql);
-        statement.executeUpdate("create database if not exists " + dbName);
-        statement.executeUpdate("create table if not exists " + dbName + "." + tName + " (ts timestamp, k int, v int)");
-    }
-
-    @Test
-    public void testMetaDataTest() throws SQLException {
-        DatabaseMetaData databaseMetaData = connection.getMetaData();
-        ResultSet resultSet = databaseMetaData.getTables(dbName, "t*", "t*", new String[]{"t"});
-        while (resultSet.next()) {
-            for (int i = 1; i <= resultSet.getMetaData().getColumnCount(); i++) {
-                System.out.printf("%d: %s\n", i, resultSet.getString(i));
-            }
-        }
-        resultSet.close();
-        databaseMetaData.isWrapperFor(null);
-        databaseMetaData.allProceduresAreCallable();
-        databaseMetaData.allTablesAreSelectable();
-        databaseMetaData.getURL();
-        databaseMetaData.getUserName();
-        databaseMetaData.isReadOnly();
-        databaseMetaData.nullsAreSortedHigh();
-        databaseMetaData.nullsAreSortedLow();
-        databaseMetaData.nullsAreSortedAtStart();
-        databaseMetaData.nullsAreSortedAtEnd();
-        databaseMetaData.getDatabaseProductName();
-        databaseMetaData.getDatabaseProductVersion();
-        databaseMetaData.getDriverName();
-        databaseMetaData.getDriverVersion();
-        databaseMetaData.getDriverMajorVersion();
-        databaseMetaData.getDriverMinorVersion();
-        databaseMetaData.usesLocalFiles();
-        databaseMetaData.usesLocalFilePerTable();
-        databaseMetaData.supportsMixedCaseIdentifiers();
-        databaseMetaData.storesUpperCaseIdentifiers();
-        databaseMetaData.storesLowerCaseIdentifiers();
-        databaseMetaData.storesMixedCaseIdentifiers();
-        databaseMetaData.supportsMixedCaseQuotedIdentifiers();
-        databaseMetaData.storesUpperCaseQuotedIdentifiers();
-        databaseMetaData.storesLowerCaseQuotedIdentifiers();
-        databaseMetaData.storesMixedCaseQuotedIdentifiers();
-        databaseMetaData.getIdentifierQuoteString();
-        databaseMetaData.getSQLKeywords();
-        databaseMetaData.getNumericFunctions();
-        databaseMetaData.getStringFunctions();
-        databaseMetaData.getSystemFunctions();
-        databaseMetaData.getTimeDateFunctions();
-        databaseMetaData.getSearchStringEscape();
-        databaseMetaData.getExtraNameCharacters();
-        databaseMetaData.supportsAlterTableWithAddColumn();
-        databaseMetaData.supportsAlterTableWithDropColumn();
-        databaseMetaData.supportsColumnAliasing();
-        databaseMetaData.nullPlusNonNullIsNull();
-        databaseMetaData.supportsConvert();
-        databaseMetaData.supportsConvert(0, 0);
-        databaseMetaData.supportsTableCorrelationNames();
-        databaseMetaData.supportsDifferentTableCorrelationNames();
-        databaseMetaData.supportsExpressionsInOrderBy();
-        databaseMetaData.supportsOrderByUnrelated();
-        databaseMetaData.supportsGroupBy();
-        databaseMetaData.supportsGroupByUnrelated();
-        databaseMetaData.supportsGroupByBeyondSelect();
-        databaseMetaData.supportsLikeEscapeClause();
-        databaseMetaData.supportsMultipleResultSets();
-        databaseMetaData.supportsMultipleTransactions();
-        databaseMetaData.supportsNonNullableColumns();
-        databaseMetaData.supportsMinimumSQLGrammar();
-        databaseMetaData.supportsCoreSQLGrammar();
-        databaseMetaData.supportsExtendedSQLGrammar();
-        databaseMetaData.supportsANSI92EntryLevelSQL();
-        databaseMetaData.supportsANSI92IntermediateSQL();
-        databaseMetaData.supportsANSI92FullSQL();
-        databaseMetaData.supportsIntegrityEnhancementFacility();
-        databaseMetaData.supportsOuterJoins();
-        databaseMetaData.supportsFullOuterJoins();
-        databaseMetaData.supportsLimitedOuterJoins();
-        databaseMetaData.getSchemaTerm();
-        databaseMetaData.getProcedureTerm();
-        databaseMetaData.getCatalogTerm();
-        databaseMetaData.isCatalogAtStart();
-        databaseMetaData.getCatalogSeparator();
-        databaseMetaData.supportsSchemasInDataManipulation();
-        databaseMetaData.supportsSchemasInProcedureCalls();
-        databaseMetaData.supportsSchemasInTableDefinitions();
-        databaseMetaData.supportsSchemasInIndexDefinitions();
-        databaseMetaData.supportsSchemasInPrivilegeDefinitions();
-        databaseMetaData.supportsCatalogsInDataManipulation();
-        databaseMetaData.supportsCatalogsInProcedureCalls();
-        databaseMetaData.supportsCatalogsInTableDefinitions();
-        databaseMetaData.supportsCatalogsInIndexDefinitions();
-        databaseMetaData.supportsCatalogsInPrivilegeDefinitions();
-        databaseMetaData.supportsPositionedDelete();
-        databaseMetaData.supportsPositionedUpdate();
-        databaseMetaData.supportsSelectForUpdate();
-        databaseMetaData.supportsStoredProcedures();
-        databaseMetaData.supportsSubqueriesInComparisons();
-        databaseMetaData.supportsSubqueriesInExists();
-        databaseMetaData.supportsSubqueriesInIns();
-        databaseMetaData.supportsSubqueriesInQuantifieds();
-        databaseMetaData.supportsCorrelatedSubqueries();
-        databaseMetaData.supportsUnion();
-        databaseMetaData.supportsUnionAll();
-        databaseMetaData.supportsOpenCursorsAcrossCommit();
-        databaseMetaData.supportsOpenCursorsAcrossRollback();
-        databaseMetaData.supportsOpenStatementsAcrossCommit();
-        databaseMetaData.supportsOpenStatementsAcrossRollback();
-        databaseMetaData.getMaxBinaryLiteralLength();
-        databaseMetaData.getMaxCharLiteralLength();
-        databaseMetaData.getMaxColumnNameLength();
-        databaseMetaData.getMaxColumnsInGroupBy();
-        databaseMetaData.getMaxColumnsInIndex();
-        databaseMetaData.getMaxColumnsInOrderBy();
-        databaseMetaData.getMaxColumnsInSelect();
-        databaseMetaData.getMaxColumnsInTable();
-        databaseMetaData.getMaxConnections();
-        databaseMetaData.getMaxCursorNameLength();
-        databaseMetaData.getMaxIndexLength();
-        databaseMetaData.getMaxSchemaNameLength();
-        databaseMetaData.getMaxProcedureNameLength();
-        databaseMetaData.getMaxCatalogNameLength();
-        databaseMetaData.getMaxRowSize();
-        databaseMetaData.doesMaxRowSizeIncludeBlobs();
-        databaseMetaData.getMaxStatementLength();
-        databaseMetaData.getMaxStatements();
-        databaseMetaData.getMaxTableNameLength();
-        databaseMetaData.getMaxTablesInSelect();
-        databaseMetaData.getMaxUserNameLength();
-        databaseMetaData.getDefaultTransactionIsolation();
-        databaseMetaData.supportsTransactions();
-        databaseMetaData.supportsTransactionIsolationLevel(0);
-        databaseMetaData.supportsDataDefinitionAndDataManipulationTransactions();
-        databaseMetaData.supportsDataManipulationTransactionsOnly();
-        databaseMetaData.dataDefinitionCausesTransactionCommit();
-        databaseMetaData.dataDefinitionIgnoredInTransactions();
-        try {
-            databaseMetaData.getProcedures("", "", "");
-        } catch (Exception e) {
-        }
-        try {
-            databaseMetaData.getProcedureColumns("", "", "", "");
-        } catch (Exception e) {
-        }
-        try {
-            databaseMetaData.getTables("", "", "", new String[]{""});
-        } catch (Exception e) {
-        }
-        databaseMetaData.getSchemas();
-        databaseMetaData.getCatalogs();
-//        databaseMetaData.getTableTypes();
-
-        databaseMetaData.getColumns(dbName, "", tName, "");
-        databaseMetaData.getColumnPrivileges("", "", "", "");
-        databaseMetaData.getTablePrivileges("", "", "");
-        databaseMetaData.getBestRowIdentifier("", "", "", 0, false);
-        databaseMetaData.getVersionColumns("", "", "");
-        databaseMetaData.getPrimaryKeys("", "", "");
-        databaseMetaData.getImportedKeys("", "", "");
-        databaseMetaData.getExportedKeys("", "", "");
-        databaseMetaData.getCrossReference("", "", "", "", "", "");
-        databaseMetaData.getTypeInfo();
-        databaseMetaData.getIndexInfo("", "", "", false, false);
-        databaseMetaData.supportsResultSetType(0);
-        databaseMetaData.supportsResultSetConcurrency(0, 0);
-        databaseMetaData.ownUpdatesAreVisible(0);
-        databaseMetaData.ownDeletesAreVisible(0);
-        databaseMetaData.ownInsertsAreVisible(0);
-        databaseMetaData.othersUpdatesAreVisible(0);
-        databaseMetaData.othersDeletesAreVisible(0);
-        databaseMetaData.othersInsertsAreVisible(0);
-        databaseMetaData.updatesAreDetected(0);
-        databaseMetaData.deletesAreDetected(0);
-        databaseMetaData.insertsAreDetected(0);
-        databaseMetaData.supportsBatchUpdates();
-        databaseMetaData.getUDTs("", "", "", new int[]{0});
-        databaseMetaData.getConnection();
-        databaseMetaData.supportsSavepoints();
-        databaseMetaData.supportsNamedParameters();
-        databaseMetaData.supportsMultipleOpenResults();
-        databaseMetaData.supportsGetGeneratedKeys();
-        databaseMetaData.getSuperTypes("", "", "");
-        databaseMetaData.getSuperTables("", "", "");
-        databaseMetaData.getAttributes("", "", "", "");
-        databaseMetaData.supportsResultSetHoldability(0);
-        databaseMetaData.getResultSetHoldability();
-        databaseMetaData.getDatabaseMajorVersion();
-        databaseMetaData.getDatabaseMinorVersion();
-        databaseMetaData.getJDBCMajorVersion();
-        databaseMetaData.getJDBCMinorVersion();
-        databaseMetaData.getSQLStateType();
-        databaseMetaData.locatorsUpdateCopy();
-        databaseMetaData.supportsStatementPooling();
-        databaseMetaData.getRowIdLifetime();
-        databaseMetaData.getSchemas("", "");
-        databaseMetaData.supportsStoredFunctionsUsingCallSyntax();
-        databaseMetaData.autoCommitFailureClosesAllResultSets();
-        databaseMetaData.getClientInfoProperties();
-        databaseMetaData.getFunctions("", "", "");
-        databaseMetaData.getFunctionColumns("", "", "", "");
-        databaseMetaData.getPseudoColumns("", "", "", "");
-        databaseMetaData.generatedKeyAlwaysReturned();
-
-    }
-
-    @AfterClass
-    public static void close() throws Exception {
-        statement.executeUpdate("drop database " + dbName);
-        statement.close();
-        connection.close();
-        Thread.sleep(10);
-
-    }
-}
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBDatabaseMetaDataTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBDatabaseMetaDataTest.java
@ -0,0 +1,913 @@
+package com.taosdata.jdbc;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Properties;
+
+public class TSDBDatabaseMetaDataTest {
+    private TSDBDatabaseMetaData metaData;
+    private static final String host = "localhost";
+
+    @Before
+    public void before() throws ClassNotFoundException, SQLException {
+        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");
+        metaData = (TSDBDatabaseMetaData) DriverManager.getConnection("jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata", properties).getMetaData();
+    }
+
+    @Test
+    public void unwrap() throws SQLException {
+        TSDBDatabaseMetaData unwrap = metaData.unwrap(TSDBDatabaseMetaData.class);
+        Assert.assertNotNull(unwrap);
+    }
+
+    @Test
+    public void isWrapperFor() throws SQLException {
+        Assert.assertTrue(metaData.isWrapperFor(TSDBDatabaseMetaData.class));
+    }
+
+    @Test
+    public void allProceduresAreCallable() throws SQLException {
+        Assert.assertFalse(metaData.allProceduresAreCallable());
+    }
+
+    @Test
+    public void allTablesAreSelectable() throws SQLException {
+        Assert.assertFalse(metaData.allTablesAreSelectable());
+    }
+
+    @Test
+    public void getURL() throws SQLException {
+        Assert.assertEquals("jdbc:TAOS://localhost:6030/?user=root&password=taosdata", metaData.getURL());
+    }
+
+    @Test
+    public void getUserName() throws SQLException {
+        Assert.assertEquals("root", metaData.getUserName());
+    }
+
+    @Test
+    public void isReadOnly() throws SQLException {
+        Assert.assertFalse(metaData.isReadOnly());
+    }
+
+    @Test
+    public void nullsAreSortedHigh() throws SQLException {
+        Assert.assertFalse(metaData.nullsAreSortedHigh());
+    }
+
+    @Test
+    public void nullsAreSortedLow() throws SQLException {
+        Assert.assertTrue(metaData.nullsAreSortedLow());
+    }
+
+    @Test
+    public void nullsAreSortedAtStart() throws SQLException {
+        Assert.assertTrue(metaData.nullsAreSortedAtStart());
+    }
+
+    @Test
+    public void nullsAreSortedAtEnd() throws SQLException {
+        Assert.assertFalse(metaData.nullsAreSortedAtEnd());
+    }
+
+    @Test
+    public void getDatabaseProductName() throws SQLException {
+        Assert.assertEquals("TDengine", metaData.getDatabaseProductName());
+    }
+
+    @Test
+    public void getDatabaseProductVersion() throws SQLException {
+        Assert.assertEquals("2.0.x.x", metaData.getDatabaseProductVersion());
+    }
+
+    @Test
+    public void getDriverName() throws SQLException {
+        Assert.assertEquals("com.taosdata.jdbc.TSDBDriver", metaData.getDriverName());
+    }
+
+    @Test
+    public void getDriverVersion() throws SQLException {
+        Assert.assertEquals("2.0.x", metaData.getDriverVersion());
+    }
+
+    @Test
+    public void getDriverMajorVersion() {
+        Assert.assertEquals(2, metaData.getDriverMajorVersion());
+    }
+
+    @Test
+    public void getDriverMinorVersion() {
+        Assert.assertEquals(0, metaData.getDriverMinorVersion());
+    }
+
+    @Test
+    public void usesLocalFiles() throws SQLException {
+        Assert.assertFalse(metaData.usesLocalFiles());
+    }
+
+    @Test
+    public void usesLocalFilePerTable() throws SQLException {
+        Assert.assertFalse(metaData.usesLocalFilePerTable());
+    }
+
+    @Test
+    public void supportsMixedCaseIdentifiers() throws SQLException {
+        Assert.assertFalse(metaData.supportsMixedCaseIdentifiers());
+    }
+
+    @Test
+    public void storesUpperCaseIdentifiers() throws SQLException {
+        Assert.assertFalse(metaData.storesUpperCaseIdentifiers());
+    }
+
+    @Test
+    public void storesLowerCaseIdentifiers() throws SQLException {
+        Assert.assertTrue(metaData.storesLowerCaseIdentifiers());
+    }
+
+    @Test
+    public void storesMixedCaseIdentifiers() throws SQLException {
+        Assert.assertFalse(metaData.storesMixedCaseIdentifiers());
+    }
+
+    @Test
+    public void supportsMixedCaseQuotedIdentifiers() throws SQLException {
+        Assert.assertFalse(metaData.supportsMixedCaseQuotedIdentifiers());
+    }
+
+    @Test
+    public void storesUpperCaseQuotedIdentifiers() throws SQLException {
+        Assert.assertFalse(metaData.storesUpperCaseQuotedIdentifiers());
+    }
+
+    @Test
+    public void storesLowerCaseQuotedIdentifiers() throws SQLException {
+        Assert.assertFalse(metaData.storesLowerCaseQuotedIdentifiers());
+    }
+
+    @Test
+    public void storesMixedCaseQuotedIdentifiers() throws SQLException {
+        Assert.assertFalse(metaData.storesMixedCaseQuotedIdentifiers());
+    }
+
+    @Test
+    public void getIdentifierQuoteString() throws SQLException {
+        Assert.assertEquals(" ", metaData.getIdentifierQuoteString());
+    }
+
+    @Test
+    public void getSQLKeywords() throws SQLException {
+        Assert.assertEquals(null, metaData.getSQLKeywords());
+    }
+
+    @Test
+    public void getNumericFunctions() throws SQLException {
+        Assert.assertEquals(null, metaData.getNumericFunctions());
+    }
+
+    @Test
+    public void getStringFunctions() throws SQLException {
+        Assert.assertEquals(null, metaData.getStringFunctions());
+    }
+
+    @Test
+    public void getSystemFunctions() throws SQLException {
+        Assert.assertEquals(null, metaData.getSystemFunctions());
+    }
+
+    @Test
+    public void getTimeDateFunctions() throws SQLException {
+        Assert.assertEquals(null, metaData.getTimeDateFunctions());
+    }
+
+    @Test
+    public void getSearchStringEscape() throws SQLException {
+        Assert.assertEquals(null, metaData.getSearchStringEscape());
+    }
+
+    @Test
+    public void getExtraNameCharacters() throws SQLException {
+        Assert.assertEquals(null, metaData.getExtraNameCharacters());
+    }
+
+    @Test
+    public void supportsAlterTableWithAddColumn() throws SQLException {
+        Assert.assertTrue(metaData.supportsAlterTableWithAddColumn());
+    }
+
+    @Test
+    public void supportsAlterTableWithDropColumn() throws SQLException {
+        Assert.assertTrue(metaData.supportsAlterTableWithDropColumn());
+    }
+
+    @Test
+    public void supportsColumnAliasing() throws SQLException {
+        Assert.assertTrue(metaData.supportsColumnAliasing());
+    }
+
+    @Test
+    public void nullPlusNonNullIsNull() throws SQLException {
+        Assert.assertFalse(metaData.nullPlusNonNullIsNull());
+    }
+
+    @Test
+    public void supportsConvert() throws SQLException {
+        Assert.assertFalse(metaData.supportsConvert());
+    }
+
+    @Test
+    public void testSupportsConvert() throws SQLException {
+        Assert.assertFalse(metaData.supportsConvert(1, 1));
+    }
+
+    @Test
+    public void supportsTableCorrelationNames() throws SQLException {
+        Assert.assertFalse(metaData.supportsTableCorrelationNames());
+    }
+
+    @Test
+    public void supportsDifferentTableCorrelationNames() throws SQLException {
+        Assert.assertFalse(metaData.supportsDifferentTableCorrelationNames());
+    }
+
+    @Test
+    public void supportsExpressionsInOrderBy() throws SQLException {
+        Assert.assertFalse(metaData.supportsExpressionsInOrderBy());
+    }
+
+    @Test
+    public void supportsOrderByUnrelated() throws SQLException {
+        Assert.assertFalse(metaData.supportsOrderByUnrelated());
+    }
+
+    @Test
+    public void supportsGroupBy() throws SQLException {
+        Assert.assertTrue(metaData.supportsGroupBy());
+    }
+
+    @Test
+    public void supportsGroupByUnrelated() throws SQLException {
+        Assert.assertFalse(metaData.supportsGroupByUnrelated());
+    }
+
+    @Test
+    public void supportsGroupByBeyondSelect() throws SQLException {
+        Assert.assertFalse(metaData.supportsGroupByBeyondSelect());
+    }
+
+    @Test
+    public void supportsLikeEscapeClause() throws SQLException {
+        Assert.assertFalse(metaData.supportsLikeEscapeClause());
+    }
+
+    @Test
+    public void supportsMultipleResultSets() throws SQLException {
+        Assert.assertFalse(metaData.supportsMultipleResultSets());
+    }
+
+    @Test
+    public void supportsMultipleTransactions() throws SQLException {
+        Assert.assertFalse(metaData.supportsMultipleTransactions());
+    }
+
+    @Test
+    public void supportsNonNullableColumns() throws SQLException {
+        Assert.assertFalse(metaData.supportsNonNullableColumns());
+    }
+
+    @Test
+    public void supportsMinimumSQLGrammar() throws SQLException {
+        Assert.assertFalse(metaData.supportsMinimumSQLGrammar());
+    }
+
+    @Test
+    public void supportsCoreSQLGrammar() throws SQLException {
+        Assert.assertFalse(metaData.supportsCoreSQLGrammar());
+    }
+
+    @Test
+    public void supportsExtendedSQLGrammar() throws SQLException {
+        Assert.assertFalse(metaData.supportsExtendedSQLGrammar());
+    }
+
+    @Test
+    public void supportsANSI92EntryLevelSQL() throws SQLException {
+        Assert.assertFalse(metaData.supportsANSI92EntryLevelSQL());
+    }
+
+    @Test
+    public void supportsANSI92IntermediateSQL() throws SQLException {
+        Assert.assertFalse(metaData.supportsANSI92IntermediateSQL());
+    }
+
+    @Test
+    public void supportsANSI92FullSQL() throws SQLException {
+        Assert.assertFalse(metaData.supportsANSI92FullSQL());
+    }
+
+    @Test
+    public void supportsIntegrityEnhancementFacility() throws SQLException {
+        Assert.assertFalse(metaData.supportsIntegrityEnhancementFacility());
+    }
+
+    @Test
+    public void supportsOuterJoins() throws SQLException {
+        Assert.assertFalse(metaData.supportsOuterJoins());
+    }
+
+    @Test
+    public void supportsFullOuterJoins() throws SQLException {
+        Assert.assertFalse(metaData.supportsFullOuterJoins());
+    }
+
+    @Test
+    public void supportsLimitedOuterJoins() throws SQLException {
+        Assert.assertFalse(metaData.supportsLimitedOuterJoins());
+    }
+
+    @Test
+    public void getSchemaTerm() throws SQLException {
+        Assert.assertNull(metaData.getSchemaTerm());
+    }
+
+    @Test
+    public void getProcedureTerm() throws SQLException {
+        Assert.assertNull(metaData.getProcedureTerm());
+    }
+
+    @Test
+    public void getCatalogTerm() throws SQLException {
+        Assert.assertEquals("database", metaData.getCatalogTerm());
+    }
+
+    @Test
+    public void isCatalogAtStart() throws SQLException {
+        Assert.assertTrue(metaData.isCatalogAtStart());
+    }
+
+    @Test
+    public void getCatalogSeparator() throws SQLException {
+        Assert.assertEquals(".", metaData.getCatalogSeparator());
+    }
+
+    @Test
+    public void supportsSchemasInDataManipulation() throws SQLException {
+        Assert.assertFalse(metaData.supportsSchemasInDataManipulation());
+    }
+
+    @Test
+    public void supportsSchemasInProcedureCalls() throws SQLException {
+        Assert.assertFalse(metaData.supportsSchemasInProcedureCalls());
+    }
+
+    @Test
+    public void supportsSchemasInTableDefinitions() throws SQLException {
+        Assert.assertFalse(metaData.supportsSchemasInTableDefinitions());
+    }
+
+    @Test
+    public void supportsSchemasInIndexDefinitions() throws SQLException {
+        Assert.assertFalse(metaData.supportsSchemasInIndexDefinitions());
+    }
+
+    @Test
+    public void supportsSchemasInPrivilegeDefinitions() throws SQLException {
+        Assert.assertFalse(metaData.supportsSchemasInPrivilegeDefinitions());
+    }
+
+    @Test
+    public void supportsCatalogsInDataManipulation() throws SQLException {
+        Assert.assertTrue(metaData.supportsCatalogsInDataManipulation());
+    }
+
+    @Test
+    public void supportsCatalogsInProcedureCalls() throws SQLException {
+        Assert.assertFalse(metaData.supportsCatalogsInProcedureCalls());
+    }
+
+    @Test
+    public void supportsCatalogsInTableDefinitions() throws SQLException {
+        Assert.assertFalse(metaData.supportsCatalogsInTableDefinitions());
+    }
+
+    @Test
+    public void supportsCatalogsInIndexDefinitions() throws SQLException {
+        Assert.assertFalse(metaData.supportsCatalogsInIndexDefinitions());
+    }
+
+    @Test
+    public void supportsCatalogsInPrivilegeDefinitions() throws SQLException {
+        Assert.assertFalse(metaData.supportsCatalogsInPrivilegeDefinitions());
+    }
+
+    @Test
+    public void supportsPositionedDelete() throws SQLException {
+        Assert.assertFalse(metaData.supportsPositionedDelete());
+    }
+
+    @Test
+    public void supportsPositionedUpdate() throws SQLException {
+        Assert.assertFalse(metaData.supportsPositionedUpdate());
+    }
+
+    @Test
+    public void supportsSelectForUpdate() throws SQLException {
+        Assert.assertFalse(metaData.supportsSelectForUpdate());
+    }
+
+    @Test
+    public void supportsStoredProcedures() throws SQLException {
+        Assert.assertFalse(metaData.supportsStoredProcedures());
+    }
+
+    @Test
+    public void supportsSubqueriesInComparisons() throws SQLException {
+        Assert.assertFalse(metaData.supportsSubqueriesInComparisons());
+    }
+
+    @Test
+    public void supportsSubqueriesInExists() throws SQLException {
+        Assert.assertFalse(metaData.supportsSubqueriesInExists());
+    }
+
+    @Test
+    public void supportsSubqueriesInIns() throws SQLException {
+        Assert.assertFalse(metaData.supportsSubqueriesInIns());
+    }
+
+    @Test
+    public void supportsSubqueriesInQuantifieds() throws SQLException {
+        Assert.assertFalse(metaData.supportsSubqueriesInQuantifieds());
+    }
+
+    @Test
+    public void supportsCorrelatedSubqueries() throws SQLException {
+        Assert.assertFalse(metaData.supportsCorrelatedSubqueries());
+    }
+
+    @Test
+    public void supportsUnion() throws SQLException {
+        Assert.assertFalse(metaData.supportsUnion());
+    }
+
+    @Test
+    public void supportsUnionAll() throws SQLException {
+        Assert.assertFalse(metaData.supportsUnionAll());
+    }
+
+    @Test
+    public void supportsOpenCursorsAcrossCommit() throws SQLException {
+        Assert.assertFalse(metaData.supportsOpenCursorsAcrossCommit());
+    }
+
+    @Test
+    public void supportsOpenCursorsAcrossRollback() throws SQLException {
+        Assert.assertFalse(metaData.supportsOpenCursorsAcrossRollback());
+    }
+
+    @Test
+    public void supportsOpenStatementsAcrossCommit() throws SQLException {
+        Assert.assertFalse(metaData.supportsOpenStatementsAcrossCommit());
+    }
+
+    @Test
+    public void supportsOpenStatementsAcrossRollback() throws SQLException {
+        Assert.assertFalse(metaData.supportsOpenStatementsAcrossRollback());
+    }
+
+    @Test
+    public void getMaxBinaryLiteralLength() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxBinaryLiteralLength());
+    }
+
+    @Test
+    public void getMaxCharLiteralLength() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxCharLiteralLength());
+    }
+
+    @Test
+    public void getMaxColumnNameLength() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxColumnNameLength());
+    }
+
+    @Test
+    public void getMaxColumnsInGroupBy() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxColumnsInGroupBy());
+    }
+
+    @Test
+    public void getMaxColumnsInIndex() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxColumnsInIndex());
+    }
+
+    @Test
+    public void getMaxColumnsInOrderBy() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxColumnsInOrderBy());
+    }
+
+    @Test
+    public void getMaxColumnsInSelect() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxColumnsInSelect());
+    }
+
+    @Test
+    public void getMaxColumnsInTable() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxColumnsInTable());
+    }
+
+    @Test
+    public void getMaxConnections() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxConnections());
+    }
+
+    @Test
+    public void getMaxCursorNameLength() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxCursorNameLength());
+    }
+
+    @Test
+    public void getMaxIndexLength() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxIndexLength());
+    }
+
+    @Test
+    public void getMaxSchemaNameLength() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxSchemaNameLength());
+    }
+
+    @Test
+    public void getMaxProcedureNameLength() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxProcedureNameLength());
+    }
+
+    @Test
+    public void getMaxCatalogNameLength() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxCatalogNameLength());
+    }
+
+    @Test
+    public void getMaxRowSize() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxRowSize());
+    }
+
+    @Test
+    public void doesMaxRowSizeIncludeBlobs() throws SQLException {
+        Assert.assertFalse(metaData.doesMaxRowSizeIncludeBlobs());
+    }
+
+    @Test
+    public void getMaxStatementLength() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxStatementLength());
+    }
+
+    @Test
+    public void getMaxStatements() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxStatements());
+    }
+
+    @Test
+    public void getMaxTableNameLength() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxTableNameLength());
+    }
+
+    @Test
+    public void getMaxTablesInSelect() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxTablesInSelect());
+    }
+
+    @Test
+    public void getMaxUserNameLength() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxUserNameLength());
+    }
+
+    @Test
+    public void getDefaultTransactionIsolation() throws SQLException {
+        Assert.assertEquals(Connection.TRANSACTION_NONE, metaData.getDefaultTransactionIsolation());
+    }
+
+    @Test
+    public void supportsTransactions() throws SQLException {
+        Assert.assertFalse(metaData.supportsTransactions());
+    }
+
+    @Test
+    public void supportsTransactionIsolationLevel() throws SQLException {
+        Assert.assertTrue(metaData.supportsTransactionIsolationLevel(Connection.TRANSACTION_NONE));
+        Assert.assertFalse(metaData.supportsTransactionIsolationLevel(Connection.TRANSACTION_READ_COMMITTED));
+        Assert.assertFalse(metaData.supportsTransactionIsolationLevel(Connection.TRANSACTION_READ_UNCOMMITTED));
+        Assert.assertFalse(metaData.supportsTransactionIsolationLevel(Connection.TRANSACTION_REPEATABLE_READ));
+        Assert.assertFalse(metaData.supportsTransactionIsolationLevel(Connection.TRANSACTION_SERIALIZABLE));
+    }
+
+    @Test
+    public void supportsDataDefinitionAndDataManipulationTransactions() throws SQLException {
+        Assert.assertFalse(metaData.supportsDataDefinitionAndDataManipulationTransactions());
+    }
+
+    @Test
+    public void supportsDataManipulationTransactionsOnly() throws SQLException {
+        Assert.assertFalse(metaData.supportsDataManipulationTransactionsOnly());
+    }
+
+    @Test
+    public void dataDefinitionCausesTransactionCommit() throws SQLException {
+        Assert.assertFalse(metaData.dataDefinitionCausesTransactionCommit());
+    }
+
+    @Test
+    public void dataDefinitionIgnoredInTransactions() throws SQLException {
+        Assert.assertFalse(metaData.dataDefinitionIgnoredInTransactions());
+    }
+
+    @Test
+    public void getProcedures() throws SQLException {
+        Assert.assertNull(metaData.getProcedures("*", "*", "*"));
+    }
+
+    @Test
+    public void getProcedureColumns() throws SQLException {
+        Assert.assertNull(metaData.getProcedureColumns("*", "*", "*", "*"));
+    }
+
+    @Test
+    public void getTables() throws SQLException {
+        Assert.assertNull(metaData.getTables("", "", "*", null));
+    }
+
+    @Test
+    public void getSchemas() throws SQLException {
+        Assert.assertNotNull(metaData.getSchemas());
+    }
+
+    @Test
+    public void getCatalogs() throws SQLException {
+        Assert.assertNotNull(metaData.getCatalogs());
+    }
+
+    @Test
+    public void getTableTypes() throws SQLException {
+        Assert.assertNotNull(metaData.getTableTypes());
+    }
+
+    @Test
+    public void getColumns() throws SQLException {
+        Assert.assertNotNull(metaData.getColumns("", "", "", ""));
+    }
+
+    @Test
+    public void getColumnPrivileges() throws SQLException {
+        Assert.assertNotNull(metaData.getColumnPrivileges("", "", "", ""));
+    }
+
+    @Test
+    public void getTablePrivileges() throws SQLException {
+        Assert.assertNotNull(metaData.getTablePrivileges("", "", ""));
+    }
+
+    @Test
+    public void getBestRowIdentifier() throws SQLException {
+        Assert.assertNotNull(metaData.getBestRowIdentifier("", "", "", 0, false));
+    }
+
+    @Test
+    public void getVersionColumns() throws SQLException {
+        Assert.assertNotNull(metaData.getVersionColumns("", "", ""));
+    }
+
+    @Test
+    public void getPrimaryKeys() throws SQLException {
+        Assert.assertNotNull(metaData.getPrimaryKeys("", "", ""));
+    }
+
+    @Test
+    public void getImportedKeys() throws SQLException {
+        Assert.assertNotNull(metaData.getImportedKeys("", "", ""));
+    }
+
+    @Test
+    public void getExportedKeys() throws SQLException {
+        Assert.assertNotNull(metaData.getExportedKeys("", "", ""));
+    }
+
+    @Test
+    public void getCrossReference() throws SQLException {
+        Assert.assertNotNull(metaData.getCrossReference("", "", "", "", "", ""));
+    }
+
+    @Test
+    public void getTypeInfo() throws SQLException {
+        Assert.assertNotNull(metaData.getTypeInfo());
+    }
+
+    @Test
+    public void getIndexInfo() throws SQLException {
+        Assert.assertNotNull(metaData.getIndexInfo("", "", "", false, false));
+    }
+
+    @Test
+    public void supportsResultSetType() throws SQLException {
+        Assert.assertFalse(metaData.supportsResultSetType(0));
+    }
+
+    @Test
+    public void supportsResultSetConcurrency() throws SQLException {
+        Assert.assertFalse(metaData.supportsResultSetConcurrency(0, 0));
+    }
+
+    @Test
+    public void ownUpdatesAreVisible() throws SQLException {
+        Assert.assertFalse(metaData.ownUpdatesAreVisible(0));
+    }
+
+    @Test
+    public void ownDeletesAreVisible() throws SQLException {
+        Assert.assertFalse(metaData.ownDeletesAreVisible(0));
+    }
+
+    @Test
+    public void ownInsertsAreVisible() throws SQLException {
+        Assert.assertFalse(metaData.ownInsertsAreVisible(0));
+    }
+
+    @Test
+    public void othersUpdatesAreVisible() throws SQLException {
+        Assert.assertFalse(metaData.othersUpdatesAreVisible(0));
+    }
+
+    @Test
+    public void othersDeletesAreVisible() throws SQLException {
+        Assert.assertFalse(metaData.othersDeletesAreVisible(0));
+    }
+
+    @Test
+    public void othersInsertsAreVisible() throws SQLException {
+        Assert.assertFalse(metaData.othersInsertsAreVisible(0));
+    }
+
+    @Test
+    public void updatesAreDetected() throws SQLException {
+        Assert.assertFalse(metaData.updatesAreDetected(0));
+    }
+
+    @Test
+    public void deletesAreDetected() throws SQLException {
+        Assert.assertFalse(metaData.deletesAreDetected(0));
+    }
+
+    @Test
+    public void insertsAreDetected() throws SQLException {
+        Assert.assertFalse(metaData.insertsAreDetected(0));
+    }
+
+    @Test
+    public void supportsBatchUpdates() throws SQLException {
+        Assert.assertFalse(metaData.supportsBatchUpdates());
+    }
+
+    @Test
+    public void getUDTs() throws SQLException {
+        Assert.assertNotNull(metaData.getUDTs("", "", "", null));
+    }
+
+    @Test
+    public void getConnection() throws SQLException {
+        Assert.assertNotNull(metaData.getConnection());
+    }
+
+    @Test
+    public void supportsSavepoints() throws SQLException {
+        Assert.assertFalse(metaData.supportsSavepoints());
+    }
+
+    @Test
+    public void supportsNamedParameters() throws SQLException {
+        Assert.assertFalse(metaData.supportsNamedParameters());
+    }
+
+    @Test
+    public void supportsMultipleOpenResults() throws SQLException {
+        Assert.assertFalse(metaData.supportsMultipleOpenResults());
+    }
+
+    @Test
+    public void supportsGetGeneratedKeys() throws SQLException {
+        Assert.assertFalse(metaData.supportsGetGeneratedKeys());
+    }
+
+    @Test
+    public void getSuperTypes() throws SQLException {
+        Assert.assertNotNull(metaData.getSuperTypes("", "", ""));
+    }
+
+    @Test
+    public void getSuperTables() throws SQLException {
+        Assert.assertNotNull(metaData.getSuperTables("", "", ""));
+    }
+
+    @Test
+    public void getAttributes() throws SQLException {
+        Assert.assertNotNull(metaData.getAttributes("", "", "", ""));
+    }
+
+    @Test
+    public void supportsResultSetHoldability() throws SQLException {
+        Assert.assertTrue(metaData.supportsResultSetHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT));
+        Assert.assertFalse(metaData.supportsResultSetHoldability(ResultSet.CLOSE_CURSORS_AT_COMMIT));
+    }
+
+    @Test
+    public void getResultSetHoldability() throws SQLException {
+        Assert.assertEquals(1, metaData.getResultSetHoldability());
+    }
+
+    @Test
+    public void getDatabaseMajorVersion() throws SQLException {
+        Assert.assertEquals(2, metaData.getDatabaseMajorVersion());
+    }
+
+    @Test
+    public void getDatabaseMinorVersion() throws SQLException {
+        Assert.assertEquals(0, metaData.getDatabaseMinorVersion());
+    }
+
+    @Test
+    public void getJDBCMajorVersion() throws SQLException {
+        Assert.assertEquals(2, metaData.getJDBCMajorVersion());
+    }
+
+    @Test
+    public void getJDBCMinorVersion() throws SQLException {
+        Assert.assertEquals(0, metaData.getJDBCMinorVersion());
+    }
+
+    @Test
+    public void getSQLStateType() throws SQLException {
+        Assert.assertEquals(0, metaData.getSQLStateType());
+    }
+
+    @Test
+    public void locatorsUpdateCopy() throws SQLException {
+        Assert.assertFalse(metaData.locatorsUpdateCopy());
+    }
+
+    @Test
+    public void supportsStatementPooling() throws SQLException {
+        Assert.assertFalse(metaData.supportsStatementPooling());
+    }
+
+    @Test
+    public void getRowIdLifetime() throws SQLException {
+        Assert.assertNull(metaData.getRowIdLifetime());
+    }
+
+    @Test
+    public void testGetSchemas() throws SQLException {
+        Assert.assertNull(metaData.getSchemas());
+    }
+
+    @Test
+    public void supportsStoredFunctionsUsingCallSyntax() throws SQLException {
+        Assert.assertFalse(metaData.supportsStoredFunctionsUsingCallSyntax());
+    }
+
+    @Test
+    public void autoCommitFailureClosesAllResultSets() throws SQLException {
+        Assert.assertFalse(metaData.autoCommitFailureClosesAllResultSets());
+    }
+
+    @Test
+    public void getClientInfoProperties() throws SQLException {
+        Assert.assertNotNull(metaData.getClientInfoProperties());
+    }
+
+    @Test
+    public void getFunctions() throws SQLException {
+        Assert.assertNotNull(metaData.getFunctions("", "", ""));
+    }
+
+    @Test
+    public void getFunctionColumns() throws SQLException {
+        Assert.assertNotNull(metaData.getFunctionColumns("", "", "", ""));
+    }
+
+    @Test
+    public void getPseudoColumns() throws SQLException {
+        Assert.assertNotNull(metaData.getPseudoColumns("", "", "", ""));
+    }
+
+    @Test
+    public void generatedKeyAlwaysReturned() throws SQLException {
+        Assert.assertFalse(metaData.generatedKeyAlwaysReturned());
+    }
+}
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/MultiThreadsWithSameStatmentTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/MultiThreadsWithSameStatmentTest.java
@ -0,0 +1,91 @@
+package com.taosdata.jdbc.cases;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.sql.*;
+import java.util.concurrent.TimeUnit;
+
+public class MultiThreadsWithSameStatmentTest {
+
+
+    private class Service {
+        public Connection conn;
+        public Statement stmt;
+
+        public Service() {
+            try {
+                Class.forName("com.taosdata.jdbc.TSDBDriver");
+                conn = DriverManager.getConnection("jdbc:TAOS://localhost:6030/?user=root&password=taosdata");
+                stmt = conn.createStatement();
+                stmt.execute("create database if not exists jdbctest");
+                stmt.executeUpdate("create table if not exists jdbctest.weather (ts timestamp, f1 int)");
+            } catch (ClassNotFoundException | SQLException e) {
+                e.printStackTrace();
+            }
+        }
+
+        public void release() {
+            try {
+                stmt.close();
+                conn.close();
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Before
+    public void before() {
+    }
+
+    @Test
+    public void test() {
+        Thread t1 = new Thread(() -> {
+            try {
+                Service service = new Service();
+                ResultSet resultSet = service.stmt.executeQuery("select * from jdbctest.weather");
+                while (resultSet.next()) {
+                    ResultSetMetaData metaData = resultSet.getMetaData();
+                    for (int i = 1; i <= metaData.getColumnCount(); i++) {
+                        System.out.print(metaData.getColumnLabel(i) + ": " + resultSet.getString(i));
+                    }
+                    System.out.println();
+                }
+                resultSet.close();
+                service.release();
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
+        });
+
+        Thread t2 = new Thread(() -> {
+            while (true) {
+                try {
+                    Service service = new Service();
+                    service.stmt.executeUpdate("insert into jdbctest.weather values(now,1)");
+                    service.release();
+                } catch (SQLException e) {
+                    e.printStackTrace();
+                }
+            }
+
+        });
+        t1.start();
+        sleep(1000);
+        t2.start();
+    }
+
+    private void sleep(long mills) {
+        try {
+            TimeUnit.MILLISECONDS.sleep(mills);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @After
+    public void after() {
+    }
+}
--- a/src/connector/odbc/CMakeLists.txt
+++ b/src/connector/odbc/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 IF (TD_LINUX_64)
--- a/src/connector/odbc/src/CMakeLists.txt
+++ b/src/connector/odbc/src/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 IF (TD_LINUX_64)
--- a/src/connector/python/linux/python2/setup.py
+++ b/src/connector/python/linux/python2/setup.py
@ -5,7 +5,7 @@ with open("README.md", "r") as fh:

 setuptools.setup(
    name="taos",
-    version="2.0.3",
+    version="2.0.4",
    author="Taosdata Inc.",
    author_email="support@taosdata.com",
    description="TDengine python client package",
--- a/src/connector/python/linux/python2/taos/cursor.py
+++ b/src/connector/python/linux/python2/taos/cursor.py
@ -184,7 +184,7 @@ class TDengineCursor(object):

        return False

-    def fetchall(self):
+    def fetchall_row(self):
        """Fetch all (remaining) rows of a query result, returning them as a sequence of sequences (e.g. a list of tuples). Note that the cursor's arraysize attribute can affect the performance of this operation.
        """
        if self._result is None or self._fields is None:
@ -203,7 +203,7 @@ class TDengineCursor(object):
            for i in range(len(self._fields)):
                buffer[i].extend(block[i])
        return list(map(tuple, zip(*buffer)))
-    def fetchall_block(self):
+    def fetchall(self):
        if self._result is None or self._fields is None:
            raise OperationalError("Invalid use of fetchall")

--- a/src/connector/python/linux/python3/setup.py
+++ b/src/connector/python/linux/python3/setup.py
@ -5,7 +5,7 @@ with open("README.md", "r") as fh:

 setuptools.setup(
    name="taos",
-    version="2.0.3",
+    version="2.0.4",
    author="Taosdata Inc.",
    author_email="support@taosdata.com",
    description="TDengine python client package",
--- a/src/connector/python/linux/python3/taos/cursor.py
+++ b/src/connector/python/linux/python3/taos/cursor.py
@ -192,7 +192,7 @@ class TDengineCursor(object):

        return False

-    def fetchall(self):
+    def fetchall_row(self):
        """Fetch all (remaining) rows of a query result, returning them as a sequence of sequences (e.g. a list of tuples). Note that the cursor's arraysize attribute can affect the performance of this operation.
        """
        if self._result is None or self._fields is None:
@ -212,7 +212,7 @@ class TDengineCursor(object):
                buffer[i].extend(block[i])
        return list(map(tuple, zip(*buffer)))

-    def fetchall_block(self):
+    def fetchall(self):
        if self._result is None or self._fields is None:
            raise OperationalError("Invalid use of fetchall")

--- a/src/connector/python/windows/python2/setup.py
+++ b/src/connector/python/windows/python2/setup.py
@ -5,7 +5,7 @@ with open("README.md", "r") as fh:

 setuptools.setup(
    name="taos",
-    version="2.0.3",
+    version="2.0.4",
    author="Taosdata Inc.",
    author_email="support@taosdata.com",
    description="TDengine python client package",
--- a/src/connector/python/windows/python2/taos/cursor.py
+++ b/src/connector/python/windows/python2/taos/cursor.py
@ -138,7 +138,7 @@ class TDengineCursor(object):
    def fetchmany(self):
        pass

-    def fetchall(self):
+    def fetchall_row(self):
        """Fetch all (remaining) rows of a query result, returning them as a sequence of sequences (e.g. a list of tuples). Note that the cursor's arraysize attribute can affect the performance of this operation.
        """
        if self._result is None or self._fields is None:
@ -158,7 +158,7 @@ class TDengineCursor(object):
                buffer[i].extend(block[i])
        return list(map(tuple, zip(*buffer)))
        
-    def fetchall_block(self):
+    def fetchall(self):
        if self._result is None or self._fields is None:
            raise OperationalError("Invalid use of fetchall")

--- a/src/connector/python/windows/python3/setup.py
+++ b/src/connector/python/windows/python3/setup.py
@ -5,7 +5,7 @@ with open("README.md", "r") as fh:

 setuptools.setup(
    name="taos",
-    version="2.0.3",
+    version="2.0.4",
    author="Taosdata Inc.",
    author_email="support@taosdata.com",
    description="TDengine python client package",
--- a/src/connector/python/windows/python3/taos/cursor.py
+++ b/src/connector/python/windows/python3/taos/cursor.py
@ -139,7 +139,7 @@ class TDengineCursor(object):
    def fetchmany(self):
        pass

-    def fetchall(self):
+    def fetchall_row(self):
        """Fetch all (remaining) rows of a query result, returning them as a sequence of sequences (e.g. a list of tuples). Note that the cursor's arraysize attribute can affect the performance of this operation.
        """
        if self._result is None or self._fields is None:
@ -159,7 +159,7 @@ class TDengineCursor(object):
                buffer[i].extend(block[i])
        return list(map(tuple, zip(*buffer)))

-    def fetchall_block(self):
+    def fetchall(self):
        if self._result is None or self._fields is None:
            raise OperationalError("Invalid use of fetchall")

--- a/src/cq/CMakeLists.txt
+++ b/src/cq/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 INCLUDE_DIRECTORIES(inc)
--- a/src/cq/src/cqMain.c
+++ b/src/cq/src/cqMain.c
@ -43,7 +43,7 @@ typedef struct {
  int32_t  master;
  int32_t  num;      // number of continuous streams
  char     user[TSDB_USER_LEN];
-  char     pass[TSDB_PASSWORD_LEN];
+  char     pass[TSDB_KEY_LEN];
  char     db[TSDB_DB_NAME_LEN];
  FCqWrite cqWrite;
  struct SCqObj *pHead;
--- a/src/cq/test/CMakeLists.txt
+++ b/src/cq/test/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 LIST(APPEND CQTEST_SRC ./cqtest.c)
--- a/src/dnode/CMakeLists.txt
+++ b/src/dnode/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc)
--- a/src/dnode/src/dnodeVWrite.c
+++ b/src/dnode/src/dnodeVWrite.c
@ -202,13 +202,14 @@ static void *dnodeProcessVWriteQueue(void *wparam) {
    for (int32_t i = 0; i < numOfMsgs; ++i) {
      taosGetQitem(pWorker->qall, &qtype, (void **)&pWrite);
      dTrace("msg:%p, app:%p type:%s will be processed in vwrite queue, qtype:%s hver:%" PRIu64, pWrite,
-             pWrite->rpcMsg.ahandle, taosMsg[pWrite->pHead->msgType], qtypeStr[qtype], pWrite->pHead->version);
+             pWrite->rpcMsg.ahandle, taosMsg[pWrite->pHead.msgType], qtypeStr[qtype], pWrite->pHead.version);

-      pWrite->code = vnodeProcessWrite(pVnode, pWrite->pHead, qtype, &pWrite->rspRet);
+      pWrite->code = vnodeProcessWrite(pVnode, &pWrite->pHead, qtype, pWrite);
      if (pWrite->code <= 0) pWrite->processedCount = 1;
-      if (pWrite->code == 0 && pWrite->pHead->msgType != TSDB_MSG_TYPE_SUBMIT) forceFsync = true;
+      if (pWrite->code > 0) pWrite->code = 0;
+      if (pWrite->code == 0 && pWrite->pHead.msgType != TSDB_MSG_TYPE_SUBMIT) forceFsync = true;

-      dTrace("msg:%p is processed in vwrite queue, result:%s", pWrite, tstrerror(pWrite->code));
+      dTrace("msg:%p is processed in vwrite queue, code:0x%x", pWrite, pWrite->code);
    }

    walFsync(vnodeGetWal(pVnode), forceFsync);
@ -221,7 +222,7 @@ static void *dnodeProcessVWriteQueue(void *wparam) {
        dnodeSendRpcVWriteRsp(pVnode, pWrite, pWrite->code);
      } else {
        if (qtype == TAOS_QTYPE_FWD) {
-          vnodeConfirmForward(pVnode, pWrite->pHead->version, 0);
+          vnodeConfirmForward(pVnode, pWrite->pHead.version, 0);
        }
        if (pWrite->rspRet.rsp) {
          rpcFreeCont(pWrite->rspRet.rsp);
--- a/src/inc/taosdef.h
+++ b/src/inc/taosdef.h
@ -256,10 +256,8 @@ int32_t tStrToInteger(const char* z, int16_t type, int32_t n, int64_t* value, bo
 #define TSDB_USER_LEN             TSDB_UNI_LEN

 // ACCOUNT is a 32 bit positive integer
-// this is the length of its string representation
-// including the terminator zero
-#define TSDB_ACCT_LEN             11
-#define TSDB_PASSWORD_LEN         TSDB_UNI_LEN
+// this is the length of its string representation, including the terminator zero
+#define TSDB_ACCT_ID_LEN          11

 #define TSDB_MAX_COLUMNS          1024
 #define TSDB_MIN_COLUMNS          2       //PRIMARY COLUMN(timestamp) + other columns
@ -267,7 +265,7 @@ int32_t tStrToInteger(const char* z, int16_t type, int32_t n, int64_t* value, bo
 #define TSDB_NODE_NAME_LEN        64
 #define TSDB_TABLE_NAME_LEN       193     // it is a null-terminated string
 #define TSDB_DB_NAME_LEN          33
-#define TSDB_TABLE_FNAME_LEN      (TSDB_ACCT_LEN + TSDB_DB_NAME_LEN + TSDB_TABLE_NAME_LEN)
+#define TSDB_TABLE_FNAME_LEN      (TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN + TSDB_TABLE_NAME_LEN)
 #define TSDB_COL_NAME_LEN         65
 #define TSDB_MAX_SAVED_SQL_LEN    TSDB_MAX_COLUMNS * 64
 #define TSDB_MAX_SQL_LEN          TSDB_PAYLOAD_SIZE
@ -293,11 +291,6 @@ int32_t tStrToInteger(const char* z, int16_t type, int32_t n, int64_t* value, bo
 #define TSDB_EP_LEN               (TSDB_FQDN_LEN+6)
 #define TSDB_IPv4ADDR_LEN      	  16
 #define TSDB_FILENAME_LEN         128
-#define TSDB_METER_VNODE_BITS     20
-#define TSDB_METER_SID_MASK       0xFFFFF
-#define TSDB_SHELL_VNODE_BITS     24
-#define TSDB_SHELL_SID_MASK       0xFF
-#define TSDB_HTTP_TOKEN_LEN       20
 #define TSDB_SHOW_SQL_LEN         512
 #define TSDB_SLOW_QUERY_SQL_LEN   512

@ -311,9 +304,6 @@ int32_t tStrToInteger(const char* z, int16_t type, int32_t n, int64_t* value, bo
 #define TSDB_MQTT_TOPIC_LEN       64
 #define TSDB_MQTT_CLIENT_ID_LEN   32

-#define TSDB_METER_STATE_OFFLINE  0
-#define TSDB_METER_STATE_ONLLINE  1
-
 #define TSDB_DEFAULT_PKT_SIZE     65480  //same as RPC_MAX_UDP_SIZE

 #define TSDB_PAYLOAD_SIZE         TSDB_DEFAULT_PKT_SIZE
@ -333,7 +323,7 @@ int32_t tStrToInteger(const char* z, int16_t type, int32_t n, int64_t* value, bo

 #define TSDB_TBNAME_COLUMN_INDEX        (-1)
 #define TSDB_UD_COLUMN_INDEX            (-100)
-#define TSDB_MULTI_METERMETA_MAX_NUM    100000  // maximum batch size allowed to load metermeta
+#define TSDB_MULTI_TABLEMETA_MAX_NUM    100000  // maximum batch size allowed to load table meta

 #define TSDB_MIN_CACHE_BLOCK_SIZE       1
 #define TSDB_MAX_CACHE_BLOCK_SIZE       128     // 128MB for each vnode
@ -395,6 +385,9 @@ int32_t tStrToInteger(const char* z, int16_t type, int32_t n, int64_t* value, bo
 #define TSDB_MIN_DB_REPLICA_OPTION      1
 #define TSDB_MAX_DB_REPLICA_OPTION      3
 #define TSDB_DEFAULT_DB_REPLICA_OPTION  1
+
+#define TSDB_MIN_DB_QUORUM_OPTION       1
+#define TSDB_MAX_DB_QUORUM_OPTION       2
 #define TSDB_DEFAULT_DB_QUORUM_OPTION   1

 #define TSDB_MAX_JOIN_TABLE_NUM         5
@ -451,7 +444,7 @@ int32_t tStrToInteger(const char* z, int16_t type, int32_t n, int64_t* value, bo
 #define TSDB_PORT_HTTP                  11
 #define TSDB_PORT_ARBITRATOR            12

-#define TSDB_MAX_WAL_SIZE    (1024*1024*2)
+#define TSDB_MAX_WAL_SIZE    (1024*1024*3)

 typedef enum {
  TAOS_QTYPE_RPC   = 0,
--- a/src/inc/taosmsg.h
+++ b/src/inc/taosmsg.h
@ -268,7 +268,7 @@ typedef struct {
 typedef struct {
  int32_t len;  // one create table message
  char    tableId[TSDB_TABLE_FNAME_LEN];
-  char    db[TSDB_ACCT_LEN + TSDB_DB_NAME_LEN];
+  char    db[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN];
  int8_t  igExists;
  int8_t  getMeta;
  int16_t numOfTags;
@ -290,7 +290,7 @@ typedef struct {

 typedef struct {
  char    tableId[TSDB_TABLE_FNAME_LEN];
-  char    db[TSDB_ACCT_LEN + TSDB_DB_NAME_LEN];
+  char    db[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN];
  int16_t type; /* operation type   */
  int16_t numOfCols; /* number of schema */
  int32_t tagValLen;
@ -322,7 +322,7 @@ typedef struct {
 } SConnectMsg;

 typedef struct {
-  char      acctId[TSDB_ACCT_LEN];
+  char      acctId[TSDB_ACCT_ID_LEN];
  char      serverVersion[TSDB_VERSION_LEN];
  char      clusterId[TSDB_CLUSTER_ID_LEN];
  int8_t    writeAuth;
@ -534,7 +534,7 @@ typedef struct {
 } SVnodeLoad;

 typedef struct {
-  char     db[TSDB_ACCT_LEN + TSDB_DB_NAME_LEN];
+  char     db[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN];
  int32_t  cacheBlockSize; //MB
  int32_t  totalBlocks;
  int32_t  maxTables;
@ -682,7 +682,7 @@ typedef struct {
 } SVnodeDesc;

 typedef struct {
-  char       db[TSDB_ACCT_LEN + TSDB_DB_NAME_LEN];
+  char       db[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN];
  SVnodeCfg  cfg;
  SVnodeDesc nodes[TSDB_MAX_REPLICA];
 } SCreateVnodeMsg, SAlterVnodeMsg;
@ -761,7 +761,7 @@ typedef struct {
 */
 typedef struct {
  int8_t   type;
-  char     db[TSDB_ACCT_LEN + TSDB_DB_NAME_LEN];
+  char     db[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN];
  uint16_t payloadLen;
  char     payload[];
 } SShowMsg;
--- a/src/inc/tcq.h
+++ b/src/inc/tcq.h
@ -26,7 +26,7 @@ typedef int32_t (*FCqWrite)(int32_t vgId, void *pHead, int32_t qtype, void *pMsg
 typedef struct {
  int32_t  vgId;
  char     user[TSDB_USER_LEN];
-  char     pass[TSDB_PASSWORD_LEN];
+  char     pass[TSDB_KEY_LEN];
  char     db[TSDB_DB_NAME_LEN];
  FCqWrite cqWrite;
 } SCqCfg;
--- a/src/inc/vnode.h
+++ b/src/inc/vnode.h
@ -49,7 +49,7 @@ typedef struct {
  SRpcMsg  rpcMsg;
  SRspRet  rspRet;
  char     reserveForSync[24];
-  SWalHead pHead[];
+  SWalHead pHead;
 } SVWriteMsg;

 // vnodeStatus
--- a/src/kit/CMakeLists.txt
+++ b/src/kit/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 ADD_SUBDIRECTORY(shell)
--- a/src/kit/shell/CMakeLists.txt
+++ b/src/kit/shell/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/client/inc)
--- a/src/kit/taosdemo/CMakeLists.txt
+++ b/src/kit/taosdemo/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/client/inc)
--- a/src/kit/taosdemox/CMakeLists.txt
+++ b/src/kit/taosdemox/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/client/inc)
--- a/src/kit/taosdump/CMakeLists.txt
+++ b/src/kit/taosdump/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/client/inc)
--- a/src/mnode/CMakeLists.txt
+++ b/src/mnode/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 IF (TD_LINUX)
--- a/src/mnode/inc/mnodeDef.h
+++ b/src/mnode/inc/mnodeDef.h
@ -138,7 +138,7 @@ typedef struct SVgObj {
  int64_t        createdTime;
  int32_t        lbDnodeId;
  int32_t        lbTime;
-  char           dbName[TSDB_ACCT_LEN + TSDB_DB_NAME_LEN];
+  char           dbName[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN];
  int8_t         inUse;
  int8_t         accessState;
  int8_t         status;
@ -179,7 +179,7 @@ typedef struct {
 } SDbCfg;

 typedef struct SDbObj {
-  char    name[TSDB_ACCT_LEN + TSDB_DB_NAME_LEN];
+  char    name[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN];
  int8_t  reserved0[4];
  char    acct[TSDB_USER_LEN];
  int64_t createdTime;
--- a/src/mnode/src/mnodeDb.c
+++ b/src/mnode/src/mnodeDb.c
@ -316,9 +316,14 @@ static int32_t mnodeCheckDbCfg(SDbCfg *pCfg) {
    return TSDB_CODE_MND_INVALID_DB_OPTION;
  }

-  if (pCfg->quorum < TSDB_MIN_DB_REPLICA_OPTION || pCfg->quorum > TSDB_MAX_DB_REPLICA_OPTION) {
-    mError("invalid db option quorum:%d valid range: [%d, %d]", pCfg->quorum, TSDB_MIN_DB_REPLICA_OPTION,
-           TSDB_MAX_DB_REPLICA_OPTION);
+  if (pCfg->quorum > pCfg->replications) {
+    mError("invalid db option quorum:%d larger than replica:%d", pCfg->quorum, pCfg->replications);
+    return TSDB_CODE_MND_INVALID_DB_OPTION;
+  }
+
+  if (pCfg->quorum < TSDB_MIN_DB_QUORUM_OPTION || pCfg->quorum > TSDB_MAX_DB_QUORUM_OPTION) {
+    mError("invalid db option quorum:%d valid range: [%d, %d]", pCfg->quorum, TSDB_MIN_DB_QUORUM_OPTION,
+           TSDB_MAX_DB_QUORUM_OPTION);
    return TSDB_CODE_MND_INVALID_DB_OPTION;
  }

--- a/src/mnode/src/mnodeVgroup.c
+++ b/src/mnode/src/mnodeVgroup.c
@ -565,7 +565,7 @@ int32_t mnodeCreateVgroup(SMnodeMsg *pMsg) {
  SDbObj *pDb = pMsg->pDb;

  SVgObj *pVgroup = (SVgObj *)calloc(1, sizeof(SVgObj));
-  tstrncpy(pVgroup->dbName, pDb->name, TSDB_ACCT_LEN + TSDB_DB_NAME_LEN);
+  tstrncpy(pVgroup->dbName, pDb->name, TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN);
  pVgroup->numOfVnodes = pDb->cfg.replications;
  pVgroup->createdTime = taosGetTimestampMs();
  pVgroup->accessState = TSDB_VN_ALL_ACCCESS;
--- a/src/os/CMakeLists.txt
+++ b/src/os/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 IF (TD_LINUX)
@ -10,3 +10,5 @@ ELSEIF (TD_WINDOWS)
 ENDIF ()

 ADD_SUBDIRECTORY(src/detail)
+ADD_SUBDIRECTORY(tests)
+
--- a/src/os/src/alpine/CMakeLists.txt
+++ b/src/os/src/alpine/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 AUX_SOURCE_DIRECTORY(. SRC)
--- a/src/os/src/darwin/CMakeLists.txt
+++ b/src/os/src/darwin/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 AUX_SOURCE_DIRECTORY(. SRC)
--- a/src/os/src/detail/CMakeLists.txt
+++ b/src/os/src/detail/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 INCLUDE_DIRECTORIES(.)
--- a/src/os/src/detail/osTime.c
+++ b/src/os/src/detail/osTime.c
@ -486,7 +486,7 @@ int64_t taosTimeTruncate(int64_t t, const SInterval* pInterval, int32_t precisio
    start = (delta / pInterval->sliding + factor) * pInterval->sliding;

    if (pInterval->intervalUnit == 'd' || pInterval->intervalUnit == 'w') {
-      /*
+     /*
      * here we revised the start time of day according to the local time zone,
      * but in case of DST, the start time of one day need to be dynamically decided.
      */
@ -501,9 +501,24 @@ int64_t taosTimeTruncate(int64_t t, const SInterval* pInterval, int32_t precisio
      start += (int64_t)(timezone * TSDB_TICK_PER_SECOND(precision));
    }

-    int64_t end = start + pInterval->interval - 1;
-    if (end < t) {
-      start += pInterval->sliding;
+    int64_t end = 0;
+
+    // not enough time range
+    if (INT64_MAX - start > pInterval->interval - 1) {
+      end = start + pInterval->interval - 1;
+
+      while(end < t && ((start + pInterval->sliding) <= INT64_MAX)) { // move forward to the correct time window
+        start += pInterval->sliding;
+
+        if (INT64_MAX - start > pInterval->interval - 1) {
+          end = start + pInterval->interval - 1;
+        } else {
+          end = INT64_MAX;
+          break;
+        }
+      }
+    } else {
+      end = INT64_MAX;
    }
  }

--- a/src/os/src/linux/CMakeLists.txt
+++ b/src/os/src/linux/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 AUX_SOURCE_DIRECTORY(. SRC)
--- a/src/os/src/windows/CMakeLists.txt
+++ b/src/os/src/windows/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 AUX_SOURCE_DIRECTORY(. SRC)
--- a/src/os/tests/CMakeLists.txt
+++ b/src/os/tests/CMakeLists.txt
@ -0,0 +1,15 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+PROJECT(TDengine)
+
+FIND_PATH(HEADER_GTEST_INCLUDE_DIR gtest.h /usr/include/gtest /usr/local/include/gtest)
+FIND_LIBRARY(LIB_GTEST_STATIC_DIR libgtest.a /usr/lib/ /usr/local/lib)
+
+IF (HEADER_GTEST_INCLUDE_DIR AND LIB_GTEST_STATIC_DIR)
+    MESSAGE(STATUS "gTest library found, build unit test")
+
+    INCLUDE_DIRECTORIES(${HEADER_GTEST_INCLUDE_DIR})
+    AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SOURCE_LIST)
+
+    ADD_EXECUTABLE(osTest ${SOURCE_LIST})
+    TARGET_LINK_LIBRARIES(osTest taos osdetail tutil common gtest pthread)
+ENDIF()
--- a/src/os/tests/test.cpp
+++ b/src/os/tests/test.cpp
@ -0,0 +1,34 @@
+#include "os.h"
+#include <gtest/gtest.h>
+#include <cassert>
+#include <iostream>
+
+#include "taos.h"
+#include "tstoken.h"
+#include "tutil.h"
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
+
+// test function in os module
+TEST(testCase, parse_time) {
+  taos_options(TSDB_OPTION_TIMEZONE, "GMT-8");
+  deltaToUtcInitOnce();
+
+  // window: 1500000001000, 1500002000000
+  // pQuery->interval: interval: 86400000, sliding:3600000
+  int64_t key = 1500000001000;
+  SInterval interval = {0};
+  interval.interval = 86400000;
+  interval.intervalUnit = 'd';
+  interval.sliding = 3600000;
+  interval.slidingUnit = 'h';
+
+  int64_t s = taosTimeTruncate(key, &interval, TSDB_TIME_PRECISION_MILLI);
+  ASSERT_TRUE(s + interval.interval >= key);
+}
+
+
+
--- a/src/plugins/CMakeLists.txt
+++ b/src/plugins/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 ADD_SUBDIRECTORY(monitor)
--- a/src/plugins/http/CMakeLists.txt
+++ b/src/plugins/http/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/zlib-1.2.11/inc)
--- a/src/plugins/http/inc/httpInt.h
+++ b/src/plugins/http/inc/httpInt.h
@ -39,7 +39,7 @@
 #define HTTP_GC_TARGET_SIZE         512
 #define HTTP_WRITE_RETRY_TIMES      500
 #define HTTP_WRITE_WAIT_TIME_MS     5
-#define HTTP_SESSION_ID_LEN         (TSDB_USER_LEN + TSDB_PASSWORD_LEN)
+#define HTTP_SESSION_ID_LEN         (TSDB_USER_LEN + TSDB_KEY_LEN)

 typedef enum HttpReqType {
  HTTP_REQTYPE_OTHERS = 0,
@ -147,7 +147,7 @@ typedef struct HttpContext {
  uint8_t      parsed;
  char         ipstr[22];
  char         user[TSDB_USER_LEN];  // parsed from auth token or login message
-  char         pass[TSDB_PASSWORD_LEN];
+  char         pass[TSDB_KEY_LEN];
  TAOS *       taos;
  void *       ppContext;
  HttpSession *session;
--- a/src/plugins/http/src/httpAuth.c
+++ b/src/plugins/http/src/httpAuth.c
@ -51,7 +51,7 @@ int32_t httpParseBasicAuthToken(HttpContext *pContext, char *token, int32_t len)

  char *password = user + 1;
  int32_t pass_len = (int32_t)((base64 + outlen) - password);
-  if (pass_len < 1 || pass_len >= TSDB_PASSWORD_LEN) {
+  if (pass_len < 1 || pass_len >= TSDB_KEY_LEN) {
    httpError("context:%p, fd:%d, basic token:%s parse password error", pContext, pContext->fd, token);
    free(base64);
    return -1;
@ -73,7 +73,7 @@ int32_t httpParseTaosdAuthToken(HttpContext *pContext, char *token, int32_t len)
    if (base64) free(base64);
    return 01;
  }
-  if (outlen != (TSDB_USER_LEN + TSDB_PASSWORD_LEN)) {
+  if (outlen != (TSDB_USER_LEN + TSDB_KEY_LEN)) {
    httpError("context:%p, fd:%d, taosd token:%s length error", pContext, pContext->fd, token);
    free(base64);
    return -1;
@ -103,8 +103,8 @@ int32_t httpGenTaosdAuthToken(HttpContext *pContext, char *token, int32_t maxLen
  size = sizeof(pContext->pass);
  tstrncpy(buffer + sizeof(pContext->user), pContext->pass, size);

-  char *encrypt = taosDesEncode(KEY_DES_4, buffer, TSDB_USER_LEN + TSDB_PASSWORD_LEN);
-  char *base64 = base64_encode((const unsigned char *)encrypt, TSDB_USER_LEN + TSDB_PASSWORD_LEN);
+  char *encrypt = taosDesEncode(KEY_DES_4, buffer, TSDB_USER_LEN + TSDB_KEY_LEN);
+  char *base64 = base64_encode((const unsigned char *)encrypt, TSDB_USER_LEN + TSDB_KEY_LEN);

  size_t len = strlen(base64);
  tstrncpy(token, base64, len + 1);
--- a/src/plugins/http/src/httpGcHandle.c
+++ b/src/plugins/http/src/httpGcHandle.c
@ -59,11 +59,11 @@ bool gcGetUserFromUrl(HttpContext* pContext) {

 bool gcGetPassFromUrl(HttpContext* pContext) {
  HttpParser* pParser = pContext->parser;
-  if (pParser->path[GC_PASS_URL_POS].pos >= TSDB_PASSWORD_LEN || pParser->path[GC_PASS_URL_POS].pos <= 0) {
+  if (pParser->path[GC_PASS_URL_POS].pos >= TSDB_KEY_LEN || pParser->path[GC_PASS_URL_POS].pos <= 0) {
    return false;
  }

-  tstrncpy(pContext->pass, pParser->path[GC_PASS_URL_POS].str, TSDB_PASSWORD_LEN);
+  tstrncpy(pContext->pass, pParser->path[GC_PASS_URL_POS].str, TSDB_KEY_LEN);
  return true;
 }

--- a/src/plugins/http/src/httpRestHandle.c
+++ b/src/plugins/http/src/httpRestHandle.c
@ -72,11 +72,11 @@ bool restGetUserFromUrl(HttpContext* pContext) {

 bool restGetPassFromUrl(HttpContext* pContext) {
  HttpParser* pParser = pContext->parser;
-  if (pParser->path[REST_PASS_URL_POS].pos >= TSDB_PASSWORD_LEN || pParser->path[REST_PASS_URL_POS].pos <= 0) {
+  if (pParser->path[REST_PASS_URL_POS].pos >= TSDB_KEY_LEN || pParser->path[REST_PASS_URL_POS].pos <= 0) {
    return false;
  }

-  tstrncpy(pContext->pass, pParser->path[REST_PASS_URL_POS].str, TSDB_PASSWORD_LEN);
+  tstrncpy(pContext->pass, pParser->path[REST_PASS_URL_POS].str, TSDB_KEY_LEN);
  return true;
 }

--- a/src/plugins/http/src/httpTgHandle.c
+++ b/src/plugins/http/src/httpTgHandle.c
@ -324,7 +324,7 @@ bool tgGetUserFromUrl(HttpContext *pContext) {

 bool tgGetPassFromUrl(HttpContext *pContext) {
  HttpParser *pParser = pContext->parser;
-  if (pParser->path[TG_PASS_URL_POS].pos >= TSDB_PASSWORD_LEN || pParser->path[TG_PASS_URL_POS].pos <= 0) {
+  if (pParser->path[TG_PASS_URL_POS].pos >= TSDB_KEY_LEN || pParser->path[TG_PASS_URL_POS].pos <= 0) {
    return false;
  }

--- a/src/plugins/monitor/CMakeLists.txt
+++ b/src/plugins/monitor/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 INCLUDE_DIRECTORIES(inc)
--- a/src/plugins/mqtt/CMakeLists.txt
+++ b/src/plugins/mqtt/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 INCLUDE_DIRECTORIES(inc)
--- a/src/query/CMakeLists.txt
+++ b/src/query/CMakeLists.txt
@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 PROJECT(TDengine)

 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/tsdb/inc)
--- a/Show More
+++ b/Show More