[td-225] merge develop

0146d60c · Haojun Liao · d2e78ac7 · 3d2706fe · 0146d60c · 0146d60c
166 changed file
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -17,6 +17,7 @@ SET(TD_MQTT FALSE)
 SET(TD_TSDB_PLUGINS FALSE)
 SET(TD_STORAGE FALSE)
 SET(TD_TOPIC FALSE)
+SET(TD_MODULE FALSE)
 SET(TD_COVER FALSE)
 SET(TD_MEM_CHECK FALSE)

--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -6,6 +6,7 @@ node {
 }
 def skipstage=0
 def abortPreviousBuilds() {
  def currentJobName = env.JOB_NAME
  def currentBuildNumber = env.BUILD_NUMBER.toInteger()
@@ -24,7 +25,7 @@ def abortPreviousBuilds() {
    build.doKill()    //doTerm(),doKill(),doTerm()
  }
 }
-//abort previous build
+//  abort previous build
 abortPreviousBuilds()
 def abort_previous(){
  def buildNumber = env.BUILD_NUMBER as int
@@ -32,20 +33,21 @@ def abort_previous(){
  milestone(buildNumber)
 }
 def pre_test(){
    sh '''
    sudo rmtaos || echo "taosd has not installed"
    '''
    sh '''
+    killall -9 taosd ||echo "no taosd running"
+    killall -9 gdb || echo "no gdb running"
    cd ${WKC}
-    git checkout develop
    git reset --hard HEAD~10 >/dev/null 
+    git checkout develop
    git pull >/dev/null
    git fetch origin +refs/pull/${CHANGE_ID}/merge
    git checkout -qf FETCH_HEAD
-    git --no-pager diff --name-only FETCH_HEAD $(git merge-base FETCH_HEAD develop)|grep -v -E '.*md|//src//connector|Jenkinsfile'
+    git clean -dfx
-    find ${WKC}/tests/pytest -name \'*\'.sql -exec rm -rf {} \\;
    cd ${WK}
    git reset --hard HEAD~10
    git checkout develop 
@@ -53,7 +55,7 @@ def pre_test(){
    cd ${WK}
    export TZ=Asia/Harbin
    date
-    rm -rf ${WK}/debug
+    git clean -dfx
    mkdir debug
    cd debug
    cmake .. > /dev/null
@@ -79,6 +81,10 @@ pipeline {
              changeRequest()
          }
          steps {
+            script{
+              abort_previous()
+              abortPreviousBuilds()
+            }
          sh'''
          cp -r ${WORKSPACE} ${WORKSPACE}.tes
          cd ${WORKSPACE}.tes
@@ -179,6 +185,14 @@ pipeline {
            rm -rf /var/log/taos/*
            ./handle_crash_gen_val_log.sh
            '''
+            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+                sh '''
+                cd ${WKC}/tests/pytest
+                rm -rf /var/lib/taos/*
+                rm -rf /var/log/taos/*
+                ./handle_taosd_val_log.sh
+                '''
+            }
            timeout(time: 45, unit: 'MINUTES'){
                sh '''
                date
@@ -209,6 +223,11 @@ pipeline {
              cd ${WKC}/tests
              ./test-all.sh b3fq
              date'''
+              sh '''
+              date
+              cd ${WKC}/tests
+              ./test-all.sh full example
+              date'''
            }
          }
        }
@@ -266,7 +285,7 @@ pipeline {
              date
              cd ${WKC}/tests
              ./test-all.sh b7fq
-              date'''
+              date'''              
            }
          }
        }        

--- a/README-CN.md
+++ b/README-CN.md
@@ -258,10 +258,16 @@ TDengine 社区生态中也有一些非常友好的第三方连接器，可以
 TDengine 的测试框架和所有测试例全部开源。
-点击[这里](tests/How-To-Run-Test-And-How-To-Add-New-Test-Case.md)，了解如何运行测试例和添加新的测试例。
+点击 [这里](tests/How-To-Run-Test-And-How-To-Add-New-Test-Case.md)，了解如何运行测试例和添加新的测试例。
 # 成为社区贡献者
-点击[这里](https://www.taosdata.com/cn/contributor/)，了解如何成为 TDengine 的贡献者。
-#加入技术交流群
+点击 [这里](https://www.taosdata.com/cn/contributor/)，了解如何成为 TDengine 的贡献者。
-TDengine官方社群「物联网大数据群」对外开放，欢迎您加入讨论。搜索微信号 "tdengine"，加小T为好友，即可入群。
+# 加入技术交流群
+TDengine 官方社群「物联网大数据群」对外开放，欢迎您加入讨论。搜索微信号 "tdengine"，加小T为好友，即可入群。
+# [谁在使用TDengine](https://github.com/taosdata/TDengine/issues/2432)
+欢迎所有 TDengine 用户及贡献者在 [这里](https://github.com/taosdata/TDengine/issues/2432) 分享您在当前工作中开发/使用 TDengine 的故事。 
--- a/README.md
+++ b/README.md
@@ -250,3 +250,6 @@ Please follow the [contribution guidelines](CONTRIBUTING.md) to contribute to th
 Add WeChat “tdengine” to join the group，you can communicate with other users.
+# [User List](https://github.com/taosdata/TDengine/issues/2432)
+If you are using TDengine and feel it helps or you'd like to do some contributions, please add your company to [user list](https://github.com/taosdata/TDengine/issues/2432) and let us know your needs.
--- a/cmake/define.inc
+++ b/cmake/define.inc
@@ -29,6 +29,10 @@ IF (TD_TOPIC)
  ADD_DEFINITIONS(-D_TOPIC)
 ENDIF ()
+IF (TD_MODULE)
+  ADD_DEFINITIONS(-D_MODULE)
+ENDIF ()
 IF (TD_GODLL)
  ADD_DEFINITIONS(-D_TD_GO_DLL_)
 ENDIF ()

--- a/cmake/input.inc
+++ b/cmake/input.inc
@@ -17,6 +17,14 @@ ELSEIF (${TOPIC} MATCHES "false")
  MESSAGE(STATUS "Build without topic plugins")
 ENDIF ()
+IF (${TD_MODULE} MATCHES "true")
+  SET(TD_MODULE TRUE)
+  MESSAGE(STATUS "Build with module plugins")
+ELSEIF (${TOPIC} MATCHES "false")
+  SET(TD_MODULE FALSE)
+  MESSAGE(STATUS "Build without module plugins")
+ENDIF ()
 IF (${COVER} MATCHES "true")
  SET(TD_COVER TRUE)
  MESSAGE(STATUS "Build with test coverage")

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

--- a/documentation20/cn/00.index/docs.md
+++ b/documentation20/cn/00.index/docs.md
@@ -120,7 +120,7 @@ TDengine是一个高效的存储、查询、分析时序大数据的平台，专
 * [TDengine性能对比测试工具](https://www.taosdata.com/blog/2020/01/18/1166.html)
 * [IDEA数据库管理工具可视化使用TDengine](https://www.taosdata.com/blog/2020/08/27/1767.html)
 * [基于eletron开发的跨平台TDengine图形化管理工具](https://github.com/skye0207/TDengineGUI)
-* [DataX，支持TDengine的离线数据采集/同步工具](https://github.com/alibaba/DataX)
+* [DataX，支持TDengine的离线数据采集/同步工具](https://github.com/wgzhao/DataX)（文档：[读取插件](https://github.com/wgzhao/DataX/blob/master/docs/src/main/sphinx/reader/tdenginereader.md)、[写入插件](https://github.com/wgzhao/DataX/blob/master/docs/src/main/sphinx/writer/tdenginewriter.md)）
 ## TDengine与其他数据库的对比测试

--- a/documentation20/cn/02.getting-started/docs.md
+++ b/documentation20/cn/02.getting-started/docs.md
@@ -179,19 +179,20 @@ taos> select avg(f1), max(f2), min(f3) from test.t10 interval(10s);
 ### TDengine服务器支持的平台列表
-|                | **CentOS**  **6/7/8** | **Ubuntu**  **16/18/20** | **Other Linux** | **统信****UOS** | **银河****/****中标麒麟** | **凝思**  **V60/V80** |
+|                | **CentOS 6/7/8** | **Ubuntu 16/18/20** | **Other Linux** | **统信 UOS** | **银河/中标麒麟** | **凝思 V60/V80** | **华为 EulerOS** |
-| -------------- | --------------------- | ------------------------ | --------------- | --------------- | ------------------------- | --------------------- |
+| -------------- | --------------------- | ------------------------ | --------------- | --------------- | ------------------------- | --------------------- | --------------------- |
-| X64            | ●                     | ●                        |                 | ○               | ●                         | ●                     |
+| X64            | ●                     | ●                        |                 | ○               | ●                         | ●                     | ●                     |
-| 树莓派ARM32    |                       | ●                        | ●               |                 |                           |                       |
+| 树莓派 ARM32    |                       | ●                        | ●               |                 |                           |                       |                       |
-| 龙芯MIPS64     |                       |                          | ●               |                 |                           |                       |
+| 龙芯 MIPS64     |                       |                          | ●               |                 |                           |                       |                       |
-| 鲲鹏  ARM64    |                       | ○                        | ○               |                 | ●                         |                       |
+| 鲲鹏 ARM64    |                       | ○                        | ○               |                 | ●                         |                       |                       |
-| 申威  Alpha64  |                       |                          | ○               | ●               |                           |                       |
+| 申威 Alpha64  |                       |                          | ○               | ●               |                           |                       |                       |
-| 飞腾ARM64      |                       | ○优麒麟                  |                 |                 |                           |                       |
+| 飞腾 ARM64      |                       | ○ 优麒麟                  |                 |                 |                           |                       |                       |
-| 海光X64        | ●                     | ●                        | ●               | ○               | ●                         | ●                     |
+| 海光 X64        | ●                     | ●                        | ●               | ○               | ●                         | ●                     |                       |
-| 瑞芯微ARM64/32 |                       |                          | ○               |                 |                           |                       |
+| 瑞芯微 ARM64/32 |                       |                          | ○               |                 |                           |                       |                       |
-| 全志ARM64/32   |                       |                          | ○               |                 |                           |                       |
+| 全志 ARM64/32   |                       |                          | ○               |                 |                           |                       |                       |
-| 炬力ARM64/32   |                       |                          | ○               |                 |                           |                       |
+| 炬力 ARM64/32   |                       |                          | ○               |                 |                           |                       |                       |
-| TI ARM32       |                       |                          | ○               |                 |                           |                       |
+| TI ARM32       |                       |                          | ○               |                 |                           |                       |                       |
+| 华为云 ARM64   |                       |                          |                 |                 |                           |                       | ●                     |
 注： ● 表示经过官方测试验证， ○ 表示非官方测试验证。
@@ -203,7 +204,7 @@ taos> select avg(f1), max(f2), min(f3) from test.t10 interval(10s);
 对照矩阵如下：
-| **CPU**     | **X64   64bit** |           |           | **X86   32bit** | **ARM64** | **ARM32** | **MIPS **  **龙芯** | **Alpha **  **申威** | **X64 **  **海光** |
+| **CPU**     | **X64 64bit** |           |           | **X86 32bit** | **ARM64** | **ARM32** | **MIPS 龙芯** | **Alpha 申威** | **X64 海光** |
 | ----------- | --------------- | --------- | --------- | --------------- | --------- | --------- | ------------------- | -------------------- | ------------------ |
 | **OS**      | **Linux**       | **Win64** | **Win32** | **Win32**       | **Linux** | **Linux** | **Linux**           | **Linux**            | **Linux**          |
 | **C/C++**   | ●               | ●         | ●         | ○               | ●         | ●         | ●                   | ●                    | ●                  |

--- a/documentation20/cn/07.advanced-features/docs.md
+++ b/documentation20/cn/07.advanced-features/docs.md
--- a/documentation20/cn/08.connector/01.java/docs.md
+++ b/documentation20/cn/08.connector/01.java/docs.md
@@ -285,7 +285,7 @@ JDBC连接器可能报错的错误码包括3种：JDBC driver本身的报错（
 * https://github.com/taosdata/TDengine/blob/develop/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBErrorNumbers.java
 * https://github.com/taosdata/TDengine/blob/develop/src/inc/taoserror.h
-### 订阅
+### <a class="anchor" id="subscribe"></a>订阅
 #### 创建
@@ -471,9 +471,11 @@ TDengine 目前支持时间戳、数字、字符、布尔类型，与 Java 对
 | BIGINT            | java.lang.Long     |
 | FLOAT             | java.lang.Float    |
 | DOUBLE            | java.lang.Double   |
-| SMALLINT, TINYINT | java.lang.Short    |
+| SMALLINT	    | java.lang.Short    |
+| TINYINT           | java.lang.Byte     |
 | BOOL              | java.lang.Boolean  |
-| BINARY, NCHAR     | java.lang.String   |
+| BINARY            | byte array         |
+| NCHAR             | java.lang.String   |

--- a/documentation20/cn/10.cluster/docs.md
+++ b/documentation20/cn/10.cluster/docs.md
@@ -111,9 +111,10 @@ taos>
 **提示：**
- 任何已经加入集群在线的数据节点，都可以作为后续待加入节点的firstEP。
+- 任何已经加入集群在线的数据节点，都可以作为后续待加入节点的 firstEP。
- firstEp这个参数仅仅在该数据节点首次加入集群时有作用，加入集群后，该数据节点会保存最新的mnode的End Point列表，不再依赖这个参数。
+- firstEp 这个参数仅仅在该数据节点首次加入集群时有作用，加入集群后，该数据节点会保存最新的 mnode 的 End Point 列表，不再依赖这个参数。
- 两个没有配置firstEp参数的数据节点dnode启动后，会独立运行起来。这个时候，无法将其中一个数据节点加入到另外一个数据节点，形成集群。**无法将两个独立的集群合并成为新的集群**。
+  - 接下来，配置文件中的 firstEp 参数就主要在客户端连接的时候使用了，例如 taos shell 如果不加参数，会默认连接由 firstEp 指定的节点。
+- 两个没有配置 firstEp 参数的数据节点 dnode 启动后，会独立运行起来。这个时候，无法将其中一个数据节点加入到另外一个数据节点，形成集群。**无法将两个独立的集群合并成为新的集群**。
 ## <a class="anchor" id="management"></a>数据节点管理

--- a/documentation20/cn/11.administrator/docs.md
+++ b/documentation20/cn/11.administrator/docs.md
@@ -6,19 +6,27 @@
 ### 内存需求
-每个 DB 可以创建固定数目的 vgroup，默认与 CPU 核数相同，可通过 maxVgroupsPerDb 配置；vgroup 中的每个副本会是一个 vnode；每个 vnode 会占用固定大小的内存（大小与数据库的配置参数 blocks 和 cache 有关)；每个 Table 会占用与标签总长度有关的内存；此外，系统会有一些固定的内存开销。因此，每个 DB 需要的系统内存可通过如下公式计算：
+每个 Database 可以创建固定数目的 vgroup，默认与 CPU 核数相同，可通过 maxVgroupsPerDb 配置；vgroup 中的每个副本会是一个 vnode；每个 vnode 会占用固定大小的内存（大小与数据库的配置参数 blocks 和 cache 有关)；每个 Table 会占用与标签总长度有关的内存；此外，系统会有一些固定的内存开销。因此，每个 DB 需要的系统内存可通过如下公式计算：
 ```
-Memory Size = maxVgroupsPerDb * (blocks * cache + 10MB) + numOfTables * (tagSizePerTable + 0.5KB)
+Database Memory Size = maxVgroupsPerDb * (blocks * cache + 10MB) + numOfTables * (tagSizePerTable + 0.5KB)
 ```
-示例：假设是 4 核机器，cache 是缺省大小 16M, blocks 是缺省值 6，假设有 10 万张表，标签总长度是 256 字节，则总的内存需求为：4 \* (16 \* 6 + 10) + 100000 \* (0.25 + 0.5) / 1000 = 499M。
+示例：假设是 4 核机器，cache 是缺省大小 16M, blocks 是缺省值 6，并且一个 DB 中有 10 万张表，标签总长度是 256 字节，则这个 DB 总的内存需求为：4 \* (16 \* 6 + 10) + 100000 \* (0.25 + 0.5) / 1000 = 499M。
-注意：从这个公式计算得到的内存容量，应理解为系统的“必要需求”，而不是“内存总数”。在实际运行的生产系统中，由于操作系统缓存、资源管理调度等方面的需要，内存规划应当在计算结果的基础上保留一定冗余，以维持系统状态和系统性能的稳定性。
+在实际的系统运维中，我们通常会更关心 TDengine 服务进程（taosd）会占用的内存量。
+```
+taosd 内存总量 = vnode 内存 + mnode 内存 + 查询内存
+```
+其中：
+1. “vnode 内存”指的是集群中所有的 Database 存储分摊到当前 taosd 节点上所占用的内存资源。可以按上文“Database Memory Size”计算公式估算每个 DB 的内存占用量进行加总，再按集群中总共的 TDengine 节点数做平均（如果设置为多副本，则还需要乘以对应的副本倍数）。
+2. “mnode 内存”指的是集群中管理节点所占用的资源。如果一个 taosd 节点上分布有 mnode 管理节点，则内存消耗还需要增加“0.2KB * 集群中数据表总数”。
+3. “查询内存”指的是服务端处理查询请求时所需要占用的内存。单条查询语句至少会占用“0.2KB * 查询涉及的数据表总数”的内存量。
-实际运行的系统往往会根据数据特点的不同，将数据存放在不同的 DB 里。因此做规划时，也需要考虑。
+注意：以上内存估算方法，主要讲解了系统的“必须内存需求”，而不是“内存总数上限”。在实际运行的生产环境中，由于操作系统缓存、资源管理调度等方面的原因，内存规划应当在估算结果的基础上保留一定冗余，以维持系统状态和系统性能的稳定性。并且，生产环境通常会配置系统资源的监控工具，以便及时发现硬件资源的紧缺情况。
-如果内存充裕，可以加大 Blocks 的配置，这样更多数据将保存在内存里，提高查询速度。
+最后，如果内存充裕，可以考虑加大 Blocks 的配置，这样更多数据将保存在内存里，提高查询速度。
 ### CPU 需求
@@ -112,17 +120,17 @@ taosd -C
 不同应用场景的数据往往具有不同的数据特征，比如保留天数、副本数、采集频次、记录大小、采集点的数量、压缩等都可完全不同。为获得在存储上的最高效率，TDengine提供如下存储相关的系统配置参数：
 - days：一个数据文件存储数据的时间跨度，单位为天，默认值：10。
- keep：数据库中数据保留的天数，单位为天，默认值：3650。
+- keep：数据库中数据保留的天数，单位为天，默认值：3650。（可通过 alter database 修改）
 - minRows：文件块中记录的最小条数，单位为条，默认值：100。
 - maxRows：文件块中记录的最大条数，单位为条，默认值：4096。
- comp：文件压缩标志位，0：关闭；1：一阶段压缩；2：两阶段压缩。默认值：2。
+- comp：文件压缩标志位，0：关闭；1：一阶段压缩；2：两阶段压缩。默认值：2。（可通过 alter database 修改）
 - walLevel：WAL级别。1：写wal，但不执行fsync；2：写wal, 而且执行fsync。默认值：1。
 - fsync：当wal设置为2时，执行fsync的周期。设置为0，表示每次写入，立即执行fsync。单位为毫秒，默认值：3000。
 - cache：内存块的大小，单位为兆字节（MB），默认值：16。
- blocks：每个VNODE（TSDB）中有多少cache大小的内存块。因此一个VNODE的用的内存大小粗略为（cache * blocks）。单位为块，默认值：4。
+- blocks：每个VNODE（TSDB）中有多少cache大小的内存块。因此一个VNODE的用的内存大小粗略为（cache * blocks）。单位为块，默认值：4。（可通过 alter database 修改）
- replica：副本个数，取值范围：1-3。单位为个，默认值：1
+- replica：副本个数，取值范围：1-3。单位为个，默认值：1。（可通过 alter database 修改）
- precision：时间戳精度标识，ms表示毫秒，us表示微秒。默认值：ms
+- precision：时间戳精度标识，ms表示毫秒，us表示微秒。默认值：ms。
- cacheLast：是否在内存中缓存子表 last_row，0：关闭；1：开启。默认值：0。（从 2.0.11 版本开始支持此参数）
+- cacheLast：是否在内存中缓存子表 last_row，0：关闭；1：开启。默认值：0。（可通过 alter database 修改）（从 2.0.11 版本开始支持此参数）
 对于一个应用场景，可能有多种数据特征的数据并存，最佳的设计是将具有相同数据特征的表放在一个库里，这样一个应用有多个库，而每个库可以配置不同的存储参数，从而保证系统有最优的性能。TDengine允许应用在创建库时指定上述存储参数，如果指定，该参数就将覆盖对应的系统配置参数。举例，有下述SQL：

--- a/documentation20/cn/12.taos-sql/docs.md
+++ b/documentation20/cn/12.taos-sql/docs.md
@@ -29,21 +29,21 @@ taos> DESCRIBE meters;
 ## <a class="anchor" id="data-type"></a>支持的数据类型
-使用TDengine，最重要的是时间戳。创建并插入记录、查询历史记录的时候，均需要指定时间戳。时间戳有如下规则：
+使用 TDengine，最重要的是时间戳。创建并插入记录、查询历史记录的时候，均需要指定时间戳。时间戳有如下规则：
- 时间格式为```YYYY-MM-DD HH:mm:ss.MS```, 默认时间分辨率为毫秒。比如：```2017-08-12 18:25:58.128```
+- 时间格式为 ```YYYY-MM-DD HH:mm:ss.MS```，默认时间分辨率为毫秒。比如：```2017-08-12 18:25:58.128```
- 内部函数now是服务器的当前时间
+- 内部函数 now 是客户端的当前时间
- 插入记录时，如果时间戳为now，插入数据时使用服务器当前时间
+- 插入记录时，如果时间戳为 now，插入数据时使用提交这条记录的客户端的当前时间
- Epoch Time: 时间戳也可以是一个长整数，表示从1970-01-01 08:00:00.000开始的毫秒数
+- Epoch Time：时间戳也可以是一个长整数，表示从 1970-01-01 08:00:00.000 开始的毫秒数
- 时间可以加减，比如 now-2h，表明查询时刻向前推2个小时(最近2小时)。 数字后面的时间单位可以是 a(毫秒)、s(秒)、 m(分)、h(小时)、d(天)、w(周)。 比如select * from t1 where ts > now-2w and ts <= now-1w, 表示查询两周前整整一周的数据。 在指定降频操作(down sampling)的时间窗口(interval)时，时间单位还可以使用 n(自然月) 和 y(自然年)。
+- 时间可以加减，比如 now-2h，表明查询时刻向前推 2 个小时（最近 2 小时）。数字后面的时间单位可以是 u(微秒)、a(毫秒)、s(秒)、m(分)、h(小时)、d(天)、w(周)。 比如 `select * from t1 where ts > now-2w and ts <= now-1w`，表示查询两周前整整一周的数据。在指定降频操作（down sampling）的时间窗口（interval）时，时间单位还可以使用 n(自然月) 和 y(自然年)。
-TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMicrosecond就可支持微秒。
+TDengine 缺省的时间戳是毫秒精度，但通过修改配置参数 enableMicrosecond 就可以支持微秒。
-在TDengine中，普通表的数据模型中可使用以下10种数据类型。 
+在TDengine中，普通表的数据模型中可使用以下 10 种数据类型。 
 |      |   类型    | Bytes  | 说明                                                         |
 | ---- | :-------: | ------ | ------------------------------------------------------------ |
-| 1    | TIMESTAMP | 8      | 时间戳。缺省精度毫秒，可支持微秒。从格林威治时间 1970-01-01 00:00:00.000 (UTC/GMT) 开始，计时不能早于该时间。 |
+| 1    | TIMESTAMP | 8      | 时间戳。缺省精度毫秒，可支持微秒。从格林威治时间 1970-01-01 00:00:00.000 (UTC/GMT) 开始，计时不能早于该时间。（从 2.0.18 版本开始，已经去除了这一时间范围限制） |
 | 2    |    INT    | 4      | 整型，范围 [-2^31+1,   2^31-1], -2^31 用作 NULL           |
 | 3    |  BIGINT   | 8      | 长整型，范围 [-2^63+1,   2^63-1], -2^63 用于 NULL                                 |
 | 4    |   FLOAT   | 4      | 浮点型，有效位数 6-7，范围 [-3.4E38, 3.4E38]                  |

--- a/documentation20/cn/13.faq/docs.md
+++ b/documentation20/cn/13.faq/docs.md
@@ -156,3 +156,13 @@ ALTER LOCAL RESETLOG;
 ```
 其含义是，清空本机所有由客户端生成的日志文件。
+## <a class="anchor" id="timezone"></a>18. 时间戳的时区信息是怎样处理的？
+TDengine 中时间戳的时区总是由客户端进行处理，而与服务端无关。具体来说，客户端会对 SQL 语句中的时间戳进行时区转换，转为 UTC 时区（即 Unix 时间戳——Unix Timestamp）再交由服务端进行写入和查询；在读取数据时，服务端也是采用 UTC 时区提供原始数据，客户端收到后再根据本地设置，把时间戳转换为本地系统所要求的时区进行显示。
+客户端在处理时间戳字符串时，会采取如下逻辑：
+1. 在未做特殊设置的情况下，客户端默认使用所在操作系统的时区设置。
+2. 如果在 taos.cfg 中设置了 timezone 参数，则客户端会以这个配置文件中的设置为准。
+3. 如果在 C/C++/Java/Python 等各种编程语言的 Connector Driver 中，在建立数据库连接时显式指定了 timezone，那么会以这个指定的时区设置为准。例如 Java Connector 的 JDBC URL 中就有 timezone 参数。
+4. 在书写 SQL 语句时，也可以直接使用 Unix 时间戳（例如 `1554984068000`）或带有时区的时间戳字符串，也即以 RFC 3339 格式（例如 `2013-04-12T15:52:01.123+08:00`）或 ISO-8601 格式（例如 `2013-04-12T15:52:01.123+0800`）来书写时间戳，此时这些时间戳的取值将不再受其他时区设置的影响。
--- a/packaging/cfg/taos.cfg
+++ b/packaging/cfg/taos.cfg
@@ -29,6 +29,9 @@
 # number of threads per CPU core
 # numOfThreadsPerCore       1.0
+# number of threads to commit cache data
+# numOfCommitThreads        4
 # the proportion of total CPU cores available for query processing
 # 2.0: the query threads will be set to double of the CPU cores.
 # 1.0: all CPU cores are available for query processing [default].

--- a/packaging/tools/remove.sh
+++ b/packaging/tools/remove.sh
@@ -120,7 +120,7 @@ function clean_service_on_systemd() {
    if [ "$verMode" == "cluster" ]; then
 		  nginx_service_config="${service_config_dir}/${nginx_service_name}.service"	
-   	 	if [ -d ${bin_dir}/web ]; then
+   	 	if [ -d ${install_nginxd_dir} ]; then
   	    if systemctl is-active --quiet ${nginx_service_name}; then
   	      echo "Nginx for TDengine is running, stopping it..."
   	      ${csudo} systemctl stop ${nginx_service_name} &> /dev/null || echo &> /dev/null

--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -83,6 +83,22 @@ typedef struct SJoinSupporter {
  SArray*         pVgroupTables;
 } SJoinSupporter;
+typedef struct SMergeCtx {
+  SJoinSupporter* p;
+  int32_t         idx;
+  SArray*         res;
+  int8_t          compared;
+}SMergeCtx;
+typedef struct SMergeTsCtx {
+  SJoinSupporter* p;
+  STSBuf*         res;
+  int64_t         numOfInput;
+  int8_t          compared;
+}SMergeTsCtx;
 typedef struct SVgroupTableInfo {
  SVgroupInfo vgInfo;
  SArray*     itemList;   //SArray<STableIdInfo>
@@ -192,7 +208,9 @@ void      tscSqlExprAssign(SExprInfo* dst, const SExprInfo* src);
 void      tscSqlExprInfoDestroy(SArray* pExprInfo);
 SColumn* tscColumnClone(const SColumn* src);
+bool tscColumnExists(SArray* pColumnList, SColumnIndex* pColIndex);
 SColumn* tscColumnListInsert(SArray* pColList, SColumnIndex* colIndex, SSchema* pSchema);
+SArray* tscColumnListClone(const SArray* src, int16_t tableIndex);
 void tscColumnListDestroy(SArray* pColList);
 void tscDequoteAndTrimToken(SStrToken* pToken);

--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -126,15 +126,15 @@ typedef struct SCond {
 } SCond;
 typedef struct SJoinNode {
-  char     tableName[TSDB_TABLE_FNAME_LEN];
  uint64_t uid;
  int16_t  tagColId;
+  SArray*  tsJoin;
+  SArray*  tagJoin;
 } SJoinNode;
 typedef struct SJoinInfo {
  bool      hasJoin;
-  SJoinNode left;
+  SJoinNode*  joinTables[TSDB_MAX_JOIN_TABLE_NUM];
-  SJoinNode right;
 } SJoinInfo;
 typedef struct STagCond {
@@ -279,7 +279,7 @@ typedef struct {
  char *         pRsp;
  int32_t        rspType;
  int32_t        rspLen;
-  uint64_t       qid;
+  uint64_t       qId;
  int64_t        useconds;
  int64_t        offset;  // offset value from vnode during projection query of stable
  int32_t        row;
@@ -362,7 +362,7 @@ typedef struct SSqlObj {
  int64_t          svgroupRid;
  int64_t          squeryLock;
+  int32_t          retryReason;  // previous error code
  struct SSqlObj  *prev, *next;
  int64_t          self;
 } SSqlObj;
@@ -435,6 +435,8 @@ void tscFreeSqlResult(SSqlObj *pSql);
 * @param pObj
 */
 void tscFreeSqlObj(SSqlObj *pSql);
+void tscFreeSubobj(SSqlObj* pSql);
 void tscFreeRegisteredSqlObj(void *pSql);
 void tscCloseTscObj(void *pObj);

--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -161,8 +161,8 @@ static void tscProcessAsyncRetrieveImpl(void *param, TAOS_RES *tres, int numOfRo
  SSqlCmd *pCmd = &pSql->cmd;
  SSqlRes *pRes = &pSql->res;
-  if ((pRes->qid == 0 || numOfRows != 0) && pCmd->command < TSDB_SQL_LOCAL) {
+  if ((pRes->qId == 0 || numOfRows != 0) && pCmd->command < TSDB_SQL_LOCAL) {
-    if (pRes->qid == 0 && numOfRows != 0) {
+    if (pRes->qId == 0 && numOfRows != 0) {
      tscError("qhandle is NULL");
    } else {
      pRes->code = numOfRows;
@@ -210,7 +210,7 @@ void taos_fetch_rows_a(TAOS_RES *tres, __async_cb_func_t fp, void *param) {
  pSql->fp      = tscAsyncFetchRowsProxy;
  pSql->param   = param;
-  if (pRes->qid == 0) {
+  if (pRes->qId == 0) {
    tscError("qhandle is invalid");
    pRes->code = TSDB_CODE_TSC_INVALID_QHANDLE;
    tscAsyncResultOnError(pSql);
@@ -301,7 +301,7 @@ static void tscAsyncResultCallback(SSchedMsg *pMsg) {
  taosReleaseRef(tscObjRef, pSql->self);
 }
-void tscAsyncResultOnError(SSqlObj* pSql) { 
+void tscAsyncResultOnError(SSqlObj* pSql) {
  SSchedMsg schedMsg = {0};
  schedMsg.fp = tscAsyncResultCallback;
  schedMsg.ahandle = (void *)pSql->self;
@@ -310,9 +310,50 @@ void tscAsyncResultOnError(SSqlObj* pSql) {
  taosScheduleTask(tscQhandle, &schedMsg);
 }
+int tscSendMsgToServer(SSqlObj *pSql);
+static int32_t updateMetaBeforeRetryQuery(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo, SQueryInfo* pQueryInfo) {
+  // handle the invalid table error code for super table.
+  // update the pExpr info, colList info, number of table columns
+  // TODO Re-parse this sql and issue the corresponding subquery as an alternative for this case.
+  if (pSql->retryReason == TSDB_CODE_TDB_INVALID_TABLE_ID) {
+    int32_t numOfExprs = (int32_t) tscSqlExprNumOfExprs(pQueryInfo);
+    int32_t numOfCols = tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
+    int32_t numOfTags = tscGetNumOfTags(pTableMetaInfo->pTableMeta);
+    SSchema *pSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
+    for (int32_t i = 0; i < numOfExprs; ++i) {
+      SSqlExpr *pExpr = &(tscSqlExprGet(pQueryInfo, i)->base);
+      pExpr->uid = pTableMetaInfo->pTableMeta->id.uid;
+      if (pExpr->colInfo.colIndex >= 0) {
+        int32_t index = pExpr->colInfo.colIndex;
+        if ((TSDB_COL_IS_NORMAL_COL(pExpr->colInfo.flag) && index >= numOfCols) ||
+            (TSDB_COL_IS_TAG(pExpr->colInfo.flag) && (index < numOfCols || index >= (numOfCols + numOfTags)))) {
+          return pSql->retryReason;
+        }
-int tscSendMsgToServer(SSqlObj *pSql);
+        if ((pSchema[pExpr->colInfo.colIndex].colId != pExpr->colInfo.colId) &&
+            strcasecmp(pExpr->colInfo.name, pSchema[pExpr->colInfo.colIndex].name) != 0) {
+          return pSql->retryReason;
+        }
+      }
+    }
+    // validate the table columns information
+    for (int32_t i = 0; i < taosArrayGetSize(pQueryInfo->colList); ++i) {
+      SColumn *pCol = taosArrayGetP(pQueryInfo->colList, i);
+      if (pCol->colIndex.columnIndex >= numOfCols) {
+        return pSql->retryReason;
+      }
+    }
+  } else {
+    // do nothing
+  }
+  return TSDB_CODE_SUCCESS;
+}
 void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
  SSqlObj* pSql = (SSqlObj*)taosAcquireRef(tscObjRef, (int64_t)param);
@@ -339,7 +380,8 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
    if (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, (TSDB_QUERY_TYPE_STABLE_SUBQUERY|TSDB_QUERY_TYPE_SUBQUERY|TSDB_QUERY_TYPE_TAG_FILTER_QUERY))) {
      tscDebug("%p update local table meta, continue to process sql and send the corresponding query", pSql);
-      STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+      STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
      code = tscGetTableMeta(pSql, pTableMetaInfo);
      assert(code == TSDB_CODE_TSC_ACTION_IN_PROGRESS || code == TSDB_CODE_SUCCESS);
@@ -349,6 +391,10 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
      }
      assert((tscGetNumOfTags(pTableMetaInfo->pTableMeta) != 0));
+      code = updateMetaBeforeRetryQuery(pSql, pTableMetaInfo, pQueryInfo);
+      if (code != TSDB_CODE_SUCCESS) {
+        goto _error;
+      }
      // tscProcessSql can add error into async res
      tscProcessSql(pSql, NULL);
@@ -463,10 +509,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
  return;
  _error:
-  if (code != TSDB_CODE_SUCCESS) {
+  pRes->code = code;
-    pSql->res.code = code;
+  tscAsyncResultOnError(pSql);
-    tscAsyncResultOnError(pSql);
-  }
  taosReleaseRef(tscObjRef, pSql->self);
 }
--- a/src/client/src/tscLocal.c
+++ b/src/client/src/tscLocal.c
@@ -309,7 +309,7 @@ TAOS_ROW tscFetchRow(void *param) {
  SSqlCmd *pCmd = &pSql->cmd;
  SSqlRes *pRes = &pSql->res;
-  if (pRes->qid == 0 ||
+  if (pRes->qId == 0 ||
      pCmd->command == TSDB_SQL_RETRIEVE_EMPTY_RESULT ||
      pCmd->command == TSDB_SQL_INSERT) {
    return NULL;
@@ -905,7 +905,7 @@ int tscProcessLocalCmd(SSqlObj *pSql) {
     * set the qhandle to be 1 in order to pass the qhandle check, and to call partial release function to
     * free allocated resources and remove the SqlObj from sql query linked list
     */
-    pRes->qid = 0x1;
+    pRes->qId = 0x1;
    pRes->numOfRows = 0;
  } else if (pCmd->command == TSDB_SQL_SHOW_CREATE_TABLE) {
    pRes->code = tscProcessShowCreateTable(pSql); 

--- a/src/client/src/tscLocalMerge.c
+++ b/src/client/src/tscLocalMerge.c
@@ -381,6 +381,8 @@ void tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrde
  tsCreateSQLFunctionCtx(pQueryInfo, pReducer->pCtx, pschema);
  setCtxInputOutputBuffer(pQueryInfo, pReducer->pCtx, pReducer, pDesc);
+  tfree(pschema);
  // we change the capacity of schema to denote that there is only one row in temp buffer
  pReducer->pDesc->pColumnModel->capacity = 1;
@@ -1624,7 +1626,7 @@ void tscInitResObjForLocalQuery(SSqlObj *pObj, int32_t numOfRes, int32_t rowLen)
    tscDestroyLocalMerger(pObj);
  }
-  pRes->qid = 1;  // hack to pass the safety check in fetch_row function
+  pRes->qId = 1;  // hack to pass the safety check in fetch_row function
  pRes->numOfRows = 0;
  pRes->row = 0;

--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@@ -903,7 +903,7 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
    return TSDB_CODE_TSC_OUT_OF_MEMORY;
  }
-  pRes->qid = 0;
+  pRes->qId = 0;
  pRes->numOfRows = 1;
  strtolower(pSql->sqlstr, sql);

--- a/src/client/src/tscProfile.c
+++ b/src/client/src/tscProfile.c
@@ -250,7 +250,7 @@ int tscBuildQueryStreamDesc(void *pMsg, STscObj *pObj) {
    pQdesc->queryId = htonl(pSql->queryId);
    //pQdesc->useconds = htobe64(pSql->res.useconds);
    pQdesc->useconds = htobe64(now - pSql->stime);
-    pQdesc->qid = htobe64(pSql->res.qid);
+    pQdesc->qId = htobe64(pSql->res.qId);
    pHeartbeat->numOfQueries++;
    pQdesc++;

--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -351,8 +351,8 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcEpSet *pEpSet) {
        taosMsleep(duration);
      }
+      pSql->retryReason = rpcMsg->code;
      rpcMsg->code = tscRenewTableMeta(pSql, 0);
      // if there is an error occurring, proceed to the following error handling procedure.
      if (rpcMsg->code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
        taosReleaseRef(tscObjRef, handle);
@@ -510,7 +510,7 @@ int tscBuildFetchMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
  SQueryInfo *pQueryInfo = tscGetActiveQueryInfo(&pSql->cmd);
  pRetrieveMsg->free = htons(pQueryInfo->type);
-  pRetrieveMsg->qid  = htobe64(pSql->res.qid);
+  pRetrieveMsg->qId  = htobe64(pSql->res.qId);
  // todo valid the vgroupId at the client side
  STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
@@ -522,7 +522,7 @@ int tscBuildFetchMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
      assert(pVgroupInfo->vgroups[vgIndex].vgId > 0 && vgIndex < pTableMetaInfo->vgroupList->numOfVgroups);
      pRetrieveMsg->header.vgId = htonl(pVgroupInfo->vgroups[vgIndex].vgId);
-      tscDebug("%p build fetch msg from vgId:%d, vgIndex:%d, qid:%" PRIu64, pSql, pVgroupInfo->vgroups[vgIndex].vgId, vgIndex, pSql->res.qid);
+      tscDebug("%p build fetch msg from vgId:%d, vgIndex:%d, qId:%" PRIu64, pSql, pVgroupInfo->vgroups[vgIndex].vgId, vgIndex, pSql->res.qId);
    } else {
      int32_t numOfVgroups = (int32_t)taosArrayGetSize(pTableMetaInfo->pVgroupTables);
      assert(vgIndex >= 0 && vgIndex < numOfVgroups);
@@ -530,12 +530,12 @@ int tscBuildFetchMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
      SVgroupTableInfo* pTableIdList = taosArrayGet(pTableMetaInfo->pVgroupTables, vgIndex);
      pRetrieveMsg->header.vgId = htonl(pTableIdList->vgInfo.vgId);
-      tscDebug("%p build fetch msg from vgId:%d, vgIndex:%d, qid:%" PRIu64, pSql, pTableIdList->vgInfo.vgId, vgIndex, pSql->res.qid);
+      tscDebug("%p build fetch msg from vgId:%d, vgIndex:%d, qId:%" PRIu64, pSql, pTableIdList->vgInfo.vgId, vgIndex, pSql->res.qId);
    }
  } else {
    STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
    pRetrieveMsg->header.vgId = htonl(pTableMeta->vgId);
-    tscDebug("%p build fetch msg from only one vgroup, vgId:%d, qid:%" PRIu64, pSql, pTableMeta->vgId, pSql->res.qid);
+    tscDebug("%p build fetch msg from only one vgroup, vgId:%d, qId:%" PRIu64, pSql, pTableMeta->vgId, pSql->res.qId);
  }
  pSql->cmd.payloadLen = sizeof(SRetrieveTableMsg);
@@ -615,10 +615,8 @@ static int32_t tscEstimateQueryMsgSize(SSqlObj *pSql, int32_t clauseIndex) {
         tableSerialize + sqlLen + 4096 + pQueryInfo->bufLen;
 }
-static char *doSerializeTableInfo(SQueryTableMsg* pQueryMsg, SSqlObj *pSql, char *pMsg) {
+static char *doSerializeTableInfo(SQueryTableMsg* pQueryMsg, SSqlObj *pSql, char *pMsg, int32_t *succeed) {
-  SQueryInfo* pQueryInfo = tscGetActiveQueryInfo(&pSql->cmd);
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, pSql->cmd.clauseIndex, 0);
-  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
  TSKEY dfltKey = htobe64(pQueryMsg->window.skey);
  STableMeta * pTableMeta = pTableMetaInfo->pTableMeta;
@@ -630,9 +628,14 @@ static char *doSerializeTableInfo(SQueryTableMsg* pQueryMsg, SSqlObj *pSql, char
      assert(index >= 0);
      SVgroupInfo* pVgroupInfo = NULL;
-      if (pTableMetaInfo->vgroupList->numOfVgroups > 0) {
+      if (pTableMetaInfo->vgroupList && pTableMetaInfo->vgroupList->numOfVgroups > 0) {
        assert(index < pTableMetaInfo->vgroupList->numOfVgroups);
        pVgroupInfo = &pTableMetaInfo->vgroupList->vgroups[index];
+      } else {
+        tscError("%p No vgroup info found", pSql);
+        *succeed = 0;
+        return pMsg;
      }
      vgId = pVgroupInfo->vgId;
@@ -711,7 +714,7 @@ static int32_t serializeSqlExpr(SSqlExpr* pExpr, STableMetaInfo* pTableMetaInfo,
  SSqlExpr* pSqlExpr = (SSqlExpr *)(*pMsg);
  SColIndex* pIndex = &pSqlExpr->colInfo;
  pIndex->colId         = htons(pExpr->colInfo.colId);
  pIndex->colIndex      = htons(pExpr->colInfo.colIndex);
  pIndex->flag          = htons(pExpr->colInfo.flag);
@@ -876,11 +879,16 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
    }
  }
-  // serialize the table info (sid, uid, tags)
+  int32_t succeed = 1;
-  pMsg = doSerializeTableInfo(pQueryMsg, pSql, pMsg);
+  // serialize the table info (sid, uid, tags)
+  pMsg = doSerializeTableInfo(pQueryMsg, pSql, pMsg, &succeed);
+  if (succeed == 0) {
+    return TSDB_CODE_TSC_APP_ERROR;
+  }
  SSqlGroupbyExpr *pGroupbyExpr = query.pGroupbyExpr;
-  if (pGroupbyExpr != NULL && pGroupbyExpr->numOfGroupCols > 0) {
+  if (pGroupbyExpr->numOfGroupCols > 0) {
    pQueryMsg->orderByIdx = htons(pGroupbyExpr->orderIndex);
    pQueryMsg->orderType = htons(pGroupbyExpr->orderType);
@@ -1206,6 +1214,23 @@ int32_t tscBuildUseDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
  return TSDB_CODE_SUCCESS;
 }
+int32_t tscBuildSyncDbReplicaMsg(SSqlObj* pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+  pCmd->payloadLen = sizeof(SSyncDbMsg);
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
+    tscError("%p failed to malloc for query msg", pSql);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+  SSyncDbMsg *pSyncMsg = (SSyncDbMsg *)pCmd->payload;
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+  tNameExtractFullName(&pTableMetaInfo->name, pSyncMsg->db);
+  pCmd->msgType = TSDB_MSG_TYPE_CM_SYNC_DB;
+  return TSDB_CODE_SUCCESS;
+}
 int32_t tscBuildShowMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
  STscObj *pObj = pSql->pTscObj;
  SSqlCmd *pCmd = &pSql->cmd;
@@ -1478,7 +1503,7 @@ int tscBuildRetrieveFromMgmtMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, 0);
  SRetrieveTableMsg *pRetrieveMsg = (SRetrieveTableMsg*)pCmd->payload;
-  pRetrieveMsg->qid  = htobe64(pSql->res.qid);
+  pRetrieveMsg->qId  = htobe64(pSql->res.qId);
  pRetrieveMsg->free = htons(pQueryInfo->type);
  return TSDB_CODE_SUCCESS;
@@ -1986,19 +2011,24 @@ int tscProcessSTableVgroupRsp(SSqlObj *pSql) {
    assert(pInfo->vgroupList != NULL);
    pInfo->vgroupList->numOfVgroups = pVgroupMsg->numOfVgroups;
-    for (int32_t j = 0; j < pInfo->vgroupList->numOfVgroups; ++j) {
+    if (pInfo->vgroupList->numOfVgroups <= 0) {
-      //just init, no need to lock
+      //tfree(pInfo->vgroupList);
-      SVgroupInfo *pVgroups = &pInfo->vgroupList->vgroups[j];
+      tscError("%p empty vgroup info", pSql);
+    } else {
+      for (int32_t j = 0; j < pInfo->vgroupList->numOfVgroups; ++j) {
+        //just init, no need to lock
+        SVgroupInfo *pVgroups = &pInfo->vgroupList->vgroups[j];
-      SVgroupMsg *vmsg = &pVgroupMsg->vgroups[j];
+        SVgroupMsg *vmsg = &pVgroupMsg->vgroups[j];
-      pVgroups->vgId = htonl(vmsg->vgId);
+        pVgroups->vgId = htonl(vmsg->vgId);
-      pVgroups->numOfEps = vmsg->numOfEps;
+        pVgroups->numOfEps = vmsg->numOfEps;
-      assert(pVgroups->numOfEps >= 1 && pVgroups->vgId >= 1);
+        assert(pVgroups->numOfEps >= 1 && pVgroups->vgId >= 1);
-      for (int32_t k = 0; k < pVgroups->numOfEps; ++k) {
+        for (int32_t k = 0; k < pVgroups->numOfEps; ++k) {
-        pVgroups->epAddr[k].port = htons(vmsg->epAddr[k].port);
+          pVgroups->epAddr[k].port = htons(vmsg->epAddr[k].port);
-        pVgroups->epAddr[k].fqdn = strndup(vmsg->epAddr[k].fqdn, tListLen(vmsg->epAddr[k].fqdn));
+          pVgroups->epAddr[k].fqdn = strndup(vmsg->epAddr[k].fqdn, tListLen(vmsg->epAddr[k].fqdn));
+        }
      }
    }
@@ -2024,7 +2054,7 @@ int tscProcessShowRsp(SSqlObj *pSql) {
  pShow = (SShowRsp *)pRes->pRsp;
  pShow->qhandle = htobe64(pShow->qhandle);
-  pRes->qid = pShow->qhandle;
+  pRes->qId = pShow->qhandle;
  tscResetForNextRetrieve(pRes);
  pMetaMsg = &(pShow->tableMeta);
@@ -2206,12 +2236,13 @@ int tscProcessQueryRsp(SSqlObj *pSql) {
  SSqlRes *pRes = &pSql->res;
  SQueryTableRsp *pQueryAttr = (SQueryTableRsp *)pRes->pRsp;
-  pQueryAttr->qid = htobe64(pQueryAttr->qid);
+  pQueryAttr->qId = htobe64(pQueryAttr->qId);
-  pRes->qid  = pQueryAttr->qid;
+  pRes->qId  = pQueryAttr->qId;
  pRes->data = NULL;
  tscResetForNextRetrieve(pRes);
+  tscDebug("%p query rsp received, qId:%"PRIu64, pSql, pRes->qId);
  return 0;
 }
@@ -2271,7 +2302,8 @@ int tscProcessRetrieveRspFromNode(SSqlObj *pSql) {
  }
  pRes->row = 0;
-  tscDebug("%p numOfRows:%d, offset:%" PRId64 ", complete:%d", pSql, pRes->numOfRows, pRes->offset, pRes->completed);
+  tscDebug("%p numOfRows:%d, offset:%" PRId64 ", complete:%d, qId:%"PRIu64, pSql, pRes->numOfRows, pRes->offset,
+      pRes->completed, pRes->qId);
  return 0;
 }
@@ -2484,6 +2516,7 @@ void tscInitMsgsFp() {
  tscBuildMsg[TSDB_SQL_DROP_USER] = tscBuildDropUserAcctMsg;
  tscBuildMsg[TSDB_SQL_DROP_ACCT] = tscBuildDropUserAcctMsg;
  tscBuildMsg[TSDB_SQL_DROP_DB] = tscBuildDropDbMsg;
+  tscBuildMsg[TSDB_SQL_SYNC_DB_REPLICA] = tscBuildSyncDbReplicaMsg;
  tscBuildMsg[TSDB_SQL_DROP_TABLE] = tscBuildDropTableMsg;
  tscBuildMsg[TSDB_SQL_ALTER_USER] = tscBuildUserMsg;
  tscBuildMsg[TSDB_SQL_CREATE_DNODE] = tscBuildCreateDnodeMsg;
@@ -2536,7 +2569,6 @@ void tscInitMsgsFp() {
  tscProcessMsgRsp[TSDB_SQL_SHOW_CREATE_TABLE] = tscProcessShowCreateRsp;
  tscProcessMsgRsp[TSDB_SQL_SHOW_CREATE_DATABASE] = tscProcessShowCreateRsp;
  tscKeepConn[TSDB_SQL_SHOW] = 1;
  tscKeepConn[TSDB_SQL_RETRIEVE] = 1;

--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -476,7 +476,7 @@ TAOS_ROW taos_fetch_row(TAOS_RES *res) {
  SSqlCmd *pCmd = &pSql->cmd;
  SSqlRes *pRes = &pSql->res;
-  if (pRes->qid == 0 ||
+  if (pRes->qId == 0 ||
      pRes->code == TSDB_CODE_TSC_QUERY_CANCELLED ||
      pCmd->command == TSDB_SQL_RETRIEVE_EMPTY_RESULT ||
      pCmd->command == TSDB_SQL_INSERT) {
@@ -508,7 +508,7 @@ int taos_fetch_block(TAOS_RES *res, TAOS_ROW *rows) {
  SSqlCmd *pCmd = &pSql->cmd;
  SSqlRes *pRes = &pSql->res;
-  if (pRes->qid == 0 ||
+  if (pRes->qId == 0 ||
      pRes->code == TSDB_CODE_TSC_QUERY_CANCELLED ||
      pCmd->command == TSDB_SQL_RETRIEVE_EMPTY_RESULT ||
      pCmd->command == TSDB_SQL_INSERT) {
@@ -554,7 +554,7 @@ static bool tscKillQueryInDnode(SSqlObj* pSql) {
  SSqlCmd* pCmd = &pSql->cmd;
  SSqlRes* pRes = &pSql->res;
-  if (pRes == NULL || pRes->qid == 0) {
+  if (pRes == NULL || pRes->qId == 0) {
    return true;
  }
@@ -1050,7 +1050,7 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
   * If qhandle is NOT set 0, the function of taos_free_result() will send message to server by calling tscProcessSql()
   * to free connection, which may cause segment fault, when the parse phrase is not even successfully executed.
   */
-  pRes->qid = 0;
+  pRes->qId = 0;
  free(str);
  if (code != TSDB_CODE_SUCCESS) {

--- a/src/client/src/tscStream.c
+++ b/src/client/src/tscStream.c
@@ -299,6 +299,7 @@ static void tscProcessStreamRetrieveResult(void *param, TAOS_RES *res, int numOf
    tfree(pTableMetaInfo->pTableMeta);
    tscFreeSqlResult(pSql);
+    tscFreeSubobj(pSql);    
    tfree(pSql->pSubs);
    pSql->subState.numOfSub = 0;
    pTableMetaInfo->vgroupList = tscVgroupInfoClear(pTableMetaInfo->vgroupList);

--- a/src/client/src/tscSub.c
+++ b/src/client/src/tscSub.c
@@ -149,7 +149,7 @@ static SSub* tscCreateSubscription(STscObj* pObj, const char* topic, const char*
  }
  strtolower(pSql->sqlstr, pSql->sqlstr);
-  pRes->qid = 0;
+  pRes->qId = 0;
  pRes->numOfRows = 1;
  code = tscAllocPayload(pCmd, TSDB_DEFAULT_PAYLOAD_SIZE);
@@ -448,7 +448,7 @@ SSqlObj* recreateSqlObj(SSub* pSub) {
    return NULL;
  }
-  pRes->qid = 0;
+  pRes->qId = 0;
  pRes->numOfRows = 1;
  int code = tscAllocPayload(pCmd, TSDB_DEFAULT_PAYLOAD_SIZE);
@@ -548,7 +548,7 @@ TAOS_RES *taos_consume(TAOS_SUB *tsub) {
    uint32_t type = pQueryInfo->type;
    tscFreeSqlResult(pSql);
    pRes->numOfRows = 1;
-    pRes->qid = 0;
+    pRes->qId = 0;
    pSql->cmd.command = TSDB_SQL_SELECT;
    pQueryInfo->type = type;

--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -711,7 +711,7 @@ void tscFreeSqlResult(SSqlObj* pSql) {
  memset(&pSql->res, 0, sizeof(SSqlRes));
 }
-static void tscFreeSubobj(SSqlObj* pSql) {
+void tscFreeSubobj(SSqlObj* pSql) {
  if (pSql->subState.numOfSub == 0) {
    return;
  }
@@ -1533,6 +1533,33 @@ int32_t tscSqlExprCopy(SArray* dst, const SArray* src, uint64_t uid, bool deepco
  return 0;
 }
+bool tscColumnExists(SArray* pColumnList, SColumnIndex* pColIndex) {
+  // ignore the tbname columnIndex to be inserted into source list
+  if (pColIndex->columnIndex < 0) {
+    return false;
+  }
+  size_t numOfCols = taosArrayGetSize(pColumnList);
+  int16_t col = pColIndex->columnIndex;
+  int32_t i = 0;
+  while (i < numOfCols) {
+    SColumn* pCol = taosArrayGetP(pColumnList, i);
+    if ((pCol->colIndex.columnIndex != col) || (pCol->colIndex.tableIndex != pColIndex->tableIndex)) {
+      ++i;
+      continue;
+    } else {
+      break;
+    }
+  }
+  if (i >= numOfCols || numOfCols == 0) {
+    return false;
+  }
+  return true;
+}
 void tscSqlExprAssign(SExprInfo* dst, const SExprInfo* src) {
  assert(dst != NULL && src != NULL);
@@ -1860,7 +1887,25 @@ int32_t tscTagCondCopy(STagCond* dest, const STagCond* src) {
  dest->tbnameCond.uid = src->tbnameCond.uid;
  dest->tbnameCond.len = src->tbnameCond.len;
-  memcpy(&dest->joinInfo, &src->joinInfo, sizeof(SJoinInfo));
+  dest->joinInfo.hasJoin = src->joinInfo.hasJoin;
+  for (int32_t i = 0; i < TSDB_MAX_JOIN_TABLE_NUM; ++i) {
+    if (src->joinInfo.joinTables[i]) {
+      dest->joinInfo.joinTables[i] = calloc(1, sizeof(SJoinNode));
+      memcpy(dest->joinInfo.joinTables[i], src->joinInfo.joinTables[i], sizeof(SJoinNode));
+      if (src->joinInfo.joinTables[i]->tsJoin) {
+        dest->joinInfo.joinTables[i]->tsJoin = taosArrayDup(src->joinInfo.joinTables[i]->tsJoin);
+      }
+      if (src->joinInfo.joinTables[i]->tagJoin) {
+        dest->joinInfo.joinTables[i]->tagJoin = taosArrayDup(src->joinInfo.joinTables[i]->tagJoin);
+      }
+    }
+  }
  dest->relType = src->relType;
  if (src->pCond == NULL) {
@@ -1906,6 +1951,23 @@ void tscTagCondRelease(STagCond* pTagCond) {
    taosArrayDestroy(pTagCond->pCond);
  }
+  for (int32_t i = 0; i < TSDB_MAX_JOIN_TABLE_NUM; ++i) {
+    SJoinNode *node = pTagCond->joinInfo.joinTables[i];
+    if (node == NULL) {
+      continue;
+    }
+    if (node->tsJoin != NULL) {
+      taosArrayDestroy(node->tsJoin);
+    }
+    if (node->tagJoin != NULL) {
+      taosArrayDestroy(node->tagJoin);
+    }
+    tfree(node);
+  }
  memset(pTagCond, 0, sizeof(STagCond));
 }
@@ -2037,7 +2099,7 @@ void tscInitQueryInfo(SQueryInfo* pQueryInfo) {
  pQueryInfo->resColumnId    = TSDB_RES_COL_ID;
  pQueryInfo->limit.limit    = -1;
  pQueryInfo->limit.offset   = 0;
  pQueryInfo->slimit.limit   = -1;
  pQueryInfo->slimit.offset  = 0;
  pQueryInfo->pUpstream      = taosArrayInit(4, POINTER_BYTES);
@@ -2598,7 +2660,7 @@ void tscDoQuery(SSqlObj* pSql) {
  } else {
    SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
    uint16_t type = pQueryInfo->type;
    if (QUERY_IS_JOIN_QUERY(type)) {
      if (!TSDB_QUERY_HAS_TYPE(type, TSDB_QUERY_TYPE_SUBQUERY)) {
        tscHandleMasterJoinQuery(pSql);
@@ -2632,16 +2694,21 @@ void tscDoQuery(SSqlObj* pSql) {
 }
 int16_t tscGetJoinTagColIdByUid(STagCond* pTagCond, uint64_t uid) {
-  if (pTagCond->joinInfo.left.uid == uid) {
+  int32_t i = 0;
-    return pTagCond->joinInfo.left.tagColId;
+  while (i < TSDB_MAX_JOIN_TABLE_NUM) {
-  } else if (pTagCond->joinInfo.right.uid == uid) {
+    SJoinNode* node = pTagCond->joinInfo.joinTables[i];
-    return pTagCond->joinInfo.right.tagColId;
+    if (node && node->uid == uid) {
-  } else {
+      return node->tagColId;
-    assert(0);
+    }
-    return -1;
+    i++;
  }
+  assert(0);
+  return -1;
 }
 int16_t tscGetTagColIndexById(STableMeta* pTableMeta, int16_t colId) {
  int32_t numOfTags = tscGetNumOfTags(pTableMeta);
@@ -3240,7 +3307,7 @@ int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAt
  pQueryAttr->queryBlockDist    = isBlockDistQuery(pQueryInfo);
  pQueryAttr->pointInterpQuery  = tscIsPointInterpQuery(pQueryInfo);
  pQueryAttr->timeWindowInterpo = timeWindowInterpoRequired(pQueryInfo);
  pQueryAttr->numOfCols         = numOfCols;
  pQueryAttr->numOfOutput       = numOfOutput;
  pQueryAttr->limit             = pQueryInfo->limit;
@@ -3256,6 +3323,12 @@ int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAt
  pQueryAttr->pGroupbyExpr    = calloc(1, sizeof(SSqlGroupbyExpr));
  *(pQueryAttr->pGroupbyExpr) = pQueryInfo->groupbyExpr;
+  if (pQueryInfo->groupbyExpr.numOfGroupCols > 0) {
+    pQueryAttr->pGroupbyExpr->columnInfo = taosArrayDup(pQueryInfo->groupbyExpr.columnInfo);
+  } else {
+    assert(pQueryInfo->groupbyExpr.columnInfo == NULL);
+  }
  pQueryAttr->pExpr1 = calloc(pQueryAttr->numOfOutput, sizeof(SExprInfo));
  for(int32_t i = 0; i < pQueryAttr->numOfOutput; ++i) {
    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);

--- a/src/common/inc/tcmdtype.h
+++ b/src/common/inc/tcmdtype.h
@@ -51,6 +51,7 @@ enum {
  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_ALTER_ACCT, "alter-acct" )
  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_ALTER_TABLE, "alter-table" )
  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_ALTER_DB, "alter-db" )
+  TSDB_DEFINE_SQL_TYPE(TSDB_SQL_SYNC_DB_REPLICA, "sync db-replica")
  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CREATE_MNODE, "create-mnode" )
  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_DROP_MNODE, "drop-mnode" )
  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CREATE_DNODE, "create-dnode" )
@@ -87,13 +88,13 @@ enum {
   */
  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_RETRIEVE_EMPTY_RESULT, "retrieve-empty-result" )
-  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_RESET_CACHE, "reset-cache" )
+  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_RESET_CACHE,  "reset-cache" )
-  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_SERV_STATUS, "serv-status" )
+  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_SERV_STATUS,  "serv-status" )
-  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CURRENT_DB, "current-db" )
+  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CURRENT_DB,   "current-db" )
  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_SERV_VERSION, "serv-version" )
-  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CLI_VERSION, "cli-version" )
+  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CLI_VERSION,  "cli-version" )
  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CURRENT_USER, "current-user ")
-  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CFG_LOCAL, "cfg-local" )
+  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CFG_LOCAL,    "cfg-local" )
  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_MAX, "max" )
 };

--- a/src/common/src/tglobal.c
+++ b/src/common/src/tglobal.c
@@ -51,7 +51,7 @@ int32_t tsMaxShellConns  = 50000;
 int32_t tsMaxConnections = 5000;
 int32_t tsShellActivityTimer  = 3;  // second
 float   tsNumOfThreadsPerCore = 1.0f;
-int32_t tsNumOfCommitThreads = 1;
+int32_t tsNumOfCommitThreads = 4;
 float   tsRatioOfQueryCores = 1.0f;
 int8_t  tsDaylight       = 0;
 char    tsTimezone[TSDB_TIMEZONE_LEN] = {0};
@@ -71,7 +71,7 @@ int32_t tsMaxBinaryDisplayWidth = 30;
 int32_t tsCompressMsgSize = -1;
 // client
-int32_t tsMaxSQLStringLen = TSDB_MAX_SQL_LEN;
+int32_t tsMaxSQLStringLen = TSDB_MAX_ALLOWED_SQL_LEN;
 int8_t  tsTscEnableRecordSql = 0;
 // the maximum number of results for projection query on super table that are returned from

--- a/src/connector/jdbc/CMakeLists.txt
+++ b/src/connector/jdbc/CMakeLists.txt
@@ -8,7 +8,7 @@ IF (TD_MVN_INSTALLED)
  ADD_CUSTOM_COMMAND(OUTPUT ${JDBC_CMD_NAME}
    POST_BUILD
    COMMAND mvn -Dmaven.test.skip=true install -f ${CMAKE_CURRENT_SOURCE_DIR}/pom.xml
-    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/target/taos-jdbcdriver-2.0.22-dist.jar ${LIBRARY_OUTPUT_PATH}
+    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/target/taos-jdbcdriver-2.0.25-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.22</version>
+  <version>2.0.25</version>
  <packaging>jar</packaging>
  <name>JDBCDriver</name>
@@ -37,17 +37,6 @@
  </developers>
  <dependencies>
-    <dependency>
-      <groupId>commons-logging</groupId>
-      <artifactId>commons-logging</artifactId>
-      <version>1.2</version>
-      <exclusions>
-        <exclusion>
-          <groupId>*</groupId>
-          <artifactId>*</artifactId>
-        </exclusion>
-      </exclusions>
-    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
@@ -61,21 +50,20 @@
      <artifactId>httpclient</artifactId>
      <version>4.5.8</version>
    </dependency>
-    <dependency>
-      <groupId>org.apache.commons</groupId>
-      <artifactId>commons-lang3</artifactId>
-      <version>3.9</version>
-    </dependency>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.2.58</version>
    </dependency>
+    <dependency>
+      <groupId>com.google.guava</groupId>
+      <artifactId>guava</artifactId>
+      <version>29.0-jre</version>
+    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-assembly-plugin</artifactId>

--- 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.22</version>
+    <version>2.0.25</version>
    <packaging>jar</packaging>
    <name>JDBCDriver</name>
    <url>https://github.com/taosdata/TDengine/tree/master/src/connector/jdbc</url>
@@ -43,7 +43,6 @@
            <version>4.13</version>
            <scope>test</scope>
        </dependency>
        <!-- for restful -->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
@@ -55,10 +54,22 @@
            <artifactId>fastjson</artifactId>
            <version>1.2.58</version>
        </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>29.0-jre</version>
+        </dependency>
    </dependencies>
    <build>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <excludes>
+                    <exclude>**/*.md</exclude>
+                </excludes>
+            </resource>
+        </resources>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>

--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractConnection.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractConnection.java
@@ -30,9 +30,12 @@ public abstract class AbstractConnection extends WrapperImpl implements Connecti
        if (isClosed())
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
        // do nothing
        return sql;
    }
    @Override
    public void setAutoCommit(boolean autoCommit) throws SQLException {
        if (isClosed())
@@ -448,7 +451,6 @@ public abstract class AbstractConnection extends WrapperImpl implements Connecti
        if (isClosed)
            throw (SQLClientInfoException) TSDBError.createSQLException(TSDBErrorNumbers.ERROR_SQLCLIENT_EXCEPTION_ON_CONNECTION_CLOSED);
        for (Enumeration<Object> enumer = properties.keys(); enumer.hasMoreElements(); ) {
            String name = (String) enumer.nextElement();
            clientInfoProps.put(name, properties.getProperty(name));

--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractParameterMetaData.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractParameterMetaData.java
+package com.taosdata.jdbc;
+import java.sql.ParameterMetaData;
+import java.sql.SQLException;
+import java.sql.Timestamp;
+import java.sql.Types;
+public abstract class AbstractParameterMetaData extends WrapperImpl implements ParameterMetaData {
+    private final Object[] parameters;
+    public AbstractParameterMetaData(Object[] parameters) {
+        this.parameters = parameters;
+    }
+    @Override
+    public int getParameterCount() throws SQLException {
+        return parameters == null ? 0 : parameters.length;
+    }
+    @Override
+    public int isNullable(int param) throws SQLException {
+        return ParameterMetaData.parameterNullableUnknown;
+    }
+    @Override
+    public boolean isSigned(int param) throws SQLException {
+        if (param < 1 && param >= parameters.length)
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE);
+        if (parameters[param - 1] instanceof Byte)
+            return true;
+        if (parameters[param - 1] instanceof Short)
+            return true;
+        if (parameters[param - 1] instanceof Integer)
+            return true;
+        if (parameters[param - 1] instanceof Long)
+            return true;
+        if (parameters[param - 1] instanceof Float)
+            return true;
+        if (parameters[param - 1] instanceof Double)
+            return true;
+        return false;
+    }
+    @Override
+    public int getPrecision(int param) throws SQLException {
+        if (param < 1 && param >= parameters.length)
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE);
+        if (parameters[param - 1] instanceof String)
+            return ((String) parameters[param - 1]).length();
+        if (parameters[param - 1] instanceof byte[])
+            return ((byte[]) parameters[param - 1]).length;
+        return 0;
+    }
+    @Override
+    public int getScale(int param) throws SQLException {
+        if (param < 1 && param >= parameters.length)
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE);
+        return 0;
+    }
+    @Override
+    public int getParameterType(int param) throws SQLException {
+        if (param < 1 && param >= parameters.length)
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE);
+        if (parameters[param - 1] instanceof Timestamp)
+            return Types.TIMESTAMP;
+        if (parameters[param - 1] instanceof Byte)
+            return Types.TINYINT;
+        if (parameters[param - 1] instanceof Short)
+            return Types.SMALLINT;
+        if (parameters[param - 1] instanceof Integer)
+            return Types.INTEGER;
+        if (parameters[param - 1] instanceof Long)
+            return Types.BIGINT;
+        if (parameters[param - 1] instanceof Float)
+            return Types.FLOAT;
+        if (parameters[param - 1] instanceof Double)
+            return Types.DOUBLE;
+        if (parameters[param - 1] instanceof String)
+            return Types.NCHAR;
+        if (parameters[param - 1] instanceof byte[])
+            return Types.BINARY;
+        if (parameters[param - 1] instanceof Boolean)
+            return Types.BOOLEAN;
+        return Types.OTHER;
+    }
+    @Override
+    public String getParameterTypeName(int param) throws SQLException {
+        if (param < 1 && param >= parameters.length)
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE);
+        if (parameters[param - 1] instanceof Timestamp)
+            return TSDBConstants.jdbcType2TaosTypeName(Types.TIMESTAMP);
+        if (parameters[param - 1] instanceof Byte)
+            return TSDBConstants.jdbcType2TaosTypeName(Types.TINYINT);
+        if (parameters[param - 1] instanceof Short)
+            return TSDBConstants.jdbcType2TaosTypeName(Types.SMALLINT);
+        if (parameters[param - 1] instanceof Integer)
+            return TSDBConstants.jdbcType2TaosTypeName(Types.INTEGER);
+        if (parameters[param - 1] instanceof Long)
+            return TSDBConstants.jdbcType2TaosTypeName(Types.BIGINT);
+        if (parameters[param - 1] instanceof Float)
+            return TSDBConstants.jdbcType2TaosTypeName(Types.FLOAT);
+        if (parameters[param - 1] instanceof Double)
+            return TSDBConstants.jdbcType2TaosTypeName(Types.DOUBLE);
+        if (parameters[param - 1] instanceof String)
+            return TSDBConstants.jdbcType2TaosTypeName(Types.NCHAR);
+        if (parameters[param - 1] instanceof byte[])
+            return TSDBConstants.jdbcType2TaosTypeName(Types.BINARY);
+        if (parameters[param - 1] instanceof Boolean)
+            return TSDBConstants.jdbcType2TaosTypeName(Types.BOOLEAN);
+        return parameters[param - 1].getClass().getName();
+    }
+    @Override
+    public String getParameterClassName(int param) throws SQLException {
+        if (param < 1 && param >= parameters.length)
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE);
+        return parameters[param - 1].getClass().getName();
+    }
+    @Override
+    public int getParameterMode(int param) throws SQLException {
+        if (param < 1 && param >= parameters.length)
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE);
+        return ParameterMetaData.parameterModeUnknown;
+    }
+}
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractResultSet.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractResultSet.java
@@ -11,6 +11,15 @@ import java.util.Map;
 public abstract class AbstractResultSet extends WrapperImpl implements ResultSet {
    private int fetchSize;
+    protected void checkAvailability(int columnIndex, int bounds) throws SQLException {
+        if (isClosed())
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
+        if (columnIndex < 1)
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE, "Column Index out of range, " + columnIndex + " < 1");
+        if (columnIndex > bounds)
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE, "Column Index out of range, " + columnIndex + " > " + bounds);
+    }
    @Override
    public abstract boolean next() throws SQLException;
@@ -46,38 +55,20 @@ public abstract class AbstractResultSet extends WrapperImpl implements ResultSet
    @Override
    public abstract double getDouble(int columnIndex) throws SQLException;
+    @Deprecated
    @Override
    public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
-        if (isClosed())
+        return getBigDecimal(columnIndex);
-            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
-        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
    }
    @Override
-    public byte[] getBytes(int columnIndex) throws SQLException {
+    public abstract byte[] getBytes(int columnIndex) throws SQLException;
-        if (isClosed())
-            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
-        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
-    }
    @Override
-    public Date getDate(int columnIndex) throws SQLException {
+    public abstract Date getDate(int columnIndex) throws SQLException;
-        if (isClosed())
-            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
-        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
-    }
    @Override
-    public Time getTime(int columnIndex) throws SQLException {
+    public abstract Time getTime(int columnIndex) throws SQLException;
-        if (isClosed())
-            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
-        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
-    }
    @Override
    public abstract Timestamp getTimestamp(int columnIndex) throws SQLException;
@@ -147,9 +138,10 @@ public abstract class AbstractResultSet extends WrapperImpl implements ResultSet
        return getDouble(findColumn(columnLabel));
    }
+    @Deprecated
    @Override
    public BigDecimal getBigDecimal(String columnLabel, int scale) throws SQLException {
-        return getBigDecimal(findColumn(columnLabel));
+        return getBigDecimal(findColumn(columnLabel), scale);
    }
    @Override
@@ -214,12 +206,7 @@ public abstract class AbstractResultSet extends WrapperImpl implements ResultSet
    public abstract ResultSetMetaData getMetaData() throws SQLException;
    @Override
-    public Object getObject(int columnIndex) throws SQLException {
+    public abstract Object getObject(int columnIndex) throws SQLException;
-        if (isClosed())
-            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
-        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
-    }
    @Override
    public Object getObject(String columnLabel) throws SQLException {
@@ -243,12 +230,7 @@ public abstract class AbstractResultSet extends WrapperImpl implements ResultSet
    }
    @Override
-    public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
+    public abstract BigDecimal getBigDecimal(int columnIndex) throws SQLException;
-        if (isClosed())
-            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
-        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
-    }
    @Override
    public BigDecimal getBigDecimal(String columnLabel) throws SQLException {
@@ -718,9 +700,7 @@ public abstract class AbstractResultSet extends WrapperImpl implements ResultSet
    @Override
    public Object getObject(String columnLabel, Map<String, Class<?>> map) throws SQLException {
-        if (isClosed())
+        return getObject(findColumn(columnLabel), map);
-            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
-        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
    }
    @Override
@@ -760,9 +740,7 @@ public abstract class AbstractResultSet extends WrapperImpl implements ResultSet
    @Override
    public Date getDate(String columnLabel, Calendar cal) throws SQLException {
-        if (isClosed())
+        return getDate(findColumn(columnLabel), cal);
-            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
-        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
    }
    @Override
@@ -774,23 +752,15 @@ public abstract class AbstractResultSet extends WrapperImpl implements ResultSet
    @Override
    public Time getTime(String columnLabel, Calendar cal) throws SQLException {
-        if (isClosed())
+        return getTime(findColumn(columnLabel), cal);
-            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
-        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
    }
    @Override
-    public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException {
+    public abstract Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException;
-        if (isClosed())
-            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
-        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
-    }
    @Override
    public Timestamp getTimestamp(String columnLabel, Calendar cal) throws SQLException {
-        if (isClosed())
+        return getTimestamp(findColumn(columnLabel), cal);
-            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
-        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
    }
    @Override
@@ -1198,9 +1168,7 @@ public abstract class AbstractResultSet extends WrapperImpl implements ResultSet
    @Override
    public <T> T getObject(String columnLabel, Class<T> type) throws SQLException {
-        if (isClosed())
+        return getObject(findColumn(columnLabel), type);
-            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
-        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
    }
 }
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractStatement.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractStatement.java
@@ -9,6 +9,8 @@ public abstract class AbstractStatement extends WrapperImpl implements Statement
    protected List<String> batchedArgs;
    private int fetchSize;
    @Override
    public abstract ResultSet executeQuery(String sql) throws SQLException;

--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/SavedPreparedStatement.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/SavedPreparedStatement.java
-package com.taosdata.jdbc;
-import com.taosdata.jdbc.bean.TSDBPreparedParam;
-import java.sql.SQLException;
-import java.sql.Timestamp;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-/**
- * this class is used to precompile the sql of tdengine insert or import ops
- */
-public class SavedPreparedStatement {
-    private TSDBPreparedStatement tsdbPreparedStatement;
-    /**
-     * sql param List
-     */
-    private List<TSDBPreparedParam> sqlParamList;
-    /**
-     * init param according the sql
-     */
-    private TSDBPreparedParam initPreparedParam;
-    /**
-     * is table name dynamic in the prepared sql
-     */
-    private boolean isTableNameDynamic;
-    /**
-     * insert or import sql template pattern, the template are the following:
-     * <p>
-     * insert/import into tableName [(field1, field2, ...)] [using stables tags(?, ?, ...) ] values(?, ?, ...) (?, ?, ...)
-     * <p>
-     * we split it to three part:
-     * 1. prefix, insert/import
-     * 2. middle, tableName [(field1, field2, ...)] [using stables tags(?, ?, ...) ]
-     * 3. valueList, the content after values, for example (?, ?, ...) (?, ?, ...)
-     */
-    private Pattern sqlPattern = Pattern.compile("(?s)(?i)^\\s*(INSERT|IMPORT)\\s+INTO\\s+((?<tablename>\\S+)\\s*(\\(.*\\))?\\s+(USING\\s+(?<stableName>\\S+)\\s+TAGS\\s*\\((?<tagValue>.+)\\))?)\\s*VALUES\\s*(?<valueList>\\(.*\\)).*");
-    /**
-     * the raw sql template
-     */
-    private String sql;
-    /**
-     * the prefix part of sql
-     */
-    private String prefix;
-    /**
-     * the middle part of sql
-     */
-    private String middle;
-    private int middleParamSize;
-    /**
-     * the valueList part of sql
-     */
-    private String valueList;
-    private int valueListSize;
-    /**
-     * default param value
-     */
-    private static final String DEFAULT_VALUE = "NULL";
-    private static final String PLACEHOLDER = "?";
-    private String tableName;
-    /**
-     * is the parameter add to batch list
-     */
-    private boolean isAddBatch;
-    public SavedPreparedStatement(String sql, TSDBPreparedStatement tsdbPreparedStatement) throws SQLException {
-        this.sql = sql;
-        this.tsdbPreparedStatement = tsdbPreparedStatement;
-        this.sqlParamList = new ArrayList<>();
-        parsePreparedParam(this.sql);
-    }
-    /**
-     * parse the init param according the sql param
-     *
-     * @param sql
-     */
-    private void parsePreparedParam(String sql) throws SQLException {
-        Matcher matcher = sqlPattern.matcher(sql);
-        if (matcher.find()) {
-            tableName = matcher.group("tablename");
-            if (tableName != null && PLACEHOLDER.equals(tableName)) {
-                // the table name is dynamic
-                this.isTableNameDynamic = true;
-            }
-            prefix = matcher.group(1);
-            middle = matcher.group(2);
-            valueList = matcher.group("valueList");
-            if (middle != null && !"".equals(middle)) {
-                middleParamSize = parsePlaceholder(middle);
-            }
-            if (valueList != null && !"".equals(valueList)) {
-                valueListSize = parsePlaceholder(valueList);
-            }
-            initPreparedParam = initDefaultParam(tableName, middleParamSize, valueListSize);
-        } else {
-            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_SQL);
-        }
-    }
-    private TSDBPreparedParam initDefaultParam(String tableName, int middleParamSize, int valueListSize) {
-        TSDBPreparedParam tsdbPreparedParam = new TSDBPreparedParam(tableName);
-        tsdbPreparedParam.setMiddleParamList(getDefaultParamList(middleParamSize));
-        tsdbPreparedParam.setValueList(getDefaultParamList(valueListSize));
-        return tsdbPreparedParam;
-    }
-    /**
-     * generate the default param value list
-     *
-     * @param paramSize
-     * @return
-     */
-    private List<Object> getDefaultParamList(int paramSize) {
-        List<Object> paramList = new ArrayList<>(paramSize);
-        if (paramSize > 0) {
-            for (int i = 0; i < paramSize; i++) {
-                paramList.add(i, DEFAULT_VALUE);
-            }
-        }
-        return paramList;
-    }
-    /**
-     * calculate the placeholder num
-     *
-     * @param value
-     * @return
-     */
-    private int parsePlaceholder(String value) {
-        Pattern pattern = Pattern.compile("[?]");
-        Matcher matcher = pattern.matcher(value);
-        int result = 0;
-        while (matcher.find()) {
-            result++;
-        }
-        return result;
-    }
-    /**
-     * set current row params
-     *
-     * @param parameterIndex the first parameter is 1, the second is 2, ...
-     * @param x              the parameter value
-     */
-    public void setParam(int parameterIndex, Object x) throws SQLException {
-        int paramSize = this.middleParamSize + this.valueListSize;
-        String errorMsg = String.format("the parameterIndex %s out of the range [1, %s]", parameterIndex, paramSize);
-        if (parameterIndex < 1 || parameterIndex > paramSize) {
-            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE,errorMsg);
-        }
-        this.isAddBatch = false; //set isAddBatch to false
-        if (x == null) {
-            x = DEFAULT_VALUE; // set default null string
-        }
-        parameterIndex = parameterIndex - 1; // start from 0 in param list
-        if (this.middleParamSize > 0 && parameterIndex >= 0 && parameterIndex < this.middleParamSize) {
-            this.initPreparedParam.setMiddleParam(parameterIndex, x);
-            return;
-        }
-        if (this.valueListSize > 0 && parameterIndex >= this.middleParamSize && parameterIndex < paramSize) {
-            this.initPreparedParam.setValueParam(parameterIndex - this.middleParamSize, x);
-            return;
-        }
-        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE,errorMsg);
-    }
-    public void addBatch() {
-        addCurrentRowParamToList();
-        this.initPreparedParam = initDefaultParam(tableName, middleParamSize, valueListSize);
-    }
-    /**
-     * add current param to batch list
-     */
-    private void addCurrentRowParamToList() {
-        if (initPreparedParam != null && (this.middleParamSize > 0 || this.valueListSize > 0)) {
-            this.sqlParamList.add(initPreparedParam); // add current param to batch list
-        }
-        this.isAddBatch = true;
-    }
-    /**
-     * execute the sql with batch sql
-     *
-     * @return
-     * @throws SQLException
-     */
-    public int[] executeBatch() throws SQLException {
-        int result = executeBatchInternal();
-        return new int[]{result};
-    }
-    public int executeBatchInternal() throws SQLException {
-        if (!isAddBatch) {
-            addCurrentRowParamToList(); // add current param to batch list
-        }
-        //1. generate batch sql
-        String sql = generateExecuteSql();
-        //2. execute batch sql
-        int result = executeSql(sql);
-        //3. clear batch param list
-        this.sqlParamList.clear();
-        return result;
-    }
-    /**
-     * generate the batch sql
-     *
-     * @return
-     */
-    private String generateExecuteSql() {
-        StringBuilder stringBuilder = new StringBuilder();
-        stringBuilder.append(prefix);
-        stringBuilder.append(" into ");
-        if (!isTableNameDynamic) {
-            // tablename will not need to be replaced
-            String middleValue = replaceMiddleListParam(middle, sqlParamList);
-            stringBuilder.append(middleValue);
-            stringBuilder.append(" values");
-            stringBuilder.append(replaceValueListParam(valueList, sqlParamList));
-        } else {
-            // need to replace tablename
-            if (sqlParamList.size() > 0) {
-                TSDBPreparedParam firstPreparedParam = sqlParamList.get(0);
-                //replace middle part and value part of first row
-                String firstRow = replaceMiddleAndValuePart(firstPreparedParam);
-                stringBuilder.append(firstRow);
-                //the first param in the middleParamList is the tableName
-                String lastTableName = firstPreparedParam.getMiddleParamList().get(0).toString();
-                if (sqlParamList.size() > 1) {
-                    for (int i = 1; i < sqlParamList.size(); i++) {
-                        TSDBPreparedParam currentParam = sqlParamList.get(i);
-                        String currentTableName = currentParam.getMiddleParamList().get(0).toString();
-                        if (lastTableName.equalsIgnoreCase(currentTableName)) {
-                            // tablename is same with the last row ,so only need to append the part of value
-                            String values = replaceTemplateParam(valueList, currentParam.getValueList());
-                            stringBuilder.append(values);
-                        } else {
-                            // tablename difference with the last row
-                            //need to replace middle part and value part
-                            String row = replaceMiddleAndValuePart(currentParam);
-                            stringBuilder.append(row);
-                            lastTableName = currentTableName;
-                        }
-                    }
-                }
-            } else {
-                stringBuilder.append(middle);
-                stringBuilder.append(" values");
-                stringBuilder.append(valueList);
-            }
-        }
-        return stringBuilder.toString();
-    }
-    /**
-     * replace the middle and value part
-     *
-     * @param tsdbPreparedParam
-     * @return
-     */
-    private String replaceMiddleAndValuePart(TSDBPreparedParam tsdbPreparedParam) {
-        StringBuilder stringBuilder = new StringBuilder(" ");
-        String middlePart = replaceTemplateParam(middle, tsdbPreparedParam.getMiddleParamList());
-        stringBuilder.append(middlePart);
-        stringBuilder.append(" values ");
-        String valuePart = replaceTemplateParam(valueList, tsdbPreparedParam.getValueList());
-        stringBuilder.append(valuePart);
-        stringBuilder.append(" ");
-        return stringBuilder.toString();
-    }
-    /**
-     * replace the placeholder of the middle part of sql template with TSDBPreparedParam list
-     *
-     * @param template
-     * @param sqlParamList
-     * @return
-     */
-    private String replaceMiddleListParam(String template, List<TSDBPreparedParam> sqlParamList) {
-        if (sqlParamList.size() > 0) {
-            //becase once the subTableName is static then  will be ignore the tag which after the first setTag
-            return replaceTemplateParam(template, sqlParamList.get(0).getMiddleParamList());
-        }
-        return template;
-    }
-    /**
-     * replace the placeholder of the template with TSDBPreparedParam list
-     *
-     * @param template
-     * @param sqlParamList
-     * @return
-     */
-    private String replaceValueListParam(String template, List<TSDBPreparedParam> sqlParamList) {
-        StringBuilder stringBuilder = new StringBuilder();
-        if (sqlParamList.size() > 0) {
-            for (TSDBPreparedParam tsdbPreparedParam : sqlParamList) {
-                String tmp = replaceTemplateParam(template, tsdbPreparedParam.getValueList());
-                stringBuilder.append(tmp);
-            }
-        } else {
-            stringBuilder.append(template);
-        }
-        return stringBuilder.toString();
-    }
-    /**
-     * replace the placeholder of the template with paramList
-     *
-     * @param template
-     * @param paramList
-     * @return
-     */
-    private String replaceTemplateParam(String template, List<Object> paramList) {
-        if (paramList.size() > 0) {
-            String tmp = template;
-            for (int i = 0; i < paramList.size(); ++i) {
-                String paraStr = getParamString(paramList.get(i));
-                tmp = tmp.replaceFirst("[" + PLACEHOLDER + "]", paraStr);
-            }
-            return tmp;
-        } else {
-            return template;
-        }
-    }
-    /**
-     * get the string of param object
-     *
-     * @param paramObj
-     * @return
-     */
-    private String getParamString(Object paramObj) {
-        String paraStr = paramObj.toString();
-        if (paramObj instanceof Timestamp || (paramObj instanceof String && !DEFAULT_VALUE.equalsIgnoreCase(paraStr))) {
-            paraStr = "'" + paraStr + "'";
-        }
-        return paraStr;
-    }
-    private int executeSql(String sql) throws SQLException {
-        return tsdbPreparedStatement.executeUpdate(sql);
-    }
-}
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBConnection.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBConnection.java
@@ -27,10 +27,6 @@ public class TSDBConnection extends AbstractConnection {
        return this.batchFetch;
    }
-    public void setBatchFetch(Boolean batchFetch) {
-        this.batchFetch = batchFetch;
-    }
    public TSDBConnection(Properties info, TSDBDatabaseMetaData meta) throws SQLException {
        this.databaseMetaData = meta;
        connect(info.getProperty(TSDBDriver.PROPERTY_KEY_HOST),
@@ -61,9 +57,7 @@ public class TSDBConnection extends AbstractConnection {
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
        }
-        TSDBStatement statement = new TSDBStatement(this, this.connector);
+        return new TSDBStatement(this, this.connector);
-        statement.setConnection(this);
-        return statement;
    }
    public TSDBSubscribe subscribe(String topic, String sql, boolean restart) throws SQLException {
@@ -79,10 +73,8 @@ public class TSDBConnection extends AbstractConnection {
    }
    public PreparedStatement prepareStatement(String sql) throws SQLException {
-        if (isClosed()) {
+        if (isClosed())
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
-        }
        return new TSDBPreparedStatement(this, this.connector, sql);
    }
@@ -104,11 +96,4 @@ public class TSDBConnection extends AbstractConnection {
        return this.databaseMetaData;
    }
-    public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
+}
-        if (isClosed()) {
\ No newline at end of file
-            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
-        }
-        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
-    }
-}
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBJNIConnector.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBJNIConnector.java
@@ -29,45 +29,25 @@ public class TSDBJNIConnector {
    private static volatile Boolean isInitialized = false;
    private TaosInfo taosInfo = TaosInfo.getInstance();
+    // Connection pointer used in C
+    private long taos = TSDBConstants.JNI_NULL_POINTER;
+    // result set status in current connection
+    private boolean isResultsetClosed = true;
+    private int affectedRows = -1;
    static {
        System.loadLibrary("taos");
        System.out.println("java.library.path:" + System.getProperty("java.library.path"));
    }
-    /**
-     * Connection pointer used in C
-     */
-    private long taos = TSDBConstants.JNI_NULL_POINTER;
-    /**
-     * Result set pointer for the current connection
-     */
-//    private long taosResultSetPointer = TSDBConstants.JNI_NULL_POINTER;
-    /**
-     * result set status in current connection
-     */
-    private boolean isResultsetClosed = true;
-    private int affectedRows = -1;
-    /**
-     * Whether the connection is closed
-     */
    public boolean isClosed() {
        return this.taos == TSDBConstants.JNI_NULL_POINTER;
    }
-    /**
-     * Returns the status of last result set in current connection
-     */
    public boolean isResultsetClosed() {
        return this.isResultsetClosed;
    }
-    /**
-     * Initialize static variables in JNI to optimize performance
-     */
    public static void init(String configDir, String locale, String charset, String timezone) throws SQLWarning {
        synchronized (isInitialized) {
            if (!isInitialized) {
@@ -93,11 +73,6 @@ public class TSDBJNIConnector {
    public static native String getTsCharset();
-    /**
-     * Get connection pointer
-     *
-     * @throws SQLException
-     */
    public boolean connect(String host, int port, String dbName, String user, String password) throws SQLException {
        if (this.taos != TSDBConstants.JNI_NULL_POINTER) {
 //            this.closeConnectionImp(this.taos);
@@ -185,13 +160,6 @@ public class TSDBJNIConnector {
    private native String getErrMsgImp(long pSql);
-    /**
-     * Get resultset pointer
-     * Each connection should have a single open result set at a time
-     */
-//    public long getResultSet() {
-//        return taosResultSetPointer;
-//    }
    private native long getResultSetImp(long connection, long pSql);
    public boolean isUpdateQuery(long pSql) {
@@ -231,6 +199,7 @@ public class TSDBJNIConnector {
 //        }
 //        return resCode;
 //    }
    private native int freeResultSetImp(long connection, long result);
    /**
@@ -323,8 +292,7 @@ public class TSDBJNIConnector {
     * Validate if a <I>create table</I> sql statement is correct without actually creating that table
     */
    public boolean validateCreateTableSql(String sql) {
-        long connection = taos;
+        int res = validateCreateTableSqlImp(taos, sql.getBytes());
-        int res = validateCreateTableSqlImp(connection, sql.getBytes());
        return res != 0 ? false : true;
    }

--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBParameterMetaData.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBParameterMetaData.java
+package com.taosdata.jdbc;
+public class TSDBParameterMetaData extends AbstractParameterMetaData {
+    public TSDBParameterMetaData(Object[] parameters) {
+        super(parameters);
+    }
+}
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBPreparedStatement.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBPreparedStatement.java
@@ -18,6 +18,7 @@ import java.io.InputStream;
 import java.io.Reader;
 import java.math.BigDecimal;
 import java.net.URL;
+import java.nio.charset.Charset;
 import java.sql.*;
 import java.util.ArrayList;
 import java.util.Calendar;
@@ -30,36 +31,49 @@ import java.util.regex.Pattern;
 * compatibility needs.
 */
 public class TSDBPreparedStatement extends TSDBStatement implements PreparedStatement {
-    protected String rawSql;
-    protected String sql;
+    private String rawSql;
-    protected ArrayList<Object> parameters = new ArrayList<>();
+    private String sql;
+    //    private ArrayList<Object> parameters = new ArrayList<>();
+    private Object[] parameters;
+    private boolean isPrepared;
    //start with insert or import and is case-insensitive
    private static Pattern savePattern = Pattern.compile("(?i)^\\s*(insert|import)");
    // is insert or import
    private boolean isSaved;
-    private SavedPreparedStatement savedPreparedStatement;
+    //    private SavedPreparedStatement savedPreparedStatement;
-    private ParameterMetaData parameterMetaData;
+    private volatile TSDBParameterMetaData parameterMetaData;
    TSDBPreparedStatement(TSDBConnection connection, TSDBJNIConnector connecter, String sql) {
        super(connection, connecter);
        init(sql);
+        if (sql.contains("?")) {
+            int parameterCnt = 0;
+            for (int i = 0; i < sql.length(); i++) {
+                if ('?' == sql.charAt(i)) {
+                    parameterCnt++;
+                }
+            }
+            parameters = new Object[parameterCnt];
+            this.isPrepared = true;
+        }
    }
    private void init(String sql) {
        this.rawSql = sql;
        preprocessSql();
+//        this.isSaved = isSavedSql(this.rawSql);
+//        if (this.isSaved) {
+//            try {
+//                this.savedPreparedStatement = new SavedPreparedStatement(this.rawSql, this);
+//            } catch (SQLException e) {
+//                e.printStackTrace();
+//            }
+//        }
-        this.isSaved = isSavedSql(this.rawSql);
-        if (this.isSaved) {
-            try {
-                this.savedPreparedStatement = new SavedPreparedStatement(this.rawSql, this);
-            } catch (SQLException e) {
-                e.printStackTrace();
-            }
-        }
    }
    /**
@@ -75,19 +89,11 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
    @Override
    public int[] executeBatch() throws SQLException {
-        if (isSaved) {
+//        if (isSaved) {
-            return this.savedPreparedStatement.executeBatch();
+//            return this.savedPreparedStatement.executeBatch();
-        } else {
+//        } else {
-            return super.executeBatch();
+        return super.executeBatch();
-        }
+//        }
-    }
-    public ArrayList<Object> getParameters() {
-        return parameters;
-    }
-    public void setParameters(ArrayList<Object> parameters) {
-        this.parameters = parameters;
    }
    /*
@@ -151,41 +157,73 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
     *
     * @return a string of the native sql statement for TSDB
     */
-    private String getNativeSql() {
+//    private String getNativeSql(String rawSql) {
-        this.sql = this.rawSql;
+//        for (int i = 0; i < parameters.length; i++) {
-        for (int i = 0; i < parameters.size(); ++i) {
+//            Object para = parameters[i];
-            Object para = parameters.get(i);
+//            if (para != null) {
+//                String paraStr = para.toString();
+//                if (para instanceof Timestamp || para instanceof String) {
+//                    paraStr = "'" + paraStr + "'";
+//                }
+//                this.sql = this.sql.replaceFirst("[?]", paraStr);
+//            } else {
+//                this.sql = this.sql.replaceFirst("[?]", "NULL");
+//            }
+//        }
+//        parameters = new Object[parameters.length];
+//        return sql;
+//    }
+    private String getNativeSql(String rawSql) throws SQLException {
+        String sql = rawSql;
+        for (int i = 0; i < parameters.length; ++i) {
+            Object para = parameters[i];
            if (para != null) {
-                String paraStr = para.toString();
+                String paraStr;
-                if (para instanceof Timestamp || para instanceof String) {
+                if (para instanceof byte[]) {
+                    paraStr = new String((byte[]) para, Charset.forName("UTF-8"));
+                } else {
+                    paraStr = para.toString();
+                }
+                // if para is timestamp or String or byte[] need to translate ' character
+                if (para instanceof Timestamp || para instanceof String || para instanceof byte[]) {
+                    paraStr = paraStr.replaceAll("'", "\\\\\\\\'");
                    paraStr = "'" + paraStr + "'";
                }
-                this.sql = this.sql.replaceFirst("[?]", paraStr);
+                sql = sql.replaceFirst("[?]", paraStr);
            } else {
-                this.sql = this.sql.replaceFirst("[?]", "NULL");
+                sql = sql.replaceFirst("[?]", "NULL");
            }
        }
-        parameters.clear();
+        clearParameters();
        return sql;
    }
    @Override
    public ResultSet executeQuery() throws SQLException {
-        if (isSaved) {
+//        if (isSaved) {
-            this.savedPreparedStatement.executeBatchInternal();
+//            this.savedPreparedStatement.executeBatchInternal();
-            return null;
+//            return null;
-        } else {
+//        } else {
-            return super.executeQuery(getNativeSql());
-        }
+        if (!isPrepared)
+            return executeQuery(this.rawSql);
+        final String sql = getNativeSql(this.rawSql);
+        return executeQuery(sql);
+//        }
    }
    @Override
    public int executeUpdate() throws SQLException {
-        if (isSaved) {
+//        if (isSaved) {
-            return this.savedPreparedStatement.executeBatchInternal();
+//            return this.savedPreparedStatement.executeBatchInternal();
-        } else {
+//        } else {
-            return super.executeUpdate(getNativeSql());
+        if (!isPrepared)
-        }
+            return executeUpdate(this.rawSql);
+        String sql = getNativeSql(this.rawSql);
+        return executeUpdate(sql);
+//        }
    }
    private boolean isSupportedSQLType(int sqlType) {
@@ -201,35 +239,6 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
            case Types.BINARY:
            case Types.NCHAR:
                return true;
-            case Types.ARRAY:
-            case Types.BIT:
-            case Types.BLOB:
-            case Types.CHAR:
-            case Types.CLOB:
-            case Types.DATALINK:
-            case Types.DATE:
-            case Types.DECIMAL:
-            case Types.DISTINCT:
-            case Types.JAVA_OBJECT:
-            case Types.LONGNVARCHAR:
-            case Types.LONGVARBINARY:
-            case Types.LONGVARCHAR:
-            case Types.NCLOB:
-            case Types.NULL:
-            case Types.NUMERIC:
-            case Types.NVARCHAR:
-            case Types.OTHER:
-            case Types.REAL:
-            case Types.REF:
-            case Types.REF_CURSOR:
-            case Types.ROWID:
-            case Types.SQLXML:
-            case Types.STRUCT:
-            case Types.TIME:
-            case Types.TIME_WITH_TIMEZONE:
-            case Types.TIMESTAMP_WITH_TIMEZONE:
-            case Types.VARBINARY:
-            case Types.VARCHAR:
            default:
                return false;
        }
@@ -259,7 +268,7 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
    public void setByte(int parameterIndex, byte x) throws SQLException {
        if (isClosed())
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
-        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+        setObject(parameterIndex,x);
    }
    @Override
@@ -315,7 +324,8 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
    public void setBytes(int parameterIndex, byte[] x) throws SQLException {
        if (isClosed())
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
-        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+        setObject(parameterIndex,x);
    }
    @Override
@@ -365,45 +375,63 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
    public void clearParameters() throws SQLException {
        if (isClosed())
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
-        parameters.clear();
+//        parameters.clear();
+        parameters = new Object[parameters.length];
    }
    @Override
    public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
        if (isClosed())
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
    }
    @Override
    public void setObject(int parameterIndex, Object x) throws SQLException {
-        if (isSaved) {
+//        if (isSaved) {
-            this.savedPreparedStatement.setParam(parameterIndex, x);
+//            this.savedPreparedStatement.setParam(parameterIndex, x);
-        } else {
+//        } else {
-            parameters.add(x);
+        if (parameterIndex < 1 && parameterIndex >= parameters.length)
-        }
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE);
+        parameters[parameterIndex - 1] = x;
+//            parameters.add(x);
+//        }
    }
    @Override
    public boolean execute() throws SQLException {
-        if (isSaved) {
+//        if (isSaved) {
-            int result = this.savedPreparedStatement.executeBatchInternal();
+//            int result = this.savedPreparedStatement.executeBatchInternal();
-            return result > 0;
+//            return result > 0;
-        } else {
+//        } else {
-            return super.execute(getNativeSql());
+        if (!isPrepared)
-        }
+            return execute(this.rawSql);
+        final String sql = getNativeSql(this.rawSql);
+        return execute(sql);
+//        }
    }
    @Override
    public void addBatch() throws SQLException {
-        if (isSaved) {
+//        if (isSaved) {
-            this.savedPreparedStatement.addBatch();
+//            this.savedPreparedStatement.addBatch();
+//        } else {
+        if (this.batchedArgs == null) {
+            batchedArgs = new ArrayList<>();
+        }
+        if (!isPrepared) {
+            addBatch(this.rawSql);
        } else {
-            if (this.batchedArgs == null) {
+            String sql = this.getConnection().nativeSQL(this.rawSql);
-                batchedArgs = new ArrayList<>();
+            addBatch(sql);
-            }
-            super.addBatch(getNativeSql());
        }
+//        }
    }
    @Override
@@ -491,9 +519,11 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
    public ParameterMetaData getParameterMetaData() throws SQLException {
        if (isClosed())
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
-        //TODO: parameterMetaData not supported
-//        return null;
+        if (parameterMetaData == null) {
-        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+            this.parameterMetaData = new TSDBParameterMetaData(parameters);
+        }
+        return this.parameterMetaData;
    }
    @Override

--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSet.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSet.java
@@ -14,9 +14,14 @@
 *****************************************************************************/
 package com.taosdata.jdbc;
+import com.google.common.primitives.Ints;
+import com.google.common.primitives.Longs;
+import com.google.common.primitives.Shorts;
 import java.math.BigDecimal;
 import java.sql.*;
 import java.util.ArrayList;
+import java.util.Calendar;
 import java.util.List;
 public class TSDBResultSet extends AbstractResultSet implements ResultSet {
@@ -120,158 +125,189 @@ public class TSDBResultSet extends AbstractResultSet implements ResultSet {
    }
    public String getString(int columnIndex) throws SQLException {
-        String res = null;
+        checkAvailability(columnIndex, this.columnMetaDataList.size());
-        int colIndex = getTrueColumnIndex(columnIndex);
+        String res = null;
        if (this.getBatchFetch())
-            return this.blockData.getString(colIndex);
+            return this.blockData.getString(columnIndex - 1);
-        this.lastWasNull = this.rowData.wasNull(colIndex);
+        this.lastWasNull = this.rowData.wasNull(columnIndex - 1);
        if (!lastWasNull) {
-            res = this.rowData.getString(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+            res = this.rowData.getString(columnIndex - 1, this.columnMetaDataList.get(columnIndex - 1).getColType());
        }
        return res;
    }
    public boolean getBoolean(int columnIndex) throws SQLException {
-        boolean res = false;
+        checkAvailability(columnIndex, this.columnMetaDataList.size());
-        int colIndex = getTrueColumnIndex(columnIndex);
+        boolean res = false;
        if (this.getBatchFetch())
-            return this.blockData.getBoolean(colIndex);
+            return this.blockData.getBoolean(columnIndex - 1);
-        this.lastWasNull = this.rowData.wasNull(colIndex);
+        this.lastWasNull = this.rowData.wasNull(columnIndex - 1);
        if (!lastWasNull) {
-            res = this.rowData.getBoolean(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+            res = this.rowData.getBoolean(columnIndex - 1, this.columnMetaDataList.get(columnIndex - 1).getColType());
        }
        return res;
    }
    public byte getByte(int columnIndex) throws SQLException {
-        byte res = 0;
+        checkAvailability(columnIndex, this.columnMetaDataList.size());
-        int colIndex = getTrueColumnIndex(columnIndex);
+        byte res = 0;
        if (this.getBatchFetch())
-            return (byte) this.blockData.getInt(colIndex);
+            return (byte) this.blockData.getInt(columnIndex - 1);
-        this.lastWasNull = this.rowData.wasNull(colIndex);
+        this.lastWasNull = this.rowData.wasNull(columnIndex - 1);
        if (!lastWasNull) {
-            res = (byte) this.rowData.getInt(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+            res = (byte) this.rowData.getInt(columnIndex - 1, this.columnMetaDataList.get(columnIndex - 1).getColType());
        }
        return res;
    }
    public short getShort(int columnIndex) throws SQLException {
-        short res = 0;
+        checkAvailability(columnIndex, this.columnMetaDataList.size());
-        int colIndex = getTrueColumnIndex(columnIndex);
+        short res = 0;
        if (this.getBatchFetch())
-            return (short) this.blockData.getInt(colIndex);
+            return (short) this.blockData.getInt(columnIndex - 1);
-        this.lastWasNull = this.rowData.wasNull(colIndex);
+        this.lastWasNull = this.rowData.wasNull(columnIndex - 1);
        if (!lastWasNull) {
-            res = (short) this.rowData.getInt(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+            res = (short) this.rowData.getInt(columnIndex - 1, this.columnMetaDataList.get(columnIndex - 1).getColType());
        }
        return res;
    }
    public int getInt(int columnIndex) throws SQLException {
-        int res = 0;
+        checkAvailability(columnIndex, this.columnMetaDataList.size());
-        int colIndex = getTrueColumnIndex(columnIndex);
+        int res = 0;
        if (this.getBatchFetch())
-            return this.blockData.getInt(colIndex);
+            return this.blockData.getInt(columnIndex - 1);
-        this.lastWasNull = this.rowData.wasNull(colIndex);
+        this.lastWasNull = this.rowData.wasNull(columnIndex - 1);
        if (!lastWasNull) {
-            res = this.rowData.getInt(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+            res = this.rowData.getInt(columnIndex - 1, this.columnMetaDataList.get(columnIndex - 1).getColType());
        }
        return res;
    }
    public long getLong(int columnIndex) throws SQLException {
-        long res = 0L;
+        checkAvailability(columnIndex, this.columnMetaDataList.size());
-        int colIndex = getTrueColumnIndex(columnIndex);
+        long res = 0L;
        if (this.getBatchFetch())
-            return this.blockData.getLong(colIndex);
+            return this.blockData.getLong(columnIndex - 1);
-        this.lastWasNull = this.rowData.wasNull(colIndex);
+        this.lastWasNull = this.rowData.wasNull(columnIndex - 1);
        if (!lastWasNull) {
-            res = this.rowData.getLong(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+            res = this.rowData.getLong(columnIndex - 1, this.columnMetaDataList.get(columnIndex - 1).getColType());
        }
        return res;
    }
    public float getFloat(int columnIndex) throws SQLException {
-        float res = 0;
+        checkAvailability(columnIndex, this.columnMetaDataList.size());
-        int colIndex = getTrueColumnIndex(columnIndex);
+        float res = 0;
        if (this.getBatchFetch())
-            return (float) this.blockData.getDouble(colIndex);
+            return (float) this.blockData.getDouble(columnIndex - 1);
-        this.lastWasNull = this.rowData.wasNull(colIndex);
+        this.lastWasNull = this.rowData.wasNull(columnIndex - 1);
        if (!lastWasNull)
-            res = this.rowData.getFloat(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+            res = this.rowData.getFloat(columnIndex - 1, this.columnMetaDataList.get(columnIndex - 1).getColType());
        return res;
    }
    public double getDouble(int columnIndex) throws SQLException {
-        double res = 0;
+        checkAvailability(columnIndex, this.columnMetaDataList.size());
-        int colIndex = getTrueColumnIndex(columnIndex);
+        double res = 0;
        if (this.getBatchFetch())
-            return this.blockData.getDouble(colIndex);
+            return this.blockData.getDouble(columnIndex - 1);
-        this.lastWasNull = this.rowData.wasNull(colIndex);
+        this.lastWasNull = this.rowData.wasNull(columnIndex - 1);
        if (!lastWasNull) {
-            res = this.rowData.getDouble(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+            res = this.rowData.getDouble(columnIndex - 1, this.columnMetaDataList.get(columnIndex - 1).getColType());
        }
        return res;
    }
-    @Deprecated
+    public byte[] getBytes(int columnIndex) throws SQLException {
-    public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
+        checkAvailability(columnIndex, this.columnMetaDataList.size());
-        return new BigDecimal(getLong(columnIndex));
+        Object value = this.rowData.get(columnIndex - 1);
+        if (value == null)
+            return null;
+        int colType = this.columnMetaDataList.get(columnIndex - 1).getColType();
+        switch (colType) {
+            case TSDBConstants.TSDB_DATA_TYPE_BIGINT:
+                return Longs.toByteArray((Long) value);
+            case TSDBConstants.TSDB_DATA_TYPE_INT:
+                return Ints.toByteArray((int) value);
+            case TSDBConstants.TSDB_DATA_TYPE_SMALLINT:
+                return Shorts.toByteArray((Short) value);
+            case TSDBConstants.TSDB_DATA_TYPE_TINYINT:
+                return new byte[]{(byte) value};
+        }
+        return value.toString().getBytes();
    }
-    public byte[] getBytes(int columnIndex) throws SQLException {
+    @Override
-        return getString(columnIndex).getBytes();
+    public Date getDate(int columnIndex) throws SQLException {
+        Timestamp timestamp = getTimestamp(columnIndex);
+        return timestamp == null ? null : new Date(timestamp.getTime());
+    }
+    @Override
+    public Time getTime(int columnIndex) throws SQLException {
+        Timestamp timestamp = getTimestamp(columnIndex);
+        return timestamp == null ? null : new Time(timestamp.getTime());
    }
    public Timestamp getTimestamp(int columnIndex) throws SQLException {
+        checkAvailability(columnIndex, this.columnMetaDataList.size());
        Timestamp res = null;
-        int colIndex = getTrueColumnIndex(columnIndex);
        if (this.getBatchFetch())
-            return this.blockData.getTimestamp(columnIndex);
+            return this.blockData.getTimestamp(columnIndex - 1);
-        this.lastWasNull = this.rowData.wasNull(colIndex);
+        this.lastWasNull = this.rowData.wasNull(columnIndex - 1);
        if (!lastWasNull) {
-            res = this.rowData.getTimestamp(colIndex);
+            res = this.rowData.getTimestamp(columnIndex - 1);
        }
        return res;
    }
    public ResultSetMetaData getMetaData() throws SQLException {
+        if (isClosed())
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
        return new TSDBResultSetMetaData(this.columnMetaDataList);
    }
    @Override
    public Object getObject(int columnIndex) throws SQLException {
-        int colIndex = getTrueColumnIndex(columnIndex);
+        checkAvailability(columnIndex, this.columnMetaDataList.size());
+        Object res = null;
        if (this.getBatchFetch())
-            return this.blockData.get(colIndex);
+            return this.blockData.get(columnIndex - 1);
-        this.lastWasNull = this.rowData.wasNull(colIndex);
+        this.lastWasNull = this.rowData.wasNull(columnIndex - 1);
-        return this.rowData.get(colIndex);
+        if (!lastWasNull) {
-    }
+            int colType = this.columnMetaDataList.get(columnIndex - 1).getColType();
+            if (colType == TSDBConstants.TSDB_DATA_TYPE_BINARY)
-    @Override
+                res = ((String) this.rowData.get(columnIndex - 1)).getBytes();
-    public Object getObject(String columnLabel) throws SQLException {
+            else
-        return this.getObject(this.findColumn(columnLabel));
+                res = this.rowData.get(columnIndex - 1);
+        }
+        return res;
    }
    public int findColumn(String columnLabel) throws SQLException {
@@ -285,14 +321,31 @@ public class TSDBResultSet extends AbstractResultSet implements ResultSet {
    @Override
    public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
-        int colIndex = getTrueColumnIndex(columnIndex);
+        if (this.getBatchFetch())
+            return new BigDecimal(this.blockData.getLong(columnIndex - 1));
-        if (!this.getBatchFetch()) {
+        this.lastWasNull = this.rowData.wasNull(columnIndex - 1);
-            this.lastWasNull = this.rowData.wasNull(colIndex);
+        BigDecimal res = null;
-            return new BigDecimal(this.rowData.getLong(colIndex, this.columnMetaDataList.get(colIndex).getColType()));
+        if (!lastWasNull) {
-        } else {
+            int colType = this.columnMetaDataList.get(columnIndex - 1).getColType();
-            return new BigDecimal(this.blockData.getLong(colIndex));
+            switch (colType) {
+                case TSDBConstants.TSDB_DATA_TYPE_TINYINT:
+                case TSDBConstants.TSDB_DATA_TYPE_SMALLINT:
+                case TSDBConstants.TSDB_DATA_TYPE_INT:
+                case TSDBConstants.TSDB_DATA_TYPE_BIGINT:
+                    res = new BigDecimal(Long.valueOf(this.rowData.get(columnIndex - 1).toString()));
+                    break;
+                case TSDBConstants.TSDB_DATA_TYPE_FLOAT:
+                case TSDBConstants.TSDB_DATA_TYPE_DOUBLE:
+                    res = new BigDecimal(Double.valueOf(this.rowData.get(columnIndex - 1).toString()));
+                    break;
+                case TSDBConstants.TSDB_DATA_TYPE_TIMESTAMP:
+                    return new BigDecimal(((Timestamp) this.rowData.get(columnIndex - 1)).getTime());
+                default:
+                    res = new BigDecimal(this.rowData.get(columnIndex - 1).toString());
+            }
        }
+        return res;
    }
    @Override
@@ -398,6 +451,12 @@ public class TSDBResultSet extends AbstractResultSet implements ResultSet {
        return this.statement;
    }
+    @Override
+    public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException {
+        //TODO：did not use the specified timezone in cal
+        return getTimestamp(columnIndex);
+    }
    public boolean isClosed() throws SQLException {
        if (isClosed)
            return true;
@@ -408,17 +467,7 @@ public class TSDBResultSet extends AbstractResultSet implements ResultSet {
    }
    public String getNString(int columnIndex) throws SQLException {
-        int colIndex = getTrueColumnIndex(columnIndex);
+        return getString(columnIndex);
-        return (String) rowData.get(colIndex);
    }
-    private int getTrueColumnIndex(int columnIndex) throws SQLException {
-        if (columnIndex < 1)
-            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE, "columnIndex(" + columnIndex + "): < 1");
-        int numOfCols = this.columnMetaDataList.size();
-        if (columnIndex > numOfCols)
-            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE, "columnIndex: " + columnIndex);
-        return columnIndex - 1;
-    }
 }
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetMetaData.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetMetaData.java
@@ -22,136 +22,160 @@ import java.util.List;
 public class TSDBResultSetMetaData extends WrapperImpl implements ResultSetMetaData {
-	List<ColumnMetaData> colMetaDataList = null;
+    List<ColumnMetaData> colMetaDataList;
-	public TSDBResultSetMetaData(List<ColumnMetaData> metaDataList) {
+    public TSDBResultSetMetaData(List<ColumnMetaData> metaDataList) {
-		this.colMetaDataList = metaDataList;
+        this.colMetaDataList = metaDataList;
-	}
+    }
-	public int getColumnCount() throws SQLException {
+    public int getColumnCount() throws SQLException {
-		return colMetaDataList.size();
+        return colMetaDataList.size();
-	}
+    }
-	public boolean isAutoIncrement(int column) throws SQLException {
+    public boolean isAutoIncrement(int column) throws SQLException {
-		return false;
+        return false;
-	}
+    }
-	public boolean isCaseSensitive(int column) throws SQLException {
+    public boolean isCaseSensitive(int column) throws SQLException {
-		return false;
+        return false;
-	}
+    }
-	public boolean isSearchable(int column) throws SQLException {
+    public boolean isSearchable(int column) throws SQLException {
-		if (column == 1) {
+        if (column == 1) {
-			return true;
+            return true;
-		}
+        }
-		return false;
+        return false;
-	}
+    }
-	public boolean isCurrency(int column) throws SQLException {
+    public boolean isCurrency(int column) throws SQLException {
-		return false;
+        return false;
-	}
+    }
-	public int isNullable(int column) throws SQLException {
+    public int isNullable(int column) throws SQLException {
-		if (column == 1) {
+        if (column < 1 && column >= colMetaDataList.size())
-			return columnNoNulls;
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE);
-		}
-		return columnNullable;
+        if (column == 1) {
-	}
+            return columnNoNulls;
+        }
-	public boolean isSigned(int column) throws SQLException {
+        return columnNullable;
-		ColumnMetaData meta = this.colMetaDataList.get(column - 1);
+    }
-		switch (meta.getColType()) {
-		case TSDBConstants.TSDB_DATA_TYPE_TINYINT:
+    public boolean isSigned(int column) throws SQLException {
-		case TSDBConstants.TSDB_DATA_TYPE_SMALLINT:
+        if (column < 1 && column >= colMetaDataList.size())
-		case TSDBConstants.TSDB_DATA_TYPE_INT:
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE);
-		case TSDBConstants.TSDB_DATA_TYPE_BIGINT:
-		case TSDBConstants.TSDB_DATA_TYPE_FLOAT:
+        ColumnMetaData meta = this.colMetaDataList.get(column - 1);
-		case TSDBConstants.TSDB_DATA_TYPE_DOUBLE:
+        switch (meta.getColType()) {
-			return true;
+            case TSDBConstants.TSDB_DATA_TYPE_TINYINT:
-		default:
+            case TSDBConstants.TSDB_DATA_TYPE_SMALLINT:
-			return false;
+            case TSDBConstants.TSDB_DATA_TYPE_INT:
-		}
+            case TSDBConstants.TSDB_DATA_TYPE_BIGINT:
-	}
+            case TSDBConstants.TSDB_DATA_TYPE_FLOAT:
+            case TSDBConstants.TSDB_DATA_TYPE_DOUBLE:
-	public int getColumnDisplaySize(int column) throws SQLException {
+                return true;
-		return colMetaDataList.get(column - 1).getColSize();
+            default:
-	}
+                return false;
+        }
-	public String getColumnLabel(int column) throws SQLException {
+    }
-		return colMetaDataList.get(column - 1).getColName();
-	}
+    public int getColumnDisplaySize(int column) throws SQLException {
+        if (column < 1 && column >= colMetaDataList.size())
-	public String getColumnName(int column) throws SQLException {
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE);
-		return colMetaDataList.get(column - 1).getColName();
-	}
+        return colMetaDataList.get(column - 1).getColSize();
+    }
-	public String getSchemaName(int column) throws SQLException {
-		throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+    public String getColumnLabel(int column) throws SQLException {
-	}
+        if (column < 1 && column >= colMetaDataList.size())
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE);
-	public int getPrecision(int column) throws SQLException {
-		ColumnMetaData columnMetaData = this.colMetaDataList.get(column - 1);
+        return colMetaDataList.get(column - 1).getColName();
-		switch (columnMetaData.getColType()) {
+    }
-		case TSDBConstants.TSDB_DATA_TYPE_FLOAT:
-			return 5;
+    public String getColumnName(int column) throws SQLException {
-		case TSDBConstants.TSDB_DATA_TYPE_DOUBLE:
+        if (column < 1 && column >= colMetaDataList.size())
-			return 9;
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE);
-		case TSDBConstants.TSDB_DATA_TYPE_BINARY:
-		case TSDBConstants.TSDB_DATA_TYPE_NCHAR:
+        return colMetaDataList.get(column - 1).getColName();
-			return columnMetaData.getColSize();
+    }
-		default:
-			return 0;
+    public String getSchemaName(int column) throws SQLException {
-		}
+        if (column < 1 && column >= colMetaDataList.size())
-	}
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE);
-	public int getScale(int column) throws SQLException {
+        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
-		ColumnMetaData meta = this.colMetaDataList.get(column - 1);
+    }
-		switch (meta.getColType()) {
-		case TSDBConstants.TSDB_DATA_TYPE_FLOAT:
+    public int getPrecision(int column) throws SQLException {
-			return 5;
+        if (column < 1 && column >= colMetaDataList.size())
-		case TSDBConstants.TSDB_DATA_TYPE_DOUBLE:
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE);
-			return 9;
-		default:
+        ColumnMetaData columnMetaData = this.colMetaDataList.get(column - 1);
-			return 0;
+        switch (columnMetaData.getColType()) {
-		}
+            case TSDBConstants.TSDB_DATA_TYPE_FLOAT:
-	}
+                return 5;
+            case TSDBConstants.TSDB_DATA_TYPE_DOUBLE:
-	public String getTableName(int column) throws SQLException {
+                return 9;
-		throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+            case TSDBConstants.TSDB_DATA_TYPE_BINARY:
-	}
+            case TSDBConstants.TSDB_DATA_TYPE_NCHAR:
+                return columnMetaData.getColSize();
-	public String getCatalogName(int column) throws SQLException {
+            default:
-		throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+                return 0;
-	}
+        }
+    }
-	public int getColumnType(int column) throws SQLException {
-		ColumnMetaData meta = this.colMetaDataList.get(column - 1);
+    public int getScale(int column) throws SQLException {
-		return TSDBConstants.taosType2JdbcType(meta.getColType());
+        if (column < 1 && column >= colMetaDataList.size())
-	}
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE);
-	public String getColumnTypeName(int column) throws SQLException {
+        ColumnMetaData meta = this.colMetaDataList.get(column - 1);
-		ColumnMetaData meta = this.colMetaDataList.get(column - 1);
+        switch (meta.getColType()) {
-		return TSDBConstants.taosType2JdbcTypeName(meta.getColType());
+            case TSDBConstants.TSDB_DATA_TYPE_FLOAT:
-	}
+                return 5;
+            case TSDBConstants.TSDB_DATA_TYPE_DOUBLE:
-	public boolean isReadOnly(int column) throws SQLException {
+                return 9;
-		return true;
+            default:
-	}
+                return 0;
+        }
-	public boolean isWritable(int column) throws SQLException {
+    }
-		return false;
-	}
+    public String getTableName(int column) throws SQLException {
+        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
-	public boolean isDefinitelyWritable(int column) throws SQLException {
+    }
-		throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
-	}
+    public String getCatalogName(int column) throws SQLException {
+        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
-	public String getColumnClassName(int column) throws SQLException {
+    }
-		int columnType = getColumnType(column);
-		String columnClassName = "";
+    public int getColumnType(int column) throws SQLException {
-		switch (columnType) {
+        ColumnMetaData meta = this.colMetaDataList.get(column - 1);
-		    case Types.TIMESTAMP:
+        return TSDBConstants.taosType2JdbcType(meta.getColType());
-		        columnClassName = Timestamp.class.getName();
+    }
+    public String getColumnTypeName(int column) throws SQLException {
+        ColumnMetaData meta = this.colMetaDataList.get(column - 1);
+        return TSDBConstants.taosType2JdbcTypeName(meta.getColType());
+    }
+    public boolean isReadOnly(int column) throws SQLException {
+        return true;
+    }
+    public boolean isWritable(int column) throws SQLException {
+        return false;
+    }
+    public boolean isDefinitelyWritable(int column) throws SQLException {
+        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+    }
+    public String getColumnClassName(int column) throws SQLException {
+        int columnType = getColumnType(column);
+        String columnClassName = "";
+        switch (columnType) {
+            case Types.TIMESTAMP:
+                columnClassName = Timestamp.class.getName();
                break;
            case Types.CHAR:
                columnClassName = String.class.getName();
@@ -168,8 +192,8 @@ public class TSDBResultSetMetaData extends WrapperImpl implements ResultSetMetaD
            case Types.INTEGER:
                columnClassName = Integer.class.getName();
                break;
-			case Types.SMALLINT:
+            case Types.SMALLINT:
-				columnClassName = Short.class.getName();
+                columnClassName = Short.class.getName();
                break;
            case Types.TINYINT:
                columnClassName = Byte.class.getName();
@@ -177,7 +201,7 @@ public class TSDBResultSetMetaData extends WrapperImpl implements ResultSetMetaD
            case Types.BIT:
                columnClassName = Boolean.class.getName();
                break;
-		}
+        }
        return columnClassName;
-	}
+    }
 }
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetRowData.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetRowData.java
@@ -21,18 +21,13 @@ import java.util.ArrayList;
 import java.util.Collections;
 public class TSDBResultSetRowData {
-    private ArrayList<Object> data = null;
+    private ArrayList<Object> data;
    private int colSize = 0;
    public TSDBResultSetRowData(int colSize) {
        this.setColSize(colSize);
    }
-    public TSDBResultSetRowData() {
-        this.data = new ArrayList<>();
-        this.setColSize(0);
-    }
    public void clear() {
        if (this.data != null) {
            this.data.clear();
@@ -71,9 +66,9 @@ public class TSDBResultSetRowData {
            case TSDBConstants.TSDB_DATA_TYPE_TIMESTAMP:
            case TSDBConstants.TSDB_DATA_TYPE_BIGINT:
                return ((Long) obj) == 1L ? Boolean.TRUE : Boolean.FALSE;
+            default:
+                return false;
        }
-        return Boolean.TRUE;
    }
    public void setByte(int col, byte value) {
@@ -198,7 +193,7 @@ public class TSDBResultSetRowData {
        data.set(col, value);
    }
-    public float getFloat(int col, int srcType) throws SQLException {
+    public float getFloat(int col, int srcType) {
        Object obj = data.get(col);
        switch (srcType) {
@@ -226,7 +221,7 @@ public class TSDBResultSetRowData {
        data.set(col, value);
    }
-    public double getDouble(int col, int srcType) throws SQLException {
+    public double getDouble(int col, int srcType) {
        Object obj = data.get(col);
        switch (srcType) {
@@ -267,9 +262,8 @@ public class TSDBResultSetRowData {
     *
     * @param col column index
     * @return
-     * @throws SQLException
     */
-    public String getString(int col, int srcType) throws SQLException {
+    public String getString(int col, int srcType) {
        switch (srcType) {
            case TSDBConstants.TSDB_DATA_TYPE_BINARY:
            case TSDBConstants.TSDB_DATA_TYPE_NCHAR:
@@ -305,11 +299,11 @@ public class TSDBResultSetRowData {
    }
    public void setTimestamp(int col, long ts) {
-        data.set(col, ts);
+        data.set(col, new Timestamp(ts));
    }
    public Timestamp getTimestamp(int col) {
-        return new Timestamp((Long) data.get(col));
+        return (Timestamp) data.get(col);
    }
    public Object get(int col) {
@@ -320,7 +314,7 @@ public class TSDBResultSetRowData {
        return colSize;
    }
-    public void setColSize(int colSize) {
+    private void setColSize(int colSize) {
        this.colSize = colSize;
        this.clear();
    }

--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/bean/TSDBPreparedParam.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/bean/TSDBPreparedParam.java
-package com.taosdata.jdbc.bean;
-import java.util.List;
-/**
- * tdengine batch insert or import param object
- */
-public class TSDBPreparedParam {
-    /**
-     * tableName, if sTable Name is not null, and this is sub table name.
-     */
-    private String tableName;
-    /**
-     * sub middle param list
-     */
-    private List<Object> middleParamList;
-    /**
-     * value list
-     */
-    private List<Object> valueList;
-    public TSDBPreparedParam(String tableName) {
-        this.tableName = tableName;
-    }
-    public String getTableName() {
-        return tableName;
-    }
-    public void setTableName(String tableName) {
-        this.tableName = tableName;
-    }
-    public List<Object> getMiddleParamList() {
-        return middleParamList;
-    }
-    public void setMiddleParamList(List<Object> middleParamList) {
-        this.middleParamList = middleParamList;
-    }
-    public void setMiddleParam(int parameterIndex, Object x) {
-        this.middleParamList.set(parameterIndex, x);
-    }
-    public List<Object> getValueList() {
-        return valueList;
-    }
-    public void setValueList(List<Object> valueList) {
-        this.valueList = valueList;
-    }
-    public void setValueParam(int parameterIndex, Object x) {
-        this.valueList.set(parameterIndex, x);
-    }
-}
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulConnection.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulConnection.java
 package com.taosdata.jdbc.rs;
-import com.taosdata.jdbc.*;
+import com.taosdata.jdbc.AbstractConnection;
+import com.taosdata.jdbc.TSDBDriver;
-import java.sql.*;
+import com.taosdata.jdbc.TSDBError;
+import com.taosdata.jdbc.TSDBErrorNumbers;
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.Statement;
 import java.util.Properties;
 public class RestfulConnection extends AbstractConnection {
@@ -55,7 +61,6 @@ public class RestfulConnection extends AbstractConnection {
    public DatabaseMetaData getMetaData() throws SQLException {
        if (isClosed())
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
-        ;
        return this.metadata;
    }

--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulDriver.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulDriver.java
@@ -17,7 +17,7 @@ public class RestfulDriver extends AbstractDriver {
    static {
        try {
-            DriverManager.registerDriver(new RestfulDriver());
+            java.sql.DriverManager.registerDriver(new RestfulDriver());
        } catch (SQLException e) {
            throw TSDBError.createRuntimeException(TSDBErrorNumbers.ERROR_URL_NOT_SET, e);
        }

--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulParameterMetaData.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulParameterMetaData.java
+package com.taosdata.jdbc.rs;
+import com.taosdata.jdbc.AbstractParameterMetaData;
+public class RestfulParameterMetaData extends AbstractParameterMetaData {
+    RestfulParameterMetaData(Object[] parameters) {
+        super(parameters);
+    }
+}
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulPreparedStatement.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulPreparedStatement.java
@@ -7,6 +7,7 @@ import java.io.InputStream;
 import java.io.Reader;
 import java.math.BigDecimal;
 import java.net.URL;
+import java.nio.charset.Charset;
 import java.sql.*;
 import java.util.Calendar;
@@ -30,7 +31,9 @@ public class RestfulPreparedStatement extends RestfulStatement implements Prepar
            parameters = new Object[parameterCnt];
            this.isPrepared = true;
        }
-        //TODO: build parameterMetaData
+        // build parameterMetaData
+        this.parameterMetaData = new RestfulParameterMetaData(parameters);
    }
    @Override
@@ -60,8 +63,15 @@ public class RestfulPreparedStatement extends RestfulStatement implements Prepar
        for (int i = 0; i < parameters.length; ++i) {
            Object para = parameters[i];
            if (para != null) {
-                String paraStr = para.toString();
+                String paraStr;
-                if (para instanceof Timestamp || para instanceof String) {
+                if (para instanceof byte[]) {
+                    paraStr = new String((byte[]) para, Charset.forName("UTF-8"));
+                } else {
+                    paraStr = para.toString();
+                }
+                // if para is timestamp or String or byte[] need to translate ' character
+                if (para instanceof Timestamp || para instanceof String || para instanceof byte[]) {
+                    paraStr = paraStr.replaceAll("'", "\\\\\\\\'");
                    paraStr = "'" + paraStr + "'";
                }
                sql = sql.replaceFirst("[?]", paraStr);
@@ -92,7 +102,7 @@ public class RestfulPreparedStatement extends RestfulStatement implements Prepar
    public void setByte(int parameterIndex, byte x) throws SQLException {
        if (isClosed())
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
-        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+        setObject(parameterIndex, x);
    }
    @Override
@@ -153,7 +163,7 @@ public class RestfulPreparedStatement extends RestfulStatement implements Prepar
    public void setBytes(int parameterIndex, byte[] x) throws SQLException {
        if (isClosed())
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
-        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+        setObject(parameterIndex, x);
    }
    @Override
@@ -210,19 +220,16 @@ public class RestfulPreparedStatement extends RestfulStatement implements Prepar
    public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
        if (isClosed())
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
-        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+        setObject(parameterIndex,x);
    }
    @Override
    public void setObject(int parameterIndex, Object x) throws SQLException {
-        if (isClosed())
-            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
        if (parameterIndex < 1 && parameterIndex >= parameters.length)
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE);
        parameters[parameterIndex - 1] = x;
    }
    @Override

--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulResultSet.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulResultSet.java
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/utils/OSUtils.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/utils/OSUtils.java
+package com.taosdata.jdbc.utils;
+public class OSUtils {
+    private static final String OS = System.getProperty("os.name").toLowerCase();
+    public static boolean isWindows() {
+        return OS.indexOf("win") >= 0;
+    }
+    public static boolean isMac() {
+        return OS.indexOf("mac") >= 0;
+    }
+    public static boolean isLinux() {
+        return OS.indexOf("nux") >= 0;
+    }
+}
--- a/src/connector/jdbc/src/main/resources/META-INF/services/java.sql.Driver
+++ b/src/connector/jdbc/src/main/resources/META-INF/services/java.sql.Driver
 com.taosdata.jdbc.TSDBDriver
+com.taosdata.jdbc.rs.RestfulDriver
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/ResultSetTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/ResultSetTest.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBConnectionTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBConnectionTest.java
@@ -233,7 +233,7 @@ public class TSDBConnectionTest {
        int status = rs.getInt("server_status()");
        Assert.assertEquals(1, status);
-        conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
+        conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
    }
    @Test(expected = SQLFeatureNotSupportedException.class)

--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBParameterMetaDataTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBParameterMetaDataTest.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBPreparedStatementTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBPreparedStatementTest.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBResultSetTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBResultSetTest.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/DriverAutoloadTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/DriverAutoloadTest.java
+package com.taosdata.jdbc.cases;
+import com.taosdata.jdbc.TSDBDriver;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.util.Properties;
+public class DriverAutoloadTest {
+    private Properties properties;
+    private String host = "127.0.0.1";
+    @Test
+    public void testRestful() throws SQLException {
+        final String url = "jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata";
+        Connection conn = DriverManager.getConnection(url, properties);
+        Assert.assertNotNull(conn);
+    }
+    @Test
+    public void testJni() throws SQLException {
+        final String url = "jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata";
+        Connection conn = DriverManager.getConnection(url, properties);
+        Assert.assertNotNull(conn);
+    }
+    @Before
+    public void before() {
+        properties = new Properties();
+        properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
+        properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
+        properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
+    }
+}
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/InsertDbwithoutUseDbTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/InsertDbwithoutUseDbTest.java
@@ -14,7 +14,6 @@ import java.util.Random;
 public class InsertDbwithoutUseDbTest {
    private static String host = "127.0.0.1";
-    //    private static String host = "master";
    private static Properties properties;
    private static Random random = new Random(System.currentTimeMillis());

--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NullValueInResultSetForJdbcRestfulTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NullValueInResultSetForJdbcRestfulTest.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/UnsignedNumberRestfulTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/UnsignedNumberRestfulTest.java
@@ -10,8 +10,8 @@ import java.util.Properties;
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
 public class UnsignedNumberRestfulTest {
    private static final String host = "127.0.0.1";
-//        private static final String host = "master";
    private static Connection conn;
    @Test

--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/AuthenticationTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/AuthenticationTest.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulConnectionTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulConnectionTest.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulDatabaseMetaDataTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulDatabaseMetaDataTest.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulJDBCTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulJDBCTest.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulParameterMetaDataTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulParameterMetaDataTest.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulPreparedStatementTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulPreparedStatementTest.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulResultSetMetaDataTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulResultSetMetaDataTest.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulResultSetTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulResultSetTest.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulStatementTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulStatementTest.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/SQLTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/SQLTest.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/utils/OSUtilsTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/utils/OSUtilsTest.java
--- a/src/dnode/CMakeLists.txt
+++ b/src/dnode/CMakeLists.txt
--- a/src/dnode/src/dnodeMain.c
+++ b/src/dnode/src/dnodeMain.c
--- a/src/dnode/src/dnodePeer.c
+++ b/src/dnode/src/dnodePeer.c
--- a/src/dnode/src/dnodeShell.c
+++ b/src/dnode/src/dnodeShell.c
--- a/src/dnode/src/dnodeVMgmt.c
+++ b/src/dnode/src/dnodeVMgmt.c
--- a/src/dnode/src/dnodeVWrite.c
+++ b/src/dnode/src/dnodeVWrite.c
--- a/src/dnode/src/dnodeVnodes.c
+++ b/src/dnode/src/dnodeVnodes.c
--- a/src/inc/module.h
+++ b/src/inc/module.h
--- a/src/inc/query.h
+++ b/src/inc/query.h
--- a/src/inc/taosdef.h
+++ b/src/inc/taosdef.h
--- a/src/inc/taosmsg.h
+++ b/src/inc/taosmsg.h
--- a/src/inc/tsdb.h
+++ b/src/inc/tsdb.h
--- a/src/inc/tsync.h
+++ b/src/inc/tsync.h
--- a/src/inc/ttokendef.h
+++ b/src/inc/ttokendef.h
--- a/src/inc/vnode.h
+++ b/src/inc/vnode.h
--- a/src/kit/shell/inc/shell.h
+++ b/src/kit/shell/inc/shell.h
--- a/src/kit/shell/src/shellEngine.c
+++ b/src/kit/shell/src/shellEngine.c
--- a/src/kit/taosdemo/CMakeLists.txt
+++ b/src/kit/taosdemo/CMakeLists.txt
--- a/src/kit/taosdemo/insert-interlace.json
+++ b/src/kit/taosdemo/insert-interlace.json
--- a/src/kit/taosdemo/insert.json
+++ b/src/kit/taosdemo/insert.json
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
--- a/src/mnode/inc/mnodeVgroup.h
+++ b/src/mnode/inc/mnodeVgroup.h
--- a/src/mnode/src/mnodeDb.c
+++ b/src/mnode/src/mnodeDb.c
--- a/src/mnode/src/mnodeDnode.c
+++ b/src/mnode/src/mnodeDnode.c
--- a/src/mnode/src/mnodeProfile.c
+++ b/src/mnode/src/mnodeProfile.c
--- a/src/mnode/src/mnodeVgroup.c
+++ b/src/mnode/src/mnodeVgroup.c
--- a/src/os/inc/osArm32.h
+++ b/src/os/inc/osArm32.h
--- a/src/os/inc/osArm64.h
+++ b/src/os/inc/osArm64.h
--- a/src/os/inc/osLinux32.h
+++ b/src/os/inc/osLinux32.h
--- a/src/os/inc/osLinux64.h
+++ b/src/os/inc/osLinux64.h
--- a/src/os/inc/osSocket.h
+++ b/src/os/inc/osSocket.h
--- a/src/os/src/detail/osSocket.c
+++ b/src/os/src/detail/osSocket.c
--- a/src/query/inc/qResultbuf.h
+++ b/src/query/inc/qResultbuf.h
--- a/src/query/inc/qUtil.h
+++ b/src/query/inc/qUtil.h
--- a/src/query/inc/sql.y
+++ b/src/query/inc/sql.y
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
--- a/src/query/src/qPercentile.c
+++ b/src/query/src/qPercentile.c
--- a/src/query/src/qResultbuf.c
+++ b/src/query/src/qResultbuf.c
--- a/src/query/src/qSqlParser.c
+++ b/src/query/src/qSqlParser.c
--- a/src/query/src/qTokenizer.c
+++ b/src/query/src/qTokenizer.c
--- a/src/query/src/qUtil.c
+++ b/src/query/src/qUtil.c
--- a/src/query/src/queryMain.c
+++ b/src/query/src/queryMain.c
--- a/src/query/src/sql.c
+++ b/src/query/src/sql.c
--- a/src/rpc/src/rpcMain.c
+++ b/src/rpc/src/rpcMain.c
--- a/src/sync/inc/syncInt.h
+++ b/src/sync/inc/syncInt.h
--- a/src/sync/src/syncMain.c
+++ b/src/sync/src/syncMain.c
--- a/src/sync/src/syncRestore.c
+++ b/src/sync/src/syncRestore.c
--- a/src/tsdb/src/tsdbCommit.c
+++ b/src/tsdb/src/tsdbCommit.c
--- a/src/tsdb/src/tsdbFS.c
+++ b/src/tsdb/src/tsdbFS.c
--- a/src/tsdb/src/tsdbFile.c
+++ b/src/tsdb/src/tsdbFile.c
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
--- a/src/tsdb/src/tsdbSync.c
+++ b/src/tsdb/src/tsdbSync.c
--- a/src/util/src/tsocket.c
+++ b/src/util/src/tsocket.c
--- a/src/vnode/inc/vnodeBackup.h
+++ b/src/vnode/inc/vnodeBackup.h
--- a/src/vnode/inc/vnodeMain.h
+++ b/src/vnode/inc/vnodeMain.h
--- a/src/vnode/inc/vnodeSync.h
+++ b/src/vnode/inc/vnodeSync.h
--- a/src/vnode/src/vnodeBackup.c
+++ b/src/vnode/src/vnodeBackup.c
--- a/src/vnode/src/vnodeMain.c
+++ b/src/vnode/src/vnodeMain.c
--- a/src/vnode/src/vnodeMgmt.c
+++ b/src/vnode/src/vnodeMgmt.c
--- a/src/vnode/src/vnodeRead.c
+++ b/src/vnode/src/vnodeRead.c
--- a/src/vnode/src/vnodeSync.c
+++ b/src/vnode/src/vnodeSync.c
--- a/src/vnode/src/vnodeWrite.c
+++ b/src/vnode/src/vnodeWrite.c
--- a/tests/Jenkinsfile
+++ b/tests/Jenkinsfile
--- a/tests/examples/JDBC/JDBCDemo/pom.xml
+++ b/tests/examples/JDBC/JDBCDemo/pom.xml
--- a/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/JDBCDemo.java
+++ b/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/JDBCDemo.java
--- a/tests/examples/JDBC/taosdemo/src/main/resources/insert.json
+++ b/tests/examples/JDBC/taosdemo/src/main/resources/insert.json
--- a/tests/examples/c/asyncdemo.c
+++ b/tests/examples/c/asyncdemo.c
--- a/tests/examples/go/taosdemo.go
+++ b/tests/examples/go/taosdemo.go
--- a/tests/perftest-scripts/perftest-query.sh
+++ b/tests/perftest-scripts/perftest-query.sh
--- a/tests/pytest/cluster/clusterEnvSetup/buildClusterEnv.sh
+++ b/tests/pytest/cluster/clusterEnvSetup/buildClusterEnv.sh
--- a/tests/pytest/cluster/clusterEnvSetup/insert.json
+++ b/tests/pytest/cluster/clusterEnvSetup/insert.json
--- a/tests/pytest/fulltest.sh
+++ b/tests/pytest/fulltest.sh
--- a/tests/pytest/handle_taosd_val_log.sh
+++ b/tests/pytest/handle_taosd_val_log.sh
--- a/tests/pytest/insert/metadataUpdate.py
+++ b/tests/pytest/insert/metadataUpdate.py
--- a/tests/pytest/perfbenchmark/bug3433.py
+++ b/tests/pytest/perfbenchmark/bug3433.py
--- a/tests/pytest/perfbenchmark/bug3589.py
+++ b/tests/pytest/perfbenchmark/bug3589.py
--- a/tests/pytest/query/bug3351.py
+++ b/tests/pytest/query/bug3351.py
--- a/tests/pytest/query/bug3375.py
+++ b/tests/pytest/query/bug3375.py
--- a/tests/pytest/query/query1970YearsAf.py
+++ b/tests/pytest/query/query1970YearsAf.py
--- a/tests/pytest/tools/insert-interlace.json
+++ b/tests/pytest/tools/insert-interlace.json
--- a/tests/pytest/tools/query.json
+++ b/tests/pytest/tools/query.json
--- a/tests/pytest/tools/taosdemoPerformance.py
+++ b/tests/pytest/tools/taosdemoPerformance.py
--- a/tests/pytest/tools/taosdemoTestInterlace.py
+++ b/tests/pytest/tools/taosdemoTestInterlace.py
--- a/tests/pytest/tools/taosdemoTestQuery.py
+++ b/tests/pytest/tools/taosdemoTestQuery.py
--- a/tests/pytest/tools/taosdemoTest2.py
+++ b/tests/pytest/tools/taosdemoTest2.py
--- a/tests/script/general/db/topic1.sim
+++ b/tests/script/general/db/topic1.sim
--- a/tests/script/general/parser/join_multitables.sim
+++ b/tests/script/general/parser/join_multitables.sim
--- a/tests/script/general/parser/topbot.sim
+++ b/tests/script/general/parser/topbot.sim
--- a/tests/script/unique/dnode/remove2.sim
+++ b/tests/script/unique/dnode/remove2.sim
--- a/tests/test-all.sh
+++ b/tests/test-all.sh